Spring Boot 2.x.x集成Spring JPA(Hibernate)并连接MySQL数据库方法咨询

Hey there! I’ve set this up dozens of times, so let me walk you through it step by step—it’s really straightforward once you cover the basics.

1. Add Required Dependencies #

First, you need to include the right starters in your build file. Spring Boot starters handle most dependency management heavy lifting for you.

For Maven (pom.xml) #

<dependencies>
    <!-- Optional: Spring Boot Web Starter (if you're building a web app) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Data JPA Starter (includes Hibernate by default) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- MySQL JDBC Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

For Gradle (build.gradle) #

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web' // optional
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'mysql:mysql-connector-java'
}

2. Configure Database & JPA Settings #

Next, update your application.properties (or application.yml if you prefer YAML) with your MySQL connection details and Hibernate configurations.

application.properties Example #

# MySQL Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/your_database_name?useSSL=false&serverTimezone=UTC
spring.datasource.username=your_mysql_username
spring.datasource.password=your_mysql_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA/Hibernate Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
spring.jpa.properties.hibernate.format_sql=true

Quick breakdown of key configs:

• spring.jpa.hibernate.ddl-auto: Use update to auto-update your schema based on entities (great for dev; switch to validate or none in production)
• show-sql + format_sql: Prints formatted SQL queries to the console for easy debugging
• dialect: Ensures Hibernate generates MySQL-specific SQL syntax

3. Create an Entity Class #

Entities map directly to your MySQL tables. Let’s make a simple User entity as an example:

import javax.persistence.*;

@Entity
@Table(name = "users") // Optional: explicitly sets table name (defaults to lowercase class name)
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // Uses MySQL auto-increment
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @Column(nullable = false)
    private String fullName;
    
    // Required: no-arg constructor for Hibernate
    public User() {}
    
    // Convenience constructor
    public User(String email, String fullName) {
        this.email = email;
        this.fullName = fullName;
    }

    // Getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getFullName() { return fullName; }
    public void setFullName(String fullName) { this.fullName = fullName; }
}

Pro tip: Add the Lombok dependency to auto-generate getters, setters, and constructors—saves tons of boilerplate code!

4. Create a Repository Interface #

Spring Data JPA eliminates the need to write DAO implementations. Just create an interface extending JpaRepository:

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;

public interface UserRepository extends JpaRepository<User, Long> {
    // Custom query method—Spring Data JPA auto-implements this!
    Optional<User> findByEmail(String email);
}

JpaRepository gives you CRUD operations out of the box (save, findById, findAll, delete, etc.). You can also define custom query methods like findByEmail above, and Spring will generate the corresponding SQL for you.

5. Use the Repository for Data Access #

Inject the repository into a service or controller to interact with the database. Here’s a simple service example:

import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;

@Service
public class UserService {
    private final UserRepository userRepository;

    // Constructor injection (preferred over @Autowired)
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User saveUser(User user) {
        return userRepository.save(user);
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> getUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

You can test this setup directly in your main application class:

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

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

    // Test data access on app startup
    @Bean
    CommandLineRunner run(UserService userService) {
        return args -> {
            userService.saveUser(new User("john@example.com", "John Doe"));
            userService.saveUser(new User("jane@example.com", "Jane Smith"));
            
            // Print all saved users
            userService.getAllUsers().forEach(user -> 
                System.out.println(user.getFullName() + " - " + user.getEmail())
            );
        };
    }
}

Quick Additional Tips #

• Transactions: Spring Data JPA methods are transactional by default for write operations (save, delete), but you can add @Transactional to service methods if you need to manage transactions manually.
• Production Best Practices: Never use ddl-auto=create or create-drop in production—this will wipe your database! Stick to validate or none, and use migration tools like Flyway or Liquibase for schema changes.
• Detailed Logging: Add logging.level.org.hibernate.SQL=DEBUG and logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE to your properties to see parameter values in executed queries.

内容的提问来源于stack exchange，提问作者Nico