spring data redis RedisTemplate操作redis相關用法


http://blog.mkfree.com/posts/515835d1975a30cc561dc35d

spring-data-redis API:http://docs.spring.io/spring-data/redis/docs/1.5.1.RELEASE/api/

 

 

首先跟大家道歉,為什么呢?在不久之前,寫了一篇http://blog.mkfree.com/posts/12,簡單地使用是沒有問題的,但如果在並發量高的時候,問題就會慢慢出現了,是什么問題呢?

當在高並發的情況下,向redis發出請求,每次操作都新建了一個連接,並且調用了一次連接就不釋放也不重新使用,沒有做連接池,雖然Redis的服務端,有一個機制是當客戶端過一些時間沒有操作時就關閉客戶端連接。
這樣有兩個缺點:
1.在一定時間內,客戶端連接數太多,在關閉連接時,也是非常消耗性能
2.達到一定的連接數時,服務端直接報錯,連接數過多

經測試總結到以上兩個問題.那應該怎么辦呢?
其實,客戶端連接可以放到一個連接池里,用完了,放回到連接池中,這樣可以重復調用。。這樣就可以限制一定數理的連接數,並且性能方面也優化了。。。后來我在官方上看到了spring data redis RedisTemplate,它封裝了redis連接池管理的邏輯,業務代碼無須關心獲取,釋放連接邏輯;spring redis同時支持了Jedis,Jredis,rjc 客戶端操作;

下面就來看看具體的程序代碼:

我首先定義了一些操作接口,我為了方便使用,重新封裝下RedisTemplate.

RedisService 想要更多的操作自己在接口里添加啦

package com.mkfree.framework.common.redis;

import java.util.Set;

/**
 * redis 的操作開放接口
 * 
 * @author hk
 * 
 *         2013-3-31 下午7:25:42
 */
public interface RedisService {

    /**
     * 通過key刪除
     * 
     * @param key
     */
    public abstract long del(String... keys);

    /**
     * 添加key value 並且設置存活時間(byte)
     * 
     * @param key
     * @param value
     * @param liveTime
     */
    public abstract void set(byte[] key, byte[] value, long liveTime);

    /**
     * 添加key value 並且設置存活時間
     * 
     * @param key
     * @param value
     * @param liveTime
     *            單位秒
     */
    public abstract void set(String key, String value, long liveTime);

    /**
     * 添加key value
     * 
     * @param key
     * @param value
     */
    public abstract void set(String key, String value);

    /**
     * 添加key value (字節)(序列化)
     * 
     * @param key
     * @param value
     */
    public abstract void set(byte[] key, byte[] value);

    /**
     * 獲取redis value (String)
     * 
     * @param key
     * @return
     */
    public abstract String get(String key);

    /**
     * 通過正則匹配keys
     * 
     * @param pattern
     * @return
     */
    public abstract Setkeys(String pattern);

    /**
     * 檢查key是否已經存在
     * 
     * @param key
     * @return
     */
    public abstract boolean exists(String key);

    /**
     * 清空redis 所有數據
     * 
     * @return
     */
    public abstract String flushDB();

    /**
     * 查看redis里有多少數據
     */
    public abstract long dbSize();

    /**
     * 檢查是否連接成功
     * 
     * @return
     */
    public abstract String ping();

}

RedisServiceImpl 接口實現類

package com.mkfree.framework.common.redis;

import java.io.UnsupportedEncodingException;
import java.util.Set;

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 org.springframework.stereotype.Service;

/**
 * 封裝redis 緩存服務器服務接口
 * 
 * @author hk
 * 
 *         2012-12-16 上午3:09:18
 */
@Service(value = "redisService")
public class RedisServiceImpl implements RedisService {

    private static String redisCode = "utf-8";

    /**
     * @param key
     */
    public long del(final String... keys) {
        return redisTemplate.execute(new RedisCallback() {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                long result = 0;
                for (int i = 0; i < keys.length; i++) {
                    result = connection.del(keys[i].getBytes());
                }
                return result;
            }
        });
    }

    /**
     * @param key
     * @param value
     * @param liveTime
     */
    public void set(final byte[] key, final byte[] value, final long liveTime) {
        redisTemplate.execute(new RedisCallback() {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                connection.set(key, value);
                if (liveTime > 0) {
                    connection.expire(key, liveTime);
                }
                return 1L;
            }
        });
    }

    /**
     * @param key
     * @param value
     * @param liveTime
     */
    public void set(String key, String value, long liveTime) {
        this.set(key.getBytes(), value.getBytes(), liveTime);
    }

    /**
     * @param key
     * @param value
     */
    public void set(String key, String value) {
        this.set(key, value, 0L);
    }

    /**
     * @param key
     * @param value
     */
    public void set(byte[] key, byte[] value) {
        this.set(key, value, 0L);
    }

    /**
     * @param key
     * @return
     */
    public String get(final String key) {
        return redisTemplate.execute(new RedisCallback() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                try {
                    return new String(connection.get(key.getBytes()), redisCode);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                return "";
            }
        });
    }

    /**
     * @param pattern
     * @return
     */
    public Setkeys(String pattern) {
        return redisTemplate.keys(pattern);

    }

    /**
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.execute(new RedisCallback() {
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.exists(key.getBytes());
            }
        });
    }

    /**
     * @return
     */
    public String flushDB() {
        return redisTemplate.execute(new RedisCallback() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb();
                return "ok";
            }
        });
    }

    /**
     * @return
     */
    public long dbSize() {
        return redisTemplate.execute(new RedisCallback() {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        });
    }

    /**
     * @return
     */
    public String ping() {
        return redisTemplate.execute(new RedisCallback() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {

                return connection.ping();
            }
        });
    }

    private RedisServiceImpl() {

    }

    @Autowired
    private RedisTemplate<string, string=""> redisTemplate;

}

spring-context.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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">

	<!-- 掃描注解Bean -->
 	<context:component-scan base-package="com.mkfree.framework.common.redis">
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
	</context:component-scan>
	<!-- 初始化屬性文件 -->
	<bean id="propertyConfigurer" class="com.mkfree.framework.common.spring.MkfreePropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:config/project.properties</value>
			</list>
		</property>
	</bean>

	<!-- 配置redis 緩存服務器 -->
	<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="hostName" value="${redis.host}" />
		<property name="port" value="${redis.port}" />
		<!-- <property name="password" value="${redis.password}" /> -->
	</bean>
	<!-- redis操作模板 -->
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
	<property name="connectionFactory">
		<ref bean="connectionFactory"/>
	</property>
	</bean>
</beans>

 

最后就是簡單的測試用例了 RedisServiceTest

package com.mkfree.framework.common.redis;

import org.junit.Assert;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class RedisServiceTest {

    ApplicationContext app = new ClassPathXmlApplicationContext("classpath:spring/spring-context.xml");
    RedisService redisService = (RedisService) app.getBean("redisService");

    @Test
    public void del() {
        redisService.set("a1", "a1");
        long result = redisService.del("a1");
        Assert.assertEquals(1L, result);
    }

    @Test
    public void set() {
        redisService.set("a1", "a1");
    }

    @Test
    public void get() {
        redisService.set("a1", "a1");
        String result = redisService.get("a1");
        Assert.assertEquals("a1", result);
    }

}


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM