zoukankan html css js c++ java

Spring Security使用详解（基本用法）

1，什么是 Spring Security ?

Spring Security 是一个相对复杂的安全管理框架，功能比 Shiro 更加强大，权限控制细粒度更高，对 OAuth 2 的支持也更友好。
由于 Spring Security 源自 Spring 家族，因此可以和 Spring 框架无缝整合，特别是 Spring Boot 中提供的自动化配置方案，可以让 Spring Security 的使用更加便捷。

2，安装配置

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

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 更多的自定义配置。比如下面样例我们就配置了两个用户，以及他们对应的角色（这种方式只适合用于测试、开发环境不适用于生产）

@Configuration
public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {

// 指定密码的加密方式
    @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依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--操作数据库-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- MySQL 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- Druid 数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.22</version>
        </dependency>

        <!-- region MyBatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>

        <!--模板引擎thmeleaf对HTML的支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>

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<Role> 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<Role> userRoles;


    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        List<SimpleGrantedAuthority> 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<Role> getUserRoles() {
        return userRoles;
    }

    public void setUserRoles(List<Role> 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<Role> getUserRolesByUid(Integer id);
  
}

（2）接着在 UserMapper 相同的位置创建 UserMapper.xml 文件，内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="example.hellosecurity.dao.UserMapperDao">
    <select id="loadUserByUsername" parameterType="string" resultType="example.hellosecurity.entity.User">
       select * from user where user_name = #{userName}
    </select>
    <select id="getUserRolesByUid" parameterType="int" resultType="example.hellosecurity.entity.Role">
       select * from  role r, user_role ur where  r.id = ur.role_id and  ur.user_id = #{id}
    </select>

</mapper>

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<Role> 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<Resources> getAllResources();
}

xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="example.hellosecurity.dao.ResourceMapperDao">

    <resultMap id="ResourcesMap" type="example.hellosecurity.entity.Resources">
        <id column="id" property="id"/>
        <result column="pattern" property="pattern"/>
        <collection property="roles" ofType="example.hellosecurity.entity.Role">
            <id column="roleId" property="id"/>
            <result column="name" property="name"/>
            <result column="description" property="description"/>
        </collection>
    </resultMap>
    <select id="getAllResources" resultMap="ResourcesMap">
        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
    </select>

</mapper>

自定义 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<ConfigAttribute> getAttributes(Object object) throws IllegalArgumentException {
        // 从参数中提取出当前请求的URL
        String requestUrl = ((FilterInvocation) object).getRequestUrl();

        // 从数据库中获取所有的资源信息，即本案例中的Resources表以及Resources所对应的role
        // 在真实项目环境中，开发者可以将资源信息缓存在Redis或者其他缓存数据库中。
        List<Resources> allResources = resourceMapperDao.getAllResources();

        // 遍历资源信息，遍历过程中获取当前请求的URL所需要的角色信息并返回。
        for (Resources resource : allResources) {
            if (antPathMatcher.match(resource.getPattern(), requestUrl)) {
                List<Role> roles = resource.getRoles();
                if(!CollectionUtils.isEmpty(roles)){
                    List<ConfigAttribute> 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<ConfigAttribute> 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<ConfigAttribute> ConfigAttributes){

        Collection<? extends GrantedAuthority> 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<FilterSecurityInterceptor>() {
                    @Override
                    public <O extends FilterSecurityInterceptor> 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<String, Object> 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<String, Object> 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，内容如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/login" method="post">
        <div>
            <label>用户名</label>
            <input type="text" name="name"/>
        </div>
        <div>
            <label>密码</label>
            <input type="password" name="passwd"/>
        </div>
        <div>
            <input type="submit" value="登陆">
        </div>
    </form>
</body>
</html>

七、注销登录配置

修改 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<String, Object> 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;
    }

查看全文

相关阅读:
struts2(五) s标签和国际化
 struts2(四) ognl表达式、值栈、actionContext之间的关系
 数据结构(一) 单链表的实现-JAVA
struts2(三) 输入校验和拦截器
 struts2(二) 表单参数自动封装和参数类型自动转换
 struts2(一) struts2入门
 Java Web(十四) 编写MyBookStore项目的总结
 Java Web(十三) 使用javamail进行发送邮件，(使用QQ，163，新浪邮箱服务器)
Java中反射机制详解
 Java Web(十二) commons-fileupload上传下载

原文地址：https://www.cnblogs.com/dw3306/p/12751373.html

Spring Security使用详解（基本用法 ）