package com.eloancn.nback.common.utils;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* VO PO 转换帮助类
*
* @author nyy
* @param <S> PO类
* @param <T> VO类
*/
public class VoPoConvertUtil<S, T> {
protected Logger logger = LoggerFactory.getLogger(this.getClass());
private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public SimpleDateFormat getFormat() {
return format;
}
public void setFormat(SimpleDateFormat format) {
this.format = format;
}
private List<String> excludeFields = null;
/**
* 构造VO PO 转换帮助类
*
*/
public VoPoConvertUtil() {
}
/**
* 构造VO PO 转换帮助类
* @param excludeFields 排除字段集合
*/
public VoPoConvertUtil(List<String> excludeFields) {
this.excludeFields = excludeFields;
}
/**
* PO转VO
* @param source PO对象
* @param target VO对象
*/
public void convert(S source, T target) {
if (source == null || target == null) {
return;
}
convert(source, target, source.getClass(), target.getClass());
}
/**
* PO转VO 自定义时间类型属性样式
* @param source PO对象
* @param target VO对象
*/
public void convert(S source, T target,String dateFormat) {
if (source == null || target == null) {
return;
}
convert(source, target, source.getClass(), target.getClass(),dateFormat);
}
/**
* 自定义时间类型属性样式
* @param source
* @param target
* @param sc
* @param tc
* @param dateFormat 时间类型属性样式
* @author YYJ
* @date 2016年6月1日
*/
private void convert(S source, T target, Class<?> sc, Class<?> tc,String dateFormat) {
SimpleDateFormat fmt = new SimpleDateFormat(dateFormat);
Class<?> scs = sc.getSuperclass();
if (scs != null) {
convert(source, target, scs, tc.getSuperclass(), dateFormat);
}
for (Field field : tc.getDeclaredFields()) {
field.setAccessible(true);
if (notFlterField(field.getName())) {
try {
Field sourceField = null;
try {
sourceField = sc.getDeclaredField(field.getName());
} catch (Exception e) {
//vo对象中有的变量在po中不存在，不需要转换,不需要打印错误日志
}
if(sourceField != null){
sourceField.setAccessible(true);
Type type = sourceField.getGenericType();
Object value = sourceField.get(source);
if (value == null) {
continue;
} else if (type.equals(String.class)) {
field.set(target, value);
} else if (type.equals(BigDecimal.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Date.class)) {
String ddd = fmt.format((Date) value);
field.set(target, ddd);
} else if (type.equals(Long.class) || type.equals(long.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Double.class) || type.equals(double.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Integer.class) || type.equals(int.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Float.class) || type.equals(float.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Byte.class) || type.equals(byte.class)) {
field.set(target, String.valueOf(value));
}
}
} catch (Exception e) {
logger.info("Po转VO发生了异常", e);
}
}
}
}
private void convert(S source, T target, Class<?> sc, Class<?> tc) {
Class<?> scs = sc.getSuperclass();
if (scs != null) {
convert(source, target, scs, tc.getSuperclass());
}
for (Field field : tc.getDeclaredFields()) {
field.setAccessible(true);
if (notFlterField(field.getName())) {
try {
Field sourceField = null;
try {
sourceField = sc.getDeclaredField(field.getName());
} catch (Exception e) {
//vo对象中有的变量在po中不存在，不需要转换,不需要打印错误日志
}
if(sourceField != null){
sourceField.setAccessible(true);
Type type = sourceField.getGenericType();
Object value = sourceField.get(source);
if (value == null) {
continue;
} else if (type.equals(String.class)) {
field.set(target, value);
} else if (type.equals(BigDecimal.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Date.class)) {
field.set(target, format.format((Date) value));
} else if (type.equals(Long.class) || type.equals(long.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Double.class) || type.equals(double.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Integer.class) || type.equals(int.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Float.class) || type.equals(float.class)) {
field.set(target, String.valueOf(value));
} else if (type.equals(Byte.class) || type.equals(byte.class)) {
field.set(target, String.valueOf(value));
}
}
} catch (Exception e) {
logger.info("Po转VO发生了异常", e);
}
}
}
}
/**
* VO 还原 PO
*
* @param source
* VO 对象
* @param target
* PO 对象
*/
public void revert(T source, S target) {
if (source == null || target == null) {
return;
}
revert(source, target, source.getClass(), target.getClass());
}
private void revert(T source, S target, Class<?> sc, Class<?> tc) {
Class<?> scs = sc.getSuperclass();
if (scs != null) {
revert(source, target, scs, tc.getSuperclass());
}
for (Field field : sc.getDeclaredFields()) {
field.setAccessible(true);
if (notFlterField(field.getName())) {
try {
Field targetField = tc.getDeclaredField(field.getName());
targetField.setAccessible(true);
Type type = targetField.getGenericType();
String value = null;
try {
value = (String) field.get(source);
} catch (Exception e) {
value = String.valueOf(field.get(source));
}
if (value == null || (type.equals(String.class) == false && StringUtils.isEmpty(value.trim()))) {
continue;
} else if (type.equals(String.class)) {
targetField.set(target, value);
} else {
if (type.equals(Long.class)) {
targetField.set(target, Long.valueOf(value));
} else if (type.equals(Double.class) || type.equals(double.class)) {
targetField.set(target, Double.valueOf(value));
} else if (type.equals(Integer.class) || type.equals(int.class)) {
targetField.set(target, Integer.valueOf(value));
} else if (type.equals(Float.class) || type.equals(float.class)) {
targetField.set(target, Float.valueOf(value));
} else if (type.equals(Byte.class) || type.equals(byte.class)) {
targetField.set(target, Byte.valueOf(value));
} else if (type.equals(Date.class)) {
if (", ".equals(value) == false) {
if (value.split(" ").length < 2) {
value = value + " 00:00:00";
}
targetField.set(target, format.parse(value));
}
} else if (type.equals(BigDecimal.class)) {
BigDecimal bigDecimal = new BigDecimal(value);
bigDecimal.setScale(4, BigDecimal.ROUND_HALF_UP);
targetField.set(target, bigDecimal);
}
}
} catch (Exception e) {
logger.info("Vo转Po发生了异常", e);
}
}
}
}
/**
* 不排除的字段
*
* @param fieldName
* @return boolean
* @exception
* @since 1.0.0
*/
private boolean notFlterField(String fieldName) {
return "serialVersionUID".equals(fieldName) == false
&& (excludeFields == null || !excludeFields.contains(fieldName));
}
}
相关推荐
在实际应用中，如果需要更精细的分离，可能会有专门的VO类，将PO转换成VO是为了适应业务需求，例如添加额外的业务逻辑属性或者隐藏敏感信息。 总结起来，这个例子展示了如何在Java中使用Hibernate处理自身关联的...
在Java开发领域，尤其是涉及到Spring框架以及数据持久化时，我们常常会遇到“PO”（Plain Old Java Object）和“VO”（Value Object）这两个概念。它们都是Java对象，但各自有不同的用途和特点。理解它们的区别对于...
"关于VO、PO的理解——java的(PO,VO,TO,BO,DAO,POJO)解释" 在 Java 中，PO、VO、TO、BO、DAO、POJO 是六个重要的概念，它们之间存在着紧密的关系，本文将对它们进行详细的解释。 首先，PO（Persistent Object）是...
"Java的(PO,VO,TO,BO,DAO,POJO)解释" Java作为一门流行的编程语言，在软件开发中扮演着重要角色，其中一些关键概念和技术为开发者提供了方便快捷的开发体验。本篇文章将对Java中的PO、VO、TO、BO、DAO、POJO等概念...
"vopo转换工具类及所需jar"是一个特定的项目，它提供了一个简单的方法来处理名为"vopo"的数据格式之间的转换。这个工具包可能包含了一些核心的类和依赖的库，使得开发者能够便捷地实现这种转换操作。 首先，`...
Oracle 自动化生成POJO（Plain Old Java Object）与VO（Value Object）工具，简称POVO工具，是一种提高开发效率的实用程序。在Java开发中，POJO和VO类经常被用于数据传输和持久化层，它们是业务逻辑和数据模型之间的...
### Java中的PO、VO、TO、BO、DAO与POJO详解 #### 一、概述 在Java企业级应用开发中，经常会遇到各种类型的对象，如PO、VO、TO、BO、DAO以及POJO等。这些对象各有侧重，在系统架构的不同层次扮演着不同的角色。...
### Java的几种对象详解：PO-VO-DAO-BO-POJO #### 一、PO：Persistant Object（持久对象） 持久对象（Persistent Object，简称PO），主要用于与数据库中的表进行映射。一个简单的PO对象可以代表数据库表中的一条...
以下是关于POJO、VO、PO、DO、DTO的详细解释及其区别。 1. POJO（Plain Old Java Object）：POJO是一个通用术语，指没有特定框架限制的简单Java对象。它通常包含了业务逻辑和数据属性，不包含任何特定框架的注解或...
Java中 PO VO BO DTO DAO 和 POJO 关系图
Java 中 PO、VO、BO、POJO、DAO、DTO、TO、QO、Bean、conn 的理解 PO（Persistent Object）：持久对象，指的是在 O/R Mapping 中将对象与关系数据库绑定的对象。PO 是由一组属性和属性的 get 和 set 方法组成。它...
Java开发中，PO（Persistant Object）、VO（Value Object）、BO（Business Object）、DAO（Data Access Object）和POJO（Plain Old Java Object）是常见的五个概念，它们在软件设计和开发中扮演着不同的角色。...
本文将深入探讨五种常见的Java对象类型：持久化对象（Persistent Object，简称PO）、值对象（Value Object，简称VO）、数据访问对象（Data Access Object，简称DAO）、业务对象（Business Object，简称BO）和平凡的...
本文将详细解析"PO/POJO/VO/BO/DAO/DTO"这六个概念，并探讨它们在实际项目开发中的作用和应用场景。 1. PO（Persistent Object，持久化对象） PO是指与数据库表结构一一对应的Java对象，它通常包含了数据库表中的...
在IT行业中，尤其是在Java开发领域，我们经常遇到“VO”、“BO”和“PO”这样的术语，它们分别代表了Value Object、Business Object和Persistent Object。理解这三个概念对于编写清晰、可维护的代码至关重要。 首先...
本文将详细介绍VO (View Object)、DTO (Data Transfer Object)、BO (Business Object)、ORM (Object Relational Mapping)、DAO (Data Access Object)、Entity (实体)、DO (Data Object)、PO (Persistent Object)、...
J2EE开发人员必须知道 Java Web开发中VO、PO、DTO、POJO代表含义。
J2EE基础知识之DTO,VO,PO,DO等定义J2EE基础知识之DTO,VO,PO,DO等定义J2EE基础知识之DTO,VO,PO,DO等定义
本人以前搞不懂这些o的区别，特意查找资料总结了一下，希望也可以帮到其他人