用Spring AOP、Java注解、反射对返回的结果集进行特殊处理

╰+哭是因爲堅強的太久メ 2022-12-04 02:21 147阅读 0赞

1.目标：业务数据中的某些字段列，需要根据用户选择的语言类型自动处理后返回对应语言的数据

2.背景：系统需要适应多种语言：中文简体、中文繁体、英语等，一个业务数据中的某些列，会同时设置多种语言的数据，用户可根据自己喜欢的语言展示对应的数据

3.用户选择语言后，前端把该参数通过header头传递到后端，后端查询业务数据后，根据header头中的多语言参数，查询业务数据中某些列对应语言的数据，再覆盖到当前的数据中，然后返回给客户端

4.难点：1.结果集的数据有数组嵌套，2.尽量少改动业务代码，且提供好的性能，来满足业务要求，因此通过aop + 注解 的方式统一处理这种类型的业务

5.实现逻辑：返回的结果集对象中有List集合，在aop切面中把结果集获取出来，并循环结果集中的每一列，判断是否为多语言字段，或者是否为List对象，把所有需要多语言处理的字段全部放到一个List集合中，通过mysql in 查询一次把数据查询出来，并组装数据为map 键值对结构，再次对结果集进行循环，再次使用反射，对需要多语言处理的字段通过key在map 集合中查询，有数据则覆盖现有数据

6.实现方法：1.在返回实体字段中添加注解，标识某些字段是多语言字段，2.在业务方法上使用注解，标识该方法需要进行多语言处理，3.添加aop切面，对服务层使用了多语言处理注解的方法进行横切，来统一多语言处理

6.代码实现

*  1.重要依赖

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
 <version>1.9.5</version>
 </dependency>

*  2.添加注解：标识某些字段是多语言字段，注解中的字段与我们系统的业务逻辑有关

@Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MultiLanguageAnnotation { 
    
        /** * 表名 */
        String tabName() default "";
    
        /** * 列名 */
        String colName() default  "";
    
        /** * 主键名 * @return */
        String pkName() default "";
    }

*  3.添加注解：标识该方法需要进行多语言处理

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MultiLanguageResponse { 
    
    }

*  4.反射处理帮助类，这里写法不太优雅，功能倒是实现了

package com.es.util;
 
 import cn.hutool.crypto.SecureUtil;
 import com.alibaba.fastjson.JSON;
 import com.egovchina.apicenter.es.config.MultiLanguageAnnotation;
 import com.egovchina.apicenter.es.searchlogic.po.TabMultiLanguagePo;
 import com.egovchina.apicenter.es.searchlogic.service.MultiLanguageService;
 import org.springframework.util.Base64Utils;
 import org.springframework.util.StringUtils;
 
 import java.io.UnsupportedEncodingException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.*;
 import java.util.stream.Collectors;
 
 /** * 多语言帮助类 */
 public class MultiLanguageUtil { 
 
 /** * 设置多语言内容 * 两种使用示例： * 1.直接在方法上使用 @MultiLanguageResponse 注解，来处理多语言 * 2.使用代码方式： List<AffairsServiceAndAffairsDocument> list = esDatas.getDatas(); String languageCode = RequestHolder.getDataLanguageHeaderValue(); MultiLanguageUtil.setMultiLanguageInfo(multiLanguageService , list , languageCode); * * @param multiLanguageService es多语言查询服务 * @param documents 要设置多语言字段的文档集合 * @param languageCode 语言类型 * @param <T> */
 public static <T> void setMultiLanguageInfo(MultiLanguageService multiLanguageService , List<T> documents , String languageCode){ 
 if(documents != null && documents.size() > 0){ 
 List<String> multiInfoIds = getMultiInfoId(documents , languageCode);
 //System.out.println("util multiInfoIds：" + JSON.toJSONString(multiInfoIds));
 if(multiInfoIds != null && multiInfoIds.size() > 0){ 
 //过滤重复multiInfoId
 multiInfoIds = multiInfoIds.stream().distinct().collect(Collectors.toList());
 //根据multiInfoId查询多语言内容
 List<TabMultiLanguagePo> multiLanguageDocuments = multiLanguageService.getByMultiInfoId(multiInfoIds);
 if(multiLanguageDocuments != null && multiLanguageDocuments.size() > 0) { 
 //把从es查询出来的多语言键值对，序列化成map
 Map<String , String> map = new HashMap<>(multiLanguageDocuments.size());
 multiLanguageDocuments.forEach(item -> map.put(item.getMultiInfoId() , item.getContentText()));
 //System.out.println("util map：" + JSON.toJSONString(map));
 
 //设置多语言内容
 setMultiValue(documents , languageCode , map);
 }
 }
 }
 }
 
 
 /** * 获取文档中有多语言注解的 multiInfoId * @param documents * @param languageCode * @param <T> * @return */
 private static <T> List<String> getMultiInfoId(List<T> documents , String languageCode){ 
 List<String> multiInfoIdList = new ArrayList<>(20);
 
 documents.forEach(item -> { 
 try { 
 Class clazz = item.getClass(); // 获取集合中的对象
 Field[] fields = clazz.getDeclaredFields();// 获取他的字段数组
 for (Field field : fields) { 
 field.setAccessible(true); // 设置字段可访问
 //获取带有 MultiLanguageAnnotation 注解的字段，并组装 multiInfoId
 MultiLanguageAnnotation languageAnnotation = field.getDeclaredAnnotation(MultiLanguageAnnotation.class);
 if (languageAnnotation != null) { 
 String multiInfoId = languageAnnotation.tabName() + languageAnnotation.colName() +
 ReflectionUtils.getFieldValue(item, languageAnnotation.pkName()) + languageCode;
 //System.out.println("multiInfoId：" + multiInfoId);
 multiInfoIdList.add(multiInfoId);
 }
 
 //获取List泛型中带有 MultiLanguageAnnotation 注解的字段，并组装 multiInfoId
 if (List.class.isAssignableFrom(field.getType())) { 
 Type genericType = field.getGenericType(); // 当前集合的泛型类型
 if (null == genericType) { 
 continue;
 }
 if (genericType instanceof ParameterizedType) { 
 //ParameterizedType pt = (ParameterizedType) genericType;
 //Class clz = (Class) pt.getActualTypeArguments()[0];//得到对象list中实例的类型
 Object obj = field.get(item);
 if(null == obj){ 
 continue;
 }
 Class childClazz = obj.getClass(); //获取到属性的值的Class对象
 if(null == childClazz){ 
 continue;
 }
 Method m = childClazz.getDeclaredMethod("size");
 int size = (Integer) m.invoke(field.get(item)); //调用list的size方法，得到list的长度
 for (int i = 0; i < size; i++) { //遍历list，调用get方法，获取list中的对象实例
 Method getM = childClazz.getDeclaredMethod("get", int.class);
 //getM.setAccessible(true);
 Object childObj = getM.invoke(field.get(item), i); //获取泛型的子类对象
 Field[] childFields = childObj.getClass().getDeclaredFields(); //得到子类对象的字段数组
 //System.out.println("list obj field size : " + objField.length);
 for (Field childField : childFields){ 
 childField.setAccessible(true);
 MultiLanguageAnnotation childLanguageAnnotation = childField.getDeclaredAnnotation(MultiLanguageAnnotation.class);
 if (childLanguageAnnotation != null) { 
 String childMultiInfoId = childLanguageAnnotation.tabName() + childLanguageAnnotation.colName() +
 ReflectionUtils.getFieldValue(childObj, childLanguageAnnotation.pkName()) + languageCode;
 //System.out.println("childMultiInfoId：" + childMultiInfoId);
 multiInfoIdList.add(childMultiInfoId);
 }
 }
 }
 }
 }
 }
 
 } catch (Exception e) { 
 e.printStackTrace();
 }
 });
 return multiInfoIdList;
 }
 
 /** * 根据多语言 multiInfoId ，设置多语言内容 * @param documents * @param map * @param <T> */
 private static <T> void setMultiValue(List<T> documents , String languageCode , Map<String , String> map){ 
 
 documents.forEach(item -> { 
 try { 
 Class clazz = item.getClass(); // 获取集合中的对象
 Field[] fields = clazz.getDeclaredFields();// 获取他的字段数组
 for (Field field : fields) { 
 field.setAccessible(true); // 设置字段可访问
 //获取带有 MultiLanguageAnnotation 注解的字段，并组装 multiInfoId
 MultiLanguageAnnotation languageAnnotation = field.getDeclaredAnnotation(MultiLanguageAnnotation.class);
 if (languageAnnotation != null) { 
 String multiInfoId = languageAnnotation.tabName() + languageAnnotation.colName() +
 ReflectionUtils.getFieldValue(item, languageAnnotation.pkName()) + languageCode;
 String contentText = map.get(multiInfoId);
 if(!StringUtils.isEmpty(contentText)){ 
 field.set(item , contentText);
 contentText = null;
 }
 }
 
 //获取List泛型中带有 MultiLanguageAnnotation 注解的字段，并组装 multiInfoId
 if (List.class.isAssignableFrom(field.getType())) { 
 Type genericType = field.getGenericType(); // 当前集合的泛型类型
 if (null == genericType) { 
 continue;
 }
 if (genericType instanceof ParameterizedType) { 
 //ParameterizedType pt = (ParameterizedType) genericType;
 //Class clz = (Class) pt.getActualTypeArguments()[0];//得到对象list中实例的类型
 Object obj = field.get(item);
 if(null == obj){ 
 continue;
 }
 Class childClazz = obj.getClass(); //获取到属性的值的Class对象
 if(null == childClazz){ 
 continue;
 }
 Method m = childClazz.getDeclaredMethod("size");
 int size = (Integer) m.invoke(field.get(item)); //调用list的size方法，得到list的长度
 for (int i = 0; i < size; i++) { //遍历list，调用get方法，获取list中的对象实例
 Method getM = childClazz.getDeclaredMethod("get", int.class);
 Object childObj = getM.invoke(field.get(item), i); //获取泛型的子类对象
 Field[] childFields = childObj.getClass().getDeclaredFields(); //得到子类对象的字段数组
 //System.out.println("list obj field size : " + objField.length);
 for (Field childField : childFields){ 
 childField.setAccessible(true);
 MultiLanguageAnnotation childLanguageAnnotation = childField.getDeclaredAnnotation(MultiLanguageAnnotation.class);
 if (childLanguageAnnotation != null) { 
 String childMultiInfoId = childLanguageAnnotation.tabName() + childLanguageAnnotation.colName() +
 ReflectionUtils.getFieldValue(childObj, childLanguageAnnotation.pkName()) + languageCode;
 String childContentText = map.get(childMultiInfoId);
 if(!StringUtils.isEmpty(childContentText)){ 
 childField.set(childObj , childContentText);
 childContentText = null;
 }
 }
 }
 }
 }
 }
 }
 } catch (Exception e) { 
 e.printStackTrace();
 }
 });
 }
 }

*  5.aop切面处理类

@Component
    @Slf4j
    @Aspect
    public class MultiLanguageAspect { 
    
        @Autowired
        private MultiLanguageService multiLanguageService;
    
        /** * 监听有多语言响应注解的方法，对结果集中的多语言字段进行处理 * @param proceedingJoinPoint * @return * @throws Throwable */
        @Around(value = "@annotation(com.apicenter.es.config.MultiLanguageResponse)")
        public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { 
            Object result = proceedingJoinPoint.proceed();
            //取到header头信息中的多语言参数字段
            String languageCode = RequestHolder.getDataLanguageHeaderValue();
            if(!StringUtils.isEmpty(languageCode)){ 
                //只对返回值类型为：ResultTemplate、List 两种类型的结果集进行多语言处理
                if(result instanceof ResultTemplate){ 
                    ResultTemplate resultTemplate = (ResultTemplate)result;
                    MultiLanguageUtil.setMultiLanguageInfo(multiLanguageService , resultTemplate.getData() , languageCode);
                } else if(result instanceof List){ 
                    List list = (List)result;
                    MultiLanguageUtil.setMultiLanguageInfo(multiLanguageService , list , languageCode);
                }
            }
            return result;
        }
    }

*  6.其他帮助类

public class RequestHolder { 
 
 private static HttpServletRequest getHttpServletRequest() { 
 try { 
 return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
 } catch (Exception e) { 
 return null;
 }
 }
 /** * 获取多语言header参数 * @return */
 public static String getDataLanguageHeaderValue() { 
 HttpServletRequest httpServletRequest = getHttpServletRequest();
 if (httpServletRequest != null) { 
 String header = httpServletRequest.getHeader("Data-Language");
 if(!StringUtils.isEmpty(header)){ 
 return header;
 }
 }
 return ""; //默认返回空
 }
 }
 
 
 
 
 public class ReflectionUtils { 
 
 private static Logger log = LoggerFactory.getLogger(ReflectionUtils.class);
 
 /** * 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter * * @param object * @param fieldName * @return */
 public static Object getFieldValue(Object object, String fieldName) { 
 Field field = getDeclaredField(object, fieldName);
 if (field == null) { 
 throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
 }
 makeAccessible(field);
 Object result = null;
 try { 
 result = field.get(object);
 } catch (IllegalAccessException e) { 
 log.error("setFieldValue:", e);
 }
 return result;
 }
 
 /** * 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter * * @param object * @param fieldName * @param value */
 public static void setFieldValue(Object object, String fieldName, Object value) { 
 Field field = getDeclaredField(object, fieldName);
 
 if (field == null) { 
 throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
 }
 
 makeAccessible(field);
 
 try { 
 field.set(object, value);
 } catch (IllegalAccessException e) { 
 log.error("setFieldValue:", e);
 }
 }
 
 
 /** * 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型 * 如: public EmployeeDao extends BaseDao<Employee, String> * * @param clazz * @param index * @return */
 @SuppressWarnings("unchecked")
 public static Class getSuperClassGenricType(Class clazz, int index) { 
 Type genType = clazz.getGenericSuperclass();
 if (!(genType instanceof ParameterizedType)) { 
 return Object.class;
 }
 Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
 if (index >= params.length || index < 0) { 
 return Object.class;
 }
 if (!(params[index] instanceof Class)) { 
 return Object.class;
 }
 return (Class) params[index];
 }
 /** * 循环向上转型, 获取对象的 DeclaredMethod * * @param object * @param methodName * @param parameterTypes * @return */
 public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes) { 
 for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) { 
 try { 
 return superClass.getDeclaredMethod(methodName, parameterTypes);
 } catch (NoSuchMethodException e) { 
 //Method 不在当前类定义, 继续向上转型
 }
 }
 return null;
 }
 
 /** * 使 filed 变为可访问 * * @param field */
 public static void makeAccessible(Field field) { 
 if (!Modifier.isPublic(field.getModifiers())) { 
 field.setAccessible(true);
 }
 }
 
 /** * 循环向上转型, 获取对象的 DeclaredField * * @param object * @param filedName * @return */
 public static Field getDeclaredField(Object object, String filedName) { 
 for (Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()) { 
 try { 
 return superClass.getDeclaredField(filedName);
 } catch (NoSuchFieldException e) { 
 //Field 不在当前类定义, 继续向上转型
 }
 }
 return null;
 }
 }

*  7.在需要进行多语言处理的服务层方法上使用 @MultiLanguageResponse 注解即可实现该功能，且不改动原有业务代码

@MultiLanguageResponse
 @Override
 public ResultTemplate<AffairsDocument> affairs(AffairsDto affairsDto) { 
 //xxx 业务处理
 return ResultTemplateUtil.ofESDatasAndPage(data);
 }

*  8.ok，结合aop、annotation、反射在不改动业务情况下实现业务功能