spring data jpa là gì

Nguồn: loda.me

Giới thiệu

Để cút tiếp vô series Spring Boot này, tôi ko thể bỏ dở một trong những phần cần thiết này là tiếp xúc với Database.

Bạn đang xem: spring data jpa là gì

Nếu bạn phải xem xét lại những bài xích trước, thì nó ở đây:

  1. 「Spring Boot #8」Tạo Web Helloworld với @Controller
  2. 「Spring Boot #9」Giải mến cơ hội Thymeleaf vận hành + Expression + Demo Full
  3. 「Spring Boot #10」@RequestMapping + @PostMapping + @ModelAttribute + @RequestParam + Web To-Do với Thymeleaf

Vì thiếu hụt phần liên kết với Database nên tất cả chúng ta ko thể đầy đủ được trang Web của tớ, vô bài xích này tất cả chúng ta tiếp tục dò thám hiểu Spring Boot JPA.

Spring Boot JPA

Spring Boot JPA là một trong phần vô hệ sinh thái xanh Spring Data, nó tạo nên một layer ở thân thích tầng service và database, gom tất cả chúng ta thao tác với database một cơ hội đơn giản và dễ dàng rộng lớn, tự động hóa config và thuyên giảm code thừa mứa.

Spring Boot JPA tiếp tục wrapper Hibernate và tạo nên một interface mạnh mẽ và tự tin. Nếu như chúng ta gặp gỡ trở ngại Lúc thao tác với Hibernate thì chớ thắc mắc, các bạn hãy nhằm Spring JPA thực hiện hộ.

Cài đặt

Để thêm thắt Spring JPA vô project, bạn phải thêm thắt dependency spring-boot-starter-data-jpa.

Ngoài rời khỏi, nhằm connect cho tới MySql, tất cả chúng ta cần thiết driver ứng, chính vì vậy cần bổ sung cập nhật thêm thắt cả dependency mysql-connector-javapom.xml.

pom.xml

<?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>
    <packaging>pom</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>me.loda.spring</groupId>
    <artifactId>spring-boot-learning</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-learning</name>
    <description>Everything about Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

        <!--spring mvc, rest-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <!-- mysql connector -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

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

</project>

Cấu trúc thư mục:

Tạo Table và dữ liệu

Trước Lúc chính thức, tất cả chúng ta cần thiết tạo nên tài liệu vô Database. Tại trên đây tôi lựa chọn MySQL.

Dưới đó là SQL Script sẽ tạo DATABASE micro_db. Chứa một TABLE độc nhất là User.

Khi chạy script này, nó sẽ bị tự động hóa insert vô db 100 User.

CREATE DATABASE micro_db;
use micro_db;
CREATE TABLE `user`
(
  `id`         bigint(20) NOT NULL      AUTO_INCREMENT,
  `hp`   		int  NULL          DEFAULT NULL,
  `stamina`    int                  DEFAULT NULL,
  `atk`      int                    DEFAULT NULL,
  `def`      int                    DEFAULT NULL,
  `agi`      int                    DEFAULT NULL,
  PRIMARY KEY (`id`)
);


DELIMITER $$
CREATE PROCEDURE generate_data()
BEGIN
  DECLARE i INT DEFAULT 0;
  WHILE i < 100 DO
    INSERT INTO `user` (`hp`,`stamina`,`atk`,`def`,`agi`) VALUES (i,i,i,i,i);
    SET i = i + 1;
  END WHILE;
END$$
DELIMITER ;

CALL generate_data();

Sau Lúc chạy hoàn thành script bên trên, tất cả chúng ta đánh giá database tiếp tục sở hữu tài liệu ko.

Tạo Model User

Khi tiếp tục sở hữu tài liệu vô Database. Chúng tớ sẽ tạo nên một Class vô Java nhằm mapping vấn đề.

Phần này tất cả chúng ta cần phải có một ít kỹ năng và kiến thức về Hibernate. Nếu chúng ta chưa chắc chắn những Annotation ở tiếp sau đây nhằm làm những gì thì nên tạm ngưng và dò thám hiểu Hibernate bên trên trên đây.

User.java

@Entity
@Table(name = "user")
@Data
public class User implements Serializable {
    private static final long serialVersionUID = -297553281792804396L;

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

    // Mapping vấn đề biến hóa với thương hiệu cột vô Database
    @Column(name = "hp")
    private int hp;
    @Column(name = "stamina")
    private int stamina;

    // Nếu ko ghi lại @Column thì tiếp tục mapping tự động hóa theo đòi thương hiệu biến
    private int atk;
    private int def;
    private int agi;
}

Tới đó là tất cả chúng ta thực hiện được nửa đàng rồi.

Vấn đề của Hibernate truyền thống

Thông thông thường, khi chúng ta tiếp tục khái niệm Entity ứng với Table vô DB trải qua Hibernate. Thì trách nhiệm tiếp sau được xem là tạo nên những class thao tác với DB.

Ví dụ mong muốn query lấy toàn bộ User vày Hibernate truyền thống lịch sử tiếp tục như sau:

Xem thêm: small black bug with hard shell

// Giả sử tiếp tục sở hữu đối tượng người tiêu dùng session rồi
Session session = getSession();

try {
    // Tất cả những mệnh lệnh hành vi với DB trải qua Hibernate
    // đều cần ở trong một thanh toán giao dịch (Transaction)
    // Bắt đầu gửi gắm dịch
    session.getTransaction().begin();

    // Tạo một query

    String sql = "Select u from " + User.class.getName() + " u ";

    // Tạo đối tượng người tiêu dùng Query.
    Query<User> query = session.createQuery(sql);

    // Thực hiện tại truy vấn và lôi ra tài liệu.
    List<User> users = query.getResultList();

    // In rời khỏi mùng hình
    for (User user : users) {
        System.out.println(user);
    }

    // Commit tài liệu và kết thúc giục session.
    session.getTransaction().commit();
} catch (Exception e) {
    e.printStackTrace();
    // Rollback vô tình huống sở hữu lỗi xẩy rời khỏi.
    session.getTransaction().rollback();
}

Mặc mặc dù Hibernate đã thử rất tuyệt và thuyên giảm code cho tới việc thao tác với Database xuống rồi, những nó vẫn chưa phải là đơn giản và dễ dàng 😦

Mục đích thuở đầu của Hibernate là gom người thiết kế dễ dàng dùng, song, bên trên thực tiễn, nhiều người gặp gỡ trở ngại trong các công việc dùng với Hibernate hơn hết jdbc.

Nắm được yếu tố này, Spring Data tiếp tục wrapper lên Hibernate một tờ nữa gọi là Spring JPA, hỗ trợ cho từng thao tác với DB của tất cả chúng ta tinh giảm xuống còn 1 dòng sản phẩm và tất yếu là làm công việc nhòa Hibernate xuống đáng chú ý nhằm rời phiền hà cho những người thiết kế.

JpaRepository

Để dùng Spring JPA, bạn phải dùng interface JpaRepository.

Yêu cầu của interface này này là chúng ta cần hỗ trợ 2 thông tin:

  1. Entity (Đối tượng ứng với Table vô DB)
  2. Kiểu tài liệu của khóa chủ yếu (primary key)

Ví dụ: Tôi mong muốn lấy vấn đề của bảng User thì thực hiện như sau:

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

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

Vậy thôi, @Repository ghi lại UserRepository là một trong Bean và phụ trách tiếp xúc với DB.

Spring Boot tiếp tục tự động nhìn thấy và khởi tạo nên đối tượng người tiêu dùng UserRepository vô Context. Việc tạo nên UserRepository trọn vẹn tự động hóa và tự động config, vì thế tất cả chúng ta tiếp tục thừa kế JpaRepository.

Bây giờ, việc lôi ra toàn cỗ User tiếp tục như sau:

@Autowired
UserRepository userRepository;

userRepository.findAll()
                .forEach(System.out::println);

Đơn giản và ngắn ngủn gọn gàng rộng lớn thật nhiều.

Nếu chúng ta dò thám tìm tòi thì tiếp tục thấy UserRepository sở hữu hàng trăm method tuy nhiên tất cả chúng ta ko cần thiết ghi chép lại nữa. Vì nó thừa kế JpaRepository rồi.

Demo

Bây giờ tất cả chúng ta tiếp tục thực hiện phần mềm Demo những chức năng cơ phiên bản với JpaRepository

Bước thứ nhất là config vấn đề về MySQL vô application.properties

application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/micro_db?useSSL=false
spring.datasource.username=root
spring.datasource.password=root


## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
# Hibernate ddl tự động hóa (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update

logging.level.org.hibernate = ERROR

Spring JPA tiếp tục tự động liên kết cho tới tất cả chúng ta, tuy nhiên ko cần thiết thêm thắt một quãng code này cả.

User.java

@Entity
@Table(name = "user")
@Data
public class User implements Serializable {
    private static final long serialVersionUID = -297553281792804396L;

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

    // Mapping vấn đề biến hóa với thương hiệu cột vô Database
    @Column(name = "hp")
    private int hp;
    @Column(name = "stamina")
    private int stamina;

    // Nếu ko ghi lại @Column thì tiếp tục mapping tự động hóa theo đòi thương hiệu biến
    private int atk;
    private int def;
    private int agi;
}

App.java

Xem thêm: summertime saga 0.20.5 việt hóa android


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

import lombok.RequiredArgsConstructor;

@SpringBootApplication
@RequiredArgsConstructor
public class App {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(App.class, args);
        UserRepository userRepository = context.getBean(UserRepository.class);

        // Lấy rời khỏi toàn cỗ user vô db
        userRepository.findAll()
                      .forEach(System.out::println);

        // Lưu user xuống database
        User user = userRepository.save(new User());
        // Khi lưu hoàn thành, nó trả về User tiếp tục lưu tất nhiên Id.
        System.out.println("User vừa vặn lưu sở hữu ID: " + user.getId());
        Long userId = user.getId();
        // Cập nhật user.
        user.setAgi(100);
        // Update user
        // Lưu ý, thời điểm hiện nay đối tượng người tiêu dùng user tiếp tục sở hữu Id. 
        // Nên nó sẽ bị update vô đối tượng người tiêu dùng sở hữu Id này 
        // chứ không cần insert một phiên bản ghi mới
        userRepository.save(user);

        // Query lôi ra user vừa vặn hoàn thành nhằm đánh giá coi.
        User user2 = userRepository.findById(userId).get();
        System.out.println("User: " + user);
        System.out.println("User2: " + user2);

        // Xóa User ngoài DB
        userRepository.delete(user);

        // In rời khỏi đánh giá coi userId còn tồn bên trên vô DB không
        User user3 = userRepository.findById(userId).orElse(null);
        System.out.println("User3: " + user2);

    }

}

OUTPUT chương trình:

User vừa vặn lưu sở hữu ID: 104
// sau thời điểm update, cả hai đối tượng người tiêu dùng user đều phải có độ quý hiếm agi mới
User: User(id=104, hp=0, stamina=0, atk=0, def=0, agi=100)
User2: User(id=104, hp=0, stamina=0, atk=0, def=0, agi=100)
// Sau Lúc xóa, user không thể tồn tại
User3: null

Kết

Đây là một trong nội dung bài viết vô [Series làm chủ Spring Boot, kể từ zero lớn hero][link-series-spring-boot] [link-series-spring-boot]: https://loda.me/spring-boot-0-series-lam-chu-spring-boot-tu-zero-to-hero-loda1558963914472

Như từng Lúc, toàn cỗ code tìm hiểu thêm bên trên Github <i class="fab fa-github"></i>