两张表 案例表里有项目表的id 在展示案例所属项目时一般做法是拿到案列表的里项目id去项目表里去查询然后赋值给案例表的项目名称字段，这样做法违背了单一职责，也就是说你查案例的列表信息的代码用到的项目表的里代码，造成了高耦合性，这对以后业务改变，代码变动太大。所以现在利用aop反射代理来实现一个方法只实现单一的功能。是方法只专注于完成一个事情，其他的事情不需要这个方法去关心。
1，首先我们要声明两个注解，一个注解在实体属性上，一个注解在方法上
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)//作用在属性上 注解也定义了属性 所以在实体上的注解得加上这些属性
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedSetValue {
Class<?> beanClass();//调用的哪个类
String method();//调用的哪个方法
String param();//传入的参数是啥
String targetFiled();//设置哪个属性值
}import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)//作用在方法上 在业务方法中加入@NeedSetFieldValue 就会执行这个注解
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedSetFieldValue {
}2 声明一个aop
import com.xz.boot.common.model.AdminPageModel;
import com.xz.boot.common.utils.BeanUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Collection;
@Component
/**
* 定义一个切面 拦截 NeedSetFieldValue注解
*/
@Aspect
public class SetFieldValueAspect {
@Autowired
BeanUtil beanUtil;
@Around("@annotation(com.xz.boot.common.annotation.NeedSetFieldValue)")
public Object doFieldValue(ProceedingJoinPoint pjp) throws Throwable {//调用的是哪个方法
//AdminPageModel 是我调用了项目的服务类返回的自定义返回实体，可以自己定义，最好设置的是Object类型，这样比较通用
AdminPageModel proceed = (AdminPageModel)pjp.proceed();//返回结果
System.out.println(proceed);
Collection data = (Collection) proceed.getData();
if(data.size()!=0){
this.beanUtil.setFieldValueForCollection((Collection) proceed.getData());//结果集处理
}
return proceed;
}
}
3 实体类上写上注解
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import com.xz.boot.common.annotation.NeedSetValue;
import com.xz.boot.dao.sys.YwItemsDao;
import com.xz.boot.service.impl.sys.YwItemsServiceImpl;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
public class YwCase extends Model<YwCase> {
private String itemId;
// 调用的类 调用方法 传入参数 赋值给 itemName字段 返回结果的title值
@NeedSetValue(beanClass = YwItemsServiceImpl.class,method = "find",param = "itemId",targetFiled = "title")
private String itemName;
}
4 在方法上加入注解
@ResponseBody
@GetMapping("list")
@NeedSetFieldValue
public Object list(Integer pageNumber, Integer pageSize,HttpServletRequest request,YwCase ywCase){
IPage<YwCase> page = new Page<>(pageNumber, pageSize);
List<YwCase> list = ywCaseService.list(request,page,ywCase);
//list 的每个YwCase都有一个itemName需要调用注解去赋值，但一个方法最好只完成一个单一的功能，在方法体里如果不用注解那就必须得调用项目的service来获取项目名称来赋值案例的itemName字段，注解就是帮我们完后调用服务来赋值的
if(list.size()<=0){
return AdminPageModel.success(list,page.getTotal());
}
return AdminPageModel.success(list,page.getTotal());
}最后附上反射工具类和redis工具类
import com.xz.boot.common.annotation.NeedSetValue;
import com.xz.boot.common.utils.redis.RedisUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Collection;
@Component
public class BeanUtil implements ApplicationContextAware {
@Resource
RedisUtils redisUtils;
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if(this.applicationContext==null){
this.applicationContext=applicationContext;
}
}
public void setFieldValueForCollection(Collection col) throws Exception {//返回的结果
if(col.size()!=0) {
Class<?> clazz = col.iterator().next().getClass();//获取service执行的类
Field[] fields = clazz.getDeclaredFields();//查询service执行结果集
for (Field field : fields) {
NeedSetValue sv = field.getAnnotation(NeedSetValue.class);//实体属性上有注解的
if (sv == null) {
continue;
}
field.setAccessible(true);//有注解的默认都是不可见的 设置为可见
Object bean = this.applicationContext.getBean(sv.beanClass());//获取属性上注解执行的类
//获取属性上注解执行的方法
Method method = sv.beanClass().getMethod(sv.method(), clazz.getDeclaredField(sv.param()).getType());
//获取属性上注解需要输入的参数
Field declaredField = clazz.getDeclaredField(sv.param());
declaredField.setAccessible(true);//参数不可见 设置为可见
Field targetField = null;
String keyPreFix = sv.beanClass() + "-" + sv.method() + "-" + sv.targetFiled() + "-";
for (Object obj : col) {//循环service返回的结果
Object paramValue = declaredField.get(obj);//获取需要传入参数的值
if (paramValue == null) {
continue;
}
Object value = null;
String key = keyPreFix+paramValue;
if(StringUtils.isNotBlank(redisUtils.get(key))){
value = redisUtils.get(key);
}else{
value = method.invoke(bean, paramValue);//方法反射获取那个类，需要传入的参数值 获取方法的执行结果
if (value != null) {
if (targetField == null) {
targetField = value.getClass().getDeclaredField(sv.targetFiled());//获取需要设置的属性
targetField.setAccessible(true); //属性默认都是不可见的，都要设置为可见
}
value = targetField.get(value);
}
redisUtils.set(key,value,1);
}
field.set(obj, value);
}
}
}
}
}import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* redis工具类
*https://www.cnblogs.com/wangkongming/p/12938709.html
* https://blog.csdn.net/ccq1127/article/details/99300183
* @author wdd
* @create 2020/7/12
* @since 1.0.0
*/
@Component
public class RedisUtils {
@Resource
private RedisTemplate<String, Object> redisTemplate ;
@Resource
private ValueOperations<String, String> valueOperations ;
@Resource
private HashOperations<String, String, Object> hashOperations ;
@Resource
private ListOperations<String, Object> listOperations ;
@Resource
private SetOperations<String, Object> setOperations ;
@Resource
private ZSetOperations<String, Object> zSetOperations ;
/** 默认过期时长，单位：秒 */
public final static long DEFAULT_EXPIRE = 60 * 60 * 24;
/** 不设置过期时长 */
public final static long NOT_EXPIRE = -1;
/**
* 将值放入缓存
*/
public void setLockValue(String key, Object value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 字符串：取对象
*/
public <T> T getObject(String key) {
Object o = redisTemplate.opsForValue().get(key);
if (o != null) {
return (T) o;
}
return null;
}
/**
* 将值放入缓存并设置时间-秒
*/
public void setLockValueTime(String key, Object value, long time) {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
redisTemplate.opsForValue().set(key, value);
}
}
/**
* 删除key
*/
public void deleteKey(String key) {
redisTemplate.delete(key);
}
/**
* 创建锁
* @param key 锁的Key
* @param value 值(随便写毫无意义)
* @param releaseTime 锁过期时间 防止死锁
* @return boolean
*/
public boolean lock2(String key, int value, long releaseTime) {
// 尝试获取锁
Boolean boo = redisTemplate.opsForValue().setIfAbsent(key, value, releaseTime, TimeUnit.SECONDS);
// 判断结果
return boo != null && boo;
}
/**
* spring-boot-starter-data-redis 2.2.7.RELEASE 上面这种不支持
* 创建锁
* @param key 锁的Key
* @param value 值(随便写毫无意义)
* @param releaseTime 锁过期时间 防止死锁
* @return boolean
*/
public boolean lock(String key, int value, long releaseTime) {
// // 尝试获取锁
// Boolean boo = redisTemplate.opsForValue().setIfAbsent(key, value, releaseTime, TimeUnit.SECONDS);
// // 判断结果
// return boo != null && boo;
// java 使用redis的事务时不能直接用Api中的multi()和exec()，这样multi()和exec()两次使用的stringRedisTemplate不是一个connect，会导致死锁，正确方式如下：
SessionCallback<Boolean> sessionCallback = new SessionCallback<Boolean>() {
List<Object> exec = null;
@Override
@SuppressWarnings("unchecked")
public Boolean execute(RedisOperations operations){
operations.multi();
redisTemplate.opsForValue().setIfAbsent(key, value);
redisTemplate.expire(key, releaseTime, TimeUnit.SECONDS);
exec = operations.exec();
if(exec.size() > 0) {
return (Boolean) exec.get(0);
}
return false;
}
};
return redisTemplate.execute(sessionCallback);
}
/**
* 根据key删除锁
*/
public void deleteLock(String key) {
// 删除key即可释放锁
deleteKey(key);
}
public void set(String key, Object value, long expire){
valueOperations.set(key, toJson(value));
if(expire != NOT_EXPIRE){
redisTemplate.expire(key, expire*60, TimeUnit.SECONDS);
}
}
public void set(String key, Object value){
set(key, value, DEFAULT_EXPIRE);
}
public <T> T get(String key, Class<T> clazz, long expire) {
String value = valueOperations.get(key);
if(expire != NOT_EXPIRE){
redisTemplate.expire(key, expire, TimeUnit.SECONDS);
}
return value == null ? null : fromJson(value, clazz);
}
public <T> T get(String key, Class<T> clazz) {
return get(key, clazz, NOT_EXPIRE);
}
public String get(String key, long expire) {
String value = valueOperations.get(key);
if(expire != NOT_EXPIRE){
redisTemplate.expire(key, expire, TimeUnit.SECONDS);
}
return value;
}
public String get(String key) {
return get(key, NOT_EXPIRE);
}
public void delete(String key) {
redisTemplate.delete(key);
}
public void deleteBatch(String key){
Set<String> keys = redisTemplate.keys(key + "*");
Iterator<String> it = keys.iterator();
while(it.hasNext()){
String keyStr = it.next();
redisTemplate.delete(keyStr);
}
}
/**
* Object转成JSON数据
*/
private String toJson(Object object){
if(object instanceof Integer || object instanceof Long || object instanceof Float ||
object instanceof Double || object instanceof Boolean || object instanceof String){
return String.valueOf(object);
}
return JSONObject.toJSONString(object);
}
/**
* JSON数据，转成Object
*/
private <T> T fromJson(String json, Class<T> clazz){
return JSONObject.parseObject(json,clazz);
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<String, Object> hmget(String key) {
Map<Object, Object> map = redisTemplate.opsForHash().entries(key);
Map<String,Object> data = new HashMap<>();
for (Object m : map.entrySet()){
data.put(m+"",map.get(m));
}
return data;
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0)
expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
总结：总体流程：定义一个属性注解作用于实体类上 属性注解 有四个属性 调用哪个类，调用哪个类的哪个方法，传入的参数是什么，获取返回值得那个属性值赋值给该属性
定义一个方法注解
在实体属性上添加属性注解，指定哪个类的哪个方法来获取返回结果赋值给实体属性值
在方法上添加方法注解，web端调用该方法就会执行方法注解，aop会获取该注解的切面，来执行属性上的注解指定的方法。BeanUtil 是利用反射来完成赋值的，为了少调用数据库，把首次获取的值存到redis上，下次调用的时候就不需要和数据库交互，直接从缓存上获取了。单一属性的赋值，都可以用这个通用的方法来赋值。
97
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
