add redis

add 单用户登录

pom.xml

@@ -23,6 +23,8 @@
         <swagger2.version>2.9.2</swagger2.version>
         <lang3.version>3.7</lang3.version>
         <druid.version>1.1.14</druid.version>
+        <redis.version>2.0.0.RELEASE</redis.version>
+        <jedis.version>2.9.0</jedis.version>
     </properties>
 
     <dependencies>
@@ -102,6 +104,13 @@
             <version>1.4.0</version>
         </dependency>
 
+        <!--&lt;!&ndash; shiro+redis缓存插件 &ndash;&gt;-->
+        <!--<dependency>-->
+            <!--<groupId>org.crazycake</groupId>-->
+            <!--<artifactId>shiro-redis</artifactId>-->
+            <!--<version>2.4.2.1-RELEASE</version>-->
+        <!--</dependency>-->
+
         <!-- jwt -->
         <dependency>
             <groupId>com.auth0</groupId>
@@ -109,6 +118,18 @@
             <version>3.2.0</version>
         </dependency>
 
+        <!--springboot中的redis依赖-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <!--<version>${redis.version}</version>-->
+        </dependency>
+        <!--<dependency>-->
+            <!--<groupId>redis.clients</groupId>-->
+            <!--<artifactId>jedis</artifactId>-->
+            <!--<version>${jedis.version}</version>-->
+        <!--</dependency>-->
+
 
     </dependencies>
 

src/main/java/com/fd/config/MyInterceptor.java

@@ -1,47 +0,0 @@
-//package com.fd.config;
-//
-//import lombok.extern.log4j.Log4j2;
-//import org.springframework.web.servlet.HandlerInterceptor;
-//
-//import javax.servlet.http.HttpServletRequest;
-//import javax.servlet.http.HttpServletResponse;
-//
-///**
-// * Created by Owen on 2019/10/25 0025 16:49
-// *
-// *  拦截验证
-// */
-//@Log4j2
-//public class MyInterceptor implements HandlerInterceptor {
-//
-//    /**
-//     * 重写preHandle方法
-//     * @param request
-//     * @param response
-//     * @param handler
-//     * @return
-//     * @throws Exception
-//     */
-//    @Override
-//    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
-////        log.info("run preHandle");
-////
-////        log.info("request url: {}", request.getRequestURL());
-////        log.info("request tRemoteAddr: {}", request.getRemoteAddr());
-//
-//
-//        String requestHeaders = request.getHeader("Access-Control-Request-Headers");
-//        if (requestHeaders==null) {
-//            requestHeaders = "";
-//        }
-//        response.setHeader("Access-Control-Allow-Credentials", "true");
-//        response.setHeader("Access-Control-Allow-Methods", "HEAD,PUT,DELETE,POST,GET");
-//        response.setHeader("Access-Control-Allow-Headers", "Accept, Origin, XRequestedWith, Content-Type, LastModified," + requestHeaders);
-//        response.setHeader("Access-Control-Allow-Origin", "*");
-//
-//
-//        return true;
-//    }
-//
-//
-//}

src/main/java/com/fd/config/RedisConfig.java

@@ -0,0 +1,116 @@
+package com.dist.config;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.cache.annotation.CachingConfigurerSupport;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.*;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+/**
+ * redis配置类
+ * @program: springbootdemo
+ * @Date: 2019/1/25 15:20
+ * @Author: Mr.Zheng
+ * @Description:
+ */
+@Configuration
+@EnableCaching //开启注解
+public class RedisConfig extends CachingConfigurerSupport {
+
+    /**
+     * retemplate相关配置
+     * @param factory
+     * @return
+     */
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
+
+        RedisTemplate<String, Object> template = new RedisTemplate<>();
+        // 配置连接工厂
+        template.setConnectionFactory(factory);
+
+        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
+        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
+
+        ObjectMapper om = new ObjectMapper();
+        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
+        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        jacksonSeial.setObjectMapper(om);
+
+        // 值采用json序列化
+        template.setValueSerializer(jacksonSeial);
+        //使用StringRedisSerializer来序列化和反序列化redis的key值
+        template.setKeySerializer(new StringRedisSerializer());
+
+        // 设置hash key 和value序列化模式
+        template.setHashKeySerializer(new StringRedisSerializer());
+        template.setHashValueSerializer(jacksonSeial);
+        template.afterPropertiesSet();
+
+        return template;
+    }
+
+    /**
+     * 对hash类型的数据操作
+     *
+     * @param redisTemplate
+     * @return
+     */
+    @Bean
+    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForHash();
+    }
+
+    /**
+     * 对redis字符串类型数据操作
+     *
+     * @param redisTemplate
+     * @return
+     */
+    @Bean
+    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForValue();
+    }
+
+    /**
+     * 对链表类型的数据操作
+     *
+     * @param redisTemplate
+     * @return
+     */
+    @Bean
+    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForList();
+    }
+
+    /**
+     * 对无序集合类型的数据操作
+     *
+     * @param redisTemplate
+     * @return
+     */
+    @Bean
+    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForSet();
+    }
+
+    /**
+     * 对有序集合类型的数据操作
+     *
+     * @param redisTemplate
+     * @return
+     */
+    @Bean
+    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
+        return redisTemplate.opsForZSet();
+    }
+
+}

src/main/java/com/fd/config/WebMvcConfg.java

@@ -1,115 +0,0 @@
-//package com.fd.config;
-//
-//import com.alibaba.fastjson.serializer.SerializerFeature;
-//import com.alibaba.fastjson.serializer.ToStringSerializer;
-//import com.alibaba.fastjson.support.config.FastJsonConfig;
-//import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
-//import com.fasterxml.jackson.databind.ObjectMapper;
-//import com.fasterxml.jackson.databind.module.SimpleModule;
-//import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
-//import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
-//import org.springframework.context.annotation.Bean;
-//import org.springframework.context.annotation.Configuration;
-//import org.springframework.http.MediaType;
-//import org.springframework.web.servlet.config.annotation.CorsRegistry;
-//import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
-//import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
-//
-//import java.util.ArrayList;
-//import java.util.List;
-//
-///**
-// * Created by Owen on 2019/10/25 0025 16:29
-// */
-//@Configuration
-//public class WebMvcConfg implements WebMvcConfigurer {
-//
-//
-//    @Bean
-//    public MyInterceptor myInterceptor(){
-//        return new MyInterceptor();
-//    }
-//
-//    /**
-// 　　* 重写addInterceptors方法
-// 　　* addPathPatterns：需要拦截的访问路径
-// 　　* excludePathPatterns：不需要拦截的路径，
-// 　　* String数组类型可以写多个用","分割
-// 　　*/
-//    @Override
-//    public void addInterceptors(InterceptorRegistry registry) {
-//        registry.addInterceptor(myInterceptor())
-////                .addPathPatterns("/**")
-//                .addPathPatterns("/api/**")
-//                .excludePathPatterns("/swagger-resources/**", "/webjars/**", "/v2/**", "/swagger-ui.html");
-//    }
-//
-//    /**
-//     * 配置全局跨域
-//     */
-//    @Override
-//    public void addCorsMappings(CorsRegistry registry) {
-//        registry.addMapping("/**")
-//                .allowedOrigins("*")
-//                .allowCredentials(true)
-//                .allowedMethods("GET", "POST", "DELETE", "PUT", "OPTIONS")
-//                .maxAge(3600);
-//    }
-//
-//
-//
-//
-//
-//    /**
-//     * fastJson相关设置
-//     * Dto包含json,需要配置不然会异常
-//     * @return
-//     */
-//    @Bean
-//    public HttpMessageConverters customConverters() {
-//
-//
-//        FastJsonHttpMessageConverter fastJson = new FastJsonHttpMessageConverter();
-//
-//        // 创建FastJson信息转换对象
-//        FastJsonConfig fastJsonConfig = new FastJsonConfig();
-//
-//        /**
-//         * 创建FastJsonConfig对象并设定序列化规则  序列化规则详见SerializerFeature类中
-//         *
-//         * 加入 fastJsonConfig.setSerializerFeatures 这方法，swagger会受影响。
-//         * 目前把他注释掉，也能正常访问发送强求，先用着
-//         * fastJsonConfig.setSerializerFeatures(SerializerFeature.QuoteFieldNames, SerializerFeature.WriteDateUseDateFormat, SerializerFeature.WriteNonStringValueAsString);
-//         */
-//
-//        // 设置全程返回时间
-//        fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");
-//        // 设置返回值为null是时输出，不写的话，null 字段 不返回。也可以设置返回空串
-////        fastJsonConfig.setSerializerFeatures(SerializerFeature.IgnoreNonFieldGetter);
-////        fastJsonConfig.setSerializerFeatures(SerializerFeature.NotWriteDefaultValue);
-//        fastJsonConfig.setSerializerFeatures(SerializerFeature.WriteNullStringAsEmpty);
-////        fastJsonConfig.setSerializerFeatures(SerializerFeature.NotWriteDefaultValue, SerializerFeature.IgnoreNonFieldGetter);
-//        fastJson.setFastJsonConfig(fastJsonConfig);
-//
-//        //3、中文乱码解决方案
-//        List<MediaType> mediaTypeList = new ArrayList<>();
-//        mediaTypeList.add(MediaType.APPLICATION_JSON_UTF8);
-//        mediaTypeList.add(MediaType.valueOf("text/html;charset=UTF-8"));
-//
-//
-//        //4、将转换规则应用于转换对象
-//        fastJson.setSupportedMediaTypes(mediaTypeList);
-//
-//
-//        return new HttpMessageConverters(fastJson);
-//    }
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//}

src/main/java/com/fd/controller/ExceptionController.java

@@ -22,14 +22,14 @@ public class ExceptionController {
     @ResponseStatus(HttpStatus.UNAUTHORIZED)
     @ExceptionHandler(ShiroException.class)
     public R handle401(ShiroException e) {
-        return new R(401, e.getMessage());
+        return new R(40002, e.getMessage());
     }
 
     // 捕捉UnauthorizedException
     @ResponseStatus(HttpStatus.UNAUTHORIZED)
     @ExceptionHandler(UnauthorizedException.class)
     public R handle401() {
-        return new R(401, "Unauthorized");
+        return new R(40003, "Unauthorized");
     }
 
     // 捕捉其他所有异常
@@ -40,24 +40,6 @@ public class ExceptionController {
     }
 
 
-//    @ExceptionHandler(ShiroException.class)
-//    public R doHandleShiroException(ShiroException e) {
-//        R r = null;
-//        if (e instanceof UnknownAccountException) {
-//            r = new R(40001, "此账户不存在");
-//        } else if (e instanceof IncorrectCredentialsException) {
-//            r = new R(40001, "密码不正确");
-//        } else  {
-//            r = new R(40001, e.getMessage());
-//
-//    }
-//
-//        return r;
-//    }
-
-
-
-
 
     private HttpStatus getStatus(HttpServletRequest request) {
         Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");

src/main/java/com/fd/controller/UserController.java

@@ -3,21 +3,26 @@ package com.fd.controller;
 import com.fd.constant.MsgCode;
 import com.fd.entity.User;
 import com.fd.repository.UserRepository;
+import com.fd.shiro.JWTToken;
 import com.fd.shiro.JWTUtil;
 import com.fd.util.R;
 import lombok.extern.log4j.Log4j2;
 import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authc.UsernamePasswordToken;
 import org.apache.shiro.authz.UnauthorizedException;
 import org.apache.shiro.authz.annotation.Logical;
 import org.apache.shiro.authz.annotation.RequiresAuthentication;
 import org.apache.shiro.authz.annotation.RequiresPermissions;
 import org.apache.shiro.authz.annotation.RequiresRoles;
+import org.apache.shiro.mgt.SecurityManager;
 import org.apache.shiro.subject.Subject;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
 
 import javax.servlet.http.HttpServletRequest;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Created by Owen on 2019/11/11 0011 16:50
@@ -29,28 +34,58 @@ public class UserController {
     @Autowired
     private UserRepository userRepository;
 
+    @Autowired
+    private RedisTemplate redisTemplate;
+
+    private static final String SALT = "cesium_";
+
     @PostMapping("/login")
     public R login(@RequestParam("username") String username,
                    @RequestParam("password") String password) {
-        log.info("run login , username:{}, password:{}", username, password);
+        log.warn("run login , username:{}, password:{}", username, password);
         User user = userRepository.findByUsername(username);
         if (user == null) {
             return new R(53000, MsgCode.U53000);
         }
         if (!password.equals(user.getPassword())) {
             // 密码不相等
-            throw new UnauthorizedException();
+            throw new UnauthorizedException("error");
         }
-        return new R(200, (Object) JWTUtil.sign(username, password));
+
+
+//        // 判断用户是否在redis存在的代码可以删除
+//        boolean hasKey = redisTemplate.hasKey(user.getUsername());
+//
+//        log.info("hasKey: {}", hasKey);
+//
+//        // 存在
+//        if (hasKey) {
+//            //踢出上一个登录用户，注销用户
+////            String oldToken = (String) redisTemplate.opsForValue().get(user.getUsername());
+//            log.info("before user is out");
+//        }
+
+        // 创建新token
+        String token = JWTUtil.sign(username, password);
+
+        // 更新到 redis, 有效期30min, 旧token无效
+        redisTemplate.opsForValue().set(user.getUsername(), token, Long.parseLong("30"), TimeUnit.MINUTES);
+        log.info("token: {}", token);
+
+        log.warn("end login");
+        return new R(200, (Object) token);
     }
 
 
     @GetMapping("/logout")
-    public R logout() {
+    public R logout(HttpServletRequest request) {
         log.info("run logout");
-        Subject subject = SecurityUtils.getSubject();
-        subject.logout();
 
+        String token = request.getHeader("Authorization");
+        String username = JWTUtil.getUsername(token);
+        redisTemplate.delete(username);
+
+        log.info("end logout");
         return new R(200, MsgCode.SUCCESS);
     }
 
@@ -146,7 +181,7 @@ public class UserController {
     @RequestMapping(path = "/401")
     @ResponseStatus(HttpStatus.UNAUTHORIZED)
     public R unauthorized() {
-        return new R(401, "Unauthorized");
+        return new R(40001, "Unauthorized");
     }
 
 

src/main/java/com/fd/shiro/JWTFilter.java

@@ -1,5 +1,13 @@
 package com.fd.shiro;
 
+import com.fd.entity.User;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.cache.Cache;
+import org.apache.shiro.cache.CacheManager;
+import org.apache.shiro.session.Session;
+import org.apache.shiro.session.mgt.DefaultSessionKey;
+import org.apache.shiro.session.mgt.SessionManager;
+import org.apache.shiro.subject.Subject;
 import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -11,6 +19,9 @@ import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+import java.io.Serializable;
+import java.util.Deque;
+import java.util.LinkedList;
 
 
 /**
@@ -20,27 +31,38 @@ public class JWTFilter extends BasicHttpAuthenticationFilter {
 
     private Logger LOGGER = LoggerFactory.getLogger(this.getClass());
 
+
     /**
      * 判断用户是否想要登入。
      * 检测header里面是否包含Authorization字段即可
      */
     @Override
     protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
+//        LOGGER.warn("run isLoginAttempt");
         HttpServletRequest req = (HttpServletRequest) request;
         String authorization = req.getHeader("Authorization");
         return authorization != null;
     }
 
+
+
     /**
-     *
+     * 执行登录验证
      */
     @Override
     protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
+//        LOGGER.warn("run executeLogin");
         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
         String authorization = httpServletRequest.getHeader("Authorization");
         JWTToken token = new JWTToken(authorization);
+
+        // 判断token 是否跟redis
+
         // 提交给realm进行登入，如果错误他会抛出异常并被捕获
         getSubject(request, response).login(token);
+
+
+
         // 如果没有抛出异常则代表登入成功，返回true
         return true;
     }
@@ -61,15 +83,15 @@ public class JWTFilter extends BasicHttpAuthenticationFilter {
      */
     @Override
     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
+//        LOGGER.warn("run isAccessAllowed");
         if (isLoginAttempt(request, response)) {
             try {
                 executeLogin(request, response);
-                return true;
             } catch (Exception e) {
                 response401(request, response);
             }
         }
-        return false;
+        return true;
     }
 
     /**

src/main/java/com/fd/shiro/MyRealm.java

@@ -2,7 +2,6 @@ package com.fd.shiro;
 
 import com.fd.entity.User;
 import com.fd.repository.UserRepository;
-import com.fd.util.R;
 import lombok.extern.log4j.Log4j2;
 import org.apache.shiro.authc.AuthenticationException;
 import org.apache.shiro.authc.AuthenticationInfo;
@@ -13,12 +12,16 @@ import org.apache.shiro.authz.SimpleAuthorizationInfo;
 import org.apache.shiro.realm.AuthorizingRealm;
 import org.apache.shiro.subject.PrincipalCollection;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Service;
 
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 
+/**
+ * 配置不校验的话，是不会走这个方法的
+ */
 @Log4j2
 @Service
 public class MyRealm extends AuthorizingRealm {
@@ -27,6 +30,9 @@ public class MyRealm extends AuthorizingRealm {
     @Autowired
     private UserRepository userRepository;
 
+    @Autowired
+    private RedisTemplate redisTemplate;
+
 
 
     /**
@@ -61,6 +67,7 @@ public class MyRealm extends AuthorizingRealm {
      */
     @Override
     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
+//        log.warn("run doGetAuthenticationInfo");
         String token = (String) auth.getCredentials();
         log.warn("token: {}", token);
         // 解密获得username，用于和数据库进行对比
@@ -74,12 +81,19 @@ public class MyRealm extends AuthorizingRealm {
             throw new AuthenticationException("User didn't existed!");
         }
 
+        // 校验请求token是否跟redis token一致
+        String redisToken = (String) redisTemplate.opsForValue().get(user.getUsername());
+        if (!token.equals(redisToken)) {
+            throw new AuthenticationException("token invalid");
+        }
+
 
         if (! JWTUtil.verify(token, username, user.getPassword())) {
-//            throw new AuthenticationException("Username or password error");
             throw new AuthenticationException("token invalid");
         }
 
+//        log.warn("end doGetAuthenticationInfo");
+
         return new SimpleAuthenticationInfo(token, token, "my_realm");
     }
 }

src/main/java/com/fd/shiro/ShiroConfig.java

@@ -10,7 +10,10 @@ import org.apache.shiro.spring.LifecycleBeanPostProcessor;
 import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
 import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
 import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
+import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
+
 import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.http.HttpMessageConverters;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -26,6 +29,15 @@ import java.util.Map;
 @Configuration
 public class ShiroConfig {
 
+    @Value("${spring.redis.host}")
+    private String host;
+
+    @Value("${spring.redis.port}")
+    private int port;
+
+    @Value("${spring.redis.jedis.timeout}")
+    private int timeout;
+
     @Bean("securityManager")
     public DefaultWebSecurityManager getManager(MyRealm realm) {
         DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
@@ -55,6 +67,7 @@ public class ShiroConfig {
 
 
 
+
         factoryBean.setFilters(filterMap);
 
         factoryBean.setSecurityManager(securityManager);
@@ -68,6 +81,7 @@ public class ShiroConfig {
 
         filterRuleMap.put("/login", "anon");
         filterRuleMap.put("/test/**", "anon");
+        filterRuleMap.put("/logout", "anon");
 
         // swagger 不拦截
         filterRuleMap.put("/swagger-resources/**", "anon");
@@ -146,4 +160,6 @@ public class ShiroConfig {
 
         return new HttpMessageConverters(fastJson);
     }
+
+
 }

src/main/resources/application-dev.properties

@@ -33,6 +33,23 @@ spring.datasource.druid.test-on-return=false
 spring.datasource.druid.web-stat-filter.enabled=true
 spring.datasource.druid.stat-view-servlet.enabled=true
 
+
+# Redis数据库索引（默认为0）
+spring.redis.database=0
+spring.redis.host=127.0.0.1
+spring.redis.port=6379
+spring.redis.password=
+# 连接超时时间 单位 ms（毫秒）
+spring.redis.timeout=3000ms
+# 连接池中的最大空闲连接，默认值也是8。
+spring.redis.jedis.pool.max-idle=8
+#连接池中的最小空闲连接，默认值也是0。
+spring.redis.jedis.pool.min-idle=0
+# 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
+spring.redis.jedis.pool.max-active=8
+# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
+spring.redis.jedis.pool.max-wait=-1ms
+
 logging.file=log/cesium.log
 
 base.path=/root/gis/data

src/main/resources/application-pro.properties

@@ -33,6 +33,23 @@ spring.datasource.druid.test-on-return=false
 spring.datasource.druid.web-stat-filter.enabled=true
 spring.datasource.druid.stat-view-servlet.enabled=true
 
+
+# Redis数据库索引（默认为0）
+spring.redis.database=0
+spring.redis.host=127.0.0.1
+spring.redis.port=6379
+spring.redis.password=
+# 连接超时时间 单位 ms（毫秒）
+spring.redis.timeout=3000ms
+# 连接池中的最大空闲连接，默认值也是8。
+spring.redis.jedis.pool.max-idle=8
+#连接池中的最小空闲连接，默认值也是0。
+spring.redis.jedis.pool.min-idle=0
+# 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
+spring.redis.jedis.pool.max-active=8
+# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
+spring.redis.jedis.pool.max-wait=-1ms
+
 logging.file=/root/java/tomcat_8082_cesium/log/cesium.log
 
 # 文件存放路径

src/main/resources/application-uat.properties

@@ -33,6 +33,23 @@ spring.datasource.druid.test-on-return=false
 spring.datasource.druid.web-stat-filter.enabled=true
 spring.datasource.druid.stat-view-servlet.enabled=true
 
+
+# Redis数据库索引（默认为0）
+spring.redis.database=0
+spring.redis.host=127.0.0.1
+spring.redis.port=6379
+spring.redis.password=4dage
+# 连接超时时间 单位 ms（毫秒）
+spring.redis.timeout=3000ms
+# 连接池中的最大空闲连接，默认值也是8。
+spring.redis.jedis.pool.max-idle=8
+#连接池中的最小空闲连接，默认值也是0。
+spring.redis.jedis.pool.min-idle=0
+# 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
+spring.redis.jedis.pool.max-active=8
+# 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
+spring.redis.jedis.pool.max-wait=-1ms
+
 logging.file=/data/tomcat_cesium_8082/log/cesium.log
 
 base.path=/root/gis/data

src/main/resources/application.properties

@@ -1,7 +1,7 @@
 server.port=8082
 
 # file multipart
-spring.profiles.active=uat
+spring.profiles.active=dev
 spring.servlet.multipart.enabled=true
 spring.servlet.multipart.max-file-size=51200MB
 spring.servlet.multipart.max-request-size=51200MB
@@ -15,4 +15,5 @@ spring.jpa.open-in-view=false
 spring.task.pool.corePoolSize=10
 spring.task.pool.maxPoolSize=100
 spring.task.pool.keepAliveSeconds=100
-spring.task.pool.queueCapacity=100
+spring.task.pool.queueCapacity=100
+