springboot集成security(认证)

目录

  • 1. 依赖
  • 2. 自定义登录逻辑
    • 1. 数据库查询
    • 2. security认证
      • 1. loadUserByUsername
      • 2. PasswordEncorder(不加密)
      • 3. MD5加密数据库密码
      • 4. PasswordEncorder(加密)
      • 5. BCryptPasswordEncoder
      • 6. 认证流程(图)
  • 3. 自定义登录界面
    • 1. 界面
    • 2. security配置类
      • 1. 配置默认登录界面
      • 2. 配置拦截与放行
      • 3. 登录成功后的处理方案
      • 4. 登陆失败后的处理方案

1. 依赖

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-securityartifactId>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.4.1version>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>

加入 spring-boot-starter-security 依赖之后,不需要任何配置,启动项目,就会出现一个登录界面:
springboot集成security(认证)_第1张图片

  • 任何访问请求都会被拦截到 /login,并且要求认证后才能访问,请求方式是 Get

  • 默认 usernameuser,每次启动都会在控制台输出一个 128Byte 的 password

  • 可通过配置文件修改默认的 usernamepassword (静态用户,适用于内部网络认证)

    spring:
      # default login url: /login
      security:
        user:
          name: dev
          # default size: 128 Byte
          password: admin
    

2. 自定义登录逻辑


1. 数据库查询

表、实体类:
springboot集成security(认证)_第2张图片

@Data
public class User {
    private Integer id;
    private String name;
    private String password;
}

配置文件:

# application name
spring:
  # mysql
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spbt?serverTimezone=Asia/Shanghai
    username: root
    password: admin
# web service port
server:
  port: 8088
mybatis-plus:
  type-aliases-package: com.chenjy.security_demo.dto
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

mapper:


DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.chenjy.security_demo.mapper.UserMapper">
    <select id="getUserByName" parameterType="string" resultType="user">
        select
               id,
               name,
               password
        from
             user
        <where>
            <if test="name != null and name != ''">
                name = #{name}
            if>
        where>
    select>
mapper>
@Mapper
public interface UserMapper {
    User getUserByName(String name);
    List<User> getUserByName();
}

启动类加上 @MapperScan 注解


service:

public interface UserService {
    User getUserByName(String name);
    List<User> getUserByName();
}
@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper userMapper;

    @Override
    public User getUserByName(String name) {
        return userMapper.getUserByName(name);
    }

    @Override
    public List<User> getUserByName() {
        return userMapper.getUserByName();
    }
}

2. security认证

要自定义 security 认证逻辑,就需要定义一个服务对象来实现 UserDetailsService 接口,并重写 loadUserByUsername 方法。


1. loadUserByUsername

loadUserByUsername

  • security 唯一的认证方法
  • 查询用户失败,会抛出 UsernameNotFoundException
@Component
public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    private UserService userService;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        com.chenjy.security_demo.dto.User user = userService.getUserByName(username);
        if (user == null) {
            throw  new UsernameNotFoundException("用户名错误");
        }
        // 匹配用户密码
        // org.springframework.security.core.userdetails.User
         User res = new User(username, user.getPassword(), AuthorityUtils.createAuthorityList());
        return res;
    }
}
  • org.springframework.security.core.userdetails.User
    springboot集成security(认证)_第3张图片

  • loadUserByUsername 需要返回一个 UserDetails 的实现类,可以直接使用 User,其有两个构造器:

    public User(String username, String password, Collection<? extends GrantedAuthority> authorities)
    public User(String username, String password, boolean enabled, boolean accountNonExpired, boolean credentialsNonExpired, boolean accountNonLocked, Collection<? extends GrantedAuthority> authorities) 
    
    • username 用户名
    • password 用户密码
    • authorities 权限集合
  • security 内部会自动进行密码匹配

这时候直接启动项目,会报错:

*java.lang.IllegalArgumentException: There is no PasswordEncoder mapped for the id "null"*

这是因为 security 5.X 需要提供一个PasswordEncorder的实例


2. PasswordEncorder(不加密)

security 内部进行密码匹配的时候,一定要进行加密和解密处理。要求 IOC 容器中,必须要存在一个 PasswordEncorder 对象,提供加密和解密逻辑。
springboot集成security(认证)_第4张图片

  • 可以直接客户端明文,数据库解密来匹配验证
  • 也可以客户端加密,数据库直接密文来匹配验证

因为我的数据库密码并未进行加密,所以这里,我们就直接返回字符串进行明文比对就行了。

@Component
public class MyPasswordEncoder implements PasswordEncoder {
    /**
     * @Description 收集页面的密码
     * @param rawPassword
     * @return String
    */
    @Override
    public String encode(CharSequence rawPassword) {
        return rawPassword.toString();
    }

    /**
     * @Description 匹配逻辑
     * @param rawPassword 明文,页面收集的密码
     * @param encodedPassword 密文,存储在数据源中的密码
     * @return boolean
    */
    @Override
    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        return rawPassword.equals(encodedPassword);
    }
}

encode 对页面收集到的密码进行加密,然后将加密好的密文交给 matches,与数据库密码进行比对。


3. MD5加密数据库密码

自定义加密工具类

public class PwdEncode {

    /**
     * @Description 收集
     * @param pwd
     * @return String
    */
    public static String encode(String pwd) {
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (Exception e) {
            System.out.println(e.toString());
            e.printStackTrace();
            return "";
        }
        char[] charArray = pwd.toCharArray();
        byte[] byteArray = new byte[charArray.length];

        for (int i = 0; i < charArray.length; i++) {
            byteArray[i] = (byte) charArray[i];
        }
        byte[] md5Bytes = md5.digest(byteArray);
        StringBuffer hexValue = new StringBuffer();
        for (int i = 0; i < md5Bytes.length; i++) {
            int val = ((int) md5Bytes[i]) & 0xff;
            if (val < 16){
                hexValue.append("0");
            }
            hexValue.append(Integer.toHexString(val));
        }
        return hexValue.toString();
    }

    /**
     * @Description 解密
     * 一次加密之后,需要两次解密
     * @param pwd
     * @return String
    */
    public static String decrypt(String pwd) {
        char[] a = pwd.toCharArray();
        for (int i = 0; i < a.length; i++) {
            a[i] = (char) (a[i] ^ 't');
        }
        String s = new String(a);
        return s;
    }

    public static void main(String[] args) {
        String s = "123456";
        System.out.println("原始:" + s);
        System.out.println("MD5后:" + encode(s));
        System.out.println("加密的:" + decrypt(s));
        System.out.println("解密的:" + decrypt(decrypt(s)));
    }
}
springboot集成security(认证)_第5张图片

然后修改数据库密码。


4. PasswordEncorder(加密)

@Component
public class MyPasswordEncoder implements PasswordEncoder {
    /**
     * @Description 收集页面的密码
     * @param rawPassword
     * @return String
    */
    @Override
    public String encode(CharSequence rawPassword) {
        return rawPassword.toString();
    }

    /**
     * @Description 匹配逻辑
     * @param rawPassword 明文,页面收集的密码
     * @param encodedPassword 密文,存储在数据源中的密码
     * @return boolean
    */
    @Override
    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        return PwdEncode.encode(rawPassword.toString()).equals(encodedPassword);
    }
}

注意: MD5解密很简单——https://www.cmd5.com/,所以不推荐使用MD5加密。


5. BCryptPasswordEncoder

鉴于MD5加密的不安全性,所以建议使用 security 自带的加密工具类 —— BCryptPasswordEncoder

  • 同一明文,加密两次,输出不同

        public static void main(String[] args) {
            String s = "123456";
            BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();;
            System.out.println("原始: " + s);
            System.out.println("加密1: " + encoder.encode(s));
            System.out.println("加密1: " + encoder.encode(s));
        }
    
  • 可使用 matches 验证明文与密文是否相同:

    System.out.println(encoder.matches(s, encoder.encode(s)));
    

BCryptPasswordEncoder使用bcrypt算法对密码进行加密,同时会为密码加上“盐”,开发者不需要自己加“盐”,即使相同的明文字段生成的加密字符串也不同。匹配时,从密文中取出“盐”,用该盐值加密明文和最终密文作对比。


BCryptPasswordEncoder的默认强度为10,开发者可以根据自己服务器的速度进行调整,以确保密码验证的时间约为1秒(官方建议)

BCryptPasswordEncoder encoder_pro = new BCryptPasswordEncoder(15);
System.out.println("加密2: " + encoder_pro.encode(s));

注册 BCryptPasswordEncoder

  • 取消MyPasswordEncoder的 @Component 注解

  • 新建一个配置类,注册 BCryptPasswordEncoder

    @Configuration
    public class SecurityConf {
        @Bean
        public BCryptPasswordEncoder passwordEncoder() {
            return new BCryptPasswordEncoder();
        }
    }
    

6. 认证流程(图)

springboot集成security(认证)_第6张图片

3. 自定义登录界面


1. 界面

依赖:

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-thymeleafartifactId>
        dependency>

resources/templates/login.html:

DOCTYPE html>
<html lang="en" xmlns:th="https://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>登录title>
head>
<body>
<div class="main">
  <div class="title">
    <span>密码登录span>
  div>

  <div class="title-msg">
    <span>请输入登录账户和密码span>
  div>

  <form class="login-form" method="post" novalidate th:action="@{/myLogin}">
    
    <div class="input-content">
      
      <div>
        <input type="text"
               autocomplete="off"
               placeholder="用户名"
               name="name"
               required/>
      div>

      <div style="margin-top: 16px">
        <input type="password"
               autocomplete="off"
               placeholder="登录密码"
               name="password"
               required
               maxlength="32"/>
      div>
    div>

    
    <div style="text-align: center">
      <button type="submit" class="enter-btn" >登录button>
    div>
  form>

div>
body>
<style>
  body{
    background: #426258;
  }
  *{
    padding: 0;
    margin: 0;
  }

  .main {
    padding-left: 25px;
    padding-right: 25px;
    padding-top: 15px;
    width: 350px;
    height: 350px;
    background: #FFFFFF;
    /*以下css用于让登录表单垂直居中在界面,可删除*/
    position: absolute;
    top: 50%;
    left: 50%;
    margin: -175px auto 0 -175px;
  }

  .title {
    width: 100%;
    height: 40px;
    line-height: 40px;
  }

  .title span {
    font-size: 18px;
    color: #353f42;
  }

  .title-msg {
    width: 100%;
    height: 64px;
    line-height: 64px;
  }

  .title:hover{
    cursor: default	;
  }

  .title-msg:hover{
    cursor: default	;
  }

  .title-msg span {
    font-size: 12px;
    color: #707472;
  }

  .input-content {
    width: 100%;
    height: 120px;
  }

  .input-content input {
    width: 330px;
    height: 40px;
    border: 1px solid #dad9d6;
    background: #ffffff;
    padding-left: 10px;
    padding-right: 10px;
  }

  .enter-btn {
    width: 350px;
    height: 40px;
    color: #fff;
    background: #0bc5de;
    line-height: 40px;
    text-align: center;
    border: 0px;
  }

  .enter-btn:hover {
    cursor:pointer;
    background: #1db5c9;
  }
style>

html>

注意: security 处理登录请求的方式一定是 POST

resources/templates/main.html:

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"
      xmlns:shiro="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>主页title>
head>
<body>
<div class="con">
    <h1><span style="color: #67865d">登陆成功span>h1>
    <br>
    <div class="component">
    div>
    <br>
div>
body>
<style>
    body {
        background-color: #c1d3d0;
    }
    .con {
        text-align: center;
    }
    .component div {
        font-size: 32px;
    }
    .component span {
        color: #FFFFFF;
        font-size: 32px;
    }
style>

2. security配置类

extends WebSecurityConfigurerAdapter 并重写 configure(HttpSecurity http)


1. 配置默认登录界面

@Configuration
public class SecurityConf extends WebSecurityConfigurerAdapter {
    /**
     * @Description 注册BCryptPasswordEncoder到容器
     * @return BCryptPasswordEncoder
     */
    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * @Description 重写父类型中的配置逻辑
     * @param http 基于http协议的security配置对象,包含所有security相关配置逻辑
     * @throws Exception 配置出错会抛出异常
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 配置请求相关内容
        http
                .formLogin()
                .loginPage("/myLogin") // 登录页面地址,默认 /login, 这里的地址要由 controller 接口地址决定
                .usernameParameter("name") // 登录页面用户名字段
                .passwordParameter("password"); // 登录页面用户密码字段

        // 关闭csrf
        http.csrf().disable();
    }
}

然后启动:

springboot集成security(认证)_第7张图片

  • 可发现,并不会拦截请求
  • 一旦自定义配置,所有的默认认证流程会全部清空

2. 配置拦截与放行

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 配置请求相关内容
        http
                .formLogin()
                .loginPage("/myLogin") // 登录页面地址,默认 /login, 这里的地址要由 controller 接口地址决定
                .usernameParameter("name") // 登录页面用户名字段
                .passwordParameter("password") // 登录页面用户密码字段
                .and()
                .authorizeRequests()
                .antMatchers("/myLogin")
                .permitAll() // /myLogin 不需要认证,可直接访问
                .anyRequest()
                .authenticated(); // 其他请求都需要认证

        // 关闭csrf
        http.csrf().disable();
    }
  • formLogin 配置登录表单
  • loginPage 配置登录界面
  • usernameParameter 登录页面用户字段名
  • passwordParameter 登录页面用户密码字段名
  • and and
  • authorizeRequests 配置拦截和放行的url
  • antMatchers 匹配多个路径,用 , 隔开
  • permitAll 前面匹配的路径全部放行
  • anyRequest 其他路径
  • authenticated 匹配的路径需要认证

注意:

  • 拦截一定要写在放行之后
  • 如果不配置 usernameParameterpasswordParameter,那么请求参数名必须是 usernamepassword,不然 security 无法识别

3. 登录成功后的处理方案

security 默认访问成功后跳转到 “/” ,现在修改配置,使其跳转到 main


方案一: 使用 successForwardUrl,请求转发 —— POST 请求。

    @RequestMapping("main")
    public String main() {
        return "main";
    }
.successForwardUrl("/main") // 登录成功跳转页面

方案二: 使用 successForwardUrl,响应重定向(重新请求) —— GET 请求。

.defaultSuccessUrl("http://127.0.0.1:8088/main") // 响应重定向(GET)

注意1: 因为 successForwardUrl 是重新发起请求,所以需要传入一个绝对地址才能成功定向。

注意2: 最好传入一个参数 alwaysUse (代表一定使用这个重定向地址),防止出现错误。

.defaultSuccessUrl("http://127.0.0.1:8088/main", true) 

方案三: 使用 successHandler,自定义认证成功后的请求处理逻辑(转发、重定向都可自定义)。

successForwardUrldefaultSuccessUrl 内部就是用的 successHandler 的实现类,进行控制成功后交给哪个方法处理。

自定义请求成功处理器: implements AuthenticationSuccessHandler

@Data
@AllArgsConstructor
@NoArgsConstructor
public class SuccessHandler implements AuthenticationSuccessHandler {
    private String url;
    public boolean isRedirect;
    
    /**
     * @Description
     * @param request 请求对象  请求转发——request.getRequestDispatcher(url).forward(request, response);
     * @param response 响应对象 重定向——response.sendRedirect(url);
     * @param authentication 认证成功后的对象,包含用户名和权限信息(防止信息泄露,所以没带密码)
    */
    @Override
    public void onAuthenticationSuccess( HttpServletRequest request,
            HttpServletResponse response,
            Authentication authentication) throws IOException, ServletException {
        if (isRedirect) {
            response.sendRedirect(url);
        } else {
            request.getRequestDispatcher(url).forward(request, response);
        }
    }
}
.successHandler(new SuccessHandler("/main", false)) // 使用自定义请求处理控制逻辑

4. 登陆失败后的处理方案

登陆失败后,默认跳转到 /login?error,现在自定义一个登录失败的处理。


方案一: 使用 failureForwardUrl,登录失败请求转发 —— POST

    @RequestMapping("fail")
    public String fail(Model model) {
        model.addAttribute("fail");
        return "login";
    }
.failureForwardUrl("/fail") // 登录失败转发
<span th:if="${fail} == 'true'" style="color: red">登陆失败span>
springboot集成security(认证)_第8张图片

方案二: 使用 failureForwardUrl,响应重定向。

.failureUrl("/fail") // 响应重定向
...
.antMatchers("/myLogin", "/fail")
.permitAll() // /myLogin,/fail 不需要认证,可直接访问
springboot集成security(认证)_第9张图片

重定向是重新发请求, 所以需要在权限配置中放行 /fail


方案三: 使用 failureForwardUrl,自定义处理器。

@Data
@AllArgsConstructor
@NoArgsConstructor
public class FailureHandler implements AuthenticationFailureHandler {
    private String url;
    private boolean isRedirect;

    @Override
    public void onAuthenticationFailure(HttpServletRequest request,
                                        HttpServletResponse response,
                                        AuthenticationException exception) throws IOException, ServletException {
        if (isRedirect) {
            response.sendRedirect(url);
        } else {
            request.getRequestDispatcher(url).forward(request, response);
        }
    }
}
.failureHandler(new FailureHandler("/fail", true)) //

你可能感兴趣的:(Spring,Boot,spring,boot,security,thymeleaf)