Разбира се, това е възможно по много лесен начин, ако схемите са еднакви. И тъй като сте създали и двете бази данни със същото съпоставяне на Hibernate, те трябва да са равни в Entity
смисъл.
Необходими са ви само две единици за постоянство на Hibernate (източници на данни). Ако и двете са конфигурирани правилно и имате конкретния EntityManager
удобни екземпляри, просто слезте до Session
на хибернация ниво - доколкото знам, JPA не поддържа това по този начин (поправете ме, ако греша) - и репликирайте изходния си обект в целевата си база данни.
Тъй като обичам да работя с Spring, ще използвам Spring Boot за следния пример. С изключение на конфигурацията, стъпката на репликация ще бъде реализирана по същия начин с всяко приложение за хибернация.
Аз също използвам две бази данни PostgreSQL вместо HSQLB, само за да го опростя. Просто разширете конфигурационната част, ако конфигурациите ви се разминават, единствената разлика между моите единици за постоянство е URL адресът на източника на данни.
Така че първо имаме нужда от обект, който да тества репликацията:
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class StorageEntry {
@Id
@GeneratedValue
private Long id;
private String someValue;
// imagine getters and setter here
}
Това е (версията на YAML) конфигурацията на двата източника на данни (вижте втория URL адрес на източник на данни, наречен targetDatabaseUrl
), Всички останали части на конфигурацията ще се използват и за двете постоянни единици:
spring:
datasource:
url: jdbc:postgresql://localhost/postgres
targetDatabaseUrl: jdbc:postgresql://localhost/postgres2
username: <username>
password: <password>
driver-class-name: org.postgresql.Driver
jpa:
database-platform: org.hibernate.dialect.PostgreSQLDialect
hibernate:
ddl-auto: create-drop
Следващата част е конфигурационният клас за източниците на данни:
import java.util.Properties;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
@Configuration
public class PersistenceConfig {
@Autowired
private JpaVendorAdapter jpaVendorAdapter;
@Value("${spring.datasource.url}")
private String databaseUrl;
@Value("${spring.datasource.targetDatabaseUrl}")
private String targetDatabaseUrl;
@Value("${spring.datasource.username}")
private String username;
@Value("${spring.datasource.password}")
private String password;
@Value("${spring.datasource.driver-class-name}")
private String driverClassName;
@Value("${spring.jpa.database-platform}")
private String dialect;
@Value("${spring.jpa.hibernate.ddl-auto}")
private String ddlAuto;
@Bean
public EntityManager sourceEntityManager() {
return sourceEntityManagerFactory().createEntityManager();
}
@Bean
public EntityManager targetEntityManager() {
return targetEntityManagerFactory().createEntityManager();
}
@Bean
public EntityManagerFactory sourceEntityManagerFactory() {
return createEntityManagerFactory("source", databaseUrl);
}
@Bean
public EntityManagerFactory targetEntityManagerFactory() {
return createEntityManagerFactory("target", targetDatabaseUrl);
}
@Bean
public PlatformTransactionManager sourceTransactionManager() {
return new JpaTransactionManager(sourceEntityManagerFactory());
}
@Bean
public PlatformTransactionManager targetTransactionManager() {
return new JpaTransactionManager(targetEntityManagerFactory());
}
private EntityManagerFactory createEntityManagerFactory(final String persistenceUnitName,
final String databaseUrl) {
final LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean();
final DriverManagerDataSource dataSource = new DriverManagerDataSource(databaseUrl, username, password);
dataSource.setDriverClassName(driverClassName);
entityManagerFactory.setDataSource(dataSource);
entityManagerFactory.setJpaVendorAdapter(jpaVendorAdapter);
entityManagerFactory.setPackagesToScan("com.example.model");
entityManagerFactory.setPersistenceUnitName(persistenceUnitName);
final Properties properties = new Properties();
properties.setProperty("hibernate.dialect", dialect);
properties.setProperty("hibernate.hbm2ddl.auto", ddlAuto);
entityManagerFactory.setJpaProperties(properties);
entityManagerFactory.afterPropertiesSet();
return entityManagerFactory.getObject();
}
}
Сега можете да използвате различните мениджъри на обекти, за да четете и записвате данните си от един източник на данни в друг. За да покажем това, ето малък тестов случай:
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.hibernate.ReplicationMode;
import org.hibernate.Session;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import com.example.model.StorageEntry;
@SpringBootTest
@RunWith(SpringRunner.class)
@Transactional(transactionManager = "targetTransactionManager")
public class ReplicationTests {
@PersistenceContext(unitName = "source")
private EntityManager sourceEntityManager;
@PersistenceContext(unitName = "target")
private EntityManager targetEntityManager;
@Test
public void copyEntityBetweenPersistenceUnits() {
final StorageEntry entityToCopy = new StorageEntry();
entityToCopy.setSomeValue("copyMe!");
sourceEntityManager.persist(entityToCopy);
final Long id = entityToCopy.getId();
final StorageEntry sourceEntity = sourceEntityManager.find(StorageEntry.class, id);
assertThat("Entity should exist in default schema!", sourceEntity, notNullValue());
StorageEntry targetEntity = targetEntityManager.find(StorageEntry.class, id);
assertThat("Target schema should not contain the entity, yet!", targetEntity, nullValue());
final Session hibernateSession = targetEntityManager.unwrap(Session.class);
hibernateSession.replicate(sourceEntity, ReplicationMode.OVERWRITE);
targetEntityManager.flush();
targetEntityManager.clear();
targetEntity = targetEntityManager.find(StorageEntry.class, id);
assertThat("Entity should be copied now!", targetEntity, notNullValue());
}
}
Накрая изберете един от възможни режими на репликация който отговаря на вашите нужди.
Това е всичко. Можете дори да използвате транзакция, просто изберете една от двете единици за постоянство и използвайте неговия мениджър на транзакции, както прави тестът с @Transactional(transactionManager = "targetTransactionManager")
.