Artikkel
Start
Begynn å lære
CodeGym /Java-blogg /Tilfeldig /Opprette en enkel nettapplikasjon ved hjelp av servlets o...
John Squirrels
Nivå
San Francisco

Opprette en enkel nettapplikasjon ved hjelp av servlets og JSP-er (del 1)

Publisert i gruppen
Kunnskap som kreves for å forstå artikkelen: Du har allerede mer eller mindre funnet ut av Java Core og vil gjerne se på JavaEE-teknologier og webprogrammering . Det ville være mest fornuftig for deg å studere Java Collections-oppdraget , som omhandler emner nær artikkelen.
Opprette en enkel nettapplikasjon ved hjelp av servlets og JSP-er (del 1) - 1
Dette materialet er den logiske fortsettelsen av artikkelen min Å lage det enkleste webprosjektet i IntelliJ Idea Enterprise . I den artikkelen demonstrerte jeg hvordan du lager en fungerende webprosjektmal. Denne gangen skal jeg vise deg hvordan du lager en enkel, men fullstendig attraktiv nettapplikasjon ved å bruke Java Servlet API og JavaServer Pages API . Vår søknad vil ha en hjemmeside med to lenker:
  • en lenke til en side for å legge til brukere;
  • en lenke til listen over brukere.
Som før vil jeg bruke IntelliJ Idea Enterprise Edition , Apache Maven (vi kobler bare til noen avhengigheter) og Apache Tomcat . Til slutt vil vi "forskjønne" applikasjonen vår ved å bruke W3.CSS -rammeverket. Vi antar at du allerede har et tomt prosjekt som vi nå vil legge til. Hvis ikke, kjør gjennom den første artikkelen og lag en. Det tar bare noen minutter :)

Litt om vår fremtidige applikasjons struktur

Hjemmesiden vår (/) vil være en høyst ordinær statisk HTML- side med en overskrift og to lenker/knapper:
  • legg til en ny bruker (navigerer til / legg til );
  • se listen over brukere (navigerer til / liste ).
Tomcat vil fange opp forespørsler for disse adressene og sende dem til en av de to servletene vi skal lage (vi spesifiserer tilordningen i web.xml ). Servletene vil deretter behandle forespørslene, forberede data (eller lagre data, hvis vi legger til en bruker), og overføre kontrollen til de riktige JSP-filene , som deretter "renderer" resultatet. Vi lagrer dataene i en vanlig vaniljeliste (List).

Lag en statisk hjemmeside

Hvis du index.jsp i nettmappen din, slett den. Opprett i stedet en enkel HTML-fil kalt index.html i denne mappen: 

<!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>
Det er ikke noe komplisert her. I tittelkoden angir vi tittelen på siden vår. I sideteksten har vi to hovedavdelinger: overskrift og innhold . Innhold div inkluderer en holder for våre knapper. Og der har vi to knapper som tar deg til den tilsvarende adressen med et klikk. Du kan kjøre prosjektet og se hvordan det ser ut nå. Klikker du på knappene får du 404-feilsider, fordi vi de tilsvarende sidene ikke eksisterer ennå. Men vi kan fortelle at knappene fungerer. Merk at dette ikke er den mest universelle tilnærmingen: hvis JavaScript er slått av i nettleseren, vil ikke disse knappene fungere. Men vi antar at ingen deaktiverer JavaScript. :) Selvfølgelig kan du klare deg med enkle lenker, men jeg foretrekker knapper. Du kan gjøre det som du foretrekker. Og ikke bekymre deg for det faktum at eksemplene mine vil ha mange divs . Vi fyller dem med stiler senere, og alt vil se vakrere ut. :)

Lag JSP-filer for å gjengi resultatet

I samme nettkatalog , lag en mappe der vi legger til JSP-filene våre . Jeg kalte det ' visninger ', men nok en gang kan du improvisere. I denne mappen lager vi to JSP-filer:
  • add.jsp — en side for å legge til brukere;
  • list.jsp — side for å vise listen over brukere.
Tilordne passende sideoverskrifter til dem. Noe som " Legg til ny bruker " og " Brukerliste ", så lar vi det være slik.
Java webinar

Lag to servletter

Servlets vil motta og behandle forespørslene som Tomcat sender dem. I src/main/java- mappen oppretter du apppakken , der vi legger kildekoden vår. Andre pakker vil også gå dit. Så for å forhindre at disse pakkene opprettes inne i hverandre, oppretter vi en klasse i apppakken ( vi sletter den senere). Lag nå tre forskjellige pakker i apppakken :
  • entities — våre enheter (klassen som beskriver brukerobjekter) går hit;
  • modell — det er her modellen vår går (vi skal snakke om dette litt senere);
  • servlets - og det er her servletene våre går.
Når du har gjort dette, kan du rolig slette den klassen fra apppakken (hvis du har laget den, selvfølgelig). Opprett to klasser i servlets -pakken:
  • AddServlet — behandler forespørsler sendt til / add ;
  • ListServlet — behandler forespørsler sendt til / list .

Koble avhengigheter i Maven

Tomcat 9. * implementerer spesifikasjonene for Servlet 4.0 og JavaServer Pages 2.3 . Det er det som står i den andre linjen i det første avsnittet i Tomcat 9s offisielle dokumentasjon. Dette betyr at hvis du, som meg, bruker denne versjonen av Tomcat , så vil koden du skal skrive og kjøre bruke disse versjonene. Men vi vil gjerne ha disse spesifikasjonene i prosjektet vårt, slik at koden vår, som bruker dem, i det minste kompileres vellykket. Og for å gjøre dette, må vi laste dem inn i prosjektet vårt. Det er her Maven kommer til unnsetning.

Den generelle regelen er denne: hvis du trenger å koble noe til prosjektet ditt ved å bruke Maven:

  • gå til depotnettstedet fra Maven;
  • finne den nødvendige versjonen av det nødvendige biblioteket;
  • få avhengighetskoden som må limes inn i din pom.xml;
  • lim inn! :)
La oss begynne. Forbered først POM-filen . Et sted etter /versjonsoppføringen , men før /project , sett inn følgende: 

<dependencies>

</dependencies>
Vi gjør dette for å indikere at vi vil liste opp de nødvendige avhengighetene i disse taggene. Gå nå til mvnrepository.com . Det er et søkefelt øverst. For å starte, søk etter ' servlet '. Det første resultatet, som er brukt mer enn syv tusen ganger, passer oss. Husk at vi trenger versjon 4.0 (for Tomcat 9). Andre versjoner kan være passende for eldre implementeringer. Dette er en ganske fersk versjon, så det er ikke så mange bruksområder. Men vi trenger det. En side åpnes hvor du kan få koden for denne avhengigheten for en rekke pakkeadministratorer, eller du kan ganske enkelt laste den ned. Men siden vi ønsker å koble den til ved hjelp av Maven, velger vi koden på Maven-fanen. Vi kopierer og limer inn i avhengighetsdelen av POM-filen vår. Hvis du får et varsel som spør om du vil aktivere automatisk import i nedre høyre hjørne av IDEA , fortsett og godtar det. Hvis du ved et uhell nektet, gå til " Innstillinger " og slå på automatisk import manuelt: Innstillinger (Ctrl + Alt + S) -> Bygg, utførelse, distribusjon -> Maven -> Importerer .og IDEA-konfigurasjonsfilene for dette prosjektet synkronisert. Etter samme prinsipp vil vi finne og koble til JavaServer Pages 2.3 (søk etter "JSP"). Og siden vi allerede har startet Maven, la oss bare fortelle det at kildefilene våre følger Java 8-syntaksen, og at vi må kompilere dem til bytekode for den versjonen. Etter alle disse trinnene vil vår pom.xml se omtrent slik ut: 

<?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>

Gjør servletene våre til ekte servletter

For øyeblikket er paret med servlets vi laget faktisk vanlige klasser. De har ingen funksjonalitet. Men nå har vi koblet Servlet API til prosjektet vårt, og dermed kan vi bruke klassene. For å gjøre servletene våre "ekte", er alt vi trenger å gjøre å få dem til å arve HttpServlet -klassen.

Kartlegging eller markering

Nå ville det være fint å på en eller annen måte fortelle Tomcat at forespørsler om / add - adressen behandles av vår AddServlet , og forespørsler om / list - adressen håndteres av ListServlet . Denne prosessen kalles kartlegging (markup). Dette gjøres i web.xml ved å bruke samme prinsipp:
  • for å starte, beskriv servleten (gi et navn og spesifiser banen til selve klassen);
  • bind deretter denne servleten til en spesifikk adresse (spesifiser servletens navn, som vi nettopp ga den, og spesifiser adressen hvis forespørsler skal sendes til denne servleten).
Beskriv servletten: 

<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>
Bind den nå til adressen: 

<servlet-mapping>
    <servlet-name>add</servlet-name>
    <url-pattern>/add</url-pattern>
</servlet-mapping>
Som du kan se, er servlet-navn det samme i begge tilfeller. Som et resultat vet Tomcat at hvis en forespørsel om /add mottas, må den sendes til app.servlets.AddServlet. Vi gjør det samme med den andre servletten. Til slutt har web.xml omtrent følgende innhold: 

<?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>
Vi har forresten ikke laget markup for hjemmesiden (/). Faktum er at vi ikke trenger det i dette tilfellet. Hjemmesiden vår er en enkel HTML-fil som bare viser to knapper. Den har ikke noe dynamisk innhold, så vi trenger ikke å lage en egen servlet for forespørsler fra / som ikke vil gjøre annet enn å videresende kjøringen til en eller annen JSP (som også må opprettes) for å tegne to knapper for oss. Vi trenger ikke dette. En statisk side passer oss. Når Tomcat mottar en forespørsel, vil den sjekke om det er en enkelt servlet som kan behandle forespørselen for den adressen, og så vil den se at denne adressen faktisk allerede inneholder den klare HTML- filen, som den vil servere. Vi kan kjøre applikasjonen vår på nytt (start serveren på nytt eller omdistribuer den igjen – hva du enn foretrekker) og sørge for at hjemmesiden er gjengitt, at ingenting er ødelagt, og overgangene skjer når vi klikker på knappene (selv om vi igjen får en feilmelding). Forresten, mens vi før fikk en 404-feil, får vi nå en 405. Det betyr at tilordningen fungerte og servletene ble funnet, men de hadde ingen passende metode for å håndtere forespørselen.

Kort digresjon: hva skjer "under panseret"?

Du har sikkert allerede tenkt på hvordan applikasjonen vår fungerer i Tomcat. Hva skjer der inne? Og hvor er main()-metoden? Så snart du går til localhost:8080 i nettleseren din, sender nettleseren en forespørsel til denne adressen ved hjelp av HTTP-protokollen. Jeg håper du allerede er klar over at det finnes mange forskjellige typer forespørsler, og de mest populære er GET og POST. Hver forespørsel skal besvares. En GET-forespørsel forventes å motta et svar med klar-til-bruk HTML-kode, returnert til nettleseren. Nettleseren erstatter deretter koden vil alle de vakre bokstavene, knappene og skjemaene. En POST-forespørsel er litt mer interessant, siden den også inneholder noe informasjon. Anta for eksempel at du skriver inn legitimasjon i et registrerings- eller påloggingsskjema på et nettsted, og klikker på "Send". Dette fører til at en POST-forespørsel med din personlige informasjon sendes til serveren. Serveren mottar denne informasjonen, behandler den og returnerer noe svar (for eksempel en HTML-side med profilen din). Den viktigste forskjellen mellom dem er at GET-forespørsler bare brukes til å hente data fra serveren, mens POST-forespørsler har noe informasjon (og dataene på serveren kan endres). Når du for eksempel laster opp bildet ditt til serveren, blir det fraktet dit i en POST-forespørsel og serveren legger det til databasen, dvs. at det skjer en endring. Nå tilbake til Tomcat. Når den mottar en forespørsel fra en klient, ser den på adressen. Den sjekker om det er en passende servlet for å behandle forespørsler for den adressen (eller en tilgjengelig ressurs som kan returneres umiddelbart). Hvis den ikke finner noe å returnere, så svarer den med en 404-feil i stedet for en HTML-side. Men hvis den finner en passende servlet "sittende" på den adressen, så ser den på forespørselstypen (GET, POST eller noe annet) og spør servleten om den har en metode som kan håndtere denne typen søk. Hvis servleten sier at den ikke vet hvordan den skal håndtere denne typen, daTomcat returnerer en 405-kode. Og dette er akkurat det som skjedde i prosjektet vårt. Men hvis en passende servlet blir funnet, og den har en passende metode, oppretter Tomcat et servletobjekt, starter det på en ny tråd(som lar den kjøre på egen hånd), og Tomcat fortsetter sitt eget arbeid, godtar og sender forespørsler. I tillegg lager Tomcat ytterligere to objekter: en HttpServletRequest (som jeg vil kalle "forespørselen" for kort), og en HttpServletResponse (som jeg vil kalle "svaret"). Den legger alle dataene mottatt fra klientens forespørsel i det første objektet, slik at alle dataene kan trekkes ut fra det. Og så etter alt dette, sender den disse to disse objektene til den riktige metoden for servleten som ble startet på en separat tråd. Så snart servleten er ferdig med arbeidet og har et svar klart til å sendes til klienten, vifter den med et flagg mot Tomcat og sier "Jeg er ferdig. Alt er klart". Tomcat mottar svaret og sender det til klienten. Dette lar Tomcat motta forespørsler og sende svar, uten å bli distrahert, og alt arbeidet gjøres av servlets som kjører på separate tråder. Det betyr at når vi skriver servletkoden, bestemmer vi hvilket arbeid som skal utføres. Og du kan tenke på at main()-metoden ligger inne i selve Tomcat (jepp, den er skrevet i Java), og når vi "starter" Tomcat, startes main()-metoden. Opprette en enkel nettapplikasjon ved hjelp av servlets og JSP-er (del 1) - 2
Java university

Bruk servlets til å fange GET-metoder og sende superenkle svar

For øyeblikket har servletene våre ingen passende metoder (GET), så Tomcat returnerer en 405-feil. La oss lage dem! HttpServlet-klassen, vi våre servlets arver, erklærer forskjellige metoder. For å tildele spesifikk kode til metodene, overstyrer vi dem ganske enkelt. I dette tilfellet må vi overstyre doGet()metoden i begge servletene. 

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

}
Som du kan se, tar denne metoden to argumenter: req (forespørsel) og resp (respons). Dette er selve objektene som Tomcat lager og fyller ut for oss når den kaller den riktige metoden i servleten. Til å begynne med lager vi de enkleste svarene. For å gjøre dette tar vi resp-objektet og henter et PrintWriter-objekt fra det. Denne typen objekter brukes til å komponere et svar. Vi bruker den til å skrive ut en enkel streng. 

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("GET method from AddServlet");
}
Vi vil gjøre noe lignende i ListServlet, og deretter starter vi serveren vår på nytt. Som du kan se, fungerer alt! Når du klikker på knappene får du opp sider med teksten som vi "skrev" med PrintWriter. Men JSP-filene som vi forberedte for å generere sider med svar, blir ikke brukt. Det er rett og slett fordi de aldri blir henrettet. Servleten vår lager svaret selv og kjører ferdig, og signaliserer til Tomcat at den er klar til å svare klienten. Tomcat tar bare svaret og sender det tilbake til klienten. La oss overføre kontrollen fra servletene til JSP-filene. Vi endrer koden for metodene våre som følger:
  • vi henter et forespørselsformidlerobjekt fra forespørselsobjektet, og gir det adressen til JSP-siden som vi ønsker å overføre kontrollen til;
  • vi bruker dette objektet til å overføre kontroll til den spesifiserte JSP-siden, og ikke glemme å sende forespørsels- og svarobjektene vi mottok fra Tomcat.

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}
I body-taggen til JSP-sidene kan du legge til noe slik at vi tydelig kan se hvilken side som vises. Når du har gjort det, start serveren på nytt og sjekk. Vi klikker på knappene på hovedsiden og sidene åpnes, noe som betyr at forespørslene sendes til servletene. Deretter overføres kontrollen til JSP-sidene, som nå blir gjengitt. Det er alt for nå. I neste del av denne artikkelen skal vi jobbe med funksjonaliteten til applikasjonen vår.

Mer lesing:
Kommentarer
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION