विभिन्न डेटाबेस के बीच डेटा कॉपी करें (दोनों jdbc समर्थित हैं)

निश्चित रूप से, यह बहुत आसान तरीके से संभव है यदि स्कीमाटा समान हैं। और चूंकि आपने एक ही हाइबरनेट मैपिंग के साथ दोनों डेटाबेस बनाए हैं, वे Entity में बराबर होने चाहिए भाव।

आपको केवल दो हाइबरनेट हठ इकाइयों (डेटा स्रोत) की आवश्यकता है। यदि दोनों ठीक से कॉन्फ़िगर किए गए हैं और आपके पास विशेष EntityManager . है आसान उदाहरण, बस हाइबरनेट Session पर जाएं स्तर - जहां तक ​​मुझे पता है कि जेपीए इस तरह से इसका समर्थन नहीं करता है (अगर मैं गलत हूं तो मुझे सुधारें) - और अपने स्रोत इकाई को अपने लक्षित डेटाबेस में दोहराएं।

क्योंकि मुझे स्प्रिंग के साथ काम करना पसंद है, मैं निम्नलिखित उदाहरण के लिए स्प्रिंग बूट का उपयोग करूंगा। कॉन्फ़िगरेशन को छोड़कर प्रतिकृति चरण को किसी भी हाइबरनेट एप्लिकेशन के साथ समान रूप से लागू किया जाएगा।

मैं इसे सरल रखने के लिए केवल एचएसक्यूएलबी के बजाय दो पोस्टग्रेएसक्यूएल डेटाबेस का उपयोग कर रहा हूं। यदि आपके कॉन्फ़िगरेशन अलग हो जाते हैं, तो बस कॉन्फ़िगरेशन भाग का विस्तार करें, मेरी दृढ़ता इकाइयों के बीच एकमात्र अंतर डेटा स्रोत 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") के साथ करता है। ।