PageHelper

  1. <!-- pageHelper分页插件 -->
  2.         <dependency>
  3.             <groupId>com.github.pagehelper</groupId>
  4.             <artifactId>pagehelper-spring-boot-starter</artifactId>
  5.             <version>1.4.2</version>
  6.         </dependency>
  1. # pagehelper分页插件配置
  2. # 配置分页数据库
  3. pagehelper.helper-dialect=mysql
  4. #启用合理化，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页
  5. pagehelper.reasonable=true
  6. #为了支持startPage(Object params)方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值
  7. # 可以配置pageNum,pageSize,count,pageSizeZero,reasonable，不配置映射的用默认值
  8. # 默认值为pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero
  9. pagehelper.params=count=countSql
  10. #支持通过 Mapper 接口参数来传递分页参数，默认值false
  11. # 分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页
  12. pagehelper.supportMethodsArguments=true
  13. #如果 pageSize=0 就会查询出全部的结果（相当于没有执行分页查询）
  14. pagehelper.page-size-zero=true
  1. // 查询mapper执行前赋值     
  2. PageHelper.startPage(1,20);

ES

1、添加maven依赖

  1. <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-elasticsearch -->
  2. <dependency>
  3.     <groupId>org.springframework.data</groupId>
  4.     <artifactId>spring-data-elasticsearch</artifactId>
  5.     <version>4.3.4</version>
  6. </dependency>

2、设置springboot中ES的版本

  1. <!-- 需要在项目中引入springboot parent包来覆盖es版本 -->
  2. <parent>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-parent</artifactId>
  5.     <version>2.5.0</version>
  6.     <relativePath/>
  7. </parent>
  11. <!-- 覆盖springboot默认es版本 -->
  12. <elasticsearch.version>7.13.0</elasticsearch.version>

3、添加es配置文件

  1. spring:
  2.   data:
  3.     elasticsearch:
  4.       client:
  5.         reactive:
  6.           endpoints: 172.16.88.128:9200
  7.           username:
  8.           password:
  9.           connection-timeout: 5000
  10.           socket-timeout: 60000

4、添加es client配置

  1. /**
  2.  * 初始化 es客户端 bean 7.13.0
  3.  * @return
  4.  */
  5. @Override
  6. @Bean
  7. public RestHighLevelClient elasticsearchClient() {
  8.     final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
  9.             .connectedTo(endpoints)
  10.             .withConnectTimeout(connectTimeout)
  11.             .withSocketTimeout(socketTimeout)
  12.             .withBasicAuth(username, password)
  13.             .build();
  14.     log.info("==============初始化ES客户端连接" + endpoints + "=================");
  15.     return RestClients.create(clientConfiguration).rest();
  16. }

继承 ElasticsearchRepository 即可使用通用api

  1. package com.csj.demo.business.repository;
  3. import com.csj.demo.business.POJO.DO.User;
  4. import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
  6. /**
  7.  * @Desc : 用户es操作类
  8.  * @Author : chen
  9.  * @Date : 2022/4/22 17:11
  10.  */
  11. public interface UserRepository extends ElasticsearchRepository<User, Long> {
  12. }

TK-Mybatis-Mapper

  1. <!--通用Mapper-->
  2.         <dependency>
  3.             <groupId>tk.mybatis</groupId>
  4.             <artifactId>mapper-spring-boot-starter</artifactId>
  5.             <version>4.2.0</version>
  6.         </dependency>
  1. # tkmapper 使用
  2. mapper.identity=MYSQL
  3. mapper.not-empty=true
  1. package com.csj.demo.business.component;
  3. import tk.mybatis.mapper.common.Mapper;
  4. import tk.mybatis.mapper.common.MySqlMapper;
  6. /**
  7. * @Desc : basemapper
  8. * @Author : chen
  9. * @Date : 2022/4/24 15:37
  10. */
  11. public interface MyMapper<T> extends Mapper<T>, MySqlMapper<T> {
  12. }
  1. // 使用过程中继承mymapper即可
  2. public interface UserMapper extends MyMapper<User> {
  4. }

mybatis

  1. # mybatis配置
  2. # mybatis全局配置
  3. mybatis.config-location:classpath:mybatis-config.xml
  4. # resultType 可以只写类的全限定名
  5. mybatis.type-aliases-package=com.csj.demo.business.POJO.DO
  6. # xml文件目录
  7. mybatis.mapper-locations=classpath:mapper/*Mapper.xml
  1. <!-- mybatis -->
  2.         <dependency>
  3.             <groupId>org.mybatis.spring.boot</groupId>
  4.             <artifactId>mybatis-spring-boot-starter</artifactId>
  5.             <version>2.2.2</version>
  6.         </dependency>

Druid

  1. spring:
  2.   # 设置数据源
  3.   datasource:
  4.     url: jdbc:mysql://172.16.88.128:3306/DB01?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
  5.     username: root
  6.     password: 123456
  7.     type: com.alibaba.druid.pool.DruidDataSource
  8.     driver-class-name: com.mysql.cj.jdbc.Driver
  9.     druid:
  10.       # 初始化大小，最小，最大活跃数
  11.       initial-size: 3
  12.       min-idle: 3
  13.       max-active: 20
  14.       # 配置获取连接等待超时的时间，单位是毫秒
  15.       max-wait: 60000
  16.       # asyncInit是1.1.4中新增加的配置，如果有initialSize数量较多时，打开会加快应用启动时间
  17.       async-init: true
  18.       # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
  19.       time-between-eviction-runs-millis: 60000
  20.       # 配置一个连接在池中最小生存的时间，单位是毫秒
  21.       min-evictable-idle-time-millis: 30000
  22.       max-evictable-idle-time-millis: 300000
  23.       # 用于检查连接的语句
  24.       validation-query: SELECT 1
  25.       test-while-idle: true
  26.       # 申请连接时执行validationQuery检测连接是否有效,会影响性能
  27.       test-on-borrow: false
  28.       # 归还连接时执行validationQuery检测连接是否有效
  29.       test-on-return: false
  30.       # 打开缓存PSCache，并且指定每个连接上PSCache的大小,mysql作用不大建议关闭,oracle开启效果好
  31.       pool-prepared-statements: false
  32.       max-pool-prepared-statement-per-connection-size: -1
  33.       max-open-prepared-statements: -1
  34.       #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙，slf4j（用log4j需要额外导入依赖，版本不同，这里也可以去掉slf4j）
  35.       filters: stat,wall,slf4j
  36.       # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
  37.       connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=200;druid.stat.logSlowSql=true;config.decrypt=true
  38.       # 配置监控服务器
  39.       stat-view-servlet:
  40.         enabled: true
  41.         url-pattern: /druid/*
  42.         # 是否可重置数据
  43.         reset-enable: false
  44.         login-username: druid
  45.         login-password: druid123
  46.       web-stat-filter:
  47.         enabled: true
  48.         url-pattern: /*
  49.         exclusions: /druid/*,*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,*.woff2
  50.         session-stat-enable: true
  51.         session-stat-max-count: 10
  52.       filter:
  53.         slf4j:
  54.           enabled: true
  55.           statement-create-after-log-enabled: false
  56.           statement-close-after-log-enabled: false
  57.           result-set-open-after-log-enabled: false
  58.           result-set-close-after-log-enabled: false
  1. //单数据源时可忽略，springboot会自动配置
  3. @Value("${spring.datasource.url}")
  4. private String url;
  5. @Value("${spring.datasource.username}")
  6. private String username;
  7. @Value("${spring.datasource.password}")
  8. private String password;
  9. @Value("${spring.datasource.driver-class-name}")
  10. private String driverClassName;
  11. @Value("${spring.datasource.initial-size}")
  12. private int initialSize;
  13. @Value("${spring.datasource.min-idle}")
  14. private int minIdle;
  15. @Value("${spring.datasource.max-active}")
  16. private int maxActive;
  17. @Value("${spring.datasource.max-wait}")
  18. private int maxWait;
  19. @Value("${spring.datasource.time-between-eviction-runs-millis}")
  20. private int timeBetweenEvictionRunsMillis;
  21. @Value("${spring.datasource.min-evictable-idle-time-millis}")
  22. private int minEvictableIdleTimeMillis;
  23. @Value("${spring.datasource.max-evictable-idle-time-millis}")
  24. private int maxEvictableIdleTimeMillis;
  25. @Value("${spring.datasource.pool-prepared-statements}")
  26. private boolean poolPreparedStatements;
  27. @Value("${spring.datasource.max-pool-prepared-statement-per-connection-size}")
  28. private int maxPoolPreparedStatementPerConnectionSize;
  29. @Value("${spring.datasource.validation-query}")
  30. private String validationQuery;
  31. @Value("${spring.datasource.test-while-idle}")
  32. private boolean testWhileIdle;
  33. @Value("${spring.datasource.test-on-borrow}")
  34. private boolean testOnBorrow;
  35. @Value("${spring.datasource.test-on-return}")
  36. private boolean testOnReturn;
  37. @Value("{spring.datasource.connection-properties}")
  38. private String connectionProperties;
  41. @Bean
  42. @Primary
  43. @ConfigurationProperties("spring.datasource.druid")
  44. public DataSource dataSource() {
  45.     DruidDataSource datasource = new DruidDataSource();
  46.     datasource.setUrl(url);
  47.     datasource.setUsername(username);
  48.     datasource.setPassword(password);
  49.     datasource.setDriverClassName(driverClassName);
  50.     datasource.setInitialSize(initialSize);
  51.     datasource.setMinIdle(minIdle);
  52.     datasource.setMaxActive(maxActive);
  53.     datasource.setMaxWait(maxWait);
  54.     datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
  55.     datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
  56.     datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);
  57.     datasource.setValidationQuery(validationQuery);
  58.     datasource.setTestWhileIdle(testWhileIdle);
  59.     datasource.setTestOnBorrow(testOnBorrow);
  60.     datasource.setTestOnReturn(testOnReturn);
  61.     datasource.setPoolPreparedStatements(poolPreparedStatements);
  62.     datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
  63.     datasource.setConnectionProperties(connectionProperties);
  64.     log.info("===========数据库连接" + url + "===========");
  65.     return datasource;
  66. }
  68. @Bean(name = "dataSource")
  69. @Primary
  70. @ConfigurationProperties("spring.datasource.druid")
  71. public DataSource dataSource(){
  72.     log.info("===========数据库连接" + url + "===========");
  73.     return DruidDataSourceBuilder.create().build();
  74. }
  77. @Value("${mybatis.config-location}")
  78. private String configLocation;
  79. @Value("${mybatis.mapper-locations}")
  80. private String mapperLocations;
  81. @Value("${mybatis.type-aliases-package}")
  82. private String typeAliasesPackage;
  84. @Bean(name = "sqlSessionFactory")
  85. @Primary
  86. SqlSessionFactory sqlSessionFactory(@Qualifier("dataSource")DataSource dataSource) throws Exception {
  87.     SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  88.     bean.setDataSource(dataSource);
  89.     bean.setConfigLocation(new DefaultResourceLoader().getResource(configLocation));
  90.     bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
  91.     bean.setTypeAliasesPackage(typeAliasesPackage);
  92.     return bean.getObject();
  93. }
  97. @Bean
  98. @Primary
  99. public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
  100.     return new SqlSessionTemplate(sqlSessionFactory);
  101. }
  103. /**
  104.  * 监控页面相关
  105.  */
  106. @Value("spring.datasource.druid.stat-view-servlet.url-pattern")
  107. private String urlPattern;
  108. @Value("spring.datasource.druid.stat-view-servlet.reset-enable")
  109. private String resetEnable;
  110. @Value("spring.datasource.druid.stat-view-servlet.login-username")
  111. private String loginUsername;
  112. @Value("spring.datasource.druid.stat-view-servlet.login-password")
  113. private String loginPassword;
  114. /**
  115.  * 配置 Druid 监控界面
  116.  * 内置没有web.xml文件，使用 SpringBoot 注册 Servlet 方式配置
  117.  */
  118. @Bean
  119. public ServletRegistrationBean statViewServlet() {
  120.     ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
  122.     // 这些参数可以在StatViewServlet 的父类 ResourceServlet 中找到
  123.     Map<String, String> initParams = new HashMap<>();
  124.     initParams.put("loginUsername", "admin"); //后台管理界面的登录账号
  125.     initParams.put("loginPassword", "123456"); //后台管理界面的登录密码
  127.     // 页面允许某用户可以访问
  128.     // initParams.put("allow", "localhost")：表示只有本机可以访问
  130.     // 第二参数为空或者为null时，表示允许所有访问
  131.     initParams.put("allow", "");
  133.     // 页面拒绝xxx访问
  134.     // initParams.put("xxx", "127.0.0.1")：表示禁止此ip访问
  136.     // 设置初始化参数
  137.     bean.setInitParameters(initParams);
  138.     return bean;
  139. }

Logback

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration scan="true" scanPeriod="10 seconds">
  4.   <contextName>logback</contextName>
  6.   <!-- 给某些包设置特定的日志级别 -->
  7.   <logger name="org.springframework" level="WARN"/>
  8.   <logger name="druid.sql" level="WARN"/>
  9.   <logger name="springfox.documentation" level="WARN"/>
  10.   <logger name="org.hibernate" level="WARN"/>
  11.   <logger name="org.mybatis" level="WARN"/>
  12.   <logger name="com.alibaba" level="WARN"/>
  13.   <!--   设置es的日志级别 `-->
  14.   <logger name="org.springframework.data.elasticsearch.client.WIRE" level="trace"/>
  15.   <logger name="org.springframework.data.convert.CustomConversions" level="ERROR"/>
  18.   <springProperty scope="context" name="logLevel" source="logging.level"/>
  19.   <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
  20.   <property name="LOG_PATTERN" value="%date{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
  21.   <!--    <property name="LOG_PATTERN" value="%msg%n" />-->
  22.   <!--    <property name="LOG_PATTERN" value="{'date':'%date{yyyy-MM-dd HH:mm:ss.SSS}', 'process':'%thread', 'level':'%-5level', 'author':'%logger{36}','msg':%msg}%n" />-->
  24.   <!-- 定义日志存储的路径 -->
  25.   <property name="FILE_PATH" value="./logs" />
  27.   <!-- 控制台输出日志 -->
  28.   <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
  29.     <encoder>
  30.       <!-- 按照上面配置的LOG_PATTERN来打印日志 -->
  31.       <pattern>${LOG_PATTERN}</pattern>
  32.     </encoder>
  33.   </appender>
  35.   <!-- 每天生成一个日志文件,每月生成一个文件夹，每天超出100M新增一个文件。 -->
  36.   <appender name="rollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
  37.     <file>${FILE_PATH}/log_current.log</file>
  38.     <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
  39.       <!--日志文件输出的文件名-->
  40.       <FileNamePattern>${FILE_PATH}/%d{yyyy-MM, aux}/log-%d{yyyy-MM-dd}.%i.log</FileNamePattern>
  41.       <!-- 日志文件最大尺寸 -->
  42.       <maxFileSize>100MB</maxFileSize>
  43.     </rollingPolicy>
  45.     <encoder>
  46.       <pattern>${LOG_PATTERN}</pattern>
  47.     </encoder>
  48.   </appender>
  50.   <!-- 日志输出级别 -->
  51.   <root level="${logLevel}">
  52.     <appender-ref ref="console" />
  53.     <appender-ref ref="rollingFile" />
  54.   </root>
  55. </configuration>
  1. # 设置日志级别
  2. logging:
  3.   level:
  4.     com.csj.demo.business: debug

JWT

  1. 标准中注册的声明 (建议但不强制使用) ：
  3. iss: jwt签发者
  4. sub: jwt所面向的用户
  5. aud: 接收jwt的一方
  6. exp: jwt的过期时间，这个过期时间必须要大于签发时间
  7. nbf: 定义在什么时间之前，该jwt都是不可用的.
  8. iat: jwt的签发时间
  9. jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。
  1. 自定义注解跳过验证
  3. @PassToken：跳过验证，通常是入口方法上用这个，比如登录接口

jwt工具类

  1. package com.csj.demo.business.utils;
  3. import com.auth0.jwt.JWT;
  4. import com.auth0.jwt.JWTCreator;
  5. import com.auth0.jwt.JWTVerifier;
  6. import com.auth0.jwt.algorithms.Algorithm;
  7. import com.auth0.jwt.exceptions.JWTDecodeException;
  8. import com.auth0.jwt.interfaces.Claim;
  9. import com.csj.demo.business.exception.OperationException;
  10. import com.csj.demo.business.exception.ResultUtils;
  12. import java.util.Calendar;
  13. import java.util.Date;
  14. import java.util.HashMap;
  15. import java.util.Map;
  17. /**
  18.  * @Desc : jwt工具类
  19.  * @Author : chen
  20.  * @Date : 2022/4/25 13:59
  21.  */
  22. public class JwtUtils {
  24.     //盐值
  25.     private static String SECRET = "superadmin";
  26.     //jwt的过期时间
  27.     private static Integer EXP = 30;
  28.     //jwt签发者
  29.     private static String ISS = "business";
  30.     //接收人员
  31.     private static String AUD = "WEB";
  32.     //面向用户
  33.     private static String SUB = "WEB";
  37.     /**
  38.      * 获取token
  39.      * @param userId
  40.      * @param userName
  41.      * @return
  42.      */
  43.     public static String getJWTToken(String userId, String userName){
  44.         return createToken(userId,userName);
  45.     }
  47.     /**
  48.      * 签发token
  49.      * @param userId
  50.      * @param userName
  51.      * @return
  52.      */
  53.     private static String createToken(String userId, String userName) {
  54.         //签发时间
  55.         Date iatDate = new Date();
  56.         //过期时间
  57.         Calendar nowTime = Calendar.getInstance();
  58.         nowTime.add(Calendar.MINUTE, EXP);
  59.         Date expiresDate = nowTime.getTime();
  60.         // header Map
  61.         Map<String, Object> header = new HashMap<>();
  62.         //加密算法
  63.         header.put("alg", "HS256");
  64.         //类型 jwt
  65.         header.put("typ", "JWT");
  67.         JWTCreator.Builder builder = JWT.create();
  68.         //header
  69.         builder.withHeader(header);
  70.         //发行人,发行时间,过期时间
  71.         builder.withIssuer(ISS)
  72.                 .withIssuedAt(iatDate)
  73.                 .withExpiresAt(expiresDate);
  74.         //载荷,负载信息  可在验证过后从token中获取到
  75.         builder.withClaim("userName", userName);
  76.         //aud 接收人员,sub 面向的用户
  77.         builder.withAudience(userId)
  78.                 .withSubject(SUB);
  79.         //token 唯一标识
  80.         builder.withJWTId(userId);
  81.         //加密
  82.         return builder.sign(Algorithm.HMAC256(userId + SECRET));
  83.     }
  85.     /**
  86.      * 验证token
  87.      * @param token
  88.      * @param userId
  89.      * @throws OperationException
  90.      */
  91.     public static void verifyToken(String token, String userId) throws OperationException {
  92.         try {
  93.             JWTVerifier verifier = JWT.require(Algorithm.HMAC256(userId + SECRET)).build();
  94.             verifier.verify(token);
  95.         } catch (Exception e) {
  96.             //效验失败 抛出异常
  97.             throw new OperationException(ResultUtils.JWT_ERRCODE_NULL);
  98.         }
  99.     }
  101.     /**
  102.      * 获取接收人员
  103.      * @param token
  104.      * @return
  105.      * @throws OperationException
  106.      */
  107.     public static String getAudience(String token) throws OperationException {
  108.         String audience = null;
  109.         try {
  110.             audience = JWT.decode(token).getAudience().get(0);
  111.         } catch (JWTDecodeException j) {
  112.             //这里是token解析失败
  113.             throw new OperationException(ResultUtils.JWT_ERRCODE_NULL);
  114.         }
  115.         return audience;
  116.     }
  118.     /**
  119.      * 获取token载荷
  120.      * @param token
  121.      * @param name
  122.      * @return
  123.      */
  124.     public static Claim getClaimByName(String token, String name) {
  125.         return JWT.decode(token).getClaim(name);
  126.     }
  127. }
  1. package com.csj.demo.business.annotation;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. /**
  9. * @Desc : 自定义注解:跳过token
  10. * @Author : chen
  11. * @Date : 2022/4/25 16:38
  12. */
  13. @Target({ElementType.METHOD, ElementType.TYPE})
  14. @Retention(RetentionPolicy.RUNTIME)
  15. public @interface PassToken {
  16.     boolean required() default true;
  17. }

自定义拦截器验证token

  1. package com.csj.demo.business.interceptor;
  3. import com.csj.demo.business.annotation.PassToken;
  4. import com.csj.demo.business.exception.OperationException;
  5. import com.csj.demo.business.exception.ResultUtils;
  6. import com.csj.demo.business.service.UserService;
  7. import com.csj.demo.business.utils.JwtUtils;
  8. import com.oracle.tools.packager.Log;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.web.method.HandlerMethod;
  11. import org.springframework.web.servlet.HandlerInterceptor;
  12. import org.springframework.web.servlet.ModelAndView;
  14. import javax.servlet.http.HttpServletRequest;
  15. import javax.servlet.http.HttpServletResponse;
  16. import java.lang.reflect.Method;
  18. /**
  19.  * @Desc : jwt验证拦截器
  20.  * @Author : chen
  21.  * @Date : 2022/4/25 16:24
  22.  */
  23. public class JwtAuthenticationInterceptor implements HandlerInterceptor {
  25.     @Autowired
  26.     private UserService userService;
  28.     @Override
  29.     public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception {
  30.         // 从请求头中取出 token  这里需要和前端约定好把jwt放到请求头一个叫token的地方
  31.         String token = httpServletRequest.getHeader("token");
  32.         // 如果不是映射到方法直接通过
  33.         if (!(object instanceof HandlerMethod)) {
  34.             return true;
  35.         }
  36.         HandlerMethod handlerMethod = (HandlerMethod) object;
  37.         Method method = handlerMethod.getMethod();
  38.         //检查是否有passtoken注释，有则跳过认证
  39.         if (method.isAnnotationPresent(PassToken.class)) {
  40.             PassToken passToken = method.getAnnotation(PassToken.class);
  41.             if (passToken.required()) {
  42.                 return true;
  43.             }
  44.         }else {
  45.             //默认全部检查
  46.             Log.info("jwt拦截验证Token");
  47.             // 执行认证
  48.             if (token == null) {
  49.                 //这里其实是登录失效,没token了
  50.                 throw new OperationException(ResultUtils.JWT_ERRCODE_NULL);
  51.             }
  52.             // 获取 token 中的 user Name
  53.             String userId = JwtUtils.getAudience(token);
  54.             //验证用户是否存在
  55.             boolean b = userService.existsUserById(Long.parseLong(userId));
  56.             if (!b) {
  57.                 throw new OperationException(ResultUtils.INVALID_USER);
  58.             }
  59.             // 验证 token
  60.             JwtUtils.verifyToken(token, userId);
  61.             //获取载荷内容
  62.             String userName = JwtUtils.getClaimByName(token, "userName").asString();
  64.             return true;
  65.         }
  66.         return true;
  67.     }
  69.     @Override
  70.     public void postHandle(HttpServletRequest httpServletRequest,
  71.                            HttpServletResponse httpServletResponse,
  72.                            Object o, ModelAndView modelAndView) throws Exception {
  74.     }
  76.     @Override
  77.     public void afterCompletion(HttpServletRequest httpServletRequest,
  78.                                 HttpServletResponse httpServletResponse,
  79.                                 Object o, Exception e) throws Exception {
  80.     }
  83. }

配置自定义拦截器

  1. package com.csj.demo.business.config;
  3. import com.csj.demo.business.interceptor.JwtAuthenticationInterceptor;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  7. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  9. /**
  10.  * @Desc : 拦截器
  11.  * @Author : chen
  12.  * @Date : 2022/4/25 16:21
  13.  */
  14. @Configuration
  15. public class InterceptorConfig implements WebMvcConfigurer {
  17.     @Override
  18.     public void addInterceptors(InterceptorRegistry registry) {
  19.         //默认拦截所有路径
  20.         registry.addInterceptor(authenticationInterceptor())
  21.                 .addPathPatterns("/**");
  22.     }
  23.     @Bean
  24.     public JwtAuthenticationInterceptor authenticationInterceptor() {
  25.         return new JwtAuthenticationInterceptor();
  26.     }
  28. }

热部署devtools

  1. <!--devtools-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-devtools</artifactId>
  5.     <scope>runtime</scope>
  6.     <optional>true</optional>
  7. </dependency>
  1. spring:
  2.   devtools:
  3.     add-properties: false
  4.     restart:
  5.     enabled: true
  6.     additional-paths: src/main/java
  7.     additional-exclude: static/**,public/**
  8.     #exclude: static/**