பகுதி 5. Servlets மற்றும் Java Servlet API. ஒரு எளிய இணைய பயன்பாட்டை எழுதுதல்

இந்த பொருள் "நிறுவன மேம்பாட்டிற்கான அறிமுகம்" தொடரின் ஒரு பகுதியாகும். முந்தைய கட்டுரைகள்:

• நெட்வொர்க்கிங் பற்றி
• மென்பொருள் கட்டமைப்பு பற்றி
• HTTP/HTTPS பற்றி
• மேவனின் அடிப்படைகள் பற்றி

கன்சோலில் உரையைக் காண்பிக்கும் ஜாவா பயன்பாடுகளை எப்படி எழுதுவது என்பது உங்களுக்கு ஏற்கனவே தெரியுமா, ஆனால் உங்கள் முதல் இணைய பயன்பாட்டை எப்படி உருவாக்குவது என்பது உங்களுக்கு இன்னும் தெரியவில்லையா? அருமை, உங்களுக்கு வசதியாக இருங்கள். இந்தக் கட்டுரையில், நாங்கள் சர்வ்லெட்டுகளைப் பற்றி அறிந்துகொள்வதோடு, உங்கள் நண்பர்களுக்கு ஒரு JAR கோப்பை அனுப்பாமலும், ஜாவாவைப் பதிவிறக்கும்படி கட்டாயப்படுத்தாமலும் நீங்கள் அவர்களுக்குப் பெருமையாக ஒரு பயன்பாட்டை எழுதுவோம். ஒரு எளிய இணைய பயன்பாட்டை எழுதுவோம் . இணைய மேம்பாட்டில் பயன்படுத்தப்படும் அணுகுமுறைகளை நீங்கள் ஏற்கனவே அறிந்திருக்கவில்லை என்றால், " எண்டர்பிரைஸ் மேம்பாட்டிற்கான அறிமுகம் " தொடரின் முதல் கட்டுரையைப் படிப்பதன் மூலம் தொடங்க பரிந்துரைக்கிறேன்.

சர்வ்லெட் என்றால் என்ன?

முதலில், சர்வ்லெட்டுகள் என்றால் என்ன, அவற்றைப் பற்றி நீங்கள் ஏன் அடிக்கடி கேட்கிறீர்கள் என்பதைக் கண்டுபிடிப்போம். Java Servlet API என்பது சர்வரில் செயல்படுத்தப்படும் தரப்படுத்தப்பட்ட API ஆகும். இது கோரிக்கை-பதில் திட்டத்தின் படி வாடிக்கையாளர்களுடன் தொடர்பு கொள்கிறது. ஒரு சர்வ்லெட் என்பது கிளையண்டிடமிருந்து கோரிக்கைகளைப் பெறக்கூடிய மற்றும் கிளையண்டிற்கு பதில்களை அளிக்கக்கூடிய ஒரு வகுப்பாகும். உண்மையில், servlets என்பது ஜாவாவில் கிளையன்ட்-சர்வர் கட்டமைப்பை உருவாக்க நாம் பயன்படுத்தும் கட்டுமானத் தொகுதிகள். அந்த கட்டிடக்கலை பற்றி நாம் ஏற்கனவே தொடரின் மற்றொரு கட்டுரையில் பேசியது உங்களுக்கு நினைவிருக்கலாம். நாங்கள் புதரைச் சுற்றி அடிக்கப் போவதில்லை: உடனே சில குறியீட்டை எழுதுவோம்.

இணைய பயன்பாட்டை உருவாக்க நீங்கள் என்ன செய்ய வேண்டும்

ஜாவா சர்வ்லெட்டுகளுடன் பணிபுரியும் போது அதிக வசதிக்காக, உங்களுக்கு IntelliJ IDEA அல்டிமேட் பதிப்பு தேவை. இது ஒரு கட்டண தயாரிப்பு, ஆனால் நீங்கள் 30 நாள் சோதனையை இயக்கலாம் அல்லது ஆரம்ப அணுகல் பதிப்பைப் பயன்படுத்தலாம், இது எப்போதும் இலவசம். மேலும், Apache Tomcat - எங்கள் பயன்பாட்டின் சேவையகத்தை நிறுவவும். டாம்கேட் ஒரு சர்வ்லெட் கொள்கலன்: இது உள்வரும் கோரிக்கைகளைச் செயலாக்குகிறது மற்றும் அவற்றை எங்கள் பயன்பாட்டிற்கு அனுப்புகிறது. டாம்கேட்டை இங்கே பதிவிறக்கவும் .

எங்கள் முதல் இணைய பயன்பாட்டை உருவாக்குவோம்

எல்லாம் தயாராக இருந்தால், ஒரு மேவன் திட்டத்தை உருவாக்கவும். நீங்கள் மேவனைப் பற்றி அறிந்திருக்கவில்லை என்றால், முந்தைய கட்டுரையைப் பாருங்கள் . ஆரம்பித்துவிடுவோம்!

1. pom.xml இல், javax.servlet-api சார்புநிலையைச் சேர்த்து, WAR பேக்கேஜிங்கைக் குறிப்பிடவும்:

   
   <?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>org.example</groupId>
      <artifactId>servlets</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
   
      <dependencies>
          <dependency>
              <groupId>javax.servlet</groupId>
              <artifactId>javax.servlet-api</artifactId>
              <version>4.0.1</version>
          </dependency>
      </dependencies>
   </project>
   

   எளிய சர்வ்லெட் வகுப்பு:

   
   import javax.servlet.ServletException;
   import javax.servlet.annotation.WebServlet;
   import javax.servlet.http.HttpServlet;
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import java.io.IOException;
   import java.io.PrintWriter;
   
   @WebServlet("/hello")
   public class MainServlet extends HttpServlet {
   
      @Override
      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
          resp.setContentType("text/html");
          PrintWriter printWriter = resp.getWriter();
          printWriter.write("Hello!");
          printWriter.close();
      }
   }
   

2. பயன்பாட்டை இயக்க, நீங்கள் ஒரு Tomcat உள்ளமைவை உருவாக்க வேண்டும்:

3. அடுத்து, Tomcat இன் எந்தப் பதிப்பைப் பயன்படுத்துவோம் என்பதையும், சேவையகத்துடன் தொடர்புகொள்வதற்கான URL மற்றும் போர்ட்டையும் குறிப்பிடுகிறோம். உங்களிடம் இது போன்ற ஏதாவது இருக்க வேண்டும்:

4. கொள்கலனில் வைக்கப்படும் கலைப்பொருளை (JAR காப்பகத்தில் கூடியிருந்த திட்டம்) இப்போது நாம் குறிப்பிட வேண்டும். நீங்கள் ஃபிக்ஸ் பொத்தானைக் கிளிக் செய்து போர் வெடித்தது என்பதைத் தேர்ந்தெடுக்கலாம் : இதன் பொருள் திட்டம் மீண்டும் கட்டப்பட்ட பிறகு, கலைப்பொருள் தானாகவே சர்வ்லெட் கொள்கலனில் வைக்கப்படும்.

5. பயன்பாட்டுச் சூழலுக்கான இயல்புநிலை மதிப்பு servlets_war_exploded . இதன் பொருள்: http://localhost:8080/servlets_war_exploded .

   நாம் ஏன் கூடுதல் உரையை விரும்புகிறோம்? தேவையில்லாததை நீக்குவோம். இப்போது எங்கள் இணைய பயன்பாட்டின் முகவரி: http://localhost:8080 .

6. சரி என்பதைக் கிளிக் செய்யவும். நாங்கள் இப்போது பயன்பாட்டைத் தொடங்கலாம் என்பதைக் காண்கிறோம்:

   இப்போது உங்கள் உலாவியில் பயன்பாட்டைத் திறக்கும்போது, ​​​​404 பிழையைப் பெற வேண்டும். இது அர்த்தமுள்ளதாக இருக்கிறது, ஏனெனில் http://localhost:8080/ என்ற முகவரிக்கு "/" க்கு மேப் செய்யும் சர்வ்லெட் தேவை, ஆனால் எங்களின் ஒரே சர்வ்லெட் வரைபடங்கள் "/hello" க்கு மட்டுமே .

7. நாம் அதை http://localhost:8080/hello இல் அணுகலாம் . நாம் அதைச் செய்தவுடன், எதிர்பார்த்த பதிலைப் பெறுவோம் — சரம் "ஹலோ"!

எல்லாம் வேலை செய்தால், குறியீட்டை பகுப்பாய்வு செய்வோம். ஒரு சாதாரண வகுப்பிலிருந்து HTTP-servlet ஐ உருவாக்க , அது HttpServlet வகுப்பைப் பெற வேண்டும். வகுப்பு அறிவிப்புக்கு மேலே, சிறுகுறிப்பைக் குறிப்பிடுகிறோம் @WebServlet(). இங்குதான் சர்வ்லெட்டை ஒரு குறிப்பிட்ட பாதையில் ("/ஹலோ") பிணைக்கிறோம் (அல்லது வரைபடம்). இந்த சிறுகுறிப்பு ஜாவா சர்வ்லெட் ஏபிஐ 3.0 இல் மட்டுமே தோன்றியது, எனவே எக்ஸ்எம்எல் கோப்பு மூலம் சர்வ்லெட் மேப்பிங் நடக்கும் என்பதற்கு இணையத்தில் நிறைய எடுத்துக்காட்டுகள் உள்ளன. இது இனி தேவையில்லை. GET கோரிக்கைகளைக் கையாள , நாங்கள் doGet()முறையை மீறுகிறோம். முறையின் அளவுருக்களுக்கு கவனம் செலுத்துங்கள்: HttpServletRequestமற்றும் HttpServletResponse. HttpServletRequestகோரிக்கை பற்றிய தேவையான அனைத்து தகவல்களையும் பொருள் நமக்கு வழங்குகிறது . இல் HttpServletResponse, நாங்கள் எங்கள் பதிலை எழுதி தேவையான தலைப்புகளை அமைக்கிறோம்.

அளவுருக்கள் மற்றும் ஒரு அமர்வுடன் பணிபுரிதல்

எங்கள் சர்வ்லெட்டை மேம்படுத்துவோம், இதன் மூலம் கோரிக்கை அளவுருக்களை செயலாக்கி ஒரு அமர்வுடன் வேலை செய்யலாம்:

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class MainServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       HttpSession session = req.getSession();
       Integer visitCounter = (Integer) session.getAttribute("visitCounter");
       if (visitCounter == null) {
           visitCounter = 1;
       } else {
           visitCounter++;
       }
       session.setAttribute("visitCounter", visitCounter);
       String username = req.getParameter("username");
       resp.setContentType("text/html");
       PrintWriter printWriter = resp.getWriter();
       if (username == null) {
           printWriter.write("Hello, Anonymous" + "<br>");
       } else {
           printWriter.write("Hello, " + username + "<br>");
       }
       printWriter.write("Page was visited " + visitCounter + " times.");
       printWriter.close();
   }
}

இப்போது சர்வ்லெட் ஒரு அமர்வுடன் செயல்படுகிறது, visitCounterஒவ்வொரு முறையும் பக்கத்தைப் பார்வையிடும்போது அதன் மதிப்பை அதிகரிக்கிறது. visitCounterபண்புக்கூறு இன்னும் உருவாக்கப்படவில்லை என்றால் (பக்கத்திற்கு முதல் வருகையின் போது), getAttribute()முறை பூஜ்யமாக இருக்கும், எனவே நாம் பூஜ்யத்தை சரிபார்க்க வேண்டும். கோரிக்கை அளவுருக்களுக்கும் இதுவே செல்கிறது. பயனர் பெயர் அளவுருவை அனுப்பவில்லை என்றால், அதன் மதிப்பு பூஜ்யமாக இருக்கும். இந்த நிலையில், பயனரை அநாமதேய பார்வையாளராக வாழ்த்துகிறோம். GET கோரிக்கையில் அளவுருவை அனுப்ப, வினவல் சரம் பயன்படுத்தப்படுகிறது, எடுத்துக்காட்டாக, பின்வரும் URL ஐப் பயன்படுத்தலாம்: http:// localhost:8080/hello? பயனர் பெயர்=பால். முந்தைய கட்டுரையில் HTTP கோரிக்கைகளைப் பற்றி மேலும் படிக்கலாம்தொடரில். எங்கள் பயன்பாட்டில் தற்போது அதிக லாஜிக் இல்லை, ஆனால் ரூட் பாதையில் 404 பிழையைப் பெறுவது கொஞ்சம் எரிச்சலூட்டும். இதை சரிசெய்ய, நாங்கள் மற்றொரு சர்வ்லெட்டை உருவாக்கி அதை தொடக்கப் பக்கத்திற்கு வரைபடமாக்குவோம்: @WebServlet("/"). இந்த சர்வ்லெட்டின் நோக்கம் கோரிக்கைகளை "/ஹலோ" பாதைக்கு திருப்பி விடுவதாகும். இதைச் செய்ய இரண்டு வழிகள் உள்ளன: "முன்னோக்கி" அல்லது "வழிமாற்று". ஒருவேளை அவற்றுக்கிடையேயான வித்தியாசத்தைப் புரிந்துகொள்வது பயனுள்ளது. ஒரு முன்னோக்கி பிரதிநிதிகள் கோரிக்கையை சேவையகத்தில் உள்ள மற்றொரு சேவையகத்திற்கு செயலாக்குகிறார். வாடிக்கையாளர் இதில் ஈடுபடவில்லை. இதைச் செய்ய, புதிய சர்வ்லெட்டின் doGet() முறையில் பின்வரும் குறியீட்டைச் சேர்க்கவும்:

getServletContext().getRequestDispatcher("/hello").forward(req, resp);

இந்தக் குறியீட்டில், நாங்கள் சர்வ்லெட் சூழலை அணுகி, தொடர்புடைய சர்வ்லெட்டிற்கான கோரிக்கை அனுப்புநரைப் பெறுகிறோம், மேலும் குறிப்பிட்ட வாதங்களுடன் (req, resp) ஒரு குறிப்பிட்ட கோரிக்கையைச் செயல்படுத்துமாறு கேட்டுக்கொள்கிறோம். கிளையண்ட் தனது கோரிக்கையைச் செயல்படுத்த வாடிக்கையாளர் பயன்படுத்த வேண்டிய முகவரியை ஒரு திசைதிருப்புதல் வாடிக்கையாளருக்குத் திருப்பித் தருகிறது. பெரும்பாலான உலாவிகள் தானாக திரும்பிய URLக்கு செல்கின்றன. திசைதிருப்புதலைச் செயல்படுத்த, இந்தக் குறியீட்டைச் சேர்க்க வேண்டும்:

resp.sendRedirect(req.getContextPath() + "/hello");

redirect()அளவுருவில் உள்ள முறையை நாங்கள் அழைக்கிறோம் HttpServletResponseமற்றும் கிளையன்ட் பயன்படுத்த வேண்டிய முகவரியை அனுப்புகிறோம். இங்கே ஒரு முக்கியமான விவரம்: HTTP அளவுருக்கள் முழு வழிமாற்று பாதையின் முடிவில் சேர்க்கப்பட வேண்டும், இது மிகவும் வசதியானது அல்ல. எங்கள் சூழ்நிலையில், அதைப் பயன்படுத்துவது விரும்பத்தக்கது forward, ஆனால் சில நேரங்களில் பயன்படுத்துவது redirectசிறந்தது. அவர்கள் வேலை செய்யும் விதத்தில் உள்ள வித்தியாசத்தை நீங்கள் புரிந்து கொண்டால், நீங்கள் தவறான தேர்வு செய்ய மாட்டீர்கள். புதிய சேவையகத்திற்கான குறியீடு இதுபோல் தெரிகிறது:

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/")
public class IndexServlet extends HttpServlet {

   @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        getServletContext().getRequestDispatcher("/hello").forward(req, resp);
       resp.sendRedirect(req.getContextPath() + "/hello");
   }
}

சுருக்கம்

உங்கள் முதல் இணைய பயன்பாடு முடிந்தது. அடுத்த கட்டுரையில், IntelliJ IDEA ஐப் பயன்படுத்தாமல் அதை எவ்வாறு பயன்படுத்துவது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். GET கோரிக்கைகளை மட்டுமே செயல்படுத்தும் ஒரு விண்ணப்பத்தை நாங்கள் எழுதினோம். மீதமுள்ள HTTP முறைகள் இதே வழியில் கையாளப்படுகின்றன - பெற்றோர் வகுப்பின் தொடர்புடைய முறைகளை மேலெழுதுவதன் மூலம். அதிநவீன பல்துறை வலை பயன்பாடுகளை உருவாக்க இது போன்ற எளிய சர்வ்லெட்டுகளைப் பயன்படுத்தலாம். நிச்சயமாக, ஸ்பிரிங் போன்ற பெரிய கட்டமைப்புகளைப் பயன்படுத்துவது இதை மிகவும் எளிதாக்குகிறது. ஆனால் நீங்கள் உண்மையிலேயே servlets இன் அனைத்து திறன்களையும் ஆழமாக ஆராய விரும்பினால், நீங்கள் அதிகாரப்பூர்வ விவரக்குறிப்பைப் படிக்கலாம் . பகுதி 6. சர்வ்லெட் கொள்கலன்கள் பகுதி 7. எம்விசி (மாடல்-வியூ-கன்ட்ரோலர்) வடிவத்தை அறிமுகப்படுத்துகிறது