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纯手工搭建,网上此类文章不多,这里给大家分享一下,也作为一个手记. 工 ...

随机推荐

【转帖】比df命令更有用的磁盘信息工具
比df命令更有用的磁盘信息工具 http://embeddedlinux.org.cn/emb-linux/entry-level/201310/30-2666.html 除了df fdisk 还有这 ...
odoo10实现单点登陆绕过登陆集成页面
背景:由于需要集成odoo平台在其他页面,需要绕开登陆. 解决办法:开辟一个自动登陆的路由用与集成页面. 1.修改web模块中controller/main.py文件,在class名字为Home中添加 ...
Spring4学习回顾之路08- FactoryBean配置Bean
建立Student.java package com.lql.srping04; /** * @author: lql * @date: 2019.10.28 * Description: */ pu ...
Tornado WebSocket简单聊天
Tornado实现了对socket的封装:tornado.web.RequestHandler 工程目录: 1.主程序 manage.py import tornado.web import torn ...
Ruby Rails学习中：User 模型，验证用户数据
用户建模一. User 模型实现用户注册功能的第一步是,创建一个数据结构,用于存取用户的信息. 在 Rails 中,数据模型的默认数据结构叫模型(model,MVC 中的 M).Rails 为解决 ...
MGR复制
CentOS7 配置如下 5.7.22 Group ReplicationMySQL5.7.22安装略在三台db服务器上面设置/etc/hosts映射,如下:192.168.1.101 mydb ...
14-Perl 引用
1.Perl 引用引用就是指针.Perl 引用是一个标量类型,可以指向变量.数组.哈希表(也叫关联数组)甚至子程序,可以应用在程序的任何地方.2.创建引用定义变量的时候,在变量名前面加个\,就得到了这 ...
关于servlet类，继承HttpServlet，但是无法导入HttpServlet包的原因和解决方法
原因:缺少tomcat的libraries(HttpServlet对应位置在tomcat的lib中====) 解决: 1. 2. 3. 4.
记录：初入Java环境部署踩坑
1.在部署环境之前,先确定大佬们用的哪几种软件,然后依次下载,安装,IDEA, JDK, Tomcat, Maven. 什么是JDK? JDK是 Java 语言的软件开发工具包,主要用于移 ...
Javascript 中apply call bind
在 javascript 中,call 和 apply 都是为了改变某个函数运行时的上下文(context)而存在的,换句话说,就是为了改变函数体内部 this 的指向. 先来一个例子: functi ...

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

环境

redis.properties配置文件

pom.xml依赖

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

在其他类中的使用

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

随机推荐

热门专题

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