Redis 讲解系列之与Spring集成(一)

水深无声 2022-06-07 10:23 139阅读 0赞

## **Redis 讲解系列之 与Spring集成(一)** ##

本章我们将实例讲解Redis如何与Spring整合。由于Redis与Spring的整合手段比较多，本章将着重讲解Spring与Spring-data-redis整合。

--------------------

## **实例** ##

*  新建Maven web项目，并将指定build path source folder。
    
     *  项目结构
        
        ![这里写图片描述][SouthEast]
 *  Customize build path source folder。
    
    ![这里写图片描述][SouthEast 1]
 *  文件代码
    
     *  pom.xml
        
            <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.sstps.oscar</groupId>
                <artifactId>Template2</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            
            
                <properties>
                    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                </properties>
            
                <dependencies>
                    <dependency>
                        <groupId>org.springframework.data</groupId>
                        <artifactId>spring-data-redis</artifactId>
                        <version>1.0.2.RELEASE</version>
                    </dependency>
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-core</artifactId>
                        <version>3.1.2.RELEASE</version>
                    </dependency>
            
            
                    <dependency>
                        <groupId>redis.clients</groupId>
                        <artifactId>jedis</artifactId>
                        <version>2.1.0</version>
                    </dependency>
                    
                    <dependency>
                        <groupId>commons-logging</groupId>
                        <artifactId>commons-logging</artifactId>
                        <version>1.1.1</version>
                        <scope>provided</scope>
                    </dependency>
                </dependencies>
            </project>
     *  redis.properties
        
            redis.host=127.0.0.1
            redis.port=6379
            redis.pass=wljr
            redis.timeout=3000
            redis.maxIdle=300
            redis.maxActive=600
            redis.maxWait=1000
            redis.testOnBorrow=true
     *  AplicationContext.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: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-3.1.xsd">
            
                <context:property-placeholder location="classpath:redis.properties" />
                <context:component-scan base-package="com.x.redis.dao">
                </context:component-scan>
                <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
                    <property name="maxIdle" value="${redis.maxIdle}" />
                    <property name="maxActive" value="${redis.maxActive}" />
                    <property name="maxWait" value="${redis.maxWait}" />
                    <property name="testOnBorrow" value="${redis.testOnBorrow}" />
                </bean>
            
            
                <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
                    <property name="hostName" value="${redis.host}"></property>
                    <property name="port" value="${redis.port}"></property>
                    <property name="password" value="${redis.pass}"></property>
                    <property name="timeout" value="${redis.timeout}"></property>
                </bean>
            
                <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
                    <property name="connectionFactory" ref="connectionFactory" />
                </bean>
            
                <bean id="userDAO" class="com.x.redis.dao.imp.UserDAOImpl" />
            </beans>
     *  UserDao.java
        
            package com.x.redis.dao;
            
            import com.x.redis.pojo.User;
            
            public interface UserDao { 
                public void saveUser(final User user);
                 public User getUser(final long id);
            
            }
     *  User.java
        
            package com.x.redis.pojo;
            
            public class User {
            
                private long id;
                private String name;
            
                public long getId() {
                    return id;
                }
            
                public void setId(long id) {
                    this.id = id;
                }
            
                public String getName() {
                    return name;
                }
            
                public void setName(String name) {
                    this.name = name;
                }
            }
     *  UserDaoImpl.java
        
            package com.x.redis.dao.imp;
            
            import java.io.Serializable;
            
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.dao.DataAccessException;
            import org.springframework.data.redis.connection.RedisConnection;
            import org.springframework.data.redis.core.RedisCallback;
            import org.springframework.data.redis.core.RedisTemplate;
            
            import com.x.redis.dao.UserDao;
            import com.x.redis.pojo.User;
            
            public class UserDAOImpl implements UserDao { 
            
                    public void saveUser(final User user) {
                        redisTemplate.execute(new RedisCallback<Object>() {
            
                            @Override
                            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                                connection.set(redisTemplate.getStringSerializer().serialize("user.uid." + user.getId()),
                                               redisTemplate.getStringSerializer().serialize(user.getName()));
                                return null;
                            }
                        });
                    }
            
                    @Override
                    public User getUser(final long id) {
                        return redisTemplate.execute(new RedisCallback<User>() {
                            @Override
                            public User doInRedis(RedisConnection connection) throws DataAccessException {
                                byte[] key = redisTemplate.getStringSerializer().serialize("user.uid." + id);
                                if (connection.exists(key)) {
                                    byte[] value = connection.get(key);
                                    String name = redisTemplate.getStringSerializer().deserialize(value);
                                    User user = new User();
                                    user.setName(name);
                                    user.setId(id);
                                    return user;
                                }
                                return null;
                            }
                        });
                    }
            
            }
     *  Template.java
        
            package com.x.redis.template;
            
            import org.springframework.context.ApplicationContext;
            import org.springframework.context.support.ClassPathXmlApplicationContext;
            
            import com.x.redis.dao.imp.UserDAOImpl;
            import com.x.redis.pojo.User;
            
            public class Temolate {
            
                public static void main(String[] args) {
                    ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:/AplicationContex.xml");
                    UserDAOImpl userDAOImpl = (UserDAOImpl) ac.getBean("userDAO");
                    User user1 = new User();
                    user1.setId(1);
                    user1.setName("Hi~Redis");
                    userDAOImpl.saveUser(user1);
                    User user2 = userDAOImpl.getUser(1);
                    System.out.println(user2.getName());
                }
            }
 *  运行结果：
    
    ![这里写图片描述][SouthEast 2]

--------------------

## **总结** ##

总的来说Spring+Spring-data-redis整合算是一种比较官方比较主流的方式，下面我们总结一下Spring+Spring-data-redis整合的优缺点：

*  缺点
    
     *  对Jedispool的封装过于完美以至于当完美需要灵活使用jedispool的时候无法自定义。
     *  RedisCliTemplate想对较复杂，而且每次要获得RedisClientTemplate有需要RedisConnection的协助，这点在UserDaoImpl.java的两个方法中提现地尤为突出。
     *  …..
 *  优点
    
     *  配置优雅，封装集成度高。
     *  ….

--------------------

## **本章实例获取链接** ##

Spring+Spring-data-redis整合例子：[http://pan.baidu.com/s/1boIIYth][http_pan.baidu.com_s_1boIIYth]

[SouthEast]: /images/20220607/f0b0d1c51016473cb67b6d59e653b787.png
[SouthEast 1]: /images/20220607/ee9ffbf789a84fbea19c384f9f886864.png
[SouthEast 2]: /images/20220607/7613f4948a854d6d91a25f1e5a974d2f.png
[http_pan.baidu.com_s_1boIIYth]: http://pan.baidu.com/s/1boIIYth