在对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. linux diff-比较给定的两个文件的不同

    推荐:更多Linux 文件查找和比较 命令关注:linux命令大全 diff命令在最简单的情况下,比较给定的两个文件的不同.如果使用“-”代替“文件”参数,则要比较的内容将来自标准输入.diff命令是 ...

  2. Delphi语法

    类与对象 从用户角度考虑,用户并不需要了解面向对象编程的知识,就可编写Delphi应用程序.当用户在建立新窗体.添加新组件以及处理事件时,大部分相关代码会由Delphi自动产生.但是,知道语言及其细节 ...

  3. IIS部署网站只有首页能访问,其他链接失效/运行.net+Access网站-可能原因:IIS未启用32位应用程序模式

    在64位的机子上IIS运行32位的.NET程序 由于64位操作系统不支持Microsoft OLE DB Provider for Jet驱动程 也不支持更早的Microsoft Access Dri ...

  4. Convolutions in TensorFlow

    Convolutions in TensorFlow Convolutions without training You might already be familiar with the term ...

  5. [bzoj1070][SCOI2007]修车[ 网络流]

    把每个工人拆成N个点.记为A[i,j]表示第i个工人修倒数第j辆车.每个车跟所有N*M个工人拆出的点连边.流量为1,费用为$time[i,j]*k$.源和每辆车连边,N*M个点和汇连边,流量都为1,费 ...

  6. 《Spring in action》之装配Bean

    创建应用对象之间协作关系的行为通常称为装配,这也是依赖注入的本质. Spring装配Bean的三种主要机制: 1.在XML中进行显示配置 2.在java中进行显示配置 3.隐式的bean发现机制和自动 ...

  7. Codeforces 300E(数学)

    题意:给定k个数字,求最小的正整数n,使得“n的阶乘”是“这k个数字的阶乘的积”的倍数.1<=k<=1e6,数字ai满足1<=ai<=1e7 分析:如果我们能对着k个数字的阶乘 ...

  8. 第3章 ES文档和故障处理

    第3章 ES文档和故障处理 一.ES网络配置表 ES网络配置表是ES的硬件和软件组成的列表.ES网络配置常包括以下项目: 分级 项目 杂项信息 系统名.系统厂商/型号.CPU速率.RAM.存储器.系统 ...

  9. Python3基础(五) 函数

    函数(function)是组织好的.可重复使用的.具有一定功能的代码段.函数能提高应用的模块性和代码的重复利用率,Python中已经提供了很多内建函数,比如print(),同时Python还允许用户自 ...

  10. Fragment中的setUserVisibleHint()方法调用

    使用Fragment的时候难免会遇到想在视图可见与不可见之中做些操作.此时一般会想到类似Activity中的onResume()和onPause()方法.Fragment中也确实有这两个方法,然而亲測 ...