springboot如何实现注册加密与登录解密功能

这篇文章将为大家详细讲解有关springboot如何实现注册加密与登录解密功能，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。

创新互联是一家专注于成都网站建设、做网站与策划设计,永定网站建设哪家好?创新互联做网站,专注于网站建设10余年,网设计领域的专业建站公司;建站业务涵盖:永定等地区。永定做网站价格咨询:18982081108

前情提要：本demo是基于springboot+mybatis-plus实现加密,加密为主，全局异常处理，日志处理为辅，而登录密码加密是每个项目中必须要的，密码不可能明文存入数据，这样没有安全性。
涉及的功能，全局异常处理，日志处理，mybatis-plus实现与数据库的交互,密码加密,restful风格

涉及的工具：IDEA,postman,sqlyog（navicat）

1. 首先我们直接看效果吧，如果你不满意，也就没必要看了

如果这正是你想要的效果呢，那你可以继续看下面的内容了

2. 首先，我们看下pom.xml文件

以下依赖为所需的主要依赖

 4.0.0
 
 org.springframework.boot
 spring-boot-starter-parent
 2.2.4.RELEASE
  
 
 com.jgsu
 springboot_rsa_encryption
 0.0.1-SNAPSHOT
 springboot_encryption
 Demo project for Spring Boot
 
 1.8
 
 
 
 
 org.springframework.boot
 spring-boot-starter-web
 
 
 org.springframework.boot
 spring-boot-starter-test
 test
 
 
 
 org.springframework.boot
 spring-boot-devtools
 true
 
 
 
 mysql
 mysql-connector-java
 5.1.47
 
 
 
 org.projectlombok
 lombok
 1.16.20
 
 
 
 com.alibaba
 druid-spring-boot-starter
 1.1.10
 
 
 
 com.baomidou
 mybatis-plus-boot-starter
 3.2.0
 
 
 
 org.springframework.boot
 spring-boot-starter-security
 2.1.6.RELEASE
 
 
 
 com.alibaba
 fastjson
 1.2.51
 
 
 
 
 
 org.springframework.boot
 spring-boot-maven-plugin
 
 
 

3. 创建启动类SpringbootEncryptionApplication

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
@SpringBootApplication
@MapperScan("com.jgsu.mapper")
public class SpringbootEncryptionApplication {
 public static void main(String[] args) {
 SpringApplication.run(SpringbootEncryptionApplication.class, args);
 }

 /**
 * 将加密工具类加入IOC容器中,便于加密
 * */
 @Bean
 public BCryptPasswordEncoder encoder() {
 return new BCryptPasswordEncoder();
 }
}

4.实体类

这里只有用户名和密码(其他数据自己可扩展)

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("user")
public class User {
 @TableId(value = "id",type = IdType.AUTO)
 private int id;
 private String username;
 private String password;
}

5. service层(业务层)

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jgsu.entity.User;
import com.jgsu.exception.DataAddException;
import com.jgsu.exception.DataMatchException;
import com.jgsu.mapper.UserMapper;
import com.jgsu.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
@Slf4j
@Service
public class UserServiceImpl implements UserService {
 @Autowired
 UserMapper userMapper;
 // 数据加密，在启动类中已经注入进IOC容器中
 @Autowired
 private BCryptPasswordEncoder encoder;
 @Override
 public User userLogin(String username,String password) {
 // mybatis-plus的条件构造器，这里实现根据username查询
 QueryWrapper wrapper = new QueryWrapper();
 wrapper.eq("username", username);
 User userLogin = userMapper.selectOne(wrapper);
 /**
 * encoder.matches(password, userLogin.getPassword()，实现输入的密码与数据库中的密码进 
 * 行匹配,如果匹配成功则返回匹配的数据给controller层，如果失败则抛异常。
 * 为什么没盐，没有解密了?因为这个已经被CryptPasswordEncoder封装好了，
 * 在encoder.matches()方进行解密匹配完全帮你封装好了，所以不必考虑，
 * 只需要将前端传入的密码与数据库中加密后的密码进行匹配就行。
 * **/
 if (userLogin != null && encoder.matches(password, userLogin.getPassword())) {
 log.info("用户{}，登录成功",username);
 return userLogin;
 } else {
 log.error("用户名或密码错误");
 throw new DataMatchException("405", "用户名或密码错误");
 }
 }
 @Override
 public User userRegister(String username, String password) {
 User user = new User();
 user.setId(user.getId());
 user.setUsername(username);
 user.setPassword(encoder.encode(password));
 int i = userMapper.insert(user);
 if (i == 1){
 log.info("用户{}注册成功",username);
 return user;
 }else {
 log.error("服务器发生异常，注册失败");
 throw new DataAddException("403","注册失败");
 }
 }
}

6. mapper层

如果不了解，可以建议去看看mybatis-plus官方文档

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jgsu.entity.User;
import org.springframework.stereotype.Repository;
@Repository
public interface UserMapper extends BaseMapper {
}

7.controller层

import com.jgsu.entity.User;
import com.jgsu.service.UserService;
import com.jgsu.utils.CommonResult;
import com.jgsu.utils.ResultCode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/user")
public class UserController {
 @Autowired
 UserService userService;
 // 注册，基于restful风格
 @GetMapping("/register/{username}/{password}")
 public CommonResult register(@PathVariable("username") String username,@PathVariable("password") String password){
 User user = userService.userRegister(username, password);
 if (user != null){
 return CommonResult.success(ResultCode.SUCCESS);
 }else {
 return CommonResult.failed(ResultCode.FAILED);
 }
 }
 // 登录，基于restful风格
 @GetMapping("/login/{username}/{password}")
 public CommonResult login(@PathVariable("username") String username,@PathVariable("password") String password) {
 User userLogin = userService.userLogin(username,password);
 if (userLogin != null) {
 return CommonResult.success(ResultCode.SUCCESS);
 } else {
 return CommonResult.failed(ResultCode.USERNAME_OR_PASSWORD_ERROR);
 }
 }
}

8.配置类(返回json数据的类)

封装错误码的接口

public interface IErrorCode {
 long getState();
 String getMessage();
}

枚举了一些常用API操作码

public enum ResultCode implements IErrorCode {
 /**
 * 成功
 */
 SUCCESS(200, "ok"),
 /**
 * 失败
 */
 FAILED(500, "server error"),
 /**
 * 验证过期
 */
 VALIDATE_FAILED(404, "undefined"),
 /**
 * 未登录
 */
 UNAUTHORIZED(401, "未登录"),
 /**
 * 用户名或密码错误
 */
 USERNAME_OR_PASSWORD_ERROR(405, "用户名或密码错误"),
 /**
 * 数据查询错误
 */
 DATA_Not_Exist_ERROR(603, "数据不存在"),
 /**
 * 数据添加出现问题
 */
 DATA_ADD_ERROR(604, "数据添加异常"),
 /**
 * 文件
 */
 FILE_ERROR(605, "上传文件出现错误"),
 /**
 * 数据查询出现问题
 */
 IMAGE_ERROR(606, "图片处理出现错误"),
 /**
 * 权限不够
 */
 FORBIDDEN(403, "forbidden");
 private long state;
 private String stateInfo;
 ResultCode(long state, String stateInfo) {
 this.state = state;
 this.stateInfo = stateInfo;
 }
 @Override
 public long getState() {
 return state;
 }
 @Override
 public String getMessage() {
 return stateInfo;
 }
}

通用返回对象

public class CommonResult {
 private long state;
 private String stateInfo;
 private T data;
 public CommonResult() {
 }
 public CommonResult(long state, String stateInfo, T data) {
 this.state = state;
 this.stateInfo = stateInfo;
 this.data = data;
 }
 public CommonResult(long state, String stateInfo) {
 this.state = state;
 this.stateInfo = stateInfo;
 }
 /**
 * 成功返回结果
 *
 * @param data 获取的数据
 */
 public static  CommonResult success(T data) {
 return new CommonResult(ResultCode.SUCCESS.getState(), ResultCode.SUCCESS.getMessage(), data);
 }
 /**
 * 成功返回结果
 * @param data 获取的数据
 * @param message 提示信息
 * @return
 */
 public static  CommonResult success(T data, String message) {
 return new CommonResult(ResultCode.SUCCESS.getState(), message, data);
 }
 /**
 * 失败返回结果
 * @param errorCode 错误码
 */
 public static  CommonResult failed(IErrorCode errorCode) {
 return new CommonResult(errorCode.getState(), errorCode.getMessage(), null);
 }
 /**
 * 失败返回结果
 * @param message 提示信息
 */
 public static  CommonResult failed(String message) {
 return new CommonResult(ResultCode.FAILED.getState(), message, null);
 }
 /**
 * 失败返回结果
 * @param code
 * @param message
 */
 public static  CommonResult failed(int code, String message) {
 return failed(ResultCode.FAILED);
 }
 /**
 * 参数验证失败返回结果
 */
 public static  CommonResult validateFailed() {
 return failed(ResultCode.VALIDATE_FAILED);
 }
 /**
 * 参数验证失败返回结果
 * @param message 提示信息
 */
 public static  CommonResult validateFailed(String message) {
 return new CommonResult(ResultCode.VALIDATE_FAILED.getState(), message, null);
 }
 /**
 * 未登录返回结果
 */
 public static  CommonResult unauthorized(T data) {
 return new CommonResult(ResultCode.UNAUTHORIZED.getState(), ResultCode.UNAUTHORIZED.getMessage(), data);
 }
 /**
 * 未授权返回结果
 */
 public static  CommonResult forbidden(T data) {
 return new CommonResult(ResultCode.FORBIDDEN.getState(), ResultCode.FORBIDDEN.getMessage(), data);
 }
 public long getState() {
 return state;
 }
 public void setState(long state) {
 this.state = state;
 }
 public String getStateInfo() {
 return stateInfo;
 }
 public void setStateInfo(String stateInfo) {
 this.stateInfo = stateInfo;
 }
 public T getData() {
 return data;
 }
 public void setData(T data) {
 this.data = data;
 }
}

9. 异常类

全局异常拦截类

@Slf4j
@ControllerAdvice
@ResponseBody
public class GlobalExceptionHander {
 @ExceptionHandler(value = Exception.class)
 public CommonResult handlerException(Exception e){
 if (e instanceof DataAddException){
 log.error("【全局异常拦截】DataAddException: 请求方法 {}, 请求路径 {}",((DataAddException)e).getCode(),((DataAddException)e).getMessage());
 return CommonResult.failed(ResultCode.DATA_ADD_ERROR);
 }else if (e instanceof DataMatchException){
 log.error("【全局异常拦截】DataMatchException: 请求方法 {}, 请求路径 {}",((DataMatchException)e).getCode(),((DataMatchException)e).getMessage());
 return CommonResult.failed(ResultCode.USERNAME_OR_PASSWORD_ERROR);
 } else {
 log.error("服务器内部出错{}",e);
 return CommonResult.failed(ResultCode.FAILED);
 }
 }
}

自定义数据添加异常类

public class DataAddException extends RuntimeException {
 private String code;
 private String message;
 public DataAddException(String code, String message) {
 this.code = code;
 this.message = message;
 }
 public String getCode() {
 return code;
 }
 public void setCode(String code) {
 this.code = code;
 }
 @Override
 public String getMessage() {
 return message;
 }
 public void setMessage(String message) {
 this.message = message;
 }
}

自定义数据匹配异常类

public class DataMatchException extends RuntimeException {
 private String code;
 private String message;
 public DataMatchException(String code, String message) {
 this.code = code;
 this.message = message;
 }
 public String getCode() {
 return code;
 }
 public void setCode(String code) {
 this.code = code;
 }
 @Override
 public String getMessage() {
 return message;
 }
 public void setMessage(String message) {
 this.message = message;
 }
}

springboot是什么

springboot一种全新的编程规范，其设计目的是用来简化新Spring应用的初始搭建以及开发过程，SpringBoot也是一个服务于框架的框架，服务范围是简化配置文件。

关于“springboot如何实现注册加密与登录解密功能”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。