若依 2.1

RuoYi

2020-08-02 cca4eeae7268ffb86767ec6d6a423a8fcffcf4fd

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
package com.ruoyi.gateway.filter; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.cloud.gateway.filter.GatewayFilter; 
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory; 
import org.springframework.http.HttpHeaders; 
import org.springframework.http.server.reactive.ServerHttpRequest; 
import org.springframework.http.server.reactive.ServerHttpResponse; 
import org.springframework.stereotype.Component; 
import com.alibaba.fastjson.JSON; 
import com.ruoyi.common.core.utils.StringUtils; 
import com.ruoyi.common.core.web.domain.AjaxResult; 
import com.ruoyi.gateway.service.ValidateCodeService; 
import reactor.core.publisher.Mono; 
 
/** 
 * 验证码过滤器 
 *  
 * @author ruoyi 
 */ 
@Component 
public class ValidateCodeFilter extends AbstractGatewayFilterFactory<Object> 
{ 
    private final static String AUTH_URL = "/oauth/token"; 
 
    @Autowired 
    private ValidateCodeService validateCodeService; 
 
    private static final String BASIC_ = "Basic "; 
 
    private static final String CODE = "code"; 
 
    private static final String UUID = "uuid"; 
     
    private static final String GRANT_TYPE = "grant_type"; 
     
    private static final String REFRESH_TOKEN = "refresh_token"; 
 
    @Override 
    public GatewayFilter apply(Object config) 
    { 
        return (exchange, chain) -> { 
            ServerHttpRequest request = exchange.getRequest(); 
 
            // 非登录请求，不处理 
            if (!StringUtils.containsIgnoreCase(request.getURI().getPath(), AUTH_URL)) 
            { 
                return chain.filter(exchange); 
            } 
             
            // 刷新token请求，不处理 
            String grantType = request.getQueryParams().getFirst(GRANT_TYPE); 
            if (StringUtils.containsIgnoreCase(request.getURI().getPath(), AUTH_URL) && StringUtils.containsIgnoreCase(grantType, REFRESH_TOKEN)) 
            { 
                return chain.filter(exchange); 
            } 
 
            // 消息头存在内容，且不存在验证码参数，不处理 
            String header = request.getHeaders().getFirst(HttpHeaders.AUTHORIZATION); 
            if (StringUtils.isNotEmpty(header) && StringUtils.startsWith(header, BASIC_) 
                    && !request.getQueryParams().containsKey(CODE) && !request.getQueryParams().containsKey(UUID)) 
            { 
                return chain.filter(exchange); 
            } 
            try 
            { 
                validateCodeService.checkCapcha(request.getQueryParams().getFirst(CODE), 
                        request.getQueryParams().getFirst(UUID)); 
            } 
            catch (Exception e) 
            { 
                ServerHttpResponse response = exchange.getResponse(); 
                response.getHeaders().add("Content-Type", "application/json;charset=UTF-8"); 
                return exchange.getResponse().writeWith( 
                        Mono.just(response.bufferFactory().wrap(JSON.toJSONBytes(AjaxResult.error(e.getMessage()))))); 
            } 
            return chain.filter(exchange); 
        }; 
    } 
}