这是JPA 关系映射 系列教程的第一篇：JPA One-To-One 外键关系映射

JPA 关系映射系列（SPring Boot, Postgresql）：

1. JPA One-To-One 外键 关系映射
2. JPA One-To-Many 关系映射
3. JPA Many-To-Many 关系映射

为了完成这边教程你所需要的工具如下：

Spring Data JPA
Spring Boot
Postgresql 数据库

如何在ubuntu下安装Postgresql以及图形界面客户端PgAdmin3，请戳我

项目依赖

<?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.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.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-jdbc</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.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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


</project>

One To One 关系：
在这里 我们使用 book 以及 book_detail 来描述一对一的关系。

Selection_054.png

下面我们来看看如果使用 Spring Boot 来定义实体映射：

package com.example.demo;

import javax.persistence.*;

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    private String name;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "book_detail")
    private BookDetail bookDetail;

    public Book() {
    }

    public Book(String name, BookDetail bookDetail) {
        this.name = name;
        this.bookDetail = bookDetail;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public BookDetail getBookDetail() {
        return bookDetail;
    }

    public void setBookDetail(BookDetail bookDetail) {
        this.bookDetail = bookDetail;
    }
}

package com.example.demo;

import javax.persistence.*;

@Entity
public class BookDetail {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;


    private long numberOfPages;


   @OneToOne(cascade = CascadeType.ALL,mappedBy = "bookDetail")
    private Book book;

    public BookDetail() {
    }

    public BookDetail(long numberOfPages, Book book) {
        this.numberOfPages = numberOfPages;
     
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public long getNumberOfPages() {
        return numberOfPages;
    }

    public void setNumberOfPages(long numberOfPages) {
        this.numberOfPages = numberOfPages;
    }

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }
}

在 Spring Boot 中所有的实体类都需要用注解 @Entity 来标记,被这个注解标记的实体类将会在数据库中生成一个对应的 Table。表名通常情况下以类名作为默认表名, 当然你也可以指定一个已经存在的表来对应这个实体类。比如:

            @Entity
            @Table(name ="book_specific")

@Id 标记一个字段为 主键(Primary Key). 当一个主键字段被定义的时候,主键的值将会被 ObjectDB 自动注入到这个字段中。

@GeneratedValue 通常情况下,关系数据库会为每一个数据库维护一个特殊的全局数字生成器。这个数字生成器会自动为每一个没有定义主键字段的实体对象生成一个 ID。

    @Id
    @GeneratedValue
    private long id;

在commit期间, AUTO策略使用全局数字生成器为每个新的实体对象生成主键。这些生成的值在数据库级别是唯一的,不会被
回收,这些主键值被多个表共享 。

简单的来解释一下这里所谓的主键值被多个表共享是什么意思，
    例如我们现在一个数据库，里面有两张表 A1 跟 A2。
A1里面有三条数据 A11 A12 A13
A2里面有三条数据 A21 A22 A23，
每一个表的每一条数据的主键id通常情况是自增加的，
所以理论上的A11 的主键id=1，A12的主键id=2，A13的主键id=3
所以理论上的A21 的主键id=1，A22的主键id=2，A23的主键id=3

但是如果你使用AUTO的策略的话，主键的增加是根据你将数值插入数据库的顺序来决定的。
如果你先在A1表中插入 A11 A12 A13三条数据，然后在A2表中插入A21 A22 A23三条数据
那们的主键的id就会变成 
A11 的主键id=1，A12的主键id=2，A13的主键id=3
A21 的主键id=4，A22的主键id=5，A23的主键id=6
如果你两个表是相互交替的插入数据，那么主键的生成也是相互的交替的，
    这就导致了每一张表的主键ID都不一定是从1开始增加的
    这取决你插入数据的顺序

这就是所谓的主键值被多个表共享

所以通常情况下我们为了保证每一个表的主键ID都从一开始增加，我们需要设置
@GeneratedValue(strategy=GenerationType.IDENTITY

关于JPA中主键的生成策略，一共有四种模式:
@GeneratedValue(strategy=GenerationType.AUTO)
@GeneratedValue(strategy=GenerationType.IDENTITY)
@GeneratedValue(strategy=GenerationType.SEQUENCE)
@GeneratedValue(strategy=GenerationType.TABLE)

如果大家对这方面感兴趣的话，请点击关注楼主，或者给楼主留言，楼主会考虑写一篇专门的文章来讲解JPA中主键的生成策略。

@OneToOne 在两个实体之间定义了一对一的关系,这里Book与BookDetail是一对一的关系。
mappedBy=”bookDetail” 定义了两张表之间由谁来维护彼此的关系。这里表示由Book这张表来维护两者之间的关系。这里
BookDetail类中的mappeBy的值 bookDetail 是实体类Book中对BookDetail的引用字段名。当我们定义了mappedBy属性之后, JPA就会在Book表中新增加一列bookDetail,它的值就是BookDetail表中的主键值。
@JoinColumn 通常情况下，如果不指定这个属性，那么JPA会默认帮你在Book类中新增一列以bookDetail为默认名字，如果你指定了这个属性，那么JPA会按照你给的属性命为新增的一列命名。

当然了关于@JoinColumn以及mappendBy这两个属性的用法不仅仅与此，事实上他们是JPA中关系映射非常重要的注解方法。
当然本文不在讨论范围之类。在之后的OneToMany以及 ManyToMany 教程中中我会详细的讨论这两个属性

当然了如果你这么定义：

class Book(){
    
@OneToOne(cascade = CascadeType.ALL,mappedBy = "book")

private BookDetail bookDetail; 

}

class BookDetail(){

@OneToOne(cascade = CascadeType.ALL)
@JoinColumn(name = "book_id")
private Book book;

}

也是可以的，只不过这回在BookDetail表中新增加的一列，他的值就是Book表中的主键值。 这一次有BookDetail来维护两个表之间的关系。

在OneToOne关系中，谁来维护关系并不是特别重要，因为两者是等价的，你可以引用我的主键，同样我也可以引用你的主键。 因此这跟OneToMany 和 ManyToMany是不一样的。 例如在OneToMany中，关系的维护方永远是Many的那一方。比如班级跟学生就是一对多的关系，这个时候就必须要在学生表中引用班级的主键作为一列。 因为我们的表是不能保存集合的关系。 在班级表中，每一个班级都有很多学生，这是一个集合，这没有办法用数据库在保存。 但是在学生表中，每一个学生都对应唯一一个班级。 所以我们可以引用班级的主键作为学生表的外键。 这就是为什么在一对多一方，关系的维护者永远是Many的那一方了。

对于OneToMany 和 ManyToMany的关系映射，是这一系列教程的后两篇文章。 稍后我会详细解释这两种映射关系

下一步我们需要给Spring Boot配置数据库,以便它能够连接到我们的数据库:
在Spring Boot的application.properties中添加以下语句:

# ===============================
# = DATA SOURCE
# ===============================
# Set here configurations for the database connection
spring.datasource.url=jdbc:postgresql://localhost:5432/jpa1
spring.datasource.username=postgres
spring.datasource.password=9145190618
spring.datasource.driver-class-name=org.postgresql.Driver
# Keep the connection alive if idle for a long time (needed in production)
spring.datasource.testWhileIdle=true
spring.datasource.validationQuery=SELECT 1
# ===============================
# = JPA / HIBERNATE
# ===============================
# Show or not log for each sql query
spring.jpa.show-sql=true
# Hibernate ddl auto (create, create-drop, update): with "create-drop" the database
# schema will be automatically created afresh for every start of application
spring.jpa.hibernate.ddl-auto=create-drop

# Naming strategy
spring.jpa.hibernate.naming.implicit-strategy=org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyHbmImpl
spring.jpa.hibernate.naming.physical-strategy=org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy

# Allows Hibernate to generate SQL optimized for a particular DBMS
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect


#There is also a /shutdown endpoint, but its only visible by default via JMX. To enable it as an HTTP endpoint, add endpoints.shutdown.enabled=true to your application.properties file.
endpoints.shutdown.enabled=true

如果你没有实现创建数据库,那么你需要手动用图形GUI或者在命令行中创建数据库

pring.datasource.url=jdbc:postgresql://localhost:5432/jpa 指明了数据库为jpa,监听端口为5432,这是Postgresql数据库的默认监听端口。

这里pring.jpa.hibernate.ddl-auto可以是none,update,create,create-drop,有关详细信息,请参考Hibernate文档。

        none: 这的默认值,不改变数据库结构。(一般在部署阶段,可以使用这个模式)
        update: Hibernate根据给定的实体结构更改数据库。
        create: 每次创建数据库,但不要在关闭时丢弃。
        create-drop: 创建数据库,然后在SessionFactory关闭时将其删除(在开发阶段,可以使用这个方式,因为每次程序启动时候   都会删除已有的数据,在重新创建)。我们这里从创建开始,因为我们还没有数据库结构。第一次运行后,我们可以根据程序要求将其切换为更新或无更新。当您想对数据库结构进行一些更改时,请使用更新。    

我们运行程序的时候,我们可以看到:数据库中已经自动创建了两张表了:

Book 表

BookDetail 表

最右边是外建，其值为book表中主键的id值

Spring Data JPA 包含了一些内置的Repository实现了一些常用的操作数据库的功能， 比如：findOne， findAll， save 等等。下面根据上面两个实体类，我们在通过JPA提供给我们的Repository来简单的操作我们的数据库。

我们所需要做的事情就是为我们的实体类 Book 和 BookDetail 建立对应的Repository接口：

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface BookDetailRepository extends JpaRepository<BookDetail, Long> {
}

下面我们运行APP来使用Repository新建数据库数据：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.ArrayList;
import java.util.List;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    @Autowired
    BookRepository bookRepository;

    @Autowired
    BookDetailRepository bookDetailRepository;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... strings) throws Exception {


        List<Book> books = new ArrayList<>();
        books.add(new Book("Book A", new BookDetail(49)));
        books.add(new Book("Book B", new BookDetail(59)));
        books.add(new Book("Book C", new BookDetail(69)));
        bookRepository.save(books);

    }
}

运行结果：

Selection_060.png

Selection_061.png

如果喜欢这篇文章，请给楼主点个赞或者加个关注。下次给大家带来的是JPA One-To-Many 关系映射 以 及JPA Many-To-Many 关系映射

源码已经分享在Github