java基础之对象类型

分类

POJO：Plain Ordinary Java Object 简单的Java对象

实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。通指没有使用Entity Beans的普通java对象，可以把POJO作为支持业务逻辑的协助类。

POJO实质上可以理解为简单的实体类，顾名思义POJO类的作用是方便程序员使用数据库中的数据表，对于广大的程序员，可以很方便的将POJO类当做对象来进行使用，当然也是可以方便的调用其get,set方法。POJO类也给我们在struts框架中的配置带来了很大的方便。
1 ．POJO持久化之后==〉PO

（在运行期，由Hibernate中的cglib动态把POJO转换为PO，PO相对于POJO会增加一些用来管理数据库entity状态的属性和方法。PO对于programmer来说完全透明，由于是运行期生成PO，所以可以支持增量编译，增量调试。）

2 ．POJO传输过程中==〉DTO

3 ．POJO用作表示层==〉VO

PO：persistant object 持久对象

1 ．有时也被称为Data对象，对应数据库中的entity，可以简单认为一个PO对应数据库中的一条记录。

2 ．在hibernate持久化框架中与insert/delet操作密切相关。

3 ．PO中不应该包含任何对数据库的操作。

就是在Object/Relation Mapping框架中的Entity，po的每个属性基本上都对应数据库表里面的某个字段。完全是一个符合Java Bean规范的纯Java对象，没有增加别的属性和方法。持久对象是由insert数据库创建，由数据库delete删除的。基本上持久对象生命周期和数据库密切相关。

DTO（TO）：Data Transfer Object 数据传输对象

1 ．用在需要跨进程或远程传输时，它不应该包含业务逻辑。

2 ．比如一张表有100个字段，那么对应的PO就有100个属性（大多数情况下，DTO 内的数据来自多个表）。但view层只需显示10个字段，没有必要把整个PO对象传递到client，这时我们就可以用只有这10个属性的DTO来传输数据到client，这样也不会暴露server端表结构。到达客户端以后，如果用这个对象来对应界面显示，那此时它的身份就转为VO。

VO：view object 值对象

视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。

1 ．主要对应页面显示（web页面/swt、swing界面）的数据对象。

2 ．可以和表对应，也可以不，这根据业务的需要。

BO ：business object 业务对象

封装业务逻辑为一个对象（可以包括多个PO，通常需要将BO转化成PO，才能进行数据的持久化，反之，从DB中得到的PO，需要转化成BO才能在业务层使用）。

关于BO主要有三种概念

1 、只包含业务对象的属性；

2 、只包含业务方法；

3 、两者都包含。

在实际使用中，认为哪一种概念正确并不重要，关键是实际应用中适合自己项目的需要。

这个对象可以包括一个或多个其它的对象。 比如一个简历，有教育经历、工作经历、社会关系等等。 我们可以把教育经历对应一个 PO ，工作经历对应一个 PO ，社会关系对应一个 PO 。 建立一个对应简历的 BO 对象处理简历，每个 BO 包含这些 PO 。 这样处理业务逻辑时，我们就可以针对 BO 去处理。

DAO ：data access object 数据访问对象

1 ．主要用来封装对DB的访问（CRUD操作）。

2 ．通过接收Business层的数据，把POJO持久化为PO。

是一个 sun 的一个标准 j2ee 设计模式， 这个模式中有个接口就是 DAO ，它是持久层的操作。为业务层提供接口。此对象用于访问数据库。通常和 PO 结合使用， DAO 中包含了各种数据库的操作方法。通过它的方法 , 结合 PO 对数据库进行相关的操作。夹在业务逻辑与数据库资源中间。配合 VO, 提供数据库的 CRUD 操作

DO：Domain Object 领域对象

就是从现实世界中抽象出来的有形或无形的业务实体。一般和数据中的表结构对应。

JavaBean 是一种JAVA语言写成的可重用组件。

它的方法命名，构造及行为必须符合特定的约定：

1、这个类必须有一个公共的缺省构造函数。

2、这个类的属性使用getter和setter来访问，其他方法遵从标准命名规范。

3、这个类应是可序列化的。

因为这些要求主要是靠约定而不是靠实现接口，所以许多开发者把JavaBean看作遵从特定命名约定的POJO。

简而言之，当一个Pojo可序列化，有一个无参的构造函数，使用getter和setter方法来访问属性时，他就是一个JavaBean

Entity

实体，和PO的功能类似，和数据表一一对应，一个实体一张表

实体类转换

方法一：BeanUtils

前提是属性名一致

// 将实体类Entity属性赋值给EntityVo
BeanUtils.copyProperties(Entity,EntityVo);

 只拷贝源对象为非空的数据：只拷贝源对象为非空的数据，防止源对象null覆盖目标对象对应值。

/**
参数1：目标对象（destination）这是要将属性值复制到的目标对象。通常是一个新创建的对象，以便将源对象的属性值复制到其中。
参数2：源对象（source）这是要从中复制属性值的源对象。
参数3：可选属性名数组（ignoreProperties）这是一个可选的字符串数组，指定要忽略复制的属性名称。如果指定了该参数，BeanUtils.copyProperties方法将不会复制在此数组中列出的属性。
*/                
BeanUtils.copyProperties(source, target, getNullPropertyNames(source));


/**
 * 只拷贝源对象为非空的数据，防止源对象null覆盖目标对象对应值
 * @param source 源对象
 * @param target 目的对象
 */
public static void copyProperties(Object source, Object target){
	BeanUtils.copyProperties(source, target, getNullPropertyNames(source));
}


/**
* 获取对象中为null的字段名
* @param source 待获取的对象
* @return
*/
public static String[] getNullPropertyNames (Object source) {
	// org.springframework.beans.BeanWrapper
	//我们就可以通过BeanWrapper访问Bean的属性和方法
	final BeanWrapper src = new BeanWrapperImpl(source);

	// java.beans.PropertyDescriptor
	//方法用于获取的类的属性，但是获取的属性不是类的成员变量。
	PropertyDescriptor[] pds = src.getPropertyDescriptors();

	Set<String> emptyNames = new HashSet<>();
	for(PropertyDescriptor pd : pds) {
		//根据名称获取属性值
		Object srcValue = src.getPropertyValue(pd.getName());
		if (srcValue == null) {
			emptyNames.add(pd.getName());
		}
	}
	String[] result = new String[emptyNames.size()];
	return emptyNames.toArray(result);
}

方法二：org.mapstruct

        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-jdk8</artifactId>
            <version>1.2.0.CR1</version>
        </dependency>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
            <version>1.2.0.CR1</version>
        </dependency>

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

@Mapper
// 注意导入的是 mapstruct包
public interface UserMapper {
    UserMapper mapper = Mappers.getMapper(UserMapper.class);
	// 映射关系注解
    @Mappings({
         @Mapping(source="userId",target = "id"),
         @Mapping(source="userName",target = "name"),
         @Mapping(source="userAge",target = "age")
    })
    UserVo UserToVo(User user);
}

使用 

UserVo userVo = UserMapper.mapper.UserToVo(user);
System.out.println(userVo);

方法三：dozer 

dozer是一个能把实体和实体之间进行转换的工具.只要建立好映射关系.就像是ORM的数据库和实体映射一样。
dozer的功能比BeanUtils功能更强大，但是BeanUtils的性能更好。
所以简单的同名同类型属性赋值转换使用BeanUtils，复杂的级联结构的属性赋值转换使用Dozer。

1、 依赖

<!--dto/entity转换操作:数据转换快慢的限制在内存，能够在内存当中放多少数据，大量数据请求减少GC次数-->
<dependency>
	<groupId>net.sf.dozer</groupId>
	<artifactId>dozer</artifactId>
	<version>5.5.1</version>
</dependency>
<!--JDK8LocalDate等转换使用-->
<dependency>
	<groupId>io.craftsman</groupId>
	<artifactId>dozer-jdk8-support</artifactId>
	<version>1.0.6</version>
</dependency>

配置类

import com.google.common.collect.Lists;
import org.dozer.DozerBeanMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.List;

/**
 * Dozer转换配置
 */
@Configuration
public class DozerConfig {

    @Bean(name = "org.dozer.Mapper")
    public DozerBeanMapper dozer() {
        //这里是配置文件的路径
        List<String> mappingFiles = Lists.newArrayList("dozer/dozer-mapping.xml");
        mappingFiles.add("dozer/dozerJdk8Converters.xml");
        DozerBeanMapper dozerBean = new DozerBeanMapper();
        dozerBean.setMappingFiles(mappingFiles);
        return dozerBean;
    }
}

 dozer-mapping.xml

<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns="http://dozer.sourceforge.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://dozer.sourceforge.net
          http://dozer.sourceforge.net/schema/beanmapping.xsd">
    <!--如果两个类需要装换的属性名相同则不需要写这个mapping-->
</mappings>

dozerJdk8Converters.xml 

<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns="http://dozer.sourceforge.net"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://dozer.sourceforge.net
      http://dozer.sourceforge.net/schema/beanmapping.xsd">
    <configuration>
        <custom-converters>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.LocalDate</class-a>
                <class-b>java.time.LocalDate</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.LocalTime</class-a>
                <class-b>java.time.LocalTime</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.LocalDateTime</class-a>
                <class-b>java.time.LocalDateTime</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.OffsetDateTime</class-a>
                <class-b>java.time.OffsetDateTime</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.ZonedDateTime</class-a>
                <class-b>java.time.ZonedDateTime</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.ZoneId</class-a>
                <class-b>java.time.ZoneId</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.Period</class-a>
                <class-b>java.time.Period</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.Duration</class-a>
                <class-b>java.time.Duration</class-b>
            </converter>
            <converter type="io.craftsman.Jdk8CompatibilityConverter">
                <class-a>java.time.Instant</class-a>
                <class-b>java.time.Instant</class-b>
            </converter>
            <converter type="io.craftsman.JdkMissingConverter">
                <class-a>java.util.Locale</class-a>
                <class-b>java.util.Locale</class-b>
            </converter>
        </custom-converters>
    </configuration>
</mappings>

 工具类

import org.apache.commons.collections.CollectionUtils;
import org.dozer.Mapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * Dozer转换工具类
 */
@Component
public class TransFormUtil {
    @Autowired
    private Mapper beanMapperBean;


    public <E, T> T convertToT(E e, Class<T> t) {
        if (null != e) {
            return beanMapperBean.map(e, t);
        }
        return null;
    }

    public <E, T> List<T> convertToTList(List<E> eList, Class<T> t) {
        if (CollectionUtils.isNotEmpty(eList)) {
            List<T> tList = new ArrayList<>();
            for (E e : eList) {
                tList.add(beanMapperBean.map(e, t));
            }
            return tList;
        }
        return null;
    }

    public <E, T> E convertToE(T t, Class<E> e) {
        if (null != t) {
            return beanMapperBean.map(t, e);
        }
        return null;
    }

    public <E, T> List<E> convertToEList(List<T> tList, Class<E> e) {
        if (CollectionUtils.isNotEmpty(tList)) {
            List<E> eList = new ArrayList<>();
            for (T t : tList) {
                eList.add(beanMapperBean.map(t, e));
            }
            return eList;
        }
        return null;
    }


    public <E, T> List<T> convertToPList(List<E> eList, Class<T> t, boolean isNull) {
        if (CollectionUtils.isNotEmpty(eList)) {
            List<T> tList = new ArrayList<>();
            for (E e : eList) {
                tList.add(beanMapperBean.map(e, t));
            }
            return tList;
        } else {
            if (isNull) {
                return null;
            } else {
                return new ArrayList<>();
            }
        }

    }

    public <E, T> T convertToP(E t, Class<T> e) {
        if (null != t) {
            return beanMapperBean.map(t, e);
        }
        return null;
    }
}

使用

@Resource
private TransFormUtil transFormUtil;
List<BeanVO> beanVOListeanVOList = transFormUtil.convertToPList(BeanList, BeanVO.class, false);