【问题标题】:What is the best way to implement custom validation in spring application?在 Spring 应用程序中实现自定义验证的最佳方法是什么?
【发布时间】:2015-09-02 09:29:26
【问题描述】:

我正在(春季开发中的新手)为我的应用程序创建 REST API,CRUD 操作已成功实施,但现在我想实施服务器端验证。我还读到有几种方法可以实现验证。

  1. 使用给定的注释 -> @notempty、@email 等...
  2. 使用自定义验证 -> 扩展验证器

我想在我的应用程序中实现它们,参考那个,

这是一种好方法吗?

还有其他方式可以实现验证吗?


控制器

@RestController
public class EmployeeController {

    @Autowired
    DataServices dataServices;

    @Autowired
    EmployeeValidator employeeValidator;

    @InitBinder
    protected void initBinder(WebDataBinder binder) {
        binder.addValidators(employeeValidator);
    }

    @RequestMapping(value = "/employee/", method = RequestMethod.POST)
    public ResponseEntity<Object> createUser(
            @Valid @RequestBody Employee employee,
            UriComponentsBuilder ucBuilder) throws Exception,
            DataIntegrityViolationException {

        if (dataServices.addEmployee(employee) == 0) {
            Error error = new Error(1, "Data integrity violation",
                    "Email id is already exists.");
            return new ResponseEntity<Object>(error, HttpStatus.CONFLICT);
        }

        HttpHeaders headers = new HttpHeaders();
        headers.setLocation(ucBuilder.path("/employee/{id}")
                .buildAndExpand(employee.getId()).toUri());
        Status status = new Status(1, "Employee has been added successfully.");

        return new ResponseEntity<Object>(status, headers, HttpStatus.CREATED);
    }
}

错误处理程序

@ControllerAdvice
public class RestErrorHandler {

    private static final Logger logger = Logger
            .getLogger(RestErrorHandler.class);

    private MessageSource messageSource;

    @Autowired
    public RestErrorHandler(MessageSource messageSource) {
        this.messageSource = messageSource;
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ResponseBody
    public ValidationErrorDTO processValidationError(
            MethodArgumentNotValidException ex) {
        logger.debug("Handling form validation error");

        BindingResult result = ex.getBindingResult();
        List<FieldError> fieldErrors = result.getFieldErrors();

        return processFieldErrors(fieldErrors);
    }

    private ValidationErrorDTO processFieldErrors(List<FieldError> fieldErrors) {
        ValidationErrorDTO dto = new ValidationErrorDTO();

        for (FieldError fieldError : fieldErrors) {
            String localizedErrorMessage = resolveLocalizedErrorMessage(fieldError);
            dto.addFieldError(fieldError.getField(), localizedErrorMessage,
                    fieldError.getDefaultMessage());
        }

        return dto;
    }

    private String resolveLocalizedErrorMessage(FieldError fieldError) {
        Locale currentLocale = LocaleContextHolder.getLocale();
        String localizedErrorMessage = messageSource.getMessage(fieldError,
                currentLocale);

        // If a message was not found, return the most accurate field error code
        // instead.
        // You can remove this check if you prefer to get the default error
        // message.
        if (localizedErrorMessage.equals(fieldError.getDefaultMessage())) {
            String[] fieldErrorCodes = fieldError.getCodes();
            localizedErrorMessage = fieldErrorCodes[0];
        }

        return localizedErrorMessage;
    }
}

验证器

@Component
public class EmployeeValidator implements Validator {

    public boolean supports(Class clazz) {
        return Employee.class.isAssignableFrom(clazz);
    }

    public void validate(Object target, Errors errors) {
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", errors
                .getFieldError().getCode(), "First name is required.");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "lastName", errors
                .getFieldError().getCode(),
                "Last name is required.");
        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "email", errors
                .getFieldError().getCode(),
                "Email is required.");

    }

}

型号

@Entity
@Table(name = "employee")
@JsonIgnoreProperties({ "hibernateLazyInitializer", "handler" })
public class Employee implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue
    @Column(name = "id")
    private long id;

    // @NotEmpty(message = "Please enter first name")
    @Column(name = "first_name")
    private String firstName;

    // @NotEmpty(message = "Please enter last name")
    @Column(name = "last_name")
    private String lastName;

    // @NotEmpty(message = "Please enter email address")
    @Email(message = "Please enter valid email address")
    @Column(name = "email", unique = true)
    private String email;

    @NotEmpty(message = "Please enter mobile number")
    @Size(min = 10, message = "Please enter valid mobile number")
    @Column(name = "phone")
    private String phone;

//Getter and Setter

}

【问题讨论】:

  • 注解:如果您开始使用 JSON 向 UI 公开您的实体(员工),您应该使用 Spring Data Rest,它正是为这种需求而设计的。关于验证,我正在使用这种策略。
  • 绑定结果有很多可用的验证示例。你到底想达到什么目标?

标签: java spring validation


【解决方案1】:

在您的方法中,您使用的是服务器端验证,但仅在控制器层中。您是否尝试过使用 Bussines 层验证,例如 Hibernate Validation API http://hibernate.org/validator/

我在最近的一个项目中使用过它,我认为它是保持数据一致性的好方法。需要一些调整和实用程序才能使其按我们的意愿工作,但这并不太难。例如,默认情况下,仅在将对象持久化到数据库后才检查此验证,但在我们的控制器中,我们需要更早地进行此验证,因此您必须实现一种调用验证机制的方法,该方法依赖于休眠验证机制.或者,作为另一个示例,我们必须在 Web 服务上开发一个类似的系统,以在传入数据无效时返回错误。

在需要时使用验证的一种方法是在所有业务对象上实现它。他们可以继承这样的类:

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.xml.bind.annotation.XmlTransient;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.fasterxml.jackson.annotation.JsonIgnore;

public abstract class BusinessObject implements Serializable, IObjectWithReport, IBusinessObject {

  private static Log log = LogFactory.getLog(BusinessObject.class.getName());

  private final Validator validator = Validation.buildDefaultValidatorFactory().getValidator();

  @JsonIgnore
  private Set<ConstraintViolation<BusinessObject>> errors;

  /* Validation methods */

  public final boolean valid() {
    preValidate();
    errors = new HashSet<ConstraintViolation<BusinessObject>>();
    errors = validator.validate(this);
    postValidate();
    return errors.isEmpty();
  }

  /**
   * Method to be overwriten in subclases so any BO can make some arrangement before checking valid
   */
  protected void preValidate() {
    log.trace("Generic prevalidate of " + this.getClass().getName());
  }
  /**
   * Method to be overwriten in subclases so any BO can make some arrangement once validation has been made
   */
  protected void postValidate() {
    log.trace("Generic postValidate of " + this.getClass().getName());
  }

  public Set<ConstraintViolation<BusinessObject>> getErrors() {
    return errors;
  }

  public boolean hasErrors() {
    return errors != null && !errors.isEmpty();
  }
}

请注意,我使用标准 javax.validation.Validation API(在此处查看参考资料JPA 2.0 : what is javax.validation.* package?)。但我使用的实现是来自 Hibernate 的。

优点:

  1. 验证放置在一个单一的层中,而不是分布在各个层中。因此它们更易于维护。
  2. 更好的模型一致性,因为数据始终以相同的方式验证,而与生成方式无关(用户输入、Web 服务、从其他系统中提取等)。

缺点:

  1. 您需要开发一些实用程序,以便在其他层中使用模型验证,但这并不是很困难。
  2. 如果您有一个简单的项目,而没有像许多信息源(用户输入、Web 服务输入、REST 服务、其他数据库系统等)或交互这样的复杂性,这可能是多余的。

【讨论】:

  • 我是春季开发新手,如果您能分享一些链接以供参考,那就太好了。谢谢!!
  • 如果您使用 Hibernate(可能使用 JPA api),您可以尝试 Hibernate Validation API hibernate.org/validator/documentation/getting-started 请注意,对于简单的项目,这可能有点矫枉过正,但这是一个很好的做法。
  • 如果是 REST API,我们如何返回验证消息?
  • 我已经用一个例子更新了我的答案。您可以在您的业务对象上使用 getErrors 并制作一个实用程序来将 Set> 错误转换为您的需要。用于 Rest 响应的 Json 消息、Web 服务响应上的 XML、将错误匹配到 JSP 中的表单字段等。
猜你喜欢
  • 2020-02-14
  • 2016-10-04
  • 1970-01-01
  • 1970-01-01
  • 2020-02-25
  • 2011-12-10
  • 1970-01-01
  • 1970-01-01
  • 2010-10-01
相关资源
最近更新 更多