redis java_Redis基本操作之Java实现(所有类型)

前不久分享过Redis的基本数据结构及基本命令详解。在熟悉了redis的基本操作之后(如果还有对redis的基本操作不熟悉的，可以点击前面的连接先熟悉下)，今天给大家分享下实际开发中对redis操作的Java实现版本。

Maven依赖

使用maven来构建项目在当下应该已经是主流了，所以我们也不例外使用了Maven。因为使用了spring对redis封装的jar，所以也需要引入spring基本jar，Maven依赖如下：

org.springframework

spring-core

5.1.5.RELEASE

org.springframework

spring-context

5.1.5.RELEASE

org.springframework.data

spring-data-redis

2.1.3.RELEASE

redis.clients

jedis

2.9.2

redis

实现代码

实现代码篇幅有点长，而且segmentfault代码div的高度有限制，建议大家把代码拷贝到开发工具中再阅读。

package spring.redis;

import org.springframework.beans.factory.InitializingBean;

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.data.redis.serializer.RedisSerializer;

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

import org.springframework.stereotype.Service;

import java.io.UnsupportedEncodingException;

import java.util.*;

import java.util.stream.Collectors;

@Service

public class SpringRedisHandler implements InitializingBean {

//redis编码

private static final String redisCode = "utf-8";

private static final String EmptyString = "";

@Autowired

private RedisTemplate jtRedis;

/**

* 设置key-value【不含超时时间】

*

* @param key

* @param value

*/

public void set(String key, Object value) {

this.set(key, String.valueOf(value), 0L);

}

/**

* 设置key-value【含超时时间】

*

* @param key

* @param value

* @param liveTime

*/

public void set(String key, Object value, long liveTime) {

this.set(key.getBytes(), String.valueOf(value).getBytes(), liveTime);

}

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

private void set(final byte[] key, final byte[] value, final long liveTime) {

jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

connection.set(key, value);

if (liveTime > 0) {

connection.expire(key, liveTime);

}

return 1L;

}

});

}

/**

* get key的值

*

* @param key

* @return

*/

public String get(final String key) {

return jtRedis.execute(new RedisCallback() {

@Override

public String doInRedis(RedisConnection connection) throws DataAccessException {

try {

return new String(connection.get(key.getBytes()), redisCode);

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

return "";

}

}

});

}

/**

* 是否存在key

*

* @param key

* @return

*/

public boolean exists(final String key) {

return jtRedis.execute(new RedisCallback() {

@Override

public Boolean doInRedis(RedisConnection connection) throws DataAccessException {

return connection.exists(key.getBytes());

}

});

}

/**

* 某数据中所有key的总数

*

* @return

*/

public long dbSize() {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

return connection.dbSize();

}

});

}

/**

* 检测redis服务器是否能平通

*/

public String ping() {

return jtRedis.execute(new RedisCallback() {

@Override

public String doInRedis(RedisConnection connection) throws DataAccessException {

return connection.ping();

}

});

}

/**

* value增加某个值

*

* @param key

* @param value

* @return

*/

public Long incr(String key, long value) {

return incr(key.getBytes(), value);

}

private Long incr(byte[] key, long value) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

return connection.incrBy(key, value);

}

});

}

/**

* 自增

*

* @param key

* @return

*/

public Long incr(String key) {

return incr(key.getBytes(), 1);

}

/**

* 自减

*

* @param key

* @return

*/

public Long decr(String key) {

return decr(key.getBytes(), 1);

}

/**

* value减少某个值

*

* @param key

* @param value

* @return

*/

public Long decr(String key, long value) {

return decr(key.getBytes(), value);

}

private Long decr(byte[] key, long value) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

return connection.decrBy(key, value);

}

});

}

/**

* 删除key

*

* @param key

* @return

*/

public Long del(String key) {

return del(key.getBytes());

}

private Long del(byte[] key) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

return connection.del(key);

}

});

}

/**

* flushdb：删除db下的所有数据

*/

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

public void flushDb() {

jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

connection.flushDb();

return 1L;

}

});

}

/**

* 设置hash

*

* @param key

* @param field

* @param value

* @return

*/

public Boolean hSet(String key, String field, String value) {

return jtRedis.execute(new RedisCallback() {

@Override

public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {

return redisConnection.hSet(key.getBytes(), field.getBytes(), value.getBytes());

}

});

}

/**

* 获取hash的属性值

*

* @param key

* @param field

* @return

*/

public String hGet(String key, String field) {

return jtRedis.execute(new RedisCallback() {

@Override

public String doInRedis(RedisConnection redisConnection) throws DataAccessException {

return new String(redisConnection.hGet(key.getBytes(), field.getBytes()));

}

});

}

/**

* 批量设置hash

*

* @param key

* @param values

*/

public void hMSet(String key, Map values) {

jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {

redisConnection.hMSet(key.getBytes(), stringObjectMapToBytes(values));

return null;

}

});

}

/**

* 批量获取hash的多个属性

*

* @param key

* @param fields

* @return

*/

public List hMGet(String key, String... fields) {

return jtRedis.execute(new RedisCallback>() {

@Override

public List doInRedis(RedisConnection redisConnection) throws DataAccessException {

List listFileds = new ArrayList<>();

for (int i = 0; i < fields.length; i++) {

listFileds.add(fields[i]);

}

List byteFileds = stringListToByte(listFileds);

return bytesListToString(redisConnection.hMGet(key.getBytes(), byteFileds.toArray(new byte[byteFileds.size()][byteFileds.size()])));

}

});

}

/**

* 获取hash的所有属性

*

* @param key

* @return

*/

public Map hGetAll(String key) {

return jtRedis.execute(new RedisCallback>() {

@Override

public Map doInRedis(RedisConnection redisConnection) throws DataAccessException {

return bytesMapToString(redisConnection.hGetAll(key.getBytes()));

}

});

}

/**

* 针对hash中某个属性增加指定的值

*

* @param key

* @param field

* @param value

* @return

*/

public Double hIncrBy(String key, String field, double value) {

return jtRedis.execute(new RedisCallback() {

@Override

public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {

return redisConnection.hIncrBy(key.getBytes(), field.getBytes(), value);

}

});

}

/**

* hash是存在某属性

*

* @param key

* @param field

* @return

*/

public Boolean hExists(String key, String field) {

return jtRedis.execute(new RedisCallback() {

@Override

public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {

return redisConnection.hExists(key.getBytes(), field.getBytes());

}

});

}

/**

* 删除hash的某属性

*

* @param key

* @param field

* @return

*/

public Long hDel(String key, String field) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {

return redisConnection.hDel(key.getBytes(), field.getBytes());

}

});

}

/**

* 向zset中的某个key添加一个属性几分数(可以根据分数排序)

*

* @param key

* @param score

* @param field

* @return

*/

public Boolean zAdd(String key, double score, String field) {

return jtRedis.execute(new RedisCallback() {

@Override

public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {

return redisConnection.zAdd(key.getBytes(), score, field.getBytes());

}

});

}

/**

* 给zset中的某个key中的某个属性增加指定分数

*

* @param key

* @param score

* @param field

* @return

*/

public Double zIncrBy(String key, double score, String field) {

return jtRedis.execute(new RedisCallback() {

@Override

public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {

return redisConnection.zIncrBy(key.getBytes(), score, field.getBytes());

}

});

}

/**

* 从list左侧插入一个元素

*

* @param key

* @param values

* @return

*/

public Long lPush(String key, String value) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

return connection.lPush(key.getBytes(), value.getBytes());

}

});

}

/**

* 从list左侧插入多个元素

*

* @param key

* @param values

* @return

*/

public Long lPush(String key, List values) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

List bytes = stringListToByte(values);

return connection.lPush(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));

}

});

}

/**

* 从list的左侧取出一个元素

*

* @param key

* @return

*/

public String lPop(String key) {

return jtRedis.execute(new RedisCallback() {

@Override

public String doInRedis(RedisConnection connection) throws DataAccessException {

if (connection.lLen(key.getBytes()) > 0) {

return new String(connection.lPop(key.getBytes()));

} else {

return EmptyString;

}

}

});

}

/**

* 向list的右侧插入一个元素

*

* @param key

* @param value

* @return

*/

public Long rPush(String key, String value) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

return connection.rPush(key.getBytes(), value.getBytes());

}

});

}

/**

* list的rpush，从右侧插入多个元素

*

* @param key

* @param values

* @return

*/

public Long rPush(String key, List values) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

List bytes = stringListToByte(values);

return connection.rPush(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));

}

});

}

/**

* 从list的右侧取出一个元素

*

* @param key

* @return

*/

public String rPop(String key) {

return jtRedis.execute(new RedisCallback() {

@Override

public String doInRedis(RedisConnection connection) throws DataAccessException {

if (connection.lLen(key.getBytes()) > 0) {

return new String(connection.rPop(key.getBytes()));

} else {

return EmptyString;

}

}

});

}

/**

* 给set中添加元素

*

* @param key

* @param values

* @return

*/

public Long sadd(String key, List values) {

return jtRedis.execute(new RedisCallback() {

@Override

public Long doInRedis(RedisConnection connection) throws DataAccessException {

List bytes = stringListToByte(values);

return connection.sAdd(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));

}

});

}

/**

* 获取set中的所有元素

*

* @param key

* @return

*/

public List smembers(String key) {

return jtRedis.execute(new RedisCallback>() {

@Override

public List doInRedis(RedisConnection connection) throws DataAccessException {

return bytesListToString(connection.sMembers(key.getBytes()));

}

});

}

/**

* set中是否包含某元素

*

* @param key

* @param value

* @return

*/

public Boolean sIsMember(String key, String value) {

return jtRedis.execute(new RedisCallback() {

@Override

public Boolean doInRedis(RedisConnection connection) throws DataAccessException {

return connection.sIsMember(key.getBytes(), value.getBytes());

}

});

}

private byte[][] change(List values) {

byte[][] result = {};

return result;

}

private List stringListToByte(List values) {

return values

.stream()

.map(p -> p.getBytes())

.collect(

Collectors.toList()

);

}

private List bytesListToString(Collection values) {

return values

.stream()

.map(p -> new String(p))

.collect(

Collectors.toList()

);

}

private Map bytesMapToString(Map values) {

Map result = new HashMap<>();

values.forEach((k, v) -> result.put(new String(k), new String(v)));

return result;

}

private Map stringObjectMapToBytes(Map values) {

Map result = new HashMap<>();

values.forEach((k, v) -> result.put(k.getBytes(), String.valueOf(v).getBytes()));

return result;

}

/**

* 正则表达式获取值

*

* @param pattern

* @return

*/

public Set keys(String pattern) {

return jtRedis.keys(pattern);

}

@Override

public void afterPropertiesSet() throws Exception {

RedisSerializer stringSerializer = new StringRedisSerializer();

jtRedis.setKeySerializer(stringSerializer);

jtRedis.setValueSerializer(stringSerializer);

jtRedis.setHashKeySerializer(stringSerializer);

jtRedis.setHashValueSerializer(stringSerializer);

}

}

配置文件

配置文件主要有两个，一个是spirng相关配置的配置文件applicationContext-redis.xml，还有一个是redis相关配置文件redis-config.properties

applicationContext-redis.xml配置文件内容如下：

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

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

xsi:schemaLocation="http://www.springframework.org/schema/beans

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

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-4.0.xsd">

redis-config.properties配置文件内容如下：

#装有redis数据库的虚拟机中的一台机器的ip

redis.host=127.0.0.1

redis.port=6379

redis.pass=

#默认存储在databse[0]数据库, redis的database相当于一个数据,默认也是0

redis.database=0

#maxIdle:最大空闲数

redis.maxIdle=300

#maxWait:最大等待时长,3秒

redis.maxWait=3000

#testOnBorrow：在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的；

redis.testOnBorrow=true

结语

虽然代码篇幅有点长，但是都是基于spring封装之后的再次封装，大家应该都能理解。并且以上方法我都有测试过，亲测可用，因为测试代码也比较的简单，因此就不贴出来了。最后，欢迎大家补充、批评、指正。