精华内容
下载资源
问答
  • 创建一个自用的文件对象Bo和Po实体类 通过构造函数读取File的信息,减少工作量 po类 package com.faker.app.po; import java.io.File; import java.io.IOException; import java.nio.file.Files; import ...

    创建一个自用的文件对象Bo和Po实体类

    通过构造函数读取File的信息,减少工作量

    po类

    package com.faker.app.po;
    
    import java.io.File;
    import java.io.IOException;
    import java.nio.file.Files;
    import java.nio.file.Path;
    import java.nio.file.Paths;
    import java.nio.file.attribute.BasicFileAttributeView;
    import java.nio.file.attribute.BasicFileAttributes;
    import java.util.Date;
    
    /**
     * <p>Title: Python文件信息及属性实体类 - PyFileAttrPo</p>
     *
     * <p>Description:Python文件信息及属性实体类</p>
     *
     * <p>Copyright: Copyright Faker(c) 2018</p>
     *
     * <p>Company: 无</p>
     *
     * @author 你猜
     *
     * @version 1.0
     */
    public class PyFileAttrPo {
    
        /** 文件本身 */
        private File file;
    
        /** 文件名 */
        private String fileName;
    
        /** 文件名前缀 */
        private String fileNamePre;
    
        /** 文件名后缀 */
        private String fileNameSuffix;
    
        /** 文件创建时间戳 */
        private Date creationTime;
    
        /** 文件最后访问时间戳 */
        private Date lastAccessTime;
    
        /** 文件最后修改时间戳 */
        private Date lastModifiedTime;
    
        /** 文件大小 */
        private Long fileSize;
    
        /**
         * 无参构造
         */
        public PyFileAttrPo() {
        }
    
        /**
         * 将文件转化为文件属性
         * @param file
         */
        public PyFileAttrPo(File file) {
            //获取文件
            try {
                this.file = file;
            } catch (Exception e) {
                e.printStackTrace();
            }
            //获取文件名和后缀
            try {
                this.fileName = file.getName();
            } catch (Exception e) {
                e.printStackTrace();
            }
            //文件名后缀
            try {
                this.fileNameSuffix = this.fileName.substring(this.fileName.lastIndexOf(".") + 1);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //文件名前缀
            try {
                this.fileNamePre = this.fileName.substring(0,this.fileName.lastIndexOf("."));
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            try {
                // 获取将要操作的文件
                Path testPath = Paths.get(file.getPath());
                BasicFileAttributeView basicView = Files.getFileAttributeView(
                        testPath , BasicFileAttributeView.class);
                // 获取访问基本属性的BasicFileAttributes
                BasicFileAttributes basicAttribs = null;
                try {
                    basicAttribs = basicView.readAttributes();
                    //创建时间
                    try {
                        this.creationTime = new Date(basicAttribs.creationTime().toMillis());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //最后访问时间
                    try {
                        this.lastAccessTime = new Date(basicAttribs.lastModifiedTime().toMillis());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //最后修改时间
                    try {
                        this.lastModifiedTime = new Date(basicAttribs.lastModifiedTime().toMillis());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //文件大小
                    try {
                        this.fileSize = basicAttribs.size();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (Exception e) {e.printStackTrace();}
        }
    
        public File getFile() {
            return file;
        }
    
        public void setFile(File file) {
            this.file = file;
        }
    
        public String getFileName() {
            return fileName;
        }
    
        public void setFileName(String fileName) {
            this.fileName = fileName;
        }
    
        public String getFileNamePre() {
            return fileNamePre;
        }
    
        public void setFileNamePre(String fileNamePre) {
            this.fileNamePre = fileNamePre;
        }
    
        public String getFileNameSuffix() {
            return fileNameSuffix;
        }
    
        public void setFileNameSuffix(String fileNameSuffix) {
            this.fileNameSuffix = fileNameSuffix;
        }
    
        public Date getCreationTime() {
            return creationTime;
        }
    
        public void setCreationTime(Date creationTime) {
            this.creationTime = creationTime;
        }
    
        public Date getLastAccessTime() {
            return lastAccessTime;
        }
    
        public void setLastAccessTime(Date lastAccessTime) {
            this.lastAccessTime = lastAccessTime;
        }
    
        public Date getLastModifiedTime() {
            return lastModifiedTime;
        }
    
        public void setLastModifiedTime(Date lastModifiedTime) {
            this.lastModifiedTime = lastModifiedTime;
        }
    
        public Long getFileSize() {
            return fileSize;
        }
    
        public void setFileSize(Long fileSize) {
            this.fileSize = fileSize;
        }
    
        @Override
        public String toString() {
            return "PyFileAttrPo{" +
                    "file=" + file +
                    ", fileName='" + fileName + '\'' +
                    ", fileNamePre='" + fileNamePre + '\'' +
                    ", fileNameSuffix='" + fileNameSuffix + '\'' +
                    ", creationTime=" + creationTime +
                    ", lastAccessTime=" + lastAccessTime +
                    ", lastModifiedTime=" + lastModifiedTime +
                    ", fileSize=" + fileSize +
                    '}';
        }
    }
    
    

    感觉try/catch块用得太多了…

    Bo类 主要是把文件时间和大小转换一下

    package com.faker.app.bo;
    
    import com.faker.app.po.PyFileAttrPo;
    
    import java.io.File;
    import java.math.BigDecimal;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /**
     * <p>Title: Python文件信息及属性实体类 - PyFileAttrBo</p>
     *
     * <p>Description:Python文件信息及属性实体类,新增了时间格式化和中文说明</p>
     *
     * <p>Copyright: Copyright Faker(c) 2018</p>
     *
     * <p>Company: 无</p>
     *
     * @author 你猜
     *
     * @version 1.0
     */
    public class PyFileAttrBo extends PyFileAttrPo{
    
        /** 文件创建时间 */
        private String creationTimeStr;
    
        /** 文件最后访问时间 */
        private String lastAccessTimeStr;
    
        /** 文件最后修改时间 */
        private String lastModifiedTimeStr;
    
        /** 文件大小 */
        private String fileSizeStr;
    
        public String getCreationTimeStr() {
            try {
                this.creationTimeStr = stampToDate(super.getCreationTime());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return creationTimeStr;
        }
    
        public void setCreationTimeStr(String creationTimeStr) {
            this.creationTimeStr = creationTimeStr;
        }
    
        public String getLastAccessTimeStr() {
            try {
                this.lastAccessTimeStr = stampToDate(super.getLastAccessTime());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return lastAccessTimeStr;
        }
    
        public void setLastAccessTimeStr(String lastAccessTimeStr) {
            this.lastAccessTimeStr = lastAccessTimeStr;
        }
    
        public String getLastModifiedTimeStr() {
            try {
                this.lastModifiedTimeStr = stampToDate(super.getLastModifiedTime());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return lastModifiedTimeStr;
        }
    
        public void setLastModifiedTimeStr(String lastModifiedTimeStr) {
            this.lastModifiedTimeStr = lastModifiedTimeStr;
        }
    
        public String getFileSizeStr() {
            try {
                this.fileSizeStr = getPrintSize(super.getFileSize());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return fileSizeStr;
        }
    
        public void setFileSizeStr(String fileSizeStr) {
            this.fileSizeStr = fileSizeStr;
        }
    
        public PyFileAttrBo() {
        }
    
        /**
         * 文件的构造函数,自动生成文件信息
         * @param file
         */
        public PyFileAttrBo(File file) {
            super(file);
            try {
                this.creationTimeStr = stampToDate(super.getCreationTime());
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                this.lastAccessTimeStr = stampToDate(super.getLastAccessTime());
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                this.lastModifiedTimeStr = stampToDate(super.getLastModifiedTime());
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                this.fileSizeStr = getPrintSize(super.getFileSize());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    
        /**
         * 格式化时间
         * @param date 时间
         * @return 格式化后的时间时间
         */
        public String stampToDate(Date date){
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return  simpleDateFormat.format(date);
        }
    
        /**
         * 将文件字节数转换为kb/mb/Gb等
         * @param size 字节数
         * 这块引用了https://blog.csdn.net/layman1024/article/details/77988079
         * @return 转换后的字符串
         */
        public String getPrintSize(long size) {
            // 如果字节数少于1024,则直接以B为单位,否则先除于1024,后3位因太少无意义
            double value = (double) size;
            if (value < 1024) {
                return String.valueOf(value) + "B";
            } else {
                value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
            }
            // 如果原字节数除于1024之后,少于1024,则可以直接以KB作为单位
            // 因为还没有到达要使用另一个单位的时候
            // 接下去以此类推
            if (value < 1024) {
                return String.valueOf(value) + "KB";
            } else {
                value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
            }
            if (value < 1024) {
                return String.valueOf(value) + "MB";
            } else {
                // 否则如果要以GB为单位的,先除于1024再作同样的处理
                value = new BigDecimal(value / 1024).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
                return String.valueOf(value) + "GB";
            }
        }
    
        @Override
        public String toString() {
            return "PyFileAttrBo{" +
                    "creationTimeStr='" + creationTimeStr + '\'' +
                    ", lastAccessTimeStr='" + lastAccessTimeStr + '\'' +
                    ", lastModifiedTimeStr='" + lastModifiedTimeStr + '\'' +
                    ", fileSizeStr='" + fileSizeStr + '\'' +
                    "} " + super.toString();
        }
    }
    
    

    最后读取到的对象大概是这个样子的(file已set为null了)

    {
     "file": null,
     "fileName": "Python_main.py",
     "fileNamePre": "Python_main",
     "fileNameSuffix": "py",
     "creationTime": 1543471776025,
     "lastAccessTime": 1543475322461,
     "lastModifiedTime": 1543475322461,
     "fileSize": 6562,
     "creationTimeStr": "2018-11-29 14:09:36",
     "lastAccessTimeStr": "2018-11-29 15:08:42",
     "lastModifiedTimeStr": "2018-11-29 15:08:42",
     "fileSizeStr": "6.4KB"
     }
    
    展开全文
  • PO,BO,VOPOJO的区别

    万次阅读 多人点赞 2018-07-17 10:43:27
    PO:persistent object 持久对象 1 .有时也被称为Data对象,对应数据库中的entity,可以简单认为一个PO对应数据库中的一条记录。 2 .在hibernate持久化框架中与insert/delet操作密切相关。 3 .PO中不应该包含...

    Java大猿帅成长手册,GitHub JavaEgg ,N线互联网开发必备技能兵器谱,涵盖分布式、微服务、RPC等互联网公司常用架构,以及数据存储、缓存、搜索等必备技能

    PO:persistent object 持久对象

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

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

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


    POJO :plain ordinary java object 无规则简单java对象

    一个中间对象,可以转化为PO、DTO、VO。

    1 .POJO持久化之后==〉PO

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

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

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

    PO 和VO都应该属于它。


    BO:business object 业务对象

    业务对象主要作用是把业务逻辑封装为一个对象。这个对象可以包括一个或多个其它的对象。

    比如一个简历,有教育经历、工作经历、社会关系等等。我们可以把教育经历对应一个PO,工作经历对应一个PO,社会关系对应一个PO。

    建立一个对应简历的BO对象处理简历,每个BO包含这些PO。

    这样处理业务逻辑时,我们就可以针对BO去处理。

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

    关于BO主要有三种概念

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

    2 、只包含业务方法;

    3 、两者都包含。

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


    VO:value object 值对象 / view object 表现层对象

    1 .主要对应页面显示(web页面/swt、swing界面)的数据对象。

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


    DTO(TO):Data Transfer Object 数据传输对象

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

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


    DAO:data access object数据访问对象

    1 .主要用来封装对DB的访问(CRUD操作)。

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

    简易的关系图:

    这里写图片描述

    展开全文
  • 初步学习:VO,BO和PO

    千次阅读 2015-07-27 21:34:38
    了解起来感觉还是挺简单的,不过被一堆VO,BO和PO给搞得不清不楚的,现在也开发了几条线了,有了一些初步的了解,先总结总结。   PO:persistantobject持久对象。在o/r映射的时候出现的概念,如果没有o/r映射,没

            该篇文章主要是对VO,PO,BO的一个了解

          PO:persistantobject持久对象。在o/r映射的时候出现的概念,如果没有o/r映射,没有这个概念存在了。可以看成是与数据库中的表相映射的java对象。

          最形象的理解就是一个PO就是数据库中的一条记录。多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。

           好处是可以把一条记录作为一个对象处理,可以方便的转为其它对象。

          BO:business object业务对象

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

          VO :ViewObject表现层对象

          主要对应界面显示的数据对象。对于一个WEB页面,或者SWT、SWING的一个界面,用一个VO对象对应整个界面的值。

     

          VO,值对象(ValueObject),PO,持久对象(PersisentObject),它们都是由一组属性和属性的get和set方法组成。从结构上看,它们并没有什么不同的地方。但从其意义和本质上来看是完全不同的:

          第一:VO是用new关键字创建,由GC回收的。PO则是向数据库中添加新数据时创建,删除数据库中数据时削除的。且它只能存活在一个数据库连接中,断开连接即被销毁。

          第二:VO是值对象,精确点讲它是业务对象,是存活在业务层的,是业务逻辑使用的,它存活的目的就是为数据提供一个生存的地方。PO则是有状态的,每个属性代表其当前的状态。它是物理数据的对象表示。使用它,可以使我们的程序与物理数据解耦,并且可以简化对象数据与物理数据之间的转换。

          第三:VO的属性是根据当前业务的不同而不同的,也就是说,它的每一个属性都一一对应当前业务逻辑所需要的数据的名称。PO的属性是跟数据库表的字段一一对应的。

          现在对VOBOPO只是初步的了解,还需要在项目中更为深刻的发现他们的作用。

    展开全文
  • 一篇文章讲清楚VO,BOPO,DO,DTO的区别

    千次阅读 多人点赞 2020-01-12 17:05:51
    随着编程工业化水平的不断加深,各种编程模型层出不穷(比如MVC),伴随着这些编程模型,又有一大批新的概念蜂拥而至,什么VO,BOPO,DO,DTO之类的,这些新的概念一直以来都是云里雾里,网上虽然也有不少文章来...

    随着编程工业化水平的不断加深,各种编程模型层出不穷(比如MVC,MVP等等),伴随着这些编程模型,又有一大批新的概念蜂拥而至,什么VO,BO,PO,DO,DTO之类的,这些新的概念一直以来都是云里雾里,网上虽然也有不少文章来区分这些概念,但看下来基本都是几篇相同的文章转载来转载去,这些文章本身也说的不明,有些还互相矛盾,再加上有些文章在简化系统里面来使用这些概念,让人越看越迷糊

    什么原因造成了这种混乱的状态,就不深究了,感觉也很难究出所以然来
    因此让我们立足这些概念本身,达成对概念理解的一致性,就足够了,这也是这边文章的主要目的
    鉴于专业术语的解释互联网上太多,一搜一大把,我就不重复一遍术语了,而且说实话,术语太抽象,不利于理解,看完其实没解决啥疑惑,我会尽量用大白话(人话)来做解释,争取让大家都能看明白

    废话不多说,先来看张图
    看完图估计大部分人就已经有了一个直观的感受了
    在这里插入图片描述
    面对这个图,让我们先从承上启下的DTO开始入手
    DTO(Data Transfer Object)数据传输对象
    这个传输通常指的前后端之间的传输
    DTO是一个比较特殊的对象,他有两种存在形式:
    在后端,他的存在形式是java对象,也就是在controller里面定义的那个东东,通常在后端不需要关心怎么从json转成java对象的,这个都是由一些成熟的框架帮你完成啦,比如spring框架
    在前端,他的存在形式通常是js里面的对象(也可以简单理解成json),也就是通过ajax请求的那个数据体
    这也是为什么把他画成横跨两层的原因

    这里可能会遇到个问题,现在微服务盛行,服务和服务之间调用的传输对象能叫DTO吗?
    我的理解是看情况
    DTO本身的一个隐含的意义是要能够完整的表达一个业务模块的输出
    如果服务和服务之间相对独立,那就可以叫DTO
    如果服务和服务之间不独立,每个都不是一个完整的业务模块,拆开可能仅仅是因为计算复杂度或者性能的问题,那这就不能够叫做DTO,只能是BO

    VO(Value Object)值对象
    VO就是展示用的数据,不管展示方式是网页,还是客户端,还是APP,只要是这个东西是让人看到的,这就叫VO
    VO主要的存在形式就是js里面的对象(也可以简单理解成json)

    VO和DTO的区别
    主要有两个区别
    一个是字段不一样,VO根据需要会删减一些字段
    另一个是值不一样,VO会根据需要对DTO中的值进行展示业务的解释
    举个简单的例子
    DTO可能是这样的

    {
    	"gender":"男",
    	"age":35
    }
    

    对于业务一来说只需要性别,而且因为是一个古风聊天室,也不能直接展示男,因此经过业务解释业务一的VO是

    {
    	"gender":"公子"
    }
    

    对于业务二来说只需要年龄,而且不需要精确的年龄,因此经过业务解释业务二的VO是

    {
    	"age":"30~39"
    }
    

    PO(Persistant Object)持久对象
    PO比较好理解
    简单说PO就是数据库中的记录,一个PO的数据结构对应着库中表的结构,表中的一条记录就是一个PO对象
    通常PO里面除了get,set之外没有别的方法
    对于PO来说,数量是相对固定的,一定不会超过数据库表的数量
    等同于Entity,这俩概念是一致的

    BO(Business Object)业务对象
    BO就是PO的组合
    简单的例子比如说PO是一条交易记录,BO是一个人全部的交易记录集合对象
    复杂点儿的例子PO1是交易记录,PO2是登录记录,PO3是商品浏览记录,PO4是添加购物车记录,PO5是搜索记录,BO是个人网站行为对象
    BO是一个业务对象,一类业务就会对应一个BO,数量上没有限制,而且BO会有很多业务操作,也就是说除了get,set方法以外,BO会有很多针对自身数据进行计算的方法
    为什么BO也画成横跨两层呢?原因是现在很多持久层框架自身就提供了数据组合的功能,因此BO有可能是在业务层由业务来拼装PO而成,也有可能是在数据库访问层由框架直接生成
    很多情况下为了追求查询的效率,框架跳过PO直接生成BO的情况非常普遍,PO只是用来增删改使用

    BO和DTO的区别
    这两个的区别主要是就是字段的删减
    BO对内,为了进行业务计算需要辅助数据,或者是一个业务有多个对外的接口,BO可能会含有很多接口对外所不需要的数据,因此DTO需要在BO的基础上,只要自己需要的数据,然后对外提供
    在这个关系上,通常不会有数据内容的变化,内容变化要么在BO内部业务计算的时候完成,要么在解释VO的时候完成

    OK,到这里这些关系基本就理清楚了

    等等,DO是什么
    DO呢,标题不是还有个DO么?
    上面这些概念基本上已经涵盖了全部的流程,DO只是跟其中一个概念相同
    但是跟哪个概念相同呢?
    现在主要有两个版本
    一个是阿里巴巴的开发手册中的定义
    DO( Data Object)这个等同于上面的PO
    另一个是在DDD(Domain-Driven Design)领域驱动设计中
    DO(Domain Object)这个等同于上面的BO

    最后,让我们再说说实际应用
    这几个概念很完整,我们在用的时候是必须按这个来做吗?
    当然不是的,系统和系统的复杂度不同,协作水平不同,完全没有必要教条主义,这些概念全上
    上哪些概念,省哪些,我给一些实际建议
    1,PO这个没法省,不管叫PO还是Entity,怎么着都得有
    2,一些工具类的系统和一些业务不是很复杂的系统DTO是可以和BO合并成一个,当业务扩展的时候注意拆分就行
    3,VO是可以第一个优化掉的,展示业务不复杂的可以压根儿不要,直接用DTO
    4,这也是最重要的一条,概念是给人用的,多人协作的时候一定要保证大家的概念一致,赶紧把这篇文章转发给跟你协作的人吧

    欢迎关注公众号,共同交流,共同进步
    欢迎关注公众号,共同交流,共同进步

    展开全文
  • VO, BO, PO, DAO,POJO之间的区别欢迎使用Markdown编辑器VOPODTOBOPOJODAO 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇...
  • PO,DTO,VO,BO,PO,POJO

    2020-03-17 15:04:28
    PO,BO,VOPOJO的区别 PO:persistent object 持久对象 1 .有时也被称为Data对象,对应数据库中的entity,可以简单认为一个PO对应数据库中的一条记录。 2 .在hibernate持久化框架中与insert/delet操作密切相关。 3...
  • * @Description: bo po 转换类 * @Author TanXiongZhan * @Date 2019/6/18 */ public abstract class BaseConverter, P> { private final static Logger logger = LoggerFactory.getLogger(BaseConverter....
  • vo bo po dto dao区别

    2013-05-16 16:39:39
    本人以前搞不懂这些o的区别,特意查找资料总结了一下,希望也可以帮到其他人
  • PO:persistent object 持久对象 1 .有时也被称为Data对象,对应数据库中的entity,可以简单认为一个PO对应数据库中的一条记录。 2 .在hibernate持久化框架中与insert/delet操作密切相关。 3 .PO中不应该包含任何...
  • bo,vo,po区别

    2007-12-29 18:13:26
    介绍vo,bo,po区别。看其他网站收集的资料。
  • VO,BOPO,DO,DTO

    2021-05-28 11:28:54
    一篇文章讲清楚VO,BOPO,DO,DTO的区别 随着编程工业化水平的不断加深,各种编程模型层出不穷(比如MVC,MVP等等),伴随着这些编程模型,又有一大批新的概念蜂拥而至,什么VO,BOPO,DO,DTO之类的,这些新...
  • PO BO VO的区别

    千次阅读 2017-03-03 11:37:32
    1、PO, Persistence Object, 持久层对象,对象的属性数据库表的字段一一对应; 2、BO, Business Object, 业务层对象,对象的属性当前业务逻辑所需的数据的名称一一对应; 3、VO, View Object, 表现层对象,对象...
  • VO:值对象 用来做数据展示的,重点体现在人们直观看到的数据,比如web页面中的数据,最主要的存在形式就是json了。...许多个PO组成一个BO 假如PO是一条购物记录,那么BO就是全部的交易记录集合对象。 或者说PO_1.
  • POJO/DTO/DO/EO/VO/BO/PO/AO的含义使用

    千次阅读 2019-12-12 19:46:44
    关于POJO/DTO/DO/EO/VO/BO/PO/AO 本文讨论 POJO/DTO/DO/EO/VO/BO/PO/AO 的定义,另外讨论了这些xO在controller、service、dao/mapper层里的使用规范。另外还稍微讨论了controller中是否要 “轻逻辑”,mapper接口的...
  • 网传一张图 PO(Persistant Object)持久对象 PO比较好理解 简单说PO就是数据库中的记录,一个PO的...BO就是PO的组合 简单的例子比如说PO是一条交易记录,BO是一个人全部的交易记录集合对象 复杂点儿的例子P.
  • PO VO DTO BO区别

    2020-11-05 20:17:40
    PO: persistant object 持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理,...建立一个对应简历的BO对象处理简历,每个BO包含这些PO。 这样处理业务逻辑时,我们就可以
  • 可以表对应,也可以不,这根据业务的需要。 PO:persistent object 持久对象 1 .有时也被称为Data对象,对应数据库中的entity,可以简单认为一个PO对应数据库中的一条记录。 2 .在hibernate持...
  • vo、bopo、dto

    2018-06-04 19:06:30
    VO(value object) 值对象 通常用于业务层之间的数据传递,和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可以表对应,也可以不,这根据业务的需要.个人觉得同DTO(数据传输对象),在web上传递。BO(business ...
  • vo和po和bo

    2011-07-06 10:39:34
    VO(value object) 值对象 ... 通常用于业务层之间的数据传递,和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可以表对应,也可以不,这根据业务的需要.个人觉得同DTO(数据传输对象),在web上传递。 ...
  • PO VO DTO BO区别及用法

    千次阅读 2018-08-21 10:18:28
    BO: businessobject业务对象 主要作用是把业务逻辑封装为一个对象。这个对象可以包括一个或多个其它的对象。 比如一个简历,有教育经历、工作经历、社会关系等等。 我们可以把教育经历对应一个PO,工作经历对应一个...
  • 是对DTO/VO/BO/PO/DO的统称。 DTO(Data Transfer Object)数据传输对象 不同服务或服务层之间的数据传输,如:RPC接口参数、Controller层的请求参数。 VO(Value Object、View Object)值对象、展示对象 ...
  • POJO的定义是无规则简单的对象,在日常的代码分层中pojo会被分为VO、BOPO、 DTO,这些分别是指哪里的对象呢?让我们一起研究下吧。 一、首先了解下VO、BOPO、 DTO是什么 VO (view object/value object)表示...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,350
精华内容 3,740
关键字:

bo和po区别