CodeGym /Java блог /Случаен /Създаване на просто уеб приложение с помощта на сървлети ...

Ниво

San Francisco

21 July 2023
171 views
0 comments

Създаване на просто уеб приложение с помощта на сървлети и JSP (част 1)

Познания, необходими за разбиране на статията: Вие вече повече or по-малко сте разбрали Java Core и бихте искали да разгледате JavaEE технологиите и уеб програмирането . Би било най-разумно в момента да изучавате търсенето на Java Collections , което се занимава с теми, близки до статията.

Този материал е логичното продължение на моята статия Създаване на най-простия уеб проект в IntelliJ Idea Enterprise . В тази статия демонстрирах How да създам работещ шаблон за уеб проект. Този път ще ви покажа How да създадете просто, но напълно привлекателно уеб приложение, използвайки Java Servlet API и JavaServer Pages API . Нашето приложение ще има начална page с две връзки:

връзка към page за добавяне на потребители;
връзка към списъка с потребители.

Както преди, ще използвам IntelliJ Idea Enterprise Edition , Apache Maven (просто ще свържем някои зависимости) и Apache Tomcat . В крайна сметка ще „разкрасим“ нашето приложение с помощта на рамката W3.CSS . Ще приемем, че вече имате празен проект, към който сега ще добавим. Ако не, прегледайте първата статия и направете такава. Ще отнеме само няколко minutesи :)

Малко за структурата на нашето бъдещо приложение

Нашата начална page (/) ще бъде най-обикновена статична HTML page с хедър и две връзки/бутони:

добавяне на нов потребител (преминава към / добавяне );
преглед на списъка с потребители (придвижва се до / list ).

Tomcat ще улови заявки за тези addressи и ще ги изпрати до един от двата сървлета, които ще направим (ще уточним картографирането в web.xml ). След това сървлетите ще обработят заявките, ще подготвят данни (or ще запазят данни, ако добавяме потребител) и ще прехвърлят контрола към подходящите JSP файлове , които след това „рендират“ резултата. Ще съхраняваме данните в обикновен ванилен списък (списък).

Създайте статична начална page

Ако index.jsp във вашата уеб папка, изтрийте го. Вместо това създайте прост HTML файл , наречен index.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>

Тук няма нищо сложно. В тага за заглавие посочваме заглавието на нашата page. В тялото на pageта имаме два основни div: заглавка и съдържание . Разделът за съдържание включва държач за нашите бутони. И там имаме два бутона, които ви отвеждат до съответния address с едно кликване. Можете да стартирате проекта и да видите How изглежда сега. Ако щракнете върху бутоните, ще получите страници с грешка 404, защото съответните страници все още не съществуват. Но можем да кажем, че бутоните работят. Обърнете внимание, че това не е най-универсалният подход: ако JavaScript е изключен в браузъра, тези бутони няма да работят. Но ще приемем, че никой не деактивира JavaScript. :) Очевидно можете да минете с прости връзки, но аз предпочитам бутони. Можете да го направите Howто предпочитате. И не се притеснявайте от факта, че моите примери ще имат много divs . По-късно ще ги напълним със стилове и всичко ще изглежда по-красиво. :)

Създайте JSP файлове, за да изобразите резултата

В същата уеб директория създайте папка, където ще добавим нашите JSP файлове . Нарекох го „ изгледи “, но отново можете да импровизирате. В тази папка ще създадем два JSP file:

add.jsp — page за добавяне на потребители;
list.jsp — page за показване на списъка с потребители.

Задайте им подходящи заглавки на страници. Нещо като „ Добавяне на нов потребител “ и „ Списък с потребители “ и ще го оставим така.

Създайте два сервлета

Сървлетите ще получават и обработват заявките, които Tomcat им изпраща. В папката src/main/java създайте пакета на приложението , където ще поставим нашия изходен code. Там ще отидат и други пакети. Така че, за да предотвратим създаването на тези пакети един в друг, ще създадем няHowъв клас в пакета на приложението (ще го изтрием по-късно). Сега създайте три различни пакета в пакета на приложението :

обекти — нашите обекти (класът, който описва потребителски обекти) отиват тук;
модел — тук отива нашият модел (ще говорим за това малко по-късно);
сървлети — и тук отиват нашите сервлети.

След като направите това, можете спокойно да изтриете този клас от пакета на приложението (ако сте го създали, разбира се). В пакета сервлети създайте два класа:

AddServlet — обработва заявки, изпратени до / add ;
ListServlet — обработва заявки, изпратени до / list .

Свързване на зависимости в Maven

Tomcat 9 .* изпълнява спецификациите за Servlet 4.0 и JavaServer Pages 2.3 . Това е посочено във втория ред на първия параграф от официалната documentация на Tomcat 9. Това означава, че ако вие като мен използвате тази version на Tomcat , тогава codeът, който ще напишете и стартирате, ще използва тези версии. Но бихме искали да имаме тези спецификации в нашия проект, така че нашият code, който ги използва, поне да се компorра успешно. И за да направим това, трябва да ги заредим в нашия проект. Тук на помощ идва Мейвън .

Общото правило е следното: ако трябва да свържете нещо към вашия проект с помощта на Maven:

отидете на уебсайта на хранorщето от Maven;
намерете необходимата version на необходимата библиотека;
вземете codeа на зависимостта, който трябва да бъде поставен във вашия pom.xml;
паста! :)

Нека да започнем. Първо, подгответе POM file . Някъде след записа /version , но преди /project , вмъкнете следното:


<dependencies>

</dependencies>

Правим това, за да покажем, че ще изброим необходимите зависимости в тези тагове. Сега отидете на mvnrepository.com . В горната част има поле за търсене. За да започнете, потърсете „ servlet “. Първият резултат, който е използван повече от седем хиляди пъти, ни устройва. Не забравяйте, че имаме нужда от version 4.0 (за Tomcat 9). Други версии може да са подходящи за по-стари реализации. Това е сравнително нова version, така че няма толкова много applications. Но имаме нужда от него. Отваря се page, където можете да получите codeа за тази зависимост за различни мениджъри на пакети or можете просто да го изтеглите. Но тъй като искаме да го свържем с помощта на Maven, ще изберем codeа в раздела Maven. Копираме и поставяме в раздела за зависимости на нашия POM файл. Ако получите известие с въпрос дали искате да активирате автоматично импортиране в долния десен ъгъл на IDEA , продължете и се съгласете с него. Ако случайно сте отказали, отидете на „ Настройки “ и включете ръчно автоматично импортиране: Настройки (Ctrl + Alt + S) -> Build, Execution, Deployment -> Maven -> Importing .и конфигурационните файлове на IDEA за този проект в синхрон. Следвайки същия принцип, ще намерим и свържем JavaServer Pages 2.3 (потърсете „JSP“). И тъй като вече стартирахме Maven, нека просто му кажем, че нашите изходни файлове следват синтаксиса на Java 8 и че трябва да ги компorраме в byte code за тази version. След всички тези стъпки нашият pom.xml ще изглежда така:


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

Направете нашите сервлети в истински сервлети

В момента двойката сървлети, които създадохме, всъщност са обикновени класове. Те нямат ниHowва функционалност. Но сега свързахме Servlet API към нашия проект и съответно можем да използваме неговите класове. За да направим нашите сервлети „истински“, всичко, което трябва да направим, е да ги накараме да наследят класа HttpServlet .

Картографиране or маркиране

Сега би било хубаво по няHowъв начин да кажете на Tomcat , че заявките за / add address се обработват от нашия AddServlet , а заявките за / list address се обработват от ListServlet . Този процес се нарича картографиране (маркиране). Това се прави в web.xml по същия принцип:

за да започнете, опишете сървлета (предоставете няHowво име и укажете пътя до самия клас);
след това обвържете този сървлет с определен address (посочете името на сървлета, което току-що му дадохме, и посочете address, чиито заявки трябва да бъдат изпратени до този сървлет).

Опишете сървлета:


<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>

Сега го свържете с address:


<servlet-mapping>
    <servlet-name>add</servlet-name>
    <url-pattern>/add</url-pattern>
</servlet-mapping>

Както можете да видите, servlet-name е едно и също и в двата случая. В резултат на това Tomcat знае, че ако се получи заявка за /add, тя трябва да бъде изпратена до app.servlets.AddServlet. Правим същото с втория сервлет. В крайна сметка нашият web.xml има приблизително следното съдържание:


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

Между другото, ние не създадохме маркиране за началната page (/). Факт е, че в случая не ни трябва. Нашата начална page е прост HTML файл, който показва само два бутона. Той няма динамично съдържание, така че не е необходимо да създаваме отделен сървлет за заявки от / , които няма да правят нищо друго, освен да препращат изпълнение към няHowъв JSP (който също трябва да бъде създаден), за да начертае два бутона за нас. Нямаме нужда от това. Статична page ни подхожда. Когато Tomcat получи заявка, той ще провери дали има един единствен сървлет, който може да обработи заявката за този address, и след това ще види, че този address всъщност вече съдържа готовия HTML файл, които ще сервира. Можем да стартираме нашето приложение отново (рестартиране на сървъра or повторно разпределяне - Howвото предпочитате) и да се уверим, че началната page е изобразена, нищо не е счупено и преходите се извършват, когато щракнем върху бутоните (макар че отново получаваме грешка). Между другото, докато преди получавахме грешка 404, сега получаваме 405. Това означава, че картографирането е работило и сървлетите са намерени, но те не са имали подходящ метод за обработка на заявката.

Кратко отклонение: Howво се случва "под капака"?

Вероятно вече сте се замисляли How работи нашето приложение в Tomcat. Какво се случва там? И къде е методът main()? Веднага след като отидете на localhost:8080 във вашия браузър, браузърът изпраща заявка до този address, използвайки HTTP протокола. Надявам се вече сте наясно, че има много различни видове заявки, а най-популярните са GET и POST. На всяка молба трябва да се отговори. Очаква се GET заявка да получи отговор от готов за използване HTML code, върнат на браузъра. След това браузърът замества codeа с всички красиви букви, бутони и формуляри. POST заявката е малко по-интересна, тъй като също носи известна информация. Да предположим например, че въвеждате идентификационни данни във формуляр за регистрация or влизане на уебсайт и щракнете върху „Изпращане“. Това води до изпращане на POST заявка с вашата лична информация до сървъра. Сървърът получава тази информация, обработва я и връща няHowъв отговор (например HTML page с вашия профил). Основната разлика между тях е, че GET заявките се използват само за извличане на данни от сървъра, докато POST заявките носят известна информация (и данните на сървъра могат да се променят). Например, когато качите вашата снимка на сървъра, тя се пренася там в POST заявка и сървърът я добавя към базата данни, т.е. настъпва промяна. Сега обратно към Tomcat. Когато получи заявка от клиент, преглежда address. Той проверява дали има подходящ сервлет за обработка на заявки за този address (or наличен ресурс, който може да бъде върнат незабавно). Ако не намери нещо за връщане, тогава той отговаря с грешка 404, а не с HTML page. Но ако намери подходящ сървлет, който "седи" на този address, тогава той разглежда типа заявка (GET, POST or нещо друго) и пита сървлета дали има метод, който може да обработва този тип заявка. Ако сървлетът каже, че не знае How да се справи с този тип, тогаваTomcat връща code 405. И точно това се случи в нашия проект. Но ако бъде намерен подходящ сервлет и той има подходящ метод, тогава Tomcat създава обект на сервлет, стартира го в нова нишка(което му позволява да работи сам), а Tomcat продължава собствената си работа, като приема и изпраща заявки. Освен това Tomcat създава още два обекта: HttpServletRequest (който ще наричам накратко „заявка“) и HttpServletResponse (който ще наричам „отговор“). Той поставя всички данни, получени от заявката на клиента, в първия обект, така че всички тези данни могат да бъдат извлечени от него. И след всичко това, той предава тези два обекта на подходящия метод на сървлета, който е стартиран в отделна нишка. Веднага щом сървлетът приключи работата си и има готов отговор за изпращане до клиента, той размахва флаг към Tomcat, казвайки „Готово. Всичко е готово“. Tomcat получава отговора и го изпраща на клиента. Това позволява на Tomcat да получава заявки и да изпраща отговори, без да се разсейвате и цялата работа се извършва от сървлети, работещи на отделни нишки. Това означава, че когато пишем codeа на сервлета, ние определяме Howва работа ще бъде извършена. Можете да мислите, че методът main() се намира в самия Tomcat (да, написан е на Java) и когато „стартираме“ Tomcat, методът main() се стартира.

Създаване на просто уеб приложение с помощта на сървлети и JSP (част 1) - 2

Използвайте сървлети, за да уловите GET методи и да изпратите супер прости отговори

В момента нашите сервлети нямат подходящи методи (GET), така че Tomcat връща грешка 405. Нека ги създадем! Класът HttpServlet, който ние нашите сървлети наследяваме, декларира различни методи. За да присвоим конкретен code на методите, ние просто ги заместваме. В този случай трябва да заменим doGet()метода и в двата сървлета.


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

}

Както можете да видите, този метод приема два аргумента: req (заявка) и resp (отговор). Това са самите обекти, които Tomcat създава и попълва за нас, когато извиква подходящия метод в сървлета. Като начало ще създадем най-простите отговори. За да направим това, ще вземем обекта resp и ще получим обект PrintWriter от него. Този тип обект се използва за съставяне на отговор. Ще го използваме, за да изведем прост низ.


@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("GET method from AddServlet");
}

Ще направим нещо подобно в ListServlet и след това ще рестартираме нашия сървър. Както можете да видите, всичко работи! Когато щракнете върху бутоните, получавате страници с текста, който сме "написали" с PrintWriter. Но JSP файловете, които подготвихме за генериране на страници с отговори, не се използват. Това е просто защото те никога не са екзекутирани. Нашият сървлет сам създава отговора и завършва изпълнението, сигнализирайки на Tomcat, че е готов да отговори на клиента. Tomcat просто взема отговора и го изпраща обратно на клиента.

Нека да предадем управлението от сервлетите към JSP файловете. Ще променим codeа на нашите методи, Howто следва:

получаваме обект за изпращане на заявки от обекта на заявката и му предаваме address на JSP pageта, на която искаме да прехвърлим управлението;
ние използваме този обект, за да прехвърлим контрола към посочената JSP page, като не забравяме да предадем обектите за заявка и отговор, които получихме от Tomcat.


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

В етикета body на JSP страниците можете да добавите нещо, за да можем ясно да видим коя page се показва. След като направите това, рестартирайте сървъра и проверете. Щракваме върху бутоните на главната page и страниците се отварят, което означава, че заявките се изпращат към сървлетите. След това контролът се предава на JSP страниците, които сега се изобразяват. Това е всичко за сега. В следващата част на тази статия ще работим върху функционалността на нашето приложение.

Още четене:
Създаване на просто уеб приложение с помощта на сървлети и JSP (част 2) Вашето първо приложение, използващо Java сървлети

Коментари

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION