Aop+自定义注解对入参进行操作（过滤、解密）_aop+注解实现前后端传参加解密

背景：对外提供接口，为了数据安全，接口入参进行了数据加密，接口收到参数后需要进行解密；如果每一个接口都要对入参进行一 一的解密操作，就大大增加了代码量和工作量；

所以，这里使用自定义注解加Aop进行无侵入式的操作；

第一步：自定义注解

package com.example.demo.common;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 自定义注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD}) // 表示该注解只能用来修饰在方法上
public @interface SystemAopAnnotation {
 
	String value() default "自定义注解";
}

第二步：参数处理

package com.example.demo.common;
 
import java.util.Arrays;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
 
/**
 * aop实现
 * @author zhaoheng
 */
@Aspect
@Component
public class DeInterceptor {
	private static final Logger log = LoggerFactory.getLogger(DeInterceptor.class);
	
    /**
     * 在方法执行之前、后执行该方法
     * 设置需要执行该方法的类路径和注解
     */
    @Around("execution(* com.example.demo.biz.*.*(..)) && (@annotation(com.example.demo.common.SystemAopAnnotation))")
    public Object interceptor(ProceedingJoinPoint point) throws Throwable {
        // 获取请求参数
        Object[] args = point.getArgs();
        String reqestParam = Arrays.toString(args);
        log.info("interceptor-入参：{}",reqestParam);
 
        // 处理参数
        JSONObject jsonObject = (JSONObject) JSON.toJSON(args[0]);
        Map<String, Object> map = new HashMap<String, Object>();
        
        // 把json对象转换为Map集合便于遍历处理参数
		map = JSON.toJavaObject(jsonObject, Map.class);
		for (Entry<String, Object> entry : map.entrySet()) {
	        /** 
	         * 入参是base64编码，这里进行解码；也可以是其他方式加密，这里进行解密
	         */
	        byte[] base64decodedBytes = Base64.getDecoder().decode(entry.getValue().toString());
	        String valueString = new String(base64decodedBytes, "utf-8");
			map.put(entry.getKey(), valueString);	
		}
			
	    // 获取接收参数的类全路径
        String classPath = args[0].getClass().getName();
        // 把处理后的参数放回去
		args[0] = JSONObject.parseObject(JSONObject.toJSONString(map), Class.forName(classPath));
        // 获取响应数据
        Object result = point.proceed(args);
        return result;
    }  
    
}

第三步：测试

1.实体类

import java.io.Serializable;
 
public class User implements Serializable{
	private static final long serialVersionUID = -1101509992831103288L;
	
	private String id;
	private String name;
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
 
	public static long getSerialversionuid() {
		return serialVersionUID;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}
}

2.controller

import com.example.demo.common.SystemAopAnnotation;
 
@CrossOrigin(origins = "*")// 允许跨越
@RestController
@RequestMapping("test")
public class TestController {
	private static final Logger log = LoggerFactory.getLogger(TestController.class);
	
	// 测试的方法
	@RequestMapping("/saveUser")
	@SystemAopAnnotation("添加用户接口") // 自定义的注解
	public String saveUser(@RequestBody User user) {
		log.info("Controller-收到的请求参数：{}",user.toString());
		return user.toString();
	}	
}

测试结果：

请求之前对数据进行了base64加密，经过aop处理（解密），controller得到的是解密后的数据