行业资讯

java实现相同属性名称及相似类型的pojo、dto、vo等互转操作

发布时间：2020-10-11 18:30:02 作者：little_how
来源：脚本之家 阅读：237

已应用于实际项目：

1.thrift对象与dto之间的互转

2.pojo与dto之间的互转

3.pojo与vo之间的互转

1.核心转换工具类，对特别复杂类型不做处理，因为业务场景还未覆盖

package littlehow.convert;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * PojoConvertUtil
 *
 * @author littlehow
 * @time 2017-05-03 16:54
 */
public class PojoConvertUtil {
  private static Logger logger = LoggerFactory.getLogger(PojoConvertUtil.class);
  /**
   * 变量缓存
   */
  private static final Map<String, Map<String, Field>> cacheFields = new ConcurrentHashMap<>();
  private static final Set<Class> basicClass = new HashSet<>();
  static {
    basicClass.add(Integer.class);
    basicClass.add(Character.class);
    basicClass.add(Byte.class);
    basicClass.add(Float.class);
    basicClass.add(Double.class);
    basicClass.add(Boolean.class);
    basicClass.add(Long.class);
    basicClass.add(Short.class);
    basicClass.add(String.class);
    basicClass.add(BigDecimal.class);
  }
  /**
   * 将具有相同属性的类型进行转换
   * @param orig
   * @param <T>
   * @return
   */
  public static <T> T convertPojo(Object orig, Class<T> targetClass) {
    try {
      T target = targetClass.newInstance();
      /** 获取源对象的所有变量 */
      Field[] fields = orig.getClass().getDeclaredFields();
      for (Field field : fields) {
        if (isStatic(field)) continue;
        /** 获取目标方法 */
        Field targetField = getTargetField(targetClass, field.getName());
        if (targetField == null) continue;
        Object value = getFiledValue(field, orig);
        if (value == null) continue;
        Class type1 = field.getType();
        Class type2 = targetField.getType();
        //两个类型是否相同
        boolean sameType = type1.equals(type2);
        if (isBasicType(type1)) {
          if (sameType) setFieldValue(targetField, target, value);
        } else if (value instanceof Map && Map.class.isAssignableFrom(type2)){//对map
          setMap((Map)value, field, targetField, target);
        } else if (value instanceof Set && Set.class.isAssignableFrom(type2)) {//对set
          setCollection((Collection)value, field, targetField, target);
        } else if (value instanceof List && List.class.isAssignableFrom(type2)) {//对list
          setCollection((Collection)value, field, targetField, target);
        } else if (value instanceof Enum && Enum.class.isAssignableFrom(type2)) {//对enum
          setEnum((Enum)value, field, targetField, target);
        } else if (value instanceof java.util.Date &&
            java.util.Date.class.isAssignableFrom(type2)) {//对日期类型，不处理如joda包之类的扩展时间，不处理calendar
          setDate((Date)value, targetField, type2, target, sameType);
        }
      }
      return target;
    } catch (Throwable t) {
      logger.error("转换失败:" + t.getMessage());
      throw new RuntimeException(t.getMessage());
    }
  }
 
  /**
   * 获取字段值
   * @param field
   * @param obj
   * @return
   */
  private static Object getFiledValue(Field field, Object obj) throws IllegalAccessException {
    //获取原有的访问权限
    boolean access = field.isAccessible();
    try {
      //设置可访问的权限
      field.setAccessible(true);
      return field.get(obj);
    } finally {
      //恢复访问权限
      field.setAccessible(access);
    }
  }
 
  /**
   * 设置方法值
   * @param field
   * @param obj
   * @param value
   * @throws IllegalAccessException
   */
  private static void setFieldValue(Field field, Object obj, Object value) throws IllegalAccessException {
    //获取原有的访问权限
    boolean access = field.isAccessible();
    try {
      //设置可访问的权限
      field.setAccessible(true);
      field.set(obj, value);
    } finally {
      //恢复访问权限
      field.setAccessible(access);
    }
  }
 
  /**
   * 转换list
   * @param orig
   * @param targetClass
   * @param <T>
   * @return
   */
  public static <T> List<T> convertPojos(List orig, Class<T> targetClass) {
    List<T> list = new ArrayList<>(orig.size());
    for (Object object : orig) {
      list.add(convertPojo(object, targetClass));
    }
    return list;
  }
 
  /**
   * 设置Map
   * @param value
   * @param origField
   * @param targetField
   * @param targetObject
   * @param <T>
   */
  private static <T> void setMap(Map value, Field origField, Field targetField, T targetObject) throws IllegalAccessException, InstantiationException{
    Type origType = origField.getGenericType();
    Type targetType = targetField.getGenericType();
    if (origType instanceof ParameterizedType && targetType instanceof ParameterizedType) {//泛型类型
      ParameterizedType origParameterizedType = (ParameterizedType)origType;
      Type[] origTypes = origParameterizedType.getActualTypeArguments();
      ParameterizedType targetParameterizedType = (ParameterizedType)targetType;
      Type[] targetTypes = targetParameterizedType.getActualTypeArguments();
      if (origTypes != null && origTypes.length == 2 && targetTypes != null && targetTypes.length == 2) {//正常泛型,查看第二个泛型是否不为基本类型
        Class clazz = (Class)origTypes[1];
        if (!isBasicType(clazz) && !clazz.equals(targetTypes[1])) {//如果不是基本类型并且泛型不一致，则需要继续转换
          Set<Map.Entry> entries = value.entrySet();
          Map targetMap = value.getClass().newInstance();
          for (Map.Entry entry : entries) {
            targetMap.put(entry.getKey(), convertPojo(entry.getValue(), (Class) targetTypes[1]));
          }
          setFieldValue(targetField, targetObject, targetMap);
          return;
        }
      }
    }
    setFieldValue(targetField, targetObject, value);
  }
 
  /**
   * 设置集合
   * @param value
   * @param origField
   * @param targetField
   * @param targetObject
   * @param <T>
   * @throws IllegalAccessException
   * @throws InstantiationException
   */
  private static <T> void setCollection(Collection value, Field origField, Field targetField, T targetObject) throws IllegalAccessException, InstantiationException{
    Type origType = origField.getGenericType();
    Type targetType = targetField.getGenericType();
    if (origType instanceof ParameterizedType && targetType instanceof ParameterizedType) {//泛型类型
      ParameterizedType origParameterizedType = (ParameterizedType)origType;
      Type[] origTypes = origParameterizedType.getActualTypeArguments();
      ParameterizedType targetParameterizedType = (ParameterizedType)targetType;
      Type[] targetTypes = targetParameterizedType.getActualTypeArguments();
      if (origTypes != null && origTypes.length == 1 && targetTypes != null && targetTypes.length == 1) {//正常泛型,查看第二个泛型是否不为基本类型
        Class clazz = (Class)origTypes[0];
        if (!isBasicType(clazz) && !clazz.equals(targetTypes[0])) {//如果不是基本类型并且泛型不一致，则需要继续转换
          Collection collection = value.getClass().newInstance();
          for (Object obj : value) {
            collection.add(convertPojo(obj, (Class) targetTypes[0]));
          }
          setFieldValue(targetField, targetObject, collection);
          return;
        }
      }
    }
    setFieldValue(targetField, targetObject, value);
  }
 
  /**
   * 设置枚举类型
   * @param value
   * @param origField
   * @param targetField
   * @param targetObject
   * @param <T>
   */
  private static <T> void setEnum(Enum value, Field origField, Field targetField, T targetObject) throws Exception{
    if (origField.equals(targetField)) {
      setFieldValue(targetField, targetObject, value);
    } else {
      //枚举类型都具有一个static修饰的valueOf方法
      Method method = targetField.getType().getMethod("valueOf", String.class);
      setFieldValue(targetField, targetObject, method.invoke(null, value.toString()));
    }
  }
 
  /**
   * 设置日期类型
   * @param value
   * @param targetField
   * @param targetFieldType
   * @param targetObject
   * @param <T>
   */
  private static <T> void setDate(Date value, Field targetField, Class targetFieldType, T targetObject, boolean sameType) throws IllegalAccessException {
    Date date = null;
    if (sameType) {
      date = value;
    } else if (targetFieldType.equals(java.sql.Date.class)) {
      date = new java.sql.Date(value.getTime());
    } else if (targetFieldType.equals(java.util.Date.class)) {
      date = new Date(value.getTime());
    } else if (targetFieldType.equals(java.sql.Timestamp.class)) {
      date = new java.sql.Timestamp(value.getTime());
    }
    setFieldValue(targetField, targetObject, date);
  }
 
  /**
   * 获取适配方法
   * @param clazz
   * @param fieldName
   * @return
   */
  public static Field getTargetField(Class clazz, String fieldName) {
    String classKey = clazz.getName();
    Map<String, Field> fieldMap = cacheFields.get(classKey);
    if (fieldMap == null) {
      fieldMap = new HashMap<>();
      Field[] fields = clazz.getDeclaredFields();
      for (Field field : fields) {
        if (isStatic(field)) continue;
        fieldMap.put(field.getName(), field);
      }
      cacheFields.put(classKey, fieldMap);
    }
    return fieldMap.get(fieldName);
  }
 
  /**
   * 确实是否为基础类型
   * @param clazz
   * @return
   */
  public static boolean isBasicType(Class clazz) {
    return clazz.isPrimitive() || basicClass.contains(clazz);
  }
 
  /**
   * 判断变量是否有静态修饰符static
   * @param field
   * @return
   */
  public static boolean isStatic(Field field) {
    return (8 & field.getModifiers()) == 8;
  }
}

下面这个类是便于输出展示的，因为只是用于打印，所以不做效率考虑

package littlehow.convert;
 
import java.lang.reflect.Field;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
 
/**
 * SimpleToStringParent
 *
 * @author littlehow
 * @time 2017-05-04 10:40
 */
public class SimpleToStringParent {
 
  @Override
  public String toString() {
    try {
      StringBuilder stringBuilder = new StringBuilder("{");
      Field[] fields = this.getClass().getDeclaredFields();
      DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      for (Field field : fields) {
        Object value = getFiledValue(field, this);
        if (value == null) continue;
        if (value instanceof Date) {
          //这里也可以直接转为时间戳
          value = dateFormat.format((Date)value);
        }
        stringBuilder.append(field.getName()).append("=").append(value).append(",");
      }
      String returnValue = stringBuilder.toString();
      if (returnValue.length() > 1) {
        returnValue = returnValue.substring(0, returnValue.length() - 1);
      }
      return this.getClass().getSimpleName() + returnValue + "}";
    } catch (Exception e) {
      // skip
    }
    return this.getClass().getSimpleName() + "{}";
  }
 
  /**
   * 获取属性值
   * @param field
   * @param obj
   * @return
   * @throws IllegalAccessException
   */
  private Object getFiledValue(Field field, Object obj) throws IllegalAccessException {
    //获取原有的访问权限
    boolean access = field.isAccessible();
    try {
      //设置可访问的权限
      field.setAccessible(true);
      return field.get(obj);
    } finally {
      //恢复访问权限
      field.setAccessible(access);
    }
  }
}

测试用的4个pojo

1.产品类

package littlehow.convert.pojo;
 
import littlehow.convert.SimpleToStringParent;
 
import java.util.List;
 
/**
 * Product
 *
 * @author littlehow
 * @time 2017-05-04 09:15
 */
public class Product extends SimpleToStringParent {
  private Integer productId;
  private String generalName;
  private String factoryName;
  private String unit;
  private String specification;
  private Integer category;
  private List<Item> items;
 
  public Integer getProductId() {
    return productId;
  }
 
  public void setProductId(Integer productId) {
    this.productId = productId;
  }
 
  public String getGeneralName() {
    return generalName;
  }
 
  public void setGeneralName(String generalName) {
    this.generalName = generalName;
  }
 
  public String getFactoryName() {
    return factoryName;
  }
 
  public void setFactoryName(String factoryName) {
    this.factoryName = factoryName;
  }
 
  public String getUnit() {
    return unit;
  }
 
  public void setUnit(String unit) {
    this.unit = unit;
  }
 
  public String getSpecification() {
    return specification;
  }
 
  public void setSpecification(String specification) {
    this.specification = specification;
  }
 
  public List<Item> getItems() {
    return items;
  }
 
  public void setItems(List<Item> items) {
    this.items = items;
  }
 
  public Integer getCategory() {
    return category;
  }
 
  public void setCategory(Integer category) {
    this.category = category;
  }
}

2.商品类

package littlehow.convert.pojo;
 
 
import littlehow.convert.SimpleToStringParent;
 
import java.util.Date;
import java.util.List;
 
/**
 * Item
 *
 * @author littlehow
 * @time 2017-05-04 09:15
 */
public class Item extends SimpleToStringParent {
  private Long itemId;
  private String itemName;
  private Byte status;
  private Boolean deleted;
  private Date createTime;
  private List<Sku> skus;
 
  public Long getItemId() {
    return itemId;
  }
 
  public void setItemId(Long itemId) {
    this.itemId = itemId;
  }
 
  public String getItemName() {
    return itemName;
  }
 
  public void setItemName(String itemName) {
    this.itemName = itemName;
  }
 
  public Byte getStatus() {
    return status;
  }
 
  public void setStatus(Byte status) {
    this.status = status;
  }
 
  public Boolean getDeleted() {
    return deleted;
  }
 
  public void setDeleted(Boolean deleted) {
    this.deleted = deleted;
  }
 
  public Date getCreateTime() {
    return createTime;
  }
 
  public void setCreateTime(Date createTime) {
    this.createTime = createTime;
  }
 
  public List<Sku> getSkus() {
    return skus;
  }
 
  public void setSkus(List<Sku> skus) {
    this.skus = skus;
  }
}

3.最小库存单位sku

package littlehow.convert.pojo;
 
import littlehow.convert.SimpleToStringParent;
 
import java.lang.reflect.Field;
 
/**
 * Sku
 *
 * @author littlehow
 * @time 2017-05-04 09:15
 */
public class Sku extends SimpleToStringParent {
  private Long skuId;
  private Byte status;
  private Boolean deleted;
  private Double price;
  private Double promoPrice;
  private Integer inventory;
  private Integer minBuy;
  private Integer blockInventory;
  private Color skuColor;
 
  public Long getSkuId() {
    return skuId;
  }
 
  public void setSkuId(Long skuId) {
    this.skuId = skuId;
  }
 
  public Byte getStatus() {
    return status;
  }
 
  public void setStatus(Byte status) {
    this.status = status;
  }
 
  public Boolean getDeleted() {
    return deleted;
  }
 
  public void setDeleted(Boolean deleted) {
    this.deleted = deleted;
  }
 
  public Double getPrice() {
    return price;
  }
 
  public void setPrice(Double price) {
    this.price = price;
  }
 
  public Double getPromoPrice() {
    return promoPrice;
  }
 
  public void setPromoPrice(Double promoPrice) {
    this.promoPrice = promoPrice;
  }
 
  public Integer getInventory() {
    return inventory;
  }
 
  public void setInventory(Integer inventory) {
    this.inventory = inventory;
  }
 
  public Integer getMinBuy() {
    return minBuy;
  }
 
  public void setMinBuy(Integer minBuy) {
    this.minBuy = minBuy;
  }
 
  public Integer getBlockInventory() {
    return blockInventory;
  }
 
  public void setBlockInventory(Integer blockInventory) {
    this.blockInventory = blockInventory;
  }
 
  public Color getSkuColor() {
    return skuColor;
  }
 
  public void setSkuColor(Color skuColor) {
    this.skuColor = skuColor;
  }
}

4.属性枚举

package littlehow.convert.pojo;
 
/**
 * Color
 *
 * @author littlehow
 * @time 2017-05-04 09:21
 */
public enum Color {
  BLACK(1),
  RED(2),
  BLUE(3),
  GREEN(4);
  public final int value;
  Color(int value) {
    this.value = value;
  }
 
  public static Color valueOf(int value) {
    switch (value) {
      case 1 : return BLACK;
      case 2 : return RED;
      case 3 : return BLUE;
      case 4 : return GREEN;
      default : throw new IllegalArgumentException(value + " is not a enum value");
    }
  }
}

转换用的dto，当然也可以将dto作为转换源

1.产品dto

package littlehow.convert.dto;
 
import littlehow.convert.SimpleToStringParent;
import littlehow.convert.pojo.Item;
 
import java.util.List;
 
/**
 * ProductDto
 *
 * @author littlehow
 * @time 2017-05-04 09:16
 */
public class ProductDto extends SimpleToStringParent {
  private Integer productId;
  private String generalName;
  private String factoryName;
  private String unit;
  private String specification;
  private Integer category;
  private List<ItemDto> items;
 
  public Integer getProductId() {
    return productId;
  }
 
  public void setProductId(Integer productId) {
    this.productId = productId;
  }
 
  public String getGeneralName() {
    return generalName;
  }
 
  public void setGeneralName(String generalName) {
    this.generalName = generalName;
  }
 
  public String getFactoryName() {
    return factoryName;
  }
 
  public void setFactoryName(String factoryName) {
    this.factoryName = factoryName;
  }
 
  public String getUnit() {
    return unit;
  }
 
  public void setUnit(String unit) {
    this.unit = unit;
  }
 
  public String getSpecification() {
    return specification;
  }
 
  public void setSpecification(String specification) {
    this.specification = specification;
  }
 
  public List<ItemDto> getItems() {
    return items;
  }
 
  public void setItems(List<ItemDto> items) {
    this.items = items;
  }
 
  public Integer getCategory() {
    return category;
  }
 
  public void setCategory(Integer category) {
    this.category = category;
  }
}

2.商品dto

package littlehow.convert.dto;
 
import littlehow.convert.SimpleToStringParent;
import littlehow.convert.pojo.Sku;
 
import java.util.Date;
import java.util.List;
 
/**
 * ItemDto
 *
 * @author littlehow
 * @time 2017-05-04 09:16
 */
public class ItemDto extends SimpleToStringParent {
  private Integer itemId;
  private String itemName;
  private Byte status;
  private Boolean deleted;
  private Date createTime;
  private List<SkuDto> skus;
 
  public Integer getItemId() {
    return itemId;
  }
 
  public void setItemId(Integer itemId) {
    this.itemId = itemId;
  }
 
  public String getItemName() {
    return itemName;
  }
 
  public void setItemName(String itemName) {
    this.itemName = itemName;
  }
 
  public Byte getStatus() {
    return status;
  }
 
  public void setStatus(Byte status) {
    this.status = status;
  }
 
  public Boolean getDeleted() {
    return deleted;
  }
 
  public void setDeleted(Boolean deleted) {
    this.deleted = deleted;
  }
 
  public Date getCreateTime() {
    return createTime;
  }
 
  public void setCreateTime(Date createTime) {
    this.createTime = createTime;
  }
 
  public List<SkuDto> getSkus() {
    return skus;
  }
 
  public void setSkus(List<SkuDto> skus) {
    this.skus = skus;
  }
}

3.skudto

package littlehow.convert.dto;
 
import littlehow.convert.SimpleToStringParent;
import littlehow.convert.pojo.Color;
 
/**
 * SkuDto
 *
 * @author littlehow
 * @time 2017-05-04 09:16
 */
public class SkuDto extends SimpleToStringParent {
  private Long skuId;
  private Byte status;
  private Boolean deleted;
  private Double price;
  private Double promoPrice;
  private Integer inventory;
  private Integer minBuy;
  private Integer blockInventory;
  private ColorDto skuColor;
 
  public Long getSkuId() {
    return skuId;
  }
 
  public void setSkuId(Long skuId) {
    this.skuId = skuId;
  }
 
  public Byte getStatus() {
    return status;
  }
 
  public void setStatus(Byte status) {
    this.status = status;
  }
 
  public Boolean getDeleted() {
    return deleted;
  }
 
  public void setDeleted(Boolean deleted) {
    this.deleted = deleted;
  }
 
  public Double getPrice() {
    return price;
  }
 
  public void setPrice(Double price) {
    this.price = price;
  }
 
  public Double getPromoPrice() {
    return promoPrice;
  }
 
  public void setPromoPrice(Double promoPrice) {
    this.promoPrice = promoPrice;
  }
 
  public Integer getInventory() {
    return inventory;
  }
 
  public void setInventory(Integer inventory) {
    this.inventory = inventory;
  }
 
  public Integer getMinBuy() {
    return minBuy;
  }
 
  public void setMinBuy(Integer minBuy) {
    this.minBuy = minBuy;
  }
 
  public Integer getBlockInventory() {
    return blockInventory;
  }
 
  public void setBlockInventory(Integer blockInventory) {
    this.blockInventory = blockInventory;
  }
 
  public ColorDto getSkuColor() {
    return skuColor;
  }
 
  public void setSkuColor(ColorDto skuColor) {
    this.skuColor = skuColor;
  }
}

4.颜色属性

package littlehow.convert.dto;
 
/**
 * ColorDto
 *
 * @author littlehow
 * @time 2017-05-04 09:21
 */
public enum ColorDto {
  BLACK(1),
  RED(2),
  BLUE(3),
  GREEN(4);
  public final int value;
  ColorDto(int value) {
    this.value = value;
  }
 
  public static ColorDto valueOf(int value) {
    switch (value) {
      case 1 : return BLACK;
      case 2 : return RED;
      case 3 : return BLUE;
      case 4 : return GREEN;
      default : throw new IllegalArgumentException(value + " is not a enum value");
    }
  }
}

测试类，简单的做了一下输出查看

package littlehow.convert.test;
 
import littlehow.convert.PojoConvertUtil;
import littlehow.convert.dto.ItemDto;
import littlehow.convert.dto.ProductDto;
import littlehow.convert.dto.SkuDto;
import littlehow.convert.pojo.Color;
import littlehow.convert.pojo.Item;
import littlehow.convert.pojo.Product;
import littlehow.convert.pojo.Sku;
import org.junit.Before;
import org.junit.Test;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
 
/**
 * TransTest
 *
 * @author littlehow
 * @time 2017-05-04 10:44
 */
public class TransTest {
  private Product product;
 
  @Before
  public void init() {
    product = new Product();
    product.setCategory(123);
    product.setFactoryName("littlehow's shop");
    product.setGeneralName("littlehow's product");
    product.setProductId(1);
    product.setSpecification("16*2u");
    product.setUnit("box");
    List<Item> items = new ArrayList<>();
    for (int i=1; i<=5; i++) {
      Item item = new Item();
      item.setCreateTime(new Date());
      item.setDeleted(i % 3 == 0);
      item.setItemId((long) i);
      item.setItemName("littlehow's " + i + "th item");
      item.setStatus((byte) (i % 4));
      List<Sku> skus = new ArrayList<>();
      for (int j=1; j<=i; j++) {
        Sku sku = new Sku();
        sku.setSkuId((long)(j * (i + 5) * 3));
        sku.setStatus((byte) 1);
        sku.setDeleted(false);
        sku.setBlockInventory(5);
        sku.setInventory(j * 100);
        sku.setMinBuy(j * 5);
        sku.setPrice(Double.valueOf(j * 103));
        sku.setPromoPrice(Double.valueOf(j * 101));
        sku.setSkuColor(Color.valueOf(j % 4 + 1));
        skus.add(sku);
      }
      item.setSkus(skus);
      items.add(item);
    }
    product.setItems(items);
  }
 
  @Test
  public void test() {
    System.out.println(product);//正常输出
    System.out.println("========================");
    ProductDto productDto = PojoConvertUtil.convertPojo(product, ProductDto.class);
    System.out.println(productDto);//正常输出，证明转换正常
    System.out.println("=========================");
    List<Item> items = product.getItems();
    List<ItemDto> itemDtos = PojoConvertUtil.convertPojos(items, ItemDto.class);
    System.out.println(itemDtos);//正常输出，数组转换成功
  }
 
  @Test
  public void test1() {
    Sku sku = product.getItems().get(0).getSkus().get(0);
    System.out.println(sku);//正常输出
    System.out.println("=========================");
    SkuDto skuDto = PojoConvertUtil.convertPojo(sku, SkuDto.class);
    System.out.println(skuDto);
  }
}

能快速完成基础类之间的互转

以上这篇java实现相同属性名称及相似类型的pojo、dto、vo等互转操作就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持亿速云。

推荐阅读：
  1. 一遍文章搞清楚VO、DTO、DO、PO的概念、区别
  2. entity、bo、vo、po、dto、pojo如何理解和区分？

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

java 属性 类型

上一篇：SpringBoot为啥不用配置启动类的实现

下一篇：Python - 笔记1

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号