對於任何一個應用而言在客戶端做的數據有效性驗證都不是安全有效的，這時候就要求我們在開發的時候在服務端也對數據的有效性進行驗證。
使用SpringMVC的Validator接口進行驗證
SpringMVC自身對數據在服務端的校驗有一個比較好的支持，它能將我們提交到服務端的數據按照我們事先的約定進行數據有效性驗證，對於不合格的數據信息SpringMVC會把它保存在錯誤對象中，這些錯誤信息我們也可以通過SpringMVC提供的標籤在前端JSP頁面上進行展示。
假設我們現在有一個需要進行驗證的實體類User，其代碼如下所示：
public class User {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String toString() {
return username + ", " + password;
}
}1.提供一個Validator的實現類，並實現Validator接口的supports方法和validate方法。
Supports方法用於判斷當前的Validator實現類是否支持校驗當前需要校驗的實體類，只有當supports方法的返回結果爲true的時候，該Validator接口實現類的validate方法纔會被調用來對當前需要校驗的實體類進行校驗。
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
public class UserValidator implements Validator {
public boolean supports(Class<?> clazz) {
// TODO Auto-generated method stub
return User.class.equals(clazz);
}
public void validate(Object obj, Errors errors) {
// TODO Auto-generated method stub
ValidationUtils.rejectIfEmpty(errors, "username", null, "Username is empty.");
User user = (User) obj;
if (null == user.getPassword() || "".equals(user.getPassword()))
errors.rejectValue("password", null, "Password is empty.");
}
}
在上述代碼中我們在supports方法中定義了該UserValidator只支持對User對象進行校驗。
在validate方法中我們校驗了User對象的username和password不爲empty的情況，這裏的empty包括null和空字符串兩種情況。
ValidationUtils類是Spring中提供的一個工具類。
Errors就是Spring用來存放錯誤信息的對象。
2.在SpringMVC中我們可以使用DataBinder來設定當前Controller需要使用的Validator。
import javax.validation.Valid;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.DataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class UserController {
@InitBinder
public void initBinder(DataBinder binder) {
binder.setValidator(new UserValidator());
}
@RequestMapping("login")
public String login(@Valid User user, BindingResult result) {
if (result.hasErrors())
return "redirect:user/login";
return "redirect:/";
}
}首先我們可以看到我們login方法接收的參數user是用@Valid進行標註的，這裏的@Valid是定義在JSR-303標準中的，我這裏使用的是Hibernate Validation對它的實現。這裏我們必須使用@Valid標註我們需要校驗的參數user，否則Spring不會對它進行校驗。另外我們的處理器方法必須給定包含Errors的參數，這可以是Errors本身，也可以是它的子類BindingResult，而且這個參數是必須緊挨着@Valid參數的，即必須緊挨着需要校驗的參數，這就意味着我們有多少個@Valid參數就需要有多少個對應的Errors參數，它們是一一對應的。前面有提到我們可以通過DataBinder來指定需要使用的Validator，我們可以看到在上面代碼中我們通過@InitBinder標記的方法initBinder設置了當前Controller需要使用的Validator是UserValidator。這樣當我們請求處理器方法login時就會使用DataBinder設定的UserValidator來校驗當前的表單對象User，首先會通過UserValidator的supports方法判斷其是否支持User對象的校驗，若支持則調用UserValidator的validate方法，並把相關的校驗信息存放到當前的Errors對象中。接着我們就可以在我們的處理器方法中根據是否有校驗異常信息來做不同的操作。在上面代碼中我們定義了在有異常信息的時候就跳轉到登陸頁面。這樣我們就可以在登陸頁面上通過errors標籤來展示這些錯誤信息了。
我們知道在Controller類中通過@InitBinder標記的方法只有在請求當前Controller的時候纔會被執行，所以其中定義的Validator也只能在當前Controller中使用，如果我們希望一個Validator對所有的Controller都起作用的話，我們可以通過WebBindingInitializer的initBinder方法來設定了。另外，在SpringMVC的配置文件中通過mvc:annotation-driven的validator屬性也可以指定全局的Validator。代碼如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<mvc:annotation-driven validator="userValidator"/>
<bean id="userValidator" class="com.xxx.xxx.UserValidator"/>
...
</beans>
使用JSR-303 Validation進行驗證
JSR-303只是一個規範，而Spring也沒有對這一規範進行實現，那麼當我們在SpringMVC中需要使用到JSR-303的時候就需要我們提供一個對JSR-303規範的實現，Hibernate Validator是實現了這一規範的，這裏我將以它作爲JSR-303的實現來講解SpringMVC對JSR-303的支持。
JSR-303的校驗是基於註解的，它內部已經定義好了一系列的限制註解，我們只需要把這些註解標記在需要驗證的實體類的屬性上或是其對應的get方法上。來看以下一個需要驗證的實體類User的代碼：
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.NotBlank;
public class User {
private String username;
private String password;
private int age;
@NotBlank(message="用戶名不能爲空")
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
@NotNull(message="密碼不能爲null")
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Min(value=10, message="年齡的最小值爲10")
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}我們可以看到我們在username、password和age對應的get方法上都加上了一個註解，這些註解就是JSR-303裏面定義的限制，其中@NotBlank是Hibernate Validator的擴展。不難發現，使用JSR-303來進行校驗比使用Spring提供的Validator接口要簡單的多。我們知道註解只是起到一個標記性的作用，它是不會直接影響到代碼的運行的，它需要被某些類識別到才能起到限制作用。使用SpringMVC的時候我們只需要把JSR-303的實現者對應的jar包放到classpath中，然後在SpringMVC的配置文件中引入MVC Namespace，並加上<mvn:annotation-driven/>就可以非常方便的使用JSR-303來進行實體對象的驗證。加上了<mvn:annotation-driven/>之後Spring會自動檢測classpath下的JSR-303提供者並自動啓用對JSR-303的支持，把對應的校驗錯誤信息放到Spring的Errors對象中。這時候SpringMVC的配置文件如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<mvc:annotation-driven/>
</beans>
接着我們來定義一個使用User對象作爲參數接收者的Controller，其代碼如下所示：
import javax.validation.Valid;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class UserController {
@RequestMapping("login")
public String login(@Valid User user, BindingResult result) {
if (result.hasErrors())
return "user/login";
return "redirect:/";
}
}這樣當我們不帶任何參數請求login.do的時候就不能通過實體對象User的屬性數據有效性限制，然後會把對應的錯誤信息放置在當前的Errors對象中。
jsp頁面顯示錯誤信息：
<form:errors path="user.username"></form:errors>JSR-303原生支持的限制有如下幾種：
|
限制 |
說明 |
|
@Null |
限制只能爲null |
|
@NotNull |
限制必須不爲null |
|
@AssertFalse |
限制必須爲false |
|
@AssertTrue |
限制必須爲true |
|
@DecimalMax(value) |
限制必須爲一個不大於指定值的數字 |
|
@DecimalMin(value) |
限制必須爲一個不小於指定值的數字 |
|
@Digits(integer,fraction) |
限制必須爲一個小數，且整數部分的位數不能超過integer，小數部分的位數不能超過fraction |
|
@Future |
限制必須是一個將來的日期 |
|
@Max(value) |
限制必須爲一個不大於指定值的數字 |
|
@Min(value) |
限制必須爲一個不小於指定值的數字 |
|
@Past |
限制必須是一個過去的日期 |
|
@Pattern(value) |
限制必須符合指定的正則表達式 |
|
@Size(max,min) |
限制字符長度必須在min到max之間 |
除了JSR-303原生支持的限制類型之外我們還可以定義自己的限制類型。定義自己的限制類型首先我們得定義一個該種限制類型的註解，而且該註解需要使用@Constraint標註。現在假設我們需要定義一個表示金額的限制類型，那麼我們可以這樣定義：
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.validation.Constraint;
import javax.validation.Payload;
import com.xxx.xxx.constraint.impl.MoneyValidator;
@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy=MoneyValidator.class)
public @interface Money {
String message() default"不是金額形式";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}我們可以看到在上面代碼中我們定義了一個Money註解，而且該註解上標註了@Constraint註解，使用@Constraint註解標註表明我們定義了一個用於限制的註解。@Constraint註解的validatedBy屬性用於指定我們定義的當前限制類型需要被哪個ConstraintValidator進行校驗。在上面代碼中我們指定了Money限制類型的校驗類是MoneyValidator。另外需要注意的是我們在定義自己的限制類型的註解時有三個屬性是必須定義的，如上面代碼所示的message、groups和payload屬性。
在定義了限制類型Money之後，接下來就是定義我們的限制類型校驗類MoneyValidator了。限制類型校驗類必須實現接口javax.validation.ConstraintValidator，並實現它的initialize和isValid方法。我們先來看一下MoneyValidator的代碼示例：
import java.util.regex.Pattern;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import com.xxx.xxx.constraint.Money;
public class MoneyValidator implements ConstraintValidator<Money, Double> {
private String moneyReg = "^\\d+(\\.\\d{1,2})?$";//表示金額的正則表達式
private Pattern moneyPattern = Pattern.compile(moneyReg);
public void initialize(Money money) {
// TODO Auto-generated method stub
}
public boolean isValid(Double value, ConstraintValidatorContext arg1) {
// TODO Auto-generated method stub
if (value == null)
return true;
return moneyPattern.matcher(value.toString()).matches();
}
}
從上面代碼中我們可以看到ConstraintValidator是使用了泛型的。它一共需要指定兩種類型，第一個類型是對應的initialize方法的參數類型，第二個類型是對應的isValid方法的第一個參數類型。從上面的兩個方法我們可以看出isValid方法是用於進行校驗的，有時候我們在校驗的過程中是需要取當前的限制類型的屬性來進行校驗的，比如我們在對@Min限制類型進行校驗的時候我們是需要通過其value屬性獲取到當前校驗類型定義的最小值的，我們可以看到isValid方法無法獲取到當前的限制類型Money。這個時候initialize方法的作用就出來了。我們知道initialize方法是可以獲取到當前的限制類型的，所以當我們在校驗某種限制類型時需要獲取當前限制類型的某種屬性的時候，我們可以給當前的ConstraintValidator定義對應的屬性，然後在initialize方法中給該屬性賦值，接下來我們就可以在isValid方法中使用其對應的屬性了。針對於這種情況我們來看一個代碼示例，現在假設我要定義自己的@Min限制類型和對應的MinValidator校驗器，那麼我可以如下定義：
Min限制類型
@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy=MinValidator.class)
public @interface Min {
int value() default 0;
String message();
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}MinValidator校驗器
public class MinValidator implements ConstraintValidator<Min, Integer> {
private int minValue;
public void initialize(Min min) {
// TODO Auto-generated method stub
//把Min限制類型的屬性value賦值給當前ConstraintValidator的成員變量minValue
minValue = min.value();
}
public boolean isValid(Integer value, ConstraintValidatorContext arg1) {
// TODO Auto-generated method stub
//在這裏我們就可以通過當前ConstraintValidator的成員變量minValue訪問到當前限制類型Min的value屬性了
return value >= minValue;
}
}ConstraintValidator泛型的第二個類型是對應的isValid的方法的第一個參數，isValid方法的第一個參數正是對應的當前需要校驗的數據的值，而它的類型也正是對應的我們需要校驗的數據的數據類型。這兩者的數據類型必須保持一致，否則Spring會提示找不到對應數據類型的ConstraintValidator。建立了自己的限制類型及其對應的ConstraintValidator後，其用法跟標準的JSR-303限制類型是一樣的。以下就是使用了上述自己定義的JSR-303限制類型——Money限制和Min限制的一個實體類：
public class User {
private int age;
private Double salary;
@Min(value=8, message="年齡不能小於8歲")
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Money(message="標準的金額形式爲xxx.xx")
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
}另外再講一點Spring對自定義JSR-303限制類型支持的新特性，那就是Spring支持往ConstraintValidator裏面注入bean對象。現在假設我們在MoneyValidator裏面需要用到Spring ApplicationContext容器中的一個UserController bean對象，那麼我們可以給ConstraintValidator定義一個UserController屬性，並給定其set方法，在set方法上加註解@Resource或@Autowired通過set方式來注入當前的ApplicationContext中擁有的UserController bean對象。所以我們可以這樣來定義我們的MoneyValidator：
public class MoneyValidator implements ConstraintValidator<Money, Double> {
private String moneyReg = "^\\d+(\\.\\d{1,2})?$";//表示金額的正則表達式
private Pattern moneyPattern = Pattern.compile(moneyReg);
private UserController controller;
public void initialize(Money money) {
// TODO Auto-generated method stub
}
public boolean isValid(Double value, ConstraintValidatorContext arg1) {
// TODO Auto-generated method stub
System.out.println("UserController: .............." + controller);
if (value == null)
returntrue;
return moneyPattern.matcher(value.toString()).matches();
}
public UserController getController() {
return controller;
}
@Resource
public void setController(UserController controller) {
this.controller = controller;
}
}