স্প্রিং বুট দুটি ডেটা উত্স কনফিগার করুন এবং ব্যবহার করুন

Question

আমি কীভাবে দুটি ডেটা উত্স কনফিগার করতে এবং ব্যবহার করতে পারি?

উদাহরণস্বরূপ এখানে প্রথম ডেটা উত্সের জন্য আমার কাছে যা রয়েছে:

application.properties

#first db
spring.datasource.url = [url]
spring.datasource.username = [username]
spring.datasource.password = [password]
spring.datasource.driverClassName = oracle.jdbc.OracleDriver

#second db ...

আবেদন ক্লাস

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

application.propertiesঅন্য ডেটা উত্স যুক্ত করতে আমি কীভাবে সংশোধন করব ? আমি কীভাবে এটি আলাদা সংগ্রহস্থল দ্বারা ব্যবহার করতে স্বীকৃতি দেব?

Answer 1

আপনি এখানে যান

#first db
spring.datasource.url = [url]
spring.datasource.username = [username]
spring.datasource.password = [password]
spring.datasource.driverClassName = oracle.jdbc.OracleDriver

#second db ...
spring.secondDatasource.url = [url]
spring.secondDatasource.username = [username]
spring.secondDatasource.password = [password]
spring.secondDatasource.driverClassName = oracle.jdbc.OracleDriver


@Bean
@Primary
@ConfigurationProperties(prefix="spring.datasource")
public DataSource primaryDataSource() {
    return DataSourceBuilder.create().build();
}

@Bean
@ConfigurationProperties(prefix="spring.secondDatasource")
public DataSource secondaryDataSource() {
    return DataSourceBuilder.create().build();
}

Comments

কটাক্ষপাত baeldung.com/spring-data-jpa-multiple-databases যা একই আপনি যা খুঁজছিলেন তা বর্ণনা করা হয়েছে।

— কে শিব প্রসাদ রেড্ডি

কখনও কখনও আপনাকে ডেটাসোর্স, লেনদেনের ব্যবস্থাপনার, এবং এসকিএলসেশনফ্যাক্টরি প্রাথমিক হিসাবে নির্ধারিত করতে হতে পারে।

— দাই কক্সিয়ান

@K। শিব প্রসাদ রেড্ডি ঠিক আছে তবে আমার কাছে 2 টি আলাদা জেপাইপোসিটোরিজ রয়েছে - স্প্রিং বুট কীভাবে জানতে পারে কোন ডেটা সোর্সটি ব্যবহার করতে হবে? প্রতিটি জর্পোসিটোরির শৌডল বিভিন্ন ডাটাবেস ব্যবহার করে

— ম্যাটলি

@ ম্যাটলি এই ব্লগ পোস্ট জাভাদেভজর্নাল.com/spring-boot/ … আপনি যা খুঁজছেন তা হতে পারে।

— কে শিব প্রসাদ রেড্ডি

@ কে.শিবপ্রসাদ রেডি একাধিক ডাটাসোর্স কনফিগার করতে সমস্ত ডাটাবেস একই সার্ভারে থাকা উচিত?

— কৃষ

Answer 2

স্প্রিং বুট 1.5.8.RELEASE সহ 2018-01-07 আপডেট করুন

বেশিরভাগ উত্তরগুলি কীভাবে সেগুলি ব্যবহার করবেন (কেবল ডেটাসোর্স হিসাবে এবং লেনদেন হিসাবে), কেবল তাদের কীভাবে কনফিগার করা যায় তা সরবরাহ করে না।

আপনি চলমান উদাহরণ এবং https://www.surasint.com/spring-boot-with-m Multiple-- ডেটাবেসস- উদাহরণ / মধ্যে কিছু ব্যাখ্যা দেখতে পারেন

আমি এখানে কিছু কোড অনুলিপি করেছি।

প্রথমে আপনাকে অ্যাপ্লিকেশন.প্রেটিটি সেট করতে হবে

#Database
database1.datasource.url=jdbc:mysql://localhost/testdb
database1.datasource.username=root
database1.datasource.password=root
database1.datasource.driver-class-name=com.mysql.jdbc.Driver

database2.datasource.url=jdbc:mysql://localhost/testdb2
database2.datasource.username=root
database2.datasource.password=root
database2.datasource.driver-class-name=com.mysql.jdbc.Driver

তারপরে তাদের এইভাবে সরবরাহকারী (@ বিয়ান) হিসাবে সংজ্ঞায়িত করুন:

@Bean(name = "datasource1")
@ConfigurationProperties("database1.datasource")
@Primary
public DataSource dataSource(){
    return DataSourceBuilder.create().build();
}

@Bean(name = "datasource2")
@ConfigurationProperties("database2.datasource")
public DataSource dataSource2(){
    return DataSourceBuilder.create().build();
}

নোট করুন যে আমার কাছে @ বিয়ান (নাম = "ডেটাসোর্স 1") এবং @ বিয়ান (নাম = "ডেটাসোর্স 2") রয়েছে, তখন আপনি যখন এটি ব্যবহার করতে পারেন যখন আমাদের @ কোয়ালিফায়ার ("ডেটাসোর্স 1") এবং @ কোয়ালিফায়ার ("ডেটাসোর্স 2"), উদাহরণ স্বরূপ

@Qualifier("datasource1")
@Autowired
private DataSource dataSource;

আপনি যদি লেনদেনের বিষয়ে চিন্তা করেন তবে আপনার উভয়ের জন্যই ডেটাসোর্স ট্রান্সজেকশন ম্যানেজারটি সংজ্ঞায়িত করতে হবে:

@Bean(name="tm1")
@Autowired
@Primary
DataSourceTransactionManager tm1(@Qualifier ("datasource1") DataSource datasource) {
    DataSourceTransactionManager txm  = new DataSourceTransactionManager(datasource);
    return txm;
}

@Bean(name="tm2")
@Autowired
DataSourceTransactionManager tm2(@Qualifier ("datasource2") DataSource datasource) {
    DataSourceTransactionManager txm  = new DataSourceTransactionManager(datasource);
    return txm;
}

তারপরে আপনি এটির মতো ব্যবহার করতে পারেন

@Transactional //this will use the first datasource because it is @primary

অথবা

@Transactional("tm2")

এটি যথেষ্ট হওয়া উচিত। উপরের লিঙ্কে উদাহরণ এবং বিশদটি দেখুন।

Comments

হাই @ সুরসিন তানচরোইন, আমরা একই উপায়ে দুটি ডেটা উত্স রাখার চেষ্টা করছি যাতে একটি ব্যর্থ হলে অ্যাপ্লিকেশনটি অন্য ডেটা উত্সে চলতে পারে। উপরোক্ত পদ্ধতির ঠিক হবে?

— অরুণ সুধাকরণ

Answer 3

পড়ুন কর্মকর্তা ডকুমেন্টেশন

---

একাধিক ডেটা উত্স তৈরি করা প্রথমটি তৈরির মতোই কাজ করে। আপনি যদি জেডিবিসি বা জেপিএর জন্য ডিফল্ট অটো-কনফিগারেশন ব্যবহার করে থাকেন তবে আপনি তাদের মধ্যে একটি প্রাইমারী হিসাবে চিহ্নিত করতে চাইতে পারেন (তারপরে এটি কোনও @ অটোভায়ার্ড ইনজেকশন দ্বারা নেওয়া হবে)।

@Bean
@Primary
@ConfigurationProperties(prefix="datasource.primary")
public DataSource primaryDataSource() {
    return DataSourceBuilder.create().build();
}

@Bean
@ConfigurationProperties(prefix="datasource.secondary")
public DataSource secondaryDataSource() {
    return DataSourceBuilder.create().build();
}

Answer 4

আমাকে স্প্রিং বুট অ্যাপ্লিকেশন থেকে 2 ডেটাসোর্সের সাথে সংযোগ স্থাপন করতে হয়েছিল এবং এটি সহজ ছিল না - স্প্রিং বুটের ডকুমেন্টেশনে উল্লিখিত সমাধানটি কার্যকর হয়নি। ইন্টারনেটে দীর্ঘ খনন করার পরে আমি এটিকে কাজ করে দিয়েছি এবং মূল ধারণাটি এই নিবন্ধ এবং অন্যান্য জায়গাগুলির গুচ্ছ থেকে নেওয়া হয়েছিল ।

নিম্নলিখিত সমাধান লেখা আছে Kotlin এবং সাথে কাজ করে স্প্রিং বুট 2.1.3 এবং হাইবারনেট কোর 5.3.7 । প্রধান সমস্যাটি যে এটা যথেষ্ট শুধু সেটআপ ভিন্ন ছিল না ডেটাউত্স configs, কিন্তু এটি কনফিগার করতে প্রয়োজন ছিল EntityManagerFactory এবং TransactionManager উভয় ডাটাবেস জন্য।

প্রথম (প্রাথমিক) ডাটাবেসের জন্য এখানে কনফিগার করা আছে:

@Configuration
@EnableJpaRepositories(
    entityManagerFactoryRef = "firstDbEntityManagerFactory",
    transactionManagerRef = "firstDbTransactionManager",
    basePackages = ["org.path.to.firstDb.domain"]
)
@EnableTransactionManagement
class FirstDbConfig {

    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.firstDb")
    fun firstDbDataSource(): DataSource {
        return DataSourceBuilder.create().build()
    }

    @Primary
    @Bean(name = ["firstDbEntityManagerFactory"])
    fun firstDbEntityManagerFactory(
        builder: EntityManagerFactoryBuilder,
        @Qualifier("firstDbDataSource") dataSource: DataSource
    ): LocalContainerEntityManagerFactoryBean {
        return builder
            .dataSource(dataSource)
            .packages(SomeEntity::class.java)
            .persistenceUnit("firstDb")
            // Following is the optional configuration for naming strategy
            .properties(
                singletonMap(
                    "hibernate.naming.physical-strategy",
                    "org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl"
                )
            )
            .build()
    }

    @Primary
    @Bean(name = ["firstDbTransactionManager"])
    fun firstDbTransactionManager(
        @Qualifier("firstDbEntityManagerFactory") firstDbEntityManagerFactory: EntityManagerFactory
    ): PlatformTransactionManager {
        return JpaTransactionManager(firstDbEntityManagerFactory)
    }
}

এবং এটি দ্বিতীয় ডাটাবেসের জন্য কনফিগার করা হয়েছে:

@Configuration
@EnableJpaRepositories(
    entityManagerFactoryRef = "secondDbEntityManagerFactory",
    transactionManagerRef = "secondDbTransactionManager",
    basePackages = ["org.path.to.secondDb.domain"]
)
@EnableTransactionManagement
class SecondDbConfig {

    @Bean
    @ConfigurationProperties("spring.datasource.secondDb")
    fun secondDbDataSource(): DataSource {
        return DataSourceBuilder.create().build()
    }

    @Bean(name = ["secondDbEntityManagerFactory"])
    fun secondDbEntityManagerFactory(
        builder: EntityManagerFactoryBuilder,
        @Qualifier("secondDbDataSource") dataSource: DataSource
    ): LocalContainerEntityManagerFactoryBean {
        return builder
            .dataSource(dataSource)
            .packages(EntityFromSecondDb::class.java)
            .persistenceUnit("secondDb")
            .build()
    }

    @Bean(name = ["secondDbTransactionManager"])
    fun secondDbTransactionManager(
        @Qualifier("secondDbEntityManagerFactory") secondDbEntityManagerFactory: EntityManagerFactory
    ): PlatformTransactionManager {
        return JpaTransactionManager(secondDbEntityManagerFactory)
    }
}

ডেটাসোর্সগুলির জন্য বৈশিষ্ট্যগুলি হ'ল:

spring.datasource.firstDb.jdbc-url=
spring.datasource.firstDb.username=
spring.datasource.firstDb.password=

spring.datasource.secondDb.jdbc-url=
spring.datasource.secondDb.username=
spring.datasource.secondDb.password=

Properties সহযোগে ইস্যু যে আমি সংজ্ঞায়িত ছিল JDBC-URL পরিবর্তে URL কারণ নইলে একটি ব্যতিক্রম ছিল না।

PS এছাড়াও আপনার ডাটাবেসে বিভিন্ন নামকরণের পরিকল্পনা থাকতে পারে, যা আমার ক্ষেত্রে ছিল the যেহেতু হাইবারনেট 5 পূর্ববর্তী সমস্ত নামকরণের স্কিমগুলিকে সমর্থন করে না, তাই আমাকে এই উত্তরটি থেকে সমাধানটি ব্যবহার করতে হয়েছিল - সম্ভবত এটি কাউকেও সহায়তা করবে।

Comments

সত্তা এবং টেবিলের নামকরণে আমার সমস্যা ছিল। এবং এটি আপনার উত্তর সহ আমাকে সহায়তা করেছে:mapOf("hibernate.physical_naming_strategy" to "org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy", "hibernate.implicit_naming_strategy" to "org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy" )

— rvit34

Answer 5

এখানে সম্পূর্ণ সমাধান

#First Datasource (DB1)
db1.datasource.url: url
db1.datasource.username:user
db1.datasource.password:password

#Second Datasource (DB2)
db2.datasource.url:url
db2.datasource.username:user
db2.datasource.password:password

যেহেতু আমরা দুটি পৃথক ডাটাবেস অ্যাক্সেস পেতে চলেছি (db1, db2), আমাদের প্রতিটি ডাটা উত্স কনফিগারেশন আলাদাভাবে কনফিগার করতে হবে যেমন:

public class DB1_DataSource {
@Autowired
private Environment env;
@Bean
@Primary
public LocalContainerEntityManagerFactoryBean db1EntityManager() {
    LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(db1Datasource());
    em.setPersistenceUnitName("db1EntityManager");
    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    em.setJpaVendorAdapter(vendorAdapter);
    HashMap<string, object=""> properties = new HashMap<>();
    properties.put("hibernate.dialect",
            env.getProperty("hibernate.dialect"));
    properties.put("hibernate.show-sql",
            env.getProperty("jdbc.show-sql"));
    em.setJpaPropertyMap(properties);
    return em;
}

@Primary
@Bean
public DataSource db1Datasource() {

    DriverManagerDataSource dataSource
            = new DriverManagerDataSource();
    dataSource.setDriverClassName(
            env.getProperty("jdbc.driver-class-name"));
    dataSource.setUrl(env.getProperty("db1.datasource.url"));
    dataSource.setUsername(env.getProperty("db1.datasource.username"));
    dataSource.setPassword(env.getProperty("db1.datasource.password"));

    return dataSource;
}

@Primary
@Bean
public PlatformTransactionManager db1TransactionManager() {

    JpaTransactionManager transactionManager
            = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(
            db1EntityManager().getObject());
    return transactionManager;
}
}

দ্বিতীয় তথ্য উত্স:

public class DB2_DataSource {

@Autowired
private Environment env;

@Bean
public LocalContainerEntityManagerFactoryBean db2EntityManager() {
    LocalContainerEntityManagerFactoryBean em
            = new LocalContainerEntityManagerFactoryBean();
    em.setDataSource(db2Datasource());
    em.setPersistenceUnitName("db2EntityManager");
    HibernateJpaVendorAdapter vendorAdapter
            = new HibernateJpaVendorAdapter();
    em.setJpaVendorAdapter(vendorAdapter);
    HashMap<string, object=""> properties = new HashMap<>();
    properties.put("hibernate.dialect",
            env.getProperty("hibernate.dialect"));
    properties.put("hibernate.show-sql",
            env.getProperty("jdbc.show-sql"));
    em.setJpaPropertyMap(properties);
    return em;
}

@Bean
public DataSource db2Datasource() {
    DriverManagerDataSource dataSource
            = new DriverManagerDataSource();
    dataSource.setDriverClassName(
            env.getProperty("jdbc.driver-class-name"));
    dataSource.setUrl(env.getProperty("db2.datasource.url"));
    dataSource.setUsername(env.getProperty("db2.datasource.username"));
    dataSource.setPassword(env.getProperty("db2.datasource.password"));

    return dataSource;
}

@Bean
public PlatformTransactionManager db2TransactionManager() {
    JpaTransactionManager transactionManager
            = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(
            db2EntityManager().getObject());
    return transactionManager;
}
}

এখানে আপনি আমার ব্লগে সম্পূর্ণ উদাহরণটি খুঁজে পেতে পারেন: একাধিক ডাটাসোর্স কনফিগারেশন সহ স্প্রিং বুট

Answer 6

# Here '1stDB' is the database name
spring.datasource.url=jdbc:mysql://localhost/A
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver


# Here '2ndDB' is the database name
spring.second-datasourcee.url=jdbc:mysql://localhost/B
spring.second-datasource.username=root
spring.second-datasource.password=root
spring.second-datasource.driver-class-name=com.mysql.jdbc.Driver


    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource firstDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.second-datasource")
    public DataSource secondDataSource() {
       return DataSourceBuilder.create().build();
    }

Answer 7

আমি মাইব্যাটিস ব্যবহার করেছি - স্প্রিংবুট ২.০ টেক স্ট্যাক, সমাধান:

//application.properties - start
    sp.ds1.jdbc-url=jdbc:mysql://localhost:3306/mydb?useSSL=false
    sp.ds1.username=user
    sp.ds1.password=pwd
    sp.ds1.testWhileIdle=true
    sp.ds1.validationQuery=SELECT 1
    sp.ds1.driverClassName=com.mysql.jdbc.Driver


    sp.ds2.jdbc-url=jdbc:mysql://localhost:4586/mydb?useSSL=false
    sp.ds2.username=user
    sp.ds2.password=pwd
    sp.ds2.testWhileIdle=true
    sp.ds2.validationQuery=SELECT 1
    sp.ds2.driverClassName=com.mysql.jdbc.Driver

//application.properties - end

//configuration class

    @Configuration
    @ComponentScan(basePackages = "com.mypkg")
    public class MultipleDBConfig {


        public static final String SQL_SESSION_FACTORY_NAME_1 = "sqlSessionFactory1";
        public static final String SQL_SESSION_FACTORY_NAME_2 = "sqlSessionFactory2";

        public static final String MAPPERS_PACKAGE_NAME_1 = "com.mypg.mymapper1";
        public static final String MAPPERS_PACKAGE_NAME_2 = "com.mypg.mymapper2";


        @Bean(name = "mysqlDb1")
        @Primary
        @ConfigurationProperties(prefix = "sp.ds1")
        public DataSource dataSource1() {
            System.out.println("db1 datasource");
            return DataSourceBuilder.create().build();
        }

        @Bean(name = "mysqlDb2")
        @ConfigurationProperties(prefix = "sp.ds2")
        public DataSource dataSource2() {
            System.out.println("db2 datasource");
            return  DataSourceBuilder.create().build();
        }

        @Bean(name = SQL_SESSION_FACTORY_NAME_1)
        @Primary
        public SqlSessionFactory sqlSessionFactory1(@Qualifier("mysqlDb1") DataSource dataSource1) throws Exception {
            System.out.println("sqlSessionFactory1");
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setTypeHandlersPackage(MAPPERS_PACKAGE_NAME_1);
            sqlSessionFactoryBean.setDataSource(dataSource1);
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBean.getObject();
            sqlSessionFactory.getConfiguration().setMapUnderscoreToCamelCase(true);
            sqlSessionFactory.getConfiguration().setJdbcTypeForNull(JdbcType.NULL);
            return sqlSessionFactory;
        }

        @Bean(name = SQL_SESSION_FACTORY_NAME_2)
        public SqlSessionFactory sqlSessionFactory2(@Qualifier("mysqlDb2") DataSource dataSource2) throws Exception {
            System.out.println("sqlSessionFactory2");
            SqlSessionFactoryBean diSqlSessionFactoryBean = new SqlSessionFactoryBean();
            diSqlSessionFactoryBean.setTypeHandlersPackage(MAPPERS_PACKAGE_NAME_2);
            diSqlSessionFactoryBean.setDataSource(dataSource2);
            SqlSessionFactory sqlSessionFactory = diSqlSessionFactoryBean.getObject();
            sqlSessionFactory.getConfiguration().setMapUnderscoreToCamelCase(true);
            sqlSessionFactory.getConfiguration().setJdbcTypeForNull(JdbcType.NULL);
            return sqlSessionFactory;
        }

        @Bean
        @Primary
        public MapperScannerConfigurer mapperScannerConfigurer1() {
            System.out.println("mapperScannerConfigurer1");
            MapperScannerConfigurer configurer = new MapperScannerConfigurer();
            configurer.setBasePackage(MAPPERS_PACKAGE_NAME_1);
            configurer.setSqlSessionFactoryBeanName(SQL_SESSION_FACTORY_NAME_1);
            return configurer;
        }

        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer2() {
            System.out.println("mapperScannerConfigurer2");
            MapperScannerConfigurer configurer = new MapperScannerConfigurer();
            configurer.setBasePackage(MAPPERS_PACKAGE_NAME_2);
            configurer.setSqlSessionFactoryBeanName(SQL_SESSION_FACTORY_NAME_2);
            return configurer;
        }



    }

দ্রষ্টব্য: 1) @ প্রাথমিক -> @ প্রাথমিক

2) ---। বৈশিষ্ট্যে "jdbc-url" -> স্প্রিং বুট 2.0 মাইগ্রেশনের পরে: ড্রাইভার ক্লাসনামের সাথে জেডিবিসি ইউআরএল প্রয়োজন

Answer 8

নীচের মতো কোনও পদ্ধতির বিপরীতে @ প্রথম টীকা ব্যবহার করা ভাল কাজ করে যদি দুটি ডেটা উত্স একই ডিবি লোকেশন / সার্ভারে থাকে।

@Bean(name = "datasource1")
@ConfigurationProperties("database1.datasource")
@Primary
public DataSource dataSource(){
  return DataSourceBuilder.create().build();
}

@Bean(name = "datasource2")
@ConfigurationProperties("database2.datasource")
public DataSource dataSource2(){
  return DataSourceBuilder.create().build();
}

যদি ডেটা উত্সগুলি বিভিন্ন সার্ভারে থাকে তবে @ প্রাথমিক এনোটোটেশনের সাথে @ কম্পোনেন্টটি ব্যবহার করা আরও ভাল । নিম্নলিখিত কোড স্নিপেট বিভিন্ন স্থানে দুটি পৃথক ডেটা উত্সগুলিতে ভাল কাজ করে

database1.datasource.url = jdbc:mysql://127.0.0.1:3306/db1
database1.datasource.username = root
database1.datasource.password = mysql
database1.datasource.driver-class-name=com.mysql.jdbc.Driver

database2.datasource1.url = jdbc:mysql://192.168.113.51:3306/db2
database2.datasource1.username = root
database2.datasource1.password = mysql
database2.datasource1.driver-class-name=com.mysql.jdbc.Driver

@Configuration
@Primary
@Component
@ComponentScan("com.db1.bean")
class DBConfiguration1{
    @Bean("db1Ds")
    @ConfigurationProperties(prefix="database1.datasource")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

}

@Configuration
@Component
@ComponentScan("com.db2.bean")
class DBConfiguration2{
    @Bean("db2Ds")
    @ConfigurationProperties(prefix="database2.datasource1")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

}

Answer 9

আমার প্রয়োজনীয়তা কিছুটা আলাদা ছিল তবে দুটি ডেটা উত্স ব্যবহৃত হয়েছিল।

একই প্যাকেজ থেকে একই জেপিএ সত্তার জন্য আমি দুটি ডেটা উত্স ব্যবহার করেছি। একটি সারণী তৈরি / আপডেট করতে সার্ভার স্টার্টআপে DDL চালানোর জন্য এবং অন্যটি রানটাইমে DML এর জন্য।

কোডের যে কোনও জায়গায় সুপার ইউজার প্রিভিলিজের আরও ব্যবহার রোধ করতে ডিডিএল বিবৃতি কার্যকর করার পরে ডিডিএল সংযোগটি বন্ধ করে দেওয়া উচিত।

প্রোপার্টি

spring.datasource.url=jdbc:postgresql://Host:port
ddl.user=ddluser
ddl.password=ddlpassword
dml.user=dmluser
dml.password=dmlpassword
spring.datasource.driver-class-name=org.postgresql.Driver

ডেটা উত্স কনফিগার ক্লাস

// ডিডিএল ডেটা উত্সের জন্য প্রথম কনফিগার ক্লাস

  public class DatabaseDDLConfig {
        @Bean
        public LocalContainerEntityManagerFactoryBean ddlEntityManagerFactoryBean() {
            LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
            PersistenceProvider persistenceProvider = new 
            org.hibernate.jpa.HibernatePersistenceProvider();
            entityManagerFactoryBean.setDataSource(ddlDataSource());
            entityManagerFactoryBean.setPackagesToScan(new String[] { 
            "com.test.two.data.sources"});
            HibernateJpaVendorAdapter vendorAdapter = new 
            HibernateJpaVendorAdapter();
            entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter);
            HashMap<String, Object> properties = new HashMap<>();
            properties.put("hibernate.dialect", 
            "org.hibernate.dialect.PostgreSQLDialect");
            properties.put("hibernate.physical_naming_strategy", 
            "org.springframework.boot.orm.jpa.hibernate.
            SpringPhysicalNamingStrategy");
            properties.put("hibernate.implicit_naming_strategy", 
            "org.springframework.boot.orm.jpa.hibernate.
            SpringImplicitNamingStrategy");
            properties.put("hibernate.hbm2ddl.auto", "update");
            entityManagerFactoryBean.setJpaPropertyMap(properties);
            entityManagerFactoryBean.setPersistenceUnitName("ddl.config");
            entityManagerFactoryBean.setPersistenceProvider(persistenceProvider);
            return entityManagerFactoryBean;
        }


    @Bean
    public DataSource ddlDataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("ddl.user");
        dataSource.setPassword(env.getProperty("ddl.password"));
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager ddlTransactionManager() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(ddlEntityManagerFactoryBean().getObject());
        return transactionManager;
    }
}

ডিএমএল ডেটা উত্সের জন্য // দ্বিতীয় কনফিগার ক্লাস class

public class DatabaseDMLConfig {

    @Bean
    @Primary
    public LocalContainerEntityManagerFactoryBean dmlEntityManagerFactoryBean() {
        LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
        PersistenceProvider persistenceProvider = new org.hibernate.jpa.HibernatePersistenceProvider();
        entityManagerFactoryBean.setDataSource(dmlDataSource());
        entityManagerFactoryBean.setPackagesToScan(new String[] { "com.test.two.data.sources" });
        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter);
        entityManagerFactoryBean.setJpaProperties(defineJpaProperties());
        entityManagerFactoryBean.setPersistenceUnitName("dml.config");
        entityManagerFactoryBean.setPersistenceProvider(persistenceProvider);
        return entityManagerFactoryBean;
    }

    @Bean
    @Primary
    public DataSource dmlDataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
        dataSource.setUrl(envt.getProperty("spring.datasource.url"));
        dataSource.setUsername("dml.user");
        dataSource.setPassword("dml.password");
        return dataSource;
    }

    @Bean
    @Primary
    public PlatformTransactionManager dmlTransactionManager() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(dmlEntityManagerFactoryBean().getObject());
        return transactionManager;
    }


  }

// কোডে ডিডিএল ডেটা উত্সের ব্যবহার।

public class DDLServiceAtStartup {

//Import persistence unit ddl.config for ddl purpose.

@PersistenceUnit(unitName = "ddl.config")
private EntityManagerFactory entityManagerFactory;

public void executeDDLQueries() throws ContentServiceSystemError {
    try {
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        entityManager.getTransaction().begin();
        entityManager.createNativeQuery("query to create/update table").executeUpdate();
        entityManager.flush();
        entityManager.getTransaction().commit();
        entityManager.close();

        //Close the ddl data source to avoid from further use in code.
        entityManagerFactory.close();
    } catch(Exception ex) {}
}

// কোডে ডিএমএল ডেটা উত্সের ব্যবহার।

public class DDLServiceAtStartup {
  @PersistenceUnit(unitName = "dml.config")
  private EntityManagerFactory entityManagerFactory;

  public void createRecord(User user) {
     userDao.save(user);
  }
}