devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringSecurity+SpringSecurityOauth2集成实现权限框架，Redis分发Token_org.springframework.security.oauth2.provider.token

作者：小小林熬夜学编程 | 2024-02-15 10:00:43

赞

踩

org.springframework.security.oauth2.provider.token.store.redis.redistokensto

       写在前面：当我们开始使用Security的时候，常常因为各种注入，而迷糊，但是很害怕使用security，感觉很重很难用！再加入oauth2更难搞，今天我就写点自己的配置理解，希望对大家有帮助！(会提供一个可以使用的源码，放在最后，如果你不想看内容，可以直接下载！)

一： spring security 的核心功能主要包括：

  • 认证 （你是谁）
  • 授权 （你能干什么）
  • 攻击防护 （防止伪造身份）

        oauth2根据使用场景不同，分成了4种模式，感兴趣的可以去了解，我们主要用密码模式，说白了就是账号密码登录模式

我们主要用认证 ——授权 ——发放Token

二：直接开始

1.核心依赖（主要就是这两个，其他的随便导下就行了，reids,mysql的自己弄下）

  1. 		<!--security依赖-->
  2. 		<dependency>
  3. 			<groupId>org.springframework.boot</groupId>
  4. 			<artifactId>spring-boot-starter-security</artifactId>
  5. 		</dependency>
  6. 		<!--oauth2依赖-->
  7. 		<dependency>
  8. 			<groupId>org.springframework.security.oauth</groupId>
  9. 			<artifactId>spring-security-oauth2</artifactId>
  10. 			<version>2.3.3.RELEASE</version>
  11. 		</dependency>

2.Yml配置文件（为了节省空间，其他配置不放了，redis，mysql的大家自己根据自己情况使用）

  1. # oauth2.0配置
  2. client:
  3.   oauth2:
  4.     client-id: appId # 客户端标识Id
  5.     secret: 123456 # 客户端安全码
  6.     # 授权类型
  7.     grant_types:
  8.       - password
  9.       - refresh_token
  10.     # token 有效期
  11.     token-validity-time: 3600
  12.     refresh-token-validity-time: 3600
  13.     # 客户端访问范围
  14.     scopes:
  15.       - api
  16.       - all

3.下面就开始核心代码编写了

第一就是security的配置类，该类相当核心，主要注入几个核心功能，先贴代码

  1. package io.springboot.netty.oauth2server;
  2.  
  3. import org.apache.commons.codec.digest.DigestUtils;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.data.redis.connection.RedisConnectionFactory;
  7. import org.springframework.security.authentication.AuthenticationManager;
  8. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  9. import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  10. import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
  11. import org.springframework.security.crypto.password.PasswordEncoder;
  12. import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;
  13.  
  14. import javax.annotation.Resource;
  15.  
  16. /**
  17.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Security 配置类
  18.  *
  19.  * @author zheng
  20.  */
  21. @Configuration
  22. @EnableWebSecurity
  23. public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
  24.  
  25.     /**
  26.      * 注入redis 连接工厂
  27.      */
  28.     @Resource
  29.     private RedisConnectionFactory redisConnectionFactory;
  30.  
  31.     /**
  32.      * 初始化 redisTokenStore 用户将token 放入redis
  33.      * @return
  34.      */
  35.     @Bean
  36.     public RedisTokenStore redisTokenStore(){
  37.         RedisTokenStore redisTokenStore = new RedisTokenStore(redisConnectionFactory);
  38.         redisTokenStore.setPrefix("TOKEN:");
  39.         return redisTokenStore;
  40.     }
  41.  
  42.     /**
  43.      * 初始化密码编码器 MD5加密
  44.      * @return
  45.      */
  46.     @Bean
  47.     public PasswordEncoder passwordEncoder(){
  48.         return new PasswordEncoder() {
  49.  
  50.             /**
  51.              * 加密
  52.              * @param rawPassword 原始密码
  53.              * @return
  54.              */
  55.             @Override
  56.             public String encode(CharSequence rawPassword) {
  57.                 return DigestUtils.md5Hex(rawPassword.toString());
  58.             }
  59.  
  60.             /**
  61.              * 校验密码
  62.              * @param rawPassword 原始密码
  63.              * @param encoderPassword 加密后密码
  64.              * @return
  65.              */
  66.             @Override
  67.             public boolean matches(CharSequence rawPassword, String encoderPassword) {
  68.                 return DigestUtils.md5Hex(rawPassword.toString()).equals(encoderPassword);
  69.             }
  70.         };
  71.     }
  72.  
  73.     /**
  74.      * 初始化管理对象
  75.      */
  76.     @Override
  77.     @Bean
  78.     public AuthenticationManager authenticationManager() throws Exception {
  79.         return super.authenticationManager();
  80.     }
  81.  
  82.     /**
  83.      * 放行 和 认证规则
  84.      * @param http
  85.      * @throws Exception
  86.      */
  87.     @Override
  88.     protected void configure(HttpSecurity http) throws Exception {
  89.         http.csrf().disable()
  90.                 .authorizeRequests()
  91.                 // 放行
  92.                 .antMatchers("/oauth/**", "/actuator/**")
  93.                 .permitAll()
  94.                 .and()
  95.                 .authorizeRequests()
  96.                 .anyRequest()
  97.                 // 其他需要拦截
  98.                 .authenticated();
  99.  
  100.     }
  101. }

        1.RedisConnectionFactory 注入redis的连接工厂，

        2.初始化 redisTokenStore 用户将token 放入redis，也可以放入内存当中，建议放入redis中。

        3.初始化密码编码器，使用MD5，亦可以换成security的加密方式。重写加密方法-encode,修改加密方式，重写校验方法-matches.

        4.初始化 AuthenticationManager认证管理对象

        5.重写config方法，配置放行和认证 、/oauth 等会我们重写它，做为登录方法使用

        "/oauth/**", "/actuator/**"

这个方法还是比较简单的，主要为了注入bean和配置一个拦截方法

授权配置类
  1.  
  2.  
  3. import io.springboot.netty.entity.LoginUser;
  4. import io.springboot.netty.service.impl.UserServiceImpl;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.security.authentication.AuthenticationManager;
  8. import org.springframework.security.crypto.password.PasswordEncoder;
  9. import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
  10. import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
  11. import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
  12. import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
  13. import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
  14. import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
  15. import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;
  16.  
  17. import javax.annotation.Resource;
  18. import java.util.LinkedHashMap;
  19.  
  20. /**
  21.  * 授权配置类
  22.  * @author zheng
  23.  */
  24. @Configuration
  25. @EnableAuthorizationServer
  26. public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {
  27.  
  28.     @Autowired
  29.     private UserServiceImpl userService;
  30.  
  31.     @Resource
  32.     private RedisTokenStore redisTokenStore;
  33.  
  34.  
  35.  
  36.     /**
  37.      * 管理器
  38.      */
  39.     @Resource
  40.     private AuthenticationManager authenticationManager;
  41.  
  42.     /**
  43.      * 密码编码器
  44.      */
  45.     @Resource
  46.     private PasswordEncoder passwordEncoder;
  47.  
  48.     /**
  49.      * 客户端配置类
  50.      */
  51.     @Resource
  52.     private ClientOauth2DataConfiguration oauth2DataConfiguration;
  53.  
  54.     /**
  55.      * 客户端配置授权模型
  56.      * @param clients
  57.      * @throws Exception
  58.      */
  59.     @Override
  60.     public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
  61.         clients.inMemory().withClient(oauth2DataConfiguration.getClientId())
  62.                 .secret(passwordEncoder.encode(oauth2DataConfiguration.getSecret()))
  63.                 .authorizedGrantTypes(oauth2DataConfiguration.getGrantTypes()) // token 授权类型
  64.                 .accessTokenValiditySeconds(oauth2DataConfiguration.getTokenValidityTime()) // token 过期时间
  65.                 .refreshTokenValiditySeconds(oauth2DataConfiguration.getRefreshTokenValidityTime()) // token 刷新过期时间
  66.                 .scopes(oauth2DataConfiguration.getScopes());
  67.     }
  68.  
  69.     /**
  70.      * 配置令牌端点的安全约束
  71.      * @param security
  72.      * @throws Exception
  73.      */
  74.     @Override
  75.     public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
  76.         // 允许访问 token 的公钥，默认 /oauth/token_key 受保护的
  77.         security.tokenKeyAccess("permitAll()")
  78.                 // 允许访问 token 的状态，默认 /oauth/check_token 受保护的
  79.                 .checkTokenAccess("permitAll()");
  80.     }
  81.  
  82.     @Override
  83.     public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
  84.             // 认证器
  85.         endpoints.authenticationManager(authenticationManager)
  86.                 // 具体登陆方法
  87.                 .userDetailsService(userService)
  88.                 // token 存储方式 redis
  89.                 .tokenStore(redisTokenStore)
  90.                 // 令牌增强对象 ， 增强返回的结果
  91.                 .tokenEnhancer((accessToken, authentication) ->{
  92.                     // 获取用户信息，然后设置
  93.                     LoginUser loginUser = (LoginUser) authentication.getPrincipal();
  94.                     LinkedHashMap<String, Object> map = new LinkedHashMap<>();
  95.                     map.put("userId",loginUser.getUserId());
  96.                     map.put("usernmae",loginUser.getUsername());
  97.                     map.put("logo", loginUser.getLogo());
  98.                     DefaultOAuth2AccessToken token = (DefaultOAuth2AccessToken) accessToken;
  99.                     token.setAdditionalInformation(map);
  100.                     return token;
  101.                 });
  102.  
  103.     }
  104. }

这个方法中，我们可以看到上一个方法注入的几个bean,并且重写三个配置类1.config,configure(ClientDetailsServiceConfigurer clients)，客户端配置授权模型，就是我们所说oauth2的四个模式，我们就用一个密码模式。

2.configure(AuthorizationServerSecurityConfigurer security)，配置令牌端点的安全约束，上面我们也提到了重写/oauth/**接口来实现登录，在这里要先给它放行，否则我们都请求不到！

3.configure(AuthorizationServerEndpointsConfigurer endpoints)，这里就是配置认证器了，我们先将管理器注入（authenticationManager），然后实现具体登录方法，主要就是为了登录校验密码，然后设置token的存放方式，最后对令牌做一个增强，就是要返回那些信息。

UserServiceImpl和ClientOauth2DataConfiguration,我们不知道是干嘛的，其实userServiceImpl不说都很清楚，就是为了校验登录用的，后面这个是为了加载client.ouath2的yml数据的，数据在上面的YML文件中
  1.  
  2.  
  3. import lombok.Data;
  4. import org.springframework.boot.context.properties.ConfigurationProperties;
  5. import org.springframework.stereotype.Component;
  6.  
  7. /**
  8.  * 客户端数据配置类
  9.  * @author zheng
  10.  */
  11. @Component
  12. @ConfigurationProperties(prefix = "client.oauth2")
  13. @Data
  14. public class ClientOauth2DataConfiguration {
  15.  
  16.  
  17.     private String clientId;
  18.  
  19.     private String secret;
  20.  
  21.     private String[] grantTypes;
  22.  
  23.     private int tokenValidityTime;
  24.  
  25.     private int refreshTokenValidityTime;
  26.  
  27.     private String[] scopes;
  28. }

UserServiceImpl 实现UserDetailes.类，重写了loadUserName方法

  1.  
  2.  
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  5. import org.springframework.beans.BeanUtils;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.security.core.userdetails.UserDetails;
  8. import org.springframework.security.core.userdetails.UserDetailsService;
  9. import org.springframework.security.core.userdetails.UsernameNotFoundException;
  10. import security.oauth2.entity.LoginUser;
  11. import security.oauth2.entity.ManorUser;
  12. import security.oauth2.mapper.ManorUserMapper;
  13.  
  14. public class UserServiceImpl extends ServiceImpl<ManorUserMapper, ManorUser> implements UserService, UserDetailsService {
  15.  
  16.     @Autowired
  17.     private ManorUserMapper userMapper;
  18.  
  19.     /**
  20.      * Security 用户登陆实现方法
  21.      * @param username
  22.      * @return
  23.      * @throws UsernameNotFoundException
  24.      */
  25.     @Override
  26.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
  27.         ManorUser user = userMapper.selectOne(new LambdaQueryWrapper<ManorUser>().eq(ManorUser::getUserId, username));
  28.         LoginUser loginUser = new LoginUser();
  29.         // 复制用户信息
  30.         BeanUtils.copyProperties(user,loginUser);
  31. //        return new User(username,user.getPassword(), AuthorityUtils.commaSeparatedStringToAuthorityList(null));
  32.         return loginUser;
  33.     }
  34. }
ManorUser是数据库表中用户表的实体类，LoginUser需要实现UserDetails中的几个方法

  1.  
  2.  
  3. import org.springframework.security.core.userdetails.UserDetails;
  4.  
  5. import com.baomidou.mybatisplus.annotation.TableId;
  6. import com.google.common.collect.Lists;
  7. import lombok.Getter;
  8. import lombok.Setter;
  9. import org.apache.commons.lang3.StringUtils;
  10. import org.springframework.security.core.GrantedAuthority;
  11. import org.springframework.security.core.authority.AuthorityUtils;
  12. import org.springframework.security.core.authority.SimpleGrantedAuthority;
  13.  
  14. import java.util.Collection;
  15. import java.util.Date;
  16. import java.util.List;
  17. import java.util.stream.Collectors;
  18. import java.util.stream.Stream;
  19.  
  20. /**
  21.  * @author zheng
  22.  */
  23. @Getter
  24. @Setter
  25. public class LoginUser implements UserDetails {
  26.  
  27.     /**
  28.      *
  29.      */
  30.     @TableId
  31.     private Integer id;
  32.     /**
  33.      * 是否需要引导（默认为0，需要 1：不需要）
  34.      */
  35.     private Integer guideType;
  36.     /**
  37.      * 等级
  38.      */
  39.     private Integer level;
  40.     /**
  41.      * 用户经验值
  42.      */
  43.     private Integer experience;
  44.  
  45.     /**
  46.      * 种植水果类型 （默认0：未种  1.桃树，2.梨树，3.西瓜，4.草莓，5.葡萄）
  47.      */
  48.     private Integer fruitsType;
  49.  
  50.     /**
  51.      * 果树等级
  52.      */
  53.     private Integer fruitsLevel;
  54.     /**
  55.      * 果树经验值
  56.      */
  57.     private Integer fruitsExp;
  58.     /**
  59.      * 用户id
  60.      */
  61.     private Integer userId;
  62.  
  63.     /**
  64.      * 弹幕开启：0 关闭 1：开启
  65.      */
  66.     private Integer setBulletArr;
  67.  
  68.     private Date createTime;
  69.  
  70.     private Integer state;
  71.  
  72.     /**
  73.      * 肥料
  74.      */
  75.     private Integer manureNum;
  76.  
  77.     /**
  78.      * 水
  79.      */
  80.     private Integer waterNum;
  81.  
  82.     /**
  83.      * 加速卡
  84.      */
  85.     private Integer cardNum;
  86.  
  87.     /**
  88.      * 当月前用户签到总数
  89.      */
  90.     private Integer addSign;
  91.  
  92.     private String logo;
  93.  
  94.     private String username;
  95.  
  96.     private String password;
  97.  
  98.     private String roles;
  99.  
  100.     private List<GrantedAuthority> authorities;
  101.  
  102.     //** 获取角色信息
  103.     @Override
  104.     public Collection<? extends GrantedAuthority> getAuthorities() {
  105.         if (StringUtils.isNotBlank(this.roles)){
  106.             //获取数据库中角色
  107.             Lists.newArrayList();
  108.             this.authorities = Stream.of(this.roles.split(",")).map(role ->{
  109.                 return new SimpleGrantedAuthority(role);
  110.             }).collect(Collectors.toList());
  111.         }else{
  112.             // 如果角色为空
  113.             this.authorities = AuthorityUtils
  114.                     .commaSeparatedStringToAuthorityList("ROLE_USER");
  115.         }
  116.         return this.authorities;
  117.     }
  118.  
  119.     @Override
  120.     public String getPassword() {
  121.         return this.password;
  122.     }
  123.  
  124.     @Override
  125.     public String getUsername() {
  126.         return this.username;
  127.     }
  128.  
  129.     @Override
  130.     public boolean isAccountNonExpired() {
  131.         return true;
  132.     }
  133.  
  134.     @Override
  135.     public boolean isAccountNonLocked() {
  136.         return true;
  137.     }
  138.  
  139.     @Override
  140.     public boolean isCredentialsNonExpired() {
  141.         return true;
  142.     }
  143.  
  144.     @Override
  145.     public boolean isEnabled() {
  146.         return this.state == 0 ? false : true;
  147.     }
  148. }
  149.

配置完成上面这些东西，我们就可以获取了TOKEN了，我们来重写一个登录方法，写一个验证接口

  1. package security.oauth2.controller;
  2.  
  3.  
  4. import lombok.SneakyThrows;
  5. import org.springframework.security.oauth2.common.DefaultOAuth2AccessToken;
  6. import org.springframework.security.oauth2.common.OAuth2AccessToken;
  7. import org.springframework.security.oauth2.provider.endpoint.TokenEndpoint;
  8. import org.springframework.web.HttpRequestMethodNotSupportedException;
  9. import org.springframework.web.bind.annotation.PostMapping;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RequestParam;
  12. import org.springframework.web.bind.annotation.RestController;
  13.  
  14. import javax.annotation.Resource;
  15. import java.security.Principal;
  16. import java.util.LinkedHashMap;
  17. import java.util.Map;
  18.  
  19. /**
  20.  * @author zheng
  21.  */
  22. @RestController
  23. @RequestMapping("oauth")
  24. public class OauthController {
  25.  
  26.     /**
  27.      * 返回增强
  28.      */
  29.     @Resource
  30.     private TokenEndpoint tokenEndpoint;
  31.  
  32.  
  33.     @PostMapping("token")
  34.     public Map<String, Object> postAccessToken(Principal principal, @RequestParam Map<String,String> param) throws HttpRequestMethodNotSupportedException {
  35.         Map<String, Object> map = custom(tokenEndpoint.postAccessToken(principal, param).getBody());
  36.         return map;
  37.     }
  38.  
  39.     private Map<String,Object> custom(OAuth2AccessToken oAuth2AccessToken){
  40.         DefaultOAuth2AccessToken token = (DefaultOAuth2AccessToken) oAuth2AccessToken;
  41.  
  42.         Map<String,Object> data =  new LinkedHashMap(token.getAdditionalInformation());
  43.         data.put("accessToken",token.getValue());
  44.         data.put("expireIn", token.getExpiresIn());
  45.         data.put("scopes", token.getScope());
  46.         if (token.getRefreshToken() != null){
  47.             data.put("refreshToken",token.getRefreshToken().getValue());
  48.         }
  49.         return data;
  50.     }
  51.  
  52. }

感兴趣的朋友可以去查查看令牌增强的用处，其实就是返回Token的使用，可以带点你自定义的信息给页面仔用。

我们来使用来测试下，我用的APIpost,你也可以用其他的测试工具

 图上可以看下参数，账号密码，没什么说的，grant_type = password,就是我上面提到的密码模式，scope，指的是接口可访问的范围，这两个参数在YML文件中，都配置了，在请求的时需要传递，在Body旁边，有个认证，postman中为英文认证单词，点击进入

 这两个参数需要从yml读取，也就是client-id和secret的值，我这里选择配置文件加载，主要就是为了验证前后端是否有资格使用登录接口，如果配置的值不一致，也是请求不了接口的。还有一种方式是从数据库中加载，security也提供了相应的方式，更加灵活点。

  1. {
  2. 	"userId": 10148629,
  3. 	"usernmae": "抽奖专用小马甲",
  4. 	"logo": "http://logo.sqsjt.net/upfiles/user/face/90/9005c1be3839c52c52c97e7589e46d5c.jpg?5F1FF05C",
  5. 	"accessToken": "5bb9602b-89bb-42d6-a4b6-3d35db9bea2a",
  6. 	"expireIn": 2489,
  7. 	"scopes": [
  8. 		"api"
  9. 	],
  10. 	"refreshToken": "0979b94e-3f85-4e5b-afa2-719f0ae17bb2"
  11. }

请求成功后，就是返回了这些，从参数可以看到我们实现的令牌增强功能，返回了自定义的三个参数，userId，username,logo,可以配置更多参数，剩下的token参数则是在 OauthController.custom中配置了。

请求成功后，我们可以在redis中看到Token的相关信息，如下图

        可是我们用token去请求接口的时候，还是会提示403，找不到相关资源，这个是因为我们还没有配置资源配置类

  1. package security.oauth2.oauth2Server;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  5. import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
  6. import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
  7. import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
  8. import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;
  9.  
  10. import javax.annotation.Resource;
  11.  
  12. /**
  13.  * @author zheng
  14.  */
  15. @Configuration
  16. @EnableResourceServer
  17. public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
  18.  
  19.     @Resource
  20.     private MyAuthenticationEntryPoint myAuthenticationEntryPoint;
  21.  
  22.     @Resource
  23.     private RedisTokenStore redisTokenStore;
  24.  
  25.     @Override
  26.     public void configure(HttpSecurity http) throws Exception {
  27.         http.authorizeRequests().anyRequest()
  28.                 .authenticated()
  29.                 .and()
  30.                 .requestMatchers().antMatchers("/user/**");
  31.     }
  32.  
  33.     @Override
  34.     public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
  35.         // 设置token存储
  36.         resources.tokenStore(redisTokenStore);
  37.         // 设置验证失败
  38.         resources.authenticationEntryPoint(myAuthenticationEntryPoint);
  39.     }
  40. }

重写config方法，验证/user/**开头的请求接口，这里可以根据具体业务配置，我们写一个UserController，来查询下用户的基本信息。

  1. package security.oauth2.controller;
  2.  
  3. import org.springframework.security.core.Authentication;
  4. import org.springframework.web.bind.annotation.GetMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6.  
  7.  
  8. /**
  9.  * 用户中心
  10.  * @author zheng
  11.  */
  12. @RestController
  13. public class UserController {
  14.  
  15.     @GetMapping("user/me")
  16.     public Object postAccessToken(Authentication authentication){
  17.         Object principal = authentication.getPrincipal();
  18.         return principal;
  19.     }
  20. }

直接请求接口，使用/oauth/token返回的access_token,可以看出来，返回了用户基本信息

用户表结构

  1. /*
  2.  Navicat Premium Data Transfer
  3.  
  4.  Source Server         : localhost
  5.  Source Server Type    : MySQL
  6.  Source Server Version : 50725
  7.  Source Host           : localhost:3306
  8.  Source Schema         : yami_shops
  9.  
  10.  Target Server Type    : MySQL
  11.  Target Server Version : 50725
  12.  File Encoding         : 65001
  13.  
  14.  Date: 24/08/2021 00:33:39
  15. */
  16.  
  17. SET NAMES utf8mb4;
  18. SET FOREIGN_KEY_CHECKS = 0;
  19.  
  20. -- ----------------------------
  21. -- Table structure for manor_user
  22. -- ----------------------------
  23. DROP TABLE IF EXISTS `manor_user`;
  24. CREATE TABLE `manor_user`  (
  25.   `id` int(11) NOT NULL AUTO_INCREMENT,
  26.   `guide_type` tinyint(1) DEFAULT 0 COMMENT '是否需要引导（默认为0，需要 1：不需要）',
  27.   `level` int(255) DEFAULT 1 COMMENT '用户等级',
  28.   `experience` int(255) DEFAULT 0 COMMENT '用户经验值',
  29.   `fruits_type` tinyint(1) DEFAULT 0 COMMENT '种植水果类型 （默认0：未种  1.桃树，2.梨树，3.西瓜，4.草莓，5.葡萄）',
  30.   `fruits_exp` int(255) DEFAULT 0 COMMENT '果树经验值',
  31.   `user_id` int(20) NOT NULL COMMENT '用户id',
  32.   `fruits_level` tinyint(2) DEFAULT 0 COMMENT '果树等级',
  33.   `set_bullet_arr` tinyint(1) DEFAULT 1 COMMENT '弹幕开启：0 关闭 1：开启',
  34.   `create_time` datetime(0) DEFAULT NULL COMMENT '创建时间',
  35.   `state` tinyint(1) DEFAULT 1 COMMENT '状态：1 启用 0 禁用',
  36.   `manure_num` int(11) DEFAULT 0 COMMENT '肥料',
  37.   `water_num` int(11) DEFAULT 0 COMMENT '水',
  38.   `card_num` int(11) DEFAULT NULL COMMENT '加速卡',
  39.   `add_sign` int(255) DEFAULT 0 COMMENT '本月前用户签到总数',
  40.   `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '用户名',
  41.   `logo` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '头像',
  42.   `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '密码',
  43.   PRIMARY KEY (`id`) USING BTREE,
  44.   UNIQUE INDEX `user_id`(`id`, `user_id`) USING BTREE
  45. ) ENGINE = InnoDB AUTO_INCREMENT = 20210513 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '广电庄园 —— 用户信息表' ROW_FORMAT = Dynamic;
  46.  
  47. -- ----------------------------
  48. -- Records of manor_user
  49. -- ----------------------------
  50. INSERT INTO `manor_user` VALUES (20210511, 1, 30, 1268710, 1, 71120, 10148629, 7, 0, '2021-06-02 11:39:33', 1, 245, 910, 2, 7, '抽奖专用小马甲', 'xxxxxxxxxxxxxxx', 'e10adc3949ba59abbe56e057f20f883e');
  51.  
  52. SET FOREIGN_KEY_CHECKS = 1;

 三：结束

        到这里，我们可以看出来，集成已经完成，其实也没有几个类，就搞定了token的分发，大家可以直接用项目源码去自己调试一下，每隔模块都写得很清晰。

        demo，我已经测试成功！！！，所以出现问题，一定是你没有配置好，请不要说项目不能使用的话。虚心接受指导，但不接受瞎xxxxx

         码云地址：https://gitee.com/jijiuc/oauth2_securtiy.git

               土豪地址：https://download.csdn.net/download/weixin_38061191/21472467

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/83451
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号