स्प्रिंग एमवीसी, स्प्रिंग डेटा जेपीए और हाइबरनेट का उपयोग करके एक सरल वेब एप्लिकेशन लिखना

नमस्कार, हेब्र! मैं आपके लिए नाम हा मिंन द्वारा "स्प्रिंग एमवीसी + स्प्रिंग डेटा जेपीए + हाइबरनेट - सीआरयूडी उदाहरण" का अनुवाद प्रस्तुत करता हूं।

इस स्प्रिंग जावा ट्यूटोरियल में, आप सीखेंगे कि एक साधारण वेब एप्लिकेशन को विकसित करके स्प्रिंग डेटा जेपीए के साथ काम करने के लिए स्प्रिंग एमवीसी एप्लिकेशन कैसे सेट किया जाए, जिससे आप क्लाइंट जानकारी का प्रबंधन कर सकें।

इस ट्यूटोरियल के पूरा होने पर, आप स्प्रिंग एमवीसी और स्प्रिंग डेटा जेपीए तकनीकों पर आधारित एक जावा वेब एप्लिकेशन बना सकते हैं, जो इस तरह दिखता है:


इस गाइड में उपयोग किए जाने वाले कार्यक्रम और प्रौद्योगिकियां हैं: जावा 8, अपाचे टोमैटैट 9, माईएसक्यूएल सर्वर 5.7, ग्रहण आईडीई 4.7 (ऑक्सीजन), स्प्रिंग फ्रेमवर्क 5.1, हाइबरनेट 5.4, स्प्रिंग डेटा जेपीए 2.1.5, और सर्विक्स 3.1।

चलो एक डेटाबेस बनाकर शुरू करते हैं।

1. एक डेटाबेस बनाना

हम MySQL का उपयोग करेंगे। हमारे उदाहरण में, हम ग्राहक तालिका में डेटा के साथ काम करेंगे, जो स्कीमा नाम की बिक्री में स्थित है। ग्राहक तालिका में 4 फ़ील्ड हैं: आईडी , नाम , ईमेल और पता :


स्कीमा और तालिका बनाने के लिए आप निम्न MySQL स्क्रिप्ट को चला सकते हैं:

CREATE DATABASE `sales`; CREATE TABLE `customer` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(45) NOT NULL, `email` varchar(45) NOT NULL, `address` varchar(45) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8; 

2. ग्रहण में एक परियोजना का निर्माण

ग्रहण में एक गतिशील वेब परियोजना बनाएं, और इसे एक मावेन परियोजना में परिवर्तित करें: ऐसा करने के लिए, परियोजना पर राइट-क्लिक करें, कॉन्फ़िगर करें> मावेन परियोजना में कनवर्ट करें का चयन करें। खुलने वाले नए POM डायलॉग बॉक्स में, निम्न जानकारी दर्ज करें:

- समूह क्रमांक: net.codejava
- कलाकारी आईडी: CustomerManager प्रबंधक

यह भी सुनिश्चित करें कि जावा प्रोजेक्ट के लिए JRE संस्करण 8 या बाद का है।

फिर, इस प्रोजेक्ट के लिए निर्भरता को कॉन्फ़िगर करने के लिए pom.xml (Maven फ़ाइल) खोलें। स्प्रिंग और हाइबरनेट फ्रेमवर्क के लिए संस्करण गुणों की घोषणा करें:

 <properties> <spring.version>5.1.5.RELEASE</spring.version> <hibernate.version>5.4.1.Final</hibernate.version> </properties> 

स्प्रिंग फ्रेमवर्क के लिए निर्भरता निर्दिष्ट करें:

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency> 

स्प्रिंग MVC वेब एप्लिकेशन बनाने के लिए:

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency> 

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

 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> <version>2.1.5.RELEASE</version> </dependency> 

हम JPA कार्यान्वयन के रूप में हाइबरनेट का उपयोग करते हैं, इसलिए निम्नलिखित निर्भरता जोड़ें:

 <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>${hibernate.version}</version> </dependency> 

MySQL के साथ काम करने के लिए आवेदन के लिए, हमें MySQL JDBC ड्राइवर के लिए एक निर्भरता की आवश्यकता है:

 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.14</version> <scope>runtime</scope> </dependency> 

और अब जावा सर्वलेट, JSP और JSTL के लिए निर्भरता:

 <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>javax.servlet.jsp-api</artifactId> <version>2.3.1</version> <scope>provided</scope> </dependency> <dependency> <groupId>jstl</groupId> <artifactId>jstl</artifactId> <version>1.2</version> </dependency> 

परियोजना के मूल में दो जावा पैकेज बनाएँ:
- net.codejava.config : विन्यास कक्षाओं के लिए।
- net.codejava.customer : आवेदन कक्षाओं के लिए।

3. एक जेपीए विन्यास फाइल बनाना

चूँकि हम JPA का उपयोग करते हैं, इसलिए हमें डेटाबेस से जुड़ने के लिए गुणों को persistence.xml , persistence.xml फ़ाइल में परिभाषित करने की आवश्यकता है, न कि hibernate.cfg.xml । परियोजना के स्रोत फ़ोल्डर में META-INF नामक एक नई निर्देशिका बनाएं, जिसमें persistence.xml फ़ाइल को इसमें रखें:


और इस फ़ाइल में नीचे कोड दर्ज करें:

 <?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd" version="2.1"> <persistence-unit name="SalesDB"> <properties> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/sales" /> <property name="javax.persistence.jdbc.user" value="root" /> <property name="javax.persistence.jdbc.password" value="(password)" /> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" /> <property name="hibernate.show_sql" value="true" /> <property name="hibernate.format_sql" value="true" /> </properties> </persistence-unit> </persistence> 

जैसा कि आप देख सकते हैं, हम डेटाबेस से कनेक्ट करने के लिए गुण निर्दिष्ट करते हैं, जैसे URL, उपयोगकर्ता, पासवर्ड और JDBC ड्राइवर वर्ग। यह भी ध्यान रखें कि SalesDB नाम का उपयोग हमारे द्वारा कॉन्फ़िगरेशन कोड में किया जाएगा।

4. एक मॉडल वर्ग बनाना

एक Customer वर्ग बनाएं जो डेटाबेस में ग्राहक तालिका में निम्नानुसार मैप करता है:

 package net.codejava.customer; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @Entity public class Customer { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String email; private String address; protected Customer() { } protected Customer(String name, String email, String address) { this.name = name; this.email = email; this.address = address; } //       .       IDE,  . } 

जैसा कि आप देख सकते हैं, हम इस क्लास को ग्राहक तालिका में मैप करने के लिए @Entity एनोटेशन का उपयोग करते हैं (क्लास का नाम टेबल नाम के समान है)। सभी वर्ग फ़ील्ड नाम तालिका में फ़ील्ड नामों के समान हैं। id फ़ील्ड में एनोटेशन @Id और @GeneratedValue दर्शाए गए हैं कि यह फ़ील्ड एक प्राथमिक कुंजी है और इसका मान स्वचालित रूप से उत्पन्न होता है।

5. स्प्रिंग एमवीसी और स्प्रिंग डेटा जेपीए का कॉन्फ़िगरेशन

अगला, हम स्प्रिंग एमवीसी और स्प्रिंग डेटा जेपीए को कॉन्फ़िगर करने के लिए जावा कोड लिखते हैं। हम जावा-आधारित कॉन्फ़िगरेशन का उपयोग करेंगे, क्योंकि यह XML की तुलना में सरल है।

स्प्रिंग डिस्पैचर सर्वलेट कॉन्फ़िगर करें

हमारे आवेदन में स्प्रिंग एमवीसी का उपयोग करने के लिए, हमें निम्न वर्ग को लिखकर आवेदन शुरू करते समय स्प्रिंग डिस्पैचर सर्वलेट को पंजीकृत करना होगा:

 package net.codejava.config; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.ServletRegistration; import org.springframework.web.WebApplicationInitializer; import org.springframework.web.context.support.AnnotationConfigWebApplicationContext; import org.springframework.web.servlet.DispatcherServlet; public class WebAppInitializer implements WebApplicationInitializer { @Override public void onStartup(ServletContext servletContext) throws ServletException { AnnotationConfigWebApplicationContext appContext = new AnnotationConfigWebApplicationContext(); appContext.register(WebMvcConfig.class); ServletRegistration.Dynamic dispatcher = servletContext.addServlet( "SpringDispatcher", new DispatcherServlet(appContext)); dispatcher.setLoadOnStartup(1); dispatcher.addMapping("/"); } } 

इस वर्ग के onStartup() पद्धति को एप्लिकेशन लोड होने पर स्वचालित रूप से सर्वलेट द्वारा बुलाया जाएगा। स्प्रिंग डिस्पैचर सर्वलेट URL "/" से मेल करके सभी अनुरोधों को संसाधित करता है और WebMvcConfig वर्ग में कॉन्फ़िगरेशन की WebMvcConfig करता है, जो नीचे वर्णित है।

स्प्रिंग MVC कॉन्फ़िगर करें

निम्न कोड वाले net.codejava.config पैकेज में WebMvcConfig क्लास बनाएँ:

 package net.codejava.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.view.InternalResourceViewResolver; @Configuration @ComponentScan("net.codejava ") public class WebMvcConfig { @Bean(name = "viewResolver") public InternalResourceViewResolver getViewResolver() { InternalResourceViewResolver viewResolver = new InternalResourceViewResolver(); viewResolver.setPrefix("/WEB-INF/views/"); viewResolver.setSuffix(".jsp"); return viewResolver; } } 

यह वर्ग वसंत को बता रही @Configuration एनोटेशन के साथ चिह्नित है कि यह एक कॉन्फ़िगरेशन फ़ाइल है। @ComponentScan स्प्रिंग को net.codejava पैकेज में कॉन्फ़िगरेशन कक्षाओं को देखने के लिए कहता है।

इस वर्ग में, हम एक सेम बनाते हैं जो इन विचारों के लिए एक उपसर्ग और प्रत्यय निर्दिष्ट करके विचारों को पहचानता है। इसलिए, JSP फ़ाइलों को संग्रहीत करने के लिए WebContent/WEB-INF अंदर views निर्देशिका बनाएं।

यहां आप अन्य स्प्रिंग MVC कॉन्फ़िगरेशन जोड़ सकते हैं।

स्प्रिंग डेटा जेपीए को कॉन्फ़िगर करना

स्प्रिंग डेटा जेपीए के साथ काम करने के लिए, हमें दो बीन्स घटक बनाने की आवश्यकता है: JpaTransactionManager और JpaTransactionManager । इसलिए, हम एक और विन्यास वर्ग JpaConfig :

 package net.codejava.config; import javax.persistence.EntityManagerFactory; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.jpa.repository.config.EnableJpaRepositories; import org.springframework.orm.jpa.JpaTransactionManager; import org.springframework.orm.jpa.LocalEntityManagerFactoryBean; import org.springframework.transaction.annotation.EnableTransactionManagement; @Configuration @EnableJpaRepositories(basePackages = {"net.codejava.customer"}) @EnableTransactionManagement public class JpaConfig { @Bean public LocalEntityManagerFactoryBean entityManagerFactory() { LocalEntityManagerFactoryBean factoryBean = new LocalEntityManagerFactoryBean(); factoryBean.setPersistenceUnitName("SalesDB"); return factoryBean; } @Bean public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) { JpaTransactionManager transactionManager = new JpaTransactionManager(); transactionManager.setEntityManagerFactory(entityManagerFactory); return transactionManager; } } 

यहां हम दो महत्वपूर्ण एनोटेशन का उपयोग करते हैं:

• @EnableJpaRepositories : स्प्रिंग डेटा JPA को रन टाइम में उपयुक्त कोड इंजेक्ट करने के लिए निर्दिष्ट पैकेज (net.codejava) में रिपॉजिटरी वर्गों की तलाश करने के लिए कहता है।
• @EnableTransactionManagement : स्प्रिंग डेटा JPA को रनटाइम पर लेनदेन का प्रबंधन करने के लिए कोड उत्पन्न करने के लिए कहता है।

इस वर्ग में, पहला तरीका EntityManagerFactory का उदाहरण देता है, जो हमारे SalesDB की दृढ़ता इकाई को नियंत्रित करता है (यह नाम persistence.xml ऊपर निर्दिष्ट है)।

अंतिम विधि EntityManagerFactory लिए JpaTransactionManager का एक उदाहरण बनाता है, पहले विधि द्वारा बनाई गई।

यह स्प्रिंग डेटा JPA का उपयोग करने के लिए आवश्यक न्यूनतम कॉन्फ़िगरेशन है।

एक रिपॉजिटरी इंटरफ़ेस बनाना

एक CustomerRepository CrudRepository इंटरफ़ेस बनाएँ जो स्प्रिंग डेटा जेपीए में परिभाषित CrudRepository इंटरफ़ेस का विस्तार करता है:

 package net.codejava.customer; import java.util.List; import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.query.Param; public interface CustomerRepository extends CrudRepository<Customer, Long> {    } 

यह लगभग सभी कोड है जो हमें डेटा तक पहुंचने की आवश्यकता है। बस सहमत हूँ? स्प्रिंग डेटा JPA के साथ, हमें DAO (Java Data Acces Object) कोड लिखने की आवश्यकता नहीं है। बस एक इंटरफ़ेस घोषित करें जो CrudRepository इंटरफ़ेस का विस्तार करता है, जो CRUD विधियों जैसे कि save() , findAll() , findById() , deleteById() , आदि को परिभाषित करता है। रन समय में, स्प्रिंग डेटा जेपीए स्वचालित रूप से कोड उत्पन्न करेगा।

कृपया ध्यान दें कि हमें CrudRepository : CrudRepository<Customer, Long> विस्तार करते समय हमें मॉडल वर्ग और प्राथमिक कुंजी फ़ील्ड के प्रकार को निर्दिष्ट करना होगा।

7. एक सेवा वर्ग बनाना

अगला, CustomerService वर्ग बनाएँ:

 package net.codejava.customer; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service @Transactional public class CustomerService { @Autowired CustomerRepository repo; public void save(Customer customer) { repo.save(customer); } public List<Customer> listAll() { return (List<Customer>) repo.findAll(); } public Customer get(Long id) { return repo.findById(id).get(); } public void delete(Long id) { repo.deleteById(id); } } 

@Transactional एनोटेशन पर ध्यान दें जो हमारी कक्षा को @Transactional । इसका मतलब यह है कि लेनदेन प्रबंधन के लिए इस वर्ग के सभी तरीकों को स्प्रिंग डेटा जेपीए द्वारा बाधित किया जाएगा। और CustomerRepository इंटरफ़ेस उदाहरण इस वर्ग में एम्बेड किया जाएगा:

 @Autowired CustomerRepository repo; 

यह जादू जैसा लगता है क्योंकि हम DAO कोड नहीं लिख रहे हैं, लेकिन स्प्रिंग डेटा JPA स्वचालित रूप से रनटाइम पर एक कार्यान्वयन बनाएगा।

जैसा कि आप देख सकते हैं, इस वर्ग के सभी तरीके CRUD संचालन के लिए हैं। यह केवल पूरी कॉल को CustomerRepository ऑब्जेक्ट को दर्शाता है। यह वर्ग आपको निरर्थक लग सकता है, लेकिन व्यवसाय / सेवा स्तर को रिपॉजिटरी / डीएओ स्तर से अलग करना आवश्यक है।

8. एक स्प्रिंग एमवीसी नियंत्रक बनाना

CustomerContoroller से सभी अनुरोधों को संभालने के लिए एक वर्ग CustomerContoroller बनाएं:

 package net.codejava.customer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; @Controller public class CustomerController { @Autowired private CustomerService customerService; //     } 

यह एक विशिष्ट स्प्रिंग MVC नियंत्रक वर्ग है जिसे @Controller का उपयोग करके एनोटेट किया गया है। आप देख सकते हैं कि @Autowired एनोटेशन का उपयोग करके CustomerService उदाहरण को इस ऑब्जेक्ट में इंजेक्ट किया जा रहा है।

हम निम्नलिखित अनुभागों में प्रसंस्करण विधियों को लिखेंगे।

9. ग्राहक सूची जोड़ना

सभी ग्राहकों को हमारे आवेदन के मुख पृष्ठ पर प्रदर्शित किया जाएगा। ऐसा करने के लिए, हमारे CustomerController वर्ग के लिए उपयुक्त प्रसंस्करण विधि जोड़ें:

 @RequestMapping("/") public ModelAndView home() { List<Customer> listCustomer = customerService.listAll(); ModelAndView mav = new ModelAndView("index"); mav.addObject("listCustomer", listCustomer); return mav; } 

ब्राउज़िंग होम पेज ( index.jsp ) इस तरह दिखना चाहिए:

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Customer Manager</title> </head> <body> <div align="center"> <h2>Customer Manager</h2> <form method="get" action="search"> <input type="text" name="keyword" />  <input type="submit" value="Search" /> </form> <h3><a href="/new">New Customer</a></h3> <table border="1" cellpadding="5"> <tr> <th>ID</th> <th>Name</th> <th>E-mail</th> <th>Address</th> <th>Action</th> </tr> <c:forEach items="${listCustomer}" var="customer"> <tr> <td>${customer.id}</td> <td>${customer.name}</td> <td>${customer.email}</td> <td>${customer.address}</td> <td> <a href="/edit?id=${customer.id}">Edit</a>   <a href="/delete?id=${customer.id}">Delete</a> </td> </tr> </c:forEach> </table> </div> </body> </html> 

अब आप वेब एप्लिकेशन शुरू कर सकते हैं। ग्राहक तालिका में कुछ पंक्तियाँ जोड़ें और http://localhost:8080/CustomerManager/ और आपको कुछ समान दिखाई देगा:

10. एक नया उपयोगकर्ता जोड़ना

एक नया ग्राहक बनाने के कार्य को कार्यान्वित करने के लिए, हमें दो हैंडलर विधियों को लिखना होगा। और पहले एक ग्राहक जोड़ने के लिए एक नया रूप प्रदर्शित करेगा:

 @RequestMapping("/new") public String newCustomerForm(Map<String, Object> model) { Customer customer = new Customer(); model.put("customer", customer); return "new_customer"; } 

JSP फॉर्म को new_customer.jsp नाम से स्वयं new_customer.jsp :

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1"    pageEncoding="ISO-8859-1"%> <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>     <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"    "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>New Customer</title> </head> <body>    <div align="center">        <h2>New Customer</h2>        <form:form action="save" method="post" modelAttribute="customer">            <table border="0" cellpadding="5">                <tr>                    <td>Name: </td>                    <td><form:input path="name" /></td>                </tr>                <tr>                    <td>Email: </td>                    <td><form:input path="email" /></td>                </tr>                <tr>                    <td>Address: </td>                    <td><form:input path="address" /></td>                </tr>                   <tr>                    <td colspan="2"><input type="submit" value="Save"></td>                </tr>                               </table>        </form:form>    </div> </body> </html> 

अब मुख्य पृष्ठ पर आपको नया ग्राहक लिंक दिखाई देगा, जब आप उस पर क्लिक करेंगे तो आपको एक नया रूप दिखाई देगा:


दूसरा हैंडलर तरीका इस फॉर्म में सेव बटन को प्रोसेस करेगा:

 @RequestMapping(value = "/save", method = RequestMethod.POST) public String saveCustomer(@ModelAttribute("customer") Customer customer) { customerService.save(customer); return "redirect:/"; } 

जैसा कि आप देख सकते हैं, यह उपयोगकर्ता को सफलतापूर्वक सहेजने के बाद होम पेज पर क्लाइंट को रीडायरेक्ट करता है।

11. उपयोगकर्ता डेटा बदलें

क्लाइंट एडिटिंग फंक्शन को लागू करने के लिए, CustomerController कंट्रोलर क्लास में निम्न हैंडलर विधि जोड़ें:

 @RequestMapping("/edit") public ModelAndView editCustomerForm(@RequestParam long id) {    ModelAndView mav = new ModelAndView("edit_customer");    Customer customer = customerService.get(id);    mav.addObject("customer", customer);    return mav; } 

आइए edit_customer.jsp फॉर्म लिखें, जिसे इस विधि द्वारा कहा जाता है:

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Edit Customer</title> </head> <body> <div align="center"> <h2>Edit Customer</h2> <form:form action="save" method="post" modelAttribute="customer"> <table border="0" cellpadding="5"> <tr> <td>ID: </td> <td>${customer.id} <form:hidden path="id"/> </td> </tr> <tr> <td>Name: </td> <td><form:input path="name" /></td> </tr> <tr> <td>Email: </td> <td><form:input path="email" /></td> </tr> <tr> <td>Address: </td> <td><form:input path="address" /></td> </tr> <tr> <td colspan="2"><input type="submit" value="Save"></td> </tr> </table> </form:form> </div> </body> </html> 

होम पेज पर क्लाइंट के बगल में एडिट हाइपरलिंक पर क्लिक करें, क्लाइंट एडिटिंग फॉर्म को कॉल किया जाएगा, जो कुछ इस तरह दिखेगा:



हैंडलर विधि अभी भी सेव बटन को प्रोसेस करती है।

12. एक ग्राहक को हटाना

डिलीट फंक्शन को लागू करने के लिए, CustomerController कंट्रोलर क्लास में निम्नलिखित हैंडलर विधि लिखें:

 @RequestMapping("/delete") public String deleteCustomerForm(@RequestParam long id) { customerService.delete(id); return "redirect:/"; } 

मुख्य पृष्ठ पर ग्राहक के बगल में स्थित हाइपरलिंक पर क्लिक करें। क्लाइंट को हटा दिया जाएगा, और सूची अपडेट की जाएगी।

13. ग्राहकों द्वारा खोजें

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

 package net.codejava.customer; import java.util.List; import org.springframework.data.jpa.repository.Query; import org.springframework.data.repository.CrudRepository; import org.springframework.data.repository.query.Param; public interface CustomerRepository extends CrudRepository<Customer, Long> { @Query(value = "SELECT c FROM Customer c WHERE c.name LIKE '%' || :keyword || '%'" + " OR c.email LIKE '%' || :keyword || '%'" + " OR c.address LIKE '%' || :keyword || '%'") public List<Customer> search(@Param("keyword") String keyword); } 

search() विधि सिर्फ एक सार विधि है @Query साथ एनोटेट किया @Query खोज क्वेरी JPA क्वेरी है।

फिर CustomerService वर्ग में विधि जोड़ें:

 public List<Customer> search(String keyword) { return repo.search(keyword); } 

अब CustomerController वर्ग के लिए एक हैंडलर विधि जोड़ें:

 @RequestMapping("/search") public ModelAndView search(@RequestParam String keyword) { List<Customer> result = customerService.search(keyword); ModelAndView mav = new ModelAndView("search"); mav.addObject("result", result); return mav; } 

और एक search.jsp खोज परिणाम search.jsp बनाएँ:

 <%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Search Result</title> </head> <body> <div align="center"> <h2>Search Result</h2> <table border="1" cellpadding="5"> <tr> <th>ID</th> <th>Name</th> <th>E-mail</th> <th>Address</th> </tr> <c:forEach items="${result}" var="customer"> <tr> <td>${customer.id}</td> <td>${customer.name}</td> <td>${customer.email}</td> <td>${customer.address}</td> </tr> </c:forEach> </table> </div> </body> </html> 

खोज फ़ंक्शन का परीक्षण करने के लिए, होम पेज पर खोज फ़ील्ड में एक कीवर्ड दर्ज करें, और Enter दबाएं। आपको खोज परिणाम पृष्ठ दिखाई देगा:

निष्कर्ष

इस गाइड में, आपने सीखा कि डेटा तक पहुंचने के लिए स्प्रिंग डेटा जेपीए का उपयोग करके स्प्रिंग एमवीसी वेब एप्लिकेशन कैसे विकसित किया जाए। जैसा कि आप देख सकते हैं, स्प्रिंग डेटा जेपीए हमारे द्वारा लिखे जाने वाले कोड को बहुत कम करता है और सरल करता है।

तुलना के लिए, यहाँ ग्रहण आईडीई में परियोजना संरचना है:


पढ़ने के लिए धन्यवाद!