java：jpa、Hibernate、Spring Data JPA、ORM以及和mybatis的区别

文章目录

- Java连接数据库几种方式
- JPA
- Hibernate和Spring Data JPA
- ORM框架
- jpa和mybatis区别
- Spring Boot JPA使用例子
- - 1、创建库和表
  - 2、添加依赖
  - 3、配置数据源和Hibernate属性
  - 4、配置实体类
  - 5、创建一个继承JpaRepository的接口：
  - 6、创建一个控制器（Controller）
  - 7、测试

Java连接数据库几种方式

JDBC: java原生提供
MyBatis: MyBatis 是一种优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和原始类型、接口和 Java POJOs(Plain Old Java Objects) 为映射，包括集成的复杂类型。
Hibernate: Hibernate 是一个开源的、用于把数据库中的表映射成对象的技术。Hibernate 可以把对象/关系映射的实现细节封装起来，让开发者专注于业务逻辑而不必顾及繁琐的数据持久化操作。Hibernate 是一个独立于应用程序的框架，它可以在应用中轻松集成数据库映射特性。
Spring Data JPA: Spring Data JPA 是 Spring 框架的一部分，它提供了一种更高级别的抽象，以简化数据库访问。Spring Data JPA 可以帮助开发者编写更少的代码，并且其设计的目的是为了简化数据访问层的代码，从而使业务逻辑与数据访问层分离。
Spring Boot JPA: Spring Boot JPA 是 Spring Boot 的一部分，它提供了一种方便的方式来连接和操作数据库。Spring Boot JPA 集成了 Hibernate 和 Spring Data JPA，使得连接和操作数据库变得非常简单。
Spring Boot MyBatis: Spring Boot MyBatis 是 Spring Boot 和 MyBatis 的结合，它提供了一种方便的方式来连接和操作数据库。Spring Boot MyBatis 集成了 MyBatis 和 Spring Boot，使得连接和操作数据库变得非常简单。
Spring Boot JdbcTemplate: Spring Boot 还提供了 JdbcTemplate 类，可以直接使用 JDBC 来连接和操作数据库。虽然不如其他一些框架那么方便，但对于一些简单的数据库操作来说，使用 JdbcTemplate 也是一个不错的选择。

JPA

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。JPA是Java EE标准的一部分，它提供了一种标准的ORM框架，使得Java程序员可以方便地将数据持久化到关系数据库中。

JPA的功能包括：

通过注解或XML描述对象-关系映射关系；
将实体对象持久化到关系数据库中；
提供查询API，使得Java程序员可以以面向对象的方式操作数据库；
支持事务管理，确保数据的一致性和完整性。

JPA的提供商包括Hibernate、Spring Data JPA等。Hibernate是JPA的一个实现，提供了强大的ORM功能。Spring Data JPA是Spring框架的一部分，提供了方便的数据访问层抽象，支持自定义查询、数据访问自动化等功能。

Hibernate和Spring Data JPA

Hibernate和Spring Data JPA是两个不同的但相互关联的技术。

Hibernate是一个持久性框架，它提供了一种将对象模型映射到关系型数据库的方式。Hibernate通过使用映射元数据，将Java对象的状态与数据库表中的数据进行关联。这样，当对象状态发生改变时，Hibernate可以自动将更改应用到数据库中。

Spring Data JPA是Spring框架的一个扩展模块，它基于Spring的面向切面编程（AOP）和依赖注入（DI）特性，为数据访问层提供了一种更高级别的抽象。Spring Data JPA简化了与数据库的交互，通过使用Repository模式，将数据访问逻辑从业务模型中分离出来，并提供了更方便的查询API。

Spring Data JPA与Hibernate紧密集成，利用了Hibernate的映射和持久化机制来实现数据访问层的自动化。通过使用Spring Data JPA，您可以更专注于业务逻辑的实现，而无需过多关注底层的数据库访问细节。

因此，Hibernate和Spring Data JPA之间的关系是，Hibernate提供了对象关系映射的基础设施，而Spring Data JPA则在此基础上提供了更高级别的抽象和便利性。两者可以一起使用，以简化Java Web应用程序的开发过程。

ORM框架

上面提到了 ORM 框架简单说明一下：
ORM，全称为Object-Relational Mapping，即对象关系映射。它是一种将数据库中的记录映射为对象的技术。通过ORM，我们可以使用面向对象的方式来操作数据库，而不需要手动编写SQL语句。ORM框架会自动将我们的操作转换为SQL语句，并执行它们以完成数据的存取操作。这种技术大大简化了数据库操作，使得开发者可以更加专注于业务逻辑而不是底层的数据库操作。

import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.PreparedStatement;  
import java.sql.ResultSet;  
import java.sql.SQLException;  
  
public class ORMExample {  
    private static final String DATABASE_URL = "jdbc:mysql://localhost:3306/database_name";  
    private static final String DATABASE_USER = "username";  
    private static final String DATABASE_PASSWORD = "password";  
  
    public static void main(String[] args) {  
        User user = null;  
        try {  
            // 连接到数据库  
            Connection connection = DriverManager.getConnection(DATABASE_URL, DATABASE_USER, DATABASE_PASSWORD);  
  
            // 创建一个模型类，对应数据库中的表  
            class User {  
                private int id;  
                private String name;  
                private String email;  
  
                public User(int id, String name, String email) {  
                    this.id = id;  
                    this.name = name;  
                    this.email = email;  
                }  
  
                public int getId() {  
                    return id;  
                }  
  
                public String getName() {  
                    return name;  
                }  
  
                public String getEmail() {  
                    return email;  
                }  
            }  
  
            // 创建一个新的User对象并保存到数据库中  
            user = new User(1, "John", "john@example.com");  
            saveUser(connection, user);  
  
            // 根据ID查询User对象  
            user = getUserById(connection, 1);  
            System.out.println(user.getName());  // 输出：John  
  
            // 更新User对象的属性并保存到数据库中  
            user.setName("New Name");  
            saveUser(connection, user);  
        } catch (SQLException e) {  
            e.printStackTrace();  
        } finally {  
            // 关闭数据库连接（可选）  
            try {  
                if (user != null) {  
                    connection.close();  
                }  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    private static void saveUser(Connection connection, User user) throws SQLException {  
        String sql = "INSERT INTO users (id, name, email) VALUES (?, ?, ?)";  
        PreparedStatement statement = connection.prepareStatement(sql);  
        statement.setInt(1, user.getId());  
        statement.setString(2, user.getName());  
        statement.setString(3, user.getEmail());  
        statement.executeUpdate();  
    }  
  
    private static User getUserById(Connection connection, int id) throws SQLException {  
        String sql = "SELECT * FROM users WHERE id = ?";  
        PreparedStatement statement = connection.prepareStatement(sql);  
        statement.setInt(1, id);  
        ResultSet resultSet = statement.executeQuery();  
        if (resultSet.next()) {  
            User user = new User(resultSet.getInt("id"), resultSet.getString("name"), resultSet.getString("email"));  
            return user;  
        } else {  
            return null;  
        }  
    }  
}

这个代码示例中，ORM库提供了一个连接数据库并操作数据的方法。通过定义一个模型类，我们可以将数据库中的表映射为Java类，并使用Java对象来操作数据。

例如，我们可以创建一个User对象，设置它的属性，然后使用saveUser()方法将其保存到数据库中。在这个例子中，ORM库提供了一个简单而直观的方式来操作数据库。

jpa和mybatis区别

JPA和MyBatis是两种广泛使用的Java持久化框架，它们有以下区别：

对象映射方式：JPA将Java对象映射到数据库表，开发者可以使用面向对象的方式进行数据库操作；而MyBatis则将SQL语句与Java对象进行映射，开发者可以编写SQL语句，并对其进行更精细的控制。
移植性：JPA的移植性较好，因为其具体实现可以由不同的厂商提供，如Hibernate、EclipseLink等；而MyBatis则更灵活，可以自由编写SQL语句，但当项目移植时，可能需要进行相应的调整。
修改字段：当需要修改字段时，JPA相对简单，而MyBatis可能需要修改多个地方。
应用场景：通常小项目适合使用JPA，大型项目则更适合使用MyBatis。此外，JPA的saveAll方法批量新增速度会很慢，而MyBatis则可以更方便地进行批量新增。

Spring Boot JPA使用例子

1、创建库和表

1.1 创建库 spring-test
1.2 创建表

CREATE TABLE `users` (
  `id` int unsigned NOT NULL AUTO_INCREMENT,
  `name` char(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  `age` int DEFAULT NULL,
  `email` char(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

1.3 添加一条数据
在这里插入图片描述

2、添加依赖

<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-web</artifactId>  
    </dependency>  
    <dependency>  
        <groupId>mysql</groupId>  
        <artifactId>mysql-connector-java</artifactId>  
        // 不指定版本可能有问题
        <version>8.0.23</version>
    </dependency>  
</dependencies>

spring-boot-starter-data-jpa 中包含 Hibernate
mysql-connector-java 这个依赖项包含了MySQL的JDBC驱动程序，它使得应用程序能够建立与MySQL数据库的连接并执行SQL查询。

3、配置数据源和Hibernate属性

application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/spring-test?useSSL=false&characterEncoding=utf-8&useLegacyDatetimeCode=false
spring.datasource.username=root
spring.datasource.password=865091

在Spring Boot中，可以在properties文件中直接配置数据库连接信息。代码中并没有直接使用这些信息，但Spring Boot会自动读取并解析这些配置，然后使用它们来创建数据源和Hibernate的会话工厂。
当Spring Boot启动时，它会扫描指定的配置文件（默认为application.properties或application.yml），并加载这些配置。在上面的例子中，Spring Boot会读取properties文件中的数据库连接信息，然后使用它们来创建一个数据源和一个事务管理器。

4、配置实体类

在Hibernate中，实体类使用@Entity注解来表示，并使用@Table注解来指定表名。每个实体类都有一个主键，可以使用@Id注解来指定主键，并使用@GeneratedValue注解来指定主键的生成策略。例如，下面的代码定义了一个名为User的实体类，该类对应数据库中的users表，主键为自增的整数类型：
model/User.java

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

@Entity  
@Table(name = "users")  
public class User {  
    @Id  
    @GeneratedValue(strategy = GenerationType.AUTO)  
    private Integer id;  
      
    @Column(name = "name")  
    private String name;  
      
    @Column(name = "email")  
    private String email;  
      
    // getter and setter methods  
}

5、创建一个继承JpaRepository的接口：

repository/UserRepository.java

package com.zhangyu.repository;

import com.zhangyu.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

在Spring Data JPA中，创建Repository接口并继承JpaRepository接口是为了简化数据访问层的开发。JpaRepository是Spring Data JPA提供的一个接口，它扩展了Spring框架的CrudRepository接口，并提供了许多用于访问数据库的方法。

通过继承JpaRepository接口，您可以定义自定义的查询方法和数据访问逻辑，而无需编写底层的SQL查询代码。JpaRepository提供了一些常用的方法，例如findAll()、findById()、save()等，可以轻松地进行数据的查询和保存操作。

通过这一步，您可以利用Spring Data JPA的便利性，快速地构建数据访问层，而无需手动编写与数据库交互的代码。这有助于减少开发工作量，提高开发效率，并确保数据访问层的代码符合Spring框架的最佳实践。

6、创建一个控制器（Controller）

package com.zhangyu.controller;

import com.zhangyu.model.User;
import com.zhangyu.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("getAll")
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}