在对JavaBean做序列化时,我们可能在某些场景希望前后兼容性好一些。比如所有的javaBean都序列化后保存在数据库,用的时候需要反序列化创建。随着业务的发展,数据模型可能会进行变更,那么原来的数据进行反序列化时可能会遇到版本不一致的问题。作者在对drools的Fact建模时就遇到了类似问题。那么有没有一种兼容性比较好的序列化方案同时又不失javaBean的基础特性(getter和setter函数)呢?答案是肯定的。

  其实,简单来说,HashMap的序列化时兼容性应该是最好的,因为它就是简单的键值对,不需要版本的概念。但毕竟不是JavaBean对象,那么能不能融合着两者呢?哈哈,当然可以,废话不多说,先上代码。

 public abstract class AbstractBean implements Serializable {
protected HashMapWrapper internalHashMapData = null; public HashMapWrapper getInternalHashMapData() {
return internalHashMapData;
} public void setInternalHashMapData(HashMapWrapper internalHashMapData) {
this.internalHashMapData = internalHashMapData;
}
}

  AbstractBean这个抽象类,保护一个HashMapWrapper的字段,用来存储所有字段的数据。

 public class FirstJavaBean extends AbstractBean {
public String getName(){
return this.internalHashMapData.getString("name");
}
public void setName(String name){
this.internalHashMapData.setString("name",name);
}
}

  继承AbstractBean时,包含了一个name字段,要特别注意getter和setter的实现方式。都是通过internalHashMapData存取数据的。这样做可以把数据的存储和数据的接口解耦了。如果FirstJavaBean接口变更了,对数据存取没有任何影响,序列化时就可以消除版本不一致带来的问题了!这个方法还是非常巧妙的有没有。

  下面是对hashMap的简单封装,由于该封装后期不再变化,对序列化也不会有任何影响。

 public class HashMapWrapper implements Serializable {
private HashMap<String,Object> internalHashMap;
public HashMapWrapper(){
internalHashMap = new HashMap<String,Object>(0);
}
public void setInternalHashMap(HashMap<String,Object> hashMap){
this.internalHashMap = hashMap;
}
public HashMap<String,Object> getInternalHashMap(){
return this.internalHashMap;
} public BigDecimal getBigDecimal(String key){
return getBigDecimalOr(key,null);
}
public BigDecimal getBigDecimalOr(String key,BigDecimal defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof BigDecimal){
return (BigDecimal)value;
}else
return defaultValue;
} public void setBigDecimal(String key,BigDecimal value){
internalHashMap.put(key,value);
} public BigInteger getBigInteger(String key){
return getBigIntegerOr(key,null);
}
public BigInteger getBigIntegerOr(String key,BigInteger defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof BigInteger){
return (BigInteger)value;
}else
return defaultValue;
}
public void setBigInteger(String key,BigInteger value){
internalHashMap.put(key,value);
}
public Boolean getBooleanOr(String key,Boolean defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Boolean){
return (Boolean)value;
}else
return defaultValue;
}
public Boolean getBoolean(String key){
return getBooleanOr(key,null);
} public void setBoolean(String key,Boolean value){
internalHashMap.put(key,value);
}
public Byte getByte(String key){
return getByteOr(key,null);
}
public Byte getByteOr(String key,Byte defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Byte){
return (Byte)value;
}else
return defaultValue;
} public void setByte(String key,Byte value){
internalHashMap.put(key,value);
}
public Character getCharacterOr(String key,Character defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Character){
return (Character)value;
}else
return defaultValue;
}
public Character getCharacter(String key){
return getCharacterOr(key,null);
}
public void setCharacter(String key,Character value){
internalHashMap.put(key,value);
}
public Date getDateOr(String key, Date defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Date){
return (Date)value;
}else
return defaultValue;
}
public Date getDate(String key){
return getDateOr(key,null);
}
public void setDate(String key,Date value){
internalHashMap.put(key,value);
} public Double getDouble(String key){
return getDoubleOr(key,null);
}
public Double getDoubleOr(String key,Double defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Double){
return (Double)value;
}else
return defaultValue;
}
public void setDouble(String key,Double value){
internalHashMap.put(key,value);
}
public Float getFloatOr(String key,Float defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Float){
return (Float)value;
}else
return defaultValue;
}
public Float getFloat(String key){
return getFloatOr(key,null);
}
public void setFloat(String key,Float value){
internalHashMap.put(key,value);
}
public Integer getIntegerOr(String key,Integer defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Integer){
return (Integer)value;
}else
return defaultValue;
}
public Integer getInteger(String key){
return getIntegerOr(key,null);
}
public void setInteger(String key,Integer value){
internalHashMap.put(key,value);
}
public Long getLongOr(String key,Long defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Long){
return (Long)value;
}else
return defaultValue;
}
public Long getLong(String key){
return getLongOr(key,null);
}
public void setLong(String key,Long value){
internalHashMap.put(key,value);
}
public Short getShortOr(String key,Short defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Short){
return (Short)value;
}else
return defaultValue;
}
public Short getShort(String key){
return getShortOr(key,null);
}
public void setShort(String key,Short value){
internalHashMap.put(key,value);
}
public String getStringOr(String key,String defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof String){
return (String)value;
}else
return defaultValue;
}
public String getString(String key){
return getStringOr(key,null);
}
public void setString(String key,String value){
internalHashMap.put(key,value);
}
public boolean getBooleanValueOr(String key,boolean defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Boolean){
return (Boolean)value;
}else
return defaultValue;
}
public boolean getBooleanValue(String key){
return getBooleanValueOr(key,false);
}
public void setBooleanValue(String key,boolean value){
internalHashMap.put(key,value);
}
public byte getByteValueOr(String key,byte defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Byte){
return (Byte)value;
}else
return defaultValue;
}
public byte getByteValue(String key){
return getByteValueOr(key,(byte)0);
}
public void setByteValue(String key,byte value){
internalHashMap.put(key,value);
}
public char getCharValueOr(String key,char defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Character){
return (Character)value;
}else
return defaultValue;
}
public char getCharValue(String key){
return getCharValueOr(key,(char)0);
}
public void setCharValue(String key,char value){
internalHashMap.put(key,value);
}
public double getDoubleValueOr(String key,double defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Double){
return (Double)value;
}else
return defaultValue;
}
public double getDoubleValue(String key){
return getDoubleValueOr(key,0.0d);
}
public void setDoubleValue(String key,double value){
internalHashMap.put(key,value);
}
public float getFloatValueOr(String key,float defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Float){
return (Float)value;
}else
return defaultValue;
}
public float getFloatValue(String key){
return getFloatValueOr(key,0.0f);
}
public void setFloatValue(String key,float value){
internalHashMap.put(key,value);
}
public int getIntValueOr(String key,int defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Integer){
return (Integer)value;
}else
return defaultValue;
}
public int getIntValue(String key){
return getIntValueOr(key,0);
}
public void setIntValue(String key,int value){
internalHashMap.put(key,value);
}
public long getLongValueOr(String key,long defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Long){
return (Long)value;
}else
return defaultValue;
}
public long getLongValue(String key){
return getLongValueOr(key,0L);
}
public void setLongValue(String key,long value){
internalHashMap.put(key,value);
}
public short getShortValueOr(String key,short defaultValue){
Object value = internalHashMap.get(key);
if(value instanceof Short){
return (Short)value;
}else
return defaultValue;
}
public short getShortValue(String key){
return getShortValueOr(key,(short)0);
}
public void setShortValue(String key,short value){
internalHashMap.put(key,value);
}
public Object getObjectOr(String key,Object defaultValue){
Object value = internalHashMap.get(key);
if( value == null ){
return defaultValue;
}else {
return internalHashMap.get(key);
}
}
public Object getObject(String key){
return internalHashMap.get(key);
}
public void setObject(String key,Object value){
internalHashMap.put(key,value);
}
public <T> T getAsResultOr(String key,T defaultValue){
T value = (T) internalHashMap.get(key);
if(value == null){
return defaultValue;
}else {
return value;
}
}
public <T> T getAsResult(String key){
return (T) internalHashMap.get(key);
}
public <T> void setAsValue(String key,T value){
internalHashMap.put(key,value);
} public boolean getboolean(String key) {
return getBooleanValue(key);
}
public void setboolean(String key,boolean value){
setBooleanValue(key,value);
}
public byte getbyte(String key) {
return getByteValue(key);
}
public void setbyte(String key,byte value){
setByteValue(key,value);
}
public char getchar(String key) {
return getCharValue(key);
}
public void setchar(String key,char value){
setCharValue(key,value);
}
public double getdouble(String key) {
return getDoubleValue(key);
}
public void setdouble(String key,double value){
setDoubleValue(key,value);
}
public float getfloat(String key) {
return getFloatValue(key);
}
public void setfloat(String key,float value){
setFloatValue(key,value);
}
public int getint(String key) {
return getIntValue(key);
}
public void setint(String key,int value){
setIntValue(key,value);
}
public long getlong(String key) {
return getLongValue(key);
}
public void setlong(String key,long value){
setLongValue(key,value);
}
public short getshort(String key) {
return getShortValue(key);
}
public void setshort(String key,short value){
setShortValue(key,value);
}
}

一种高兼容性的JavaBean序列化方案的更多相关文章

  1. 几种Android数据序列化方案

    一.引言 数据的序列化在Android开发中占据着重要的地位,无论是在进程间通信.本地数据存储又或者是网络数据传输都离不开序列化的支持.而针对不同场景选择合适的序列化方案对于应用的性能有着极大的影响. ...

  2. 最经常使用的两种C++序列化方案的使用心得(protobuf和boost serialization)

    导读 1. 什么是序列化? 2. 为什么要序列化?优点在哪里? 3. C++对象序列化的四种方法 4. 最经常使用的两种序列化方案使用心得 正文 1. 什么是序列化? 程序猿在编写应用程序的时候往往须 ...

  3. 最常用的两种C++序列化方案的使用心得(protobuf和boost serialization)

    导读 1. 什么是序列化? 2. 为什么要序列化?好处在哪里? 3. C++对象序列化的四种方法 4. 最常用的两种序列化方案使用心得 正文 1. 什么是序列化? 程序员在编写应用程序的时候往往需要将 ...

  4. PHP四种序列化方案

    原文地址:https://t.ti-node.com/thread/... 数据的序列化是一个非常有用的功能,然而目测很多人跟我一样,在刚接触这玩意的时候压根就不理解这货色到底是干啥用的,反正老师说了 ...

  5. 深入挖掘.NET序列化机制——实现更易用的序列化方案

    .NET框架为程序员提供了“序列化和反序列化”这一有力的工具,使用它,我们能很容易的将内存中的对象图转化为字节流,并在需要的时候再将其恢复.这一技术的典型应用场景包括[1] : 应用程序运行状态的持久 ...

  6. 最常用的C++序列化方案:protobuf

    参考链接:最常用的两种C++序列化方案的使用心得(protobuf和boost serialization) [c++] Google Protobuf库1. 什么是序列化?程序员在编写应用程序的时候 ...

  7. 序列化方案选型对比 - JSON/ProtocolBuffer/FlatBuffer/DIMBIN

    4千字长文预警!! 背景 JSON/XML不好吗? 好,再没有一种序列化方案能像JSON和XML一样流行,自由.方便,拥有强大的表达力和跨平台能力.是通用数据传输格式的默认首选.不过随着数据量的增加和 ...

  8. Java高并发的常见应对方案

    Java高并发的常见应对方案 一.关于并发我们说的高并发是什么? 在互联网时代,高并发,通常是指,在某个时间点,有很多个访问同时到来. 高并发,通常关心的系统指标与业务指标? QPS:每秒钟查询量,广 ...

  9. 几种常见的微服务架构方案简述——ZeroC IceGrid、Spring Cloud、基于消息队列

    微服务架构是当前很热门的一个概念,它不是凭空产生的,是技术发展的必然结果.虽然微服务架构没有公认的技术标准和规范草案,但业界已经有一些很有影响力的开源微服务架构平台,架构师可以根据公司的技术实力并结合 ...

随机推荐

  1. FileInputStream实现读取文件内容并输出到屏幕上

    java输入输出流是站在程序的角度来说的.从文件中读取数据用输入流,向文件中写数据用输出流. package com.janson.day20180827; import java.io.FileIn ...

  2. 爬虫之Selenium库

    官方文档:https://selenium-python.readthedocs.io/ Selenium:自动化测试工具,支持多种浏览器.爬虫中主要用来解决JavaScript渲染的问题. 一.开始 ...

  3. 1002 A+B for Polynomials (PAT (Advanced Level) Practice)

    This time, you are supposed to find A+B where A and B are two polynomials. Input Specification: Each ...

  4. 部署live555到云

    1.下载live555源码:    wget http://www.live555.com/liveMedia/public/live.2017.10.28.tar.gz    2.解压源码包:   ...

  5. java Beanutils.copyProperties( )用法

    这是一篇开发自辩甩锅稿~~~~ 昨天测试小姐姐将我的一个bug单重开了,emmmm....内心OS:就调整下对象某个属性类型这么简单的操作,我怎么可能会出错呢,一定不是我的锅!!but再怎么抗拒,bu ...

  6. hdu 1853 KM算法

    #include<stdio.h> #include<math.h> #include<string.h> #define N 200 #define inf 99 ...

  7. 做ssh框架整合的时候,遇到如下错误:AnnotationTransactionAttributeSource is only available on Java 1.5 and higher

    nested exception is java.lang.IllegalStateException: AnnotationTransactionAttributeSource is only av ...

  8. 关于使用CELERY的一点心得

    使用也有大半年了.稳定性没话说啊. 但有一个坑,是我以前没注意的,记录下来. 就是本来一个任务是可以异步并行执行的..但如何需要CELERY的执行结果来作判断的话,就会变得异步串行的. 这要值得注意. ...

  9. 给nginx生成自签名证书

    https://blog.csdn.net/qq_26819733/article/details/53431662 https://www.liaoxuefeng.com/article/00141 ...

  10. CI 日志类

    开发ci的过程中,使用log能直观的看出代码运行到哪,还可设置代码查看数据接口的发送情况.日志类: <?php defined('BASEPATH') OR exit('No direct sc ...