前言

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

基本框架搭建

基本框架的搭建可参照我之前的博文《使用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:#数据源1first:username: rootpassword: ZZlj981225url: jdbc:mysql://rm-bp1a8r0z2zl9v603r2o.mysql.rds.aliyuncs.com:3306/book?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTCdriver-class-name: com.mysql.cj.jdbc.Drivertype: com.alibaba.druid.pool.DruidDataSource#数据源2second:username: rootpassword: ZZlj981225url: jdbc:mysql://rm-bp1a8r0z2zl9v603r2o.mysql.rds.aliyuncs.com:3306/car?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTCdriver-class-name: com.mysql.cj.jdbc.Drivertype: com.alibaba.druid.pool.DruidDataSource#Spring Boot 默认是不注入这些属性值的，需要自己绑定#druid 数据源专有配置#初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时initialSize: 5#最小连接池数量minIdle: 5#最大连接池数量maxActive: 20#获取连接时最大等待时间，单位毫秒，配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。#maxWait: 60000timeBetweenEvictionRunsMillis: 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# 打开PSCachepoolPreparedStatements: 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: 500MBmax-request-size: 500MB

Redis

#Redisredis:database: 0host: 127.0.0.1password: 12345port: 6379#连接超时时间毫秒(类型为Duration，添加秒)timeout: 30000# Lettucelettuce: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: mysqlreasonable: truesupport-methods-arguments: trueparams: 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")@Beanpublic DataSource druidDataSource() {return new DruidDataSource();}//因为Springboot内置了servlet容器，所以没有web.xml，替代方法就是将ServletRegistrationBean注册进去//加入后台监控@Bean  //这里其实就相当于servlet的web.xmlpublic 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同时存在优先denyinitParas.put("resetEnable", "false");//禁用HTML页面的Reset按钮bean.setInitParameters(initParas);return bean;}//再配置一个过滤器，Servlet按上面的方式注册Filter也只能这样@Beanpublic 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() {@Overridepublic void initMap() {// to do nothing}};// 如果模板引擎是 freemarkerString templatePath = "/templates/mapper.xml.ftl";// 如果模板引擎是 velocity// String templatePath = "/templates/mapper.xml.vm";// 自定义输出配置List<FileOutConfig> focList = new ArrayList<>();// 自定义配置会被优先输出focList.add(new FileOutConfig(templatePath) {@Overridepublic 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 {/*** 分页插件*/@Beanpublic 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@Primarypublic DataSource multipleDataSource(@Qualifier("first") DataSource first, @Qualifier("second") DataSource second) {DynamicDataSource dynamicDataSource = new DynamicDataSource();Map<Object, Object> targetDataSources = new HashMap<>();//放入数据源1targetDataSources.put(DBTypeEnum.first.getValue(), first);//放入数据源2targetDataSources.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 {@Overrideprotected 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;@Beanpublic 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 {@AutowiredJedisPool jedisPool;/*** 获取单个对象* */public <T> T get(String key,  Class<T> clazz) {Jedis jedis = null;try {jedis =  jedisPool.getResource();//生成真正的keyString 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;}//生成真正的keyString 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();//生成真正的keyString realKey  = key;return  jedis.exists(realKey);}finally {returnToPool(jedis);}}/*** 增加值* */public <T> Long incr(String key) {Jedis jedis = null;try {jedis =  jedisPool.getResource();//生成真正的keyString realKey  = key;return  jedis.incr(realKey);}finally {returnToPool(jedis);}}/*** 减少值* */public <T> Long decr(String key) {Jedis jedis = null;try {jedis =  jedisPool.getResource();//生成真正的keyString 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,"失败了");}