Dit første program, der bruger Java-servlets

Hej allesammen! Du bliver fortrolig med servlets som et grundlæggende koncept for webudvikling, og du vil kunne skrive en simpel applikation, der bruger dem. For at undgå unødvendige handlinger starter vi ikke fra bunden. Vi fortsætter med at arbejde på vores applikation fra min tidligere artikel om Hibernate . Men da vi lige er begyndt at stifte bekendtskab med servlets, har jeg fjernet alt relateret til Auto-klassen fra applikationen og efterladt kun User-klassen og handlinger, der involverer den. Projektet vil være struktureret således: Så servlets! Wikipedia udtaler: "En Java-servlet er en Java-softwarekomponent, der udvider en servers muligheder. Selvom servlets kan reagere på mange typer anmodninger, implementerer de oftest webcontainere til hosting af webapplikationer på webservere og kvalificerer sig således som en server- side servlet web API." Dette er helt rigtigt. Her støder vi for første gang på konceptet med en "klient-server-applikationsarkitektur." Det er ret simpelt i sin kerne. Klienten får adgang til serveren ved at sende en HTTP-anmodning. Serveren genererer de nødvendige data (henter dem f.eks. fra en database) og returnerer dem til klienten. Det enkleste eksempel er, når du klikker på knappen "Venner" på et bestemt socialt netværk, og derved sender en anmodning til serveren. Serveren opdaterer listen over dine venner i databasen og returnerer den til dig (klienten). Listen over HTTP-anmodninger er ret stor, så hvis du aldrig har stødt på dem før, så ville det være bedst for dig at læse om dem andre steder, f.eks.her . Vores mål er at: Oprette en CRUD-applikation ved hjælp af servlets. Applikationen skal være i stand til at oprette, læse, opdatere og slette brugere fra databasen ved hjælp af en servlet, der behandler HTTP-anmodninger. Vores applikation fra Hibernate-artiklen kunne allerede gøre dette, men den blev styret direkte fra Java-kode, mere præcist, fra main()-metoden. Denne gang er det klienten, der sender anmodningerne, dvs. dig :) Det første vi skal gøre er at tilføje nye afhængigheder til vores 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 tilføjede 3 afhængigheder:

1. Selve javax.servlet-api-biblioteket
2. JSTL-tagbiblioteket. Det vil være nødvendigt at oprette klientsiden, nemlig JSP-siderne
3. Spring-WebMVC. Vi skal bruge en forårstime, som vi vil tale om lidt senere.

Servlet-styring håndteres af servlet-beholderen. I vores tilfælde vil vi bruge Apache Tomcat. Det er ret populært — du har sikkert allerede hørt om det :) Servlets livscyklus består af følgende trin:

1. Hvis der ikke er nogen servlet i beholderen:
   
   • Servlet-klassen indlæses af containeren.
   • Containeren opretter en forekomst af servletklassen.
   • Containeren kalder init()-metoden. Denne metode initialiserer servlet'en og kaldes først, før servlet'en kan betjene anmodninger. I løbet af hele livscyklussen kaldes init()-metoden kun én gang.
2. Betjen kundens anmodning. Hver anmodning behandles i sin egen separate tråd. Containeren kalder service()-metoden for hver anmodning. Denne metode bestemmer typen af ​​indgående anmodning og sender den til den passende metode til behandling. Servletudvikleren skal levere implementeringer til disse metoder. Hvis der kommer en forespørgsel til en behandler, der ikke er implementeret, kaldes den overordnede klasses metode og ender normalt med at returnere en fejl til rekvirenten.


3. Hvis containeren skal fjerne servlet'en, kalder den destroy() metoden, som tager servlet'en ud af drift. Ligesom init()-metoden kaldes denne metode også én gang under hele servlet-cyklussen.

Vores servlet ser ret simpelt ud:

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, indeholder den init()-metoden, som blev beskrevet ovenfor, og implementerer 4 metoder, der falder sammen med fire HTTP-anmodninger: doPost(), doGet(), doPut() og doDelete(). De lader os oprette, læse, opdatere og slette brugere. Metoderne accepterer forekomster af klasserne javax.servlet.http.HttpServletRequest og javax.servlet.http.HttpServletResponse som input, dvs. anmodninger sendt til serveren og svar modtaget af klienten. Internt kalder metoderne de relevante metoder i UserService-klassen, og et svar for klienten genereres og omdirigeres til /users URL. For eksempel får vi i doGet()-metoden en liste over alle brugere. Dernæst opretter vi et RequestDispatcher-objekt, som lader os inkludere objekter i en HTTP-anmodning og omdirigere det til en specifik ressource (for eksempel til en klient-JSP-side). I doPut()-metoden (som opdaterer brugerdata), behandler vi en HTTP-anmodning, udtrækker id-, navn- og aldersparametrene, finder brugeren med det angivne id, tildeler den navnet og alderen i anmodningen og returnerer til siden /brugere. Men for at alle disse metoder skal fungere korrekt, skal vi konfigurere servlet'en. For at gøre dette bruger 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 tags i denne fil er ret intuitive, men lad os gennemgå dem i rækkefølge. <velkomst-fil-liste> - JSP-startsiden er angivet, som vil blive åbnet først, når applikationen starter. I vores tilfælde er dette index.jsp. <servlet> - Registrering af vores UserSimpleServlet-klasse som en servlet. <servlet-mapping> - et meget vigtigt tag. Den definerer de URL'er, der vil blive behandlet af servlet'en. I vores tilfælde er det alle URL'er, så vi angiver blot "/". Men hvis vi havde en applikation, der involverede brugere og deres biler (biler), så kunne vi oprette en anden servlet (SimpleAutoServlet). Så ville brugerservletens mapping være "/users" (dvs. anmodninger om brugere), og autoservletens mapping ville være "/autos". Og endelig <filter>. Internt definerer den en instans af organisationen. springframework.web.filter.HiddenHttpMethodFilter klasse. Denne artikel handler ikke om foråret, så jeg vil ikke beskrive den i detaljer. Jeg vil kun sige, at det kun er boltet på vores applikation som en ekstra funktion. Sagen er, at vi kommer til at bruge JSP-sider til at oprette klientsiden. Vores data vil blive vist på siden som en tabel med en liste over brugere. Inde på JSP-siderne vil <form/> HTML-tags blive brugt. Men kun HTTP GET- og POST-anmodninger kan bruges til at sende data fra en <form/>. Med andre ord, for alle tre operationer - opdatering, sletning og oprettelse af en bruger - ville vi kun skulle bruge POST-anmodninger. Brug af PUT- og DELETE-anmodninger ville ikke være en mulighed for os. I princippet er dette ganske normalt og nemt at implementere, men HiddenHttpMethodFilter-klassen lader os bruge dem. På denne måde læseren vil tydeligere se forskellen mellem operationer i applikationen. Lad os endelig gå videre til klientsiden. Det er repræsenteret af 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) indeholder to typer tekst: statiske kildedata, der kan formateres som tekst (HTML, SVG, WML eller XML), og JSP-elementer, der bruges til at konstruere dynamisk indhold. For at hjælpe dig med at forstå, hvad en JSP-side er, har jeg kopieret en passage fra en meget god artikel. "Dybest set, første gang der anmodes om en JSP, bliver den til en servlet og fungerer som en servlet. Dette er meget vigtigt at forstå. En JSP-side ER IKKE som en HTML-side - en begyndende programmør skal klart forstå, at dette er en anden servlet — det er bare, at du ikke behøver at skrive for at programmere, hvordan det vises. Det kan ganske enkelt tegnes. Og tilføje data, hvor det er nødvendigt. Men fordi en JSP-side minder om HTML, vil en designer naturligvis finde det nemmere. Og endnu en gang UNDERSTREG STÆRKT for begyndere,en JSP-side er en SERVLET. Det genereres, inklusive tilføjelse af alle data, på serveren. Det er her alle data indsættes. Og i browseren får brugeren den færdige HTML-side, som ikke har tegn på Java." Du kan være sikker på, at en JSP-side virkelig er en servlet, fordi hver side har en metode, der skal udføres. Eksempelvis indeks .jsp angiver, at når du klikker på knappen "Begynd at arbejde med databasen", vil get-metoden blive udført (metode = "get"). AddUser.jsp-siden, som er ansvarlig for at oprette nye brugere, udfører post-metoden (metode = "indlæg"), når du klikker på knappen Gem. Resten af ​​JSP-siden består af almindelig statisk HTML-markering, så vi vil ikke dvæle ved det. Det er et emne for en anden artikel, og der er masser om dette emne på internettet. Så vi har oprettet vores applikation! Nu skal vi teste det i aktion! For at gøre dette har vi brug for Apache Tomcat servlet-beholderen nævnt ovenfor. Du kan downloade beholderenfra den officielle hjemmeside (jeg bruger version 8). Dernæst skal vi oprette en konfiguration i IDEA for at køre vores applikation gennem Tomcat. For at gøre dette skal du åbne fanen "Rediger konfigurationer", oprette en ny konfiguration og vælge "Tomcat Server Local". På fanen "Applikationsserver" skal du angive stien til Tomcat-mappen . Gå derefter til fanen "Deployment". Her konfigurerer vi implementeringen af ​​vores applikation på den lokale server. Tryk på "+", vælg "Artifact" -> YourProjectName:war (vi bygger applikationen til en krigsfil). Og det opsummerer det omtrent! På siden "Server" kan du se, at vores applikation kører på http://localhost:8080/. Gem konfigurationen og giv den et navn (jeg kalder min konfiguration "Tommy"). Dernæst, på Maven-fanen i IDEA (på højre side), vil vi bruge war-plugin'et til at bygge vores projekt til en krigsfil (Plugins -> krig -> krig: krig). Når opbygningen er færdig, skal du køre programmet og vente. Succes! Startsiden blev lanceret. Nu klikker vi på knappen "Begynd at arbejde med databasen". Vores index.jsp vil generere en GET-anmodning, som vil blive behandlet af serveren. Serveren vil generere et svar og returnere det til os i form af en liste over alle eksisterende brugere (forudsat at der er brugere i databasen, selvfølgelig). Og der er de! At der har du det! Du skrev din første applikation ved hjælp af Java-servlets. Det var ikke så slemt, vel? :) Til hjemmearbejde kunne du gendanne bilens funktionalitet fra den forrige artikel. Med andre ord, opret en separat servlet- og JSP-sider til biler, og lær applikationen, hvordan man viser en brugers biler, tilføjer nye biler til en bruger og redigerer og sletter dem. PS Servlets og JavaServer Pages er ret gamle teknologier. På internettet kan du ofte finde kommentarer som "Hvem har brug for det her gamle skrammel?" Svaret er ret simpelt: hovedsageligt folk, der vil arbejde på rigtige projekter, hvor de med stor sandsynlighed kan støde på en masse kode, der bruger disse teknologier. Og selv uden at forstå hvordan det virker, er det stadig sjovt at skære "gammelt skrammel" op til noget nyt :) For en mere grundig undersøgelse af JSP og servlets kan du henvise til bogen "Head First Servlets and JSP ". Den er skrevet af de samme forfattere som den berømte superbog "Head First Java", som mange vil tage som garanti for kvalitet :) Jeg håber denne artikel har været nyttig! Tak for din opmærksomhed, og held og lykke med at lære!