Springboot Security Oauth2 第二篇：构建一个适用于项目的认证服务器

最新推荐文章于 2019-12-23 16:37:32 发布
最新推荐文章于 2019-12-23 16:37:32 发布
阅读量822 收藏 7
点赞数 1
分类专栏： Springboot Security 文章标签： SpringSecurity OAuth2 服务端 SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013034378/article/details/88309604
版权

本文在第一篇简单例子的基础上进行了升级，本文例子只做认证授权服务器。使用场景的话：该认证授权服务器可做多个客户端的认证中心，多个客户端都访问该服务获取token，然后通过token访问接口。客户端部分下一篇讲解。
升级部分包括：

  1. 用户信息存在于Mysql中，方便管理用户；
  2. Token存在于Redis中，方便管理token，如果存在于内存中，重启服务token就失效了；

运用技术：springboot2.x、springsecurity5.x、mybatis、redis等

1.pom.xml

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.2.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!-- spring-security-oauth2 -->
		<dependency>
			<groupId>org.springframework.security.oauth</groupId>
			<artifactId>spring-security-oauth2</artifactId>
			<version>2.3.4.RELEASE</version>
		</dependency>
		<!--redis -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<!--mybatis-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>
		<!--mysql-->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<!-- Druid 数据连接池依赖 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.9</version>
		</dependency>
		<!-- lombok插件 -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.4</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>

2.application.yml 配置

server:
  port: 8888
spring:
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 0
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 20
        min-idle: 0
    timeout: 2000
  datasource:
    url: jdbc:mysql://localhost:3307/oauth?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: Wbb2018.
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
  security:
    oauth2:
      client:
        redirectUris: http://localhost:9999/webjars/springfox-swagger-ui/o2c.html,http://localhost:9998/webjars/springfox-swagger-ui/o2c.html  #该配置目前没有用上，会在下一篇客户端中讲解
        clientId: demoClient
        clientSecret: demoSecret
        authorizedGrantTypes: authorization_code,client_credentials, password, refresh_token,implicit
        scopes: read,write
        resourceIds: oauth2-resource
        accessTokenValiditySeconds: 3600
        refreshTokenValiditySeconds: 3600
mybatis:
  configuration:
    map-underscore-to-camel-case: true

3.Sql方面的代码

3.1表结构sql代码。
这里我建了3个表，user表用于存放用户信息(账号，密码)，role表用于存放role权限信息，user_permission用于存放用户和权限的绑定信息。


SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(64) DEFAULT NULL,
  `describe` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of role
-- ----------------------------
INSERT INTO `role` VALUES ('1', 'USER', '普通用户');
INSERT INTO `role` VALUES ('2', 'ADMIN', '管理员');

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(64) DEFAULT NULL,
  `password` varchar(64) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'user', '123456');
INSERT INTO `user` VALUES ('2', 'admin', '123456');

-- ----------------------------
-- Table structure for user_permission
-- ----------------------------
DROP TABLE IF EXISTS `user_permission`;
CREATE TABLE `user_permission` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) DEFAULT NULL,
  `role_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user_permission
-- ----------------------------
INSERT INTO `user_permission` VALUES ('1', '1', '1');
INSERT INTO `user_permission` VALUES ('2', '2', '2');

3.2.JavaBean

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class RoleDO {

    private Integer id;
    private String name;
    private String describe;
}

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class UserDO {

    private Integer id;
    private String username;
    private String password;
    private String roleName;
}

3.3.Mybatis Mapper ，都比较简单，就不做解释

import com.wbb.security.bean.RoleDO;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

@Repository
public interface RoleMapper {
    @Select("select id,name,describe from role where id = #{id}")
    RoleDO selectById(@Param("id") Integer id);

}

import com.wbb.security.bean.UserDO;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

@Repository
public interface UserMapper {

    @Select("select id,username,password from user where username = #{username}")
    UserDO selectByName(@Param("username") String username);
}

import com.wbb.security.bean.UserPermissionDO;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface UserPermissionMapper {

    @Select("select up.id,up.role_id,up.user_id,r.`name` as role_name from user_permission up " +
            "join user u on up.user_id = u.id " +
            "join role r on up.role_id = r.id where user_id = #{userId}")
    List<UserPermissionDO> selectByUserId(Integer userId);
}

4.配置认证授权服务器，就不详细介绍，需要介绍可以去看上一篇

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.approval.UserApprovalHandler;
import org.springframework.security.oauth2.provider.token.TokenStore;

@Configuration
@EnableAuthorizationServer
public class Oauth2ServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    TokenStore tokenStore;
    @Autowired
    private UserApprovalHandler userApprovalHandler;


    @Value("${spring.security.oauth2.client.clientId}")
    private String clientId;
    @Value("${spring.security.oauth2.client.clientSecret}")
    private String clientSecret;
    @Value("${spring.security.oauth2.client.redirectUris}")
    private String[] redirectUris;
    @Value("${spring.security.oauth2.client.authorizedGrantTypes}")
    private String[] authorizedGrantTypes;
    @Value("${spring.security.oauth2.client.resourceIds}")
    private String resourceIds;
    @Value("${spring.security.oauth2.client.scopes}")
    private String[] scopes;
    @Value("${spring.security.oauth2.client.accessTokenValiditySeconds}")
    private int accessTokenValiditySeconds;
    @Value("${spring.security.oauth2.client.refreshTokenValiditySeconds}")
    private int refreshTokenValiditySeconds;
    
    /**
     * @param security
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
       security.realm(resourceIds)
               .tokenKeyAccess("permitAll()")
               .checkTokenAccess("isAuthenticated()")
               .allowFormAuthenticationForClients();
    }
    /**
     * @param clients
     * @throws Exception
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
                .withClient(clientId)
                .secret(new BCryptPasswordEncoder().encode(clientSecret))
                .redirectUris(redirectUris)
                .authorizedGrantTypes(authorizedGrantTypes)
                .scopes(scopes)
                .resourceIds(resourceIds)
                .accessTokenValiditySeconds(accessTokenValiditySeconds)
                .refreshTokenValiditySeconds(refreshTokenValiditySeconds);
    }

    /**
     *
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
      // 这里与上一篇不同的是，增加tokenStore(用户存放token)和userApprovalHandler(用于用户登录)配置
        endpoints.tokenStore(tokenStore).userApprovalHandler(userApprovalHandler)
                endpoints.tokenStore(tokenStore)	
                .userApprovalHandler(userApprovalHandler)
                .authenticationManager(authenticationManager)
                .allowedTokenEndpointRequestMethods(HttpMethod.GET,HttpMethod.POST);//获取token允许的访问方式
    }
}

5.配置


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.approval.ApprovalStore;
import org.springframework.security.oauth2.provider.approval.TokenApprovalStore;
import org.springframework.security.oauth2.provider.approval.TokenStoreUserApprovalHandler;
import org.springframework.security.oauth2.provider.request.DefaultOAuth2RequestFactory;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.redis.RedisTokenStore;

@EnableGlobalMethodSecurity(prePostEnabled = true)
@EnableWebSecurity
/**
 * Spring Security默认是禁用注解的，要想开启注解， 需要在继承WebSecurityConfigurerAdapter,并在类上加@EnableGlobalMethodSecurity注解
 * 这里使用redis存储token
 */
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    RedisConnectionFactory redisConnectionFactory;
    @Autowired
    private ClientDetailsService clientDetailsService;

	//使用redis来存储token信息
    @Bean
    public TokenStore tokenStore(){
        return new RedisTokenStore(redisConnectionFactory);
    }

    //MyUserDetailsService用于存放用户信息
    @Bean
    public MyUserDetailsService myUserDetailsService(){
        return new MyUserDetailsService();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService())
                .passwordEncoder(passwordEncoder());
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.formLogin()
                .loginPage("/login.html")
                .loginProcessingUrl("/login")
                .and().logout().logoutUrl("/logout").deleteCookies("JSESSIONID").permitAll()
                .and().authorizeRequests()
                .antMatchers("/login.html").permitAll()
                .anyRequest().authenticated()
                .and().csrf().disable();
    }

    /**
     * spring5.x 需要注入一个PasswordEncoder，否则会报这个错There is no PasswordEncoder mapped for the id \"null\"
     * 加了密码加密，所有用到的密码都需要这个加密方法加密
     * @return
     */
    @Bean
    PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    /**
     * 需要配置这个支持password模式
     */
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
    @Bean
    @Autowired
    public TokenStoreUserApprovalHandler userApprovalHandler(TokenStore tokenStore){
        TokenStoreUserApprovalHandler handler = new TokenStoreUserApprovalHandler();
        handler.setTokenStore(tokenStore);
        handler.setRequestFactory(new DefaultOAuth2RequestFactory(clientDetailsService));
        handler.setClientDetailsService(clientDetailsService);
        return handler;
    }

    @Bean
    @Autowired
    public ApprovalStore approvalStore(TokenStore tokenStore) throws Exception {
        TokenApprovalStore store = new TokenApprovalStore();
        store.setTokenStore(tokenStore);
        return store;
    }
}
  1. 编写MyUserDetailsService类，实现UserDetailsService接口，在loadUserByUsername()方法中来做自己的认证登录逻辑。在该方法中先根据用户名去数据库中找该用户，找到该用户后，再去找该用户的权限，最后通过User类的构造方法返回一个User对象。

import com.wbb.security.bean.UserDO;
import com.wbb.security.bean.UserPermissionDO;
import com.wbb.security.mapper.RoleMapper;
import com.wbb.security.mapper.UserMapper;
import com.wbb.security.mapper.UserPermissionMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;

import java.util.ArrayList;
import java.util.List;

public class MyUserDetailsService implements UserDetailsService {

    @Autowired
    PasswordEncoder passwordEncoder;
    @Autowired
    UserMapper userMapper;
    @Autowired
    RoleMapper roleMapper;
    @Autowired
    UserPermissionMapper userPermissionMapper;
    
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        System.out.println("login name:"+username);
        UserDO userDO =userMapper.selectByName(username);
        if(userDO == null){
            throw  new UsernameNotFoundException("用户不存在");
        }
        ArrayList<GrantedAuthority> authorities = new ArrayList<>();
        List<UserPermissionDO> userPermissionDOs = userPermissionMapper.selectByUserId(userDO.getId());
        for(UserPermissionDO userPermissionDO:userPermissionDOs){
            //这个权限牵涉到底层的投票机制，默认是一票制AffirmativeBased：如果有任何一个投票器运行访问，请求将被立刻允许，而不管之前可能有的拒绝决定
            // RoleVoter投票器识别以"ROLE_"为前缀的role,这里配置已ROLE_前缀开头的role
            authorities.add(new SimpleGrantedAuthority("ROLE_"+userPermissionDO.getRoleName()));
        }
        return new User(username,passwordEncoder.encode(userDO.getPassword()),authorities);
    }
}

7.超low登陆页面login.html，在本篇中无用，配合下一篇客户端使用。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/login" method="post">
    <input type="text"  name="username">
    <input type="password" name="password">
    <input type="submit" value="登录">
</form>
</body>
</html>

8.区别于上一篇，由于本文讲解的是认证授权服务端，就不配置ResourceServerConfig。配置完上面几步后，认证服务器就已经完成了。
接下来，启动项目，直接访问http://localhost:8888/oauth/token?grant_type=password&client_id=demoClient&client_secret=demoSecret&username=admin&password=123456，访问成功，返回值也没问题
在这里插入图片描述
换一个user用户，同样没问题
在这里插入图片描述
演示到这里就结束了，因为是认证服务器，本文就不访问接口url了，只演示获取token这部分，url访问放到下一篇客户端中演示。

讲到这里，本篇文章到此也就结束了,如果文章中有问题,或者有一些不够严谨完善的地方,希望大家体谅体谅。欢迎大家留言,交流交流。
最后附上本项目github地址

WuBinBin-Albert
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权
03-24
Springboot整合Spring security+Oauth2+JWT搭建认证服务器，网关，微服务之间权限认证及授权。 OAuth2是一个关于授权的开放标准，核心思路是通过各类认证手段（具体什么手段OAuth2不关心）认证用户身份，并颁发token（令牌），使得第三方应用可以使用该令牌在限定时间、限定范围访问指定资源。
spring boot security oauth2例子
04-01
一个springboot为框架的security oauth2应用例子，同时集成了swagger2的 restful API查看页面，druid数据源监控, mybatis自动生成和分页插件，远程资源服务器的认证和授权，也可以去github下载 https://github.com/ustcwudi/SpringBoot-Seed https://github.com/ustcwudi/SpringBoot-Seed-Service
spring boot security oauth2 认证服务器搭建
Riteny的博客
03-17 660
最近在搞关于oauth2的系统，在网上的资料比较杂乱，也痛苦了不少了时间，最后终于开发好了符合自己实际应用的系统 在这里顺便把整理后的例子发上来，希望能够帮到别人，同时也给自己留个记录 首先，先添加依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&...
Springboot+SpringSecurity+jwt+OAuth2+Swagger2 验证码验证
springboot+springSecurity+jwt+OAuth2+Swagger2
11-08 895
第一步：加入工具包 <!--工具包--> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>4.5.11</version> </depen...
【转载】spring-security-oauth2(一) 项目环境搭建
yxbmail_2010的博客
12-23 262
图片验证码 图片验证码生成接口 认证流程加入图片验证码校验 图片验证码重构 1.图片验证码生成接口 调用com.google.code.kaptcha.Producer生成图片验证码 将随机数存到session缓存中 将生成的图片写到响应流中 图片验证码封装类  ImageCaptchaVo...
springboot-oauth2-server：一个简单的Oauth2服务器，它使用springboot配置了JWT
02-19
总结来说，`springboot-oauth2-server`项目提供了一个基础模板，展示了如何利用SpringBoot和OAuth2实现一个安全的认证服务器，并结合JWT来处理令牌。这为开发者搭建自己的认证系统提供了一条清晰的路径。理解并掌握...
springboot-oauth2-jwt-example:通过JWT令牌学习Oauth2
05-03
这个项目名为“springboot-oauth2-jwt-example”，它是一个示例应用，旨在帮助开发者了解如何将这些技术集成到自己的Java应用中。 **OAuth2** 是一个授权框架，它允许第三方应用在用户的许可下访问其私有资源，而...
springboot+springsecurity+oauth2.zip
07-21
SpringBoot、SpringSecurity和OAuth2是Java开发领域中三个非常重要的技术组件，它们共同构建了安全、高效的应用程序框架。让我们深入探讨这三个组件的核心概念、功能以及如何在实际项目中结合使用。 首先，...
springboot整合Oauth2,GateWay实现网关登录授权验证
12-14
SpringBoot整合OAuth2和Gateway实现网关登录授权验证是一个复杂而关键的过程，它涉及到现代微服务架构中的安全性设计。OAuth2是一种授权框架，用于保护API并允许第三方应用访问受保护的资源，而Spring Gateway作为...
ssm搭建、Oauth2.0客户端和服务端
02-26
包括三个简单的项目以及mybatis用于自动生成bean、dao、mapping所需的文件，项目分别为: 1、ssm的简单搭建。 2、oauth2.0的客户端。 3、oauth2.0的服务端。
Spring Security教程（8）---- 自定义决策管理器及修改权限前缀
jaune162的专栏，最新动态请关注：https://jaune162.blog
01-17 2万+
首先介绍下Spring的决策管理器，其接口为AccessDecisionManager，抽象类为AbstractAccessDecisionManager。而我们要自定义决策管理器的话一般是继承抽象类而不去直接实现接口。 在Spring中引入了投票器（AccessDecisionVoter）的概念，有无权限访问的最终觉得权是由投票器来决定的，最常见的投票器为RoleVoter，在RoleVote
第十八章：SpringBoot项目中使用SpringSecurity整合OAuth2设计项目API安全接口服务
恒宇少年De成长之路
04-22 1354
OAuth是一个关于授权的开放网络标准，在全世界得到的广泛的应用，目前是2.0的版本。OAuth2在“客户端”与“服务提供商”之间，设置了一个授权层(authorization layer)。“客户端”不能直接登录“服务提供商”，只能登录授权层，以此将用户与客户端分离。“客户端”登录需要OAuth提供的令牌，否则将提示认证失败而导致客户端无法访问服务。下面我们就来讲解...
spring boot 整合 spring security 登录认证
架构师的成长之路的博客
03-06 2万+
spring boot 整合 spring security 登录认证实现访问控制的方法多种多样，可以通过Aop、拦截器实现，也可以通过框架实现（如：Apache Shiro）,本文将具体介绍在Spring Boot中如何使用Spring Security进行安全控制更多干货分布式实战（干货）spring cloud 实战（干货）mybatis 实战（干货）spring boot 实战（干货）Re...
【Spring实战】----Security4.1.3鉴权之美--基于投票的AccessDecisionManager实现及源码分析
honghailiang的专栏
12-29 9211
一、背景知识 Spring实战篇系列----Security4.1.3认证过程源码分析 和Spring实战篇系列----Security4.1.3实现根据请求跳转不同登录页以及登录后根据权限跳转到不同页配置 中均有提到，每一次请求都会走Security Filter，鉴权的过滤器为FilterSecurityInterceptor，其中会判断是否要对请求进行鉴权，以及需要鉴权的会基于投票的A
SpringBoot + Spring Security OAuth2基本使用
热门推荐
whyalwaysmea
03-28 8万+
OAuth2.0基本知识 网上关于OAuth2.0的介绍已经很多了，这里就不做过多的介绍，不太了解的朋友可以参考理解OAuth 2.0 Spring Security OAuth2 基本配置 这里依然使用maven来做管理 &lt;dependency&gt; &lt;groupId&gt;org.springframework.security.oauth&lt...
第七章 SpringCloud OAuth2认证中心-搭建认证中心
justlpf的专栏
10-31 2317
原文地址:https://blog.csdn.net/crazycoder2010/article/details/78464883
Spring Boot 2.0 整合 Spring Security Oauth2
weixin_33862514的博客
04-29 464
是金子在哪都会发光的——每个说这句话的人都误以为自己是金子。 https://user-gold-cdn.xitu.io/2018/4/29/16311778866b1c3b?w=2199&amp;h=1500&amp;f=jpeg&amp;s=385604 前言 在Spring Security源码分析十一：Spring Security OAuth2整合JWT中，我们使用Spring Bo...
SpringBoot实现OAuth2认证服务器
最新发布
05-17
OAuth2是一种授权协议，用于授权第三方应用程序访问用户资源。Spring Security是一个强大的安全框架，可以与OAuth2协议一起使用来构建安全的应用程序。Spring Boot框架可以轻松地构建基于Spring Security和OAuth2的认证服务器。 下面是实现Spring Boot OAuth2认证服务器的步骤： 1. 添加Spring Security和OAuth2依赖项。在pom.xml文件中添加以下依赖项： ```xml <dependency> <groupId>org.springframework.security.oauth</groupId> <artifactId>spring-security-oauth2</artifactId> <version>2.4.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> ``` 2. 配置Spring Security。创建一个SecurityConfig类，继承WebSecurityConfigurerAdapter，并覆盖configure方法： ```java @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private UserDetailsService userDetailsService; @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { auth.userDetailsService(userDetailsService); } @Override protected void configure(HttpSecurity http) throws Exception { http.csrf().disable() .authorizeRequests() .antMatchers("/oauth/token").permitAll() .anyRequest().authenticated() .and() .httpBasic(); } @Bean public PasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } } ``` 这里定义了一个UserDetailsService来获取用户信息，并使用BCryptPasswordEncoder来加密密码。configure方法定义了认证和授权的规则，这里允许访问/oauth/token路径。 3. 配置OAuth2。创建一个AuthorizationServerConfig类，继承AuthorizationServerConfigurerAdapter，并覆盖configure方法： ```java @Configuration @EnableAuthorizationServer public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter { @Autowired private AuthenticationManager authenticationManager; @Autowired private UserDetailsService userDetailsService; @Autowired private DataSource dataSource; @Autowired private PasswordEncoder passwordEncoder; @Override public void configure(ClientDetailsServiceConfigurer clients) throws Exception { clients.jdbc(dataSource).passwordEncoder(passwordEncoder); } @Override public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception { endpoints.authenticationManager(authenticationManager) .userDetailsService(userDetailsService); } } ``` 这里使用了JDBC存储客户端信息和令牌，使用PasswordEncoder来加密客户端密码。configure方法定义了授权服务器的配置，包括客户端信息、令牌存储方式、身份验证管理器和用户详细信息服务。 4. 配置数据源。在application.properties文件中配置数据源，例如使用MySQL数据库： ``` spring.datasource.url=jdbc:mysql://localhost:3306/oauth2?useSSL=false spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver ``` 5. 测试OAuth2认证服务器。启动应用程序并访问/oauth/token路径，可以获取访问令牌。例如： ``` curl -X POST \ http://localhost:8080/oauth/token \ -H 'Authorization: Basic Y2xpZW50OnNlY3JldA==' \ -H 'Content-Type: application/x-www-form-urlencoded' \ -d 'grant_type=password&username=user&password=password' ``` 这里使用了基本身份验证来验证客户端，用户名为client，密码为secret。授权类型为密码，用户名为user，密码为password。成功获取访问令牌后，可以使用该令牌来访问需要授权的资源。 以上就是使用Spring Boot实现OAuth2认证服务器的步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值