HTTP. Servlets

На первом вводном видео блока 2 данного курса мы поговорим про то, какие пакеты в Java используются для осуществления сетевого взаимодействия. Поговорим про два основных подхода: TCP и UDP Networking, и когда использовать один, а когда другой.

00:00 - Введение
00:27 - java.net и java.nio - два пакета для работы с сетями
02:51 - TCP Networking
05:13 - UDP Networking
05:55 - Когда использовать TCP и UDP
07:43 - Используемое ПО - Java 15 и IntelliJ IDEA

Базовый класс из пакета java.net для отправки запросов серверу - это класс Socket. На занятии на практике разберем, как с ним работать, как отправлять запрос через OutputStream и получать ответ через InputStream, узнаем TCP порты по умолчанию и такой класс как InetAddress.

00:00 - Введение
00:15 - Создание нового проекта
01:05 - Класс Socket
01:46 - TCP порты по умолчанию
03:07 - Использование InputStream и OutputStream
06:52 - Класс InetAddress
08:30 - Резюме

Базовый класс из пакета java.net для получения запросов от клиента - это класс ServerSocket. На занятии на практике разберем, как с ним работать, как обработать запрос через OutputStream и отправить ответ через InputStream. Продемонстрируем один цикл обмена между клиентом и сервером (one round-robin cycle) и несколько (many round-robin cycles). 

00:00 - Введение
00:29 - Класс ServerSocket
01:57 - Блокирующий метод accept
03:07 - Использование InputStream и OutputStream
04:54 - One round-robin cycle
06:56 - Many round-robin cycles

Для реализации сетевого взаимодействия по протоколу UDP в Java из пакета java.net есть класс DatagramSocket. Он используется в качестве реализации как клиента, так и сервера, в отличие от TCP протокола, что мы и продемонстрируем на примерах в видео.

00:00 - Введение
00:30 - Реализация UDP клиента
04:32 - UDP не проверяет успешность отправки
05:35 - Реализация UDP сервера
08:58 - Резюме

Теперь у нас достаточно теоретической и практической базы для более детального изучения основного протокола прикладного уровня - HTTP. На видео подробно разберем, из каких основных логических частей он состоит и что означает каждая из них.

00:00 - Введение
00:15 - Протокол HTTP
01:02 - Клиент-серверная архитектура
01:44 - Веб-сервер
02:05 - Структура HTTP-сообщения
02:30 - Стартовая строка запроса
03:12 - HTTP-метод
03:57 - URL
05:58 - Стартовая строка ответа
06:22 - Response status codes
06:37 - 1xx status codes
07:02 - 2xx status codes
07:41 - 3xx status codes
08:12 - 4xx status codes
08:37 - 5xx status codes
09:02 - Заголовок (Header)
10:22 - Тело (Body)
11:19 - Резюме

Первый класс из пакета java.net для отправки запросов по протоколу HTTP - это URL. Разберем на примерах как с ним работать, а также рассмотрим его возможность отправки POST запросов и даже считывания файлов с жесткого диска. 

00:00 - Введение
00:48 - Класс URL из пакета java.net
02:29 - Работа с Headers и Body
03:57 - POST запросы
05:12 - URL для считывания файлов

На замену класса URL нам пришел новый класс HttpClient, начиная с версии Java 11. На видео разберем отправку основных запросов GET и POST для демонстрации удобства работы с объектом класс HttpClient из пакета java.net.

00:00 - Введение
01:00 - HttpClient для работы по HTTP
03:20 - Класс HttpRequest
04:20 - BodyHandler
05:05 - Класс HttpResponse
06:33 - Отправка POST запроса
07:42 - Резюме

Для того, чтобы корректно передавать и обрабатывать HTTP Body, нам необходимо использовать соответствующие заголовки (Headers). Для этого существует два из них: content-type и accept. Разберемся в них более подробно и какое значение они могут принимать, другими словами поговорим о MIME types. В заключительной части видео узнаем как отслеживать запросы в браузере через инструменты разработчика.

00:00 - Введение
00:21 - Заголовки content-type и accept
01:31 - Структура MIME type
02:57 - Основные типы в MIME type
04:51 - Подтипы в MIME type
05:35 - Инструменты разработчика в браузере

XML формат был когда-то очень распространен и естественно встречается до сих пор в старых проектах, либо когда необходимо интегрироваться в новых проектах со старыми. Также использовалась конфигурация (настройка) приложений через XML формат. К счастью, он был заменен на более современные и не такие многословные форматы как, например, yaml или json. На видео разберем основную структуру XML документов и поймем, как просто он устроен на самом деле, ведь состоит всего лишь из двух основных частей: теги и атрибуты. 

00:00 - Введение
00:33 - Принцип работа с XML
02:06 - Структура XML
03:04 - Tags
03:42 - XML элементы
06:45 - Attributes
07:30 - Резюме
10:12 - XML namespaces

HTML формат всегда используется при работе с браузерами, ведь они отображают информацию пользователю именно благодаря этому текстовому формату данных. Конечно же это не единственное его применение. Например, HTML также используется для генерации и отправки почтовых сообщений. Благодаря тому, что HTML невероятно похож на XML, нам будет довольно просто и легко освоиться с ним. 

00:00 - Введение
00:30 - Структура HTML документа
01:51 - Tag head
03:28 - Tag body
05:23 - Tag form
07:20 - Резюме

Вот мы и дошли до одного из самых распространенных текстовых форматов передачи данных, которые используются в современных приложениях не только на Java, но и в большинстве других языков программирования, - это JSON. Он пришел к нам из языка JavaScript и расшифровывается как JavaScript Object Notation. На видео разберем, почему он перехватил инициативу у более старого формата XML.

00:00 - Введение
00:52 - Преобразование XML в JSON
04:45 - Представление массивов в JSON
06:35 - Резюме

Для того, чтобы понимать, как устроен Apache Tomcat и как он обрабатывает запросы и создает ответы на них, мы напишем свой простой веб-сервер (веб-сервер - это обычное приложение, которое умеет обрабатывать HTTP запросы). Убедимся, что HTTP сообщение версии 1.1 представляет из себя один кусок информации, в отличие от версии протокола HTTP 2, которое мы совсем скоро разберем на следующих видео.

00:00 - Введение
00:44 - Реализация веб-сервера
02:59 - Обработка запроса
05:55 - Создание ответа
08:52 - Отправка POST запроса через HttpClient
11:25 - Тестирование функционала

Как мы помним, метод accept у SocketServer блокирующий, и до тех пор, пока наш веб-сервер вновь не вызовет этот метод - все остальные HTTP запросы будут ожидать, стоя в очереди. Для того, чтобы наш реализованный веб-сервер умел параллельно обрабатывать HTTP запросы, необходимо добавить пул соединений и отправлять обработку каждого HTTP запроса этому пулу. На видео продемонстрируем как это сделать и протестируем написанный функционал.

00:00 - Введение
00:40 - Пул соединений
02:00 - Как остановить веб-сервер
03:25 - Тестирование функционала
04:55 - Резюме

Для лучшего понимания новшеств протокола HTTP/2, мы начнем с истории его возникновения - это 1991 год. Плавно пройдя по всем выпущенным версиям, мы увидим все основные улучшения протокола HTTP/2 и опишем первые два из них: бинарный вместо текстового и мультиплексирование.

00:00 - Введение
00:24 - HTTP/0.9
01:08 - HTTP/1.0
02:35 - Недостатки HTTP/1.0
03:38 - HTTP/1.1
05:34 - Недостатки HTTP/1.1
06:14 - HTTP/2
06:51 - Бинарный протокол
07:23 - Latency
08:00 - Frames и Streams
09:38 - Мультиплексирование

На видео продолжаем разбираться с протоколом HTTP 2 и подробно рассмотрим оставшиеся 4-е основных нововведения: Server Push, Сжатие заголовков методом HPACK, Приоритизация потоков и Безопасность. В самом конце видео посоветую вам отличную книгу для прочтения по шифрам и криптографии.

00:00 - Введение
00:36 - Server Push
04:03 - Сжатие заголовков методом HPACK
05:41 - Пример работы HPACK
10:18 - Приоритизация потоков
11:38 - Безопасность
12:15 - Книга для прочтения

Вот мы и дошли до заключительного третьего блока курса по HTTP. Servlets - это работа с веб-сервером Apache Tomcat, который является самым распространенным в реальных приложениях, написанных на Java. На первом занятии этого блока мы разберем основные его компоненты, установим его на локальный компьютер и попробуем запустить.

00:00 - Введение
00:14 - Веб-сервер Apache Tomcat
01:07 - Основные компоненты Apache Tomcat
02:02 - Структура каталогов Apache Tomcat
03:53 - WAR - Web Archive
04:26 - Установка и распаковка Apache Tomcat
06:44 - Запуск Apache Tomcat
08:15 - Переменные окружения
09:54 - Проверка работоспособности Apache Tomcat

На видео углубимся в конфигурацию веб-сервера Apache Tomcat. Рассмотрим его конфигурацию через основные файлы server.xml и tomcat-users.xml, которые лежат в директории conf. Также зайдем на manager страничку, которая позволяет наблюдать и руководить процессом остановки, разворачивания приложений и т.д. Далее зайдем в директорию webapps, которая отвечает за все приложения, которые запущены на нашем Apache Tomcat. Убедимся в соответствии названий этих приложений и пути в URL для обращения к ним.

00:00 - Введение
00:15 - Документация Apache Tomcat
00:46 - Директория conf
02:30 - Файл tomcat-users.xml
04:10 - manager страница
05:16 - Файл server.xml
06:45 - Директория webapps
08:50 - Резюме

До текущего момента мы ни разу не создавали web приложение на Java. И, как мы видим, структура такого приложения отличается от тех, что мы привыкли создавать. На видео разберем несколько способов создания такого web приложения в среде разработки IntelliJ IDEA, а также как эта среда разработки работает с нашими артифактами (artefacts), что в нашем случае является WAR и его разархивированная версия - WAR exploded. Далее попробуем собрать наш веб архив (WAR) и несколькими способами задеплоить его на Apache Tomcat.

00:00 - Введение
00:34 - Структура WAR - веб-архивов
02:15 - Создание веб-проекта. Способ №1
03:32 - Создание веб-проекта. Способ №2
03:55 - Работа с artefacts в IntelliJ IDEA
06:02 - Директория web в Java проекте
07:01 - Создание WAR
07:40 - Разворачивание WAR в Apache Tomcat
08:59 - Примеры других проектов

Каждый раз собирать WAR и деплоить его вручную в Apache Tomcat, копируя веб-архив (WAR) в директорию webapps - очень неудобно и долго. Поэтому есть отличная возможность делать это через нашу среду разработки IntelliJ IDEA. Это позволит нам не только сэкономить время, но также и использовать debug как нашего локального веб-приложения, так и даже удаленного! 

00:00 - Введение
00:37 - Конфигурация Apache Tomcat в IntelliJ IDEA
04:02 - Решение конфликта TCP портов
05:02 - Успешный запуск web приложения в IntelliJ IDEA
05:39 - public и private (WEB-INF) ресурсы

На видео разберемся с основным функционалом Catalina - это объекты класса HttpServlet. Именно они занимаются обработкой наших HTTP запросов и именно там мы будем писать основной функционал. Также поговорим про жизненный цикл сервлетов.

00:00 - Введение
00:42 - Детальная архитектура Apache Tomcat
04:34 - Жизненный цикл сервлетов
06:15 - Инициализация сервлетов
07:24 - Исходный код Apache Tomcat

Для создания своего первого сервлета, нам необходимо будет подключить зависимость servlet-api.jar, чтобы получить доступ к таким классам как HttpServlet, HttpServletRequest и многие другие. Посмотрим, как маппить сервлет на URL path, что из себя представляет метод service и как он перенаправляет запросы в зависимости от HTTP метода.

00:00 - Введение
00:32 - Подключение servlet-api.jar
02:38 - Создание класса FirstServlet
05:09 - Метод service
06:07 - Переопределение метода doGet
08:09 - Маппинг сервлетов
10:01 - Тестирование сервлета

Мы уже прекрасно знаем как выглядят HTTP заголовки и зачем они нужны, но теперь нам необходимо разобраться с тем, как их использовать в наших сервлетах. Нам нужно знать как они получаются из HTTP запроса, а также как их устанавливать в HTTP ответах, чем и будем заниматься в этом видео.

00:00 - Введение
00:24 - Debug жизненного цикла сервлетов
03:40 - Получение заголовка из HttpServletRequest
04:20 - Заголовок user-agent
05:16 - Итерирование по всем заголовкам запроса
05:55 - Установка заголовков в HttpServletResponse. Кодировка
08:26 - Резюме

Мы уже разбирали на предыдущих занятиях, что такое параметры запроса. Теперь узнаем как их передавать не одним (через URL), а двумя разными способами. Конечно же увидим, как их извлекать на стороне нашего сервлета, а также познакомимся с очень мощным и удобным HTTP клиентом - Postman.

00:00 - Введение
00:40 - Получение параметров из HttpServletRequest
03:15 - Http client от IntelliJ IDEA
04:24 - Http client - Postman
07:13 - Передача параметров через HTTP Body

Мы уже начинали работать с телом запроса HTTP Body, когда возвращали HTML страницу из нашего первого сервлета в HttpServletResponse. Теперь давайте более подробно остановимся на этой теме и детальнее разберем в видео как не только возвращать, но и отправлять самим в HTTP запросах.

00:00 - Введение
00:30 - Запрос с HTTP Body
03:08 - Тестирование через Postman
03:51 - Заголовки в запросе с HTTP Body

Для того, чтобы браузер начал процесс скачивания файла с сервера нам на жесткий диск - недостаточно просто передать что-то в теле запроса HTTP Body. Для этого нам нужно еще дополнительно передать заголовок content-disposition. Разберемся в видео, как это нужно делать правильно.

00:00 - Введение
00:25 - Заголовок Content-Disposition
01:48 - Класс DownloadServlet
04:03 - Считывание данных из classpath ресурса

На предыдущем курса по JDBC мы уже начинали разбираться с архитектурой Java приложений и тем, что нужно разбивать все классы на уровни. Теперь мы продолжаем наращивать эти уровни и представить архитектуру именно Java веб приложений. На видео разберемся с этим более подробно.

00:00 - Введение
01:28 - Архитектура веб приложений
03:18 - Шаблон проектирования MVC
04:54 - Доп функционал в веб приложениях
06:29 - Резюме

На первом практическом занятии по курсу HTTP. Servlets мы попробуем использовать весь полученный багаж знаний на текущий момент, чтобы реализовать MVC приложение, соблюдая уровневую архитектуру, которую прошли на прошлом занятии. 

00:00 - Введение
00:40 - Подключение к базе данных
01:49 - Flight entity mapping
03:24 - ConnectionManager. PropertiesUtil. JDBC Driver
09:50 - FlightDao
16:32 - FlightService. DTO
22:05 - FlightServlet
26:57 - Troubleshooting
30:15 - Ticket entity mapping
31:08 - TicketDao
35:22 - TicketService
35:22 - TicketServlet
43:32 - Тестирование функционала
44:58 - Резюме

Язык программирования Java появился в далеком 1995 году, поэтому в нем осталось довольно много подходов, которые в текущее время уже не актуальны. Имеется в виду именно шаблонный код, который повторяется из класса в класс и не нужен программисту - это так называемый Boilerplate. Для того, чтобы убрать его из наших Java проектов, мы воспользуемся прекрасной библиотечкой Lombok, которая привнесет ясность и уберет ненужный Boilerplate.

00:00 - Введение
01:02 - Boilerplate
02:10 - Подключение lombok.jar
03:01 - Установка плагина Lombok
03:46 - Аннотации Lombok
05:58 - Delombok аннотаций
06:40 - Корректировка существующего кода

Cookies - это возможность хранить информацию на стороне клиента (в нашем случае это обычный браузер) для своих нужд. Для того, чтобы попросить клиент сохранить у себя данные в cookies необходимо передать со стороны сервера соответствующий заголовок Set-Cookie. После чего, браузер с каждым запросом на этот сервер будет передавать только его cookie в соответствующем заголовке с названием Cookie.

00:00 - Введение
00:12 - Application в Dev Tools
01:14 - Что такое Cookies
01:52 - Механизм работы Cookies
04:23 - Java реализация Cookies
10:25 - Тестирование функционала

На одной из теоретических лекций этого курса мы оговаривали, что протокол TCP поддерживает так называемые сессии - это время между открытием и закрытием соединения с сервером, за которое и клиент и сервер могут передавать друг другу request-response (round-robin). Но для осуществления такого механизма на стороне приложения (HTTP протокол) нужно прибегать к собственным реализациям, которых существует несколько. На видео разберем одну из них, которая идет по умолчанию в Apache Tomcat.

00:00 - Введение
00:15 - Что такое сессия
01:15 - Cookie JSESSIONID
02:20 - Класс HttpSession
06:15 - Исходный код Apache Tomcat

Атрибуты - это обычный ассоциативный массив, в котором ключом всегда является объект типа String, а значением - совершенно любой объект класса Object. Атрибуты можно использовать как вспомогательную информацию и хранить в трех типах объектов: ServletContext (глобальное хранилище для всего веб приложения), HttpSession и HttpServletRequest (используется с перенаправлением запросов и JSP, что будет разобрано в следующих видео).

00:00 - Введение
00:20 - Установка и получение атрибутов
04:58 - Удаление Cookies из браузера
06:01 - Атрибуты в ServletContext, HttpSession и HttpServletRequest

Довольно часто происходит перенаправление запросов от пользователя, когда изначальный обработчик этого запроса не может или не умеет обработать его полностью или частично. Для этого механизма существует 3 разных способа: forward, include и sendRedirect (универсальный для всего протокола HTTP). На видео разберем подробно с примерами каждый из них.

00:00 - Введение
00:30 - forward теория
01:11 - include теория
01:54 - sendRedirect теория
03:24 - Java реализация forward
07:28 - Нюансы закрытия request OutputStream
10:00 - Java реализация include
11:09 - Java реализация sendRedirect

Вот мы и дошли до нового для нас варианта реализации уровня представления - это JSP страницы. На видео подробно разберем их, пройдя жизненный цикл JSP, и узнаем, что на самом деле это обычные сервлеты. Поэтому жизненный цикл JSP включает в себя жизненный цикл сервлетов.

00:00 - Введение
00:53 - Template Engine
01:38 - JSP
02:30 - Жизненный цикл JSP
06:29 - Исходный код Apache Tomcat
08:24 - Резюме

Мы уже знаем, что JSP - это обычный HttpServlet и подчиняются обычному жизненному циклу сервлетов. Поэтому на видео попробуем переписать TicketServlet с предыдущего занятия на JSP страницу и посмотрим, как это будет выглядеть. Также поговорим про скриплеты, которые не следует использовать и которые мы совсем скоро заменим с помощью EL и JSTL.

00:00 - Введение
01:07 - Создание первой JSP страницы
04:00 - Переписывание TicketServlet на tickets.jsp
08:30 - Тестирование функционала
09:08 - JSP declaration
10:38 - резюме

JSP страницы используют 3 различных директивы для различных нужд: page, include и taglib. С первой мы уже более менее познакомились на предыдущем видео, но углубимся в нее еще больше. С taglib более плотно поработаем при подключении библиотеки JSTL. Но больше всего уделим внимания директиве include и перенаправлению запросов из сервлетов на JSP страницы.

00:00 - Введение
00:16 - JSP tags
00:48 - Директива page
01:56 - Директива taglib
02:44 - Директива include
03:46 - Практика директивы include
07:00 - forward запроса из сервлета на JSP
08:28 - Установка кодировки через директиву page
08:50 - Класс JspHelper
10:22 - Резюме

Expression Language - очень удобное средство, которое также повсеместно используется в современных библиотеках и фреймворках, и которое позволит нам заменить наши скриплеты (динамическую часть) в JSP страницах, чтобы убрать Java код. Конечно, с циклами и условными конструкциями помочь EL не сможет, но с остальным - продемонстрируем в этом видео.

00:00 - Введение
00:43 - Expression Language
02:15 - Доступные объекты в EL
03:41 - Операторы в EL
05:08 - Практика EL
12:35 - Резюме

JSTL - это библиотека, которая позволяет нам выполнять на стороне JSP страниц такие вещи как циклы, условные конструкции, вызовы вспомогательных функций, интернационализации и многое другое. Иначе говоря, она позволит нам полностью избавится от вкраплений Java кода, дополняя Expression Language. На занятии разберемся, как подключить JSTL в проект и на JSP страницах.

00:00 - Введение
00:22 - Что такое JSTL
00:47 - Насройка JSTL в проекте
01:44 - Условные выражения в JSTL
03:15 - Циклы в JSTL
04:28 - Вспомогательные функции в JSTL
05:30 - Интернационализация в JSTL
06:00 - Скачивание и настройка JSTL зависимостей
09:12 - Подключение JSTL на JSP странице

На предыдущем занятии мы успешно подключи все необходимые JSTL зависимости и настроили на JSP странице. На этом видео мы попрактикуемся и заменим существующую динамическую составляющую наших страницах на JSTL циклы и условные конструкции, полностью избавившись от скриплетов. Также увидим, что на JSP страницах можно даже использовать debug.

00:00 - Введение
00:23 - Обновление TicketServlet
03:21 - Использование JSTL функций
04:45 - Debug JSP страниц
06:05 - Использование JSTL условных операторов
07:02 - Обновление FlightServlet
09:55 - Context Path

В HTML есть тэг form, который позволяет отправлять на сервер данные в HTML Body, что является единственным вариантом без использования JavaScript. Более того, он ограничен только двумя HTTP методами: get (по умолчанию) и post. На занятии подробно разберем этот тэг на примере создания своей странички регистрации пользователя.

00:00 - Введение
01:08 - Создание registration.jsp
02:44 - Tag input (text type)
05:35 - Tag input (date type)
06:21 - Tag input (password type)
06:57 - Отправка формы на сервер
08:52 - Tag select
10:17 - Tag input (radio/checkbox type)
12:20 - Использование JSTL
14:45 - Тестирование функционала

Вторая часть наших больших практических занятий, где мы вновь пройдем всю цепочку наших слоев, соблюдая MVC архитектуру, начиная от JSP и заканчивая базами данных. В этот раз, мы полностью завершим процесс регистрации нашего пользователя, чтобы в последующем на основании этого проходить следующие важные связанные темы как аутентификация, авторизация и т.д.

00:00 - Введение
01:30 - Создание таблицы users
03:48 - Создание сущности User
05:41 - Создание UserDao
09:43 - Создание CreateUserDto
11:19 - Реализация doPost в RegistrationServlet
13:25 - Создание UserService
17:10 - Создание CreateUserValidator
22:32 - Создание CreateUserMapper
25:05 - Создание LocalDateFormatter
28:38 - Реализация метода create в UserService
31:12 - Тестирование функционала
32:56 - Обработка ошибок валидации в RegistrationServlet
37:00 - Резюме

Довольно часто есть необходимость загрузить вместе с формой какую-то картинку (аватар пользователя) или любой другой бинарный файл. К счастью, для этого есть специальный тип в тэге input - file. Но этого недостаточно, чтобы и клиент и сервер смогли обмениваться бинарными файлами друг с другом. На занятии подробно разберемся со всеми нюансами и как нужно правильно это делать на практике.

00:00 - Введение
00:33 - Tag input (file type)
02:21 - Класс Part
03:29 - Аннотация @MultipartConfig
04:50 - Создание колонки image в базе данных
05:58 - Обновление сущности User
06:58 - Создание ImageService
10:38 - Обновление RegistrationServlet
11:02 - Обновление UserService
13:45 - Тестирование функционала

Мы уже хорошо знаем как сохранять картинку на сервер, используя обычный тэг input с типом file. Но как теперь отобразить ее на странице? Для этого тоже есть специальный тэг в HTML - img. Более того, есть аналогичные теги для видео (тэг video) и аудио (тэг audio). На видео попрактикуемся более подробно.

00:00 - Введение
00:21 - Тэг img
02:51 - Создание ImageServlet
05:36 - Обновление ImageService
07:40 - Отправка файла любого размера в выходной поток
10:38 - Тестирование функционала
12:33 - Тэги video и audio

Кроме сервлетов Apache Tomcat предоставляет нам еще один гибкий механизм фильтров, который реализует паттерн проектирования: цепочку обязанностей (Chain of Responsibility). У фильтров есть свой жизненный цикл. А для их создания необходимо просто реализовать интерфейс типа Filter и указать urlPattern как и в сервлетах, чтобы определить запросы, для которых этот фильтр должен срабатывать. На видео более детально разберемся с этим.

00:00 - Введение
00:15 - Фильтры
01:32 - Жизненный цикл фильтров
02:10 - Создание CharsetFilter
04:50 - Chain of Responsibility
06:39 - Тестирование фильтра
07:53 - Привязка фильтров по servletNames
09:24 - Filter/Servlet init params
10:18 - Filter dispatcher types
11:45 - Error page

На второй части темы фильтров мы больше попрактикуемся с перенаправлениями запросов, порешаем пару задач и разберемся в том, в какой последовательности эти фильтры будут вызываться в нашей цепочке фильтров.

00:00 - Введение
00:53 - Перенаправление запросов в фильтрах
03:50 - Тестирование функционала
05:58 - Создание LoggingFilter
07:14 - Последовательность вызовов в фильтрах

Аутентификация - это на самом деле в большинстве случаев для обычных пользователей всего лишь ввод email и пароля на страницах приложений, чтобы выйти в него. Поэтому наша задача в этом видео - показать, как это делается, создав собственную Login страничку и пройдя вновь весь путь от этой страницы до базы данных и назад.

00:00 - Введение
00:13 - Что такое Аутентификация
00:58 - Создание login.jsp
04:04 - Создание LoginServlet
06:05 - Получение User из БД по email и password
11:34 - Метод login в UserService
12:58 - Добавление всех полей в UserDto
14:02 - Создание UserMapper
16:11 - Реализация doPost в LoginServlet
21:16 - Тестирование функционала

Во всех приложениях, где есть аутентификация, должен быть предусмотрен функционал противоположный ему. Т.е. пользователь хочет вылогиниться из системы, другими словами говоря, сделать logout. Продемонстрируем в видео, как это реализовать в коде, а также разберемся с таким HTTP статус кодом как 405.

00:00 - Введение
00:38 - Кнопка Logout в Github
01:31 - Создание LogoutServlet
03:07 - Кнопка Logout в header.jsp
05:09 - Тестирование функционала
06:12 - 405 status code

Авторизация (Authorization) - это один из важнейших аспектов практически любого приложения, который идет поверх пройденной нами темы аутентификации. Суть в том, чтобы определять доступ к ресурсам системы для пользователей, и на основании их ролей позволять или не позволять выполнять какие-то действия. Более того, знание фильтров и того, как устроена авторизация и аутентификация, нам очень поможет в дальнейшем, когда мы приступим к изучению Spring Security. Ведь он полностью основывается на работе наших фильтров.

00:00 - Введение
00:25 - Что такое авторизация
01:15 - Создание AuthorizationFilter
04:30 - Определение public paths. Класс UrlPath
07:35 - Проверка logged in пользователя в системе
09:00 - Reject пользователя. Header referer
10:30 - Тестирование функционала
12:39 - Ошибка too many redirects

В современном мире, если ты хочешь, чтобы твое приложение было популярным и успешным, им должны пользоваться люди из разных уголков планеты. Но все не так просто, как может показаться на первый взгляд, ведь для этого нужно предусмотреть интернационализацию приложения и последующую локализацию его под конкретный рынок (регион). Ведь люди из разных стран видят одинаковую информацию твоего приложения, а следовательно, должны видеть ее на понятном для них языке, формате дат, единиц измерения, символики и многое другое. На видео поговорим об этом более подробно и что же предоставляет нам Java для реализации интернационализации и локализации.

00:00 - Введение
00:40 - Интернационализация (i18n)
01:10 - Локализация (l10n)
01:45 - Разница между i18n и l10n
04:23 - Класс Locale
06:53 - Класс ResourceBundle
11:56 - Установка UTF-8 в настройках IntelliJ IDEA

Мы теперь знаем, что такое интернационализация и локализация, в чем разница между ними и их сокращенные названия (i18n, l10n), и даже владеем функционалом для реализации этого в Java. Теперь нам необходимо использовать эти знания для интернационализации наших страниц при помощи уже пройденной библиотеки JSTL. На видео проработаем такую возможность для одной страницы, но все будет точно также реализовываться для всех остальных.

00:00 - Введение
00:38 - JSTL fmt
04:41 - Добавление переводов в Resource Bundle
06:23 - Тестирование функционала 1
07:20 - Динамическое изменение языка в приложении
09:38 - Создание LocaleServlet
13:17 - Тестирование функционала 2

В заключительном видео довольно большого курса по HTTP. Servlets мы поговорим немного про архитектуру построения веб приложений на сервлетах, какие технологии дальше следует учить, чтобы упростить написание веб приложений на Java, а также порекомендую литературу для закрепления пройденного материала. В общем говоря, обсудим дальнейший путь нашего развития!

00:00 - Введение
00:17 - Что мы уже знаем на текущий момент
01:13 - Dispatcher Servlet
02:26 - Spring / Spring Boot
03:12 - Maven / Gradle
03:56 - Рекомендуемая литература