改写的Spring监听器，拦截器，myBatis拦截器

   为方便使用，对Spring监听器，拦截器，myBatis拦截器做了一些简单的简化处理。如图：

一、Spring拦截器：

public class CommonMVCInterceptor implements HandlerInterceptor {

	@Autowired(required = false)
	List<EasyMvcInterceptor> interceptors;

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		return doPreHandle(request, response, handler);
	}

	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
		// 简单处理下后面的逻辑，用处不大
		doAfterInterceptor();
	}

	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
		// 简单处理下后面的逻辑，用处不大
		doAfterInterceptor();
	}

	private boolean doPreHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
		if (!neet2Interceptor(handler)) {
			return true;
		}
		for (EasyMvcInterceptor interceptor : interceptors) {
			boolean excuteSuccess = interceptor.doBusiness((HandlerMethod) handler, request, response);
			if (!excuteSuccess) {
				return false;
			}
		}
		return true;
	}

	private void doAfterInterceptor() {
		if (null != interceptors && interceptors.size() > 0) {
			for (EasyMvcInterceptor interceptor : interceptors) {
				interceptor.doAfterInterceptor();
			}
		}
	}

	private boolean neet2Interceptor(Object handler) {
		return handler instanceof HandlerMethod && null != interceptors && interceptors.size() > 0;
	}

}

public interface EasyMvcInterceptor {

	default void doAfterInterceptor() {

	}

	default boolean doBusiness(HandlerMethod handlerMethod, HttpServletRequest request, HttpServletResponse response) {
		return doBusiness(handlerMethod, request);
	}

	default boolean doBusiness(HandlerMethod handlerMethod, HttpServletRequest request) {
		Method method = handlerMethod.getMethod();
		return doBusiness(method, request);
	}

	default boolean doBusiness(Method method, HttpServletRequest request) {
		return doBusiness(method, SystemUtils.getRequestParams(request));
	}

	default boolean doBusiness(Method method, Map<String, String> params) {
		return true;
	}

}

//配置类
@Configuration
public class WebConfig implements WebMvcConfigurer {

	@Bean
	public CommonMVCInterceptor commonMVCInterceptor() {
		return new CommonMVCInterceptor();
	}

	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 限流拦截
		InterceptorRegistration commonMVCInterceptor= registry.addInterceptor(commonMVCInterceptor());
		commonMVCInterceptor.addPathPatterns("/**");
		commonMVCInterceptor.excludePathPatterns( "/error/**", "uedit");
		commonMVCInterceptor.order(1);
	}
	}

//限流拦截器
public class LimitInterceptor implements EasyMvcInterceptor {

	@Override
	public boolean doBusiness(Method method, HttpServletRequest request) {
		Limiter limiter = method.getAnnotation(Limiter.class);
		if (null != limiter) {
			try {
				String api = SystemUtils.getApiFromRequest(request);
				String token = RedisRaterLimiter.acquireTokenFromBucket(api,limiter.limit(), limiter.timeout());
				if (null == token) {
					throw new LocalException("您的访问太过频繁");
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new LocalException("您的访问太过频繁");
			}
		}
		return true;
	}
}

好处：
1、Spring拦截器只用注册一次，
2、不用再去作HandlerMethod 类型转换类型判断。
3、方便扩展。

二、Spring容器刷新监听器

public class CommonSpringListener implements ApplicationListener<ContextRefreshedEvent> {

	@Autowired(required = false)
	List<EasySpringListener> easySpringListeners;

	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {

		ApplicationContext applicationContext = event.getApplicationContext();
		// 异步执行一些容器启动时的初始化工作
		if (null != easySpringListeners && easySpringListeners.size() > 0) {
			easySpringListeners.forEach((easySpringListener) -> {
				easySpringListener.doSome(applicationContext);
			});
		}
	}
}

public interface EasySpringListener {
	public void doSome(ApplicationContext applicationContext);
}

使用示例，

public class DictUtils implements EasySpringListener {
	@Override
	public void doSome(ApplicationContext applicationContext) {
		initDictionary();
	}

对监听器只做了些简单的处理，不用每次去获取容器

三、MyBatis拦截器

@Intercepts({ @Signature(type = Executor.class, method = "update", args = { MappedStatement.class, Object.class }) })
@Component
@Slf4j
public class CommonSqlInterceptor implements Interceptor {

	@Autowired
	List<EasySqlInterceptor> interceptors;

	@Override
	public Object intercept(Invocation invocation) throws Throwable {

		Object state = invocation.getArgs()[0];
		Object paremModel = invocation.getArgs()[1];
		if (!need2Interceptor(state ,paremModel )) {
			return invocation.proceed();
		}

		MappedStatement ms = (MappedStatement) state;
		// 处理执行前的逻辑
		executorBeforeExecutor(ms, paremModel);
		// 执行sql
		Object proceed = invocation.proceed();
		// 处理执行后的逻辑
		executorAfterExecutor(ms, paremModel);
		
		return proceed;
	}

	@Override
	public Object plugin(Object target) {
		return Plugin.wrap(target, this);
	}

	@Override
	public void setProperties(Properties properties) {

	}

	private void executorBeforeExecutor(MappedStatement ms, Object paremModel) {
		if (null != interceptors && interceptors.size() > 0) {
			try {
				interceptors.forEach(it -> it.doBusinessBeforeExecutor(ms, paremModel));
			} catch (Exception e) {
				// 不影响正常逻辑的使用
				return;
			}
		}
	}

	private void executorAfterExecutor(MappedStatement ms, Object paremModel) {
		if (null != interceptors && interceptors.size() > 0) {
			try {
				interceptors.forEach(it -> it.doBusinessAfterExecutor(ms, paremModel));
			} catch (Exception e) {
				// 不影响正常逻辑的使用
				log.warn("处理sql执行后逻辑出错，错误类型={},错误消息={}", e.getClass(), e.getMessage());
				return;
			}
		}
	}

	//只拦截对象，不拦截集合等参数
	private boolean need2Interceptor(Object state, Object paremModel) {
		boolean isMappedStatement = state instanceof MappedStatement;
		if (!isMappedStatement) {
			return false;
		}
		if (null == paremModel) {
			return false;
		}
		boolean isMap = paremModel instanceof Map;
		if (isMap) {
			return false;
		}

		boolean isList = paremModel instanceof List;
		if (isList) {
			return false;
		}

		return true;
	}
}

public interface EasySqlInterceptor {

	default boolean condition() {
		return true;
	}

	default boolean condition(String sqlId) {
		return condition();
	}

	default boolean condition(MappedStatement ms, Object paremModel) {
		return condition(ms.getId());
	}

	default void doBusinessBeforeExecutor(MappedStatement ms, Object paremModel) {
		if (!condition(ms, paremModel)) {
			return;
		}
		String msId = ms.getId();
		if (isInsert(ms)) {
			doBusinessBeforeInsert(msId, paremModel);
		} else if (isUpdate(ms, paremModel)) {
			doBusinessBeforeUpdate(msId, paremModel);
		} else if (isDelete(ms, paremModel)) {
			doBusinessBeforeDelete(msId, paremModel);
		}
	}

	default void doBusinessBeforeInsert(String sqlId, Object paremModel) {

	}

	default void doBusinessBeforeUpdate(String sqlId, Object paremModel) {

	}

	default void doBusinessBeforeDelete(String sqlId, Object paremModel) {

	}

	// ------------------------------------------------------------------------------------------------------

	default void doBusinessAfterExecutor(MappedStatement ms, Object paremModel) {
		if (!condition()) {
			return;
		}
		String msId = ms.getId();
		if (isInsert(ms)) {
			doBusinessAfterInsert(msId, paremModel);
		} else if (isUpdate(ms, paremModel)) {
			doBusinessAfterUpdate(msId, paremModel);
		} else if (isDelete(ms, paremModel)) {
			doBusinessAfterDelete(msId, paremModel);
		}
	}

	default void doBusinessAfterInsert(String sqlId, Object paremModel) {

	}

	default void doBusinessAfterUpdate(String sqlId, Object paremModel) {

	}

	default void doBusinessAfterDelete(String sqlId, Object paremModel) {

	}

	public static boolean isInsert(MappedStatement ms) {
		return ms.getSqlCommandType().equals(SqlCommandType.INSERT);
	}

	public static boolean isUpdate(MappedStatement ms, Object paremModel) {
		return ms.getSqlCommandType().equals(SqlCommandType.UPDATE) && !isDelete(ms, paremModel);
	}

	public static boolean isDelete(MappedStatement ms, Object paremModel) {
		// 是直接删除
		boolean isDelete = ms.getSqlCommandType().equals(SqlCommandType.DELETE);
		if (isDelete) {
			return true;
		}
		// 是软删除
		List<String> deleteFlag = Arrays.asList("delete", "softDelete");
		boolean isSoftDelete = deleteFlag.stream().anyMatch(d -> ms.getId().indexOf(d) != -1);
		if (isSoftDelete) {
			return true;
		}
		// 是更新删除标误解
		Object fieldValue = DrinReflectUtils.getFieldValue(paremModel, "delFlag");
		return "1".equals(String.valueOf(fieldValue));
	}
}

使用示例：

public interface PublicFieldHandler extends EasySqlInterceptor {

	public String getFieldName();

	public Object getDefaultValue(String type);

	@Override
	default void doBusinessBeforeInsert(String msId, Object paremModel) {
		setValue(paremModel);
	}

	@Override
	default void doBusinessBeforeUpdate(String msId, Object paremModel) {
		setValue(paremModel, "updateBy", "updateDate");
	}

	default void setValue(Object object, String... names) {
		for (String name : names) {
			if (name.equals(getFieldName())) {
				setValue(object);
				break;
			}
		}
	}

	default void setValue(Object object) {
		try {
			Field field = object.getClass().getDeclaredField(getFieldName());
			if (null == field) {
				return;
			}
			field.setAccessible(true);
			// 看下原来是否设置了值
			Object oldValue = field.get(object);
			if (isNotNull(oldValue)) {
				return;
			}
			field.set(object, getDefaultValue(field.getType().getSimpleName()));
		} catch (Exception e) {
		}
	}

}

public class UpdateDateFieldHandler implements PublicFieldHandler {

	@Override
	public String getFieldName() {
		return “updateDate”;
	}

	@Override
	public Object getDefaultValue(String type) {
		FieldType valueOf = FieldType.valueOf(type);
		switch (valueOf) {
		case Long:
			return System.currentTimeMillis();
		default:
			return new Date();
		}
	}
}