参考Spring Data Redis官方文档：https://docs.spring.io/spring-data/redis/docs/2.1.3.RELEASE/reference/html/

下面的例子会在我的github中呈现：https://github.com/sunkang123/redis

下面的例子只是展示最常用的使用，更多的详细用法参考官方文档

1.环境准备和配置文件准备

• 需要搭建一台redis服务，并启动服务

• 首先来看项目的结构

  
  

• 项目增加maven的依赖

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>1.6.1.RELEASE</version>
    </dependency>
      <dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.9.0</version>
      </dependency>

    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.6.1</version>
    </dependency>

    </dependencies>

• redis的连接池参数配置文件redis.properties

# Redis settings
redis.host=192.168.44.129
redis.port=6379
redis.pass=

#最大空闲数：空闲链接数大于maxIdle时，将进行回收
redis.maxIdle=300
#最大连接数：能够同时建立的“最大链接个数”
redis.MaxTotal=600
#最大等待时间：单位ms
redis.maxWait=1000
#使用连接时，检测连接是否成功
redis.testOnBorrow=true
#当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
redis.timeout=10000

• redis与spring整合的配置文件applicationContext-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:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context" 
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- Configurer that replaces ${...} placeholders with values from a properties file -->
    <context:property-placeholder location="classpath:redis.properties"/>

    <context:annotation-config />
    <!-- jedis连接池配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="MaxTotal" value="${redis.MaxTotal}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <!-- jedis连接工程的配置 -->
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
        p:host-name="${redis.host}" p:port="${redis.port}"
          p:password="${redis.pass}" p:pool-config-ref="poolConfig"
            p:timeout="${redis.timeout}"/>
    <!-- redisTemplate配置 -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate" 
        p:connection-factory-ref="connectionFactory"/>
</beans>

• 2.StringRedisTemplate的简单使用

直接放代码

• RedisTemplateExample测试

/**
 * @Project: redis
 * @description: StringRedisTemplate 的简单使用
 * @author: sunkang
 * @create: 2019-01-12 21:12
 * @ModificationHistory who      when       What
 **/
public class RedisTemplateExample {
    public static void main(String[] args) {
        ApplicationContext context =  new ClassPathXmlApplicationContext("classpath:applicationContext-redis.xml");
        RedisTemplate  redisTemplate =  context.getBean("redisTemplate",StringRedisTemplate.class);
        //对普通字符串操  ,下面的两个方式相同
        //方式一： Key Type Operations
        redisTemplate.opsForValue().set("string","key");
        //方式二：Key Bound Operations
        redisTemplate.boundValueOps("string").set("key1");

        //对list进行操作
        //方式一： Key Type Operations
        redisTemplate.opsForList().leftPush("listKey","element");
        //方式二：Key Bound Operations
        redisTemplate.boundListOps("listKey").rightPush("element2");

        List<String> list =   redisTemplate.opsForList().range("listKey",0,-1);
        System.out.println(list);

        //其他的数据接口方式不再演示
        //hash
        redisTemplate.opsForHash().put("hash","key1","values");
         //set
        redisTemplate.opsForSet().add("set","set1","set2");
        //HyperLogLog
        redisTemplate.opsForHyperLogLog().add("hyper","123");
        //zset
        redisTemplate.opsForZSet().add("zset","number1",1);


        //使用RedisCallback 接口来操作数据
        redisTemplate.execute(new RedisCallback() {
            @Override
            public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
                Long size = redisConnection.dbSize();
                //直接使用StringRedisConnection连接实例来操作数据
                StringRedisConnection connection =  (StringRedisConnection) redisConnection;
                connection.set("key","value");
                return null;
            }
        });
        //HashMapping  对象和map互相转换
        Person person = new Person();
        person.setFirstname("sun");
        person.setLastname("kang");
        //写进redis
        writeHash("person",person,redisTemplate);
        //从reids获取数据
        Person person1 =   loadHash("person",redisTemplate);
        System.out.println(person1);

        //使用pipeline
        redisTemplate.executePipelined(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                StringRedisConnection stringRedisConn = (StringRedisConnection)connection;
                for(int i=0; i< 10; i++) {
                    stringRedisConn.lPush("myqueue",i+"");
                }
                return null;
            }
        });

        //其他的方式可以参考官网，这里不再一一介绍
    }

    public static void writeHash(String key, Person person,RedisTemplate redisTemplate) {
        HashMapper<Person, String, String > mapper = new PersonHashMapper();
        //把person 转换成mapper
        Map<String,String> map =  mapper.toHash(person);
        redisTemplate.opsForHash().putAll(key,map);
    }

    public static Person loadHash(String key,RedisTemplate redisTemplate) {
        Map<String, String> loadedHash =  redisTemplate.opsForHash().entries(key);
        HashMapper<Person, String, String > mapper = new PersonHashMapper();
        //把map 转成person实体
        Person person =   mapper.fromHash(loadedHash);
        return person;
    }
}

在需要存在实体的时候，可以用mapper的结构来代替javabean的实体存储，就会涉及到map到entity的转换过程，所以还需要一个HashMapper实体来转换mapper与实体的关系。还需要一个具体的实体类

• PersonHashMapper 来转换实体与map对象

/**
 * @Project: redis
 * @description: 需要继承HashMapper 这个接口重写
 * @author: sunkang
 * @create: 2019-01-12 22:51
 * @ModificationHistory who      when       What
 **/
public class PersonHashMapper implements HashMapper<Person,String,String> {
    @Override
    public Map<String, String> toHash(Person person) {

        Map<String,String> map = new HashMap<String,String>();
        map.put("firstname",person.getFirstname());
        map.put("lastname",person.getLastname());

        return map;
    }

    @Override
    public Person fromHash(Map<String, String> map) {
        Person person = new Person();
        person.setFirstname( map.get("firstname"));
        person.setLastname( map.get("lastname"));
        return person;
    }
}

• person实体

/**
 * @Project: redis
 * @description:  person实体
 * @author: sunkang
 * @create: 2019-01-12 22:46
 * @ModificationHistory who      when       What
 **/
public class Person {
    private    String firstname;
    private   String lastname;

    public String getFirstname() {
        return firstname;
    }

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    @Override
    public String toString() {
        return "Person{" +
                "firstname='" + firstname + '\'' +
                ", lastname='" + lastname + '\'' +
                '}';
    }
}