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

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

సమూహంలో ప్రచురించబడింది
సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి సరళమైన వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 1) కథనాన్ని అర్థం చేసుకోవడానికి అవసరమైన జ్ఞానం: మీరు ఇప్పటికే జావా కోర్‌ని ఎక్కువ లేదా తక్కువ కనుగొన్నారు మరియు JavaEE సాంకేతికతలు మరియు వెబ్ ప్రోగ్రామింగ్‌లను చూడాలనుకుంటున్నారు. మీరు ప్రస్తుతం కథనానికి దగ్గరగా ఉన్న అంశాలతో వ్యవహరించే జావా సేకరణల అన్వేషణను అధ్యయనం చేయడం చాలా సమంజసమైనది.
సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 2) - 1

ఎంటిటీలను సృష్టిస్తోంది

ఎంటిటీల ప్యాకేజీలో , మేము Userరెండు ప్రైవేట్ స్ట్రింగ్ వేరియబుల్‌లను కలిగి ఉన్న తరగతిని సృష్టిస్తాము : పేరు మరియు పాస్‌వర్డ్ . కన్స్ట్రక్టర్‌లను (డిఫాల్ట్ మరియు రెండు విలువలను తీసుకునే ఒకటి) మరియు గెట్టర్‌లు/సెట్టర్‌లను సృష్టించండి మరియు పద్దతి మరియు పద్ధతులతో toString()పాటు పద్ధతిని భర్తీ చేయండి . మరో మాటలో చెప్పాలంటే, తరగతిని సృష్టించేటప్పుడు గౌరవనీయమైన జావా డెవలపర్ చేసే ప్రతిదాన్ని మేము చేస్తాము. equals()hashCode() 

public class User {
    private String name;
    private String password;

    public User() {
    }

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (name != null ? !name.equals(user.name) : user.name != null) return false;
        return password != null ? password.equals(user.password) : user.password == null;

    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (password != null ? password.hashCode() : 0);
        return result;
    }
}
ఇప్పుడు మనం వినియోగదారుల జాబితాను సృష్టించడం ప్రారంభించవచ్చు. మేము దీనికి వినియోగదారులను జోడిస్తాము మరియు వాటిని ప్రదర్శించడానికి దాని నుండి వినియోగదారులను తీసుకుంటాము. అయితే, మాకు ఒక సమస్య ఉంది. మేము మా సర్వ్లెట్ వస్తువులను సృష్టించము. టామ్‌క్యాట్ మన కోసం దీన్ని చేస్తుంది. వాటిలో మేము భర్తీ చేసే పద్ధతులు ఇప్పటికే మాకు నిర్వచించబడ్డాయి మరియు మేము పారామితులను చేయలేము. అలాంటప్పుడు మన రెండు సర్వ్‌లెట్‌లలో కనిపించే భాగస్వామ్య జాబితాను ఎలా సృష్టించాలి? మేము ప్రతి సర్వ్‌లెట్‌లో జాబితా ఆబ్జెక్ట్‌ను సృష్టించినట్లయితే, మేము ఒక జాబితాకు వినియోగదారులను జోడిస్తాము, కానీ ListServletలో మరొకరి నుండి వినియోగదారులను ప్రదర్శిస్తాము .. కాబట్టి మనకు రెండు సర్వ్‌లెట్‌ల ద్వారా భాగస్వామ్యం చేయబడిన వస్తువు అవసరం. సాధారణంగా చెప్పాలంటే, మా ప్రోగ్రామ్‌లోని అన్ని తరగతుల ద్వారా భాగస్వామ్యం చేయబడిన ఒక వస్తువు అవసరం: మొత్తం ప్రోగ్రామ్‌కు ఒక వస్తువు. మీరు డిజైన్ నమూనాల గురించి ఏదైనా విన్నారని నేను ఆశిస్తున్నాను. కొంతమంది వ్యక్తులకు, వారి ప్రోగ్రామ్‌లో సింగిల్‌టన్ నమూనా కోసం ఇది మొదటి నిజమైన అవసరం కావచ్చు . మీరు రెట్టింపు చెక్‌లు మరియు సింక్రొనైజేషన్‌తో కొన్ని స్వీట్ సింగిల్‌టన్‌ను బయటకు తీయవచ్చు (అవును, మా అప్లికేషన్ మల్టీథ్రెడ్ చేయబడింది, ఎందుకంటే టామ్‌క్యాట్ సర్వ్‌లెట్‌లు ప్రత్యేక థ్రెడ్‌లపై నడుస్తాయి). కానీ నేను ప్రారంభ ప్రారంభ సాంకేతికతను ఉపయోగించబోతున్నాను, ఎందుకంటే ఇక్కడ మా ప్రయోజనాల కోసం ఇది పూర్తిగా సరిపోతుంది.

ఒక నమూనాను సృష్టిస్తోంది

మోడల్ ప్యాకేజీలో తరగతిని సృష్టించండి (మరియు సింగిల్టన్ నమూనాను అమలు చేయండి) మరియు దానిని అసాధారణమైనదిగా పిలవండి. ఉదాహరణకు, మోడల్ . మేము మా తరగతిలోని వినియోగదారుల యొక్క ప్రైవేట్ జాబితాను సృష్టిస్తాము మరియు రెండు పద్ధతులను అమలు చేస్తాము: ఒకటి వినియోగదారుని జోడించడానికి మరియు మరొకటి స్ట్రింగ్‌ల జాబితాను (యూజర్ పేర్లు) అందించడానికి. మా వినియోగదారు ఆబ్జెక్ట్ వినియోగదారు పేరు మరియు పాస్‌వర్డ్‌ను కలిగి ఉన్నందున మరియు మేము వినియోగదారు పాస్‌వర్డ్‌లను బహిర్గతం చేయకూడదనుకుంటున్నందున, మా వద్ద పేర్ల జాబితా మాత్రమే ఉంటుంది. 

public class Model {
    private static Model instance = new Model();

    private List<User> model;

    public static Model getInstance() {
        return instance;
    }

    private Model() {
        model = new ArrayList<>();
    }

    public void add(User user) {
        model.add(user);
    }

    public List<String> list() {
        return model.stream()
                .map(User::getName)
                .collect(Collectors.toList());
    }
}

MVC గురించి కొంచెం

మీరు ఇప్పటికే సింగిల్టన్ గురించి విన్నారు కాబట్టి , మీరు బహుశా మరొక డిజైన్ నమూనా మోడల్-వ్యూ-కంట్రోలర్ (MVC) గురించి విన్నారు. వీక్షణ నుండి వ్యాపార తర్కాన్ని వేరు చేయడం దీని ఉద్దేశ్యం. అంటే, అంశాలను ఎలా ప్రదర్శించాలో నిర్ణయించే కోడ్ నుండి ఏమి చేయాలో నిర్ణయించే కోడ్‌ను వేరు చేయడం. డేటా ఎలా ప్రదర్శించబడుతుందనే దానికి వీక్షణ బాధ్యత వహిస్తుంది . మా విషయంలో, వీక్షణలు మా JSP పేజీలు . అందుకే నేను వాటిని వీక్షణలు అనే ఫోల్డర్‌లో ఉంచాను . మోడల్ అనేది ప్రోగ్రామ్ వాస్తవానికి పని చేసే డేటా. మా విషయంలో, ఇది వినియోగదారులు (వినియోగదారుల జాబితా). మరియు కంట్రోలర్లు వాటి మధ్య లింక్. వారు మోడల్ నుండి డేటాను తీసుకొని వీక్షణలకు పంపుతారు (లేదా టామ్‌క్యాట్ నుండి కొంత డేటాను పొందండి, దీన్ని ప్రాసెస్ చేసి, మోడల్‌కు పంపండి). మీరు వాటిలో మీ వ్యాపార తర్కాన్ని (ప్రోగ్రామ్ ఏమి చేయాలి) నిర్వచించండి, మోడల్ లేదా వీక్షణలో కాదు. అందువలన, ప్రతి భాగం దాని స్వంత వ్యాపారాన్ని నిర్వహిస్తుంది:
Java university
  • మోడల్ డేటాను నిల్వ చేస్తుంది;
  • వీక్షణలు డేటా యొక్క అందమైన ప్రాతినిధ్యాలను అందిస్తాయి;
  • కంట్రోలర్లు డేటా ప్రాసెసింగ్‌ను నిర్వహిస్తాయి.
ఇది ప్రోగ్రామ్‌ను ఒక తరగతిలోని అన్ని కోడ్‌ల క్రూరమైన కుప్పగా కాకుండా చాలా సరళంగా మరియు నిర్వహించదగినదిగా ఉండటానికి అనుమతిస్తుంది. MVC వెబ్ ప్రోగ్రామింగ్‌కు మాత్రమే సరిపోదు, అయితే ఇది ప్రత్యేకంగా ఈ ప్రాంతంలో (దాదాపు ఎల్లప్పుడూ) ఉపయోగించబడుతుంది. మా విషయంలో, సర్వ్‌లెట్‌లు కంట్రోలర్‌లుగా పనిచేస్తాయి. ఇది నమూనా యొక్క చాలా ఉపరితలం మరియు సంక్షిప్త వివరణ, కానీ MVC ఈ కథనం యొక్క ప్రధాన అంశం కాదు. ఎవరైనా మరింత తెలుసుకోవాలనుకుంటే, Google మీ స్నేహితుడు! వినియోగదారుని జోడించడం కోసం ఒక ఫారమ్‌ను సృష్టించండి. add.jsp కి ఫారమ్‌ని జోడించండి . ఇది రెండు టెక్స్ట్ ఇన్‌పుట్ ఫీల్డ్‌లను కలిగి ఉండాలి (ఒకటి సాధారణం, మరొకటి - పాస్‌వర్డ్ ఫీల్డ్) మరియు డేటాను సర్వర్‌కు పంపడానికి ఒక బటన్. 

<form method="post">
    <label>Name:
        <input type="text" name="name"><br />
    </label>

    <label>Password:
        <input type="password" name="pass"><br />
    </label>
    <button type="submit">Submit</button>
</form>
ఇక్కడ ఫారమ్ విలువ పోస్ట్‌తో మెథడ్ అట్రిబ్యూట్‌ని కలిగి ఉంది . ఈ ఫారమ్ నుండి డేటా POST అభ్యర్థనగా సర్వర్‌కు వెళ్తుందని ఇది సూచిస్తుంది . చర్య లక్షణం పేర్కొనబడలేదు, అంటే అభ్యర్థన మేము ( /add ) నుండి ఈ పేజీకి వచ్చిన అదే చిరునామాకు పంపబడుతుంది . కాబట్టి, GET అభ్యర్థనను స్వీకరించిన తర్వాత , ఈ చిరునామాకు కట్టుబడి ఉన్న మా సర్వ్లెట్ యాడ్-యూజర్ ఫారమ్‌తో JSP ని అందిస్తుంది. మరియు అది POST అభ్యర్థనను స్వీకరిస్తే , ఫారమ్ దాని డేటాను ఇక్కడకు పంపినట్లు మాకు తెలుసు (దీనిని మేము అభ్యర్థన వస్తువు నుండి సంగ్రహిస్తాముdoPost()పద్ధతి, ప్రాసెస్, మరియు పొదుపు కోసం మోడల్‌కు పాస్ చేయండి). ఇన్‌పుట్ ఫీల్డ్‌లు పేరు (యూజర్ పేర్ల కోసం లేదా పాస్‌వర్డ్‌ల కోసం పాస్ ) అనే పరామితిని కలిగి ఉండటం గమనించదగ్గ విషయం . ఇది చాలా ముఖ్యమైన అంశం. అందువల్ల, అభ్యర్థన (సర్వ్‌లెట్ లోపల) నుండి ఈ డేటాను (నమోదింపబడే వినియోగదారు పేరు మరియు పాస్‌వర్డ్) స్వీకరించడానికి, మేము ఈ పేరు మరియు పాస్ ఫీల్డ్‌లను ఉపయోగిస్తాము. కానీ తరువాత దాని గురించి మరింత. డేటాను పంపడం కోసం నా బటన్ మళ్లీ ఒక బటన్‌గా రూపొందించబడింది , ఆచారం ప్రకారం అవుట్‌పుట్ ఫీల్డ్‌గా కాదు. ఈ విధానం ఎంత విస్తృతంగా ఆమోదించబడిందో నాకు తెలియదు, కానీ ఇది నాకు పని చేస్తుంది (Chrome బ్రౌజర్).

POST అభ్యర్థనల సర్వ్లెట్ హ్యాండ్లింగ్

AddServlet కి తిరిగి వెళ్దాం . అభ్యర్థనలను పొందేందుకు మా సర్వ్‌లెట్‌ని "క్యాచ్" చేయడానికి అనుమతించడానికి , మేము HttpServletdoGet() తరగతిలోని పద్ధతిని అధిగమించామని నేను మీకు గుర్తు చేస్తున్నాను . POST అభ్యర్థనలను కూడా క్యాచ్ చేయడానికి మా సర్వ్‌లెట్‌కి బోధించడానికి , మేము తప్పనిసరిగా పద్ధతిని కూడా భర్తీ చేయాలి . మేము పని చేసే ఇలాంటి అభ్యర్థన మరియు ప్రతిస్పందన వస్తువులను టామ్‌క్యాట్ పాస్ చేస్తుంది. ప్రారంభించడానికి, ఫారమ్ ద్వారా పంపబడిన అభ్యర్థన పేరు మరియు పాస్ పారామితులను సంగ్రహించండి (మీరు ఫారమ్‌లో వేర్వేరు పేర్లను పేర్కొన్నట్లయితే, ఆ పేర్లను ఉపయోగించండి). ఆ తరువాత, అందుకున్న డేటాను ఉపయోగించి వినియోగదారు వస్తువును సృష్టించండి. అప్పుడు మేము మోడల్ వస్తువును పొందుతాము మరియు సృష్టించిన వినియోగదారుని మోడల్‌కు జోడిస్తాము. doPost() 

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String name = req.getParameter("name");
    String password = req.getParameter("pass");
    User user = new User(name, password);
    Model model = Model.getInstance();
    model.add(user);
}

వీక్షణకు డేటాను పంపడం

ListServlet కి వెళ్దాం . పద్ధతి doGet()ఇప్పటికే అమలు చేయబడింది. ఇది నియంత్రణను వీక్షణకు బదిలీ చేస్తుంది ( list.jsp ). మీకు ఇది ఇంకా లేకుంటే, AddServlet లో పద్ధతితో సారూప్యతతో దీన్ని సృష్టించండి . ఇప్పుడు మోడల్ నుండి వినియోగదారు పేర్ల జాబితాను పొందడం మరియు వాటిని వీక్షణకు పంపడం మంచిది, ఇది వాటిని అందుకుంటుంది మరియు వాటిని అందంగా ప్రదర్శిస్తుంది. దీన్ని చేయడానికి, మేము టామ్‌క్యాట్ నుండి స్వీకరించిన అభ్యర్థన వస్తువును మళ్లీ ఉపయోగిస్తాము . మనం ఈ వస్తువుకు ఒక లక్షణాన్ని జోడించవచ్చు, దానికి ఒక రకమైన పేరు పెట్టవచ్చు. నిజానికి, మనం పాస్ చేయాలనుకుంటున్న వస్తువును వీక్షణకు జోడించవచ్చు. సర్వ్లెట్ నుండి వీక్షణకు నియంత్రణను బదిలీ చేసేటప్పుడు, సర్వ్లెట్ అందుకున్న అదే అభ్యర్థన మరియు ప్రతిస్పందన వస్తువులను వీక్షిస్తాము అనే వాస్తవం కారణంగా, మేము అభ్యర్థన వస్తువుకు మా పేర్ల జాబితాను జోడించవచ్చు మరియు అభ్యర్థన నుండి మా వినియోగదారు పేర్ల జాబితాను పొందవచ్చు. దృష్టిలో వస్తువు. మేము ListServlet తరగతిని పూర్తి చేసాము , కాబట్టి నేను మొత్తం తరగతి కోడ్‌ని ఇక్కడ ప్రెజెంట్ చేస్తాను: 

package app.servlets;

import app.model.Model;

import javax.servlet.RequestDispatcher;
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 ListServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Model model = Model.getInstance();
        List<String> names = model.list();
        req.setAttribute("userNames", names);

        RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/list.jsp");
        requestDispatcher.forward(req, resp);
    }
}

JSP ఫైల్‌లలో జావా కోడ్‌ని అమలు చేస్తోంది

ఇది list.jsp ని చూడవలసిన సమయం . ListServlet దీనికి నియంత్రణను బదిలీ చేసినప్పుడు మాత్రమే ఇది అమలు చేయబడుతుంది . అదనంగా, మేము ఇప్పటికే సర్వ్‌లెట్‌లోని మోడల్ నుండి వినియోగదారు పేర్ల జాబితాను సిద్ధం చేసాము మరియు దానిని అభ్యర్థన ఆబ్జెక్ట్‌లో ఇక్కడ పంపాము. మేము పేర్ల జాబితాను కలిగి ఉన్నందున, మేము forలూప్‌ని ఉపయోగించి దానిపై పునరావృతం చేయవచ్చు మరియు ప్రతి పేరును ప్రదర్శిస్తాము. నేను ముందే చెప్పినట్లుగా, JSP ఫైల్‌లు జావా కోడ్‌ను అమలు చేయగలవు (ఇది స్టాటిక్ HTML పేజీల నుండి భిన్నంగా ఉంటుంది). కొన్ని కోడ్‌ని అమలు చేయడానికి, మనం చేయాల్సిందల్లా కింది నిర్మాణాన్ని తగిన స్థలంలో ఉంచడం: 

<!-- html code -->
<%
    // Java code
%>
<!-- html code -->
ఈ నిర్మాణంలో, మేము అనేక వేరియబుల్స్‌కు ప్రాప్యతను పొందుతాము:
  • అభ్యర్థన - మా అభ్యర్థన వస్తువు, మేము సర్వ్లెట్ నుండి ఆమోదించాము, ఇక్కడ అది కేవలం req అని పిలువబడుతుంది ;
  • ప్రతిస్పందన - ప్రతిస్పందన వస్తువు ( సర్వ్‌లెట్‌లో రెస్ప్ అని పిలుస్తారు);
  • out — ఒక JspWriter ఆబ్జెక్ట్ (ఇది ఒక సాధారణ రైటర్‌ను వారసత్వంగా పొందుతుంది), దీనిని మనం నేరుగా HTML పేజీలోనే "వ్రాయడానికి" ఉపయోగించవచ్చు . ప్రకటన out.println("హలో, వరల్డ్!") System.out.println("హలో, వరల్డ్!") కి చాలా పోలి ఉంటుంది , కానీ వాటిని గందరగోళానికి గురి చేయవద్దు!
  • out.println() HTML పేజీకి "వ్రాయుతుంది" , System.out.println సిస్టమ్ అవుట్‌పుట్ స్ట్రీమ్‌కి వ్రాస్తుంది . మీరు Java కోడ్‌తో JSP విభాగంలో System.out.println() కి కాల్ చేస్తే , మీరు ఫలితాలను టామ్‌క్యాట్ కన్సోల్‌లో చూస్తారు, కానీ పేజీలో కాదు .
మీరు JSPలో అందుబాటులో ఉన్న ఇతర వస్తువులను ఇక్కడ చూడవచ్చు . మేము సర్వ్‌లెట్ నుండి పంపబడిన పేర్ల జాబితాను పొందడానికి అభ్యర్థన ఆబ్జెక్ట్‌ని ఉపయోగించవచ్చు (మేము ఈ ఆబ్జెక్ట్‌కు సంబంధిత లక్షణాన్ని జోడించాము), మరియు ఈ పేర్లను ప్రదర్శించడానికి మేము అవుట్ ఆబ్జెక్ట్‌ని ఉపయోగిస్తాము . వాటిని ప్రదర్శిస్తాము (ప్రస్తుతానికి, సాధారణ HTML జాబితాగా): 

<ul>
    <%
        List<String> names = (List<String>) request.getAttribute("userNames");

        if (names != null && !names.isEmpty()) {
            for (String s : names) {
                out.println("<li>" + s + "</li>");
            }
        }
    %>
</ul>
మేము వినియోగదారులు ఉన్నట్లయితే మాత్రమే జాబితాను ప్రదర్శించాల్సి ఉంటే మరియు ఇంకా వినియోగదారులు ఎవరూ లేరని హెచ్చరికను ప్రదర్శిస్తే, మేము ఈ విభాగాన్ని కొద్దిగా తిరిగి వ్రాయవచ్చు: 

<%
    List<String> names = (List<String>) request.getAttribute("userNames");

    if (names != null && !names.isEmpty()) {
        out.println("<ui>");
        for (String s : names) {
            out.println("<li>" + s + "</li>");
        }
        out.println("</ui>");
    } else out.println("<p>There are no users yet!</p>");
%>
సర్వ్‌లెట్‌ల నుండి వీక్షణలకు డేటాను ఎలా పంపాలో ఇప్పుడు మాకు తెలుసు, మేము మా AddServletని మెరుగుపరచగలము, తద్వారా ఇది వినియోగదారుని విజయవంతమైన జోడింపు గురించి నోటిఫికేషన్‌ను ప్రదర్శిస్తుంది. దీన్ని చేయడానికి, పద్ధతిలో doPost(), మోడల్‌కు కొత్త వినియోగదారుని జోడించిన తర్వాత, మేము ఈ వినియోగదారు పేరును req ఆబ్జెక్ట్ యొక్క లక్షణాలకు జోడించవచ్చు మరియు నియంత్రణను తిరిగి వీక్షణకు పంపవచ్చు ( add.jsp ) . మరియు ఇప్పుడు మేము దానికి జావా కోడ్‌తో ఒక విభాగాన్ని జోడిస్తాము, అక్కడ అభ్యర్థనలో అటువంటి లక్షణం ఉందా లేదా అని మేము తనిఖీ చేస్తాము మరియు అది ఉంటే - వినియోగదారు విజయవంతంగా జోడించబడిన సందేశాన్ని మేము ప్రదర్శిస్తాము. ఈ మార్పుల తర్వాత, AddServlet యొక్క పూర్తి కోడ్ ఇలా కనిపిస్తుంది: 

package app.servlets;

import app.entities.User;
import app.model.Model;

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

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

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String name = req.getParameter("name");
        String password = req.getParameter("pass");
        User user = new User(name, password);
        Model model = Model.getInstance();
        model.add(user);

        req.setAttribute("userName", name);
        doGet(req, resp);
    }
}
ఇక్కడ, పద్ధతి ముగింపులో doPost()మేము మోడల్‌కు జోడించబడిన వినియోగదారు పేరుతో ఒక లక్షణాన్ని సృష్టిస్తాము, ఆపై doGet()మేము ప్రస్తుత అభ్యర్థన మరియు ప్రతిస్పందనను పంపే పద్ధతికి కాల్ చేస్తాము. పద్ధతి doGet()ఇప్పుడు నియంత్రణను వీక్షణకు బదిలీ చేస్తుంది, ఇది ఒక లక్షణంగా జోడించబడిన జోడించబడిన వినియోగదారు పేరుతో అభ్యర్థన వస్తువును కూడా స్వీకరిస్తుంది. ఇంకా మనం చేయాల్సింది add.jspని పరిష్కరించడం , తద్వారా అటువంటి లక్షణం లేకుంటే అది నోటిఫికేషన్‌ను ప్రదర్శిస్తుంది. add.jsp యొక్క చివరి వెర్షన్ ఇక్కడ ఉంది : 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Add new user</title>
    </head>

    <body>
        <div>
            <h1>Super app!</h1>
        </div>

        <div>
            <%
                if (request.getAttribute("userName") != null) {
                    out.println("<p>User '" + request.getAttribute("userName") + "' added!</p>");
                }
            %>
            <div>
                <div>
                    <h2>Add user</h2>
                </div>

                <form method="post">
                    <label>Name:
                        <input type="text" name="name"><br />
                    </label>
                    <label>Password:
                        <input type="password" name="pass"><br />
                    </label>
                    <button type="submit">Submit</button>
                </form>
            </div>
        </div>

        <div>
            <button onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
పేజీ బాడీ కింది వాటిని కలిగి ఉంటుంది:
  • శీర్షికతో ఒక div;
  • కంటెంట్ కోసం ఒక div కంటైనర్, ఇందులో వినియోగదారు పేరుతో ఒక లక్షణం ఉందో లేదో తనిఖీ చేస్తుంది;
  • యాడ్-యూజర్ ఫారమ్‌తో ఒక div;
  • మరియు దిగువన, హోమ్ పేజీకి తిరిగి రావడానికి బటన్‌తో కూడిన ఫుటర్.
ఇది చాలా ఎక్కువ divs లాగా అనిపించవచ్చు, కానీ మేము శైలులను జోడించినప్పుడు వాటిని తర్వాత ఉపయోగిస్తాము. list.jsp యొక్క చివరి వెర్షన్ ఇక్కడ ఉంది : 

<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Users</title>
    </head>

    <body>
        <div>
            <h1>Super app!</h1>
        </div>

        <div>
            <div>
                <div>
                    <h2>Users</h2>
                </div>
                <%
                    List<String> names = (List<String>) request.getAttribute("userNames");

                    if (names != null && !names.isEmpty()) {
                        out.println("<ui>");
                        for (String s : names) {
                            out.println("<li>" + s + "</li>");
                        }
                        out.println("</ui>");
                    } else out.println("<p>There are no users yet!</p>");
                %>
            </div>
        </div>

        <div>
            <button onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
అందువల్ల, వినియోగదారులను సేవ్ చేయవచ్చు మరియు జోడించవచ్చు మరియు వారి పేర్ల జాబితాను కూడా ప్రదర్శించగల పూర్తిగా పని చేసే వెబ్ అప్లికేషన్ మా వద్ద ఉంది. ఇప్పుడు మనం దానిని అందంగా మార్చాలి... :) సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 2) - 2

శైలులను జోడిస్తోంది. మేము W3.CSS ఫ్రేమ్‌వర్క్‌ని ఉపయోగిస్తాము

ప్రస్తుతానికి, మా అప్లికేషన్ పని చేస్తుంది, కానీ ఇది పూర్తిగా దారుణంగా కనిపిస్తోంది. కాబట్టి, నేపథ్యాన్ని జోడించి, టెక్స్ట్ మరియు బటన్లకు రంగులు వేయండి, జాబితాలకు శైలిని జోడించండి, మూలకాలను సమలేఖనం చేయండి, ఇండెంట్లను జోడించండి మరియు మొదలైనవి. మాన్యువల్‌గా స్టైల్స్ రాయడం వల్ల చాలా సమయం పడుతుంది మరియు మన నరాలపై పన్ను పడుతుంది. కాబట్టి నేను W3.CSS ఫ్రేమ్‌వర్క్‌ని ఉపయోగించమని ప్రతిపాదించాను . ఇది ఇప్పటికే స్టైల్‌లతో ఉపయోగించడానికి సిద్ధంగా ఉన్న తరగతులను కలిగి ఉంది. మేము సరైన ప్రదేశాలలో ఉపయోగించాలనుకుంటున్న CSS తరగతులను ఏర్పాటు చేయాలి. వాటిని మా పేజీలకు జోడించడానికి, మేము మొదట స్టైల్ ఫైల్‌ని కనెక్ట్ చేస్తాము. దీన్ని చేయడానికి రెండు మార్గాలు ఉన్నాయి:

  1. మా పేజీల ద్వారా వెళ్లి, హెడ్ సెక్షన్‌లోని స్టైల్ ఫైల్‌కి క్రింది డైరెక్ట్ లింక్‌ను ఇన్సర్ట్ చేయండి

    <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">

    మీకు శాశ్వత ఇంటర్నెట్ కనెక్షన్ ఉంటే ఈ ఎంపిక అనుకూలంగా ఉంటుంది. మీరు స్థానిక సర్వర్‌లో మీ పేజీలను తెరిచినప్పుడు, శైలులు ఇంటర్నెట్ నుండి తీసివేయబడతాయి.

  2. మీరు ఇంటర్నెట్ కనెక్షన్‌పై ఆధారపడకుండా స్థానికంగా అన్ని స్టైల్‌లను కలిగి ఉండాలనుకుంటే, స్టైల్ ఫైల్‌ని డౌన్‌లోడ్ చేసి వెబ్ ఫోల్డర్‌లో ఎక్కడో ఉంచండి (ఉదా. web/styles/w3.css ). ఆపై మా అన్ని పేజీల ( index.html, add.jsp, list.jsp ) ద్వారా వెళ్లి హెడ్ సెక్షన్‌లోని స్టైల్ ఫైల్‌కి క్రింది లింక్‌ను జోడించండి :

    <link rel="stylesheet" href="styles/w3.css">

    ఆ తర్వాత, ట్యాగ్‌ల ద్వారా వెళ్లి మీకు నచ్చిన స్టైల్‌లను జోడించండి. నేను దీని గురించి వివరంగా చెప్పను. బదులుగా, నేను రాస్టర్-శైలి తరగతులతో నా మూడు ఫైల్‌ల యొక్క ఉపయోగించడానికి సిద్ధంగా ఉన్న సంస్కరణలను అందిస్తాను.

index.html 

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Super app!</title>
        <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
    </head>

    <body class="w3-light-grey">
        <div class="w3-container w3-blue-grey w3-opacity w3-right-align">
            <h1>Super app!</h1>
        </div>

        <div class="w3-container w3-center">
            <div class="w3-bar w3-padding-large w3-padding-24">
                <button class="w3-btn w3-hover-light-blue w3-round-large" onclick="location.href='/list'">List users</button>
                <button class="w3-btn w3-hover-green w3-round-large" onclick="location.href='/add'">Add user</button>
            </div>
        </div>
    </body>
</html>
add.jsp
Java webinar 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Add new user</title>
        <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
    </head>

    <body class="w3-light-grey">
        <div class="w3-container w3-blue-grey w3-opacity w3-right-align">
            <h1>Super app!</h1>
        </div>

        <div class="w3-container w3-padding">
            <%
                if (request.getAttribute("userName") != null) {
                    out.println("<div class=\"w3-panel w3-green w3-display-container w3-card-4 w3-round\">\n" +
                            "   <span onclick=\"this.parentElement.style.display='none'\"\n" +
                            "   class=\"w3-button w3-margin-right w3-display-right w3-round-large w3-hover-green w3-border w3-border-green w3-hover-border-grey\">×</span>\n" +
                            "   <h5>User '" + request.getAttribute("userName") + "' added!</h5>\n" +
                            "</div>");
                }
            %>
            <div class="w3-card-4">
                <div class="w3-container w3-center w3-green">
                    <h2>Add user</h2>
                </div>
                <form method="post" class="w3-selection w3-light-grey w3-padding">
                    <label>Name:
                        <input type="text" name="name" class="w3-input w3-animate-input w3-border w3-round-large" style="width: 30%"><br />
                    </label>
                    <label>Password:
                        <input type="password" name="pass" class="w3-input w3-animate-input w3-border w3-round-large" style="width: 30%"><br />
                    </label>
                    <button type="submit" class="w3-btn w3-green w3-round-large w3-margin-bottom">Submit</button>
                </form>
            </div>
        </div>

        <div class="w3-container w3-grey w3-opacity w3-right-align w3-padding">
            <button class="w3-btn w3-round-large" onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
list.jsp 

<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
    <head>
        <title>Users list</title>
        <link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
    </head>

    <body class="w3-light-grey">
        <div class="w3-container w3-blue-grey w3-opacity w3-right-align">
            <h1>Super app!</h1>
        </div>

        <div class="w3-container w3-center w3-margin-bottom w3-padding">
            <div class="w3-card-4">
                <div class="w3-container w3-light-blue">
                    <h2>Users</h2>
                </div>
                <%
                    List<String> names = (List<String>) request.getAttribute("userNames");

                    if (names != null && !names.isEmpty()) {
                        out.println("<ul class=\"w3-ul\">");
                        for (String s : names) {
                            out.println("<li class=\"w3-hover-sand\">" + s + "</li>");
                        }
                        out.println("</ul>");

                    } else out.println("<div class=\"w3-panel w3-red w3-display-container w3-card-4 w3-round\">\n"
+
                            "   <span onclick=\"this.parentElement.style.display='none'\"\n" +
                            "   class=\"w3-button w3-margin-right w3-display-right w3-round-large w3-hover-red w3-border w3-border-red w3-hover-border-grey\">×</span>\n" +
                            "   <h5>There are no users yet!</h5>\n" +
                            "</div>");
                %>
            </div>
        </div>

        <div class="w3-container w3-grey w3-opacity w3-right-align w3-padding">
            <button class="w3-btn w3-round-large" onclick="location.href='/'">Back to main</button>
        </div>
    </body>
</html>
అంతే. :) మీకు ఇంకా ఏవైనా ప్రశ్నలు లేదా వ్యాఖ్యలు ఉంటే, లేదా ఏదైనా పని చేయకపోతే, దయచేసి వ్యాఖ్యానించండి. మరియు అది ఎలా జరిగిందో నేను కొన్ని స్క్రీన్‌షాట్‌లను జత చేస్తాను.
సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 2) - 3
సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 2) - 4
సర్వ్‌లెట్‌లు మరియు JSPలను ఉపయోగించి ఒక సాధారణ వెబ్ అప్లికేషన్‌ను సృష్టించడం (పార్ట్ 2) - 5
చివరకు , మీరు ఈ ప్రాజెక్ట్‌తో ప్రాక్టీస్ చేయాలనుకుంటే, మీరు ఈ క్రింది వాటిని ప్రయత్నించవచ్చు:
  • వినియోగదారుని తొలగించడానికి సర్వ్‌లెట్ మరియు JSPని తయారు చేయండి మరియు ఇప్పటికే ఉన్న వినియోగదారుని సవరించడానికి మరొక జతని జోడించండి. ఫలితం సర్వ్‌లెట్‌లను ఉపయోగించి రూపొందించబడిన నిజమైన CRUD వెబ్ అప్లికేషన్. ;)
  • జాబితాను డేటాబేస్తో భర్తీ చేయండి, తద్వారా సర్వర్ పునఃప్రారంభించబడిన తర్వాత జోడించబడిన వినియోగదారులు అదృశ్యం కాలేరు. :)
అదృష్టం!

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