spring boot定制Jackson ObjectMapper，為什么不生效

先說結論：

項目中定制了spring 的redisTemplate，而這個template沒有使用我自定義的Jackson ObjectMapper。所以不生效。

 

下面是詳細過程：

起因是spring boot項目加入了shiro，我打算使用redis去存儲shiro的會話，方便以后橫向擴展。

參考了網上的實現后，決定通過擴展org.apache.shiro.session.mgt.eis.AbstractSessionDAO來實現。

以下是實現代碼：

package com.ceiec.baseplatform.config;

import com.ceiec.baseplatform.redis.StringKeyRedisTemplate;
import org.apache.commons.collections.CollectionUtils;
import org.apache.shiro.session.Session;
import org.apache.shiro.session.UnknownSessionException;
import org.apache.shiro.session.mgt.eis.AbstractSessionDAO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.Collection;
import java.util.concurrent.TimeUnit;

@Component
public class RedisSessionDAO extends AbstractSessionDAO {
    private static Logger logger = LoggerFactory.getLogger(RedisSessionDAO.class);

    @SuppressWarnings("rawtypes")
    @Autowired
    private StringKeyRedisTemplate<String, Object> redisTemplate;

    private static final String DEFAULT_SESSION_KEY_PREFIX = "shirosession:";

    private String keyPrefix = DEFAULT_SESSION_KEY_PREFIX;

    private long expireTime = 120000;

    public RedisSessionDAO() {
        super();
    }

    public RedisSessionDAO(long expireTime) {
        super();
        this.expireTime = expireTime;
    }

    @Override // 更新session
    public void update(Session session) throws UnknownSessionException {
        System.out.println("===============update================");
        if (session == null || session.getId() == null) {
            return;
        }
        session.setTimeout(expireTime);
        String key = getKey(session);
        redisTemplate.opsForValue().set(key, session, expireTime, TimeUnit.MILLISECONDS);
    }

    private String getKey(Session session) {
        return this.keyPrefix + String.valueOf(session.getId());
    }
    private String getSessionIdKey(String sessionId) {
        return this.keyPrefix + String.valueOf(sessionId);
    }

    @Override // 刪除session
    public void delete(Session session) {
        System.out.println("===============delete================");
        if (null == session) {
            return;
        }
        redisTemplate.opsForValue().getOperations().delete(getKey(session));
    }

    @Override
// 獲取活躍的session，可以用來統計在線人數，如果要實現這個功能，可以在將session加入redis時指定一個session前綴，統計的時候則使用keys("session-prefix*")的方式來模糊查找redis中所有的session集合
    public Collection<Session> getActiveSessions() {
//        System.out.println("==============getActiveSessions=================");
//        return redisTemplate.keys("*");
        return CollectionUtils.EMPTY_COLLECTION;
    }

    @Override// 加入session
    protected Serializable doCreate(Session session) {
        System.out.println("===============doCreate================");
        Serializable sessionId = this.generateSessionId(session);
        this.assignSessionId(session, sessionId);

        redisTemplate.opsForValue().set(getKey(session), session, expireTime, TimeUnit.MILLISECONDS);
        return sessionId;
    }

    @Override// 讀取session
    protected Session doReadSession(Serializable sessionId) {
        System.out.println("==============doReadSession=================");
        if (sessionId == null) {
            return null;
        }
        return (Session) redisTemplate.opsForValue().get(getSessionIdKey(String.valueOf(sessionId)));
    }

    public long getExpireTime() {
        return expireTime;
    }

    public void setExpireTime(long expireTime) {
        this.expireTime = expireTime;
    }


}

然后將該RedisSessionDao注冊到sessionManager等，這個不在本文范圍內，有興趣可搜索相關shiro配置。

    @Autowired
    private RedisSessionDAO redisSessionDAO;
   
    @Bean
    public SecurityManager securityManager(){
        DefaultWebSecurityManager securityManager =  new DefaultWebSecurityManager();
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionDAO(redisSessionDAO);
        securityManager.setSessionManager(sessionManager);
        //設置realm.
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

 

一切看起來不錯。運行，登錄，然后，報錯了。

現在不太能重現那個錯誤，大概是，登錄時，會把org.apache.shiro.session.mgt.SimpleSession的實例寫入到redis。

其中有一個方法如下：

/**
 * @since 0.9
 */
public boolean isValid() {
    return !isStopped() && !isExpired();
}
序列化時，會序列化一個valid：true的屬性到json中。

 

而在后續讀會話時，會反序列化session。然后報錯，提示不認識valid屬性。

於是在網上查詢spring boot如何定制objectMapper去忽略不認識的屬性，

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

按照網上說法和文檔，如果只要替換ObjectMapper的話，只要按照下面說的這樣去定義一個@Bean和@Primary標注的class。

但是在按照上述方法去配置后，發現沒有效果。

后邊想了很久。。。。突然發現自己的項目中，因為不想用jdk的序列化器，所以自定義了

Spring的RedisTemplate，去使用jackson的序列化器。
而這個template中可能沒有使用我自定義的ObjectMapper。

后邊發現，果然如此。
然后修改后如下：

package com.ceiec.baseplatform.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.DefaultStringRedisConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * desc: redis操作類
 * @author: 
 * creat_date: 2018/1/4
 * creat_time: 17:18
 **/
@Component
public class StringKeyRedisTemplate<K, V> extends RedisTemplate<K, V> {


    /**
     * Constructs a new <code>StringRedisTemplate</code> instance. {@link #setConnectionFactory(RedisConnectionFactory)}
     * and {@link #afterPropertiesSet()} still need to be called.
     */
    public StringKeyRedisTemplate() {

    }

    /**
     * Constructs a new <code>StringRedisTemplate</code> instance ready to be used.
     *
     * @param connectionFactory connection factory for creating new connections
     */
    @Autowired
    public StringKeyRedisTemplate(RedisConnectionFactory connectionFactory) {
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        //設置key序列化器
        setKeySerializer(stringSerializer);
        setHashKeySerializer(stringSerializer);
        //設置value的序列化器
        ObjectMapper mapper = jacksonObjectMapper();
        setValueSerializer(new GenericJackson2JsonRedisSerializer(mapper));
        setHashValueSerializer(new GenericJackson2JsonRedisSerializer(mapper));

        setConnectionFactory(connectionFactory);
        afterPropertiesSet();
    }

    @Override
    protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        return new DefaultStringRedisConnection(connection);
    }

    public ObjectMapper jacksonObjectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        
        logger.info("construct complete! " + objectMapper);
        return objectMapper;
    }
}