java.lang.IllegalStateException: Failed to deserialize object type

这两天系统时不时的会报这个错误，具体的堆栈信息如下：

java.lang.IllegalStateException: Failed to deserialize object type
        at org.springframework.util.SerializationUtils.deserialize(SerializationUtils.java:75)
        at com.mljr.acs.msettle.core.utils.JedisUtil.get(JedisUtil.java:168)
        at com.xxxx.xxxx.xxxx.web.action.FundTransferBillAction.getCacheAccountList(FundTransferBillAction.java:179)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:498)
         .........................
         .........................
 Caused by: java.lang.ClassNotFoundException: com.xxxx.xxxxx.base.model.customized.FundTransferModel
        at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1332)
        at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1166)
        at java.lang.Class.forName0(Native Method)
        at java.lang.Class.forName(Class.java:348)
        at java.io.ObjectInputStream.resolveClass(ObjectInputStream.java:628)
        at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1620)
        at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
        at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1781)
        at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
        at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
        at org.springframework.util.SerializationUtils.deserialize(SerializationUtils.java:69)
        ... 77 common frames omitted

看到最后的堆栈信息，可以知道根本原因在于没有找到FundTransferModel这个类，看了下报错的代码行，代码是这样的：

FundTransferModel transferBean = (FundTransferModel) jedisUtil.get(allocationUseId);

代码的目的是从redis缓存中获取对象，但是对象的路径并不是错误信息中那个找不到的路径：

//报错类路径
com.xxxx.xxxxx.base.model.customized.FundTransferModel

//实际路径
com.mljr.xxxx.xxxx.core.apps.base.model.customized.FundTransferModel

因为之前服务做过一次优化，重新调整了类路径，调整前的路径确实是报错的那个路径。

所以原因在于：
保存到redis中的对象是以报错类路径保存的，因为没有设置过超时时间，调整了类路径后，重新取出时转类型时就有问题了。后来把相关缓存内容清掉，重新写入了一次，之后就恢复正常了。

下面看下redis写入的实现：

private JedisPool pool ;

/**
 *最大连接数
 */
public static final int CONFIG_MAX_ACTIVE = 500;

/**
  * 最大空闲连接数，-1 表示无限制
  */
 public static final int CONFIG_MAX_IDLE = -1;

/**
 * 取一个连接的最长阻塞时间, milliseconds. 此处设置为10秒
 */
 public static final int CONFIG_MAX_WAITE_MILLISECOND = 1000; // 10 seconds.

//redis 连接池相关参数配置
private Jedis getJedis() {
	if (pool == null) {
		config = new JedisPoolConfig();
		config.setMaxTotal(CONFIG_MAX_ACTIVE);
		config.setMaxIdle(CONFIG_MAX_IDLE);
		config.setMaxWaitMillis(CONFIG_MAX_WAITE_MILLISECOND);
		config.setBlockWhenExhausted(false);
		JedisPool pool = new JedisPool(config, host, port, timeout, password);
		}
	jedis = pool.getResource();
	return jedis;
 }

//存储对象
public void setex(String key, Object object, int seconds) {
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            jedis.setex(key.getBytes(), seconds, SerializationUtils.serialize(object));
        } catch (Exception e) {
            logger.error("#设置缓存对象时发生错误", e);
        } finally{
            releaseJedis(jedis);
        }
    }
    
//获取缓存对象
public Object get(String key) {
        Jedis jedis = null;
        try {
            jedis = this.getJedis();
            return  SerializationUtils.deserialize(jedis.get(key.getBytes()));
        } catch (Exception e) {
            logger.error("#获取缓存对象时发生错误", e);
            return null;
        } finally{
            releaseJedis(jedis);
        }
    }

在存储前，用了序列化工具类对对象进行序列化然后存储，取出的时候再进行一次反序列化，序列化的工具类是Spring提供的工具类，实现如下所示：
SerializationUtils.java

public abstract class SerializationUtils {

	/**
	 * Serialize the given object to a byte array.
	 * @param object the object to serialize
	 * @return an array of bytes representing the object in a portable fashion
	 */
	@Nullable
	public static byte[] serialize(@Nullable Object object) {
		if (object == null) {
			return null;
		}
		ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
		try {
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(object);
			oos.flush();
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Failed to serialize object of type: " + object.getClass(), ex);
		}
		return baos.toByteArray();
	}

	/**
	 * Deserialize the byte array into an object.
	 * @param bytes a serialized object
	 * @return the result of deserializing the bytes
	 */
	@Nullable
	public static Object deserialize(@Nullable byte[] bytes) {
		if (bytes == null) {
			return null;
		}
		try {
			ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
			return ois.readObject();
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Failed to deserialize object", ex);
		}
		catch (ClassNotFoundException ex) {
			throw new IllegalStateException("Failed to deserialize object type", ex);
		}
	}

}

就是用 ByteArrayOutputStream 写做了序列化，用ByteArrayInputStream读做了反序列化，进入 ois.readObject() 查看读取对象的过程：

/**
     * Read an object from the ObjectInputStream.  The class of the object, the
     * signature of the class, and the values of the non-transient and
     * non-static fields of the class and all of its supertypes are read.
     * Default deserializing for a class can be overridden using the writeObject
     * and readObject methods.  Objects referenced by this object are read
     * transitively so that a complete equivalent graph of objects is
     * reconstructed by readObject.
     * 
     * 注释含义：
     * 从ObjectInputStream读取一个对象。
     * 对象所属类，类的签名，所有非transient修饰的变量，以及超类的相关信息都会被读取。
     * 类的默认的反序列化方法可以使用writeObject 和 readObject 方法覆盖。
     * 被该对象引用的对象能够等价的被readObject重构。
     *
     * <p>The root object is completely restored when all of its fields and the
     * objects it references are completely restored.  At this point the object
     * validation callbacks are executed in order based on their registered
     * priorities. The callbacks are registered by objects (in the readObject
     * special methods) as they are individually restored.
     *
     * <p>Exceptions are thrown for problems with the InputStream and for
     * classes that should not be deserialized.  All exceptions are fatal to
     * the InputStream and leave it in an indeterminate state; it is up to the
     * caller to ignore or recover the stream state.
     *
     * @throws  ClassNotFoundException Class of a serialized object cannot be
     *          found.
     * @throws  InvalidClassException Something is wrong with a class used by
     *          serialization.
     * @throws  StreamCorruptedException Control information in the
     *          stream is inconsistent.
     * @throws  OptionalDataException Primitive data was found in the
     *          stream instead of objects.
     * @throws  IOException Any of the usual Input/Output related exceptions.
     */
    public final Object readObject()
        throws IOException, ClassNotFoundException
    {
        if (enableOverride) {
            return readObjectOverride();
        }

        // if nested read, passHandle contains handle of enclosing object
        int outerHandle = passHandle;
        try {
            Object obj = readObject0(false);
            handles.markDependency(outerHandle, passHandle);
            ClassNotFoundException ex = handles.lookupException(passHandle);
            if (ex != null) {
                throw ex;
            }
            if (depth == 0) {
                vlist.doCallbacks();
            }
            return obj;
        } finally {
            passHandle = outerHandle;
            if (closed && depth == 0) {
                clear();
            }
        }
    }

由第一段注释可知，在反序列化的时候，即 readObject 时，不只会读取对象的所有属性字段，对象的类信息和超类信息也会被读取。改造前后的对象（FundTransferModel）的属性值虽然相同，但是类信息是不同的，所以在转换类型的时候就会抛出 ClassNotFoundException 异常。

总结：
redis 存储信息时，如果只保留对象的部分信息，尽量不要保存对象本身。如需保存对象所有数据，可以保存对象的JSON串。上面的问题，如果是保存的JSON串，在读取的时候是不会关注对象的类信息的。