spring data jpa使用，转：http://www.manongjc.com/article/25284.html#four_1_7

2024-03-30 15:45•html•阅读 2779

时间:2018-12-18

本文章向大家介绍Jap相关的使用，主要包括Jap相关的使用使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

目录
一、Jpa的概念
二、Jpa的相关注解描述
三、Jpa中类实体的实现以及映射关系的实现
四、具体代码实现数据的保存、修改、查询
- 1、springboot+jap相关配置以及代码实现
- 2、spring+jpa整合

一、jpa的概念

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。主要作用是简化JavaEE和JavaSE的应用开发，还有就是对ORM技术的整合。Hibernate 从3.2开始，就开始兼容JPA。Hibernate3.2获得了Sun TCK的JPA(Java Persistence API)兼容认证。其实如果对hibernate比较熟的，对于理解和应用JPA来说其实就没有多大困难了！,这里就不对Hibernate进行具体的介绍了。下文中用的全部为注释进行操作的，这里就不进行一一解说了。

二、jpa的相关注解描述

注解	作用
@Basic	基本注解，默认有
@Entity	指出该Java类为实体类，将映射到指定的数据库
@Table	标注常用name属性，用于指定数据库的表的名称
@Id	主键的映射
@GeneratedValue	用于标注主键的生成策略，通过strategy属性指定
@Column	映射数据表的列名，指定unique，length等
@Temporal	在属性上调整精度，比如Date
@Transient	忽略该属性，不需要映射到数据表的一列，否则默认为@Basic
@JoinColumn	用来映射外键
@JoinTable	插入表多用于多对多或者一对多
@OneToOne	映射一对一的关系
@OneToMany	映射少对多的关系
@ManyToOne	映射多对少的关系
@ManyToMany	映射多对对的关系

@Table的常用属性：
- name : 用来命名当前实体类对应的数据库表的名字
- uniqueConstraints : 用来批量命名唯一键
- catalog : 实体指定的目录名或是数据库名
- schema : 实体指定的目录名或是数据库名
@Entity的常用属性：
- name : 实体的名称
@GeneratedValue的常用属性:
- strategy : ID的生成策略
  - GenerationType.IDENTITY 主键由数据库自动生成（主要是自动增长型）
  - GenerationType.AUTO 主键由程序控制
  - GenerationType.TABLE 使用一个特定的数据库表格来保存主键
  - GenerationType.SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列
@Column相关属性：
- name : 对应的列表的名称
- unique : 是否是唯一
- nullable : 是否为空
- length : 长度
- insertable : 是否插入表
- updatable :是否更新表
@Temporal
- value : TemporalType.DATE,TemporalType.TIME,TemporalType.TIMESTAMP,以上三个参数分别表示年月日、时分秒、年与日时分秒
@JoinColumn部分参数:
- name : 表的名称，一般情况下默认，但是多对多的时候第三方表的时候需要填写
- referencedColumnName : 产生外键，依据的列的名称
@OneToOne、@OneToMany、@ManyToMany、@ManyToOne相关参数：
- targetEntity : 变量对应的类
- cascade : 关联级别
- fetch : 加载方式 FetchType.EAGER数据同步加 FetchType.LAZY 懒加载，使用的时候才会加载
- optional : 当其为false 真实关系必须存在当其为true 可以不存在
- mappedBy : 放弃对外键的维护，数值为本类中在外键维护类中的变量名称
- orphanRemoval : 当执行级联操作删除时，如果此为true 那么就把关系被维护端的数据实体删除，false 不删除，删除的只是关系

三、jpa中类实体的映射关系

实体关系映射，简化编程操作，把冗余的操作交给底层框架来处理。只要我们把实体关系的映射写清楚，那么就不用过多的考虑sql语句的关系了。

1、一对一映射(@OneToOne)

一对一关系，说白了就是一个萝卜一个坑，这里例子是Student<----->Car,一个学生只有一辆车，一辆车的归属只是一个学生(当然学生可以没有车，车也可以不属于任何学生）,如果关系必须存在的话,需要设置@OneToOne的属性optional

 @OneToOne(optional = false)

Car的实例代码：

@Entity(name = "car")
@Table(name = "car",uniqueConstraints = {@UniqueConstraint(columnNames = {"license_plate"})})
public class Car {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer carId;
    @Column(name = "license_plate")
    private String licensePlate;
    @Column(name = "car_name")
    private String carName;
    @Column(name = "car_color")
    private String carColor;
    @OneToOne
    @JoinColumn(name = "sid",referencedColumnName = "id")
    private Student student;
    .......get和set方法
}

Student的实现：

@Entity(name = "student")
@Table(name ="student" ,catalog = "smartdot")
public class Student {
    @Id
    //生成策略
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column(name = "class_num")
    private String  class_num;
    @Column(name = "student_name")
    private String  student_name;
    @Column(
            name = "student_num",//对应的列表的名称
            unique = true,//是否为唯一
            nullable = false,//是否为空
            length = 20,//长度
            insertable = true,//是否插入表
            updatable = true)//是否更新表
    private String  student_num;
    @Temporal(TemporalType.TIMESTAMP)
    private Date  date;
    /**
     * fetch 属性为：
     *      FetchType.EAGER   数据同步加载
     *      FetchType.LAZY    懒加载，使用的时候才会加载
     * mappedBy 属性为:
     *     定义类之间的双向关系。如果类之间是单向关系，不需要提供定义，
     *     如果类和类之间形成双向关系.我们就需要使用这个属性进行定义，
     *     否则可能引起数据一致性的问题。该属性的值是“多”方class里的“一”方的变量名。
     *
     * targetEntity:
     *     定义关系类的类型，默认是该成员属性对应的类类型，所以通常不需要提供定义。
     * cascade 级联操作:
     *      CascadeType.PERSIST  级联新建
     *      CascadeType.REMOVE   级联删除
     *      CascadeType.REFRESH  级联刷新
     *      CascadeType.MERGE    级联更新
     *      CascadeType.ALL      级联以上全部
     * orphanRemoval :
     *      当执行级联操作删除时，如果此为true
     *      那么就把关系被维护端的数据实体删除，
     *      false 不删除，删除的只是关系
     */

    @OneToOne(cascade = {CascadeType.ALL},orphanRemoval = true)
    @JoinColumn(name = "car_id",referencedColumnName = "carid")
    private Car car;
    .......get和set方法
}

2、一对多映射(@OneToMany和@ManyTone)

一对多关系即数据库中的一行数据关联另一个数据库中的多行关系,多对一与之相反。举个具体的例子，现在有100本书，有10个学生，分给10个学生那么每一本书肯定属于一个学生，每个学生有多本书。所以他们的对应关系为:

Student-----OneToMany----->Book

Book-----ManyToOne----->Student

@ManyToOne 以在Collection、Set、List、Map上使用，我们可以根据业务需要选择。Collection类是Set和List的父类，在未确定使用Set或List时可使用；

Set集合中对象不能重复，并且是无序的;List集合中的对象可以有重复，并且可以有排序；

Book的实现代码:

@Entity(name = "book")
@Table(name = "book")
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    /*
    TABLE：使用一个特定的数据库表格来保存主键。
    SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
    IDENTITY：主键由数据库自动生成（主要是自动增长型）
    AUTO：主键由程序控制
    */
    private Integer bookId;
    @Column(name = "book_name",unique = false,nullable = false)
    private String bookName;
    @Column(name = "book_price",unique = false,nullable = false)
    private String bookPrice;
    @Column(name = "book_color",unique = false,nullable = false)
    private String bookColor;
    @ManyToOne(fetch = FetchType.LAZY,optional = true,cascade = {CascadeType.MERGE,CascadeType.PERSIST })
    @JoinColumn(name="sid")
    private Student student;
    .......get和set方法
}

Student的实现代码：

@Entity(name = "student")
@Table(name ="student" ,catalog = "smartdot")
public class Student {
    @Id
    //生成策略
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column(name = "class_num")
    private String  class_num;
    @Column(name = "student_name")
    private String  student_name;
    @Column(
            name = "student_num",//对应的列表的名称
            unique = true,//是否为唯一
            nullable = false,//是否为空
            length = 20,//长度
            insertable = true,//是否插入表
            updatable = true)//是否更新表
    private String  student_num;
    @Temporal(TemporalType.TIMESTAMP)
    private Date  date;
    @OneToMany(targetEntity = Book.class,fetch=FetchType.EAGER, orphanRemoval = false,cascade={CascadeType.ALL })
    @JoinColumn(name = "sid",referencedColumnName = "id")
    //注意这里需要初始化
    private Set<Book> books = new HashSet<>();
    .......get和set方法
}

3、多对多映射关系(@ManyToMany)

多对多关系是关系数据库中两个表之间的一种关系，该关系中第一个表中的一个行可以与第二个表中的一个或多个行相关。第二个表中的一个行也可以与第一个表中的一个或多个行相关。举个简单的例子：一个学生可以报考多门课程、每一门课程有很多学生报考，学生和课程之间产生了多对多的关系，需要注意的是在多对多关系的中，我们需要让其中的一方放弃对外键的维护，下面的例子中，课程放弃了对外键的维护。

Student的实现：

@Entity(name = "student")
@Table(name ="student" ,catalog = "smartdot")
public class Student {
    @Id
    //生成策略
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column(name = "class_num")
    private String  class_num;
    @Column(name = "student_name")
    private String  student_name;
    @Column(
            name = "student_num",//对应的列表的名称
            unique = true,//是否为唯一
            nullable = false,//是否为空
            length = 20,//长度
            insertable = true,//是否插入表
            updatable = true)//是否更新表
    private String  student_num;
    @Temporal(TemporalType.TIMESTAMP)
    private Date  date;

    @ManyToMany(targetEntity = Course.class,cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinTable(name = "student_course_mapping",
            joinColumns = {@JoinColumn(name = "s_id")},
            inverseJoinColumns = {@JoinColumn(name = "c_id")})
    private Set<Course> courses = new HashSet<>();
    .......get和set方法

Course的实现：

@Entity
@Table(name = "course")
public class Course {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column(name = "course_credit")
    private String  course_credit;
    @Column(name = "course_name")
    private String  course_name;
    //放弃  外键的维护
    //mappedBy声明于关系的被维护方，声明的值为关系的维护方的关系对象属性名
    @ManyToMany(fetch = FetchType.LAZY,mappedBy = "courses")
    private Set<Student> students = new HashSet<>();
    .......get和set方法
}

4、单向与双向关联的简介

本文从头到尾所有的示例，使用的都是双向关联。即在关联双方都进行关联声明。而事实上，除了双向关联，还有一种用法是单向关联。即在关联的其中一方进行关联。其实可以简单的理解为Student中有Car的变量，但是Car中没有Student的变量，这时候就是单向关联。这样的话student中有外键只想Car但是Car就不会在产生外键了。

四、具体代码实现数据的保存、修改、查询

1、springboot+jap相关配置：

1.1相关的pom.xml，通过maven导入包

<?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>com.smartdot</groupId>
    <artifactId>springbootjap</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>springbootjap Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.smartdot.com</url>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--springboot的相关-->
        <!--spring-boot-starter-web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--spring-boot-starter-test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>compile</scope>
        </dependency>
        <!--spring-boot-starter-aop-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--spring-boot-configuration-processor-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-jpa -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
        </dependency>
        <!--spring boot web依赖包-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>compile</scope>
        </dependency>
        <!--jstl包-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <scope>compile</scope>
        </dependency>

        <!-- =========数据库相关======================== -->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
        </dependency>

上一篇 »转：spring mvc model.addAttribute页面c:forEach取不到
下一篇 »，转PHP中isset(和unset(函数的用法小结

spring data jpa使用，转：http://www.manongjc.com/article/25284.html#four_1_7

目录

一、Jpa的概念

二、Jpa的相关注解描述

三、Jpa中类实体的实现以及映射关系的实现

1、一对一映射(@OneToOne)

2、一对多映射(@OneToMany和@ManyTone))

3、多对多映射关系(@ManyToMany)

4、单向与双向关联的简介

四、具体代码实现数据的保存、修改、查询

1、springboot+jap相关配置以及代码实现

1.1相关的pom.xml，通过maven导入包

1.2 数据库配置

1.3 Jpa的pojo和repository的配置

1.4创建Student的Repository

1.5完成数据库的增删改查的代码具体实现

1.6 为单个Repository添加自定义方法

1.7 使用@Query增加原生的sql语句查询hql语句查询

2、spring+jpa整合

一、jpa的概念

二、jpa的相关注解描述

三、jpa中类实体的映射关系

1、一对一映射(@OneToOne)

2、一对多映射(@OneToMany和@ManyTone)

3、多对多映射关系(@ManyToMany)

4、单向与双向关联的简介

四、具体代码实现数据的保存、修改、查询

1、springboot+jap相关配置：

1.1相关的pom.xml，通过maven导入包

spring data jpa使用 ，转：http://www.manongjc.com/article/25284.html#four_1_7

目录

一、jpa的概念

二、jpa的相关注解描述

三、jpa中类实体的映射关系

1、一对一映射(@OneToOne)

2、一对多映射(@OneToMany和@ManyTone)

3、多对多映射关系(@ManyToMany)

4、单向与双向关联的简介

四、具体代码实现数据的保存、修改、查询

1、springboot+jap相关配置：

1.1相关的pom.xml，通过maven导入包

相关推荐

JavaScript编码规范

网页特殊符号HTML代码，转

QtCreator Local and Expression 界面为空，转 原始链接；http://www.cnblogs.com/daizhe11/archive/2013/10/25/3387496.htmlQt Creator 调试器 在 Ubuntu 13.10下 局部变量和表达式

.net 时间戳和日期互转 【转】http://www.cnblogs.com/zhuiyi/p/5307540.html

SpringMVC配置数据库连接池 http://www.cnblogs.com/coqn/archive/2012/08/15/SpringMvc%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA%E9%85%8D%E7%BD%AE.htmlSpringMvc环境搭建，配置文件 spring配置：context:property-placeholder 读取配置文件信息 在配置文件中使用el表达式填充值

li标签之间的空隙问题，转 原文地址：http://www.cnblogs.com/laogao/archive/2012/08/13/2636419.htmlcss li 空隙问题

【转】Python将列表数据写入文件，txt, csv，excel

Web 前沿——HTML5 Form Data 对象的使用

spring data jpa使用，转：http://www.manongjc.com/article/25284.html#four_1_7

QtCreator Local and Expression 界面为空，转原始链接；http://www.cnblogs.com/daizhe11/archive/2013/10/25/3387496.htmlQt Creator 调试器在 Ubuntu 13.10下局部变量和表达式

.net 时间戳和日期互转【转】http://www.cnblogs.com/zhuiyi/p/5307540.html

SpringMVC配置数据库连接池 http://www.cnblogs.com/coqn/archive/2012/08/15/SpringMvc%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA%E9%85%8D%E7%BD%AE.htmlSpringMvc环境搭建，配置文件 spring配置：context:property-placeholder 读取配置文件信息在配置文件中使用el表达式填充值

li标签之间的空隙问题，转原文地址：http://www.cnblogs.com/laogao/archive/2012/08/13/2636419.htmlcss li 空隙问题