springboot + redis 操作几种数据类型

1、在application.properties文件中进行redis的相关配置

# Redis 配置
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=192.168.131.59
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0

2、在pom.xml文件中进行配置

<!-- redis依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3、建立Student.java类

import java.io.Serializable;
import java.util.Date;
import javax.persistence.*;

public class Student extends BaseBeanVO implements Serializable {

	private static final long serialVersionUID = 1L;

	/**
	 * 主键
	 */
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer id;

	/**
	 * 学生姓名
	 */
	private String name;

	/**
	 * 学生姓名
	 */
	private String account;

	/**
	 * 学生姓名
	 */
	private String password;

	/**
	 * 图片
	 */
	private String image;

	/**
	 * 是否已经毕业（0：没有毕业 1：已经毕业）
	 */
	@Column(name = "is_graduated")
	private String isGraduated;

	/**
	 * 微信OPENID
	 */
	private String openid;

	/**
	 * 微信昵称
	 */
	@Column(name = "wx_nickname")
	private String wxNickname;

	/**
	 * 微信账号
	 */
	@Column(name = "wx_account")
	private String wxAccount;

	/**
	 * 微信头像
	 */
	@Column(name = "wx_headimage")
	private String wxHeadimage;

	/**
	 * 是否删除（0：未删除 1：已删除）
	 */
	@Column(name = "is_delete")
	private Integer isDelete;

	/**
	 * 创建时间
	 */
	private Date createtime;

	/**
	 * 更新时间
	 */
	private Date updatetime;

	/**
	 * 获取主键
	 *
	 * @return id - 主键
	 */
	public Integer getId() {
		return id;
	}

	/**
	 * 设置主键
	 *
	 * @param id
	 *            主键
	 */
	public void setId(Integer id) {
		this.id = id;
	}

	/**
	 * 获取学生姓名
	 *
	 * @return name - 学生姓名
	 */
	public String getName() {
		return name;
	}

	/**
	 * 设置学生姓名
	 *
	 * @param name
	 *            学生姓名
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * 获取图片
	 *
	 * @return image - 图片
	 */
	public String getImage() {
		return image;
	}

	/**
	 * 设置图片
	 *
	 * @param image
	 *            图片
	 */
	public void setImage(String image) {
		this.image = image;
	}

	/**
	 * 获取是否已经毕业（0：没有毕业 1：已经毕业）
	 *
	 * @return is_graduated - 是否已经毕业（0：没有毕业 1：已经毕业）
	 */
	public String getIsGraduated() {
		return isGraduated;
	}

	/**
	 * 设置是否已经毕业（0：没有毕业 1：已经毕业）
	 *
	 * @param isGraduated
	 *            是否已经毕业（0：没有毕业 1：已经毕业）
	 */
	public void setIsGraduated(String isGraduated) {
		this.isGraduated = isGraduated;
	}

	public String getOpenid() {
		return openid;
	}

	public void setOpenid(String openid) {
		this.openid = openid;
	}

	/**
	 * 获取微信昵称
	 *
	 * @return wx_nickname - 微信昵称
	 */
	public String getWxNickname() {
		return wxNickname;
	}

	/**
	 * 设置微信昵称
	 *
	 * @param wxNickname
	 *            微信昵称
	 */
	public void setWxNickname(String wxNickname) {
		this.wxNickname = wxNickname;
	}

	/**
	 * 获取微信账号
	 *
	 * @return wx_account - 微信账号
	 */
	public String getWxAccount() {
		return wxAccount;
	}

	/**
	 * 设置微信账号
	 *
	 * @param wxAccount
	 *            微信账号
	 */
	public void setWxAccount(String wxAccount) {
		this.wxAccount = wxAccount;
	}

	/**
	 * 获取微信头像
	 *
	 * @return wx_headimage - 微信头像
	 */
	public String getWxHeadimage() {
		return wxHeadimage;
	}

	/**
	 * 设置微信头像
	 *
	 * @param wxHeadimage
	 *            微信头像
	 */
	public void setWxHeadimage(String wxHeadimage) {
		this.wxHeadimage = wxHeadimage;
	}

	/**
	 * 获取是否删除（0：未删除 1：已删除）
	 *
	 * @return is_delete - 是否删除（0：未删除 1：已删除）
	 */
	public Integer getIsDelete() {
		return isDelete;
	}

	/**
	 * 设置是否删除（0：未删除 1：已删除）
	 *
	 * @param isDelete
	 *            是否删除（0：未删除 1：已删除）
	 */
	public void setIsDelete(Integer isDelete) {
		this.isDelete = isDelete;
	}

	/**
	 * 获取创建时间
	 *
	 * @return createtime - 创建时间
	 */
	public Date getCreatetime() {
		return createtime;
	}

	/**
	 * 设置创建时间
	 *
	 * @param createtime
	 *            创建时间
	 */
	public void setCreatetime(Date createtime) {
		this.createtime = createtime;
	}

	/**
	 * 获取更新时间
	 *
	 * @return updatetime - 更新时间
	 */
	public Date getUpdatetime() {
		return updatetime;
	}

	/**
	 * 设置更新时间
	 *
	 * @param updatetime
	 *            更新时间
	 */
	public void setUpdatetime(Date updatetime) {
		this.updatetime = updatetime;
	}

	public String getAccount() {
		return account;
	}

	public void setAccount(String account) {
		this.account = account;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", account=" + account + ", password=" + password + ", image="
				+ image + ", isGraduated=" + isGraduated + ", openid=" + openid + ", wxNickname=" + wxNickname
				+ ", wxAccount=" + wxAccount + ", wxHeadimage=" + wxHeadimage + ", isDelete=" + isDelete
				+ ", createtime=" + createtime + ", updatetime=" + updatetime + "]";
	}

}

4、创建RedisController.java类

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ailschn.integral.model.Student;

/**
 * redis
 *
 */
@RestController
public class RedisController {
	@Autowired
	private StringRedisTemplate stringRedisTemplate;

	@Autowired
	private RedisTemplate redisTemplate;

	// redisTemplate.opsForValue();//操作字符串
	// redisTemplate.opsForHash();//操作hash
	// redisTemplate.opsForList();//操作list
	// redisTemplate.opsForSet();//操作set
	// redisTemplate.opsForZSet();//操作有序set

	/**
	 * 字符串
	 */
	@RequestMapping(value = "/redis/string")
	public void stringOperation(@RequestBody Student student) {
		// key、value
		redisTemplate.opsForValue().set("name", student.getName());

		System.out.println("》》》》》》" + redisTemplate.opsForValue().get("name"));
	}

	/**
	 * 集合
	 */
	@RequestMapping(value = "/redis/set")
	public void setOperation(@RequestBody Student student) {
		Set<String> set1 = new HashSet<String>();
		set1.add("set1");
		set1.add("set2");
		set1.add("set3");
		// 插入
		redisTemplate.opsForSet().add("set1", set1);
		// 获取
		Set<String> resultSet = redisTemplate.opsForSet().members("set1");
		System.out.println("resultSet:" + resultSet);
	}

	/**
	 * Map
	 */
	@RequestMapping(value = "/redis/map")
	public void mapOperation(@RequestBody Student student) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("key1", "value1");
		map.put("key2", "value2");
		map.put("key3", "value3");
		map.put("key4", "value4");
		map.put("key5", "value5");
		// 插入
		redisTemplate.opsForHash().putAll("map1", map);

		Map<String, String> resultMap = redisTemplate.opsForHash().entries("map1");
		System.out.println("resultMap:" + resultMap);

		List<String> reslutMapList = redisTemplate.opsForHash().values("map1");
		System.out.println("reslutMapList:" + reslutMapList);

		Set<String> resultMapSet = redisTemplate.opsForHash().keys("map1");
		System.out.println("resultMapSet:" + resultMapSet);

		String value = (String) redisTemplate.opsForHash().get("map1", "key1");
		System.out.println("value:" + value);
	}

	/**
	 * List
	 */
	@RequestMapping(value = "/redis/list")
	public void listOperation(@RequestBody Student student) {
		List<String> list1 = new ArrayList<String>();
		list1.add("a1");
		list1.add("a2");
		list1.add("a3");

		List<String> list2 = new ArrayList<String>();
		list2.add("b1");
		list2.add("b2");
		list2.add("b3");
		// 插入
		redisTemplate.opsForList().leftPush("listkey1", list1);
		redisTemplate.opsForList().rightPush("listkey2", list2);

		// 取数据
		List<String> resultList1 = (List<String>) redisTemplate.opsForList().leftPop("listkey1");
		List<String> resultList2 = (List<String>) redisTemplate.opsForList().rightPop("listkey2");
		System.out.println("resultList1:" + resultList1);
		System.out.println("resultList2:" + resultList2);
	}

	/**
	 * Student
	 */
	@RequestMapping(value = "/redis/student")
	public void studentOperation(@RequestBody Student student) {
		List<Student> studentList = new ArrayList<Student>();
		Student student1 = new Student();
		student1.setId(1);
		student1.setName("小王");

		Student student2 = new Student();
		student1.setId(3);
		student1.setName("老朱");
		studentList.add(student1);
		studentList.add(student2);

		redisTemplate.opsForValue().set("studentList", studentList);
		// Object object = redisTemplate.opsForValue().get("studentList");

		// 强转
		List<Student> resultList = (List<Student>) redisTemplate.opsForValue().get("studentList");

		if (resultList != null && resultList.size() > 0) {
			for (Student nowStudent : resultList) {
				System.out.println(">>>>>>>" + nowStudent.getName());
			}
		}

	}
}