Jsp java что это
Перейти к содержимому

Jsp java что это

  • автор:

Java Server Pages

Java Server Pages представляет технологию, которая позволяет создавать динамические веб-страницы. Изначально JSP (вместе с сервлетами) на заре развития Java EE являлись доминирующим подходом к веб-разработке на языке Java. И хотя в настоящее время они уступило свое место другой технологии — JSF, тем не менее JSP продолжают широко использоваться.

По сути Java Server Page или JSP представляет собой html-код с вкраплениями кода Java. В то же время станицы jsp — это не стандартные html-страницы. Когда приходит запрос к определенной странице JSP, то сервер обрабатывает ее, генерирует из нее код html и отправляет его клиенту. В итоге пользователь после обращения к странице JSP видит в своем браузере обычную html-страницу.

Как и обычные статические веб-страницы, файлы JSP необходимо размещать на веб-сервере, к которому обычные пользователи могут обращаться по протоколу http, например, набирая в адресной строке браузера нужный адрес. Однако чтобы сервер мог обрабатывать файлы JSP, он должен использовать движок JSP ( JSP engine ), который также называют JSP-контейнером. Есть множество движков JSP, и все они реализуют одну и ту же спецификацию и в целом работают одинаково. Однако тем не менее при переносе кода с одного веб-сервера на другой могут потребоваться небольшие изменения.

JSP Engine

В данном случае для работы с JSP мы будем использовать Apache Tomcat, который одновременно является и веб-сервером и контейнером сервлетов и JSP.

Создадим простейшую страницу JSP. Для этого где-нибудь на жестком диске определим файл index.jsp . Все станицы JSP имеют расширение jsp . Откроем этот файл в любом текстовом редакторе и определим в нем следующий код:

     First JSP App   

Today

С помощью тегов мы можем определить код Java на странице JSP. В данном случае мы просто определяем переменную типа String, которая называется header.

Затем идет стандартный код страницы html. Чтобы внедрить код java внутрь html-страницы применяются теги — после знака равно указывается выражение Java, результат которого будет выводиться вместо этих тегов. В данном случае, используются две таких вставки. Первая вставка — значение переменной header, которая была определена выше. Вторая вставка — выражение new java.util.Date() , которое возвращает текущую дату.

Для тех, кто знаком с веб-разработкой на PHP, это может напоминать оформление файлов php, которые также содержать код html и код php.

Теперь поместим данный файл на сервер — в данном случае в контейнер Tomcat. Перейдем в Apache Tomcat к папке webapps\ROOT . Удалим из нее все содержимое и поместим нашу страницу index.jsp , которая была создана выше.

Java Server Pages

Запустим Apache Tomcat (если он не запущен), и обратимся к приложению по адресу http://localhost:xxxx/index.jsp , где xxxx — номер порта, по которому запущен Tomcat:

Введение в Java Server Page

В итоге Tomcat получит запрос к странице index.jsp, обработает код на java, сгенерирует html-страницу и отправит ее пользователю.

Java Server Pages

Технология Java Server Pages (JSP) является составной частью единой технологии создания бизнес-приложений J2EE. JSP — это альтернативная методика разработки приложений, динамически генерирующих ответ на те или иные запросы клиента. Прежде чем JSP документ будет использован, специальная процедура преобразует его в соответствующий сервлет. В свою очередь, сервлет, как правило, пишется на языке Java и реализует определенный интерфейс. Далее, сервлет также не является самостоятельным приложением и функционирует, только будучи помещен в соответствующий web-контейнер. Web-контейнер обеспечивает обмен данными между сервлетом и клиентами, берет на себя выполнение таких функций, как создание программной среды для функционирующего сервлета, идентификацию и авторизацию клиентов, организацию сессии для каждого из них.

На настоящий момент реализована трансляция JSP страницы в сервлет, программный код которого пишется на языке Java. Однако авторы спецификации Java Server Pages оставляют возможность реализации JSP и на других языках программирования.

Соотношение между сервлетами бизнес-приложения и адресами URL на сервере задается в дескрипторе размещения. Технология реализации сервлетов обсуждается в отдельной статье. Сейчас же важно отметить тот факт, что программный код, используемый для написания сервлетов, не всегда удобен для динамической генерации текстовых документов в ответ на запрос клиента. Например, фрагмент сервлета, где осуществляется генерация динамической HTML страницы, может выглядеть следующим образом:

PrintWriter out = res.getWriter(); out.println(""); out.println(""); . out.println(""); out.println(""); out.close();

Как видим, каждой строке HTML документа в сервлете соответствует определенный фрагмент программного кода, что не способствует простоте разработки и сопровождения бизнес-приложений.

Удобнее разделить динамическую и статическую части генерируемой web-страницы. Для создания динамической части по-прежнему будет использоваться Java или другой язык программирования. Статическую же часть имеет смысл оформить как текстовый документ — Java Server Page (JSP страницу), оформленную в соответствии с требованиями HTML, XML или другого стандарта разметки. Фактически, JSP страница можно рассматривать как шаблон или прообраз динамической страницы, которую остается дополнить динамическими элементами. Для описания динамической составляющей, в технологии JSP предусмотрено два основных механизма: компоненты JavaBean и библиотеки дополнительных тэгов. Как результат, технология JSP предполагает параллельную работу над приложением двух разных специалистов: программиста и ответственного за верстку документов (web мастера), которые отвечают, соответственно, за разработку динамической и статической частей документов, генерируемых в ответ на запросы клиентов.

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

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

JSP страница

Как правило, JSP страница хранится в отдельном файле с расширением .jsp. Большая часть содержимого JSP страницы преобразуется в сервлете в набор инструкций out.println(). Пример JSP страницы:

  All Customers   0 ) < %> 
"> else < %> > > %>

Динамическая составляющая JSP страницы представлена тремя типами специальных элементов: директивами, action и скриптами. Подробнее каждый из них рассматривается в соответствующем разделе.

Директивы

Поскольку web контейнер, прежде чем использовать JSP страницу, предоставленную разработчиками бизнес-приложения, транслирует ее в соответствующий сервлет, имеет смысл предоставить возможность оставлять на JSP странице директивы, которые будут управлять процессом трансляции. Директивы имеют синтаксис .

Рассмотрим некоторые из таких директив.

Директива page. Декларирует ряд свойств JSP страницы. Синтаксис директивы:

Опишем некоторые наиболее интересные параметры данной директивы:

  • import — Как уже говорилось, JSP страница перед использованием должна быть преобразована в программный код — класс, соответствующего сервлета. В свою очередь, класс сервлета может обращаться к другим классам из стандартных библиотек Java или классам из других пакетов. По умолчанию, класс сервлета, получаемый после трансляции JSP страницы, может иметь связь с пакетами java.lang, java.servlet, java.servlet.jsp и java.servlet.http. Если для класса сервлета требуется обеспечить связь с другими пакетами, например, с xbcat.util как в приведенном выше примере JSP страницы, последнюю следует дополнить директивой page, имеющей атрибут import с названием соответствующего пакета.
  • session — Если для связи с клиентом используется протокол HTTP, то для каждого сеанса по умолчанию создается объект session, позволяющий сохранять информацию об этом клиенте в интервале между его обращениями к серверу. С другой стороны, если атрибут session был указан со значением false, это позволяет отказаться от создания объекта сессии и использовать освободившиеся ресурсы сервера для решения других задач.
  • buffer — Содержимое страницы, созданной в ответ на запрос клиента, сервлет передает в поток вывода out, откуда оно затем передается web контейнером непосредственно клиенту. Чтобы получить более оптимальный режим передачи, в этом потоке предусмотрен режим буферизации. При этом объем буфера по умолчанию составляет 8 килобайт. Параметр buffer директивы page позволяет либо задать другой объем буфера, либо вообще отказаться от режима буферизации, передав атрибуту значение «none».
  • isThreadSafe — Согласно спецификации сервлетов, web контейнер по умолчанию позволяет одному и тому же экземпляру сервлета параллельно обрабатывать запросы сразу от нескольких клиентов. При этом каждому из запросов выделяется отдельный трэд. Между тем, в некоторых случаях бывает полезно запретить параллельную обработку запросов. (Соответствующий контроллер в web контейнере выстраивает приходящие запросы в очередь и передает их сервлету на обработку строго по одному.) Для этого достаточно использовать атрибут isThreadSafe, со значением false.
  • pageEncoding — Позволяет разработчику приложения декларировать кодировку, которая должна использоваться в документе, передаваемом клиенту. По умолчанию считается, что страница имеет кодировку ISO-8859-1.
  • contentType — В ответ на запрос клиента, JSP страница по умолчанию генерирует документ типа HTML. Вместе с тем, область применения технологии Java Server Pages гораздо шире, поскольку она позволяет генерировать любые другие типы текстовых документов: XML, WML, VRML и т.д. MIME-тип генерируемого документа декларируется атрибутом contentType. Как уже понятно, по умолчанию этот атрибут имеет значение «test/html». Вместе с типом документа, спецификация JSP позволяет в том же атрибуте указывать также кодировку генерируемого документа.

Директива taglib. Позволяет использовать на JSP страницах дополнительные тэги, созданные разработчиком приложения (custom тэги). Синтаксис директивы:

где, uri — абсолютный или относительный адрес URI, уникальным образом идентифицирующий дескриптор библиотеки тэгов, связанных с указанным префиксом. Указанный префикс используется для идентификации соответствующих custom тэгов.

Процедуру создания custom тэгов мы рассмотрим позднее.

Директива include. Используется для помещения в JSP страницу текстов и программного кода из других источников. Подстановка выполняется в момент, трансляции JSP страницы в соответствующий сервлет. Пример использования директивы:

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

Фрагмент программного кода на JSP странице (скрипт)

Скрипт, как и остальные элементы, привносит в конечный документ динамическую составляющую. Однако, в отличие от них, скрипт — программный код, помещенный непосредственно в текст JSP страницы. Скрипт может производить вычисления или манипулировать объектами, что позволяет наглядно связывать характеристики генерируемой страницы с параметрами запроса клиента и бизнес-правилами приложения. Элементы скриптов бывают трех типов: декларации, скриплеты и выражения.

Декларации.

После преобразования JSP страницы в сервлет большая часть ее содержимого попадает в метод _jspService(), который вызывается всякий раз, когда появляется необходимость обработать заказ клиента. Декларация на JSP странице чаще всего используется для того, чтобы объявить дополнительные атрибуты и методы в классе сервлета, которые будут доступны при обработке любого запроса клиента. Декларации имеют синтаксис .

Примеры деклараций на JSP странице:

Скриплеты.

Скриплет может содержать программный код и декларации локальных переменных, которые будут использованы для обработки запросов клиентов. Фактически, скриплет — это фрагмент программного кода из будущего сервлета, который в свое время будет помещен в метод _jspService(). Являясь частью сервлета, скриплет получает доступ к объекту response и, соответственно, может самостоятельно формировать определенную часть конечной динамической страницы. Однако чаще всего скриплеты используются не для этого, а для того, чтобы управлять объектами бизнес-логики и логикой приложения.

Скриплет имеет синтаксис . Пример использования скриплетов в содержимом JSP страницы:

 Good morning else < %>Good afternoon %>

Чтобы оценить наглядность и простоту этой конструкции, сравните ее с эквивалентным фрагментом программного кода в сервлете:

if (i == 0) < out.println("Good morning"); >else

Выражения.

Часто страница, передаваемая клиенту, содержит результаты вычислений или обращений к тем или иным методам и атрибутам определенных классов. Любой из таких динамических элементов можно преобразовать в строку и представить на JSP странице с помощью вызова out.println в соответствующем скриплете:

Вторую строку в приведенном примере удобнее и нагляднее представить в боле кратном виде, используя синтаксис выражения :

Другой пример использования выражения в теле JSP страницы:

 Hi, now the servlet processing th request.

JSP страницы и объекты

В ходе обработки запросов, JSP страница может получать доступ к объектам, расположенным на сервере, создавать их и модифицировать. Доступ к объектам осуществляется через элементы скриптов и action. Каждый создаваемый в приложении объект имеет определенное время существования, которое декларируется в соответствующем атрибуте. Спецификацией предусматривается четыре интервала:

  • page — Объект, чье время существования определяется как page, доступен в пределах только той JSP страницы, где он был создан. Все ссылки на этот объект должны быть освобождены сразу же после того, как запрос клиента был обработан.
  • request — Объект, чье время существования определяется как request, доступен для всех страниц, связанных с обработкой данного запроса. В частности, если имеет место переадресация обработки на новую JSP страницу, данный объект будет доступен и на прежней, и на новой странице. Как и в предыдущем случае, ссылки на объект после обработки запроса должны быть освобождены.
  • session — Объект с областью видимости session доступен для всех страниц, обрабатывающих запросы, связанные с определенной сессией (сеансом связи с конкретным клиентом). Ссылки на объекты, связанные с сессией, помещаются в объект session. По окончании сеанса связи ссылки должны быть освобождены.
  • application — Наиболее общая область видимости. Объекты, имеющие область существования application, не привязаны к какой-либо отдельной странице или сеансу связи и доступны со всех JSP страниц данного приложения.

JSP страница всегда имеет доступ к определенному набору объектов, создаваемых web контейнером по умолчанию:

  • request — Объект, содержащий запрос клиента. Относится к классу javax.servlet.ServletRequest или другому наследующему его классу. Например, для протокола HTTP это будет объект класса javax.servlet.http.HttpServletRequest. Область видимости объекта — request.
  • response — Объект, в который сервлет будет помещать ответ на запрос пользователя. Относится к классу javax.servlet.ServletResponse или другому наследующему его классу. Например, для протокола HTTP это будет объект класса javax.servlet.http.HttpServletResponse. Область видимости объекта — request.
  • pageContext — Объект, определяющий контекст JSP страницы. Область видимости объекта — page
  • session — Объект, создаваемый контейнером для идентификации клиента, а также хранения персональных объектов. Создается контейнером для протокола HTTP и является экземпляром класса javax.servlet.http.HttpSession.
  • application — Объект, связанный с конфигурацией сервлета, соответствующего данной JSP странице. Область видимости объекта — application.
  • out — Объект, содержащий выходной поток сервлета. Информация, посылаемая в этот поток, будет передана клиенту. Объект является экземпляром класса javax.servlet.jsp.JspWriter. Например, большая часть статического шаблона на JSP странице, в идеале, должна быть записана в виде соответствующего набора команд out.println(). Область видимости объекта — page.
  • config — Объект, связанный с конфигурацией сервлета. Является экземпляром класса javax.servlet.ServletConfig. Для JSP страницы область видимости объекта config — page.
  • page — Объект, связанный с обработкой данной страницы. Область видимости — page

Элементы action

Независимо от того, какой тип будет иметь документ, генерируемый в ответ на запрос пользователя, в общем случае, JSP страница содержит текст и тэги. Очевидно, что последние соответствуют типу генерируемого документа: HTML, XML и т.д. Кроме того, в теле JSP страницы могут содержаться фрагменты программного кода на языке Java, которые должны войти в состав сервлета, получаемого после трансляции: декларации, скриплеты и выражения. Идея заключается в том, чтобы дополнить набор тэгов стандартной разметки специальными тэгами — элементами action, за которыми разработчик бизнес-приложения может скрыть часть программного кода, относящегося к приложению, либо некоторые дополнительные инструкции.

Заметим, что с точки зрения специалиста по верстке документов, элементы action являются такими же тэгами, как и все остальные, а потому допустимо их совместное использование с другими элементами:

Рассмотрим некоторые из этих элементов.

Стандартные элементы action

Стандартные элементы action выглядят как обычные тэги, название которых начинается с сочетания символов jsp:, например . Согласно терминологии XML, это означает, что стандартные элементы action в технологии JSP принадлежат пространству имен jsp.

jsp:useBean

Элемент jsp:useBean позволяет использовать на JSP странице объекты, соответствующие компонентам JavaBean. Элемент содержит параметр, который связывает с компонентом некий уникальный идентификатор. Последний затем будет использоваться при обращениях к этому объекту:

В данном примере создается объект класса com.myco. В дальнейшем, чтобы обратиться к нему, достаточно воспользоваться идентификатором «customer». Например:

По умолчанию, объекты, связанные с элементом JavaBean, по умолчанию имеют область видимости page. Разработчик JSP страницы может указать более продолжительное время существования объекта JavaBean, воспользовавшись при написании элемента jsp:useBean элементом scope. Возможные значения этого атрибута — page, request, session и application — мы обсуждали несколько ранее во время разговора об области видимости объектов, связанных с JSP страницей.

Мы не будем рассматривать остальные атрибуты элемента jsp:useBean. Приведем лишь еще один пример его использования:

Внутреннее устройство элементов JavaBean будет рассмотрено нами в отдельной статье.

jsp:setProperty и jsp:getProperty

Любой класс должен давать доступ к некоторым из своих атрибутов и методов. Отличие элемента JavaBean заключается в том, что доступ к атрибутам у него унифицирован и реализуется на JSP странице с помощью элементов jsp:setProperty и jsp:getProperty.

Элемент jsp:getProperty берет экземпляр Bean, извлекает значение указанного атрибута, преобразует его в случае необходимости в строку и помещает в поток данных, передаваемых клиенту. Например, согласно следующей записи

в генерируемый документ помещается значение свойства name из экземпляра Bean, имеющего идентификатор user.

Элемент jsp:setProperty, в отличие от предыдущего, не извлекает, а задает новое значение атрибута. Например:

Помимо явного задания новых значений, элемент jsp:setProperty позволяет заносить в атрибут объекта значение, извлеченное из запроса клиента. Например:

Данная запись означает, что среди данных, полученных от клиента, находится параметр login и его значение передается для помещения в атрибут name объекта Bean, имеющего идентификатор «user».

Наконец, когда названия полей в запросе клиента совпадают с названиями атрибутов объекта Bean, предусмотрен еще один вариант, когда разом осуществляется перенос всех значений. Например:

jsp:include

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

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

Пример использования элемента jsp:include:

jsp:forward

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

В следующем, более сложном примере динамическая страница завершается содержимым текстового файла, название которого берется из переменной someValue:

В заключение следует заметить, что есть две основные схемы обработки запросов клиента:

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

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

Дополнительные наборы тэгов

Введение

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

Построение custom тэгов связано с написанием определенного программного кода. Технология JSP предусматривает размещение этого кода в отдельном программном модуле — библиотеке custom тэгов. Разработка подобных библиотек может быть поручена сторонним компаниям. Подключение JSP страницы к той или иной библиотеке custom тэгов осуществляется с помощью ранее описанной директивы taglib. Указанная директива связывает дескриптор соответствующей библиотеки с определенным префиксом, который, в свою очередь, идентифицирует в теле JSP страницы все custom тэги из данной библиотеки. Так, директива

объявляет, что в JSP странице используется библиотека дополнительных тэгов, название каждого из которых начинается с префикса dscat. Например:

All Customers 

Программный код данной библиотеки описывается дескриптором exttags.tld. Мы не будем здесь останавливаться на правилах написания дескриптора библиотеки, а рассмотрим лишь один из возможных примеров его реализации:

   1.0 1.2 dscat pageheader ru.view.tag.PageHeader   

Создание библиотеки custom тэгов

Custom тэги без обработки содержимого

Программный код для поддержки custom тэга — это специальным образом написанный экземпляр Java класса, который вызывается web контейнером всякий раз, когда требуется обработать JSP страницу, содержащую соответствующий тэг.

В простейшем случае, для поддержки custom тэга можно взять какой-либо из классов бизнес-приложения и дополнить его методами, соответствующими интерфейсу Tag. Если же внешних объектов использовать не надо, то в качестве базового класса можно использовать TagSupport. Эти и другие стандартные классы и интерфейсы находятся в пакете javax.servlet.jsp.tagext.

Пример класса, осуществляющего поддержку custom тэга:

public CopyrightTag extends TagSupport < public int doStartTag() throws Exception < pageContext.getOut().print("© Copyright, 2001"); return SKIP_BODY; > public int doEndTag() < return EVAL_PAGE; >>

Методы класса, который осуществляет обработку custom тэга, вызываются в определенной последовательности. Когда в JSP странице обработка доходит до открывающего custom тэга, для его обработки вызывается метод doStartTag(). Когда обработка доходит до соответствующего закрывающего тэга, вызывается метод doEndTag(). Для обработки той части JSP страницы, которая заключена между этими двумя тэгами, используются методы doInitBody() и doAfterBody().

Помимо того, что метод doStartTag() может осуществлять какую-либо обработку запроса, большое значение имеет возвращаемое им значение. Если это SKIP_BODY, то информация, заключенная между соответствующими открывающим и закрывающим тэгами, будет игнорироваться, а обработка JSP страницы сразу перейдет на закрывающий тэг. Чтобы содержимое custom тэга все же обрабатывалось, медот должен возвратить EVAL_BODY_INCLUDE. Аналогично, если метод doEndTag() возвратит значение SKIP_PAGE, то оставшаяся часть JSP страницы после закрывающего тэга будет проигнорирована. Чтобы не допустить этого, метод должен возвратить значение EVAL_PAGE.

В некоторых случаях бывает необходимо показать содержимое custom тэга не один, а несколько раз. В этом случае, класс, осуществляющий обработку тэга, должен реализовывать интерфейс IterationTag, либо использовать в качестве родителя класс TagSupport. Чтобы повторить вывод содержимого custom тэга еще раз, необходимо, чтобы методы doStartTag и doAfterBody возвращали EVAL_BODY_AGAIN.

Custom тэги с обработкой содержимого

Если требуется доступ к содержимому custom тэга, то соответствующий Java класс должен реализовывать интерфейс BodyTag или же наследовать класс BodyTagSupport. И в том, и в другом случае класс может реализовать методы doInitBody и doAfterBody.

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

Метод doAfterBody вызывается после того, как содержимое custom тэга было обработано. Как и в предыдущем разделе, метод doAfterBody может указывать, следует ли повторить обработку содержимого тэга еще раз. Если это необходимо, метод должен возвратить значение EVAL_BODY_BUFFERED. В противном случае он должен возвратить SKIP_BODY.

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

Непосредственно для доступа к содержимому custom тэга технологией предусмотрено два метода: getString и getReader.

Атрибуты в custom тэгах

Помимо информации в промежутке между открывающим и закрывающим тэгами, custom тэг может иметь некоторые атрибуты, которые также могут оказывать влияние на порядок обработки запроса клиента. Для каждого из таких атрибутов в классе, реализующем custom тэг, должен быть указан соответствующий атрибут, а также два метода get и set. Например, если custom тэг имеет вид

то реализующий этот custom тэг класс должен содержать следующий код:

protected String height = null; public String getHeight() < return (this.height); >public void setHeight(String value)

Атрибуты custom тэга также необходимо декларировать в дескрипторе библиотеки custom тэгов.

Следует заметить, что в этом разделе мы рассмотрели лишь наиболее часто используемые методы, связанные с обработкой custom тэгов. К примеру, неосвещенными остались такие важные темы, как интерфейс TryCatchFinally и абстрактный класс BodyContent.

Технологии JSP: описание, особенности, использование

В программировании на том или ином языке приходится учитывать огромное количество особенностей. Java – универсальный современный способ создания контента кроссплатформенного типа. Его достаточно легко освоить, а вот с применением возникают некие трудности. Особенно если нужно создавать серверные приложения.

В данной статье познакомимся с технологией под названием JSP. Она активно применяется при написании определенного типа веб-страничек. Освоить оную рекомендуется из-за того, что с ее помощью удастся довольно быстро делать HTML-сайты.

Что это такое

JSP расшифровывается как Java Server Pages. Это технология, которая позволяет разработчикам веб-контента создавать содержимое с динамическими и статическими компонентами. Странички JSP включают в себя текст разного типа. Первый вариант – статическая исходная информация. Она может быть представлена в:

Второй тип текста – JSP элементы. Они отвечают за создание динамического содержимого. Также допускается применение полноценной библиотеки JSP тегов и EL. Все это помогает внедрить Java-код в статичное содержимое JSP-страничек.

JSP – это некая платформенно-независимая технология, используемая для написания HTML динамического характера. Теги здесь применяются для того, чтобы извлекать информацию из БД, обмениваться имеющимися сведениями и так далее. Для запуска часто применяются среды IDE NetBeans или Eclipse.

Несколько слов о сервлетах

Говоря о HTML и серверных утилитах, стоит обратить внимание на такую особенность, как сервлет. Это специальный программный модуль, который используется для обработки запросов клиентов. Отвечает за реализацию интерфейса сервлета. Находится на серверной стороне.

Работает по принципу запрос-ответ. Используются преимущественно для расширения веб-servers. Принцип работы несколько напоминает JSP.

Чем Java Server Page лучше Servlets

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

  1. Отвечает за возможность создания и управления HTML динамического типа. В данном случае процессы будут осуществляться более просто.
  2. Для работы не требуется загрузка дополнительного программного обеспечения или документов. Пример – можно обойтись без файла класса java и web.xml.
  3. Обработка ведется web-container для всех корректировок кода. Это приводит к тому, что JSP помогает избежать перекомпиляции.

А еще доступ здесь осуществляется напрямую. Сервлеты требуют предварительного проведения сопоставления с web.xml.

О важности технологии

Стоит обратить внимание на то, что JSP – это то, с чем должен ознакомиться каждый программер. Связано это с несколькими причинами. Для начала нужно рассмотреть возможности и сферы применения технологии. Она дает возможность:

  • получения информации из HTML страницы в Java-коде;
  • отправлять электронные материалы из Java на HTML;
  • заниматься написанием Джава-кода непосредственно внутри HTML (но лучше не слишком часто пользоваться соответствующим приемом).

Знать упомянутую технологию важно по нескольким причинам. А именно:

  • это одна из ключевых особенностей веб-технологий в Джаве;
  • применяется в крупных компаниях и сложных проектах;
  • хорошо интегрируется с сервлетами Джавы внутри контейнера сервлетов.

JSV – база для тех, кто планирует заниматься HTML и серверными утилитами. Облегчает и ускоряет работу любого программера.

Цикл жизни

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

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

Перевод – самое начало

Это – первый этап. Здесь происходит следующее:

  1. Контейнер переводит JSP документ в код Джавы. Он выступает сервлетом.
  2. Перевод проводится в автоматическом режиме через веб-сервер.
  3. Последний находит и проверяет достоверность, а затем производит запись сервлета для JPS page.

Здесь никаких проблем с пониманием быть не должно.

Компиляция – шаг два

После описанных ранее действий контейнер JSP будет компилировать исходный Java-код. Это необходимо для того, чтобы создавать следующие servlets и сгенерированный классовый файл.

Загружаем и инициализируем – шаг три

Третий этап предусматривает следующее:

  1. JSP Container загружает ранее созданный servlet.
  2. Если процесс прошел правильно, будет создан экземпляр класса сервлета.
  3. Важно учесть, что здесь используется конструктор, не имеющий никаких аргументов.
  4. Контейнер JSP проводит инициализацию экземпляра объекта через вызов метода init. Он реализуется container посредством обращения к jspInit().

Элемент кода выше наглядно демонстрирует, каким образом осуществляется инициализация экземпляра.

Выполнение – шаг четыре

Теперь, когда основные этапы позади, происходит не менее важный момент – выполнение. Здесь технология JSP вызовет метод _jspService(). У него два параметра:

  • httpServletRequest;
  • HttpServletResponse.

Вызывается рассматриваемый метод всего один раз для каждого отдельного запроса.

Упомянутый метод будет отвечать за генерацию ответов на посланный запрос.

Разрушение – логическое завершение

На данном этапе целесообразно говорить о прекращении жизненного цикла.

При разрушении контейнер будет удалять JSP при помощи jspDestroy(). Как это происходит, указано на наглядном примере выше.

Первый проект – tutorial

Для того, чтобы лучше разобраться в HTML и динамических страницах, созданных через рассматриваемую технологию, рекомендуется создать первый проект. Приведенный пример будет реализован через Eclipse.

Чтобы воспользоваться первым приложением JSP, необходимы следующие «компоненты»:

  • Java;
  • JSP;
  • Apache Tomcat 8;
  • Eclipse IDE.

Разобраться с соответствующей технологией HTML не составляет никакого труда, если действовать последовательно.

Создание проекта

Для того, чтобы создавать страницы JSP и подобного рода приложения, можно действовать следующим образом:

  • Создать новый проект динамического характера.

  • Добавить имя разработки. Пусть будет RankWebApplication.

  • Нажать на кнопку Next.
  • Далее предстоит осуществить настройку проекта. Шаг рекомендуется пропустить, так как в примере речь идет лишь о демонстрационной разработке.
  • Создавать web.xml не нужно. Этот факт требуется подтвердить в настройках веб-модуля.
  • Щелкнуть по кнопке с надписью «Готово».
  • Составить структуру каталогов имеющегося проекта.

  • Нажать ПКМ по каталогу «Веб Контент» и добавить новый файл JSP в разработку.

  • Назвать файл как NewRankFile.jsp.
  • Подтвердить операцию.

  • Установить шаблон JSP.

  • После того, как описанные действия останутся позади, произойдет создание нового файла. В «листинг 1» необходимо добавить html body, предложенное ниже. Он отвечает за выведение рейтинга команд по крикету.

  • Запустить проект, кликнув ПКМ по оному. Далее предстоит щелкнуть по надписи «Запуск от имени».
  • Выбрать «Запустить на сервере». После этого необходимо собственноручно определить новый сервер Tomcat. Это необходимо для первого проекта в Эклипсе. Требуется поставить отметку около «Всегда использовать данный server для этого проекта». При подобных обстоятельствах не придется осуществлять повторный выбор.
  • На экране появится рейтинги UCC и время обновления HTML. Оно будет сгенерировано через JSP выражение. Выходной ссылкой выступает http://localhost:8080/RankWebApplication/NewRankFile.jsp.

По итогу на экране появится картинка, представленная выше. Это – первый ознакомительный проект, наглядно показывающий принцип работы JSP.

Директивы

Теги директивного типа – средства создания указаний направления и инструкций. Оные должны использоваться тогда, когда происходит перевод жизненного цикла JSP. Они оказывают воздействие полностью на структуру класса сервлета.

Обычно обладают весьма простым синтаксисом:

При желании можно объединить установку нескольких имеющихся атрибутов для одной директивы:

Директивы бывают нескольких типов:

Каждый вариант предусматривает собственную область применения и особенности. Далее они будут рассмотрены в полной мере.

Директивы страницы

Тег, который предусматривает инструкции и указания для переводчика в момент перевода жизненного цикла JSP для HTML. Включается в любом место. Разработчики имеют негласное правило – тег директивы страницы устанавливается в самом верху кодификации.

Синтаксис представлен на элементе кода выше. А ниже – аналог в XML.

В качестве примера можно описать атрибут в виде импорта. Он включается в самом верху странички. Запись имеет следующую форму:

Атрибуты

Перед тем, как работать с директивами странички JSP, необходимо выучить возможные атрибуты. Они представлены в таблице ниже.

Имя Характеристика
Language Отвечает за определение языка, который применяется в криптлетах JSP файлов, выражениях или иных документах, включаемых к коду оттранслированного типа.
Page Import Определение пакетов, которые были импортированы.
Extends Установка суперкласса для сервлета, который будет сгенерирован. Использовать крайне осторожно.
Session Если значение true – переменная session, которая была заранее определена, привязана к сессии при наличии таковой. В противном случае будет создаваться новая сессия. К ней осуществится непосредственная привязка. Если же значение false – сессии не используются. При обращении к переменной session возникает ошибка трансляции JSP страничек в сервлеты.
Buffer Установка размера буфера для JSPWriterOut.
autoFlush Отвечает за определение того, нужно ли будет проводить автоматическую очистку буфера при ошибках или переполненности.
isThreadSafe При параметре true устанавливается нормальная работа сервлета. Множественные запросы будут обрабатываться одновременно через один экземпляр. False показывает, что сервлет должен наследовать однопоточную модель. Здесь все запросы будут обрабатываться отдельными экземплярами класса.
errorPage Страница, которая будет выводиться при ошибках, приводящих к исключениям.
Info Отвечает за определение строки информации о странице. Она доступа посредством метода getServletInfo().
isErrorPage Может ли HTML применяется для обработки ошибок иных JSP страничек. Изначально – нет.
pageEncording Определение кодировки символов JSP. Изначально установлен charset из contentType.
contentType Определение кодировки для страницы JSP и ответа, а также MIME-тип ответа JSP.

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

Включение директивы

Тег include тоже применяется во время перевода жизненного цикла JSP. Необходим для включения файла. Отвечает за объединение содержимого еще нескольких файлов. Директива включения входит в любое место на HTML (странице).

Выше приведен пример синтаксиса. Обладает всего одним атрибутом – file.

Тег Taglib

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

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

Скриптовые теги

Изучая tutorials по HTML и JSP, стоит обратить внимание на скриптовые теги. Они относятся к сценариям. Дают возможность добавления кода сценария в кодификацию Джавы для сгенерированной странички. Она создается переводчиком.

Бывает нескольких типов:

  • Сценария. Отвечает за реализацию функциональности метода _jspService через написание кода Джавы. Применяется для создания соответствующей кодификации на JSP Page. Имеет вид:

  • Декларативный. Применяется, чтобы объявлять переменные класса и реализацию методов класса jspInt и jspDestroy:

  • Выражение тега. Применяется для того, чтобы создавать Джава-выражения. Его нельзя заканчивать точкой с запятой, поставленные непосредственно в теге:

Эти основы помогут на первых порах разобраться с директивами JSP.

Языки выражения

Для того, чтобы получать доступ к информации приложения, которая хранится в JavaBeans, нужно использовать специальный язык. Он предусматривает разнообразные компоненты, которые даже у начинающего программера не вызовут никаких затруднений.

Операторы

Операторы могут быть:

  • арифметическими;
  • отношений;
  • логическими.

Тут ситуация точно такая же, как и в случае с обычной математикой. Чтобы разобраться в оных, достаточно взять учебник по информатике.

Неявные объекты

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

Выше представлены некоторые типы неявных объектов.

Методы

Не стоит забывать о методах. Огромную роль играют методы, которые доступны в классе Throwable.

Вот некоторые из них. Оные считаются самыми важными и используемыми на практике.

О получении полного спектра знаний – что лучше выбрать

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

  1. Обучение в ВУЗе. Ученик узнает, что такое input type и изучит основы программирования на Джаве. Долгий подход, зато по выпуску человеку будет выдан диплом.
  2. Самообразование. Никаких подтверждений наличия знаний не будет. Вариант хорош для тех, кто хочет быть самоучкой и не претендует на звание опытного разработчика в крупной компании.
  3. Обучение в техникуме. В России найти среднее профессиональное образование по направлению Java проблематично. Но такой вариант сгодится, если хочется продолжить после обучение в ВУЗе.

Лучший выход out of situation – это прохождение узкоспециализированных курсов с выдачей сертификатов. Можно учиться в любом месте и в любое время. Срок обучения – до года. Есть предложения и для новичков, и для опытных разработчиков.

JavaServer Pages

JavaServer Pages (JSP) — это стандартное расширение Java, которое определено поверх сервлетных расширений. Цель JSP состоит в упрощении создания и управления динамическими Web страницами.

Как упоминалось ранее, свободно распространяемый Tomcat, реализация от jakarta.apache.org, автоматически поддерживает JSP.

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

При первой загрузке JSP загружается JSP контейнером (который обычно ассоциирован, или является частью Web сервера), далее сервлетный код, который обязательно выделяется JSP тегами, автоматически генерируется, компилируется и загружается в контейнер сервлетов. Статическая часть HTML страницы производится посредством посылки статического объекта типа String в метод write( ). Динамическая часть включается прямо в сервлет.

С этого момента, пока исходная JSP страница не будет изменена, она будет вести себа так, как будто бы это была статическая HTML страница, ассоциированная с сервлетом (однако весь HTML код на самом деле генерируется сервлетом). Если вы измените исходный код для JSP, он автоматически перекомпилируется и перезагрузится при следующем запросе этой страницы. Конечно, по причине такого динамизма, вы увидите замедленный ответ для первого доступа к JSP. Однако, так как JSP обычно используется гораздо чаще, чем меняется, вы обычно не будете чувствовать влияние этой задержки.

Структура JSP страницы — это что-то среднее между сервлетом и HTML страницей. JSP тэги начинаются и заканчиваются угловой скобкой, также как и HTML коды, но теги также включают знаки процента, так что все JSP теги обозначаются так:

За лидирующим знаком процента могут следовать другие символы, которые определяют точный тип JSP кода в тэге.

Вот чрезвычайно простой JSP пример, который использует стандартный библиотечный Java вызов для получения текущего времени в миллисекундах, которое затем делится на 1000, чтобы получить время в секундах. Так как используется JSP выражение (<%=), результат вычислений преобразуется в строку, а затем поместится в сгенерированную Web страницу:

//:! c15:jsp:ShowSeconds.jsp html>body> H1>The time in seconds is:  System.currentTimeMillis()/1000 %>H1> body>html> ///:~

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

Когда клиент создает запрос к JSP странице, Web сервер должен быть сконфигурирован, чтобы переправить запрос к JSP контейнеру, который затем вовлекает страницу. Как упомянуто ранее, при первом обращении запрашивается страница, генерируются компоненты, указанные на странице, и JSP контейнером компилируется один или несколько сервлетов. В приведенном выше примере сервлет будет содержать код конфигурации объекта HTTPServletResponse, производя объект PrintWriter’а (который всегда называется out), а затем включится расчет времени с помощью очень краткой инструкции, но среднестатистический HTML программист/Web дизайнер не имеет опыта в написании такого кода.

Неявные объекты

Сервлеты включают классы, которые предоставляют удобные утилиты, такие как HttpServletRequest, HttpServletResponse, Session и т. п. Объекты этих классов встроены в JSP спецификацию и автоматически доступны для использования в вашем JSP без написания дополнительных строк кода. Неявные объекты JSP детально перечислены в приведенной ниже таблице.

Неявные переменные Тип (javax.servlet) Описание Область видимости
request Зависимый от протокола подтип HttpServletRequest Запрос, который совершил вызов службы. request
response Зависимый от протокола подтип HttpServletResponse Ответ на запрос. page
pageContext jsp.PageContext Контекст страницы, инкапсулирующий зависящие от реализации возможности и предоставляющий удобные методы и доступ к пространству имен этого JSP. page
session Зависящий от протокола подтип http.HttpSession Объект сессии, создаваемый для запроса клиента. Смотрите объект Session для сервлета. session
application ServletContext Контекст сервлета, получаемый из объекта конфигурации сервлета (например, getServletConfig(), getContext( ). app
out jsp.JspWriter Объект, который пишет в выходной поток. page
config ServletConfig ServletConfig для этого JSP. page
page java.lang.Object Экземпляр класса реализации этой страницы, обрабатывающий текущий запрос. page

Область видимости каждого объекта может значительно варьироваться. Например, объект сессии имеет область видимости, которая превышает страницу, так как она может распространяться на несколько клиентских запросов и страниц. Объект приложения может предоставить обслуживание группе JSP страниц, которые вместе представляют Web приложение.

JSP директивы

Директивы являются сообщениями JSP контейнеру и обозначаются символом «@»:

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

сообщает, что скриптовой язык, используемый внутри JSP страницы, это Java. Фактически, JSP спецификация только описывает семантику скриптов для языковых атрибутов, эквивалентных «Java». Смысл этой директивы состоит во встраивании гибкости в JSP технологию. В будущем, если вы выберите другой язык, скажем Python (хороший выбор для скриптов), то такой язык должен иметь поддержку Java Run-time Environment, выставляя наружу объектную модель Java технологии для скриптового окружения, особенно для неявных переменных, определенных выше, свойств JavaBeans и публичных методов.

Наиболее важными директивами являются директивы страницы. Они определяют несколько атрибутов страницы и взаимодействие этих атрибутов с JSP контейнером. Эти атрибуты включают: language, extends, import, session, buffer, autoFlush, isThreadSafe, info и errorPage. Например:

Эта строка, прежде всего, указывает, что эта страница требует участие в HTTP сессии. Так как мы не установили директиву языка, JSP контейнер по умолчанию использует Java и неявную переменную скриптового языка с названием session типа javax.servlet.http.HttpSession. Если бы директива использовала false, то неявная переменная session будет недоступна. Если переменная session не определена, то по умолчанию считается «true».

Атрибут import описывает типы, которые доступны для скриптовой среды. Этот атрибут используется так же, как и в языке программирования Java, т. е., разделенный запятыми обычный список выражений import. Этот список импортируется транслируемой реализацией JSP страницы и доступен для скриптового окружения. Скажем еще раз, что в настоящее время это определено, только если значением директивы языка является «java».

Скриптовые элементы JSP

Как только вы использовали директивы для установки скриптового окружения, вы можете использовать скриптовые элементы. JSP 1.1 имеет три скриптовых языковых элемента — декларацию, скриплет и выражение. Декларация декларирует элементы, скриплеты являются фрагментами инструкций, а выражения являются полным языковым выражением. В JSP каждый скриптовый элемент начинается с »

 declaration %>  scriptlet %>  expression %>

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

jsp:declaration> declaration jsp:declaration> jsp:scriptlet> scriptlet jsp:scriptlet> jsp:expression> expression jsp:expression

Кроме тоге, есть два типа комментариев:

 jsp comment --%>  html comment --> 

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

Декларации используются для объявления переменных и методов в скриптовом языке (в настоящее время только в Java), используемых на JSP странице. Декларация должна быть законченным Java выражением и не может производить никакого вывода в выходной поток. В приведенном ниже примере Hello.jsp декларации для переменных loadTime, loadDate и hitCount являются законченными Java выражениями, которые объявляют и инициализируют новые переменные.

//:! c15:jsp:Hello.jsp  Этот JSP комментарий не появится в сгенерированном html --%>  Это JSP директива: --%>  page import="java.util.*" %>  Эта декларации: --%> ! long loadTime= System.currentTimeMillis(); Date loadDate = new Date(); int hitCount = 0; %>   Следующие несколько строк являются результатом JSP выражений, вставленных в сгенерированный html; знак '=' указывает на JSP выражение --%> Эта страница была загружена  loadDate %>  Hello, world! It's  new Date() %>  Here's an object:  new Object() %>  This page has been up  (System.currentTimeMillis()-loadTime)/1000 %> seconds  Page has been accessed  ++hitCount %> times since  loadDate %>   "Скриплет", которые пишет на консоли сервера и на странице клиента. Обратите, что необходимо ставить ';': --%>  System.out.println("Goodbye"); out.println("Cheerio"); %>  ///:~

Когда вы запустите эту программу, вы увидите, что переменные loadTime, loadDate и hitCount содержат свои значения между обращениями к странице, так что они явно являются полями, а не локальными переменными.

В конце примера помещен скриплет, который пишет «Goodbye» на консоль Web сервера и «Cheerio» в неявный объект вывода JspWriter. Скриплет может содержать любые фрагменты кода, которые являются имеющими силу инструкциями Java. Скриплеты выполняются во время обработки запроса. Когда все фрагменты скриплета в данном JSP будут скомбинированы по порядку своего появления в JSP странице, они должны дать имеющую силу инструкцию, определенную для языка программирования Java. Будет ли скриплет производить вывод в выходной поток или нет, зависит только от кода скриплета. Вы должны знать, что скриплет может воздействовать на объекты, которые видимы для него.

JSP выражения можно найти вперемешку с HTML в среднем разделе Hello.jsp. Выражения должны быть законченными Java инструкциями, которые вычисляются, переводятся в строку и посылаются в вывод. Если результат инструкции не может быть переведен в строку (String), будет выброшено исключение ClassCastException.

Извлечение полей и значений

Следующий пример похож на приведенный ранее в разделе о сервлетах. При первом показе страницы она определяет, что у вас нет полей и возвращает страницу, содержащую форму с помощью того же самого кода, что и в примере с сервлетом, но в формате JSP. Когда вы отправляете форму с заполненными полями по тому же самому JSP URL’у, страница обнаруживает поля и отображает их. Это прелестная техника, поскольку она позволяет вам получить две страницы, одна из которых содержит форму для заполнения пользователем, а вторая содержит код ответа на эту страницу, в едином файле, таким образом, облегчается создание и поддержка.

//:! c15:jsp:DisplayFormData.jsp  Извлечение данных из HTML формы. --%>  Эта JSP также генерирует форму. --%>  page import="java.util.*"%>   DisplayFormData   Enumeration flds = request.getParameterNames(); if (!flds.hasMoreElements()) < // Нет полей %>  method="POST" action="DisplayFormData.jsp">  for (int i = 0; i  10; i++)  %> Fieldi%>:  type="text" size="20" name="Fieldi%>" value="Valuei%>">   > %>  TYPE=submit name=submit value="Submit">   > else  while (flds.hasMoreElements())  String field = (String) flds.nextElement(); String value = request.getParameter(field); %> field%> = value%>    > > %>    ///:~ 

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

Атрибуты JSP страницы и область видимости

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

Этот пример также показывает использование встроенного HTML и записи в out, чтобы в результате получить HTML страницу.

Первая часть информации производит имя сервлета, которое, вероятнее всего, будет просто «JSP», но это зависит от вашей реализации. Вы можете также определить текущую версию контейнера сервлетов, используя объект application. И, наконец, после установки атрибута сессии в обычной области видимости отображаются «имена атрибутов». Обычно вы не используете область видимости в большинстве JSP; они показаны здесь просто, чтобы добавить интереса в этот пример. Есть три следующие атрибута области видимости: область видимости страницы (scope 1), область видимости запроса (scope 2), область видимости сессии (scope 3 — здесь доступен только один элемент — это «My dog», добавленный прямо перед циклом) и область видимости приложения (scope 4), основанная на объекте ServletContext. Есть один ServletContext на каждое «Web приложение» в каждой Java Машине. («Web приложение» — это набор сервлетов и содержимого, установленного под определенным подмножеством URL’ов Сервера, таких как /catalog. Они устанавливаются с помощью конфигурационного файла.) В области видимости приложения вы увидите объекты, которые представляют пути для рабочего каталога и временного каталога.

Манипуляция сессиями в JSP

Сессии были введены в предыдущем разделе, посвященном сервлетам и также доступны в JSP. Следующие примеры исследуют сессионные объекты и позволяют вам манипулировать промежутком времени, прежде, чем сессия станет недействительной.

//:! c15:jsp:SessionObject.jsp  Получение и установка значений объекта сессии --%>   Session id:  session.getId() %>   This session was created at  session.getCreationTime() %>     Old MaxInactiveInterval =  session.getMaxInactiveInterval() %>   session.setMaxInactiveInterval(5); %>  New MaxInactiveInterval=  session.getMaxInactiveInterval() %>   If the session object "My dog" is still around, this value will be non-null:    Session value for "My dog" =  session.getAttribute("My dog") %>    Теперь добавим объект сессии "My dog" --%>  session.setAttribute("My dog", new String("Ralph")); %> My dog's name is  session.getAttribute("My dog") %>   See if "My dog" wanders to another form --%>  TYPE=POST ACTION=SessionObject2.jsp>  TYPE=submit name=submit Value="Invalidate"> /FORM>  TYPE=POST ACTION=SessionObject3.jsp>  TYPE=submit name=submit Value="Keep Around">   ///:~

Объект сессии предоставляется по умолчанию, так что он доступен без дополнительного кода. Вызов getID( ), getCreationTime( ) и getMaxInactiveInterval( ) используются для отображения информации об этом сессионном объекте.

Когда вы в первый раз получите эту сессию, вы увидите, что MaxInactiveInterval составляет, например, 1800 секунд (30 минут). Это зависит от конфигурации вашего контейнера JSP/сервлетов. MaxInactiveInterval сокращается до 5 секунд, чтобы сделать вещи интереснее. Если вы перегрузите страницу до того, как истекут 5 секунд, то вы увидите:

Session value for «My dog» = Ralph

Но если вы подождете больший интервал, то «Ralph» станет null.

Чтобы посмотреть, как сессионная информация переносится на другие страницы, а также, чтобы посмотреть эффект становления объекта сессии недействительным по сравнению с простым вариантом, когда вы дали ему устареть, созданы две новые страницы. Первая (доступна при нажатии кнопки «invalidate» в SessionObject.jsp) читает сессионную информацию, а затем явно делает сессию недействительной:

//:! c15:jsp:SessionObject2.jsp  Объект сессии переноситься --%>   Session id: session.getId()%>  Session value for "My dog" session.getValue("My dog")%>   session.invalidate(); %>   ///:~

Чтобы экспериментировать с этим, обновите SessionObject.jsp, затем сразу же кликните на кнопку «invalidate», чтобы перейти к странице SessionObject2.jsp. В этом месте вы все еще будете видеть «Ralph» и сразу после этого (прежде, чем пойдет интервал в 5 секунд), обновите SessionObject2.jsp, чтобы увидеть, что сессия была успешно сделана недействительной и «Ralph» исчез.

Если вы вернетесь на SessionObject.jsp, обновите страницу так, чтобы вы снова имели 5-ти секундный интервал, затем нажмете кнопку «Keep Around», то вы попадете на следующую страницу SessionObject3.jsp, которая не делает сессию недействительной:

//:! c15:jsp:SessionObject3.jsp  Переход объекта сессии по страницам --%>   Session id: session.getId()%>  Session value for "My dog" session.getValue("My dog")%>   TYPE=POST ACTION=SessionObject.jsp> TYPE=submit name=submit Value="Return">   ///:~ 

Поскольку эта страница не делает сессию недействительной, «Ralph» будет оставаться во время каждого обновления страницы до тех пор, пока не пройдет 5-ти секундный интервал между обновлениями. Это мало чем отличается от игрушки «Tomagotchi» — до тех пор, пока вы играете с «Ralph», он будет здесь, в противном случае он исчезнет.

Создание и изменение cookies

Cookie были введены в предыдущем разделе о сервлетах. Опять таки, краткость JSP делает обращение с cookies более простым, чем при использовании сервлетов. Следующий пример показывает это с помощью получения cookie, которые пришли в запросе, чтения и изменения максимального возраста (дата устаревания) и присоединения нового cookie в ответный запрос:

//:! c15:jsp:Cookies.jsp  Эта программа ведет себя по разному в разных броузерах! --%>   Session id:  session.getId() %>   Cookie[] cookies = request.getCookies(); for(int i = 0; i  cookies.length; i++)  %> Cookie name:  cookies[i].getName() %>  value:  cookies[i].getValue() %>  Old max age in seconds:  cookies[i].getMaxAge() %>  cookies[i].setMaxAge(5); %> New max age in seconds:  cookies[i].getMaxAge() %>  > %> ! int count = 0; int dcount = 0; %>  response.addCookie(new Cookie( "Bob" + count++, "Dog" + dcount++)); %>  ///:~ 

Так как каждый браузер хранит cookie по-своему, вы можете видеть разное поведение в разных браузерах (не убежден, но это может быть некоторой ошибкой, которая может быть исправлена в то время, когда вы читаете это). Также вы можете получить разные результаты, если вы выгрузите браузер и запустите его, по сравнению с тем, если вы посетите другую страницу, а затем вернетесь на Cookies.jsp. Обратите внимание, что использование объекта сессии выглядит более уместным, чем прямое использование cookies.

После отображения идентификатора сессии каждый cookie в массиве cookies, пришедший с объектом запроса, отображается на странице наряду с его максимальным возрастом. Максимальный возраст изменяется и отображается снова, чтобы проверить новое значение, затем новый cookie добавляется в ответ. Однако ваш браузер может проигнорировать этот максимальный возраст; стоит поиграть с этой программой и поизменять значение максимального возраста, чтобы посмотреть поведение под различными браузерами.

Заключение о JSP

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

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

Однако весь ужас JSP состоит в том, что необходимо учитывать, что создание JSP требует большего уровня умения, чем простое программирования на Java или просто создание Web страниц. Кроме того, отладка неработающего JSP не такое простое дело, как в случае Java программы, так как (в настоящее время) сообщения об ошибках более непонятны. Это должно измениться с улучшением систем разработки, но мы можем также видеть другие технологии, основанные на Java и Web, которые лучше адаптированы к умениям дизайнеров Web сайтов.

Упражнения

  1. Создайте JSP страницу, которая печатает строку текста, использующую тэг . Установите цвет этого текста случайным образом, используя код, встроенный в JSP страницу. Если у вас нет существующего JSP контейнера, вам необходимо загрузить, установить и запустить Tomcat с сайта jakarta.apache.org, чтобы иметь возможность запускать JSP.
  2. Измените значение максимального возраста в Cookies.jsp и пронаблюдайте поведение в различных браузерах. Также обратите внимание на различие между повторным посещением страницы и выгрузкой/загрузкой браузера. Если у вас нет существующего JSP контейнера, вам необходимо загрузить, установить и запустить Tomcat с сайта jakarta.apache.org, чтобы иметь возможность запускать JSP.
  3. Создайте JSP с одним полем, которое позволяет пользователю вводить время действия сессии, и со вторым полем, которое содержит данные, хранящиеся в сессии. Кнопка отсылки обновляет страницу и получает текущее время действия сессии и данные сессии, а потом помещает их в качестве значения по умолчанию в вышеупомянутые поля. Если у вас нет существующего JSP контейнера, вам необходимо загрузить, установить и запустить Tomcat с сайта jakarta.apache.org, чтобы иметь возможность запускать JSP.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *