ஸ்பிரிங் மாடுலித்தில் பல MySQL தரவு மூலங்களை நெறிப்படுத்துதல்

மட்டு தரவுத்தள மேலாண்மைக்கான தடையற்ற கட்டமைப்பு

ஸ்பிரிங் பூட் பயன்பாட்டில் பல தரவுமூலங்களை நிர்வகிப்பது சவாலானதாக இருக்கும், குறிப்பாக ஸ்பிரிங் மாடுலித் போன்ற மாடுலர் ஆர்கிடெக்சருடன் பணிபுரியும் போது. ஒவ்வொரு தொகுதிக்கும் தனிப்பட்ட தரவு மூலங்கள், பரிவர்த்தனை மேலாளர்கள் மற்றும் நிறுவன மேலாளர்கள் ஆகியவற்றை கைமுறையாக உள்ளமைக்க வேண்டிய அவசியம் பெரும்பாலும் வாய்மொழி மற்றும் மீண்டும் மீண்டும் வரும் குறியீட்டிற்கு வழிவகுக்கிறது. ஒவ்வொரு தொகுதியும் அதன் தனித்துவமான MySQL தரவுத்தளத்துடன் மற்றும் ஸ்கீமாவுடன் இணைக்கும்போது இந்த சிக்கலானது பெரிதாக்கப்படுகிறது.

தனித்துவமான தொகுதிகள் அங்கீகாரம், பில்லிங் மற்றும் அறிக்கையிடல் ஆகியவற்றைக் கையாளும் ஒரு அமைப்பை நீங்கள் உருவாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். ஒவ்வொரு தொகுதிக்கும் அதன் சொந்த பிரத்யேக தரவுத்தளம் தேவைப்படுகிறது, இது கவலைகளை பிரிப்பதையும் மேம்படுத்தப்பட்ட பராமரிப்பையும் உறுதி செய்கிறது. இருப்பினும், இந்த உள்ளமைவுகளை கைமுறையாக நிர்வகிப்பது ஒரு மேல்நோக்கிப் போராக உணர்கிறது. ஒவ்வொரு தொகுதிக்கும் பீன்ஸை வரையறுப்பதில் செலவழித்த முயற்சி உங்கள் உற்பத்தித்திறனைப் பாதிக்கும் ஒரு இடையூறாகும். 🏗️

எளிதான, அதிக தானியங்கி வழி இருந்தால் என்ன செய்வது? டெவலப்பர்கள் இன்று தரவுத்தள உள்ளமைவுகளை எளிதாக்கும் தீர்வுகளைத் தேடுகின்றனர், அவை மீண்டும் பயன்படுத்தக்கூடியதாகவும், தொகுதிகள் முழுவதும் சீரானதாகவும் இருக்கும். ஸ்பிரிங் மாடுலித்தின் திறன்களைப் பயன்படுத்துவதன் மூலம், கொதிகலன் குறியீடு மூலம் உங்கள் திட்டத்தை அதிகப்படுத்தாமல் பல தரவு மூலங்களை ஒருங்கிணைக்க ஒரு தூய்மையான அணுகுமுறை இருக்கலாம்.

இந்த வழிகாட்டியில், Spring Modulith பயன்பாட்டில் MySQL தரவுமூல உள்ளமைவை நெறிப்படுத்துவதற்கான அணுகுமுறையை ஆராய்வோம். உங்கள் வளர்ச்சி அனுபவத்தை மாற்றக்கூடிய நடைமுறை எடுத்துக்காட்டுகள் மற்றும் உத்திகளுக்கு நாங்கள் முழுக்கு போடுவோம், இது குறைவான சோர்வு மற்றும் திறமையானதாக இருக்கும். 🌟

பல MySQL தரவு மூலங்களுடன் ஸ்பிரிங் மாடுலித்தை மேம்படுத்துதல்

வழங்கப்பட்ட ஸ்கிரிப்டுகள் பல உள்ளமைவை சீராக்க வடிவமைக்கப்பட்டுள்ளன MySQL தரவு மூலங்கள் ஒரு ஸ்பிரிங் மாடுலித் பயன்பாட்டில். பண்புகள் அடிப்படையிலான உள்ளமைவுகளை மேம்படுத்துவதன் மூலம், ஒவ்வொரு தரவு மூலத்திற்கும் பீன்ஸை கைமுறையாக வரையறுக்க வேண்டிய தேவையை நாங்கள் தவிர்க்கிறோம். எடுத்துக்காட்டாக, `@EnableConfigurationProperties` இன் பயன்பாடு DatasourceProperties வகுப்பை நேரடியாக `application.yml` அல்லது `application.properties` கோப்புடன் இணைக்கிறது, இது தரவுத்தள உள்ளமைவுகளின் டைனமிக் இன்ஜெக்ஷனைச் செயல்படுத்துகிறது. இது கொதிகலன் குறியீட்டைக் குறைக்கிறது மற்றும் பராமரிப்பை ஊக்குவிக்கிறது. உங்கள் பயன்பாடு பயனர் அங்கீகாரம் மற்றும் பகுப்பாய்வு இரண்டையும் ஆதரிக்கும் ஒரு சூழ்நிலையை கற்பனை செய்து பாருங்கள், ஒவ்வொன்றும் தனித்தனி தரவுத்தளங்களைப் பயன்படுத்துகிறது - இந்த அமைப்பு இந்த தொகுதிகளுக்கு இடையில் தடையற்ற மாற்றங்களை உறுதி செய்கிறது. 🔄

ஸ்கிரிப்ட்டின் மற்றொரு முக்கிய பகுதி `HikariDataSource`, ஒரு உயர் செயல்திறன் இணைப்பு பூலிங் பொறிமுறையைப் பயன்படுத்துவதாகும். இது பல இணைப்புகளை திறமையாக நிர்வகிக்கிறது, இது அதிக போக்குவரத்து அல்லது ஒரே நேரத்தில் தரவுத்தள செயல்பாடுகளை கையாளும் பயன்பாடுகளுக்கு முக்கியமானது. கூடுதலாக, நிறுவனங்களை பொருத்தமான தரவுத்தள திட்டத்திற்கு வரைபடமாக்க, `LocalContainerEntityManagerFactoryBean` ஐ வரையறுக்கிறோம். இந்த மாடுலர் அணுகுமுறையானது, தனித்தனி தொகுதிகள் வெவ்வேறு திட்டங்களில் செயல்பட அனுமதிக்கிறது, பாதுகாப்பை மேம்படுத்துகிறது மற்றும் தரவின் தருக்கப் பிரிவினையை மேம்படுத்துகிறது. எடுத்துக்காட்டாக, தனித்தனி திட்டங்களில் உள்ள முக்கியமான பில்லிங் தகவலிலிருந்து அங்கீகாரத் தரவு தனிமைப்படுத்தப்பட்டு, பாதுகாப்பையும் இணக்கத்தையும் மேம்படுத்துகிறது.

`JpaTransactionManager`ன் பயன்பாடு தரவு மூலங்கள் முழுவதும் பரிவர்த்தனை ஒருமைப்பாட்டை உறுதி செய்கிறது. ஒவ்வொரு தரவு மூலமும் அதன் சொந்த பரிவர்த்தனை மேலாளரைப் பெறுகிறது, செயல்பாடுகள் பல தரவுத்தளங்களில் இருக்கும்போது மோதல்களைத் தடுக்கிறது. நடைமுறையில், ஒரு தொகுதி (அறிக்கையிடல் போன்றவை) தோல்வியடைந்தாலும், மற்றொரு தொகுதியில் (அங்கீகாரம் போன்றவை) பரிவர்த்தனைகள் பாதிக்கப்படாமல் இருக்கும். பயன்பாட்டின் நம்பகத்தன்மையை பராமரிக்க இந்த வடிவமைப்பு அவசியம். டெவலப்பர்கள் தனித்தனி மாட்யூல்களைச் சோதித்து மாற்றியமைக்க முடியும், இது பிழைத்திருத்தம் மற்றும் புதுப்பிப்புகளை மிகவும் கையாளக்கூடியதாக ஆக்குகிறது. 🚀

இறுதியாக, `@Qualifier` மற்றும் `setPackagesToScan` போன்ற கட்டளைகளுடன் உள்ளமைவின் மட்டுத்தன்மை மேம்படுத்தப்படுகிறது. ஒவ்வொரு தொகுதியும் அதன் குறிப்பிட்ட தரவுமூலம் மற்றும் நிறுவனங்களுடன் குழப்பமின்றி இணைக்கப்பட்டுள்ளதை இவை உறுதி செய்கின்றன. எடுத்துக்காட்டாக, ஒரு தொகுதியானது ஒரு பிரத்யேக திட்டத்தில் சேமிக்கப்பட்ட அறிக்கையிடல் தரவைக் கையாளுகிறது என்றால், `setPackagesToScan` ஆனது தொடர்புடைய தொகுப்பிற்கு மட்டுமே நிறுவனத்தை ஸ்கேன் செய்வதைக் கட்டுப்படுத்துகிறது. இது மேல்நிலையை குறைக்கிறது மற்றும் கணினியை மேலும் திறமையாக்குகிறது. ஒன்றாக, இந்த கட்டமைப்புகள் பல தரவு ஆதாரங்கள் தேவைப்படும் திட்டங்களுக்கு மீண்டும் பயன்படுத்தக்கூடிய, அளவிடக்கூடிய கட்டமைப்பை வழங்குகின்றன. பயன்பாடுகள் சிக்கலானதாக வளரும்போது இத்தகைய தகவமைப்பு மிகவும் முக்கியமானது, இந்த தீர்வை நவீன நிறுவன அமைப்புகளுக்கு ஏற்றதாக ஆக்குகிறது.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariDataSource;
@Configuration
@EnableConfigurationProperties(DatasourceProperties.class)
public class MultiDatasourceConfig {
    @Bean
    public DataSource dataSourceOne(DatasourceProperties properties) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(properties.getDbOne().getUrl());
        dataSource.setUsername(properties.getDbOne().getUsername());
        dataSource.setPassword(properties.getDbOne().getPassword());
        return dataSource;
    }
    @Bean
    public DataSource dataSourceTwo(DatasourceProperties properties) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(properties.getDbTwo().getUrl());
        dataSource.setUsername(properties.getDbTwo().getUsername());
        dataSource.setPassword(properties.getDbTwo().getPassword());
        return dataSource;
    }
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryOne(DataSource dataSourceOne) {
        LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
        factoryBean.setDataSource(dataSourceOne);
        factoryBean.setPackagesToScan("com.example.module1");
        factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        return factoryBean;
    }
    @Bean
    public JpaTransactionManager transactionManagerOne(EntityManagerFactory entityManagerFactoryOne) {
        return new JpaTransactionManager(entityManagerFactoryOne);
    }
}

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConstructorBinding;
import org.springframework.stereotype.Component;
@ConfigurationProperties(prefix = "datasource")
@Component
public class DatasourceProperties {
    private final DbProperties dbOne;
    private final DbProperties dbTwo;
    @ConstructorBinding
    public DatasourceProperties(DbProperties dbOne, DbProperties dbTwo) {
        this.dbOne = dbOne;
        this.dbTwo = dbTwo;
    }
    public DbProperties getDbOne() { return dbOne; }
    public DbProperties getDbTwo() { return dbTwo; }
}
class DbProperties {
    private String url;
    private String username;
    private String password;
    // Getters and setters...
}

தானியங்கு தரவுத்தள நிர்வாகத்துடன் மாடுலித் பயன்பாடுகளை மேம்படுத்துதல்

ஸ்பிரிங் மாடுலித் பயன்பாட்டில் பல தரவு மூலங்களை உள்ளமைப்பதில் அடிக்கடி கவனிக்கப்படாத அம்சம் பிழை கையாளுதல் மற்றும் கண்காணிப்பு ஆகும். பலவற்றைக் கையாளும் போது MySQL தரவு மூலங்கள், இணைப்பு தோல்விகள் அல்லது தவறான உள்ளமைவுகளை முன்கூட்டியே கண்டறியும் வழிமுறைகளை வைத்திருப்பது அவசியம். ஸ்பிரிங் பூட் ஆக்சுவேட்டர் போன்ற கருவிகளைப் பயன்படுத்தி ஒவ்வொரு தரவு மூலத்திற்கும் சுகாதாரச் சோதனைகளைச் செயல்படுத்துவது நிகழ்நேர நிலை நுண்ணறிவை வழங்க முடியும். பயனர் மேலாண்மை அல்லது அறிக்கையிடல் போன்ற தனிப்பட்ட தொகுதிகள் சரியாகச் செயல்படுவதை உறுதிசெய்ய இந்த சுகாதார இறுதிப்புள்ளிகள் உதவுகின்றன. எடுத்துக்காட்டாக, அங்கீகரிப்பு தொகுதியின் தரவுமூலம் தோல்வியுற்றால் கண்காணிப்பு அமைப்பு உங்களை எச்சரிக்கலாம். 🛠️

மற்றொரு முக்கியமான அம்சம் சுற்றுச்சூழல்-குறிப்பிட்ட உள்ளமைவுகளின் ஒருங்கிணைப்பு ஆகும். பயன்பாடுகள் பெரும்பாலும் மேம்பாடு, சோதனை மற்றும் உற்பத்தி போன்ற பல சூழல்களில் இயங்குகின்றன. ஸ்பிரிங் சுயவிவரங்களைப் பயன்படுத்துவதன் மூலம், நீங்கள் சூழல் சார்ந்த தரவுமூல பண்புகளை மாறும் வகையில் ஏற்றலாம். வளர்ச்சித் தரவுத்தளங்கள் தனிமைப்படுத்தப்பட்டிருக்கும் போது, ​​உற்பத்தி அமைப்பு பாதுகாப்பாக இணைக்கப்படுவதை இது உறுதி செய்கிறது. எடுத்துக்காட்டாக, ஒரு டெவலப்பர் ஒரு இலகுரக MySQL நிகழ்வைப் பயன்படுத்தி உள்நாட்டில் சோதிக்க முடியும், அதே நேரத்தில் தயாரிப்பு தரவுமூலம் AWS RDS ஐப் பயன்படுத்துகிறது. சுயவிவரங்கள் இத்தகைய மாற்றங்களை தடையின்றி செய்து பாதுகாப்பை பராமரிக்கின்றன.

இறுதியாக, மேம்பட்ட இணைப்பு பூலிங் உள்ளமைவுகளைப் பயன்படுத்துவதைக் கவனியுங்கள். போது ஹிகாரிசிபி முன்னிருப்பாக மிகவும் திறமையானது, பூல் அளவை மேம்படுத்துதல், காலக்கெடு மற்றும் சரிபார்ப்பு வினவல்கள் சுமையின் கீழ் அதிகபட்ச செயல்திறனை உறுதி செய்கிறது. எடுத்துக்காட்டாக, உங்கள் அறிக்கையிடல் தொகுதியானது கடுமையான வினவல்களை அடிக்கடி செயல்படுத்தினால், குறிப்பிட்ட தரவுமூலத்திற்கான இணைப்புக் குளத்தின் அளவை அதிகரிப்பது இடையூறுகளைத் தடுக்கலாம். இந்த மாடுலர் உள்ளமைவு, பயனரின் தேவைகள் அதிகரிக்கும் போது, ​​பயன்பாட்டை அளவிடக்கூடியதாகவும் வலுவாகவும் ஆக்குகிறது. ஒன்றாக, இந்த உத்திகள் உங்கள் ஸ்பிரிங் மாடுலித் அமைப்பை மேம்படுத்துகின்றன மற்றும் அனைத்து தொகுதிகளிலும் நம்பகத்தன்மையை பராமரிக்கின்றன. 🚀