今天，我们使用AOP来开发一个参数验证。
首先，我们理理这个参数验证的原理以及流程。
第一步，我们会定义一个注解，这个注解可以被用来修饰某一方法的参数，如下:
public Object login(@RequestBody @CustomValid LoginDto loginDto, HttpSession session){
return loginService.login(loginDto,session);
}这里的@CustomValid就是我们的自定义注解。
它的代码如下：
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface CustomValid {
}第二步，我们会在切入点的环绕通知中获取所有的方法参数:
//获取所有的方法参数
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature)signature;
Method targetMethod = methodSignature.getMethod();
Parameter[] parameters=targetMethod.getParameters();通过这一句代码来获取需要验证的方法参数类型：
List<Class> list=validationProcessor.getValidateClass(parameters);其内部实现:
public List<Class> getValidateClass(Parameter[] parameters){
List<Class> list=new ArrayList<Class>();
for (Parameter parameter : parameters) {
Annotation[] annotations=parameter.getAnnotations();
for (Annotation annotation : annotations) {
if(annotation instanceof CustomValid){
list.add(parameter.getType());
}
}
}
return list;
}原理就是通过反射获取参数数组中各个参数上的注解，并判断是否有@CustomValid这个注解，如果有就加入列表，最终返回。
第三步，获取到需要验证的参数类型之后，我们进行双重循环，找出需要进行参数验证的参数对象：
for (Object arg : joinPoint.getArgs()) {
for (Class aClass : list) {
//将参数与需要验证的参数类型进行匹配
if(arg.getClass().getName().equals(aClass.getName())){
try {
//如果验证失败
ValidResult validResult=validationProcessor.valid(arg.getClass().getDeclaredFields(),arg);
if(!validResult.isValid()){
return new Result<String>(ResultState.ERROR,validResult.getValidFailMessage());
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}这里validationProcessor有一个valid方法，该方法通过参数对象的所有成员变量，并取出每个成员变量上的注解，进一步进行验证，代码如下：
public ValidResult valid(Field[] fields, Object target) throws IllegalAccessException {
for (Field field : fields) {
//获取每个成员的注解
Annotation[] annotations=field.getDeclaredAnnotations();
// 判断注解是否在validMapping里面
for (Annotation annotation : annotations) {
ValidInterface validInterface=validMapping.get(annotation.annotationType());
//如果validMapping拥有相关实现
if(validInterface!=null){
field.setAccessible(true);
//如果这个成员变量注解验证失败
if(! validInterface.valid(field.get(target))){
return new ValidResult(false,validInterface.getErrorMessage(field.getName()));
}
}
}
}
return new ValidResult(true);
}这里面有一个validMapping对象，该map维护验证注解与内部验证类的映射关系：
private HashMap<Class<? extends Annotation>,ValidInterface> validMapping=new HashMap<>();
{
//注册验证注解实现
validMapping.put(CustomNotNull.class, new CustomNotNull.Validation());
validMapping.put(CustomEmail.class,new CustomEmail.validation());
}其中，每一个验证注解都会实现一个ValidInterface接口，代码如下:
public interface ValidInterface {
boolean valid(Object object);
String getErrorMessage(String fieldName);
}当验证器进行验证的话，valid方法会被调用，如果验证通过，返回true 反之false。
getErrorMessage 则是返回验证失败后的提示信息。
这是ValidResult的代码：
public class ValidResult {
private boolean isValid;
private String validFailMessage;
public ValidResult(boolean isValid,String validFailMessage){
this.isValid=isValid;
this.validFailMessage=validFailMessage;
}
public ValidResult(boolean isValid){
this.isValid=isValid;
}
}其主要职责就是存放验证结果。
这样，一个完整的参数验证流程就完成了，让我们来总结一下：
1.循环判断参数是否含有@CustomValid注解，若有则进行下一步，否则退出。
2.取出含有@CustomValid注解的参数对象，取出其所有的成员变量。
3.循环获得每个成员变量上的注解，若在验证处理器内部拥有注册，则调用这个验证注解提供的验证接口。
4.返回验证结果，让切入点的环绕通知决定下一步结果。
不完美的地方：
在这里，我们通过手工的方式进行了验证接口的注册：
private HashMap<Class<? extends Annotation>,ValidInterface> validMapping=new HashMap<>();
{
//注册验证注解实现
validMapping.put(CustomNotNull.class, new CustomNotNull.Validation());
validMapping.put(CustomEmail.class,new CustomEmail.validation());
}这个做法在我看来，是不够完美的，我想是否可以运用多态或者继承，来实现验证注解与验证处理接口的联系？而非这样进行手工注册。
这里是一个需要思考的地方。