కథనాన్ని అర్థం చేసుకోవడానికి అవసరమైన జ్ఞానం: మీరు ఇప్పటికే ఎక్కువ లేదా తక్కువ జావా కోర్‌ని కనుగొన్నారు మరియు JavaEE సాంకేతికతలు మరియు వెబ్ ప్రోగ్రామింగ్‌లను చూడాలనుకుంటున్నారు . మీరు ప్రస్తుతం కథనానికి దగ్గరగా ఉన్న అంశాలతో వ్యవహరించే జావా కలెక్షన్స్ క్వెస్ట్‌ని అధ్యయనం చేయడం చాలా సమంజసంగా ఉంటుంది .
![సర్వ్లెట్లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 1) - 1]()
ఈ విషయం IntelliJ Idea Enterpriseలో సరళమైన వెబ్ ప్రాజెక్ట్‌ను సృష్టించడం అనే నా కథనం యొక్క తార్కిక కొనసాగింపు . ఆ వ్యాసంలో, పని చేసే వెబ్ ప్రాజెక్ట్ టెంప్లేట్‌ను ఎలా సృష్టించాలో నేను ప్రదర్శించాను. ఈసారి నేను Java Servlet API మరియు JavaServer Pages APIని ఉపయోగించి సరళమైన కానీ పూర్తిగా ఆకర్షణీయమైన వెబ్ అప్లికేషన్‌ను ఎలా సృష్టించాలో మీకు చూపుతాను . మా అప్లికేషన్ రెండు లింక్‌లతో హోమ్ పేజీని కలిగి ఉంటుంది:
ప్రారంభిద్దాం. ముందుగా, POM ఫైల్‌ను సిద్ధం చేయండి . ఎక్కడో /వెర్షన్ ఎంట్రీ తర్వాత, కానీ /ప్రాజెక్ట్ ముందు , కింది వాటిని చొప్పించండి:
![సర్వ్లెట్లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 1) - 2]()
సర్వ్‌లెట్‌ల నుండి JSP ఫైల్‌లకు నియంత్రణను పాస్ చేద్దాం. మేము మా పద్ధతుల కోడ్‌ని ఈ క్రింది విధంగా మారుస్తాము:
- వినియోగదారులను జోడించడం కోసం పేజీకి లింక్;
- వినియోగదారుల జాబితాకు లింక్.
మా భవిష్యత్ అప్లికేషన్ యొక్క నిర్మాణం గురించి కొంచెం
మా హోమ్ పేజీ (/) హెడర్ మరియు రెండు లింక్‌లు/బటన్‌లతో అత్యంత సాధారణ స్టాటిక్ HTML పేజీ అవుతుంది :- కొత్త వినియోగదారుని జోడించండి (కి నావిగేట్ చేస్తుంది / జోడించు );
- వినియోగదారుల జాబితాను వీక్షించండి (/ జాబితాకు నావిగేట్ చేస్తుంది ).
స్టాటిక్ హోమ్ పేజీని సృష్టించండి
మీరు మీ వెబ్ ఫోల్డర్‌లో 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>
ఫలితాన్ని అందించడానికి JSP ఫైల్‌లను సృష్టించండి
అదే వెబ్ డైరెక్టరీలో, మేము మా JSP ఫైల్‌లను జోడించే ఫోల్డర్‌ను సృష్టించండి . నేను దీనిని ' వీక్షణలు ' అని పిలిచాను, కానీ మరోసారి మీరు మెరుగుపరచవచ్చు. ఈ ఫోల్డర్‌లో, మేము రెండు JSP ఫైల్‌లను సృష్టిస్తాము:- add.jsp — వినియోగదారులను జోడించడానికి ఒక పేజీ;
- list.jsp — వినియోగదారుల జాబితాను ప్రదర్శించడానికి పేజీ.
రెండు సర్వ్లెట్లను సృష్టించండి
సర్వ్లెట్లు టామ్‌క్యాట్ పంపే అభ్యర్థనలను స్వీకరిస్తాయి మరియు ప్రాసెస్ చేస్తాయి . src /main/java ఫోల్డర్‌లో, యాప్ ప్యాకేజీని సృష్టించండి , అక్కడ మేము మా సోర్స్ కోడ్‌ను ఉంచుతాము. ఇతర ప్యాకేజీలు కూడా అక్కడికి వెళ్తాయి. కాబట్టి, ఈ ప్యాకేజీలు ఒకదానికొకటి సృష్టించబడకుండా నిరోధించడానికి, మేము యాప్ ప్యాకేజీలో కొంత తరగతిని సృష్టిస్తాము (మేము దానిని తర్వాత తొలగిస్తాము). ఇప్పుడు యాప్ ప్యాకేజీలో మూడు విభిన్న ప్యాకేజీలను సృష్టించండి :- ఎంటిటీలు — మా ఎంటిటీలు (వినియోగదారు వస్తువులను వివరించే తరగతి) ఇక్కడకు వెళ్తాయి;
- మోడల్ - ఇక్కడే మా మోడల్ వెళుతుంది (దీని గురించి కొంచెం తరువాత మాట్లాడుతాము);
- సర్వ్లెట్లు - మరియు ఇక్కడే మా సర్వ్లెట్లు వెళ్తాయి.
- AddServlet — పంపిన అభ్యర్థనలను ప్రాసెస్ చేస్తుంది / జోడించు ;
- ListServlet — / జాబితాకు పంపిన అభ్యర్థనలను ప్రాసెస్ చేస్తుంది .
మావెన్‌లో డిపెండెన్సీలను కనెక్ట్ చేస్తోంది
టామ్‌క్యాట్ 9 .* సర్వ్లెట్ 4.0 మరియు జావా సర్వర్ పేజీలు 2.3 కోసం స్పెసిఫికేషన్‌లను అమలు చేస్తుంది . టామ్‌క్యాట్ 9 యొక్క అధికారిక డాక్యుమెంటేషన్‌లోని మొదటి పేరాలోని రెండవ పంక్తిలో పేర్కొన్నది అదే . దీని అర్థం మీరు, నాలాగే, టామ్‌క్యాట్ యొక్క ఈ సంస్కరణను ఉపయోగిస్తే , మీరు వ్రాసే మరియు అమలు చేసే కోడ్ ఈ సంస్కరణలను ఉపయోగిస్తుంది. కానీ మేము మా ప్రాజెక్ట్‌లో ఈ స్పెసిఫికేషన్‌లను కలిగి ఉండాలనుకుంటున్నాము, తద్వారా వాటిని ఉపయోగించే మా కోడ్ కనీసం విజయవంతంగా కంపైల్ చేస్తుంది. మరియు దీన్ని చేయడానికి, మేము వాటిని మా ప్రాజెక్ట్‌లోకి లోడ్ చేయాలి. ఇక్కడే మావెన్ రక్షించటానికి వస్తాడు.|
సాధారణ నియమం ఇది: మీరు మావెన్‌ని ఉపయోగించి మీ ప్రాజెక్ట్‌కి ఏదైనా కనెక్ట్ చేయవలసి వస్తే:
|
<dependencies>
</dependencies>
<?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>
<?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>
చిన్న డైగ్రెషన్: "అండర్ ది హుడ్" ఏమి జరుగుతుంది?
టామ్‌క్యాట్‌లో మా అప్లికేషన్ ఎలా పని చేస్తుందో మీరు బహుశా ఇప్పటికే ఆలోచించి ఉండవచ్చు. అక్కడ ఏం జరుగుతుంది? మరియు ప్రధాన () పద్ధతి ఎక్కడ ఉంది? మీరు మీ బ్రౌజర్‌లో localhost:8080కి వెళ్లిన వెంటనే, బ్రౌజర్ HTTP ప్రోటోకాల్‌ని ఉపయోగించి ఈ చిరునామాకు అభ్యర్థనను పంపుతుంది. అనేక రకాల అభ్యర్థనలు ఉన్నాయని మరియు అత్యంత జనాదరణ పొందినవి GET మరియు POST అని మీకు ఇప్పటికే తెలుసునని నేను ఆశిస్తున్నాను. ప్రతి అభ్యర్థనకు సమాధానం ఇవ్వాలి. ఒక GET అభ్యర్థన బ్రౌజర్‌కు తిరిగి ఇవ్వబడిన HTML కోడ్‌ని ఉపయోగించడానికి సిద్ధంగా ఉన్న ప్రతిస్పందనను అందుకుంటుంది. బ్రౌజర్ కోడ్‌ని అన్ని అందమైన అక్షరాలు, బటన్లు మరియు ఫారమ్‌లను భర్తీ చేస్తుంది. POST అభ్యర్థన కొంచెం ఆసక్తికరంగా ఉంటుంది, ఎందుకంటే ఇది కొంత సమాచారాన్ని కూడా కలిగి ఉంటుంది. ఉదాహరణకు, మీరు వెబ్‌సైట్‌లో రిజిస్ట్రేషన్ లేదా సైన్-ఇన్ ఫారమ్‌లో ఆధారాలను నమోదు చేసి, "పంపు" క్లిక్ చేయండి. దీని వలన మీ వ్యక్తిగత సమాచారంతో POST అభ్యర్థన సర్వర్‌కు పంపబడుతుంది. సర్వర్ ఈ సమాచారాన్ని అందుకుంటుంది, ప్రాసెస్ చేస్తుంది మరియు కొంత ప్రతిస్పందనను అందిస్తుంది (ఉదాహరణకు, మీ ప్రొఫైల్‌తో కూడిన HTML పేజీ). వాటి మధ్య ఉన్న ప్రధాన వ్యత్యాసం ఏమిటంటే, GET అభ్యర్థనలు సర్వర్ నుండి డేటాను తిరిగి పొందడానికి మాత్రమే ఉపయోగించబడతాయి, అయితే POST అభ్యర్థనలు కొంత సమాచారాన్ని కలిగి ఉంటాయి (మరియు సర్వర్‌లోని డేటా మారవచ్చు). ఉదాహరణకు, మీరు మీ చిత్రాన్ని సర్వర్‌కి అప్‌లోడ్ చేసినప్పుడు, అది POST అభ్యర్థనలో అక్కడకు తీసుకువెళుతుంది మరియు సర్వర్ దానిని డేటాబేస్‌కు జోడిస్తుంది, అనగా మార్పు సంభవిస్తుంది. ఇప్పుడు తిరిగి టామ్‌క్యాట్‌కి. ఇది క్లయింట్ నుండి అభ్యర్థనను స్వీకరించినప్పుడు, అది చిరునామాను చూస్తుంది. ఇది ఆ చిరునామా కోసం అభ్యర్థనలను ప్రాసెస్ చేయడానికి తగిన సర్వ్లెట్ ఉందో లేదో తనిఖీ చేస్తుంది (లేదా వెంటనే తిరిగి ఇవ్వగల అందుబాటులో ఉన్న వనరు). అది తిరిగి ఇవ్వడానికి ఏదైనా కనుగొనలేకపోతే, అప్పుడు అది HTML పేజీకి బదులుగా 404-ఎర్రర్‌తో ప్రతిస్పందిస్తుంది. కానీ అది ఆ చిరునామాలో "కూర్చుని" తగిన సర్వ్‌లెట్‌ని కనుగొంటే, అది అభ్యర్థన రకాన్ని (GET, POST లేదా మరేదైనా) చూసి, ఈ రకమైన ప్రశ్నను నిర్వహించగల పద్ధతిని కలిగి ఉందా అని సర్వ్‌లెట్‌ని అడుగుతుంది. ఈ రకాన్ని ఎలా నిర్వహించాలో తనకు తెలియదని సర్వ్లెట్ చెబితే, అప్పుడుటామ్‌క్యాట్ 405 కోడ్‌ను అందిస్తుంది. మరియు ఇది మా ప్రాజెక్ట్‌లో జరిగింది. కానీ తగిన సర్వ్లెట్ కనుగొనబడి, దానికి తగిన పద్ధతి ఉంటే, టామ్‌క్యాట్ సర్వ్లెట్ ఆబ్జెక్ట్‌ను సృష్టించి, దాన్ని కొత్త థ్రెడ్‌లో ప్రారంభిస్తుంది(ఇది దాని స్వంతదానిపై అమలు చేయడానికి అనుమతిస్తుంది), మరియు టామ్‌క్యాట్ తన స్వంత పనిని కొనసాగిస్తుంది, అభ్యర్థనలను అంగీకరించడం మరియు పంపడం. అదనంగా, టామ్‌క్యాట్ మరో రెండు వస్తువులను సృష్టిస్తుంది: ఒక HttpServletRequest (దీనిని నేను సంక్షిప్తంగా "అభ్యర్థన" అని పిలుస్తాను), మరియు HttpServletResponse (దీనిని నేను "ప్రతిస్పందన" అని పిలుస్తాను). ఇది క్లయింట్ అభ్యర్థన నుండి స్వీకరించబడిన మొత్తం డేటాను మొదటి ఆబ్జెక్ట్‌లో ఉంచుతుంది, కాబట్టి ఆ డేటా మొత్తం దాని నుండి సంగ్రహించబడుతుంది. ఆపై అన్ని తరువాత, ఇది ఈ రెండు వస్తువులను ప్రత్యేక థ్రెడ్‌లో ప్రారంభించిన సర్వ్లెట్ యొక్క తగిన పద్ధతికి పంపుతుంది. సర్వ్లెట్ తన పనిని పూర్తి చేసి, క్లయింట్‌కు పంపడానికి సిద్ధంగా ఉన్న ప్రతిస్పందనను కలిగి ఉన్న వెంటనే, అది "నేను పూర్తి చేసాను. అంతా సిద్ధంగా ఉంది" అని టామ్‌క్యాట్‌పై జెండాను ఊపుతుంది. టామ్‌క్యాట్ ప్రతిస్పందనను స్వీకరిస్తుంది మరియు దానిని క్లయింట్‌కు పంపుతుంది. ఇది టామ్‌క్యాట్ అభ్యర్థనలను స్వీకరించడానికి మరియు ప్రతిస్పందనలను పంపడానికి అనుమతిస్తుంది, పరధ్యానం చెందకుండా, మరియు అన్ని పనిని ప్రత్యేక థ్రెడ్‌లపై నడుస్తున్న సర్వ్లెట్లు చేస్తాయి. అంటే మనం సర్వ్లెట్ కోడ్‌ను వ్రాసినప్పుడు ఏ పనిని నిర్వహించాలో నిర్ణయిస్తాము. మరియు మీరు ప్రధాన() పద్ధతిని టామ్‌క్యాట్‌లోనే ఉన్నట్లు భావించవచ్చు (అవును, ఇది జావాలో వ్రాయబడింది), మరియు మేము టామ్‌క్యాట్‌ను "లాంచ్" చేసినప్పుడు, మెయిన్() పద్ధతి ప్రారంభించబడుతుంది.
GET పద్ధతులను క్యాచ్ చేయడానికి మరియు సూపర్ సింపుల్ ప్రతిస్పందనలను పంపడానికి సర్వ్లెట్లను ఉపయోగించండి
ప్రస్తుతానికి, మా సర్వ్‌లెట్‌లకు తగిన పద్ధతులు లేవు (GET), కాబట్టి Tomcat 405 ఎర్రర్‌ను అందిస్తుంది. వాటిని సృష్టిద్దాం! HttpServlet తరగతి, మేము మా సర్వ్లెట్లు వారసత్వంగా పొందుతాము, వివిధ పద్ధతులను ప్రకటిస్తుంది. పద్ధతులకు నిర్దిష్ట కోడ్‌ని కేటాయించడానికి, మేము వాటిని భర్తీ చేస్తాము.doGet()ఈ సందర్భంలో, మేము రెండు సర్వ్‌లెట్‌లలోని పద్ధతిని భర్తీ చేయాలి .
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
PrintWriter writer = resp.getWriter();
writer.println("GET method from AddServlet");
}
- మేము అభ్యర్థన ఆబ్జెక్ట్ నుండి అభ్యర్థన డిస్పాచర్ ఆబ్జెక్ట్‌ను పొందుతాము మరియు మేము నియంత్రణను బదిలీ చేయాలనుకుంటున్న JSP పేజీ యొక్క చిరునామాను పాస్ చేస్తాము;
- మేము టామ్‌క్యాట్ నుండి స్వీకరించిన అభ్యర్థన మరియు ప్రతిస్పందన వస్తువులను పాస్ చేయడం మర్చిపోకుండా, పేర్కొన్న JSP పేజీకి నియంత్రణను బదిలీ చేయడానికి ఈ వస్తువును ఉపయోగిస్తాము.
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
requestDispatcher.forward(req, resp);
}
GO TO FULL VERSION