spring+redis实例（二）

这一篇redis实例是基于序列化储存-（写入对象，读取对象）

在spring+redis(一)中我们介绍了在spring中怎么去操作储存redis，基于string的储存，今天我们介绍一下redis基于序列化的储存。

平常在项目里面往数据库存贮的大多数是一个对象，因为我们好多都是面向对象开发。

下面的例子介绍了往redis数据库里面写入session对象：

1.既然是写入一个对象，我们肯定要有一个对象，下面是一个session class：

package com.lcc.api.dto.session;

import java.io.Serializable;

import java.util.Map;

public class MobileSessionInfo extends SessionInfo implements Serializable {

    private static final long serialVersionUID = -9170869913976089130L;

    private Map<String, String> emails;

    public Map<String, String> getEmails() {

        return emails;

    }

    public void setEmails(Map<String, String> emails) {

        this.emails = emails;

    }

    @Override

    public String toString() {

        return new StringBuilder().append("{emails: ").append(emails).append("}").toString();

    }

}

package com.lcc.api.dto.session;

import java.io.Serializable;

public abstract class SessionInfo implements Serializable {

    private static final long serialVersionUID = 6544973626519192604L;

    private String key;

    // timestamp

    private Long createdAt;

    // unit: second

    private Long expiryTime;

    public String getKey() {

        return key;

    }

    public void setKey(String key) {

        this.key = key;

    }

    public Long getCreatedAt() {

        return createdAt;

    }

    public void setCreatedAt(Long createdAt) {

        this.createdAt = createdAt;

    }

    public Long getExpiryTime() {

        return expiryTime;

    }

    public void setExpiryTime(Long expiryTime) {

        this.expiryTime = expiryTime;

    }

    @Override

    public String toString() {

        return new StringBuilder().append("{key: ").append(key).append(", createdAt: ").append(createdAt)

                .append(", expiryTime: ").append(expiryTime).append("}").toString();

    }

}

2.接下来写一个service去操作写入session对象:

package com.lcc.service.app.impl;

import com.lcc.api.dto.session.MobileSessionInfo;

import com.lcc.service.BaseAuthorityService;

import com.lcc.service.app.DeviceService;

import java.util.HashMap;

import java.util.Map;

public class DeviceServiceImpl implements DeviceService {

    private BaseAuthorityService authorityService;

    private Long expiryTime = 24*60*60L;

    public void setAuthorityService(BaseAuthorityService authorityService) {

        this.authorityService = authorityService;

    }

    public void setExpiryTime(Long expiryTime) {

        this.expiryTime = expiryTime;

    }

    @Override

    public void catchSession(String deviceId) {

        MobileSessionInfo session = new MobileSessionInfo();

            Map<String, String> emails = new HashMap<String, String>();

            session.setKey(deviceId);

            session.setEmails(emails);

            session.setExpiryTime(expiryTime);

            authorityService.saveSessionInfo(session);

        }

}

package com.lcc.service;

import com.lcc.domain.enums.SessionCacheMode;

import com.lcc.api.dto.session.SessionInfo;

public interface BaseAuthorityService {

    SessionInfo getSessionInfo(String sessionId);

    void saveSessionInfo(SessionInfo session);

    SessionCacheMode getCacheMode();

}

package com.lcc.api.domain.enums;

public enum SessionCacheMode {

    LOCAL(1), //

    REDIS(2);

    private Integer value;

    SessionCacheMode(Integer value) {

        this.value = value;

    }

    public Integer getValue() {

        return value;

    }

    public static SessionCacheMode fromValue(Integer value) {

        for (SessionCacheMode mode : values()) {

            if (mode.getValue() == value) {

                return mode;

            }

        }

        return null;

    }

}

package com.lcc.authority;

import com.google.common.collect.Maps;

import com.lcc.api.domain.enums.SessionCacheMode;

import com.lcc.api.dto.session.SessionInfo;

import com.lcc.logger.Logger;

import com.lcc.logger.LoggerFactory;

import com.lcc.service.BaseAuthorityService;

import org.joda.time.LocalDateTime;

import org.springframework.data.redis.core.RedisTemplate;

import java.util.Date;

import java.util.concurrent.ConcurrentMap;

import java.util.concurrent.TimeUnit;

public class AuthorityService implements BaseAuthorityService {

    private static final Logger LOGGER = LoggerFactory.getLogger(AuthorityService.class);

    private static final String CAHCE_MODE_KEY = "cache-mode";

    private RedisTemplate<String, SessionInfo> sessionTemplate;

    public void setSessionTemplate(RedisTemplate<String, SessionInfo> sessionTemplate) {

        this.sessionTemplate = sessionTemplate;

    }

    /**

     * session global attributes

     * <p>

     * default open redis session cache mode

     * </p>

     *

     */

    private static final ConcurrentMap<String, Object> BUCKETS = Maps.newConcurrentMap();

    static {

        BUCKETS.put(CAHCE_MODE_KEY, SessionCacheMode.REDIS);

    }

    @Override

    public SessionInfo getSessionInfo(String sessionId) {

        LOGGER.info("get session {}, cache mode {}", sessionId, getCacheMode());

        SessionInfo sessionInfo = null;

        try {

            sessionInfo = sessionTemplate.opsForValue().get(sessionId);

        } catch (Exception e) {

            LOGGER.error("get session from redis exception", e);

        }

        return sessionInfo;

    }

    @Override

    public void saveSessionInfo(SessionInfo session) {

        session.setCreatedAt(LocalDateTime.now().toDate().getTime());

        try {

            sessionTemplate.opsForValue().set(session.getKey(), session);

            sessionTemplate.expire(session.getKey(), session.getExpiryTime(), TimeUnit.SECONDS);

        } catch (Exception e) {

            LOGGER.error("H5 save session exception, open local cache mode", e);

        }

    }

    @Override

    public SessionCacheMode getCacheMode() {

        return (SessionCacheMode) BUCKETS.get(CAHCE_MODE_KEY);

    }

}

3.基本的java class搞定了，然后看下spring配置文件：

<bean class="org.springframework.data.redis.core.RedisTemplate"

          id="authorityCacheRedisJdkSerializationTemplate" p:connection-factory-ref="h5SessionRedisConnectionFactory">

        <property name="keySerializer">

            <bean

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

        </property>

        <property name="valueSerializer">

            <bean

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

        </property>

    </bean>

    <bean id="h5SessionRedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"

          p:host-name="${redis.session.host}" p:port="${redis.session.port}">

        <constructor-arg index="0" ref="jedisPoolConfig" />

    </bean>

    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">

        <property name="maxTotal" value="60"/>

        <property name="maxIdle" value="15"/>

        <property name="testOnBorrow" value="true"/>

    </bean>

<bean id="deviceService" class="com.opentrans.otms.service.xtt.impl.DeviceServiceImpl">

        <property name="authorityService" ref="authorityService" />

        <property name="expiryTime" value="${session.expiry.time}" />

    </bean>

<bean id="authorityService" class="com.opentrans.otms.authority.AuthorityService" >

        <property name="sessionTemplate" ref="authorityCacheRedisJdkSerializationTemplate" />

    </bean>

总结：redis序列化操作和文本操作最主要的区别是RedisTemplate里面两个属性的配置不同：

一个是keySerializer一个是valueSerializer(StringRedisSerializer|JdkSerializationRedisSerializer)

   <bean class="org.springframework.data.redis.core.RedisTemplate"

          id="truckkCacheRedisJdkSerializationTemplate" p:connection-factory-ref="truckCacheRedisConnectionFactory">

        <property name="keySerializer">

            <bean

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

        </property>

        <property name="valueSerializer">

            <bean

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

        </property>

    </bean>

    <bean class="org.springframework.data.redis.core.RedisTemplate"

          id="authorityCacheRedisJdkSerializationTemplate" p:connection-factory-ref="h5SessionRedisConnectionFactory">

        <property name="keySerializer">

            <bean

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

        </property>

        <property name="valueSerializer">

            <bean

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

        </property>

    </bean>