स्प्रिंग डेटा की-वैल्यू रिपोजिटरी का उपयोग करके डेटा खोजों का आयोजन

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



और इसलिए स्प्रिंग में KeyValueOperations है, जो स्प्रिंग डेटा रिपॉजिटरी के समान है, लेकिन यह Key-Value की अवधारणा पर काम करता है और डेटा को एक HashMap संरचना में रखता है (मैंने यहां स्प्रिंग डेटा रिपॉजिटरी के बारे में लिखा है )। वस्तुएं किसी भी प्रकार की हो सकती हैं, मुख्य बात यह है कि कुंजी निर्दिष्ट है।

public class Status { @org.springframework.data.annotation.Id private long statusId; private String code; private String name; .... 

यहां कुंजी स्थिति आईडीडी है, और एनोटेशन का पूरा रास्ता विशेष रूप से इंगित किया गया है, भविष्य में मैं जेपीए इकाई का उपयोग करूंगा, और वहां एक आईडी भी है, लेकिन पहले से ही डेटाबेस से संबंधित है।
KeyValueOperations में स्प्रिंग डेटा रिपॉजिटरी के समान तरीके हैं

 interface KeyValueOperations { <T> T insert(T objectToInsert); void update(Object objectToUpdate); void delete(Class<?> type); <T> T findById(Object id, Class<T> type); <T> Iterable<T> find(KeyValueQuery<?> query, Class<T> type); .... . 

तो आप स्प्रिंग बीन के लिए जावा KeyValueOperations कॉन्फ़िगरेशन निर्दिष्ट कर सकते हैं

 @SpringBootApplication public class DemoSpringDataApplication { @Bean public KeyValueOperations keyValueTemplate() { return new KeyValueTemplate(keyValueAdapter()); } @Bean public KeyValueAdapter keyValueAdapter() { return new MapKeyValueAdapter(ConcurrentHashMap.class); } 

शब्दकोश भंडारण वर्ग यहाँ सूचीबद्ध है - समवर्ती हाशप

और जब से मैं जेपीए इकाई शब्दकोशों के साथ काम करूंगा, मैं उनमें से दो को इस परियोजना से जोड़ूंगा।

यह "स्थिति" और "कार्ड" का शब्दकोश है

 @Entity public class Status { @org.springframework.data.annotation.Id private long statusId; private String code; private String name; @Id @Column(name = "STATUS_ID") public long getStatusId() { return statusId; } .... @Entity public class Card { @org.springframework.data.annotation.Id private long cardId; private String code; private String name; @Id @Column(name = "CARD_ID") public long getCardId() { return cardId; } ... 

ये मानक संस्थाएं हैं जो डेटाबेस में तालिकाओं के अनुरूप हैं, मैं प्रत्येक इकाई के लिए दो Id एनोटेशन पर ध्यान आकर्षित करता हूं, एक जेपीए के लिए, दूसरा KeyValueOperations के लिए।

शब्दकोशों की संरचना समान है, उनमें से एक का उदाहरण है

 create table STATUS ( status_id NUMBER not null, code VARCHAR2(20) not null, name VARCHAR2(50) not null ); -- Create/Recreate primary, unique and foreign key constraints alter table STATUS add constraint STATUS_PK primary key (STATUS_ID) 

उनके लिए स्प्रिंग डेटा रिपोजिटरी:

 @Repository public interface CardCrudRepository extends CrudRepository<Card, Long> { } @Repository public interface StatusCrudRepository extends CrudRepository<Status, Long> { } 

और यहाँ DictionaryProvider उदाहरण है जहाँ हम स्प्रिंग डेटा रिपॉजिटरी और KeyValueOperations कनेक्ट करते हैं

 @Service public class DictionaryProvider { private static Logger logger = LoggerFactory.getLogger(DictionaryProvider.class); private Map<Class, CrudRepository> repositoryMap = new HashMap<>(); @Autowired private KeyValueOperations keyValueTemplate; @Autowired private StatusCrudRepository statusRepository; @Autowired private CardCrudRepository cardRepository; @PostConstruct public void post() { repositoryMap.put(Status.class, statusRepository); repositoryMap.put(Card.class, cardRepository); } public <T> Optional<T> dictionaryById(Class<T> clazz, long id) { Optional<T> optDictionary = keyValueTemplate.findById(id, clazz); if (optDictionary.isPresent()) { logger.info("Dictionary {} found in keyValueTemplate", optDictionary.get()); return optDictionary; } CrudRepository crudRepository = repositoryMap.get(clazz); optDictionary = crudRepository.findById(id); keyValueTemplate.insert(optDictionary.get()); logger.info("Dictionary {} insert in keyValueTemplate", optDictionary.get()); return optDictionary; } .... 

ऑटो इंजेक्शन इसमें रिपॉजिटरी के लिए और KeyValueOperations के लिए इंस्टॉल किए जाते हैं, और फिर सरल लॉजिक (यहां, बिना नल आदि की जांच के), हम keyValueTemplate डिक्शनरी में देखते हैं, अगर वहाँ है, तो हम वापस आ जाते हैं, अन्यथा हम crudRepository के माध्यम से डेटाबेस से निकालते हैं और keyValueTemplate में जगह देते हैं, और देते हैं। बाहर।

लेकिन अगर यह सब केवल एक महत्वपूर्ण खोज तक सीमित होगा, तो शायद कुछ खास नहीं है। और इसलिए KeyValueOperations में CRUD ऑपरेशन, और अनुरोधों की एक विस्तृत श्रृंखला है। यहां एक ही keyValueTemplate में खोज का एक उदाहरण है, लेकिन पहले से ही KeyValueQuery क्वेरी का उपयोग करके कोड द्वारा।

  public <T> Optional<T> dictionaryByCode(Class<T> clazz, String code) { KeyValueQuery<String> query = new KeyValueQuery<>(String.format("code == '%s'", code)); Iterable<T> iterable = keyValueTemplate.find(query, clazz); Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return Optional.of(iterator.next()); } return Optional.empty(); } 

और यह समझ में आता है, अगर पहले मैंने आईडी द्वारा खोजा था और ऑब्जेक्ट keyValueTemplate में मिला था, तो उसी ऑब्जेक्ट के कोड से खोज करने पर यह पहले से ही keyValueTemplate से वापस आ जाएगा, डेटाबेस तक कोई पहुंच नहीं होगी। वसंत अभिव्यक्ति भाषा का उपयोग अनुरोध का वर्णन करने के लिए किया जाता है।

परीक्षण के उदाहरण:
आईडी खोज

  private void find() { Optional<Status> status = dictionaryProvider.dictionaryById(Status.class, 1L); Assert.assertTrue(status.isPresent()); Optional<Card> card = dictionaryProvider.dictionaryById(Card.class, 100L); Assert.assertTrue(card.isPresent()); } 

कोड द्वारा खोजें

  private void findByCode() { Optional<Card> card = dictionaryProvider.dictionaryByCode(Card.class, "VISA"); Assert.assertTrue(card.isPresent()); } 

आप के माध्यम से डेटा की सूची प्राप्त कर सकते हैं

 <T> Iterable<T> find(KeyValueQuery<?> query, Class<T> type); 

आप अनुरोध में छँटाई निर्दिष्ट कर सकते हैं

 query.setSort(Sort.by(DESC, "name")); 

सामग्री:

स्प्रिंग-डेटा कीवल्यू

गिथब परियोजना