項目中需要兩個不同的web項目互相訪問，用戶對象為同一個User。決定用Redis來存儲用戶對象信息。。。ok，環境搭建開始：
1.pom.xml引入Redis依賴的jar:
<!-- jedis -->
<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.7.3</version>
</dependency>
2.新建 spring-redis.xml ：
<!-- 配置JedisPoolConfig實例 -->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="maxTotal" value="${redis.maxActive}" />
<property name="maxWaitMillis" value="${redis.maxWait}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
</bean>
<!-- 配置JedisConnectionFactory -->
<bean id="jedisConnectionFactory" 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.pass}"/> -->
<property name="database" value="${redis.dbIndex}"/>
<property name="poolConfig" ref="poolConfig"/>
</bean>
<!-- 配置RedisTemplate -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory"/>
</bean>
3.新建 redis.properties:
redis.host=192.168.152.129（redis部署所在的服務器地址） redis.port=6379 redis.maxIdle=100 redis.maxActive=300 redis.maxWait=1000 redis.testOnBorrow=true redis.dbIndex=0
4.在Spring總的配置文件中將spring-redis.xml include進去（用過spring的人都知道怎么做吧。。。）
5.新建Redis操作工具類（里面的方法可以自己擴充）：
package com.odao.utils.redis;
import java.io.UnsupportedEncodingException;
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.Component;
/**
*
* @author wangfj
*
*/
@Component
public class RedisUtils {
private static String redisCode = "utf-8";
@Autowired
private RedisTemplate redisTemplate;
/**
* @param key
*/
public long del(final String... keys) {
return (Long) 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 (String) 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 key
* @return
*/
public boolean exists(final String key) {
return (Boolean) redisTemplate.execute(new RedisCallback() {
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
return connection.exists(key.getBytes());
}
});
}
/**
* @return
*/
public String flushDB() {
return (String) redisTemplate.execute(new RedisCallback() {
public String doInRedis(RedisConnection connection) throws DataAccessException {
connection.flushDb();
return "ok";
}
});
}
/**
* @return
*/
public long dbSize() {
return (Long) redisTemplate.execute(new RedisCallback() {
public Long doInRedis(RedisConnection connection) throws DataAccessException {
return connection.dbSize();
}
});
}
/**
* @return
*/
public String ping() {
return (String) redisTemplate.execute(new RedisCallback() {
public String doInRedis(RedisConnection connection) throws DataAccessException {
return connection.ping();
}
});
}
}
6.新建對象序列化工具類：
package com.odao.utils.common.config;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
*
* @author wangfj
*
*/
public class SerializeUtil {
//序列化對象
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
}catch (Exception e) {
e.printStackTrace();
}
return null;
}
//反序列化對象
public static Object unserialize( byte[] bytes) {
ByteArrayInputStream bais = null;
try {
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
7.登錄時，將用戶對象存到Redis（做測試，用的超時時間為1分鍾）：
redisUtils.set("userInfo".getBytes(), SerializeUtil.serialize(user),60);
8.做了一個測試類：
public static void main(String[] args){
Jedis jedis = new Jedis("192.168.152.129",6379);
byte[] value = jedis.get("userInfo".getBytes());
if(value != null){
Object object = SerializeUtil.unserialize(value);
if(object != null){
User user = (User)object;
System.out.println(user.getUserName()+"=="+user.getPassword());
}
}
}
運行結果：
wangfj==1c29b046d2723c5939fcaca89da2857b
總結：既然用戶對象已經存儲到了Redis中，那么我們只需要在每個項目中加一個跳轉另一個系統的鏈接（登錄鏈接）
將Redis中的這個用戶的key傳過去，然后再被跳轉的項目中
通過Redis拿一次用戶信息，就能得到一個項目登錄，跳轉另一個項目就自動登錄的效果了。