update 配置统一提取为 properties 配置类

ruoyi-framework/src/main/java/com/ruoyi/framework/config/FilterConfig.java

@@ -3,7 +3,8 @@ package com.ruoyi.framework.config;
 import cn.hutool.core.util.StrUtil;
 import com.ruoyi.common.filter.RepeatableFilter;
 import com.ruoyi.common.filter.XssFilter;
-import org.springframework.beans.factory.annotation.Value;
+import com.ruoyi.framework.config.properties.XssProperties;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.web.servlet.FilterRegistrationBean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -15,41 +16,33 @@ import java.util.Map;
 /**
  * Filter配置
  *
- * @author ruoyi
+ * @author Lion Li
  */
 @Configuration
-public class FilterConfig
-{
-    @Value("${xss.enabled}")
-    private String enabled;
+public class FilterConfig {
 
-    @Value("${xss.excludes}")
-    private String excludes;
+    @Autowired
+    private XssProperties xssProperties;
 
-    @Value("${xss.urlPatterns}")
-    private String urlPatterns;
-
-    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @SuppressWarnings({"rawtypes", "unchecked"})
     @Bean
-    public FilterRegistrationBean xssFilterRegistration()
-    {
+    public FilterRegistrationBean xssFilterRegistration() {
         FilterRegistrationBean registration = new FilterRegistrationBean();
         registration.setDispatcherTypes(DispatcherType.REQUEST);
         registration.setFilter(new XssFilter());
-        registration.addUrlPatterns(StrUtil.split(urlPatterns, ","));
+        registration.addUrlPatterns(StrUtil.split(xssProperties.getUrlPatterns(), ","));
         registration.setName("xssFilter");
         registration.setOrder(FilterRegistrationBean.HIGHEST_PRECEDENCE);
         Map<String, String> initParameters = new HashMap<String, String>();
-        initParameters.put("excludes", excludes);
-        initParameters.put("enabled", enabled);
+        initParameters.put("excludes", xssProperties.getExcludes());
+        initParameters.put("enabled", xssProperties.getEnabled());
         registration.setInitParameters(initParameters);
         return registration;
     }
 
-    @SuppressWarnings({ "rawtypes", "unchecked" })
+    @SuppressWarnings({"rawtypes", "unchecked"})
     @Bean
-    public FilterRegistrationBean someFilterRegistration()
-    {
+    public FilterRegistrationBean someFilterRegistration() {
         FilterRegistrationBean registration = new FilterRegistrationBean();
         registration.setFilter(new RepeatableFilter());
         registration.addUrlPatterns("/*");

ruoyi-framework/src/main/java/com/ruoyi/framework/config/SwaggerConfig.java

@@ -0,0 +1,131 @@
+package com.ruoyi.framework.config;
+
+import com.github.xiaoymin.knife4j.spring.annotations.EnableKnife4j;
+import com.ruoyi.common.config.RuoYiConfig;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.ApiInfoBuilder;
+import springfox.documentation.builders.PathSelectors;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.service.*;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spi.service.contexts.SecurityContext;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Swagger2的接口配置
+ *
+ * @author Lion Li
+ */
+@Configuration
+@EnableSwagger2
+@EnableKnife4j
+@ConditionalOnClass({Docket.class, ApiInfoBuilder.class})
+@ConditionalOnProperty(prefix = "swagger", value = "enable", matchIfMissing = true)
+public class SwaggerConfig {
+    /**
+     * 系统基础配置
+     */
+    @Autowired
+    private RuoYiConfig ruoyiConfig;
+
+    /**
+     * 标题
+     */
+    @Value("${swagger.title}")
+    private String title;
+
+    /**
+     * 描述
+     */
+    @Value("${swagger.description}")
+    private String description;
+
+    /**
+     * 版本
+     */
+    @Value("${swagger.version}")
+    private String version;
+
+    /**
+     * 创建API
+     */
+    @Bean
+    public Docket createRestApi() {
+        return new Docket(DocumentationType.SWAGGER_2)
+                // 用来创建该API的基本信息，展示在文档的页面中（自定义展示的信息）
+                .apiInfo(apiInfo())
+                // 设置哪些接口暴露给Swagger展示
+                .select()
+                // 扫描所有有注解的api，用这种方式更灵活
+                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
+                // 扫描指定包中的swagger注解
+                // .apis(RequestHandlerSelectors.basePackage("com.ruoyi.project.tool.swagger"))
+                // 扫描所有 .apis(RequestHandlerSelectors.any())
+                .paths(PathSelectors.any())
+                .build()
+                /* 设置安全模式，swagger可以设置访问token */
+                .securitySchemes(securitySchemes())
+                .securityContexts(securityContexts());
+    }
+
+    /**
+     * 安全模式，这里指定token通过Authorization头请求头传递
+     */
+    private List<SecurityScheme> securitySchemes() {
+        List<SecurityScheme> apiKeyList = new ArrayList<SecurityScheme>();
+        apiKeyList.add(new ApiKey("Authorization", "Authorization", "header"));
+        return apiKeyList;
+    }
+
+    /**
+     * 安全上下文
+     */
+    private List<SecurityContext> securityContexts() {
+        List<SecurityContext> securityContexts = new ArrayList<>();
+        securityContexts.add(
+                SecurityContext.builder()
+                        .securityReferences(defaultAuth())
+                        .forPaths(PathSelectors.regex("^(?!auth).*$"))
+                        .build());
+        return securityContexts;
+    }
+
+    /**
+     * 默认的安全上引用
+     */
+    private List<SecurityReference> defaultAuth() {
+        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
+        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
+        authorizationScopes[0] = authorizationScope;
+        List<SecurityReference> securityReferences = new ArrayList<>();
+        securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
+        return securityReferences;
+    }
+
+    /**
+     * 添加摘要信息
+     */
+    private ApiInfo apiInfo() {
+        // 用ApiInfoBuilder进行定制
+        return new ApiInfoBuilder()
+                // 设置标题
+                .title(title)
+                // 描述
+                .description(description)
+                // 作者信息
+                .contact(new Contact(ruoyiConfig.getName(), null, null))
+                // 版本
+                .version(version)
+                .build();
+    }
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/ThreadPoolConfig.java

@@ -1,8 +1,9 @@
 package com.ruoyi.framework.config;
 
 import com.ruoyi.common.utils.Threads;
+import com.ruoyi.framework.config.properties.ThreadPoolProperties;
 import org.apache.commons.lang3.concurrent.BasicThreadFactory;
-import org.springframework.beans.factory.annotation.Value;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -21,43 +22,31 @@ import java.util.concurrent.ThreadPoolExecutor;
 @Configuration
 public class ThreadPoolConfig {
 
-    // 核心线程池大小
-    @Value("${threadPoolConfig.corePoolSize}")
-    private int corePoolSize;
-
-    // 最大可创建的线程数
-    @Value("${threadPoolConfig.maxPoolSize}")
-    private int maxPoolSize;
-
-    // 队列最大长度
-    @Value("${threadPoolConfig.queueCapacity}")
-    private int queueCapacity;
-
-    // 线程池维护线程所允许的空闲时间
-    @Value("${threadPoolConfig.keepAliveSeconds}")
-    private int keepAliveSeconds;
-
-    // 线程池对拒绝任务(无线程可用)的处理策略
-    @Value("${threadPoolConfig.rejectedExecutionHandler}")
-    private String rejectedExecutionHandler;
+    @Autowired
+    private ThreadPoolProperties threadPoolProperties;
 
     @Bean(name = "threadPoolTaskExecutor")
     @ConditionalOnProperty(prefix = "threadPoolTaskExecutor", name = "enabled", havingValue = "true")
     public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
-        executor.setMaxPoolSize(maxPoolSize);
-        executor.setCorePoolSize(corePoolSize);
-        executor.setQueueCapacity(queueCapacity);
-        executor.setKeepAliveSeconds(keepAliveSeconds);
+        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
+        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
+        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
+        executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());
         RejectedExecutionHandler handler;
-        if (rejectedExecutionHandler.equals("CallerRunsPolicy")) {
-            handler = new ThreadPoolExecutor.CallerRunsPolicy();
-        } else if (rejectedExecutionHandler.equals("DiscardOldestPolicy")) {
-            handler = new ThreadPoolExecutor.DiscardOldestPolicy();
-        } else if (rejectedExecutionHandler.equals("DiscardPolicy")) {
-            handler = new ThreadPoolExecutor.DiscardPolicy();
-        } else {
-            handler = new ThreadPoolExecutor.AbortPolicy();
+        switch (threadPoolProperties.getRejectedExecutionHandler()) {
+            case "CallerRunsPolicy":
+                handler = new ThreadPoolExecutor.CallerRunsPolicy();
+                break;
+            case "DiscardOldestPolicy":
+                handler = new ThreadPoolExecutor.DiscardOldestPolicy();
+                break;
+            case "DiscardPolicy":
+                handler = new ThreadPoolExecutor.DiscardPolicy();
+                break;
+            default:
+                handler = new ThreadPoolExecutor.AbortPolicy();
+                break;
         }
         executor.setRejectedExecutionHandler(handler);
         return executor;
@@ -68,7 +57,7 @@ public class ThreadPoolConfig {
      */
     @Bean(name = "scheduledExecutorService")
     protected ScheduledExecutorService scheduledExecutorService() {
-        return new ScheduledThreadPoolExecutor(corePoolSize,
+        return new ScheduledThreadPoolExecutor(threadPoolProperties.getCorePoolSize(),
                 new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build()) {
             @Override
             protected void afterExecute(Runnable r, Throwable t) {

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/CaptchaProperties.java

@@ -0,0 +1,24 @@
+package com.ruoyi.framework.config.properties;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 验证码 配置属性
+ *
+ * @author Lion Li
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "captcha")
+public class CaptchaProperties {
+    // 验证码类型
+    private String type;
+    // 验证码类别
+    private String category;
+    // 数字验证码位数
+    private Integer numberLength;
+    // 字符验证码长度
+    private Integer charLength;
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/DruidProperties.java

@@ -1,76 +1,54 @@
 package com.ruoyi.framework.config.properties;
 
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
 import com.alibaba.druid.pool.DruidDataSource;
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
 
 /**
  * druid 配置属性
- * 
- * @author ruoyi
+ *
+ * @author Lion Li
  */
+@Data
 @Configuration
-public class DruidProperties
-{
-    @Value("${spring.datasource.druid.initialSize}")
+@ConfigurationProperties(prefix = "spring.datasource.druid")
+public class DruidProperties {
+
+    /** 初始连接数 */
     private int initialSize;
-
-    @Value("${spring.datasource.druid.minIdle}")
+    /** 最小连接池数量 */
     private int minIdle;
-
-    @Value("${spring.datasource.druid.maxActive}")
+    /** 最大连接池数量 */
     private int maxActive;
-
-    @Value("${spring.datasource.druid.maxWait}")
+    /** 配置获取连接等待超时的时间 */
     private int maxWait;
-
-    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
+    /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
     private int timeBetweenEvictionRunsMillis;
-
-    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
+    /** 配置一个连接在池中最小生存的时间，单位是毫秒 */
     private int minEvictableIdleTimeMillis;
-
-    @Value("${spring.datasource.druid.maxEvictableIdleTimeMillis}")
+    /** 配置一个连接在池中最大生存的时间，单位是毫秒 */
     private int maxEvictableIdleTimeMillis;
-
-    @Value("${spring.datasource.druid.validationQuery}")
+    /** 配置检测连接是否有效 */
     private String validationQuery;
-
-    @Value("${spring.datasource.druid.testWhileIdle}")
+    /** 初始连接数 */
     private boolean testWhileIdle;
-
-    @Value("${spring.datasource.druid.testOnBorrow}")
+    /** 初始连接数 */
     private boolean testOnBorrow;
-
-    @Value("${spring.datasource.druid.testOnReturn}")
+    /** 初始连接数 */
     private boolean testOnReturn;
 
-    public DruidDataSource dataSource(DruidDataSource datasource)
-    {
-        /** 配置初始化大小、最小、最大 */
+    public DruidDataSource dataSource(DruidDataSource datasource) {
         datasource.setInitialSize(initialSize);
         datasource.setMaxActive(maxActive);
         datasource.setMinIdle(minIdle);
-
-        /** 配置获取连接等待超时的时间 */
         datasource.setMaxWait(maxWait);
-
-        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
         datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
-
-        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
         datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
         datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);
-
-        /**
-         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
-         */
         datasource.setValidationQuery(validationQuery);
-        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
         datasource.setTestWhileIdle(testWhileIdle);
-        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
         datasource.setTestOnBorrow(testOnBorrow);
-        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
         datasource.setTestOnReturn(testOnReturn);
         return datasource;
     }

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/SwaggerProperties.java

@@ -0,0 +1,36 @@
+package com.ruoyi.framework.config.properties;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 验证码 配置属性
+ *
+ * @author Lion Li
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "swagger")
+public class SwaggerProperties {
+
+    /**
+     * 验证码类型
+     */
+    private Boolean enabled;
+    /**
+     * 验证码类别
+     */
+    private String title;
+    /**
+     * 数字验证码位数
+     */
+    private String description;
+    /**
+     * 字符验证码长度
+     */
+    private String version;
+
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/ThreadPoolProperties.java

@@ -0,0 +1,47 @@
+package com.ruoyi.framework.config.properties;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 验证码 配置属性
+ *
+ * @author Lion Li
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "thread-pool")
+public class ThreadPoolProperties {
+
+    /**
+     * 是否开启线程池
+     */
+    private boolean enabled;
+
+    /**
+     * 核心线程池大小
+     */
+    private int corePoolSize;
+
+    /**
+     * 最大可创建的线程数
+     */
+    private int maxPoolSize;
+
+    /**
+     * 队列最大长度
+     */
+    private int queueCapacity;
+
+    /**
+     * 线程池维护线程所允许的空闲时间
+     */
+    private int keepAliveSeconds;
+
+    /**
+     * 线程池对拒绝任务(无线程可用)的处理策略
+     */
+    private String rejectedExecutionHandler;
+
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/TokenProperties.java

@@ -0,0 +1,26 @@
+package com.ruoyi.framework.config.properties;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+@Data
+@Component
+@ConfigurationProperties(prefix = "token")
+public class TokenProperties {
+
+    /**
+     * 令牌自定义标识
+     */
+    private String header;
+
+    /**
+     * 令牌秘钥
+     */
+    private String secret;
+
+    /**
+     * 令牌有效期（默认30分钟）
+     */
+    private int expireTime;
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/config/properties/XssProperties.java

@@ -0,0 +1,32 @@
+package com.ruoyi.framework.config.properties;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * 验证码 配置属性
+ *
+ * @author Lion Li
+ */
+@Data
+@Component
+@ConfigurationProperties(prefix = "xss")
+public class XssProperties {
+
+    /**
+     * 过滤开关
+     */
+    private String enabled;
+
+    /**
+     * 排除链接（多个用逗号分隔）
+     */
+    private String excludes;
+
+    /**
+     * 匹配链接
+     */
+    private String urlPatterns;
+
+}

ruoyi-framework/src/main/java/com/ruoyi/framework/web/service/TokenService.java

@@ -10,11 +10,11 @@ import com.ruoyi.common.core.redis.RedisCache;
 import com.ruoyi.common.utils.ServletUtils;
 import com.ruoyi.common.utils.ip.AddressUtils;
 import com.ruoyi.common.utils.ip.IpUtils;
+import com.ruoyi.framework.config.properties.TokenProperties;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 
 import javax.servlet.http.HttpServletRequest;
@@ -25,22 +25,10 @@ import java.util.concurrent.TimeUnit;
 /**
  * token验证处理
  *
- * @author ruoyi
+ * @author Lion Li
  */
 @Component
-public class TokenService
-{
-    // 令牌自定义标识
-    @Value("${token.header}")
-    private String header;
-
-    // 令牌秘钥
-    @Value("${token.secret}")
-    private String secret;
-
-    // 令牌有效期（默认30分钟）
-    @Value("${token.expireTime}")
-    private int expireTime;
+public class TokenService {
 
     protected static final long MILLIS_SECOND = 1000;
 
@@ -51,17 +39,18 @@ public class TokenService
     @Autowired
     private RedisCache redisCache;
 
+    @Autowired
+    private TokenProperties tokenProperties;
+
     /**
      * 获取用户身份信息
      *
      * @return 用户信息
      */
-    public LoginUser getLoginUser(HttpServletRequest request)
-    {
+    public LoginUser getLoginUser(HttpServletRequest request) {
         // 获取请求携带的令牌
         String token = getToken(request);
-        if (Validator.isNotEmpty(token))
-        {
+        if (Validator.isNotEmpty(token)) {
             Claims claims = parseToken(token);
             // 解析对应的权限以及用户信息
             String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
@@ -75,10 +64,8 @@ public class TokenService
     /**
      * 设置用户身份信息
      */
-    public void setLoginUser(LoginUser loginUser)
-    {
-        if (Validator.isNotNull(loginUser) && Validator.isNotEmpty(loginUser.getToken()))
-        {
+    public void setLoginUser(LoginUser loginUser) {
+        if (Validator.isNotNull(loginUser) && Validator.isNotEmpty(loginUser.getToken())) {
             refreshToken(loginUser);
         }
     }
@@ -86,10 +73,8 @@ public class TokenService
     /**
      * 删除用户身份信息
      */
-    public void delLoginUser(String token)
-    {
-        if (Validator.isNotEmpty(token))
-        {
+    public void delLoginUser(String token) {
+        if (Validator.isNotEmpty(token)) {
             String userKey = getTokenKey(token);
             redisCache.deleteObject(userKey);
         }
@@ -101,8 +86,7 @@ public class TokenService
      * @param loginUser 用户信息
      * @return 令牌
      */
-    public String createToken(LoginUser loginUser)
-    {
+    public String createToken(LoginUser loginUser) {
         String token = IdUtil.fastUUID();
         loginUser.setToken(token);
         setUserAgent(loginUser);
@@ -119,12 +103,10 @@ public class TokenService
      * @param loginUser
      * @return 令牌
      */
-    public void verifyToken(LoginUser loginUser)
-    {
+    public void verifyToken(LoginUser loginUser) {
         long expireTime = loginUser.getExpireTime();
         long currentTime = System.currentTimeMillis();
-        if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
-        {
+        if (expireTime - currentTime <= MILLIS_MINUTE_TEN) {
             refreshToken(loginUser);
         }
     }
@@ -134,13 +116,12 @@ public class TokenService
      *
      * @param loginUser 登录信息
      */
-    public void refreshToken(LoginUser loginUser)
-    {
+    public void refreshToken(LoginUser loginUser) {
         loginUser.setLoginTime(System.currentTimeMillis());
-        loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
+        loginUser.setExpireTime(loginUser.getLoginTime() + tokenProperties.getExpireTime() * MILLIS_MINUTE);
         // 根据uuid将loginUser缓存
         String userKey = getTokenKey(loginUser.getToken());
-        redisCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
+        redisCache.setCacheObject(userKey, loginUser, tokenProperties.getExpireTime(), TimeUnit.MINUTES);
     }
 
     /**
@@ -148,8 +129,7 @@ public class TokenService
      *
      * @param loginUser 登录信息
      */
-    public void setUserAgent(LoginUser loginUser)
-    {
+    public void setUserAgent(LoginUser loginUser) {
         UserAgent userAgent = UserAgentUtil.parse(ServletUtils.getRequest().getHeader("User-Agent"));
         String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
         loginUser.setIpaddr(ip);
@@ -164,11 +144,10 @@ public class TokenService
      * @param claims 数据声明
      * @return 令牌
      */
-    private String createToken(Map<String, Object> claims)
-    {
+    private String createToken(Map<String, Object> claims) {
         String token = Jwts.builder()
                 .setClaims(claims)
-                .signWith(SignatureAlgorithm.HS512, secret).compact();
+                .signWith(SignatureAlgorithm.HS512, tokenProperties.getSecret()).compact();
         return token;
     }
 
@@ -178,10 +157,9 @@ public class TokenService
      * @param token 令牌
      * @return 数据声明
      */
-    private Claims parseToken(String token)
-    {
+    private Claims parseToken(String token) {
         return Jwts.parser()
-                .setSigningKey(secret)
+                .setSigningKey(tokenProperties.getSecret())
                 .parseClaimsJws(token)
                 .getBody();
     }
@@ -192,8 +170,7 @@ public class TokenService
      * @param token 令牌
      * @return 用户名
      */
-    public String getUsernameFromToken(String token)
-    {
+    public String getUsernameFromToken(String token) {
         Claims claims = parseToken(token);
         return claims.getSubject();
     }
@@ -204,18 +181,15 @@ public class TokenService
      * @param request
      * @return token
      */
-    private String getToken(HttpServletRequest request)
-    {
-        String token = request.getHeader(header);
-        if (Validator.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX))
-        {
+    private String getToken(HttpServletRequest request) {
+        String token = request.getHeader(tokenProperties.getHeader());
+        if (Validator.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX)) {
             token = token.replace(Constants.TOKEN_PREFIX, "");
         }
         return token;
     }
 
-    private String getTokenKey(String uuid)
-    {
+    private String getTokenKey(String uuid) {
         return Constants.LOGIN_TOKEN_KEY + uuid;
     }
 }