SpringBoot05 数据操作04 -> JPA实体类注解、springboot测试类、lombok的使用

最新推荐文章于 2023-10-30 17:00:39 发布
最新推荐文章于 2023-10-30 17:00:39 发布
阅读量195 收藏
点赞数
文章标签： java 数据库 开发工具
原文链接：http://www.cnblogs.com/NeverCtrl-C/p/8176353.html
版权

前提准备：

　　搭建一个springboot项目，详情请参见其它博客：点击前往

　　　

1 引入相关依赖

　　web、mysql、jpa、lombok

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.xiangxu</groupId>
    <artifactId>springboottest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboottest</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--工具相关-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <!--<dependency>-->
            <!--<groupId>org.projectlombok</groupId>-->
            <!--<artifactId>lombok</artifactId>-->
        <!--</dependency>-->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>
pom.xml

 

2 创建数据库表并利用工具生成实体类

　　详情参见其它博客：点击前往

package cn.xiangxu.springboottest.model;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "girl")
public class GirlModel {
    @Id
    private Integer girlId;

    private Integer age;

    private String name;

    public Integer getGirlId() {
        return girlId;
    }

    public void setGirlId(Integer girlId) {
        this.girlId = girlId;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    @Override
    public String toString() {
        return "GirlModel{" +
                "girlId=" + girlId +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
View Code

　　2.1 JPA

　　　　JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中

　　　　特点01：支持利用注解的形式实现实体类和数据库表之间的映射关系，框架会根据这个关系将实体对象持久化到数据库中

　　　　特点02：JPA已经提供了一些基本的数据操作API，开发者无需写任何代码就可以实现单表的CRUD

　　　　特点03：面向对象进行数据操作而不是面向数据库查询语言进行数据库操作

　　　　百度百科：点击前往

　　2.2 JPA相关的实体注解

　　　　2.2.1 @Entity

　　　　　　标记在类上，作为实体类的标识；有了这个注解后spring容器会自动对这个实体类进行扫描

　　　　　　技巧01：可以指定名称，例如 -> @Entity(name = "girl")

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Entity {
    String name() default "";
}
源码
　　　　2.2.2 @Table

　　　　　　当数据库中的表和实体类的类名不一致时需要用到这个注解

　　　　　　技巧01：数据库表明如果是 test_girl 实体类名是 TestGirl 时就认为数据库表名和实体类名是一致的

　　　　　　技巧02：指定数据库表名名称，例如 -> @Table(name = "girl")

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
    String name() default "";

    String catalog() default "";

    String schema() default "";

    UniqueConstraint[] uniqueConstraints() default {};

    Index[] indexes() default {};
}
View Code
　　　　2.2.3 @Id

　　　　　　标记在实体类的字段上，指明哪个字段是数据表对应的主键

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Id {
}
View Code
　　　　2.2.4 @GeneratedValue

　　　　　　标记在主键字段上，用于指定主键值的生成策略

　　　　　　技巧01：@GeneratedValue(strategy=GenerationType.AUTO) 也是默认策略， 即写成@GeneratedValue也可； 类似于hibernate的native策略，生成方式取决于底层的数据库。 
　　　　　　技巧02：@GeneratedValue(strategy = GenerationType.IDENTITY)指定“自动增长”策略，适用于MySQL； 
　　　　　　技巧03：@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = “seq_tbl_person”)指定“序列”策略，常用于Oracle，其中generator表示生成器的名字。而且还要指定@SequenceGenerator(name = “seq_tbl_person”, sequenceName = “seq_tbl_person”, allocationSize = 1)注解配合使用 
其中name指定生成器的名字（与generator的值一样），sequenceName指定数据库中定义序列的名字，allocationSize指定序列每次增长1

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface GeneratedValue {
    GenerationType strategy() default GenerationType.AUTO;

    String generator() default "";
}
View Code
　　　　2.2.5 @Column

　　　　　　标记在属性上，用于指定一些约束或者解决属性名和字段名的不一致问题；该注解有以下属性：

　　　　　　　　name：指定数据库表中的字段名称，当实体类的属性名称和数据库表的字段名称不一致时需要使用；但是利用工具生成的实体类一般不需要这个属性

　　　　　　　　unique：字段唯一约束，默认为false

　　　　　　　　nullable：字段非空约束，默认为true

　　　　　　　　insertable：该字段是否支持插入操作，默认为true

　　　　　　　　updatable：该字段是否支持更新操作，默认为true

　　　　　　　　columnDefinition：指明该字段在数据库中的类型，一般的类型在数据库中使用相应的类型进行对应的，但是Date类型需要指定，因为在数据库中有DATE，TIME两种类型

　　　　　　　　length：指定该属性的长度，仅对string类型的属性有效

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    String name() default "";

    boolean unique() default false;

    boolean nullable() default true;

    boolean insertable() default true;

    boolean updatable() default true;

    String columnDefinition() default "";

    String table() default "";

    int length() default 255;

    int precision() default 0;

    int scale() default 0;
}
View Code
　　　　2.2.6 @OrderBy

　　　　　　加载数据时指定顺序

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OrderBy {
    String value() default "";
}
View Code
　　　　2.2.7 @Transient

　　　　　　指定该属性不是数据库表的映射字段

　　　　　　技巧01：如果一个属性并非数据库表的字段映射。就务必将其标示为@Transient。否则。ORM框架默认其注解为@Basic

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Transient {
}
View Code
　　　　2.2.8 @OneToOne

　　　　　　描述一对一关联

　　　　　　待更新...2018年1月2日10:54:18

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OneToOne {
    Class targetEntity() default void.class;

    CascadeType[] cascade() default {};

    FetchType fetch() default FetchType.EAGER;

    boolean optional() default true;

    String mappedBy() default "";

    boolean orphanRemoval() default false;
}
View Code
　　　　2.2.9 @ManyToOne

　　　　　　描述多对一关联

　　　　　　待更新...2018年1月2日10:54:18

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ManyToMany {
    Class targetEntity() default void.class;

    CascadeType[] cascade() default {};

    FetchType fetch() default FetchType.LAZY;

    String mappedBy() default "";
}
View Code
　　　　2.2.10 @OneToMany

　　　　　　描述一对多关联 待更新...2018年1月2日10:54:18

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OneToMany {
    Class targetEntity() default void.class;

    CascadeType[] cascade() default {};

    FetchType fetch() default FetchType.LAZY;

    String mappedBy() default "";

    boolean orphanRemoval() default false;
}
View Code
　　　　2.2.11 @ManyToMany

　　　　　　描述多对多关联 待更新...2018年1月2日10:54:18

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OneToMany {
    Class targetEntity() default void.class;

    CascadeType[] cascade() default {};

    FetchType fetch() default FetchType.LAZY;

    String mappedBy() default "";

    boolean orphanRemoval() default false;
}
View Code
　　　　2.2.12 @JoinColumn

　　　　　　待更新...2018年1月2日10:54:18

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface JoinColumn {
    String name() default "";

    String referencedColumnName() default "";

    boolean unique() default false;

    boolean nullable() default true;

    boolean insertable() default true;

    boolean updatable() default true;

    String columnDefinition() default "";

    String table() default "";

    ForeignKey foreignKey() default @ForeignKey;
}
View Code
　　　　2.2.13 @MappedSuperclass

　　　　　　待更新...2018年1月2日10:54:18

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MappedSuperclass {
}
View Code
　　　　2.2.14 @Embedded

　　　　　　待更新...2018年1月2日10:54:18

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.persistence;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Embedded {
}
View Code

　　　　参考文档：点击前往

 

3 编写持久层接口

　　请参见其他博客：点击前往

 　　技巧01：必须进行数据库链接配置，因为我们导入了数据库连接的相关依赖，springboot项目的@EnableAutoConfiguration注解会自动根据依赖进行自动配置，如果找不到连接信息就会抛出异常

4 编写测试类

　　右键 -> go to -> test

　　ctrl + shift + t

　　技巧01：在测试类上添加 @RunWith(SpringRunner.class) 和 @SpringBootTest

　　技巧02：可在测试类中依赖注入容器中的bean，具体的测试方法和junit一样

package cn.xiangxu.springboottest.dao;

import cn.xiangxu.springboottest.model.GirlModel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

import java.util.List;

import static org.junit.Assert.*;

@RunWith(SpringRunner.class)
@SpringBootTest
public class GirlDaoTest {

    @Resource
    private GirlDao girlDao;

    @Test
    public void test01() {
        System.out.println("测试方法");
        Assert.assertNotEquals(3, 4);
    }

    @Test
    public void findAll() {
        List<GirlModel> girlModelList = girlDao.findAll();
        System.out.println(girlModelList);
        for (GirlModel girlModel : girlModelList) {
            System.out.println(girlModel);
        }
    }



}
View Code

　　

 

5 lombok的使用

　　lombok是一个工具，导入lombok的依赖后就可以利用注解来代替一些简单的代码　

　　5.1 使用lombok的坑

　　　　在使用了 lombok 注解，并且导入相关jar包后，通过IDEA运行时会出错；因为lombok会在项目进行打包时自动给添加了lombok注解的地方添加相应的代码，但是我们通过IDEA运行springboot项目时还未进行打包操作，所以会报错；通常的做法是在IDEA中安装一个插件

　　　　安装插件的教程：点击前往

　　5.2 lombok提供了很多的注解，三少常用的注解如下：

　　　　@Data -> 标注在实体类上回自动生成equals()、hashCode()、toString()、get方法、set方法【实体类神器注解】　　

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package lombok;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
public @interface Data {
    String staticConstructor() default "";
}
View Code

　　　　@Getter -> 仅仅生成get方法

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package lombok;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
public @interface Getter {
    AccessLevel value() default AccessLevel.PUBLIC;

    Getter.AnyAnnotation[] onMethod() default {};

    boolean lazy() default false;

    /** @deprecated */
    @Deprecated
    @Retention(RetentionPolicy.SOURCE)
    @Target({})
    public @interface AnyAnnotation {
    }
}
View Code

　　　　@Setter -> 仅仅生成set方法

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package lombok;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
public @interface Setter {
    AccessLevel value() default AccessLevel.PUBLIC;

    Setter.AnyAnnotation[] onMethod() default {};

    Setter.AnyAnnotation[] onParam() default {};

    /** @deprecated */
    @Deprecated
    @Retention(RetentionPolicy.SOURCE)
    @Target({})
    public @interface AnyAnnotation {
    }
}
View Code

　　　　@Slf4j -> 日志对象

　　　　　　具体用法请参见博客：点击前往　　

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package lombok.extern.slf4j;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.TYPE})
public @interface Slf4j {
    String topic() default "";
}
View Code

　　　　其他注解请参见：官网、博客

 

转载于:https://www.cnblogs.com/NeverCtrl-C/p/8176353.html

weixin_30376163
关注
【SpringBoot】76、SpringBoot中使用JPA作为数据持久化框架
Asurplus
03-16 9万+
JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
SpringBoot 整合mybatis，mybatis-plus
热门推荐
congge_study的博客
06-23 2万+
SpringBoot 整合mybatis，mybatis-plus
springboot实体类Lombok简化、CRUD操作、业务层快速开发
LXZ_1024的博客
04-06 830
文章目录一、Lombok工具二、2.数据层开发——基础CRUD三、业务层快速开发 一、Lombok工具 实体类的开发可以自动通过工具手工生成get/set方法，然后覆盖toString()方法，方便调试，等等。不过这一套操作书写很繁琐，有对应的工具可以帮助我们简化开发，介绍一个小工具，lombok。 Lombok，一个Java类库，提供了一组注解，简化POJO实体类开发，SpringBoot目前默认集成了lombok技术，并提供了对应的版本控制，所以只需要提供对应的坐标即可，在pom.xml中添加lomb
springboot 实体类
剑指天下的博客
04-20 2322
@Data @ToString @TableName("drug") public class Drug { @TableId(type = IdType.AUTO) private Integer id; @TableField("imagesAddress") private String imagesAddress; @TableField("imPr...
SpringBoot实体类——VO/DTO/PO简单总结
tang_seven的博客
03-13 1万+
简单记录一下springboot后端开发中的实体类VO、DTO、PO等的使用
springboot配置实体类
weixin_45493295的博客
07-24 831
//方法一，通过配置config来配置实体类 @Configuration @PropertySource(value="classpath:pay.properties") public class WXConfig implements Serializable { @Value("${wxpay.appid}") private String payAppid; } //方法二，通过controller层直接引用 @RestController @RequestMapping("a.
spring-boot 开发项目 - 实体类
weixin_45229417的博客
04-21 1633
本文章记录在利用spring-boot开发相应的一些通常的操作，仅为自己在下次开发项目时调用。 1 实体类 序列化 // 序列化 public class entity implements Serializable{ // 反序列化之后进行id确认，假如id不确认时则不进行序列化 private static final long serialVersionUID=1L; } 2.@Data属性 lombok包下的 集合了@Getter @Setter @RequiredArgsConstruc
springboot使用jpa绑定mysql空间数据geometry到实体类
ununie的博客
08-06 3394
业务需求读取mysql中的空间数据。但又不知道如何把空间数据绑定到java实体类的字段上。找了很多资料，在此做个总结。 参考： https://stackoverflow.com/questions/44068177/hibernate-spatial-mysql-5-7 https://blog.csdn.net/dream8062/article/details/80363198 ...
springboot中使用Spring Data Jpa
daimenglaoshi的博客
12-04 847
ORM即Object-Relationl Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了 。在ORM出现之前，我们是用jdbc来操作数据库，但jdbc没有封装，对于大项目来说，使用复杂，也难以实现MVC的概念，所以人们就开发了ORM框架来解决这些问题。比如Hibernate，Mybatis，不过Hibernate是完全的ORM框架，mybatis是半ORM框架，因为它需要手动建表和自
7.springboot中整合Jpa多数据源
daimenglaoshi的博客
12-05 878
在使用Mybatis时会涉及多数据源的问题，同样，当我们使用Jpa作为持久化处理方式时，也会涉及多数据源的问题，本节我们来讲解一下Springboot如何整合Spring data Jpa多数据源。添加lomboc，web，spring data jpa, mysql依赖默认Mysql驱动时8，如果本机安装的Mysql是5，需要手动修改版本 ，修改后的依赖信息如下： 添加 Druid连接池依赖 创建好的项目结构如下:boot1和boot2application.properties中配置两个数据源 4.创
Struts 2 基本语法
Be_Proud的博客
12-19 799
struts2的三要素：JSP视图部分、业务控制器Action、配置struts.xml
SpringBoot个人博客开发（十一）----实体类构建
ce121的博客
07-04 889
在项目目录下新建一个包PersisentObject po层，装载的是实体类。在其中创建 Blog类 在Blog类中创建主键等 private Long id; private String title; @Basic(fetch = FetchType.EAGER) @Lob private String content; private String firstPicture; private String flag; private Inte
SpringBoot 八 创建实体类Entity
weixin_38628400的博客
08-11 1万+
src/main/java :主程序入口Application，可以通过直接运行该类来启动 Spring Boot 应用。 * 1创建时需要在com.example.demo项目下新建一个 domain 包 一般用来存放实体类 然后在该包下 新建实体类Company.class * 知识点 1）@开头表示注解 但IDEA约定大于配置 所以也相当于声明(应该是这样) // @Entity 声明这是一个实体类 //@Table(name = “company”) 表示要创建的表 叫company 一般与类
SpringBoot开源项目个人博客——(5)创建实体类
qq_45678967的博客
05-30 1124
SpringBoot开源项目个人博客——(5)创建实体类
从零开始的Spring Boot实体类之旅：知识点全解析
最新发布
那仰望的人，心底的孤独和叹息
10-30 2885
Springboot实体类entity相关知识点详解：@Data @AllArgsConstructor @NoArgsConstructor @EqualsAndHashCode ；@TableName @TableId @TableField @Accessors(chain = true) 注解的详细用处解读；属性的注释自动生成问题；java序列化反序列化，实体类实现Serializable接口，指定serialVersionUID的值，JSON序列化与反序列化，jackson库及JsonUtil
springBoot项目中怎么简化实体类
weixin_44950062的博客
08-27 261
@Data 这个注解可以省去大量的get 和set方法 使用步骤 1. 导入依赖 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.16.20</version> </dependency>
使用SpringBoot配置信息修改服务器配置
黑马程序员官方博客
07-20 2596
SpringBoot还提供了将配置文件中的数据封装到我们自定义的实体类对象中的方式。具体操作如下将实体类bean的创建交给Spring管理。在类上添加@Component注解使用注解表示加载配置文件在该注解中也可以使用prefix属性指定只加载指定前缀的数据在中进行注入Enterprise}}";}}使用第三种方式，在实体类上有如下警告提示这个警告提示解决是在pom.xml中添加如下依赖即可...
springboot第25集：实体类定义规则
程序员哆啦A梦，蓝胖子
06-08 1053
PO：持久化对象，一个PO对象对应一张表里面的一条记录。全部对应VO：View视图对象，用来在页面中展示数据的，页面需要哪些字段属性就添加哪些，查询出来之后赋值操作比PO对象要简单。所以提高性能。DTO：数据传递对象，如果要查询的结果集有多张表，或者从多个表获得的数据就可以封装DTO对象，把这些表的数据全部封装到一起，形成一个对象。POJO：中间形态，可以在PO，VO，DTO之间互相转换。POJO...
【springboot】项目中的实体类PO,BO,DTO,VO的区别和作用
橙子的博客
01-31 4794
VO，BO，PO，DTO这样分层还是很有意义的。尤其在团队成员较多的情况下，结构更加一目了然，同时也能很大程度避免多端系统数据所需不一致时，有人修改属性影响其他页面。但也完全没有必要教条主义，把这些全部用上，需要根据所开发的业务复杂度来取舍，如果本身业务逻辑不负责，照搬全上反而让开发变的更复杂。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值