@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拦截器的加解密操作。