`

Redis（使用Jedis）初步使用

redisjedis 
阅读更多

关于redis，网上有太多的介绍，也有使用，但是找了很多，基本都是用的spring-data-redis，而不是jedis。二者的比较可以在网上查看，个人还是先琢磨着用了jedis的实现。
提到redis，肯定会想到memcached，那就简单的介绍一下memcached。

memcached：内存对象缓存系统，能回避读取磁盘时发生的I/O消耗成本，在web应用程序和数据库之间复制粘贴memcached时会产生较好的读取性能。 常用于需要快速查询的应用程序。memcached所有的值均是字符串，而redis支持丰富的功能集，同时redis可以持久化数据。

Redis： redis远程字典服务器，开源，高级的NOSQL键值数据存储。 redis是一种内存型数据存储，也可以将它写入磁盘中实现耐久性。

redis使用两种方式来持久存储数据：RDB 和AOF 。
RDB持久性： 按照指定的间隔对数据集执行时间点快照，不是非常持久，而且可能会丢失一些数据，但是速度非常快。
AOF持久性要长得多，而且记录了服务器收到的每个写入操作，写入操作在服务器启动时重新执行，重新构建原始数据集，查询redis时，将从内存中获取数据，绝不从磁盘获取数据。

Redis支持的数据类型： 字符串，列表，集合，有序集，哈希值，速度快，操作原子性。 所以多个客户端会并发访问一个redis服务器，获取相同的更新值。

Redis多效用，1，缓存 2消息队列（redis支持发布，订阅） 3 短期应用程序数据（web回话，web页面命中计数）。

接下来记录我自己根据在网上研究的实现的一个小demo。
redis的安装网上有很多，可以自行研究安装。

环境： maven+ mybaitis+springmvc
首先jar的引用：pom.xml中

<!-- 与redis集成 -->

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.6.0</version>
</dependency>

然后配置文件：redis.properties
#redis相关配置
#最大连接数，设定为8
redis.maxTotal=8
#最大空闲连接数，设定为5
redis.maxIdle=5
#最小空闲连接数，即为初始化连接数，设定为1
redis.minIdle=1
#最大等待时间单位为毫秒，设定为10秒
redis.maxWaitMillis=10000
# 对获取到的connection进行validateObject检验
redis.testOnBorrow=true
#redis域名或ip配置
redis.hostName=localhost
#redis开设的端口号
redis.port=6379


配置文件：spring-config-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:c="http://www.springframework.org/schema/c"
xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
  http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
 
 
 
<!-- basic jedis pool configuration -->
    <bean id="JedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
         <!-- 最大连接数限制，系统默认为8 -->
        <property name="maxTotal" value="${redis.maxTotal}" />
    <!-- 最大空闲连接数限制，系统默认为8 -->
        <property name="maxIdle" value="${redis.maxIdle}" />
    <!-- 最小空闲连接数限制，系统默认为0 -->
    <property name="minIdle" value="${redis.minIdle}" />
    <!-- 最大等待时间单位为毫秒，设定为10秒 -->
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
    <!-- 对获取到的connection进行validateObject检验-->
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
       
      
<property name="timeBetweenEvictionRunsMillis" value="-1" />
    </bean>
   
   <!-- 这边设置各个业务的redis域名/ip以及对应的端口号 -->
    <!-- 期望将各个业务应用用到的redis隔离开，目前通过端口号隔离 -->
    <bean id="JedisPool" class="redis.clients.jedis.JedisPool"> 
         <constructor-arg index="0" ref="JedisPoolConfig" />
        <constructor-arg index="1" value="${redis.hostName}" />
        <constructor-arg index="2" value="${redis.port}" /> 
    </bean> 
   
    <!-- JedisPool manager -->
    <bean id="JedisTemplate" class="com.demo.modules.cache.jedis.JedisTemplate" >
     <constructor-arg index="0" name="jedisPool" ref="JedisPool" />
    </bean>


</beans>


JedisTemplate是另外实现的一个类。
public class JedisTemplate {
private Logger logger = LoggerFactory.getLogger(JedisTemplate.class);
@Autowired
private JedisPool jedisPool;

public JedisTemplate(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}

// 设置key并且设定一个默认失效时间
// 设置失效时间，此处单位秒seconds
public void set(String key, String value, int expiredseconds) {
if (key != null && value != null && expiredseconds > 0) {
JedisPool jedisPool = null;
Jedis jedis = null;
try {
// 获取jedis pool对象
jedisPool = getJedisPool();
if (jedisPool != null) {
// 从jedis pool连接池里边获取一个jedis连接对象
jedis = jedisPool.getResource();
jedis.setex(key, expiredseconds, value);
logger.info("jedisTemplate>>>set key={},value={},expired={} succeed", new Object[] { key, value, expiredseconds });
}
} catch (Exception e) {
if (jedisPool != null) {
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>set key={},value={},expired={} failed e={}", new Object[] { key, value, expiredseconds, e.getCause() });
} finally {
// 处理完毕后，一定将jedis连接对象释放回到连接池中
if (jedisPool != null) {
jedisPool.returnResource(jedis);
}
}
}
}

// 设置key-value不设置失效时间
public void set(String key, String value) {
if (key != null && value != null) {
JedisPool jedisPool = null;
Jedis jedis = null;
try {
jedisPool = getJedisPool();
if (jedisPool != null) {
jedis = jedisPool.getResource();
jedis.set(key, value);
logger.info("jedisTemplate>>>set key={},value={} succeed", new Object[] { key, value });
}
} catch (Exception e) {
if (jedisPool != null) {
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>set key={},value={} failed e={}", new Object[] { key, value, e.getCause() });
} finally {
if (jedisPool != null) {
jedisPool.returnResource(jedis);
}
}
}
}

// 根据key查询value
public String get(String key) {
String value = "";
if (null != key && !"".equals(key)) {
JedisPool jedisPool = null;
Jedis jedis = null;
try {
jedisPool = getJedisPool();
if (jedisPool != null) {
jedis = jedisPool.getResource();
String tmp = jedis.get(key);
value = tmp != null ? tmp : value;
logger.info("jedisTemplate>>>get key={},value={} succeed", new Object[] { key, value });
}
} catch (Exception e) {
if (jedisPool != null) {
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>get key={},value={} failed e={}", new Object[] { key, value, e.getCause() });
} finally {
if (jedisPool != null) {
jedisPool.returnResource(jedis);
}
}
}
return value;
}

// 设置hset,key-fieldKey-value值
public void hset(String key, String fieldKey, String value) {
if (key != null && value != null && fieldKey != null) {
JedisPool jedisPool = null;
Jedis jedis = null;
try {
jedisPool = getJedisPool();
if (jedisPool != null) {
jedis = jedisPool.getResource();
jedis.hset(key, fieldKey, value);
logger.info("jedisTemplate>>>hset key={},fieldKey={},value={} succeed", new Object[] { key, fieldKey, value });
}
} catch (Exception e) {
if (jedisPool != null) {
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>hset key={},fieldKey={},value={} failed e={}", new Object[] { key, fieldKey, value, e.getCause() });
} finally {
if (jedisPool != null) {
jedisPool.returnResource(jedis);
}
}
}
}

// 获取hgetall key对应的值，放在map<fieldKey,value>中返回
public Map<String, String> hgetAll(String key) {
Map<String, String> map = new HashMap<String, String>();
if (key != null) {
JedisPool jedisPool = null;
Jedis jedis = null;
try {
jedisPool = getJedisPool();
if (jedisPool != null) {
jedis = jedisPool.getResource();
Map<String, String> tmpmap = jedis.hgetAll(key);
map = tmpmap != null ? tmpmap : map;
logger.info("jedisTemplate>>>hgetall key={},value={} succeed", new Object[] { key, tmpmap });
}
} catch (Exception e) {
if (jedisPool != null) {
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>hget key={},value={},failed e={}", new Object[] { key, map, e.getCause() });
} finally {
if (jedisPool != null) {
jedisPool.returnResource(jedis);
}
}
}
return map;
}

/**
* <pre>
* 查询匹配keys全部key键值列表
*
* redis里边的keys* 命令
*/
public Set<String> keys(String keysPattern) {
Set<String> set = new HashSet<String>();
if (keysPattern != null && !"".equals(keysPattern)) {
JedisPool jedisPool = null;
Jedis jedis = null;
try {
jedisPool = getJedisPool();
if (jedisPool != null) {
jedis = jedisPool.getResource();
Set<String> tmp = jedis.keys(keysPattern);
set = tmp != null ? tmp : set;
logger.info("jedisTemplate>>>keys keyPattern={}, set.size={}", new Object[] { keysPattern, set.size() });
}
} catch (Exception e) {
if (jedisPool != null) {
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>keys keyPattern={}, failed e={}", new Object[] { keysPattern, e.getCause() });
} finally {
if (jedisPool != null) {
jedisPool.returnResource(jedis);
}
}
}
return set;
}

// 从hset中hget出对应的key-field对应的value值
public String hget(String key, String fieldKey) {
String value = "";
if (key != null && fieldKey != null) {
JedisPool jedisPool = null;
Jedis jedis = null;
try {
jedisPool = getJedisPool();
if (jedisPool != null) {
jedis = jedisPool.getResource();
String tmp = jedis.hget(key, fieldKey);
value = tmp != null ? tmp : value;
logger.info("jedisTemplate>>>hget key={},fieldKey={},value={} succeed", new Object[] { key, fieldKey, value });
}
} catch (Exception e) {
if (jedisPool != null) {
jedisPool.returnBrokenResource(jedis);
}
logger.error("jedisTemplate>>>hget key={},fieldKey={},value={} failed e={}", new Object[] { key, fieldKey, value, e.getCause() });
} finally {
if (jedisPool != null) {
jedisPool.returnResource(jedis);
}
}
}
return value;
}

public JedisPool getJedisPool() {
return jedisPool;
}

public void setJedisPool(JedisPool jedisPool) {
this.jedisPool = jedisPool;
}

}


接下来在service中使用
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserRepository userRepository;
@Autowired
private JedisTemplate jedisTemplate;

public User getUserByName(String name) {
User u = (User) SerializeUtil.deserialization(jedisTemplate.get("user"));

User user = null;
if (null == u) {

user = userRepository.getUserByUserName(name);
jedisTemplate.set("user", SerializeUtil.serialization(user), 1 * 60 * 60);
} else {
user = u;
}
return user;
}
}

SerializeUtil 是一个序列化的工具类：
public class SerializeUtil {
public static String serialization(Object obj) {
String result = StringUtils.EMPTY;
ObjectOutputStream oos = null;
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
result = bos.toString("ISO-8859-1");
result = URLEncoder.encode(result, "UTF-8");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (oos != null) {
oos.close();
oos = null;
}
} catch (Exception e) {
}
return result;
}

}

public static Object deserialization(String serial) {
if (StringUtils.isBlank(serial)) {
return null;
}
ObjectInputStream ois = null;
Object result = null;
try {
String str = URLDecoder.decode(serial, "UTF-8");
ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes("ISO-8859-1"));
ois = new ObjectInputStream(bis);
result = ois.readObject();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
if (ois != null) {
ois.close();
ois = null;
}
} catch (Exception e) {
}
return result;
}
}
}

再加上controller 调用service方法。 打开本地的redis服务。



















分享到：
| kindeditor的使用
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    各种版本的redis+Jedis驱动包

    在这个压缩包中，包含了不同平台下的Redis安装包，以及Jedis驱动，这使得在Windows和Linux环境下都能轻松地使用Redis。 首先，让我们详细了解Redis的不同版本： 1. **Redis Windows 32位与64位安装包**：Redis原本...

    linux中安装redis和jedis及jedispool

    linux中安装redis和jedis及jedispool； redis安装所遇到的问题；

    redis使用jedis测试

    Jedis是Java语言中广泛使用的Redis客户端库，提供了丰富的API以便于与Redis服务器进行交互。在本测试环境中，我们将探讨如何利用Jedis进行Redis的基本操作，包括增删等。 首先，我们需要在本地或服务器上安装Redis...

    redis，jedis 需要的jar包

    使用Java操作Redis需要jedis-2.1.0.jar，如果需要使用Redis连接池的话，还需commons-pool-1.5.4.jar使用Java操作Redis需要jedis-2.1.0.jar，如果需要使用Redis连接池的话，还需commons-pool-1.5.4.jar

    spring boot redis-jedis

    本篇文章将深入探讨如何在Spring Boot项目中集成Redis，并使用Jedis客户端进行操作。 首先，我们要在Spring Boot项目中引入Redis和Jedis的依赖。在`pom.xml`文件中，我们需要添加以下依赖： ```xml &lt;groupId&gt;org...

    redis相关jar包（redis2.1.5、jedis2.9.0）

    在Java开发中，我们通常使用Jedis作为客户端库来与Redis进行交互。本文将深入探讨Redis、Jedis以及Spring Data Redis这三个核心概念，并结合提供的jar包版本，解析它们在实际开发中的应用。 首先，Redis是一个开源...

    Redis及使用Jedis开发所需jar

    在Java开发环境中，为了使用Jedis与Redis进行交互，我们需要引入相应的jar包。这些jar包通常包含了Jedis库本身和其依赖的其他库，如连接池管理、网络通信等组件。"Redis4JavaDev"这个压缩包很可能包含了这些必要的...

    征服 Redis + Jedis

    Jedis是Java语言中广泛使用的Redis客户端库，它提供了丰富的API来操作Redis服务器，包括数据的读写、事务处理、发布订阅等功能。这篇“征服Redis + Jedis”的博文很可能是介绍如何在Java应用中高效地使用Redis和...

    redis jredis jedis 使用

    标题中的“redis jredis jedis 使用”表明我们将探讨三个与Redis相关的Java客户端库：Redis本身、JRedis和Jedis。Redis是一个开源的、基于内存的数据结构存储系统，常被用作数据库、缓存和消息中间件。而JRedis和...

    Redis+Jedis+案例实战（高清视频教程）.rar

    2. Jedis使用指南： - 连接与断开：掌握如何使用Jedis建立连接，执行命令，以及在完成操作后正确关闭连接。 - 命令操作：学习Jedis提供的API，如设置、获取、删除键值对，操作列表、集合、哈希等数据结构。 - ...

    redis集成 jedis使用

    Jedis是Java语言中广泛使用的Redis客户端，提供了丰富的API来操作Redis服务器。在本文中，我们将深入探讨如何集成Redis并使用Jedis进行五种基本数据类型的测试：字符串（Strings）、哈希（Hashes）、列表（Lists）、...

    java连接redis/jedis连接池/jedis相关工具/jedis对象存取

    Jedis是Java语言中广泛使用的Redis客户端库，它提供了丰富的API来操作Redis服务器。 首先，让我们深入了解Java如何通过Jedis连接到Redis。Jedis连接池是优化资源管理的关键，它允许开发者预先创建并复用连接，避免...

    中间件：Redis 之 Jedis的使用

    ### 中间件：Redis 之 Jedis的使用 #### 一、Jedis简介 Jedis作为Redis官方推荐的Java客户端工具，在后端开发领域扮演着重要角色。它不仅提供了丰富的API来实现对Redis数据库的各种操作，而且还具备高效的连接池...

    redis jedis jar包

    Jedis是Java语言中用于操作Redis的客户端库，它的功能强大且易于使用，支持多种Redis命令，使得开发者能够轻松地在Java应用中集成和操作Redis。 标题中的“redis jedis jar包”指的是使用Jedis库的Java开发者需要的...

    Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制

    本项目结合了Apache Shiro、JSON Web Token (JWT)、SpringBoot、MySQL数据库以及Redis缓存技术（通过Jedis客户端）来实现这一机制。下面我们将详细探讨这些组件在实现无状态鉴权中的作用。 **Apache Shiro** Apache...

    redis,jedis,jar包

    Redis是一款高性能的...总的来说，Jedis作为Java开发者的首选Redis客户端，其简洁的API和强大的功能使得在Java应用中集成和使用Redis变得简单易行。正确理解和熟练使用Jedis，将有助于你构建高效、可靠的分布式系统。

    redis，jedis，sentinel需要的两个jar包

    在Java开发中，我们通常使用Jedis库来与Redis进行交互。Jedis是一个简单易用、高效的Redis客户端，提供了丰富的Redis命令支持。 标题中的“redis，jedis，sentinel需要的两个jar包”指的是为了在Java项目中使用...

    java连接redis的jedis.jar包

    下面将详细阐述Jedis库的使用方法、核心概念以及如何在Java项目中集成和操作Redis。 首先，我们需要了解Jedis的基本概念。Jedis是一个开源的Java客户端，它提供了丰富的API，支持多种Redis命令，如字符串、哈希、...

    Redis和Jedis示例代码

    Jedis示例java编程相关代码适合java初学者使用，可熟悉redis缓存相关的操作，以及java编码基于springboot和jedis访问redis服务进行key/value键值对存储和获取附带redis环境安装教程，以及redis入门的介绍教程。...

    jedis-2.9.0 最新版Redis客户端CSDN下载

    Jedis是Java语言中使用最广泛的Redis客户端库，它提供了丰富的API来操作Redis服务器。在这个"jedis-2.9.0"的最新版本中，我们包含了三个重要的文件： 1. `jedis-2.9.0.jar`：这是Jedis的二进制发行版，包含了所有...

Magicbox
Global site tag (gtag.js) - Google Analytics