Java实现加盐算法的两种方法

package com.example.demo.common;

import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;

import java.util.UUID;

public class PasswordUtils{

    /**
     * 1.加盐并生成最终的密码
     * @param password 明文的密码
     * @return 最终生成的密码
     */
    public static String encrypt(String password){
        //a.产生盐值
        //UUID.randomUUID()会生成32位数字+4位-，是随机的唯一的，将4位-去掉就得到32位数字的盐值
        String salt = UUID.randomUUID().toString().replace("-","");
        //生成加盐后的密码(需要使用MD5)
        String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
        //生成最终的密码格式
        String finalPassword = salt + "$" + saltPassword;
        return finalPassword;
    }

    /**
     * 2.加盐并生成最终密码格式（方法一的重载），区别于上面的方法：这个方法是用来解密的，给定了盐值，生成一个最终密码，
     后面要和正确的最终密码进行比对
     * @param password 需要验证的明文密码
     * @param salt
     * @return
     */
    public static  String encrypt(String password, String salt){
        //1.生成一个加密后的密码
        String saltPassword = DigestUtils.md5DigestAsHex((salt + password).getBytes());
        //2.生成最终的密码（待验证）
        String finalPassword = salt + "$" + saltPassword;
        return finalPassword;
    }

    /**
     * 3.验证密码
     * @param inputPassword  登录用户输入的明文密码
     * @param finalPassword  数据库中实际的最终密码格式
     * @return
     */
    public static boolean check(String inputPassword, String finalPassword){
        //首先判断这两个参数到底有没有值,数据库中的最终密码是不是65位
        if(StringUtils.hasLength(inputPassword) && StringUtils.hasLength(finalPassword)
        && finalPassword.length() == 65){
            //a.首先从最终的密码中得到盐值
            //使用$将finalPassword划分成两个部分，前面的32位的部分就是盐值
            //注意：这里的$是被认为是一个通配符，所以要转义一下
            String salt = finalPassword.split("\\$")[0];
            //b.使用之前加密的方法，生成最终的密码格式（待验证）
            String checkPassword = encrypt(inputPassword,salt);
            if(checkPassword.equals(finalPassword)){
                return true;
            }
        }
        return false;
    }
}

@RequestMapping("/reg")
public AjaxResult reg(UserInfo userinfo) {
    //非空判断
    //虽然前端已经进行了非空检查，但是用户可能会通过别的方式直接访问url绕过前端的非空校验，所以作为后端，应该要考虑到这一点
    //所以在后端也是要写非空校验的
    if (userinfo == null || !StringUtils.hasLength(userinfo.getUsername()) ||
        !StringUtils.hasLength(userinfo.getPassword())){
            return AjaxResult.fail(-1,"非法参数");
    }
    //不是空的话，就直接返回成功的响应就行了
    //这里响应的是1，所以前端在进行成功判断的时候才有result.data == 1这一条

    //注册成功之后要将密码加盐，写进数据库中
    userinfo.setPassword(PasswordUtils.encrypt(userinfo.getPassword()));
    return AjaxResult.success(userService.reg(userinfo));
}

@RequestMapping("/login")
public AjaxResult login(HttpServletRequest request, String username, String password) {
    //1.进行非空判断
    if (!StringUtils.hasLength(username) || !StringUtils.hasLength(password)){
        //说明没有传入任何参数
        return AjaxResult.fail(-1,"非法请求");
    }
    //2.查询数据库
    UserInfo userinfo = userService.getUserByName(username);
    if (userinfo != null && userinfo.getId() > 0) {
        //能获得id就说明用户名一定是在数据库中，说明是有效用户

        //使用自己写的加盐算法来判断登录
        //password是输入的待验证的明文密码，userinfo.getPassword()得到的是数据库中正确的最终密码格式
        if (PasswordUtils.check(password,userinfo.getPassword())){
            //将用户的session存储下来
            //参数为true：要是没有session就创建一个会话
            HttpSession session = request.getSession(true);
            //设置session的key和value
            session.setAttribute(ApplicationVariable.USER_SESSION_KEY,userinfo);
            //要是密码正确，在将数据返回之前，考虑到隐私，隐藏密码
            userinfo.setPassword("");
            return AjaxResult.success(userinfo);
        }
    }
    return AjaxResult.fail(0,null);
}

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

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;

//关闭spring security的验证
@SpringBootApplication(exclude = SecurityAutoConfiguration.class)
public class Demo3Application {
    public static void main(String[] args) {
        SpringApplication.run(Demo3Application.class, args);
    }
}

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@SpringBootTest
class Demo3ApplicationTests {

    @Test
    void contextLoads() {
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String str = "111";
        //进行加密
        String finalPassword = bCryptPasswordEncoder.encode(str);
        System.out.println(finalPassword);
        //验证密码
        String inputPassword1 = "123";
        String inputPassword2 = "111";
        //inputPassword是用户输入的密码（待验证），finalPassword是存储在数据库中的最终密码格式
        System.out.println(bCryptPasswordEncoder.matches(inputPassword1,finalPassword));
        System.out.println(bCryptPasswordEncoder.matches(inputPassword2,finalPassword));
    }

}