精华内容
下载资源
问答
  • 根据数据库中表的字段自动生成java中的vo类,方便调用
  • NULL 博文链接:https://joynet007.iteye.com/blog/972596
  • 前言:idea 功能很强大,以前不知道有这样的提升工作效率的...生成的VO类效果: 一、连接数据库 打开项目: 1、点击右侧的datesource图标,要是没有该图标,请去自行百度 2、点击 + 号 3、选择 datasource ...

    前言:idea 功能很强大,以前不知道有这样的提升工作效率的方法,虽然有的工具确实可以直接生成实体类,mapper文件,还有dao接口,但是个人觉得涉及到复杂业务还是只生成实体类比较好,后面部分就自己搞定就可以了。

    生成的VO类效果:

    一、连接数据库

    打开项目:

    1、点击右侧的datesource图标,要是没有该图标,请去自行百度

    2、点击 + 号

    3、选择 datasource

    4、选择 mysql

    1、填写一个连接名,随便填什么都行

    2、不用选择,默认就行

    3、填写数据库连接的 IP地址,比如本地数据库可以填写:localhost或者127.0.0.1

    4、填写数据库开放的端口号,一般没设置的话默认都是3306

    5、填写你需要连接的数据库名

    6、填写数据库的用户名

    7、填写数据库密码

    8、这里会有一个驱动需要点击下载,图中是已经下载好了

    9、填写自己的数据库连接url,然后可以点击9所在按钮进行测试连接,本地连接失败检查是否开启了mysql服务

     

    连接好了如上图所示,可以看到自己的数据库和表,选择一个表右键,网上教程一般到这里结束,都是选择说Generate POJOs.groovy,然后在弹出窗口选择需要生成的文件夹所在即可。

    我选择一张表进行生成示例如下:

    表明去除了“_”然后以驼峰方式生成了类名,而且开始的package 路径也不对,重点是没有注释,没有注释,没有注释!

    网上搜了一些方法,都不太行,要不就是到处报错,没辙只能自己瞎琢磨。没想到最后也不难,下面就是实现:

    右键选择表,在选择Generate POJOs.groovy 的下面那一项:

    进来只有Generate POJOs.groovy,右键新建另外一个比如我的叫做:MyGeneratePOJOs.groovy,里面内容如下:

    import com.intellij.database.model.DasTable
    import com.intellij.database.model.ObjectKind
    import com.intellij.database.util.Case
    import com.intellij.database.util.DasUtil
    import java.io.*
    import java.text.SimpleDateFormat
    
    /*
     * Available context bindings:
     *   SELECTION   Iterable<DasObject>
     *   PROJECT     project
     *   FILES       files helper
     */
    packageName = ""
    typeMapping = [
            (~/(?i)tinyint|smallint|mediumint/)      : "Integer",
            (~/(?i)int/)                             : "Long",
            (~/(?i)bool|bit/)                        : "Boolean",
            (~/(?i)float|double|decimal|real/)       : "Double",
            (~/(?i)datetime|timestamp|date|time/)    : "Date",
            (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
            (~/(?i)/)                                : "String"
    ]
    
    
    FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->
        SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
    }
    
    def generate(table, dir) {
        def className = javaClassName(table.getName(), true)
        def fields = calcFields(table)
        packageName = getPackageName(dir)
        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File(dir, className + ".java")), "UTF-8"))
        printWriter.withPrintWriter {out -> generate(out, className, fields,table)}
    
    //    new File(dir, className + ".java").withPrintWriter { out -> generate(out, className, fields,table) }
    }
    
    // 获取包所在文件夹路径
    def getPackageName(dir) {
        return dir.toString().replaceAll("\\\\", ".").replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";"
    }
    
    def generate(out, className, fields,table) {
        out.println "package $packageName"
        out.println ""
        out.println "import javax.persistence.*;"
        //out.println "import javax.persistence.Column;"
        //out.println "import javax.persistence.Entity;"
        //out.println "import javax.persistence.Table;"
        //out.println "import java.io.Serializable;"
        //out.println "import lombok.Getter;"
        //out.println "import lombok.Setter;"
        //out.println "import lombok.ToString;"
        Set types = new HashSet()
    
        fields.each() {
            types.add(it.type)
        }
    
        if (types.contains("Date")) {
            out.println "import java.util.Date;"
        }
    
        if (types.contains("InputStream")) {
            out.println "import java.io.InputStream;"
        }
        out.println ""
        out.println "/**\n" +
                " * @Description  \n" +
                " * @Author  lqk\n" +
                " * @Date "+ new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " \n" +
                " */"
        out.println ""
        //out.println "@Setter"
        //out.println "@Getter"
        //out.println "@ToString"
        out.println "@Entity"
        out.println "@Table ( name =\""+table.getName() +"\" )"
        out.println "public class $className  {"
        //out.println ""
        //out.println genSerialID()
        fields.each() {
            out.println ""
            // 输出注释
            if (isNotEmpty(it.commoent)) {
                out.println "\t/**"
                out.println "\t * ${it.commoent.toString()}"
                out.println "\t */"
            }
    
            if (it.annos != "") out.println "   ${it.annos.replace("[@Id]", "")}"
    
            // 输出成员变量
            out.println "\tprivate ${it.type} ${it.name};"
        }
    
        // 输出get/set方法
    //    fields.each() {
    //        out.println ""
    //        out.println "\tpublic ${it.type} get${it.name.capitalize()}() {"
    //        out.println "\t\treturn this.${it.name};"
    //        out.println "\t}"
    //        out.println ""
    //
    //        out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"
    //        out.println "\t\tthis.${it.name} = ${it.name};"
    //        out.println "\t}"
    //    }
        out.println ""
        out.println "}"
    }
    
    def calcFields(table) {
        DasUtil.getColumns(table).reduce([]) { fields, col ->
            def spec = Case.LOWER.apply(col.getDataType().getSpecification())
    
            def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value
            def comm =[
                    colName : col.getName(),
                    name :  javaName(col.getName(), false),
                    type : typeStr,
                    commoent: col.getComment(),
                    annos: "\t@Column(name = \""+col.getName()+"\" )"]
            if("id".equals(Case.LOWER.apply(col.getName())))
                comm.annos +=["@Id"]
            fields += [comm]
        }
    }
    
    // 处理类名(这里是因为我的表都是以t_命名的,所以需要处理去掉生成类名时的开头的T,
    // 如果你不需要那么请查找用到了 javaClassName这个方法的地方修改为 javaName 即可)
    def javaClassName(str, capitalize) {
        def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
                .collect { Case.LOWER.apply(it).capitalize() }
                .join("")
                .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
        // 去除开头的T  http://developer.51cto.com/art/200906/129168.htm
        //s = s[1..s.size() - 1]
        capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
    }
    
    def javaName(str, capitalize) {
    //    def s = str.split(/(?<=[^\p{IsLetter}])/).collect { Case.LOWER.apply(it).capitalize() }
    //            .join("").replaceAll(/[^\p{javaJavaIdentifierPart}]/, "_")
    //    capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
        def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
                .collect { Case.LOWER.apply(it).capitalize() }
                .join("")
                .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
        capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
    }
    
    def isNotEmpty(content) {
        return content != null && content.toString().trim().length() > 0
    }
    
    static String changeStyle(String str, boolean toCamel){
        if(!str || str.size() <= 1)
            return str
    
        if(toCamel){
            String r = str.toLowerCase().split('_').collect{cc -> Case.LOWER.apply(cc).capitalize()}.join('')
            return r[0].toLowerCase() + r[1..-1]
        }else{
            str = str[0].toLowerCase() + str[1..-1]
            return str.collect{cc -> ((char)cc).isUpperCase() ? '_' + cc.toLowerCase() : cc}.join('')
        }
    }
    
    static String genSerialID()
    {
        return "\tprivate static final long serialVersionUID =  "+Math.abs(new Random().nextLong())+"L;"
    }

    生成VO类的文件,右键新建另外一个比如我的叫做:VOGeneratePOJOs.groovy,里面内容如下:

    import com.intellij.database.model.DasTable
    import com.intellij.database.model.ObjectKind
    import com.intellij.database.util.Case
    import com.intellij.database.util.DasUtil
    import java.io.*
    import java.text.SimpleDateFormat
    
    /*
     * Available context bindings:
     *   SELECTION   Iterable<DasObject>
     *   PROJECT     project
     *   FILES       files helper
     */
    packageName = ""
    typeMapping = [
            (~/(?i)tinyint|smallint|mediumint/)      : "Integer",
            (~/(?i)int/)                             : "Long",
            (~/(?i)bool|bit/)                        : "Boolean",
            (~/(?i)float|double|decimal|real/)       : "Double",
            (~/(?i)datetime|timestamp|date|time/)    : "Date",
            (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
            (~/(?i)/)                                : "String"
    ]
    
    
    FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->
        SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
    }
    
    def generate(table, dir) {
        def className = javaClassName(table.getName(), true) + "VO"
        def fields = calcFields(table)
        packageName = getPackageName(dir)
        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File(dir, className + ".java")), "UTF-8"))
        printWriter.withPrintWriter {out -> generate(out, className, fields,table)}
    
    //    new File(dir, className + ".java").withPrintWriter { out -> generate(out, className, fields,table) }
    }
    
    // 获取包所在文件夹路径
    def getPackageName(dir) {
        return dir.toString().replaceAll("\\\\", ".").replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";"
    }
    
    def generate(out, className, fields,table) {
        out.println "package $packageName"
        out.println ""
        //out.println "import javax.persistence.*;"
        //out.println "import javax.persistence.Column;"
        //out.println "import javax.persistence.Entity;"
        //out.println "import javax.persistence.Table;"
        //out.println "import java.io.Serializable;"
        //out.println "import lombok.Getter;"
        //out.println "import lombok.Setter;"
        //out.println "import lombok.ToString;"
        Set types = new HashSet()
    
        fields.each() {
            types.add(it.type)
        }
    
        if (types.contains("Date")) {
            out.println "import java.util.Date;"
        }
    
        if (types.contains("InputStream")) {
            out.println "import java.io.InputStream;"
        }
        out.println ""
        out.println "/**\n" +
                " * @Description  \n" +
                " * @Author  lqk\n" +
                " * @Date "+ new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " \n" +
                " */"
        out.println ""
        //out.println "@Setter"
        //out.println "@Getter"
        //out.println "@ToString"
        //out.println "@Entity"
        //out.println "@Table ( name =\""+table.getName() +"\" )"
        out.println "public class $className {"
        //out.println ""
        //out.println genSerialID()
        fields.each() {
            out.println ""
            // 输出注释
            if (isNotEmpty(it.commoent)) {
                //out.println "\t/**"
                //out.println "\t * ${it.commoent.toString()}"
                //out.println "\t */"
            }
    
            //if (it.annos != "") out.println "   ${it.annos.replace("[@Id]", "")}"
    
            // 输出成员变量
            out.println "\tprivate ${it.type} ${it.name};"
        }
    
        // 输出get/set方法
    //    fields.each() {
    //        out.println ""
    //        out.println "\tpublic ${it.type} get${it.name.capitalize()}() {"
    //        out.println "\t\treturn this.${it.name};"
    //        out.println "\t}"
    //        out.println ""
    //
    //        out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"
    //        out.println "\t\tthis.${it.name} = ${it.name};"
    //        out.println "\t}"
    //    }
        out.println ""
        out.println "}"
    }
    
    def calcFields(table) {
        DasUtil.getColumns(table).reduce([]) { fields, col ->
            def spec = Case.LOWER.apply(col.getDataType().getSpecification())
    
            def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value
            def comm =[
                    colName : col.getName(),
                    name :  javaName(col.getName(), false),
                    type : typeStr,
                    commoent: col.getComment(),
                    annos: "\t@Column(name = \""+col.getName()+"\" )"]
            if("id".equals(Case.LOWER.apply(col.getName())))
                comm.annos +=["@Id"]
            fields += [comm]
        }
    }
    
    // 处理类名(这里是因为我的表都是以t_命名的,所以需要处理去掉生成类名时的开头的T,
    // 如果你不需要那么请查找用到了 javaClassName这个方法的地方修改为 javaName 即可)
    def javaClassName(str, capitalize) {
        def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
                .collect { Case.LOWER.apply(it).capitalize() }
                .join("")
                .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
        // 去除开头的T  http://developer.51cto.com/art/200906/129168.htm
        //s = s[1..s.size() - 1]
        capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
    }
    
    def javaName(str, capitalize) {
    //    def s = str.split(/(?<=[^\p{IsLetter}])/).collect { Case.LOWER.apply(it).capitalize() }
    //            .join("").replaceAll(/[^\p{javaJavaIdentifierPart}]/, "_")
    //    capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
        def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
                .collect { Case.LOWER.apply(it).capitalize() }
                .join("")
                .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
        capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
    }
    
    def isNotEmpty(content) {
        return content != null && content.toString().trim().length() > 0
    }
    
    static String changeStyle(String str, boolean toCamel){
        if(!str || str.size() <= 1)
            return str
    
        if(toCamel){
            String r = str.toLowerCase().split('_').collect{cc -> Case.LOWER.apply(cc).capitalize()}.join('')
            return r[0].toLowerCase() + r[1..-1]
        }else{
            str = str[0].toLowerCase() + str[1..-1]
            return str.collect{cc -> ((char)cc).isUpperCase() ? '_' + cc.toLowerCase() : cc}.join('')
        }
    }
    
    static String genSerialID()
    {
        return "\tprivate static final long serialVersionUID =  "+Math.abs(new Random().nextLong())+"L;"
    }



     

    展开全文
  • VO类时,继承基础类,是最简单的vo类写法,但是在用mybatisplus时候,就不太好查询,通过这个转换器,可以 进行查询基础类,通过mybatisplus,在转换成VO类 基础实体类示例 @Data @TableName("table_test") public...

    java实体类转换器


    写VO类时,继承基础类,是最简单的vo类写法,但是在用mybatisplus时候,就不太好查询,通过这个转换器,可以 进行查询基础类,通过mybatisplus,在转换成VO类
    基础实体类示例

    @Data
    @TableName("table_test")
    public class Test{
    	private Integer id;
    	private String name;
    }
    

    vo类示例

    @Data
    @TableName("table_test")
    public class TestVo extends Test{
    	private AAA aaa;
    }
    

    转换示例

    Test test = (mybatisplus查询语句)
    TestVo testvo = generalConvertor.convertor(test,TestVo.class);
    

    转换器代码,

    package com.zst.aim.config;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Set;
    import java.util.TreeSet;
    
    import javax.annotation.Resource;
    
    import org.springframework.stereotype.Component;
    
    import com.github.dozermapper.core.Mapper;
    
    /**
     * @Description:生成实体类
     */
    @Component
    public class GeneralConvertor {
    
        @Resource
        private Mapper mapper;
    
        /**
         * List 实体类 转换器
         *
         * @param source 原数据
         * @param clz    转换类型
         * @param <T>
         * @param <S>
         * @return
         */
        public <T, S> List<T> convertor(List<S> source, Class<T> clz) {
            if (source == null || source.size() == 0) {
                return null;
            }
            List<T> map = new ArrayList<>();
            for (S s : source) {
                map.add(mapper.map(s, clz));
            }
            return map;
        }
    
        /**
         * Set 实体类 深度转换器
         *
         * @param source 原数据
         * @param clz    目标对象
         * @param <T>
         * @param <S>
         * @return
         */
        public <T, S> Set<T> convertor(Set<S> source, Class<T> clz) {
            if (source == null || source.size() == 0) {
                return null;
            }
            Set<T> set = new TreeSet<>();
            for (S s : source) {
                set.add(mapper.map(s, clz));
            }
            return set;
        }
    
        /**
         * 实体类 深度转换器
         *
         * @param source
         * @param clz
         * @param <T>
         * @param <S>
         * @return
         */
        public <T, S> T convertor(S source, Class<T> clz) {
            if (source == null) {
                return null;
            }
            return mapper.map(source, clz);
        }
    
        public void convertor(Object source, Object object) {
            mapper.map(source, object);
        }
    
        public <T> void copyConvertor(T source, Object object) {
            mapper.map(source, object);
        }
    
    }
    
    
    展开全文
  • 简单易用的vo类

    2020-09-26 23:53:14
    简单易用的vo类 说明: 不考虑很多情况,我们可以使用下面的类作为vo视图解析对象 只可以测试用,或者学习ajax整合springboot小项目,自己方便的时候使用 Msg package com.shaoming.model.vo; import java.util....

    简单易用的vo类

    说明:

    不考虑很多情况,我们可以使用下面的类作为vo视图解析对象

    只可以测试用,或者学习ajax整合springboot小项目,自己方便的时候使用

    Msg

    package com.shaoming.model.vo;
    
    import java.util.HashMap;
    import java.util.Map;
    
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
    
    @ApiModel("视图返回对象,jsonresult")
    public class Msg {
    	// 状态码 100 成功 200 失败
    	@ApiModelProperty(value = "响应码")
    	private int code;
    	// 提示信息
    	@ApiModelProperty(value = "提示信息")
    	private String msg;
    	// 用户要返回给客户端的数据
    	@ApiModelProperty(value = "数据信息")
    	private Map<String, Object> data = new HashMap<String, Object>();
    
    	// 当前对象添加用户要返回给客户端的数据
    	public Msg add(String key, Object value) {
    		this.getData().put(key, value);
    		return this;
    	}
    
    	// 执行成功
    	public static Msg success() {
    		Msg result = new Msg();
    		result.setCode(100);
    		result.setMsg("执行成功!");
    		return result;
    	}
    
    	// 执行失败
    	public static Msg fail() {
    		Msg result = new Msg();
    		result.setCode(200);
    		result.setMsg("执行失败!");
    		return result;
    	}
    
    	public int getCode() {
    		return code;
    	}
    
    	public void setCode(int code) {
    		this.code = code;
    	}
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    
    	public Map<String, Object> getData() {
    		return data;
    	}
    
    	public void setData(Map<String, Object> data) {
    		this.data = data;
    	}
    }
    
    
    展开全文
  • 结论:解决VO类属性与要返回的json串字段名称不一样的问题,需要用到@JsonProperty(“xxx”)这个注解 那具体怎么使用呢?下面我拿我个人的例子来说明。 需要返回的json串字段格式如下: { "code": 0, "msg": ...

    结论:解决VO类属性与要返回的json串字段名称不一样的问题,需要用到@JsonProperty(“xxx”)这个注解

    那具体怎么使用呢?下面我拿我个人的例子来说明。

    需要返回的json串字段格式如下:

    在这里插入图片描述

    {
        "code": 0,
        "msg": "成功",
        "data": [
            {
                "name": "热榜",
                "type": 1,
                "foods": [
                    {
                        "id": "123456",
                        "name": "皮蛋粥",
                        "price": 1.2,
                        "description": "好吃的皮蛋粥",
                        "icon": "http://xxx.com",
                    }
                ]
            }
    

    但可以明显看到,有两个名称一样的name字段。会让人容易混淆。

    所以在VO类,我们具体的来写,如:categoryName,productNam。这样写,就可以达到见名知意的效果。

    那么问题来了,你这样写VO类的属性,返回的json串字段,也会是categoryName,productNam。

    这样就会与我们想要返回的两个name字段不一致。

    那么在不改json串两个name名称的情况下,如何达到categotyName在转json的串的时候是name呢?

    这就要用到@JsonProperty("name")

    案例解决方法

    在VO类的categoryName属性上面加上@JsonProperty("name")注解。

    这样做,就会将VO类的categoryName属性在转json串的时候,字段名称不会是CategotyName,而是注解中的name。

    这样,会与要求返回的name是一样的了,前端可以接收到相应的数据,而VO类属性,也能达到见名知意效果。

    具体代码

    ProductInfoVO

    /**
     * Created by 李柏霖
     * 2020/10/17 21:20
     */
    
    package com.lbl.VO;
    
    import com.fasterxml.jackson.annotation.JsonProperty;
    import lombok.Data;
    
    import java.math.BigDecimal;
    
    @Data
    public class ProductInfoVO {
    
        @JsonProperty("id")
        private String productiId;
        @JsonProperty("name")
        private String productnName;
        @JsonProperty("price")
        private BigDecimal productPrice;
        @JsonProperty("description")
        private String productDescription;
        @JsonProperty("icon")
        private String productIcon;
    }
    

    ProductVO

    /**
     * 商品(包含类目)
     * Created by 李柏霖
     * 2020/10/17 21:12
     */
    
    package com.lbl.VO;
    
    import com.fasterxml.jackson.annotation.JsonProperty;
    import lombok.Data;
    
    import java.util.List;
    
    @Data
    public class ProductVO {
    
        @JsonProperty("name")
        private String categoryName;
    
        @JsonProperty("type")
        private Integer categoryType;
    
        @JsonProperty("foods")
        private List<ProductInfoVO> productInfoVOList;
    }
    

    ResultVO

    /**
     * http请求返回的最外层对象
     * Created by 李柏霖
     * 2020/10/17 20:45
     */
    
    package com.lbl.VO;
    
    import lombok.Data;
    
    @Data
    public class ResultVO<T> {
    
        //错误码
        private Integer code;
        //提示信息
        private String msg;
        //返回的具体内容
        private T data;
    }
    

    BuyerProductController

    (这边只是返回json字段名,并没有加真实数据,单纯为了验证json串格式)

    /**
     * 买家商品
     * Created by 李柏霖
     * 2020/10/17 20:11
     */
    
    package com.lbl.controller;
    
    import com.lbl.VO.ProductInfoVO;
    import com.lbl.VO.ProductVO;
    import com.lbl.VO.ResultVO;
    import com.lbl.dataObject.ProductCategory;
    import com.lbl.dataObject.ProductInfo;
    import com.lbl.service.ICategoryService;
    import com.lbl.service.IProductService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @RestController
    @RequestMapping("/buyer/product")
    public class BuyerProductController {
    
        @Autowired
        IProductService productService;
    
        @Autowired
        ICategoryService categoryService;
    
        @GetMapping("/list")
        public ResultVO list(){
            //1.查询所有的上架商品
            List<ProductInfo> productInfoList = productService.findUpAll();
            //2.查询类目(一次性查询)
            List<ProductCategory> categoryList = new ArrayList<>();
    
            //3.数据拼装
    
    
            //最外层(1层)
            ResultVO<Object> resultVO = new ResultVO<>();
            resultVO.setCode(0);
            resultVO.setMsg("成功");
            //类目层(2层)
            ProductVO productVO = new ProductVO();
            //商品详情层(3层)
            List<ProductInfoVO> productInfoVOList=new ArrayList<>();
            ProductInfoVO productInfoVO = new ProductInfoVO();
            productInfoVOList.add(productInfoVO);
    
    
    
    
            //在1层拼接2层
            resultVO.setData(productVO);
            //在类(在2层拼接3层)
            productVO.setProductInfoVOList(productInfoVOList);
            return resultVO;
        }
    }
    

    页面效果:

    (这边只是返回json字段名,并没有加真实数据,单纯为了验证json串格式)

    在这里插入图片描述

    展开全文
  • vo类,model类,dto类的作用及划分 1、entity里的每一个字段,与数据库相对应, 2、dto里的每一个字段,是和你前台页面相对应, 3、VO,这是用来转换从entity到dto,或者从dto到entity的中间的东西。 举个例子: 你...
  • 在前后分离的时候,后台会接受前台传来的不同类型的参数,后台需要继承多种数据的类去承接,这就是VO类,他里面可以包含某些类或者某些成员变量,直接上例子: public class TongJivo { private Material ...
  • 定义vo类和JSON转换工具类

    千次阅读 2019-01-11 11:06:38
    通过JSON自动的处理机制需要进行多层VO对象的取得,这样的做法在实际工作中比较麻烦,也不建议使用,所以此时如果是一个单独的VO对象则可以自己编写一个程序. 定义BO与JSON的转换处理 package mao.shu.util; import...
  • Java 的 VO类

    万次阅读 多人点赞 2018-02-02 12:31:44
    今天,遇到一个操作,要在页面上查看一些固定的信息,用到了VO类和 从内存中加载数据。下面说一下 VO类。 首先,java有几种对象(PO,VO,DAO,BO,POJO) 一、PO:persistant object 持久对象,可以看成是与数据库中的表相...
  • POJO与VO类区别 POJO:实体类与数据库中的表一一对应,实体类属性与数据库表的字段一一对应。—— 用于数据层 VO:用于需要把某页面的所有数据封装起来。—— 用于表示层,逻辑层 如果在一个页面中需要获取三张表...
  • --Vo类与实体l类互相转换 --> <dependency> <groupId>net.sf.dozer</groupId> <artifactId>dozer</artifactId> <version>5.4.0</version> <!-- 排除 slf4j ...
  • IDEA-lombok插件,实体类,VO类注解@Data无法导包,使用(附解决办法)学习目标前言引起原因:如图所示(两个)解决方法1解决方法2解决方法3总结 前言 希望:2021新的一年,想要的都拥有,得不到的都释怀! 引起...
  • Java 前后端交互的通用VO类

    千次阅读 2019-08-07 15:36:20
    日常开发中,经常会遇到前后端交互的时候,后端返回前端数据的问题,通常的做法是在Controller里将需要的数据以JSON的格式返回,但是为了系统更加的有条理性,也为了异常排查问题方便,我们整合一个交互VO类(顺便...
  • Java DAO模式 VO类设计

    千次阅读 2018-04-17 23:05:36
    程序严格来讲分为四个层次:显示层、控制层、业务层、数据...随即想到用简单JAVA(po、to、pojo、vo)实现。java的(PO,VO,TO,BO,DAO,POJO)解释:https://www.cnblogs.com/yxnchinahlj/archive/2012/02/24/2366110.ht...
  • VO类和实体类的转换是我们写业务逻辑代码中很经常用到的东西,最近我们项目组规定统一用mapstruct来做,mapstruct是在程序编译的时候就已经生成了VO类和实体类的转换类,这样子就不用在程序运行的时候才去转换,减少...
  • 关于mybatis的resultMap映射VO类

    千次阅读 2019-05-22 19:19:50
    今天的模块需要用到多表联查,将查到的结果放到一个新的实体中,而这几张表的主键我需要用到,难过的是多个表的主键名都是 id ,这就导致新的实体中多个表的主键字段名无法区分,最后再查询语句中加入别名以区分...
  • 根据表名自动生成VO,快速搞定VO类

    千次阅读 2018-05-03 14:36:19
    SELECT '/*** ' || c.comments || '*/ ' || '@Column(name = "' || A.COLUMN_NAME || '") ' || decode(a.DATA_TYPE, 'DATE', 'private Date', 'NUMBER'...
  • 如果泛泛来分,VO可以分为2:特征点法和直接法,可以参考《十四讲》的分类方法;细分的话,可以把SVO算作第三,但其实SVO可以算作直接法的特殊形式或者将特征点和直接法相结合的结果。这三种方法各有什么特点?...
  • 映射到Lists中,在关系中创建实体对象 然后写Mapper.xml映射,resultMap和association(巨容易写错) type和javaType要带路径 column和数据库列名一致 property要和实体成员变量完全一致 id标签似乎是去重? ...
  • pojo类和vo类分别是什么

    千次阅读 2018-03-13 16:01:54
    vo有两种说法,一个是viewObject,一个是valueObject.. 就拿前者来说吧,它只负责封装页面传递过来的数据,这和PO有些不同 就拿struts1来说,ActionForm就是一个典型的viewObject. 而valueObject是页面与页面之间的传递...
  • 增删改都涉及的是单表,而只有查询操作既可以设计到单表操作又可以涉及到多表操作,所以对于输入映射...但是太麻烦了 所以可以用resultMap,把实体表映射到关系表,即在关系表orders的中定义private User user;
  • 为了保证VO类的序列化一致,只需在VO类中加入private static final long serialVersionUID = -8940196742313994740L;这样的声明代码即可。这个在Eclipse的默认设置中是会以黄叹号的形式显示在类名出,点击叹号...
  • spring-data-jpa实现vo类的动态添加查询

    千次阅读 2019-03-14 16:08:22
    最近开始使用spring-data-jpa,它对于实体的基本查询非常方便,vo查询还是需要写sql,动态条件的查询则需要继承JpaSpecificationExecutor<T>来实现,网上例子非常多。这里找到一个封装不错的例子,配置查询...
  • /** * 使用 JpaRepository 实现多表连查,返回自定义vo类 * 1.dao的方法名,禁止使用find一类的开头,不然会报错,因为,Jparepository会根据find等关键词自动映射sql,这个机制导致报错 * 2.@Query nativeQuery = ...
  • 日期转换写了一大推,不如一个@JsonFormat来的省时省劲! @Column(name = "UPLOAD_TIME") @Temporal(TemporalType.DATE) @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") ...
  • ----使用MyEclipse自动生成Hibernate映射文件和VO类及无主键生成2个VO类的问题 ----MyEclipse 10 1.切换MyEclipse Database Explorer环境 new一个Driver,以Oracle数据库举例,在完善信息并引入jar后,点击Test ...
  • 1.增加了Vo类的生成,其实思路很简单,利用生成的entity实体类,复制一份,替换掉其中的几个关键字就可以了。 2.可以根据表名,根据参数判断是否去掉前缀,然后根据剩余部分自动生成包名,在批量生成时更好的区分每...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,919
精华内容 20,767
关键字:

Vo类