SpringBoot学习笔记

新建SpringBoot项目

阿里云地址：https://start.aliyun.com
异常消息处理

1. // 1.自定义异常类,继承RuntimeException
2. public class MyException extends RuntimeException{
3.     public MyException() {
4.     }
5. }
7. // 2.定义全局异常类
8. @RestControllerAdvice
9. public class GloabExceptionAdvice {
10.     //异常注解，value是要拦截的异常类，可以自定义，这里为拦截整个异常类
11.     @ExceptionHandler(value = Exception.class)
12.     public ResponseEntity<Map<String,Object>> exceptionHandler(Exception ex) {
13.         System.out.println("进入异常消息");
14.         ex.printStackTrace();
15.         return Result.res(HttpStatus.INTERNAL_SERVER_ERROR,false,ex.getMessage(),null,new Date());
16.     }
17. }
19. // 3.主动抛出异常
20. throw new MyException();

复制代码

异常处理类

1. //作为springmvc的异常处理器
2. //@ControllerAdvice
3. @RestControllerAdvice
4. public class ProjectExceptionAdvice {
5.     @ExceptionHandler
6.     public R doException(Exception ex) {
7.         //to do
8.         ex.printStackTrace();//控制台输出错误信息
9.         return new R("服务器故障，请稍后再试！")
10.     }
11. }

复制代码

消息返回结果类

1. public class R {
2.     private Boolean flag;
3.     private Object data;
4.     private String msg;
5.    
6.     public R() {}
7.    
8.     public R(Boolean flag) {
9.         this.flag = flag;
10.     }
11.    
12.     public R(Boolean flag, Object data) {
13.         this.flag = flag;
14.         this.data = data;
15.     }
16.    
17.     public R(String msg) {
18.         this.msg = msg;
19.     }
20. }

复制代码

表现层统一api返回数据

status - int, 状态码
success - boolean, 结果标识，错误情况下需为 false
message - string, 错误信息
time - datetime, 当前时间

返回json数据

1. {
2.     "status": 200,
3.     "success": true,
4.     "message": "register successful",
5.     "data": {
6.         "nickname ": " Jones "
7.         },
8.     "time": "2021-08-23 14:50:28"
9. }

复制代码

自定义返回数据类

1. public class R {
2.     private int status;
3.     private Boolean success;
4.     private Object data;
5.     private String message;
6.     private String time;
7.    
8.     public R() {}
9.    
10.     public R(Boolean success) {
11.         this.success = success;
12.     }
13.    
14.     public R(int status, Boolean success, String message, Object data, String time) {
15.         this.status = status;
16.         this.success = success;
17.         this.message = message;
18.         this.data = data;
19.         this.time = time;
20.     }
21.    
22.     public R(String message) {
23.         this.success = false;
24.         this.message = message;
25.     }
26. }

复制代码

基于ResponseEntity的自定义返回

1. @Data
2. public class Result{
3.     private String aaaa;
5.     public static ResponseEntity<Map<String,Object>> res(HttpStatus status, Boolean success, String message, Object data, Date time) {
6.         Map<String,Object> map = new HashMap<>();
7.         map.put("status",status.value());
8.         map.put("success",success);
9.         map.put("message",message);
10.         map.put("data",data);
11.         map.put("time",time);
12.         return new ResponseEntity<>(map, status);
13.     }
15.     public static ResponseEntity<Map<String,Object>> res(Boolean success, String message, Object data, Date time) {
16.         return res(HttpStatus.OK,success,message,data,time);
17.     }
19.     public static ResponseEntity<Map<String,Object>> res(Boolean success, String message, Object data) {
20.         return res(HttpStatus.OK,success,message,data,new Date());
21.     }
23.     public static ResponseEntity<Map<String,Object>> res(String message, Object data) {
24.         return res(HttpStatus.OK,true,message,data,new Date());
25.     }
26. }

复制代码

整合MyBatis

1、设置数据源参数

1. spring:
2.   datasource:
3.     driver-class-name: com.mysql.cj.jdbc.Driver
4.     url: jdbc:mysql://localhost:3306/databasename?serverTimezone=UTC
5.     username: root
6.     password: 123456

复制代码

2、定义数据层接口与映射配置

1. @Mapper
2. public interface UserDao {
3.    
4.     @Select("select * from user where id=#{id}")
5.     public User getById(Integer id);
6.    
7.     @Select("select * from user")
8.     public List<User> getAll();
9. }

复制代码

3、XML配置

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE mapper
3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5.    
6. <mapper namespace="com.banyu.achieve.xml.dao.IUserDao">
7.     <select id="findAll" resultType="com.banyu.achieve.xml.domain.User">
8.         select * from user;
9.     </select>
10.     <insert id="saveUser" parameterType="com.banyu.achieve.xml.domain.User" >
11.         
12.         <selectKey keyColumn="id" resultType="int" order="AFTER" keyProperty="id">
13.             select last_insert_id()
14.         </selectKey>
15.         insert into user(username,birthday,sex,address) values (#{username},#{birthday},#{sex},#{address})
16.     </insert>
17.     <update id="updateUser" parameterType="com.banyu.achieve.xml.dao.IUserDao">
18.         update user set username =#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id =#{id}
19.     </update>
20.     <select id="findUserByName" parameterType="String" resultType="user">
21.         
22.         
23.         select * from user where username like "%${name}%"
24.     </select>
26.     <select id="getTotal" resultType="int" >
27.         select count(*) from user
28.     </select>
30.     <delete id="deleteUser" parameterType="int">
31.         delete from user where id = #{id}
32.     </delete>
34.         <select id="findUserById" parameterType="int" resultType="user">
35.         select * from user where id = #{id}
36.     </select>
37. </mapper>

复制代码

Mybatis-plus

常用注解

1. @TableName("表名")   //当表名与实体类名不一致时，可以在实体类上加入@TableName（）声明
2. @TableId(type =IdType.AUTO)  //设置为默认主键，方式为自增
3. @TableId  //声明属性为表中的主键（若属性名称不为默认id）
4. @TableFieId("字段")  //当实体类属性与表字段不一致时，可以用来声明
5. @TableLogic   //指定逻辑删除字段

复制代码

自动填充

1. //创建时间
2. @TableField(fill = FieldFill.INSERT)
3. private Date createTime;
5. //更新时间
6. @TableField(fill = FieldFill.INSERT_UPDATE)
7. private Date updateTime;

复制代码

1. @Component // 一定不要忘记把处理器加到IOC容器中！
2. public class MyMetaObjectHandler implements MetaObjectHandler {
3.     // 插入时的填充策略
4.     @Override
5.     public void insertFill(MetaObject metaObject) {
6.         log.info("start insert fill.....");
7.         // setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject
8.         this.setFieldValByName("createTime",new Date(),metaObject);
9.         this.setFieldValByName("updateTime",new Date(),metaObject);
10.     }
11.     // 更新时的填充策略
12.     @Override
13.     public void updateFill(MetaObject metaObject) {
14.         log.info("start update fill.....");
15.         this.setFieldValByName("updateTime",new Date(),metaObject);
16.     }
17. }

复制代码

查询

查询单个

1. LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
2. queryWrapper.eq(User::getUsername,user.getUsername());
3. queryWrapper.eq(User::getPassword,user.getPassword());
4. User userDB = userMapper.selectOne(queryWrapper);
5. if (userDB!=null){
6.     return userDB;
7. }
8. throw new RuntimeException("登录失败！！");

复制代码

查询多个

1. userMapper.selectList(null);

复制代码

查询

1. @Test
2. public void testSelectById(){
3.     User user =userMapper.selectById(1);
4.     System.out.println(user)
5. }
7. //测试批量查询
8. @Test
9. public void testSelectByBatchId(){
10.     List<User> user =userMapper.selectBatchIds(Arrays.asList(1,2,3));
11.     users.forEach(System.out::println)
12. }
14. //条件查询
15. public void testSelectByBatchIds(){
16.     HashMap<String,Object> map=new HashMap<>();
17.     //自定义查询
18.     map.put("name","shuishui");
19.     map.put("age",3);
20.    
21.     List<User> user = userMapper.selectByMap(map);
22.     users.forEach(System.out::println);
23. }

复制代码

分页

添加分页拦截器配置

1. @Configuration
2. public class MPConfig {
4.     @Bean
5.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
6.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
7.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
8.         return interceptor;
9.     }
10. }

复制代码

分页功能实现

1. @Test
2. public void getByPage(current) {
3.     //page对象
4.     IPage page = new Page(1,5);
5.     userMapper.selectPage(page,null);
6.     System.out.println(page.getRecords());  //获取记录
7. }

复制代码

JWT



JWT结构

1.Header

1. {
2.     "alg": "HS256",
3.     "typ": "JWT"
4. }

复制代码

2.Payload

1. {
2.     "name": "admin",
3.     "admin": true
4. }

复制代码

3.Signature

header和payload的base64编码加上密钥

1. signature = HMACSHA256(base64UrlEncode(header)+"."+base64UrlEncode(payload),secret)

复制代码

引入JWT

• maven依赖
  

1. <dependency>
2.     <groupId>com.auth0</groupId>
3.     <artifactId>java-jwt</artifactId>
4.     <version>3.19.1</version>
5. </dependency>

复制代码

Token生成

1. public String getToken() {
2.     //获取时间
3.     Calendar instance = Calendar.getInstance();
4.     instance.add(Calendar.SECOND,20);  //20秒
5.     //生成token
6.     String token = JWT.create()
7.         .withClaim("userId", "1") //payload
8.         .withClaim("username", "admin") //注意类型
9.         .withExpiresAt(instance.getTime()) //令牌时间
10.         .sign(Algorithm.HMAC256("123key"));//签名
12.     System.out.println(token);
13.     return token;
14. }

复制代码

Token验证

1. public Boolean verifyToken(){
2.     //根据密钥构建验证
3.     JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("123key")).build();
4.     try {
5.         //验证token，如果验证失败则抛出异常
6.         DecodedJWT verify = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NTExMjI3NTgsInVzZXJJZCI6IjEiLCJ1c2VybmFtZSI6ImFkbWluIn0.4aLHFDuJMJnFWali_3BSryE9ezdj6twj4QZnlwTVWDw");
7.         //获取token里面的信息
8.         System.out.println(verify.getClaim("userId").asString());
9.         System.out.println(verify.getClaim("username").asString());
10.     }catch (Exception e) {
11.         //验证失败
12.         e.printStackTrace();
13.     }
14. }

复制代码

Token异常处理

验证token失败的时候抛出的异常

• 签名不一致异常
  

  SignatureVerificationException
  

  
  
• 令牌过期异常
  

  TokenExpiredException
  

  
  
• 算法不匹配异常
  

  AlgorithmMismatchException
  

  
  
• 失效的payload异常
  

  InvalidClaimException
  

  
  

JWTUtil封装

1. public class JWTUtil {
3.     //signature密钥
4.     private static final String SIGN = "123key";
6.     /**
7.      * 生成token
8.      * @param map
9.      * @return token
10.      */
11.     public static String getToken(Map<String,String> map){
13.         //生成过期时间
14.         Calendar instance = Calendar.getInstance();
15.         instance.add(Calendar.DATE,7);
17.         JWTCreator.Builder builder = JWT.create();
19.         map.forEach(( k, v ) -> {
20.             builder.withClaim(k,v);
21.         });
22.         String token = builder.withExpiresAt(instance.getTime()).sign(Algorithm.HMAC256(SIGN));
24.         return token;
25.     }
27.     /**
28.      * 验证token并返回token的信息
29.      * @param token
30.      * @return token内信息
31.      */
32.     public static DecodedJWT verifyToken(String token) {
33.         return JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
34.     }
35. }

复制代码

Controller逻辑

1. @RestController
2. public class UserController {
3.     @Autowired
4.     private UserService userService;
5.     @PostMapping("/user/login")
6.     public ResponseEntity<Map<String,Object>> login(@RequestBody User user, HttpServletResponse response){
7.         //返回数据的map
8.         Map<String,Object> map = new HashMap<>();
9.         //生成token用map
10.         Map<String,String> payload = new HashMap<>();
11.         try {
12.             User userDB = userService.login(user);
13.             //生成token
14.             payload.put("userId", String.valueOf(userDB.getId()));
15.             payload.put("username", userDB.getUsername());
16.             String token = JWTUtil.getToken(payload);
17.             map.put("state",true);
18.             map.put("message","登录成功！！");
19.             map.put("token",token);
20.             //设置返回请求头
21.             response.setHeader("token",token);
22.         }catch (Exception e){
23.             //            e.printStackTrace();
24.             map.put("state",false);
25.             map.put("message",e.getMessage());
26.         }
28.         return new ResponseEntity<>(map, HttpStatus.OK);
29.     }
30.     @PostMapping("/shop/test")
31.     public ResponseEntity<Map<String,Object>> test() {
32.         Map<String,Object> map = new HashMap<>();
33.         map.put("state",true);
34.         map.put("message","请求成功");
35.         return new ResponseEntity<>(map,HttpStatus.OK);
36.     }
37. }

复制代码

Interceptor拦截器

1. public class JWTInterceptor implements HandlerInterceptor {
2.     @Override
3.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
4.         Map<String,Object> map = new HashMap<>();
5.         String token = request.getHeader("token");
6.         try {
7.             DecodedJWT decodedJWT = JWTUtil.verifyToken(token);
8.             return true; //正常返回true放行
9.         }catch (SignatureVerificationException e){
10.             e.printStackTrace();
11.             map.put("message","无效签名");
12.         }catch (TokenExpiredException e){
13.             e.printStackTrace();
14.             map.put("message","token过期");
15.         }catch (AlgorithmMismatchException e){
16.             e.printStackTrace();
17.             map.put("message","token算法不一致");
18.         }catch (Exception e){
19.             e.printStackTrace();
20.             map.put("message","无效签名");
21.         }
22.         map.put("state",false);
23.         //jackson转换 map转json
24.         String json = new ObjectMapper().writeValueAsString(map);
25.         response.setContentType("application/json;charset=UTF-8"); //注意编码
26.         response.getWriter().println(json);
27.         return false; //拦截
28.     }
29. }

复制代码

配置添加拦截器

1. @Configuration
2. public class InterceptorConfig implements WebMvcConfigurer {
3.     @Override
4.     public void addInterceptors(InterceptorRegistry registry) {
5.         //添加过滤规则
6.         registry.addInterceptor(new JWTInterceptor())
7.                 .addPathPatterns("/**") //所有路径都拦截
8.                 .excludePathPatterns("/user/**"); //所有用户都放行
9.     }
10. }

复制代码

CORS跨域配置

全局配置

1. @Configuration
2. public class CorsConfig {
4.     @Bean
5.     public CorsFilter corsFilter() {
6.         UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
7.         CorsConfiguration corsConfiguration = new CorsConfiguration();
8.         corsConfiguration.addAllowedOrigin("*"); //允许任何域名使用
9.         corsConfiguration.addAllowedHeader("*"); //允许任何请求头
10.         corsConfiguration.addAllowedMethod("*"); //允许任何请求方式
11.         source.registerCorsConfiguration("/**",corsConfiguration); //处理所有请求的跨域配置
12.         return new CorsFilter(source);
13.     }
14. }

复制代码

局部配置

1. @CrossOrigin //直接加载controller上
2. @Controller

复制代码

JJWT

安装maven依赖

1. <dependency>
2.     <groupId>io.jsonwebtoken</groupId>
3.     <artifactId>jjwt</artifactId>
4.     <version>0.9.1</version>
5. </dependency>

复制代码

生成Token

1. @Test
2. void getToken() {
3.     long time = 1000*60*60*24;  //过期时间
4.     String sign = "123key";  //签名密钥
5.     JwtBuilder jwtBuilder = Jwts.builder();  //jwt构造器
6.     String jwtToken = jwtBuilder
7.         .setHeaderParam("typ","JWT")  //设置header
8.         .setHeaderParam("alg", "HS256")
9.         .claim("username","tom")   //设置payload
10.         .claim("role","admin")
11.         .setSubject("admin-test")  //设置主题
12.         .setExpiration(new Date(System.currentTimeMillis()+time))  //设置过期时间，当前系统时间加上24小时
13.         .setId(UUID.randomUUID().toString())  //设置id
14.         .signWith(SignatureAlgorithm.HS256,sign)  //签名，对应算法
15.         .compact();  //组合前面的内容
16.     System.out.println(jwtToken);
17. }

复制代码

验证解析Token

1. @Test
2. public void parse() {
3.     String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6InRvbSIsInJvbGUiOiJhZG1pbiIsInN1YiI6ImFkbWluLXRlc3QiLCJleHAiOjE2NTE0MTg1MjQsImp0aSI6ImVhNTA1NjljLTYzYTYtNGEzZC1hNTc3LWI0NDViZDBmOTcwYiJ9.5dRw8edgag5dsRmTBr2XXaUC8RU6nypMBcqOd8ZcuJo";
4.     String sign = "123key";
5.     JwtParser jwtParser = Jwts.parser();
6.     Jws<Claims> claimsJws = jwtParser.setSigningKey(sign).parseClaimsJws(token);
7.     Claims claims = claimsJws.getBody();
8.     System.out.println(claims.get("username"));
9.     System.out.println(claims.get("role"));
10.     System.out.println(claims.getSubject());
11.     System.out.println(claims.getExpiration().toLocaleString());
12. }

复制代码

自定义异常和404异常

自定义异常类

1. package com.meteor.exception;
3. //继承RuntimeException
4. public class NotFoundException extends RuntimeException{
5.     //继承父类的有参构造
6.     public NotFoundException(String message) {
7.         super(message);
8.     }
9. }

复制代码

全局异常拦截器

1. @RestControllerAdvice
2. public class GlobalExceptionResolver {
4.     @ExceptionHandler(TokenExceptio.class)  //权限校验异常
5.     public ResponseEntity<Map<String,Object>> tokenExceptionHandler(Exception ex) {
6.         System.out.println("进入token权限校验异常");
7.         Map<String,Object> map  = new HashMap<>();
8.         map.put("message",ex.getMessage());
9.         map.put("state",401);
10.         return new ResponseEntity<>(map, HttpStatus.UNAUTHORIZED);
11.     }
13.     @ExceptionHandler(NotFoundException.class)  //404自定义异常
14.     public ResponseEntity<String> notFoundExceptionHandler(Exception ex) {
15.         System.out.println("进入资源未找到异常");
16.         return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
17.     }
19.     @ExceptionHandler(Exception.class)  //用来处理所有异常
20.     public ResponseEntity<String> exceptionHandler(Exception ex) {
21.         System.out.println("进入自定义异常");
22.         return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
23.     }
24. }

复制代码

权限拦截器

1. //验证JWT，继承HandlerInterceptor
2. public class JWTInterceptor implements HandlerInterceptor {
3.     @Override
4.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
5.         Map<String,Object> map = new HashMap<>();
6.         String token = request.getHeader("token");
7.         String msg = "";
8.         try {
9.             DecodedJWT decodedJWT = JWTUtil.verifyToken(token);
10.             return true;
11.         }catch (SignatureVerificationException e){
12.             e.printStackTrace();
13.             msg = "无效签名"
14.         }catch (TokenExpiredException e){
15.             e.printStackTrace();
16.             msg = "token过期"
17.         }catch (AlgorithmMismatchException e){
18.             e.printStackTrace();
19.             msg = "token算法不一致"
20.         }catch (Exception e){
21.             e.printStackTrace();
22.             msg = "无效签名"
23.         }
24.         throw new TokenExceptio(msg);  //直接抛出自定义异常
25.     }
26. }

复制代码

将拦截器添加到拦截器配置

1. @Configuration
2. public class InterceptorConfig implements WebMvcConfigurer {
3.     @Override
4.     public void addInterceptors(InterceptorRegistry registry) {
5.         registry.addInterceptor(new JWTInterceptor())  //自定义拦截器
6.                 .addPathPatterns("/**")  //添加拦截链接
7.                 .excludePathPatterns("/user/**");   //添加排除链接
8.     }
9. }

复制代码

自定义错误异常控制器

1. @RestController
2. @RequestMapping({"${server.error.path:${error.path:/error}}"})
3. public class MyErrorController implements ErrorController {
5.     @RequestMapping
6.     public ResponseEntity<Map<String,Object>> error(HttpServletRequest request) {
7.         HttpStatus status = this.getStatus(request);
8.         Map<String,Object> map = new HashMap<>();
9.         map.put("status",status.value());
10.         if (HttpStatus.NOT_FOUND.equals(status)) {
11.             map.put("message","请求资源不存在");
12.         } else if (HttpStatus.UNAUTHORIZED.equals(status)) {
13.             map.put("message","账号权限不足");
14.         }
15.         return new ResponseEntity<>(map,HttpStatus.NOT_FOUND);
16.     }
18.     public HttpStatus getStatus(HttpServletRequest request) {
19.         Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
20.         System.out.println("权限state：" +  statusCode);
21.         if (statusCode == null) {
22.             return HttpStatus.INTERNAL_SERVER_ERROR;
23.         } else {
24.             try {
25.                 return HttpStatus.valueOf(statusCode);
26.             } catch (Exception var4) {
27.                 return HttpStatus.INTERNAL_SERVER_ERROR;
28.             }
29.         }
30.     }
31. }

复制代码

hutool－all工具包

https://zhuanlan.zhihu.com/p/372359362
引入Hutool

1. <dependency>
2.     <groupId>cn.hutool</groupId>
3.     <artifactId>hutool-all</artifactId>
4.     <version>5.6.5</version>
5. </dependency>

复制代码

Hibernate.validator

常用注解

注解释义@Nul被注释的元素必须为 null@NotNull被注释的元素必须不为 null@AssertTrue被注释的元素必须为 true@AssertFalse被注释的元素必须为 false@Min(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值@Max(value)被注释的元素必须是一个数字，其值必须小于等于指定的最大值@DecimalMin(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值@DecimalMax(value)被注释的元素必须是一个数字，其值必须小于等于指定的最大值@Size(max, min)被注释的元素的大小必须在指定的范围内，元素必须为集合，代表集合个数@Digits (integer, fraction)被注释的元素必须是一个数字，其值必须在可接受的范围内@Past被注释的元素必须是一个过去的日期@Future被注释的元素必须是一个将来的日期@Email被注释的元素必须是电子邮箱地址@Length(min=, max=)被注释的字符串的大小必须在指定的范围内，必须为数组或者字符串，若微数组则表示为数组长度，字符串则表示为字符串长度@NotEmpty被注释的字符串的必须非空@Range(min=, max=)被注释的元素必须在合适的范围内@NotBlank被注释的字符串的必须非空@Pattern(regexp = )正则表达式校验@Valid对象级联校验,即校验对象中对象的属性使用步骤

1、在Employee类上加上具体的约束注解。

1. public class Employee {
2.    @Null
3.    private Integer id;
4.    
5.    @NotNull
6.    private Integer parent_id;
7.    
8.    @NotBlank
9.    private String name;
11.    @PastOrPresent
12.    private LocalDateTime createtime;
13. }

复制代码

2、在controller的类上加上@Validated注解，标注这个类需要校验。在需要校验的参数前面加上@Valid注解，使这个实体类的属性得到校验。

1. @RestController
2. @Validated
3. public class TestController2 {
5.     @PostMapping("/add")
6.     public Object add(@RequestBody @Valid Employee employee){
7.         return "ok";
8.     }
9. }

复制代码

3、Validator的全局异常捕获

1. @RestControllerAdvice
2. public class GlobalExceptionHandler {
3.     @ExceptionHandler(value = {VerifyEXception.class, MethodArgumentNotValidException.class})
4.     public ResponseEntity<Map<String,Object>> verifyEceptionHandler(Exception ex) {
5.         System.out.println("进入数据校验失败异常");
6.         //获取valid的message
7.         String msg = ((MethodArgumentNotValidException) ex).getFieldError().getDefaultMessage();
8.         return Result.res(HttpStatus.UNPROCESSABLE_ENTITY,false,msg,null,new Date());
9.     }
10. }
12. @ExceptionHandler(MethodArgumentNotValidException.class)
13. @ResponseBody
14. public ResponseEntity handleBindException(MethodArgumentNotValidException ex) {
15.     FieldError fieldError = ex.getBindingResult().getFieldError();
16.     log.warn("参数校验异常:{}({})", fieldError.getDefaultMessage(),fieldError.getField());
17.     return ResponseEntity.ok(Response.fail(211,fieldError.getDefaultMessage(),fieldError.getDefaultMessage()));
18. }

复制代码

Get请求

1. @RestController
2. @RequestMapping("/test")
3. @Validated
4. public class TestController {
6.     /**
7.      * 测试校验框架返回结果格式
8.      */
9.     @GetMapping(value = "/validator2")
10.     public String testValidator2(@NotBlank(message = "姓名不能为空") String name){
11.         return "校验成功...";
12.     }
14. }

复制代码

Annotation

权限注解，用于Contoller方法上，在拦截器preHandle中进行权限校验，原理是获取方法上的权限注解，根据注解的值进行校验。

1. @Target(ElementType.METHOD)                                // 该注解可作用的目标
2. @Retention(RetentionPolicy.RUNTIME)                // 作用时机
3. public @interface AuthCheck {
5.     String value() default "";  // 默认为空
7. }

复制代码

校验注解

1. private Optional<AuthCheck> getAuthCheck(Object handler) {
2.     if (handler instanceof HandlerMethod) {
3.         HandlerMethod handlerMethod = (HandlerMethod) handler;
4.         AuthCheck authCheck = handlerMethod.getMethod().getAnnotation(AuthCheck.class);
5.         if (authCheck == null) {
6.             return Optional.empty();
7.         }
8.         return Optional.of(authCheck);
9.     }
10.     return Optional.empty();
11. }

复制代码

调用方法

1. Optional<AuthCheck> authCheck = this.getAuthCheck(handler);
2. if (!authCheck.isPresent()) {
3.     return true;
4. }

复制代码

ThreadLocal

一、ThreadLocal简介

多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。
　　ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一乐ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题，如下图所示：

ThreadLocal常用方法：

• public void set(T value)       设置当前线程的线程句不变量的值
  
• public T get()                       返回当前线程所对应的线程局部变量的值
  

二、Springboot应用ThreadLocal

使用ThreadLocal保存用户信息

客户端发送的每次Http请求，对应的在服务端都会分配一个新的线程来处理，在处理过程中设计到的后端代码都属于同一个线程，可以通过一下代码获取线程ID.

1. Thread.currentThread().getId();  //获取当前线程ID

复制代码

我们可以配置拦截器，通过preHandle方法中的header来获取User信息，并调用ThreadLocal的set方法来设置当前线程的线程局部变量的值（用户信息User），然后就能在后续的Controller方法中通过ThreadLocal的get方法来获取到用户信息（可实现权限控制）
编写User实体类

1. @Data
2. public class User() {
3.     private Long id;
4.     private String username;
5.     private String password;
6.     private Integer type;     //用户类型，用于权限校验
7. }

复制代码

编写AuthUser类，封装ThreadLocal来操作用户数据

1. public class AuthUser {
2.     private static final ThreadLocal<User> threadLocal = new ThreadLocal() ;
4.     public static User get() {
5.         return threadLocal.get();
6.     }
8.     public static void set(User value) {
9.         threadLocal.set(value);
10.     }
12.     public static void remove() {
13.         threadLocal.remove();
14.     }
16.     public static Long getUserId() {
17.         try {
18.             return threadLocal.get().getUid();
19.         } catch (Exception e) {
20.             throw new TokenCheckException("铁子,请先登录再操作");
21.         }
22.     }
24. }

复制代码

Redis

基本操作

1. //增
2. redisTemplate.opsForValue().put("key","value");
3. //删
4. redisTemplate.delete(key);
5. //改
6. redisTemplate.opsForValue().set("key","value");
7. //查
8. redisTemplate.opsForValue().get("key");
9. //是否存在
10. redisTemplate.hasKey(key);
11. //设置过期时间
12. redisTemplate.expire(key, timeout, unit);
13. redisTemplate.expireAt(key, date);

复制代码

使用redis实现登录

登录成功将用户信息存入redis
redis工具类

1. @Component
2. @SuppressWarnings({"unchecked", "all"})
3. public class RedisUtils {
4.     private static final Logger log = LoggerFactory.getLogger(RedisUtils.class);
5.     private RedisTemplate<String, String> redisTemplate;
7.     public RedisUtils(RedisTemplate<String, String> redisTemplate) {
8.         this.redisTemplate = redisTemplate;
9.     }
11.     /**
12.      * 指定缓存失效时间
13.      *
14.      * @param key  键
15.      * @param time 时间(秒)
16.      */
17.     public boolean expire(String key, long time) {
18.         try {
19.             if (time > 0) {
20.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
21.             }
22.         } catch (Exception e) {
23.             log.error(e.getMessage(), e);
24.             return false;
25.         }
26.         return true;
27.     }
29.     /**
30.      * 指定缓存失效时间
31.      *
32.      * @param key      键
33.      * @param time     时间(秒)
34.      * @param timeUnit 单位
35.      */
36.     public boolean expire(String key, long time, TimeUnit timeUnit) {
37.         try {
38.             if (time > 0) {
39.                 redisTemplate.expire(key, time, timeUnit);
40.             }
41.         } catch (Exception e) {
42.             log.error(e.getMessage(), e);
43.             return false;
44.         }
45.         return true;
46.     }
48.     /**
49.      * 根据 key 获取过期时间
50.      *
51.      * @param key 键 不能为null
52.      * @return 时间(秒) 返回0代表为永久有效
53.      */
54.     public long getExpire(String key) {
55.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
56.     }
58.     /**
59.      * 查找匹配key
60.      *
61.      * @param pattern key
62.      * @return /
63.      */
64.     public List<String> scan(String pattern) {
65.         ScanOptions options = ScanOptions.scanOptions().match(pattern).build();
66.         RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
67.         RedisConnection rc = Objects.requireNonNull(factory).getConnection();
68.         Cursor<byte[]> cursor = rc.scan(options);
69.         List<String> result = new ArrayList<>();
70.         while (cursor.hasNext()) {
71.             result.add(new String(cursor.next()));
72.         }
73.         try {
74.             RedisConnectionUtils.releaseConnection(rc, factory);
75.         } catch (Exception e) {
76.             log.error(e.getMessage(), e);
77.         }
78.         return result;
79.     }
81.     /**
82.      * 分页查询 key
83.      *
84.      * @param patternKey key
85.      * @param page       页码
86.      * @param size       每页数目
87.      * @return /
88.      */
89.     public List<String> findKeysForPage(String patternKey, int page, int size) {
90.         ScanOptions options = ScanOptions.scanOptions().match(patternKey).build();
91.         RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
92.         RedisConnection rc = Objects.requireNonNull(factory).getConnection();
93.         Cursor<byte[]> cursor = rc.scan(options);
94.         List<String> result = new ArrayList<>(size);
95.         int tmpIndex = 0;
96.         int fromIndex = page * size;
97.         int toIndex = page * size + size;
98.         while (cursor.hasNext()) {
99.             if (tmpIndex >= fromIndex && tmpIndex < toIndex) {
100.                 result.add(new String(cursor.next()));
101.                 tmpIndex++;
102.                 continue;
103.             }
104.             // 获取到满足条件的数据后,就可以退出了
105.             if (tmpIndex >= toIndex) {
106.                 break;
107.             }
108.             tmpIndex++;
109.             cursor.next();
110.         }
111.         try {
112.             RedisConnectionUtils.releaseConnection(rc, factory);
113.         } catch (Exception e) {
114.             log.error(e.getMessage(), e);
115.         }
116.         return result;
117.     }
119.     /**
120.      * 判断key是否存在
121.      *
122.      * @param key 键
123.      * @return true 存在 false不存在
124.      */
125.     public boolean hasKey(String key) {
126.         try {
127.             return redisTemplate.hasKey(key);
128.         } catch (Exception e) {
129.             log.error(e.getMessage(), e);
130.             return false;
131.         }
132.     }
134.     /**
135.      * 删除缓存
136.      *
137.      * @param key 可以传一个值 或多个
138.      */
139.     public void del(String... keys) {
140.         if (keys != null && keys.length > 0) {
141.             if (keys.length == 1) {
142.                 boolean result = redisTemplate.delete(keys[0]);
143.                 log.debug("--------------------------------------------");
144.                 log.debug(new StringBuilder("删除缓存：").append(keys[0]).append("，结果：").append(result).toString());
145.                 log.debug("--------------------------------------------");
146.             } else {
147.                 Set<String> keySet = new HashSet<>();
148.                 for (String key : keys) {
149.                     keySet.addAll(redisTemplate.keys(key));
150.                 }
151.                 long count = redisTemplate.delete(keySet);
152.                 log.debug("--------------------------------------------");
153.                 log.debug("成功删除缓存：" + keySet.toString());
154.                 log.debug("缓存删除数量：" + count + "个");
155.                 log.debug("--------------------------------------------");
156.             }
157.         }
158.     }
160.     // ============================String=============================
162.     /**
163.      * 普通缓存获取
164.      *
165.      * @param key 键
166.      * @return 值
167.      */
168.     public String get(String key) {
169.         return key == null ? null : redisTemplate.opsForValue().get(key);
170.     }
172.     /**
173.      * 批量获取
174.      *
175.      * @param keys
176.      * @return
177.      */
178.     public List<Object> multiGet(List<String> keys) {
179.         List list = redisTemplate.opsForValue().multiGet(Sets.newHashSet(keys));
180.         List resultList = Lists.newArrayList();
181.         Optional.ofNullable(list).ifPresent(e-> list.forEach(ele-> Optional.ofNullable(ele).ifPresent(resultList::add)));
182.         return resultList;
183.     }
185.     /**
186.      * 普通缓存放入
187.      *
188.      * @param key   键
189.      * @param value 值
190.      * @return true成功 false失败
191.      */
192.     public boolean set(String key, String value) {
193.         try {
194.             redisTemplate.opsForValue().set(key, value);
195.             return true;
196.         } catch (Exception e) {
197.             log.error(e.getMessage(), e);
198.             return false;
199.         }
200.     }
202.     /**
203.      * 普通缓存放入并设置时间
204.      *
205.      * @param key   键
206.      * @param value 值
207.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
208.      * @return true成功 false 失败
209.      */
210.     public boolean set(String key, String value, long time) {
211.         try {
212.             if (time > 0) {
213.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
214.             } else {
215.                 set(key, value);
216.             }
217.             return true;
218.         } catch (Exception e) {
219.             log.error(e.getMessage(), e);
220.             return false;
221.         }
222.     }
224.     /**
225.      * 普通缓存放入并设置时间
226.      *
227.      * @param key      键
228.      * @param value    值
229.      * @param time     时间
230.      * @param timeUnit 类型
231.      * @return true成功 false 失败
232.      */
233.     public boolean set(String key, String value, long time, TimeUnit timeUnit) {
234.         try {
235.             if (time > 0) {
236.                 redisTemplate.opsForValue().set(key, value, time, timeUnit);
237.             } else {
238.                 set(key, value);
239.             }
240.             return true;
241.         } catch (Exception e) {
242.             log.error(e.getMessage(), e);
243.             return false;
244.         }
245.     }
247.     // ================================Map=================================
249.     /**
250.      * HashGet
251.      *
252.      * @param key  键 不能为null
253.      * @param item 项 不能为null
254.      * @return 值
255.      */
256.     public Object hget(String key, String item) {
257.         return redisTemplate.opsForHash().get(key, item);
258.     }
260.     /**
261.      * 获取hashKey对应的所有键值
262.      *
263.      * @param key 键
264.      * @return 对应的多个键值
265.      */
266.     public Map<Object, Object> hmget(String key) {
267.         return redisTemplate.opsForHash().entries(key);
269.     }
271.     /**
272.      * HashSet
273.      *
274.      * @param key 键
275.      * @param map 对应多个键值
276.      * @return true 成功 false 失败
277.      */
278.     public boolean hmset(String key, Map<String, Object> map) {
279.         try {
280.             redisTemplate.opsForHash().putAll(key, map);
281.             return true;
282.         } catch (Exception e) {
283.             log.error(e.getMessage(), e);
284.             return false;
285.         }
286.     }
288.     /**
289.      * HashSet 并设置时间
290.      *
291.      * @param key  键
292.      * @param map  对应多个键值
293.      * @param time 时间(秒)
294.      * @return true成功 false失败
295.      */
296.     public boolean hmset(String key, Map<String, Object> map, long time) {
297.         try {
298.             redisTemplate.opsForHash().putAll(key, map);
299.             if (time > 0) {
300.                 expire(key, time);
301.             }
302.             return true;
303.         } catch (Exception e) {
304.             log.error(e.getMessage(), e);
305.             return false;
306.         }
307.     }
309.     /**
310.      * 向一张hash表中放入数据,如果不存在将创建
311.      *
312.      * @param key   键
313.      * @param item  项
314.      * @param value 值
315.      * @return true 成功 false失败
316.      */
317.     public boolean hset(String key, String item, String value) {
318.         try {
319.             redisTemplate.opsForHash().put(key, item, value);
320.             return true;
321.         } catch (Exception e) {
322.             log.error(e.getMessage(), e);
323.             return false;
324.         }
325.     }
327.     /**
328.      * 向一张hash表中放入数据,如果不存在将创建
329.      *
330.      * @param key   键
331.      * @param item  项
332.      * @param value 值
333.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
334.      * @return true 成功 false失败
335.      */
336.     public boolean hset(String key, String item, String value, long time) {
337.         try {
338.             redisTemplate.opsForHash().put(key, item, value);
339.             if (time > 0) {
340.                 expire(key, time);
341.             }
342.             return true;
343.         } catch (Exception e) {
344.             log.error(e.getMessage(), e);
345.             return false;
346.         }
347.     }
349.     /**
350.      * 删除hash表中的值
351.      *
352.      * @param key  键 不能为null
353.      * @param item 项 可以使多个 不能为null
354.      */
355.     public void hdel(String key, String... item) {
356.         redisTemplate.opsForHash().delete(key, item);
357.     }
359.     /**
360.      * 判断hash表中是否有该项的值
361.      *
362.      * @param key  键 不能为null
363.      * @param item 项 不能为null
364.      * @return true 存在 false不存在
365.      */
366.     public boolean hHasKey(String key, String item) {
367.         return redisTemplate.opsForHash().hasKey(key, item);
368.     }
370.     /**
371.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
372.      *
373.      * @param key  键
374.      * @param item 项
375.      * @param by   要增加几(大于0)
376.      * @return
377.      */
378.     public double hincr(String key, String item, double by) {
379.         return redisTemplate.opsForHash().increment(key, item, by);
380.     }
382.     /**
383.      * hash递减
384.      *
385.      * @param key  键
386.      * @param item 项
387.      * @param by   要减少记(小于0)
388.      * @return
389.      */
390.     public double hdecr(String key, String item, double by) {
391.         return redisTemplate.opsForHash().increment(key, item, -by);
392.     }
394.     // ============================set=============================
396.     /**
397.      * 根据key获取Set中的所有值
398.      *
399.      * @param key 键
400.      * @return
401.      */
402.     public Set<String> sGet(String key) {
403.         try {
404.             return redisTemplate.opsForSet().members(key);
405.         } catch (Exception e) {
406.             log.error(e.getMessage(), e);
407.             return null;
408.         }
409.     }
411.     /**
412.      * 根据value从一个set中查询,是否存在
413.      *
414.      * @param key   键
415.      * @param value 值
416.      * @return true 存在 false不存在
417.      */
418.     public boolean sHasKey(String key, String value) {
419.         try {
420.             return redisTemplate.opsForSet().isMember(key, value);
421.         } catch (Exception e) {
422.             log.error(e.getMessage(), e);
423.             return false;
424.         }
425.     }
427.     /**
428.      * 将数据放入set缓存
429.      *
430.      * @param key    键
431.      * @param values 值 可以是多个
432.      * @return 成功个数
433.      */
434.     public long sSet(String key, String... values) {
435.         try {
436.             return redisTemplate.opsForSet().add(key, values);
437.         } catch (Exception e) {
438.             log.error(e.getMessage(), e);
439.             return 0;
440.         }
441.     }
443.     /**
444.      * 将set数据放入缓存
445.      *
446.      * @param key    键
447.      * @param time   时间(秒)
448.      * @param values 值 可以是多个
449.      * @return 成功个数
450.      */
451.     public long sSetAndTime(String key, long time, String... values) {
452.         try {
453.             Long count = redisTemplate.opsForSet().add(key, values);
454.             if (time > 0) {
455.                 expire(key, time);
456.             }
457.             return count;
458.         } catch (Exception e) {
459.             log.error(e.getMessage(), e);
460.             return 0;
461.         }
462.     }
464.     /**
465.      * 获取set缓存的长度
466.      *
467.      * @param key 键
468.      * @return
469.      */
470.     public long sGetSetSize(String key) {
471.         try {
472.             return redisTemplate.opsForSet().size(key);
473.         } catch (Exception e) {
474.             log.error(e.getMessage(), e);
475.             return 0;
476.         }
477.     }
479.     /**
480.      * 移除值为value的
481.      *
482.      * @param key    键
483.      * @param values 值 可以是多个
484.      * @return 移除的个数
485.      */
486.     public long setRemove(String key, Object... values) {
487.         try {
488.             Long count = redisTemplate.opsForSet().remove(key, values);
489.             return count;
490.         } catch (Exception e) {
491.             log.error(e.getMessage(), e);
492.             return 0;
493.         }
494.     }
496.     // ===============================list=================================
498.     /**
499.      * 获取list缓存的内容
500.      *
501.      * @param key   键
502.      * @param start 开始
503.      * @param end   结束 0 到 -1代表所有值
504.      * @return
505.      */
506.     public List<String> lGet(String key, long start, long end) {
507.         try {
508.             return redisTemplate.opsForList().range(key, start, end);
509.         } catch (Exception e) {
510.             log.error(e.getMessage(), e);
511.             return null;
512.         }
513.     }
515.     /**
516.      * 获取list缓存的长度
517.      *
518.      * @param key 键
519.      * @return
520.      */
521.     public long lGetListSize(String key) {
522.         try {
523.             return redisTemplate.opsForList().size(key);
524.         } catch (Exception e) {
525.             log.error(e.getMessage(), e);
526.             return 0;
527.         }
528.     }
530.     /**
531.      * 通过索引 获取list中的值
532.      *
533.      * @param key   键
534.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
535.      * @return
536.      */
537.     public Object lGetIndex(String key, long index) {
538.         try {
539.             return redisTemplate.opsForList().index(key, index);
540.         } catch (Exception e) {
541.             log.error(e.getMessage(), e);
542.             return null;
543.         }
544.     }
546.     /**
547.      * 将list放入缓存
548.      *
549.      * @param key   键
550.      * @param value 值
551.      * @return
552.      */
553.     public boolean lSet(String key, String value) {
554.         try {
555.             redisTemplate.opsForList().rightPush(key, value);
556.             return true;
557.         } catch (Exception e) {
558.             log.error(e.getMessage(), e);
559.             return false;
560.         }
561.     }
563.     /**
564.      * 将list放入缓存
565.      *
566.      * @param key   键
567.      * @param value 值
568.      * @param time  时间(秒)
569.      * @return
570.      */
571.     public boolean lSet(String key, String value, long time) {
572.         try {
573.             redisTemplate.opsForList().rightPush(key, value);
574.             if (time > 0) {
575.                 expire(key, time);
576.             }
577.             return true;
578.         } catch (Exception e) {
579.             log.error(e.getMessage(), e);
580.             return false;
581.         }
582.     }
584.     /**
585.      * 将list放入缓存
586.      *
587.      * @param key   键
588.      * @param value 值
589.      * @return
590.      */
591.     public boolean lSet(String key, List<String> value) {
592.         try {
593.             redisTemplate.opsForList().rightPushAll(key, value);
594.             return true;
595.         } catch (Exception e) {
596.             log.error(e.getMessage(), e);
597.             return false;
598.         }
599.     }
601.     /**
602.      * 将list放入缓存
603.      *
604.      * @param key   键
605.      * @param value 值
606.      * @param time  时间(秒)
607.      * @return
608.      */
609.     public boolean lSet(String key, List<String> value, long time) {
610.         try {
611.             redisTemplate.opsForList().rightPushAll(key, value);
612.             if (time > 0) {
613.                 expire(key, time);
614.             }
615.             return true;
616.         } catch (Exception e) {
617.             log.error(e.getMessage(), e);
618.             return false;
619.         }
620.     }
622.     /**
623.      * 根据索引修改list中的某条数据
624.      *
625.      * @param key   键
626.      * @param index 索引
627.      * @param value 值
628.      * @return /
629.      */
630.     public boolean lUpdateIndex(String key, long index, String value) {
631.         try {
632.             redisTemplate.opsForList().set(key, index, value);
633.             return true;
634.         } catch (Exception e) {
635.             log.error(e.getMessage(), e);
636.             return false;
637.         }
638.     }
640.     /**
641.      * 移除N个值为value
642.      *
643.      * @param key   键
644.      * @param count 移除多少个
645.      * @param value 值
646.      * @return 移除的个数
647.      */
648.     public long lRemove(String key, long count, Object value) {
649.         try {
650.             return redisTemplate.opsForList().remove(key, count, value);
651.         } catch (Exception e) {
652.             log.error(e.getMessage(), e);
653.             return 0;
654.         }
655.     }
657.     /**
658.      * @param prefix 前缀
659.      * @param ids    id
660.      */
661.     public void delByKeys(String prefix, Set<Long> ids) {
662.         Set<String> keys = new HashSet<>();
663.         for (Long id : ids) {
664.             keys.addAll(redisTemplate.keys(new StringBuffer(prefix).append(id).toString()));
665.         }
666.         long count = redisTemplate.delete(keys);
667.         // 此处提示可自行删除
668.         log.debug("--------------------------------------------");
669.         log.debug("成功删除缓存：" + keys.toString());
670.         log.debug("缓存删除数量：" + count + "个");
671.         log.debug("--------------------------------------------");
672.     }
673. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！