<dependency>
  <groupId>me.zhyd.oauth</groupId>
  <artifactId>JustAuth</artifactId>
  <version>${latest.version}</version>
</dependency>

AuthRequest authRequest = new AuthWeChatRequest(AuthConfig.builder()
      .clientId("Client ID")
      .clientSecret("Client Secret")
      .redirectUri("https://www.zhyd.me/oauth/callback/wechat")
      .build());

String authorizeUrl = authRequest.authorize(AuthStateUtils.createState());

import me.zhyd.oauth.config.AuthConfig;
import me.zhyd.oauth.request.AuthWeChatOpenRequest;
import me.zhyd.oauth.model.AuthCallback;
import me.zhyd.oauth.request.AuthRequest;
import me.zhyd.oauth.utils.AuthStateUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@RestController
@RequestMapping("/oauth")
public class RestAuthController {
    @RequestMapping("/render")
    public void renderAuth(HttpServletResponse response) throws IOException {
        AuthRequest authRequest = getAuthRequest();
        response.sendRedirect(authRequest.authorize(AuthStateUtils.createState()));
    }
    @RequestMapping("/callback")
    public Object login(AuthCallback callback) {
        AuthRequest authRequest = getAuthRequest();
        return authRequest.login(callback);
    }
    private AuthRequest getAuthRequest() {
        return new AuthWeChatOpenRequest(AuthConfig.builder()
                .clientId("Client ID")
                .clientSecret("Client Secret")
                .redirectUri("https://www.zhyd.me/oauth/callback/wechat")
                .build());
    }
}

public class AuthWeChatOpenRequest extends AuthDefaultRequest {
    public AuthWeChatOpenRequest(AuthConfig config) {
        super(config, AuthDefaultSource.WECHAT_OPEN);
    }
    public AuthWeChatOpenRequest(AuthConfig config, AuthStateCache authStateCache) {
        super(config, AuthDefaultSource.WECHAT_OPEN, authStateCache);
    }
    .....
}
public class AuthDefaultCache implements AuthCache {
    /**
     * state cache
     */
    private static Map<String, CacheState> stateCache = new ConcurrentHashMap<>();
    private final ReentrantReadWriteLock cacheLock = new ReentrantReadWriteLock(true);
    private final Lock writeLock = cacheLock.writeLock();
    private final Lock readLock = cacheLock.readLock();
    public AuthDefaultCache() {
        if (AuthCacheConfig.schedulePrune) {
            this.schedulePrune(AuthCacheConfig.timeout);
        }
    }
  }

import lombok.extern.slf4j.Slf4j;
import me.zhyd.oauth.cache.AuthCacheConfig;
import me.zhyd.oauth.cache.AuthStateCache;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
/**
 * 自定義AuthState Rds 緩存
 * @author zak
 **/
@Slf4j
@Component
public class AuthStateRedisCache implements AuthStateCache {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 存入緩存，默認(rèn)3分鐘
     *
     * @param key   緩存key
     * @param value 緩存內(nèi)容
     */
    @Override
    public void cache(String key, String value) {
        log.info("RDS, 存入緩存，默認(rèn)3分鐘, key: {}, value: {}", key, value);
        stringRedisTemplate.opsForValue().set(key, value, AuthCacheConfig.timeout, TimeUnit.MILLISECONDS);
    }
    /**
     * 存入緩存
     *
     * @param key     緩存key
     * @param value   緩存內(nèi)容
     * @param timeout 指定緩存過(guò)期時(shí)間（毫秒）
     */
    @Override
    public void cache(String key, String value, long timeout) {
        log.info("RDS, 存入緩存, key: {}, value: {}, timeout: {}", key, value, timeout);
        stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.MILLISECONDS);
    }
    /**
     * 獲取緩存內(nèi)容
     *
     * @param key 緩存key
     * @return 緩存內(nèi)容
     */
    @Override
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
    /**
     * 是否存在key，如果對(duì)應(yīng)key的value值已過(guò)期，也返回false
     *
     * @param key 緩存key
     * @return true：存在key，并且value沒(méi)過(guò)期；false：key不存在或者已過(guò)期
     */
    @Override
    public boolean containsKey(String key) {
        return stringRedisTemplate.hasKey(key);
    }
}

    @Resource
    private AuthStateRedisCache stateRedisCache;
    AuthRequest authRequest = new AuthWeChatOpenRequest(AuthConfig.builder()
        .clientId(wechatAppId)
        .clientSecret(wechatAppSecret)
        .redirectUri(StrUtil.isNotBlank(redirectUri) ? redirectUri : wechatRedirectUri)
        .build(), stateRedisCache);