如何在spring配置文件中配置jedis连接池主从redis_框架

xmlns:mvc=">

@param args

public static void main(String[] args) {

//连接 redis 服务

Jedis jedis = new Jedis( "1921688815" ,6379);

//密码验证-如果你没有设置 redis 密码可不验证即可使用相关命令

// jedisauth(" abcdefg ");

//简单的key-value 存储

jedisset( "redis" , "myredis" );

System out println(jedisget( "redis" ));

//在原有值得基础上添加,如若之前没有该key，则导入该key

//之前已经设定了 redis 对应" myredis ",此句执行便会使 redis 对应"myredisyourredis "

jedisappend( "redis" , "yourredis" );

jedisappend( "content" , "rabbit" );

// mset 是设置多个key-value值参数（key1,value1,key2,value2,, keyn , valuen）

// mget 是获取多个key所对应的value值参数（key1,key2,key3,, keyn ）返回的是个list

jedismset( "name1" , "yangw" , "name2" , "demon" , "name3" , "elena" );

System out println(jedismget( "name1" , "name2" , "name3" ));

//map

Map<String,String> user = new HashMap<String,String>();

userput( "name" , "cd" );

userput( "password" , "123456" );

//map存入 redis

jedishmset( "user" , user);

// mapkey 个数

System out println(String format ( "len:%d" , jedishlen( "user" )));

//map中的所有键值

System out println(String format ( "keys: %s" , jedishkeys( "user" ) ));

//map中的所有value

System out println(String format ( "values: %s" , jedishvals( "user" ) ));

//取出map中的name字段值

List<String> rsmap = jedishmget( "user" , "name" , "password" );

System out println(rsmap);

//删除map中的某一个键值 password

jedishdel( "user" , "password" );

System out println(jedishmget( "user" , "name" , "password" ));

//list

jedisdel( "listDemo" );

System out println(jedislrange( "listDemo" , 0, -1));

jedislpush( "listDemo" , "A" );

jedislpush( "listDemo" , "B" );

jedislpush( "listDemo" , "C" );

System out println(jedislrange( "listDemo" , 0, -1));

System out println(jedislrange( "listDemo" , 0, 1));

//set

jedissadd( "sname" , "wobby" );

jedissadd( "sname" , "kings" );

jedissadd( "sname" , "demon" );

System out println(String format ( "set num: %d" , jedisscard( "sname" )));

System out println(String format ( "all members: %s" , jedissmembers( "sname")));

System out println(String format ( "is member: %B" , jedissismember( "sname" , "wobby" )));

System out println(String format ( "rand member: %s" , jedissrandmember("sname" )));

//删除一个对象

jedissrem( "sname" , "demon" );

System out println(String format ( "all members: %s" , jedissmembers( "sname")));

}

二、将自定义对象保存到redis中：

1、自定义pojo 实现Serializable 接口：

package cnmingyuanredis;

import javaioSerializable;

测试用 pojo ，实现了 Serializable ，以便进行系列化 *** 作

@author mingyuan

public class Person implements Serializable {

private static final long serialVersionUID = -3562550857760039655L;

private String name ;

private int age ;

public Person(){}

public Person(String name, int age) {

super ();

this name = name;

this age = age;

}

public String getName() {

return name ;

}

public void setName(String name) {

this name = name;

}

public int getAge() {

return age ;

}

public void setAge( int age) {

this age = age;

}

@Override

public String toString() {

return "Person [name=" + name + ", age=" + age + "]" ;

}

2、测试类：

package cnmingyuanredis;

import javaioByteArrayInputStream;

import javaioByteArrayOutputStream;

import javaioIOException;

import javaioObjectInputStream;

import javaioObjectOutputStream;

import redisclientsjedisJedis;

public class Test {

@param args

@throws IOException

@throws ClassNotFoundException

public static void main(String[] args) throws IOException,

ClassNotFoundException {

// Jedis redis = new Jedis ("1921688815");

Jedis redis = new Jedis( "1921688815" , 6379);

// connect可以不要，因为在执行set *** 作的时候会先进行判断客户端是否于服务器端建立了连接，若无，则启动连接过程

redisconnect();

String set = redisset( "mingyuan" , "1" );

System out println( " set result \t" + set);

redisincr( "mingyuan" );

String string = redisget( "mingyuan" );

System out println( " get result of key 'mingyuan' \t" + string);

// 下面是对对象进行存储的测试代码

ByteArrayOutputStream bos = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(bos);

Person person = new Person( "liudehua" ,22);

ooswriteObject(person);

byte [] byteArray = bostoByteArray();

oosclose();

bosclose();

String setObjectRet = redisset( "mingyuan" getBytes(), byteArray);

System out println( " set object return \t" + setObjectRet);

byte [] bs = redisget( "mingyuan" getBytes());

ByteArrayInputStream bis = new ByteArrayInputStream(bs);

ObjectInputStream inputStream = new ObjectInputStream(bis);

Person readObject = (Person) inputStreamreadObject();

System out println( " read object \t" + readObjecttoString());

inputStreamclose();

bisclose();

redisdisconnect();

}

不多说直接上代码：

<groupId>orgspringframeworkboot</groupId>

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

<groupId>redisclients</groupId>

<artifactId>jedis</artifactId>

</exclusion>

<groupId>iolettuce</groupId>

<artifactId>lettuce-core</artifactId>

</exclusion>

</exclusions>

</dependency>

<groupId>redisclients</groupId>

<artifactId>jedis</artifactId>

</dependency>

<groupId>orgapachecommons</groupId>

<artifactId>commons-pool2</artifactId>

</dependency>

<groupId>comalibaba</groupId>

<artifactId>fastjson</artifactId>

</dependency>

#Matser的ip地址

redishostName=1721644148

#端口号

redisport=6379

#如果有密码

redispassword=

#客户端超时时间单位是毫秒默认是2000

redistimeout=10000

#最大空闲数

redismaxIdle=300

#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 24以后用redismaxTotal

#redismaxActive=600

#控制一个pool可分配多少个jedis实例,用来替换上面的redismaxActive,如果是jedis 24以后用该属性

redismaxTotal=1000

#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。

redismaxWaitMillis=1000

#连接的最小空闲时间默认1800000毫秒(30分钟)

redisminEvictableIdleTimeMillis=300000

#每次释放连接的最大数目,默认3

redisnumTestsPerEvictionRun=1024

#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1

redistimeBetweenEvictionRunsMillis=30000

#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个

redistestOnBorrow=true

#在空闲时检查有效性, 默认false

redistestWhileIdle=true

package comjunsidemoconfig;

import orgspringframeworkbeansfactoryannotationValue;

import orgspringframeworkcontextannotationBean;

import orgspringframeworkcontextannotationConfiguration;

import orgspringframeworkcontextannotationPropertySource;

import orgspringframeworkdataredisconnectionRedisConnectionFactory;

import orgspringframeworkdataredisconnectionjedisJedisConnectionFactory;

import orgspringframeworkdatarediscoreRedisTemplate;

import orgspringframeworkdataredisserializerGenericJackson2JsonRedisSerializer;

import orgspringframeworkdataredisserializerStringRedisSerializer;

import comjunsidemoutilsRedisUtil;

import redisclientsjedisJedisPoolConfig;

Redis配置类

@author pzx

2019年6月8日

@Configuration

@PropertySource("classpath:redisproperties")

public class RedisConfig {

@Value("${redismaxIdle}")

private Integer maxIdle;

@Value("${redismaxTotal}")

private Integer maxTotal;

@Value("${redismaxWaitMillis}")

private Integer maxWaitMillis;

@Value("${redisminEvictableIdleTimeMillis}")

private Integer minEvictableIdleTimeMillis;

@Value("${redisnumTestsPerEvictionRun}")

private Integer numTestsPerEvictionRun;

@Value("${redistimeBetweenEvictionRunsMillis}")

private long timeBetweenEvictionRunsMillis;

@Value("${redistestOnBorrow}")

private boolean testOnBorrow;

@Value("${redistestWhileIdle}")

private boolean testWhileIdle;

@Value("${springredisclusternodes}")

private String clusterNodes;

@Value("${springredisclustermax-redirects}")

private Integer mmaxRedirectsac;

JedisPoolConfig 连接池

@return

@Bean

public JedisPoolConfig jedisPoolConfig() {

JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

// 最大空闲数

jedisPoolConfigsetMaxIdle(maxIdle);

// 连接池的最大数据库连接数

jedisPoolConfigsetMaxTotal(maxTotal);

// 最大建立连接等待时间

jedisPoolConfigsetMaxWaitMillis(maxWaitMillis);

// 逐出连接的最小空闲时间默认1800000毫秒(30分钟)

jedisPoolConfigsetMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);

// 每次逐出检查时逐出的最大数目如果为负数就是 : 1/abs(n), 默认3

jedisPoolConfigsetNumTestsPerEvictionRun(numTestsPerEvictionRun);

// 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1

jedisPoolConfigsetTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

// 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个

jedisPoolConfigsetTestOnBorrow(testOnBorrow);

// 在空闲时检查有效性, 默认false

jedisPoolConfigsetTestWhileIdle(testWhileIdle);

return jedisPoolConfig;

}

@param jedisPoolConfig

@return

@Bean

public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig){

JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);

//连接池

JedisConnectionFactorysetPoolConfig(jedisPoolConfig);

//IP地址

JedisConnectionFactorysetHostName("1721644148");

//端口号

JedisConnectionFactorysetPort(6379);

//如果Redis设置有密码

//JedisConnectionFactorysetPassword(password);

//客户端超时时间单位是毫秒

JedisConnectionFactorysetTimeout(5000);

return JedisConnectionFactory;

}

实例化 RedisTemplate 对象

@return

@Bean

public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

initDomainRedisTemplate(redisTemplate, redisConnectionFactory);

return redisTemplate;

}

设置数据存入 redis 的序列化方式,并开启事务

@param redisTemplate

@param factory

private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {

//如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！

redisTemplatesetKeySerializer(new StringRedisSerializer());

redisTemplatesetHashKeySerializer(new StringRedisSerializer());

redisTemplatesetHashValueSerializer(new GenericJackson2JsonRedisSerializer());

redisTemplatesetValueSerializer(new GenericJackson2JsonRedisSerializer());

// 开启事务

redisTemplatesetEnableTransactionSupport(true);

redisTemplatesetConnectionFactory(factory);

}

@Bean(name = "redisUtil")

public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {

RedisUtil redisUtil = new RedisUtil();

redisUtilsetRedisTemplate(redisTemplate);

return redisUtil;

}

1，JedisPool的使用

//WHEN_EXHAUSTED_FAIL = 0; 直接抛出异常throw new NoSuchElementException("Pool exhausted");

//WHEN_EXHAUSTED_BLOCK = 1;borrowObject()将会阻塞，直到有可用新的或者空闲的object为止，或者如果配置了maxWait，

//如果请求阻塞超时，将抛出NoSuchElementException如果maxWait为负数，请求将会无限制的阻

//塞下去，默认配置。

//WHEN_EXHAUSTED_GROW = 2;borrowObject()将会继续创建新的对象，并返回，因此，pool维护的对像数将超出maxActive；

</bean>

public String set(String key, String value) {

Jedis jedis = null;

boolean success = true;

try {

jedis = thispoolgetResource();

return jedisset(key, value);

}catch (JedisException e) {

success = false;

if(jedis != null){

poolreturnBrokenResource(jedis);

}

throw e;

}finally{

if(success && jedis != null){

thispoolreturnResource(jedis);

}

获取Jedis

poolgetResource();

这个可以直接看Pool的getResource方法,

最终还是GenericObjectPool的borrowObject()方法借用对象

@SuppressWarnings("unchecked")

public T getResource() {

try {

return (T) internalPoolborrowObject();

} catch (Exception e) {

throw new JedisConnectionException(

"Could not get a resource from the pool", e);

}

用完归还,调用的是GenericObjectPool的returnObject（)方法

poolreturnResource(jedis)

//JedisPooljava

public void returnResource(final BinaryJedis resource) {

returnResourceObject(resource);

}

//Pooljava

public void returnResourceObject(final Object resource) {

try {

internalPoolreturnObject(resource);

} catch (Exception e) {

throw new JedisException(

"Could not return the resource to the pool", e);

}

出错，调用的是GenericObjectPool的invalidateObject（)方法

最后在JedisFactory的destroyObject（）中调用jedisquit()请求Server关闭连接

poolreturnBrokenResource(jedis)

//JedisPooljava

public void returnBrokenResource(final BinaryJedis resource) {

returnBrokenResourceObject(resource);

}

//Pooljava

protected void returnBrokenResourceObject(final Object resource) {

try {

//失效

internalPoolinvalidateObject(resource);

} catch (Exception e) {

throw new JedisException(

"Could not return the resource to the pool", e);

}

//GenericObjectPool

public void invalidateObject(Object obj)

throws Exception

{

try

{

if (this_factory != null)

this_factorydestroyObject(obj);

}

finally {

synchronized (this) {

this_numActive -= 1;

allocate();

}

//JedisFactory

public void destroyObject(final Object obj) throws Exception {

if (obj instanceof Jedis) {

final Jedis jedis = (Jedis) obj;

if (jedisisConnected()) {

try {

jedisquit();

} catch (Exception e) {

}

jedisdisconnect();

} catch (Exception e) {

}

JedisPool源代码

package redisclientsjedis;

import orgapachecommonspoolBasePoolableObjectFactory;

import orgapachecommonspoolimplGenericObjectPoolConfig;

import redisclientsutilPool;

public class JedisPool extends Pool<Jedis> {

public JedisPool(final Config poolConfig, final String host) {

this(poolConfig, host, ProtocolDEFAULT_PORT, ProtocolDEFAULT_TIMEOUT, null, ProtocolDEFAULT_DATABASE);

}

public JedisPool(String host, int port) {

this(new Config(), host, port, ProtocolDEFAULT_TIMEOUT, null, ProtocolDEFAULT_DATABASE);

}

public JedisPool(final String host) {

this(host, ProtocolDEFAULT_PORT);

}

public JedisPool(final Config poolConfig, final String host, int port,

int timeout, final String password) {

this(poolConfig, host, port, timeout, password, ProtocolDEFAULT_DATABASE);

}

public JedisPool(final Config poolConfig, final String host, final int port) {

this(poolConfig, host, port, ProtocolDEFAULT_TIMEOUT, null, ProtocolDEFAULT_DATABASE);

}

public JedisPool(final Config poolConfig, final String host, final int port, final int timeout) {

this(poolConfig, host, port, timeout, null, ProtocolDEFAULT_DATABASE);

}

public JedisPool(final Config poolConfig, final String host, int port, int timeout, final String password,

final int database) {

super(poolConfig, new JedisFactory(host, port, timeout, password, database));

}

public void returnBrokenResource(final BinaryJedis resource) {

returnBrokenResourceObject(resource);

}

public void returnResource(final BinaryJedis resource) {

returnResourceObject(resource);

}

PoolableObjectFactory custom impl

private static class JedisFactory extends BasePoolableObjectFactory {

private final String host;

private final int port;

private final int timeout;

private final String password;

private final int database;

public JedisFactory(final String host, final int port,

final int timeout, final String password, final int database) {

super();

thishost = host;

thisport = port;

thistimeout = timeout;

thispassword = password;

thisdatabase = database;

}

public Object makeObject() throws Exception {

final Jedis jedis = new Jedis(thishost, thisport, thistimeout);

jedisconnect();

if (null != thispassword) {

jedisauth(thispassword);

}

if( database != 0 ) {

jedisselect(database);

}

return jedis;

}

public void destroyObject(final Object obj) throws Exception {

if (obj instanceof Jedis) {

final Jedis jedis = (Jedis) obj;

if (jedisisConnected()) {

try {

jedisquit();

} catch (Exception e) {

}

jedisdisconnect();

} catch (Exception e) {

}

public boolean validateObject(final Object obj) {

if (obj instanceof Jedis) {

final Jedis jedis = (Jedis) obj;

try {

return jedisisConnected();/ && jedisping()equals("PONG");/

} catch (final Exception e) {

return false;

}

} else {

return false;

目前在做自动化测试时，设计到需要获取存储在redis中的值，总结了 *** 作代码如下：

需要jar包：jedis-273jar、commons-pool2-241jar

code如下：

[java] view plain copy

package cnmiguutils;

import javautilIterator;

import javautilList;

import cnmigubaseGlobalSettings;

import redisclientsjedisJedis;

import redisclientsjedisJedisPool;

import redisclientsjedisJedisPoolConfig;

<Description>redis相关 *** 作类

@author YanLu

public class RedisUtil {

private JedisPool pool=null;

private Jedis redis = null;

Log4jUtil log = new Log4jUtil(thisgetClass()getName());

//构造函数,创建对象时进行初始化

public RedisUtil() {

if (pool == null) {

// 池基本配置

//JedisPoolConfig config = new JedisPoolConfig();

// 最大连接数, 默认8个

configsetMaxTotal(20);

// 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。

configsetMaxIdle(5);

// 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；

configsetMaxWaitMillis(10000);

// 在borrow一个jedis实例时，是否提前进行validate *** 作；如果为true，则得到的jedis实例均是可用的；

configsetTestOnBorrow(false);

//创建redis连接池

//thispool = new JedisPool(config,"17218173188",6379);

thispool = new JedisPool(new JedisPoolConfig(), GlobalSettingsgetProperty("redismasterhost"), IntegerparseInt(GlobalSettingsgetProperty("redismasterport")));

//获取Jedis实例

thisredis = poolgetResource();

loginfo("Connection to redis server sucessfully");

}

关闭连接

@param pool

@param redis

public void quitConnection(Jedis redis) {

if (redis != null) {

redisquit();

//poolreturnResource(redis);

}

获取key对应的value

说明：方法中目前只针对key数据类型为String和hash的情况作了处理，其他数据类型可根据需要进行扩展即可

@param key

@return

public String getValue(String key){

String value = null;

try {

if(redis == null || !redisexists(key)){

loginfo("key:"+key+" is not found");

quitConnection(redis);

return value;

}

//获取key对应的数据类型

String type = redistype(key);

loginfo("key:" + key + " 的类型为：" + type);

if(typeequals("string")){

//get(key)方法返回key所关联的字符串值

value = redisget(key);

}

if(typeequals("hash")){

//一下方法仅适用于listsize=1时，否者value将取集合中最后一个元素的值

List<String> list = redishvals(key);//hvals(key)返回哈希表 key 中所有域的值

//Set<String> set = redishkeys(key);

Iterator<String> it=listiterator();

while(ithasNext()){

value = itnext();

loginfo("value:"+value);

}

if(typeequals("list")){

loginfo(key+"类型为list暂未处理");

}

if(typeequals("set")){

loginfo(key+"类型为list暂未处理");

}

} catch (Exception e) {

// TODO Auto-generated catch block

eprintStackTrace();

}finally{

//关闭连接

quitConnection(redis);

}

return value;

}

[java] view plain copy

</pre>测试代码如下：<pre name="code" class="java">package cnmigutest;

import orgtestngannotationsTest;

import cnmiguutilsLog4jUtil;

import cnmiguutilsRedisUtil;

<Description> 测试RedisUtil类

@author YanLu

public class TestRedis {

private Log4jUtil log = new Log4jUtil(thisgetClass()getName());

@Test

public void testRedisUtil(){

RedisUtil ru = new RedisUtil();

//获取redis中对应的value值

String value=rugetValue("SMS_NODE_TIMES_13814528620");

loginfo(value);

}

此外，我还讨论过较为常见的基于服务器的数据存储，比如MongoDB和CouchDB。每个数据存储都有其优势和劣势，特别是当应用于特定领域时。本期的Java开发20关注的是Redis，一种轻量级键值对数据存储。多数NoSQL实现本质上都是键值对，但是Redis支持非常丰富的值集，其中包括字符串、列表、集以及散列。因此，Redis通常被称为数据结构服务器。Redis也以异常快速而闻名，这使得它成为某一特定类型使用案例的最优选择。当我们想要了解一种新事物时，将其同熟知的事物进行比较可能会有所帮助，因此，我们将通过对比其与memcached的相似性以开启Redis探索之旅。接着我们将介绍Redis的主要功能，这些功能可以使其在某些应用场景可以胜过memcached。最后我将向您展示如何将Redis作为一个传统数据存储用于模型对象。Redis和memcachedMemcached是一个众所周知的内存对象缓存系统，通过将目标键和值导入内存缓存运行。因此，Memcached能回避读取磁盘时发生的I/O成本问题。在Web应用程序和数据库之间粘贴memcached时会产生更好的读取性能。因此，对于那些需要快速数据查询的应用程序，Memcached是一个不错的选择。其中的一个例子为股票查询服务，需要另外访问数据库获取相对静态数据，如股票名称或价格信息。MemcacheDB将Redis与memcached相比较并不公平，它与MemcacheDB相比要好的多，MemcacheDB是一个分布式键值对存储系统，专为数据持久化而设计。MemcacheDB与Redis较为相似，其新增优势可以使其轻松地与memcached实现的客户端进行通信。但是memcached也有其局限性，其中一个事实就是它所有的值均是简单的字符串。Redis作为memcached的替代者，支持更加丰富的功能集。一些基准(benchmarks)也表明Redis的速度要比memcached快很多。Redis提供的丰富数据类型使其可以在内存中存储更为复杂的数据，这是使用memcached无法实现的。同memcached不一样，Redis可以持久化其数据。Redis解决了一个重大的缓存问题，而其丰富的功能集又为其找到了其他用途。由于Redis能够在磁盘上存储数据以及跨节点复制数据，因而可以作为数据仓库用于传统数据模式（也就是说，您可以使用Redis，就像使用RDBMS一样）。Redis还经常被用作队列系统。在本用例中，Redis是备份和工作队列持久化存储（利用Redis的列表类型）的基础。GitHub是以此种方法使用Redis的大规模基础架构示例准备好Redis，立即开始!要开始使用Redis，您需要访问它，可以通过本地安装或者托管供应商来实现访问。如果您使用的MAC，安装过程可能就不那么简单。如果您使用的是Windows，您需要先安装Cygwin。如果您正在寻找一个托管供应商，Redis4You拥有一个免费计划。不管您以何种方式访问，您都能够根据本文下列示例进行 *** 作，但是我需要指出的是，使用一个托管供应商进行缓存可能并不是很好的缓存解决方案，因为网络延迟可能会抵消任何性能优势。您需要通过命令与Redis进行交互，这就是说，这里没有SQL类查询语言。使用Redis工作非常类似于使用传统map数据结构，即所有的一切都拥有一个键和一个值，每个值都有多种与之关联的数据类型。每个数据类型都有其自己的命令集。例如，如果您计划使用简单数据类型，比如某种缓存模式，您可以使用命令set和get。您可以通过命令行shell与一个Reids实例进行交互。还有多个客户端实现，可以以编程方式与Redis进行交互。清单1展示了一个使用基础命令的简单命令行shell交互：清单1使用基础的Redis命令redis127001:6379>setpageregistrationOKredis127001:6379>keys1)"foo"2)"page"redis127001:6379>getpage"registration"在这里，我通过set命令将键"page"与值"registration"相关联。接着，我发出keys命令（后缀表示我想看到所有可用的实例键。keys命令显示有一个page值和一个foo，我可以通过get命令检索到与一个键关联的值。请记住，使用get检索到的值只能是一个字符串。如果一个键的值是一个列表，那么您必须使用一个特定列表的命令来检索列表元素。（注意，有可以查询值类型的命令）。Java与Jedis集成对于那些想要将Redis集成到Java应用程序的编程人员，Redis团队建议使用一个名为Jedis的项目，Jedis是一个轻量级库，可以将本地Redis命令映射到Java方法。例如Jedis可以获取并设置简单值，如清单2所示：清单2Java代码中的基础Redis命令JedisPoolpool=newJedisPool(newJedisPoolConfig(),"localhost");Jedisjedis=poolgetResource();jedisset("foo","bar");Stringfoobar=jedisget("foo");assertfoobarequals("bar");poolreturnResource(jedis);pooldestroy();在清单2中，我配置了一个连接池并捕获连接，（与您在典型JDBC场景中的 *** 作非常相似）然后我在清单的底部设置了返回 *** 作。在连接池逻辑之间，我设置了值"bar"和键"foo"，这是我通过get命令检索到的。与memcached类似，Redis允许您将过期（expiration）时间关联到一个值。因此我设置了这样一个值（比如，股票临时交易价格），最终将从Redis缓存中清除掉。如果我想在Jedis中设置一个过期时间，需要在发出set调用之后将其和一个过期时间关联。如清单3所示：清单3Redis值可以设置为终止jedisset("gone","daddy,gone");jedisexpire("gone",10);Stringthere=jedisget("gone");assertthereequals("daddy,gone");Threadsleep(4500);StringnotThere=jedisget("gone");assertnotThere==null;在清单3中，我使用了一个expire调用将"gone"的值设置为在10秒钟内终止。调用Threadsleep之后，"gone"的get调用会返回null。Redis中的数据类型使用Redis数据类型，比如列表和散列需要专用命令用法。例如，我可以通过为键附加值来创建列表。

以上就是关于如何在spring配置文件中配置jedis连接池主从redis全部的内容，包括:如何在spring配置文件中配置jedis连接池主从redis、java代码中单表查询出的list集合怎么读写到redis中、java 监听redis map是否有修改等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！

欢迎分享，转载请注明来源：内存溢出

原文地址:https://54852.com/web/9620990.html

如何在spring配置文件中配置jedis连接池主从redis

发表评论

评论列表（0条）