వ్యాసం
ప్రారంభించండి
నేర్చుకోవడం ప్రారంభించండి
CodeGym /జావా బ్లాగ్ /యాదృచ్ఛికంగా /సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లి...
John Squirrels
స్థాయి
San Francisco

సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 1)

సమూహంలో ప్రచురించబడింది
కథనాన్ని అర్థం చేసుకోవడానికి అవసరమైన జ్ఞానం: మీరు ఇప్పటికే ఎక్కువ లేదా తక్కువ జావా కోర్‌ని కనుగొన్నారు మరియు JavaEE సాంకేతికతలు మరియు వెబ్ ప్రోగ్రామింగ్‌లను చూడాలనుకుంటున్నారు . మీరు ప్రస్తుతం కథనానికి దగ్గరగా ఉన్న అంశాలతో వ్యవహరించే జావా కలెక్షన్స్ క్వెస్ట్‌ని అధ్యయనం చేయడం చాలా సమంజసంగా ఉంటుంది .
సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 1) - 1
ఈ విషయం 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-ఎర్రర్ పేజీలను పొందుతారు, ఎందుకంటే మాకు సంబంధిత పేజీలు ఇంకా లేవు. కానీ బటన్లు పనిచేస్తాయని మేము చెప్పగలం. ఇది అత్యంత సార్వత్రిక విధానం కాదని గమనించండి: బ్రౌజర్‌లో జావాస్క్రిప్ట్ ఆఫ్ చేయబడితే, ఈ బటన్‌లు పని చేయవు. కానీ ఎవరూ జావాస్క్రిప్ట్‌ని డిసేబుల్ చేయరని మేము అనుకుంటాము. :) సహజంగానే, మీరు సాధారణ లింక్‌లతో పొందవచ్చు, కానీ నేను బటన్‌లను ఇష్టపడతాను. మీకు నచ్చిన విధంగా మీరు దీన్ని చేయవచ్చు. మరియు నా ఉదాహరణలలో చాలా divలు ఉంటాయి అనే వాస్తవం గురించి చింతించకండి . మేము వాటిని తర్వాత స్టైల్స్‌తో నింపుతాము మరియు ప్రతిదీ మరింత అందంగా కనిపిస్తుంది. :)

ఫలితాన్ని అందించడానికి JSP ఫైల్‌లను సృష్టించండి

అదే వెబ్ డైరెక్టరీలో, మేము మా JSP ఫైల్‌లను జోడించే ఫోల్డర్‌ను సృష్టించండి . నేను దీనిని ' వీక్షణలు ' అని పిలిచాను, కానీ మరోసారి మీరు మెరుగుపరచవచ్చు. ఈ ఫోల్డర్‌లో, మేము రెండు JSP ఫైల్‌లను సృష్టిస్తాము:
  • add.jsp — వినియోగదారులను జోడించడానికి ఒక పేజీ;
  • list.jsp — వినియోగదారుల జాబితాను ప్రదర్శించడానికి పేజీ.
Java university
వారికి తగిన పేజీ శీర్షికలను కేటాయించండి. " కొత్త వినియోగదారుని జోడించు " మరియు " వినియోగదారు జాబితా " వంటివి , మరియు మేము దానిని అలాగే వదిలివేస్తాము.

రెండు సర్వ్లెట్లను సృష్టించండి

సర్వ్‌లెట్‌లు టామ్‌క్యాట్ పంపే అభ్యర్థనలను స్వీకరిస్తాయి మరియు ప్రాసెస్ చేస్తాయి . src /main/java ఫోల్డర్‌లో, యాప్ ప్యాకేజీని సృష్టించండి , అక్కడ మేము మా సోర్స్ కోడ్‌ను ఉంచుతాము. ఇతర ప్యాకేజీలు కూడా అక్కడికి వెళ్తాయి. కాబట్టి, ఈ ప్యాకేజీలు ఒకదానికొకటి సృష్టించబడకుండా నిరోధించడానికి, మేము యాప్ ప్యాకేజీలో కొంత తరగతిని సృష్టిస్తాము (మేము దానిని తర్వాత తొలగిస్తాము). ఇప్పుడు యాప్ ప్యాకేజీలో మూడు విభిన్న ప్యాకేజీలను సృష్టించండి :
  • ఎంటిటీలు — మా ఎంటిటీలు (వినియోగదారు వస్తువులను వివరించే తరగతి) ఇక్కడకు వెళ్తాయి;
  • మోడల్ - ఇక్కడే మా మోడల్ వెళుతుంది (దీని గురించి కొంచెం తరువాత మాట్లాడుతాము);
  • సర్వ్లెట్లు - మరియు ఇక్కడే మా సర్వ్లెట్లు వెళ్తాయి.
మీరు దీన్ని పూర్తి చేసిన తర్వాత, మీరు యాప్ ప్యాకేజీ నుండి ఆ తరగతిని ప్రశాంతంగా తొలగించవచ్చు (మీరు దీన్ని సృష్టించినట్లయితే). సర్వ్లెట్ ప్యాకేజీలో , రెండు తరగతులను సృష్టించండి:
  • AddServlet — పంపిన అభ్యర్థనలను ప్రాసెస్ చేస్తుంది / జోడించు ;
  • ListServlet — / జాబితాకు పంపిన అభ్యర్థనలను ప్రాసెస్ చేస్తుంది .

మావెన్‌లో డిపెండెన్సీలను కనెక్ట్ చేస్తోంది

టామ్‌క్యాట్ 9 .* సర్వ్లెట్ 4.0 మరియు జావా సర్వర్ పేజీలు 2.3 కోసం స్పెసిఫికేషన్‌లను అమలు చేస్తుంది . టామ్‌క్యాట్ 9 యొక్క అధికారిక డాక్యుమెంటేషన్‌లోని మొదటి పేరాలోని రెండవ పంక్తిలో పేర్కొన్నది అదే . దీని అర్థం మీరు, నాలాగే, టామ్‌క్యాట్ యొక్క ఈ సంస్కరణను ఉపయోగిస్తే , మీరు వ్రాసే మరియు అమలు చేసే కోడ్ ఈ సంస్కరణలను ఉపయోగిస్తుంది. కానీ మేము మా ప్రాజెక్ట్‌లో ఈ స్పెసిఫికేషన్‌లను కలిగి ఉండాలనుకుంటున్నాము, తద్వారా వాటిని ఉపయోగించే మా కోడ్ కనీసం విజయవంతంగా కంపైల్ చేస్తుంది. మరియు దీన్ని చేయడానికి, మేము వాటిని మా ప్రాజెక్ట్‌లోకి లోడ్ చేయాలి. ఇక్కడే మావెన్ రక్షించటానికి వస్తాడు.

సాధారణ నియమం ఇది: మీరు మావెన్‌ని ఉపయోగించి మీ ప్రాజెక్ట్‌కి ఏదైనా కనెక్ట్ చేయవలసి వస్తే:

  • మావెన్ నుండి రిపోజిటరీ వెబ్‌సైట్‌కి వెళ్లండి;
  • అవసరమైన లైబ్రరీ యొక్క అవసరమైన సంస్కరణను కనుగొనండి;
  • మీ pom.xmlలో అతికించవలసిన డిపెండెన్సీ కోడ్‌ని పొందండి;
  • అతికించండి! :)
ప్రారంభిద్దాం. ముందుగా, POM ఫైల్‌ను సిద్ధం చేయండి . ఎక్కడో /వెర్షన్ ఎంట్రీ తర్వాత, కానీ /ప్రాజెక్ట్ ముందు , కింది వాటిని చొప్పించండి: 

<dependencies>

</dependencies>
మేము ఈ ట్యాగ్‌లలో అవసరమైన డిపెండెన్సీలను జాబితా చేస్తామని సూచించడానికి దీన్ని చేస్తాము. ఇప్పుడు mvnrepository.com కి వెళ్లండి . ఎగువన శోధన ఫీల్డ్ ఉంది. ప్రారంభించడానికి, ' servlet ' కోసం శోధించండి. ఏడు వేల కంటే ఎక్కువ సార్లు ఉపయోగించబడిన మొదటి ఫలితం మనకు సరిపోతుంది. గుర్తుంచుకోండి, మనకు వెర్షన్ 4.0 ( టామ్‌క్యాట్ 9 కోసం) ఇతర సంస్కరణలు పాత అమలులకు తగినవి కావచ్చు. ఇది చాలా ఇటీవలి వెర్షన్, కాబట్టి ఎక్కువ ఉపయోగాలు లేవు. కానీ మాకు అది కావాలి. మీరు వివిధ ప్యాకేజీ నిర్వాహకుల కోసం ఈ డిపెండెన్సీ కోసం కోడ్‌ను పొందగలిగే పేజీ తెరవబడుతుంది లేదా మీరు దీన్ని డౌన్‌లోడ్ చేసుకోవచ్చు. కానీ మేము దీన్ని మావెన్‌ని ఉపయోగించి కనెక్ట్ చేయాలనుకుంటున్నాము కాబట్టి, మేము మావెన్ ట్యాబ్‌లో కోడ్‌ని ఎంచుకుంటాము. మేము మా POM ఫైల్ యొక్క డిపెండెన్సీ విభాగంలోకి కాపీ చేసి పేస్ట్ చేస్తాము. మీరు IDEA యొక్క కుడి దిగువ మూలలో స్వీయ-దిగుమతిని ప్రారంభించాలనుకుంటున్నారా అని అడిగే నోటిఫికేషన్ మీకు వచ్చినట్లయితే , ముందుకు సాగండి మరియు దానికి అంగీకరించండి. మీరు అనుకోకుండా తిరస్కరించినట్లయితే, " సెట్టింగ్‌లు "కి వెళ్లి, స్వీయ-దిగుమతి మాన్యువల్‌గా ఆన్ చేయండి: సెట్టింగ్‌లు (Ctrl + Alt + S) -> బిల్డ్, ఎగ్జిక్యూషన్, డిప్లాయ్‌మెంట్ -> మావెన్ -> దిగుమతి .మరియు ఈ ప్రాజెక్ట్ కోసం IDEA కాన్ఫిగరేషన్ ఫైల్‌లు సమకాలీకరించబడ్డాయి. అదే సూత్రాన్ని అనుసరించి, మేము JavaServer పేజీలు 2.3 ("JSP" కోసం శోధించండి) కనుగొని కనెక్ట్ చేస్తాము. మరియు మేము ఇప్పటికే మావెన్‌ను ప్రారంభించాము కాబట్టి, మన సోర్స్ ఫైల్‌లు జావా 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>

మా సర్వ్‌లెట్‌లను నిజమైన సర్వ్‌లెట్‌లుగా మార్చండి

ప్రస్తుతానికి, మేము సృష్టించిన సర్వ్‌లెట్‌ల జత వాస్తవానికి సాధారణ తరగతులు. వాటికి ఎలాంటి కార్యాచరణ లేదు. కానీ ఇప్పుడు మేము మా ప్రాజెక్ట్‌కి సర్వ్లెట్ APIని కనెక్ట్ చేసాము మరియు తదనుగుణంగా మేము దాని తరగతులను ఉపయోగించవచ్చు. మా సర్వ్‌లెట్‌లను "వాస్తవికంగా" చేయడానికి, మనం చేయాల్సిందల్లా వాటిని 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>
మీరు చూడగలిగినట్లుగా, సర్వ్లెట్-పేరు రెండు సందర్భాల్లోనూ ఒకే విధంగా ఉంటుంది. ఫలితంగా, /జోడించడానికి అభ్యర్థన వస్తే, అది తప్పనిసరిగా app.servlets.AddServletకి పంపబడుతుందని టామ్‌క్యాట్‌కు తెలుసు. మేము రెండవ సర్వ్లెట్తో అదే పని చేస్తాము. చివరికి, మా 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 కోడ్‌ను అందిస్తుంది. మరియు ఇది మా ప్రాజెక్ట్‌లో జరిగింది. కానీ తగిన సర్వ్లెట్ కనుగొనబడి, దానికి తగిన పద్ధతి ఉంటే, టామ్‌క్యాట్ సర్వ్లెట్ ఆబ్జెక్ట్‌ను సృష్టించి, దాన్ని కొత్త థ్రెడ్‌లో ప్రారంభిస్తుంది(ఇది దాని స్వంతదానిపై అమలు చేయడానికి అనుమతిస్తుంది), మరియు టామ్‌క్యాట్ తన స్వంత పనిని కొనసాగిస్తుంది, అభ్యర్థనలను అంగీకరించడం మరియు పంపడం. అదనంగా, టామ్‌క్యాట్ మరో రెండు వస్తువులను సృష్టిస్తుంది: ఒక HttpServletRequest (దీనిని నేను సంక్షిప్తంగా "అభ్యర్థన" అని పిలుస్తాను), మరియు HttpServletResponse (దీనిని నేను "ప్రతిస్పందన" అని పిలుస్తాను). ఇది క్లయింట్ అభ్యర్థన నుండి స్వీకరించబడిన మొత్తం డేటాను మొదటి ఆబ్జెక్ట్‌లో ఉంచుతుంది, కాబట్టి ఆ డేటా మొత్తం దాని నుండి సంగ్రహించబడుతుంది. ఆపై అన్ని తరువాత, ఇది ఈ రెండు వస్తువులను ప్రత్యేక థ్రెడ్‌లో ప్రారంభించిన సర్వ్‌లెట్ యొక్క తగిన పద్ధతికి పంపుతుంది. సర్వ్లెట్ తన పనిని పూర్తి చేసి, క్లయింట్‌కు పంపడానికి సిద్ధంగా ఉన్న ప్రతిస్పందనను కలిగి ఉన్న వెంటనే, అది "నేను పూర్తి చేసాను. అంతా సిద్ధంగా ఉంది" అని టామ్‌క్యాట్‌పై జెండాను ఊపుతుంది. టామ్‌క్యాట్ ప్రతిస్పందనను స్వీకరిస్తుంది మరియు దానిని క్లయింట్‌కు పంపుతుంది. ఇది టామ్‌క్యాట్ అభ్యర్థనలను స్వీకరించడానికి మరియు ప్రతిస్పందనలను పంపడానికి అనుమతిస్తుంది, పరధ్యానం చెందకుండా, మరియు అన్ని పనిని ప్రత్యేక థ్రెడ్‌లపై నడుస్తున్న సర్వ్‌లెట్‌లు చేస్తాయి. అంటే మనం సర్వ్‌లెట్ కోడ్‌ను వ్రాసినప్పుడు ఏ పనిని నిర్వహించాలో నిర్ణయిస్తాము. మరియు మీరు ప్రధాన() పద్ధతిని టామ్‌క్యాట్‌లోనే ఉన్నట్లు భావించవచ్చు (అవును, ఇది జావాలో వ్రాయబడింది), మరియు మేము టామ్‌క్యాట్‌ను "లాంచ్" చేసినప్పుడు, మెయిన్() పద్ధతి ప్రారంభించబడుతుంది. సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 1) - 2
Java webinar

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లో ఇదే విధమైన పనిని చేస్తాము, ఆపై మేము మా సర్వర్‌ని పునఃప్రారంభిస్తాము. మీరు గమనిస్తే, ప్రతిదీ పనిచేస్తుంది! మీరు బటన్‌లపై క్లిక్ చేసినప్పుడు, మేము ప్రింట్‌రైటర్‌తో "వ్రాసిన" టెక్స్ట్‌తో కూడిన పేజీలను మీరు పొందుతారు. కానీ ప్రతిస్పందనలతో పేజీలను రూపొందించడానికి మేము సిద్ధం చేసిన JSP ఫైల్‌లు ఉపయోగించబడవు. ఎందుకంటే అవి ఎప్పుడూ అమలు చేయబడవు. మా సర్వ్లెట్ ప్రతిస్పందనను స్వయంగా సృష్టించి, రన్నింగ్‌ను పూర్తి చేస్తుంది, క్లయింట్‌కు ప్రతిస్పందించడానికి సిద్ధంగా ఉందని టామ్‌క్యాట్‌కి సంకేతం ఇస్తుంది. టామ్‌క్యాట్ ప్రతిస్పందనను తీసుకుంటుంది మరియు దానిని క్లయింట్‌కు తిరిగి పంపుతుంది. సర్వ్‌లెట్‌ల నుండి JSP ఫైల్‌లకు నియంత్రణను పాస్ చేద్దాం. మేము మా పద్ధతుల కోడ్‌ని ఈ క్రింది విధంగా మారుస్తాము:
  • మేము అభ్యర్థన ఆబ్జెక్ట్ నుండి అభ్యర్థన డిస్పాచర్ ఆబ్జెక్ట్‌ను పొందుతాము మరియు మేము నియంత్రణను బదిలీ చేయాలనుకుంటున్న JSP పేజీ యొక్క చిరునామాను పాస్ చేస్తాము;
  • మేము టామ్‌క్యాట్ నుండి స్వీకరించిన అభ్యర్థన మరియు ప్రతిస్పందన వస్తువులను పాస్ చేయడం మర్చిపోకుండా, పేర్కొన్న JSP పేజీకి నియంత్రణను బదిలీ చేయడానికి ఈ వస్తువును ఉపయోగిస్తాము.

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}
JSP పేజీల బాడీ ట్యాగ్‌లో, మీరు ఏదైనా జోడించవచ్చు, తద్వారా ఏ పేజీ ప్రదర్శించబడుతుందో మేము స్పష్టంగా చూడగలము. మీరు దాన్ని పూర్తి చేసిన తర్వాత, సర్వర్‌ని పునఃప్రారంభించి, తనిఖీ చేయండి. మేము ప్రధాన పేజీలోని బటన్‌లను క్లిక్ చేస్తాము మరియు పేజీలు తెరవబడతాయి, అంటే అభ్యర్థనలు సర్వ్‌లెట్‌లకు పంపబడుతున్నాయి. అప్పుడు నియంత్రణ JSP పేజీలకు పంపబడుతుంది, అవి ఇప్పుడు రెండర్ చేయబడుతున్నాయి. ఇప్పటికి ఇంతే. ఈ కథనం యొక్క తదుపరి భాగంలో , మేము మా అప్లికేషన్ యొక్క కార్యాచరణపై పని చేస్తాము.

మరింత పఠనం:
వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION