servlets மற்றும் JSPகளைப் பயன்படுத்தி எளிய இணைய பயன்பாட்டை உருவாக்குதல் (பகுதி 1)

கட்டுரையைப் புரிந்துகொள்ள தேவையான அறிவு: நீங்கள் ஏற்கனவே ஜாவா கோர் பற்றி அதிகமாகவோ அல்லது குறைவாகவோ கண்டுபிடித்துவிட்டீர்கள் , மேலும் JavaEE தொழில்நுட்பங்கள் மற்றும் வலை நிரலாக்கத்தைப் பார்க்க விரும்புகிறீர்கள் . கட்டுரைக்கு நெருக்கமான தலைப்புகளைக் கையாளும் ஜாவா சேகரிப்புத் தேடலை நீங்கள் தற்போது படிப்பது மிகவும் அர்த்தமுள்ளதாக இருக்கும் .

IntelliJ Idea Enterprise இல் எளிமையான வலைத் திட்டத்தை உருவாக்குதல் என்ற எனது கட்டுரையின் தர்க்கரீதியான தொடர்ச்சி இதுவாகும் . அந்த கட்டுரையில், வேலை செய்யும் வலை திட்ட டெம்ப்ளேட்டை எவ்வாறு உருவாக்குவது என்பதை நான் விளக்கினேன். இந்த முறை Java Servlet API மற்றும் JavaServer Pages API ஐப் பயன்படுத்தி எளிமையான ஆனால் முற்றிலும் கவர்ச்சிகரமான இணைய பயன்பாட்டை எவ்வாறு உருவாக்குவது என்பதை நான் உங்களுக்குக் காண்பிப்பேன் . எங்கள் விண்ணப்பம் இரண்டு இணைப்புகளுடன் முகப்புப் பக்கம் இருக்கும்:

பயனர்களைச் சேர்ப்பதற்கான பக்கத்திற்கான இணைப்பு;
பயனர்களின் பட்டியலுக்கான இணைப்பு.

முன்பு போலவே, IntelliJ Idea Enterprise Edition , Apache Maven (சில சார்புகளை இணைப்போம்) மற்றும் Apache Tomcat ஆகியவற்றைப் பயன்படுத்துவேன் . இறுதியில், W3.CSS கட்டமைப்பைப் பயன்படுத்தி எங்கள் பயன்பாட்டை "அழகப்படுத்துவோம்". உங்களிடம் ஏற்கனவே ஒரு வெற்று திட்டம் உள்ளது என்று வைத்துக்கொள்வோம், அதை நாங்கள் இப்போது சேர்ப்போம். இல்லையென்றால், முதல் கட்டுரையைப் படித்து, ஒன்றை உருவாக்கவும். இதற்கு சில நிமிடங்கள் மட்டுமே ஆகும் :)

எங்கள் எதிர்கால பயன்பாட்டின் கட்டமைப்பைப் பற்றி கொஞ்சம்

எங்கள் முகப்புப் பக்கம் (/) ஒரு தலைப்பு மற்றும் இரண்டு இணைப்புகள்/பொத்தான்கள் கொண்ட மிகவும் சாதாரண நிலையான HTML பக்கமாக இருக்கும் :

புதிய பயனரைச் சேர்க்கவும் (செல்க / சேர் );
பயனர்களின் பட்டியலைக் காண்க (/ பட்டியலுக்கு செல்லவும் ).

Tomcat இந்த முகவரிகளுக்கான கோரிக்கைகளைப் பிடித்து, நாங்கள் செய்யப் போகும் இரண்டு சர்வ்லெட்டுகளில் ஒன்றிற்கு அவற்றை அனுப்பும் (மேப்பிங்கை web.xml இல் குறிப்பிடுவோம் ). சர்வ்லெட்டுகள் கோரிக்கைகளைச் செயல்படுத்தும், தரவைத் தயார் செய்யும் (அல்லது நாங்கள் பயனரைச் சேர்த்தால் தரவைச் சேமிக்கும்), மேலும் கட்டுப்பாட்டை பொருத்தமான JSP கோப்புகளுக்கு மாற்றும் , அதன் பிறகு முடிவை "ரெண்டர்" செய்யும். நாங்கள் தரவை வெற்று வெண்ணிலா பட்டியலில் (பட்டியல்) சேமிப்போம்.

நிலையான முகப்புப் பக்கத்தை உருவாக்கவும்

உங்கள் வலை கோப்புறையில் index.jsp இருந்தால் , அதை நீக்கவும். அதற்கு பதிலாக, இந்த கோப்புறையில் index.html எனப்படும் எளிய HTML கோப்பை உருவாக்கவும்:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>My super project!</title>
</head>
<body>
    <!-- header -->
    <div>
        <h1>Super app!<//h1>
    </div>

    <div>       <!-- content -->
        <div>    <!-- button holder -->
            <button onclick="location.href='/list'">List users<//button>
            <button onclick="location.href='/add'">Add user<//button>
        </div>
    </div>
</body>
</html>

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

முடிவை வழங்க JSP கோப்புகளை உருவாக்கவும்

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

add.jsp — பயனர்களைச் சேர்ப்பதற்கான ஒரு பக்கம்;
list.jsp — பயனர்களின் பட்டியலைக் காண்பிக்கும் பக்கம்.

அவர்களுக்கு பொருத்தமான பக்க தலைப்புகளை ஒதுக்கவும். " புதிய பயனரைச் சேர் " மற்றும் " பயனர் பட்டியல் " போன்றவை , அதை அப்படியே விட்டுவிடுவோம்.

இரண்டு சர்வ்லெட்டுகளை உருவாக்கவும்

டாம்கேட் அனுப்பும் கோரிக்கைகளை சர்வலெட்டுகள் பெற்று செயல்படுத்தும் . src/main/java கோப்புறையில் , ஆப்ஸ் பேக்கேஜை உருவாக்கவும் , அங்கு எங்கள் மூலக் குறியீட்டை வைப்போம். மற்ற தொகுப்புகளும் அங்கு செல்லும். எனவே, இந்தத் தொகுப்புகள் ஒன்றின் உள்ளே உருவாக்கப்படுவதைத் தடுக்க, ஆப்ஸ் தொகுப்பில் சில வகுப்பை உருவாக்குவோம் (அதை பின்னர் நீக்குவோம்). இப்போது பயன்பாட்டு தொகுப்பில் மூன்று வெவ்வேறு தொகுப்புகளை உருவாக்கவும் :

நிறுவனங்கள் — எங்கள் நிறுவனங்கள் (பயனர் பொருள்களை விவரிக்கும் வகுப்பு) இங்கே செல்கின்றன;
மாதிரி - இது எங்கள் மாதிரி செல்கிறது (இதைப் பற்றி சிறிது நேரம் கழித்து பேசுவோம்);
servlets - இங்குதான் எங்கள் servlets செல்கின்றன.

இதைச் செய்தவுடன், ஆப்ஸ் தொகுப்பிலிருந்து அந்த வகுப்பை நிதானமாக நீக்கலாம் (நிச்சயமாக நீங்கள் உருவாக்கியிருந்தால்). servlets தொகுப்பில் , இரண்டு வகுப்புகளை உருவாக்கவும்:

AddServlet - க்கு அனுப்பப்பட்ட கோரிக்கைகளை செயலாக்குகிறது .
ListServlet - / பட்டியலிடப்பட்ட கோரிக்கைகளை செயலாக்குகிறது .

மேவெனில் சார்புகளை இணைக்கிறது

Tomcat 9 .* Servlet 4.0 மற்றும் JavaServer பக்கங்கள் 2.3 க்கான விவரக்குறிப்புகளை செயல்படுத்துகிறது . டாம்கேட் 9 இன் அதிகாரப்பூர்வ ஆவணத்தின் முதல் பத்தியின் இரண்டாவது வரியில் அதுதான் கூறப்பட்டுள்ளது . என்னைப் போலவே நீங்களும் இந்த Tomcat பதிப்பைப் பயன்படுத்தினால் , நீங்கள் எழுதி இயக்கும் குறியீடு இந்தப் பதிப்புகளைப் பயன்படுத்தும். ஆனால் எங்கள் திட்டத்தில் இந்த விவரக்குறிப்புகள் இருக்க வேண்டும் என்று நாங்கள் விரும்புகிறோம், அதனால் அவற்றைப் பயன்படுத்தும் எங்கள் குறியீடு, குறைந்தபட்சம் வெற்றிகரமாக தொகுக்கப்படும். இதைச் செய்ய, அவற்றை எங்கள் திட்டத்தில் ஏற்ற வேண்டும். இங்குதான் மேவன் மீட்புக்கு வருகிறார்.

பொதுவான விதி இதுதான்: மேவனைப் பயன்படுத்தி உங்கள் திட்டத்துடன் ஏதாவது இணைக்க வேண்டும் என்றால்:

Maven இலிருந்து களஞ்சிய வலைத்தளத்திற்குச் செல்லவும்;
தேவையான நூலகத்தின் தேவையான பதிப்பைக் கண்டறியவும்;
உங்கள் pom.xml இல் ஒட்ட வேண்டிய சார்புக் குறியீட்டைப் பெறுங்கள்;
ஒட்டவும்! :)

ஆரம்பித்துவிடுவோம். முதலில், POM கோப்பைத் தயாரிக்கவும் . எங்கோ /பதிப்பு உள்ளீட்டிற்குப் பிறகு, ஆனால் /திட்டத்திற்கு முன் , பின்வருவனவற்றைச் செருகவும்:


<dependencies>

</dependencies>

இந்தக் குறிச்சொற்களுக்குள் தேவையான சார்புகளை பட்டியலிடுவோம் என்பதைக் குறிக்க இதைச் செய்கிறோம். இப்போது mvnrepository.com க்குச் செல்லவும் . மேலே ஒரு தேடல் புலம் உள்ளது. தொடங்க, ' servlet ' ஐத் தேடவும். ஏழாயிரம் முறைக்கு மேல் பயன்படுத்தப்பட்ட முதல் முடிவு நமக்குப் பொருத்தமாக இருக்கிறது. நினைவில் கொள்ளுங்கள், எங்களுக்கு பதிப்பு 4.0 தேவை ( Tomcat 9 க்கு) பிற பதிப்புகள் பழைய செயலாக்கங்களுக்குப் பொருத்தமானதாக இருக்கலாம். இது மிகவும் சமீபத்திய பதிப்பாகும், அதனால் அதிக பயன்கள் இல்லை. ஆனால் நமக்கு அது தேவை. பல்வேறு தொகுப்பு மேலாளர்களுக்கான இந்த சார்புக்கான குறியீட்டை நீங்கள் பெறக்கூடிய ஒரு பக்கம் திறக்கிறது அல்லது நீங்கள் அதை பதிவிறக்கம் செய்யலாம். ஆனால் நாம் அதை Maven ஐப் பயன்படுத்தி இணைக்க விரும்புவதால், Maven தாவலில் குறியீட்டைத் தேர்ந்தெடுப்போம். எங்கள் POM கோப்பின் சார்பு பிரிவில் நகலெடுத்து ஒட்டுகிறோம். IDEA இன் கீழ் வலது மூலையில் தானாக இறக்குமதியை இயக்க விரும்புகிறீர்களா என்று கேட்கும் அறிவிப்பைப் பெற்றால் , அதை ஏற்கவும். நீங்கள் தற்செயலாக மறுத்தால், " அமைப்புகள் " என்பதற்குச் சென்று, தானாக இறக்குமதியை கைமுறையாக இயக்கவும்: அமைப்புகள் (Ctrl + Alt + S) -> உருவாக்குதல், செயல்படுத்துதல், வரிசைப்படுத்துதல் -> மேவன் -> இறக்குமதி செய்தல் .மற்றும் இந்த திட்டத்திற்கான IDEA உள்ளமைவு கோப்புகள் ஒத்திசைவில் உள்ளன. அதே கொள்கையைப் பின்பற்றி, ஜாவாசர்வர் பக்கங்கள் 2.3 ("JSP" ஐத் தேடவும்) கண்டுபிடித்து இணைப்போம் . நாம் ஏற்கனவே Maven ஐ ஆரம்பித்துவிட்டதால், நமது மூலக் கோப்புகள் Java 8 தொடரியல் பின்பற்றுகிறது என்பதையும், அந்த பதிப்பிற்கான பைட்கோடில் அவற்றை தொகுக்க வேண்டும் என்பதையும் கூறுவோம். இந்த அனைத்து படிகளுக்கும் பிறகு, எங்கள் 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>cc.codegym.info.fatfaggy</groupId>
    <artifactId>my-super-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compile.source>1.8</maven.compile.source>
        <maven.compile.target>1.8</maven.compile.target>
    </properties>

    <dependencies>
        <!-- Servlet API 4.0 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- JavaServer Pages API 2.3 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

எங்கள் சர்வ்லெட்டுகளை உண்மையான சர்வ்லெட்டுகளாக ஆக்குங்கள்

இந்த நேரத்தில், நாங்கள் உருவாக்கிய சேவையகங்களின் ஜோடி உண்மையில் சாதாரண வகுப்புகள். அவர்களுக்கு எந்த செயல்பாடும் இல்லை. ஆனால் இப்போது சர்வ்லெட் ஏபிஐயை எங்கள் திட்டத்துடன் இணைத்துள்ளோம் , அதன்படி அதன் வகுப்புகளைப் பயன்படுத்தலாம். எங்கள் சர்வ்லெட்டுகளை "உண்மையானதாக" மாற்ற, நாம் செய்ய வேண்டியது, அவற்றை HttpServlet வகுப்பைப் பெறச் செய்வதுதான்.

மேப்பிங் அல்லது மார்க்அப்

இப்போது எப்படியாவது டாம்கேட்டிடம் / சேர் முகவரிக்கான கோரிக்கைகள் எங்கள் AddServlet ஆல் செயலாக்கப்படும் என்றும் / பட்டியல் முகவரிக்கான கோரிக்கைகள் ListServlet ஆல் கையாளப்படுகின்றன என்றும் கூறுவது நன்றாக இருக்கும் . இந்த செயல்முறை மேப்பிங் (மார்க்அப்) என்று அழைக்கப்படுகிறது. இது web.xml இல் அதே கொள்கையைப் பயன்படுத்தி செய்யப்படுகிறது :

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

சேவையகத்தை விவரிக்கவும்:


<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>

இப்போது அதை முகவரியுடன் இணைக்கவும்:


<servlet-mapping>
    <servlet-name>add</servlet-name>
    <url-pattern>/add</url-pattern>
</servlet-mapping>

நீங்கள் பார்க்க முடியும் என, இரண்டு நிகழ்வுகளிலும் servlet-பெயர் ஒன்றுதான். இதன் விளைவாக, /சேர்ப்பதற்கான கோரிக்கை பெறப்பட்டால், அது app.servlets.AddServlet க்கு அனுப்பப்பட வேண்டும் என்பதை Tomcat அறிந்திருக்கிறது. இரண்டாவது சர்வ்லெட்டிலும் நாங்கள் அதையே செய்கிறோம். முடிவில், எங்கள் web.xml தோராயமாக பின்வரும் உள்ளடக்கத்தைக் கொண்டுள்ளது:


<?xml version="1.0" encoding="UTF-8"?>
<web-app 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"
         version="3.1">

    <!-- add servlet -->
    <servlet>
        <servlet-name>add</servlet-name>
        <servlet-class>app.servlets.AddServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>add</servlet-name>
        <url-pattern>/add</url-pattern>
    </servlet-mapping>

    <!-- list servlet -->
    <servlet>
        <servlet-name>list</servlet-name>
        <servlet-class>app.servlets.ListServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>list</servlet-name>
        <url-pattern>/list</url-pattern>
    </servlet-mapping>
</web-app>

முகப்புப் பக்கத்திற்கு (/) மார்க்அப்பை நாங்கள் உருவாக்கவில்லை. இந்த விஷயத்தில் நமக்கு அது தேவையில்லை என்பதே உண்மை. எங்கள் முகப்புப் பக்கம் இரண்டு பொத்தான்களைக் காட்டும் எளிய HTML கோப்பாகும். இதில் டைனமிக் உள்ளடக்கம் இல்லை, எனவே எங்களுக்காக இரண்டு பட்டன்களை வரைய சில JSP க்கு (அதையும் உருவாக்க வேண்டும்) முன்னோக்கி செயல்படுத்துவதைத் தவிர வேறு எதையும் செய்யாது / கோரிக்கைகளுக்கு நாங்கள் தனி சர்வ்லெட்டை உருவாக்க வேண்டியதில்லை . எங்களுக்கு இது தேவையில்லை. ஒரு நிலையான பக்கம் எங்களுக்கு பொருந்தும். டாம்கேட் ஒரு கோரிக்கையைப் பெறும்போது, அந்த முகவரிக்கான கோரிக்கையைச் செயல்படுத்தக்கூடிய ஒரு சர்வ்லெட் உள்ளதா என்பதைச் சரிபார்த்து, இந்த முகவரியில் ஏற்கனவே தயாராக உள்ள HTML கோப்பு இருப்பதைப் பார்க்கும்., இது வரை சேவை செய்யும். நாங்கள் எங்கள் பயன்பாட்டை மீண்டும் இயக்கலாம் (சேவையகத்தை மறுதொடக்கம் செய்யலாம் அல்லது அதை மீண்டும் வரிசைப்படுத்தலாம் - நீங்கள் விரும்பியது எதுவாக இருந்தாலும்) மற்றும் முகப்புப் பக்கம் ரெண்டர் செய்யப்பட்டுள்ளதா, எதுவும் உடைக்கப்படவில்லை என்பதை உறுதிசெய்து, பொத்தான்களைக் கிளிக் செய்யும் போது மாற்றங்கள் நிகழும் (மீண்டும் பிழை ஏற்பட்டாலும்). 404 பிழையைப் பெறுவதற்கு முன்பு, இப்போது 405 ஐப் பெறுகிறோம். இதன் பொருள் மேப்பிங் வேலைசெய்தது மற்றும் சர்வ்லெட்டுகள் கண்டுபிடிக்கப்பட்டன, ஆனால் கோரிக்கையை கையாளுவதற்கு பொருத்தமான முறை அவர்களிடம் இல்லை.

குறுகிய திசைதிருப்பல்: "ஹூட்டின் கீழ்" என்ன நடக்கிறது?

டாம்காட்டில் எங்கள் பயன்பாடு எவ்வாறு செயல்படுகிறது என்பதைப் பற்றி நீங்கள் ஏற்கனவே யோசித்திருக்கலாம். அங்கு என்ன நடக்கிறது? முக்கிய() முறை எங்கே? உங்கள் உலாவியில் localhost:8080 க்குச் சென்றவுடன், உலாவி HTTP நெறிமுறையைப் பயன்படுத்தி இந்த முகவரிக்கு கோரிக்கையை அனுப்புகிறது. பல்வேறு வகையான கோரிக்கைகள் உள்ளன என்பதை நீங்கள் ஏற்கனவே அறிந்திருப்பீர்கள் என்று நம்புகிறேன், மேலும் மிகவும் பிரபலமானவை GET மற்றும் POST ஆகும். ஒவ்வொரு கோரிக்கைக்கும் பதிலளிக்க வேண்டும். ஒரு GET கோரிக்கையானது பயன்படுத்தத் தயாராக இருக்கும் HTML குறியீட்டின் பதிலைப் பெறும் என எதிர்பார்க்கப்படுகிறது, அது உலாவிக்குத் திரும்பும். உலாவி பின்னர் குறியீட்டை அனைத்து அழகான எழுத்துக்கள், பொத்தான்கள் மற்றும் படிவங்களை மாற்றுகிறது. ஒரு POST கோரிக்கை இன்னும் கொஞ்சம் சுவாரஸ்யமானது, ஏனெனில் இது சில தகவல்களையும் கொண்டுள்ளது. எடுத்துக்காட்டாக, இணையதளத்தில் பதிவு அல்லது உள்நுழைவு படிவத்தில் நற்சான்றிதழ்களை உள்ளிட்டு, "அனுப்பு" என்பதைக் கிளிக் செய்க. இது உங்கள் தனிப்பட்ட தகவலுடன் ஒரு POST கோரிக்கையை சேவையகத்திற்கு அனுப்புகிறது. சேவையகம் இந்தத் தகவலைப் பெற்று, செயலாக்குகிறது மற்றும் சில பதிலை வழங்குகிறது (உதாரணமாக, உங்கள் சுயவிவரத்துடன் கூடிய HTML பக்கம்). அவற்றுக்கிடையேயான முக்கிய வேறுபாடு என்னவென்றால், GET கோரிக்கைகள் சேவையகத்திலிருந்து தரவை மீட்டெடுக்க மட்டுமே பயன்படுத்தப்படுகின்றன, அதே சமயம் POST கோரிக்கைகள் சில தகவல்களைக் கொண்டுள்ளன (மேலும் சேவையகத்தில் உள்ள தரவு மாறலாம்). எடுத்துக்காட்டாக, நீங்கள் உங்கள் படத்தை சர்வரில் பதிவேற்றும் போது, அது ஒரு POST கோரிக்கையில் கொண்டு செல்லப்பட்டு, சர்வர் அதை தரவுத்தளத்தில் சேர்க்கிறது, அதாவது ஒரு மாற்றம் ஏற்படுகிறது. இப்போது மீண்டும் டாம்கேட்டிற்கு. வாடிக்கையாளரிடமிருந்து கோரிக்கையைப் பெறும்போது, அது முகவரியைப் பார்க்கிறது. அந்த முகவரிக்கான கோரிக்கைகளைச் செயல்படுத்த பொருத்தமான சர்வ்லெட் உள்ளதா என்பதை இது சரிபார்க்கிறது (அல்லது கிடைக்கக்கூடிய ஆதாரம் உடனடியாகத் திருப்பித் தரப்படும்). திரும்பப் பெற ஏதாவது கிடைக்கவில்லை என்றால், பின்னர் அது HTML பக்கத்தை விட 404-பிழையுடன் பதிலளிக்கிறது. ஆனால் அந்த முகவரியில் பொருத்தமான சர்வ்லெட் "உட்கார்ந்து" இருப்பதைக் கண்டால், அது கோரிக்கை வகையைப் (GET, POST அல்லது வேறு ஏதாவது) பார்த்து, இந்த வகை வினவலைக் கையாளும் முறை உள்ளதா என்று சர்வ்லெட்டிடம் கேட்கும். இந்த வகையை எவ்வாறு கையாள்வது என்று தனக்குத் தெரியாது என்று சர்வ்லெட் கூறினால், பிறகுடாம்கேட் 405 குறியீட்டை வழங்குகிறது. இது தான் எங்கள் திட்டத்தில் நடந்தது. ஆனால் பொருத்தமான சர்வ்லெட் கண்டுபிடிக்கப்பட்டு, அதற்கு பொருத்தமான முறை இருந்தால், டாம்கேட் ஒரு சர்வ்லெட் பொருளை உருவாக்கி, அதை புதிய நூலில் தொடங்கும்.(இது சொந்தமாக இயங்க அனுமதிக்கிறது), மேலும் டாம்கேட் தனது சொந்த வேலையைத் தொடர்கிறது, கோரிக்கைகளை ஏற்று அனுப்புகிறது. கூடுதலாக, Tomcat மேலும் இரண்டு பொருட்களை உருவாக்குகிறது: ஒரு HttpServletRequest (இதை நான் சுருக்கமாக "கோரிக்கை" என்று அழைப்பேன்), மற்றும் ஒரு HttpServletResponse (இதை நான் "பதில்" என்று அழைப்பேன்). இது கிளையண்டின் கோரிக்கையிலிருந்து பெறப்பட்ட எல்லா தரவையும் முதல் பொருளில் வைக்கிறது, எனவே அந்தத் தரவை அதிலிருந்து பிரித்தெடுக்க முடியும். இவை அனைத்திற்கும் பிறகு, இந்த இரண்டு பொருட்களையும் ஒரு தனி நூலில் தொடங்கப்பட்ட சர்வ்லெட்டின் பொருத்தமான முறைக்கு அனுப்புகிறது. சர்வ்லெட் தனது வேலையை முடித்து, கிளையண்டிற்கு அனுப்பத் தயாராக இருக்கும் பதிலைப் பெற்றவுடன், "நான் முடித்துவிட்டேன். எல்லாம் தயாராக உள்ளது" என்று டாம்கேட்டில் கொடியை அசைக்கிறது. டாம்கேட் பதிலைப் பெற்று வாடிக்கையாளருக்கு அனுப்புகிறது. இது டாம்கேட் கோரிக்கைகளைப் பெறவும் பதில்களை அனுப்பவும் உதவுகிறது, திசைதிருப்பப்படாமல், அனைத்து வேலைகளும் தனித்தனி நூல்களில் இயங்கும் சர்வ்லெட்டுகளால் செய்யப்படுகிறது. அதாவது நாம் சர்வ்லெட் குறியீட்டை எழுதும்போது என்ன வேலை செய்ய வேண்டும் என்பதை தீர்மானிக்கிறோம். டாம்கேட்டிற்குள்ளேயே பிரதான() முறை அமைந்திருப்பதாக நீங்கள் நினைக்கலாம் (ஆம், இது ஜாவாவில் எழுதப்பட்டுள்ளது), மேலும் நாம் டாம்காட்டை "தொடங்கும்போது", மெயின்() முறை தொடங்கப்படும்.

servlets மற்றும் JSPகளைப் பயன்படுத்தி எளிய இணைய பயன்பாட்டை உருவாக்குதல் (பகுதி 1) - 2

GET முறைகளைப் பிடிக்க மற்றும் மிக எளிமையான பதில்களை அனுப்ப சர்வ்லெட்டுகளைப் பயன்படுத்தவும்

இந்த நேரத்தில், எங்கள் சர்வ்லெட்டுகளில் பொருத்தமான முறைகள் இல்லை (GET), எனவே Tomcat 405 பிழையை வழங்குகிறது. அவற்றை உருவாக்குவோம்! HttpServlet வகுப்பு, எங்கள் சர்வ்லெட்டுகள் மரபுரிமையாக பல்வேறு முறைகளை அறிவிக்கிறது. முறைகளுக்கு குறிப்பிட்ட குறியீட்டை ஒதுக்க, நாங்கள் அவற்றை மேலெழுதுகிறோம். doGet()இந்த வழக்கில், இரண்டு சர்வ்லெட்டுகளிலும் உள்ள முறையை நாம் மேலெழுத வேண்டும் .


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

}

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


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("GET method from AddServlet");
}

ListServlet இல் இதேபோன்ற ஒன்றைச் செய்வோம், பின்னர் எங்கள் சேவையகத்தை மறுதொடக்கம் செய்வோம். நீங்கள் பார்க்க முடியும் என, எல்லாம் வேலை செய்கிறது! நீங்கள் பொத்தான்களைக் கிளிக் செய்யும் போது, நாங்கள் PrintWriter மூலம் "எழுதிய" உரையுடன் பக்கங்களைப் பெறுவீர்கள். ஆனால் பதில்களுடன் பக்கங்களை உருவாக்க நாங்கள் தயார் செய்த JSP கோப்புகள் பயன்படுத்தப்படவில்லை. ஏனென்றால் அவை ஒருபோதும் செயல்படுத்தப்படவில்லை. எங்கள் சர்வ்லெட் தானே பதிலை உருவாக்கி, இயங்குவதை முடித்து, வாடிக்கையாளருக்கு பதிலளிக்க தயாராக இருப்பதாக டாம்கேட்டிற்கு சமிக்ஞை செய்கிறது. டாம்கேட் பதிலை எடுத்து வாடிக்கையாளருக்கு திருப்பி அனுப்புகிறது.

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

கோரிக்கைப் பொருளிலிருந்து கோரிக்கை அனுப்பும் பொருளைப் பெறுகிறோம், மேலும் கட்டுப்பாட்டை மாற்ற விரும்பும் JSP பக்கத்தின் முகவரியை அனுப்புவோம்;
குறிப்பிட்ட JSP பக்கத்திற்கு கட்டுப்பாட்டை மாற்ற இந்தப் பொருளைப் பயன்படுத்துகிறோம், Tomcat இலிருந்து நாங்கள் பெற்ற கோரிக்கை மற்றும் மறுமொழி பொருள்களை அனுப்ப மறக்கவில்லை.


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}

JSP பக்கங்களின் உடல் குறிச்சொல்லில், நீங்கள் எதையாவது சேர்க்கலாம், இதன் மூலம் எந்தப் பக்கம் காட்டப்படுகிறது என்பதை நாம் தெளிவாகக் காணலாம். நீங்கள் அதைச் செய்தவுடன், சேவையகத்தை மறுதொடக்கம் செய்து சரிபார்க்கவும். பிரதான பக்கத்தில் உள்ள பொத்தான்களைக் கிளிக் செய்து, பக்கங்கள் திறக்கப்படும், அதாவது கோரிக்கைகள் சேவையகங்களுக்கு அனுப்பப்படுகின்றன. பின்னர் கட்டுப்பாடு JSP பக்கங்களுக்கு அனுப்பப்படுகிறது, அவை இப்போது வழங்கப்படுகின்றன. இப்பொழுது இத்துடன் நிறைவடைகிறது. இந்த கட்டுரையின் அடுத்த பகுதியில் , எங்கள் பயன்பாட்டின் செயல்பாட்டைப் பற்றி நாங்கள் வேலை செய்வோம்.

மேலும் வாசிப்பு:
servlets மற்றும் JSPகளைப் பயன்படுத்தி எளிய இணைய பயன்பாட்டை உருவாக்குதல் (பகுதி 2) ஜாவா சர்வ்லெட்டுகளைப் பயன்படுத்தும் உங்கள் முதல் பயன்பாடு