SpringSecurity和oauth2微信登陆

<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.2.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-jwt</artifactId>
    <version>1.0.10.RELEASE</version>
</dependency>`

#微信公众号的appid
wechat.appid=your wechat appid
#微信公众号的appsecret
wechat.secret=your wechat secret
#微信登录授权回调地址
wechat.redirect_uri=your redirect uri

public class WechatAuthenticationFilter extends
        AbstractAuthenticationProcessingFilter {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private static final String WECHAT_AUTHENTICATE_URL = "/wechat/login/authenticate";

    private final Cache cache;

    @Autowired
    private WechatProperties wechatProperties;

    public WechatAuthenticationFilter(RequestMatcher requiresAuthenticationRequestMatcher,
                                      Cache cache) {
        super(requiresAuthenticationRequestMatcher);
        this.cache = cache;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request,
                                                HttpServletResponse response) throws AuthenticationException,
            IOException, ServletException {
        logger.info("微信登录鉴权");
        String code = request.getParameter("code");
        if (StringUtils.isBlank(code)) {
            throw new WechatAuthenticationException(ErrorCodeEnum.WECHAT_AUTH_CODE_REQUIRED.getErrorCode(),
                    ErrorCodeEnum.WECHAT_AUTH_CODE_REQUIRED.getErrorMsg());
        }

        WechatAuthUserInfo wechatAuthUserInfo = WechatAuthUtils.getUserInfoByCodeAndAccessToken(
                code, wechatProperties.getAppid(), wechatProperties.getSecret());

        // 检查是否已绑定用户
        String openid = wechatAuthUserInfo.getOpenid();
        UserAccountDao mainUserDao = BeanUtils.getBean(UserAccountDao.class);
        UserAccount userAccount = mainUserDao.getByOpenid(openid);
        if (userAccount == null) {
            throw new WechatAuthenticationException(
                    ErrorCodeEnum.WECHAT_AUTH_OPENID_NOT_BIND.getErrorCode(),
                    ErrorCodeEnum.WECHAT_AUTH_OPENID_NOT_BIND.getErrorMsg());
        }

        logger.info("微信登录鉴权成功");

        // 生成jwt token并返回
        JwtTokenProperties jwtTokenProperties = BeanUtils.getBean(JwtTokenProperties.class);
        String token = JwtUtils.createToken(userAccount, jwtTokenProperties.getExpireInMinute(),
                jwtTokenProperties.getSecret());
        response.setHeader("Access-Token", token);
        return new WechatAuthenticationToken(userAccount);
    }

    /**
     * 匹配url是否是微信授权回调
     * 
     * @param request
     *            请求
     * @return boolean
     */
    @Override
    protected boolean requiresAuthentication(HttpServletRequest request,
            HttpServletResponse response) {
        return StringUtils.endsWith(request.getRequestURI(), WECHAT_AUTHENTICATE_URL) && request
                .getMethod().equalsIgnoreCase("get");
    }
}

public class WechatAuthenticationProvider implements AuthenticationProvider {

    @Autowired
    private Cache cache;

    @Override
    public Authentication authenticate(Authentication authentication)
            throws AuthenticationException {
        WechatAuthenticationToken wechatAuthenticationToken = (WechatAuthenticationToken) authentication;
        UserAccount userAccount = wechatAuthenticationToken.getUserAccount();
        cache.put(userAccount.getUuid(), userAccount);
        return wechatAuthenticationToken;
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return WechatAuthenticationToken.class.equals(authentication);
    }
}

public class WechatAuthenticationToken extends AbstractAuthenticationToken {

    private static final long serialVersionUID = -2872688686791428001L;
    private final UserAccount userAccount;

    public WechatAuthenticationToken(UserAccount userAccount) {
        super(null);
        this.userAccount = userAccount;
        super.setAuthenticated(true);
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return Collections.emptyList();
    }

    @Override
    public Object getCredentials() {
        return null;
    }

    @Override
    public Object getPrincipal() {
        return userAccount;
    }

    public UserAccount getUserAccount() {
        return userAccount;
    }
}

public class WechatAuthenticationException extends AuthenticationException {

    private static final long serialVersionUID = 3045924610355703429L;
    private String errorCode;

    public WechatAuthenticationException(String errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }

    public String getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }
}

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private Cache cache;

    @Autowired
    private WechatAuthenticationProvider wechatAuthenticationProvider;

    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Autowired
    private WechatProperties wechatProperties;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable() // 关闭csrf
                .authorizeRequests().antMatchers("/wechat/**").permitAll() // 微信登录授权
                .antMatchers("/**").authenticated() // 其他接口需要登陆
                .and().anonymous().disable().exceptionHandling()
                .authenticationEntryPoint(new RestAuthenticationEntryPoint())
                .and()
                .addFilterBefore(wechatAuthenticationFilter(),
                        UsernamePasswordAuthenticationFilter.class) // 微信授权登录过滤器
                .addFilterBefore(jwtAuthenticationFilter,
                        RequestCacheAwareFilter.class); // jwt验证过滤器

    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/static/**");
        super.configure(web);
    }

    @Bean
    public WechatAuthenticationFilter wechatAuthenticationFilter() {
        String wechatRedirectUri = wechatProperties.getRedirectUri();
        String wechatAuthorizeUrl = WechatAuthUtils.generateAuthorizeUrl(wechatProperties.getAppid(),
                URLEncoder.encode(wechatRedirectUri), WechatAuthScopeEnum.SNSAPI_USERINFO);
        return new WechatAuthenticationFilter(
                new AntPathRequestMatcher(WECHAT_AUTHENTICATE_URL),
                cache);
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(wechatAuthenticationProvider)
                .userDetailsService(userDetailsService)
                .passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}