مرحبا يا هبر! أقدم لكم ترجمة دليل
"Spring MVC + Spring Data JPA + Hibernate - CRUD Example" by Nam Ha Minh.
في هذا البرنامج التعليمي Spring Java ، ستتعلم كيفية إعداد تطبيق Spring MVC للعمل مع Spring Data JPA من خلال تطوير تطبيق ويب بسيط يتيح لك إدارة معلومات العميل.
عند الانتهاء من هذا البرنامج التعليمي ، يمكنك إنشاء تطبيق ويب Java يستند إلى تقنيات Spring MVC و Spring Data JPA ، والتي تبدو كما يلي:
البرامج والتقنيات المستخدمة في هذا الدليل هي: Java 8 و Apache Tomcat 9 و MySQL Server 5.7 و Eclipse IDE 4.7 (Oxygen) و Spring Framework 5.1 و Hibernate 5.4 و Spring Data JPA 2.1.5 و Servlet 3.1.
لنبدأ بإنشاء قاعدة بيانات.
1. إنشاء قاعدة بيانات
سوف نستخدم الخلية. في مثالنا ، سنعمل مع البيانات في جدول
العملاء ، الموجود في المخطط المسمى
المبيعات . يحتوي جدول
العملاء على 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. إنشاء مشروع في الكسوف
قم بإنشاء مشروع ويب ديناميكي في Eclipse ، وقم بتحويله إلى مشروع Maven: للقيام بذلك ، انقر بزر الماوس الأيمن على المشروع ، حدد
Configure> Convert to Maven Project . في شاشة
إنشاء POM جديدة تفتح ، أدخل المعلومات التالية:
- معرف المجموعة:
net.codejava- معرف قطعة أثرية:
CustomerManagerتأكد أيضًا من أن إصدار JRE لمشروع Java هو 8 أو أحدث.
بعد ذلك ، افتح
pom.xml (ملف Maven) لتكوين التبعيات لهذا المشروع. قم بتعريف خصائص الإصدار لـ Spring and Hibernate Frameworks:
<properties> <spring.version>5.1.5.RELEASE</spring.version> <hibernate.version>5.4.1.Final</hibernate.version> </properties>
حدد التبعية لـ Spring Framework:
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring.version}</version> </dependency>
لإنشاء تطبيقات Spring MVC على الويب:
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>${spring.version}</version> </dependency>
لاستخدام Spring Data 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>
والآن تبعيات Java Servlet و 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>
قم بإنشاء حزمتي Java في جذر المشروع:
-
net.codejava.config : لفئات التكوين.
-
net.codejava.customer : لفئات التطبيق.
3. إنشاء ملف تكوين JPA
نظرًا لأننا نستخدم JPA ، نحتاج إلى تعريف الخصائص للاتصال بقاعدة البيانات في ملف
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; }
كما ترون ، نستخدم التعليق التوضيحي
@Entity لتعيين هذه الفئة لجدول
العملاء (اسم الفئة هو نفسه اسم الجدول). جميع أسماء الحقول في الفصل مماثلة لأسماء الحقول في الجدول. يحتوي حقل
id على التعليقات التوضيحية
@Id و
@GeneratedValue للإشارة إلى أن هذا الحقل هو مفتاح أساسي ويتم إنشاء قيمته تلقائيًا.
5. تكوين Spring MVC و Spring Data JPA
بعد ذلك ، نكتب شفرة Java لتكوين Spring MVC و Spring Data JPA. سنستخدم التكوين المستند إلى Java ، لأنه أبسط من XML.
تكوين Spring Dispatcher Servlet
لاستخدام Spring MVC في طلبنا ، نحتاج إلى تسجيل Spring Dispatcher Servlet عند بدء تشغيل التطبيق عن طريق كتابة الفصل التالي:
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() طريقة
onStartup() من هذه الفئة تلقائيًا بواسطة servlet عند تحميل التطبيق. يعالج Spring Dispatcher Servlet جميع الطلبات من خلال مطابقة عنوان URL "/" ويبحث عن التكوين في فئة
WebMvcConfig ، الموضحة أدناه.
تكوين الربيع MVC
قم
WebMvcConfig فئة
WebMvcConfig في الحزمة
net.codejava.config التي تحتوي على التعليمات البرمجية التالية:
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 يخبر Spring أنه ملف تكوين. يخبر
@ComponentScan Spring بالبحث عن فئات التكوين في حزمة
net.codejava .
في هذه الفئة ، نقوم بإنشاء فاصوليا يتعرف على طرق العرض عن طريق تحديد بادئة ولاحقة لطرق العرض هذه. لذلك ، قم بإنشاء دليل
views داخل دليل
WebContent/WEB-INF لتخزين ملفات JSP.
هنا يمكنك إضافة تكوينات Spring MVC الأخرى.
تكوين بيانات الربيع JPA
للعمل مع Spring Data JPA ، نحتاج إلى إنشاء مكونين للفاصوليا:
EntityManagerFactory و
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 : يخبر Spring Data JPA بالبحث عن فئات المستودع في الحزمة المحددة (net.codejava) لحقن الشفرة المناسبة في وقت التشغيل.@EnableTransactionManagement : يخبر Spring Data JPA بإنشاء رمز لإدارة المعاملات في وقت التشغيل.
في هذه الفئة ، تنشئ الطريقة الأولى
EntityManagerFactory لـ
EntityManagerFactory للتحكم في وحدة الثبات في
SalesDB (يتم تحديد هذا الاسم في
persistence.xml أعلاه).
الطريقة الأخيرة تنشئ مثيل
JpaTransactionManager لـ
EntityManagerFactory ، تم إنشاؤه بواسطة الطريقة السابقة.
هذا هو الحد الأدنى من التكوين المطلوب لاستخدام Spring Data JPA.
إنشاء واجهة مستودع
إنشاء واجهة
CustomerRepository يمتد واجهة
CrudRepository المعرفة في Spring Data JPA:
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> { }
هذا هو تقريبا كل رمز نحتاجه للوصول إلى البيانات. أتفق فقط؟ باستخدام Spring Data JPA ، لسنا بحاجة إلى كتابة رمز DAO (Java Data Acces Object). قم فقط بتعريف الواجهة التي تعمل على
CrudRepository واجهة
CrudRepository ، والتي تحدد أساليب CRUD مثل
save() ،
findAll() ،
findById() ،
deleteById() ، إلخ. في وقت التشغيل ، ستقوم Spring Data JPA بإنشاء رمز تلقائيًا.
يرجى ملاحظة أننا يجب أن نحدد نوع فئة النموذج ونوع حقل المفتاح الأساسي عند تمديد
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 صفنا. هذا يعني أنه سيتم اعتراض Spring Data JPA جميع أساليب هذه الفئة لإدارة المعاملات. وسيتم تضمين مثيل واجهة
CustomerRepository في هذه الفئة:
@Autowired CustomerRepository repo;
هذا يبدو سحريًا لأننا لا نكتب رمز DAO ، لكن Spring Data JPA ستنشئ تطبيقًا تلقائيًا في وقت التشغيل.
كما ترون ، كل الطرق في هذا الفصل مخصصة لعمليات CRUD. يقوم ببساطة بتفويض المكالمة بالكامل إلى كائن
CustomerRepository . قد تبدو هذه الفئة زائدة عن الحاجة بالنسبة لك ، لكن من الضروري فصل مستوى العمل / الخدمة عن مستوى المستودع / DAO.
8. إنشاء وحدة تحكم MVC الربيع
إنشاء فئة
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;
هذا هو فصل Spring MVC Controller الذي يتم
@Controller باستخدام
@Controller . يمكنك أن ترى أن مثيل
CustomerService يتم حقنه في هذا الكائن باستخدام التعليق التوضيحي
@Autowired .
سنكتب طرق المعالجة في الأقسام التالية.
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 :
<%@ 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 . استعلام البحث هو استعلام 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. سترى صفحة نتائج البحث:
النتائج
في هذا الدليل ، تعلمت كيفية تطوير تطبيق ويب Spring MVC باستخدام Spring Data JPA للوصول إلى البيانات. كما ترى ، فإن Spring Data JPA تقلل وتبسط بشكل كبير الشفرة التي نحتاج إلى كتابتها.
للمقارنة ، هنا هو هيكل المشروع في Eclipse IDE:
شكرا للقراءة!