Spring-data-redisインスタンス応用

17908 ワード
Redis
[b]spring-data-redisインスタンスアプリケーション[/b]
1.Spring FrameworkがJDBCをサポートしているのと同様に、RedisのKey-Valueデータストレージ操作に対してより高いレベルの抽象を提供します.
2.これを使わない場合は、redis接続の接続と閉じる操作を自分で行い、接続を閉じないため、慎重に閉じる必要があります.
多すぎて(接続プール方式)接続できないほど
3.RedisTemplateはスレッドが安全である(spring-data-redisの操作インタフェース)
4.ObjectMapperはスレッドが安全(外部シーケンス化で使用)
[b]spring-data-redis Operations[/b]
Spring-data-redisはjedisに対して次の機能を提供します.
1.接続プールの自動管理、高度にカプセル化された「RedisTemplate」クラスを提供
2.jedisクライアントに大量のapiを分類してカプセル化し、同じタイプの操作をoperationインタフェースにカプセル化する
ValueOperations:簡単K-V操作
SetOperations:set型データ操作
ZSetOperations:zsetタイプデータ操作
HashOperations:mapタイプに対するデータ操作
ListOperations:listタイプに対するデータ操作
3.キーに対する「bound」(バインディング)操作を容易化するAPIを提供し、指定したキーをboundでカプセル化し、「明示的」に再びキーを指定することなく一連の操作を行うことができる.
BoundValueOperations
BoundSetOperations
BoundListOperations
BoundSetOperations
BoundHashOperations
両者の違いは、setを行うときにkey値を書く(複数のkeyの操作が可能)、1つは使わない(1つのkeyの操作しかできない)ことです.
ValueOperations valueOper = redisTemplate.opsForValue(); //      ValueOperations

[b]Spring-data-redis:serializer(シーケンス化方式)[/b]
シーケンス化の設定(内蔵でも別でも構いません)
Spring-data-redisは、jedisを使用する開発者にとって非常に便利なserializerポリシーを提供しています.sdrは4種類の内蔵serializerを提供しています.
1.Jdk SerializationRedisSerializer:JDKのシーケンス化手段(serializableインタフェース、ObjectInputStrean、ObjectOutputStream)を使用して、データをバイトストリームで格納する
2.StringRedisSerializer:文字列符号化、データはstringで格納
3.JacksonJsonRedisSerializer:json形式ストレージ
4.OxmSerializer:xml形式ストレージ
[b]注意:[/b]
1.ここで、JdkSerializationRedisSerializerおよびStringRedisSerializerは最も基本的なシーケンス化戦略である.
2.「JacksonJsonRedisSerializer」と「OxmSerializer」はstirngストレージに基づいているため、それらは比較的「高度」なシーケンス化(最終的にはstring解析およびjavaオブジェクトの構築)である.
RedisTemplateでは4種類のserializerを宣言する必要があります.デフォルトは「J d k SerializationRedisSerializer」です.
1)keySerializer:通常のK-V操作時にkeyがとるシーケンス化戦略
2)valueSerializer:valueによるシーケンス化戦略
3)hashKeySerializer:hashデータ構造におけるhash-keyのシーケンス化ポリシー
4)hashValueSerializer:hash-valueのシーケンス化ポリシー
[b]注意:[/b]いずれにしても、key/hashKeyはStringRedisSerializerを採用することを推奨します.
[b]例:[/b]
redis.properties 
# Redis settings
redis.host=127.0.0.1
redis.port=6379
redis.pass=

redis.maxIdle=300
redis.maxTotal=600
redis.maxWaitMillis=1000
redis.testOnBorrow=true

applicationContext.xml 

	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"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	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">


	
	
	

	
	
		
		
		
		
	

			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" />

	
		
		
							class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		
		
							class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />

User.java 
package com.redis;
import java.io.Serializable;

public class User implements Serializable{
	private static final long serialVersionUID = 1L;
	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;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}

	public User(long id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public User() {
		super();
		// TODO Auto-generated constructor stub
	}
}

[b]内部JdkSerializationRedisSerializerツールによるシーケンス化[/b]
main 
package com.redis;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

public class SpringDataRedisTest {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");
		System.out.println("redisTemplate == " + redisTemplate);

		ValueOperations valueOper = redisTemplate.opsForValue();
		User u1 = new User(10, "zhangsan");
		User u2 = new User(11, "lisi");
		valueOper.set("u:u1", u1);
		valueOper.set("u:u2", u2);

		User User = valueOper.get("u:u1");
		System.out.println("User == " + User.toString());
		User User2 = valueOper.get("u:u2");
		System.out.println("User2 == " + User2.toString());
	}
}

[b]外部jacksonツールによるシーケンス化[/b]
1.内部のシーケンス化ツールを使用してValueOperationsを作成するときにオブジェクトのClassTypeを指定するため、外部のシーケンス化ツールを使用してString(インタフェース統合)に基づいてすべてを作成できます.
ValueOperations valueOper = redisTemplate.opsForValue(); //      ValueOperations,   User

main 
package com.redis;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDataRedisOtherJsonTest {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisClientTest redisClientTest = (RedisClientTest) applicationContext.getBean("redisClientTest");
		System.out.println("redisClientTest == " + redisClientTest);

		User user1 = new User();
		user1.setId(21);
		user1.setName("obama21");
		redisClientTest.insertUser(user1);
		System.out.println("insertUser");

		User user2 = redisClientTest.getUser(21);
		System.out.println("user2 == " + user2.toString());

	}
}

JsonRedisSeriaziler.java 
package com.redis;
import java.io.IOException;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.stereotype.Service;

@Service("jsonRedisSeriaziler")
public class JsonRedisSeriaziler {
	private ObjectMapper objectMapper = new ObjectMapper();

	/**
	 * java-object as json-string
	 *
	 * @param object
	 * @return
	 */
	public String seriazileAsString(Object object) {
		if (object == null) {
			return null;
		}

		try {
			return this.objectMapper.writeValueAsString(object);
		} catch (JsonGenerationException e) {
			e.printStackTrace();
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * json-string to java-object
	 *
	 * @param str
	 * @return
	 */
	public  T deserializeAsObject(String str, Class clazz) {
		if (str == null || clazz == null) {
			return null;
		}
		try {
			return this.objectMapper.readValue(str, clazz);
		} catch (JsonParseException e) {
			e.printStackTrace();
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return null;
	}
}

RedisClientTest.java 
package com.redis;
import javax.annotation.Resource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

@Service("redisClientTest")
public class RedisClientTest {

	@Resource(name = "jsonRedisSeriaziler")
	private JsonRedisSeriaziler seriaziler;

	@Resource(name = "redisTemplate")
	private RedisTemplate redisTemplate;

	public void insertUser(User user) {
		ValueOperations operations = redisTemplate.opsForValue();
		operations.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
	}

	public User getUser(long id) {
		ValueOperations operations = redisTemplate.opsForValue();
		String json = operations.get("user:" + id);
		System.out.println("json ==" + json);
		return seriaziler.deserializeAsObject(json, User.class);
	}
}

参考原文:[url]http://shift-alt-ctrl.iteye.com/blog/1886831[/url]
[b]Spring-data-redisトランザクション[/b]
1.enableTransactionSupport:トランザクションサポートを有効にするかどうか.XMLファイルで構成するには(StringRedisTemplateのプロパティ)
2.enableTransactionSupportがtrueの場合、システムはトランザクションにバインドされた接続を自動的に取得します.1つの方法の複数回のRedisに対してこの検索を削除することができて、いつも同じ接続を使用します.
ただし、同じ接続を使用するもconnectionは行われていない.Multi()とconnection.exec()は、トランザクションを有効にできません.
3.sdrはSessionCallbackインタフェースを提供し、スレッドとのマルチオペレーション実行に使用する.(同じ接続)
非接続プール環境では、トランザクション操作;sdrの場合、get、setなどの操作のたびにpoolからconnectionが取得されます.
したがって、接続プール環境では、トランザクションの使用に注意する必要があります.
public void saveNoPoolUser(final User user) {
	redisTemplate.watch("user:" + user.getId());
	redisTemplate.multi();
	ValueOperations tvo = redisTemplate.opsForValue();
	tvo.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
	redisTemplate.exec();
}

接続プール環境では、セッションCallbackを使用して接続をバインドする必要があります.
public void savePoolUser(final User user) {
	SessionCallback sessionCallback = new SessionCallback() {
    @Override
    public User execute(RedisOperations operations) throws DataAccessException {
        operations.multi();
        String key = "user:" + user.getId();
        ValueOperations oper = operations.opsForValue();
        oper.set(key,seriaziler.seriazileAsString(user));
        operations.exec();
        return user;
    }
};
redisTemplate.execute(sessionCallback);
}

SpringDataRedisTransactional.java 
package com.redis;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDataRedisTransactional {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisClientTest redisClientTest = (RedisClientTest) applicationContext.getBean("redisClientTest");
		System.out.println("redisClientTest == " + redisClientTest);

		User user1 = new User();
		user1.setId(33);
		user1.setName("obama31 55");
		redisClientTest.savePoolUser(user1);
		System.out.println("insertUser");

		User user2 = redisClientTest.getUser(33);
		System.out.println("user2 == " + user2.toString());

	}
}

RedisClientTest.java 
package com.redis;
import javax.annotation.Resource;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("redisClientTest")
public class RedisClientTest {

	@Resource(name = "jsonRedisSeriaziler")
	private JsonRedisSeriaziler seriaziler;

	@Resource(name = "redisTemplate")
	private RedisTemplate redisTemplate;

	public void insertUser(User user) {
		ValueOperations operations = redisTemplate.opsForValue();
		operations.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
	}

	public User getUser(long id) {
		ValueOperations operations = redisTemplate.opsForValue();
		String json = operations.get("user:" + id);
		System.out.println("json ==" + json);
		return seriaziler.deserializeAsObject(json, User.class);
	}

	public void savePoolUser(final User user) {
		SessionCallback sessionCallback = new SessionCallback() {
			@Override
			public User execute(RedisOperations operations) throws DataAccessException {
				operations.multi();
				String key = "user:" + user.getId();
				ValueOperations oper = operations.opsForValue();
				oper.set(key, seriaziler.seriazileAsString(user));
				operations.exec();
				return user;
			}
		};
		redisTemplate.execute(sessionCallback);
	}

	public void saveNoPoolUser(final User user) {
		redisTemplate.watch("user:" + user.getId());
		redisTemplate.multi();
		ValueOperations tvo = redisTemplate.opsForValue();
		tvo.set("user:" + user.getId(), seriaziler.seriazileAsString(user));
		redisTemplate.exec();
	}
}

[b]Pipeline[/b]
1.コマンドをキャッシュし、その時点でredisサーバに1回のパッケージングで送信して処理する
2.pipeline方式で大量の操作がある場合、ネットワークでの遅延時間を多く節約でき、pipeline方式でコマンドをパッケージして送信することに注意する必要があります.
redisは、すべてのコマンドを処理する前に、すべてのコマンドの処理結果をキャッシュする必要があります.パッケージ化されたコマンドが多ければ多いほど、キャッシュのメモリ消費量も多くなります.だからパッケージのコマンドが多ければ多いほどいいわけではありません.
[b]数字が格納されている場合(もちろん値のシーケンス化はStringRedisSerializerで行う必要があります.そうでなければincrementでは使用できません)[/b]
package com.redis;

import java.io.Serializable;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

public class SpringDataRedisTestLong {
	public static void main(String[] args) throws InterruptedException {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");

		RedisTemplate redisTemplate = (RedisTemplate) applicationContext.getBean("redisTemplate");
		System.out.println("redisTemplate == " + redisTemplate);

		ValueOperations valueOper = redisTemplate.opsForValue();
		long i = 10245;
		valueOper.set("u:u53", String.valueOf(i));

		System.out.println("redisTemplate == 100");
		valueOper.increment("u:u53", 3L);//       
		System.out.println("redisTemplate == 100");

		String User = (String) valueOper.get("u:u53");
		System.out.println("User == " + User);

		long j =Long.parseLong(User);
		System.out.println("j == " + j);
	}
}

参考原文:[url]http://www.cnblogs.com/luochengqiuse/p/4640932.html[/b][/url]
参考原文:[url]http://shift-alt-ctrl.iteye.com/blog/1887370[/url]
参考原文:[url]http://shift-alt-ctrl.iteye.com/blog/1886831[/url]
原文(性能比較)参照:[url]http://blog.csdn.net/u010739551/article/details/48165063[/url]
[b]使用するjarパッケージは以下の通りです.
ASP.NET FormsAuthenticationサイト間ログイン時に絶対アドレスが返される問題
Scott MitchellのASP.NET 2.0データチュートリアルの42:データを削除するためにクライアント確認を追加する