前言
这是我在梳理另一篇关于SpringSecurity OAuth2完整文章的时候关注到的一个对象，那么下面我们来深入看看这个AuthorizationCodeServices对象！
介绍
我们知到授权服颁发Token我们可以存储在授权服中，也可以存储在MySQL中，当然也可以存储在Redis中，这个我们是通过TokenStore来实现的，这个我这里就不做重点介绍了，但是授权服中不止给第三方办法Token，当我们在做授权码认证的时候我们还向客户端颁发了一个授权码！那么AuthorizationCodeServices对象就是关于这个授权码颁发后怎么存储的对象！AuthorizationCodeServices这个对象我们是配置在授权服配置中的AuthorizationServerEndpointsConfigurer中，也就是如下代码
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {
@Autowired
private AuthorizationCodeServices authorizationCodeServices;
@Bean
public AuthorizationCodeServices authorizationCodeServices() { //设置授权码模式的授权码如何 存取，这里采用内存方式
return new InMemoryAuthorizationCodeServices();
}
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) {//配置令牌的访问端点和令牌服务
endpoints
.authorizationCodeServices(authorizationCodeServices)//授权码服务
.authenticationManager(authenticationManager)//认证管理器
.tokenServices(tokenService())
.allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST)
;
}
}
一般我们刚开始搭建授权服务的时候，都是采用基于授权服内存的，注意这里指的内存不是Redis，就是存储在JAVA程序中的！刚开始基于授权服内存主要是方便前期编写代码，让我们更加关注授权服的核心流程实现，而不是刚开始就引入MySQL、Redis这些第三方中间件！这里我为什么会写这篇文章呢，主要就是在我编写AuthorizationServerEndpointsConfigurer的配置的时候，发现即使我这里不配置authorizationCodeServices，也能实现授权码模式，嘿，这我就不乐意了，源码调试起来！
默认实现InMemoryAuthorizationCodeServices
有理有据！我加上端点，检测AuthorizationServerEndpointsConfigurer中的值变化！
Debug启动！！！
断点
程序走完configure方法后AuthorizationServerEndpointsConfigurer中的authorizationCodeServices还是null，于是我们继续跟进
当程序走完这行代码，检测到authorizationCodeServices还是null，那么我们直接查看endpoints属性！
endpoints属性
AuthorizationServerEndpointsConfigurer这个对象，我们看看！
这里authorizationCodeServices还是null，那么有这个属性，肯定就有赋值的地方，我们找一下！
核心代码就是这行，也就是说我们如果自己不配置AuthorizationCodeServices，那么默认实现就是InMemoryAuthorizationCodeServices，有理有据！
关于AuthorizationCodeServices的实现方式，上面有提到Redis，MySQL，那么我们乘着这个机会都学习下吧！
AuthorizationCodeServices配置MySQL存储
数据库表准备
CREATE TABLE `oauth_code` (
`create_time` timestamp(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
`code` varchar (255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
`authentication` blob NULL,
INDEX `code_index` (`code`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact ;
这是存储授权码的表！
导入数据源
导入MySQL数据源，如果项目中有用到MyBatis或者MP的话就不需要导入数据源，只需要导入数据库驱动即可！如果没有用到MyBatis或者MP那么就需要导入数据源！
<!--数据库驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--mybatis-plus或者mybatis都行-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.2.0</version>
</dependency>
<!--如果没有mybatis或者mp那么就需要手动导入数据源，DataSource无法注入-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
关于其他MySQL配置文件的我就不多说了，和平常一样！
配置JDBC存储
@Autowired
private AuthorizationCodeServices authorizationCodeServices;
@Bean
public AuthorizationCodeServices authorizationCodeServices(DataSource dataSource) {
return new JdbcAuthorizationCodeServices(dataSource);//设置授权码模式的授权码如何存取
}
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) {//配置令牌的访问端点和令牌服务
endpoints
.authorizationCodeServices(authorizationCodeServices)//配置授权码服务
.authenticationManager(authenticationManager)//认证管理器-提供给登录使用
.tokenServices(tokenService())
.allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST)
;
}
重启服务测试
AuthorizationCodeServices基于Redis
导入Redis依赖
这个不管是RedisTemplate还是jedis都行，因为反正实现都是自己写的，哈哈！
<!-- Redis 二者行-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.0.1</version>
</dependency>
根据不同的依赖实现即可！
基于RedisTemplate实现
/**
* @author TAO
* @description: redis 基本操作 可扩展,基本够用了
* @date 2021/4/17 19:26
*/
@Slf4j
@Service
public class RedisRepository {
/**
* Spring Redis Template
*/
private RedisTemplate<String, Object> redisTemplate;
public RedisRepository(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* 获取链接工厂
*/
public RedisConnectionFactory getConnectionFactory() {
return this.redisTemplate.getConnectionFactory();
}
/**
* 获取 RedisTemplate对象
*/
public RedisTemplate<String, Object> getRedisTemplate() {
return redisTemplate;
}
/**
* 清空DB
*
* @param node redis 节点
*/
public void flushDB(RedisClusterNode node) {
this.redisTemplate.opsForCluster().flushDb(node);
}
/**
* 添加到带有 过期时间的 缓存
*
* @param key redis主键
* @param value 值
* @param time 过期时间(单位秒)
*/
public void setExpire(final byte[] key, final byte[] value, final long time) {
redisTemplate.execute((RedisCallback<Long>) connection -> {
connection.setEx(key, time, value);
return 1L;
});
}
/**
* 添加到带有 过期时间的 缓存
*
* @param key redis主键
* @param value 值
* @param time 过期时间
* @param timeUnit 过期时间单位
*/
public void setExpire(final String key, final Object value, final long time, final TimeUnit timeUnit) {
redisTemplate.opsForValue().set(key, value, time, timeUnit);
}
public void setExpire(final String key, final Object value, final long time) {
this.setExpire(key, value, time, TimeUnit.SECONDS);
}
public void setExpire(final String key, final Object value, final long time, final TimeUnit timeUnit, RedisSerializer<Object> valueSerializer) {
byte[] rawKey = rawKey(key);
byte[] rawValue = rawValue(value, valueSerializer);
redisTemplate.execute(new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
potentiallyUsePsetEx(connection);
return null;
}
public void potentiallyUsePsetEx(RedisConnection connection) {
if (!TimeUnit.MILLISECONDS.equals(timeUnit) || !failsafeInvokePsetEx(connection)) {
connection.setEx(rawKey, TimeoutUtils.toSeconds(time, timeUnit), rawValue);
}
}
private boolean failsafeInvokePsetEx(RedisConnection connection) {
boolean failed = false;
try {
connection.pSetEx(rawKey, time, rawValue);
} catch (UnsupportedOperationException e) {
failed = true;
}
return !failed;
}
}, true);
}
/**
* 一次性添加数组到 过期时间的 缓存，不用多次连接，节省开销
*
* @param keys redis主键数组
* @param values 值数组
* @param time 过期时间(单位秒)
*/
public void setExpire(final String[] keys, final Object[] values, final long time) {
for (int i = 0; i < keys.length; i++) {
redisTemplate.opsForValue().set(keys[i], values[i], time, TimeUnit.SECONDS);
}
}
/**
* 一次性添加数组到 过期时间的 缓存，不用多次连接，节省开销
*
* @param keys the keys
* @param values the values
*/
public void set(final String[] keys, final Object[] values) {
for (int i = 0; i < keys.length; i++) {
redisTemplate.opsForValue().set(keys[i], values[i]);
}
}
/**
* 添加到缓存
*
* @param key the key
* @param value the value
*/
public void set(final String key, final Object value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 查询在以keyPatten的所有 key
*
* @param keyPatten the key patten
* @return the set
*/
public Set<String> keys(final String keyPatten) {
return redisTemplate.keys(keyPatten + "*");
}
/**
* 根据key获取对象
*
* @param key the key
* @return the byte [ ]
*/
public byte[] get(final byte[] key) {
return redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(key));
}
/**
* 根据key获取对象
*
* @param key the key
* @return the string
*/
public Object get(final String key) {
return redisTemplate.opsForValue().get(key);
}
/**
* 根据key获取对象
*
* @param key the key
* @param valueSerializer 序列化
* @return the string
*/
public Object get(final String key, RedisSerializer<Object> valueSerializer) {
byte[] rawKey = rawKey(key);
return redisTemplate.execute(connection -> deserializeValue(connection.get(rawKey), valueSerializer), true);
}
/**
* Ops for hash hash operations.
*
* @return the hash operations
*/
public HashOperations<String, String, Object> opsForHash() {
return redisTemplate.opsForHash();
}
/**
* 对HashMap操作
*
* @param key the key
* @param hashKey the hash key
* @param hashValue the hash value
*/
public void putHashValue(String key, String hashKey, Object hashValue) {
opsForHash().put(key, hashKey, hashValue);
}
/**
* 获取单个field对应的值
*
* @param key the key
* @param hashKey the hash key
* @return the hash values
*/
public Object getHashValues(String key, String hashKey) {
return opsForHash().get(key, hashKey);
}
/**
* 根据key值删除
*
* @param key the key
* @param hashKeys the hash keys
*/
public void delHashValues(String key, Object... hashKeys) {
opsForHash().delete(key, hashKeys);
}
/**
* key只匹配map
*
* @param key the key
* @return the hash value
*/
public Map<String, Object> getHashValue(String key) {
return opsForHash().entries(key);
}
/**
* 批量添加
*
* @param key the key
* @param map the map
*/
public void putHashValues(String key, Map<String, Object> map) {
opsForHash().putAll(key, map);
}
/**
* 集合数量
*
* @return the long
*/
public long dbSize() {
return redisTemplate.execute(RedisServerCommands::dbSize);
}
/**
* 清空redis存储的数据
*
* @return the string
*/
public String flushDB() {
return redisTemplate.execute((RedisCallback<String>) connection -> {
connection.flushDb();
return "ok";
});
}
/**
* 判断某个主键是否存在
*
* @param key the key
* @return the boolean
*/
public boolean exists(final String key) {
return redisTemplate.hasKey(key);
}
/**
* 删除key
*
* @param keys the keys
* @return the long
*/
public boolean del(final String... keys) {
boolean result = false;
for (String key : keys) {
result = redisTemplate.delete(key);
}
return result;
}
/**
* 对某个主键对应的值加一,value值必须是全数字的字符串
*
* @param key the key
* @return the long
*/
public long incr(final String key) {
return redisTemplate.opsForValue().increment(key);
}
/**
* redis List 引擎
*
* @return the list operations
*/
public ListOperations<String, Object> opsForList() {
return redisTemplate.opsForList();
}
/**
* redis List数据结构 : 将一个或多个值 value 插入到列表 key 的表头
*
* @param key the key
* @param value the value
* @return the long
*/
public Long leftPush(String key, Object value) {
return opsForList().leftPush(key, value);
}
/**
* redis List数据结构 : 移除并返回列表 key 的头元素
*
* @param key the key
* @return the string
*/
public Object leftPop(String key) {
return opsForList().leftPop(key);
}
/**
* redis List数据结构 :将一个或多个值 value 插入到列表 key 的表尾(最右边)。
*
* @param key the key
* @param value the value
* @return the long
*/
public Long in(String key, Object value) {
return opsForList().rightPush(key, value);
}
/**
* redis List数据结构 : 移除并返回列表 key 的末尾元素
*
* @param key the key
* @return the string
*/
public Object rightPop(String key) {
return opsForList().rightPop(key);
}
/**
* redis List数据结构 : 返回列表 key 的长度 ; 如果 key 不存在，则 key 被解释为一个空列表，返回 0 ; 如果 key 不是列表类型，返回一个错误。
*
* @param key the key
* @return the long
*/
public Long length(String key) {
return opsForList().size(key);
}
/**
* redis List数据结构 : 根据参数 i 的值，移除列表中与参数 value 相等的元素
*
* @param key the key
* @param i the
* @param value the value
*/
public void remove(String key, long i, Object value) {
opsForList().remove(key, i, value);
}
/**
* redis List数据结构 : 将列表 key 下标为 index 的元素的值设置为 value
*
* @param key the key
* @param index the index
* @param value the value
*/
public void set(String key, long index, Object value) {
opsForList().set(key, index, value);
}
/**
* redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
*
* @param key the key
* @param start the start
* @param end the end
* @return the list
*/
public List<Object> getList(String key, int start, int end) {
return opsForList().range(key, start, end);
}
/**
* redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
*
* @param key the key
* @param start the start
* @param end the end
* @param valueSerializer 序列化
* @return the list
*/
public List<Object> getList(String key, int start, int end, RedisSerializer<Object> valueSerializer) {
byte[] rawKey = rawKey(key);
return redisTemplate.execute(connection -> deserializeValues(connection.lRange(rawKey, start, end), valueSerializer), true);
}
/**
* redis List数据结构 : 批量存储
*
* @param key the key
* @param list the list
* @return the long
*/
public Long leftPushAll(String key, List<String> list) {
return opsForList().leftPushAll(key, list);
}
/**
* redis List数据结构 : 将值 value 插入到列表 key 当中，位于值 index 之前或之后,默认之后。
*
* @param key the key
* @param index the index
* @param value the value
*/
public void insert(String key, long index, Object value) {
opsForList().set(key, index, value);
}
private byte[] rawKey(Object key) {
Assert.notNull(key, "non null key required");
if (key instanceof byte[]) {
return (byte[]) key;
}
RedisSerializer<Object> redisSerializer = (RedisSerializer<Object>) redisTemplate.getKeySerializer();
return redisSerializer.serialize(key);
}
private byte[] rawValue(Object value, RedisSerializer valueSerializer) {
if (value instanceof byte[]) {
return (byte[]) value;
}
return valueSerializer.serialize(value);
}
private List deserializeValues(List<byte[]> rawValues, RedisSerializer<Object> valueSerializer) {
if (valueSerializer == null) {
return rawValues;
}
return SerializationUtils.deserialize(rawValues, valueSerializer);
}
private Object deserializeValue(byte[] value, RedisSerializer<Object> valueSerializer) {
if (valueSerializer == null) {
return value;
}
return valueSerializer.deserialize(value);
}
}
redis配置这里就不逼逼了，自己看着办吧！
配置Redis存储
继承RandomValueAuthorizationCodeServices
@Service
public class RedisAuthorizationCodeServices extends RandomValueAuthorizationCodeServices {
String AUTH_CODE_PREFIX = "yiyi:code:auth:";
private final RedisRepository redisRepository;
private final RedisSerializer<Object> valueSerializer;
public RedisAuthorizationCodeServices(RedisRepository redisRepository) {
this.redisRepository = redisRepository;
this.valueSerializer = RedisSerializer.java();
}
/**
* 将存储code到redis，并设置过期时间，10分钟
*/
@Override
protected void store(String code, OAuth2Authentication authentication) {
redisRepository.setExpire(redisKey(code), authentication, 10, TimeUnit.MINUTES, valueSerializer);
}
@Override
protected OAuth2Authentication remove(final String code) {
String codeKey = redisKey(code);
OAuth2Authentication token = (OAuth2Authentication) redisRepository.get(codeKey, valueSerializer);
redisRepository.del(codeKey);
return token;
}
/**
* redis中 code key的前缀
*/
private String redisKey(String code) {
return AUTH_CODE_PREFIX + code;
}
}
从新注入AuthorizationCodeServices为RandomValueAuthorizationCodeServices
@Autowired
private RandomValueAuthorizationCodeServices authorizationCodeServices;
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints) {//配置令牌的访问端点和令牌服务
endpoints
.authorizationCodeServices(authorizationCodeServices)
.authenticationManager(authenticationManager)//认证管理器
.tokenServices(tokenService())
.allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST)
;
}
重启服务测试
搞定
版权声明：本文为CSDN877425287原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。