springboot+mybatisPlus+druid+AOP实现多数据源动态切换

前言基本框架搭建druid的集成简介依赖yaml 中druid的配置yaml中其他配置文件上传Redis端口设置sql日志打印指定分页对应数据库 DruidConfig Druid控制台配置 mybatisPlus的集成简介特性所需依赖代码生成器MybatisplusConfig配置类 Aop实现多数据源的动态切换原理依赖数据源配置动态切换创建枚举类动态数据源工具AOP指定mapper对应的数据源应用当前数据源 Redis的集成依赖初始化服务操作工具类测试

前言

最近应工作需要，需要多数据源动态切换，在此期间多次踩坑，好在得以一一解决，完美的版本做此记录。 如若需要源码请私信我邮箱。

基本框架搭建

基本框架的搭建可参照我之前的博文《使用IDEA搭建springboot+token+swagger-ui》跳转 这里我将完善druid连接池的使用以及mybatisPlus的集成和AOP实现多数据源动态切换

druid的集成

简介

#druid连接池运行原理 #连接池初始化的时候按照initialSize创建多个连接 #有DB操作访问的时候，就从里面取一个 #如果当前正在使用的连接=maxActive,就会进入等待，没有到maxActive拿一个空闲连接，没有空闲就创建一个新连接，等待超过maxWati则会报错 #使用完毕还回去等待其它人用，不会物理销毁 #每一个connection在连接池里都有空闲时长的，允许最大空闲时长：minEvictableldleTimeMillis,多久检测一次：timeBetweenEvictionRunsMillis #maxActive如何配置：理论上应该设置成最大并发数 #只要连接被前端业务拿到就算不空闲了，这个时候如果说长时间占有连接，连接数是不会崩溃，连接池主动关闭是使用中的连接，属于一个高级功能 #removeAbandoned=“true” #removeAbandonedTimeout=“60” #logAbandoned=“true”

依赖

<!-- druid --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.21</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.22</version> </dependency> <!-- mysql驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency>

yaml 中druid的配置

这里我直接贴出来了多数据源的配置

spring: datasource: druid: #数据源1 first: username: root password: ZZlj981225 url: jdbc:mysql://你的数据库地址:3306/book?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource #数据源2 second: username: root password: ZZlj981225 url: jdbc:mysql://你的数据库地址:3306/car?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource #Spring Boot 默认是不注入这些属性值的，需要自己绑定 #druid 数据源专有配置 #初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时 initialSize: 5 #最小连接池数量 minIdle: 5 #最大连接池数量 maxActive: 20 #获取连接时最大等待时间，单位毫秒，配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。 #maxWait: 60000 timeBetweenEvictionRunsMillis: 60000 #连接保持空闲⽽而不不被驱逐的最⻓长时间,当前5分钟，单位毫秒 minEvictableIdleTimeMillis: 300000 #用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。 validationQuery: SELECT 1 FROM DUAL #建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 testWhileIdle: true #申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 testOnBorrow: false #归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能 testOnReturn: false # 打开PSCache poolPreparedStatements: true #配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入 filters: stat,wall,log4j,config #指定每个连接上PSCache的大小 maxPoolPreparedStatementPerConnectionSize: 20 #合并多个DruidDataSource的监控数据 useGlobalDataSourceStat: true #通过connectProperties属性来打开mergeSql功能；慢SQL记录 connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

yaml中其他配置

因为这次采用yaml配置文件的形式，这里我将剩余的配置贴出

文件上传

#文件上传大小限制 servlet: multipart: max-file-size: 500MB max-request-size: 500MB

Redis

#Redis redis: database: 0 host: 127.0.0.1 password: 12345 port: 6379 #连接超时时间毫秒(类型为Duration，添加秒) timeout: 30000 # Lettuce lettuce: pool: # 连接池最大连接数（使用负值表示没有限制） max-active: 60 # 连接池中的最小空闲连接 min-idle: 5 # 连接池中的最大空闲连接 max-idle: 10 #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。 max-wait: 50000 #空闲链接检测线程检测周期毫秒（负值表示不检测）(类型为Duration，添加秒) time-between-eviction-runs: 60s #关闭超时时间 shutdown-timeout: 1000

端口设置

#端口 server: port: 8080

sql日志打印

#sql日志打印 logging: level: com: item: demo: mapper: debug

指定分页对应数据库

#ָ分页给mysql用 pagehelper: helper-dialect: mysql reasonable: true support-methods-arguments: true params: count=countSql

DruidConfig Druid控制台配置

package com.item.demo.config; import com.alibaba.druid.pool.DruidDataSource; import com.alibaba.druid.support.http.StatViewServlet; import com.alibaba.druid.support.http.WebStatFilter; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.sql.DataSource; import java.util.HashMap; import java.util.Map; @Configuration public class DruidConfig { @ConfigurationProperties(prefix = "spring.datasource") @Bean public DataSource druidDataSource() { return new DruidDataSource(); } //因为Springboot内置了servlet容器，所以没有web.xml，替代方法就是将ServletRegistrationBean注册进去 //加入后台监控 @Bean //这里其实就相当于servlet的web.xml public ServletRegistrationBean statViewServlet() { ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<StatViewServlet>(new StatViewServlet(), "/druid/*"); //后台需要有人登录，进行配置 //bean.addUrlMappings(); 这个可以添加映射，我们在构造里已经写了 //设置一些初始化参数 Map<String, String> initParas = new HashMap<>(); initParas.put("loginUsername", "admin");//账号 initParas.put("loginPassword", "123456");//密码 //允许谁能防伪 initParas.put("allow", "");//这个值为空或没有就允许所有人访问，ip白名单 //initParas.put("allow","localhost");//只允许本机访问，多个ip用逗号,隔开 //initParas.put("deny","");//ip黑名单，拒绝谁访问 deny和allow同时存在优先deny initParas.put("resetEnable", "false");//禁用HTML页面的Reset按钮 bean.setInitParameters(initParas); return bean; } //再配置一个过滤器，Servlet按上面的方式注册Filter也只能这样 @Bean public FilterRegistrationBean webStatFilter() { FilterRegistrationBean bean = new FilterRegistrationBean(); //可以设置也可以获取,设置一个阿里巴巴的过滤器 bean.setFilter(new WebStatFilter()); bean.addUrlPatterns("/*"); //可以过滤和排除哪些东西 Map<String, String> initParams = new HashMap<String, String>(); //把不需要监控的过滤掉,这些不进行统计 initParams.put("exclusions", "*.js,*.css,/druid/*"); bean.setInitParameters(initParams); return bean; } }

到这里我们便完成了Druid的配置

mybatisPlus的集成

简介

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ） 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

所需依赖

<!--mybatis plus--> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.0</version> </dependency> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-generator</artifactId> <version>3.4.0</version> </dependency> <!--mybatis plus 模板引擎--> <dependency> <groupId>org.freemarker</groupId> <artifactId>freemarker</artifactId> <version>2.3.30</version> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency>

代码生成器

也可参照官网所提供的

package com.item.demo.utile; import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException; import com.baomidou.mybatisplus.core.toolkit.StringPool; import com.baomidou.mybatisplus.generator.AutoGenerator; import com.baomidou.mybatisplus.generator.InjectionConfig; import com.baomidou.mybatisplus.generator.config.*; import com.baomidou.mybatisplus.generator.config.po.TableInfo; import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy; import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine; import org.springframework.util.StringUtils; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class CodeGenerator { /** * <p> * 读取控制台内容 * </p> */ public static String scanner(String tip) { Scanner scanner = new Scanner(System.in); StringBuilder help = new StringBuilder(); help.append("请输入" + tip + "："); System.out.println(help.toString()); if (scanner.hasNext()) { String ipt = scanner.next(); if (!StringUtils.isEmpty(ipt)) { return ipt; } } throw new MybatisPlusException("请输入正确的" + tip + "！"); } public static void main(String[] args) { // 代码生成器 AutoGenerator mpg = new AutoGenerator(); // 全局配置 GlobalConfig gc = new GlobalConfig(); String projectPath = System.getProperty("user.dir"); gc.setOutputDir(projectPath + "/src/main/java"); gc.setAuthor("jobob"); gc.setOpen(false); // gc.setSwagger2(true); 实体属性 Swagger2 注解 mpg.setGlobalConfig(gc); // 数据源配置 DataSourceConfig dsc = new DataSourceConfig(); dsc.setUrl("jdbc:mysql://rm-bp1a8r0z2zl9v603r2o.mysql.rds.aliyuncs.com:3306/car?useUnicode=true&characterEncoding=utf8&useSSL=false"); // dsc.setSchemaName("public"); dsc.setDriverName("com.mysql.cj.jdbc.Driver"); dsc.setUsername("root"); dsc.setPassword("ZZlj981225"); mpg.setDataSource(dsc); // 包配置 PackageConfig pc = new PackageConfig(); pc.setModuleName(scanner("模块名")); pc.setParent("com.item"); mpg.setPackageInfo(pc); // 自定义配置 InjectionConfig cfg = new InjectionConfig() { @Override public void initMap() { // to do nothing } }; // 如果模板引擎是 freemarker String templatePath = "/templates/mapper.xml.ftl"; // 如果模板引擎是 velocity // String templatePath = "/templates/mapper.xml.vm"; // 自定义输出配置 List<FileOutConfig> focList = new ArrayList<>(); // 自定义配置会被优先输出 focList.add(new FileOutConfig(templatePath) { @Override public String outputFile(TableInfo tableInfo) { // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！ return projectPath + "/src/main/resources/mapper/" + pc.getModuleName() + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML; } }); cfg.setFileOutConfigList(focList); mpg.setCfg(cfg); // 配置模板 TemplateConfig templateConfig = new TemplateConfig(); // 配置自定义输出模板 //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别 templateConfig.setXml(null); mpg.setTemplate(templateConfig); // 策略配置 StrategyConfig strategy = new StrategyConfig(); strategy.setNaming(NamingStrategy.underline_to_camel); strategy.setColumnNaming(NamingStrategy.underline_to_camel); // strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!"); strategy.setEntityLombokModel(true); strategy.setRestControllerStyle(true); // 公共父类 // strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!"); // 写于父类中的公共字段 strategy.setSuperEntityColumns("id"); strategy.setInclude(scanner("表名，多个英文逗号分割").split(",")); strategy.setControllerMappingHyphenStyle(true); strategy.setTablePrefix(pc.getModuleName() + "_"); mpg.setStrategy(strategy); mpg.setTemplateEngine(new FreemarkerTemplateEngine()); mpg.execute(); } }

MybatisplusConfig配置类

这里直接贴出了多数据源的配置

package com.item.demo.config; import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder; import com.baomidou.mybatisplus.core.MybatisConfiguration; import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor; import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean; import com.item.demo.common.DBTypeEnum; import com.item.demo.common.DynamicDataSource; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.type.JdbcType; import org.mybatis.spring.annotation.MapperScan; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.transaction.annotation.EnableTransactionManagement; import javax.sql.DataSource; import java.util.HashMap; import java.util.Map; @EnableTransactionManagement @Configuration @MapperScan("com.item.demo.mapper") //指定mapper位置 public class MybatisplusConfig { /** * 分页插件 */ @Bean public PaginationInterceptor paginationInterceptor() { PaginationInterceptor paginationInterceptor = new PaginationInterceptor(); // paginationInterceptor.setLimit(你的最大单页限制数量，默认 500 条，小于 0 如 -1 不受限制); return paginationInterceptor; } //初始化数据源1 @Bean(name = "first") @ConfigurationProperties(prefix = "spring.datasource.druid.first") public DataSource db1() { return DruidDataSourceBuilder.create().build(); } //初始化数据源2 @Bean(name = "second") @ConfigurationProperties(prefix = "spring.datasource.druid.second") public DataSource db2() { return DruidDataSourceBuilder.create().build(); } /** * 动态数据源配置 * @return */ @Bean @Primary public DataSource multipleDataSource(@Qualifier("first") DataSource first, @Qualifier("second") DataSource second) { DynamicDataSource dynamicDataSource = new DynamicDataSource(); Map<Object, Object> targetDataSources = new HashMap<>(); //放入数据源1 targetDataSources.put(DBTypeEnum.first.getValue(), first); //放入数据源2 targetDataSources.put(DBTypeEnum.second.getValue(), second); dynamicDataSource.setTargetDataSources(targetDataSources); //设置默认数据源 dynamicDataSource.setDefaultTargetDataSource(first); return dynamicDataSource; } @Bean("sqlSessionFactory") public SqlSessionFactory sqlSessionFactory() throws Exception { MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean(); sqlSessionFactory.setDataSource(multipleDataSource(db1(), db2())); /** * setMapperLocations必须加，解决报错：invalid bound statement (not found)问题 * 指定mapper所在位置 */ sqlSessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml")); MybatisConfiguration configuration = new MybatisConfiguration(); configuration.setJdbcTypeForNull(JdbcType.NULL); configuration.setMapUnderscoreToCamelCase(true); configuration.setCacheEnabled(false); sqlSessionFactory.setConfiguration(configuration); //添加分页功能 sqlSessionFactory.setPlugins(paginationInterceptor()); return sqlSessionFactory.getObject(); } }

关于mybatisplus方法的使用请参照mybatisplus官网教程

Aop实现多数据源的动态切换

原理

通过aop指定mapper所对应的数据源再进行切换

依赖

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>

数据源配置

数据源的配置参照上文中druid的配置和mybatis配置类

动态切换

为方便阅读，我贴出当前项目结构

创建枚举类

package com.item.demo.common; /** * 动态数据源枚举类 * */ public enum DBTypeEnum { first("first"), second("second"); private String value; DBTypeEnum(String value) { this.value = value; } public String getValue() { return value; } }

动态数据源工具

用一个常量来存储当前的数据源

package com.item.demo.common; /** * 动态数据源 DbContextHolder */ public class DbContextHolder { private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>(); /** * 设置数据源 * @param dbTypeEnum */ public static void setDbType(DBTypeEnum dbTypeEnum) { contextHolder.set(dbTypeEnum.getValue()); } /** * 取得当前数据源 * @return */ public static String getDbType() { return (String) contextHolder.get(); } }

AOP指定mapper对应的数据源

package com.item.demo.common; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component; /** * 动态数据源AOP */ @Component @Order(value = -100) @Slf4j @Aspect public class DataSourceSwitchAspect { //设置该路径下mapper使用first数据源 @Pointcut("execution(* com.item.demo.mapper.first..*.*(..))") private void firstAspect() { } //设置该路径下mapper使用second数据源 @Pointcut("execution(* com.item.demo.mapper.second..*.*(..))") private void secondAspect() { } @Before("firstAspect()") public void first() { log.info("切换到first数据源..."); DbContextHolder.setDbType(DBTypeEnum.first); } @Before("secondAspect()") public void second() { log.info("切换到second数据源..."); DbContextHolder.setDbType(DBTypeEnum.second); } }

应用当前数据源

spring boot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源 这样我们可以在执行查询之前，设置使用的数据源。实现可动态路由的数据源，在每次数据库查询操作前执行。 它的抽象方法 determineCurrentLookupKey() 决定使用哪个数据源。

package com.item.demo.common; import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; public class DynamicDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { return DbContextHolder.getDbType(); } }

Redis的集成

依赖

<!--redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.2.4.RELEASE</version> </dependency> <!--redis集成--> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> <!--redis连接池--> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.8.0</version> </dependency>

初始化服务

package com.item.demo.config; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Value; 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 redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; @Configuration @EnableCaching public class RedisCacheConfiguration extends CachingConfigurerSupport { Logger logger = LoggerFactory.getLogger(RedisCacheConfiguration.class); @Value("${spring.redis.host}") private String host; @Value("${spring.redis.port}") private int port; @Value("${spring.redis.timeout}") private int timeout; @Value("${spring.redis.lettuce.pool.max-idle}") private int maxIdle; @Value("${spring.redis.lettuce.pool.max-wait}") private long maxWaitMillis; @Value("${spring.redis.password}") private String password; @Bean public JedisPool redisPoolFactory() { logger.info("JedisPool注入成功！！"); logger.info("redis地址：" + host + ":" + port); JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); jedisPoolConfig.setMaxIdle(maxIdle); jedisPoolConfig.setMaxWaitMillis(maxWaitMillis); JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password); return jedisPool; } }

操作工具类

package com.item.demo.utile; import com.alibaba.fastjson.JSON; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; @Service public class RedisUtils { @Autowired JedisPool jedisPool; /** * 获取单个对象 * */ public <T> T get(String key, Class<T> clazz) { Jedis jedis = null; try { jedis = jedisPool.getResource(); //生成真正的key String realKey = key; String str = jedis.get(realKey); T t = stringToBean(str, clazz); return t; }finally { returnToPool(jedis); } } /** * 存入对象 * */ public <T> boolean set(String key, T value) { Jedis jedis = null; try { jedis = jedisPool.getResource(); String str = beanToString(value); if(str == null || str.length() <= 0) { return false; } //生成真正的key String realKey = key; int seconds = 0; if(seconds <= 0) { jedis.set(realKey, str); }else { jedis.setex(realKey, seconds, str); } return true; }finally { returnToPool(jedis); } } /** * 判断key是否存在 * */ public <T> boolean exists(String key) { Jedis jedis = null; try { jedis = jedisPool.getResource(); //生成真正的key String realKey = key; return jedis.exists(realKey); }finally { returnToPool(jedis); } } /** * 增加值 * */ public <T> Long incr(String key) { Jedis jedis = null; try { jedis = jedisPool.getResource(); //生成真正的key String realKey = key; return jedis.incr(realKey); }finally { returnToPool(jedis); } } /** * 减少值 * */ public <T> Long decr(String key) { Jedis jedis = null; try { jedis = jedisPool.getResource(); //生成真正的key String realKey = key; return jedis.decr(realKey); }finally { returnToPool(jedis); } } private <T> String beanToString(T value) { if(value == null) { return null; } Class<?> clazz = value.getClass(); if(clazz == int.class || clazz == Integer.class) { return ""+value; }else if(clazz == String.class) { return (String)value; }else if(clazz == long.class || clazz == Long.class) { return ""+value; }else { return JSON.toJSONString(value); } } private <T> T stringToBean(String str, Class<T> clazz) { if(str == null || str.length() <= 0 || clazz == null) { return null; } if(clazz == int.class || clazz == Integer.class) { return (T)Integer.valueOf(str); }else if(clazz == String.class) { return (T)str; }else if(clazz == long.class || clazz == Long.class) { return (T)Long.valueOf(str); }else { return JSON.toJavaObject(JSON.parseObject(str), clazz); } } private void returnToPool(Jedis jedis) { if(jedis != null) { jedis.close(); } } }

测试

@GetMapping @ApiOperation(value = "测试redis") public Object redis() { boolean b = redisUtils.set("key2","hello word"); if(b){ String value = redisUtils.get("key2",String.class); return ResultVo.oK(value); } return ResultVo.failed(500,"失败了"); }