死灰复燃的Security

时间 2019-11-08

标签死灰复燃 security 繁體版

原文原文链接

一直以来,Spring系列给人的感受都是快速,简洁,好理解,易操做.但Security是一个特例,这个框架相比而言,首先就是复杂,其次是灵活性也不够.好在因而Spring出的,所以与Spring配合比较好.而且在Spring的大力推广和支持下,它仍然屹立在这里.固然它也有本身的优势,好比他与LDAP还有Oauth这些结构的集成,处理的也不错.咱们今天主要从如下几个方面来分享关于Security的知识:java

基础使用web
与OAuth2.x的集成spring

1. Security的基础使用

在web应用的设计中,权限是一个绕不开的话题.而在web权限设计中,RBAC是最流行的设计思路了.(除了RABC,还有像Linux中的ACL权限设计).在RBAC这种设计思路的引导下,咱们能够有不少种实现方式,从最简单的一个过滤器开始,到Security或Shiro,甚至和其余的第三方进行集成,都是没有问题的.今天咱们就先来看看Spring Security怎么使用.数据库

1.1 SpringBoot中Security的默认配置

咱们建立一个SpringBoot项目,而后引入spring-security,pom中的依赖以下所示:json

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

</dependencies>

而后咱们添加一个测试的接口,以下所示:api

@RestController
@RequestMapping("users/")
public class UserInfoController {

    @GetMapping("hello")
    public String hello(){
        return "HelloWorld";
    }
}

最后是咱们的启动类,其实启动类并无任何改变:浏览器

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

咱们启动,就会发如今日志里,他给咱们生成了这样的一段内容:tomcat

2018-11-13 13:42:15.307  INFO 13084 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2018-11-13 13:42:15.620  INFO 13084 --- [           main] .s.s.UserDetailsServiceAutoConfiguration : 

Using generated security password: b74fd02a-0ad2-40ec-b6cd-3f2edfa015c1

2018-11-13 13:42:15.756  INFO 13084 --- [           main] o.s.s.web.DefaultSecurityFilterChain     : Creating filter chain: any request, [org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@7f13811b, org.springframework.security.web.context.SecurityContextPersistenceFilter@22d7fd41, org.springframework.security.web.header.HeaderWriterFilter@4fc165f6, org.springframework.security.web.csrf.CsrfFilter@65514add, org.springframework.security.web.authentication.logout.LogoutFilter@3bc69ce9, org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@1ca610a0, org.springframework.security.web.authentication.ui.DefaultLoginPageGeneratingFilter@79980d8d, org.springframework.security.web.authentication.ui.DefaultLogoutPageGeneratingFilter@59fc6d05, org.springframework.security.web.authentication.www.BasicAuthenticationFilter@1775c4e7, org.springframework.security.web.savedrequest.RequestCacheAwareFilter@19fd43da, org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@2785db06, org.springframework.security.web.authentication.AnonymousAuthenticationFilter@78307a56, org.springframework.security.web.session.SessionManagementFilter@5a7df831, org.springframework.security.web.access.ExceptionTranslationFilter@750f64fe, org.springframework.security.web.access.intercept.FilterSecurityInterceptor@1f9d4b0e]
2018-11-13 13:42:15.878  INFO 13084 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2018-11-13 13:42:15.885  INFO 13084 --- [           main] top.lianmengtu.security.Application      : Started Application in 4.07 seconds (JVM running for 4.73)

这里给咱们生成了一个密码,它是作什么的呢?咱们如今来访问咱们的测试接口,而后就会有一个登陆窗口让你登陆.这是怎么回事儿呢?安全

http://localhost:8080/users/hello

这是由于当咱们添加了security模块后,SpringBoot默认为咱们启用了security的拦截,而且若是咱们没有配置默认的用户名密码的话,他就给咱们生成了一个默认的用户名user,而密码则就是我在上面的日志中.当咱们完成登陆后,咱们就能够正常使用咱们的接口了.服务器

1.2 SpringBoot中SpringSecurity的简易配置

如今咱们来对SpringSecurity进行自定义用户名密码配置,咱们建立一个application.yml,而后设置以下:

spring:
  security:
    user:
      name: zhangsan
      password: zhangsan123

而后重启咱们的应用,咱们会发现,SpringBoot不在给咱们提供默认密码了,而当咱们访问咱们的接口的时候,咱们可使用新配置的zhangsan和zhangsan123进行登陆.这样的配置主要是由SpringSecurity中的WebSecurityConfig来实现的,所以咱们也能够将用户名和密码写到那里面,这里就不给你们演示了.

1.3 Security的一些自定义实现

但这种方式仍然不够灵活,一般咱们都会考虑由咱们本身来定义用户信息以及权限信息,其实用户信息与权限信息也是权限框架关注的两个主要点,这两点也被称为认证及受权.所谓认证,通俗点来说，就是登陆校验,肯定访问用户的凭据是否正确.所谓受权就是该合法用户是否拥有对应的权限.

这是咱们就须要问一个问题,Spring Security如何处理url与权限的匹配,也就是说Spring Security他如何知道哪些url是能够被公开访问,哪些url登陆后能够访问,哪些还须要某些固定的权限才能够访问?

1.3.1 用户认证

这些问题的答案就在WebSecurityConfigurerAdapter里,在这个Adapter里有两个configure函数,一个是configure(HttpSecurity http),主要做用是配置哪些url能够直接放过,哪些是须要登陆才能访问的,另一个是configure(AuthenticationManagerBuilder auth),这个函数主要是用来作用户认证的,咱们如今先来写url的映射与拦截.以下所示:

package top.lianmengtu.security.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;


@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().anyRequest().authenticated();
    }
    
}

此时若是咱们访问咱们的接口,就会出现403的场景,以下所示,有没有很熟悉的感受:

Whitelabel Error Page
This application has no explicit mapping for /error, so you are seeing this as a fallback.
Wed Nov 14 17:58:11 CST 2018
There was an unexpected error (type=Forbidden, status=403).
Access Denied

只是这样还不行,由于咱们但愿可以放过一些接口,好比登陆,而后其余的但愿让用户登陆以后可以进行访问.咱们先来改造一下咱们的url处理接口configure(HttpSecurity http).

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests().antMatchers("/auth/login").permitAll()//放过登陆接口
            .and().formLogin().loginProcessingUrl("/auth/login")//指定登陆处理接口
            .successHandler(loginSuccessHandler).failureHandler(loginFailHandler)//指定登陆成功与登陆失败的处理器
            .and().authorizeRequests().anyRequest().authenticated()//对其余接口的权限限制为登陆后才能访问
            .and().csrf().disable();//禁用csrf拦截,若是使用restclient和postman测试,建议禁掉,要否则会出错
}

此时就须要用到configure(AuthenticationManagerBuilder auth)这个函数了.咱们能够透过这个函数注入一个UsersDetailsService,而后在UserDetailsService里来进行准确的处理.此时完成的SecurityConfig以下所示:

package top.lianmengtu.security.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import top.lianmengtu.security.handler.LoginFailHandler;
import top.lianmengtu.security.handler.LoginSuccessHandler;

/**
 * @program test_security
 * @description
 * @author: Jacob.Li
 * @create: 2018-11-13 16:01
 **/
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private MyUserDetailServiceImpl userDetailService;

    @Autowired
    private LoginSuccessHandler loginSuccessHandler;

    @Autowired
    private LoginFailHandler loginFailHandler;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().antMatchers("/auth/login").permitAll()//放过登陆接口
                .and().formLogin().loginProcessingUrl("/auth/login")//指定登陆处理接口
                .successHandler(loginSuccessHandler).failureHandler(loginFailHandler)//指定登陆成功与登陆失败的处理器
                .and().authorizeRequests().anyRequest().authenticated()//对其余接口的权限限制为登陆后才能访问
                .and().csrf().disable();//禁用csrf拦截,若是使用restclient和postman测试,建议禁掉,要否则会出错
    }

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

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

UserDetailsService的实现以下:

package top.lianmengtu.security.config;

import org.springframework.beans.factory.annotation.Autowired;
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.stereotype.Component;
import top.lianmengtu.security.users.model.UserInfo;
import top.lianmengtu.security.users.service.IUserInfoService;


@Component
public class MyUserDetailServiceImpl implements UserDetailsService {

    @Autowired
    private IUserInfoService userInfoService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        System.out.println("----Hello");
        System.out.println("name:"+username);
        if(!username.equals("zhangsan")){
            throw new UsernameNotFoundException("用户名不对");
        }
        UserInfo userInfo=userInfoService.loadByNickName(username);
        return User.withUsername(username).password(userInfo.getPassword()).roles("ADMIN").build();
    }
}

UserDetailsService里有一个userInfoService,这个是咱们临时自定义的一个接口,咱们能够在这个接口里接入数据库,这里只是一个简单的实现,以下所示:

package top.lianmengtu.security.users.service;

import top.lianmengtu.security.users.model.UserInfo;

public interface IUserInfoService {
    public UserInfo loadByNickName(String nickName);
}


package top.lianmengtu.security.users.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import top.lianmengtu.security.users.model.UserInfo;
import top.lianmengtu.security.users.service.IUserInfoService;


@Service
public class UserInfoService implements IUserInfoService {

    @Autowired
    PasswordEncoder passwordEncoder;

    @Override
    public UserInfo loadByNickName(String nickName) {
        UserInfo userInfo=new UserInfo();
        userInfo.setNickName("zhangsan");
        userInfo.setPassword(passwordEncoder.encode("123456"));
        return userInfo;
    }
}

那登陆成功或失败的处理逻辑呢?咱们在SecurityConfig里添加了LoginSuccessHandler和LoginFailHandler,也只是一个简单的实现,这里仅供参考:

package top.lianmengtu.security.handler;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @program test_security
 * @description
 * @author: Jacob.Li
 * @create: 2018-11-14 16:41
 **/
@Component
public class LoginFailHandler implements AuthenticationFailureHandler {
    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        ObjectMapper objectMapper=new ObjectMapper();
        httpServletResponse.setContentType("application/json;charset=UTF-8");
        Map<String,String> result=new HashMap<>();
        result.put("code","-1");
        result.put("msg","用户名/密码错误,请从新登陆");
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(result));
    }
}

package top.lianmengtu.security.handler;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @program test_security
 * @description
 * @author: Jacob.Li
 * @create: 2018-11-14 14:01
 **/
@Component
public class LoginSuccessHandler implements AuthenticationSuccessHandler {

    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        ObjectMapper objectMapper=new ObjectMapper();
        httpServletResponse.setContentType("application/json;charset=UTF-8"); // 响应类型
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString("登陆验证成功"));
        System.out.println("-----login successful:"+objectMapper.writeValueAsString(authentication.getDetails()));
    }
}

而后咱们启用restclient进行测试,就能够获得咱们预期的结果了.

1.3.2 用户受权

如今咱们完成了用户的认证,那受权如何处理呢?其实在咱们刚刚所展现出来的UserDetailsService里,有一个roles,这里描述的是用户的角色,咱们如今只须要作两件事就能够了.第一件就是获取当前请求的url及其须要的角色,第二件就是与当前用户的角色进行比较并做出放行或者拦阻的操做.

在SpringSecurity中,进行url拦截的是FilterInvocationSecurityMetadataSource,这里咱们自定义一个MyFilterInvocationSecurityMetadataSource,主要用于拿到当前url所须要的角色信息,并将这个url对应的角色信息传入到下一个组件AccessDecisionManager中而后与用户所拥有的角色进行比较,若是url没有找到或者url没有角色信息,这里添加了一个默认的登陆认证,也能够直接放行.代码以下所示:

package top.lianmengtu.security.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.access.SecurityConfig;
import org.springframework.security.web.FilterInvocation;
import org.springframework.security.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.stereotype.Component;
import top.lianmengtu.security.users.service.IAuthorityService;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;

/**
 * @program test_security
 * @description
 * @author: Jacob.Li
 * @create: 2018-11-15 09:37
 **/
@Component
public class MyFilterInvocationSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {

    @Autowired
    private IAuthorityService authorityService; //接入自定义的Service

    @Override
    public Collection<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
        String requestUrl=((FilterInvocation)object).getRequestUrl();
        System.out.println("----->MyFilterInvocationSecurityMetadataSource:拿到了url:"+requestUrl);
        if(requestUrl.equals("/auth/login")){ //登陆接口,直接放过
            return null;
        }
        List<String> roleList=authorityService.findRolesByUrl(requestUrl);
        if(roleList.size()>0){
            String[] roleArray=new String[roleList.size()];
            for (int i = 0; i < roleList.size(); i++) {
                roleArray[i]=roleList.get(i);
            }
            return SecurityConfig.createList(roleArray);
        }
        return SecurityConfig.createList("ROLE_LOGIN"); //其余接口设置为登陆放行,也能够像登陆接口同样直接放过
    }

    @Override
    public Collection<ConfigAttribute> getAllConfigAttributes() {
        return null;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return FilterInvocation.class.isAssignableFrom(clazz);
    }
}

在这个实现中咱们注入了咱们本身的AuthorityService,这里实现的比较简单,你们能够根据须要从本身的数据库里对数据进行查找,Service示例以下所示:

package top.lianmengtu.security.users.service;

import java.util.List;

public interface IAuthorityService {

    public List<String> findRolesByUrl(String url);

}

-------------------------------------------------------

package top.lianmengtu.security.users.service.impl;

import org.springframework.stereotype.Service;
import top.lianmengtu.security.users.service.IAuthorityService;

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


@Service
public class AuthorityServiceImpl implements IAuthorityService {

    @Override
    public List<String> findRolesByUrl(String url) {
        System.out.println("-----url:"+url);
        List<String> rolesList=new ArrayList<>();
        rolesList.add("ADMIN");
        rolesList.add("MANAGER");
        return rolesList;
    }
}

当FilterInvocationSecurityMetadataSource的操做完成以后,他会将这个角色列表传入到AccessDecisionManager中,在其中与登陆用户的角色进行比较,而后决定放过仍是拦截,自定义AccessDecisionManager代码以下所示:

package top.lianmengtu.security.config;

import org.springframework.security.access.AccessDecisionManager;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.access.ConfigAttribute;
import org.springframework.security.authentication.AnonymousAuthenticationToken;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.InsufficientAuthenticationException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.Iterator;

/**
 * @program test_security
 * @description
 * @author: Jacob.Li
 * @create: 2018-11-15 09:55
 **/
@Component
public class MyAccessDecisionManager implements AccessDecisionManager {

    @Override
    public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
        Iterator<ConfigAttribute> configAttributeIterator = configAttributes.iterator(); //获取上个组件中传过来的角色集合
        while (configAttributeIterator.hasNext()){
            ConfigAttribute configAttribute=configAttributeIterator.next();
            String role=configAttribute.getAttribute();
            if("ROLE_LOGIN".equals(role)){ //判断是否须要具有登陆权限
                if(authentication instanceof AnonymousAuthenticationToken){
                    throw new BadCredentialsException("未登录");
                }
                return;
            }
            Collection<? extends GrantedAuthority> currentUserAuthorities=authentication.getAuthorities();//获取用户的角色信息
            for(GrantedAuthority grantedAuthority: currentUserAuthorities){
                if(grantedAuthority.getAuthority().equals(role)){//若是用户的角色信息包含了当前连接所须要的角色,则放行
                    return;
                }
            }
        }
        throw new AccessDeniedException("权限不足");
    }

    @Override
    public boolean supports(ConfigAttribute attribute) {
        return true;
    }

    @Override
    public boolean supports(Class<?> clazz) {
        return true;
    }
}

如今咱们已经作好了用户受权的操做,如今是以异常的形式来展示结果,咱们能够对结果进行处理,将结果转换为咱们指望的json形式而后返回给前台,这是由AccessDeniedHandler来处理的,自定义AccessDeniedHandler的代码以下所示:

package top.lianmengtu.security.handler;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

/**
 * @program test_security
 * @description
 * @author: Jacob.Li
 * @create: 2018-11-15 10:06
 **/
@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
        httpServletResponse.setStatus(HttpServletResponse.SC_FORBIDDEN);
        httpServletResponse.setCharacterEncoding("UTF-8");
        PrintWriter out = httpServletResponse.getWriter();
        Map<String,String> result=new HashMap<>();
        result.put("code","-1");
        result.put("msg","权限不足");
        ObjectMapper objectMapper=new ObjectMapper();
        String resultString=objectMapper.writeValueAsString(result);
        out.write(resultString);
        out.flush();
        out.close();
    }
}

截止到如今,咱们的准备工做已经作完了,如今咱们来进行最后一步整合的操做,咱们修改一下咱们自定义的那个WebSecurityConfigurerAdapter组件中的configure(HttpSecurity http)函数,来使咱们的处理真正生效,代码以下所示:

package top.lianmengtu.security.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.security.config.annotation.ObjectPostProcessor;
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.web.access.intercept.FilterInvocationSecurityMetadataSource;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
import top.lianmengtu.security.handler.LoginFailHandler;
import top.lianmengtu.security.handler.LoginSuccessHandler;
import top.lianmengtu.security.handler.MyAccessDeniedHandler;

/**
 * @program test_security
 * @description
 * @author: Jacob.Li
 * @create: 2018-11-13 16:01
 **/
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private MyUserDetailServiceImpl userDetailService;

    @Autowired
    private LoginSuccessHandler loginSuccessHandler;

    @Autowired
    private LoginFailHandler loginFailHandler;

    @Autowired
    private MyAccessDeniedHandler myAccessDeniedHandler;

    @Autowired
    private MyFilterInvocationSecurityMetadataSource myFilterInvocationSecurityMetadataSource;

    @Autowired
    private MyAccessDecisionManager myAccessDecisionManager;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .withObjectPostProcessor(new ObjectPostProcessor<FilterSecurityInterceptor>() {//这里的ObjectPostProcessor能够彻底挪出去,像其余的handler同样
                    @Override
                    public <O extends FilterSecurityInterceptor> O postProcess(O object) {
                        object.setSecurityMetadataSource(myFilterInvocationSecurityMetadataSource);//配置咱们刚刚自定义好的FilterInvocationSecurityMetadataSource,来加载url所须要的角色
                        object.setAccessDecisionManager(myAccessDecisionManager);//配置咱们刚刚自定义好的AccessDecisionManager,来进行用户角色和url所需角色的对比
                        return object;
                    }
                })
                .antMatchers("/auth/login").permitAll()//放过登陆接口
                .and().formLogin().loginProcessingUrl("/auth/login")//指定登陆处理接口
                .successHandler(loginSuccessHandler).failureHandler(loginFailHandler)//指定登陆成功与登陆失败的处理器
                .and().authorizeRequests().anyRequest().authenticated()//对其余接口的权限限制为登陆后才能访问
                .and().csrf().disable()
                .exceptionHandling().accessDeniedHandler(myAccessDeniedHandler);//受权失败的处理
    }

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

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

好了,咱们的受权工做已经完成了,如今咱们能够从新启动咱们的项目,而后能够用restClient访问咱们的接口进行测试了.

2. OAuth2.0

咱们能够看到,基本受权使用Spring Security是比较复杂的,咱们彻底能够只用一个Filter加几个自定义注解完成这项工做,这也是不少人在开发一个单体项目时所作的一件事儿.这里之因此提到单体项目是由于在多个项目之间,若是咱们想要进行权限限制,就不能在这么作了,尤为是咱们将咱们的部分资源公开提供给其余人使用的时候,这样的一刀切权限可能就不太适合.

当多个应用之间共享权限的时候,咱们每每会关注两个问题,第一是权限的安全性,第二,是权限的粒度.什么意思呢?好比说咱们提供了一个资源管理服务器,里面有照片、视频、文档,而后你们能够往咱们的资源服务器上传本身的资源.后来用户又在另一个网站上须要上传本身的头像,但他不想用默认的头像,想用本身在资源服务器上的照片,那么此时,若是他将本身在资源服务器上的用户名和密码告诉那个网站的话,首先是不安全,那个网站能够随时访问他的资源服务器,其次是权限太大,第三方网站不只仅能够访问他的照片,还可以访问他的视频和文档,这就很危险了.为了解决这类问题,OAuth就诞生了.他容许用户进行部分受权.他的原理很简单.

OAuth在资源服务器和第三方网站之间作了一个受权层,而后受权层负责针对客户端进行权限的限制,包括权限的范围,有效期,这样客户端由于没法直接访问资源服务器,从而保护了用户的资源.

那么他的运行流程呢,就是这样的:

用户打开客户端之后，客户端要求用户给予受权。
用户赞成给予客户端受权。
客户端使用上一步得到的受权，向认证服务器申请令牌。
认证服务器对客户端进行认证之后，确认无误，赞成发放令牌。
客户端使用令牌，向资源服务器申请获取资源。
资源服务器确认令牌无误，赞成向客户端开放资源。

2.1 OAuth2.0受权模式

在以上这6步中,最关键的一步就是2,用户如何才可以给客户端受权呢?OAuth2.0提供了四中受权方式,分别为:

受权码模式
简化模式
密码模式
客户端模式

2.1.1受权码模式

受权码模式（authorization code）是功能最完整、流程最严密的受权模式。它的特色就是经过客户端的后台服务器，与"服务提供商"的认证服务器进行互动。他的具体步骤以下:

用户访问客户端，后者将前者导向认证服务器。
用户选择是否给予客户端受权。
假设用户给予受权，认证服务器将用户导向客户端事先指定的"重定向URI"（redirection URI），同时附上一个受权码。
客户端收到受权码，附上早先的"重定向URI"，向认证服务器申请令牌。这一步是在客户端的后台的服务器上完成的，对用户不可见。
认证服务器核对了受权码和重定向URI，确认无误后，向客户端发送访问令牌（access token）和更新令牌（refresh token）。

2.1.2 简化模式

简化模式（implicit grant type）不经过第三方应用程序的服务器，直接在浏览器中向认证服务器申请令牌，跳过了"受权码"这个步骤，所以得名。全部步骤在浏览器中完成，令牌对访问者是可见的，且客户端不须要认证。步骤以下:

客户端将用户导向认证服务器。
用户决定是否给于客户端受权。
假设用户给予受权，认证服务器将用户导向客户端指定的"重定向URI"，并在URI的Hash部分包含了访问令牌。
浏览器向资源服务器发出请求，其中不包括上一步收到的Hash值。
资源服务器返回一个网页，其中包含的代码能够获取Hash值中的令牌。
浏览器执行上一步得到的脚本，提取出令牌。
浏览器将令牌发给客户端。

2.1.3 密码模式

密码模式（Resource Owner Password Credentials Grant）中，用户向客户端提供本身的用户名和密码。客户端使用这些信息，向"服务商提供商"索要受权。在这种模式中，用户必须把本身的密码给客户端，可是客户端不得储存密码。这一般用在用户对客户端高度信任的状况下，好比客户端是操做系统的一部分，或者由一个著名公司出品。而认证服务器只有在其余受权模式没法执行的状况下，才能考虑使用这种模式。步骤以下:

用户向客户端提供用户名和密码。
客户端将用户名和密码发给认证服务器，向后者请求令牌。
认证服务器确认无误后，向客户端提供访问令牌。

2.1.4 客户端模式

客户端模式（Client Credentials Grant）指客户端以本身的名义，而不是以用户的名义，向"服务提供商"进行认证。严格地说，客户端模式并不属于OAuth框架所要解决的问题。在这种模式中，用户直接向客户端注册，客户端以本身的名义要求"服务提供商"提供服务，其实不存在受权问题。步骤以下:

客户端向认证服务器进行身份认证，并要求一个访问令牌。
认证服务器确认无误后，向客户端提供访问令牌。

2.2 SpringBoot中的OAuth2.0

如今咱们知道OAuth受权主要由三部分构成,首先是客户端,而后是认证服务器,最后是咱们的资源服务器,以前SpringBoot一直将OAuth2.0认证放在了SpringSecurity下,但在SpringBoot2.0文档中,Spring官方说再也不提供认证服务器,可是以前的仍然是可使用的,只是在未来会被移除.

本文相关视频