在对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. Manacher算法(马拉车算法)浅谈

    什么是Manacher算法? 转载自百度百科 Manachar算法主要是处理字符串中关于回文串的问题的,它可以在 O(n) 的时间处理出以字符串中每一个字符为中心的回文串半径,由于将原字符串处理成两倍 ...

  2. Servlet的说明及使用案例

    Servlet的说明及使用案例 制作人:全心全意 Servle的基础介绍 Servlet结构体系 Servlet对象.ServletConfig对象与Serializable对象是接口对象,其中Ser ...

  3. 【Codeforces 1038D】Slime

    [链接] 我是链接,点我呀:) [题意] 题意 [题解] 相当于让你确定每个数字前面的系数是-1还是+1 有个结论是这样每次和相邻的减的话, 任何出除了全"-1"和全"+ ...

  4. 最长上升子序列的回溯 ZOJ 2432

    题目大意: 找一组最长上升公共子序列,并把任意一组满足的情况输出出来 最长公共上升子序列不清楚可以先看这篇文章 http://www.cnblogs.com/CSU3901130321/p/41826 ...

  5. springboot 2.x 集成 drools 7.x

    简介:springboot 2.0.4.RELEASE 集成 drools 7.11.0.Final 1.项目结构 2. pom.xml文件 <?xml version="1.0&qu ...

  6. 【Tomcat】tomcat配置多域名和虚拟路径

    当我们用浏览器在访问网页的时候,如访问www.baidu.com,一般都认为会在DNS服务器上找这个域名对应的IP,然后向这个IP发送请求 并响应,其实在DNS服务器解析之前,本机会先在你的系统配置文 ...

  7. Linux下汇编语言学习笔记71 ---

    这是17年暑假学习Linux汇编语言的笔记记录,参考书目为清华大学出版社 Jeff Duntemann著 梁晓辉译<汇编语言基于Linux环境>的书,喜欢看原版书的同学可以看<Ass ...

  8. 作DJANGO ORM时的一些最佳实践

    还是国外的正规,都在作DJANGO ORM的解藕化工作了. 外键不用,多对多,一对多,不用. 参考URL: http://scottlobdell.me/2015/01/sql-database-be ...

  9. docker: 解决centos7下cgroup.procs: no such device的错误

    在centos7下,运行docker run的时候会发生cgroup.procs: no such device的错误,解决方法是编辑 /lib/systemd/system/docker.servi ...

  10. Android: ADB not responding. You can wait more, or kill “adb.exe”

    Windows Only: Open a command prompt with administration permission and type netsh interface tcp set ...