Redis 配置连接池，redisTemplate 操作多个db数据库，切换多个db，解决JedisConnectionFactory的设置连接方法过时问题。（转）

环境

springmvc
jdk1.8
maven

redis.properties配置文件

#redis setting

redis.host=localhost

redis.port=6379

redis.password=

redis.maxIdle=200

redis.minIdle=0

redis.maxActive=50

redis.maxWait=10000

redis.testOnBorrow=true

redis.timeout=100000

#定义需要使用的db

//#sessionCode DB

sessionCodeDb = 0

//#车辆基本信息 DB

bicycleInfoDb = 15

//#当前位置信息 DB

currentLocationDb = 14

//#锁车/解锁 DB

lockDb = 13

//#根据车牌获取电子车牌 DB

ebikeNoDb = 12

//#根据电子车牌获取车牌 DB

bikeNoDb = 11

pom.xml依赖

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <spring.version>5.1.2.RELEASE</spring.version>

    </properties>

    <!-- spring4 start -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context-support</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-web</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-webmvc</artifactId>

            <version>${spring.version}</version>

        </dependency>

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->

        <dependency>

            <groupId>redis.clients</groupId>

            <artifactId>jedis</artifactId>

            <version>2.9.3</version>

        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->

        <dependency>

            <groupId>org.springframework.data</groupId>

            <artifactId>spring-data-redis</artifactId>

            <version>2.0.14.RELEASE</version>

        </dependency>

        <!-- fastjson -->

        <dependency>

            <groupId>com.alibaba</groupId>

            <artifactId>fastjson</artifactId>

            <version>1.2.11</version>

        </dependency>

        <!-- json-lib -->

        <!-- <dependency> <groupId>net.sf.json-lib</groupId> <artifactId>json-lib</artifactId> <version>2.4</version> <classifier>jdk15</classifier>

            </dependency> -->

        <dependency>

            <groupId>net.sf.json-lib</groupId>

            <artifactId>json-lib</artifactId>

            <version>2.4</version>

            <classifier>jdk15</classifier>

        </dependency>

RedisConfig.java 配置类初始化redis连接池

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.RedisPassword;

import org.springframework.data.redis.connection.RedisStandaloneConfiguration;

import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.ValueOperations;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import org.springframework.stereotype.Component;

import redis.clients.jedis.JedisPoolConfig;

import javax.annotation.PostConstruct;

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.TimeUnit;

@Component

@Slf4j

public class RedisConfig {

    @Value("${redis.host}")

    private String hostName;

    @Value("${redis.port}")

    private int port;

    @Value("${redis.password}")

    private String passWord;

    @Value("${redis.maxIdle}")

    private int maxIdl;

    @Value("${redis.minIdle}")

    private int minIdl;

    @Value("${redis.timeout}")

    private int timeout;

    @Value("${sessionCodeDb}")

    private int sessionCodeDb;

    @Value("${bicycleInfoDb}")

    private int bicycleInfoDb;

    @Value("${currentLocationDb}")

    private int currentLocationDb;

    @Value("${lockDb}")

    private int lockDb;

    @Value("${ebikeNoDb}")

    private int ebikeNoDb;

    @Value("${bikeNoDb}")

    private int bikeNoDb;

    public static Map<Integer,RedisTemplate<Serializable, Object>> redisTemplateMap = new HashMap<>();

    @PostConstruct

    public void initRedisTemp() throws Exception{

        log.info("###### START 初始化 Redis 连接池 START ######");

        redisTemplateMap.put(sessionCodeDb,redisTemplateObject(sessionCodeDb));

        redisTemplateMap.put(bicycleInfoDb,redisTemplateObject(bicycleInfoDb));

        redisTemplateMap.put(currentLocationDb,redisTemplateObject(currentLocationDb));

        redisTemplateMap.put(lockDb,redisTemplateObject(lockDb));

        redisTemplateMap.put(ebikeNoDb,redisTemplateObject(ebikeNoDb));

        redisTemplateMap.put(bikeNoDb,redisTemplateObject(bikeNoDb));

        log.info("###### END 初始化 Redis 连接池 END ######");

    }

    public RedisTemplate<Serializable, Object> redisTemplateObject(Integer dbIndex) throws Exception {

        RedisTemplate<Serializable, Object> redisTemplateObject = new RedisTemplate<Serializable, Object>();

        redisTemplateObject.setConnectionFactory(redisConnectionFactory(jedisPoolConfig(),dbIndex));

        setSerializer(redisTemplateObject);

        redisTemplateObject.afterPropertiesSet();

        return redisTemplateObject;

    }

    /**

     * 连接池配置信息

     * @return

     */

    public JedisPoolConfig jedisPoolConfig() {

        JedisPoolConfig poolConfig=new JedisPoolConfig();

        //最大连接数

        poolConfig.setMaxIdle(maxIdl);

        //最小空闲连接数

        poolConfig.setMinIdle(minIdl);

        poolConfig.setTestOnBorrow(true);

        poolConfig.setTestOnReturn(true);

        poolConfig.setTestWhileIdle(true);

        poolConfig.setNumTestsPerEvictionRun(10);

        poolConfig.setTimeBetweenEvictionRunsMillis(60000);

        //当池内没有可用的连接时，最大等待时间

        poolConfig.setMaxWaitMillis(10000);

        //------其他属性根据需要自行添加-------------

        return poolConfig;

    }

    /**

     * jedis连接工厂

     * @param jedisPoolConfig

     * @return

     */

    public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig,int db) {

        //单机版jedis

        RedisStandaloneConfiguration redisStandaloneConfiguration =

                new RedisStandaloneConfiguration();

        //设置redis服务器的host或者ip地址

        redisStandaloneConfiguration.setHostName(hostName);

        //设置默认使用的数据库

        redisStandaloneConfiguration.setDatabase(db);

        //设置密码

        redisStandaloneConfiguration.setPassword(RedisPassword.of(passWord));

        //设置redis的服务的端口号

        redisStandaloneConfiguration.setPort(port);

        //获得默认的连接池构造器(怎么设计的，为什么不抽象出单独类，供用户使用呢)

        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =

                (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder)JedisClientConfiguration.builder();

        //指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！）

        jpcb.poolConfig(jedisPoolConfig);

        //通过构造器来构造jedis客户端配置

        JedisClientConfiguration jedisClientConfiguration = jpcb.build();

        //单机配置 + 客户端配置 = jedis连接工厂

        return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);

    }

    private void setSerializer(RedisTemplate<Serializable, Object> template) {

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(

                Object.class);

        ObjectMapper om = new ObjectMapper();

        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(om);

        template.setKeySerializer(template.getStringSerializer());

        template.setValueSerializer(jackson2JsonRedisSerializer);

        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        //在使用String的数据结构的时候使用这个来更改序列化方式

        RedisSerializer<String> stringSerializer = new StringRedisSerializer();

        template.setKeySerializer(stringSerializer );

        template.setValueSerializer(stringSerializer );

        template.setHashKeySerializer(stringSerializer );

        template.setHashValueSerializer(stringSerializer );

    }

    /**

     * 删除对应的value

     * @param key

     */

    public void remove(final String key,int db) {

        RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);

        if (exists(key,redisTemplate)) {

            redisTemplate.delete(key);

        }

    }

    /**

     * 判断缓存中是否有对应的value

     * @param key

     * @return

     */

    public boolean exists(final String key,RedisTemplate<Serializable, Object> redisTemplate) {

        return redisTemplate.hasKey(key);

    }

    /**

     * 读取缓存

     * @param key

     * @return

     */

    public Object get(final String key,int db) {

        RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);

        Object result = null;

        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();

        result = operations.get(key);

        return result;

    }

    /**

     * 写入缓存

     * @param key

     * @param value

     * @return

     */

    public boolean set(final String key, Object value,int db) {

        RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);

        boolean result = false;

        try {

            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();

            operations.set(key, value);

            result = true;

        } catch (Exception e) {

            log.error("set cache error", e);

        }

        return result;

    }

    /**

     * 根据key 获取过期时间

     * @param key 键 不能为null

     * @return 返回0代表为永久有效

     */

    public long getExpire(String key,TimeUnit unit,int db) {

        RedisTemplate<Serializable, Object> redisTemplate = getRedisTemplateByDb(db);

        return redisTemplate.getExpire(key, unit);

    }

/**

     * 根据db 获取对应的redisTemplate实例

     * @param db

     * @return

     */

    public RedisTemplate<Serializable, Object> getRedisTemplateByDb(int db){

        return redisTemplateMap.get(db);

    }

}

在其他类中的使用

    @Autowired

    private RedisConfig redisUtil;

    //#获取db0 数据库的数据

    public static Integer sessionCodeDb = 0;

/**

     * 根据sessionCode获取userId

     * @param sessionCode

     * @return

     */

    public String getUserIdBySessionCode(String sessionCode){

        try {

            Object obj = redisUtil.get(sessionCode,sessionCodeDb);

            if(obj!=null) {

                return obj.toString();

            }else{

                return null;

            }

        }catch (Exception e){

            e.printStackTrace();

            return null;

        }

    }

Redis 配置连接池，redisTemplate 操作多个db数据库，切换多个db，解决JedisConnectionFactory的设置连接方法过时问题。（转）的更多相关文章

python使用dbutils的PooledDB连接池，操作数据库
1.使用dbutils的PooledDB连接池,操作数据库. 这样就不需要每次执行sql后都关闭数据库连接,频繁的创建连接,消耗时间 2.如果是使用一个连接一直不关闭,多线程下,插入超长字符串到数据库 ...
泊爷带你学go -- redis连接池的操作
package main import ( "common" "fmt" "proto" "strconv" " ...
springboot整合druid连接池、mybatis实现多数据源动态切换
demo环境: JDK 1.8 ,Spring boot 1.5.14 一整合durid 1.添加druid连接池maven依赖 <dependency> <groupId> ...
ASP.NET MVC- EF返回连接池用ADO.NET方式访问数据库
用习惯了ADO.NET的方式去访问数据库,虽然ADO.NET写的代码没有EF简洁,可是也并不麻烦.而且EF在进行多表查询的那种方式是,EF需要先去数据库里定义外键,再进去一次代码生成,然后才能用INC ...
JDBC连接池。。。转载
1. 引言近年来,随着Internet/Intranet建网技术的飞速发展和在世界范围内的迅速普及,计算机应用程序已从传统的桌面应用转到Web应用.基于B/S(Browser/Server)架 ...
Oracle连接池
原由:许多用户可能在查询相同的数据库以获取相同的数据.在这些情况下,可以通过使应用程序共享到数据源的连接来提高应用程序的性能.否则,让每个用户打开和关闭单独的连接的开销会对应用程序性能产生不利影响.这 ...
redis连接池——JedisPool和JedisCluster的介绍与使用
目录 Jedis使用方式的介绍 Redis连接池介绍创建连接池配置文件单机版的Redis连接池集群版的Redis连接池总结 Jedis使用方式的介绍 Jedis就是Java实现的操作Redis ...
C3p0连接池配置
在Java开发中,使用JDBC操作数据库的四个步骤如下: ①加载数据库驱动程序(Class.forName("数据库驱动类");) ②连接数据库(Connection co ...
搭建spring工程配置数据源连接池
Spring作为一个优秀的开源框架,越来越为大家所熟知,前段时间用搭了个spring工程来管理数据库连接池,没有借助Eclipse纯手工搭建,网上此类文章不多,这里给大家分享一下,也作为一个手记. 工 ...

随机推荐

[CF544D]Destroying Roads_最短路_bfs
D. Destroying Roads 题目大意: In some country there are exactly n cities and m bidirectional roads conne ...
架构设计之CAP定理
一.什么是 CAP? 「 CAP定理」又被称为布鲁尔定理,它提出对于一个分布式系统而言,不能同时满足以下三点: Consisteny(一致性) Availability(可用性) Partitio ...
X86逆向12：内存补丁的制作
本章我们将学习各种打补丁的方式,补丁在软件的破解过程中非常的重要,比如软件无法脱壳我们就只能通过打补丁的方式来破解程序,补丁原理就是当程序运行起来会被释放到内存并解码,然后补丁就通过地址或特征码定位到 ...
Lua 截取字符串（截取utf-8格式字符串）
对utf-8完全没概念的可以看看我上一篇随笔:简单说说utf-8编码格式另外,还要知道string.sub 和 string.byte 的用法. 先上完整代码: local StringHelper ...
SSD性能测试
Tested by CrystalDiskMark 7 * MB/s = 1,000,000 bytes/s [SATA/600 = 600,000,000 bytes/s]* KB = 1000 b ...
Android 直连SQL
在工作中遇到需求需要Android直接连接SQL,看了一些人说不建议直连,但我对性能没有要求,甚至说只要在局域网内能够使用就行,简单说把手机当作一个简单的移动操作点. 代码的话,网上都有比如: htt ...
c# TCP/IP协议利用Socket Client通信(只含客户端Demo)
完全是基础,新手可以随意看看,大牛可以关闭浏览页了,哈哈. TCP/IP协议 TCP/IP是一系列网络通信协议的统称,其中最核心的两个协议是TCP和IP.TCP称为传输控制协议,IP称为互联网络协议. ...
【原创】大数据基础之Gobblin（2）持久化kafka到hdfs
gobblin 0.10 想要持久化kafka到hdfs有很多种方式,比如flume.logstash.gobblin,其中flume和logstash是流式的,gobblin是批处理式的,gobbl ...
移动端真机debug调试神器 vConsole学习（二）之实战
项目中实际使用在项目中实际使用的时候发现还是有很多问题的最初使用方式 <script src="vconsole.min.js"></script> ...
opencv ORB各参数的含义
ORB中有很多参数可以设置,在OpenCV中它可以通过ORB来创建一个ORB检测器. ORB::ORB(int nfeatures=500, float scaleFactor=1.2f, int n ...

Redis 配置连接池，redisTemplate 操作多个db数据库，切换多个db，解决JedisConnectionFactory的设置连接方法过时问题。（转）

环境

redis.properties配置文件

pom.xml依赖

RedisConfig.java 配置类 初始化redis连接池

在其他类中的使用

Redis 配置连接池，redisTemplate 操作多个db数据库，切换多个db，解决JedisConnectionFactory的设置连接方法过时问题。（转）的更多相关文章

随机推荐

热门专题

RedisConfig.java 配置类初始化redis连接池