SpringSecurity如何使用?

2021-01-21 10:34发布

9条回答
我的网名不再改
2楼 · 2021-01-21 16:30

Spring Security如何控制权限概要 Spring使用由Filter组成的Chain,来判断权限。如下图所示:Spring预定义了很多out-of-boxed filter供开发者直接使用。每个Filter一般情况下(有些Filter是abstract的),都和配置文件的一个元素(有的情况下可能是属性)对应。比如:AUTHENTICATION_PROCESSING_FILTER,对应配置文件里面的:http/form-login元素。 如果Spring提供的Filter不能满足系统的权限功能,开发者可以自定义Filter,然后把Filter放在某个Filter Chain的某个位置。可以替换掉原有Filter Chain的某个Filter,也可以放在某个Filter之前或者之后。 总之,Spring Security采用Filter Chain模式判断权限,Spring提供了一些Filter,也支持开发者自定义Filter。与WEB系统的集成 使用Java EE的Filter(非Spring的Filter)机制,将需要权限判断的url,“牵引”给Spring的Filter Chain即可。 一般情况下,将所有的url都引入Filter Chain。

Spring Security如何控制权限概要 Spring使用由Filter组成的Chain,来判断权限。如下图所示:Spring预定义了很多out-of-boxed filter供开发者直接使用。每个Filter一般情况下(有些Filter是abstract的),都和配置文件的一个元素(有的情况下可能是属性)对应。比如:AUTHENTICATION_PROCESSING_FILTER,对应配置文件里面的:http/form-login元素。 如果Spring提供的Filter不能满足系统的权限功能,开发者可以自定义Filter,然后把Filter放在某个Filter Chain的某个位置。可以替换掉原有Filter Chain的某个Filter,也可以放在某个Filter之前或者之后。 总之,Spring Security采用Filter Chain模式判断权限,Spring提供了一些Filter,也支持开发者自定义Filter。与WEB系统的集成 使用Java EE的Filter(非Spring的Filter)机制,将需要权限判断的url,“牵引”给Spring的Filter Chain即可。 一般情况下,将所有的url都引入Filter Chain。

哆啦公
4楼 · 2021-01-21 17:29

 Spring使用由Filter组成的Chain来判断权限。

freediandianer
5楼 · 2021-01-21 18:55

Spring Security如何控制权限概要 Spring使用由Filter组成的Chain,来判断权限。如下图所示:Spring预定义了很多out-of-boxed filter供开发者直接使用。每个Filter一般情况下(有些Filter是abstract的),都和配置文件的一个元素(有的情况下可能是属性)对应。比如:AUTHENTICATION_PROCESSING_FILTER,对应配置文件里面的:http/form-login元素。 如果Spring提供的Filter不能满足系统的权限功能,开发者可以自定义Filter,然后把Filter放在某个Filter Chain的某个位置。可以替换掉原有Filter Chain的某个Filter,也可以放在某个Filter之前或者之后。 总之,Spring Security采用Filter Chain模式判断权限,Spring提供了一些Filter,也支持开发者自定义Filter。与WEB系统的集成 使用Java EE的Filter(非Spring的Filter)机制,将需要权限判断的url,“牵引”给Spring的Filter Chain即可。 一般情况下,将所有的url都引入Filter Chain。

寂静的枫林
6楼 · 2021-01-22 11:47

Spring Security如何控制权限概要 Spring使用由Filter组成的Chain,来判断权限。如下图所示:Spring预定义了很多out-of-boxed filter供开发者直接使用。每个Filter一般情况下(有些Filter是abstract的),都和配置文件的一个元素(有的情况下可能是属性)对应。比如:AUTHENTICATION_PROCESSING_FILTER,对应配置文件里面的:http/form-login元素。 如果Spring提供的Filter不能满足系统的权限功能,开发者可以自定义Filter,然后把Filter放在某个Filter Chain的某个位置。可以替换掉原有Filter Chain的某个Filter,也可以放在某个Filter之前或者之后。 总之,Spring Security采用Filter Chain模式判断权限,Spring提供了一些Filter,也支持开发者自定义Filter。与WEB系统的集成 使用Java EE的Filter(非Spring的Filter)机制,将需要权限判断的url,“牵引”给Spring的Filter Chain即可。 一般情况下,将所有的url都引入Filter Chain。

十七
7楼 · 2021-01-22 14:34

step1:导入依赖坐标

org.springframework.security

spring-security-web

4.1.0.RELEASE


org.springframework.security

spring-security-config

4.1.0.RELEASE

    

    step2:在web.xml中配置过滤器

springSecurityFilterChain   

    org.springframework.web.filter.DelegatingFilterProxy 

  

        

  

springSecurityFilterChain  

/  

注意过滤器名字必须固定为:springSecurityFilterChain

        

     step3:创建spring 配置文件spring-security.xml       

default-target="true" authentication-failure-url="/login_error.html"/>

   

配置说明:

intercept-url 表示拦截页面 

security="none"  设置此资源不被拦截. 

*  表示的是该目录下的资源,只包括本级目录不包括下级目录

** 表示的是该目录以及该目录下所有级别子目录的资源

form-login  为开启表单登录

use-expressions 为是否使用使用 Spring 表达式语言( SpEL ),默认为true ,如果开启,则拦截的配置应该写成以下形式

ROLE_USER:必须验证具备该角色后才能访问,注意角色名称必须以ROLE_开头

csrf disabled="true"  关闭csrf ,如果不加会出现错误

default-target-url:指定了成功进行身份验证和授权后默认呈现给用户的页面。

authentication-failure-url:指定了身份验证失败时跳转到的页面

login-page:指定登录页面。


    step4:创建登录成功页面

        

    step5:创建登录页面

        登录提交地址/login 改地址由SpringSecurity生成,提交方法必须是POST


buzuofa100
8楼 · 2021-01-25 10:41

Spring Security如何控制权限概要 Spring使用由Filter组成的Chain,来判断权限。如下图所示:Spring预定义了很多out-of-boxed filter供开发者直接使用。每个Filter一般情况下(有些Filter是abstract的),都和配置文件的一个元素(有的情况下可能是属性)对应。比如:AUTHENTICATION_PROCESSING_FILTER,对应配置文件里面的:http/form-login元素。 如果Spring提供的Filter不能满足系统的权限功能,开发者可以自定义Filter,然后把Filter放在某个Filter Chain的某个位置。可以替换掉原有Filter Chain的某个Filter,也可以放在某个Filter之前或者之后。 总之,Spring Security采用Filter Chain模式判断权限,Spring提供了一些Filter,也支持开发者自定义Filter。与WEB系统的集成 使用Java EE的Filter(非Spring的Filter)机制,将需要权限判断的url,“牵引”给Spring的Filter Chain即可。 一般情况下,将所有的url都引入Filter Chain。

pipi雪
9楼 · 2021-04-27 10:07

1,什么是 Spring Security ?

  • Spring Security 是一个相对复杂的安全管理框架,功能比 Shiro 更加强大,权限控制细粒度更高,对 OAuth 2 的支持也更友好。

  • 由于 Spring Security 源自 Spring 家族,因此可以和 Spring 框架无缝整合,特别是 Spring Boot 中提供的自动化配置方案,可以让 Spring Security 的使用更加便捷。

2,安装配置

     org.springframework.boot     spring-boot-starter-security 

3、开始测试:

首先在项目添加一个简单的 /hello 接口:

复制代码

@RestController public class HelloController {     @GetMapping("/hello")     public String hello() {         return "欢迎访问 hangge.com";     } }

复制代码

接着启动项目,直接访问 /hello 接口则会自动跳转到登录页面(这个登录页面是由 Spring Security 提供的)

 

 

 (3)我们必须登录后才能访问 /hello 接口。默认用户名是 user,而登录密码则在每次启动项目时随机生成,我们可以在项目启动日志中找到。

 

 

 (4)登录后则会自动跳转到之前我访问的 /hello 接口:

4,配置用户名和密码

    如果对默认的用户名和密码不满意,可以在 application.properties 中配置默认的用户名、密码和角色。这样项目启动后就不会随机生成密码了,而是使用我们配置的用户、密码,并且登录后还具有一个 admin 角色(关于角色的用法再后面的文章会相信介绍)。

spring.security.user.name=hangge spring.security.user.password=123 spring.security.user.roles=admin

 

基于内存的用户、URL权限配置:

1,用户角色配置:

(1)我们可以通过自定义类继承 WebSecurityConfigurerAdapter,从而实现对 Spring Security 更多的自定义配置。比如下面样例我们就配置了两个用户,以及他们对应的角色(这种方式只适合用于测试、开发环境不适用于生产)

复制代码

  MyWebSecurityConfig
// 指定密码的加密方式
    @Bean
    public PasswordEncoder passwordEncoder() {
//        return new BCryptPasswordEncoder();
        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);
            }
        };
    }
// 配置用户及其对应的角色     @Override     protected void configure(AuthenticationManagerBuilder auth) throws Exception {         auth.inMemoryAuthentication()         .withUser("root").password("123").roles("ADMIN","DBA")         .and()         .withUser("admin").password("123").roles("ADMIN","USER")         .and()         .withUser("hangge").password("123").roles("USER");     }
    // 配置 URL 访问权限     @Override     protected  void configure(HttpSecurity http) throws Exception {         http.authorizeRequests() // 开启 HttpSecurity 配置             .antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL必须具备ADMIN角色             .antMatchers("/user/**").access("hasAnyRole('ADMIN','USER')") // 该模式需要ADMIN或USER角色             .antMatchers("/db/**").access("hasRole('ADMIN') and hasRole('DBA')") // 需ADMIN和DBA角色             .anyRequest().authenticated() // 用户访问其它URL都必须认证后访问(登录后访问)             .and().formLogin().loginProcessingUrl("/login").permitAll() // 开启表单登录并配置登录接口             .and().csrf().disable(); // 关闭csrf     }
 } 

复制代码

(2)配置完成后,重启项目,就可以使用这两个用户进行登录了。 

  • formLogin() 方法表示开启表单登录,即我们之前看到的登录页面。

  • loginProcessingUrl() 方法配置登录接口为“/login”,即可以直接调用“/login”接口,发起一个 POST 请求进行登录,登录参数中用户名必须为 username,密码必须为 password,配置 loginProcessingUrl 接口主要是方便 Ajax 或者移动端调用登录接口。

  • permitAll() 表示和登录相关的接口都不需要认证即可访问。

三、基于数据库的用户角色配置

maven依赖:

 View Code

2,创建数据表:

复制代码

CREATE TABLE `resources` (   `id` int(11) NOT NULL AUTO_INCREMENT,   `pattern` varchar(255) DEFAULT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `role` (   `id` int(11) NOT NULL AUTO_INCREMENT,   `name` varchar(32) DEFAULT NULL,   `description` varchar(255) DEFAULT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `role_resource` (   `id` int(11) NOT NULL AUTO_INCREMENT,   `role_id` int(11) DEFAULT NULL,   `resource_id` int(11) DEFAULT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `user` (   `id` int(64) NOT NULL AUTO_INCREMENT,   `user_name` varchar(32) DEFAULT NULL,   `password` varchar(255) DEFAULT NULL,   `enable` tinyint(4) DEFAULT NULL,   `locked` tinyint(4) DEFAULT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; CREATE TABLE `user_role` (   `id` int(11) NOT NULL AUTO_INCREMENT,   `user_id` int(11) DEFAULT NULL,   `role_id` int(11) DEFAULT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

复制代码

3,创建实体类

复制代码

public class Resources {          private Integer id;          private String pattern;     private List roles; }

复制代码复制代码

public class Role implements Serializable {     private static final long serialVersionUID = 825384782616737527L;          private Integer id;          private String name;          private String description; }

复制代码复制代码

public class User implements UserDetails {     private Integer id;          private String userName;          private String password;          private boolean enable;          private boolean locked;     private List userRoles;     @Override     public Collection getAuthorities() {         List authorities = new ArrayList<>();         for (Role role : userRoles) {             authorities.add(new SimpleGrantedAuthority(role.getName()));         }         return authorities;     }     @Override     public String getUsername() {         return userName;     }     @Override     public boolean isAccountNonExpired() {         return true;     }     @Override     public boolean isAccountNonLocked() {         return !locked;     }     @Override     public boolean isCredentialsNonExpired() {         return true;     }     @Override     public boolean isEnabled() {         return enable;     }     public void setPassword(String password) {         this.password = password;     }     public String getPassword() {         return password;     }     public boolean isEnable() {         return enable;     }     public void setEnable(boolean enable) {         this.enable = enable;     }     public Integer getId() {         return id;     }     public void setId(Integer id) {         this.id = id;     }     public String getUserName() {         return userName;     }     public void setUserName(String userName) {         this.userName = userName;     }     public boolean isLocked() {         return locked;     }     public void setLocked(boolean locked) {         this.locked = locked;     }     public List getUserRoles() {         return userRoles;     }     public void setUserRoles(List userRoles) {         this.userRoles = userRoles;     } }

复制代码

接着创建用户表对应的实体类。用户实体类需要实现 UserDetails 接口,并实现该接口中的 7 个方法:

  • getAuthorities():获取当前用户对象所具有的角色信息

  • getPassword():获取当前用户对象的密码

  • getUsername():获取当前用户对象的用户名

  • isAccountNonExpired():当前账户是否未过期

  • isAccountNonLocked():当前账户是否未锁定

  • isCredentialsNonExpired():当前账户密码是否未过期

  • isEnabled():当前账户是否可用

(1)用户根据实际情况设置这 7 个方法的返回值。默认情况下不需要开发者自己进行密码角色等信息的比对,开发者只需要提供相关信息即可,例如:

  • getPassword() 方法返回的密码和用户输入的登录密码不匹配,会自动抛出 BadCredentialsException 异常

  • isAccountNonLocked() 方法返回了 false,会自动抛出 AccountExpiredException 异常。

  • 本案例因为数据库中只有 enabled 和 locked 字段,故账户未过期和密码未过期两个方法都返回 true.

(2)getAuthorities 方法用来获取当前用户所具有的角色信息,本案例中,用户所具有的角色存储在 roles 属性中,因此该方法直接遍历 roles属性,然后构造 SimpleGrantedAuthority 集合并返回。

4,创建数据库访问层

(1)首先创建 UserMapper 接口:

复制代码

@Repository public interface UserMapperDao {   public User loadUserByUsername(String userName);   public List getUserRolesByUid(Integer id);    }

复制代码

(2)接着在 UserMapper 相同的位置创建 UserMapper.xml 文件,内容如下:

复制代码

               select * from user where user_name = #{userName}                  select * from  role r, user_role ur where  r.id = ur.role_id and  ur.user_id = #{id}      

复制代码

5,创建 UserService

定义的 UserService 实现 UserDetailsService 接口,并实现该接口中的 loadUserByUsername 方法,该方法将在用户登录时自动调用。

loadUserByUsername 方法的参数就是用户登录时输入的用户名,通过用户名去数据库中查找用户:

  • 如果没有查找到用户,就抛出一个账户不存在的异常。

  • 如果查找到了用户,就继续查找该用户所具有的角色信息,并将获取到的 user 对象返回,再由系统提供的 DaoAuthenticationProvider类去比对密码是否正确。

复制代码

@Service public class UserService implements UserDetailsService {     @Autowired     private UserMapperDao userMapperDao;     @Autowired     private PasswordEncoder passwordEncoder;     @Override     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {         User user = userMapperDao.loadUserByUsername(username);           if (user == null) {             throw new UsernameNotFoundException("账户不存在!");         }          // 我的数据库用户密码没加密,这里手动设置         String encodePassword = passwordEncoder.encode(user.getPassword());         System.out.println("加密后的密码:" + encodePassword);         user.setPassword(encodePassword);         List userRoles = userMapperDao.getUserRolesByUid(user.getId());         user.setUserRoles(userRoles);         return user;     } }

复制代码

 

6,配置 Spring Security

 Spring Security 大部分配置与前文一样,只不过这次没有配置内存用户,而是将刚刚创建好的 UserService 配置到 AuthenticationManagerBuilder 中。

复制代码

@Configuration public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {     @Autowired     private UserService userService;     // 指定密码的加密方式     @Bean     public PasswordEncoder passwordEncoder() {         return new BCryptPasswordEncoder(); //        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); //            } //        };     }     // 配置用户及其对应的角色     @Override     protected void configure(AuthenticationManagerBuilder auth) throws Exception {         auth.userDetailsService(userService);     }     // 配置基于内存的 URL 访问权限     @Override     protected  void configure(HttpSecurity http) throws Exception {         http.authorizeRequests() // 开启 HttpSecurity 配置                 .antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL必须具备ADMIN角色                 .antMatchers("/user/**").access("hasAnyRole('ADMIN','USER')") // 该模式需要ADMIN或USER角色                 .antMatchers("/db/**").access("hasRole('ADMIN') and hasRole('DBA')") // 需ADMIN和DBA角色                 .anyRequest().authenticated() // 用户访问其它URL都必须认证后访问(登录后访问)                 .and().formLogin().loginProcessingUrl("/login").permitAll() // 开启表单登录并配置登录接口                 .and().csrf().disable(); // 关闭csrf     }

复制代码

7,运行测试 

1)首先在 Conctoller 中添加如下接口进行测试:

复制代码

@RestController public class HelloController {       @GetMapping("/admin/hello")     public String admin() {         return "hello admin";     }       @GetMapping("/user/hello")     public String user() {         return "hello user";     }     @GetMapping("/db/hello")     public String db() {         return "hello db";     }       @GetMapping("/hello")     public String hello() {         return "hello";     } }

复制代码

接下来测试一下,我们使用 admin 用户进行登录,由于该用户具有 ADMIN 和 USER 这两个角色,所以登录后可以访问 /hello、/admin/hello 以及 /user/hello 这三个接口。

    虽然前面我们实现了通过数据库来配置用户与角色,但认证规则仍然是使用 HttpSecurity 进行配置,还是不够灵活,无法实现资源和角色之间的动态调整。

    要实现动态配置  URL 权限,就需要开发者自定义权限配置,具体步骤如下。

四、基于数据库的URL权限规则配置 

下面是基于 resource 表 和  role_resource 表来实现:

(1)首先创建 resourceMapper 接口:

复制代码

@Repository public interface ResourceMapperDao {     /**      * @Author dw      * @Description 获取所有的资源      * @Date 2020/4/15 11:16      * @Param      * @return      */     public List getAllResources(); }

复制代码

xml:

复制代码

                                                                                                     SELECT          r.*,          re.id AS roleId,          re.`name`,          re.description         FROM resources AS r         LEFT JOIN role_resource AS rr  ON r.id = rr.resource_id         LEFT JOIN role AS re ON re.id = rr.role_id      

复制代码

自定义 FilterInvocationSecurityMetadataSource

注意:自定义 FilterInvocationSecurityMetadataSource 主要实现该接口中的 getAttributes 方法,该方法用来确定一个请求需要哪些角色。

复制代码

/**  * @Author dw  * @ClassName CustomFilterInvocationSecurityMetadataSource  * @Description 要实现动态配置权限,首先需要自定义 FilterInvocationSecurityMetadataSource:  * 自定义 FilterInvocationSecurityMetadataSource 主要实现该接口中的 getAttributes 方法,该方法用来确定一个请求需要哪些角色。  * @Date 2020/4/15 11:36  * @Version 1.0  */ @Component public class CustomFilterInvocationSecurityMetadataSource  implements FilterInvocationSecurityMetadataSource {          // 创建一个AntPathMatcher,主要用来实现ant风格的URL匹配。     AntPathMatcher antPathMatcher = new AntPathMatcher();     @Autowired    private ResourceMapperDao resourceMapperDao;     @Override     public Collection getAttributes(Object object) throws IllegalArgumentException {         // 从参数中提取出当前请求的URL         String requestUrl = ((FilterInvocation) object).getRequestUrl();         // 从数据库中获取所有的资源信息,即本案例中的Resources表以及Resources所对应的role         // 在真实项目环境中,开发者可以将资源信息缓存在Redis或者其他缓存数据库中。         List allResources = resourceMapperDao.getAllResources();         // 遍历资源信息,遍历过程中获取当前请求的URL所需要的角色信息并返回。         for (Resources resource : allResources) {             if (antPathMatcher.match(resource.getPattern(), requestUrl)) {                 List roles = resource.getRoles();                 if(!CollectionUtils.isEmpty(roles)){                     List allRoleNames = roles.stream()                             .map(role -> new SecurityConfig(role.getName().trim()))                             .collect(Collectors.toList());                     return allRoleNames;                 }             }         }         // 如果当前请求的URL在资源表中不存在相应的模式,就假设该请求登录后即可访问,即直接返回 ROLE_LOGIN.         return SecurityConfig.createList("ROLE_LOGIN");     }     // 该方法用来返回所有定义好的权限资源,Spring Security在启动时会校验相关配置是否正确。     @Override     public Collection getAllConfigAttributes() {         // 如果不需要校验,那么该方法直接返回null即可。         return null;     }     // supports方法返回类对象是否支持校验。     @Override     public boolean supports(Class clazz) {         return FilterInvocation.class.isAssignableFrom(clazz);     }      }

复制代码

自定义 AccessDecisionManager

 当一个请求走完 FilterInvocationSecurityMetadataSource 中的 getAttributes 方法后,接下来就会来到 AccessDecisionManager 类中进行角色信息的对比,自定义 AccessDecisionManager 代码如下:

复制代码

@Component public class CustomAccessDecisionManager implements AccessDecisionManager {     // 该方法判断当前登录的用户是否具备当前请求URL所需要的角色信息     @Override     public void decide(Authentication auth, Object object, Collection ConfigAttributes){         Collection userHasAuthentications = auth.getAuthorities();         // 如果具备权限,则不做任何事情即可         for (ConfigAttribute configAttribute : ConfigAttributes) {             // 如果需要的角色是ROLE_LOGIN,说明当前请求的URL用户登录后即可访问             // 如果auth是UsernamePasswordAuthenticationToken的实例,说明当前用户已登录,该方法到此结束             if ("ROLE_LOGIN".equals(configAttribute.getAttribute())                     && auth instanceof UsernamePasswordAuthenticationToken) {                 return;             }             // 否则进入正常的判断流程             for (GrantedAuthority authority : userHasAuthentications) {                 // 如果当前用户具备当前请求需要的角色,那么方法结束。                 if (configAttribute.getAttribute().equals(authority.getAuthority())) {                     return;                 }             }         }         // 如果不具备权限,就抛出AccessDeniedException异常         throw new AccessDeniedException("权限不足");     }     @Override     public boolean supports(ConfigAttribute attribute) {         return true;     }     @Override     public boolean supports(Class clazz) {         return true;     } }

复制代码

配置 Spring Security

 这里与前文的配置相比,主要是修改了 configure(HttpSecurity http) 方法的实现并添加了两个 Bean。至此我们边实现了动态权限配置,权限和资源的关系可以在 role_resource表中动态调整。

修改  MyWebSecurityConfig:

复制代码

   // 配置基于数据库的 URL 访问权限     @Override     protected void configure(HttpSecurity http) throws Exception {         http.authorizeRequests()                 .withObjectPostProcessor(new ObjectPostProcessor() {                     @Override                     public  O postProcess(O object) {                         object.setSecurityMetadataSource(accessMustRoles());                         object.setAccessDecisionManager(rolesCheck());                         return object;                     }                 })                 .and().formLogin().loginProcessingUrl("/login").permitAll()//开启表单登录并配置登录接口                 .and().csrf().disable(); // 关闭csrf     }    @Bean     public CustomFilterInvocationSecurityMetadataSource accessMustRoles() {         return new CustomFilterInvocationSecurityMetadataSource();     }     @Bean     public CustomAccessDecisionManager rolesCheck() {         return new CustomAccessDecisionManager();     }

复制代码

要配置角色继承关系,只需在 Spring Security 的配置类中提供一个 RoleHierarchy 即可。

复制代码

   // 配置角色继承关系     @Bean     RoleHierarchy roleHierarchy() {         RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();         String hierarchy = "ROLE_DBA > ROLE_ADMIN > ROLE_USER";         roleHierarchy.setHierarchy(hierarchy);         return roleHierarchy;     }

复制代码

 

 在之前的所有样例中,登录表单一直都是使用 Spring Security 提供的默认登录页,登录成功后也是默认的页面跳转。有时我们想要使用自定义的登录页,或者在前后端分离的开发方式中,前后端的数据交互通过 JSON 进行,这时登录成功后就不是页面跳转了,而是一段 JSON 提示。下面通过样例演示如何进行登录表单的个性化配置。

自定义登录页面、登录接口、登录成功或失败的处理逻辑

首先修改 Spring Security 配置,增加相关的自定义代码:

  • 将登录页改成使用自定义页面,并配置登录请求处理接口,以及用户密码提交时使用的参数名。

  • 自定义了登录成功、登录失败的处理逻辑,根据情况返回响应的 JSON 数据。

复制代码

@Configuration public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {     // 指定密码的加密方式     @SuppressWarnings("deprecation")     @Bean     PasswordEncoder passwordEncoder(){         // 不对密码进行加密         return NoOpPasswordEncoder.getInstance();     }       // 配置用户及其对应的角色     @Override     protected void configure(AuthenticationManagerBuilder auth) throws Exception {         auth.inMemoryAuthentication()                 .withUser("root").password("123").roles("DBA")                 .and()                 .withUser("admin").password("123").roles("ADMIN")                 .and()                 .withUser("hangge").password("123").roles("USER");     }       // 配置 URL 访问权限     @Override     protected void configure(HttpSecurity http) throws Exception {         http.authorizeRequests() // 开启 HttpSecurity 配置             .antMatchers("/db/**").hasRole("DBA") // db/** 模式URL需DBA角色             .antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL需ADMIN角色             .antMatchers("/user/**").hasRole("USER") // user/** 模式URL需USER角色             .anyRequest().authenticated() // 用户访问其它URL都必须认证后访问(登录后访问)             .and().formLogin()  // 开启登录表单功能             .loginPage("/login_page") // 使用自定义的登录页面,不再使用SpringSecurity提供的默认登录页             .loginProcessingUrl("/login") // 配置登录请求处理接口,自定义登录页面、移动端登录都使用该接口             .usernameParameter("name") // 修改认证所需的用户名的参数名(默认为username)             .passwordParameter("passwd") // 修改认证所需的密码的参数名(默认为password)             // 定义登录成功的处理逻辑(可以跳转到某一个页面,也可以返会一段 JSON)             .successHandler(new AuthenticationSuccessHandler() {                 @Override                 public void onAuthenticationSuccess(HttpServletRequest req,                                                     HttpServletResponse resp,                                                     Authentication auth)                         throws IOException, ServletException {                     // 我们可以跳转到指定页面                     // resp.sendRedirect("/index");                        // 也可以返回一段JSON提示                     // 获取当前登录用户的信息,在登录成功后,将当前登录用户的信息一起返回给客户端                     Object principal = auth.getPrincipal();                     resp.setContentType("application/json;charset=utf-8");                     PrintWriter out = resp.getWriter();                     resp.setStatus(200);                     Map map = new HashMap<>();                     map.put("status", 200);                     map.put("msg", principal);                     ObjectMapper om = new ObjectMapper();                     out.write(om.writeValueAsString(map));                     out.flush();                     out.close();                 }             })             // 定义登录失败的处理逻辑(可以跳转到某一个页面,也可以返会一段 JSON)             .failureHandler(new AuthenticationFailureHandler() {                 @Override                 public void onAuthenticationFailure(HttpServletRequest req,                                                     HttpServletResponse resp,                                                     AuthenticationException e)                         throws IOException, ServletException {                     resp.setContentType("application/json;charset=utf-8");                     PrintWriter out = resp.getWriter();                     resp.setStatus(401);                     Map map = new HashMap<>();                     // 通过异常参数可以获取登录失败的原因,进而给用户一个明确的提示。                     map.put("status", 401);                     if (e instanceof LockedException) {                         map.put("msg", "账户被锁定,登录失败!");                     }else if(e instanceof BadCredentialsException){                         map.put("msg","账户名或密码输入错误,登录失败!");                     }else if(e instanceof DisabledException){                         map.put("msg","账户被禁用,登录失败!");                     }else if(e instanceof AccountExpiredException){                         map.put("msg","账户已过期,登录失败!");                     }else if(e instanceof CredentialsExpiredException){                         map.put("msg","密码已过期,登录失败!");                     }else{                         map.put("msg","登录失败!");                     }                     ObjectMapper mapper = new ObjectMapper();                     out.write(mapper.writeValueAsString(map));                     out.flush();                     out.close();                 }             })             .permitAll() // 允许访问登录表单、登录接口             .and().csrf().disable(); // 关闭csrf     } }

复制代码

(2)在 resource/templates 目录下创建一个登录页面 login_page.html,内容如下:

复制代码

            Title                
                                   
         
                                   
         
                      
       

复制代码

七、注销登录配置

修改 Spring Security 配置

复制代码

// 配置 URL 访问权限     @Override     protected void configure(HttpSecurity http) throws Exception {         http.authorizeRequests() // 开启 HttpSecurity 配置             .antMatchers("/db/**").hasRole("DBA") // db/** 模式URL需DBA角色             .antMatchers("/admin/**").hasRole("ADMIN") // admin/** 模式URL需ADMIN角色             .antMatchers("/user/**").hasRole("USER") // user/** 模式URL需USER角色             .anyRequest().authenticated() // 用户访问其它URL都必须认证后访问(登录后访问)             .and().formLogin().loginProcessingUrl("/login").permitAll() // 开启表单登录并配置登录接口             .and().logout() // 开启注销登录的配置             .logoutUrl("/logout") // 配置注销登录请求URL为"/logout"(默认也就是 /logout)             .clearAuthentication(true) // 清除身份认证信息             .invalidateHttpSession(true) // 使 session 失效             // 配置一个 LogoutHandler,开发者可以在这里完成一些数据清除工做             .addLogoutHandler(new LogoutHandler() {                 @Override                 public void logout(HttpServletRequest req,                                    HttpServletResponse resp,                                    Authentication auth) {                     System.out.println("注销登录,开始清除Cookie。");                 }             })             // 配置一个 LogoutSuccessHandler,开发者可以在这里处理注销成功后的业务逻辑             .logoutSuccessHandler(new LogoutSuccessHandler() {                 @Override                 public void onLogoutSuccess(HttpServletRequest req,                                             HttpServletResponse resp,                                             Authentication auth)                         throws IOException, ServletException {                     // 我们可以跳转到登录页面                     // resp.sendRedirect("/login");                       // 也可以返回一段JSON提示                     resp.setContentType("application/json;charset=utf-8");                     PrintWriter out = resp.getWriter();                     resp.setStatus(200);                     Map map = new HashMap<>();                     map.put("status", 200);                     map.put("msg", "注销成功!");                     ObjectMapper om = new ObjectMapper();                     out.write(om.writeValueAsString(map));                     out.flush();                     out.close();                 }             })             .and().csrf().disable(); // 关闭csrf     }

复制代码

密码加密配置

(1)要配置密码加密只需要修改两个地方。首先要修改 HttpSecurity 配置中的 PasswordEncoder 这个Bean 的实现,这里我们采用 BCryptPasswordEncoder 加密方案。

Spring Security 提供了多种密码加密方案,官方推荐使用 BCryptPasswordEncoder: BCryptPasswordEncoder 使用 BCrypt 强哈希函数,开发者在使用时可以选择提供 strength 和 SecureRandom 实例。 strength 取值在 4~31 之间(默认为 10)。strength 越大,密钥的迭代次数越多(密钥迭代次数为 2^strength)

(2)接着将用户的密码改成使用 BCryptPasswordEncoder 加密后的密码(如果是数据库认证,库里的密码同样也存放加密后的密码)

 @Bean     PasswordEncoder passwordEncoder(){         // 使用BCrypt强哈希函数加密方案,密钥迭代次数设为10(默认即为10)         return new BCryptPasswordEncoder(10);     }

通过注解配置方法安全

1)首先我们要通过 @EnableGlobalMethodSecurity 注解开启基于注解的安全配置:

@EnableGlobalMethodSecurity 注解参数说明:

  • prePostEnabled = true 会解锁 @PreAuthorize 和 @PostAuthorize 两个注解。顾名思义,@PreAuthorize 注解会在方法执行前进行验证,而 @PostAuthorize 注解会在方法执行后进行验证。

  • securedEnabled = true 会解锁 @Secured 注解。

(2)开启注解安全配置后,接着创建一个 MethodService 进行测试:

复制代码

@Service public class MethodService {       // 访问该方法需要 ADMIN 角色。注意:这里需要在角色前加一个前缀"ROLE_"     @Secured("ROLE_ADMIN")     public String admin() {         return "hello admin";     }       // 访问该方法既要 ADMIN 角色,又要 DBA 角色     @PreAuthorize("hasRole('ADMIN') and hasRole('DBA')")     public String dba() {         return "hello dba";     }       // 访问该方法只需要 ADMIN、DBA、USER 中任意一个角色即可     @PreAuthorize("hasAnyRole('ADMIN','DBA','USER')")     public String user() {         return "hello user";     } }

复制代码

 

获取用户信息:

1)通过 Authentication.getPrincipal() 可以获取到代表当前用户的信息,这个对象通常是 UserDetails 的实例。通过 UserDetails 的实例我们可以获取到当前用户的用户名、密码、角色等信息。

    Spring Security 使用一个 Authentication 对象来描述当前用户的相关信息,而 SecurityContext 持有的是代表当前用户相关信息的 Authentication 的引用。
    这个 Authentication 对象不需要我们自己去创建,在与系统交互的过程中,Spring Security 会自动为我们创建相应的 Authentication 对象,然后赋值给当前的 SecurityContext。

方式一:

复制代码

@RestController public class HelloController {       @GetMapping("/hello")     public String hello() {         return "当前登录用户:" + SecurityContextHolder.getContext().getAuthentication().getName();     } }

复制代码

方式2:

复制代码

    /**      * 获取用户明细      * @param principal      * @return      */     @RequestMapping(value = "getUserInfo", method = RequestMethod.GET)     public Principal getUserDetails(Principal principal) {         logger.info("用户名:{}",principal.getName());         return principal;     }     /**      * 获取用户明细      * @param authentication      * @return      */     @RequestMapping(value = "getUserInfo2", method = RequestMethod.GET)     public Authentication getUserInfo2(Authentication authentication) {         logger.info("用户名:{}", authentication);         return authentication;     }     /**      * 只获取用户信息      * @param userDetails      * @return      */     @RequestMapping(value = "getUser", method = RequestMethod.GET)     public UserDetails getUser(@AuthenticationPrincipal UserDetails userDetails) {         logger.info("用户名:{}",userDetails.getUsername());         return userDetails;     }



相关问题推荐

  • 回答 36

    看军事新闻的同学应该都知道,一艘航空母舰作战能力虽然很强,但是弱点太明显,就是防御能力太差,单艘的航空母舰很少单独行动,通常航空母舰战斗群才是主要军事力量,你可以把单艘航母理解为的单体应用(防御差,机动性不好),把航母战斗群(调度复杂,维护...

  • 回答 31

    初始化过程细节:首先进行的就是将服务装载到容器中,然后准备注册服务。和Spring中启动过程类似,Spring启动时,将bean装载进容器中的时候,首先要解析bean。所以dubbo也是先读配置文件解析服务。解析服务:基于dubbo.jar内的META-INF/spring.handlers配置,...

  • 回答 27

    分布式事务 指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上 。换成比较容易理解的话,就是多个事务之间再保持事务的特性,也就是多个事务之间保证结果的一致性。分布式事务解决方案1、基于XA协议的两阶...

  • 什么是接口幂等性?2021-02-24 18:21
    回答 25

    1. 接口调用存在的问题        现如今我们的系统大多拆分为分布式SOA,或者微服务,一套系统中包含了多个子系统服务,而一个子系统服务往往会去调用另一个服务,而服务调用服务无非就是使用RPC通信或者restful,既然是通信,那么就有可能在服务器处理...

  • 回答 21

    前提是另外一个bean在bean容器中能找到

  • 回答 22

    1.View——表示层1.1准备数据实现方式:struts,servlet等1.2显示数据实现方式:extjs,jsp,jquery,html等2.Service——业务层实现方式:drools等3.Dao——数据访问层实现方式:hibernate、mybatis等...

  • SpringCloud Netflix和Sprin2020-11-12 09:41
    回答 8
    已采纳

    SpringCloud Netflix和SpringCloud Alibaba的区别如下图:

  • 回答 16

    哨兵(Sentinel)是 redis 的高可用性解决方案,前面我们讲的主从复制它是高可用的基础,需要人工介入才能完成故障转移,哨兵可以解决这个问题,在主从复制情况下,当主节点发生故障时,哨兵可以自动的发现故障并且完成故障转移,实现真正的 redis 高可用。在...

  • 回答 8

    redis为什么会有高并发问题redis的出身决定Redis是一种单线程机制的nosql数据库,基于key-value,数据可持久化落盘。由于单线程所以redis本身并没有锁的概念,多个客户端连接并不存在竞争关系,但是利用jedis等客户端对redis进行并发访问时会出现问题。发生连...

  • 回答 8

    用dubbo是想利用分布式集群的形式来提高服务的并发量,适用与大型项目.如果不用它还想提高并发另一个解决方案是springCloud+微服务.适合大中小型项目.当前对并发要求的项目还是很多的,所以dubbo用的也相对较多.建议如果是初学者可以跳过dubbo直接学习第二个方...

  • 回答 4

    不需要。一般是service分出去。然后其它放在web层即一个jar为service业务处理,一个为web层war包

  • 回答 7

    在回答这个问题之前,我们先回答一下什么是锁。普通的锁,即在单机多线程环境下,当多个线程需要访问同一个变量或代码片段时,被访问的变量或代码片段叫做临界区域,我们需要控制线程一个一个的顺序执行,否则会出现并发问题。如何控制呢?就是设置一个各个线...

  • 回答 6

     springmvc位于表现层,主要与浏览器进行交互(接收和响应浏览器请求)。springmvc采用MVC设计模型,模型由model、view和controller组成。         model(模型):对应JavaBean         view(视图):对应JSP         controller(控制器)...

没有解决我的问题,去提问