admin
2021-01-19 8f1b5245c592cd6dc5eb5a73f9a0ceb2a85f2048
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package com.ks.daylucky.aspect;
 
import com.ks.daylucky.manager.RedisManager;
import com.ks.daylucky.util.annotation.RequestSerializable;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.annotation.Order;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.yeshi.utils.JsonUtil;
import org.yeshi.utils.StringUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;
 
import javax.annotation.Resource;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
 
@Component
@Aspect
@Order(4)
public class RequestSerializableAspect {
 
    private Set<Long> waitingThreadSet = new HashSet<>();
    @Resource
    private RedisManager redisManager;
 
    private ExpressionParser parser = new SpelExpressionParser();
 
    private DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();
 
    /**
     * 获取表达的值
     *
     * @param spELString
     * @param joinPoint
     * @return
     */
    public String generateKeyBySpEL(String spELString, ProceedingJoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String[] paramNames = nameDiscoverer.getParameterNames(methodSignature.getMethod());
        Expression expression = parser.parseExpression(spELString);
        EvaluationContext context = new StandardEvaluationContext();
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        return expression.getValue(context).toString();
    }
 
    @Around("execution(public * com.ks.daylucky.controller.api.client..*.*(..))")
    public Object requestSerializable(ProceedingJoinPoint joinPoint) throws Throwable {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method targetMethod = methodSignature.getMethod();
        String cacheKey = null;
 
        Method realMethod = joinPoint.getTarget().getClass().getDeclaredMethod(joinPoint.getSignature().getName(),
                targetMethod.getParameterTypes());
 
 
        if (realMethod.isAnnotationPresent(RequestSerializable.class)) {
            ServletRequestAttributes servletContainer = (ServletRequestAttributes) RequestContextHolder
                    .getRequestAttributes();
            RequestSerializable rs = realMethod.getAnnotation(RequestSerializable.class);
            String key = rs.key();
            cacheKey = generateKeyBySpEL(key, joinPoint);
 
            try {// redis做原子性保护
                if (!StringUtil.isNullOrEmpty(cacheKey)) {
                    cacheKey = joinPoint.getTarget().getClass().getName() + "." + targetMethod.getName() + "-"
                            + cacheKey;
                    String cacheAlias = cacheKey;
                    cacheKey = "rs-" + StringUtil.Md5(cacheKey);
                    // jiedis原子性做拦截
                    Jedis jedis = redisManager.getJedis();
                    long threadId = Thread.currentThread().getId();
                    try {
                        waitingThreadSet.add(threadId);
                        String result = null;
                        long startTime = System.currentTimeMillis();
                        // 等待响应
                        while (StringUtil.isNullOrEmpty(result)) {
                            result = jedis.set(cacheKey, "1", new SetParams().nx().ex(30));
                            if (StringUtil.isNullOrEmpty(result)) {
                                try {
                                    Thread.sleep(50);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                if (System.currentTimeMillis() - startTime > 1000 * 30L) {
                                    waitingThreadSet.remove(Thread.currentThread().getId());
                                    PrintWriter out = servletContainer.getResponse().getWriter();
                                    out.print(JsonUtil.loadFalseResult("连接超时"));
                                    return null;
                                }
                            } else {
                                break;
                            }
                        }
 
                        if (!StringUtil.isNullOrEmpty(result)) {
                            try {
                                return joinPoint.proceed();
                            } finally {
                                jedis.del(cacheKey);
                                waitingThreadSet.remove(Thread.currentThread().getId());
                            }
                        }
                    } finally {
                        jedis.close();
                    }
                }
            } catch (Exception e) {// 原子性保护出错
                return joinPoint.proceed();
            }
        }
 
 
        return joinPoint.proceed();
 
    }
 
    class ParamsTypeValue {
        Class<?> type;
        Object value;
 
        public ParamsTypeValue(Class<?> type, Object value) {
            this.type = type;
            this.value = value;
        }
 
        public ParamsTypeValue() {
 
        }
    }
 
}