структура web приложения java
Пишем простое веб-приложение используя Spring MVC, Spring Data JPA и Hibernate
Привет, Хабр! Представляю Вашему вниманию перевод руководства «Spring MVC + Spring Data JPA + Hibernate — CRUD Example» автора Nam Ha Minh.
В этом руководстве по Java Spring вы узнаете, как настроить Spring MVC приложение для работы с Spring Data JPA, разработав простое веб-приложение, которое позволяет управлять информацией о клиентах.
По завершению этого руководства, вы сможете создать веб-приложение Java основанное на технологиях Spring MVC и Spring Data JPA, которое выглядит следующим образом:
Программы и технологии используемые в этом руководстве: Java 8, Apache Tomcat 9, MySQL Server 5.7, Eclipse IDE 4.7 (Oxygen), Spring Framework 5.1, Hibernate 5.4, Spring Data JPA 2.1.5 и Servlet 3.1.
Начнём с создания базы данных.
1. Создание базы данных
Мы будем использовать MySQL. В нашем пример мы будем работать с данными в таблице customer, которая находится в схеме с именем sales. Таблица customer имеет 4 поля: id, name, email и address:
Вы можете запустить следующий MySQL скрипт для создания схемы и таблицы:
2. Создание проекта в Eclipse
Создайте Dynamic Web Project в Eclipse, и конвертируйте его в проект Maven: для этого нажмите ПКМ по проекту, выберете Configure > Convert to Maven Project. В открывшемся диалоговом окне Create new POM введите следующую информацию:
— Group Id: net.codejava
— Artifact Id: CustomerManager
Также убедитесь, что версия JRE для проекта Java 8 или новее.
Затем, откройте pom.xml (файл Maven), чтобы настроить зависимости для этого проекта. Объявите свойства версий для Spring и Hibernate Frameworks:
Укажите зависимость для Spring Framework:
Для создания веб-приложений Spring MVC:
Для использования Spring Data JPA:
Мы используем Hibernate в качестве реализации JPA, поэтому добавим следующую зависимость:
Для того, чтобы приложение работало с MySQL, нам нужна зависимость для драйвера MySQL JDBC:
И теперь зависимости для Java Servlet, JSP и JSTL:
Создайте два Java пакета в корне проекта:
— net.codejava.config : для классов конфигурации.
— net.codejava.customer : для классов приложения.
3. Создание файла настройки JPA
И впишите в этот файл код представленный ниже:
Как вы можете видеть, мы указываем свойства для соединения с базой данных, такие как URL, user, password и класс JDBC драйвера. Так же обратите внимание, что имя SalesDB будет использоваться нами в коде конфигурации.
4. Создание Model Class
5. Конфигурация Spring MVC и Spring Data JPA
Далее, напишем Java код для настройки Spring MVC и Spring Data JPA. Мы будем использовать конфигурацию на основе Java, так как она проще, чем XML.
Настройка Spring Dispatcher Servlet
Для использования Spring MVC в нашем приложении, нам надо зарегистрировать Spring Dispatcher Servlet при запуске приложения, написав следующий класс:
Настройка Spring MVC
В этом классе мы создаём bean-компонент, который распознаёт представления (View), с помощью указания префикса и суффикса для этих представлений. Поэтому создайте каталог views внутри каталога WebContent/WEB-INF для хранения JSP файлов.
Здесь вы можете добавить и другие конфигурации Spring MVC.
Настройка Spring Data JPA
Здесь мы используем две важные аннотации:
Это минимальная необходимая конфигурация для использования Spring Data JPA.
Создание Repository Interface
7. Создание Service Class
Затем, создайте класс CustomerService :
Это похоже на магию, поскольку мы не пишем DAO код, но Spring Data JPA автоматически создаст реализацию во время выполнения.
8. Создание контроллера Spring MVC
Создайте класс CustomerContoroller для обработки всех запросов от клиентов:
Мы напишем методы обработки в следующих секциях.
9. Добавление списка клиентов
На домашней странице нашего приложения будут отображаться все клиенты, для этого добавьте соответствующий обрабатывающий метод в наш CustomerController класс:
Домашняя страница просмотра ( index.jsp ) должна выглядеть следующим образом:
10. Добавление нового пользователя
Для того, чтобы реализовать функцию создания нового клиента, нам нужно написать два метода-обработчика. И первый из них будет отображать новую форму для добавления клиента:
Напишем саму JSP форму с именем new_customer.jsp :
Теперь на главной странице у вас появится ссылка New Customer, при нажатии на которую вы увидите новую форму:
Второй метод-обработчик будет обрабатывать кнопку Save в этой форме:
Как вы можете видеть, она перенаправляет клиента на домашнюю страницу, после успешного сохранения пользователя.
11. Изменение данных пользователя
Чтобы реализовать функцию редактирования клиента, добавим следующий метод-обработчик в класс CustomerController :
Нажмите на гиперссылку Edit рядом с клиентом на домашней странице, вызовется форма редактирования клиента, которая будет выглядеть примерно вот так:
Метод-обработчик по-прежнему обрабатывает кнопку Save.
12. Удаление клиента
Для реализации функции удаления, напишите следующий метод-обработчик в классе CustomerController :
Нажмите на гиперссылку Delete рядом с клиентом на главной странице. Клиент удалится, а список обновится.
13. Поиск по клиентам
Наконец, давайте реализуем функцию поиска, которая позволяет пользователю искать клиентов, вводя ключевое слово. Функция поиска ищет ключевые слова в трёх полях: имя, email и адрес, для чего нам потребуется написать собственный метод в интерфейсе CustomerRepository :
Затем добавьте метод в класс CustomerService :
Теперь добавьте метод-обработчик в класс CustomerController :
И создайте страницу результата поиска search.jsp :
Для тестирования функции поиска, введите ключевое слово в поле поиска на домашней странице, и нажмите Enter. Вы увидите страницу результата поиска:
Выводы
В данном руководстве вы узнали как можно разработать веб-приложение Spring MVC, используя Spring Data JPA для доступа к данным. Как вы могли видеть, Spring Data JPA значительно уменьшает и упрощает код, который нам нужно писать.
Для сравнения, вот структура проекта в Eclipse IDE:
Разработка веб приложения на основе Java EE+JSP+Hibernate+Maven+Spring MVC в NetBeans. Часть 1
Вступление
Это будет серия статей, помогающих начинающим Java разработчикам в их нелегком пути. Покажу пример создания интернет магазина.
Первое что вам понадобится — это NetBeans 7.3. Скачать можно здесь.
Почему именно он? Думаю для начинающих в ЕЕ — это идеальный вариант.
Используемые технологии:
1) NetBeans 7.3;
2) Maven;
3) Hibernate;
4) Spring MVC;
5) JSP+JSTL;
6) Знание про Сервлеты, Сессии, JavaBean, XML и т.д.;
7) HTML+CSS (немного красоты по Вашему вкусу, но лучше заплатить левым людям, — у Вас с серверной стороной итак хлопот хватит);
8) Java SE (знание коллекций, умение обрабатывать исключения… В общем, стандартный набор);
9) Знание паттернов проектирования (DAO, Factory);
10) JPA;
11) SVN;
12) SQL (для написания скриптов, заполняющих наши БД).
Начнем с того, где мы будем хранить наш код и как обмениваться им с друзьями. Думаю, не все начинающие знают про репозитории, и эта часть именно для них.
Есть такое понятие, как репозиторий — удаленный сервер хранения кода.
Если Вам дадут тестовое задание, и Вы пошлете его архивом, то Вас скорее всего тоже пошлют. Может, не пошлют, но точно разочаруются в Вас.
Существуют различные репозитории CVS, SVN, Git. Для начинающих я считаю оптимальным SVN. Ну а Вам главное не знать что это, а уметь применять. Пока достаточно будет и этого, остальное придет с опытом.
Итак, есть сайт www.assembla.com/ — Вам нужно там зарегистрироваться. После регистрации нужно создать на этом сайте открытый репозиторий на стартовой странице. После регистрации будет . Cоздать свое собственное пространство.
Далее публичный проект, и первый будет Subversion (SVN). Даете ему имя и заканчиваете создание. После этого вверху, на черной полоске сайта, отобразится его имя, Вы нажимаете по нему — и вас перенаправит на страницу Вашего пространства. Там будет закладка «Исходный код/SVN». В этой вкладке будет ссылка на Ваш проект. Если ничего не получится, попробуйте найти видео как это делать на www.youtube.com/.
Далее, полностью удалите проект, который вы закоммитили. Дальше зайдите в папку, где у вас проекты хранятся, и проверьте что реально все удалено. Потом возвращаетесь в NetBeans и ищете в панели меню вкладку Группа(на панели где Файл, Вид, Правка, Переход, Источник. ) в нем есть наш Subversion. И в подменю на нем есть «Получить». Дальше в диалоговых окнах надо будет указать ссылку на репозиторий (это ссылка которую вы получили на сайте во вкладке «Исходный код».) И когда он предложит выкачивать папки, то по дереву репозитория нужно будет найти ваш проект и выбрать его, и по окончанию вы выкачаете свой проект. Вот так происходит обмен кодом.
Ваш проект будет постоянно синхронизироваться с репозиторием и помечать файлы, которые были изменены, или новые(то что отличается от версии на репозитории). Чтобы обновить, нужно вызвать контекстное меню, и в закладке «Управление Версиями» будет большой список того, что можно делать с проектом. «Обновлять» — это обновить свои файлы; «Фиксировать» — ложить код который Вы написали или изменили в репозиторий; «Сбрасывать» — возвращаться к версии на репозитории, и «Сравнивать» — отображение изменений строк которые отличаются от удаленных. Это способ командного обмена кодом, который используется всегда и нужно к нему привыкать.
Начало
Итак, если нам нужно с кем-то поделиться кодом, показать его кому то,- мы теперь вооружены хорошеньким инструментом для этого.
Вы уже скачали NetBeans, поигрались с SVN — теперь перейдем к делу. Создаете проект. Нажимаете «Создать проект», там выбираете Maven-> Веб-приложение. Называете как хотите, это все Ваша фантазия. Итак, у нас есть веб-приложение, сборка нашего проекта идет мавеном, у нас есть цель и теперь наступило время подумать над тем, как ее осуществить. То есть Вы, как разработчик, должны подумать над тем, как будет выглядеть Ваше приложение, какую иметь архитектуру, дерево пакетов и так далее. Общее количество строк кода здесь около 4000 и лучше позаботиться о красивой архитектуре заранее, иначе потом Вы просто не будете понимать что где и как у Вас работает, каким чудом Вы, к примеру, выводите последнюю купленную вещь, как считаете общую сумму покупок. И если Вас потом попросят что-то доделать или добавить — Вы осознаете что проще написать все с нуля.
Ну и конечно нам нужно прикинуть наш план действий.
Итак: План действий
1) описываем entity(entities) — сущности. Это POJO — класс, связанный с БД с помощью аннотации (@Entity) или через XML. Использовать будем JPA, поэтому импортировать надо javax.persistence.* Почему не Hibernate Persistence API, т.к если использовать его и потом мы захотим сменить ORM библиотеку, то придется переписывать и наши классы, а JPA — это стандарт от Sun. По поводу того, что такое JPA — ну для Вас могу своими словами сказать так: это библиотека предоставляющая API для работы с *долго живущими* объектами, то есть позволяет нам удобно сохранять наши объекты в БД. Могу дать совет: создайте для этого отдельный пакет назовите его entity или domain — как хотите, главное чтобы Вам было понятно. В конечном итоге это может выглядеть так: edu.shop.model.domain.Customer.java edu.shop.model.domain.Notebook.java.
Подробнее буду описывать непосредственно при рассмотрении данного пункта. Сейчас задача стоит прикинуть план действий.
2) Создаем HibernateUtil (вообще суффикс или приставка Util подразумевает, что код в этом классе есть универсальный и используется множеством классов).
Итак, в HibernateUtil мы размещаем SessionFactory. Он тяжеловесный. Этот код, по идее, должен быть независим от всего приложения, так как он устанавливает соединение с базой данных при старте и должен нам давать только Сессии с базой данных. Еще мы в этом классе регистрируем наши классы-сущности. Подробнее про этот класс расскажу позже. Засунем его тоже в отдельный пакет, к примеру, edu.shop.model.hbutil.HibernateUtil.java
3) Пишем DAO.
Что в нем писать? Пишем то, что мы хотим получить от базы данных, но нам не нужно думать как получились эти данные, важен результат. К примеру, мы определяем интерфейс ProductDAO и пишем в нем методы
List> getAllProducts(); потом пишем его реализацию ProductDAOImpl.
В чем идея? Если бы это приложение писал я и Вы, Вы бы сказали: «Миха, мне нужны от БД следующие данные: все товары что у меня есть в БД». Я отвечаю: «не вопрос». И далее следующее развитие событий: вы в своем коде, везде где нужно делать запросы к базе пишете следующее%
*здесь обращение к методу*.getAllProducts(); — и видите, что компилятор не ругается, а реализацию этого интерфейса я мог еще не успеть написать. И какой итог? У Вас все скомпилилось, а рабочего кода даже нет. Здесь мы применим Enums и паттерн Factory, и еще кое-что, но всему свое время. Именно в DAO нужно уделить особое внимание обработке исключений, хотя бы генерировать страницы с ошибками. Чтобы Вы быстро находили кусок неработающего кода. Иначе, Вы просто замучаетесь с отладкой.
3)Здесь начнется наша работа с Spring MVC. Это долгая история и этому будет посвящена отдельная статья. Сразу скажу — это самое сложное в этом приложении. Но я Вам покажу и более простой вариант, как выводить все, не особо заботясь про паттерн MVC.
Затронем использование скриплетов.
4) Здесь у нас будут вспомогательные классы, добавляющие всякие вкусности в наш проект: подсчет общей суммы покупок; последняя купленная вещь; вспомогательные переменные, которые пригодятся нам для работы метода, который, к примеру, будет выводить нам с БД вещи не дороже 5000 грн, или не дешевле 500; вывод всех ноутбуков марки Асус. Этот пункт тесно взаимосвязан с предыдущим.
Пока остановимся на этом. С остальным разберемся чуть позже. Итак, у нас есть намеченный план, приступим к его реализации.
Entity
Мы создали наш проект и создали наш пакет с сущностями. Пусть это будет edu.shop.entity. Там мы создаем такие классы:
Примечание. Корзина, в которой будут храниться наши купленные товары, будет как таблица в БД, это я сделал т.к на ней покажу некоторые основы работы с БД. Для реального случая целесообразнее будет использовать коллекции для хранения наших товаров.
1) Product
2) Notebook
3) Camera
4) Book
5) Cable
6) Customer
7) Cart
Поговорим немного о том, что такое класс-сущность.
Entity (Сущность) — POJO-класс, связанный с БД с помощью аннотации (@Entity) или через XML. К такому классу предъявляются следующие требования:
— Должен иметь пустой конструктор (public или protected);
— Не может быть вложенным, интерфейсом или enum;
— Не может быть final и не может содержать final-полей/свойств;
— Должен содержать хотя бы одно @Id-поле.
При этом entity может:
— Содержать непустые конструкторы;
— Наследоваться и быть наследованным;
— Содержать другие методы и реализовывать интерфейсы.
Entities могут быть связаны друг с другом: один-к-одному, один-ко-многим, многие-к-одному и многие-ко-многим.
Использовать мы будем аннотации. И тут сразу у нас появляется возможность описать двумя способами. Либо мы будем писать аннотации непосредственно над полями, либо над геттерами. Скажу одно: правильно писать над геттерами, а причину Вы спросите в гугле. Не могу я все темы абсолютно здесь описать.
Есть еще одно что хочу сказать. Для этого придется показать 2 примера описания класса сущности. Итак, первый пример:
Коментарии к нему я написал в самом коде:
Второй способ: пишем над геттерами. Пояснения смотрим в коде.
Итак, у Вас есть два примера классов сущностей. Создайте остальные, используя эти примеры. Такие поля как: модель, год публикации, имя, стоимость — все на Вашу фантазию. Включите обязательно поле Available(в переводе наличие). Оно Вам потом пригодится. Можете сделать его булевым и добавить столбец с именем количество. Это все нам пригодится.
Теперь приведем пример нашего HibernateUtil
Приступим к следующей части. Что такое DAO. Это шаблон проектирования.
Его смысл:
— Весь доступ к базе данных в системе производится через DAO для инкапсуляции.
— Каждый экземпляр DAO отвечает за один первичный доменный объект или сущность. Если доменный объект имеет независимый цикл жизни, он должен иметь свой собственный DAO.
— DAO отвечает за операции создания, чтения (по первичному ключу), обновления и удаления (то есть, CRUD (create, read, update, delete)) доменного объекта.
— DAO может разрешать запросы, основанные на критерии, отличном от первичного ключа. Я ссылаюсь на такие методы как finder или finders. Метод finder обычно возвращает коллекцию доменных объектов, за которые отвечает DAO.
— DAO не занимается обработкой транзакций, сессий или соединений. Это делается вне DAO для обеспечения гибкости.
Подробнее всегда расскажет гугл.
Мы пока напишем DAO для наших продуктов.
Итак, подумаем что нам вообще нужно. Таблица Product будет иметь 4 поля Id,nameProduct,available+amount+actionForServlet. Она нам будет нужна, чтобы создать на нашем сайте категории. Над последним полем пока не заморачиваемся. Единственное что нам нужно — это получение списка продуктов.
Реализация нашего интерфейса. Пояснения смотрим в коде
Итак, теперь у нас есть возможность получать данные из БД. Вы можете, используя скриплеты, создать незамысловатый цикл for-each и вывести свою продукцию на вашу страницу index.jsp
Но это на первое время, а вообще так делать плохо. Это нарушает наш паттерн MVC. Как сделать правильно я объясню в следующем уроке, если мне дадут инвайт. Во втором уроке мы займемся Spring, в третьем коснемся паттерна Factory, и углубимся в хибернейт. Для особо нетерпеливых, покажу как нужно удалять из БД, сохранять в БД и удалять полностью все из БД. Ну, а как сделать, чтобы все это взаимодействовало в целом с нашим приложением и подробное рассмотрение оставим на потом.
Сохранить в БД
Удалить из базы по id
Также Вам нужен будет файл настройки Hibernate. Создайте в Derby БД shop. Имя и пароль пользователя root и pass соответственно. Если не получится — не расстраивайтесь — я уделю еще этому время.
О том, как заполнять наши БД поговорим позже. Можете заполнить их вручную. Либо дождаться следующего урока.
Разработка web-приложения на основе технологии Java
Содержание
Java и web-разработка [ править ]
Сбор данных для web-приложения [ править ]
Парсинг [ править ]
Парсинг – это автоматический сбор информации с какого-либо источника.
Цель парсинга – сбор данных со страниц ресурсов с дальнейшей обработкой и преобразованием.
Работа парсинга заключается в сопоставлении строки естественного языка или языка программирования с формальными правилами. Приведем пример. Представьте себя радистом на войне. Вы получаете зашифрованное сообщение. У вас есть правила дешифровки. Вы начинаете разгадывать послание согласно этому методу. Вы смотрите вначале на символ из полученного сообщения. Потом на свою таблицу с его значением. Например, цифре «1» соответствует буква «Я». Вы сопоставляете все символы и получаете то сообщение, которое можно прочитать. Парсинг работает точно так же. Есть некоторый шаблон сообщения, написанный на формальном языке. С ним сравнивается какая-то строка.
Независимо от того на каком формальном языке программирования написан парсер, алгоритм его действия остается одинаковым:
В интернете часто встречаются выражения, из которых следует, будто парсер (поисковый робот, бот) путешествует по Всемирной сети. Но зачастую эта программа никогда не покидает компьютера, на котором она инсталлирована. Этим парсер коренным образом отличается от компьютерного вируса – автономной программы, способной к размножению, хотя по сути своей работы он похож на троян. Ведь он получает данные, иногда конфиденциального характера, не спрашивая желания их владельца.
Разберемся зачем нужен парсинг. Сбор информации в интернете – трудоемкая, рутинная, отнимающая много времени работа. Парсеры, способные в течение суток перебрать большую часть веб-ресурсов в поисках нужной информации, автоматизируют ее. Без программ парсинга владельцам интернет-магазинов, которым требуются сотни однотипных описаний товаров, технических характеристик и другого контента, не являющегося интеллектуальной собственностью, было бы трудно вручную заполнять характеристики товаров.
Возможностью «спарсить» чужой контент для наполнения своего сайта пользуются многие веб-мастера и администраторы сайтов. Это оправдано, если требуется часто изменять контент для представления текущих новостей или другой, быстро меняющейся информации. Парсинг – «палочка-выручалочка» для организаторов спам-рассылок по электронной почте или каналам мобильной связи. Для этого им надо запустить «бота» путешествовать по социальным сетям и собирать «телефоны, адреса, явки». Ну и хозяева некоторых, особенно недавно организованных веб-ресурсов, любят наполнить свой сайт чужим контентом. Правда, они рискуют, поскольку поисковые системы быстро находят и банят любителей копипаста.
Теперь разберемся со сложностями парсинга, а точнее с этическими и техническими сложностями. Вопрос о том, является ли парсинг воровством контента, активно обсуждается во Всемирной сети. Большинство оппонентов считают, что заимствование части контента, не являющегося интеллектуальной собственностью, например, технических описаний, допустимо. Ссылка на первоисточник контента рассматривается как способ частичной легитимации. В то же время, наглое копирование, включая грамматические ошибки, осуждается интернет-сообществом, а поисковыми системами рассматривается как повод для блокировки ресурса.
Кроме этических проблем парсер способен создать и технические. Он автомат, робот, но его вход на сайт фиксируется, а входящий и исходящий трафики учитываются. Количество подключений к веб-ресурсу в секунду устанавливает создатель программы. Делать этот параметр очень большим нельзя, поскольку сервер может не переварить потока входящего трафика. При частоте 200–250 подключений в секунду работа парсера рассматривается как аналогичная DOS-атаке. Интернет-ресурс, к которому проявлено такое внимание, блокируется до выяснения обстоятельств.
Java библиотека jsoup [ править ]
Jsoup — это библиотека Java для работы с реальным HTML. Она обеспечивает очень удобный API (программный интерфейс приложения) для извлечения и манипулирования данными. Jsoup реализует WHATWG HTML5 спецификацию, и разбирает HTML в ту же объектную модель документа, как это делают современные браузер вроде Chrome и Firefox. Вот некоторые из полезных функций Jsoup библиотеки:
Jsoup предназначен для работы с различными видами HTML существующими в реальном мире, включая должным образом подтвержденный HTML c неполным неподтвержденным набором тэгов. Одно из основных преимуществ Jsoup это его надежность.
Сервлеты [ править ]
Технология сервлетов [ править ]
Сервлет – это Java-программа, которая в качестве своего суперкласса использует класс HttpServlet. Сервлет используется для того, чтобы расширить возможности существующего сервера, в частности веб-сервера.
В начале своего развития Интернет состоял только из статического содержимого, создаваемого с помощью языка разметки гипертекста (Hypertext Markup Language, HTML). В то время любой, кто мог создать страницу HTML, считался специалистом по Интернету. Это, однако, продолжалось недолго.
Динамическое содержимое стало доступно в web благодаря технологии интерфейса общего шлюза (Common Gateway Interface, CGI). CGI позволяет web-серверу вызывать внешнюю программу и передавать ей данные запроса HTTP для его обработки. Ответ внешней программы передается затем web-cepвepy, который пересылает его клиентскому браузеру. Программы CGI могут быть написаны на любом языке, который способен вызывать web-cepвep. Со временем самым популярным языком для написания программ CGI стал Perl.
Однако по мере роста популярности Интернета число пользователей, посещающих популярные web-сайты, росло экспоненциально, и стало очевидно, что CGI неспособен обеспечить масштабируемость приложений Интернета. Недостаток CGI состоит в том, что каждый клиентский запрос заставляет web-сервер порождать новый процесс запрошенной программы CGI. Как известно, создание процесса является дорогой операцией, которой требуется много процессорных циклов и оперативной памяти.
Постепенно новые технологии заменяют технологию CGI в разработке web-приложений. Мир был свидетелем появления следующих технологий:
Сервлеты и JSP имеют следующие преимущества:
Архитектура сервлетных приложений
Сервлет является классом Java, который может быть динамически загружен и выполнен специальным web-сервером. Этот поддерживающий сервлеты web-сервер называется контейнером сервлетов (servlet container). В начальный период развития технологии сервлетов он назывался процессором сервлетов (servlet engine). Сервлеты взаимодействую с клиентами по модели запрос-ответ на базе HTTP. Поскольку технология сервлетов работает поверх HTTP, контейнер сервлетов должен поддерживать HTTP как протокол для передачи запросов клиента и ответов сервера. Однако контейнер сервлетов может поддерживать и другие протоколы, такие как HTTPS (HTTP поверх SSL) для защищенных транзакций.
Как работает сервлет
Сервлет загружается контейнером сервлетов при первом запросе сервлета. Затем сервлету передается запрос пользователя, сервлет обрабатывает его и возвращает ответ контейнеру сервлетов, который в свою очередь посылает ответ пользователю. После этого сервлет остается в памяти, ожидая другие запросы, — он не будет выгружаться из памяти, если только контейнер сервлетов не почувствует недостаток в памяти. Однако каждый раз, когда запрашивается сервлет, контейнер сервлетов сравнивает метку времени загруженного сервлета с файлом класса сервлета. Если метка времени файла класса оказывается более поздней, сервлет перезагружается в памяти. Таким образом, не требуется перезапускать контейнер сервлетов всякий раз при обновлении сервлетов.
Контейнер сервлетов Tomcat и шаги создания сервлетов [ править ]
Сегодня доступно несколько контейнеров сервлетов. Наиболее популярным и признаваемым как официальный контейнер сервлетов/JSP является Tomcat. Разработанный первоначально компанией Sun Microsystems, исходный код Tomcat был передан Apache Software Foundation в октябре 1999 г. В своем новом доме Tomcat был включен в проект Jakarta. Apache, Sun и другие компании с помощью добровольцев со всего мира превратили Tomcat в эталонную реализацию контейнера сервлетов мирового уровня. Через два месяца после передачи была выпущена версия Tomcat 3.0. Затем было несколько промежуточных версий Tomcat, и на данный момент уже существует версия 9.0.
Контейнер сервлетов 9.0 (Catalina) основывается на совершенно новой архитектуре. Он был разработан заново с целью достижения максимальной гибкости и производительности. Версия 9.0 реализует спецификации Servlet 4.0.
Tomcat сам по себе является web-сервером. Это означает, что Tomcat можно использовать для обслуживания HTTP-запросов сервлетов, а также статических файлов (HTML, файлов изображений и т. д.). На практике, однако, Tomcat обычно применяется как модуль с другим более мощным web-сервером, таким как web- сервер Apache или сервер Microsoft, поскольку это ускоряет обработку запро¬сов без сервлетов и без JSP. Только запросы сервлетов или JSP передаются Tomcat.
Чтобы написать сервлет, требуется как минимум версия 1.2 набора разра¬ботчика Java (JDK, Java Development Kit). Эталонные реализации сервлетов и JSP не включены в J2SE, но они имеются в Tomcat. Tomcat написан полностью на Java.
Шесть шагов создания сервлетов
После установки и конфигурирования Tomcat следует привести его в рабочее состояние. По сути, чтобы написать и запустить сервлет, необходимо выполнить следующие шаги:
Жизненный цикл сервлетов [ править ]
Сервлеты разрабатываются с помощью пакета javax.servlet, который содержит семь интерфейсов, три класса и два исключения.
Пакет содержит семь интерфейсов:
И классы исключений:
Жизненный цикл сервлетов
Интерфейс Servlet в пакете javax.servlet является основой программирования сервлетов. Servlet — центральная абстракция технологии сервлетов Java. Каждый создаваемый сервлет должен явно или неявно реализовать интерфейс javax.servlet.Servlet. Жизненный цикл сервлета определяется тремя его методами: init, service и destroy.
Метод init вызывается контейнером сервлетов после создания экземпляра класса сервлета. Контейнер сервлетов вызывает этот метод только один раз для указания сервлету, что сервлет включается в работу. Метод init должен быть успешно выполнен, прежде чем сервлет сможет получить какие-либо запросы.
Можно переопределить этот метод для записи кода инициализации, который необходимо выполнить только один раз, такой как загрузка драйвера базы данных, инициализация значений и т.д. В других случаях этот метод обычно оставляют пустым.
Метод имеет следующую сигнатуру:
public void init(ServletConfig config) throws ServletException
Метод init является важным также потому, что контейнер сервлетов передает объект ServletConfig, который содержит конфигурационные значения, объявленные в файле web.xml для этого приложения.
Этот метод может порождать исключение ServletException. Контейнер сервлетов не может запустить сервлет в работу, если метод init порождает исключение ServletException или метод не возвращает управление в течение периода времени, определенного web-сервером.
Метод service вызывается контейнером сервлетов после метода init, чтобы позволить сервлету ответить на запрос.
Сервлеты обычно выполняются внутри многопоточных контейнеров сервлетов, которые могут обрабатывать множество запросов одновременно. Поэтому необходимо помнить о синхронизации доступа к любым общим ресурсам, таким как файлы, сетевые соединения и переменные класса и экземпляра сервлета. Например, если открыть файл и выполнить запись в этот файл в сервлете, то нужно учитывать, что другой поток того же сервлета может открыть тот же файл.
Метод имеет следующую сигнатуру:
public void service (ServletRequest request, ServletResponse response) throws ServletException, java. io. IOException
Контейнер сервлетов передает объекты ServletRequest и ServletResponse. Объект ServletRequest содержит запрос клиента, а объект ServletResponse содержит ответ сервлета. Эти два объекта позволяют писать код, который определяет, как сервлет обслуживает клиентский запрос.
Метод service генерирует исключение ServletException, если возникает исключение, которое влияет на нормальную работу сервлета. Метод service может также порождать исключение java.io. IOException, если во время выполнения метода возникает исключительная ситуация при вводе или выводе.
Метод service предназначен для того, чтобы можно было написать код, который заставляет сервлет функционировать требуемым образом.
Контейнер сервлетов вызывает метод destroy перед удалением экземпляра сервлета из службы. Это обычно происходит, когда контейнер сервлетов выключается или контейнеру сервлетов требуется дополнительная свободная память.
Этот метод вызывается только после того, как все потоки выполнения в методе service сервлета заканчиваются, или после того, как завершится период ожидания. После вызова метода destroy контейнер сервлетов не будет снова вызывать метод service этого сервлета.
Метод destroy дает сервлету возможность очистить все использовавшиеся ресурсы (например: память, дескрипторы файлов, потоки выполнения), и гарантирует, что любое устойчивое состояние синхронизировано с текущим состоянием сервлета в памяти.
Сигнатура этого метода:
public void destroy()
Демонстрация жизненного цикла сервлетов
При первом вызове сервлета на консоль выводятся следующие две строки:
Это говорит, что был вызван метод init, а затем метод service. Однако при последующих запросах вызывается только метод service. Сервлет выводит на консоль строку:
Это доказывает, что метод init вызывается только один раз.
Что делают в листинге getServletlnfo и getServletConfig? Ничего. В классе PrimitiveServlet они присутствуют лишь с целью удовлетворения спецификации, согласно которой класс должен предоставить реализации для всех методов в интерфейсе, который он реализует.
В методе getServletlnfo можно вернуть любую строку, например название компании, имя автора или другую необходимую информацию. Кто-то из про¬граммистов может расширить ваш класс сервлета, и он захочет узнать, какую полезную информацию предоставляет создатель сервлета.
Запросы и ответы [ править ]
Запросы и ответы составляют суть web-приложения. В сервлетном приложении пользователь с помощью web-браузера посылает запрос контейнеру сервлетов, а контейнер сервлетов передает запрос сервлету.
В сервлетной парадигме запрос пользователя представляется объектом ServletRequest, пересылаемым контейнером сервлетов в качестве первого аргумента метода service. Вторым аргументом метода service является объект ServletResponse, который представляет ответ пользователю.
Интерфейс ServletRequest определяет объект, используемый для инкапсуляции информации о запросе пользователя, включая пары имя/значение параметров, атрибуты и входной поток.
Интерфейс ServletRequest предоставляет важные методы, которые обеспечивают доступ к информации о пользователе. Например, метод getParameterNames возвращает Enumeration, содержащее имена параметров текущего запроса. Для получения значения каждого параметра служит метод getParameter интерфейса ServletRequest.
Методы getRemoteAddress и getRemoteHost можно применять для извлечения идентификационных данных компьютера пользователя. Первый метод возвращает строку, представляющую IP-адрес компьютера, который используется клиентом. Второй метод возвращает строку, содержащую квалифицированное имя хоста компьютера.
Листинги ниже демонстрируют объект ServletRequest в действии. Пример состоит из сервлета с именем RequestDemoServlet и формы HTML, содержащейся в файле indех.html, который необходимо поместить в каталог приложения.
Чтобы выполнить пример, запросите сначала файл index.html.
После отправки формы на экране должен появиться список имен атрибутов и значений.
Интерфейс ServletResponse представляет ответ пользователю. Наиболее важным методом этого интерфейса является getWriter. Он позволяет получить объект java.io.PrintWriter, который можно применять для записи тегов HTML и другого текста для пользователя.
Листинги представляют файл HTML с именем index.html и сервлет, метод service которого переопределяется кодом, который выводит некоторые теги HTML пользователю. Этот сервлет является модификацией примера в предыдущих листингах, извлекающего различную информацию о пользователе. Вместо вывода информации на консоль, метод service посылает ее назад пользователю.
Запустите приложение, в форме введите любое значение в качестве значения автора.
Класс HttpServlet [ править ]
Выше говорилось о том, как создавать сервлеты, выполнять их с помощью пакета javax.servlet. Однако при программировании сервлетов обычно работают с пакетом javax.servlet.http. Классы и интерфейсы этого пакета являются производными от классов и интерфейсов пакета javax.servlet. Члены javax.servlet.http богаче и удобнее в использовании. В этом пакете класс HttpServlet, представляющий сервлет, расширяет javax.servlet.GenericServIet и вносит большое число соб¬ственных методов. Пакет javax.servlet.http имеет интерфейсы HttpServletRequest и HttpServletResponse, которые эквивалентны интерфейсам javax.servlet.Request и javax.servlet. Response соответственно. HttpServletResponse расширяет интер¬фейс javax.servlet.ServletResponse, a HttpServlet Request является производным от и нтерфейса javax.servlet.Servlet Response.
Имеются дополнительные классы, которые недоступны в пакете javax.servlet. Например, можно использовать класс с именем Cookie (это небольшие текстовые файлы, в которые браузер записывает данные с посещенных вами сайтов) для работы с файлами cookie. Кроме того, класс HttpServlet предоставляет методы для работы с сеан¬сами пользователей.
Теперь рассмотрим класс HttpServlet, который обычно расширяется при разработке сервлетов.
Класс HttpServlet расширяет класс javax.servlet.GenericServlet. Класс HttpSenvlet добавляет ряд интересных методов. Наиболее важными являются шесть методов doxxx. Это методы doPost, doPut, doGet, doDelete, doOptions и doTrace. Каждый из них вызывается при использовании соответствующего метода запроса HTTP. Например, метод doGet вызывается, когда сервлет получает запрос HTTP, который был послан с помощью метода GET.
Из шести методов doxxx наиболее часто используются методы doPost и doGet. Метод doPost вызывается, когда браузер посылает запрос HTTP с помощью метода POST. Метод POST может использоваться формой HTML. Рассмотрим следующую форму HTML на клиентской стороне:
Когда пользователь нажимает кнопку Submit, чтобы отправить форму, бра¬узер посылает серверу запрос HTTP с помощью метода POST. Web-сервер пе¬редает этот запрос сервлету Register, и вызывается метод cepвлета doPost. Пара имя/значение параметра формы посылается в теле запроса. Например, если в приведенной выше форме ввести Ann в качестве значения firstName и Go в качестве значения lastName, то в теле запроса будет содержаться:
Форма HTML может также использовать метод GET; однако POST приме¬няется с формами HTML значительно чаще.
Метод doGet вызывается, когда запрос HTTP посылается с помощью мето¬да GET. GET является методом, используемым в HTTP по умолчанию. При вводе URL, например www.yahoo.com, запрос посылается на Yahoo! с помо¬щью метода GET. Если метод GET применяется в форме, пара имя/значение параметра добавляется к URL. Поэтому, если в форме имеются два параметра с именами firstName и lastName и пользователь вводит Ann и Go соответствен¬но, то U RL сервлета будет таким:
При получении метода GET сервлет вызовет свой метод doGet.
Интерфейс HttpServletRequest имеет метод с именем getMethod, который возвращает String, содержащую метод HTTP, используемый клиентским запросом. Зная метод HTTP, метод service вызывает соответствующий метод doxxx.
Сервлет в листинге ниже применяет методы doGet и doPost.
Когда сервлет вызывается в первый раз из web-браузера путем ввода URL cepвлета в поле Address или Location, в качестве метода запроса используется GET. На серверной стороне вызывается метод doGet. Сервлет посылает строку «The servlet has received a GET. Now, click the button below». («Сервлет получил GET. Теперь нажмите кнопку, расположенную ниже».) плюс форму HTML.
Посылаемая браузеру форма применяет метод POST. Когда пользователь нажимает кнопку, чтобы отправить форму, серверу передается запрос POST. Сервлет вызывает метод doPost, посылая браузеру String, содержащую «The servlet has received a POST. Thank you» («Сервлет получил POST Спасибо»).
Интерфейс HttpServerRequest [ править ]
Помимо нескольких специфических для протокола методов, содержащихся в классе HttpServlet, пакетjavax.servlet.http предоставляет также развитые интер¬фейсы запроса и ответа: HttpServletRequest и HttpServletResponse. Сегодня мы познакомимся с интерфейсом запроса HttpServletRequest с помощью ряда примеров.
Получение заголовков запроса HTTP из HttpServletRequest
Запрос HTTP, который браузер клиента посылает серверу, включает в себя заголовок запроса HTTP с важной информацией, такой как cookie и referer. Доступ к заголовкам можно получить с помощью объекта HttpServletRequest, передаваемого методу doxxx.
Следующий пример демонстрирует, как можно использовать интерфейс HttpServletRequest для получения всех имен заголовков и для отправки пар имя/ значение заголовков в браузер.
RegisterServlet в листинге использует методы getHeaderNames и getHeader. Сначала вызывается getHeaderNames для получения Enumeration, содержащего все имена заголовков, находящиеся в клиентском запросе. Значение каждого заголовка извлекается с помощью метода getHeader, которому передается имя заголовка.
Выходные данные кода зависят от клиентского окружения, в частности от используемого браузера и операционной системы клиентской машины. Например, некоторые браузеры могут посылать серверу файлы cookie. На наличие заголовка referer запроса HTTP влияет то, как пользователь запрашивает сервлет: вводит URL в поле Address/Location или щелкает мышью на гиперссылке.
Получение строки запроса из HttpServletRequest Следующим важным методом является getQueryString, который использу¬ется для извлечения строки запроса HTTP. Строка запроса размещается в U RL справа от пути доступа к сер влету.
Если в форме HTML используется метод GET, то пара имя/значение пара¬метра добавляется к URL. Код в следующем листинге является сервлетом с именем HttpRequestDemoServlet, который выводит на экран значение строки запроса и форму.
Когда пользователь вводит URL сервлета в веб-браузере и сервлет вызывается в первый раз, строка запроса содержит null.
После ввода каких-то значений в форму HTML и отправки формы страница выводится заново (см. рис. ниже). Обратите внимание, что теперь имеется добавленная к URL строка. Строка запроса содержит пары имя/значение параметров, разделенные знаком амперсанда (&).
Получение параметров из HttpServletRequest
Выше было показано, как получить строку запроса, содержащую значение. Следовательно, можно получить пары имя/значение параметров формы или другие значения предыдущей страницы. Однако применение метода getQueryString для получения пар имя/значение параметров формы нежелательно, так как в этом случае придется самостоятельно выполнять анализ стро¬ки. Можно использовать другие методы HttpServletRequest для получения имен и значений параметров: методы getParameterNames и getParameter.
Метод getParameterNames возвращает Enumeration, содержащее имена па¬раметров. Однако во многих случаях имена параметров уже известны, и этот метод использовать не нужно. Для получения значения параметра служит ме¬тод getParameter, принимающий имя параметра в качестве аргумента. Следующий пример демонстрирует, как можно использовать методы getParameterNames и getParameter для вывода всех имен и значений парамет¬ров формы HTML c предыдущей страницы.
При первом вызове сервлет не имеет никаких параметров предыдущего зап¬роса, поэтому не выводится никаких пар имя/значение:
При последующих запросах пользователь должен ввести значения обоих параметров: firstName и lastName:
Обработка многозадачных параметров Нередко требуется использовать в форме параметры с одинаковыми именами, например, в случае применения элементов управления флажком, которые могут принимать несколько значений, или при наличии элемента управления HTML с множественным выбором. В подобных ситуациях нельзя использовать метод getParameter, так как он будет выдавать только первое значение. Вместо этого применяется метод getParameterValues.
Метод getParameterValues имеет один аргумент: имя параметра. Он возвращает массив строк, содержащий все значения этого параметра. Если параметр с данным именем не найден, метод getParameterValues вернет null.
В следующем примере используется метод getParameterValues для получения всех любимых музыкальных жанров, выбранных пользователем. Код этого сервлета показан в листинге ниже.
При первом вызове сервлета вызывается метод doGet, который посылает форму. Форма имеет четыре элемента управления флажком с одним именем: favoriteMusic. Однако значения флажков различны.
Когда пользователь устанавливает флажки, браузер посылает все выбранные значения. На серверной стороне используется метод getParameterValues для извлечения значений, посланных в запросе.
Интерфейс HttpServerResponse [ править ]
Интерфейс HttpServletResponse предоставляет несколько зависящих от протокола методов, недоступных в интерфейсе javax.servlet.ServletResponse. Интер¬фейс HttpServletResponse расширяет интерфейс javax.servlet.Servlet Response. В примерах, на прошлом уроке, использовались два метода HttpServletResponse при отправке выходных данных в браузер: setContentType и getWriter.
Имеются и другие методы. Метод addCookie посылает браузеру cookie. Для обработки URL, посылаемых браузеру, также используются специальные методы.
Еще одним интересным методом интерфейса HttpServletResponse является метод sendHeader. Он позволяет добавить поле имя/значение в заголовок ответа.
Можно также использовать метод sendRedirect для перенаправления пользователя на другую страницу. Когда вызывается этот метод, web-cepвер посылает специальное сообщение браузеру для запроса другой страницы. Поэтому всегда осуществляется взаимодействие с клиентской стороной, прежде чем извлекается другая страница. Этот метод применяется в следующем примере.
Следующий листинг показывает страницу Login, которая предлагает пользователю ввести имя пользователя и пароль. Если оба значения правильны, пользователь перенаправляется на страницу Welcome. В противном случае пользователь увидит ту же самую страницу Login.
При первом вызове сервлета вызывается метод doGet. Метод doGet выводит форму. Пользователь может ввести имя пользователя и пароль и отправить форму. Отметим, что форма применяет метод POST, что означает, что на серверной стороне вызывается метод doPost и имя пользователя, и пароль сравниваются с предопределенными значениями. Если имя и пароль совпадают, пользователь перенаправляется на страницу Welcome. В противном случае метод doPost снова выводит форму Login вместе с сообщением об ошибке.
В коде листинга присутствует закрытый (private) метод с именем sendLoginForm, который получает объект HttpServletResponse и логическое значение, указывающее, будет ли вместе с формой посылаться сообщение об ошибке. Метод sendLoginForm вызывается из методов doGet и doPost. Когда он вызывается из метода doGet, сообщение об ошибке не задается, так как это первый запрос страницы пользователем. Поэтому флаг withErrorMessge установлен в false. При вызове из метода doPost флаг принимает значение true, по¬скольку метод send Login Form вызывается из метода doPost только в том случае, если имя пользователя и пароль не соответствуют заданным.
Отправка специальных символов [ править ]
Несколько символов имеют в HTML специальное назначение. Например, сим¬вол «меньше» ( ) является закрывающим символом тега HTML.
При отправке этих символов для отображения в браузере необходимо зако¬дировать их, чтобы они выводились правильно. Например, рассмотрим код листинга ниже. Метод doGet из SpecialCharacterServlet предназначен для отправки строки, которая будет выводиться браузером как следующий текст:
Однако этот код создает проблему.
Поскольку означает в HTML перевод строки, текст выводится неправильно. интерпретируется как команда разбиения исходной строки на две, и выходные данные выводятся в двух строках. Если требуется вывести на экран специальный символ, его необходимо закодировать. Символ «меньше» ( ) как «>». Другими специальными символами являются амперсанд (&) и двойная кавычка («). Амперсанд (&) заменяется кодом «&аmp;», а двойная кавычка («) — «&quоt;». Кроме того, два и более пробелов всегда выводятся как один пробел, если не преобразовать каждый отдельный пробел в «&nbsр;».
Преобразование каждого вхождения специального символа является скучной работой. Имеется функция, которая делает это автоматически. Она называется encodeHtmlTag. Если строка String, посылаемая браузеру, содержит специальный символ, передайте ее на преобразование функции encodeHtmlTag.
Следующий листинг демонстрирует сервлет, который использует метод encodeHtmlTag для кодирования любой строки String со специальными символами:
Отправка кода ошибки
HttpServletResponse позволяет также посылать предопределенные сообщения об ошибках. Интерфейс определяет ряд public static final целых чисел, которые начинаются с SC_. Например, SC_FORBIDDEN будет транслироваться в НТТР-ошибку 403.
Вместе с кодом ошибки можно послать индивидуальное сообщение об ошибке. При неудачной регистрации, вместо повторного вывода на экран страницы Login, можно послать НТТР-ошибку 403 и сообщение:
Технология JavaServer Pages [ править ]
JavaServer Pages [ править ]
Серверные страницы Java (JavaServer Pages, JSP) представляют собой еще одну технологию Java для разработки web-приложений. JSP были выпущены в то время, когда технология сервлетов завоевала популярность как одна из лучших доступных web-технологий. Однако JSP не заменяют сервлеты. Фактически JSP являются расширением технологии сервлетов, и общая практика состоит в использовании сервлетов и страниц JSP в одном web-приложении.
Создание JSP является настолько простым, что можно писать приложения JSP, не имея больших знаний о базовом API. Однако высококлассный web-программист Java обязан знать как JSP, так и сервлеты. Даже если применяются только страницы JSP в web-приложениях Java, понимание технологии сервлетов по-прежнему очень важно. JSP используют те же методы, что применяются при программировании сервлетов. Например, в JSP работают с запросами HTTP и ответами HTTP, с параметрами запроса, атрибутами запроса, со средством управления сеансом, cookie, перезаписью URL и т.д.
История Java-программирования на стороне сервера началась с сервлетов. Компания Sun представила сервлеты в 1996 г. как небольшие приложения на основе Java для добавления динамического содержимого в web-приложения. С ростом популярности Java сервлеты стали одной из самых распространенных технологий Интернета. Однако программисты сервлетов знают, сколь обременительным является программирование с помощью сервлетов, особенно, когда необходимо послать длинную страницу HTML, которая содержит мало кода. Рассмотрим в качестве примера листинг ниже. Этот код является фрагментом приложения на основе сервлетов, который выводит имена и значения всех параметров в запросе HTTP.
Почти половина содержимого, посланного методом doPost, является статическим HTML. Однако каждый тег HTML должен быть помещен в String и передан с помощью метода println объекта PrintWriter. Это скучная работа. Хуже того, страница HTML может быть значительно больше.
Другим недостатком использования сервлетов является то, что любое изменение будет требовать вмешательства программиста сервлета. Даже незначительная графическая модификация, например изменение значения атрибута BGCOLOR тега с #DADADA на #FFFFFF, потребует работы программиста (который в этом случае будет действовать под управлением более сведущего в графике web-дизайнера).
Компания Sun увидела эту проблему и вскоре разработала ее решение. Результатом явилась технология JSP. Согласно web-сайту Sun, «технология JSP является расширением технологии сервлетов, созданным для поддержки разработки страниц HTML и XML». Применение JSP значительно облегчает комбинирование фиксированных или статических шаблонных данных с динамическим содержимым.
Еще раз подчеркнем, что JSP не являются заменой сервлетов. Скорее, технология JSP и сервлеты совместно предоставляют привлекательное решение для программирования и создания сценариев Web, предлагая независимость от платформы, улучшенную производительность, разделение логики и представления, легкость администрирования, расширяемость на уровень предприятия и, самое важное, легкость в использовании.
Создание первой серверной страницы. Принцип работы JSP [ править ]
Сегодня мы напишем простую страницу JSP и выполним ее. Для выполнения приложений JSP используем Tomcat 8. Если Tomcat 8 установлен и сконфигурирован для сервлетных приложений, то больше ничего делать не надо.
JSP существенно упрощает работу с сервлетами. Для выполнения своей страницы JSP необходимо только сконфигурировать контейнер JSP (Tomcat) и написать страницу JSP. Конфигурирование выполняется лишь однажды в самом начале. Не требуется никакой компиляции.
Создание файла JSP
В NetBeans файл создается следующим образом, в созданном веб-проекте кликните правой кнопкой мыши на папку каталога «веб-страницы» → новый → JSP.
Страница JSP содержит вперемешку теги HTML и код Java. Теги HTML выполняют задачу представления, а код создает содержимое. В своей наиболее простой форме страница JSP может включать в себя только HTML, как показано в листинге ниже:
Конечно, код в листингe выше не является полезным, но он иллюстрирует тот факт, что страница JSP вовсе не обязана иметь код. Если страница статичес¬кая, нет необходимости помещать ее в файл JSP, так как файлы JSP обрабаты¬ваются медленнее, чем файлы HTML. Использовать файл JSP для тегов HTML можно в том случае, если предполагается добавить в него в будущем код Java. Это избавит от проблемы изменения ссылок на эту страницу.
Как мы видим код листинга использует код Java для отправки текста. Функции out.println служит для отправки String web-браузеру.
Другой пример представлен в листинге ниже. Этот фрагмент кода выводит строку «Добро пожаловать. Время сервера:» и время сервера:
Принцип работы JSP
Скриплеты. Директивы [ править ]
Скриптлет — это кусок Java-программы, встроенной в HTML-страницу. Создадим JSP файл и вставим в него скриптлет, который будет выводить некоторый текст:
В предыдущем примере мы использовали метод «out» для того, чтобы выводить HTML-текст. При программировании JSP вряд ли всегда будет удобно выводить HTML-текст средствами потока вывода «out». Допустим, нам нужно вывести результат поиска по базе данных. Это удобно сделать в виде HTML-таблицы. Для этого вовсе не обязательно использовать out. Более удобное решение показано в следующем листинге:
Кроме вставки уже существующих фрагментов кола директивы могут быть использованы для импортирования файлов:
Обработка форм с использованием компонента Beans [ править ]
Компоненты JavaBean – это многократно используемые классы Java, позволяющие разработчикам существенно ускорять процесс разработкии WEB-приложений путем их сборки из программных компонентов. JavaBeans и другие компонентные технологии привели к появлению нового типа программирования – сборки приложений из компонентов, при котором разработчик должен знать только сервисы компонентов; детали реализации компонентов не играют никакой роли.
JavaBean – это одноуровневые объекты, использующиеся для того, чтобы инкапсулировать в одном объекте код, данные или и то, и другое. Компонент JavaBean может иметь свойства, методы и события, открытые для удаленного доступа.
Требования к проектированию компонентов JavaBeans
Требования к проектированию компонентов JavaBeans определяют свойства класса и методы public, дающие доступ к свойствам. Свойство компонента JavaBeans может быть:
Не существует требования, чтобы свойство реализовывалось переменной экземпляра. Свойство просто должно быть доступно через методы public, следующие определенным правилам:
Кроме методов свойств компонент JavaBeans должен определить конструктор без параметров.
Методы getters setters
Компонент JavaBean должен удовлетворять определенным соглашениям о наименовании методов и экспортируемых событий. Одним из важных понятий технологии JavaBeans является внешний интерфейс properties (свойства). Property JavaBean – это методы getters и setters, обеспечивающие доступ к информации о внутреннем состоянии компонента JavaBean. Для обращения к компонентам JavaBeans на странице JSP необходимо использовать следующее описание тега в разделе head :
Идентификатор BeanID определяет имя компонента JavaBean, являющееся уникальным в области видимости, определенной атрибутом scope. По умолчанию принимается область видимости scope=»page», т.е. текущая страница JSP.
Обязательный атрибут класса компонента «class» может быть описан следующим способом:
Свойство JavaBean компонента устанавливается тегом jsp:setProperty. Пример :
Для чтения свойства компонента JavaBean с именем myBean используется тег jsp:getProperty :
Рассмотрим простой пример, в котором на странице JSP будет выведено приветствие и введённые данные пользователя в HTML форму. Первым делом создаем HTML форму и записываем файл как «index.jsp»
В форме задали три имени для различных элементов: name, lastname, age. Создаем класс NameHandler:
В этом классе описаны get и set для каждого элемента формы на основе имени этого элемента.
Запускаем приложение, вводим форму необходимые данные нажимаем кнопку «ок».