二、框架原理
在介绍框架的原理前，先说明一下，我们为什么要设计这么一个框架： 在电商体系下的业务系统目前大家基本都是采用中心化的RPC服务输出业务能力，比如：商品这个业务，所有电商里涉及到商品的业务能力基本由这个业务领域管理，最基本的有：商品查询【单个／批量】、商品发布／编辑、商品上下架、商品SKU管理、商品类目管理、商品库存管理等，在做这些业务服务时就遇到大量的需要对服务接口参数的合法性、有效性、约定性的校验工作，于是就有了这个动力，寻求一种更高抽象的解决办法。- 框架内部运行机制
2. 框架角色介绍
1）校验规则：是框架里最底层的校验逻辑执行单元，基础校验、边界校验、个性化校验都在这个模块里完成， 校验规则有基础的校验规则（比如为空，为NULL等），也有个性化的校验规则（比如针对不同 业务的特殊校验规则）大家只要实现一个校验规则的接口，就可以写自己的校验规则。 【稍后有代码实例】 2）校验入口：并不是所有的接口服务需要做校验，校验入口就是告诉框架那个服务接口或方法需要做参数数据 校验。 3）校验支架：连接校验入口与校验规则。告诉框架在那个入口的某个参数上要执行哪个校验规则。他们三者的 关系就比如烹饪一道菜，食材、菜谱、厨师之间的关系； 食材就好比校验规则，菜谱就好比是 校验入口，厨师就是校验支架他能按照菜谱，选择适合的食材烹饪出一道美味的佳肴！ 他们之间的关系如下：复制代码
3. 实现原理刨析
1）我们先看一下校验规则的实现原理，代码如下：
所有校验规则都需要实现 ParamCheck 这个接口，定义如下：
/** * 校验规则的定义 * 主要有两类： * 1、基本数据类型的为空为NULL等基本校验，这些我已经写好 * 2、个性化自定义的校验，比如批量查询阀值校验，这些往往有特定的场景和背景，只需要实现该接口 */public interface ParamCheck { /** * 所有需要校验的逻辑类，都需要实现这个方法 * @param t 待校验的值 * @param objectType 待校验值的数据类型 * @param c 自定义校验时的规则内容 * @return CheckResult 校验结果&描述 */ CheckResult check(Object t, Class objectType, String c) throws ServiceCheckException; /** * 检验规则的名称，通过这个名称来动态找到注解里配置的校验规则类 * @return */ String name();}这个接口定义了两个方法：check()方法就是所有校验规则的基本校验逻辑.name()方法返回校验规则的名称，系统会初始化加载这些规则并置入本地内存里，之后所有的校验工作都会由这些在内存中的校验规则类来完成。我们来分别刨析实现一个基础的校验规则类和一个个性化的校验规则类，如下：/** * 基础校验规则-对象是否为NUll的校验，最基础的校验，每一个参数都需要检验这一步 */@CheckRulepublic class ObjectCheck implements ParamCheck { /** * 所有需要校验的逻辑类，都需要实现这个方法 * * @param t 待校验的值 * @param objectType 待校验值的数据类型 * @param c 自定义校验时的规则内容 * @return CheckResult 校验结果&描述 */ @Override public CheckResult check(Object t, Class objectType, String c) { return CheckUtils.objectIsNullCheck(t); } /** * 检验规则的名称，通过这个名称来动态找到注解里配置的校验规则类 * * @return */ @Override public String name() { return Object.class.getName(); }}/** * 个性化校验规则-列表的个数是否超越设定的阀值 */@CheckRulepublic class MaxSizeCheck implements ParamCheck { private final static Logger logger = LoggerFactory.getLogger(MaxSizeCheck.class); /** * 所有需要校验的逻辑类，都需要实现这个方法 * * @param t 待校验的值 * @param objectType 待校验值的数据类型 * @param c 自定义校验时的规则内容 * @return CheckResult 校验结果&描述 */ @Override public CheckResult check(Object t, Class objectType, String c) throws ServiceCheckException { CheckResult checkResult = new CheckResult(true); //如果校验列表的个数是否超越设定的阀值，没有传阀值过来，默认通过 if(StringUtils.isEmpty(c)){ return checkResult; } Integer maxSize; try { ／** * 这里可以做优化，将所有个性化的校验条件加载时都初始化好 */ JSONObject objectCondition = JSON.parseObject(c); maxSize = objectCondition.getInteger("maxSize"); if (null == maxSize) { return checkResult; } }catch (Exception e){ logger.error("MaxSizeCheck Error: msg="+c,e); throw new ServiceCheckException("MaxSizeCheck Error: msg=" + c + e.getMessage()); } return CheckUtils.sizeGreaterThanFeedCheck(t,maxSize,objectType); } /** * 检验规则的名称，通过这个名称来动态找到注解里配置的校验规则类 * * @return */ @Override public String name() { return this.getClass().getSimpleName(); }}复制代码 注意：每一个规则都需要加一个注解，系统就是通过这个注解来识别校验规则，并自动加载到内存里的。
校验规则注解代码如下：
/** * 校验规则注解，每一个校验规则类加一个这个注解，就可以通过 * applicationContext.getBeansWithAnnotation() 完成初始化 */@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Servicepublic @interface CheckRule { String name() default ""; //校验规则名称（确保唯一）}复制代码 以上代码，就是校验规则的核心代码及运行机制，那么校验规则可以横向的无限扩展，您只需要实现 ParamCheck 这个接口，并在规则前面使用@CheckRule 标注一下即可，系统就会自动把您的校验规则加载到内存里。那么校验规则有了，该如何使用呢？看如下的代码：
public class TagWriteServiceImpl implements TagWriteService { @Autowired private TagManager tagManager; /** * @param tagOption * @return * @ParameterCheck 这个注解是 接口的入参校验 通过注解+AOP完成 */ @ParameterCheck(exceptionHandler = ServiceCheckFailedHanlder.class) public ResultDO tagAdd(tagWriteOption tagOption) { //todo 自己的业务逻辑 (在做业务逻辑之前，系统其实已经通过ParameterCheck这个注解对 tagWriteOption这个对象&对象 指定的属性做了基础的校验工作) ....... }}使用刨析：第一步：需要在待进行参数校验的方法前面加 @ParameterCheck这个注解。第二步：在@ParameterCheck注解里指定一个校验不通过的错误信息返回对象，如上代码中的 ServiceCheckFailedHanlder 类。这个类的具体实现如下： public class ServiceCheckFailedHanlder implements ICheckFailedHandler { ／** * 框架本身是一个通用的框架，但总会有一些信息是需要定制化的，比如不同的业务代码中有自己不同的错误提示包装类等 * 框架为了增加通用性和灵活性，这里框架只定义了一个接口ICheckFailedHandler， * 具体的有业务方自己去实现 *／ @Override public Object validateFailed(String msg, Class returnType, Object... args) { //todo，这里就可以写自己业务的错误信息封装代码了 BaseResultDO result = new BaseResultDO<>(); result.setSuccess(false); result.setResultCode(BaseResultTypeEnum.PARAM_ERROR.getCode()); result.setResultMessage(msg); return result; }}上面说到，在做业务逻辑之前，系统其实已经通过ParameterCheck这个注解对 tagWriteOption这个对象&对象指定的属性做了基础的校验工作，是如何做到的呢？1、首先只要方法上有ParameterCheck这个注解，系统都会针对方法里边所有的参数进行基本的为NULL校验。实现如下： 系统通过AOP自动拦截有ParameterCheck注解的方法。AOP拦截实现如下：@Component@Aspect@Order(1)public class ParamCheckAop extends AbsAopServiceParamterCheck { private static Logger logger = LoggerFactory.getLogger("aopServiceParameterCheck"); /** * 只要有ParameterCheck 这个注解的方法，都会被拦截 * @param pjp * @return * @throws Throwable */ @Around("@annotation(parameterCheck)") public Object around(ProceedingJoinPoint pjp, ParameterCheck parameterCheck) throws Throwable { long startTime = System.currentTimeMillis(); //执行校验方法 CheckResult checkSuccess = super.check(pjp, true); long annExceTime = System.currentTimeMillis() - startTime; if (logger.isDebugEnabled()) { logger.debug(pjp.getTarget().getClass().getSimpleName() + "|checkTime=" + annExceTime); } if (!checkSuccess.isSuccess()) { Method method = getMethod(pjp); ICheckFailedHandler handler = CheckFailedHandlerWrapper.getInstance() .getCheckFailedHander(parameterCheck.exceptionHandler()); return handler.validateFailed(checkSuccess.getMsg(), method.getReturnType(), pjp.getArgs()); } return pjp.proceed(); } private Method getMethod(JoinPoint pjp) { MethodSignature method = (MethodSignature) pjp.getSignature(); return method.getMethod(); }} AbsAopServiceParamterCheck是框架提供的一个抽象类，实现如下：public abstract class AbsAopServiceParamterCheck { private static Logger logger = LoggerFactory.getLogger(AbsAopServiceParamterCheck.class); @Resource private ServiceParameterCheck serviceParameterCheck; protected CheckResult check(ProceedingJoinPoint pjp, boolean isWriteLog) throws Throwable { Signature sig = pjp.getSignature(); MethodSignature msig; if (!(sig instanceof MethodSignature)) { throw new IllegalArgumentException("该注解只能用于方法"); } msig = (MethodSignature) sig; Object target = pjp.getTarget(); Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes()); //当前方法是否ParameterCheck这个注解 if(currentMethod.isAnnotationPresent(ParameterCheck.class)){ //方法参数 Object[] args = pjp.getArgs(); Object[] params = new Object[args.length+2]; params[0] = pjp.getTarget(); //类名全路径 params[1] = currentMethod.getName(); //方法名 for(int i = 0;i annotationManagerMap = new HashMap<>(); /** * 在初始化类的时候执行,将每一个注册的对象的属性缓存起来 */ @PostConstruct protected void init() throws ServiceCheckException { Map objectMap = applicationContext.getBeansWithAnnotation(ServiceCheckPoint.class); /** 初始化-入参【对象级&方法级】的注解属性 **/ for(Object o : objectMap.values()){ if(o instanceof IAnnotationManager){ annotationManagerMap.put(((IAnnotationManager)o).getAnnotationCheckType().name(),((IAnnotationManager)o)); ((IAnnotationManager)o).init(); } } } /** * 根据方法上的入参做校验 * @param args * @return */ public CheckResult checkMethod(Object ...args){ return annotationManagerMap.get(AnnotationCheckType.METHOD.name()).check(args); } /** * 根据入参对象上的注解 * @param o * @return */ public CheckResult checkObject(Object o){ return annotationManagerMap.get(AnnotationCheckType.OBJECT.name()).check(o); } /** * 根据入参对象上的注解批量校验 * @param objects * @return */ public CheckResult batchCheckObjecs(Object[] objects){ IAnnotationManager iAnnotationManager = annotationManagerMap.get(AnnotationCheckType.OBJECT.name()); if(ArrayUtils.isEmpty(objects)){ return new CheckResult(true); } for(Object o : objects){ Class objectType = o.getClass(); if(objectType.getSimpleName().endsWith("List")){ o = ((List)o).get(0); }else if(objectType.getSimpleName().endsWith("Map")){ o = ((Map)o).values().toArray()[0]; }else if(objectType.getSimpleName().endsWith("Set")){ o = ((Set)o).toArray()[0]; }else if(objectType.isArray()){ o = Arrays.asList(o).get(0); } CheckResult checkRult = iAnnotationManager.check(o); if(!checkRult.isSuccess()){ return checkRult; } } return new CheckResult(true); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; }} 具体校验在这里：/** * 针对服务接口的方法参数做校验 */@ServiceCheckPointpublic class ServiceMethodAnnotationManager implements IAnnotationManager,ApplicationContextAware { private final static Logger logger = LoggerFactory.getLogger(ServiceMethodAnnotationManager.class); /** * 每个服务对应的方法集合 */ private Map methodMap = new HashMap<>(); /** * 每个服务对应的方法参数列表 */ private Map >> methodParamMap = new HashMap<>(); /** * 前面两位用作其他用途 */ private final static Integer reserveLen = 2; @Resource ParamCheckManager paramCheckManager; private ApplicationContext applicationContext; @Override @PostConstruct public void init() throws ServiceCheckException { Map objectMap = applicationContext.getBeansWithAnnotation(ServiceMethodCheck.class); try { for(Object o: objectMap.values()){ Class clazz = o.getClass().getSuperclass(); //获取方法列表，如果没有注册，直接跳出返回 Method[] methods = clazz.getDeclaredMethods(); if(ArrayUtils.isEmpty(methods)){ break; } for(Method method : methods){ //方法上是否有ParameterCheck这个注解 if(method.isAnnotationPresent(ParameterCheck.class)){ String key = clazz.getName() + "." + method.getName(); Class [] parameterTypes = method.getParameterTypes(); if(!ArrayUtils.isEmpty(parameterTypes)) { methodParamMap.put(key, Arrays.asList(parameterTypes)); } methodMap.put(key,method); } } } logger.warn(" ServiceMethodAnnotationManager init success ,methodMap:" + JSON.toJSONString(methodMap)); }catch (Exception e){ logger.error("ServiceMethodAnnotationManager error!",e); throw new ServiceCheckException("ServiceMethodAnnotationManager Init Error! " + e.getMessage()); } } /** * 具体执行校验的入口之一 * @param args * @return CheckResult 校验结果 & 错误描述 */ @Override public CheckResult check(Object... args) { CheckResult checkResult = new CheckResult(true); /**参数列表为空，直接返回true，不做校验**/ if(ArrayUtils.isEmpty(args)){ return checkResult; } /**参数长度必须大于两个，第一个是接口服务类对象，第二个是调用的方法签名，剩余的是入参**/ if(args.length < reserveLen){ return checkResult; } Object[] objects = args; //第二个是调用的方法签名 String methodName = args[1].toString(); //类名+方法名作为key String key = args[0].getClass().getName()+"."+methodName; /** 这个类+方法下的参数列表，methodParamMap在初始化的时候已经设置好了 **/ List > paramTypeNameList = methodParamMap.get(key); /** 说明不需要检验 **/ if(CollectionUtils.isEmpty(paramTypeNameList)){ return checkResult; } //获取对应key的方法对象 Method method = methodMap.get(key); //获取对应方法上的注解 ParameterCheck annotation = method.getAnnotation(ParameterCheck.class); if(null == annotation){ return checkResult; } //获取方法参数里对应的注解列表 Map annotationAndParamIndexMap = getAnnotationAndParamIndex(method); /** * 循环校验传入的参数,为什么要从2开始， * 因为第一个参数是服务对象。 * 第二个参数是方法签名。 * 从第三个参数开始，才是方法的参数列表 */ try { for (int i = reserveLen; i < objects.length; i++) { int paramIndex = i-reserveLen; //字段上有uncheck这个注解，说明不需要做检验，忽略 if (isCheck(annotationAndParamIndexMap, paramIndex)) { //如果参数上没有自定义注解，那么就以方法注解上的自定义注解为检验的规则 if(isHaveSelfCheck(annotationAndParamIndexMap, paramIndex)){ //参数上的自定义检验规则注解 SelfCheck paramAnnotation = (SelfCheck)annotationAndParamIndexMap.get(paramIndex); checkResult = paramCheckManager.check(objects[i], paramTypeNameList.get(paramIndex), Arrays.asList(paramAnnotation.check()), paramAnnotation.condition(), paramAnnotation.msg()); }else{ checkResult = paramCheckManager.check(objects[i], paramTypeNameList.get(paramIndex), Arrays.asList(annotation.selfCheck()), annotation.condition(), annotation.msg()); } if (!checkResult.isSuccess()) { return checkResult; } } } }catch (Exception e){ /**如果检验里边发生了异常，默认通过校验。可以往下走*/ logger.error("ServiceMethodAnnotationManager error ,msg=",e); } return new CheckResult(true); } /** * 每个实现这个接口，都需要返回一个校验的级别:方发入参级别 * @return */ @Override public AnnotationCheckType getAnnotationCheckType() { return AnnotationCheckType.METHOD; } /** * 获取不需要检查的参数的索引集合 * @param method * @return */ private Map getAnnotationAndParamIndex(Method method){ Map annotationAndParamIndexMap = new HashMap<>(); //获取方法参数里是否有 uncheck这个注解 Annotation[][] annotations = method.getParameterAnnotations(); if(!ArrayUtils.isEmpty(annotations)) { for (int i = 0; i < annotations.length; i++) { for (int j = 0; j < annotations[i].length; j++) { //把参数及对应参数上的注解记录解析出来 循环下标是从0开始，i=0 实际上是指第一个参数。 if(null != annotations[i][j]) { annotationAndParamIndexMap.put(i,annotations[i][j]); } } } } return annotationAndParamIndexMap; } /** * 字段上有uncheck这个注解，不需要做检验，忽略 * @param annotationAndParamIndexMap * @param paramIndex * @return */ private boolean isCheck(Map annotationAndParamIndexMap,Integer paramIndex) { if(CollectionUtils.isEmpty(annotationAndParamIndexMap)){ return true; } //如果对应的参数里包含 Uncheck这个注解，就返回false，不校验这个参数 if(annotationAndParamIndexMap.get(paramIndex) instanceof Uncheck){ return false; } return true; } /** * 字段上是否有 自定义的注解 selfCheck * @param annotationAndParamIndexMap * @param paramIndex * @return */ private boolean isHaveSelfCheck(Map annotationAndParamIndexMap,Integer paramIndex){ if(CollectionUtils.isEmpty(annotationAndParamIndexMap)){ return false; } if(annotationAndParamIndexMap.get(paramIndex) instanceof SelfCheck){ return true; } return false; } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; }} 这一行代码就是具体的校验checkResult = paramCheckManager.check(objects[i], paramTypeNameList.get(paramIndex), Arrays.asList(paramAnnotation.check()), paramAnnotation.condition(), paramAnnotation.msg());我们看下paramCheckManager的实现如下：@Servicepublic class ParamCheckManager { @Resource private ParamCheckCollection paramCheckCollection; /** * 基础校验&自定义校验 * 基础校验是必须要做的，自定义校验根据注解上的配置来决定是否要做 * @param v * @param objectType * @param selfChecks * @param condition * @param failMsg * @return */ public CheckResult check(Object v, Class objectType, List selfChecks, String condition, String failMsg) throws ServiceCheckException { //基础的校验，对象为NULL，为EMPTY CheckResult baseCheck = paramCheckCollection.getParamCheckInstance(objectType.getName()).check(v, objectType, condition); //基础校验不通过，直接返回false if (!baseCheck.isSuccess()) { return baseCheck; } //加载自定义的数据校验 if (!CollectionUtils.isEmpty(selfChecks)) { for (String selfCheck : selfChecks) { if (!StringUtils.isEmpty(selfCheck)) { CheckResult checkRult = paramCheckCollection.getParamCheckInstance(selfCheck).check(v, objectType, condition); //自定义校验不通过，直接返回false if (!checkRult.isSuccess()) { // 使用用户自定义的校验失败信息 if (StringUtils.isNotBlank(failMsg)) { checkRult.setMsg(failMsg); } return checkRult; } } } } return new CheckResult(true); }}其中 ParamCheckCollection这里封装了所有的校验规则（包括框架里的和将来自己要写的都是在这里加载完成的）/** * 所有注册的检验类（对象类型的、集合类型的、自定义类型等） */@Servicepublic class ParamCheckCollection implements ApplicationContextAware { private Map paramCheckMap; private ApplicationContext applicationContext; /** * 初始化完成所有校验的规则类，并按照名称植入map中 */ @PostConstruct protected void init(){ Map tempParamCheckMap = applicationContext.getBeansWithAnnotation(CheckRule.class); if(!CollectionUtils.isEmpty(tempParamCheckMap)){ paramCheckMap = new HashMap<>(tempParamCheckMap.size()); for(Object o : tempParamCheckMap.values()){ if(o instanceof ParamCheck){ ParamCheck paramCheck = (ParamCheck)o; paramCheckMap.put(paramCheck.name(),paramCheck); } } } } /** * 返回对应规则名称的校验类,如果没有找到对应的规则类，那么返回对象检验规则类 * @param checkName * @return */ public ParamCheck getParamCheckInstance(String checkName){ if(StringUtils.isEmpty(checkName)){ return paramCheckMap.get(Object.class.getName()); } ParamCheck iParamCheck = paramCheckMap.get(checkName); return (null != iParamCheck)? iParamCheck : paramCheckMap.get(Object.class.getName()); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; }}2、对象属性上的校验是如何做到的呢？ 待校验的对象代码如下： @MinNum 就是框架里的一个个性化校验规则：校验数字的大小是否大于某个数字，数字由业务自己定义。 @ParameterCheck 是一个基础校验规则：校验对象是否为NULL。 属性前没有注解的，默认不需要进行校验，框架就不会去校验这些属性。 校验逻辑，如上面所讲，框架会加载类里的属性并，检查类的属性里是否有注解。public class TagWriteOption implements Serializable { private static final long serialVersionUID = -1639997547043197452L; /** * 商品id，必填 */ @MinNum(value = 1, msg = "itemId需要大于0") private Long itemId; /** * 商品所属市场 */ @ParameterCheck(msg = "market不能为空") private Integer market; /** * 调用的业务系统的名称 */ private String appName;}3、方法上有ParameterCheck这个注解，系统都会针对方法里边所有的参数进行基本的为NULL校验， 那如果有些方法的参数我不想做校验，如何实现？ 框架考虑到了这个情况，您只需要在该参数前面加@Uncheck注解,框架检测到参数前有这个注解， 就会忽略这个参数的校验，上面的代码中有实现。/** * 不需要检查*/@Target({ElementType.FIELD,ElementType.METHOD,ElementType.PARAMETER})@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface Uncheck {}复制代码 至此，您已经知道了这个框架的核心实现原理和代码，并知道如何定义自己的校验规则运用到您自己的业务场景里去。完全是透明可扩展的，框架其实就是定义了一个通用的规则执行与规则定义标准以及集成了基础的校验规则。大家完全可以在框架源码的基础上，进行二次开发与规则定义以达到更加个性化的业务场景校验。
目前框架支持的校验注解如下：
@MinNum 数字最小值校验
@MaxNum 数字最大值校验
@MinSize 集合最小个数校验
@MaxSize 结合最大个数校验
@StrSize 字符串长度校验
@NotNull 非空校验
@SelfDef 自定义校验
@Num 数字区间校验
@CollectionSize 集合区间校验
4. 框架特点总结
1）代码隔离，将校验的代码逻辑与业务逻辑代码彻底隔离解耦。
数据校验的代码，全部独立封装到一个个的校验规则里，大家可以维护一个自己的校验规则库，用的时候只需要配置一下注解+规则名称即可。
2）可扩展性极强，校验规则可根据业务场景实际情况支持无限横向扩展。
3）性能极佳，通过预加载模块将所有类加载到内存，使用时无需创建对象。
4）代码0侵入完成，只需要配置几个注解，就可以实现基础&个性化的入参数据校验，对业务代码无任何污染。
5）智能化校验，框架可根据参数的数据类型实现智能的数据校验，针对参数的类型做对应的基础校验，比如对象为null，字符串为空，列表大小等，自定义的对象，根据对象属性上的注解完成必要的校验。
6）校验结果按需定制，不同的业务领域或代码对于入参数据校验不通过的返回有不一样的提示信息，框架提供灵活的校验结果返回信息，仅需要实现一个异常返回接口即可。
7）校验规则配置灵活，默认所有参数都会做基础校验，也可以校验指定的参数，当然也可以指定不需要进行校验等。
8）代码高度重复利用，对于一个基础性的校验，只需要封装在一个基础性的校验规则里即可，以后使用只需要配置一个注解，就可以重复利用，间接的提升了开发效率和代码维护成本。
本文主要介绍了框架的基础原理和如何使用，限于篇幅和个人能力原因，大家在阅读过程中有任何疑问和问题，可以直接提问，欢迎大家提出任何建议和意见，一起完善这个框架，让这个框架做的更好，更有价值和意义！
框架是我和公司另外一个同事一起完成，大家有问题可以发邮件给我们wangchun_166@126.com、yihuihuiyi@gmail.com，我们随时恭候您的建议和意见！