redis_代码实现

偏执的太偏执、 2022-05-25 08:55 66阅读 0赞

1．创建工程

创建一个maven项目mavenRedis，pom.xml中添加redis配置：

<groupId>redis.clients</groupId>

<artifactId>jedis</artifactId>

</dependency>

如果是一个spring的web工程，还需要添加：

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

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

<version>1.6.4.RELEASE</version>

</dependency>

2．基本操作

**package** mavenRedis;

**import** org.junit.Test;

**import** redis.clients.jedis.Jedis;

**public** **class** TestRedis \{

@Test

**public** **void** testRedis()\{

//创建一个Redis 客户端

Jedis jedis = **new** Jedis("192.168.75.105", 6380);

jedis.auth("123456");

//插入数据

// 第三个参数不写为强行产生此key和value，为XX表示key存在才修改、为NX表示不存在时才插入

jedis.set("key1", "HelloWorld");

// 保存5秒

jedis.expire("key1", 5);

String value = jedis.get("key1");

System.***out***.println(value);

//关闭

jedis.disconnect();\}

其他操作和命令雷同。

3．线程池

**package** mavenRedis;

**import** redis.clients.jedis.Jedis;

**import** redis.clients.jedis.JedisPool;

**import** redis.clients.jedis.JedisPoolConfig;

**public** **class** RedisUtils \{

**private** **static** JedisPool *jedisPool* = **null**;

**static** \{

**try** \{

JedisPoolConfig config = **new** JedisPoolConfig();

// 最大连接数，低版本使用的是setMaxActive，默认为8，-1为不限制

config.setMaxTotal(1024);

// 允许的最大空闲连接数，默认为8

config.setMaxIdle(200);

// 等待连接的最大时间，低版本使用的是setMaxWait,单位毫秒，默认-1表示永不超时

config.setMaxWaitMillis(10000);

// true表示获取到的jedis实例提前进行了validate操作，确保获取到的实例是可用的

config.setTestWhileIdle(**true**);

// 表示从连接池中获取连接前是否运行validationQuery，true=运行\[默认\]，false=不运行

config.setTestOnBorrow(**true**);

// 表示将连接归还连接池前是否运行validationQuery，true=运行，false=不运行\[默认\]；

config.setTestOnReturn(**false**);

// 连接保持空闲而不被驱逐的最长时间5分钟

config.setMinEvictableIdleTimeMillis(300000);

// 在每次空闲连接回收器线程(如果有)运行时检查的连接数量

config.setNumTestsPerEvictionRun(3);

// 每60秒运行一次空闲连接回收器

config.setTimeBetweenEvictionRunsMillis(60000);

String ip = "192.168.75.105";

**int** port = 6380;

// 读取超时时间

**int** readTimeOut = 3000;

// 密码

String auth = "123456";

// 数据库，默认为0

**int** database = 2;

*jedisPool* = **new** JedisPool(config, ip, port, readTimeOut, auth, database);

\} **catch** (Exception e)\{

e.printStackTrace();

**public** **synchronized** **static** Jedis getJedis()\{

**try** \{

**if** (*jedisPool* != **null**)\{

**return** *jedisPool*.getResource();

\} **catch** (Exception e)\{

e.printStackTrace();

**return** **null**;

**public** **static** **void** returnResource(**final** Jedis jedis)\{

**if** (jedis != **null**)\{

*jedisPool*.returnResource(jedis);

使用：

**public** **class** TestRedis \{

@Test

**public** **void** testRedisPool()\{

Jedis jedis = RedisUtils.*getJedis*();

jedis.set("key2", "HelloWorld2");

String value = jedis.get("key2");

RedisUtils.*returnResource*(jedis);

System.***out***.println(value);

将参数放到配置文件中，有三种方法，详见《javaSe》相关章节，方法一直接读文件，但使用不简洁，方法二依赖spring及使用的类需要用注解扫描，方法三依赖spring。为了实用性强，本例使用方法三。

配置文件redis.properties内容：

redis.host=192.168.75.105

redis.port=6380

redis.password=123456

redis.database=2

redis.timeout=5000

redis.userPool=false

redis.pool.maxIdle=200

redis.pool.minIdle=0

redis.pool.maxTotal=1024

redis.pool.maxWaitMillis=3000

redis.pool.minEvictableIdleTimeMillis=300000

redis.pool.numTestsPerEvictionRun=3

redis.pool.timeBetweenEvictionRunsMillis=60000

redis.pool.testOnBorrow=true

redis.pool.testOnReturn=true

redis.pool.testWhileIdle=true

Spring中添加配置：

<bean class=*"com.harvetech.utils.PropertyConfigurerUtils"*>

<property name=*"locations"*>

<list>

<value>classpath:redis.properties</value>

</list>

</property>

</bean>

PropertyConfigurerUtils 类如下：

**package** com.harvetech.utils;

**import** java.util.HashMap;

**public** **class** PropertyConfigurerUtils **extends** PropertyPlaceholderConfigurer \{

**private** **static** Map<String, String> *propertiesMap* = **new** HashMap<String, String>();

@Override

**protected** **void** processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props) **throws** BeansException \{

**super**.processProperties(beanFactoryToProcess, props);

**for** (Object key : props.keySet()) \{

String keyStr = key.toString();

String value = props.getProperty(keyStr);

System.***out***.println(key\+" : " +value);

*propertiesMap*.put(keyStr, value);

**public** **static** String getProperty(String name) \{

**return** *propertiesMap*.get(name);

RedisUtils类改造：

**package** mavenRedis;

**import** redis.clients.jedis.Jedis;

**import** redis.clients.jedis.JedisPool;

**import** redis.clients.jedis.JedisPoolConfig;

**public** **class** RedisUtils \{

**private** **static** JedisPool *jedisPool* = **null**;

// 读取超时时间

**static** **int** *readTimeOut* = Integer.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.timeout"));

**static** String *ip* = PropertyConfigurerUtils.*getProperty*("redis.host");

**static** **int** *port* = Integer.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.port"));

**static** String *auth* = PropertyConfigurerUtils.*getProperty*("redis.password");

**static** **int** *database* = Integer.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.database"));

**static** **int** *maxTotal* = Integer.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.pool.maxTotal"));

**static** **int** *maxIdle* = Integer.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.pool.maxIdle"));

**static** **int** *minIdle* = Integer.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.pool.minIdle"));

**static** **long** *maxWaitMillis* = Long.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.pool.maxWaitMillis"));

**static** **boolean** *testOnBorrow* = "true".equals(PropertyConfigurerUtils.*getProperty*("redis.pool.testOnBorrow"));

**static** **boolean** *testOnReturn* = "true".equals(PropertyConfigurerUtils.*getProperty*("redis.pool.testOnReturn"));

**static** **boolean** *testWhileIdle* = "true".equals(PropertyConfigurerUtils.*getProperty*("redis.pool.testWhileIdle"));

**static** **long** *minEvictableIdleTimeMillis* = Long.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.pool.minEvictableIdleTimeMillis"));

**static** **int** *numTestsPerEvictionRun* = Integer.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.pool.numTestsPerEvictionRun"));

**static** **long** *timeBetweenEvictionRunsMillis* = Long.*valueOf*(PropertyConfigurerUtils.*getProperty*("redis.pool.timeBetweenEvictionRunsMillis"));

**static** \{

**try** \{

JedisPoolConfig config = **new** JedisPoolConfig();

// 最大连接数，低版本使用的是setMaxActive，默认为8，-1为不限制

config.setMaxTotal(*maxTotal*);

// 允许的最大空闲连接数，默认为8

config.setMaxIdle(*maxIdle*);

// 允许的最小空闲连接数

config.setMinIdle(*minIdle*);

// 等待连接的最大时间，低版本使用的是setMaxWait,单位毫秒，默认-1表示永不超时

config.setMaxWaitMillis(*maxWaitMillis*);

// true表示获取到的jedis实例提前进行了validate操作，确保获取到的实例是可用的

config.setTestWhileIdle(*testWhileIdle*);

// 表示从连接池中获取连接前是否运行validationQuery，true=运行\[默认\]，false=不运行

config.setTestOnBorrow(*testOnBorrow*);

// 表示将连接归还连接池前是否运行validationQuery，true=运行，false=不运行\[默认\]；

config.setTestOnReturn(*testOnReturn*);

// 连接保持空闲而不被驱逐的最长时间5分钟

config.setMinEvictableIdleTimeMillis(*minEvictableIdleTimeMillis*);

// 在每次空闲连接回收器线程(如果有)运行时检查的连接数量

config.setNumTestsPerEvictionRun(*numTestsPerEvictionRun*);

// 每60秒运行一次空闲连接回收器

config.setTimeBetweenEvictionRunsMillis(*timeBetweenEvictionRunsMillis*);

*jedisPool* = **new** JedisPool(config, *ip*, *port*, *readTimeOut*, *auth*, *database*);

\} **catch** (Exception e)\{

e.printStackTrace();

**public** **synchronized** **static** Jedis getJedis()\{

**try** \{

**if** (*jedisPool* != **null**)\{

**return** *jedisPool*.getResource();

\} **catch** (Exception e)\{

e.printStackTrace();

**return** **null**;

**public** **static** **void** returnResource(**final** Jedis jedis)\{

**if** (jedis != **null**)\{

*jedisPool*.returnResource(jedis);

使用redis的地方：

**private** Jedis jedis = RedisUtils.*getJedis*();

jedis.set("key2", "44");

4．集成spring

配置文件和上面一样，spring中添加配置项：

<bean id=*"propConf"*  class=*"org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"*>

<property name=*"nullValue"* value=*"@null"* />

<property name=*"systemPropertiesModeName"* value=*"SYSTEM\_PROPERTIES\_MODE\_OVERRIDE"* />

<property name=*"ignoreResourceNotFound"* value=*"true"* />

<property name=*"ignoreUnresolvablePlaceholders"* value=*"true"* />

<property name=*"fileEncoding"* value=*"UTF-8"* />

<property name=*"locations"*>

<list>

<value>classpath:redis.properties</value>

</list>

</property>

</bean>

<import resource=*"classpath:redis.xml"*/>

Redis.xml内容如下：

<?xml version=*"1.0"* encoding=*"UTF-8"*?>

<beans xmlns=*"http://www.springframework.org/schema/beans"*

xmlns:xsi=*"http://www.w3.org/2001/XMLSchema-instance"* xmlns:p=*"http://www.springframework.org/schema/p"*

xmlns:context=*"http://www.springframework.org/schema/context"*

xsi:schemaLocation=*"  *

*            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  *

*            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"*

default-lazy-init=*"true"*>

<bean id=*"jedisPoolConfig"* class=*"redis.clients.jedis.JedisPoolConfig"*>

<property name=*"maxIdle"* value=*"$\{redis.pool.maxIdle\}"* />

<property name=*"minIdle"* value=*"$\{redis.pool.minIdle\}"* />

<property name=*"maxTotal"* value=*"$\{redis.pool.maxTotal\}"* />

<property name=*"maxWaitMillis"* value=*"$\{redis.pool.maxWaitMillis\}"* />

<property name=*"minEvictableIdleTimeMillis"* value=*"$\{redis.pool.minEvictableIdleTimeMillis\}"*></property>

<property name=*"numTestsPerEvictionRun"* value=*"$\{redis.pool.numTestsPerEvictionRun\}"*></property>

<property name=*"timeBetweenEvictionRunsMillis"* value=*"$\{redis.pool.timeBetweenEvictionRunsMillis\}"*></property>

<property name=*"testOnBorrow"* value=*"$\{redis.pool.testOnBorrow\}"* />

<property name=*"testOnReturn"* value=*"$\{redis.pool.testOnReturn\}"* />

<property name=*"testWhileIdle"* value=*"$\{redis.pool.testWhileIdle\}"*></property>

</bean>

<bean id=*"jedisConnectionFactory"*

class=*"org.springframework.data.redis.connection.jedis.JedisConnectionFactory"*>

<property name=*"hostName"* value=*"$\{redis.host\}"* />

<property name=*"port"* value=*"$\{redis.port\}"* />

<property name=*"password"* value=*"$\{redis.password\}"* />

<property name=*"database"* value=*"$\{redis.database\}"* />

<property name=*"poolConfig"* ref=*"jedisPoolConfig"* />

</bean>

<bean class=*"org.springframework.data.redis.core.RedisTemplate"*

p:connection-factory-ref=*"jedisConnectionFactory"* />

</beans>

定义redis工具类RedisTool：

package com.harvetech.utils;

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

import org.springframework.dao.DataAccessException;

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

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

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

import org.springframework.stereotype.Component;

/\*\*

\* 功能：redis工具类

\* 创建时间：2017年9月6日

\*/

@Component

**public** **class** RedisTool \{

@Autowired

**private** RedisTemplate redisTemplate;

**private** Integer database;

**public** Integer getDatabase() \{

**return** database;

**public** **void** setDatabase(Integer database) \{

**this**.database = database;

@SuppressWarnings(\{ "unchecked", "rawtypes"\})

**public** **void** set(**final** String key, **final** String value) \{

redisTemplate.execute(**new** RedisCallback() \{

**public** Long doInRedis(RedisConnection connection) **throws** DataAccessException \{

**if** (database != **null**)\{

connection.select(database);

connection.set(key.getBytes(), value.getBytes());

**return** 1L;

\});

/\*\*

\* **@param** liveTime 存活时间/秒

\*/

@SuppressWarnings(\{ "unchecked", "rawtypes"\})

**public** **void** set(**final** String key, **final** String value, **final** **long** liveTime) \{

redisTemplate.execute(**new** RedisCallback() \{

**public** Long doInRedis(RedisConnection connection) **throws** DataAccessException \{

**if** (database != **null**)\{

connection.select(database);

connection.setEx(key.getBytes(), liveTime, value.getBytes());

**return** 1L;

\});

@SuppressWarnings(\{ "unchecked", "rawtypes"\})

**public** **void** set(**final** String key, **final** Integer value) \{

redisTemplate.execute(**new** RedisCallback() \{

**public** Long doInRedis(RedisConnection connection) **throws** DataAccessException \{

**if** (database != **null**)\{

connection.select(database);

connection.set(key.getBytes(), *intToBytes*(value));

**return** 1L;

\});

@SuppressWarnings(\{ "unchecked", "rawtypes"\})

**public** String get(**final** String key) \{

**return** (String) redisTemplate.execute(**new** RedisCallback() \{

**public** Object doInRedis(RedisConnection connection) **throws** DataAccessException \{

**try** \{

**if** (database != **null**)\{

connection.select(database);

**return** **new** String(connection.get(key.getBytes()));

\} **catch** (Exception e) \{

**return** **null**;

\});

/\*\*

\* 描述: 自增  key不存在则为1

\*/

@SuppressWarnings(\{ "unchecked", "rawtypes"\})

**public** Long incrby(**final** String key) \{

**return** (Long)redisTemplate.execute(**new** RedisCallback() \{

**public** Long doInRedis(RedisConnection connection) **throws** DataAccessException \{

**if** (database != **null**)\{

connection.select(database);

Long incr = connection.incr(key.getBytes());

**return** incr;

\});

@SuppressWarnings(\{ "unchecked", "rawtypes"\})

**public** Long decrby(**final** String key) \{

**return** (Long)redisTemplate.execute(**new** RedisCallback() \{

**public** Long doInRedis(RedisConnection connection) **throws** DataAccessException \{

**if** (database != **null**)\{

connection.select(database);

Long incr = connection.decr(key.getBytes());

**return** incr;

\});

@SuppressWarnings(\{ "unchecked", "rawtypes"\})

**public** Long del(**final** String key)\{

**return** (Long)redisTemplate.execute(**new** RedisCallback<Object>()\{

**public** Long doInRedis(RedisConnection connection) **throws** DataAccessException \{

**if** (database != **null**)\{

connection.select(database);

**return** connection.del(key.getBytes());

\});

**public** **static** **byte**\[\] intToBytes( **int** value )

**byte**\[\] src = **new** **byte**\[4\];

src\[3\] =  (**byte**) ((value>>24) & 0xFF);

src\[2\] =  (**byte**) ((value>>16) & 0xFF);

src\[1\] =  (**byte**) ((value>>8) & 0xFF);

src\[0\] =  (**byte**) (value & 0xFF);

**return** src;

使用的地方：

@Resource

**private** RedisTool redisTool;

redisTool.set("key1","23");

redis_代码实现

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Redis实现消息队列-代码实现2

相关 Java代码实现redis分布式锁

相关 redis常用命令 & java中代码实现

相关 redis分布式锁详解、代码实现以及优化

相关分布式redis锁代码实现

相关基于redis分布式锁_代码实现

相关 redis作为消息队列实现代码

相关 springboot - 集成redis完整代码实现

相关 redis_代码实现

相关 java代码通过redis实现分布式锁