SpringBoot配置类相关注解+自定义注解AOP打印日志+自定义注解拦截身份敏感信息

@EnableAutoConfiguration

尝试根据开发者添加的jar依赖自动配置Spring应用

@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration{
	
}

@Configuration

尽管可以使用一个XML源来调用SpringApplication.run()，但官方建议使用@Configuration类作为主要源。
等同于Spring的XML配置文件beans；用@Bean标注方法等价于XML中配置bean，使用Java代码可以检查类型安全。

@Import：用来导入其他配置类，将class导入容器中

@ComponentScan：注解自动收集所有的Spring组件，包括@Configuration类

@ImportResource：如果需要使用基于XML的配置，官方建议仍旧从一个@Configuration类开始。可以使用附加的@ImportResource注解加载XML配置文件

@ComponentScan：表示将该类自动发现扫描组件。如果扫描到有@Component、@Controller、@Service等这些注解的类，并注册为Bean，并结合@Autowired注解导入，可以自动收集所有的Spring组件，包括@Configuration类

@ComponentScan(basePackages = "com.yoodb.blog",
includeFilters = {@ComponentScan.Filter(Aspect.class)})

@Inject：等价于默认的@Autowired，只是没有required属性

@Qualifier：当有多个同一类型的Bean时，可以用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者，实例代码如下：

@Autowired 
@Qualifier(value = "demoInfoService") 
private DemoInfoService demoInfoService;

@Resource(name=“name”,type=“type”)：没有括号内内容的话，默认byName。与@Autowired类似。

Spring Boot自定义注解、AOP打印日志

把controller的每个request请求日志收集起来，调用接口、执行时间、返回值这几个重要的信息存储到数据库里，然后可以使用火焰图统计接口调用时长，平均响应时长，以便于我们对接口的调用和执行情况及时掌握。

一、添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.1.4.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.1.4.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>2.1.4.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
  </dependency>

二、自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface WebLogger{
	
	String value() default "";
}

三、切面

@Aspect
@Component
public class WebLoggerAspect{
	
	@Pointcut("@annotation(com.michael.anno.WebLogger)")
	public void log(){}

	/**
		计算接口调用时间
		统计请求的参数时有个bug，joinpoint.getArgs返回值是一个Object数组，但是数组里只有参数值，没有参数名。
	*/
	@Around("log()")
	public Object doAround(ProceedingJoinPoint joinPoint)throws Throwable{
		
		long startTime = System.currentTimeMillis();

		Object result = joinPoint.proceed();

		System.out.println("Response："+new Gson().toJson(result));
		System.out.println("耗时："+(System.currentTimeMillis()-startTime));
		return result;
	}

	/**
		统计request请求相关参数
	*/
	@Before("log()")
	public void doBefore(JoinPoing joinPoint){
		
		//获取请求对象
		ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
		HttpServletRequest request = attributes.getRequest();

		System.out.println("==================Start=================");
        System.out.println("URL：" + request.getRequestURL().toString());
        System.out.println("Description：" + getLogValue(joinPoint));//获取目标方法的描述
        System.out.println("Method：" + request.getMethod().toString());//获取目标请求方式 GET
	
		//打印controller全路径及method
        System.out.println("Class Method：" + joinPoint.getSignature().getDeclaringTypeName() + "," + joinPoint.getSignature().getName());//获取目标请求全类名和
        
        System.out.println("客户端IP：" + request.getRemoteAddr());
        System.out.println("请求参数：" + new Gson().toJson(joinPoint.getArgs()));//获取请求参数
	}
	
	private String getLogValue(JoinPoint joinPoint){
		
		MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
 
        WebLogger webLogger = method.getAnnotation(WebLogger.class);//获取注解对象
 
        return webLogger.value();//获取注解对象的值
	}

	@After("log()")
    public void doAfter() {
        System.out.println("==================End=================");
    }
}

四、使用注解

@Controller
@RequestMapping("/student")
public class StudentController{
	
	private final Logger logger= LoggerFactory.getLogger(StudentController.class);

	@GetMapping("/list")
    @WebLogger("学生列表")
    public @ResponseBody  List<Student> list(){
        ArrayList<Student> list=new ArrayList<>();
        Student student0=new Student(1,"kobe",30);
        Student student1=new Student(2,"james",30);
        Student student2=new Student(3,"rose",30);
 
        list.add(student0);
        list.add(student1);
        list.add(student2);
 
        return list;
    }
 
    @WebLogger("学生实体")
    @RequestMapping("/detail")
    public @ResponseBody Student student(int id){
        return new Student(1,"kobe",30);
    }
}

在分布式部署的环境中，出现高并发时日志打印会出现错乱的情况，这里还需要把线程id或者声明一个guid， 存入ThreadLoal中统计使用。当然更多的人还是使用ELK等分布式日志解决方法

自定义注解 + 拦截器实现身份证等敏感数据加解密

MyBatis Plugin允许在已映射语句执行过程中的某一点进行拦截调用

//语句执行拦截
Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)

// 参数获取、设置时进行拦截
ParameterHandler (getParameterObject, setParameters)

// 对返回结果进行拦截
ResultSetHandler (handleResultSets, handleOutputParameters)

//sql语句拦截
StatementHandler (prepare, parameterize, batch, update, query)

对于数据的加密与解密，应当存在两个拦截器：

一、定义需要加密解密的敏感信息注解

/**
	定义注解敏感信息类（如实体类POJO\PO）的注解
*/
@Inherited
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SensitiveData{

}

/**
 * 注解敏感信息类中敏感字段的注解
 */
@Inherited
@Target({ ElementType.Field })
@Retention(RetentionPolicy.RUNTIME)
public @interface SensitiveField {
}

二、定义加密接口及其实现类

定义加密接口，方便以后拓展加密方法（如AES加密算法拓展支持PBE算法，只需要注入时指定一下便可）

public interface EncryptUtil{
	
	<T> T encrypt(Field[] declaredFields, T paramsObject) throws IllegalAccessException;
}

@Component
public class SESEncrypt implements EncryptUtil{
	
	@Autowired
	SESUtil.aesUtil;
	
	//加密
	@Override
	public <T> T encrypt(Field[] declaredFields,T paramsObject) throws IllegalAccessException {
		
		for (Field field : declaredFields) {
            //取出所有被EncryptDecryptField注解的字段
            SensitiveField sensitiveField = field.getAnnotation(SensitiveField.class);
            if (!Objects.isNull(sensitiveField)) {
                field.setAccessible(true);
                Object object = field.get(paramsObject);
                //暂时只实现String类型的加密
                if (object instanceof String) {
                    String value = (String) object;
                    //加密  这里我使用自定义的AES加密工具
                    field.set(paramsObject, aesUtil.encrypt(value));
                }
            }
        }
        return paramsObject;
	}
}

三、实现入参加密拦截器

MyBatis的interceptor接口有如下方法需要实现：

public interface Interceptor {
 
  //主要参数拦截方法（核心拦截逻辑）
  Object intercept(Invocation invocation) throws Throwable;
 
  //mybatis插件链
  default Object plugin(Object target) {return Plugin.wrap(target, this);}
 
  //自定义插件配置文件方法
  default void setProperties(Properties properties) {}
 
}

/**
	@Signature中
	type 属性指定当前拦截器使用StatementHandler 、ResultSetHandler、ParameterHandler，Executor的一种
	method 属性指定使用以上四种类型的具体方法（可进入class内部查看其方法）
	args 属性指定预编译语句
*/
@Slf4j
@Component
@Intercepts({@Signature(type = ParameterHandler.class, method = "setParameters", args = PreparedStatement.class),})//开启拦截器
public class EncryptInterceptor implements Interceptor{
	
	private final EncryptDecryptUtil encryptUtil;

	@Autowired
	public EncryptInterceptor(EncryptDecryptUtil encryptUtil){
		this.encryptUtil = encryptUtil;
	}

	@Override
	public Object intercept(Invocation invocation)throws Throwable{
		
		//指定了 type= parameterHandler 后，这里的 invocation.getTarget() 便是parameterHandler 
		//若指定ResultSetHandler ，这里则能强转为ResultSetHandler
		ParameterHandler parameterHandler = (ParameterHandler)invocation.getTarget();
		
		//获取参数对象，即mapper中的paramsType的实例
		Field parameterField = parameterHandler.getClass().getDeclaredField("parameterObject");
		parameterField.setAccessible(true);

		//取出实例
		Object parameterObject = parameterField.get(parameterHandler);
		if(parameterObject != null){
			Class<?> parameterObjectClass = parameterObject.getClass();

			//校验该实例的类是否被@SensitiveData所注解
			SensitiveData sensitiveData = AnnotationUtils.findAnnotation(parameterObjectClass, SensitiveData.class);
			if(Objects.nonNull(sensitiveData)){
				//去除当前类所有字段，传入加密方法
				Field[] ddeclaredFields = parameterObjectClass.getDeclaredFields()l
				encryptUtil.encrypt(declaredFields,parameterObject);
			}
		}
		return invocation.proceed();
	}

	//切记配置，否则当前拦截器不会加入拦截器链
	@Override
	public Object plugin(Object o){
		return Plugin.wrap(o,this);
	}

	//自定义配置写入，没有自定义配置的可以直接置空此方法
	@Override
	public void setProperties(Properties properties){
		
	}
	
}

四、定义解密接口及其实现类

public interface DecryptUtil{
	<T> T decrypt(T result) throws IllegalAccessException;
}

public class AESDecrypt implements DecryptUtil{
	
	@Autowired
	AESUtil aesUtil;

	@Override
    public <T> T decrypt(T result) throws IllegalAccessException {
        //取出resultType的类
        Class<?> resultClass = result.getClass();
        Field[] declaredFields = resultClass.getDeclaredFields();
        for (Field field : declaredFields) {
            //取出所有被EncryptDecryptField注解的字段
            SensitiveField sensitiveField = field.getAnnotation(SensitiveField.class);
            if (!Objects.isNull(sensitiveField)) {
                field.setAccessible(true);
                Object object = field.get(result);
                //只支持String的解密
                if (object instanceof String) {
                    String value = (String) object;
                    //对注解的字段进行逐一解密
                    field.set(result, aesUtil.decrypt(value));
                }
            }
        }
        return result;
    }
}

五、定义出参解密拦截器

@Slf4j
@Component
@Intercepts({
        @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})
})
public class DecryptInterceptor implements Interceptor {
 
    @Autowired
    DecryptUtil aesDecrypt;
 
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        //取出查询的结果
        Object resultObject = invocation.proceed();
        if (Objects.isNull(resultObject)) {
            return null;
        }
        //基于selectList
        if (resultObject instanceof ArrayList) {
            ArrayList resultList = (ArrayList) resultObject;
            if (!CollectionUtils.isEmpty(resultList) && needToDecrypt(resultList.get(0))) {
                for (Object result : resultList) {
                    //逐一解密
                    aesDecrypt.decrypt(result);
                }
            }
        //基于selectOne
        } else {
            if (needToDecrypt(resultObject)) {
                aesDecrypt.decrypt(resultObject);
            }
        }
        return resultObject;
    }
 
    private boolean needToDecrypt(Object object) {
        Class<?> objectClass = object.getClass();
        SensitiveData sensitiveData = AnnotationUtils.findAnnotation(objectClass, SensitiveData.class);
        return Objects.nonNull(sensitiveData);
    }
 
 
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
 
    @Override
    public void setProperties(Properties properties) {
 
    }
}

六、注解实体类中需要加解密的字段

此时在mapper中，指定paramType=User resultType=User 便可实现脱离业务层，基于mybatis拦截器的加解密操作。