Redis的简单入门

最新推荐文章于 2023-07-06 16:24:07 发布

mdw5521

最新推荐文章于 2023-07-06 16:24:07 发布

阅读量259

点赞数

分类专栏： Redis 文章标签： Redis

本文链接：https://blog.csdn.net/mdw5521/article/details/78781346

版权

Redis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

上次介绍了一些Redis的一些基本的操作，这次我们来实现一个简单的小例子，比如说我们正常登陆的时间，登陆成功后会跳转到网页的首页，首页也是访问量最大的，那么首页的数据每次都要从数据库查询吗?那当然不是，这是我们的缓存就派上了用场，这里我做了个小例子，用户登陆成功跳转到书籍列表查询

要使用Redis首先需要jar支持

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

添加jar后我们需要在applicationContext.xml配置Redis这里以单机版本为例，集群版已注释

<!-- 连接池配置 -->
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<!-- 最大连接数 -->
		<property name="maxTotal" value="30" />
		<!-- 最大空闲连接数 -->
		<property name="maxIdle" value="10" />
		<!-- 每次释放连接的最大数目 -->
		<property name="numTestsPerEvictionRun" value="1024" />
		<!-- 释放连接的扫描间隔（毫秒） -->
		<property name="timeBetweenEvictionRunsMillis" value="30000" />
		<!-- 连接最小空闲时间 -->
		<property name="minEvictableIdleTimeMillis" value="1800000" />
		<!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
		<property name="softMinEvictableIdleTimeMillis" value="10000" />
		<!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
		<property name="maxWaitMillis" value="1500" />
		<!-- 在获取连接的时候检查有效性, 默认false -->
		<property name="testOnBorrow" value="true" />
		<!-- 在空闲时检查有效性, 默认false -->
		<property name="testWhileIdle" value="true" />
		<!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
		<property name="blockWhenExhausted" value="false" />
	</bean>	
	<!-- jedis客户端单机版 -->
	 <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
	    <!-- value为你安装Redis的服务器IP -->
		<constructor-arg name="host" value="172.16.143.88"></constructor-arg>
		 <!-- value为你安装Redis的端口号 -->
		<constructor-arg name="port" value="6379"></constructor-arg>
		<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
	</bean>
	                              <!--  jedis的实现类的全路径 -->
	<bean id="jedisClient" class="com.miao.redis.JedisClientPool"/> 
	
	
	<!-- jedis集群版配置 -->
	<!-- <bean id="redisClient" class="redis.clients.jedis.JedisCluster">
		<constructor-arg name="nodes">
			<set>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"></constructor-arg>
					<constructor-arg name="port" value="7001"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"></constructor-arg>
					<constructor-arg name="port" value="7002"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"></constructor-arg>
					<constructor-arg name="port" value="7003"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"></constructor-arg>
					<constructor-arg name="port" value="7004"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"></constructor-arg>
					<constructor-arg name="port" value="7005"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.25.153"></constructor-arg>
					<constructor-arg name="port" value="7006"></constructor-arg>
				</bean>
			</set>
		</constructor-arg>
		<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
	</bean>
	<bean id="jedisClientCluster" class="com.taotao.sso.dao.JedisClientCluster"></bean> -->

配置完成后，我们需要Redis的操作接口和其实现类，这里给大家整理了还算是很齐的

接口：

package com.miao.redis;

import java.util.List;
import java.util.Map;
import java.util.Set;

public interface JedisClient {

	String set(String key, String value);
	String get(String key);
	Boolean exists(String key);
	Long expire(String key, int seconds);
	Long ttl(String key);
	Long incr(String key);
	Long hset(String key, String field, String value);
	String hget(String key, String field);
	Long hdel(String key, String... field);
	Long persist(final String key);
	Long del(final String key);
	Long hlen(final String key);
	Boolean hexists(final String key, final String field);
	Set<String> hkeys(final String key);
	List<String> hvals(final String key);
	Map<String, String> hgetAll(final String key);
	Long rpush(final String key, final String... string);
	Long lpush(final String key, final String... string);
	Long llen(final String key);
	List<String> lrange(final String key, final long start, final long end);
	String ltrim(final String key, final long start, final long end);
	String lindex(final String key, final long index);
	String lset(final String key, final long index, final String value);
	Long lrem(final String key, final long count, final String value);
	String lpop(final String key);
	String rpop(final String key);
	Long sadd(final String key, final String... member);
	Set<String> smembers(final String key);
	Boolean sismember(final String key, final String member);
	Long srem(final String key, final String... member);
	
}

实现类：

package com.miao.redis;

import java.util.List;
import java.util.Map;
import java.util.Set;

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

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;



public class JedisClientPool implements JedisClient{
	/*
	 * 单节点使用redis
	 */
	@Autowired
	private JedisPool jedisPool;

	public String set(String key, String value) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.set(key, value);
		jedis.close();
		return result;
	}

	public String get(String key) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.get(key);
		jedis.close();
		return result;
	}

	public Boolean exists(String key) {
		Jedis jedis = jedisPool.getResource();
		Boolean result = jedis.exists(key);
		jedis.close();
		return result;
	}

	public Long expire(String key, int seconds) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.expire(key, seconds);
		jedis.close();
		return result;
	}

	public Long ttl(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.ttl(key);
		jedis.close();
		return result;
	}

	public Long incr(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.incr(key);
		jedis.close();
		return result;
	}

	public Long hset(String key, String field, String value) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hset(key, field, value);
		jedis.close();
		return result;
	}

	public String hget(String key, String field) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.hget(key, field);
		jedis.close();
		return result;
	}

	public Long hdel(String key, String... field) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hdel(key, field);
		jedis.close();
		return result;
	}

	public Long persist(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.persist(key);
		jedis.close();
		return result;
	}

	public Long del(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.del(key);
		jedis.close();
		return result;
	}

	public Long hlen(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hlen(key);
		jedis.close();
		return result;
	}

	public Boolean hexists(String key, String field) {
		Jedis jedis = jedisPool.getResource();
		Boolean result = jedis.hexists(key, field);
		jedis.close();
		return result;
	}

	public Set<String> hkeys(String key) {
		Jedis jedis = jedisPool.getResource();
		Set<String> result = jedis.hkeys(key);
		jedis.close();
		return result;
	}

	public List<String> hvals(String key) {
		Jedis jedis = jedisPool.getResource();
		List<String> result = jedis.hvals(key);
		jedis.close();
		return result;
	}

	public Map<String, String> hgetAll(String key) {
		Jedis jedis = jedisPool.getResource();
		Map<String, String> result = jedis.hgetAll(key);
		jedis.close();
		return result;
	}

	public Long rpush(String key, String... string) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.rpush(key, string);
		jedis.close();
		return result;
	}

	public Long lpush(String key, String... string) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.lpush(key, string);
		jedis.close();
		return result;
	}

	public Long llen(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.llen(key);
		jedis.close();
		return result;
	}

	public List<String> lrange(String key, long start, long end) {
		Jedis jedis = jedisPool.getResource();
		List<String> result = jedis.lrange(key, start, end);
		jedis.close();
		return result;
	}

	public String ltrim(String key, long start, long end) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.ltrim(key, start, end);
		jedis.close();
		return result;
	}

	public String lindex(String key, long index) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.lindex(key, index);
		jedis.close();
		return result;
	}

	public String lset(String key, long index, String value) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.lset(key, index, value);
		jedis.close();
		return result;
	}

	public Long lrem(String key, long count, String value) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.lrem(key, count, value);
		jedis.close();
		return result;
	}

	public String lpop(String key) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.lpop(key);
		jedis.close();
		return result;
	}

	public String rpop(String key) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.rpop(key);
		jedis.close();
		return result;
	}

	public Long sadd(String key, String... member) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.sadd(key, member);
		jedis.close();
		return result;
	}

	public Set<String> smembers(String key) {
		Jedis jedis = jedisPool.getResource();
		Set<String> result = jedis.smembers(key);
		jedis.close();
		return result;
	}

	public Boolean sismember(String key, String member) {
		Jedis jedis = jedisPool.getResource();
		Boolean result = jedis.sismember(key, member);
		jedis.close();
		return result;
	}

	public Long srem(String key, String... member) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.srem(key, member);
		jedis.close();
		return result;
	}

}

上面的代码直接复制就可用，因为代码量太大，集群版就不贴出来了，如果需要可以私信我。有了接口实现类和配置文件，因为项目中把Book类转成了Json字符串类型进行存储，所以把JsonUtil也贴出来

JsonUtil所需jar包：

<!-- Jackson Json处理工具包 -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.9.2</version>
</dependency>

JsonUtil工具类：

package com.miao.util;

import java.util.List;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;


public class JsonUtils {

    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();

    /**
     * 将对象转换成json字符串。
     * <p>Title: pojoToJson</p>
     * <p>Description: </p>
     * @param data
     * @return
     */
    public static String objectToJson(Object data) {
    	try {
			String string = MAPPER.writeValueAsString(data);
			return string;
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
    	return null;
    }
    
    /**
     * 将json结果集转化为对象
     * 
     * @param jsonData json数据
     * @param clazz 对象中的object类型
     * @return
     */
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
        	e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json数据转换成pojo对象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     * @param jsonData
     * @param beanType
     * @return
     */
    public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
    	JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
    	try {
    		List<T> list = MAPPER.readValue(jsonData, javaType);
    		return list;
		} catch (Exception e) {
			e.printStackTrace();
		}
    	
    	return null;
    }
    
}

登陆成功后访问show方法，那么show方法中我们应该先去查询缓存，如果缓存中没有数据，那么再去查找数据库，然后把信息存到缓存中，再次访问该放页面时直接从缓存中取值。缓存只是我们来缓解数据库压力的，所以当它出现异常不能影响我们项目正常运行。所以我们要加上try-catch,下面就代码实现，我们的业务逻辑写在service层。

package com.miao.service;

import java.util.List;
import java.util.UUID;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.miao.mapper.BookMapper;
import com.miao.pojo.Book;
import com.miao.pojo.BookExample;
import com.miao.redis.JedisClient;
import com.miao.util.CookieUtils;
import com.miao.util.JsonUtils;

@Service
public class BookServiceImpl implements BookService {

	@Autowired
	private BookMapper bookMapper;

	@Autowired
	private JedisClient jedisClient;

	public List<Book> show(HttpServletRequest request, HttpServletResponse response) {

		// 先查询缓存start
		try {
			// 查询缓存中的token值
			String token = CookieUtils.getCookieValue(request, "BOOK_INFOR");
			// 获取json对象
			String BooksJson = jedisClient.get("REDIS_BOOKS_KEY" + ":" + token);
			// 如果查询到的数据不为空或者null
			if (BooksJson != null && BooksJson != "") {
				// 将json转换为book类型
				List<Book> books = JsonUtils.jsonToList(BooksJson, Book.class);
				// 将信息存到model中
				System.out.println("本次查询的是缓存");
				return books;
			}
		} catch (Exception e) {
		}
		// 查询缓存end

		BookExample example = new BookExample();
		System.out.println("本次查询的是数据库");
		List<Book> list = bookMapper.selectByExample(example);
		
		// 將书本信息存入到缓存start
		try {
			// 生成一个随机字符码
			String token = UUID.randomUUID().toString();
			System.out.println(token);
			// 将book信息存储到redis中
			jedisClient.set("REDIS_BOOKS_KEY" + ":" + token, JsonUtils.objectToJson(list));
			// 设置缓存的过期时间为1000秒
			jedisClient.expire("REDIS_BOOKS_KEY" + ":" + token, 1000);
			// 将token信息写入到cookie中，默认关闭浏览器失效
			CookieUtils.setCookie(request, response, "BOOK_INFOR", token);
			System.out.println("本次是往缓存存值");

		} catch (Exception e) {
			// TODO: handle exception
		}
		// 將书本信息存入到缓存end
		
		return list;
	}

	
}

到此我们的代码就结束了下面我们来试验下,登陆-然后刷新六次首页,我们会发现后面取值都是在缓存中取的，证明我们缓存起到了效果

mdw5521

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Redis的简单入门

上次介绍了一些Redis的一些基本的操作，这次我们来实现一个简单的小例子，比如说我们正常登陆的时间，登陆成功后会跳转到网页的首页，首页也是访问量最大的，那么首页的数据每次都要从数据库查询吗?那当然不是，这是我们的缓存就排上了用场，这里我做了个小例子，用户登陆成功跳转到书籍列表查询
复制链接

扫一扫