Java Servlets и JSP: основы веб-разработки для начинающих

Для кого эта статья:

• Новички в веб-разработке, желающие освоить Java
• Студенты и начинающие программисты, изучающие технологии Java EE

• Профессионалы, интересующиеся основами и архитектурой Java веб-приложений

  Мир Java веб-разработки часто кажется новичкам непроходимыми джунглями технологий и терминов. Servlets и JSP — два мощных инструмента, которые, несмотря на свой возраст, остаются фундаментом для создания надёжных серверных приложений. В этой статье я расскажу, как эти технологии работают, почему они важны даже в эпоху модных JavaScript-фреймворков, и как построить своё первое веб-приложение на Java без лишней головной боли. 🚀

Хотите быстро освоить веб-разработку на Java и создавать профессиональные приложения? Курс Java-разработки от Skypro проведёт вас от основ программирования до продвинутых техник работы с Servlets и JSP. Вы получите не только теоретические знания, но и реальные проекты в портфолио под руководством опытных разработчиков. Инвестируйте в навыки, которые востребованы на рынке прямо сейчас!

Что такое Servlets и JSP: фундамент Java веб-разработки

Servlets и JSP (JavaServer Pages) — это две ключевые технологии Java EE (Enterprise Edition), которые позволяют создавать динамические веб-приложения. Несмотря на появление множества современных фреймворков, понимание этих базовых технологий критически важно для каждого Java веб-разработчика.

Представьте, что вы строите дом. Сервлеты — это прочный фундамент и несущие стены, а JSP — это интерьерное оформление и отделка. Без понимания того, как работает фундамент, невозможно построить устойчивый дом.

Сервлеты — это Java-классы, которые расширяют функциональность веб-сервера. Они обрабатывают HTTP-запросы, взаимодействуют с базами данных, вызывают другие веб-сервисы и формируют ответы клиенту. Сервлеты работают на серверной стороне и могут генерировать динамический контент.

Основные характеристики сервлетов:

• Работают внутри контейнера сервлетов (например, Apache Tomcat)
• Могут обрабатывать различные типы HTTP-запросов (GET, POST, PUT и т.д.)
• Сохраняют состояние между запросами через сессии
• Имеют доступ ко всей мощи Java API

JSP (JavaServer Pages) — технология, позволяющая создавать динамические веб-страницы с использованием HTML, XML и встроенного Java-кода. JSP-страницы компилируются в сервлеты перед выполнением, что обеспечивает высокую производительность.

Михаил Петров, старший Java-разработчик

Когда я впервые столкнулся с задачей создания веб-приложения на Java, я потратил недели на изучение различных фреймворков, пытаясь выбрать "лучший". В итоге, запутавшись в Spring, Struts и JSF, я вернулся к основам — Servlets и JSP. Создав небольшое приложение для учёта личных финансов, я понял, насколько эффективен этот "простой" стек. Мы часто недооцениваем базовые технологии, гоняясь за трендами. За два месяца я смог запустить полноценное приложение, которое работало стабильно и обслуживало около 100 пользователей. Позже, когда я начал использовать фреймворки, понимание основ сервлетов помогло мне быстрее осваивать новые инструменты и видеть, что происходит "под капотом".

Преимущества использования JSP:

• Разделение HTML-кода и Java-логики
• Возможность использования тегов для упрощения разработки
• Поддержка Expression Language (EL) для доступа к данным
• Встроенная поддержка JSTL (JSP Standard Tag Library)

Архитектура Java веб-приложений: основные компоненты

Стандартная архитектура Java веб-приложений на основе Servlets и JSP обычно следует паттерну MVC (Model-View-Controller), где сервлеты выступают в роли контроллеров, JSP — в роли представлений, а Java-классы — в роли моделей. 🏗️

Основные компоненты архитектуры:

• Веб-контейнер (Servlet Container) — среда выполнения для сервлетов и JSP
• Сервлеты — обрабатывают запросы и управляют потоком данных
• JSP — формируют пользовательский интерфейс
• Фильтры — перехватывают запросы для предобработки или постобработки
• Слушатели (Listeners) — отслеживают события в веб-приложении
• JavaBeans — хранят и обрабатывают данные

Жизненный цикл веб-приложения начинается с развертывания WAR-файла (Web Application Archive) в веб-контейнере. Контейнер создаёт экземпляры сервлетов, инициализирует их и обрабатывает входящие HTTP-запросы.

Типичный поток выполнения запроса в Java веб-приложении:

1. Клиент отправляет HTTP-запрос на сервер
2. Запрос проходит через настроенные фильтры
3. Веб-контейнер определяет нужный сервлет на основе URL-маппинга в web.xml
4. Сервлет обрабатывает запрос, взаимодействует с бизнес-логикой и готовит данные
5. Сервлет перенаправляет запрос на соответствующую JSP-страницу
6. JSP отображает данные в формате HTML
7. Ответ отправляется клиенту

Все компоненты Java веб-приложения настраиваются в дескрипторе развертывания web.xml или с помощью аннотаций (в более новых версиях Java EE). Этот файл определяет структуру приложения, маппинги URL, инициализационные параметры и многое другое.

Структура типичного Java веб-проекта выглядит следующим образом:

webapp/
├── WEB-INF/
│ ├── web.xml
│ ├── classes/
│ │ └── com/
│ │ └── example/
│ │ ├── servlets/
│ │ ├── models/
│ │ └── utils/
│ ├── lib/
│ │ └── (JAR-файлы)
│ └── tags/
├── css/
├── js/
├── images/
└── *.jsp

Создание первого сервлета: от теории к практике

Разработка первого сервлета — это ключевой шаг в освоении Java веб-программирования. Давайте рассмотрим практический пример создания простого сервлета, который обрабатывает HTTP-запросы и генерирует ответы. 💻

Для работы с сервлетами вам потребуется:

• JDK (Java Development Kit) версии 8 или выше
• Веб-контейнер (Apache Tomcat, Jetty или аналог)
• Servlet API (обычно включается в веб-контейнер)
• IDE (например, IntelliJ IDEA или Eclipse)

Шаг 1: Создайте новый проект веб-приложения в вашей IDE.

Шаг 2: Добавьте зависимость Servlet API в ваш pom.xml (для Maven) или build.gradle (для Gradle):

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>

Шаг 3: Создайте ваш первый сервлет:

package com.example.servlets;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException {

response.setContentType("text/html");
response.setCharacterEncoding("UTF-8");

try (PrintWriter writer = response.getWriter()) {
writer.println("<!DOCTYPE html>");
writer.println("<html>");
writer.println("<head>");
writer.println("<title>Мой первый сервлет</title>");
writer.println("</head>");
writer.println("<body>");
writer.println("<h1>Привет, мир сервлетов!</h1>");
writer.println("<p>Текущее время: " + new java.util.Date() + "</p>");
writer.println("</body>");
writer.println("</html>");
}
}
}

Шаг 4: Настройте дескриптор развертывания 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_4_0.xsd"
version="4.0">

<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>com.example.servlets.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>helloServlet</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>

</web-app>

Шаг 5: Разверните ваше приложение в веб-контейнере (например, Tomcat) и протестируйте, открыв в браузере http://localhost:8080/your-app/hello.

Основные методы, которые вы можете переопределить в сервлете:

• doGet() — обработка GET-запросов (получение данных)
• doPost() — обработка POST-запросов (отправка данных)
• doPut() — обработка PUT-запросов (обновление ресурсов)
• doDelete() — обработка DELETE-запросов (удаление ресурсов)
• init() — инициализация сервлета
• destroy() — освобождение ресурсов перед уничтожением сервлета

Для обработки параметров запроса используйте метод getParameter():

String username = request.getParameter("username");

Для работы с сессией используйте методы getSession():

HttpSession session = request.getSession();
session.setAttribute("user", username);
String user = (String) session.getAttribute("user");

Алексей Соколов, веб-разработчик

На проекте электронной коммерции для крупного ритейлера я столкнулся с интересной задачей — нужно было добавить функциональность для обработки платежей с минимальными изменениями существующей архитектуры. Решение на основе сервлетов оказалось идеальным. Я создал отдельный сервлет PaymentProcessorServlet, который принимал данные формы оплаты, взаимодействовал с платёжным шлюзом через API и перенаправлял пользователя на страницу результата.

Самая сложная часть заключалась в обеспечении безопасности транзакций. Я реализовал фильтр сервлетов для проверки CSRF-токенов и шифрования чувствительных данных. Благодаря гибкости сервлетов и их прямому доступу к HTTP-запросам/ответам, мне удалось внедрить эту функциональность за три дня, без изменения существующего кода. Система успешно обрабатывает до 1000 транзакций в день, и за полгода работы не было ни одного инцидента с безопасностью.

JSP страницы: динамический HTML на основе Java

JavaServer Pages (JSP) — технология, которая позволяет создавать динамические веб-страницы, сочетая статический HTML с Java-кодом. JSP значительно упрощает создание пользовательских интерфейсов по сравнению с генерацией HTML напрямую из сервлетов. 🖌️

JSP-файлы имеют расширение .jsp и содержат HTML с вставками специальных тегов и Java-кода. При первом обращении к JSP-странице она компилируется в сервлет, который затем выполняется. Результаты кэшируются, поэтому последующие запросы выполняются быстрее.

Основные элементы JSP:

• Директивы — настройки для процесса компиляции JSP (<%@ ... %>)
• Скриптлеты — блоки Java-кода (<% ... %>)
• Выражения — вычисляемые и отображаемые значения (<%= ... %>)
• Объявления — определения методов и переменных (<%! ... %>)
• Комментарии — не видны клиенту (<%-- ... --%>)
• Действия — стандартные операции, например, включение других файлов (<jsp:include>)
• EL-выражения — упрощённый доступ к данным (${...})
• JSTL — библиотека стандартных тегов для типичных задач

Пример простой JSP-страницы:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
<title>Моя первая JSP-страница</title>
</head>
<body>
<h1>Привет, JSP!</h1>

<% 
// Это скриптлет – блок Java-кода
java.time.LocalDateTime now = java.time.LocalDateTime.now();
%>

<p>Текущая дата и время: <%= now %></p>

<% 
for(int i = 1; i <= 5; i++) { 
%>
<p>Строка №<%= i %></p>
<% 
} 
%>

<!-- Использование Expression Language (EL) -->
<p>Доступ к параметру запроса: ${param.name}</p>
</body>
</html>

Неявные объекты в JSP, доступные без объявления:

JSP Standard Tag Library (JSTL) предоставляет готовые теги для типичных задач программирования:

• Core — базовые операции (условия, циклы)
• Formatting — форматирование данных (чисел, дат)
• SQL — работа с базами данных
• XML — обработка XML
• Functions — полезные функции для работы со строками

Пример использования JSTL:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<body>
<h1>Список пользователей</h1>
<c:forEach var="user" items="${userList}">
<p>${user.name} – ${user.email}</p>
</c:forEach>

<c:if test="${not empty message}">
<p class="message">${message}</p>
</c:if>
</body>
</html>

Для использования JSTL необходимо добавить соответствующие зависимости в проект и импортировать нужные библиотеки тегов с помощью директивы taglib.

Интеграция Servlets и JSP для создания полноценных сайтов

Интеграция сервлетов и JSP — это ключ к созданию хорошо структурированных веб-приложений на Java. Такой подход реализует паттерн MVC (Model-View-Controller), где сервлеты выступают контроллерами, JSP — представлениями, а Java-классы — моделями. 🔄

Рассмотрим типичный рабочий процесс интеграции:

1. Клиент отправляет HTTP-запрос на сервер
2. Сервлет перехватывает запрос и определяет действие
3. Сервлет взаимодействует с бизнес-логикой (моделью)
4. Данные сохраняются в объектах запроса, сессии или контекста
5. Сервлет перенаправляет запрос на JSP-страницу
6. JSP-страница отображает данные и формирует HTML-ответ

Передача данных от сервлета к JSP осуществляется несколькими способами:

• Через атрибуты запроса (для данных, актуальных только для текущего запроса)
• Через атрибуты сессии (для данных, сохраняемых между запросами одного пользователя)
• Через атрибуты контекста приложения (для глобальных данных, доступных всем пользователям)

Пример интеграции сервлета и JSP для отображения списка пользователей:

1. Сервлет:

@WebServlet("/users")
public class UserListServlet extends HttpServlet {

private UserService userService = new UserService(); // Сервис для работы с данными

@Override
protected void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException {

// Получаем данные из модели
List<User> users = userService.getAllUsers();

// Сохраняем данные в атрибуте запроса
request.setAttribute("userList", users);

// Перенаправляем на JSP для отображения
request.getRequestDispatcher("/WEB-INF/views/user-list.jsp")
.forward(request, response);
}
}

2. JSP-страница (user-list.jsp):

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Список пользователей</title>
<link rel="stylesheet" href="${pageContext.request.contextPath}/css/style.css">
</head>
<body>
<h1>Пользователи системы</h1>

<table>
<tr>
<th>ID</th>
<th>Имя</th>
<th>Email</th>
<th>Действия</th>
</tr>
<c:forEach var="user" items="${userList}">
<tr>
<td>${user.id}</td>
<td>${user.name}</td>
<td>${user.email}</td>
<td>
<a href="user?id=${user.id}">Просмотр</a>
<a href="user/edit?id=${user.id}">Редактировать</a>
<a href="user/delete?id=${user.id}">Удалить</a>
</td>
</tr>
</c:forEach>
</table>

<a href="user/create">Добавить нового пользователя</a>
</body>
</html>

Для обработки форм обычно используется сочетание GET и POST запросов:

• GET — для отображения формы
• POST — для обработки отправленных данных

Пример обработки формы:

@WebServlet("/user/create")
public class UserCreateServlet extends HttpServlet {

private UserService userService = new UserService();

// Отображение формы
@Override
protected void doGet(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException {

request.getRequestDispatcher("/WEB-INF/views/user-form.jsp")
.forward(request, response);
}

// Обработка отправленных данных
@Override
protected void doPost(HttpServletRequest request, 
HttpServletResponse response) 
throws ServletException, IOException {

String name = request.getParameter("name");
String email = request.getParameter("email");
String password = request.getParameter("password");

try {
User user = new User(name, email, password);
userService.createUser(user);

// Добавляем сообщение об успехе
request.getSession().setAttribute("message", 
"Пользователь успешно создан!");

// Перенаправляем на список пользователей
response.sendRedirect(request.getContextPath() + "/users");
} catch (Exception e) {
// В случае ошибки возвращаем на форму с сообщением
request.setAttribute("error", e.getMessage());
request.setAttribute("user", new User(name, email, ""));
request.getRequestDispatcher("/WEB-INF/views/user-form.jsp")
.forward(request, response);
}
}
}

Важные практики при интеграции Servlets и JSP:

• Размещайте JSP-страницы в папке WEB-INF для предотвращения прямого доступа
• Используйте EL и JSTL вместо скриптлетов для улучшения читаемости JSP
• Применяйте единый шаблон для всех страниц (header, footer, navigation)
• Валидируйте входные данные в сервлетах перед обработкой
• Используйте PRG-паттерн (Post-Redirect-Get) для предотвращения повторной отправки форм

Освоение Servlets и JSP — важный шаг в карьере Java-разработчика. Эти технологии не только формируют основу для понимания более сложных фреймворков, но и позволяют создавать полноценные веб-приложения с чистой и понятной архитектурой. Начните с простых проектов, постепенно добавляя новые компоненты, и вы быстро почувствуете, как растут ваши навыки веб-разработки на Java. Помните — в программировании нет универсальных решений, и знание фундаментальных технологий даёт вам мощный инструментарий для решения любых задач.

Читайте также

• VS Code для Java: легкая среда разработки с мощным функционалом
• Циклы for и for each в Java: различия и практика применения
• Профессиональные практики Java-разработки: от новичка к мастеру кода
• Групповая обработка данных в Java: Stream API для разработчиков
• Алгоритмы сортировки в Java: от базовых методов до TimSort
• Лучшая Java IDE: выбор инструментов для разработки проектов
• Обработка исключений в Java: защита кода от ошибок в продакшене
• Наследование в Java: основы, типы, применение в разработке
• Как стать Java-разработчиком без опыта: 5 проверенных шагов
• Java-разработка для Android: создание мобильных приложений с нуля