扩展网上找来的一个VOPO工具类

最新推荐文章于 2025-03-04 09:03:53 发布
原创 最新推荐文章于 2025-03-04 09:03:53 发布 · 191 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #Bean #SQL

本文介绍了一个用于Java项目的Bean转换工具类，该工具可以实现VO（View Object）与PO（Persistent Object）之间的相互转换，并提供了自定义异常处理及数据类型转换等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.

package com.jdnis.constant;

public class Datatpye {

	public final static String STRING="java.lang.String";
	public final static String INTEGER="java.lang.Integer";
	public final static String DOUBLE="java.lang.Double";
	public final static String FLOAT="java.lang.Float";
	public final static String LONG="java.lang.Long";
	public final static String BIGDECIMAL = "java.math.BigDecimal";  
	public final static String DATE = "java.util.Date"; 
	public final static String TIMESTMAP = "java.sql.Timestamp";  
	public final static String BYTE = "java.lang.Byte"; 
	public final static String BOOLEAN = "jjava.lang.Boolean";

	public final static String INT="int";
	public final static String FLOAT_l="float";
	public final static String DOUBLE_l="double";
	public final static String LONG_l="long";
	public final static String BYTE_l="byte";
	public final static String BOOLEAN_l="boolean";
}

2.自定义一个异常类DefaultException
3.

package com.jdnis.utils;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

import com.jdnis.constant.Datatpye;
import com.jdnis.exception.DefaultException;
import com.jdnis.po.PersonPO;
import com.jdnis.vo.Person;


public class BeanConverter {

	private static HashMap hmSetMethodsBeans = new HashMap();   
    private static HashMap hmGetMethodsBeans = new HashMap(); 
    public static final String VOTOPO="voToPo";
    public static final String POTOVO="poToVo";

    /**  
     * @param instance  
     * @param cls  
     * @return  Object
     * @throws ClassCastException  
     */  
    public static Object copyVoToPo(BaseVO instance) throws ClassCastException {   
        Object obj = null;   
        Class cls = null;
		try {
			cls = BeanUtils.getPoByVoUseName(instance).getClass();
		} catch (DefaultException e1) {
			e1.printStackTrace();
		} 
        HashMap hmGetMethods = getGetMethods(instance.getClass());   
        HashMap hmSetMethods = getSetMethods(cls);   
        Set keySet = null;   
        keySet = hmSetMethods.keySet();  //得到的是一组键(key,value)的集合 
        Iterator it = keySet.iterator();   
        while (it.hasNext()){   
            String _propertyName = (String)it.next();//得到key()  
            Method getMethod = (Method)hmGetMethods.get(_propertyName);//得到key对应的get方法名
            Method setMethod = (Method)hmSetMethods.get(_propertyName); //得到key对应的set方法名

            if (setMethod != null && getMethod != null) {   
                try {   
                    if (obj == null)
                        obj = cls.newInstance();
                        //得到VO中方法的返回值
                        Object param = getMethod.invoke(instance, null); 
                        //求得(PO)setter的参数---数据类型
                        String paramTypeName = setMethod.getParameterTypes()[0].getName();
                        setMethod.invoke(obj,new Object[]{changeType(param, paramTypeName, VOTOPO)});

                } catch (Exception e){   
                    e.printStackTrace();  
                    throw new ClassCastException();   
                }   
            }   
        }
        return obj;   
    }  

    /**  
     * @param instance  
     * @param cls  
     * @return  Object
     * @throws ClassCastException  
     */  
    public static Object copyVoToPo(Object instance, Class cls) throws ClassCastException {   
        Object obj = null;   
        HashMap hmGetMethods = getGetMethods(instance.getClass());   
        HashMap hmSetMethods = getSetMethods(cls);   

        Set keySet = null;   
        keySet = hmSetMethods.keySet();  //得到的是一组键(key,value)的集合 
        Iterator it = keySet.iterator();   
        while (it.hasNext()){   
            String _propertyName = (String)it.next();//得到key()  
            Method getMethod = (Method)hmGetMethods.get(_propertyName);//得到key对应的get方法名
            Method setMethod = (Method)hmSetMethods.get(_propertyName); //得到key对应的set方法名

            if (setMethod != null && getMethod != null) {   
                try {   
                    if (obj == null)
                        obj = cls.newInstance();
                        //得到VO中方法的返回值
                        Object param = getMethod.invoke(instance, null); 
                        //求得(PO)setter的参数---数据类型
                        String paramTypeName = setMethod.getParameterTypes()[0].getName();
                        setMethod.invoke(obj,new Object[]{changeType(param, paramTypeName, VOTOPO)});

                } catch (Exception e){   
                    e.printStackTrace();  
                    throw new ClassCastException();   
                }   
            }   
        }
        return obj;   
    }  

    /**  
     * @param instance  
     * @param cls  
     * @return  Object
     * @throws ClassCastException  
     */  
    public static Object copyPoToVo(BasePO instance) throws ClassCastException {   
        Object obj = null;   
        Class cls = null;
        try {
			cls = BeanUtils.getVoByPoUseName(instance).getClass();
		} catch (DefaultException e1) {
			e1.printStackTrace();
		}
        HashMap hmGetMethods = getGetMethods(instance.getClass());   
        HashMap hmSetMethods = getSetMethods(cls);   
        Set keySet = null;   
        keySet = hmSetMethods.keySet();  //得到的是一组键(key,value)的集合 
        Iterator it = keySet.iterator();   
        while (it.hasNext()){   
            String _propertyName = (String)it.next();//得到key()  
            Method getMethod = (Method)hmGetMethods.get(_propertyName);//得到key对应的get方法名
            Method setMethod = (Method)hmSetMethods.get(_propertyName); //得到key对应的set方法名

            if (setMethod != null && getMethod != null) {   
                try {   
                    if (obj == null)
                        obj = cls.newInstance();   
                       //得到PO中方法的返回值
                        Object param = getMethod.invoke(instance, null); 
                        //求得setter的参数---数据类型
                        setMethod.invoke(obj,new String[]{(String)changeType(param, "java.lang.String", POTOVO)});
                } catch (Exception e){   
                    e.printStackTrace();  
                    throw new ClassCastException();   
                }   
            }   
        }
        return obj;   
    }  

    /**  
     * @param instance  
     * @param cls  
     * @return  Object
     * @throws ClassCastException  
     */  
    public static Object copyPoToVo(Object instance, Class cls) throws ClassCastException {   
        Object obj = null;   
        HashMap hmGetMethods = getGetMethods(instance.getClass());   
        HashMap hmSetMethods = getSetMethods(cls);   
        Set keySet = null;   
        keySet = hmSetMethods.keySet();  //得到的是一组键(key,value)的集合 
        Iterator it = keySet.iterator();   
        while (it.hasNext()){   
            String _propertyName = (String)it.next();//得到key()  
            Method getMethod = (Method)hmGetMethods.get(_propertyName);//得到key对应的get方法名
            Method setMethod = (Method)hmSetMethods.get(_propertyName); //得到key对应的set方法名

            if (setMethod != null && getMethod != null) {   
                try {   
                    if (obj == null)
                        obj = cls.newInstance();   
                       //得到PO中方法的返回值
                        Object param = getMethod.invoke(instance, null); 
                        //求得setter的参数---数据类型
                        setMethod.invoke(obj,new String[]{(String)changeType(param, "java.lang.String", POTOVO)});
                } catch (Exception e){   
                    e.printStackTrace();  
                    throw new ClassCastException();   
                }   
            }   
        }
        return obj;   
    }  

    /**
     * 将srcObject对象转换成为type类型的数据
     * @param srcObject  
     * @param type  
     * @return  Object
     * @throws ClassCastException  
     */
    public static Object changeType(Object srcObject, String type, String str) throws DefaultException{
    	if(POTOVO.equals(str)){
    		return BeanUtils.changeToType(srcObject, "java.lang.String");
    	}else if(VOTOPO.equals(str)){
    		return BeanUtils.changeToType(srcObject, type);
    	}
    	return null;
    }
	/**
	 * 解析Javabean，取得这个bean class的属性和Set方法
	 */

	public static HashMap getSetMethods(Class cls) throws ClassCastException{
		return getSetMethods(cls,Object.class);
	}

	public static HashMap getSetMethods(Class cls, Class stopClass)	throws ClassCastException {
		String clsName = cls.getName();
		HashMap hmBean = (HashMap)hmSetMethodsBeans.get(clsName);
		if (hmBean != null)
			return hmBean;

		BeanInfo beanInfo = null;

		try {
			beanInfo = Introspector.getBeanInfo(cls, stopClass);
		} catch (IntrospectionException e) {
			e.printStackTrace();
			throw new ClassCastException();
		}
		PropertyDescriptor[] props;
		HashMap hm = new HashMap();
		props = beanInfo.getPropertyDescriptors();

		for (int i = 0; i < props.length; i++) {
			Method setMethod = props[i].getWriteMethod();

			if (setMethod != null){
				String field = props[i].getName().toLowerCase();
				hm.put(field, setMethod);
			}
		}
		hmSetMethodsBeans.put(clsName, hm);

		return hm;
	}

	/**
	 * 解析Javabean，取得这个bean class的属性和Set方法
	 */
	public static HashMap getGetMethods(Class cls)throws ClassCastException{
		return getGetMethods(cls,Object.class);
	}

	public static HashMap getGetMethods(Class cls, Class stopClass) throws ClassCastException {
		String clsName = cls.getName();//得到类的名称
		HashMap hmBean = (HashMap)hmGetMethodsBeans.get(clsName);//得到方法对象的集合
		if (hmBean != null){
			return hmBean;
		}

		BeanInfo drbeanInfo = null;//bean实例的相关信息

		try {
			drbeanInfo = Introspector.getBeanInfo(cls);
		} catch (IntrospectionException e) {
			e.printStackTrace();
			throw new ClassCastException();
		}

		PropertyDescriptor[] props;//属性列表
		HashMap hm = new HashMap();
		props = drbeanInfo.getPropertyDescriptors();

		for (int i = 0; i < props.length; i++) {
			Method getMethod = props[i].getReadMethod();

			if (getMethod != null); {
				String field = props[i].getName().toLowerCase();
				hm.put(field, getMethod);
			}
		}
		hmGetMethodsBeans.put(clsName, hm);

		return hm;
	}
}

    	public static void main(String[] args){
    		Person person = new Person("123","456","789","42.02");
    		PersonPO po = new PersonPO();
    		po = (PersonPO)BeanConverter.copyVoToPo(person, po.getClass());
    		System.out.println(person.getName()+" " +person.getAge()+"  "+person.getNum()+"  "+person.getScore());
    		System.out.println(po.getName()+" " +po.getAge()+"  "+po.getNum()+"  "+po.getScore());
    	}
    }
7.9 SpringBoot实战 拷贝工具类，扩展BeanUtils.copyProperties
天罡gg的专栏
08-14 1155
为什么要实现拷贝工具类？本文主要解决在VO、BO、PO之间对象转换时的代码冗余问题，扩展BeanUtils，提升我们使用的用户体验。拷贝普通对象Bean拷贝集合对象List拷贝分页对象Page，内容不多但都是项目必备，并且涵盖了几个关键的基础知识：泛型方法、函数式接口、可变参数、重载！最关键的是有完整的拷贝工具类源码~ 还等什么，Let’s Go~想要看更多实战好文章，还是给大家推荐我的实战专栏–>《基于SpringBoot+SpringCloud+Vue前后端分离项目实战》，由我和前端狗哥。
简述Java项目中VO，BO，PO，DO，DTO之类的文件概念、易混点
简单发点工作中用到的，或者记录下小知识点
06-26 1248
分层使用VO（视图对象）、BO（业务对象）、PO（持久对象）、DTO（数据传输对象）在大型团队中有助于清晰界定结构，减少因数据需求不一致而导致的代码冲突。然而，这种分层并非一成不变，应根据业务的复杂性灵活调整。对于简单业务，甚至可以省略VO，直接使用DTO向前端传输数据。关键在于团队内部必须对这些概念有统一的理解。如果使用不当，反而可能导致代码混乱。数据对象：xxxPO，其中xxx为数据表名（也可使用DO）。数据传输对象：xxxDTO，其中xxx与业务领域相关。
vopo转换工具类及所需jar
08-14
简单的vopo转换功能及依赖jar
VOPO对象介绍
周二也被占用
09-11 1041
PO:解释也有分歧的，可以解释为Persisent Object(持久对象),也可以解释为Param Object(参数对象)  VO:可以解释为Value Object(值对象),也可以解释为View Object(页面展示的对象).  但是你必须理解  持久对象,比如数据库表对应有一个持久对象[DO]  参数对象,比如在Service层传递的QueryObject.[PO]  视
po,mo互转工具
03-14
今天我给大家带来了自制的mo、po文件相互转换工具， 主要特点是方便简洁。 ==================================================================================== 使用方法： 把要转换的mo或po文件拖到bat上即可，会自动在文件原目录生成对应的另一种格式。
Vo\Po转换器
daochuwenziyao的博客
05-20 2513
VoPoConverter import java.util.ArrayList; import java.util.List; import org.dozer.DozerBeanMapper; public class VoPoConverter { /** * 将src对象中的属性值复制到desc对象的同名属性中 * * @param
Java的(PO,VO,TO,BO,DAO,POJO)解释
vipbooks的专栏
01-16 602
PO(persistant object) 持久对象 在 o/r映射的时候出现的概念，如果没有o/r映射，没有这个概念存在了。通常对应数据模型(数据库),本身还有部分业务逻辑的处理。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 VO(value object) 值对象 通常用于业务层
java术语（PO/POJO/VO/BO/DAO/DTO）
04-14
POJO是一个普通的Java类，没有特定的约束或框架依赖。它被广泛用于表示业务逻辑中的实体对象，可以是数据库表的映射，也可以是纯粹的业务对象。POJO的概念是为了强调其简单性，与那些带有特定框架特性的复杂对象...
扩展MyBatisPlus代码生成器实现自定义源码生成，可生成前端页面、vo对象、dto对象等代码
03-07
可以创建一个自定义类，继承官方的`Generator`或`AbstractGenerator`类，重写`outputCustomFile()`方法。在这个方法里，我们可以控制文件的命名和生成逻辑，确保生成的前端页面文件名保持原样，而不是按照默认规则...
java vo po_Java中的VO,PO等
weixin_30395941的博客
02-12 351
O/R Mapping 是 Object Relational Mapping(对象关系映射)的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的需要了解，即VO，PO。VO，值对象(Value Object)PO，持久对象(Persisent Object)它们是由一组属性及其get/set组成。从结构上看，它们并没有什么不...
Java Bean POJO Entity VO PO DAO
heginux的博客
01-18 421
以上都是Java对象，适用不同场合Java Bean
VO、TO、PO、POJO、BO
疯猫
11-17 1866
VO、TO、PO、POJO、BO VO：实际上很模糊，通常指ValueObject和ViewObject ViewObject：UI需要的对象，如Struts的FormBean Value Object：ValueObject和Transfer Object的总称。 TO： Transfer Object，数据传输物件，在应用程序不同tie之间传输的对象 PO：Persistent Objec
java-VO/PO/DTO解释以及实战代码
苦逼的老王的博客
01-13 7247
java-VO/PO/DTO解释以及实战代码
Java 中 VO、POJO、DTO 的区别详解
最新发布
qq_48131648的博客
03-04 1383
POJO 是一种简单的 Java 对象，它不依赖于任何特定的框架或技术，仅仅遵循 Java 的基本语法和面向对象编程原则。POJO 的主要特点是没有继承特定的类，也不实现特定的接口（除了 Java 标准库中的接口，如Serializable接口，用于对象的序列化和反序列化场景）。它纯粹用于封装数据，并且通常包含私有属性以及对应的getter和setter方法，以便对属性进行访问和修改。return id;VO 同样是用于封装数据的对象，但它更强调数据的值本身。
Java中的VO，BO，PO，DO，DTO
Lifelong learning
12-11 7094
  随着现在后端编程标准化程度越来越高，各种编程模型层出不穷。作为Java开发人员，大部分人不免要接触VO，BO，PO，DO，DTO之类的，但很多人对这些概念一直以来都是云里雾里，团队开发过程中也总是处于混乱的状态，抓起来就用，本来是规范性的东西，却反而导致更加混乱了。   今天我们把这些概念掰开揉碎来讲解一下，力求有一个清晰的理解，在开发中能有所助益。文中又理解不到位的，也欢迎大家斧正。 概念 VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。
Java 中 PO 与 VO 的区别
weixin_30763397的博客
08-24 495
什么是PO PO(Persistence Object 持久化对象)是直接跟持久层数据库打交道的java Bean (model,entity,bean等叫法都是可以的)，里面除了私有的成员变量之外，就只有其对应的set/get方法， 而且其变量一般跟数据库表中的列几乎(除了名字)一样。 什么是VO VO(Value Object 值对象)除了可以跟PO完全一样的变量，set/get方法...
专门处理日期，字符转换的方法 ，实现日期和字符之间的拷贝
xfhuaguang的专栏
06-03 460
public static Object VotoPo(Class po,Object vo) throws Exception   {   Object opo = null;       ConvertUtilsBean convertUtils = new ConvertUtilsBean();//java自动转换的工具类       DateConverter dateConverter 
深入理解Java设计模式中的PO/POJO/VO/BO/DAO/DTO术语
简单来说，POJO就是一个普通的Java类，它不包含任何的业务逻辑或者持久化逻辑。POJOs通常用于作为数据传输对象（DTO）或者值对象（VO）。 3. VO（Value Object）- 值对象 值对象通常用于封装数据，并且在某些上下文...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值