🧝🏼 🎼 👜 ClusterJ - जावा से MySQL NDB क्लस्टर के साथ काम करना 🍇 ⚠️ 😩

नमस्कार, हेब्र! इस लेख में मैं जावा के लिए एक लाइब्रेरी पर विचार करना चाहता हूं जैसे कि ClusterJ , जो Java कोड से MySQL NDBCLUSTER इंजन के साथ काम करना बहुत आसान बनाता है, जो कि JPA और Hibernate अवधारणा के समान एक उच्च-स्तरीय एपीआई है।

इस लेख के ढांचे में, हम SpringBoot पर एक सरल एप्लिकेशन बनाएंगे, और ऑटोकॉन्फ़िगरेशन का उपयोग करके अनुप्रयोगों में सुविधाजनक उपयोग के लिए बोर्ड पर ClusterJ साथ एक स्टार्टर भी बनाएंगे। हम JUnit5 और TestContainers का उपयोग करके सरल परीक्षण TestContainers , जो एपीआई के मूल उपयोग को दिखाएगा।
मैं कई कमियों के बारे में भी बात करूंगा जो मुझे उसके साथ काम करने की प्रक्रिया में सामना करना पड़ा था।

कौन परवाह करता है, बिल्ली में आपका स्वागत है।

परिचय

MySQL NDB Cluster सक्रिय रूप से काम में उपयोग किया जाता है, और एक परियोजना में, गति के लिए, कार्य सामान्य JDBC बजाय ClusterJ पुस्तकालय का उपयोग करना था, जो कि इसके API में JPA समान है, और वास्तव में, libndbclient.so लाइब्रेरी पर एक आवरण है जो इसे JNI माध्यम से उपयोग करता है।

जो लोग नहीं जानते हैं, उनके लिए MySQL NDB क्लस्टर एक वितरित कंप्यूटिंग वातावरण के लिए अनुकूलित एक अत्यधिक सुलभ और निरर्थक MySQL संस्करण है जो क्लस्टर में संचालित करने के लिए NDB भंडारण NDB ( NDBCLUSTER ) का उपयोग करता है। मैं यहाँ इस पर विस्तार से ध्यान नहीं देना चाहता, आप यहाँ और यहाँ पढ़ सकते हैं

इस डेटाबेस के साथ जावा कोड से काम करने के दो तरीके हैं:

JDBC और SQL प्रश्नों के माध्यम से मानक
MySQL Cluster में उच्च-प्रदर्शन डेटा एक्सेस के लिए Via ClusterJ ।

ClusterJ 4 मुख्य अवधारणाओं के आसपास बनाया गया है:

SessionFactory - कनेक्शन पूल का एक एनालॉग, जिसका उपयोग सत्र प्राप्त करने के लिए किया जाता है। क्लस्टर के प्रत्येक उदाहरण का अपना सत्र सत्र होना चाहिए।
Session - एक MySQL क्लस्टर के लिए एक सीधा संबंध है।
Domain Object - एक एनोटेट इंटरफ़ेस जो JPA समान Java कोड में तालिका के मानचित्रण का प्रतिनिधित्व JPA ।
Transaction - कार्य की एक परमाणु इकाई है। किसी भी समय, एक सत्र में, एक लेनदेन निष्पादित होता है। कोई भी ऑपरेशन (प्राप्त करें, डालें, अपडेट करें, हटाएं) एक नए लेनदेन में किया जाता है।

क्लस्टर सीमाएँ:

जॉइन का अभाव
टेबल और इंडेक्स बनाने का कोई तरीका नहीं है। ऐसा करने के लिए, JDBC उपयोग करें।
कोई विलंबित लोडिंग ( Lazy ) नहीं। एक बार में पूरा रिकॉर्ड डाउनलोड किया जाता है।
डोमेन ऑब्जेक्ट में, तालिकाओं के बीच संबंधों को परिभाषित करना संभव नहीं है। OneToMany , ManyToOne , OneToMany की समानता पूरी तरह से अनुपस्थित है।

अभ्यास। बात सस्ती है। मुझे कोड दिखाओ।

ठीक है, पर्याप्त सिद्धांत, चलिए अभ्यास करते हैं।

सामना करने वाली पहली समस्या केंद्रीय मावेन रिपॉजिटरी में ClusterJ की कमी है। स्थानीय रिपॉजिटरी में पेन के साथ लाइब्रेरी स्थापित करें। यह स्पष्ट है कि अच्छे के लिए, यह Nexus या कुछ Artifactory में झूठ होना चाहिए, लेकिन हमारे उदाहरण के लिए यह अनावश्यक है।

इसलिए, यहां जाएं और अपना ऑपरेटिंग सिस्टम चुनें। यदि आप एक Linux OS पर हैं, तो Linux mysql-cluster-community-java नामक पैकेज डाउनलोड करें और इस rpm / डिब पैकेज को स्थापित करें। यदि आपके पास Windows , तो पूर्ण mysql-cluster-gp संग्रह डाउनलोड करें।

एक तरह से या किसी अन्य, हमारे पास फ़ॉर्म की एक जार फ़ाइल होगी: clusterj-{version}.jar । हम इसे maven माध्यम से डालते हैं:

 mvn install:install-file -DgroupId=com.mysql.ndb -DartifactId=clusterj -Dversion={version} -Dpackaging=jar -Dfile=clusterj-{version}.jar -DgeneratePom=true

हमें libndbclient लाइब्रेरी की भी आवश्यकता है, जो NDB API साथ काम करने के लिए C++ फ़ंक्शंस का एक सेट है, जिसे ClusterJ माध्यम से कॉल करता है। Windows यह लाइब्रेरी (.dll) ndbclient_{version} mysql-cluster-gp संग्रह में है, Linux आपको ndbclient_{version} पैकेज डाउनलोड करना ndbclient_{version} ।

इसके बाद, एक प्रोजेक्ट बनाएं। हम परीक्षण के लिए SpringBoot , JUnit5 + TestContainers उपयोग करेंगे।

परियोजना की अंतिम संरचना

परियोजना में दो मॉड्यूल शामिल हैं:

clusterj-spring-boot-starter एक स्टार्टर है जिसमें ClusterJ शामिल ClusterJ , साथ ही एटकोनफिगरेशन भी है। इस स्टार्टर की बदौलत, हम हमारे appliation.yml फ़ाइल में MySQL NDB के कनेक्शन का वर्णन इस प्रकार कर सकते हैं:

 clusterj: connectString: localhost:1186 dataBaseName: NDB_DB

उसके बाद, SpringBoot हमारे लिए कनेक्शन के लिए आवश्यक SessionFactory कारखाना बना देगा।

clusterj-app ही एप्लिकेशन है, जिसे हमारा स्टार्टर उपयोग करेगा। आइए हम इस पर अधिक विस्तार से ध्यान दें।

आरंभ करने के लिए, हमें JPA तरह एक डोमेन मॉडल बनाना होगा। केवल इस मामले में हमें इसे एक इंटरफ़ेस के रूप में करने की आवश्यकता है, जिसमें clusterj का कार्यान्वयन clusterj जाएगा:

 import com.mysql.clusterj.annotation.Column; import com.mysql.clusterj.annotation.PersistenceCapable; import com.mysql.clusterj.annotation.PrimaryKey; @PersistenceCapable(table = "user") public interface User { @PrimaryKey int getId(); void setId(int id); @Column(name = "firstName") String getFirstName(); void setFirstName(String firstName); @Column(name = "lastName") String getLastName(); void setLastName(String lastName); }

अभी एक समस्या है। PersistenceCapable एनोटेशन में स्कीमा या डेटाबेस का नाम निर्दिष्ट करने की क्षमता है जिसमें तालिका निहित है, हालांकि यह काम नहीं करता है। निश्चित रूप से। ClusterJ इसे लागू नहीं किया गया है। इसलिए, ClusterJ माध्यम से काम कर रहे सभी तालिकाओं को एक ही स्कीमा में होना चाहिए, जिसके परिणामस्वरूप तालिकाओं का एक डंप होता है, जो तार्किक रूप से विभिन्न ClusterJ होना चाहिए।

अब इस इंटरफ़ेस का उपयोग करने का प्रयास करते हैं। ऐसा करने के लिए, हम एक साधारण परीक्षण लिखते हैं।

MySQL Cluster स्थापित करने से परेशान नहीं होने के लिए, हम एकीकरण परीक्षण TestContainers और Docker के लिए अद्भुत पुस्तकालय का उपयोग करेंगे। चूंकि हम JUnit5 का उपयोग कर रहे हैं, हम एक सरल Extension लिखेंगे:

एक्सटेंशन सोर्स कोड

 import com.github.dockerjava.api.model.Network; import lombok.extern.slf4j.Slf4j; import org.junit.jupiter.api.extension.Extension; import org.testcontainers.containers.BindMode; import org.testcontainers.containers.GenericContainer; import org.testcontainers.containers.wait.strategy.Wait; import org.testcontainers.shaded.com.google.common.collect.ImmutableMap; import java.time.Duration; import java.util.stream.Stream; @Slf4j class MySQLClusterTcExtension implements Extension { private static final String MYSQL_USER = "sys"; private static final String MYSQL_PASSWORD = "qwerty"; private static final String CLUSTERJ_DATABASE = "NDB_DB"; private static Network.Ipam getIpam() { Network.Ipam ipam = new Network.Ipam(); ipam.withDriver("default"); Network.Ipam.Config config = new Network.Ipam.Config(); config.withSubnet("192.168.0.0/16"); ipam.withConfig(config); return ipam; } private static org.testcontainers.containers.Network network = org.testcontainers.containers.Network.builder() .createNetworkCmdModifier(createNetworkCmd -> createNetworkCmd.withIpam(getIpam())) .build(); private static GenericContainer ndbMgmd = new GenericContainer<>("mysql/mysql-cluster") .withNetwork(network) .withClasspathResourceMapping("mysql-cluster.cnf", "/etc/mysql-cluster.cnf", BindMode.READ_ONLY) .withClasspathResourceMapping("my.cnf", "/etc/my.cnf", BindMode.READ_ONLY) .withCreateContainerCmdModifier(createContainerCmd -> createContainerCmd.withIpv4Address("192.168.0.2")) .withCommand("ndb_mgmd") .withExposedPorts(1186) .waitingFor(Wait.forListeningPort().withStartupTimeout(Duration.ofSeconds(150))); private static GenericContainer ndbd1 = new GenericContainer<>("mysql/mysql-cluster") .withNetwork(network) .withClasspathResourceMapping("mysql-cluster.cnf", "/etc/mysql-cluster.cnf", BindMode.READ_ONLY) .withClasspathResourceMapping("my.cnf", "/etc/my.cnf", BindMode.READ_ONLY) .withCreateContainerCmdModifier(createContainerCmd -> createContainerCmd.withIpv4Address("192.168.0.3")) .withCommand("ndbd"); private static GenericContainer ndbMysqld = new GenericContainer<>("mysql/mysql-cluster") .withNetwork(network) .withCommand("mysqld") .withCreateContainerCmdModifier(createContainerCmd -> createContainerCmd.withIpv4Address("192.168.0.10")) .withClasspathResourceMapping("mysql-cluster.cnf", "/etc/mysql-cluster.cnf", BindMode.READ_ONLY) .withClasspathResourceMapping("my.cnf", "/etc/my.cnf", BindMode.READ_ONLY) .waitingFor(Wait.forListeningPort()) .withEnv(ImmutableMap.of("MYSQL_DATABASE", CLUSTERJ_DATABASE, "MYSQL_USER", MYSQL_USER, "MYSQL_PASSWORD", MYSQL_PASSWORD)) .withExposedPorts(3306) .waitingFor(Wait.forListeningPort()); static { log.info("Start MySQL Cluster testcontainers extension...\n"); Stream.of(ndbMgmd, ndbd1, ndbMysqld).forEach(GenericContainer::start); String ndbUrl = ndbMgmd.getContainerIpAddress() + ":" + ndbMgmd.getMappedPort(1186); String mysqlUrl = ndbMysqld.getContainerIpAddress() + ":" + ndbMysqld.getMappedPort(3306); String mysqlConnectionString = "jdbc:mysql://" + mysqlUrl + "/" + CLUSTERJ_DATABASE + "?useUnicode=true" + "&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false"; System.setProperty("clusterj.connectString", ndbUrl); System.setProperty("clusterj.dataBaseName", CLUSTERJ_DATABASE); System.setProperty("spring.datasource.username", MYSQL_USER); System.setProperty("spring.datasource.password", MYSQL_PASSWORD); System.setProperty("spring.datasource.url", mysqlConnectionString); } }

इस एक्सटेंशन में, हम क्लस्टर के कंट्रोल नोड, नोड के लिए एक तिथि और MySQL नोड बढ़ाते हैं। उसके बाद, हमने स्प्रिंगबूट द्वारा उपयोग के लिए उचित कनेक्शन सेटिंग्स सेट कीं, बस जो हमने स्टार्टर ऑटो-कॉन्फ़िगरेशन में वर्णित की हैं:

 System.setProperty("clusterj.connectString", ndbUrl); System.setProperty("clusterj.dataBaseName", CLUSTERJ_DATABASE); System.setProperty("spring.datasource.username", MYSQL_USER); System.setProperty("spring.datasource.password", MYSQL_PASSWORD); System.setProperty("spring.datasource.url", mysqlConnectionString);

अगला, हम एक एनोटेशन लिखते हैं जो हमें परीक्षणों में कंटेनरों को घोषित रूप से बढ़ाने की अनुमति देगा। यहां सब कुछ बहुत सरल है, हम अपने एक्सटेंशन का उपयोग करते हैं:

 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @ExtendWith(MySQLClusterTcExtension.class) public @interface EnableMySQLClusterContainer { }

अंत में, हम परीक्षण लिखते हैं:

 @Test void shouldGetUserViaClusterJ() { User newUser = session.newInstance(User.class); newUser.setId(1); newUser.setFirstName("John"); newUser.setLastName("Jonson"); session.persist(newUser); User userFromDb = session.find(User.class, 1); assertAll( () -> assertEquals(userFromDb.getId(), 1), () -> assertEquals(userFromDb.getFirstName(), "John"), () -> assertEquals(userFromDb.getLastName(), "Jonson")); }

यह परीक्षण दिखाता है कि हम प्राथमिक कुंजी द्वारा रिकॉर्ड कैसे प्राप्त कर सकते हैं। यह क्वेरी SQL क्वेरी के बराबर है:

 SELECT * FROM user WHERE id = 1;

चलो एक और परीक्षण करते हैं, अधिक जटिल तर्क के साथ:

 @Test void queryBuilderTest() { QueryBuilder builder = session.getQueryBuilder(); QueryDomainType<User> userQueryDomainType = builder.createQueryDefinition(User.class); // parameter PredicateOperand propertyIdParam = userQueryDomainType.param("lastName"); // property PredicateOperand propertyEntityId = userQueryDomainType.get("lastName"); userQueryDomainType.where(propertyEntityId.equal(propertyIdParam)); Query<User> query = session.createQuery(userQueryDomainType); query.setParameter("lastName", "Jonson"); List<User> foundEntities = query.getResultList(); Optional<User> firstUser = foundEntities.stream().filter(u -> u.getId() == 1).findFirst(); Optional<User> secondUser = foundEntities.stream().filter(u -> u.getId() == 2).findFirst(); assertAll( () -> assertEquals(foundEntities.size(), 2), () -> assertTrue(firstUser.isPresent()), () -> assertTrue(secondUser.isPresent()), () -> assertThat(firstUser.get(), allOf( hasProperty("firstName", equalTo("John")), hasProperty("lastName", equalTo("Jonson")) ) ), () -> assertThat(secondUser.get(), allOf( hasProperty("firstName", equalTo("Alex")), hasProperty("lastName", equalTo("Jonson")) ) ) ); }

QueryBuilder उपयोग जटिल प्रश्नों का निर्माण करने के लिए किया जाता है, where , equal , like QueryBuilder । इस परीक्षण में, हम उन सभी उपयोगकर्ताओं को बाहर निकालते हैं जिनका अंतिम नाम = जोंसन है। यह क्वेरी निम्न SQL बराबर है:

 SELECT * FROM user WHERE lastName = 'Jonson';

यहाँ भी, एक समस्या में भाग गया। प्रपत्र की एक क्वेरी संकलित करने में असमर्थ

 SELECT * FROM user WHERE (lastName = 'Jonson' and firstName = 'John') or id = 2;

यह सुविधा वर्तमान में लागू नहीं है। आप परीक्षण देख सकते हैं: andOrNotImplemented ।

पूर्ण परीक्षण उदाहरण

 @SpringBootTest @ExtendWith(SpringExtension.class) @EnableAutoConfiguration @EnableMySQLClusterContainer class NdbClusterJTest { @Autowired private JdbcTemplate jdbcTemplate; @Autowired private SessionFactory sessionFactory; private Session session; @BeforeEach void setUp() { jdbcTemplate.execute("CREATE TABLE IF NOT EXISTS `user` (id INT NOT NULL PRIMARY KEY," + " firstName VARCHAR(64) DEFAULT NULL," + " lastName VARCHAR(64) DEFAULT NULL) ENGINE=NDBCLUSTER;"); session = sessionFactory.getSession(); } @Test void shouldGetUserViaClusterJ() { User newUser = session.newInstance(User.class); newUser.setId(1); newUser.setFirstName("John"); newUser.setLastName("Jonson"); session.persist(newUser); User userFromDb = session.find(User.class, 1); assertAll( () -> assertEquals(userFromDb.getId(), 1), () -> assertEquals(userFromDb.getFirstName(), "John"), () -> assertEquals(userFromDb.getLastName(), "Jonson")); } @Test void queryBuilderTest() { User newUser1 = session.newInstance(User.class); newUser1.setId(1); newUser1.setFirstName("John"); newUser1.setLastName("Jonson"); User newUser2 = session.newInstance(User.class); newUser2.setId(2); newUser2.setFirstName("Alex"); newUser2.setLastName("Jonson"); session.persist(newUser1); session.persist(newUser2); QueryBuilder builder = session.getQueryBuilder(); QueryDomainType<User> userQueryDomainType = builder.createQueryDefinition(User.class); // parameter PredicateOperand propertyIdParam = userQueryDomainType.param("lastName"); // property PredicateOperand propertyEntityId = userQueryDomainType.get("lastName"); userQueryDomainType.where(propertyEntityId.equal(propertyIdParam)); Query<User> query = session.createQuery(userQueryDomainType); query.setParameter("lastName", "Jonson"); List<User> foundEntities = query.getResultList(); Optional<User> firstUser = foundEntities.stream().filter(u -> u.getId() == 1).findFirst(); Optional<User> secondUser = foundEntities.stream().filter(u -> u.getId() == 2).findFirst(); assertAll( () -> assertEquals(foundEntities.size(), 2), () -> assertTrue(firstUser.isPresent()), () -> assertTrue(secondUser.isPresent()), () -> assertThat(firstUser.get(), allOf( hasProperty("firstName", equalTo("John")), hasProperty("lastName", equalTo("Jonson")) ) ), () -> assertThat(secondUser.get(), allOf( hasProperty("firstName", equalTo("Alex")), hasProperty("lastName", equalTo("Jonson")) ) ) ); } @Test void andOrNotImplemented() { QueryBuilder builder = session.getQueryBuilder(); QueryDomainType<User> userQueryDomainType = builder.createQueryDefinition(User.class); // parameter PredicateOperand firstNameParam = userQueryDomainType.param("firstName"); // property PredicateOperand firstName = userQueryDomainType.get("firstName"); // parameter PredicateOperand lastNameParam = userQueryDomainType.param("lastName"); // property PredicateOperand lastName = userQueryDomainType.get("lastName"); // parameter PredicateOperand idParam = userQueryDomainType.param("id"); // property PredicateOperand id = userQueryDomainType.get("id"); Executable executable = () -> userQueryDomainType.where(firstNameParam.equal(firstName) .and(lastNameParam.equal(lastName)) .or(idParam.equal(id))); UnsupportedOperationException exception = assertThrows(UnsupportedOperationException.class, executable); assertEquals("Not implemented.", exception.getMessage()); } @AfterEach void tearDown() { session.deletePersistentAll(User.class); session.close(); } }

हमारे एनोटेशन @EnableMySQLClusterContainer के लिए धन्यवाद, हमने परीक्षणों के लिए वातावरण तैयार करने के विवरण को छिपा दिया। इसके अलावा, हमारे स्टार्टर के लिए, हम बस अपने परीक्षण में सेशनफैक्टरी को इंजेक्ट कर सकते हैं, और इसे अपनी आवश्यकताओं के लिए उपयोग कर सकते हैं, इस तथ्य के बारे में चिंता किए बिना कि इसे मैन्युअल रूप से बनाने की आवश्यकता है।
यह सब हमें सेवा के बुनियादी ढांचे के बजाय परीक्षणों के व्यापार तर्क को लिखने पर केंद्रित करता है।

मैं इस तथ्य पर भी ध्यान देना चाहता हूं कि आपको पैरामीटर के साथ ClusterJ का उपयोग करने वाले एप्लिकेशन को चलाने की आवश्यकता है:

 -Djava.library.path=/usr/lib/x86_64-linux-gnu/

जो libndbclient.so को रास्ता libndbclient.so । इसके बिना, कुछ भी काम नहीं करेगा।

निष्कर्ष

मेरे लिए, ClusterJ उन प्रणालियों में ClusterJ अच्छी बात है जो डेटा एक्सेस स्पीड के लिए महत्वपूर्ण हैं, लेकिन मामूली खामियां और सीमाएं समग्र प्रभाव को खराब करती हैं। यदि आपके पास चुनने का अवसर है और आप पहुंच की गति की परवाह नहीं करते हैं, तो मुझे लगता है कि JDBC का उपयोग करना बेहतर है।

लेख ने लेनदेन और ताले के साथ काम करने पर विचार नहीं किया, और इसलिए यह काफी बदल गया।

यह बात है, हैप्पी कोडिंग!

उपयोगी लिंक:

परियोजना के साथ सभी कोड यहाँ निहित हैं
डाउनलोड पृष्ठ
ClusterJ के बारे में जानकारी
जावा और एनडीबी क्लस्टर के साथ काम करें
प्रो MySQL NDB क्लस्टर बुक
MySQL NDB क्लस्टर के बारे में और यहाँ

MySQL रिपॉजिटरी में और भी अधिक परीक्षण मामले।

ClusterJ - जावा से MySQL NDB क्लस्टर के साथ काम करना

परिचय

अभ्यास। बात सस्ती है। मुझे कोड दिखाओ।

निष्कर्ष

उपयोगी लिंक:

More articles: