SpringBoot+security+oauth2搭建demo

已于 2023-06-15 17:02:20 修改
阅读量1.6k 收藏 20
点赞数 22
文章标签： spring boot java spring
于 2023-06-15 16:54:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39095701/article/details/131229569
版权

前言

搭建Spring Security OAuth2密码模式demo使用postman测试，一方面在慢慢完善使用oauth2过程中做一个系统的总结，一方面做一个知识输出

一、认证授权服务搭建

  • 添加依赖
<properties>
    <java.version>1.8</java.version>
    <spring.boot.version>2.3.12.RELEASE</spring.boot.version>
    <spring-cloud-starter-oauth2.version>2.2.5.RELEASE</spring-cloud-starter-oauth2.version>
    <slf4j.version>1.7.21</slf4j.version>
</properties>

<dependencies>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>

   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-oauth2</artifactId>
       <version>${spring-cloud-starter-oauth2.version}</version>
   </dependency>

   <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.8</version>
   </dependency>

   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
       <version>${slf4j.version}</version>
   </dependency>

   <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.37</version>
   </dependency>

   <dependency>
       <groupId>cn.hutool</groupId>
       <artifactId>hutool-all</artifactId>
       <version>5.8.4.M1</version>
   </dependency>

   <!--jwt-->
   <dependency>
       <groupId>io.jsonwebtoken</groupId>
       <artifactId>jjwt</artifactId>
       <version>0.9.1</version>
   </dependency>

   <!--jdbc-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-jdbc</artifactId>
   </dependency>

   <!--redis-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>

</dependencies>
  • AuthorizationServerConfig.java
/**
 * @Author LY
 * @ClassName AuthorizationServerConfig
 * @Date 2023/6/10 14:42
 * @Description 认证服务器配置
 * @Version 1.0
 */
@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private UserServiceImpl userDetailsService;
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private DataSource dataSource;
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    /**
     * 初始化 redisTokenStore 用户将token 放入redis
     * @return
     */
    @Bean
    public RedisTokenStore redisTokenStore(){
        RedisTokenStore redisTokenStore = new RedisTokenStore(redisConnectionFactory);
        redisTokenStore.setPrefix("TOKEN:");
        return redisTokenStore;
    }

    /**
     * 设置认证令牌放行
     */
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security
            //允许所有资源服务器访问公钥端点（/oauth/token_key）
            //只允许验证用户访问令牌解析端点（/oauth/check_token）
            .tokenKeyAccess("permitAll()")
            .checkTokenAccess("permitAll()")
            //允许表单验证
            .allowFormAuthenticationForClients();//主要是让/oauth/token支持client_id以及client_secret作登录认证
    }

    /**
     * 配置授权以及令牌的访问端点和令牌服务
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        //认证信息从数据库获取
        clients.withClientDetails(clientDetails());
//        // 使用内存操作测试
//        clients.inMemory()
//                .withClient("client-app")
//                .secret(new BCryptPasswordEncoder().encode("123456"))
//                .resourceIds("resId")
//                .scopes("all")
//                .authorizedGrantTypes("password", "refresh_token", "client_credentials")
//                .and()
//                .withClient("client-app2")
//                .secret(new BCryptPasswordEncoder().encode("123456"))
//                .resourceIds("resId2")
//                .scopes("all")
//                .authorizedGrantTypes("password", "refresh_token", "client_credentials")
//                .accessTokenValiditySeconds(3600)
//                .refreshTokenValiditySeconds(86400);
    }

    @Bean
    public ClientDetailsService clientDetails() {
    		// 自定义实现
        return new CustomJdbcClientDetailsService(dataSource);
        // 默认实现
//        return new JdbcClientDetailsService(dataSource);
    }

    /**
     * 配置令牌端点的安全约束
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                // 请求方式
                .allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST)
                // 指定认证管理器
                .authenticationManager(authenticationManager)
                // 用户账号密码认证
                .userDetailsService(userDetailsService)
//                .accessTokenConverter(jwtAccessTokenConverter())
                // 指定token存储位置
                .tokenStore(redisTokenStore())
                // 令牌增强对象 ， 增强返回的结果
                .tokenEnhancer((accessToken, authentication) -> {
                    // 获取用户信息，然后设置
                    SecurityUser user = (SecurityUser) authentication.getPrincipal();
                    LinkedHashMap<String, Object> map = new LinkedHashMap<>();
                    map.put("userId",user.getId());
                    map.put("usernmae",user.getUsername());
                    map.put("enabled", user.getEnabled());
                    DefaultOAuth2AccessToken token = (DefaultOAuth2AccessToken) accessToken;
                    token.setAdditionalInformation(map);
                    return token;
                });
    }
	/*------------使用jwt配置token-------------*/
//    @Bean
//    public TokenStore jwtTokenStore(){
//        JwtTokenStore jwtTokenStore = new JwtTokenStore(jwtAccessTokenConverter());
//        return jwtTokenStore;
//    }
//
//    @Bean
//    public JwtAccessTokenConverter jwtAccessTokenConverter(){
//        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
//        jwtAccessTokenConverter.setSigningKey("SigningKey");//设置对称签名秘钥
//        return jwtAccessTokenConverter;
//    }
}
  • ResourceServerConfig.java
/**
 * @Author LY
 * @ClassName ResourceServerConfig
 * @Date 2023/6/10 22:27
 * @Description 资源服务器配置
 * @Version 1.0
 */
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) {
        // 配置资源id，这里的资源id和授权服务器中的资源id一致
        resources.resourceId("resId")
                // 设置这些资源仅基于令牌认证
                .stateless(true);
    }

    /**
     * 配置 URL 访问权限
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .anyRequest().authenticated();
    }
}
  • WebSecurityConfig.java
/**
 * @Author LY
 * @ClassName WebSecurityConfig
 * @Date 2023/6/10 14:52
 * @Description SpringSecurity授权配置
 * @Version 1.0
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true,securedEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

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

    @Autowired
    private UserServiceImpl userDetailsService;

    @Bean
    @Override
    protected UserDetailsService userDetailsService() {
        return super.userDetailsService();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    	// 从数据库读取配置
        auth.userDetailsService(userDetailsService);
        // 使用内存操作
//        auth
//            .inMemoryAuthentication()
//            .withUser("admin").password(new BCryptPasswordEncoder().encode("123456")).roles("ADMIN")
//            .and()
//            .withUser("andy").password(new BCryptPasswordEncoder().encode("123456")).roles("TEST");
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    /**
     * 拦截配置
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()//配置需要认证的请求
                .antMatchers("/oauth/**").permitAll() //放行
                .anyRequest().authenticated()//其他请求需要认证
                .and().csrf().disable()
                // 禁用session，因为我们使用的是token，session没有用途
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }
}

核心配置基本完成，下面配置自定义UserDetails，UserDetailsService，JdbcClientDetailsService

  • UserDetails自定义 这个类也是从网上摘取的，可自行进行扩展改造
/**
 * @Author LY
 * @ClassName SecurityUser
 * @Date 2023/6/10 14:58
 * @Description Security用户信息
 * @Version 1.0
 */
@Data
public class SecurityUser implements UserDetails {

    /**
     * ID
     */
    private Long id;
    /**
     * 用户名
     */
    private String username;
    /**
     * 用户密码
     */
    private String password;
    /**
     * 用户状态
     */
    private Boolean enabled;
    /**
     * 权限数据
     */
    private Collection<SimpleGrantedAuthority> authorities;

    public SecurityUser() {}

    public SecurityUser(UserDTO userDTO) {
        this.setId(userDTO.getId());
        this.setUsername(userDTO.getUsername());
        this.setPassword(userDTO.getPassword());
        this.setEnabled(userDTO.getStatus() == 1);
        if (userDTO.getRoles() != null) {
            authorities = new ArrayList<>();
            userDTO.getRoles().forEach(item -> authorities.add(new SimpleGrantedAuthority(item)));
        }
    }

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

    @Override
    public String getPassword() {
        return this.password;
    }

    @Override
    public String getUsername() {
        return this.username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return this.enabled;
    }
}

/**
 * @Author LY
 * @ClassName UserDTO
 * @Date 2023/6/10 14:56
 * @Description 用户信息
 * @Version 1.0
 */
@Data
@EqualsAndHashCode(callSuper = false)
@AllArgsConstructor
public class UserDTO{
    private Long id;
    private String username;
    private String password;
    private Integer status;
    private List<String> roles;

}
  • UserDetailsService自定义
/**
 * @Author LY
 * @ClassName UserServiceImpl
 * @Date 2023/6/10 14:54
 * @Description 用户信息校验
 * @Version 1.0
 */
@Service
@Slf4j
public class UserServiceImpl implements UserDetailsService {

    private List<UserDTO> userList;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @PostConstruct
    public void initData() {
        String password = passwordEncoder.encode("123456");
        userList = new ArrayList<>();
        userList.add(new UserDTO(1L,"admin", password,1, CollUtil.toList("ADMIN")));
        userList.add(new UserDTO(2L,"andy", password,1, CollUtil.toList("TEST")));
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        log.info("当前登录用户：{}",username);
        // 这里使用上面定义的用户及权限认证，可以换成自己的从数据库读取
        List<UserDTO> findUserList = userList.stream().filter(item -> item.getUsername().equals(username)).collect(Collectors.toList());
        if (CollUtil.isEmpty(findUserList)) {
            throw new UsernameNotFoundException("用户名或密码错误!");
        }
        SecurityUser securityUser = new SecurityUser(findUserList.get(0));
        if (!securityUser.isEnabled()) {
            throw new DisabledException("该账户已被禁用，请联系管理员!");
        } else if (!securityUser.isAccountNonLocked()) {
            throw new LockedException("该账号已被锁定，请联系管理员!");
        } else if (!securityUser.isAccountNonExpired()) {
            throw new AccountExpiredException("该账号已过期，请联系管理员!");
        } else if (!securityUser.isCredentialsNonExpired()) {
            throw new CredentialsExpiredException("该账户的登录凭证已过期，请重新登录!");
        }
//        String password = passwordEncoder.encode("123456");
//        CustomUserDetails user = new CustomUserDetails(username,password, AuthorityUtils.
//                commaSeparatedStringToAuthorityList("ROLE_ADMIN"));
//        return user;
        return securityUser;
    }
}
  • JdbcClientDetailsService自定义
/**
 * @Author LY
 * @create 2023/6/7 11:17
 * @Description 自定义jdbc数据库读取信息
 */
@Slf4j
public class CustomJdbcClientDetailsService extends JdbcClientDetailsService {

    //操作oauth_client_details数据库SQL语句，另外可以自行注入
    private static final String CLIENT_FIELDS_FOR_UPDATE = "resource_ids, scope, "
            + "authorized_grant_types, web_server_redirect_uri, authorities, access_token_validity, "
            + "refresh_token_validity, additional_information, autoapprove";
    private static final String CLIENT_FIELDS = "client_secret, " + CLIENT_FIELDS_FOR_UPDATE;
    private static final String BASE_FIND_STATEMENT = "select client_id, " + CLIENT_FIELDS + " from oauth_client_details";
    private static final String DEFAULT_FIND_STATEMENT = BASE_FIND_STATEMENT + " order by client_id";
    private static final String DEFAULT_SELECT_STATEMENT = BASE_FIND_STATEMENT + " where client_id = ?";
        private static final String DEFAULT_INSERT_STATEMENT = "insert into oauth_client_details (" + CLIENT_FIELDS
            + ", client_id) values (?,?,?,?,?,?,?,?,?,?,?)";
    private static final String DEFAULT_UPDATE_STATEMENT = "update oauth_client_details " + "set "
            + CLIENT_FIELDS_FOR_UPDATE.replaceAll(", ", "=?, ") + "=? where client_id = ?";
    private static final String DEFAULT_UPDATE_SECRET_STATEMENT = "update oauth_client_details "
            + "set client_secret = ? where client_id = ?";
    private static final String DEFAULT_DELETE_STATEMENT = "delete from oauth_client_details where client_id = ?";

    //1.用于client_secret密码入库与出库时转化
    private PasswordEncoder passwordEncoder = NoOpPasswordEncoder.getInstance();
    //2.数据库存操作。
    private final JdbcTemplate jdbcTemplate;
    private JdbcListFactory listFactory;

    public CustomJdbcClientDetailsService(DataSource dataSource) {
        super(dataSource);
        Assert.notNull(dataSource, "DataSource required");
        this.jdbcTemplate = new JdbcTemplate(dataSource);
        this.listFactory = new DefaultJdbcListFactory(new NamedParameterJdbcTemplate(jdbcTemplate));
    }

    /**
     * 核心方法。加载ClientDetails by clientId
     */
    @Override
    public ClientDetails loadClientByClientId(String clientId) throws InvalidClientException {
        log.info("==== 加载ClientDetails by clientId:{} ====",clientId);
        ClientDetails details = null;
        try {
            details = jdbcTemplate.queryForObject(DEFAULT_SELECT_STATEMENT, new ClientDetailsRowMapper(), clientId);
        }
        catch (EmptyResultDataAccessException e) {
            throw new NoSuchClientException("No client with requested id: " + clientId);
        }
        return details;
    }
		
		// 重新映射字段显示   需要哪些字段添加哪些
    static class ClientDetailsRowMapper implements RowMapper<ClientDetails> {

        @Override
        public ClientDetails mapRow(ResultSet rs, int rowNum) throws SQLException {
            // 筛选值
            BaseClientDetails details = new BaseClientDetails();
            details.setClientId(rs.getString("client_id"));
            details.setClientSecret(rs.getString("client_secret"));
            details.setResourceIds(StringUtils.commaDelimitedListToSet(rs.getString("resource_ids")));
            details.setScope(StringUtils.commaDelimitedListToSet(rs.getString("scope")));
            details.setAuthorizedGrantTypes(StringUtils.commaDelimitedListToSet(rs.getString("authorized_grant_types")));
            details.setAuthorities(getAuthority(rs.getString("authorities")));
            return details;
        }

        private Collection<? extends GrantedAuthority> getAuthority(String authorities) {
            if (!StringUtils.hasText(authorities)) {
                return new ArrayList<>();
            }
            return AuthorityUtils.commaSeparatedStringToAuthorityList(authorities);
        }
    }
}
  • yml配置
server:
  port: 10001

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/permission
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

  # redis 配置
  redis:
    # 地址
    host: 127.0.0.1
    # 端口，默认为6379
    port: 6379
    # 密码
    password:

logging:
  level:
    org:
      springframework:
      	# 打印security日志
        security: debug

测试认证：http://localhost:10001/oauth/token
grant_type:password
client_id:client-app
client_secret:123456
username:admin
password:123456
在这里插入图片描述
可以看到成功获取了access_token
测试授权我们先需要添加测试控制层AuthController.java

@RestController
public class AuthController {
		// 需要ADMIN权限访问
    @PreAuthorize("hasAuthority('ADMIN')")
    @RequestMapping(value = "/getStr1",method = {RequestMethod.GET})
    public String getStr1(){
        return "getStr1";
    }
		// 需要TEST权限访问
    @PreAuthorize("hasAuthority('TEST')")
    @RequestMapping(value = "/getStr2",method = {RequestMethod.GET})
    public String getStr2(){
        return "getStr2";
    }

    @RequestMapping(value = "/getStr3",method = {RequestMethod.GET})
    public String getStr3(){
        return "getStr3";
    }
}

授权测试

测试地址：http://localhost:10001/getStr1
在这里插入图片描述测试地址：http://localhost:10001/getStr2
在这里插入图片描述可以看到访问getStr1能正常访问，访问getStr2提示“不允许访问”，因为我们当前登录的账号只有ADMIN权限，测试结果复核预期

资源服务id测试

从上面的配置我们指定认证授权服务配置的client_id=client-app属于resourceId=resId，另一个client_id=client-app2属于resourceId=resId2
在这里插入图片描述在这里插入图片描述可以看到当前登录的用户属于resourceId=resId资源并没有其他资源访问权限，测试期望预期，认证授权服务端测试结束

我们可以看下redis存储的TOKEN信息：
在这里插入图片描述

二、资源服务搭建

<properties>
  <java.version>1.8</java.version>
  <spring.boot.version>2.3.12.RELEASE</spring.boot.version>
  <spring-cloud-starter-oauth2.version>2.2.5.RELEASE</spring-cloud-starter-oauth2.version>
  <slf4j.version>1.7.21</slf4j.version>
</properties>

<dependencies>
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-oauth2</artifactId>
      <version>${spring-cloud-starter-oauth2.version}</version>
  </dependency>

  <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.8</version>
  </dependency>

  <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
  </dependency>

  <dependency>
      <groupId>cn.hutool</groupId>
      <artifactId>hutool-all</artifactId>
      <version>5.8.4.M1</version>
  </dependency>
  
</dependencies>
  • ResourceServerConfigurerAdapter.java
/**
 * @Author LY
 * @ClassName WebSecurityConfig
 * @Date 2023/6/10 17:58
 * @Description 资源服务配置
 * @Version 1.0
 */
@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) {
        // 配置资源id，这里的资源id和授权服务器中的资源id一致
        resources.resourceId("resId2")
                .stateless(true);
    }

    /**
     * 配置 URL 访问权限
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf().disable().authorizeRequests()
                .antMatchers("/oauth/**").permitAll() //设置/oauth/**的接口不需要授权就可以访问
                .anyRequest().authenticated();
    }

}
  • yml配置
server:
  port: 10002

#spring:
#  datasource:
#    url: jdbc:mysql://127.0.0.1:3306/permission
#    username: root
#    password: root
#    driver-class-name: com.mysql.jdbc.Driver

security:
  oauth2:
    client:
      # 客户端id
      client-id: client-app2
      # 客户端密钥
      client-secret: 123456
#      resource-ids: resId2
      access-token-uri: http://127.0.0.1:10001/oauth/token
      user-authorization-uri: http://127.0.0.1:10001/oauth/authorize
    resource:
      # 认证服务器验证token的请求接口
      token-info-uri: http://127.0.0.1:10001/oauth/check_token
      # 获取用户信息
      user-info-uri: http://127.0.0.1:10001/users/current

logging:
  level:
    org:
      springframework:
      	# security日志打印
        security: debug
  • 控制层
/**
 * @Author LY
 * @ClassName SystemController
 * @Date 2023/6/10 17:56
 * @Description 测试资源服务接口权限
 * @Version 1.0
 */
@RestController
public class SystemController {

    @PreAuthorize("hasAuthority('ADMIN')")
    @RequestMapping(value = "/getSys1",method = {RequestMethod.GET})
    public String getSys1(){
        final SecurityContext context = SecurityContextHolder.getContext();
        System.out.println(context.getAuthentication());

        return "sys1";
    }

    @PreAuthorize("hasAuthority('TEST')")
    @RequestMapping(value = "/getSys2",method = {RequestMethod.GET})
    public String getSys2(){
        return "sys2";
    }

    @RequestMapping(value = "/getSys3",method = {RequestMethod.GET})
    public String getSys3(){
    		// 登录信息
        final SecurityContext context = SecurityContextHolder.getContext();
        System.out.println(context.getAuthentication().isAuthenticated());
        System.out.println(context.getAuthentication().getAuthorities());
        System.out.println(context.getAuthentication().getPrincipal());
        System.out.println(context.getAuthentication().getDetails());
        return "sys3";
    }

}

资源服务搭建完成，接下来使用postman测试接口：
在这里插入图片描述在这里插入图片描述在这里插入图片描述可以看见当前登录的用户是存在ADMIN权限而没有TEST权限，测试期望预期
接下来测试资源服务resourceId验证：
在这里插入图片描述在这里插入图片描述可以看到当前登录的用户属于resourceId=resId2资源并没有其他资源访问权限，测试期望预期，资源服务端测试访问资源id验证结束

总结： 整个认证授权测试结束，其中测试了使用注解限制，测试了resourceId资源服务限制，测试结果基本符合我们的期望，到此使用SpringBoot+security+oauth2搭建demo完成

源代码地址：https://gitee.com/xiaomao12/ly_oauth2.git

酥骨鱼
关注
Spring Security OAuth2入门Demo
诺浅的专栏
11-17 1782
写在前面 项目基于Spring Cloud，需要你对Spring Cloud有所了解，篇幅所限，本文只会列出关键代码，文末会给出完整的项目GIT地址，建议下载下来导入到idea中再进行查看。 项目的目录结构 其中auth-server为认证模块，client-user为资源模块。 auth-server模块配置 首先需要导入oauth2的包 <dependency> <groupId>org.springframework.cloud</groupId>
【Spring】搭建SpringBoot + OAuth2认证授权服务
一个不断前行的程序者
09-12 3508
在这篇博客中，我们成功搭建了一个基于Spring Boot和OAuth2的认证授权服务。我们配置了用户存储、安全配置、OAuth2授权服务器和资源服务器，并创建了一些基本的控制器和前端页面来演示登录和访问受保护资源的过程。请注意，这只是一个简单的示例，用于演示基本的OAuth2流程。在生产环境中，你需要考虑更多的安全性和配置选项，例如使用JWT令牌、配置数据库、添加错误处理、日志记录等。
springboot OAuth2.0-demo
12-17
1、基于springboot oauth2.0 实现资源访问认证； 2、访问前需要获取token; 3、携带token访问资源接口。
SpringBoot安全实战：整合SpringSecurity实现OAuth2认证与授权
最新发布
梵心白莲的博客
03-12 1522
在当今数字化的时代，应用程序的安全性至关重要。OAuth2 作为一种开放标准的授权协议，被广泛应用于第三方应用授权和用户认证场景。Spring Security 是 Spring 生态系统中强大的安全框架，而 Spring Boot 则为开发者提供了快速搭建应用的便捷方式。本文将详细介绍如何在 Spring Boot 项目中整合 Spring Security 实现 OAuth2 认证与授权。
spring-boot spring-security-oauth2 完整demo
11-22
spring-boot spring-security-oauth2 完整demo，可以使用微信的方式来获取token和查看资源，注意看代码中的备注
Spring Boot集成oauth2快速入门demo
HBLOG
04-28 740
1.oauth2介绍1，什么是 OAuth 2?OAuth 是一个开放标准，该标准允许用户让第三方应用访问该用户在某一网站上存储的私密资源（如头像、照片、视频等），而在这个过程中无须将用户名和密码提供给第三方应用。实现这一功能是通过提供一个令牌（token），而不是用户名和密码来访问他们存放在特定服务提供者的数据。每一个令牌授权一个特定的网站在特定的时段内访问特定的资源。这样，OAuth 让用户可...
spring boot + spring security + github 基于oauth2.0授权码模式实现单点登录的最简demo
lhq123lol的博客
03-04 395
本章主要介绍sso单点登录。 1.1 简介 暂无 1.2 示例demo spring boot + spring security + github 基于oauth2.0授权码模式实现单点登录的最简demo , 点击下方连接，获取快速入门方式 https://gitee.com/duobab/springboot-security-oauth2-demo ...
整理了八个开源的 Spring Boot 学习资源
纯洁的微笑
05-22 1885
Spring Boot 算是目前 Java 领域最火的技术栈了，松哥年初出版的 《Spring Boot + Vue 全栈开发实战》迄今为止已经加印了 3 次，Sprin...
springboot+security+cas集成demo
11-23
本文将详细解析"springboot+security+cas集成demo"的相关知识点。 首先，Spring Boot是由Pivotal团队提供的一个用于简化Spring应用初始搭建以及开发过程的框架。它集成了大量的常用组件，并提供了默认配置，使得...
SpringBoot+Security+Oauth2 实战Demo教程
对于初学者而言，SpringBoot+Security+Oauth2的小Demo具有极高的参考价值。它不仅展示了一个典型的Web应用是如何构建的，还涉及到如何确保应用的安全性。通过参考Demo，学习者可以了解如何使用Spring Boot快速搭建...
SpringBoot3.0 + SpringSecurity6.0 +OAuth2 使用Github作为授权登录
weixin_46076174的博客
06-16 3887
开放授权（OAuth）是一个开放标准，允许用户让第三方应用访问该用户在某一网站上存储的私密的资源（如照片，视频，联系人列表），而无需将用户名和密码提供给第三方应用。 OAuth允许用户提供一个令牌，而不是用户名和密码来访问他们存放在特定服务提供者的数据。过程如下： （A）用户打开客户端以后，客户端要求用户给予授权。 （B）用户同意给予客户端授权。 （C）客户端使用上一步获得的授权，向认证服务器申请令牌。 （D）认证服务器对客户端进行认证以后，确认无误，同意发放令牌。 （E）客户端使用令牌，向资源服务器申请获
spring-boot-oauth2-demo
05-12
spring-boot-oauth2-demo
spring security oauth2 demo
06-05
代码直接导入eclipse，然后把数据库语句添加到mysql，启动AlanOAuthApplication就可以跑起来了，详细说明在项目的README.md里面。
spring-boot-oauth2-demo-master_springbootdemo_DEMO_
10-02
Spring boot demo auth认证代码示例
springboot集成oauth2.0
07-27
springboot 集成oauth2.0服务器，基于oauth2.0授权码形式集成
基于Springboot集成security、oauth2实现认证鉴权、资源管理源码
04-22
基于Springboot集成security、oauth2实现认证鉴权、资源管理源码，具体相关博文我发表在https://www.cnblogs.com/xiaofengxzzf/p/10733955.html
SpringBoot+Spring Security Oauth2实现客户端授权
热门推荐
qq_33460562的博客
02-23 4万+
框架使用SpringBoot + Spring Security Oauth2 主要完成了客户端授权 可以通过mysql数据库读取当前客户端表信息进行验证，token存储在数据库中 1.引入依赖 oauth2 依赖于spring security，需要引入spring， mysql，redis， mybatis &amp;amp;amp;amp;lt;dependencies&amp;amp;amp;amp;gt; &am
spring-boot spring-security-oauth2 Demo
weixin_41887312的博客
07-05 1680
从初学者的角度来看，初次使用spring-boot和spring-security-oauth2整合，第一步自然是搭建一个“Hello World”先跑起来。那么二话不说，先来一个spring-boot的“Hello World”。Part1:1、pom.xml&lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/group...
SpringBoot图文教程「概念+案例 思维导图」「基础篇上」
Z875983491的专栏
02-12 458
有天上飞的概念，就要有落地的实现 概念+代码实现是本文的特点，教程将涵盖完整的图文教程，代码案例 每个知识点配套自测面试题，学完技术自我测试 本文初学向，所以希望文中所有的代码案例都能敲一遍 大哥大姐新年好，点赞转发不要少 **文本已收录至GitHub开源仓库 Lu_JavaNodes 码云仓库地址Lu_JavaNodes ，**包含教程涉及所有思维导图，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值