一种高兼容性的JavaBean序列化方案
在对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序列化方案的更多相关文章
- 几种Android数据序列化方案
一.引言 数据的序列化在Android开发中占据着重要的地位,无论是在进程间通信.本地数据存储又或者是网络数据传输都离不开序列化的支持.而针对不同场景选择合适的序列化方案对于应用的性能有着极大的影响. ...
- 最经常使用的两种C++序列化方案的使用心得(protobuf和boost serialization)
导读 1. 什么是序列化? 2. 为什么要序列化?优点在哪里? 3. C++对象序列化的四种方法 4. 最经常使用的两种序列化方案使用心得 正文 1. 什么是序列化? 程序猿在编写应用程序的时候往往须 ...
- 最常用的两种C++序列化方案的使用心得(protobuf和boost serialization)
导读 1. 什么是序列化? 2. 为什么要序列化?好处在哪里? 3. C++对象序列化的四种方法 4. 最常用的两种序列化方案使用心得 正文 1. 什么是序列化? 程序员在编写应用程序的时候往往需要将 ...
- PHP四种序列化方案
原文地址:https://t.ti-node.com/thread/... 数据的序列化是一个非常有用的功能,然而目测很多人跟我一样,在刚接触这玩意的时候压根就不理解这货色到底是干啥用的,反正老师说了 ...
- 深入挖掘.NET序列化机制——实现更易用的序列化方案
.NET框架为程序员提供了“序列化和反序列化”这一有力的工具,使用它,我们能很容易的将内存中的对象图转化为字节流,并在需要的时候再将其恢复.这一技术的典型应用场景包括[1] : 应用程序运行状态的持久 ...
- 最常用的C++序列化方案:protobuf
参考链接:最常用的两种C++序列化方案的使用心得(protobuf和boost serialization) [c++] Google Protobuf库1. 什么是序列化?程序员在编写应用程序的时候 ...
- 序列化方案选型对比 - JSON/ProtocolBuffer/FlatBuffer/DIMBIN
4千字长文预警!! 背景 JSON/XML不好吗? 好,再没有一种序列化方案能像JSON和XML一样流行,自由.方便,拥有强大的表达力和跨平台能力.是通用数据传输格式的默认首选.不过随着数据量的增加和 ...
- Java高并发的常见应对方案
Java高并发的常见应对方案 一.关于并发我们说的高并发是什么? 在互联网时代,高并发,通常是指,在某个时间点,有很多个访问同时到来. 高并发,通常关心的系统指标与业务指标? QPS:每秒钟查询量,广 ...
- 几种常见的微服务架构方案简述——ZeroC IceGrid、Spring Cloud、基于消息队列
微服务架构是当前很热门的一个概念,它不是凭空产生的,是技术发展的必然结果.虽然微服务架构没有公认的技术标准和规范草案,但业界已经有一些很有影响力的开源微服务架构平台,架构师可以根据公司的技术实力并结合 ...
随机推荐
- TestNG套件测试(一)
测试套件是用于测试软件程序的行为或一组行为的测试用例集合. 在TestNG中,我们无法在测试源代码中定义一个套件,但它可以由一个XML文件表示,可以灵活配置要运行的测试. 套件用<suite&g ...
- Linux 安装 MySQL 详解(rpm 包)
说明:Linux 系统中软件的安装在 root 用户下进行,此安装方式为 rpm 包方式,安装的版本为:MySQL-5.6.25-1.linux_glibc2.5.x86_64.rpm-bundle. ...
- Docker从入门到实践
一般说来 SPA 的项目我们只要启一个静态文件 Server 就可以了,但是针对传统项目就不一样了,一个项目会依赖很多服务端程序.之前我们的开发模式是在一台开发机上部署开发环境,所有人都在这台开发机上 ...
- 【OpenCV, MFC】利用MFC和OpenCV通过系统对话框打开和保存图片
打开图片: void CImageProDlg::OnImageopen() { // TODO: 在此添加命令处理程序代码 Invalidate(); CFileDialog dlg(TRUE, N ...
- getContextPath和getRealPath的区别-----其实主要区别就是相对路径和绝对路径
getContextPath和getRealPath的区别 其实主要区别就是相对路径和绝对路径 https://blog.csdn.net/zsmj_2011/article/details/4121 ...
- Leetcode 68.文本左右对齐
文本左右对齐 给定一个单词数组和一个长度 maxWidth,重新排版单词,使其成为每行恰好有 maxWidth 个字符,且左右两端对齐的文本. 你应该使用"贪心算法"来放置给定的单 ...
- rm -rf & node
rm -rf & node rm -rf $ rm -rf mydir https://www.computerhope.com/issues/ch000798.htm https://sta ...
- 【网络流24题】最长k可重区间集问题(费用流)
[网络流24题]最长k可重区间集问题 [问题分析] 最大权不相交路径问题,可以用最大费用最大流解决. [建模方法] 方法1 按左端点排序所有区间,把每个区间拆分看做两个顶点<i.a>< ...
- pg_dump: [archiver (db)] connection to database “dbase” failed: FATAL: Peer authentication failed for user “postgres”
"Peer authentication" means that it's comparing your database username against your Linux ...
- SPOJ QTREE2 lct
题目链接 题意: 给一棵树.有边权 1.询问路径的边权和 2.询问沿着路径的第k个点标. 思路:lct裸题. #include <iostream> #include <fstrea ...