Detaillierte Erläuterung von Beispielen der von SpringBoot implementierten Spring Data JPA-Integration

In diesem Artikel werden hauptsächlich die relevanten Kenntnisse über die Integration von SpringData JPA und die Lese- und Schreibtrennung vorgestellt. Freunde in Not können sich auf den

zugehörigen Code beziehen: github OSCchina

Was ist JPA?? 🎜>/Assoziations-Mapping-Tool zur Verwaltung relationaler Daten in Java-Anwendungen. Es umfasst die folgenden Aspekte:1. ORM-Mapping unterstützt

xml

und Annotationsmethoden zum Erstellen von Entitäten und Tabellen-Mapping zwischen.2. Die Java-Persistenz-API definiert einige häufig verwendete CRUDSchnittstellen, die wir nur direkt aufrufen müssen, ohne die Details des zugrunde liegenden JDBC und SQL zu berücksichtigen.

3.JPQL AbfrageSprache Dies ist ein sehr wichtiger Aspekt bei Persistenzoperationen durch

Objektorientierte

-Abfragesprache, um zu vermeiden, dass die SQL des Programms eng gekoppelt ist. Bei unserer Arbeit verwenden wir alle ORM-Technologien wie Hibernate, JOOQ usw. Je nach Bedarf verwenden wir verschiedene ORM

Frameworks

, wenn wir das ORM-Framework ändern müssen Aufgrund der unterschiedlichen Implementierung und Verwendung verschiedener ORM-Frameworks müssen wir den Code häufig neu erstellen. Das Aufkommen von JPA besteht darin, dieses Problem vollständig zu lösen Framework zeichnen sich dadurch aus, dass es einfach zu verwenden ist und eine starke Skalierbarkeit aufweist. Es bietet eine Reihe von Standardschnittstellen für die ORM-Technologie zur Integration verschiedener ORM-Frameworks.Hibernate-Implementierung von JPA

JPA selbst implementiert keine spezifischen Implementierungen, sondern definiert nur einige Schnittstellenspezifikationen, sodass

andere

ORMs diese Schnittstellen speziell implementieren können. Die derzeit beste Implementierung der JPA-Spezifikation ist Hibernate. Lassen Sie mich hier Mybatis erwähnen. Mybatis implementiert die JPA-Spezifikation nicht und kann nicht als echtes ORM-Framework angesehen werden. Was ist

Spring Data JPA ist nur ein Modul des Spring Data-Frameworks, das die Verwendung von JPA erheblich vereinfachen kann. Die Stärke von Spring Data JPA besteht darin, dass es die Geschäftslogik unserer Persistenzschicht vereinfachen kann, indem es die Namen der Persistenzschicht standardisiert Methoden und die Verwendung der Namen, um zu bestimmen, welche Geschäftslogik implementiert werden muss, haben wir die Möglichkeit, den größten Teil unserer Entwicklung abzuschließen, ohne einen Satz SQL zu schreiben oder eine DAO-Layer-Logik auszuführen. Natürlich für einige komplexe Abfragen mit hohen Leistungsanforderungen , Spring Data JPA unterstützt uns auch bei der Verwendung von nativem SQL.

Hier werden wir nicht zu viel über JPA und Spring Data JPA vorstellen, hauptsächlich einige Details der Integration mit SpringBoot und Beispiel.Abhängigkeit einführen

Nachdem wir diese Abhängigkeit eingeführt hatten, stellten wir fest, dass auch das Hibernate-Paket eingeführt wurde, das nun ein Standardansatz ist, dass Hibernate berücksichtigt wurde Als beste Implementierung der JPA-Spezifikation wird hier nicht vorgestellt. Sie können einen weiteren Artikel lesen.

Konfiguration unserer Datenquelle und JPA (Hibernate). )

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-jpa -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Druiden-Datenquelleninjektion

EntityManagerFactory-Instanzinjektion

#配置模板
#https://docs.spring.io/spring-boot/docs/1.4.0.RELEASE/reference/html/common-application-properties.html
#数据源
spring.datasource.druid.write.url=jdbc:mysql://localhost:3306/jpa
spring.datasource.druid.write.username=root
spring.datasource.druid.write.password=1
spring.datasource.druid.write.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.druid.read.url=jdbc:mysql://localhost:3306/jpa
spring.datasource.druid.read.username=root
spring.datasource.druid.read.password=1
spring.datasource.druid.read.driver-class-name=com.mysql.jdbc.Driver
#JPA (JpaBaseConfiguration, HibernateJpaAutoConfiguration)
spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect
spring.jpa.database=mysql
spring.jpa.generate-ddl=true
#就是hibernate.hbm2ddl.auto,具体说明可以看README
spring.jpa.hibernate.ddl-auto=update
#通过方法名解析sql的策略,具体说明可以看README,这里就不配置了
spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.DefaultComponentSafeNamingStrategy
spring.jpa.show-sql=true
#spring.jpa.properties.*
#spring.jpa.properties.hibernate.hbm2ddl.auto=update
#spring.jpa.properties.hibernate.show_sql=true
#spring.jpa.properties.hibernate.use-new-id-generator-mappings=true

EntityManagerFactory ähnelt der SessionFactory von Hibernate und der SqlSessionFactory von mybatis. Kurz gesagt, wir müssen immer einen EntityManager abrufen, der der Session von Hibernate und der sqlSession von mybatis ähnelt. Eine davon ist die Injektion von EntityManagerFactory direkt und die andere besteht darin, indirekt über LocalContainerEntityManagerFactoryBean zu injizieren. Obwohl diese beiden Methoden auf LocalContainerEntityManagerFactoryBean basieren, gibt es immer noch einige Unterschiede in der Konfiguration

@Configuration
public class DruidDataSourceConfig {
  /**
   * DataSource 配置
   * @return
   */
  @ConfigurationProperties(prefix = "spring.datasource.druid.read")
  @Bean(name = "readDruidDataSource")
  public DataSource readDruidDataSource() {
    return new DruidDataSource();
  }
  /**
   * DataSource 配置
   * @return
   */
  @ConfigurationProperties(prefix = "spring.datasource.druid.write")
  @Bean(name = "writeDruidDataSource")
  @Primary
  public DataSource writeDruidDataSource() {
    return new DruidDataSource();
  }
}

1 🎜>Konfiguration: Konfigurieren Sie die

-Eigenschaften von Hibernate über spring.jpa.properties.* EntityManagerFactory

-Konfiguration:

Für diese Konfiguration ist das

Die getObject()-Methode kann eine Instanz von EntityManagerFactory abrufen, die mit der ersten identisch zu sein scheint. Es gibt keinen Unterschied, aber wir können getObject() nicht direkt verwenden, sonst können wir sie nicht abrufen, und a Es wird eine Nullzeigerausnahme gemeldet

Konfiguration der Lese-/Schreibtrennung

spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.use-new-id-generator-mappings=true
@Configuration
@EnableJpaRepositories(value = "com.lc.springBoot.jpa.repository",
            entityManagerFactoryRef = "writeEntityManagerFactory",
            transactionManagerRef="writeTransactionManager")
public class WriteDataSourceConfig {
  @Autowired
  JpaProperties jpaProperties;
  @Autowired
  @Qualifier("writeDruidDataSource")
  private DataSource writeDruidDataSource;
  /**
   * EntityManagerFactory类似于Hibernate的SessionFactory,mybatis的SqlSessionFactory
   * 总之,在执行操作之前,我们总要获取一个EntityManager,这就类似于Hibernate的Session,
   * mybatis的sqlSession.
   * @return
   */
  @Bean(name = "writeEntityManagerFactory")
  @Primary
  public EntityManagerFactory writeEntityManagerFactory() {
    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
    factory.setJpaVendorAdapter(vendorAdapter);
    factory.setPackagesToScan("com.lc.springBoot.jpa.entity");
    factory.setDataSource(writeDruidDataSource);//数据源
    factory.setJpaPropertyMap(jpaProperties.getProperties());
    factory.afterPropertiesSet();//在完成了其它所有相关的配置加载以及属性设置后,才初始化
    return factory.getObject();
  }
  /**
   * 配置事物管理器
   * @return
   */
  @Bean(name = "writeTransactionManager")
  @Primary
  public PlatformTransactionManager writeTransactionManager() {
    JpaTransactionManager jpaTransactionManager = new JpaTransactionManager();
    jpaTransactionManager.setEntityManagerFactory(this.writeEntityManagerFactory());
    return jpaTransactionManager;
  }
}

Benutzerdefinierte Injektion von AbstractRoutingDataSource

spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect
spring.jpa.database=mysql
spring.jpa.generate-ddl=true
#就是hibernate.hbm2ddl.auto,具体说明可以看README
spring.jpa.hibernate.ddl-auto=update
#通过方法名解析sql的策略,具体说明可以看README,这里就不配置了
spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.DefaultComponentSafeNamingStrategy
spring.jpa.show-sql=true
@Configuration
@EnableJpaRepositories(value = "com.lc.springBoot.jpa.repository",
    entityManagerFactoryRef = "writeEntityManagerFactory",
    transactionManagerRef = "writeTransactionManager")
public class WriteDataSourceConfig1 {
  @Autowired
  JpaProperties jpaProperties;
  @Autowired
  @Qualifier("writeDruidDataSource")
  private DataSource writeDruidDataSource;
  /**
   * 我们通过LocalContainerEntityManagerFactoryBean来获取EntityManagerFactory实例
   * @return
   */
  @Bean(name = "writeEntityManagerFactoryBean")
  @Primary
  public LocalContainerEntityManagerFactoryBean writeEntityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
    return builder
        .dataSource(writeDruidDataSource)
        .properties(jpaProperties.getProperties())
        .packages("com.lc.springBoot.jpa.entity") //设置实体类所在位置
        .persistenceUnit("writePersistenceUnit")
        .build();
    //.getObject();//不要在这里直接获取EntityManagerFactory
  }
  /**
   * EntityManagerFactory类似于Hibernate的SessionFactory,mybatis的SqlSessionFactory
   * 总之,在执行操作之前,我们总要获取一个EntityManager,这就类似于Hibernate的Session,
   * mybatis的sqlSession.
   * @param builder
   * @return
   */
  @Bean(name = "writeEntityManagerFactory")
  @Primary
  public EntityManagerFactory writeEntityManagerFactory(EntityManagerFactoryBuilder builder) {
    return this.writeEntityManagerFactoryBean(builder).getObject();
  }
  /**
   * 配置事物管理器
   * @return
   */
  @Bean(name = "writeTransactionManager")
  @Primary
  public PlatformTransactionManager writeTransactionManager(EntityManagerFactoryBuilder builder) {
    return new JpaTransactionManager(writeEntityManagerFactory(builder));
  }
}

Benutzerdefinierte Annotation

@Bean(name = "writeEntityManagerFactoryBean")
  @Primary
  public LocalContainerEntityManagerFactoryBean writeEntityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
    return builder
        .dataSource(writeDruidDataSource)
        .properties(jpaProperties.getProperties())
        .packages("com.lc.springBoot.jpa.entity") //设置实体类所在位置
        .persistenceUnit("writePersistenceUnit")
        .build();
    //.getObject();//不要在这里直接获取EntityManagerFactory
  }

Verwenden Sie ThreadLocal, um die Datenquelle an den Thread zu binden

Aspekte definieren

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von Beispielen der von SpringBoot implementierten Spring Data JPA-Integration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!