ஜாவா சர்வ்லெட்டுகளைப் பயன்படுத்தும் உங்கள் முதல் பயன்பாடு

எல்லோருக்கும் வணக்கம்! இணைய மேம்பாட்டின் அடிப்படைக் கருத்தாக சர்வ்லெட்டுகளை நீங்கள் நன்கு அறிந்திருப்பீர்கள், மேலும் அவற்றைப் பயன்படுத்தும் எளிய பயன்பாட்டை உங்களால் எழுத முடியும். தேவையற்ற செயல்களைத் தவிர்க்க, புதிதாக தொடங்க மாட்டோம். Hibernate பற்றிய எனது முந்தைய கட்டுரையிலிருந்து எங்கள் விண்ணப்பத்தில் தொடர்ந்து பணியாற்றுவோம் . ஆனால் நாங்கள் இப்போதுதான் சர்வ்லெட்டுகளுடன் பழகத் தொடங்கியுள்ளதால், ஆட்டோ கிளாஸ் தொடர்பான அனைத்தையும் அப்ளிகேஷனில் இருந்து நீக்கிவிட்டு, யூசர் கிளாஸ் மற்றும் அது சம்பந்தப்பட்ட செயல்களை மட்டும் விட்டுவிட்டேன். திட்டம் பின்வருமாறு கட்டமைக்கப்படும்: எனவே, சேவையாளர்களே! விக்கிபீடியா கூறுகிறது: "ஒரு Java servlet என்பது ஒரு சேவையகத்தின் திறன்களை நீட்டிக்கும் ஒரு Java மென்பொருள் கூறு ஆகும். servlets பல வகையான கோரிக்கைகளுக்கு பதிலளிக்க முடியும் என்றாலும், அவை பொதுவாக வலை சேவையகங்களில் வலை பயன்பாடுகளை ஹோஸ்ட் செய்வதற்கு வலை கொள்கலன்களை செயல்படுத்துகின்றன, இதனால் சேவையகமாக தகுதி பெறுகின்றன- பக்க சர்வ்லெட் வலை API." இது முற்றிலும் உண்மை. இங்கே, முதன்முறையாக, "கிளையன்ட்-சர்வர் அப்ளிகேஷன் ஆர்கிடெக்சர்" என்ற கருத்தை நாங்கள் காண்கிறோம். இது அதன் மையத்தில் மிகவும் எளிமையானது. கிளையன்ட் HTTP கோரிக்கையை அனுப்புவதன் மூலம் சேவையகத்தை அணுகுகிறார். சேவையகம் தேவையான தரவை உருவாக்குகிறது (உதாரணமாக, ஒரு தரவுத்தளத்திலிருந்து அதைப் பெறுகிறது) மற்றும் அதை கிளையண்டிற்கு திருப்பித் தருகிறது. ஒரு குறிப்பிட்ட சமூக வலைப்பின்னலில் "நண்பர்கள்" பொத்தானைக் கிளிக் செய்தால், அதன் மூலம் சேவையகத்திற்கு ஒரு கோரிக்கையை அனுப்புவது எளிமையான உதாரணம். சேவையகம் தரவுத்தளத்தில் உள்ள உங்கள் நண்பர்களின் பட்டியலைப் புதுப்பித்து, அதை உங்களுக்கு (வாடிக்கையாளருக்கு) திருப்பித் தருகிறது. HTTP கோரிக்கைகளின் பட்டியல் மிகப் பெரியது, எனவே நீங்கள் அவற்றை இதற்கு முன் சந்தித்ததில்லை எனில், அவற்றைப் பற்றி வேறு எங்காவது படிப்பது சிறந்தது, எடுத்துக்காட்டாக,இங்கே . எங்கள் நோக்கம்: servlets ஐப் பயன்படுத்தி CRUD பயன்பாட்டை உருவாக்குவது. பயன்பாடு HTTP கோரிக்கைகளைச் செயலாக்கும் சர்வ்லெட்டைப் பயன்படுத்தி தரவுத்தளத்திலிருந்து பயனர்களை உருவாக்க, படிக்க, புதுப்பிக்க மற்றும் நீக்க முடியும். Hibernate கட்டுரையிலிருந்து எங்கள் பயன்பாடு ஏற்கனவே இதைச் செய்ய முடியும், ஆனால் இது ஜாவா குறியீட்டிலிருந்து நேரடியாகக் கட்டுப்படுத்தப்பட்டது, இன்னும் துல்லியமாக, முக்கிய() முறையிலிருந்து. இந்த நேரத்தில், வாடிக்கையாளர் தான் கோரிக்கைகளை அனுப்புவார், அதாவது நீங்கள் :) நாம் செய்ய வேண்டிய முதல் விஷயம், எங்கள் pom.xml கோப்பில் புதிய சார்புகளைச் சேர்ப்பதுதான்.

 <xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.itis4</groupId>
     <artifactId>UsersDaoProject</artifactId>
     <version>1.0-SNAPSHOT</version>
 
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-war-plugin</artifactId>
                 <version>2.6</version>
             </plugin>
         </plugins>
     </build>
 
     <dependencies>
         <!-- PostgreSQL  -->
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
             <version>9.4.1212.jre7</version>
         </dependency>
 
         <!-- Hibernate 5.2.6 Final -->
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-core</artifactId>
             <version>5.2.6.Final</version>
         </dependency>
 
         <dependency>
             <groupId>jstl</groupId>
             <artifactId>jstl</artifactId>
             <version>1.2</version>
         </dependency>
         <dependency>
             <groupId>javax.servlet</groupId>
             <artifactId>javax.servlet-api</artifactId>
             <version>3.1.0</version>
         </dependency>
 
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>4.3.4.RELEASE</version>
         </dependency>
 
     </dependencies>
 
 </project>
 

நாங்கள் 3 சார்புகளைச் சேர்த்துள்ளோம்:

1. javax.servlet-api நூலகம்
2. JSTL டேக் லைப்ரரி. கிளையன்ட் பக்கத்தை உருவாக்க இது தேவைப்படும், அதாவது JSP பக்கங்கள்
3. ஸ்பிரிங்-வெப்எம்விசி. எங்களுக்கு ஒரு வசந்த வகுப்பு தேவைப்படும், அதைப் பற்றி சிறிது நேரம் கழித்து பேசுவோம்.

சர்வ்லெட் மேலாண்மை சர்வ்லெட் கொள்கலனால் கையாளப்படுகிறது. எங்கள் விஷயத்தில், நாங்கள் Apache Tomcat ஐப் பயன்படுத்துவோம். இது மிகவும் பிரபலமானது — நீங்கள் இதைப் பற்றி ஏற்கனவே கேள்விப்பட்டிருக்கலாம் :) சர்வ்லெட் வாழ்க்கைச் சுழற்சி பின்வரும் படிகளைக் கொண்டுள்ளது:

1. கொள்கலனில் சர்வ்லெட் இல்லை என்றால்:
   
   • சர்வ்லெட் வகுப்பு கொள்கலன் மூலம் ஏற்றப்படுகிறது.
   • கொள்கலன் சர்வ்லெட் வகுப்பின் உதாரணத்தை உருவாக்குகிறது.
   • கொள்கலன் init() முறையை அழைக்கிறது. இந்த முறை servlet ஐ துவக்குகிறது மற்றும் servlet கோரிக்கைகளை வழங்கும் முன் முதலில் அழைக்கப்படுகிறது. முழு வாழ்க்கைச் சுழற்சியிலும், init() முறை ஒருமுறை மட்டுமே அழைக்கப்படுகிறது.
2. வாடிக்கையாளர் கோரிக்கைக்கு சேவை செய்யுங்கள். ஒவ்வொரு கோரிக்கையும் அதன் சொந்த தனி நூலில் செயலாக்கப்படுகிறது. கொள்கலன் ஒவ்வொரு கோரிக்கைக்கும் சேவை() முறையை அழைக்கிறது. இந்த முறை உள்வரும் கோரிக்கையின் வகையைத் தீர்மானிக்கிறது மற்றும் செயலாக்கத்திற்கான பொருத்தமான முறைக்கு அனுப்புகிறது. சர்வ்லெட் டெவலப்பர் இந்த முறைகளுக்கான செயலாக்கங்களை வழங்க வேண்டும். செயல்படுத்தப்படாத ஹேண்ட்லருக்கான கோரிக்கை வந்தால், பெற்றோர் வகுப்பின் முறை அழைக்கப்படுகிறது மற்றும் வழக்கமாக கோரிக்கையாளருக்கு ஒரு பிழையை வழங்கும்.


3. கொள்கலன் சர்வ்லெட்டை அகற்ற வேண்டும் என்றால், அது அழிவு() முறையை அழைக்கிறது, இது சர்வ்லெட்டை செயல்பாட்டிலிருந்து வெளியேற்றும். init() முறையைப் போலவே, இந்த முறையும் முழு சர்வ்லெட் சுழற்சியின் போது ஒரு முறை அழைக்கப்படுகிறது.

எங்கள் சர்வ்லெட் மிகவும் எளிமையானது:

 package servlets;
 
 import models.User;
 import services.UserService;
 import javax.servlet.RequestDispatcher;
 import javax.servlet.ServletConfig;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.util.List;
 
 public class UserSimpleServlet extends HttpServlet {
 
     private UserService service = new UserService();
 
     public void init(ServletConfig servletConfig) {
         try {
             super.init(servletConfig);
         } catch (ServletException e) {
             e.printStackTrace();
         }
     }
 
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
         List<User> users = service.findAllUsers();
         req.setAttribute("users", users);
         RequestDispatcher dispatcher = req.getRequestDispatcher("/showUsers.jsp");
         dispatcher.forward(req, resp);
 
     }
 
     @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
             throws ServletException, IOException {
 
         String name = req.getParameter("name");
         int age = Integer.parseInt(req.getParameter("age"));
         User user = new User(name, age);
         service.saveUser(user);
         resp.sendRedirect("/users");
 
     }
 
     @Override
     protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         int id = Integer.parseInt(req.getParameter("id"));
         User user = service.findUser(id);
         user.setName(req.getParameter("name"));
         user.setAge(Integer.parseInt(req.getParameter("age")));
         service.updateUser(user);
         resp.sendRedirect("/users");
     }
 
     @Override
     protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {
         int id = Integer.parseInt(req.getParameter("id"));
         service.deleteUser(service.findUser(id));
         resp.sendRedirect("/users");
     }
 }
 

நீங்கள் பார்க்க முடியும் என, இது மேலே விவரிக்கப்பட்ட init() முறையைக் கொண்டுள்ளது மற்றும் நான்கு HTTP கோரிக்கைகளுடன் ஒத்துப்போகும் 4 முறைகளை செயல்படுத்துகிறது: doPost(), doGet(), doPut() மற்றும் doDelete(). பயனர்களை உருவாக்க, படிக்க, புதுப்பிக்க மற்றும் நீக்க அவை நம்மை அனுமதிக்கின்றன. முறைகள் javax.servlet.http.HttpServletRequest மற்றும் javax.servlet.http.HttpServletResponse வகுப்புகளின் நிகழ்வுகளை உள்ளீடாக ஏற்றுக்கொள்கின்றன, அதாவது சேவையகத்திற்கு அனுப்பப்படும் கோரிக்கைகள் மற்றும் கிளையன்ட் பெற்ற பதில்கள். உள்நாட்டில், முறைகள் பயனர் சேவை வகுப்பின் தொடர்புடைய முறைகளை அழைக்கின்றன, மேலும் கிளையண்டிற்கான பதில் உருவாக்கப்பட்டு /பயனர்கள் URL க்கு திருப்பி விடப்படும். எடுத்துக்காட்டாக, doGet() முறையில், அனைத்து பயனர்களின் பட்டியலைப் பெறுகிறோம். அடுத்து, நாங்கள் ஒரு RequestDispatcher பொருளை உருவாக்குகிறோம், இது HTTP கோரிக்கையில் பொருட்களைச் சேர்த்து, அதை ஒரு குறிப்பிட்ட ஆதாரத்திற்கு (உதாரணமாக, கிளையன்ட் JSP பக்கத்திற்கு) திருப்பிவிடும். doPut() முறையில் (பயனர் தரவைப் புதுப்பிக்கும்), HTTP கோரிக்கையைச் செயல்படுத்தி, ஐடி, பெயர் மற்றும் வயது அளவுருக்களைப் பிரித்தெடுத்து, குறிப்பிட்ட ஐடியுடன் பயனரைக் கண்டறிந்து, கோரிக்கையில் உள்ள பெயரையும் வயதையும் ஒதுக்கி, திருப்பி அனுப்புவோம். /பயனர்கள் பக்கத்திற்கு. ஆனால் இந்த முறைகள் அனைத்தும் சரியாக வேலை செய்ய, நாம் servlet ஐ கட்டமைக்க வேண்டும். இதைச் செய்ய, WeB-INF கோப்புறையில் web.xml கோப்பைப் பயன்படுத்துகிறோம்.

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app version="3.1"
          xmlns="http://xmlns.jcp.org/xml/ns/javaee"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
 
     <welcome-file-list>
         <welcome-file>index.jsp</welcome-file>
     </welcome-file-list>
 
     <servlet>
         <servlet-name>UserSimpleServlet</servlet-name>
         <servlet-class>servlets.UserSimpleServlet</servlet-class>
     </servlet>
 
     <servlet-mapping>
         <servlet-name>UserSimpleServlet</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>
 
     <filter>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
     </filter>
 
     <filter-mapping>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <servlet-name>UserSimpleServlet</servlet-name>
     </filter-mapping>
 
 </web-app>
 

இந்த கோப்பில் உள்ள அனைத்து குறிச்சொற்களும் மிகவும் உள்ளுணர்வு கொண்டவை, ஆனால் அவற்றை வரிசையாகப் பார்ப்போம். <welcome-file-list> - JSP தொடக்கப் பக்கம் குறிக்கப்படுகிறது, இது பயன்பாடு தொடங்கும் போது முதலில் திறக்கப்படும். எங்கள் விஷயத்தில், இது index.jsp. <servlet> - எங்கள் UserSimpleServlet வகுப்பை ஒரு servlet ஆக பதிவு செய்தல். <servlet-mapping> - மிக முக்கியமான குறிச்சொல். இது servlet ஆல் செயலாக்கப்படும் URLகளை வரையறுக்கிறது. எங்கள் விஷயத்தில், இவை அனைத்தும் URLகள், எனவே நாங்கள் "/" என்பதைக் குறிப்பிடுகிறோம். ஆனால் பயனர்கள் மற்றும் அவர்களின் கார்கள் (ஆட்டோக்கள்) சம்பந்தப்பட்ட பயன்பாடு எங்களிடம் இருந்தால், நாங்கள் இரண்டாவது சர்வ்லெட்டை (SimpleAutoServlet) உருவாக்கலாம். பின்னர் பயனர் சர்வ்லெட்டின் மேப்பிங் "/பயனர்கள்" (அதாவது பயனர்கள் பற்றிய கோரிக்கைகள்), மற்றும் ஆட்டோ சர்வ்லெட்டின் மேப்பிங் "/autos" ஆக இருக்கும். இறுதியாக, <வடிகட்டி>. உள்நாட்டில், இது org இன் ஒரு நிகழ்வை வரையறுக்கிறது. springframework.web.filter.HiddenHttpMethodFilter வகுப்பு. இந்தக் கட்டுரை வசந்த காலத்தைப் பற்றியது அல்ல, எனவே நான் அதை விரிவாக விவரிக்க மாட்டேன். இது கூடுதல் அம்சமாக மட்டுமே எங்கள் பயன்பாட்டில் இணைக்கப்பட்டுள்ளது என்று மட்டுமே கூறுவேன். விஷயம் என்னவென்றால், கிளையன்ட் பக்கத்தை உருவாக்க JSP பக்கங்களைப் பயன்படுத்தப் போகிறோம். எங்கள் தரவு பயனர்களின் பட்டியலுடன் ஒரு அட்டவணையாக பக்கத்தில் காட்டப்படும். JSP பக்கங்களுக்குள், <form/> HTML குறிச்சொற்கள் பயன்படுத்தப்படும். ஆனால் HTTP GET மற்றும் POST கோரிக்கைகள் மட்டுமே <form/> இலிருந்து தரவை அனுப்புவதற்குப் பயன்படுத்தப்படும். வேறு வார்த்தைகளில் கூறுவதானால், மூன்று செயல்பாடுகளுக்கும் - புதுப்பித்தல், நீக்குதல் மற்றும் ஒரு பயனரை உருவாக்குதல் - நாம் POST கோரிக்கைகளை மட்டுமே பயன்படுத்த வேண்டும். PUT மற்றும் DELETE கோரிக்கைகளைப் பயன்படுத்துவது எங்களுக்கு ஒரு விருப்பமாக இருக்காது. கொள்கையளவில், இது மிகவும் சாதாரணமானது மற்றும் செயல்படுத்த எளிதானது, ஆனால் HiddenHttpMethodFilter வகுப்பு அவற்றைப் பயன்படுத்த அனுமதிக்கிறது. இந்த வழியில், பயன்பாட்டில் உள்ள செயல்பாடுகளுக்கு இடையிலான வேறுபாட்டை வாசகர் இன்னும் தெளிவாகக் காண்பார். இறுதியாக, வாடிக்கையாளர் பக்கத்திற்கு செல்லலாம். இது ஐந்து JSP பக்கங்களால் குறிக்கப்படுகிறது. index.jsp.

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Hello!</title>
 </head>
 <body>
 If you want to start working with the user database,<br>
 click the button below:
 
 <form action = "users" method="get">
     <input type="submit" value="Start working with database">
 </form>
 </body>
 </html>
 

addUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Add new user</title>
 </head>
 <body>
 <form action = "/users" method="post">
     <input required type="text" name="name" placeholder="Name">
     <input required type="text" name="age" placeholder="Age">
     <input type="submit" value="Save">
 </form>
 </body>
 </html>
 
 

deleteUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Delete user</title>
 </head>
 <body>
 
 Are you sure you want to delete the user ${param.id}?
 
 &lform action="/users/${param.id}" method="post">
     <input type="hidden" name="id" value="${param.id}">
     <input type="hidden" name="_method" value="delete">
     <input type="submit" value="Delete">
 </form>
 
 </body>
 </html>
 
 

showUsers.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <html>
 <head>
     <title>User list</title>
 </head>
 <body>
 <table border="2">
     <tr>
         <td>ID</td>
         <td>Name</td>
         <td>Age</td>
         <td>Actions</td>
     </tr>
     <c:forEach items="${users}" var = "user">
         <tr>
             <td>${user.getId()}</td>
             <td>${user.getName()}</td>
             <td>${user.getAge()}</td>
             <td>
                 <form action = "updateUser.jsp" method="post">
                     <input type="hidden" name="id" value="${user.getId()}">
                     <input type="hidden" name="name" value="${user.getName()}">
                     <input type="hidden" name="age" value="${user.getAge()}">
                     <input type="submit" value="Modify" style="float:left">
                 </form>
                 <form action="deleteUser.jsp" method="post">
                     <input type="hidden" name="id" value="${user.getId()}">
                     <input type="submit" value="Delete" style="float:left">
                 </form></td>
         </tr>
     </c:forEach>
 </table>
 
 <form action = "addUser.jsp">
     <input type="submit" value="Add new user">
 </form>
 </body>
 </html>

updateUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Modify user data</title>
 </head>
 <body>
 
 Edit user
 
 <form action="/users/${param.id}" method="post">
     <input type="hidden" name = "id" value="${param.id}">
     <input type="text" name="name" value="${param.name}" placeholder=${param.name}>
     <input type="text" name="age" value="${param.age}" placeholder=${param.age}>
     <input type="hidden" name="_method" value="put">
     <input type="submit" value="Update">
 </form>
 
 </body>
 </html>
 

ஒரு JSP (JavaServer Page) பக்கம் இரண்டு வகையான உரைகளைக் கொண்டுள்ளது: நிலையான மூலத் தரவு உரையாக வடிவமைக்கப்படலாம் (HTML, SVG, WML அல்லது XML), மற்றும் டைனமிக் உள்ளடக்கத்தை உருவாக்கப் பயன்படுத்தப்படும் JSP கூறுகள். JSP பக்கம் என்றால் என்ன என்பதைப் புரிந்துகொள்ள உங்களுக்கு உதவ, ஒரு நல்ல கட்டுரையிலிருந்து ஒரு பத்தியை நகலெடுத்துள்ளேன். "அடிப்படையில், முதன்முறையாக ஒரு JSP கோரப்படும்போது, ​​அது ஒரு சர்வ்லெட்டாக மாறி, சர்வ்லெட்டாக செயல்படுகிறது. இதைப் புரிந்துகொள்வது மிகவும் முக்கியம். JSP பக்கம் HTML பக்கத்தைப் போன்றது அல்ல - இது மற்றொரு சர்வ்லெட் என்பதை ஒரு தொடக்க புரோகிராமர் தெளிவாகப் புரிந்து கொள்ள வேண்டும். — நீங்கள் எழுதாமல் இருப்பது எப்படி காட்டப்படும் என்பதை நிரல் செய்ய வேண்டும்.அதை எளிமையாக வரையலாம்.தேவையான இடங்களில் டேட்டாவைச் சேர்க்கவும்.ஆனால் JSP பக்கம் HTML-ஐ நினைவூட்டுவதால், வடிவமைப்பாளர் அதை எளிதாகக் கண்டுபிடிப்பார்.மீண்டும் ஒருமுறை ஆரம்பநிலைக்கு வலுவாக வலியுறுத்துங்கள்,ஒரு JSP பக்கம் ஒரு SERVLET ஆகும். சர்வரில் எல்லா தரவையும் சேர்ப்பது உட்பட இது உருவாக்கப்படுகிறது. இங்குதான் அனைத்து தரவுகளும் செருகப்படுகின்றன. உலாவியில், பயனர் முடிக்கப்பட்ட HTML பக்கத்தைப் பெறுகிறார், அதில் ஜாவாவின் அறிகுறிகள் இல்லை." JSP பக்கம் உண்மையில் ஒரு சர்வ்லெட் என்பதை நீங்கள் உறுதியாக நம்பலாம், ஏனெனில் ஒவ்வொரு பக்கமும் செயல்படுத்தப்பட வேண்டிய ஒரு முறை உள்ளது. எடுத்துக்காட்டாக, அட்டவணை .jsp என்பது "தரவுத்தளத்துடன் பணிபுரியத் தொடங்கு" பொத்தானைக் கிளிக் செய்யும் போது, ​​பெறு முறை செயல்படுத்தப்படும் (முறை = "பெறு") புதிய பயனர்களை உருவாக்குவதற்குப் பொறுப்பான addUser.jsp பக்கம், இடுகை முறையைச் செயல்படுத்துகிறது. (முறை = "இடுகை") நீங்கள் சேமி பொத்தானைக் கிளிக் செய்யும் போது, ​​மீதமுள்ள JSP பக்கமானது வழக்கமான நிலையான HTML மார்க்அப்பால் ஆனது, எனவே நாங்கள் அதைப் பற்றி சிந்திக்க மாட்டோம். இது மற்றொரு கட்டுரைக்கான தலைப்பு மற்றும் இதில் நிறைய உள்ளன. இணையத்தில் தலைப்பு. எனவே, நாங்கள்' எங்கள் விண்ணப்பத்தை உருவாக்கியுள்ளோம்! இப்போது நாம் அதை செயலில் சோதிக்க வேண்டும்! இதைச் செய்ய, மேலே குறிப்பிட்டுள்ள Apache Tomcat சர்வ்லெட் கொள்கலன் நமக்குத் தேவை. நீங்கள் கொள்கலனை பதிவிறக்கம் செய்யலாம்அதிகாரப்பூர்வ வலைத்தளத்திலிருந்து (நான் பதிப்பு 8 ஐப் பயன்படுத்துகிறேன்). அடுத்து, டாம்கேட் மூலம் எங்கள் பயன்பாட்டை இயக்க ஐடியாவில் உள்ளமைவை உருவாக்க வேண்டும். இதைச் செய்ய, "உள்ளமைவுகளைத் திருத்து" தாவலைத் திறந்து, புதிய உள்ளமைவை உருவாக்கி, "Tomcat Server Local" என்பதைத் தேர்ந்தெடுக்கவும். "பயன்பாட்டு சேவையகம்" தாவலில், டாம்கேட் கோப்புறைக்கான பாதையை குறிப்பிடவும் அடுத்து, "வரிசைப்படுத்தல்" தாவலுக்குச் செல்லவும். இங்கே, உள்ளூர் சர்வரில் எங்கள் பயன்பாட்டின் வரிசைப்படுத்தலை உள்ளமைக்கிறோம். "+" ஐ அழுத்தி, "கலைப்பொருள்" -> YourProjectName:war என்பதைத் தேர்ந்தெடுக்கவும் (நாங்கள் பயன்பாட்டை போர்க் கோப்பாக உருவாக்குவோம்). அது பற்றி சுருக்கமாக! "சர்வர்" பக்கத்தில், எங்கள் பயன்பாடு http://localhost:8080/ இல் இயங்குவதை நீங்கள் பார்க்கலாம். உள்ளமைவைச் சேமித்து அதற்கு ஒரு பெயரைக் கொடுங்கள் (நான் எனது கட்டமைப்பை "டாமி" என்று அழைக்கிறேன்). அடுத்து, IDEA இல் உள்ள Maven தாவலில் (வலது பக்கத்தில்), போர்க் கோப்பில் எங்கள் திட்டத்தை உருவாக்க போர் செருகுநிரலைப் பயன்படுத்துவோம் (Plugins -> war -> war: war). உருவாக்கம் முடிந்ததும், பயன்பாட்டை இயக்கி காத்திருக்கவும். வெற்றி! தொடக்கப் பக்கம் தொடங்கப்பட்டது. இப்போது "தரவுத்தளத்துடன் வேலை செய்யத் தொடங்கு" பொத்தானைக் கிளிக் செய்க. எங்கள் index.jsp சேவையகத்தால் செயலாக்கப்படும் GET கோரிக்கையை உருவாக்கும். சேவையகம் ஒரு பதிலை உருவாக்கி, ஏற்கனவே உள்ள அனைத்து பயனர்களின் பட்டியலின் வடிவத்தில் அதை எங்களிடம் திருப்பித் தரும் (நிச்சயமாக தரவுத்தளத்தில் பயனர்கள் இருக்கிறார்கள் என்று வைத்துக்கொள்வோம்). அங்கே அவர்கள் இருக்கிறார்கள்! உங்களிடம் உள்ளது என்று! ஜாவா சர்வ்லெட்டுகளைப் பயன்படுத்தி உங்கள் முதல் விண்ணப்பத்தை எழுதினீர்கள். அது அவ்வளவு மோசமாக இல்லை, இல்லையா? :) வீட்டுப்பாடத்திற்கு, முந்தைய கட்டுரையிலிருந்து காரின் செயல்பாட்டை மீட்டெடுக்கலாம். வேறு வார்த்தைகளில் கூறுவதானால், கார்களுக்கான தனி சர்வ்லெட் மற்றும் ஜேஎஸ்பி பக்கங்களை உருவாக்கி, பயனரின் கார்களை எவ்வாறு பட்டியலிடுவது, பயனருக்கு புதிய கார்களைச் சேர்ப்பது மற்றும் அவற்றைத் திருத்துவது மற்றும் நீக்குவது ஆகியவற்றை பயன்பாட்டிற்குக் கற்பிக்கவும். PS Servlets மற்றும் JavaServer பக்கங்கள் பழமையான தொழில்நுட்பங்கள். இணையத்தில், "இந்த பழைய குப்பை யாருக்கு தேவை?" போன்ற கருத்துகளை நீங்கள் அடிக்கடி காணலாம். பதில் மிகவும் எளிமையானது: முக்கியமாக உண்மையான திட்டங்களில் பணிபுரியும் நபர்கள், இந்த தொழில்நுட்பங்களைப் பயன்படுத்தும் பல குறியீட்டை அவர்கள் சந்திக்க நேரிடலாம். மேலும் இது எவ்வாறு இயங்குகிறது என்பதைப் புரிந்து கொள்ளாமல், "பழைய குப்பைகளை" புதியதாக வெட்டுவது இன்னும் வேடிக்கையாக இருக்கிறது :) JSP மற்றும் servlets பற்றிய முழுமையான ஆய்வுக்கு, "Head First Servlets and JSP" என்ற புத்தகத்தைப் பார்க்கவும்.. இது பிரபல சூப்பர் புத்தகமான "ஹெட் ஃபர்ஸ்ட் ஜாவா" போன்ற அதே ஆசிரியர்களால் எழுதப்பட்டது, இது தரத்திற்கு உத்தரவாதமாக பலர் எடுக்கும் :) இந்த கட்டுரை பயனுள்ளதாக இருக்கும் என்று நம்புகிறேன்! உங்கள் கவனத்திற்கு நன்றி, கற்றலில் நல்ல அதிர்ஷ்டம்!