如何在独立Java应用中集成Spring Boot Hibernate JPA

Hey there! I get that you want to reuse your existing Spring Data JPA repositories (backed by Hibernate) in a standalone Java app without falling back to raw JDBC. Let's walk through the most practical approaches to make this work.

Approach 1: Initialize a Minimal Spring Context in Your Standalone App #

Since Spring Data JPA relies on Spring's core infrastructure, the most straightforward way is to spin up a lightweight Spring context in your non-Spring app that loads just the JPA-related beans (repositories, entity manager, data source, etc.). Here's how to do it step-by-step:

Step 1: Extract Reusable JPA Components #

First, split your existing Spring Boot app to isolate the JPA layer into a separate module (e.g., your-app-jpa). This module should contain:

• Your JPA entity classes
• Spring Data JPA repository interfaces
• Any shared JPA configuration (like entity scanning rules)

This way, both your original Spring Boot app and the standalone app can depend on this module, avoiding code duplication.

Step 2: Add Dependencies to the Standalone App #

In your standalone app's build file (Maven/Gradle), include the necessary Spring and JPA dependencies:

• spring-core and spring-context for core Spring functionality
• spring-data-jpa for repository support
• hibernate-core as the JPA provider
• Your database driver (e.g., mysql-connector-java for MySQL)
• The reusable your-app-jpa module you created

Step 3: Create a Spring Configuration Class #

Write a configuration class to set up the data source, entity manager, transaction manager, and enable repository scanning:

@Configuration
@EnableJpaRepositories(basePackages = "com.yourcompany.yourapp.repositories")
@EntityScan(basePackages = "com.yourcompany.yourapp.entities")
public class JpaStandaloneConfig {

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/your_database");
        dataSource.setUsername("db_user");
        dataSource.setPassword("db_password");
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
        emf.setDataSource(dataSource());
        emf.setPackagesToScan("com.yourcompany.yourapp.entities");
        
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        emf.setJpaVendorAdapter(vendorAdapter);
        
        Map<String, Object> jpaProperties = new HashMap<>();
        jpaProperties.put("hibernate.hbm2ddl.auto", "update");
        jpaProperties.put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        emf.setJpaPropertyMap(jpaProperties);
        
        return emf;
    }

    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }
}

Step 4: Use the Repository in Your Standalone App #

Initialize the Spring context, fetch the repository bean, and start using your CRUD operations:

public class StandaloneMain {
    public static void main(String[] args) {
        // Initialize the Spring context with our JPA config
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JpaStandaloneConfig.class);
        
        // Retrieve the repository bean from the context
        UserRepository userRepo = context.getBean(UserRepository.class);
        
        // Perform CRUD operations just like in your Spring Boot app
        User newUser = new User("Alice", "alice@example.com");
        userRepo.save(newUser);
        
        List<User> allUsers = userRepo.findAll();
        allUsers.forEach(user -> System.out.println("User: " + user.getName()));
        
        // Don't forget to close the context when done
        context.close();
    }
}

Approach 2: Expose Repositories via REST API (Alternative) #

If you don't want to introduce Spring dependencies into your standalone app, you can wrap your Spring Boot repositories in REST endpoints using Spring Web. Then your standalone app can call these endpoints over HTTP to perform database operations.

For example, create a simple controller in your Spring Boot app:

@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserRepository userRepo;

    public UserController(UserRepository userRepo) {
        this.userRepo = userRepo;
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepo.save(user);
    }

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

Then in your standalone app, use an HTTP client like HttpClient or OkHttp to call these endpoints. This approach keeps your standalone app completely Spring-free, but it's an indirect way to use the repositories (since you're going through HTTP instead of direct method calls).

Key Considerations #

• Transaction Management: Make sure your configuration includes a transaction manager (like JpaTransactionManager) to handle transactions for repository operations (e.g., save(), delete()).
• Dependency Conflicts: When adding Spring dependencies to your standalone app, watch out for version conflicts with existing libraries. Use a BOM (like Spring's spring-boot-dependencies) to align versions.
• Resource Cleanup: Always close the Spring context when your standalone app finishes to release database connections and other resources.

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