Spring Security

最新推荐文章于 2022-11-01 17:14:40 发布
最新推荐文章于 2022-11-01 17:14:40 发布
阅读量111 收藏
点赞数
分类专栏： Spring Boot Spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justfamily/article/details/104129027
版权

Spring Security

  • 开发Web应用，对页面的安全控制通常是必须的。比如：对于没有访问权限的用户需要转到登录表单页面。要实现访问控制的方法多种多样，可以通过Aop、拦截器实现，也可以通过框架实现，例如：Apache Shiro、Spring Security 。Spring Security 认证流程

    • UsernamePasswordAuthenticationFilter 实现获得用户名和密码的操作，并且只允许post请求方法
    SecurityContextPersistenceFilter extends GenericFilterBean{
}
  
AbstractAuthenticationProcessingFilter extends GenericFilterBean{
  
}

UsernamePasswordAuthenticationFilter extends AbstractAuthenticationProcessingFilter{
   @Override
   public Authentication attemptAuthentication(HttpServletRequest request, 
               HttpServletResponse response) throws AuthenticationException {
      //return super.attemptAuthentication(request, response);
      if (this.postOnly && !request.getMethod().equals("POST")) {
         throw new AuthenticationServiceException("Authentication method not supported:" 
                                                  + request.getMethod());
      }
      String username = this.obtainUsername(request);
      String password = this.obtainPassword(request);
      if (username == null) {
            username = "";
      }
      if (password == null) {
            password = "";
      }

      username = username.trim();
      UsernamePasswordAuthenticationToken token = new 
        UsernamePasswordAuthenticationToken(username, password);
      this.setDetails(request, token);
      // 通过调用 getAuthenticationManager() 来获取 AuthenticationManager 对象，通过调用它的 authenticate 方法来查找支持该 token 认证方式的 provider，然后调用该 provider 的 authenticate 方法进行认证
      return this.getAuthenticationManager().authenticate(authRequest);
    }
}
    • AuthenticationManager 接口有一个 authenticate 方法，通过该方法调用 AuthenticationProvider 的authenticate方法
    public class ProviderManager implements AuthenticationManager {
    // 维护一个AuthenticationProvider列表
    private List<AuthenticationProvider> providers = Collections.emptyList();
 
    public Authentication authenticate(Authentication authentication) 
      throws AuthenticationException {
      Class<? extends Authentication> toTest = authentication.getClass();
      AuthenticationException lastException = null;
      Authentication result = null;
      boolean debug = logger.isDebugEnabled();
      // 获得认证方式的 provider
      Iterator var6 = this.getProviders().iterator();
      //依次来认证
      while(var6.hasNext()) {
          AuthenticationProvider provider = (AuthenticationProvider)var6.next();
          if (provider.supports(toTest)) {
              try {
                  // 如果有Authentication信息，则直接返回
                  result = provider.authenticate(authentication);
                  if (result != null) {
                      this.copyDetails(authentication, result);
                      break;
                  }
              } catch (AccountStatusException var11) {
                  this.prepareException(var11, authentication);
                  throw var11;
              } catch (InternalAuthenticationServiceException var12) {
                  this.prepareException(var12, authentication);
                  throw var12;
              } catch (AuthenticationException var13) {
                  lastException = var13;
              }
          }
        }
    }
}
    • DaoAuthenticationProvider 主要完成用户授权校验，authenticate方法会调用 additionalAuthenticationChecks方法，来对请求的用户名和密码进行校验。如果校验不通过，则返回 Bad credentials
    AbstractUserDetailsAuthenticationProvider implements AuthenticationProvider{
}

DaoAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider{
  // retrieveUser方法，它返回UserDetails类
  protected final UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
    UserDetails loadedUser;
    try {
　　　 //调用 UserDetailsService 对象的 loadUserByUsername这个方法；
      loadedUser = this.getUserDetailsService().loadUserByUsername(username);
    } catch (UsernameNotFoundException var6) {
        if (authentication.getCredentials() != null) {
            String presentedPassword = authentication.getCredentials().toString();
            this.passwordEncoder.isPasswordValid(this.userNotFoundEncodedPassword, 
                                                 presentedPassword, (Object)null);
        }
        throw var6;
    } catch (Exception var7) {
        throw new InternalAuthenticationServiceException(var7.getMessage(), var7);
    }

    if (loadedUser == null) {
        throw new InternalAuthenticationServiceException("UserDetailsService returned null, which is an interface contract violation");
    } else {
        return loadedUser;
    }
  }
  
  // additionalAuthenticationChecks方法，拿到通过用户姓名获得的该用户的信息（密码等）和用户输入的密码加密后对比，如果不正确就会报错Bad credentials的错误
  protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
    Object salt = null;
    if (this.saltSource != null) {
　　　　  //此方法在你的配置文件中去配置实现的 也是spring security加密的关键 ------划重点
        salt = this.saltSource.getSalt(userDetails);
    }

    if (authentication.getCredentials() == null) {
        this.logger.debug("Authentication failed: no credentials provided");
        throw new BadCredentialsException(this.messages.getMessage(
          "AbstractUserDetailsAuthenticationProvider.badCredentials", 
          "Bad credentials"));
    } else {
        String presentedPassword = authentication.getCredentials().toString();
        if (!this.passwordEncoder.isPasswordValid(userDetails.getPassword(), 
                                                  presentedPassword, salt)) {
            this.logger.debug(
              "Authentication failed: password does not match stored value");
            throw new BadCredentialsException(this.messages.getMessage(
              "AbstractUserDetailsAuthenticationProvider.badCredentials", 
              "Bad credentials"));
        }
    }
  }
}
    • DaoAuthenticationProvider 类中的 retrieveUser方法，是用来返回UserDetails类的，UserDetails是Spring对用户身份信息封装的一个接口。使用 UserDetailsService 类可以从特定的地方（通常是数据库）加载用户信息。
    public interface UserDetailsService {
   UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
}

public interface UserDetails extends Serializable {
    Collection<? extends GrantedAuthority> getAuthorities();

    String getPassword();
    String getUsername();
    boolean isAccountNonExpired();
    boolean isAccountNonLocked();
    boolean isCredentialsNonExpired();
    boolean isEnabled();
}

  • Spring Boot 集成 Spring Security

    • 创建一个 demo 项目 ， 可以正常访问：http://localhost:8080/hello

    • 修改 pom 文件， 添加依赖

      <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
      • 添加依赖后，整个应用就有了默认的安全机制，当再次打开URL，你将看到一个alert表单对话框，需要输入用户名和密码
      • security默认的用户名是user, 默认密码是应用启动的时候，通过UUID算法随机生成的。

    • 通过 application.propertiesm配置你可以修改默认用户名和密码

      spring.security.user.name=admin
spring.security.user.password=123456

    • 使用内存用户名密码认证，自定义一个配置类 SecurityConfig , HttpSecurity 方法介绍

      @Configuration
@EnableWebSecurity
class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    // 在任何应用中，并不是所有请求都需要同等程度地保护起来。有些请求需要认证，有些则不需要。
    // 对每个请求进行细粒度安全性控制的关键在于重载configure(HttpSecurity)方法
    @Override
    protected void configure(HttpSecurity http) throws Exception {  
      // 默认配置， 父类中的实现 ： super.configure(http);
      http.authorizeRequests()
          .anyRequest().authenticated()  // 所有请求需要身份认证
          .and().formLogin()
          .and().httpBasic();
      // 
      http.authorizeRequests()  // 对请求进行认证
          .antMatchers("/", "/hello").permitAll()
          .antMatchers("/admin/**").hasRole("ADMIN")   // 角色检查
          .antMatchers("/user/**").hasRole("USER")   // 角色检查
          .antMatchers("/**").hasAnyRole("ADMIN", "USER")
          .and().formLogin()
          .and().logout().logoutSuccessUrl("/login").permitAll()
          .and().csrf().disable();   // 关闭csrf验证
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 使用内存用户名密码认证
        auth.inMemoryAuthentication()
          .withUser("user").password(passwordEncoder().encode("1234")).roles("USER")
          .and().withUser("admin").password(passwordEncoder().encode("admin"))
          .roles("ADMIN", "USER");
    }
  
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

  • 用数据库存储用户和角色，实现安全认证

    • 数据库层设计：新建三张表User,Role,UserRole

      @Entity
class User {
  private Integer id;
  private String userName;
  private String password;
}

@Entity
class Role {
  private Integer id;
  private String role;
}

@Entity
class UserRole {
  private Integer id;
  private Integer userId;
  private Integer roleId;
}

    • 配置类 SecurityConfig

      @Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
    @Override
    @Bean
    public UserDetailsService userDetailsService() { //覆盖写userDetailsService方法
        return new CustomUserDetailService();
    }
  
    @Override
    protected void configure(HttpSecurity http) throws Exception { 
        http.authorizeRequests()  // 对请求进行认证
          .antMatchers("/", "/hello").permitAll()
          .antMatchers("/admin/**").hasAuthority("ADMIN") // 授权检查
          .antMatchers("/user/**").hasAuthority("USER")   // 授权检查
          .antMatchers("/**").hasAnyAuthority("ADMIN","USER")
          .and().formLogin()
          .and().logout().logoutSuccessUrl("/login").permitAll()
          .and().csrf().disable();   // 关闭csrf验证
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService()); //从数据库获取用户和角色
    }
}

    • 实现 UserDetailsService 子类

      public class CustomUserDetailService implements UserDetailsService {
  @Autowired
   UserDao userDao;
   @Autowired
   RoleDao roleDao;
  
  @Override
  public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
    User user = userDao.getUserByUsername(username);
		ArrayList<String> userRoles = roleDao.listByUserId(user.getId());

    List<SimpleGrantedAuthority> list = new ArrayList<SimpleGrantedAuthority>();
    for (String roleName : userRoles) {
      list.add(new SimpleGrantedAuthority(roleName));
    }
    return new org.springframework.security.core.userdetails.User(
      user.getUserName(), user.getPassword(), list);
  }
}

    • 自定义登录页面 Spring Security 5 Login Form Example

  • Spring Security 和 JWT 整合

    • 修改pom 文件

      <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.7.0</version>
</dependency>

    • 添加配置类

      @Configuration
@EnableWebSecurity
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    // 设置 HTTP 验证规则
    @Override
    protected void configure(HttpSecurity http) throws Exception {
      
      http.authorizeRequests()  // 对请求进行认证
          .antMatchers("/hello").permitAll()  // 不需要身份认证
          .antMatchers("/admin/**").hasRole("ADMIN")   // 角色检查
          .antMatchers("/**").hasAnyRole("ADMIN", "USER")
          .antMatchers("/hello").hasAuthority("AUTH_WRITE")  // 权限检查
          .and().formLogin()
          .and().logout().logoutSuccessUrl("/login").permitAll()
          .and().csrf().disable();   // 关闭csrf验证
          // 在UsernamePasswordAuthenticationFilter 之前添加一个过滤器（让所有 /login 的请求都经过 JWTLoginFilter 过滤器，进行登录校验，验证成功后，生成JWT 返回）
          .and().addFilterBefore(new JWTLoginFilter("/login", authenticationManager()), UsernamePasswordAuthenticationFilter.class)
          // 在UsernamePasswordAuthenticationFilter 之前添加一个过滤器（让所有请求都经过JWTAuthenticationFilter 过滤器，从JWT中取出username和authentication，并生成Token，验证Token是否合法）
          .addFilterBefore(new JWTAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 使用自定义的身份验证组件，代替默认的 DaoAuthenticationProvider
        auth.authenticationProvider(new CustomAuthenticationProvider());
    }
}

  • Spring Boot Security 整合 OAuth2 设计安全API接口服务

    • oauth2 知识介绍

      • oauth2授权主要由两部分组成：认证服务(Authorization server)和 资源服务(Resource server)
      • oauth2 主要支持4种模式4种 grant_type
        • authorization_code ：授权码模式，即先登录获取code，再获取token
        • client_credentials ：客户端模式，用户向客户端注册，然后客户端以自己的名义向’服务端’获取资源，无用户
        • password ： 密码模式，将用户名 密码传过去，直接获取token
        • refresh_token ：刷新access_token

    • 建表：Spring OAuth2 己经设计好了数据库的表，且不可变。表及字段说明参照：Oauth2数据库表说明

    • pom 文件

      <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.8.RELEASE</version>
</dependency>

    • 新增 AuthorizationServerConfiguration 配置类

      @Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter {
    // 注入authenticationManager 来支持 password grant type
    @Autowired
    private AuthenticationManager authenticationManager;
  
    // 配置内存存储 token
    @Bean
    public TokenStore tokenStore() {
        return new InMemoryTokenStore();
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) 
      throws Exception {
        // 配置oauth2服务跨域
        CorsConfigurationSource source = new CorsConfigurationSource() {
            @Override
            public CorsConfiguration getCorsConfiguration(HttpServletRequest request) {
                CorsConfiguration corsConfiguration = new CorsConfiguration();
                corsConfiguration.addAllowedHeader("*");
                corsConfiguration.addAllowedOrigin(request.getHeader( HttpHeaders.ORIGIN));
                corsConfiguration.addAllowedMethod("*");
                corsConfiguration.setAllowCredentials(true);
                corsConfiguration.setMaxAge(3600L);
                return corsConfiguration;
            }
        };
        // 意思是 /oauth/token 路径 不需要授权就可以访问
        security.tokenKeyAccess("permitAll()")
                .checkTokenAccess("permitAll()")
                .allowFormAuthenticationForClients()
                .addTokenEndpointAuthenticationFilter(new CorsFilter(source));
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        // 为了测试方便，我们先插入一条客户端信息
        clients.inMemory().withClient("dev").secret("dev").scopes("app")
                .authorizedGrantTypes("client_credentials","authorization_code",
                                      "password","refresh_token")
                .redirectUris("http://www.baidu.com")
                .refreshTokenValiditySeconds(360).accessTokenValiditySeconds(360)
                .autoApprove(false);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.tokenStore(tokenStore())
          // 配置内存存储 token , 使用authenticationManager 来支持 password grant type
          .authenticationManager(authenticationManager);
    }
}

    • 新增 ResourceServerConfig

      // 配置 OAuth2 管理的资源，和 WebSecurityConfig 授权配置一样
@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.requestMatchers().antMatchers("/hi")
                .and()
                .authorizeRequests()
                .antMatchers("/hi").authenticated();
    }
}

    • 修改 WebSecurityConfig ， 支持 password 模式

      @Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http.authorizeRequests()
                .antMatchers("/", "/hello").permitAll()
                .antMatchers("/**").authenticated()
//                .anyRequest().authenticated()
                .and().formLogin()
                .and().httpBasic();
    }
  
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
          .withUser("user")
          .password(passwordEncoder().encode("1234"))
          .roles("USER");
    }
  
    // 支持 OAuth2 的密码编码方式， 因为OAuth2 不支持 BCrypt
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new PasswordEncoder() {
            @Override
            public String encode(CharSequence charSequence) {
                return charSequence.toString();
            }

            @Override
            public boolean matches(CharSequence charSequence, String s) {
                return Objects.equals(charSequence.toString(),s);
            }
        };
    }
  
    // 需要配置这个支持password模式 , support password grant type
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

    • 测试： 密码授权模式、刷新 token 模式 、客户端授权模式

      #密码授权模式
curl -X POST -d "username=user&password=1234&grant_type=password&client_id=dev&client_secret=dev" http://localhost:8080/oauth/token

{"error":"unsupported_grant_type","error_description":"Unsupported grant type"}

{"access_token":"b541cb47-aab8-48b5-b845-dfe002e4dbe3","token_type":"bearer","refresh_token":"8cfad00a-3ce0-4925-bb8c-bf52725d1fec","expires_in":359,"scope":"app"}

# 刷新 token 模式
curl -X POST -d "grant_type=refresh_token&refresh_token=8cfad00a-3ce0-4925-bb8c-bf52725d1fec&client_id=dev&client_secret=dev" http://localhost:8080/oauth/token

{"error":"server_error","error_description":"Internal Server Error"} # 意思是 UserDetailsService is required

#客户端授权模式
curl -X POST -d "grant_type=client_credentials&client_id=dev&client_secret=dev" http://localhost:8080/oauth/token

{"access_token":"598ab278-b5f0-484b-bdc6-ff01199c3631","token_type":"bearer","expires_in":359,"scope":"app"}

# 访问 URL
curl http://localhost:8080/hi\?name\=zhangsan\&access_token\=b541cb47-aab8-48b5-b845-dfe002e4dbe3

    • 测试授权码模式

      http://localhost:8080/oauth/authorize?response_type=code&client_id=dev&redirect_uri=http://www.baidu.com

    • 其他

      • SpringBoot + Spring Security OAuth2基本使用 运行不起来，报错：Field configurers in org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerSecurityConfiguration required a bean of type ‘java.util.List’ that could not be found
Dong滴个Dong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前端优化之-设置较长的expires
百川异源，终归于海
07-05 1万+
前端优化中很重要的一项是设置一个较长的过期时间，例如yahoo的expires设的是10年，page speed推荐一个月以上。设expires的目的就是让没有更新的资源不应该产生http请求，如果强制产生请求则返回304，减少服务器压力和降低带宽。exprires属于服务器优化范畴，需要修改服务器配置并重启。http header相关知识expires：指定缓存到期GMT的绝对时间，如果设了max-age，max-age就会覆盖expires。如果expires到期需要重新请求。last-modifi
自定义spring security oauth2 /oauth/token以及token失效/过期的返回内容格式
qq_37634156的博客
06-12 1万+
在整合Spring Security Oauth2的时候，获取token的接口/oauth/token的返回内容格式为固定的，如下图所示：而token过期或者无效的返回参数格式如下图所示：实际在我们的项目中有时候会要求自定义返回内容格式，下面分别介绍获取token和token失效/过期的自定义返回内容格式。 2、创建获取token接口返回值的转换类 创建一个类来完成对获取token接口的返回参数进行转换成我们自定义的格式，这里使用到了@JsonSerialize注解，该注解主要用于数据转换，不知
聊聊 OAuth 2.0 的 token expire_in 使用
冷冷的博客
04-08 1万+
问题背景 有同学私信问了这样的问题，访问 pig4cloud 的演示环境 查看登录请求 network 返回报文如下: { "access_token":"16d35799-9cbb-4c23-966d-ab606029a623", "token_type":"bearer", "re...
Spring Security 每次返回新 token
weixin_42555971的博客
11-01 997
新 token
Spring Security JWT 添加额外信息
weixin_42555971的博客
11-01 942
增强
springsecurity
07-23
Spring Security 是一个强大的且高度可定制的身份验证和访问控制框架，专为Java应用程序设计。它为Web应用和企业级应用提供了全面的安全解决方案，包括登录、权限管理、会话管理、跨站请求伪造（CSRF）防护等核心...
Spring Security in Action
11-22
Spring Security 实践指南 Spring Security 是一个基于 Java 的安全框架，旨在提供身份验证、授权和访问控制等功能。下面是 Spring Security 的主要知识点： 一、身份验证（Authentication） 身份验证是指对用户...
SpringSecurity.zip
06-08
​ Spring Security：spring家族一员。是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转...
springSecurity
最新发布
10-14
springSecurity
springboot+ spring security实现登录认证
05-04
SpringBoot结合Spring Security实现登录认证是企业级应用开发中常见的安全框架组合，它们为Web应用程序提供了强大的安全性。本文将深入探讨这两个技术的核心概念、配置以及如何整合以实现用户登录认证功能。 ...
Spring-Security-Oauth整合Spring-Security,拦截器
盲目的拾荒者的博客
04-22 1万+
程序的目的主要是，在自己开发的web项目中，即提供前端页面调用访问得接口（带有安全机制），也提供第三方调用的API(基于授权认证的). 在整合的过程中发现SpringSecurity不能到即处理自己的web请求也处理第三方调用请求。所以采用拦截器拦截处理本地的web请求，spring-security-oauth对第三方认证请求进行认证与授权。如果对Oauth2.0不熟悉请参考Oauth2.0介...
使用Spring Cloud Security OAuth2搭建授权服务
热门推荐
王鸿飞的专栏
09-14 13万+
Spring Cloud Security OAuth2 是 Spring 对 OAuth2 的开源实现，优点是能与Spring Cloud技术线无缝集成，如果全部使用默认配置，开发者只需要添加注解就能完成 OAuth2 授权服务的搭建。添加依赖授权服务是基于Spring Security的，因此需要在项目中引入两个依赖： <dependency> <groupId>org.spri
Spring Security Oauth2 之 理解OAuth 2.0授权流程
vincent
04-03 1万+
总览 本系列针对Security-Oauth2架构的剖析，包括：oauth2.0认证架构详解、架构源码解读、核心结构配置。 本篇是对oauth2认证流程的概述，喜欢的多多pick！ 内容引用书籍：The OAuth 2.0 Authorization Framework gitHub 链接：https://g...
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...
Spring Security（二）OAuth2认证详解
乌龟的专栏
08-11 1万+
1、OAuth2.0 简介 OAuth 2.0是用于授权的行业标准协议。OAuth 2.0为简化客户端开发提供了特定的授权流，包括Web应用、桌面应用、移动端应用等。 1.1 OAuth2.0 相关名词解释 Resource owner（资源拥有者）：拥有该资源的最终用户，他有访问资源的账号密码； Resource server（资源服务器）：拥有受保护资源的服务器，如果请求包含正确的访问令牌，可以访问资源； Client（客户端）：访问资源的客户端，会使用访问令牌去获取资源服务器的资源，可
Spring Security 与 OAuth2（介绍）
乌龟的专栏
08-16 740
个人 OAuth2 全部文章 Spring Security 与 OAuth2（介绍）：https://www.jianshu.com/p/68f22f9a00ee Spring Security 与 OAuth2（授权服务器）：https://www.jianshu.com/p/227f7e7503cb Spring Security 与 OAuth2（资源服务器）：https://www.jianshu.com/p/6dd03375224d Spring Security 与 OAuth2（客户
使用Spring Security和OAuth2实现RESTful服务安全认证
zw456的专栏
11-05 1万+
使用Spring Security和OAuth2实现RESTful服务安全认证 　　 这篇教程是展示如何设置一个OAuth2服务来保护REST资源. 源代码下载github. 你能下载这个源码就开始编写一个被OAuth方法保护的服务。该源码包含功能： * 用户注册和登录 * Email验证 * Password 丢失 采取的技术有以下： * OAuth2 Protoc
从零开始的Spring Security Oauth2（一）
小王的博客
07-09 4万+
使用配置 1.简易的分为三个步骤 配置资源服务器 配置认证服务器 配置spring security 2.oauth2根据使用场景不同，分成了4种模式 授权码模式（authorization code） 简化模式（implicit） 密码模式（resource owner password credentials） 客户端模式（c...
（一）、Spring Security OAuth2 五种授权方式介绍
qq_30062125的博客
01-31 6547
1、简介 OAuth 2.0定义了五种授权方式。 authorization_code：授权码类型，授权系统针对登录用户下发code，应用系统拿着code去授权系统换取token。 implicit：隐式授权类型。authorization_code的简化类型，授权系统针对登录系统直接下发token，302 跳转到应用系统url。 password：资源所有者（即用户）密码类型。应用系统采集...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值