k94314517
2024-03-04 c1e7bbbec984e4cd1b9f31490e3d85ae7c923ab0
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
package com.doumee.config.Jwt;
 
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.config.annotation.ErpLoginRequired;
import com.doumee.config.annotation.LoginRequired;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.redis.RedisUtil;
import com.doumee.dao.business.model.Member;
import io.jsonwebtoken.JwtException;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.Objects;
 
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
 
 
    @Autowired
    private JdbcTemplate dao;
 
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
 
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
 
    /**
     * 添加拦截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //API接口JwtToken拦截器
        HandlerInterceptor TokenInterceptor = new HandlerInterceptor() {
            @Override
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                // 如果不是映射到方法直接通过
                if (!(handler instanceof HandlerMethod)) {
                    return true;
                }
                HandlerMethod handlerMethod = (HandlerMethod) handler;
 
                Class<?> beanType = handlerMethod.getBeanType();
 
//                Method method = handlerMethod.getMethod();
 
                // 有 @LoginRequired 注解,需要登录认证
                if (beanType.isAnnotationPresent(LoginRequired.class) || handlerMethod.hasMethodAnnotation(LoginRequired.class)) {
                    //获取token
                    String token = request.getHeader(JwtTokenUtil.HEADER_KEY);  // 从 http 请求头中取出 token
                    if (StringUtils.isNotBlank(token)) {
                        checkLogin(request,response);
                    } else {
                        throw new BusinessException(ResponseStatus.NO_LOGIN.getCode(),"未登录");
                    }
                } else if(beanType.isAnnotationPresent(ErpLoginRequired.class) || handlerMethod.hasMethodAnnotation(ErpLoginRequired.class)){
                    try {
                        //ERP 业务注解
                        String token = request.getHeader(JwtTokenUtil.HEADER_KEY);
                        String redisToken = RedisUtil.getObject(redisTemplate,Constants.RedisKeys.ERP_TOKEN,String.class);
                        if(StringUtils.isBlank(redisToken)||!token.equals(redisToken)){
                            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"授权已失效");
                        }
                        request.setAttribute(JwtTokenUtil.HEADER_KEY,token);
                    } catch (IllegalArgumentException | JwtException e) {
                        throw new BusinessException(ResponseStatus.NO_LOGIN.getCode(),"授权已失效");
                    }
//                    request.setAttribute("token", token);
                }
                return true;
            }
        };
        registry.addInterceptor(TokenInterceptor).addPathPatterns("/web/**","/visitbiz/**");
    }
 
 
 
    public Boolean checkLogin(HttpServletRequest request, HttpServletResponse response){
        String token = request.getHeader(JwtTokenUtil.HEADER_KEY);
        try {
            //判断Token是否超时
            boolean expiration = JwtTokenUtil.isTokenExpired(token);
            if (expiration) {
                throw new BusinessException(ResponseStatus.TOKEN_EXCEED_TIME.getCode(),"长时间未操作,请重新登录");
            }
            //获取账号ID
            String memberId = JwtTokenUtil.getJwtPayLoad(token).getMemberId();
            Member member = dao.queryForObject(" select  *  from `member` where id  = ?  limit 1  ", new BeanPropertyRowMapper<>(Member.class),memberId );
            if(Objects.isNull(member)){
                throw new BusinessException(ResponseStatus.DATA_EMPTY);
            }
            if(member.getIsdeleted()== Constants.ONE){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"用户已删除,请联系管理员");
            }
            if(member.getStatus() != Constants.ZERO){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"用户已禁用,请联系管理员");
            }
            request.setAttribute(JwtTokenUtil.UserId_Name, memberId);
            request.setAttribute(JwtTokenUtil.MEMBER, member);
            return true;
        } catch (IllegalArgumentException | JwtException e) {
            throw new BusinessException(ResponseStatus.NO_LOGIN.getCode(),"未登录");
        }
    }
 
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
 
 
}