aop编程 springboot 修改dao层所有方法的返回值

• aop 切点表达式
• 修改dao层所有方法的返回值
• • 问题场景
  • aop解决方案
• 实现要点
• • 获取函数返回值，判断返回类型为List 或者 Map
  • concurrentModifyException Map的并发修改异常

Spring AOP切点表达式-SpringBoot从入门到熟悉（十五）

• 项目数据源需要从Oracle转为mysql,因此要对mybatis mapper文件做修改
• 但是mybatis 文件里写的sql语句有很多返回的数据库字段是小写英文，在oracle返回结果字段都是大写，而mysql返回字段包含小写英文，因此在使用mysql数据源的情况下，java代码获取的是大写英文字段，就会获取不到指定字段。

mapper文件：
select station_name,bay_name from stationTable;
java代码：
String stationName=stationBayList.get(i).get(“STATION_NAME”).toString(); (切换成mysql数据源会报错,因为返回的key 是 “station_name”)

• 切点为将dao层返回类型为 List(Map) 的所有函数
• 实现将 List(Map) 或者 Map 中的key 全部转为大写

获取函数返回类型,用 instanceof 关键字判断

            //执行方法  获取方法执行结果
            object=proceedingJoinPoint.proceed();
            if(object instanceof List){
                List objectList=(List)object;
                //是 List

转为 ConcurrentHashMap

        records=records.stream().map(map -> {
            ConcurrentHashMap concurrentHashMap=new ConcurrentHashMap(map);
            Map newMap=new HashMap<>();
            for(String key:concurrentHashMap.keySet()){
                newMap.put(key.toUpperCase(),concurrentHashMap.get(key));
            }
            return newMap;
        }).collect(Collectors.toList());

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;



@Aspect
@Component
public class DaoAspect {


    
    @Pointcut("execution(* com.dfe.e8800p.scheduler.dao.*.*(..))")
    public void daoPoint() {
//        log.info("analyse方法 为切点");

    }




//    // 前置通知：在目标方法执行之前执行
//    @Before(value = "excutePoint()")
//    public void befor(JoinPoint joinPoint) {
//        String name = joinPoint.getSignature().getName();
//        System.out.println(name + "方法, 执行 befor");
//    }
//
//    // 后置通知：在目标方法执行之后执行
//    @After(value = "excutePoint()")
//    public void after(JoinPoint joinPoint) {
//        String name = joinPoint.getSignature().getName();
//        System.out.println(name + "方法, 执行 after");
//    }
//
//    // 返回通知：获取目标方法的返回值
//    @AfterReturning(value = "excutePoint()", returning = "result")
//    public void afterReturning(JoinPoint joinPoint, Object result) {
//        String name = joinPoint.getSignature().getName();
//        System.out.println(name + "方法, 执行 " + "afterReturning" + ", 返回: " + result);
//    }
//
//    // 异常通知：当目标方法出现异常时，会执行该方法
//    @AfterThrowing(value = "excutePoint()", throwing = "e")
//    public void afterThrowing(JoinPoint joinPoint, Exception e) {
//        String name = joinPoint.getSignature().getName();
//        System.out.println(name + "方法, 执行 " + "afterThrowing" + ", 抛出异常: " + e);
//    }
//


    // 环绕通知：可实现任意通知，可调用 proceedingJoinPoint.proceed() 方法使目标方法继续执行

    
    @Around(value = "daoPoint()")
    public Object aroundSystemDeficiency(ProceedingJoinPoint proceedingJoinPoint){


        //类型转换，向下转型，必定成功，因为其内部的实现MethodSignatureImpl实现的就是MethodSignature接口
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
        //获取method对象s
        Method method = signature.getMethod();
        //获取方法的返回值的类型
        Class  returnType=   method.getReturnType();

        
        Object object = null;

        try {
            //执行方法  获取方法执行结果
            object=proceedingJoinPoint.proceed();
            if(object instanceof List){
                List objectList=(List)object;
                //是 List