Вашето първо приложение, използващо Java сървлети

Здравейте всички! Ще се запознаете със сървлетите като основна концепция за уеб разработка и ще можете да напишете просто приложение, което ги използва. За да избегнем ненужни действия, няма да започнем от нулата. Ще продължим да работим върху нашето приложение от предишната ми статия за Hibernate . Но тъй като тепърва започваме да се запознаваме със сървлетите, премахнах всичко свързано с класа Auto от приложението и оставих само класа User и действията, свързани с него. Проектът ще бъде структуриран по следния начин: И така, сервлети! Wikipedia гласи: „Сървлетът на Java е софтуерен компонент на Java, който разширява възможностите на сървър. Въпреки че сървлетите могат да отговорят на много видове заявки, те най-често внедряват уеб контейнери за хостване на уеб applications на уеб сървъри и по този начин се квалифицират като сървър- страничен сървлет уеб API." Това е точно така. Тук за първи път се натъкваме на концепцията за "архитектура на приложение клиент-сървър". В основата си е доста проста. Клиентът осъществява достъп до сървъра чрез изпращане на HTTP заявка. Сървърът генерира необходимите данни (например извлича ги от база данни) и ги връща на клиента. Най-простият пример е, когато щракнете върху бутона „Приятели“ в определена социална мрежа, като по този начин изпратите заявка до сървъра. Сървърът актуализира списъка с вашите приятели в базата данни и го връща на вас (клиента). Списъкът с HTTP заявки е доста голям, така че ако никога преди не сте ги срещали, тогава би било най-добре да прочетете за тях другаде, напр.тук _ Нашата цел е да: Създаваме CRUD приложение с помощта на сървлети. Приложението трябва да може да създава, чете, актуализира и изтрива потребители от базата данни с помощта на сървлет, който обработва HTTP заявки. Нашето приложение от статията за Hibernate вече можеше да направи това, но се управляваше директно от codeа на Java, по-точно от метода main(). Този път клиентът е този, който ще изпраща заявките, т.е. вие :) Първото нещо, което трябва да направим е да добавим нови зависимости към нашия 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>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>
 

Добавихме 3 зависимости:

1. Самата библиотека javax.servlet-api
2. Библиотеката с етикети JSTL. Ще е необходимо за създаване на клиентската страна, а именно JSP страниците
3. Spring-WebMVC. Ще ни трябва един пролетен клас, за който ще говорим малко по-късно.

Управлението на сервлетите се управлява от контейнера на сервлетите. В нашия случай ще използваме Apache Tomcat. Доста е популярен — вероятно вече сте чували за него :) Жизненият цикъл на сервлета се състои от следните стъпки:

1. Ако в контейнера няма сървлет:
   
   • Класът сървлет се зарежда от контейнера.
   • Контейнерът създава екземпляр на класа сервлет.
   • Контейнерът извиква метода init(). Този метод инициализира сървлета и се извиква първо, преди сървлетът да може да обслужва заявки. През целия жизнен цикъл методът init() се извиква само веднъж.
2. Обслужване на заявка на клиента. Всяка заявка се обработва в отделна нишка. Контейнерът извиква метода service() за всяка заявка. Този метод определя вида на входящата заявка и я изпраща към подходящия метод за обработка. Разработчикът на сървлета трябва да осигури реализации за тези методи. Ако пристигне заявка за манипулатор, който не е имплементиран, методът на родителския клас се извиква и обикновено завършва с връщане на грешка на заявителя.


3. Ако контейнерът трябва да премахне сървлета, той извиква метода destroy(), който изважда сървлета от работа. Подобно на метода init(), този метод също се извиква веднъж по време на целия цикъл на сервлета.

Нашият сервлет изглежда доста прост:

 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");
     }
 }
 

Както можете да видите, той съдържа метода init(), който беше описан по-горе, и имплементира 4 метода, които съвпадат с четири HTTP заявки: doPost(), doGet(), doPut() и doDelete(). Те ни позволяват да създаваме, четем, актуализираме и изтриваме потребители. Методите приемат екземпляри на класовете javax.servlet.http.HttpServletRequest и javax.servlet.http.HttpServletResponse като вход, т.е. заявки, изпратени до сървъра, и отговори, получени от клиента. Вътрешно методите извикват съответните методи на класа UserService и се генерира отговор за клиента и се пренасочва към /users URL. Например в метода doGet() получаваме списък с всички потребители. След това създаваме обект RequestDispatcher, който ни позволява да включваме обекти в HTTP заявка и да я пренасочваме към конкретен ресурс (например към JSP page на клиент). В метода doPut() (който актуализира потребителските данни) ние обработваме HTTP заявка, извличаме параметрите за идентификатор, име и възраст, намираме потребителя с посочения идентификатор, присвояваме му името и възрастта, посочени в заявката, и връщаме към pageта /потребители. Но за да работят правилно всички тези методи, трябва да конфигурираме сървлета. За целта използваме file web.xml в папката WEB-INF.

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

Всички тагове в този файл са доста интуитивни, но нека ги прегледаме по ред. <welcome-file-list> - Показва се началната JSP page, която ще се отвори първа при стартиране на приложението. В нашия случай това е index.jsp. <servlet> - Регистрация на нашия клас UserSimpleServlet като сервлет. <servlet-mapping> - много важен таг. Той дефинира URL addressите, които ще бъдат обработени от сървлета. В нашия случай това са всички URL addressи, така че просто посочваме "/". Но ако имахме приложение, включващо потребители и техните автомобor (автомобor), тогава бихме могли да създадем втори сървлет (SimpleAutoServlet). Тогава съпоставянето на потребителския сървлет ще бъде "/users" (т.е. заявки за потребители), а съпоставянето на автоматичния сървлет ще бъде "/autos". И накрая, <filter>. Вътрешно той дефинира екземпляр на org. springframework.web.filter.HiddenHttpMethodFilter клас. Тази статия не е за пролетта, така че няма да я описвам подробно. Ще кажа само, че е монтиран в нашето приложение само като допълнителна функция. Работата е там, че ще използваме JSP страници, за да създадем клиентската страна. Нашите данни ще бъдат показани на pageта като table със списък на потребителите. Вътре в JSP страниците ще се използват <form/> HTML тагове. Но само HTTP GET и POST заявки могат да се използват за изпращане на данни от <form/>. С други думи, и за трите операции - актуализиране, изтриване и създаване на потребител - ще трябва да използваме само POST заявки. Използването на заявки PUT и DELETE не би било опция за нас. По принцип това е съвсем нормално и лесно за изпълнение, но класът HiddenHttpMethodFilter ни позволява да ги използваме. По този начин, читателят ще види по-ясно разликата между операциите в приложението. И накрая, нека преминем към клиентската страна. Той е представен от пет JSP страници. 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>
 

JSP (JavaServer Page) page съдържа два типа текст: статични изходни данни, които могат да бъдат форматирани като текст (HTML, SVG, WML or XML), и JSP елементи, използвани за конструиране на динамично съдържание. За да ви помогна да разберете Howво е JSP page, копирах пасаж от много добра статия. „По принцип първият път, когато се поиска JSP, той се превръща в сървлет и работи като сървлет. Това е много важно да се разбере. JSP pageта НЕ Е като HTML page – начинаещият програмист трябва ясно да разбере, че това е друг сървлет — просто не пишете, трябва да програмирате How се показва. Може просто да бъде начертано. И да добавите данни, където е необходимо. Но тъй като JSP pageта напомня на HTML, дизайнерът очевидно ще го намери по-лесно. И още веднъж СИЛНО НАБЛЕГАЙТЕ на начинаещите,JSP page е SERVLET. Той се генерира, включително добавянето на всички данни, на сървъра. Това е мястото, където се въвеждат всички данни. И в браузъра потребителят получава готовата HTML page, която няма признаци на Java." Можете да сте сигурни, че една JSP page наистина е сървлет, защото всяка page има метод, който трябва да бъде изпълнен. Например индекс .jsp показва, че когато щракнете върху бутона "Започнете работа с базата данни", ще се изпълни методът get (method = "get"). Страницата addUser.jsp, която отговаря за създаването на нови потребители, изпълнява метода post (method = "post"), когато щракнете върху бутона за запазване. Останалата част от JSP pageта е съставена от обикновен статичен HTML code, така че няма да се спираме на него. Това е тема за друга статия и има много за тази тема в интернет. Така че ние създадохме нашето приложение! Сега трябва да го тестваме в действие! За да направим това, се нуждаем от контейнера за сервлети Apache Tomcat, споменат по-горе. Можете да изтеглите контейнераот официалния сайт (аз използвам version 8). След това трябва да създадем конфигурация в IDEA, за да стартираме нашето приложение през Tomcat. За да направите това, отворете раздела "Редактиране на конфигурации", създайте нова конфигурация и изберете "Tomcat Server Local". В раздела „Сървър за applications“ посочете пътя до папката Tomcat След това отидете на раздела „Внедряване“. Тук конфигурираме внедряването на нашето приложение на локалния сървър. Натиснете "+", изберете "Artifact" -> YourProjectName:war (ще изградим приложението към war файл). И това обобщава всичко! На pageта „Сървър“ можете да видите, че нашето приложение ще работи на http://localhost:8080/. Запазете конфигурацията и й дайте име (аз наричам моята конфигурация "Томи"). След това в раздела Maven в IDEA (от дясната страна) ще използваме приставката за война, за да изградим нашия проект във файл за война (Добавки -> война -> война: война). След като изграждането приключи, стартирайте приложението и изчакайте. Успех! Началната page беше стартирана. Сега кликваме върху бутона „Започнете работа с базата данни“. Нашият index.jsp ще генерира GET заявка, която ще бъде обработена от сървъра. Сървърът ще генерира отговор и ще ни го върне под формата на списък с всички съществуващи потребители (ако приемем, че има потребители в базата данни, разбира се). И ето ги! Ето го! Написахте първото си приложение с помощта на Java сървлети. Това не беше толкова лошо, нали? :) За домашна работа може да възстановите функционалността на колата от предишната статия. С други думи, създайте отделен сървлет и JSP страници за автомобor и научете приложението How да изброява автомобorте на потребител, да добавя нови автомобor към потребител и да ги редактира и изтрива. PS Servlets и JavaServer Pages са доста древни технологии. В интернет често можете да намерите коментари като "Кому са нужни тези стари боклуци?" Отговорът е доста прост: главно хора, които ще работят по реални проекти, където е възможно да се натъкнат на много code, който използва тези технологии. И дори без да разбирате How работи, пак е забавно да нарежете "старите боклуци" на нещо ново :) За по-задълбочено проучване на JSP и сървлетите можете да се обърнете към книгата "Head First Servlets and JSP ". Написана е от същите автори като известната супер книга "Head First Java", която мнозина ще приемат като гаранция за качество :) Надявам се тази статия да е била полезна! Благодаря за вниманието и успех в обучението!