SpringOauth2简单登陆

傷城~ 2023-05-31 12:11 80阅读 0赞

SpringOauth2实现Jdbc简单认证登陆

创建一个SpringBoot工程
依赖如下:

  1. <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>1.5.10.RELEASE</version>
  5.         <relativePath /> <!-- lookup parent from repository -->
  6.     </parent>
  8.     <properties>
  9.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  10.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  11.         <java.version>1.8</java.version>
  12.     </properties>
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.springframework.boot</groupId>
  17.             <artifactId>spring-boot-starter-security</artifactId>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>org.springframework.boot</groupId>
  21.             <artifactId>spring-boot-starter-web</artifactId>
  22.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.security.oauth</groupId>
  27.             <artifactId>spring-security-oauth2</artifactId>
  28.         </dependency>
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  33.         </dependency>
  35.         <dependency>
  36.             <groupId>mysql</groupId>
  37.             <artifactId>mysql-connector-java</artifactId>
  38.             <version>8.0.16</version>
  39.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-test</artifactId>
  44.             <scope>test</scope>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.security</groupId>
  48.             <artifactId>spring-security-test</artifactId>
  49.             <scope>test</scope>
  50.         </dependency>
  51.     </dependencies>

这里主要依赖的是Spring Security 、Spring Security Oauth2 依赖，创建好项目后我们创建一个User类并且实现UserDetail接口如下：

  1. public class UserInfo implements UserDetails{ 
  3.     private String name;
  5.     private String email;
  7.     private String password;
  9.     public void setPassword(String password) { 
  10.         this.password = password;
  11.     }
  13.     public String getName() { 
  14.         return name;
  15.     }
  17.     public void setName(String name) { 
  18.         this.name = name;
  19.     }
  21.     public String getEmail() { 
  22.         return email;
  23.     }
  25.     public void setEmail(String email) { 
  26.         this.email = email;
  27.     }
  29.     @Transient
  30.     private List<GrantedAuthority> authorityList;
  32.     public List<GrantedAuthority> getAuthorityList() { 
  33.         return authorityList;
  34.     }
  36.     public void setAuthorityList(List<GrantedAuthority> authorityList) { 
  37.         this.authorityList = authorityList;
  38.     }
  40.     @Override
  41.     public Collection<? extends GrantedAuthority> getAuthorities() { 
  42.         return authorityList;
  43.     }
  45.     @Override
  46.     public String getPassword() { 
  47.         return password;
  48.     }
  50.     @Override
  51.     public String getUsername() { 
  52.         return name;
  53.     }
  55.     @Override
  56.     public boolean isAccountNonExpired() { 
  57.         return true;
  58.     }
  60.     @Override
  61.     public boolean isAccountNonLocked() { 
  62.         return true;
  63.     }
  65.     @Override
  66.     public boolean isCredentialsNonExpired() { 
  67.         return true;
  68.     }
  70.     @Override
  71.     public boolean isEnabled() { 
  72.         return true;
  73.     }
  75.     @Override
  76.     public String toString() { 
  77.         return "UserInfo{" +
  78.                 "name='" + name + '\'' +
  79.                 ", email='" + email + '\'' +
  80.                 ", password='" + password + '\'' +
  81.                 ", authorityList=" + authorityList +
  82.                 '}';
  83.     }
  84. }

这里UserDetail接口我就不多解释了，这几个方法大家都应该很清楚，然后我们创建一个CustomerUserService去实现UserDetailsService接口的loadUserByUsername方法：

  1. @Service
  2. public class CustomerUserService implements UserDetailsService { 
  3.     private Logger log = LoggerFactory.getLogger(this.getClass());
  5.     @Override
  6.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { 
  7.         UserInfo user = new UserInfo();
  8.         user.setName(username);
  9.         user.setPassword("123456");
  11.         log.info("username ->" + username);
  13.         if (user.getName().equals("zhoubiao")) { 
  14.             List<GrantedAuthority> auths = new ArrayList<>();
  15.             auths.add(new SimpleGrantedAuthority("ROLE_USER"));
  16.             user.setAuthorityList(auths);
  17.             log.info("user ->" + user);
  18.             return user;
  19.         }
  21.         return null;
  22.     }
  23. }

这里的代码很简单。这里的角色权限都是写死的。不管是用mybatis的mapper还是spring data jpa 都可以通过注入到这里来进行查询操作。这里为了简化操作。我就写死了。

然后我们创建我们的授权服务器：

  1. @Configuration
  2. @EnableAuthorizationServer
  3. public class OAuth2AuthorizationServer extends
  4.         AuthorizationServerConfigurerAdapter { 
  6.     @Resource
  7.     private DataSource dataSource;
  9.     @Bean
  10.     public ClientDetailsService clientDetailsService() { 
  11.         return new JdbcClientDetailsService(dataSource);
  12.     }
  14.     @Override
  15.     public void configure(ClientDetailsServiceConfigurer clients)
  16.             throws Exception { 
  17.         clients.jdbc(dataSource);
  18.     }

注意这里的DataSource是依赖Spring Data Jpa 中为我们封装的Spring Jdbc的相关配置依赖。

下面就是我们的资源服务器配置了如下：

  1. @Configuration
  2. @EnableResourceServer
  3. public class OAuth2ResourceServer extends ResourceServerConfigurerAdapter { 
  5.     @Override
  6.     public void configure(HttpSecurity http) throws Exception { 
  7.         http.authorizeRequests()
  8.             .anyRequest()
  9.             .authenticated()
  10.         .and()
  11.             .requestMatchers()
  12.             .antMatchers("/api/**");
  13.     }
  15. }

这里注意资源服务器应该是和授权服务器分开的，这里为了演示方便，我把他们放在一起了。这里对/api/下的所有请求进行拦截认证。

我们在pom.xml中引入了Security 的依赖，那么我们是需要使用到它的，那么我们创建一个WebSecurityConfig并且继承自WebSecurityConfigurerAdapter这个适配器类

  1. @EnableWebSecurity
  2. @Configuration
  3. public class WebSecurityConfig extends WebSecurityConfigurerAdapter { 
  4.     @Autowired
  5.     private CustomerUserService customerUserService;
  6.     @Autowired
  7.     public void configureAuthentication(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception { 
  8.         authenticationManagerBuilder
  10.        .userDetailsService(this.customerUserService);
  11.     }
  12. }

这里使用了AuthenticationManagerBuilder来管理认证信息，最后我们创建一个UserController 来进行测试：

  1. @Controller
  2. public class UserController { 
  4.     @RequestMapping("/api/userinfo")
  5.     public ResponseEntity<UserInfo> getUserInfo() { 
  6.         UserInfo user = (UserInfo) SecurityContextHolder.getContext()
  7.                 .getAuthentication().getPrincipal();
  8.         String email = user.getUsername();
  9.         user.setName(user.getUsername());
  10.         user.setEmail(email);
  12.         return ResponseEntity.ok(user);
  13.     }
  14. }

下面是application.properties配置：

  1. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  2. spring.datasource.url=jdbc:mysql://localhost:3306/_oauth2
  3. spring.datasource.username=root
  4. spring.datasource.password=root
  6. #jpa
  7. spring.jpa.hibernate.ddl-auto=update
  8. spring.jpa.show-sql=true

下面是这个资源需要的sql，这里为什么需要创建sql呢，因为我们是走的jdbc模式，下面这个sql的结构可以从JdbcClientDetailsService 这个类从获取，如下：
在这里插入图片描述

  1. SET NAMES utf8;
  2. SET FOREIGN_KEY_CHECKS = 0;
  4. -- ----------------------------
  5. -- Table structure for `oauth_client_details`
  6. -- ----------------------------
  7. DROP TABLE IF EXISTS `oauth_client_details`;
  8. CREATE TABLE `oauth_client_details` (
  9.   `client_id` varchar(48) NOT NULL,
  10.   `resource_ids` varchar(256) DEFAULT NULL,
  11.   `client_secret` varchar(256) DEFAULT NULL,
  12.   `scope` varchar(256) DEFAULT NULL,
  13.   `authorized_grant_types` varchar(256) DEFAULT NULL,
  14.   `web_server_redirect_uri` varchar(256) DEFAULT NULL,
  15.   `authorities` varchar(256) DEFAULT NULL,
  16.   `access_token_validity` int(11) DEFAULT NULL,
  17.   `refresh_token_validity` int(11) DEFAULT NULL,
  18.   `additional_information` varchar(4096) DEFAULT NULL,
  19.   `autoapprove` varchar(256) DEFAULT NULL,
  20.   PRIMARY KEY (`client_id`)
  21. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  23. -- ----------------------------
  24. -- Records of `oauth_client_details`
  25. -- ----------------------------
  26. BEGIN;
  27. INSERT INTO `oauth_client_details` VALUES ('clientapp', null, '112233', 'read_userinfo', 'authorization_code', 'http://localhost:9001/callback', null, '3600', null, null, null);
  28. COMMIT;
  30. SET FOREIGN_KEY_CHECKS = 1;

然后我们使用chrome浏览器访问http://localhost:8080/oauth/authorize?client_id=clientapp&redirect_uri=http://localhost:9001/callback&response_type=code&scope=read_userinfo

然后出现了身份认证：
在这里插入图片描述
我们输入账号和密码点击登陆后：

在这里插入图片描述
这里提示我们授权。我们点击Approve，如果点击了Deny就是拒绝授权。

在这里插入图片描述
这里我们就拿到了授权码，然后我们使用postman之类的http来进行后面的测试：
在这里插入图片描述
在这里插入图片描述
这里我们要填入客户端id 和密码，这里是来自数据里面的。这里所有的表单填入的信息都来自数据库表中的数据。

然后我们点击发送：
在这里插入图片描述
这里就可以拿到token了。然后我们就可以用token 来换取我们的api服务了
在这里插入图片描述

在这里插入图片描述
这里就拿到了我们api提供的信息了。

总结

这里使用了授权码模式的oauth2的认证，总体来说很简单的。注意这里的实验是不能用在生产级别的，如果要用到生产级，那么还需要对代码进行多次的封装和配置。

发表评论

表情：
评论列表 （有 0 条评论，80人围观）

还没有评论，来说两句吧...

相关阅读