美文网首页springbootspring 整合使用个人学习
Spring Security实现分布式认证授权

Spring Security实现分布式认证授权

作者: Doooook | 来源:发表于2020-12-21 21:22 被阅读0次

    一、搭建注册中心

    1.1 需求分析

    回顾技术方案如下:

    分布式系统认证技术方案

    1、UAA认证服务负责认证授权。
    2、所有请求经过网关到达微服务。
    3、网关负责鉴权客户端以及请求转发。
    4、网关将token解析后传递给微服务,微服务进行授权。

    1.2 注册中心

    所有的微服务的请求都经过网关,网关从认证中心读取微服务的地址,将请求转发至微服务,注册中心采用Eureka。

    1、创建maven工程,工程结构如下:

    注册中心工程结构

    2、pom依赖如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.pengjs.book.admin.distributed.security</groupId>
            <artifactId>distributed-security</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
    
        <groupId>com.pengjs.book.admin.distributed.security.discovery</groupId>
        <artifactId>distributed-security-discovery</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>distributed-security-discovery</name>
        <description>distributed-security-discovery</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    2、配置文件application.yml

    spring:
      application:
        name: distributed-discovery
    
    server:
      port: 53000
    eureka:
      server:
        # 关闭服务自我保护,客户端心跳检测15分钟内错误达到80%的服务会开启保护,导致别人还认为是好用的服务
        enable-self-preservation: false
        # 清理间隔(单位毫秒,默认60*1000),5秒将客户端剔除的服务在服务注册中心列表中剔除
        eviction-interval-timer-in-ms: 10000
        # eureka是CAP理论基于AP策略,为了保证一致性,关闭此切换CP,默认不关闭,false关闭
        shouldUseReadOnlyResponseCache: true
      client:
        register-with-eureka: false # false: 不作为一个客户端注册到注册中心
        fetch-registry: false # 为true时,可以启动,但是异常:cannot execute request on any known server
        instance-info-replication-interval-seconds: 10
        service-url:
          defaultZone: http://localhost:${server.port}/eureka/
      instance:
        hostname: ${spring.cloud.client.ip-address}
        prefer-ip-address: true
        instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance-id:${server.port}}
    

    3、注册中心启动类

    @SpringBootApplication
    @EnableEurekaServer
    public class DistributedSecurityDiscoveryApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DistributedSecurityDiscoveryApplication.class, args);
        }
    
    }
    

    二、搭建网关工程

    2.1 角色分析

    网关整合OAuth2.0有两种思路,一种是认证服务器生成jwt令牌,所有请求统一在网关层验证,判断权限等操作;另外一种是由资源服务器处理,网关只做请求转发。

    我们选用第一种,把API网关作为OAuth2.0的资源服务器角色,实现接入客户端权限拦截、令牌解析并转发当前登录用户信息(jsonToken)给微服务,这样下游微服务就不需要关心令牌格式解析以及OAuth2.0相关机制了。

    API网关在认证授权体系里主要负责两件事:
    (1)作为OAuth2.0的资源服务器角色,实现接入方权限拦截。
    (2)令牌解析并转发当前登录用户信息(明文token)给微服务。

    微服务拿到明文token(明文token中包含登录用户的身份和权限信息)后也需要做两件事:
    (1)用户授权拦截(看当前用户是否有权限访问资源)。
    (2)将用户信息存储进当前线程上下文(有利于后续业务逻辑随时获取当前用户信息)。

    2.2 创建工程

    网关工程结构如下:

    网关工程结构

    1、pom依赖

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>com.pengjs.book.admin.distributed.security</groupId>
            <artifactId>distributed-security</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </parent>
        <groupId>com.pengjs.book.admin.distributed.security.gateway</groupId>
        <artifactId>distributed-security-gateway</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>distributed-security-gateway</name>
        <description>distributed-security-gateway</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
            <dependency>
                <groupId>com.netflix.hystrix</groupId>
                <artifactId>hystrix-javanica</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.retry</groupId>
                <artifactId>spring-retry</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-security</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-oauth2</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-jwt</artifactId>
            </dependency>
            <dependency>
                <groupId>javax.interceptor</groupId>
                <artifactId>javax.interceptor-api</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    2、配置文件application.yml

    spring:
      application:
        name: gateway-server
      main:
        allow-bean-definition-overriding: true
    
    server:
      port: 53010
    
    logging:
      level:
        root: info
        org:
          springframework: info
    
    zuul:
      retryable: true
      ignored-services: "*"
      add-host-header: true
      sensitive-headers: "*"
      routes:
        uaa-service:
          stripPrefix: false
          path: /uaa/**
        order-service:
          stripPrefix: false
          path: /order/**
    
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:53000/eureka/
      instance:
        preferIpAddress: true
        instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${spring.application.instance-id:${server.port}}
    
    management:
      endpoints:
        web:
          exposure:
            include: refresh,health,info,env
    feign:
      hystrix:
        enabled: false
      compression:
        request:
          enabled: true
          mime-types[0]: text/xml
          mime-types[1]: application/xml
          mime-types[2]: application/json
          min-request-size: 2048
        response:
          enabled: true
    

    统一认证服务(UAA)与统一订单服务都是网关下微服务,需要在网关上新增路由配置:

    zuul:
      retryable: true
      ignored-services: "*"
      add-host-header: true
      sensitive-headers: "*"
      routes:
        uaa-service:
          stripPrefix: false
          path: /uaa/**
        order-service:
          stripPrefix: false
          path: /order/**
    

    上面配置了网关接收的请求url若符合/order/**表达式,则将被转发到order-service(统一订单服务)中。

    3、启动类

    @SpringBootApplication
    @EnableZuulProxy
    @EnableDiscoveryClient
    public class DistributedSecurityGatewayApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DistributedSecurityGatewayApplication.class, args);
        }
    
    }
    

    三、网关资源服务配置

    3.1 配置资源服务

    ResourceServerConfig中定义资源服务资源,主要配置的内容就是定义一些匹配规则,描述某个接入客户端需要什么样的权限才能访问某个微服务:

    @Configuration
    public class ResourceServerConfig {
    
        /**
         * 资源列表,与服务端的resourceIds一致
         */
        private static final String RESOURCE_ID = "res1";
    
        /**
         * 从TokenConfig中注入tokenStore
         */
        @Autowired
        private TokenStore tokenStore;
    
        /**
         * uaa资源服务配置
         */
        @Configuration
        @EnableResourceServer
        public class UaaServerConfig extends ResourceServerConfigurerAdapter {
    
            @Override
            public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
                resources.tokenStore(tokenStore).resourceId(RESOURCE_ID)
                        .stateless(true);
            }
    
            @Override
            public void configure(HttpSecurity http) throws Exception {
                // uaa认证全部放行
                http.authorizeRequests()
                        .antMatchers("/uaa/**").permitAll();
            }
        }
    
        /**
         * order资源服务配置
         */
        @Configuration
        @EnableResourceServer
        public class OrderServerConfig extends ResourceServerConfigurerAdapter {
    
            @Override
            public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
                resources.tokenStore(tokenStore).resourceId(RESOURCE_ID)
                        .stateless(true);
            }
    
            @Override
            public void configure(HttpSecurity http) throws Exception {
                // order需要有ROLE_API的scope
                http.authorizeRequests()
                        .antMatchers("/order/**")
                        .access("#oauth2.hasScope('ROLE_API')");
            }
    
        }
    
        // 配置其他资源服务。。。
    
    }
    

    3.2 安全配置

    /**
     * 安全访问控制
     */
    @Configuration
    @EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    
        /**
         * 安全拦截机制(最重要)
         * @param http
         * @throws Exception
         */
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            // 网关:所有的请求都放行,只在resource config中拦截
            http.authorizeRequests()
                    .antMatchers("/**").permitAll()
                    .and().csrf().disable();
        }
    }
    

    四、转发明文token给微服务

    通过Zuul过滤器的方式实现,目的是让上下游微服务能够很方便的获取到当前的登录用户信息(明文token)

    (1)实现Zuul前置过滤器,完成当前登录用户信息提取,并放入转发到微服务的request中

    /**
     * token传递拦截
     */
    public class AuthFilter extends ZuulFilter {
    
        @Override
        public String filterType() {
            // 请求之前进行拦截
            return "pre";
        }
    
        @Override
        public int filterOrder() {
            // 最优先,数值越小越优先
            return 0;
        }
    
        @Override
        public boolean shouldFilter() {
            return true;
        }
    
        @Override
        public Object run() throws ZuulException {
            // 4. 转发给具体的微服务
            RequestContext context = RequestContext.getCurrentContext();
            // 1. 从安全的上下文中获取当前用户对象
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            // 无token直接访问网关内资源的情况,目前只有uaa服务直接暴露
            if (!(authentication instanceof OAuth2Authentication)) {
                // 不解析
                return null;
            }
            OAuth2Authentication oAuth2Authentication = (OAuth2Authentication) authentication;
            Authentication userAuthentication = oAuth2Authentication.getUserAuthentication();
            // 2. 获取当前用户身份信息
            String principals = userAuthentication.getName();
    
            // 3. 获取当前用户权限信息
            List<String> authorities = new ArrayList<>();
            userAuthentication.getAuthorities().forEach(s -> authorities.add(((GrantedAuthority) s).getAuthority()));
            OAuth2Request oAuth2Request = oAuth2Authentication.getOAuth2Request();
            Map<String, String> requestParameters = oAuth2Request.getRequestParameters();
    
            // 4. 把身份信息和权限信息中,加入到http的header中
            // 保留原本的基本信息
            Map<String, Object> jsonToken = new HashMap<>(requestParameters);
            if (userAuthentication != null) {
                jsonToken.put("principal", principals);
                jsonToken.put("authorities", authorities);
            }
            // 5. 组装明文token,转发给微服务。放入header,名称json-token
            context.addZuulRequestHeader("json-token", EncryptUtil.encodeUTF8StringBase64(JSON.toJSONString(jsonToken)));
            return null;
        }
    }
    

    (2)将Filter纳入到Spring容器
    配置AuthFilter

    @Configuration
    public class ZuulConfig {
    
        @Bean
        public AuthFilter preFilter() {
            return new AuthFilter();
        }
    
        @Bean
        public FilterRegistrationBean corsFilter() {
            final UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
            final CorsConfiguration config = new CorsConfiguration();
            config.setAllowCredentials(true);
            config.addAllowedOrigin("*");
            config.addAllowedHeader("*");
            config.addAllowedMethod("*");
            config.setMaxAge(18000L);
            source.registerCorsConfiguration("/**", config);
            CorsFilter corsFilter = new CorsFilter(source);
            FilterRegistrationBean bean = new FilterRegistrationBean(corsFilter);
            bean.setOrder(Ordered.HIGHEST_PRECEDENCE);
            return bean;
        }
    
    }
    

    五、微服务解析令牌并鉴权

    当微服务收到明文token后,该怎么鉴权拦截呢?自己实现一个Filter?自己解析明文token,自己定义一套资源访问策略?
    能不能适配Spring Security呢,是不是突然想起了前面我们实现的Spring Security基于token认证的例子。咱们还是拿统一订单服务作为网关下游微服务,对它进行改造,增加微服务用户鉴权拦截功能。

    (1)增加测试资源
    OrderController增加以下endpoint:

    @RestController
    public class OrderController {
    
        /**
         * 流程:当携带token访问这个资源的时候,会通过远程的service去请求地址
         * http://localhost:53020/uaa/oauth/check_token校验token是否合法
         * @return
         */
        @GetMapping(value = "/r1")
        // 拥有p1权限方可访问此URL
        @PreAuthorize("hasAnyAuthority('p1')")
        public String r1() {
            // 通过spring security api获取当前登录用户
            UserDto userDto = (UserDto) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
            // String username = (String) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
            // return username + "访问资源1";
            // return userDto.getUsername() + "访问资源1";
            return JSON.toJSONString(userDto) + "访问资源1";
        }
    
        @GetMapping(value = "/r2")
        // 拥有p2权限方可访问此URL
        @PreAuthorize("hasAnyAuthority('p2')")
        public String r2() {
            UserDto userDto = (UserDto) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
            // return userDto.getUsername() + "访问资源2";
            return JSON.toJSONString(userDto) + "访问资源2";
        }
    
    }
    

    (2)Spring Security配置
    开启方法保护,并增加Spring配置策略,除了/login方法不受保护(统一认证要调用),其他的资源全部需要认证才能访问。

    @Configuration
    @EnableResourceServer
    // 或者是单独配置WebSecurityConfig也可以
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    
        /**
         * 资源列表,与服务端的resourceIds一致
         */
        private static final String RESOURCE_ID = "res1";
    
        /**
         * 从TokenConfig中注入tokenStore
         */
        @Autowired
        private TokenStore tokenStore;
    
        @Override
        public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
            // 资源id
            resources.resourceId(RESOURCE_ID)
                    // 验证令牌的服务
                    // .tokenServices(tokenService())
                    // 不再使用验证令牌服务,让其自己验证
                    .tokenStore(tokenStore)
                    .stateless(true);
        }
    
        /**
         * 资源访问策略
         * @param http
         * @throws Exception
         */
        @Override
        public void configure(HttpSecurity http) throws Exception {
            http.authorizeRequests()
                    .antMatchers("/**")
                    // .access("#oauth2.hasScope('all')") // 所有的请求都必须有scope=all,跟服务端一致
                    .access("#oauth2.hasScope('ROLE_ADMIN')") // 所有的请求都必须有scope=ROLE_ADMIN,跟服务端一致
                    .and().csrf().disable() // 关闭CSRF
                    // 基于token的方式,session就不用再记录了
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        }
    
    }
    

    综合以上配置,共定义了三个资源,拥有p1权限才可以访问r1资源,拥有p2权限才可以访问r2资源。

    (3)定义Filter拦截token,并形成Spring Security的Authentication对象

    @Component
    public class TokenAuthenticationFilter extends OncePerRequestFilter {
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
            String token = request.getHeader("json-token");
            if (null != token) {
                // 1. 解析token
                // 解码
                String json = EncryptUtil.decodeUTF8StringBase64(token);
                // 将token转成json对象
                JSONObject userJson = JSON.parseObject(json);
                // UserDto user = new UserDto();
                // // 用户身份信息
                // user.setUsername(userJson.getString("principal"));
                // uaa那边存的是整个用户的信息,这里就可以直接转为UserDto
                UserDto user = JSON.parseObject(userJson.getString("principal"), UserDto.class);
                // 用户权限
                JSONArray authoritiesArray = userJson.getJSONArray("authorities");
                String[] authorities = authoritiesArray.toArray(new String[authoritiesArray.size()]);
    
                // 2. 新建并填充authentication(身份信息和权限)
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(user,
                        null, AuthorityUtils.createAuthorityList(authorities));
                // 设置details
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
    
                // 3. 将authentication保存到安全上下文中
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
            // 过滤器继续往前走
            filterChain.doFilter(request, response);
        }
    }
    

    经过上边的过滤器,资源服务中就可以方便的获取到用户的身份信息:

    UserDto userDto = (UserDto) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
    

    六、集成测试

    本案例测试过程描述:
    1、采用OAuth2.0的密码模式从UAA中获取token
    2、使用该token通过网关访问订单服务的测试资源

    (1)通过网关访问UAA的授权获取令牌,获取token,注意网关端口是53010
    http://127.0.0.1:53010/uaa/oauth/token

    通过网关访问UAA的授权获取令牌

    (2)通过网关UAA校验token
    http://127.0.0.1:53010/uaa/oauth/check_token

    通过网关UAA校验token

    (3)带上token访问资源
    http://localhost:53010/order/r1

    带上token访问资源

    七、扩展用户信息

    7.1 需求分析

    目前jwt令牌存储了用户身份信息、权限信息,网关将token明文转发给微服务使用,目前用户身份信息锦包含了用户的账户,微服务还需要用户的ID、手机号等重要信息。

    在认证阶段DaoAuthenticationProvider会调用UserDetailsService查询用户信息,这里是可以获取到齐全的用户信息的。由于JWT令牌中用户身份信息来源于UserDetailsUserDetails中仅定义了username为用户的身份信息,这里有两个思路,第一是可以扩展UserDetails,使之包含更多的自定义属性,第二也可以扩展username的内容,比如存入json数据内容作为username的内容。相比较而言,方案二比较简单还不用破坏UserDetails的结构,我们采用方案二。

    7.2 修改UserDetailsService

    从数据库查询到user,将整体的user转成json存入到UserDetails对象中。

        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            // 将来连接数据库根据账号查询用户信息
            // 登录账号
            System.out.println("username=" + username);
            UserDto userByUsername = userDao.getUserByUsername(username);
            if (null == userByUsername) {
                // 如果用户查询不到,返回null,返回给provider,由provider来抛异常
                return null;
            }
            // 根据用户的ID查询用户的权限
            List<String> permissions = userDao.findPermissionByUserId(userByUsername.getId());
            String[] permissionArray = new String[permissions.size()];
            permissions.toArray(permissionArray);
            // 将userByUsername转换为json,整体存入到userDetails
            String principal = JSON.toJSONString(userByUsername);
            UserDetails userDetails = User.withUsername(principal).password(userByUsername.getPassword())
                    .authorities(permissionArray).build();
            return userDetails;
        }
    

    7.3 修改资源服务器过滤器

    资源服务中的过滤器负责从Header中解析json-token,从中即可拿到网关放入的用户身份信息,代码如下:

    @Component
    public class TokenAuthenticationFilter extends OncePerRequestFilter {
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
            String token = request.getHeader("json-token");
            if (null != token) {
                // 1. 解析token
                // 解码
                String json = EncryptUtil.decodeUTF8StringBase64(token);
                // 将token转成json对象
                JSONObject userJson = JSON.parseObject(json);
                // UserDto user = new UserDto();
                // // 用户身份信息
                // user.setUsername(userJson.getString("principal"));
                // uaa那边存的是整个用户的信息,这里就可以直接转为UserDto
                UserDto user = JSON.parseObject(userJson.getString("principal"), UserDto.class);
                // 用户权限
                JSONArray authoritiesArray = userJson.getJSONArray("authorities");
                String[] authorities = authoritiesArray.toArray(new String[authoritiesArray.size()]);
    
                // 2. 新建并填充authentication(身份信息和权限)
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(user,
                        null, AuthorityUtils.createAuthorityList(authorities));
                // 设置details
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
    
                // 3. 将authentication保存到安全上下文中
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
            // 过滤器继续往前走
            filterChain.doFilter(request, response);
        }
    }
    

    八、总结

    重点回顾:

    什么是认证、授权、会话。
    Java Servlet为支持http会话做了哪些是儿。
    基于Session认证机制的运作流程。
    基于token认证机制的运作流程。
    理解Spring Security的工作原理,Spring Security结构总览,认证流程和授权,中间涉及到哪些组件,这些组件分别处理什么,如何自定义这些组件满足个性需求。
    OAuth2.0认证的四种模式?他们的大体流程是什么?
    Spring Cloud Security OAuth2.0包括哪些组件?自责?
    分布式系统认证需要解决的问题?

    相关文章

      网友评论

        本文标题:Spring Security实现分布式认证授权

        本文链接:https://www.haomeiwen.com/subject/dbbknktx.html