Maven项目使用redis(手动式写入)_stringredistemplate maven-优快云博客

本文链接：https://blog.youkuaiyun.com/mmmmmmFC/article/details/80389390

本文介绍了如何在Maven项目中集成Redis作为缓存，包括导入相关依赖，配置XML，定义接口和实现，以及使用序列化工具类。通过IRedisBaiseTakes接口对外提供操作，并使用RedisDesktopManager进行检验，但尚未实现Mybatis的二级缓存功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、通过maven导入相关包

	<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.6.2.RELEASE</version>
		</dependency>

注意相关版本的适配，这里采用了较低的版本

2、配置applicationContext.xml

<!--设置数据池 -->
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxIdle" value="300"></property>
		<property name="minIdle" value="100"></property>
		<property name="maxTotal" value="500"></property>
		<property name="maxWaitMillis" value="3000"></property>
		<property name="testOnBorrow" value="true"></property>
	</bean>
	<bean id="jedisConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
		p:host-name="127.0.0.1" p:port="6379" p:poolConfig-ref="poolConfig" />
	<bean id="stringRedisTemplate"
		class="org.springframework.data.redis.core.StringRedisTemplate"
		p:connection-factory-ref="jedisConnectionFactory"></bean>
	<bean id="redisTemplate"
		class="org.springframework.data.redis.core.RedisTemplate"
		p:connection-factory-ref="jedisConnectionFactory">
		<!--以下针对各种数据进行序列化方式的选择 -->
		<property name="keySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="valueSerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="hashKeySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<!--<property name="hashValueSerializer"> <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" 
			/> </property> -->
	</bean>

在这里配置了两个Bean[redisTemplate] [stringRedisTemplate]一个支持全String类型的存取，一个用来通过序列化的方式

存取对象。

3、编写IRedisBaiseTakes接口

以接口的形式对外暴露相关操作类

import java.util.List;

/**
 * @author FCmmmmmm
 * @author https://blog.youkuaiyun.com/u010690828/article/details/77141083
 */
public interface IRedisBaiseTakes<H, K, V> {
	// 增
	public void add(K key, String value);

	public void addObj(H objectKey, K key, V object);

	// 删
	public void delete(K key);

	public void delete(List<K> listKeys);

	public void deletObj(H objecyKey, K key);

	// 改
	public void update(K key, String value);

	public void updateObj(H objectKey, K key, V object);

	// 查
	public String get(K key);

	public V getObj(H objectKey, K key);
	
	//查询包含---存在
	public boolean isContainsStringKey(K key);
	
	public boolean isContainObj(H objectKey, K key);
}

4、编写序列化工具类SerializeUtil也可以使用java自带的序列化工具

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * @author FCmmmmmm
 *
 */
public class SerializeUtil {
	public static byte[] serialize(Object object) {
		ObjectOutputStream oos = null;
		ByteArrayOutputStream baos = null;
		try {
			// 序列化
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			byte[] bytes = baos.toByteArray();
			return bytes;
		} catch (Exception e) {
			System.out.println("序列化失败");
		}
		return null;
	}

	public static Object unserialize(byte[] bytes) {
		ByteArrayInputStream bais = null;
		try {
			// 反序列化
			bais = new ByteArrayInputStream(bytes);
			ObjectInputStream ois = new ObjectInputStream(bais);
			return ois.readObject();
		} catch (Exception e) {

		}
		return null;
	}
}

5、编写接口的实现类

import java.io.Serializable;
import java.util.List;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import com.sd.util.SerializeUtil;

/**
 * @author FCmmmmmm
 * @author 用到了util包下的 serializeUtil 请不要随意修改*/


@Component("RedisTakes")
public class RedisServiceImp implements IRedisBaiseTakes<String, String, Object> {

	@Resource(name = "stringRedisTemplate")
	private StringRedisTemplate redisTemplate;
	@Resource(name = "redisTemplate")
	private RedisTemplate<String, Serializable> redis;

	private static Logger logger = LoggerFactory.getLogger(RedisServiceImp.class);

	// inject the redisTemplate as ListOperations
	/*
	 * (non-Javadoc)
	 * 
	 * @see com.sd.redis.IRedisBaiseTakes#add(java.lang.Object, java.lang.String)
	 */
	@Override
	public void add(String key, String value) {
		if (redisTemplate == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return;
		}
		redisTemplate.opsForValue().set(key, value);
	}

	/**
	 * @param objectKey
	 *            外包集合名称
	 * @param key
	 *            单个对象id
	 * @param object
	 *            对象
	 */
	@Override
	public void addObj(String objectKey, String key, Object object) {
		if (redisTemplate == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return;
		}

		redis.opsForHash().put(objectKey, key, SerializeUtil.serialize(object));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.sd.redis.IRedisBaiseTakes#delete(java.lang.Object)
	 */
	@Override
	public void delete(String key) {
		if (redisTemplate == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return;
		}
		redisTemplate.delete(key);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.sd.redis.IRedisBaiseTakes#delete(java.util.List)
	 */
	@Override
	public void delete(List<String> listKeys) {
		if (redisTemplate == null || listKeys.size() < 1) {
			logger.warn("----redisTemplate操作出错-----");
			return;
		}
		redisTemplate.delete(listKeys);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.sd.redis.IRedisBaiseTakes#deletObj(java.lang.Object,
	 * java.lang.Object)
	 */
	@Override
	public void deletObj(String objecyKey, String key) {
		if (redisTemplate == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return;
		}
		redis.opsForHash().delete(objecyKey, key);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.sd.redis.IRedisBaiseTakes#update(java.lang.Object, java.lang.String)
	 */
	@Override
	public void update(String key, String value) {
		if (redisTemplate == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return;
		} else {
			redisTemplate.delete(key);
			redisTemplate.opsForValue().set(key, value);

		}
	}

	/**
	 * @param objectKey
	 *            对象集合id
	 * @param key
	 *            单个对象id
	 * @param object
	 *            经过序列化的对象
	 */
	@Override
	public void updateObj(String objectKey, String key, Object object) {

	}

	@Override
	public String get(String key) {
		if (redisTemplate == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return null;
		}
		String value = (String) redisTemplate.opsForValue().get(key);
		return value;
	}

	/**
	 * @return 返回一个object对象
	 */
	@Override
	public Object getObj(String objectKey, String key) {
		if (redis == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return null;
		}
		Object obj = SerializeUtil.unserialize((byte[]) redis.opsForHash().get(objectKey, key));
		return obj;
	}

	@Override
	public boolean isContainsStringKey(String key) {
		if (redisTemplate == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return false;
		}else {
			return   redisTemplate.hasKey(key);
		}
	}

	@Override
	public boolean isContainObj(String objectKey, String key) {
		if (redis == null || key == null || "".equals(key)) {
			logger.warn("----redisTemplate操作出错-----");
			return false;
		}else {
			return   redis.opsForHash().hasKey(objectKey, key);
		}
	}

}

6、测试

（1）、编写一个类一定要单独形成class，并且以public修饰且实现序列化接口

对bean层的实体类都要实现Serializable接口

import java.io.Serializable;

/**
 * @author FCmmmmmm
 *
 */
@SuppressWarnings("serial")
public class People implements Serializable {
	String id;
	String name;
	/**
	 * @return the id
	 */
	public String getId() {
		return id;
	}
	/**
	 * @param id the id to set
	 */
	public void setId(String id) {
		this.id = id;
	}
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	
}

（2）、直接测试只检验了逻辑但是未运行Service层

import java.io.Serializable;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import com.sd.util.SerializeUtil;

/**
 * @author FCmmmmmm
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(locations = { "classpath:applicationContext.xml" })
public class TestRedis {

	// RedisServiceImp serviceImp = new RedisServiceImp();
	/*
	 * @Resource(name = "redisTemplate") private ListOperations<String, String>
	 * listOps;
	 */
	@Resource(name = "stringRedisTemplate")
	private StringRedisTemplate redisTemplate;
	@Resource(name = "redisTemplate")
	private RedisTemplate<String, Serializable> redis;

	@Test
	public void get() {
		String string = (String) redisTemplate.opsForValue().get("ssa");
		System.out.println(string);
	}

	@Test
	public void insert() {
		redisTemplate.opsForValue().set("ssa", "asa");
	}

	@Test
	public void insertObject() {
		People people = new People();
		people.setId("1");
		people.setName("我是测试1号");
		try {
			redis.opsForHash().put("003", "001", SerializeUtil.serialize(people));
		} catch (Exception e) {

			e.printStackTrace();
		}
	}

	@Test
	public void getObject() {
		People p = (People) SerializeUtil.unserialize((byte[])redis.opsForHash().get("001", "001"));
		System.out.println(p.name);
	}

	public void addLink(String userId, String l) {
		redisTemplate.opsForList().leftPush(userId, l);
	}
}

7、检验结果使用了RedisDesktopManager软件