spring和redis集成

最新推荐文章于 2024-08-20 15:48:23 发布

weixin_34309435

最新推荐文章于 2024-08-20 15:48:23 发布

阅读量82

点赞数

文章标签： java 数据结构与算法 python

原文链接：https://my.oschina.net/newdeng/blog/1820112

版权

2019独角兽企业重金招聘Python工程师标准>>>

redis作为一个缓存在实际项目中使用的非常频繁，下面就来介绍下怎么使用。

1.创建项目

创建一个简单的maven项目，

2. pom文件中引入jar包

因为是和spring集成，所以sprig相关的包肯定不能少，所以要用的包如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.xing.deng</groupId>
  <artifactId>spring-redis</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  
   <properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<org.springframework.version>4.2.8.RELEASE</org.springframework.version>
		<org.apache.logging.log4j.version>2.8.2</org.apache.logging.log4j.version>
	</properties>
  <dependencies>
  	<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-oxm</artifactId>
			<version>${org.springframework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.7.4.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		
		<!-- json -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>2.8.4</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.8.4</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>2.8.4</version>
		</dependency>
		
		<!-- redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.7.4.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>
  
 	 <!-- common -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.3.2</version>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-collections4</artifactId>
			<version>4.0</version>
		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>1.10</version>
		</dependency>
		<dependency>
		    <groupId>commons-io</groupId>
		    <artifactId>commons-io</artifactId>
		    <version>2.5</version>
		</dependency>
		<dependency>
  			<groupId>commons-fileupload</groupId>
  			<artifactId>commons-fileupload</artifactId>
  			<version>1.3.1</version>
		</dependency>
  </dependencies>
</project>

3. web.xml 的配置

4. 配置文件介绍

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:util="http://www.springframework.org/schema/util"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
		
	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
		lazy-init="false">
		<property name="hostName" value="${redis.host}" />
		<property name="port" value="${redis.port}" />
		<property name="database" value="${redis.database}" />
		<property name="timeout" value="${redis.timeout}" />
		<property name="usePool" value="${redis.use.pool}" />
		<property name="poolConfig" ref="redisPoolConfig" />
		<property name="password" value="${redis.password}" />
	</bean>
        
    <bean id="redisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" lazy-init="false">
    	<property name="maxTotal" value="${redis.maxTotal}" />
    	<property name="maxIdle" value="${redis.maxIdle}" />
    	<property name="minIdle" value="${redis.minIdle}" />
    	<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
    	<property name="testOnCreate" value="${redis.testOnCreate}" />
    	<property name="testOnBorrow" value="${redis.testOnBorrow}" />
    	<property name="testOnReturn" value="${redis.testOnReturn}" />
    	<property name="testWhileIdle" value="${redis.testWhileIdle}" />
    	<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />
    	<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />
    	<property name="softMinEvictableIdleTimeMillis" value="${redis.softMinEvictableIdleTimeMillis}" />
    	<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />
    </bean>
    	
	<!-- redis template definition -->
	<bean id="jdkRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
	  p:connection-factory-ref="jedisConnectionFactory" 
	  lazy-init="false">
	  <property name="keySerializer" ref="stringRedisSerializer"></property>
	</bean>
	
	<bean id="stringRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
	  p:connection-factory-ref="jedisConnectionFactory" 
	  lazy-init="false">
	  <property name="keySerializer" ref="stringRedisSerializer"></property>
	  <property name="valueSerializer" ref="stringRedisSerializer"></property>
	  <property name="hashKeySerializer" ref="stringRedisSerializer"></property>
	  <property name="hashValueSerializer" ref="stringRedisSerializer"></property>
	</bean>
	
	<bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"></bean> 

</beans>

注意：这个是读取properties文件，不然容器不知道从哪读取属性文件

5.代码coding

KeyGenerator.java

package com.lieni.tuimu.am.core.redis;

import org.springframework.util.StringUtils;

public abstract class KeyGenerator {

    public static final String CACHE_KEY_SEPARATOR = ".";

    protected static String genKeyInProject(String projectName, long primaryKey, String... funcs) {
        return genKeyInProject(projectName, String.valueOf(primaryKey), funcs);
    }

    protected static String genKeyInProject(String projectName, String primaryKey, String... funcs) {
        StringBuilder sb = new StringBuilder();
        sb.append(projectName).append(CACHE_KEY_SEPARATOR).append(primaryKey);
        for (String func : funcs) {
            if (!StringUtils.isEmpty(func)) {
                sb.append(CACHE_KEY_SEPARATOR).append(func);
            }
        }
        return sb.toString();
    }
}

RedisKeyGenerator.java

package com.lieni.tuimu.am.core.redis;

public class RedisKeyGenerator extends WebRedisKeyGenerator {

    // 自定义的key
    private static final String OBTAIN_COUNT_KEY_PROFIX = "my.obtain.count";

    /**
     * 生成记录认领操作数的key
     *
     * @param userId 用户id
     * @return String
     */
    public static String genObtainCountKey(long userId) {
        return genKey(OBTAIN_COUNT_KEY_PROFIX, String.valueOf(userId));
    }

}

WebRedisKeyGenerator.java

package com.lieni.tuimu.am.core.redis;

public class WebRedisKeyGenerator extends KeyGenerator {

    // 项目模块的key
    private static final String PROJECT_NAME = "spring-redis";

    protected static String genKey(long primaryKey, String... funcs) {
        return genKey(String.valueOf(primaryKey), funcs);
    }

    protected static String genKey(String primaryKey, String... funcs) {
        return genKeyInProject(PROJECT_NAME, primaryKey, funcs);
    }
}

6. 启动项目

编写调用类，将项目加载到tomcat容器中启动

TestController.java

package com.lieni.tuimu.am.test.controller;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.lieni.tuimu.am.core.redis.RedisKeyGenerator;

@RestController
public class TestController {

    @Autowired
    private RedisTemplate<String, String> stringRedisTemplate;

    @RequestMapping(value = "v1/info/redis/test", method = RequestMethod.GET)
    public String methodName(HttpServletRequest request, HttpServletResponse response,
            @RequestParam(value = "userId", required = true) long userId) {

        String genObtainCountKey = RedisKeyGenerator.genObtainCountKey(userId);
        String stringOne = stringRedisTemplate.opsForValue().get(genObtainCountKey);

        stringRedisTemplate.opsForValue().increment(genObtainCountKey, 1);
        // stringRedisTemplate.expireAt(genObtainCountKey, new Date());

        String stringTwo = stringRedisTemplate.opsForValue().get(genObtainCountKey);

        String x = "one=" + null == stringOne ? "xx" : stringOne + ":==:two;=" + null == stringTwo ? "yy" : stringTwo;

        return x;
    }
}

启动成功后，通过postman 调用结果如下：

上面是直接存字符串的形式，下面介绍下几种类型：

结构类型	结构存储的值	结构的读写能力
String	可以是字符串、整数或者浮点数	对整个字符串或者字符串的其中一部分执行操作；对象和浮点数执行自增(increment)或者自减(decrement)
List	一个链表，链表上的每个节点都包含了一个字符串	从链表的两端推入或者弹出元素；根据偏移量对链表进行修剪(trim)；读取单个或者多个元素；根据值来查找或者移除元素
Hash	包含键值对的无序散列表	添加、获取、移除单个键值对；获取所有键值对
Set	包含字符串的无序收集器(unorderedcollection)，并且被包含的每个字符串都是独一无二的、各不相同	添加、获取、移除单个元素；检查一个元素是否存在于某个集合中；计算交集、并集、差集；从集合里卖弄随机获取元素
ZSet	字符串成员(member)与浮点数分值(score)之间的有序映射，元素的排列顺序由分值的大小决定	添加、获取、删除单个元素；根据分值范围(range)或者成员来获取元素

直接看测试结果：

package com.lieni.tuimu.am.test.controller;

import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration({ "/spring/web-context.xml", "/spring/application-context.xml" })
public class JunitBaseTest {

}

package com.lieni.tuimu.am.test.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.Resource;

import org.junit.Test;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;

import com.lieni.tuimu.am.test.controller.bean.User;

public class RedisController extends JunitBaseTest {

    @Resource(name = "stringRedisTemplate") // 普通字符串使用 stringRedisTemplate
    RedisTemplate<String, String> stringRedisTemplate;

    @Test
    public void testString() throws InterruptedException {
        String key = "stringkey";
        stringRedisTemplate.delete(key);
        // 存
        stringRedisTemplate.opsForValue().set(key, "我是redisStringkey的value");
        // 设置过期时间
        stringRedisTemplate.expireAt(key, new Date(2018, 5, 30));
        // 获取过期时间
        Long expire = stringRedisTemplate.getExpire(key, TimeUnit.DAYS);
        System.out.println(expire);
        // 取值
        String string = stringRedisTemplate.opsForValue().get(key);
        System.out.println(string);
        Thread.sleep(5000L);
        stringRedisTemplate.opsForValue().set(key, "我是redisStringkey的value2");
        System.out.println(stringRedisTemplate.getExpire(key, TimeUnit.DAYS));
        System.out.println(stringRedisTemplate.opsForValue().get(key));
        // 上面的运行结果说明同一个key的过期时间当再次存的时候 需要重新设置

    }

    @Resource(name = "stringRedisTemplate")
    RedisTemplate<String, String> listRedisTemplate;

    @Test
    public void testList() {
        listRedisTemplate.delete("listKey");
        List<String> values = new ArrayList<>();
        values.add("1");
        values.add("3");
        values.add("2");
        listRedisTemplate.opsForList().leftPushAll("listKey", values);
        List<String> range = listRedisTemplate.opsForList().range("listKey", 0, -1);
        for (String string : range) {
            System.out.println(string);
        }

    }

    @Resource(name = "jdkRedisTemplate") // 对象必须使用 jdkRedisTemplate
    RedisTemplate<String, User> listUserRedisTemplate;

    @Test
    public void testListBean() {
        listUserRedisTemplate.delete("listUserKey");
        List<User> values = new ArrayList<>();
        User userOne = new User();
        userOne.setName("Tom");
        userOne.setAge(18);
        userOne.setAddress("USA");
        User userTwo = new User();
        userTwo.setName("小明");
        userTwo.setAge(20);
        userTwo.setAddress("china");
        values.add(userOne);
        values.add(userTwo);

        listUserRedisTemplate.opsForList().leftPushAll("listUserKey", values);
        List<User> range = listUserRedisTemplate.opsForList().range("listUserKey", 0, -1);
        for (User string : range) {
            System.out.println(string);
        }

    }

    @Resource(name = "stringRedisTemplate")
    RedisTemplate<String, Map<String, String>> listMapRedisTemplate;

    @Test
    public void testMap() {
        listMapRedisTemplate.delete("listMapKey");
        Map<String, String> hashmap = new HashMap<>();
        hashmap.put("name", "Tom");
        hashmap.put("age", "18");
        // 存map的形式
        listMapRedisTemplate.opsForHash().putAll("listMapKey", hashmap);
        // 获取对应listMapKey的map对象
        Map<Object, Object> entries = listMapRedisTemplate.opsForHash().entries("listMapKey");
        Set<Entry<Object, Object>> entrySet = entries.entrySet();
        for (Entry<Object, Object> entry : entrySet) {
            System.out.println(entry.getKey() + "==:" + entry.getValue());
        }
        // 获取指定key中map中的指定key
        String age = (String) listMapRedisTemplate.opsForHash().get("listMapKey", "age");
        System.out.println(age);

    }

    @Resource(name = "stringRedisTemplate")
    RedisTemplate<String, String> setRedisTemplate;

    @Test
    public void testSet() {
        setRedisTemplate.delete("setKey");
        setRedisTemplate.opsForSet().add("setKey", "set1");
        setRedisTemplate.opsForSet().add("setKey", "set3");
        setRedisTemplate.opsForSet().add("setKey", "set2");
        setRedisTemplate.opsForSet().add("setKey", "set4");
        Set<String> members = setRedisTemplate.opsForSet().members("setKey");
        for (String string : members) {
            System.out.println(string);
        }
        System.out.println("=============");
        String[] set = { "1", "2", " 4", " 3" };
        setRedisTemplate.opsForSet().add("setAll", set);
        Set<String> members2 = setRedisTemplate.opsForSet().members("setAll");
        for (String string : members2) {
            System.out.println(string);
        }

    }

    @Resource(name = "stringRedisTemplate")
    RedisTemplate<String, Object> zSetRedisTemplate;

    @Test
    public void testZSet() {
        zSetRedisTemplate.delete("setAllZ");
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<ZSetOperations.TypedTuple<Object>>();
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>("b", 2.0);// 这里必须是2.0，因为那边是用Double收参
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<Object>("c", 3.0);
        ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<Object>("d", 1.0);
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        zSetRedisTemplate.opsForZSet().add("setAllZ", tuples);
        Set<Object> range = zSetRedisTemplate.opsForZSet().range("setAllZ", 0, -1);
        for (Object object : range) {
            System.out.println(object);
        }

    }

}

参考文档：https://blog.csdn.net/weixin_37490221/article/details/78134105

转载于:https://my.oschina.net/newdeng/blog/1820112