SpringBoot 가 어떻게 JPA 를 통합 하 는 지 자세히 알 아 보 세 요.

SpringBoot 통합 JPA
JPA & Spring Data JPA
JPA 는 자바 Persistence API 의 약칭 으로 중국어 이름 자바 지구 층 API 로 Sun 이 공식 적 으로 제기 한 자바 지구 화 규범 이다.
그 설계 목 표 는 주로 기 존의 지구 화 개발 작업 을 간소화 하고 ORM 기술 을 통합 시 키 는 것 이다.
JPA 는 XML 파일 이나 주석(JDK 5.0 또는 더 높 은 버 전)을 사용 하여 대상-관련 표 의 매 핑 관 계 를 설명 합 니 다.실행 중인 실체 대상 을 데이터베이스 에 영구적 으로 유지 할 수 있 습 니 다.자바 개발 자 에 게 자바 응용 프로그램의 관계 데 이 터 를 관리 하 는 ORM 도 구 를 제공 합 니 다.
쉽게 말 하면 JPA 는 POJO(Plain Ordinary Java Object)에 지속 적 인 표준 규범 을 제공 하 는 것 으로 자바 의 일반 대상 이 대상 관 계 를 통 해 매 핑(Object-Relational Mapping,ORM)을 데이터베이스 에 지속 적 으로 표시 할 것 이다.
JPA 는 기 존 하 이 버 네 이 트,톱 링크,JDO 등 ORM 프레임 을 충분히 흡수 한 토대 에서 발 전 했 기 때문에 사용 하기 쉽 고 신축성 이 강하 다 는 장점 이 있다.
Spring Data JPA 는 Spring 이 Spring Data 프레임 워 크 를 기반 으로 JPA 규범 을 바탕 으로 개발 한 프레임 워 크 로 Spring Data JPA 를 사용 하면 JPA 의 쓰기 법 을 크게 간소화 할 수 있 으 며,쓰기 실현 이 거의 필요 없 는 상태 에서 데이터베이스 에 대한 접근 과 조작 을 실현 할 수 있 으 며,CRUD 외 에 페이지 나 누 기와 정렬 등 자주 사용 되 는 기능 도 포함한다.
Spring Data JPA 는 페이지 별 조회,사용자 정의 SQL,지정 N 조 기록 조회,연결 표 조회 등 기능 에 대한 지원 도 제공 합 니 다.
JPA 는 새로운 ORM 프레임 워 크 가 아니 라 기 존의 ORM 기술 을 규범화 하 는 데 사 용 될 뿐 기 존의 Hibernate,TopLink 등 프레임 워 크 를 대체 할 수 없습니다.반대로 JPA 개발 을 사용 할 때 저 희 는 이러한 ORM 프레임 워 크 에 사용 할 것 입 니 다.다만 이때 개 발 된 응용 은 더 이상 지속 적 인 공급 자 에 의존 하지 않 습 니 다.응용 프로그램 은 코드 를 수정 하지 않 은 상태 에서 어떠한 JPA 환경 에서 도 실행 할 수 있 으 며,진정 으로 낮은 결합 을 하고 확장 가능 한 프로그램 설 계 를 할 수 있 습 니 다.
Hibernate & JPA
1、JPA
전체 이름 은 자바 Persistence API 로 JDK 5.0 주석 이나 XML 을 통 해 대상-관계 표 의 매 핑 관 계 를 설명 하고 실행 기간 의 실체 대상 을 데이터베이스 에 영구적 으로 유지 합 니 다.
JPA 의 출현 에는 두 가지 이유 가 있다.
첫째,기 존의 자바 EE 와 자바 SE 응용 대상 의 지속 적 인 개발 작업 을 간소화 한다.
둘째,썬 은 ORM 기술 을 통합 해 지구 화 분야 의 통일 을 이 루 고자 한다.
JPA 가 제공 하 는 기술:
1)ORM 맵 메타 데이터:JPA 는 XML 과 JDK 5.0 주석 두 가지 메타 데이터 형식 을 지원 합 니 다.메타 데이터 설명 대상 과 표 간 의 맵 관 계 를 지원 합 니 다.프레임 워 크 는 이에 따라 실체 대상 을 데이터베이스 시트 에 영구적 으로 유지 합 니 다.
2)JPA 의 API:실체 대상 을 조작 하고 CRUD 작업 을 수행 하 는 데 사 용 됩 니 다.프레임 워 크 는 배경 에서 모든 일 을 완성 하고 개발 자 는 번 거 로 운 JDBC 와 SQL 코드 에서 벗 어 납 니 다.
3)조회 언어:데이터베이스 가 아 닌 대상 을 대상 으로 하 는 조회 언어 로 데 이 터 를 조회 하여 프로그램의 SQL 문장 이 긴밀 하 게 결합 되 지 않도록 한다.
2.JPA&Hibernate 관계
JPA 는 규범,하 이 버 네 이 트 는 프레임,JPA 는 지구 화 규범,하 이 버 네 이 트 는 JPA 를 실현 했다.
Hibernate VS Mybatis
Mybatis:작고 편리 하 며 효율 적 이 고 간단 하 며 직접적 이 고 반자동 적 입 니 다.
Hibernate:강력,편리,효율,복잡,커 브,전자 동
가 져 오기 의존

<dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>
        <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>
    </dependencies>

2.간단 한 CRUD
2.1 프로필

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/shy
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
  jpa:
    hibernate:
      #            create       update          
      ddl-auto: update
      #     sql  
    show-sql: true
server:
  port: 80

그 중에서 spring.jpa.hibenate.ddl-auto 매개 변 수 는 데이터베이스 시트 구 조 를 자동 으로 업데이트 할 지 여 부 를 설정 하 는 데 사 용 됩 니 다.create,create-drop,update,vaidate,none 5 개의 값 을 얻 을 수 있 습 니 다.

create 는 hibenate 를 불 러 올 때마다 존재 하 는 데이터베이스 시트 구 조 를 삭제 하고 다시 생 성 합 니 다

create-drop 은 hibenate 를 불 러 올 때마다 존재 하 는 데이터베이스 시트 구 조 를 삭제 하고 다시 생 성 하 며 session Factory 가 닫 혔 을 때 생 성 된 데이터베이스 시트 구 조 를 자동 으로 삭제 합 니 다

4.567917.update 는 hibenate 를 처음 불 러 올 때 만 데이터베이스 시트 구 조 를 자동 으로 생 성 하고 나중에 hibenate 를 다시 불 러 올 때 model 류 에 따라 표 구 조 를 자동 으로 업데이트 합 니 다

vaidate 는 hibenate 를 불 러 올 때마다 데이터베이스 시트 구 조 를 검증 하고 데이터베이스 에 있 는 표 와 만 비교 하 며 새 표를 만 들 지 는 않 지만 새 값 을 삽입 합 니 다

none 종료 자동 업데이트

2.2 실체 류
Shop：

package com.shy.entity;
import lombok.Data;
import javax.persistence.*;
@Data
//  jpa         
@Entity//  jpa                
public class Shop{
    @Id//         
    @GeneratedValue(strategy = GenerationType.IDENTITY)//  
    private Integer shopId;

    @Column(length = 20)
    private String shopName;

    private double price;

    private Integer shopClassId;

    private Integer num;
}

ShopClass,상품 유형

package com.shy.entity;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Data
@Entity
public class ShopClass {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer shopClassId;

    private String shopClassName;
}

2.3 Dao 층
dao 계승 JpaRepository 클래스 를 작성 하고 실행 할 실체 클래스 와 홈 키 형식 을 입력 합 니 다.

package com.example.dao;
import com.shy.entity.Shop;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/*     T :         
 *     ID :         OID(       ，     )   */

@Repository
public interface ShopRepository extends JpaRepository<Shop,Integer> {
    /*
     *           JpaRepository
     *               
     *    JPA     
     *             ，          。
     * */
}

JpaRepository:

package org.springframework.data.jpa.repository;

import java.util.List;
import javax.persistence.EntityManager;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

@NoRepositoryBean
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {

	@Override
	List<T> findAll();//       

	@Override
	List<T> findAll(Sort sort);//          

	@Override
	List<T> findAllById(Iterable<ID> ids);//   ID      

	@Override
	<S extends T> List<S> saveAll(Iterable<S> entities);//      （    ）    

	void flush();//     

	<S extends T> S saveAndFlush(S entity); //            

	<S extends T> List<S> saveAllAndFlush(Iterable<S> entities);

	@Deprecated
	default void deleteInBatch(Iterable<T> entities){deleteAllInBatch(entities);}

	void deleteAllInBatch(Iterable<T> entities); //         

	void deleteAllByIdInBatch(Iterable<ID> ids);

	void deleteAllInBatch();//         

	@Deprecated
	T getOne(ID id);//   ID    

	T getById(ID id);

	@Override
	<S extends T> List<S> findAll(Example<S> example);//      Example       

	@Override
	<S extends T> List<S> findAll(Example<S> example, Sort sort);//      Example          
}

2.4 서비스 층
service:

package com.shy.service;

import com.shy.entity.Shop;
import com.shy.vo.ShopAndShopClassVo;

import java.util.List;

public interface ShopService {
    //      
    List<Shop> findAll();

    //    
    Shop addShop(Shop shop);

    //    id     
    Shop updateShop();

    //    id    
    void delShop(Integer id);
}

Impl:

package com.shy.service;

import com.shy.dao.ShopRepository;
import com.shy.entity.Shop;
import com.shy.vo.ShopAndShopClassVo;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ShopServiceImpl implements ShopService{
    @Autowired
    private ShopRepository shopRepository;

    @Override
    public List<Shop> findAll() {
        return shopRepository.findAll();
    }

    @Override
    public Shop addShop(Shop shop) {
        shop.setPrice(333);
        shop.setShopClassId(3);
        shop.setNum(30);
        shop.setShopName("  ");
        return shopRepository.save(shop);
    }

    @Override
    public Shop updateShop() {
        Shop shop = new Shop();
        shop.setShopId(11);
        shop.setShopName("  ");
        shop.setShopClassId(3);
        shop.setNum(40);
        return shopRepository.save(shop);
    }

    @Override
    public void delShop(Integer id) {
        shopRepository.deleteById(id);
        System.out.println("    ");
    }
}

2.5 controller

package com.shy.controller;

import com.alibaba.fastjson.JSON;
import com.shy.entity.Shop;
import com.shy.service.ShopService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ShopController {
    @Autowired
    private ShopService shopService;

    @GetMapping("/list")
    public String findAll(){
        return JSON.toJSONString(shopService.findAll());
    }

    @GetMapping("/save")
    public String save(Shop shop){
        return JSON.toJSONString(shopService.addShop(shop));
    }

    @GetMapping("/saveAndFlush")
    public String saveAndFlush(){
        return JSON.toJSONString(shopService.updateShop());
    }

    @GetMapping("/delShop/{id}")
    public void delShop(@PathVariable Integer id){
        shopService.delShop(id);
    }

}

전 과정 용 postman 테스트
3.사용자 정의 SQL
Shop Repository 에 추가

//    sql    ，nativeQuery = true
 	//?1       
    @Query(value="select * from shop where shop.price = ?1",nativeQuery = true)
    Shop findByPrice(Double price);

    //    ,@Modifying+@Query      ，serviceImpl      ,   hql  ，   entity    
    @Transactional//                
    @Modifying//           int/Integer
    @Query("update Shop s set s.shopName = ?1 where s.shopId = ?2")
    int updateshop2(String name,Integer shopId);

service:

//        
    Shop findByPrice(Double price);

	//       sql  
    int updateshop2(String name,Integer shopId);

Impl:

@Override
    public Shop findByPrice(Double price) {
        return shopRepository.findByPrice(price);
    }

	@Override
    public int updateshop2(String name, Integer shopId) {
        return shopRepository.updateshop2(name, shopId);
    }

controller:

@GetMapping("/listPrice/{price}")
    public String findByPrice(@PathVariable Double price){
        return JSON.toJSONString(shopService.findByPrice(price));
    }

	@GetMapping("/saveAndFlush2/{id}/{name}")
    public String saveAndFlush2(@PathVariable(value = "id") Integer shopId,
                               @PathVariable String name){
        return shopService.updateshop2(name, shopId)>0?"    ":"    ";
    }

페이지 별 조회
Pageable 은 Spring 패 키 징 의 페이지 구현 클래스 로 사용 할 때 페이지 수,각 페이지 수,정렬 규칙 을 입력 해 야 합 니 다.
Spring Data JPA 는 페이지 나 누 기 기능 을 내장 해 주 었 습 니 다.조회 방법 에 서 는 매개 변수 Pageable 을 입력 해 야 합 니 다.조회 에 여러 개의 매개 변수 가 있 을 때 Pageable 은 마지막 매개 변수 로 전송 하 는 것 을 권장 합 니 다.
Pageable 을 사용 할 때 페이지 수,각 페이지 수,정렬 규칙 을 입력 해 야 합 니 다.정렬 규칙 은 생략 할 수 있 습 니 다.
service:

 /**
     *     
     * @param pageNo    
     * @param pageSize         
     * @param pageable Spring         
     * @return   
     */
    Page<Shop> pageShop(Integer pageNo,Integer pageSize,Pageable pageable);

Impl：

@Override
    public Page<Shop> pageShop(Integer pageNo, Integer pageSize, Pageable pageable) {
        //               ，       
        //     0  
        pageable = PageRequest.of(pageNo,pageSize, Sort.Direction.DESC, "shopId");
        return shopRepository.findAll(pageable);
    }

controller:

@GetMapping("/pageShop/{pageNo}/{pageSize}")
    public String pageShop(@PathVariable Integer pageNo,
                           @PathVariable Integer pageSize,Pageable pageable){
        return JSON.toJSONString(shopService.pageShop(pageNo, pageSize, pageable));
    }

연속 표 조회
VO(value object)값 대상
4.567917.보통 업무 층 간 의 데이터 전달 에 사용 되 는데 데이터 만 포함 할 뿐이다.

View object:보기 대상

페이지 가 전달 하 는 대상,패 키 징 대상 을 받 습 니 다.
업무 처리 가 완 료 된 대상 을 페이지 에 사용 할 데이터 로 밀봉 합 니 다.
연결 표 조회 결 과 를 받 기 위해 ShopAndShopClassVo 를 만 듭 니 다.
enity,여기 인삼 구조 가 있어 야 합 니 다.안 으로 값 을 부여 해 야 합 니 다.

package com.shy.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ShopAndShopClassVo {
    private String shopName;
    private double price;
    private String shopClassName;
}

ShopRepository：

//    
    @Query("select new com.shy.vo.ShopAndShopClassVo(s.shopName,s.price,sc.shopClassName) from Shop 			s,ShopClass sc " +
            "where s.shopClassId=sc.shopClassId and sc.shopClassName=?1")
    List<ShopAndShopClassVo> findShopInfo(String shopClassName);

JPQL 에서 조회 하 는데 그 특징 은 원래 의 SQL 문장 과 유사 하고 대상 을 대상 으로 하 며 클래스 이름과 속성 을 통 해 접근 하 는 것 이지 테이블 이름과 테이블 속성 이 아 닙 니 다.
service:

//    
    List<ShopAndShopClassVo> findShopInfo(String shopClassName);

Impl:

@Override
    public List<ShopAndShopClassVo> findShopInfo(String shopClassName) {
        return shopRepository.findShopInfo(shopClassName);
    }

controller:

@GetMapping("/andFind/{name}")
    public String findShopInfo(@PathVariable("name") String shopClassName){
        return JSON.toJSONString(shopService.findShopInfo(shopClassName));
    }

6.조별 조회
데 이 터 를 받 는 또 다른 쓰기 방법 으로 결과 집합 인 터 페 이 스 를 만들어 서 연결 표 조회 후의 결 과 를 받 습 니 다.
결과 집합 인터페이스 류 를 정의 합 니 다.인터페이스 류 의 내용 은 상품 표 와 상품 유형 표 에서 나 옵 니 다.
entity:

package com.shy.entity;

public interface GroupShop {
    String getNum();
    String getShopClassName();
}

실행 중 Spring 은 인터페이스(GroupShop)에 되 돌아 오 는 결 과 를 받 기 위해 프 록 시 클래스 를 자동 으로 생산 합 니 다.코드 에 서 는 getXX 형식 으로 가 져 옵 니 다.
ShopRepository：

//    
    @Query("select count(s.shopName) as     ,sc.shopClassName as      from Shop s,ShopClass sc where s.shopClassId=sc.shopClassId group by s.shopClassId")
    List<GroupShop> groupShop();

service:

//    
    List<GroupShop> groupShop();

Impl:

@Override
    public List<GroupShop> groupShop() {
        return shopRepository.groupShop();
    }

controller:

@GetMapping("/groupShop")
    public String groupShop(){
        return JSON.toJSONString(shopService.groupShop());
    }

7.my batis 와 비교

jpa 는 대상 과 대상 간 의 매 핑 이 고 my batis 는 대상 과 결과 집합 의 매 핑 이다

jpa 이식 성 이 비교적 좋 습 니 다.어떤 데이터 베 이 스 를 사용 하 는 지 에 관심 을 가 질 필요 가 없습니다.my batis 는 sql 문 구 를 자 유 롭 게 쓰기 때문에 프로젝트 를 이식 할 때 sql 을 고 쳐 야 합 니 다

필드 를 수정 할 때 JPA 가 더 간단 합 니 다.my batis 는 xml,mapper 등 파일 을 수정 해 야 합 니 다

my batis 사용자 정의 sql,비교적 유연 하고 복잡 한 sql 도 쓸 수 있 습 니 다.JPA 는 간단 한 표 sql 에 만 적합 합 니 다

요약:my batis 와 JPA 는 각각 장점 이 있 습 니 다.sql 이 간단 하면 jpa 의 사용 효율 이 더욱 높 습 니 다.sql 이 복잡 하고 사용자 정의 가 필요 하 다 면 my batis 를 사용 하 는 것 이 더욱 편리 합 니 다

SpringBoot 가 어떻게 JPA 를 통합 하 는 지 에 대한 자세 한 설명 은 여기까지 입 니 다.SpringBoot 통합 JPA 에 관 한 더 많은 내용 은 예전 의 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 응원 부 탁 드 리 겠 습 니 다!