文章目录
- aop 切点表达式
- 修改dao层所有方法的返回值
- 问题场景
- aop解决方案
- 实现要点
- 获取函数返回值，判断返回类型为List 或者 Map
- concurrentModifyException Map的并发修改异常
aop 切点表达式
Spring AOP切点表达式-SpringBoot从入门到熟悉（十五）
修改dao层所有方法的返回值
问题场景
- 项目数据源需要从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”)
aop解决方案
- 设置aop切点为将dao层所有函数
- 在切面函数中，筛选返回类型为 List(Map) 的函数
- 实现将返回类型为 List(Map) 或者 Map 中的key 全部转为大写
实现要点
获取函数返回值，判断返回类型为List 或者 Map
获取函数返回类型,用 instanceof 关键字判断
//执行方法 获取方法执行结果
object=proceedingJoinPoint.proceed();
if(object instanceof List){
List objectList=(List)object;
//是 List<Map>类型
if(objectList.size() > 0 && objectList.get(0) instanceof Map){
List<Map<String,Object>> recordList=(ArrayList<Map<String,Object>>)object;
recordList=changeKeyToUpperCaseList(recordList);
return recordList;
}
}else if(object instanceof Map){
Map<String,Object> record=(Map<String,Object>)object;
record=changeKeyToUpperCase(record);
return record;
}concurrentModifyException Map的并发修改异常
转为 ConcurrentHashMap
records=records.stream().map(map -> {
ConcurrentHashMap<String,Object> concurrentHashMap=new ConcurrentHashMap(map);
Map<String,Object> 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;
/**
* @program: DDC-parent
* @description: dao层 将返回map 的 key转为大写
* @author: TATE.LU
* @create: 2021-11-09 19:29
**/
@Aspect
@Component
public class DaoAspect {
/**
* @Description: dao包下的所有方法
* @Param:
* @return:
*/
@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() 方法使目标方法继续执行
/**
* @Description: 分析事件之前打印日志，统计耗时
* @Param:
* @return:
*/
@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<Map>类型
if(objectList.size() > 0 && objectList.get(0) instanceof Map){
List<Map<String,Object>> recordList=(ArrayList<Map<String,Object>>)object;
recordList=changeKeyToUpperCaseList(recordList);
return recordList;
}
}else if(object instanceof Map){
//是 Map 类型
Map<String,Object> record=(Map<String,Object>)object;
record=changeKeyToUpperCase(record);
return record;
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}
return object;
}
//将所有key转为大写 List<Map>
public List<Map<String,Object>> changeKeyToUpperCaseList(List<Map<String,Object>> records){
records=records.stream().map(map -> {
ConcurrentHashMap<String,Object> concurrentHashMap=new ConcurrentHashMap(map);
Map<String,Object> newMap=new HashMap<>();
for(String key:concurrentHashMap.keySet()){
newMap.put(key.toUpperCase(),concurrentHashMap.get(key));
}
return newMap;
}).collect(Collectors.toList());
return records;
}
//将所有key转为大写 Map
public Map<String,Object> changeKeyToUpperCase(Map<String,Object> record){
ConcurrentHashMap<String,Object> concurrentHashMap=new ConcurrentHashMap(record);
Map<String,Object> newMap=new HashMap<>();
for(String key:concurrentHashMap.keySet()){
newMap.put(key.toUpperCase(),concurrentHashMap.get(key));
}
return newMap;
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
