🦇 😛 🐲 स्प्रिंग डेटा जपा 🍝 👨🏾‍🎨 🏴󠁧󠁢󠁳󠁣󠁴󠁿

लेख में मैं स्प्रिंग डेटा के उपयोग का वर्णन करूंगा।

स्प्रिंग डेटा डेटाबेस संस्थाओं के साथ बातचीत करने के लिए एक अतिरिक्त सुविधाजनक तंत्र है, उन्हें रिपॉजिटरी में व्यवस्थित करना, डेटा को पुनः प्राप्त करना, बदलना, कुछ मामलों में, इसके लिए यह एक इंटरफ़ेस और विधि घोषित करने के लिए पर्याप्त होगा, बिना कार्यान्वयन के।

सामग्री:

वसंत का भंडार
विधि के नाम से अनुरोध विधि
कॉन्फ़िगरेशन और सेटअप
विशेष पैरामीटर प्रसंस्करण
कस्टम रिपोजिटरी कार्यान्वयन
कस्टम बेस रिपोजिटरी
क्वेरी तरीके - क्वेरी

1. स्प्रिंग रिपोजिटरी

स्प्रिंग डेटा में मूल अवधारणा रिपॉजिटरी है। ये कई इंटरफेस हैं जो इसके साथ बातचीत करने के लिए जेपीए एंटिटी का उपयोग करते हैं। तो उदाहरण के लिए एक इंटरफ़ेस
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID>
डेटा (CRUD संचालन) को खोजने, सहेजने, हटाने के लिए बुनियादी संचालन प्रदान करता है

 T save(T entity); Optional findById(ID primaryKey); void delete(T entity);

और अन्य ऑपरेशन।

अन्य अमूर्तियां हैं, जैसे पेजिंगएंडसॉर्टिंगरिपोसेरी।

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

1. एक इकाई बनाएँ

 @Entity @Table(name = "EMPLOYEES") public class Employees { private Long employeeId; private String firstName; private String lastName; private String email; // . . .

2. स्प्रिंग डेटा इंटरफेस में से एक से, उदाहरण के लिए CrudRepository से प्राप्त किया गया

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long>

3. ग्राहक (सेवा) में डेटा संचालन के लिए एक नया इंटरफ़ेस का उपयोग करें

 @Service public class EmployeesDataService { @Autowired private CustomizedEmployeesCrudRepository employeesCrudRepository; @Transactional public void testEmployeesCrudRepository() { Optional<Employees> employeesOptional = employeesCrudRepository.findById(127L); //.... }

यहाँ मैंने रेडी-मेड FindById विधि का उपयोग किया। यानी इतनी जल्दी और आसानी से, कार्यान्वयन के बिना, हमें CrudRepository से संचालन की तैयार सूची मिलती है:

  S save(S var1); Iterable<S> saveAll(Iterable<S> var1); Optional<T> findById(ID var1); boolean existsById(ID var1); Iterable<T> findAll(); Iterable<T> findAllById(Iterable<ID> var1); long count(); void deleteById(ID var1); void delete(T var1); void deleteAll(Iterable<? extends T> var1); void deleteAll();

यह स्पष्ट है कि यह सूची सबसे अधिक संभावना है कि इकाई के साथ बातचीत करने के लिए पर्याप्त नहीं है, और यहां आप अतिरिक्त क्वेरी विधियों के साथ अपने इंटरफ़ेस का विस्तार कर सकते हैं।

2. विधि नाम से क्वेरी विधि

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

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long> { //    firstName And LastName Optional<Employees> findByFirstNameAndLastName(String firstName, String lastName); //   5  FirstName       FirstName List<Employees> findFirst5ByFirstNameStartsWithOrderByFirstName(String firstNameStartsWith);

प्रलेखन पूरी सूची को परिभाषित करता है, और विधि लिखने के लिए नियम। परिणाम एक इकाई टी, वैकल्पिक, सूची, स्ट्रीम हो सकता है। एक विकास के माहौल में, जैसे कि आइडिया, क्वेरी विधियों को लिखने के लिए एक संकेत है।

यह इस तरह से एक विधि को परिभाषित करने के लिए पर्याप्त है, कार्यान्वयन के बिना, और वसंत इकाई के लिए एक अनुरोध तैयार करेगा।

 @SpringBootTest public class DemoSpringDataApplicationTests { @Autowired private CustomizedEmployeesCrudRepository employeesCrudRepository; @Test @Transactional public void testFindByFirstNameAndLastName() { Optional<Employees> employeesOptional = employeesCrudRepository.findByFirstNameAndLastName("Alex", "Ivanov");

3. विन्यास और सेटअप

पूरा प्रोजेक्ट जीथब पर उपलब्ध है
जीथब डेमोस्प्रिंगडाटा

यहां मैं केवल कुछ फीचर्स पर टच करूंगा।

TransactionManager, dataSource, और unitManagerFactory सेम संदर्भ में परिभाषित किए गए हैं। Xml। इसमें भी संकेत देना जरूरी है

 <jpa:repositories base-package="com.example.demoSpringData.repositories"/>

पथ जहां रिपॉजिटरी को परिभाषित किया गया है।

EntityManagerFactory हाइबरनेट ORM के साथ काम करने के लिए कॉन्फ़िगर किया गया है, और यह बदले में, Oracle XE डेटाबेस के साथ है, यहां अन्य विकल्प संभव हैं, संदर्भ में। xml यह सब दिखाई दे रहा है। Pom फ़ाइल में सभी निर्भरताएँ हैं।

4. मापदंडों का विशेष प्रसंस्करण

क्वेरी विधियों में, उनके मापदंडों में, आप विशेष मापदंडों का उपयोग कर सकते हैं Pageable, Sort, साथ ही Top और First पर प्रतिबंध।

उदाहरण के लिए, इस तरह, आप दूसरे पृष्ठ (-0 के साथ अनुक्रमणिका), तीन तत्वों के आकार और प्रथम नाम से क्रमबद्ध कर सकते हैं, रिपॉजिटरी विधि में पैजेबल पैरामीटर निर्दिष्ट करने के बाद, विधि नाम से मानदंड का भी उपयोग किया जाएगा - "फर्स्टनाम द्वारा खोजें% के साथ शुरू

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long> { List<Employees> findByFirstNameStartsWith(String firstNameStartsWith, Pageable page); //.... } //   @Test @Transactional public void testFindByFirstNameStartsWithOrderByFirstNamePage() { List<Employees> list = employeesCrudRepository .findByFirstNameStartsWith("A", PageRequest.of(1,3, Sort.by("firstName"))); list.forEach(e -> System.out.println(e.getFirstName() + " " +e.getLastName())); }

5. भंडार के लिए कस्टम कार्यान्वयन

मान लीजिए कि आपको रिपॉजिटरी में एक विधि की आवश्यकता है जिसे विधि के नाम से वर्णित नहीं किया जा सकता है, तो आप इसे अपने स्वयं के इंटरफ़ेस और इसके कार्यान्वयन वर्ग का उपयोग करके लागू कर सकते हैं। नीचे दिए गए उदाहरण में, मैं कर्मचारियों को अधिकतम वेतन वाले कर्मचारियों को प्राप्त करने के लिए एक विधि में जोड़ दूंगा।

इंटरफ़ेस की घोषणा करें

 public interface CustomizedEmployees<T> { List<T> getEmployeesMaxSalary(); }

इंटरफ़ेस को लागू करता है। HQL (SQL) का उपयोग करके मुझे अधिकतम वेतन वाले कर्मचारी मिलते हैं, अन्य कार्यान्वयन संभव हैं।

 public class CustomizedEmployeesImpl implements CustomizedEmployees { @PersistenceContext private EntityManager em; @Override public List getEmployeesMaxSalary() { return em.createQuery("from Employees where salary = (select max(salary) from Employees )", Employees.class) .getResultList(); } }

और CustomEmployees के साथ Crud Repository Employees का विस्तार करना।

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long>, CustomizedEmployees<Employees>

यहां एक महत्वपूर्ण विशेषता है। इम्प्लिमेंट पर क्लास इंप्लीमेंटिंग इंटरफ़ेस (पोस्टफिक्स) समाप्त होना चाहिए, या कॉन्फ़िगरेशन में आपको अपना पोस्टफिक्स डालना होगा

 <repositories base-package="com.repository" repository-impl-postfix="MyPostfix" />

रिपॉजिटरी के माध्यम से इस पद्धति के संचालन की जांच करना

 public class DemoSpringDataApplicationTests { @Autowired private CustomizedEmployeesCrudRepository employeesCrudRepository; @Test @Transactional public void testMaxSalaryEmployees() { List<Employees> employees = employeesCrudRepository.getEmployeesMaxSalary(); employees.stream() .forEach(e -> System.out.println(e.getFirstName() + " " + e.getLastName() + " " + e.getSalary())); }

एक अन्य मामला जब स्प्रिंग इंटरफ़ेस में एक मौजूदा विधि के व्यवहार को बदलना आवश्यक है , उदाहरण के लिए, क्रूड रिपेरिटरी में हटाएं, मुझे चाहिए कि डेटाबेस से हटाने के बजाय, हटाने का संकेत सेट किया जाए। तकनीक बिल्कुल वैसी ही है। नीचे एक उदाहरण है:

 public interface CustomizedEmployees<T> { void delete(T entity); // ... } //  CustomizedEmployees public class CustomizedEmployeesImpl implements CustomizedEmployees { @PersistenceContext private EntityManager em; @Transactional @Override public void delete(Object entity) { Employees employees = (Employees) entity; employees.setDeleted(true); em.persist(employees); }

अब, यदि आप कर्मचारियों को हटाने के लिए कहते हैं, तो आप केवल हटाए गए के रूप में चिह्नित होंगे।

6. यूजर बेस रिपोजिटरी

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

 public interface BaseEntity { Boolean getDeleted(); void setDeleted(Boolean deleted); } //  Employees @Entity @Table(name = "EMPLOYEES") public class Employees implements BaseEntity { private Boolean deleted; @Override public Boolean getDeleted() { return deleted; } @Override public void setDeleted(Boolean deleted) { this.deleted = deleted; } //    @NoRepositoryBean public interface BaseRepository <T extends BaseEntity, ID extends Serializable> extends JpaRepository<T, ID> { void delete(T entity); } //    BaseRepository public class BaseRepositoryImpl <T extends BaseEntity, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements BaseRepository<T, ID> { private final EntityManager entityManager; public BaseRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) { super(entityInformation, entityManager); this.entityManager = entityManager; } @Transactional @Override public void delete(BaseEntity entity) { entity.setDeleted(true); entityManager.persist(entity); } }

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

  <jpa:repositories base-package="com.example.demoSpringData.repositories" base-class="com.example.demoSpringData.BaseRepositoryImpl"/>

अब कर्मचारी रिपोजिटरी (और अन्य) को बेसपरोसिटरी से विस्तारित किया जाना चाहिए और पहले से ही क्लाइंट में इसका उपयोग करना चाहिए।

 public interface EmployeesBaseRepository extends BaseRepository <Employees, Long> { // ... }

कर्मचारियों की जाँच करना

 public class DemoSpringDataApplicationTests { @Resource private EmployeesBaseRepository employeesBaseRepository; @Test @Transactional @Commit public void testBaseRepository() { Employees employees = new Employees(); employees.setLastName("Ivanov"); // Query by Example (QBE) Example<Employees> example = Example.of(employees); Optional<Employees> employeesOptional = employeesBaseRepository.findOne(example); employeesOptional.ifPresent(employeesBaseRepository::delete); }

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

7. क्वेरी के तरीके - क्वेरी

मैंने पहले लिखा था कि अगर आपको किसी विशिष्ट विधि या इसके कार्यान्वयन की आवश्यकता है, जिसे विधि नाम का उपयोग करके वर्णित नहीं किया जा सकता है, तो यह कुछ अनुकूलित इंटरफ़ेस (CustomEmployees) के माध्यम से किया जा सकता है और गणना कार्यान्वयन कर सकता है। और आप दूसरे तरीके से जा सकते हैं, क्वेरी (HQL या SQL) को इंगित करके, इस फ़ंक्शन की गणना कैसे करें।
GetEmployeesMaxSalary के साथ मेरे उदाहरण के लिए, यह कार्यान्वयन विकल्प और भी सरल है। मैं इसे वेतन इनपुट पैरामीटर के साथ जटिल करूंगा। यानी यह इंटरफ़ेस में गणना पद्धति और अनुरोध को घोषित करने के लिए पर्याप्त है।

 @Repository public interface CustomizedEmployeesCrudRepository extends CrudRepository<Employees, Long>, CustomizedEmployees<Employees> { @Query("select e from Employees e where e.salary > :salary") List<Employees> findEmployeesWithMoreThanSalary(@Param("salary") Long salary, Sort sort); // ... }

चेक

 @Test @Transactional public void testFindEmployeesWithMoreThanSalary() { List<Employees> employees = employeesCrudRepository.findEmployeesWithMoreThanSalary(10000L, Sort.by("lastName"));

मैं केवल यह उल्लेख करूंगा कि इसमें संशोधन के अनुरोध हो सकते हैं, इसके लिए उनके साथ अतिरिक्त @Modifying एनोटेशन जोड़ा गया है

 @Modifying @Query("update Employees e set e.firstName = ?1 where e.employeeId = ?2") int setFirstnameFor(String firstName, String employeeId);

क्वेरी एनोटेशन की महान विशेषताओं में से एक स्पेल भावों के माध्यम से टेम्पलेट # {# एंट्रीनाम " का उपयोग करके क्वेरी में इकाई डोमेन प्रकार का प्रतिस्थापन है।

इसलिए, उदाहरण के लिए, मेरे काल्पनिक उदाहरण में, जब मुझे सभी संस्थाओं के लिए "हटाए गए" चिह्न की आवश्यकता होती है, तो मैं "हटाए गए" या "सक्रिय" संकेत के साथ वस्तुओं की सूची प्राप्त करने की विधि के साथ एक मूल इंटरफ़ेस बनाऊंगा।

 @NoRepositoryBean public interface ParentEntityRepository<T> extends Repository<T, Long> { @Query("select t from #{#entityName} t where t.deleted = ?1") List<T> findMarked(Boolean deleted); }

इसके अलावा, संस्थाओं के लिए सभी रिपोजिटरी को इससे बढ़ाया जा सकता है। इंटरफेस जो रिपॉजिटरी नहीं हैं, लेकिन "बेस-पैकेज" कॉन्फ़िगरेशन फ़ोल्डर में स्थित हैं, @NoRepositoryBean को एनोटेट करें।

कर्मचारी रिपोजिटरी

 @Repository public interface EmployeesEntityRepository extends ParentEntityRepository <Employees> { }

अब जब अनुरोध निष्पादित होता है, तो इकाई नाम T को विशिष्ट निकाय के लिए अनुरोध निकाय में प्रतिस्थापित किया जाएगा जो कि इस मामले में ParentEntityRepository का विस्तार करेगा।

निरीक्षण

 @SpringBootTest public class DemoSpringDataApplicationTests { @Autowired private EmployeesEntityRepository employeesEntityRepository; @Test @Transactional public void testEntityName() { List<Employees> employeesMarked = employeesEntityRepository.findMarked(true); // ...

सामग्री
स्प्रिंग डेटा जेपीए - संदर्भ प्रलेखन
गिथब पर प्रोजेक्ट

स्प्रिंग डेटा जपा