springboot+redis+切面实现数据字典功能

最新推荐文章于 2024-02-29 14:03:11 发布
最新推荐文章于 2024-02-29 14:03:11 发布
阅读量2.2k 收藏 8
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40663800/article/details/96866732
版权

自定义注解：DataDict，用于bo对象类，需要翻译的属性

package com.zddts.common.annotation.dict;
 
import java.lang.annotation.*;
 
/**
 * 说明：数据字典处理类
 * Created by luojie on 2019/05/29.
 */
//@DataDict(  dict="patType", source = "patType" )
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataDict {
 
 
    /**
     * 方法描述 描述标准编码
     * @return
     */
    String dict() default "";
 
    /**
     * 方法描述,可使用占位符获取参数:{{source}}
     * 主要标准编码之来源
     */
    String source() default "";
 
 
}

自定义注解： 

DataDictClass  用来表面返回对象集合需要，本功能目前只支持bean对象的属性翻译
package com.zddts.common.annotation.dict;
 
import java.lang.annotation.*;
 
/**
 * 说明：
 * Created by luojie on 2019/05/29.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataDictClass {
 
}

切面处理： DataDictAspect

package com.zddts.ac.aop;
 
import com.alibaba.fastjson.JSON;
import com.zddts.ac.client.PubappClient;
import com.zddts.common.annotation.dict.DataDict;
import com.zddts.common.annotation.dict.DataDictClass;
import com.zddts.common.bo.pubapp.PuCodeBo;
import com.zddts.common.utils.BeanUtils;
import org.apache.commons.lang.StringUtils;
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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
 
/**
 * 说明：数据字典切面类
 * Created by luojie on 2019/05/29.
 */
@Aspect
@Component
public class DataDictAspect {
 
    @Autowired
    PubappClient pubappClient;
 
    /**
     * 非基本类型在 CLASS 中的定义
     */
    private static final String FILED_NAME_TYPE = "TYPE";
 
    private Map<String, String> dictInfoMap = new ConcurrentHashMap<>();
 
    @Pointcut("@annotation(dataDictClass)")
    public void doDataDictClass(DataDictClass dataDictClass) {
    }
 
    @Around("@annotation(dataDictClass)")
    public Object translation(final ProceedingJoinPoint pjp, DataDictClass dataDictClass) throws Throwable {
        Object result = pjp.proceed();
        if (result == null) {
            return result;
        }
        Object obj;
        if (result instanceof List || result instanceof ArrayList) {
            List olist = ((List) result);
            if (olist.size() == 0) {
                return result;
            }
            obj = olist.get(0);
        } else {
            obj = result;
        }
        List<Map<String, String>> dictParams = boDict(obj.getClass());
        if (dictParams.size() == 0) {
            return result;
        }
        //TODO 后期需优化读取Redis
        List<PuCodeBo> dictInfos = pubappClient.getPuCodeByType("patType");
 
        if (dictInfos == null && dictInfos.size() == 0) {
            return result;
        }
        //先把字典值转成map
        for (PuCodeBo puCodeBo : dictInfos) {
            dictInfoMap.put(puCodeBo.getCodeType() + puCodeBo.getValue(), puCodeBo.getCodeName());
        }
 
        if (result instanceof List || result instanceof ArrayList) {
            for (Object o : (List) result) {
                sign(o, dictParams, dictInfoMap);
            }
        } else {
            sign(result, dictParams, dictInfoMap);
        }
        return result;
    }
 
    /**
     * 单个设置值
     *
     * @param obj
     * @param dictParams
     * @param dictInfoMap
     */
    public void sign(Object obj, List<Map<String, String>> dictParams, Map<String, String> dictInfoMap) {
 
        for (Map<String, String> dictParam : dictParams) {
            String dict = dictParam.get("dict");
            String source = dictParam.get("source");
            String dictName = dictParam.get("dictName");
            try {
                //获取源编码值
                String sourceValue = (String) BeanUtils.getBeanFieldValue(obj.getClass(), obj, source);
                String dictCodeName = dictInfoMap.get(dict + sourceValue);
                //设置值
                BeanUtils.setBeanField(obj.getClass(), obj, dictName, dictCodeName);
            } catch (Exception e) {
                e.printStackTrace();
            }
 
        }
 
 
    }
 
    /**
     * 获取bo中属性值
     *
     * @param cla
     * @return
     */
    private List<Map<String, String>> boDict(Class cla) {
        Field[] fields = cla.getDeclaredFields();
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();
        Map<String, String> map;
        DataDict dataDict;
        for (Field field : fields) {
            if (field.isAnnotationPresent(DataDict.class)) {
                map = new HashMap<String, String>();
                dataDict = field.getAnnotation(DataDict.class);
                map.put("dict", dataDict.dict());
                map.put("source", dataDict.source());
                map.put("dictName", field.getName());
                list.add(map);
            }
        }
        return list;
    }
 
}

 

使用：

对要数据字典转换的方法加上DataDictClass注解

 

需要注解翻译的加上注解DataDict ，dict是指标准码的编码

 

工具类：主要用了反射机制

package com.zddts.common.utils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;
import java.util.Map.Entry;

public class BeanUtils {

    /**
     * 方法说明：将List<Map>转换为List<Bean>
     *
     * @param mapList
     * @param cls
     * @return
     * @throws Exception
     */
    public static List<Object> mapListToBeanList(
            List<Map<String, Object>> mapList, Class<?> cls) throws Exception {
        if (mapList == null || mapList.size() == 0) {
            return null;
        }
        List<Object> beanList = new ArrayList<Object>();
        Object bean = null;
        for (Map<String, Object> map : mapList) {
            bean = mapToBean(map, cls);
            if (bean == null) {
                continue;
            }
            beanList.add(bean);
        }
        return beanList;
    }

    /**
     * 设置bean 属性值,没有下划线的
     *
     * @param map
     * @param cls
     * @return
     * @throws Exception
     */
    public static Object mapToBeanNL(Map<String, Object> map, Class<?> cls) throws Exception {
        if (map == null || map.size() == 0) {
            return null;
        }
        Object obj = cls.newInstance();
        for (Entry<String, Object> entry : map.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            if (value == null) {
                continue;
            }
            // 判断字段是否存在
            String fieldName = key;
            Field field = getBeanField(cls, fieldName);
            if (field == null) {
                continue;
            }
            // 判断字段的set方法是否存在
            String setMethodName = StringUtils.pareSetName(fieldName);
            Method method = getBeanMethod(cls, setMethodName, field.getType());
            if (method == null) {
                continue;
            }

            String fieldType = field.getType().getSimpleName();
            if ("String".equals(fieldType)) {
                method.invoke(obj, value.toString());
            } else if ("long".equals(fieldType) || "Long".equals(fieldType)) {
                method.invoke(obj, Long.valueOf(value.toString()));
            } else if ("int".equals(fieldType) || "Integer".equals(fieldType)) {
                method.invoke(obj, value.toString());
            } else if ("double".equals(fieldType) || "Double".equals(fieldType)) {
                method.invoke(obj, Double.valueOf(value.toString()));
            } else if ("float".equals(fieldType) || "Float".equals(fieldType)) {
                method.invoke(obj, Float.valueOf(value.toString()));
            } else if ("boolean".equals(fieldType) || "Boolean".equals(fieldType)) {
                if (value.getClass().equals(Boolean.class)) {
                    method.invoke(obj, (Boolean) value);
                } else {
                    method.invoke(obj, Boolean.valueOf(value.toString()));
                }
            } else if ("Date".equals(fieldType)) {
                if (value != null) {
                    if (value.getClass().equals(Date.class)) {
                        method.invoke(obj, (Date) value);
                    } else {
                        method.invoke(obj, DateUtils.strToDate(value.toString()));
                    }
                }
            }
        }
        return obj;
    }

    /**
     * 设置bean 属性值
     *
     * @param map
     * @param cls
     * @return
     * @throws Exception
     */
    public static Object mapToBean(Map<String, Object> map, Class<?> cls)
            throws Exception {
        if (map == null || map.size() == 0) {
            return null;
        }
        Object obj = cls.newInstance();
        for (Entry<String, Object> entry : map.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            if (value == null) {
                continue;
            }
            // 判断字段是否存在
            String fieldName = StringUtils.toUnderLine(key.toLowerCase());
            Field field = getBeanField(cls, fieldName);
            if (field == null) {
                continue;
            }
            // 判断字段的set方法是否存在
            String setMethodName = StringUtils.pareSetName(fieldName);
            Method method = getBeanMethod(cls, setMethodName, field.getType());
            if (method == null) {
                continue;
            }

            String fieldType = field.getType().getSimpleName();
            if ("String".equals(fieldType)) {
                method.invoke(obj, value.toString());
            } else if ("long".equals(fieldType) || "Long".equals(fieldType)) {
                method.invoke(obj, Long.valueOf(value.toString()));
            } else if ("int".equals(fieldType) || "Integer".equals(fieldType)) {
                method.invoke(obj, value.toString());
            } else if ("double".equals(fieldType) || "Double".equals(fieldType)) {
                method.invoke(obj, Double.valueOf(value.toString()));
            } else if ("float".equals(fieldType) || "Float".equals(fieldType)) {
                method.invoke(obj, Float.valueOf(value.toString()));
            } else if ("boolean".equals(fieldType)
                    || "Boolean".equals(fieldType)) {
                if (value.getClass().equals(Boolean.class)) {
                    method.invoke(obj, (Boolean) value);
                } else {
                    method.invoke(obj, Boolean.valueOf(value.toString()));
                }
            } else if ("Date".equals(fieldType)) {
                if (value != null) {
                    if (value.getClass().equals(Date.class)) {
                        method.invoke(obj, (Date) value);
                    } else {
                        method.invoke(obj, DateUtils
                                .strToDate(value.toString()));
                    }
                }
            }
        }
        return obj;
    }

    /**
     * 方法说明：将List<Bean>转换为List<Map>
     *
     * @param beanList
     * @return
     * @throws Exception
     */
    public static List<Map<String, Object>> beanListToMapList(
            List<Map<String, Object>> beanList) throws Exception {
        if (beanList == null || beanList.size() == 0) {
            return null;
        }
        List<Map<String, Object>> mapList = new ArrayList<Map<String, Object>>();
        Map<String, Object> map = null;
        for (Object bean : beanList) {
            map = beanToMap(bean);
            if (map == null || map.size() == 0) {
                continue;
            }
            mapList.add(map);
        }
        return mapList;
    }

    /**
     * 设置bean 属性值
     *
     * @param bean
     * @return
     * @throws Exception
     */
    public static Map<String, Object> beanToMap(Object bean) throws Exception {
        if (bean == null) {
            return null;
        }
        Map<String, Object> map = new HashMap<String, Object>();
        Class<?> cls = bean.getClass();
        Field fields[] = cls.getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName();
            String fieldType = field.getType().getSimpleName();
            boolean isBooleanType = false;
            if (fieldType.equals("boolean") || fieldType.equals("Boolean")) {
                isBooleanType = true;
            }
            String getMethodName = StringUtils.pareGetName(fieldName,
                    isBooleanType);
            // 判断字段的无参get方法是否存在
            Method method = getBeanMethod(cls, getMethodName, new Class[]{});
            if (method == null) {
                continue;
            }
            Object fieldValue = method.invoke(bean, new Object[]{});
            map.put(StringUtils.toUnderLine(field.getName()).toUpperCase(),
                    fieldValue);
        }
        return map;
    }

    /**
     * 判断该方法是否存在
     *
     * @param methods
     * @param met
     * @return
     */
    public static boolean checkMethod(Method methods[], String met) {
        if (null != methods) {
            for (Method method : methods) {
                if (met.equals(method.getName())) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 方法说明：获取bean的指定方法
     * <p>
     * <p>
     * Author： zhenqiangs Create Date： 2016-4-30 下午01:07:12 History: 2016-4-30
     * 下午01:07:12 zhenqiangs Created.
     *
     * @param cls
     * @param methodName
     * @param paramTypes
     * @return
     */
    private static Method getBeanMethod(Class<?> cls, String methodName,
                                        Class<?>... paramTypes) {
        if (cls == null) {
            return null;
        }
        Method setMethod = null;
        try {
            setMethod = cls.getMethod(methodName, paramTypes);
        } catch (Exception e) {

        }
        return setMethod;
    }

    /**
     * 方法说明：获取bean的指定属性
     *
     * @param cls
     * @param fieldName
     * @return
     */
    public static Field getBeanField(Class<?> cls, String fieldName) {
        if (cls == null) {
            return null;
        }
        Field field = null;
        try {
            field = cls.getDeclaredField(fieldName);
        } catch (Exception e) {

        }
        return field;
    }

    /**
     * 设置对应值
     *
     * @param fieldName
     */
    public static void setBeanField(Class<?> cls, Object obj, String fieldName, Object value) throws Exception {

        // 判断字段是否存在
        Field field = getBeanField(cls, fieldName);
        if (field == null) {
            return;
        }
        // 判断字段的set方法是否存在
        String setMethodName = StringUtils.pareSetName(fieldName);
        Method method = getBeanMethod(cls, setMethodName, field.getType());
        if (method == null) {
            return;
        }
        //为空不设置
        if (value == null) {
            return;
        }
        String fieldType = field.getType().getSimpleName();
        if ("String".equals(fieldType)) {
            method.invoke(obj, value.toString());
        } else if ("long".equals(fieldType) || "Long".equals(fieldType)) {
            method.invoke(obj, Long.valueOf(value.toString()));
        } else if ("int".equals(fieldType) || "Integer".equals(fieldType)) {
            method.invoke(obj, value.toString());
        } else if ("double".equals(fieldType) || "Double".equals(fieldType)) {
            method.invoke(obj, Double.valueOf(value.toString()));
        } else if ("float".equals(fieldType) || "Float".equals(fieldType)) {
            method.invoke(obj, Float.valueOf(value.toString()));
        } else if ("boolean".equals(fieldType) || "Boolean".equals(fieldType)) {
            if (value.getClass().equals(Boolean.class)) {
                method.invoke(obj, (Boolean) value);
            } else {
                method.invoke(obj, Boolean.valueOf(value.toString()));
            }
        } else if ("Date".equals(fieldType)) {
            if (value.getClass().equals(Date.class)) {
                method.invoke(obj, (Date) value);
            } else {
                method.invoke(obj, DateUtils.strToDate(value.toString()));
            }
        }
    }

    /**
     * 设置对应值
     *
     * @param fieldName
     */
    public static Object getBeanFieldValue(Class<?> cls, Object obj, String fieldName) throws Exception {

        // 判断字段是否存在
        Field field = getBeanField(cls, fieldName);
        // 判断字段的set方法是否存在
        String getMethodName = StringUtils.pareGetName(fieldName, false);
        // 判断字段的无参get方法是否存在
        Method method = getBeanMethod(cls, getMethodName, new Class[]{});
        Object fieldValue = method.invoke(obj, new Object[]{});
        return fieldValue;
    }
}

 

luu_一只程序猿
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
springboot实现消息转换、切面AOP和Redis缓存
11-16
springboot实现消息转换、切面AOP和Redis缓存,实现相关技术的实例，以及相关方法的使用说明
springboot+redis+切面实现数据字典和自动设置用户信息功能解放双手
boomLJiE的博客
05-30 8193
首先 自定义注解：DataDict，用于bo对象类，需要翻译的属性 package com.zddts.common.annotation.dict; import java.lang.annotation.*; /** * 说明：数据字典处理类 * Created by luojie on 2019/05/29. */ //@DataDict( dict="pat...
springboot 注解属性转换字典
最新发布
qq_31745863的博客
02-29 538
可以看到通过注解生成了一个statusText字段,并且为字段中配置的转换后的值。此处Vo属性上加上自定义注解。
使用redis+切面完成分布式锁
weixin_41036287的博客
11-10 1414
近日在项目上，需要用到分布式锁，那肯定redis实现了，后来一想干脆写个切面吧，后期方便使用，于是查看了很多文章，然后照猫画虎的实现了，废话不多说，直接上代码！ maven使用包 <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> </depende
自定义Redis注解及切面导入
mayongbo19的博客
07-03 484
1.切面类 @Aspect @Component public class DelRedisAspect { public static final Logger logger = LoggerFactory.getLogger(DelRedisAspect.class); @Autowired RedisClient redisClient; /** ...
SpringBoot AOP切面 + Redis 身份验证
LinzhiQQQ的博客
12-02 684
一个成熟的项目中，如果有些方法是对登录身份有所限制的话，我们往往回去验证一下用户的身份，方法很简单，就是从Cookie里取出我们的身份信息，再判断是否有效 我们这里使用的身份验证工具时 Redis，我们在用户登录时为用户生成一个 token，把 token 放进 Cookie 传到前端的同时也在Redis 里保存 token 1.创建一个 Redis 用的属性类，如有效期，前缀等 /** ...
vue+springboot+redis+kaptcha实现登录验证码
04-10
vue+springboot+redis+kaptcha实现登录页验证码
springboot+websocket+redis实现聊天室
08-05
springboot+websocket+redis实现聊天室功能，可以实现私聊和群聊(并支持发送图片)
Springboot+redis+mybatisplus实例
03-07
Springboot+redis+mybatisplus
springboot+redis实现查询附近商铺功能.zip
05-20
springboot+redis实现查询附近商铺功能.zip
Springboot+Redis单点登录.zip
10-27
单点登录英文全称Single Sign On，简称就是SSO。它的解释是：在多个应用系统中，只需要登录一次，就可以访问其他相互信任的应用系统。
京东秒杀系统模块的Redis分布式锁深度剖析，没给你讲明白你打我！
互联网架构小马的博客
10-22 559
1|0背景 目前开发过程中，按照公司规范，需要依赖框架中的缓存组件。不得不说，做组件的大牛对CRUD操作的封装，连接池、缓存路由、缓存安全性的管控都处理的无可挑剔。但是有一个小问题，该组件没有对分布式锁做实现，那就要想办法依靠缓存组件自己去实现一个分布式锁了。 什么，为啥要自己实现？有现成的开源组件直接拿过来用不就行了，比如Spring-Integration-Redis提供RedisLockRegistry，Redisson，不比自己去实现快的多。那我得声明一下，本人也不喜欢重复造轮子。具体原因呢，首
redis缓存原理与实现_基于Redis与切面实现方法通用缓存
weixin_39997311的博客
12-08 774
简介随着系统QPS逐渐提高，在一些读取频繁变更较少数据场景下，适当添加缓存不仅能提升用户访问速度还可以减轻系统压力。使用缓存主要有两个用途：高性能、高并发高性能：查询mysql耗时需要300ms,存到缓存redis，每次查询仅需要几毫秒,性能瞬间提升百倍。高并发mysql 单机支撑2K QPS就容易报警了，使用缓存的话，单机支撑的并发量轻松1s几万~十几万。缓存位于内存，内存对高并发的良...
Redis缓存切面异常注解
weixin_54889617的博客
11-17 512
1:此注解可以搭配上一篇的缓存切面 * 依赖就不过多展示了,和上一篇依赖一样 2: 自定义缓存切面异常注解 package com.qycq.api.annotations; import io.swagger.annotations.ApiModel; import java.lang.annotation.*; /** * 概要: * <p> As we all know, where there is Wolong, there must be phoenix!</p&gt
redis缓存切面实现(支持缓存key的spel表达式)
aiji7208的博客
07-03 486
1.定义注解 package com.g2.order.server.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.la...
JAVA开发（通过AOP切面方式管理redis缓存）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
01-11 625
在调用查询方法时，判断redis中是否已经有，如果有则优先从redis中查询。 如果没有则在数据库中查询后并存入到Redis中一份，并给其设置过期时间。 这样在过期时间之内，查询数据会从redis中查询，过期之后会重新从数据库中查询并存入到Redis一份。再对这个数据库表进行新增、编辑、删除的操作时，将redis中存储的数据。 进行删除，这样下次查询就会查询数据库中最新的。
spring-aop(上)-查询切面并缓存
qq_39465518的博客
07-22 336
什么是aop（官方的讲） 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 aop的基本概念 AOP 是一个概念，一个规范，本身并没有设定具体语.
Redis缓存切面处理
iechenyb专栏
08-26 673
package com.cyb.web.example.controller; import java.util.List; import java.util.Map; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cache.annotation.Cacheable; import org.springframework.util.StringUtils; impor.
【SpringBoot】24、SpringBoot中实现数据字典
热门推荐
Asurplus
07-17 22万+
数据字典是指对数据的数据项、数据结构、数据流、数据存储、处理逻辑等进行定义和描述，其目的是对数据流程图中的各个元素做出详细的说明，使用数据字典为简单的建模项目
springboot+redis+mysql+uniapp实现点赞和评论功能
07-14
实现点赞和评论功能可以使用Spring Boot作为后端框架，Redis作为缓存数据库，MySQL作为持久化数据库，UniApp作为前端框架。以下是一个简单的实现步骤： 1. 创建Spring Boot项目并配置MySQL和Redis的连接。 2. 创建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值