JPA作持久層操作 - tw511教學網

JPA（Hibernate是jpa的實現）

jpa是對實體類操作，從而通過封裝好的介面直接設定資料庫的表結構。雖然jpa可以直接通過編寫java程式碼來運算元據庫表結構，避免了sql的編寫，但別忘了需要先建立jpa需要操作的資料庫並更改組態檔到該資料庫，jpa不能建庫！！！

國外比較流行jpa，國內更加流行mybatis，因為mybatis直接運算元據庫容易懂和後期維護一點。（其實是國內程式設計師亂搞，國外的比較有規矩）

本文只介紹了jpa的基本使用操作以及基本語法

JPA VS Mybatis

大專案用mybatis，小專案（微服務：小程式等）用JPA （JPA方便，但大專案到後期需要從sql語句上優化時JPA無法優化）

JPA操作

jpa是javax包下的，所以後面導包的時候注意一下，別導錯了。只有事務、Param的導包是導spring框架下的

匯入依賴

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

設定設定yaml

spring:
  jpa:
		#開啟SQL語句執行紀錄檔資訊
    show-sql: true	//生產環境下就改成false吧，true沒必要
    hibernate:
    	#設定為自動建立
      ddl-auto: update

建立實體類

@Data
@Entity   //表示這個類是一個實體類 javax包下的
@Table(name = "users")    //對應的資料庫中表名稱 javax包下的
public class Account {

    @GeneratedValue(strategy = GenerationType.IDENTITY)   //生成策略，這裡設定為自增
    @Column(name = "id")    //對應表中id這一列
    @Id     //此屬性為主鍵
    int id;

    @Column(name = "username")   //對應表中username這一列
    String username;

    @Column(name = "password")   //對應表中password這一列
    String password;
}

建立repo包，建Repository類

每一個表都要設定相應的Repository實現類，service層可以通過該類物件運算元據庫（因為該類封裝了運算元據庫的方法集）

如果需要的操作沒有被封裝，還可以在Repository類中用已經封裝的方法自定義新的方法（自定義規則在下面）

注：JpaRepository有兩個泛型，前者是具體操作的物件實體，也就是對應的表，後者是ID的型別

@Repository	//別忘了注入bean
public interface AccountRepository extends JpaRepository<Account, Integer> {	//<A,B>A中是表的實體類，B是ID的型別
    
}

呼叫方法執行sql

@Resource
AccountRepository accountRepository;


void pageAccountService() {
    accountRepository.findById(1).ifPresent(System.out::println);
}

補充：

在Repository中根據方法名稱拼接自定義sql

例子：

repository：

@Repository
public interface AccountRepository extends JpaRepository<Account, Integer> {

    Account findByIdAndUsername(int id, String username);
  //可以使用Optional類進行包裝，Optional<Account> findByIdAndUsername(int id, String username);
    
    //方法名稱拼接自定義模糊查詢
    List<Account> findAllByUsernameLike(String str);
}

service：

@Resource
AccountRepository accountRepository;


void pageAccountService(String str) {
     accountRepository.findAllByUsernameLike("%str%").forEach(System.out::println); //不建議這種模糊查詢，建議用原生sql的concat，以免sql注入
}

方法拼接規則：

雖然介面預置的方法使用起來非常方便，但是如果我們需要進行條件查詢等操作或是一些判斷，就需要自定義一些方法來實現，同樣的，我們不需要編寫SQL語句，而是通過方法名稱的拼接來實現條件判斷，這裡列出了所有支援的條件判斷名稱：

`Distinct`	`findDistinctByLastnameAndFirstname`	`select distinct … where x.lastname = ?1 and x.firstname = ?2`
`And`	`findByLastnameAndFirstname`	`… where x.lastname = ?1 and x.firstname = ?2`
`Or`	`findByLastnameOrFirstname`	`… where x.lastname = ?1 or x.firstname = ?2`
`Is`，`Equals`	`findByFirstname`,`findByFirstnameIs`,`findByFirstnameEquals`	`… where x.firstname = ?1`
`Between`	`findByStartDateBetween`	`… where x.startDate between ?1 and ?2`
`LessThan`	`findByAgeLessThan`	`… where x.age < ?1`
`LessThanEqual`	`findByAgeLessThanEqual`	`… where x.age <= ?1`
`GreaterThan`	`findByAgeGreaterThan`	`… where x.age > ?1`
`GreaterThanEqual`	`findByAgeGreaterThanEqual`	`… where x.age >= ?1`
`After`	`findByStartDateAfter`	`… where x.startDate > ?1`
`Before`	`findByStartDateBefore`	`… where x.startDate < ?1`
`IsNull`，`Null`	`findByAge(Is)Null`	`… where x.age is null`
`IsNotNull`，`NotNull`	`findByAge(Is)NotNull`	`… where x.age not null`
`Like`	`findByFirstnameLike`	`… where x.firstname like ?1`
`NotLike`	`findByFirstnameNotLike`	`… where x.firstname not like ?1`
`StartingWith`	`findByFirstnameStartingWith`	`… where x.firstname like ?1`（引數與附加`%`繫結）
`EndingWith`	`findByFirstnameEndingWith`	`… where x.firstname like ?1`（引數與字首`%`繫結）
`Containing`	`findByFirstnameContaining`	`… where x.firstname like ?1`（引數繫結以`%`包裝）
`OrderBy`	`findByAgeOrderByLastnameDesc`	`… where x.age = ?1 order by x.lastname desc`
`Not`	`findByLastnameNot`	`… where x.lastname <> ?1`
`In`	`findByAgeIn(Collection<Age> ages)`	`… where x.age in ?1`
`NotIn`	`findByAgeNotIn(Collection<Age> ages)`	`… where x.age not in ?1`
`True`	`findByActiveTrue()`	`… where x.active = true`
`False`	`findByActiveFalse()`	`… where x.active = false`
`IgnoreCase`	`findByFirstnameIgnoreCase`	`… where UPPER(x.firstname) = UPPER(?1)`

完全自定義sql

JPQL操作實體類，從而運算元據庫

比如我們要更新使用者表中指定ID使用者的密碼：

@Repository
public interface AccountRepository extends JpaRepository<Account, Integer> {

    @Transactional    //DML操作需要事務環境，可以不在這裡宣告在方法前宣告，但是呼叫時一定要處於事務環境下
    @Modifying     //表示這是一個DML操作
    @Query("update Account set password = ?2 where id = ?1") //這裡操作的是一個實體類對應的表，引數使用?代表，後面接第n個引數
    int updatePasswordById(int id, String newPassword);
    
    //@Query("update Account set password = :password where username = :name")  這樣寫也可以
    int updatePasswordByUsername(@Param("name") String username,   //我們可以使用@Param指定名稱
                             @Param("password") String newPassword);
}

@Test
void updateAccount(){
    repository.updatePasswordById(1, "654321");
}

原生SQL直接運算元據庫

實現根據使用者名稱稱修改密碼：

@Transactional
@Modifying
@Query(value = "update users set password = :password where username = :name", nativeQuery = true) //使用原生SQL，除了預留位置不同其他和Mybatis一樣，這裡使用 :名稱 表示引數，當然也可以繼續用上面那種方式。
int updatePasswordByUsername(@Param("name") String username,   //我們可以使用@Param指定名稱
                             @Param("password") String newPassword);

@Test
void updateAccount(){
    repository.updatePasswordByUsername("Admin", "654321");
}

JPA關聯查詢

對一：會在寫了註解（@OneToOne @MangToOne）的類中建立欄位。對多：需要多的那方原本就有欄位，才可以用該欄位對應註解這方的主鍵

一對一

而使用者資訊和使用者詳細資訊之間形成了一對一的關係，那麼這時我們就可以直接在類中指定這種關係：

@Data
@Entity
@Table(name = "users")
public class Account {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    @Id
    int id;

    @Column(name = "username")
    String username;

    @Column(name = "password")
    String password;

    @JoinColumn(name = "detail_id")   //指定儲存外來鍵的欄位名稱。在本表中建立detail_id，並外來鍵連線AccountDetail表的主鍵id
    @OneToOne    //宣告為一對一關係  
    AccountDetail detail; 
    //執行程式碼：alter table users add constraint xxxxx foreign key (detail_id) references users_detail (id)
}

在修改實體類資訊後，我們發現在啟動時也進行了更新，紀錄檔如下：

Hibernate: alter table users add column detail_id integer
Hibernate: create table users_detail (id integer not null auto_increment, address varchar(255), email varchar(255), phone varchar(255), real_name varchar(255), primary key (id)) engine=InnoDB
Hibernate: alter table users add constraint FK7gb021edkxf3mdv5bs75ni6jd foreign key (detail_id) references users_detail (id)

測試查詢：

@Test
void pageAccount() {
    repository.findById(1).ifPresent(System.out::println);
}

結果：在建立關係之後，我們查詢Account物件時，會自動將關聯資料的結果也一併進行查詢。

Hibernate: select account0_.id as id1_0_0_, account0_.detail_id as detail_i4_0_0_, account0_.password as password2_0_0_, account0_.username as username3_0_0_, accountdet1_.id as id1_1_1_, accountdet1_.address as address2_1_1_, accountdet1_.email as email3_1_1_, accountdet1_.phone as phone4_1_1_, accountdet1_.real_name as real_nam5_1_1_ from users account0_ left outer join users_detail accountdet1_ on account0_.detail_id=accountdet1_.id where account0_.id=?
Account(id=1, username=Test, password=123456, detail=AccountDetail(id=1, address=四川省成都市青羊區, [email protected], phone=1234567890, realName=本偉))

懶載入

不想載入外來鍵表的資訊時，可以設定懶載入，這樣只有在需要時才會向資料庫獲取：

設定懶載入後，使用懶載入設定過的屬性時的方法需要在事務環境下獲取（因為repository方法呼叫完後Session會立即關閉

@JoinColumn(name = "detail_id")
@OneToOne(fetch = FetchType.LAZY)    //將獲取型別改為LAZY
AccountDetail detail;

接著我們測試一下：（測試類裡開啟事務會自動回滾，不想回滾則在方法前加@Commit。當然畢竟是測試類還是建議保留自動回滾）

@Transactional   //懶載入屬性需要在事務環境下獲取，因為repository方法呼叫完後Session會立即關閉
@Test
void pageAccount() {
    repository.findById(1).ifPresent(account -> {
        System.out.println(account.getUsername());   //獲取使用者名稱
        System.out.println(account.getDetail());  //獲取詳細資訊（懶載入）
    });
}

接著我們來看看控制檯輸出了什麼：可以看到，獲取使用者名稱之前，並沒有去查詢使用者的詳細資訊，而是當我們獲取詳細資訊時才進行查詢並返回AccountDetail物件。

Hibernate: select account0_.id as id1_0_0_, account0_.detail_id as detail_i4_0_0_, account0_.password as password2_0_0_, account0_.username as username3_0_0_ from users account0_ where account0_.id=?
Test
Hibernate: select accountdet0_.id as id1_1_0_, accountdet0_.address as address2_1_0_, accountdet0_.email as email3_1_0_, accountdet0_.phone as phone4_1_0_, accountdet0_.real_name as real_nam5_1_0_ from users_detail accountdet0_ where accountdet0_.id=?
AccountDetail(id=1, address=四川省成都市青羊區, [email protected], phone=1234567890, realName=盧本)

關聯表之間操作一致

【提前更改實體類的設定】

@JoinColumn(name = "detail_id")
@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL) //設定關聯操作為ALL
AccountDetail detail;

ALL：所有操作都進行關聯操作
PERSIST：插入操作時才進行關聯操作
REMOVE：刪除操作時才進行關聯操作
MERGE：修改操作時才進行關聯操作

可以多個並存，接著我們來進行一下測試：

@Test
void addAccount(){
    Account account = new Account();
    account.setUsername("Nike");
    account.setPassword("123456");
    AccountDetail detail = new AccountDetail();
    detail.setAddress("重慶市渝中區解放碑");
    detail.setPhone("1234567890");
    detail.setEmail("[email protected]");
    detail.setRealName("張三");
  	account.setDetail(detail);
    account = repository.save(account);	//記得用repository儲存
    System.out.println("插入時，自動生成的主鍵ID為："+account.getId()+"，外來鍵ID為："+account.getDetail().getId());
}

可以看到紀錄檔結果：結束後會發現資料庫中兩張表都同時存在資料。

Hibernate: insert into users_detail (address, email, phone, real_name) values (?, ?, ?, ?)
Hibernate: insert into users (detail_id, password, username) values (?, ?, ?)
插入時，自動生成的主鍵ID為：6，外來鍵ID為：3

一對多

接著我們來看一對多關聯，比如每個使用者的成績資訊：

Account類：

@JoinColumn(name = "uid")  //注意這裡的name指的是Score表中的uid欄位對應的就是當前的主鍵，會將uid外來鍵設定為當前的主鍵
//執行的語句為：alter table account_score add constraint xxxxx foreign key (uid) reference account(id)
@OneToMany(fetch = FetchType.LAZY,cascade = CascadeType.ALL)  //在移除Account時，一併移除所有的成績資訊，依然使用懶載入
List<Score> scoreList;

@Data
@Entity
@Table(name = "users_score")   //成績表，注意只存成績，不存學科資訊，學科資訊id做外來鍵
public class Score {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    @Id
    int id;

    @OneToOne   //一對一對應到學科上
    @JoinColumn(name = "cid")
    Subject subject;

    @Column(name = "socre")
    double score;

    @Column(name = "uid")
    int uid;
}

@Data
@Entity
@Table(name = "subjects")   //學科資訊表
public class Subject {

    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cid")
    @Id
    int cid;

    @Column(name = "name")
    String name;

    @Column(name = "teacher")
    String teacher;

    @Column(name = "time")
    int time;
}

在資料庫中填寫相應資料，接著我們就可以查詢使用者的成績資訊了：成功得到使用者所有的成績資訊，包括得分和學科資訊。

@Transactional
@Test
void test() {
    repository.findById(1).ifPresent(account -> {
        account.getScoreList().forEach(System.out::println);
    });
}

多對一

同樣的，我們還可以將對應成績中的教師資訊單獨分出一張表儲存，並建立多對一的關係，因為多門課程可能由同一個老師教授：

Subjects表：

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "tid")   //儲存教師ID的欄位，和一對一是一樣的，也會在當前表中創個外來鍵tid,對應Teacher表的主鍵
Teacher teacher;
//執行的程式碼：
//alter table subjects add colunm tid integer
//alter table subjects add constraint xxxxx foreign key(tid) reference teachers (id)

接著就是教師實體類了：

@Data
@Entity
@Table(name = "teachers")
public class Teacher {

    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Id
    int id;

    @Column(name = "name")
    String name;

    @Column(name = "sex")
    String sex;
}

最後我們再進行一下測試：

@Transactional
@Test
void test() {
    repository.findById(3).ifPresent(account -> {
        account.getScoreList().forEach(score -> {
            System.out.println("課程名稱："+score.getSubject().getName());
            System.out.println("得分："+score.getScore());
            System.out.println("任課教師："+score.getSubject().getTeacher().getName());
        });
    });
}

成功得到多對一的教師資訊。

多對多

最後我們再來看最複雜的情況，現在我們一門課程可以由多個老師教授，而一個老師也可以教授多個課程，那麼這種情況就是很明顯的多對多場景，現在又該如何定義呢？我們可以像之前一樣，插入一張中間表表示教授關係，這個表中專門儲存哪個老師教哪個科目：

Subjects表：

@ManyToMany(fetch = FetchType.LAZY)   //多對多場景
//注意此操作，最後只會在該表多一個欄位，和一箇中間表，不會在另一個表中多一個欄位。需要編寫類似程式碼才會出現
@JoinTable(name = "teach_relation",     //多對多中間關聯表
        joinColumns = @JoinColumn(name = "cid"),    //當前實體主鍵在關聯表中的欄位名稱
        inverseJoinColumns = @JoinColumn(name = "tid")   //教師實體主鍵在關聯表中的欄位名稱，並在當前表中建立tid欄位作為外來鍵連線關聯表的tid
)
List<Teacher> teacher;

接著，JPA會自動建立一張中間表，並自動設定外來鍵，我們就可以將多對多關聯資訊編寫在其中了。