Din første applikasjon som bruker Java-servlets

Hei alle sammen! Du vil bli kjent med servlets som et grunnleggende konsept for webutvikling, og du vil kunne skrive en enkel applikasjon som bruker dem. For å unngå unødvendige handlinger starter vi ikke fra bunnen av. Vi vil fortsette å jobbe med applikasjonen vår fra min forrige artikkel om Hibernate . Men siden vi akkurat har begynt å bli kjent med servlets, har jeg fjernet alt relatert til Auto-klassen fra applikasjonen og kun overlatt brukerklassen og handlinger som involverer den. Prosjektet vil være strukturert slik: Så, servletter! Wikipedia sier: "En Java-servlet er en Java-programvarekomponent som utvider mulighetene til en server. Selv om servlets kan svare på mange typer forespørsler, implementerer de oftest nettbeholdere for å være vert for webapplikasjoner på webservere og kvalifiserer dermed som en server- side servlet web API." Dette er nøyaktig sant. Her kommer vi for første gang over konseptet med en "klient-server-applikasjonsarkitektur." Det er ganske enkelt i kjernen. Klienten får tilgang til serveren ved å sende en HTTP-forespørsel. Serveren genererer de nødvendige dataene (henter dem for eksempel fra en database) og returnerer dem til klienten. Det enkleste eksemplet er når du klikker på "Venner"-knappen på et bestemt sosialt nettverk, og dermed sender en forespørsel til serveren. Serveren oppdaterer listen over vennene dine i databasen og returnerer den til deg (klienten). Listen over HTTP-forespørsler er ganske stor, så hvis du aldri har møtt dem før, vil det være best for deg å lese om dem andre steder, for eksempel,her . Vårt mål er å: Lage en CRUD-applikasjon ved hjelp av servlets. Applikasjonen må kunne opprette, lese, oppdatere og slette brukere fra databasen ved hjelp av en servlet som behandler HTTP-forespørsler. Vår applikasjon fra Hibernate-artikkelen kunne allerede gjøre dette, men den ble kontrollert direkte fra Java-kode, mer presist, fra main()-metoden. Denne gangen er det klienten som skal sende forespørslene, dvs. deg :) Det første vi må gjøre er å legge til nye avhengigheter til vår pom.xml-fil.

 <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>com.itis4</groupId>
     <artifactId>UsersDaoProject</artifactId>
     <version>1.0-SNAPSHOT</version>
 
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-war-plugin</artifactId>
                 <version>2.6</version>
             </plugin>
         </plugins>
     </build>
 
     <dependencies>
         <!-- PostgreSQL  -->
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
             <version>9.4.1212.jre7</version>
         </dependency>
 
         <!-- Hibernate 5.2.6 Final -->
         <dependency>
             <groupId>org.hibernate</groupId>
             <artifactId>hibernate-core</artifactId>
             <version>5.2.6.Final</version>
         </dependency>
 
         <dependency>
             <groupId>jstl</groupId>
             <artifactId>jstl</artifactId>
             <version>1.2</version>
         </dependency>
         <dependency>
             <groupId>javax.servlet</groupId>
             <artifactId>javax.servlet-api</artifactId>
             <version>3.1.0</version>
         </dependency>
 
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>4.3.4.RELEASE</version>
         </dependency>
 
     </dependencies>
 
 </project>
 

Vi la til 3 avhengigheter:

1. Selve javax.servlet-api-biblioteket
2. JSTL-kodebiblioteket. Det vil være nødvendig for å opprette klientsiden, nemlig JSP-sidene
3. Spring-WebMVC. Vi trenger en vårtime, som vi skal snakke om litt senere.

Servlet-administrasjon håndteres av servlet-beholderen. I vårt tilfelle vil vi bruke Apache Tomcat. Det er ganske populært — du har sikkert allerede hørt om det :) Livssyklusen for servleten består av følgende trinn:

1. Hvis det ikke er noen servlet i beholderen:
   
   • Servletklassen lastes av containeren.
   • Beholderen oppretter en forekomst av servletklassen.
   • Beholderen kaller init()-metoden. Denne metoden initialiserer servleten og kalles først, før servleten kan betjene forespørsler. Over hele livssyklusen kalles init()-metoden bare én gang.
2. Betjen kundens forespørsel. Hver forespørsel behandles i sin egen tråd. Containeren kaller service()-metoden for hver forespørsel. Denne metoden bestemmer typen innkommende forespørsel og sender den til den riktige metoden for behandling. Servletutvikleren må levere implementeringer for disse metodene. Hvis det kommer en forespørsel for en behandler som ikke er implementert, kalles den overordnede klassens metode og ender vanligvis opp med å returnere en feil til rekvirenten.


3. Hvis containeren trenger å fjerne servleten, kaller den destroy()-metoden, som tar servleten ut av drift. I likhet med init()-metoden kalles denne metoden også én gang i løpet av hele servlet-syklusen.

Servleten vår ser ganske enkel ut:

 package servlets;
 
 import models.User;
 import services.UserService;
 import javax.servlet.RequestDispatcher;
 import javax.servlet.ServletConfig;
 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 UserSimpleServlet extends HttpServlet {
 
     private UserService service = new UserService();
 
     public void init(ServletConfig servletConfig) {
         try {
             super.init(servletConfig);
         } catch (ServletException e) {
             e.printStackTrace();
         }
     }
 
     @Override
     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 
         List<User> users = service.findAllUsers();
         req.setAttribute("users", users);
         RequestDispatcher dispatcher = req.getRequestDispatcher("/showUsers.jsp");
         dispatcher.forward(req, resp);
 
     }
 
     @Override
     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
             throws ServletException, IOException {
 
         String name = req.getParameter("name");
         int age = Integer.parseInt(req.getParameter("age"));
         User user = new User(name, age);
         service.saveUser(user);
         resp.sendRedirect("/users");
 
     }
 
     @Override
     protected void doPut(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
         int id = Integer.parseInt(req.getParameter("id"));
         User user = service.findUser(id);
         user.setName(req.getParameter("name"));
         user.setAge(Integer.parseInt(req.getParameter("age")));
         service.updateUser(user);
         resp.sendRedirect("/users");
     }
 
     @Override
     protected void doDelete(HttpServletRequest req, HttpServletResponse resp) throws IOException {
         int id = Integer.parseInt(req.getParameter("id"));
         service.deleteUser(service.findUser(id));
         resp.sendRedirect("/users");
     }
 }
 

Som du kan se, inneholder den init()-metoden, som ble beskrevet ovenfor, og implementerer 4 metoder som sammenfaller med fire HTTP-forespørsler: doPost(), doGet(), doPut() og doDelete(). De lar oss opprette, lese, oppdatere og slette brukere. Metodene aksepterer forekomster av javax.servlet.http.HttpServletRequest og javax.servlet.http.HttpServletResponse-klassene som input, dvs. forespørsler sendt til serveren og svar mottatt av klienten. Internt kaller metodene de relevante metodene til UserService-klassen, og et svar for klienten genereres og omdirigeres til /users URL. For eksempel, i doGet()-metoden får vi en liste over alle brukere. Deretter lager vi et RequestDispatcher-objekt, som lar oss inkludere objekter i en HTTP-forespørsel og omdirigere den til en spesifikk ressurs (for eksempel til en klient-JSP-side). I doPut()-metoden (som oppdaterer brukerdata), behandler vi en HTTP-forespørsel, trekker ut id-, navn- og aldersparametere, finner brukeren med spesifisert id, tildeler den navnet og alderen som er i forespørselen, og returnerer til /users-siden. Men for at alle disse metodene skal fungere riktig, må vi konfigurere servleten. For å gjøre dette bruker vi web.xml-filen i WEB-INF-mappen.

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app version="3.1"
          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">
 
     <welcome-file-list>
         <welcome-file>index.jsp</welcome-file>
     </welcome-file-list>
 
     <servlet>
         <servlet-name>UserSimpleServlet</servlet-name>
         <servlet-class>servlets.UserSimpleServlet</servlet-class>
     </servlet>
 
     <servlet-mapping>
         <servlet-name>UserSimpleServlet</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>
 
     <filter>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
     </filter>
 
     <filter-mapping>
         <filter-name>hiddenHttpMethodFilter</filter-name>
         <servlet-name>UserSimpleServlet</servlet-name>
     </filter-mapping>
 
 </web-app>
 

Alle taggene i denne filen er ganske intuitive, men la oss gå gjennom dem i rekkefølge. <velkomstfilliste> - JSP-startsiden er angitt, som vil åpnes først når applikasjonen starter. I vårt tilfelle er dette index.jsp. <servlet> - Registrering av UserSimpleServlet-klassen vår som en servlet. <servlet-mapping> - en veldig viktig kode. Den definerer URL-ene som skal behandles av servleten. I vårt tilfelle er det alle nettadresser, så vi angir ganske enkelt "/". Men hvis vi hadde en applikasjon som involverte brukere og deres biler (biler), så kunne vi opprette en andre servlet (SimpleAutoServlet). Da vil brukerservletens mapping være "/users" (dvs. forespørsler om brukere), og autoservletens mapping vil være "/autos". Og til slutt, <filter>. Internt definerer den en forekomst av organisasjonen. springframework.web.filter.HiddenHttpMethodFilter-klassen. Denne artikkelen handler ikke om våren, så jeg vil ikke beskrive den i detalj. Jeg vil bare si at den er boltet på applikasjonen vår bare som en tilleggsfunksjon. Saken er at vi skal bruke JSP-sider for å lage klientsiden. Våre data vil bli vist på siden som en tabell med en liste over brukere. Inne på JSP-sidene vil <form/> HTML-tagger bli brukt. Men bare HTTP GET- og POST-forespørsler kan brukes til å sende data fra et <form/>. Med andre ord, for alle tre operasjonene - oppdatering, sletting og opprettelse av en bruker - må vi bare bruke POST-forespørsler. Å bruke PUT- og DELETE-forespørsler ville ikke vært et alternativ for oss. I prinsippet er dette ganske normalt og enkelt å implementere, men HiddenHttpMethodFilter-klassen lar oss bruke dem. På denne måten, leseren vil tydeligere se forskjellen mellom operasjoner i applikasjonen. Til slutt, la oss gå videre til klientsiden. Den er representert av fem JSP-sider. index.jsp.

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Hello!</title>
 </head>
 <body>
 If you want to start working with the user database,<br>
 click the button below:
 
 <form action = "users" method="get">
     <input type="submit" value="Start working with database">
 </form>
 </body>
 </html>
 

addUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Add new user</title>
 </head>
 <body>
 <form action = "/users" method="post">
     <input required type="text" name="name" placeholder="Name">
     <input required type="text" name="age" placeholder="Age">
     <input type="submit" value="Save">
 </form>
 </body>
 </html>
 
 

deleteUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Delete user</title>
 </head>
 <body>
 
 Are you sure you want to delete the user ${param.id}?
 
 &lform action="/users/${param.id}" method="post">
     <input type="hidden" name="id" value="${param.id}">
     <input type="hidden" name="_method" value="delete">
     <input type="submit" value="Delete">
 </form>
 
 </body>
 </html>
 
 

showUsers.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <html>
 <head>
     <title>User list</title>
 </head>
 <body>
 <table border="2">
     <tr>
         <td>ID</td>
         <td>Name</td>
         <td>Age</td>
         <td>Actions</td>
     </tr>
     <c:forEach items="${users}" var = "user">
         <tr>
             <td>${user.getId()}</td>
             <td>${user.getName()}</td>
             <td>${user.getAge()}</td>
             <td>
                 <form action = "updateUser.jsp" method="post">
                     <input type="hidden" name="id" value="${user.getId()}">
                     <input type="hidden" name="name" value="${user.getName()}">
                     <input type="hidden" name="age" value="${user.getAge()}">
                     <input type="submit" value="Modify" style="float:left">
                 </form>
                 <form action="deleteUser.jsp" method="post">
                     <input type="hidden" name="id" value="${user.getId()}">
                     <input type="submit" value="Delete" style="float:left">
                 </form></td>
         </tr>
     </c:forEach>
 </table>
 
 <form action = "addUser.jsp">
     <input type="submit" value="Add new user">
 </form>
 </body>
 </html>

updateUser.jsp

 <%@ page contentType="text/html;charset=UTF-8" language="java" %>
 <html>
 <head>
     <title>Modify user data</title>
 </head>
 <body>
 
 Edit user
 
 <form action="/users/${param.id}" method="post">
     <input type="hidden" name = "id" value="${param.id}">
     <input type="text" name="name" value="${param.name}" placeholder=${param.name}>
     <input type="text" name="age" value="${param.age}" placeholder=${param.age}>
     <input type="hidden" name="_method" value="put">
     <input type="submit" value="Update">
 </form>
 
 </body>
 </html>
 

En JSP-side (JavaServer-side) inneholder to typer tekst: statiske kildedata som kan formateres som tekst (HTML, SVG, WML eller XML), og JSP-elementer som brukes til å konstruere dynamisk innhold. For å hjelpe deg å forstå hva en JSP-side er, har jeg kopiert et avsnitt fra en veldig god artikkel. "I utgangspunktet, første gang en JSP blir forespurt, blir den til en servlet og fungerer som en servlet. Dette er veldig viktig å forstå. En JSP-side ER IKKE som en HTML-side - en begynnende programmerer må tydelig forstå at dette er en annen servlet — det er bare det at du ikke trenger å programmere hvordan det vises. Det kan ganske enkelt tegnes. Og legge til data der det er nødvendig. Men fordi en JSP-side minner om HTML, vil en designer åpenbart finne det lettere. Og nok en gang VEKRE sterkt for nybegynnere,en JSP-side er en SERVLET. Den genereres, inkludert å legge til alle dataene, på serveren. Det er her alle dataene legges inn. Og i nettleseren får brukeren den ferdige HTML-siden, som ikke har tegn til Java." Du kan være sikker på at en JSP-side virkelig er en servlet, fordi hver side har en metode som må utføres. For eksempel indekserer .jsp indikerer at når du klikker på "Start å jobbe med databasen"-knappen, vil get-metoden bli utført (metode = "get"). AddUser.jsp-siden, som er ansvarlig for å opprette nye brukere, kjører post-metoden (metode = "post") når du klikker på lagre-knappen. Resten av JSP-siden består av vanlig statisk HTML-oppmerking, så vi vil ikke dvele ved det. Det er et emne for en annen artikkel, og det er mye om dette emne på Internett. Så vi har laget vår applikasjon! Nå må vi teste den i aksjon! For å gjøre dette trenger vi Apache Tomcat-servletbeholderen nevnt ovenfor. Du kan laste ned beholderenfra den offisielle nettsiden (jeg bruker versjon 8). Deretter må vi opprette en konfigurasjon i IDEA for å kjøre applikasjonen vår gjennom Tomcat. For å gjøre dette, åpne fanen "Rediger konfigurasjoner", opprett en ny konfigurasjon og velg "Tomcat Server Local". På "Application Server"-fanen, spesifiser banen til Tomcat-mappen. Gå deretter til "Deployment"-fanen. Her konfigurerer vi distribusjonen av applikasjonen vår på den lokale serveren. Trykk "+", velg "Artifact" -> YourProjectName:war (vi bygger applikasjonen til en krigsfil). Og det oppsummerer det omtrent! På "Server"-siden kan du se at applikasjonen vår vil kjøre på http://localhost:8080/. Lagre konfigurasjonen og gi den et navn (jeg kaller konfigurasjonen min "Tommy"). Deretter, på Maven-fanen i IDEA (på høyre side), vil vi bruke krigspluginen til å bygge prosjektet vårt til en krigsfil (Plugins -> krig -> krig: krig). Etter at byggingen er fullført, kjør programmet og vent. Suksess! Startsiden ble lansert. Nå klikker vi på knappen "Begynn å jobbe med databasen". Vår index.jsp vil generere en GET-forespørsel som vil bli behandlet av serveren. Serveren vil generere et svar og returnere det til oss i form av en liste over alle eksisterende brukere (forutsatt at det er brukere i databasen, selvfølgelig). Og der er de! At der har du det! Du skrev din første applikasjon med Java-servlets. Det var ikke så ille, var det? :) For lekser kan du gjenopprette bilfunksjonaliteten fra forrige artikkel. Med andre ord, lag en egen servlet- og JSP-sider for biler, og lær applikasjonen hvordan du kan liste opp en brukers biler, legge til nye biler til en bruker og redigere og slette dem. PS Servlets og JavaServer Pages er ganske eldgamle teknologier. På Internett kan du ofte finne kommentarer som "Hvem trenger dette gamle søppelet?" Svaret er ganske enkelt: hovedsakelig folk som skal jobbe med virkelige prosjekter, hvor de ganske mulig kan støte på mye kode som bruker disse teknologiene. Og selv uten å forstå hvordan det fungerer, er det fortsatt gøy å kutte opp "gammelt søppel" til noe nytt :) For en grundigere studie av JSP og servlets kan du referere til boken "Head First Servlets and JSP ". Den er skrevet av de samme forfatterne som den kjente superboken "Head First Java", som mange vil ta som en garanti for kvalitet :) Jeg håper denne artikkelen har vært til hjelp! Takk for oppmerksomheten, og lykke til med læringen!