熵增学院-Jacob-死灰复燃的Security

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

基础使用

与OAuth2.x的集成

1. Security的基础使用

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

1.1 SpringBoot中Security的默认配置

我们创建一个SpringBoot项目,然后引入spring-security,pom中的依赖如下所示:

<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>

然后我们添加一个测试的接口,如下所示:

@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);

    }

}

我们启动,就会发现在日志里,他给我们生成了这样的一段内容:

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官方说不再提供认证服务器,但是之前的仍然是可以使用的,只是在将来会被移除.