java类javax.validation.constraints.Pattern的实例源码

@RequestMapping(value = "/api/v1/export/account",
        method = RequestMethod.POST,
        consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE,
        produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<?> validate(
        @RequestParam @NotBlank String username,
        @RequestParam @NotBlank String password,
        @RequestParam @Pattern(regexp = Patterns.IPV4) String remoteAddress,
        @RequestParam(required = false) @Pattern(regexp = "\\d+") String otp,
        @RequestParam(required = false) Boolean otpRequired) {

    LOG.info("Received request for /api/v1/export/account: username={} otpRequired={} otp={} remoteAddress={}",
            username, otpRequired, otp, remoteAddress);

    final ExternalAuthenticationRequest authenticationRequest = new ExternalAuthenticationRequest();
    authenticationRequest.setUsername(username);
    authenticationRequest.setPassword(password);
    authenticationRequest.setRemoteAddress(remoteAddress);
    authenticationRequest.setOtp(otp);
    authenticationRequest.setRequireOtp(otpRequired != null ? otpRequired : false);

    try {
        return checkExternalAuthenticationFeature.checkAuthentication(authenticationRequest);

    } catch (Exception ex) {
        LOG.error("External authentication failed for username=" + username, ex);

        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(ExternalAuthenticationFailure.unknownError());
    }
}

/**
 * 获取用户名
 * 
 * @return 用户名
 */
@NotEmpty(groups = Save.class)
@Pattern(regexp = "^[0-9a-z_A-Z\\u4e00-\\u9fa5]+$")
@Column(nullable = false, updatable = false, unique = true, length = 100)
public String getUsername() {
    return username;
}

/**
 * 获取密码
 * 
 * @return 密码
 */
@NotEmpty(groups = Save.class)
@Pattern(regexp = "^[^\\s&\"<>]+$")
@Column(nullable = false)
public String getPassword() {
    return password;
}

/**
 * 获取用户名
 * 
 * @return 用户名
 */
@NotEmpty(groups = Save.class)
@Pattern(regexp = "^[0-9a-z_A-Z\\u4e00-\\u9fa5]+$")
@Length(min = 2, max = 20)
@Column(nullable = false, updatable = false, unique = true, length = 100)
public String getUsername() {
    return username;
}

/**
 * 获取密码
 * 
 * @return 密码
 */
@NotEmpty(groups = Save.class)
@Pattern(regexp = "^[^\\s&\"<>]+$")
@Length(min = 4, max = 20)
@Column(nullable = false)
public String getPassword() {
    return password;
}

/**
 * 获取编号
 * 
 * @return 编号
 */
@JsonProperty
@Field(store = Store.YES, index = Index.UN_TOKENIZED)
@Pattern(regexp = "[\\s\\S]*")
@Length(max = 100)
@Column(nullable = false, unique = true, length = 100)
public String getSn() {
    return sn;
}

protected void addValidation(final INamedParam parameter,
        final JVar argumentVariable) {
    if (isNotBlank(parameter.getPattern())) {
        JAnnotationUse patternAnnotation = argumentVariable.annotate(Pattern.class);
        patternAnnotation.param("regexp", parameter.getPattern());
    }

    final Integer minLength = parameter.getMinLength();
    final Integer maxLength = parameter.getMaxLength();
    if ((minLength != null) || (maxLength != null)) {
        final JAnnotationUse sizeAnnotation = argumentVariable
                .annotate(Size.class);

        if (minLength != null) {
            sizeAnnotation.param("min", minLength);
        }

        if (maxLength != null) {
            sizeAnnotation.param("max", maxLength);
        }
    }

    final BigDecimal minimum = parameter.getMinimum();
    if (minimum != null) {
        addMinMaxConstraint(parameter, "minimum", Min.class, minimum,
                argumentVariable);
    }

    final BigDecimal maximum = parameter.getMaximum();
    if (maximum != null) {
        addMinMaxConstraint(parameter, "maximum", Max.class, maximum,
                argumentVariable);
    }

    if (parameter.isRequired()) {
        argumentVariable.annotate(NotNull.class);
    }
}

@Override
public void deleteInstanceStorageInstances(
  @DefaultValue("en") @Pattern(regexp = "[a-zA-Z]{2}") String lang,
  Map<String, String> okapiHeaders,
  Handler<AsyncResult<Response>> asyncResultHandler,
  Context vertxContext) throws Exception {

  String tenantId = okapiHeaders.get(TENANT_HEADER);

  if (blankTenantId(tenantId)) {
    badRequestResult(asyncResultHandler, BLANK_TENANT_MESSAGE);

    return;
  }

  vertxContext.runOnContext(v -> {
    try {
      PostgresClient postgresClient = PostgresClient.getInstance(
        vertxContext.owner(), TenantTool.calculateTenantId(tenantId));

      postgresClient.mutate(String.format("TRUNCATE TABLE %s_%s.instance",
        tenantId, "inventory_storage"),
        reply -> {
          asyncResultHandler.handle(io.vertx.core.Future.succeededFuture(
            InstanceStorageResource.DeleteInstanceStorageInstancesResponse
              .noContent().build()));
        });
    }
    catch(Exception e) {
      asyncResultHandler.handle(io.vertx.core.Future.succeededFuture(
        InstanceStorageResource.DeleteInstanceStorageInstancesResponse
          .withPlainInternalServerError(e.getMessage())));
    }
  });
}

private String getDes(String str){
    java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("[a-z]{6,7}\\s*[=]\\s*");
    Matcher matcher = pattern.matcher(str);
    boolean isFindRegexp = false;
    int beginIndex = -1,endIndex = -1,count = 0;
    while (matcher.find()) {
        count++;
        if (!isFindRegexp && matcher.group().matches("message\\s*[=]\\s*")) {
            isFindRegexp = true;
            beginIndex = matcher.end();
            continue;
        }
        if(isFindRegexp){
            endIndex = matcher.start();
            break;
        }
    }
    if(count==1){
        return str.substring(beginIndex+1,str.lastIndexOf("\""));
    }else{
        if(endIndex==-1){
            return str.substring(beginIndex+1,str.lastIndexOf("\""));
        }else{
            str = str.substring(beginIndex,endIndex);
            return str.substring(1,str.lastIndexOf("\""));
        }
    }
}

@PostConstruct
public void init() {
    validationAnnotations = new HashSet<>();
    validationAnnotations.addAll(Arrays.asList(NotNull.class, Size.class,
            Pattern.class, DecimalMin.class, DecimalMax.class, Min.class,
            Max.class));

}