Технология 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) { %>
Динамическая составляющая 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 Good afternoon
Чтобы оценить наглядность и простоту этой конструкции, сравните ее с эквивалентным фрагментом программного кода в сервлете:
if (i == 0) { out.println("Good morning"); } else { out.println("Good afternoon"); }
ВыраженияЧасто страница, передаваемая клиенту, содержит результаты вычислений или обращений к тем или иным методам и атрибутам определенных классов. Любой из таких динамических элементов можно преобразовать в строку и представить на 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
Независимо от того, какой тип будет иметь документ, генерируемый в ответ на запрос пользователя, в общем случае, 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 тэг класс должен содержать следующий код:
изХорошо Плохо
JSP (JavaServer Pages ) - технология, позволяющая веб-разработчикам легко создавать содержимое, которое имеет как статические, так и динамические компоненты. По сути, страница JSP является текстовым документом, который содержит текст двух типов: статические исходные данные, которые могут быть оформлены в одном из текстовых форматов HTML , SVG , WML , или XML , и JSP элементы, которые конструируют динамическое содержимое. Кроме этого могут использоваться библиотеки JSP тегов, а также (Expression Language), для внедрения Java-кода в статичное содержимое JSP-страниц.
JSP - одна из высокопроизводительных технологий, так как весь код страницы транслируется в java-код сервлета с помощью компилятора JSP страниц Jasper , и затем компилируется в байт-код виртуальной машины java (JVM). Контейнеры сервлетов , способные исполнять JSP страницы, написаны на языке Java, который может работать на различных платформах. JSP страницы загружаются на сервере и управляются из структуры специального Java server packet, который называется Java EE Web Application, в большинстве своём упакованные в файловые архивы .war и .ear .
Выгода, которую дает технология JSP в сравнении с другими веб-технологиями заключается в том, что JSP является платформонезависимой, переносимой и легко расширяемой технологией для разработки веб-приложений.
Начиная с версии 1.2, JavaServer Pages были разработаны в рамках Java Community Process . JSR 53 определяет оба стандарта JSP 1.2 и Servlet 2.3, а JSR 152 определяет спецификацию JSP 2.0. В мае 2006 года JSP спецификация 2.1 была выпущена под JSR 245 в рамках Java EE 5 . 10 декабря 2009 года была выпущена спецификация JSP 2.2 как содержание выпуска JSR 245.
JSP 1.0 и JSP 1.1Необходимо отметить, что эти версии кардинально отличаются от версий предыдущих, которые в свою очередь воспринимались больше, как ответ Java на ASP . Некоторые основные возможности и трюки прошлых версий были убраны или заменены другими. Например, возможность разрабатывать библиотеки тегов. Главной идеей было разделение кода и содержимого. Так как в больших объемах исходного кода трудно сориентироваться и отделить контент от самого кода, то пришла идея их разделить (перенести) с помощью JSP тегов таких как например . Для реализации этой задумки JSP теги разделили на три логические группы: директивы, скриптовые элементы и действия.
JSP 1.2JSP 1.2 расширяет спецификацию JavaServer Pages 1.1 (JSP 1.1) следующим образом:
- Требуют платформы Java 2 версии 1.2 или более поздней;
- Использует Servlet 2.3 как основу своей семантики;
- Определяет синтаксис XML для страниц JSP;
- Предоставляет проверку страниц JSP на этапе трансляции;
- Специфицирует очистку библиотеки тегов на этапе прогона;
- Улучшает контракт обработчика тегов;
- Предоставляет улучшенную поддержку авторизации страниц;
- Улучшает поддержку кодировки символов и локализации;
- Устраняет печально известное ограничение «flush before you include» из JSP 1.1.
Новая версия спецификации JSP дополнена функциональностью увеличивающей скорость работы программиста. А именно:
- Expression Language (EL) - язык выражений, позволяет среди прочего создавать разработчикам шаблоны в стиле Velocity ;
- Более простой и быстрый способ создавать новые теги с помощью файлов.tag , теперь для создания новых тегов не обязательно знать Java;
- Удобный способ управления вложеными бинами (JavaBeans);
- Более быстрый и лёгкий способ отображения параметров переменных:
Hello, ${ param.visitor }
JSP 2.1- Включает в себя JSTL и JavaServer Faces ;
- Новая версия поддерживает отложенное исполнение выражений и литеральные выражения, а также J5EE enumeration.
Платформа Java EE 5 главным образом фокусируется на простую разработку используя языковые аннотации Java, которые были введены J2SE 5.0 . JSP 2.1 поддерживает эту цель определением аннотаций для зависимых инъекций в JSP операторах и в контекстных слушателях (Listeners).
ОбзорJavaServer Pages (JSP) позволяют отделить динамическую часть страниц от статического HTML . Процедура довольно проста, создаёте обычный код HTML (статический), а динамическую часть заключаете в специальные теги "" .
Имя вашего хоста:
JSP страницы имеют расширение.jsp и размещаются там же, где и обычные Web страницы. Структура таких страниц может состоять из пяти конструкций: HTML , комментарии, скриптовые элементы, директивы и действия. JSP страница при компиляции преобразуется в обычный сервлет со статическим содержимым, которое направляется в поток вывода, связанный с методом service. Поэтому при первом запросе этот процесс может вызвать некую задержку, но в большинстве своём незаметную первому пользователю. Комментарии в документе или программе служат к объяснению содержимого. Они не являются причиной замедления программы, так как транслятор и исполнитель их игнорируют. Скриптовые элементы позволяют вам указать код на языке Java , который впоследствии станет частью конечного сервлета, директивы дадут вам возможность управлять всей структурой сервлета, а действия служат для задания существующих используемых компонентов, а также для контроля над поведением движка JSP. Для упрощения работы со скриптами имеются заранее определённые переменные, такие как request, response, pageContext, session, out, application, config, page, exception . Пример JSP страницы с использованием всех составляющих JSP конструкции:
КомментарииКомментарии используются для пояснения исходного текста программы. В JSP-страницах комментарии можно разделить на две группы:
- комментарии исходного кода JSP
- комментарии HTML -разметки.
Комментарии исходного кода JSP отмечаются специальной последовательностью символов: в конце комментария. Данный вид комментариев удаляется на этапе компиляции JSP-страницы и потому не доступны пользователям. Пример JSP-комментария:
Комментарии HTML -разметки оформляются в соответствии с правилами языка HTML. Данный вид комментариев рассматривается JSP-компилятором как статический текст и помещается в выходной HTML-документ. JSP-выражения внутри HTML-комментариев исполняются. Пример HTML-комментария:
-->
Скриптовые элементыСпецификация JSP различает три типа скриптовых элементов:
- Объявления
- Выражения
- Скриплеты
Объявления обычно используются для определения переменных, методов, внутренних классов и остальных действующих Java конструкций на уровне класса. В выражения вкладываются любые действующие выражения Java. С помощью скриплетов в JSP страницы вкладываются работающие части кода Java. Все эти элементы начинаются знаками . Обратите внимание и на то, что все скриптовые элементы отличаются немного записью конструкции. Объявления используют восклицательный знак (! ) в конструкции (), а выражения знак равенства (=) (), в то время как скриплеты используют стандартный формат записи ().
Объявления JSPОбъявления JSP позволят вам задавать переменные, методы, внутренние классы и так далее. Другими словами объявления Вы используете для определения конструкций Java, которые Вы в программе используете. Так как объявления не осуществляют вывода, то обычно они используются совместно с JSP выражениями или скриплетами. В приведённом в качестве примера фрагменте JSP отображается количество запросов к данной странице с момента загрузки сервера (или с момента последнего изменения и перезагрузки сервлета). Обратите внимание, что в примере мы используем как объявление, так и выражение и что внутри конструкции после объявления стоит точка с запятой (; ):
Количество обращений к странице с момента загрузки сервера:
Выражения JSPВыражения JSP применяются для того, чтобы вставить значения Java непосредственно в вывод. Выражения Java вычисляются, конвертируются в строку и вставляются в страницу. Эти вычисления проходят во время выполнения (то есть при запросе страницы), а потому существует полный доступ к информации о самом запросе. В выражениях можно использовать постоянные, переменные, вызовы различных методов. Все выражения, вне зависимости от сложности их содержимого, вычисляются в один результат или число. JSP страницы полагаются на JSP Writer, который берёт любой результат выражения, переводит его в тип String (текстовый) и заносит в буферную память. Например, следующий код служит для отображения даты и времени запроса данной страницы:
Текущее время: Имя вашего хоста:
Необходимо обратить внимание на три правила:
- JSP выражения должны в себе содержать выражения Java;
- каждое JSP выражение должно содержать только одно выражение Java;
- выражения JSP не должны заканчиваться точкой с запятой (;), в отличие от Jаva объявлений.
Если вы хотите сделать что-то большее чем просто вставку выражений, то скриплеты JSP дадут вам возможность вставить любой код в метод сервлета, который будет создан при обработке данной страницы. В данном случае Вы можете использовать большинство конструкций Java. Скриплеты также имеют доступ к тем же заранее определённым переменным, что и выражения. Поэтому, например, если вы хотите вывести что-нибудь на страницу, вы должны использовать заранее определённую переменную out .
Обратите внимание на то, что код внутри скриплета вставляется в том виде, как он был записан, и весь статический HTML (текст шаблона) до или после скриплета конвертируется при помощи оператора print . Например, следующий фрагмент JSP содержит смешанный текст шаблона и скриплета:
< B> Удачного< /B> вам дня! < B> Неудачного< /B> вам дня!
После преобразования скриплета код будет выглядеть следующим образом:
If (Math .random () < 0.5 ) { out.println ("Удачного вам дня!" ) ; } else { out.println ("Неудачного вам дня!" ) ; }
Это означает, что скриплеты не обязательно должны содержать завершённые фрагменты Java, и что оставленные открытыми блоки могут оказать влияние на статический HTML вне скриплета.
Директивы JSPJSP страница может послать сообщение соответствующему контейнеру с указаниями какие действия необходимо провести. Эти сообщения называются директивами. Все директивы начинаются с . Директивы в JSP странице приводят к тому, что контейнер пошлёт заявку на исполнение определённой службы, которая в генерированном документе не объявляется. Форму записи директив можно изобразить следующим образом:
Вы также можете объединить установку нескольких атрибутов для одной директивы:
Существует три основных типа директив: page , которая позволяет вам совершать такие операции, как импорт классов, изменение суперкласса сервлета, и т. п.; include , которая даёт вам возможность вставить файл в класс сервлета при трансляции JSP файла в сервлет; и taglib , позволяющий расширить множество тегов своими собственными, которые JSP контейнер способен истолковать.
Директива JSP pageКак можно догадаться из названия, данная директива предоставляет атрибуты для JSP страницы. Атрибуты, определённые в этой директиве, внедряются в данную JSP страницу и на все её вложенные статические элементы, независимо от того были ли они вставлены с помощью директивы include или с помощью действия jsp:include . Форма записи директивы page следующая:
В качестве примера приведём следующую запись:
Эта директива заявляет, что JSP страница импортирует классы из двух пакетов Java, java.util и com.myclasses , а потом уточняет размер буферной памяти, которая должна быть использована для обработки данной JSP страницы.
- import="пакет.class1, пакет.class2, ..., пакет.classN". Позволяет вам задать пакеты, которые должны быть импортированы. Это единственный атрибут, который может использоваться несколько раз в одной директиве. В список необходимо включить все классы Java, которые Вы хотите использовать и которые не являются частью исходного набора импортируемых классов. Исходный набор содержит: java.lang.*, javax.servlet.*, javax.servlet.jsp.* и javax.servlet.http.*. Пример использования атрибута import:
- language="java". Данный атрибут предназначен для задания используемого языка программирования. По умолчанию принимается значение "java" . Этот атрибут необязательно использовать, но тем не менее проблема потом может наступить в случае, если поставщик JSP контейнера будет использовать другие языки (например, JavaScript). Пример записи данного атрибута следующий:
- extends="пакет.class". Задаёт суперкласс (родительский класс) для генерируемого сервлета. Обычно сервлет возникает расширением исходного класса. Опытные программисты могут с помощью этого атрибута создавать собственные суперклассы. Пример использования этого атрибута может выглядеть следующим образом:
- session="true|false". Данный атрибут может принимать значение true или false , которые определяют принимает ли участие JSP страница в трансляции HTTP . Значение true («истина», принимается по умолчанию) сигнализирует о том, что заранее определённая переменная session (тип HttpSession) должна быть привязана к существующей сессии, если таковая имеется, в противном случае создаётся новая сессия, к которой и осуществляется привязка. Значение false («ложь») определяет, что сессии не будут использоваться, и попытки обращения к переменной session приведут к возникновению ошибки при трансляции JSP страницы в сервлет. Пример использования данного атрибута может выглядеть следующим образом:
- buffer="размерkb|none". Данный атрибут задаёт объём буферной памяти, необходимой для объекта JspWriter, на который ссылается заранее определённая переменная out . Значение принимаемое по умолчанию зависит от настроек сервера, но должно превышать 8kb . Значение задаётся либо в форме «размерkb» либо «none». Если Вы укажете значение буферной памяти как none , то сервлет не будет ничего сохранять в буферную память и передаст результат, записанный до переменной out , прямо объекту PrintWriter , который предоставляется вместе с объектом ServletResponse. Если Вы зададите значение буферной памяти на конкретную величину, то JspWriter будет в эту память сохранять данные, в результате чего увеличится производительность. В отличие от объекта PrintWriter объект JspWriter может вызывать исключительные ситуации IOExceptions . Исходная величина буферной памяти равна 8kB . Пример записи данного атрибута может выглядеть следующим образом:
- autoflush="true|false". true или false . Значение true («истина», принимаемое по умолчанию) устанавливает, что при переполнении буферной памяти он автоматически очистится. Значение false («ложь»), которое крайне редко используется, устанавливает что переполнение буфера должно приводить к возникновению исключительной ситуации (IOExceptions). Обычно атрибуты buffer и autoflush устанавливаются вместе в одной директиве. При установке значение атрибута buffer="none" установка значения false для атрибута autoflush недопустима. Пример может выглядеть следующим образом:
- isThreadSafe="true|false". Данный атрибут может принимать значения true или false . Значение true («истина», принимается по умолчанию) задаёт нормальный режим выполнения сервлета, когда множественные запросы обрабатываются одновременно с использованием одного экземпляра сервлета, исходя из соображения что автор синхронизировал доступ к переменным этого экземпляра. Значение false («ложь») сигнализирует о том, что сервлет должен наследовать SingleThreadModel (однопоточную модель), при которой последовательные или одновременные запросы обрабатываются отдельными экземплярами сервлета. Другими словами значение true приведёт к тому, что контейнер может посылать сервлету сразу несколько запросов, в то время как при значении false контейнер посылает запросы по одному. Пример использования выглядит так:
- info="информация". Задаёт строку, которая может быть получена при использовании метода Servlet.getServletInfo(). Обычно этот метод возвращает информацию о сервлете (например, авторе, версии и авторских правах). Пример записи данного атрибута может выглядеть следующим образом:
- errorPage="url". Задаёт JSP страницу, которая вызывается в случае возникновения каких-либо событий Throwables , которые не обрабатываются на данной странице. Случится ли на JSP странице исключение и JSP страница не имеет собственного кода для решения этого исключения, то контейнер автоматически передаст управление на URL , которую Вы задали в качестве значения атрибута errorPage . Пример записи выглядит так:
- isErrorPage="true|false". Данный атрибут может принимать значения true или false . Сигнализирует о том, может ли эта страница использоваться для обработки ошибок для других JSP страниц или нет. По умолчанию принимается значение false («ложь»). Пример использования данного атрибута может выглядеть следующим образом:
- contentType="MIME-Тип". Данный атрибут задаёт тип MIME для вывода и по желанию можно задать кодировку знаков в ответе (HTML ответе). По умолчанию в качестве значения MIME используется text/html . Для наглядности можем использовать следующий пример:
Того же результата можно добиться и использованием скриплета:
Директива JSP include
Эта директива позволяет Вам включать файлы в сервлет в процессе трансляции JSP страницы. Использование директивы выглядит следующим образом:
Заданный URL обычно интерпретируется относительно JSP страницы, на которой расположена ссылка, но, как и при использовании любых других относительных URL вы можете задать системе положение интересующего вас ресурса относительно домашнего каталога Web сервера, добавив в начало URL символ «/ ». Содержимое подключаемого файла обрабатывается как обычный текст JSP и поэтому может включать такие элементы как статический HTML , элементы скриптов, директивы и действия. Например, многие сайты используют небольшую панель навигации на каждой странице. В связи с проблемами использования фреймов HTML часто эта задача решается размещением небольшой таблицы сверху или в левой половине страницы, HTML код которой многократно повторяется для каждой страницы сайта. Директива include наиболее естественный способ решения этой задачи, избавляющий разработчика от кошмара рутины копирования HTML в каждый отдельный файл. Это происходит следующим образом:
< html> < head> < title> Тестовая страница< /title> < /head> < body> < /body> < /html>
Учтите что поскольку директива include подключает файлы в ходе трансляции страницы, то после внесения изменений в панель навигации вам потребуется повторная трансляция всех использующих её JSP страниц. Что в данном случае является хорошим компромиссом, поскольку как правило панель навигации меняется достаточно редко и процесс подключения не теряет своей эффективности. Если же подключённые файлы меняются довольно часто, вы можете использовать вместо этого действие jsp:include . Это действие подключает файл в процессе обращения к JSP.
Директива JSP taglibКак уже известно, в JSP страницах элементы записываются с помощью знаков (условных знаков, меток, марок). Множество знаков, которые JSP контейнер способен истолковать, можно расширить с помощью так называемых библиотек знаков. Также к расширенному множеству знаков можно присоединять действия, вследствие чего происходит расширение самого языка JSP. Действия можно разделить на стандартные и собственные. Обобщённый способ записи может выглядеть так:
Библиотеку знаков необходимо идентифицировать с помощью URI адреса (уникального идентификатора ресурса). URI может быть как абсолютным так и отностительным. Уникальный идентификатор ресурса определяет расположение библиотеки знаков (TLD), который определяет собственные знаки этой библиотеки. Пример записи директивы:
JSP страница может содержать бесконечное кол-во директив taglib , но для каждой директивы необходимо установить различные префиксы, которые определяют содержимое библиотеки на странице. В качестве префикса можете использовать какой угодно текст, слово. В то время, как директиву taglib можно использовать где угодно на JSP странице, все собственные знаки, которые эти директивы используют, должны использоваться за ними.
ДействияДействия JSP используют конструкции с синтаксисом XML для управления работой движка сервлета. Вы можете динамически подключать файл, многократно использовать компоненты JavaBeans , направить пользователя на другую страницу или сгенерировать HTML для Java plugin. Все эти действия детально рассмотрены далее. Помните что как и во всем XML , имена элементов и атрибутов регистрозависимы. Действия можно разделить на две группы: стандартные и созданные (собственные, что создает сам программист). Допустимо применение следующих стандартных действий:
- jsp:declaration - Объявление, аналогичен тегу ;
- jsp:scriptlet - Скриптлет, аналогичен тегу ;
- jsp:expression - Выражение, аналогичен тегу ;
- jsp:text - Вывод текста;
- jsp:useBean - Поиск или создание нового экземпляра JavaBean;
- jsp:setProperty - Установка свойств JavaBean;
- jsp:getProperty - Вставить свойство JavaBean в поток вывода;
- jsp:include - Подключает файл в момент запроса страницы;
- jsp:forward - Перенаправляет запрос на другую страницу;
- jsp:param - Добавляет параметры в объект запроса, например в элементах forward, include, plugin.;
- jsp:plugin - Генерирует код (в зависимости от типа используемого броузера), который создает тег OBJECT или EMBED для Java plugin;
- jsp:params - Группирует параметры внутри тега jsp:plugin;
- jsp:fallback - Указывает содержимое, которое будет использоваться браузером клиента, если подключаемый модуль не сможет запуститься. Используется внутри элемента plugin.
Это действие позволяет загружать JavaBean для последующего использования на JSP странице. Эта возможность позволяет многократно использовать классы Java, не отказываясь при этом от преимуществ, предоставляемых сервлетами JSP. Помимо этого, это один из способов, как большую часть обработки Java исключить из JSP страницы. Если перенести обработку Java из JSP страницы до JavaBean, то потом эти функции можно использовать и в остальных JSP страницах. Простейший синтаксис для указания используемого bean:
< jsp:useBean id="имя" class ="пакет.class" />
Как правило это означает «создание нового экземпляра объекта класса, заданного через class , и его связь с переменной с именем, заданным при помощи id ». Однако можно задать атрибут scope (принимает значения page|request|session|application , page для страницы, request для запросов, session для сессий или диалогов, application для аппликаций), который ассоциирует bean не только с текущей страницей. В таком случае, полезно получить ссылки на существующие beans , и действие jsp:useBean создает экземпляр нового объекта лишь в том случае если не существует ни одного объекта с теми же значениями id и scope . Теперь, когда у вас есть bean , вы можете изменять его свойства при помощи действия jsp:setProperty , или используя для этого скриплет и явно вызывая метод объекта с именем переменной заданном ранее через атрибут id . Recall that with beans , когда вы говорите «у этого bean есть свойство типа X с названием foo », вы на самом деле имеете ввиду «у этого класса есть метод getFoo , который возвращает данные типа X, и другой метод setFoo , которому в качестве параметра передается X.» Действие jsp:setProperty более подробно рассмотрено в следующем разделе, но сейчас вы должны запомнить что вы можете либо явно задавать value , задавая атрибут param , чтобы получить значение из соответствующего параметра запроса, или просто перечислить свойства, чтобы получить значения из параметров запроса с теми же именами что и свойства. Вы можете получить значения существующих свойств при помощи выражений JSP или скриплетов, вызвав соответствующий метод getXxx , или (чаще всего), воспользовавшись действием jsp:getProperty .
Класс, заданный для bean, должен находиться в обычном каталоге классов сервера, а не в части, зарезервированной для классов, автоматически перезагружаемых после редактирования. Например, для Java Web Server, все используемые классы должны размещаться в каталоге classes или в .jar файле каталога lib , а не в каталоге servlets . Ниже приведен простой пример, загружающий bean и устанавливающий/получающий простой строковый параметр.
BeanTest.jsp
< html> < head> < title>< /title> < /head> < body> < h1> Многократное использование JavaBeans в JSP< /h1> < jsp:useBean id="test" class ="hall.SimpleBean" /> < jsp:setProperty name="test" property="message" value="Привет, WWW" /> < p> Сообщение: < jsp:getProperty name="test" property="message" /> < /p> < /body> < /html>
SimpleBean.java
Package hall ; public class SimpleBean { private String message = "Текст сообщения не задан" ; public String getMessage() { return (message) ; } public void setMessage(String message) { this .message = message; } }
Еще несколько деталей о использовании jsp:useBean . Простейший способ использовать bean - это использование конструкции:
< jsp:useBean id="имя" class ="пакет.class" />
для загрузки bean , а затем использовать jsp:setProperty и jsp:getProperty для модификации и получения его свойств (параметров). Однако существуют еще два других способа. Во-первых, вы можете использовать формат контейнера, а именно:
< jsp:useBean ...> Тело < /jsp:useBean>
для того чтобы обеспечить выполнение Тела только в том случае, если экземпляр bean создается впервые, а не тогда, когда находится и используется уже существующий bean . Как обсуждается далее, beans могут совместно использоваться, поэтому не каждое выражение jsp:useBean приводит к созданию экземпляра нового bean . Во-вторых, кроме id и class , существуют еще три других атрибута, которые вы можете использовать: scope , type , и beanName . Эти атрибуты описаны далее:
- id - дает имя переменной, которая ссылается на bean . Если удается найти bean с теми же самыми значениями id и scope , то вместо создания нового экземпляра используется ранее созданный объект;
- class - задает полное имя пакета bean ;
- scope - задает область, в которой bean должен быть доступен. Может принимать четыре допустимых значения: page , request , session и application . По умолчанию принимает значение page , означающее что bean доступен только на текущей странице (размещается в PageContext текущей страницы). Значение request означает что bean доступен только для текущего запроса клиента (размещается в объекте ServletRequest). Значение session означает что объект доступен всем страницам на протяжении жизни текущей HttpSession . И, наконец, значение application означает что он доступен всем страницам, использующим тот же самый ServletContext . Причина необходимости этого атрибута заключается в том что jsp:useBean приводит к созданию нового экземпляра объекта в том случае, если нет уже существующего объекта с тем же id и scope . Иначе используется уже существующий объект, и все элементы jsp:setParameter или любые другие между тегами jsp:useBean игнорируются.
- type - указывает тип переменной, которая ссылается на объект. Должен совпадать с именем класса, суперкласса или реализуемого интерфейса. Запомните что имя переменной задается через атрибут id .
- beanName - дает имя bean , которое будет использовано методом instantiate . Можно задать type и beanName , и опустить атрибут class .
Вы можете использовать jsp:setProperty для присвоения значений свойствам ранее описанных beans . Вы можете делать это двумя способами. Во-первых, вы можете использовать jsp:setProperty после, но вне элемента jsp:useBean , так как это показано в примере:
< jsp:useBean id="myName" ... /> ... < jsp:setProperty name="myName" property="someProperty" ... />
В этом случае jsp:setProperty выполняется независимо от того, был ли найден существующий bean или был создан новый экземпляр. Другим вариантом заключается в размещении jsp:setProperty в теле элемента jsp:useBean , как это показано в другом примере:
< jsp:useBean id="myName" ... > ... < jsp:setProperty name="myName" property="someProperty" ... /> < /jsp:useBean>
При этом jsp:setProperty выполняется лишь в том случае, если был создан новый экземпляр объекта, а не тогда, когда находится уже существующий. Действие jsp:setProperty допускает применение следующих четырех атрибутов:
- name - этот обязательный атрибут служит для задания bean , свойства которого будут устанавливаться. Элемент jsp:useBean должен предшествовать использованию элемента jsp:setProperty .
- property - этот обязательный атрибут устанавливает свойство, которое вы хотите установить. Однако существует частный случай: значение «* » означает что все параметры запроса, чьи имена совпадают с именами свойств bean будут переданы соответствующему методу установки свойств.
- value - этот необязательный атрибут устанавливает значение свойства. Строковые значения автоматически преобразуются в числовые, boolean , Boolean , byte , Byte , char и Character с использованием стандартного метода valueOf соответствующего класса. Например, значение "true" для свойства boolean или Boolean будет конвертированно при помощи метода Boolean.valueOf , а значение «42» для свойства int или Integer будет конвертированно при помощи метода Integer.valueOf . Вы не можете одновременно использовать атрибуты value и param , но можете вообще их не использовать. Ознакомьтесь с описанием атрибута param , которое представлено ниже.
- param - этот необязательный атрибут устанавливает параметр запроса, используемый для получения свойства. Если в текущем запросе этот параметр отсутствует, никаких действий не происходит: система не передает значение null методу устанавливающему свойства. Таким образом, допустимо использование в bean свойств по умолчанию, переопределяя их лишь в том случае если этого требуют параметры запроса. Например, следующий фрагмент означает следующее: «установить свойство numberOfItems в соответствии со значением параметра запроса numItems , а если такой параметр в запросе отсутствует - никакие действия не выполняются.»
< jsp:setProperty name="orderBean" property="numberOfItems" param="numItems" />
Если вы не используете ни value , ни param , это приравнивается к тому, как если бы вы задали имя param совпадающее с именем property . Вы можете применить этот принцип автоматического использования свойств запроса, чьи имена совпадают с именами свойств и пойти далее, задав в качестве имени свойства «* » и опустив параметры value и param . В этом случае сервер обработает допустимые свойства и параметры запроса, на предмет совпадения их с идентичными именами. Далее приведен пример в котором используется bean для создания таблицы простых чисел. Если существует параметр numDigits в данных запроса, он передается в свойство bean numDigits . Аналогично для numPrimes . JspPrimes.jsp
< html> < head> < title> Многократное использование JavaBeans в JSP< /title> < /head> < body> < h1> Многократное использование JavaBeans в JSP< /h1> < jsp:useBean id="primeTable" class ="hall.NumberedPrimes" /> < jsp:setProperty name="primeTable" property="numDigits" /> < jsp:setProperty name="primeTable" property="numPrimes" /> < p> Несколько < jsp:getProperty name="primeTable" property="numDigits" /> символьных простых чисел: < jsp:getProperty name="primeTable" property="numberedList" /> < /p> < /body> < /html>
Действие jsp:getPropertyЭтот элемент определяет значение свойства bean , конвертирует его в строку и направляет в поток вывода. Для выполнения действия требуется задание двух атрибутов: имени bean , которое предварительно задается в действии jsp:useBean , и имя свойства, значение которого должно быть определено. Далее приведен пример использования этого действия:
< jsp:useBean id="itemBean" ... /> ... < UL> < LI> Количество предметов: < jsp:getProperty name="itemBean" property="numItems" /> < LI> Цена за штуку: < jsp:getProperty name="itemBean" property="unitCost" /> < /UL>
Действие jsp:includeЭто действие позволяет вставлять содержимое файлов в генерируемую страницу. Синтаксис действия:
< jsp:include page="относительный URL" flush="true" />
В отличие от директивы include , которая вставляет файл на этапе трансляции JSP страницы, это действие вставляет файл при запросе страницы. Это приводит к некоторой потере эффективности и исключает возможность наличия во вставляемом файле кода JSP, но зато дает существенное преимущество в гибкости.
Пример вставки содержимого четырех файлов в JSP-страницу:
< html> < head> < title> Новости< /title> < /head> < body> < h1> Новости< /h1> < p> Вот фрагменты наших четырех самых популярных статей:< /p> < ol> < li>< jsp:include page="news/Item1.html" flush="true" />< /li> < li>< jsp:include page="news/Item2.html" flush="true" />< /li> < li>< jsp:include page="news/Item3.html" flush="true" />< /li> < li>< jsp:include page="news/Item4.html" flush="true" />< /li> < /ol> < /body> < /html>
Действие jsp:forwardЭто действие позволяет вам передать запрос другой статической HTML странице, сервлету или JSP странице. В отличие от действия jsp:include обработка актуальной страницы заканчивается. Оно использует один атрибут page , который должен содержать относительный URL и на основании которого упорядочен объект request . К исходным параметрам запроса, которой передается другой странице, можете с помощью действия jsp:param добавить и другие параметры. Значением атрибута page может быть как статическое значение, так и вычисляемое в процессе запроса, что и показано на следующих двух примерах:
< jsp:forward page="/utils/errorReporter.jsp" /> < jsp:forward page="" />
Также с помощью действия jsp:forward можно передать управление на другую страницу, но с условием, что перед вызовом этого действия ничего не было записано в выходящую буферную память (иначе будет вызвано исключение IllegalStateException).
Действие jsp:param и действие jsp:paramsЭто действие предоставляет информацию типа название/значение. Данное действие используется в основном вместе со знакомыми уже действиями jsp:include и jsp:forward . Кроме этого его можно использовать и вместе с действием jsp:plugin . В остальных случаях использование этого действия не имеет значения. Использование jsp:param с действиями jsp:include и jsp:forward передаться новым страницам исходный объект request , который будет расширен на новые параметры. Если Вы зададите новые значения для уже существующих параметров, то именно новые значения будут иметь преимущество. С помощью действия jsp:params можно задать сразу несколько параметров
Действие jsp:pluginЭто действие позволяет вам вставить элемент OBJECT или EMBED (в зависимости от типа используемого браузера), необходимый для запуска аплетов, использующих plugin Java. Другими словами данное действие служит к генерированию HTML для вложения Java API в JSP страницу. Таким же образом можете вставлять URL для скачивания модулей для Java API от JavaSoft, который предоставляет возможность запускать аплеты внутри браузера. Форма записи данного действия выглядит следующим образом.
Вопросы и ответы на собеседование по теме Java Server Pages (JSP).
Вопросы
2. Расскажите об этапах (фазах) жизненного цикла jsp.
3. Расскажите о методах жизненного цикла jsp.
4. Какие методы жизненного цикла JSP могут быть переопределены?
5. Как можно предотвратить прямой доступ к JSP странице из браузера?
6. Как закомментировать код в jsp?
7. Объясните Scriptlet, Expression и Declaration в JSP.
8. Какие неявные, внутренние объекты и методы есть на jsp странице?
9. Почему неявные объекты не доступны в обычной JSP странице?
10. Что вы знаете о PageContext и какие преимущества его использования?
11. Как сконфигурировать init параметры для JSP?
12. Почему не рекомендуется использовать скриптовые элементы в jsp?
13. Можем ли мы определить класс внутри JSP страницы?
14. Какие есть способы вставки java кода в jsp страницу?
15. Как можно запретить использование скриптов и java кода на jsp странице?
16. Что вы знаете о jsp тегах? Объясните как вы понимаете Action tag и JSP Action Elements.
17. Какая разница между директивой include и jsp:include action?
18. Что вы знаете о языке выражений jsp (JSP Expression Language – EL)?
19. Назовите неявные, внутренние объекты JSP EL и их отличия от объектов jsp.
20. Как узнать имя http метода используя JSP EL?
21. Что такое JSTL (Jsp Standard tag library)?
22. На какие категории можно разделить JSTL теги, приведите примеры.
23. Что вы знаете о написании пользовательских jsp тегов?
24. Приведите пример использования собственных тегов.
25. Почему не нужно конфигурировать стандартные JSP теги в web.xml?
26. Как можно обработать ошибки jsp страниц?
27. Как происходит обработка ошибок с помощью jstl?
28. Как сделать «новую линию в HTML» в JSP?
29. Приведите пример конфигурации JSP в дескрипторе развертывания.
30. Как деактивировать использование EL на JSP?
31. Когда контейнер проинициализирует множество JSP/Servlet объектов?
32. Можно ли использовать javascript на jsp странице?
33. Всегда ли создается объект сессии на jsp странице, можно ли отключить его создание?
34. Какая разница между JspWriter и Servlet PrintWriter?
35. Как можно расширить функциональность jsp?
36. Best Practices в JSP.
JSP — это JavaServer Pages. JSP является серверной технологией для создания динамических веб-страниц. JSP расширяет технологию сервлетов, чтобы помочь разработчикам создавать динамические страницы с HTML подобным синтаксисом.
Создание представлений поддерживается и в сервлетах, но в таком случае код выглядит ужасным и подвержен ошибкам. Так же было замечено, что большинство элементов веб страницы является статическими и поэтому JSP страница больше подходит к веб-страницам. По возможности необходимо избегать бизнес логики на странице JSP и использовать страницу только в качестве представления. Поэтому рекомендуется использовать JSP actions элементы или JSTL теги вместо написания JSP скриптов.
Еще одним преимуществом в JSP является горячее развертывание. Мы можем заменить старую страницу на другую в контейнере и пользователям будет отображаться новая JSP страница. Таким образом нет необходимости компилировать весь проект или перезапускать сервер для обновления части страниц.
2. Расскажите об этапах (фазах) жизненного цикла jsp.Если посмотреть код внутри созданной JSP страницы, то он будет выглядеть как HTML и не будет похож на java класс. Конвертацией JSP страниц в HTML код занимается контейнер, который так же создает сервлет для использования в веб приложении. Жизненный цикл JSP состоит из нескольких фаз:
Жизненные циклы методов JSP:
- jspInit() — метод объявлен в JSP странице и реализуется с помощью реализаций контейнера. Этот метод вызывается один раз в жизненном цикле JSP для того, чтобы инициализировать конфигурационные параметры, указанные в дескрипторе развертывания. Этот метод можно переопределить с помощью определения элемента JSP scripting и указания необходимых параметров для инициализации.
- _jspService() — этот JSP метод внедряется JSP контейнером для каждого запроса клиента с помощью передачи объекта запроса и ответа. Отметьте, что имя метода начинается с нижнего подчеркивания и отличается от других методов жизненного цикла тем, что его невозможно переопределить. Весь JSP код проходит через этот метод и он переопределен по умолчанию. Этот метод определен в HttpJspPage интерфейсе.
- jspDestroy() — метод вызывается контейнером JSP для удаления объекта из памяти (на последней фазе жизненного цикла JSP — Destroy). Метод вызывается только один раз и мы можем его переопределить для очищения любых ресурсов, которые были созданы в JSP init методе.
Мы можем переопределить jspInit() и jspDestroy() методы с помощью использования скриптов JSP. Метод jspInit() переопределяется для создания общих ресурсов, которые мы хотели бы использовать в методе обслуживания JSP, а jspDestroy() метод переопределяется, чтобы освободить общие ресурсы на фазе уничтожения.
5. Как можно предотвратить прямой доступ к JSP странице из браузера?Директория WEB-INF не имеет прямого доступа из веб приложения. Поэтому мы можем положить JSP страницы внутри этой папки и тем самым запретить доступ к странице из браузера. Однако в этом случае необходимо настраивать дескриптор развертывания наподобие сервлетов. Простая конфигурация дескриптора web.xml показана ниже.
Test /WEB-INF/test.jsp test Test Value Test /Test.do
< servlet - name > Test < / servlet - name > < jsp - file > / WEB - INF / test . jsp < / jsp - file > < init - param > < param - name > test < / param - name > < param - value > Test Value < / param - value > < / init - param > < / servlet > < servlet - mapping > < servlet - name > Test < / servlet - name > < url - pattern > / Test . do < / url - pattern > < / servlet - mapping > |
JSP предоставляет две возможности закомментировать код:
- HTML комментарии — . Такие комментарии будут видны клиенту при просмотре кода страницы.
- JSP комментарии — . Такие комментарии создаются в созданном сервлете и не посылаются клиенту. Для любых комментариев по коду или отладочной информации необходимо использовать этот тип комментариев.
Scriptlet, Expression и Declaration — скриптовые элементы внутри JSP страницы, которые могут выполнять Java код. Скриптлеты задаются тегом . Любой код внутри этих тегов будет передан _jspService() методу.
Date d = new Date () ; System . out . println ("Current Date=" + d ) ; |
Достаточно часто требуется показать динамическую информацию с использованием метода out.print() . Для этого существует язык выражений (expression), который записывается как . Например, выражение может быть переписано с помощью JSP выражения . Отметьте, что всё, что находится внутри тегов будет передано в out.print() метод. Так же обратите внимание, что скриптлеты могут содержать несколько java выражений, разделенных точкой с запятой, в то время как выражения не должны заканчиваться на точку с запятой.
JSP Declaration используется для объявления методов и переменных класса сервлета. Declaration записываются с помощью тега , например — .
8. Какие неявные, внутренние объекты и методы есть на jsp странице?JSP implicit objects (неявные объекты) создаются контейнером при конвертации JSP страницы в код сервлета для помощи разработчикам. Эти объекты можно использовать напрямую в скриптлетах для передачи информации в сервис методы, однако мы не можем использовать неявные объекты в JSP Declaration, т.к. такой код пойдет на уровень класса.
Существует 9 видов неявных объектов, которые можно использовать прямо на JSP странице. Семь из них объявлены как локальные переменные в начале _jspService()
метода, а два оставшихся могут быть использованы как аргументы метода _jspService()
.
Index JSP Page
Hi There
Current Time is:
Request User-Agent:
User init param value:
User context param value:
User Session ID:
PageContext attribute: {Name="Test",Value=""}
Generated Servlet Name:
< ! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< meta http - equiv = "Content-Type" content = "text/html; charset=US-ASCII" > Index JSP Page < / title > < / head >
Current
Time
is
<
/
strong
>
:
Request
User
-
Agent
<
/
strong
>
:
User
init
param
value
<
/
strong
>
:
User
context
param
value
<
/
strong
>
:
User
Session
ID
<
/
strong
>
:
PageContext
attribute
<
/
strong
>
:
{
Name
=
"Test"
,
Value
=
"
"
}
Generated Servlet Name < / strong > : < / body > < / html > |
Неявный объект исключений JSP недоступен в обычных JSP страницах и используется на страницах ошибок JSP только для того, чтобы перехватить исключение, брошенное JSP страницей и далее предоставить какую-либо полезную информацию клиенту.
10. Что вы знаете о PageContext и какие преимущества его использования?Неявный объект JSP pageContext является экземпляром реализации абстрактного класса javax.servlet.jsp.PageContext . Мы можем использовать объект pageContext для получения и установки атрибутов с различной областью видимости и для проброса запросов к другому ресурсу. Этот объект так же обладает ссылкой на другой неявный объект. Это единственный объект, который представлен в JSP implicit objects и JSP EL implicit objects.
11. Как сконфигурировать init параметры для JSP?Мы можем задать параметры инициализации для JSP аналогично сервлетам в web.xml файле. Мы должны сконфигурировать init параметры JSP с элементами servlet и servlet-mapping. Единственным отличием будет указание местонахождения JSP страницы.
JSP страницы в основном используются для целей отображения представления, а вся бизнес логика и модели должны быть реализованы в сервлетах или классах моделях. Мы должны передавать параметры к JSP странице через атрибуты и затем использовать их для создания HTML ответа на JSP странице. Большая часть JSP содержит HTML код и для того, чтобы помочь дизайнерам понять код JSP страницы и разрабатывать их, предоставляют элементы action, JSP EL, JSP Standart Tag Library. Именно эти элементы необходимо использовать вместо скриптлетов для создания моста между JSP HTML и JSP java частями.
13. Можем ли мы определить класс внутри JSP страницы?Определить класс внутри JSP страницы можно, но это считается плохой практикой. Это можно сделать так
< jsp - property - group > < url - pattern > * . jsp < / url - pattern > < scripting - invalid > true < / scripting - invalid > < / jsp - property - group > < / jsp - config > |
JSP элементы или теги action предоставляют полезную функциональность для работы с Java Bean, вложения ресурсов, проброса запроса и создания динамических XML элементов. Элементы jsp action всегда начинаются с записи jsp: и мы можем использовать их прямо внутри страницы JSP без необходимости подключения библиотек или других настроек.
Наиболее часто используемыми элементами action являются: jsp:useBean , jsp:getProperty , jsp:setProperty , jsp:include , jsp:forward .
17. Какая разница между директивой include и jsp:include action?Разница между директивой JSP include
и jsp:include
action заключается в том, что для директивы include, контент для другого ресурса будет добавлен в созданный сервлет на этапе трансляции JSP (фаза Translation), в то время как jsp:include
action работает в рантайме.
Другое отличие JSP include action
в том, что мы можем передать параметры для вложения с помощью команды jsp:params
, в то время как директива jsp include
не имеет возможности передавать параметры.
Использовать директиву JSP include необходимо для статических ресурсов вроде header, footer, image file для повышения производительности. Если же нам необходима динамика, передача параметров для обработки, то необходимо использовать тег jsp:include action.
В большинстве случаев мы используем JSP для целей просмотра, а вся бизнес-логика присутствует в сервлете или классах модели. После получения запроса клиента он обрабатывается в сервлете, а затем добавляем атрибуты в request/session/context scope, которые должны быть извлечены в JSP коде. Для создания ответа представлений так же используются request
, headers
, cookies
и init
параметры.
Мы можем использовать скриптлеты в JSP выражениях для получения атрибутов и параметров в JSP с Java кодом и использовать его для представлений. Проблема заключается в том, что веб дизайнеры обычно не знают java код, и именно поэтому в JSP 2.0 введен язык выражений (EL), через который мы можем получить атрибуты и параметры с помощью тегов HTML.
Синтаксис expression language выглядит как $ {имя}
, и мы можем использовать EL неявные объекты и операторы языка выражений для извлечения атрибутов из разных scopes и использовать их в JSP странице.
Язык выражений JSP предоставляет множество неявных объектов, которые можно использовать для получения атрибутов в различных областях видимости (scopes) и для значений параметров. Важно отметить, что они отличаются от неявных объектов JSP и содержат атрибуты в заданной области видимости. Наиболее часто использующийся implicit object в JSP EL и JSP page — это объект pageContext. Ниже представлена таблица неявных объектов JSP EL.
| pageScope | Map | Карта атрибутов для page scope. |
| requestScope | Map | Используется для получения атрибутов в request scope. |
| sessionScope | Map | Используется для получения атрибутов из session scope. |
| applicationScope | Map | Используется для получения атрибутов из application scope. |
| param | Map | Используется для получения значения параметра request, возвращает одно значение. |
| paramValues | Map | Используется для получения значений параметров запроса в массиве. Удобно для параметров запроса, который содержит множество значений. |
| header | Map | Используется для получения информации о request header. |
| headerValues | Map | Используется для получения значений header values в массиве. |
| cookie | Map | Используется для получения значения cookie в JSP |
| initParam | Map | Используется для получения параметров context init. Мы не можем использовать их для параметров инициализации сервлета (servlet init params). |
| pageContext | pageContext | Такой же как и объект JSP implicit pageContext. Используется для получения request, session references и т.д. К примеру, получение имени request HTTP Method. |
Вот так: ${pageContext.request.method} .
21. Что такое JSTL (Jsp Standard tag library)?Стандартная библиотека тегов JSP (англ. JavaServer Pages Standard Tag Library, JSTL) - расширение спецификации JSP, добавляющее библиотеку JSP тегов для общих нужд, таких как разбор XML данных, условная обработка, создание циклов и поддержка интернационализации. JSTL - конечный результат JSR 52, разработанного в рамках процесса сообщества Java.
JSTL является альтернативой такому виду встроенной в JSP логики, как скриптлеты, то есть прямые вставки Java кода. Использование стандартизованного множества тегов предпочтительнее, поскольку получаемый код легче поддерживать и проще отделять бизнес-логику от логики отображения. Для использования JSTL тегов необходимо подключить библиотеку и указать на страницах пространство имен.
jstl jstl 1.2 taglibs standard 1.1.2
jstl < / groupId > jstl < / artifactId > 1.2 < / version > < / dependency >
taglibs < / groupId > standard < / artifactId > 1.1.2 < / version > < / dependency > |
Для подключения пространства имен основных тегов JSTL необходимо указать на JSP странице код:
|
JSTL теги разделяются на пять категорий согласно их функциональности:
JSP позволяет создавать свои собственные теги с необходимой функциональностью. Мы можем добавить библиотеку тегов на страницу JSP используя указание пространства имен. Для создания своего тега мы можем использовать следующие компоненты:
- JSP Custom Tag Handler
- Создание файла Tag Library Descriptor (TLD)
- Deployment Descriptor конфигурацию для TLD
Например нам необходимо отформатировать в каком-либо стиле очень длинное число. Для этого можно использовать собственный тег вроде:
< mytags : formatNumber number = "123456.789" format = "#,###.00" / > |
Используя входные параметры, число должно быть преобразовано на JSP странице в таком виде 123,456.79 согласно шаблону. Т.к. JSTL не предоставляет такой функциональности, то нам придется создать собственный тег для получения необходимого результата.
25. Почему не нужно конфигурировать стандартные JSP теги в web.xml?Нам не нужно настраивать стандартные теги JSP в web.xml, потому что TLD файлы уже находятся внутри каталога META-INF в JSTL jar файлах. Когда контейнер загружает веб-приложение и находит TLD файлы в директории META-INF в JAR файле, то он автоматически настраивает их для непосредственного использования на JSP страницах. Остается только задать пространство имен на jsp странице.
26. Как можно обработать ошибки jsp страниц?Для обработки исключений выброшенных на jsp странице необходимо всего лишь задать страницу ошибки. Для создания страницы ошибки JSP мы должны установить значение page directive attribute isErrorPage в значение true. Тогда мы получим доступ к неявным объектам исключений в JSP и сможем передавать собственные сообщение об ошибках клиенту (обычно более информативных).
Настройка дескриптора развертывания выглядит так.
404 /error.jsp java.lang.Throwable /error.jsp
< error - page > < error - code > 404 < / error - code > / error . jsp < / location > < / error - page > < error - page > < exception - type > java . lang . Throwable < / exception - type > / error . jsp < / location > < / error - page > |
Перехватывать исключения и обрабатывать их в служебных методах класса можно с помощью JSTL Core Tags c:catch и c:if . Тег c:catch перехватывает исключение и обертывает его в переменную exception, которую мы можем обработать в теге c:if .
Exception is: ${exception}
Exception Message: ${exception.message}
< c : catch var = "exception" >
< / c : catch > < c : if test = "${exception ne null}" > Exception is : $ { exception } < br / > Exception Message : $ { exception . message } < / p > < / c : if > |
Обратите внимание что используется язык выражений JSP EL в теге c:if .
28. Как сделать «новую линию в HTML» в JSP?Для переноса строки можно использовать тег c:out и атрибут escapeXml для отключения обработки HTML элементов и браузер получит следующий код как строку (и обработает элемент
как требуется).
16 ответов
Технология JSP является частью Java технологии семьи. Страницы JSP: скомпилирован в сервлеты и может вызывать Компоненты JavaBeans (beans) или Компоненты Enterprise JavaBeans (предприятие beans) для выполнения обработки на сервере. Таким образом, JSP технология является ключевым компонентом масштабируемая архитектура для веб-приложения.
A: Технология JavaServer Faces - это структура для создания пользовательских интерфейсов для веб-приложений. JavaServer Faces технология включает в себя:
Набор API для: представления пользовательского интерфейса компонентов и управления их состоянием, обработки событий и проверки ввода, определение навигации по страницам и поддержки интернационализации и доступность.
Пользовательский тег JavaServer Pages (JSP) библиотека для выражения JavaServer Интерфейс Faces на странице JSP.
JSP - это специализированный сервлет.
JSF - это набор тегов, которые вы можете использовать с JSP.
С точки зрения браузера/клиента
JSP и JSF выглядят одинаково, поскольку в соответствии с требованиями приложений JSP больше подходит для приложений, основанных на запросах.
JSF предназначен для более богатых веб-приложений, основанных на событиях. Я вижу событие более зернистым, чем запрос/ответ.
С точки зрения сервера
Страница JSP преобразуется в сервлет и имеет минимальное поведение.
Страница JSF преобразуется в дерево компонентов (специализированным FacesServlet), и он следует за жизненным циклом компонента, определенным спецификацией.
Сервлеты:
API Java Servlet позволяет разработчикам Java писать серверный код для доставки динамического веб-контента. Как и другие проприетарные веб-серверы API, API-интерфейс Java Servlet предлагает улучшенную производительность по сравнению с CGI; однако он имеет некоторые ключевые дополнительные преимущества. Поскольку сервлеты были закодированные в Java, они обеспечивают объектно-ориентированный подход (OO) и, что более важно, могут работать на любой платформе. Таким образом, код был переносимым на любой хост, поддерживающий Java. Сервлеты в значительной степени способствовали популярности Java, поскольку он стал широко использоваться технологии для разработки веб-приложений на стороне сервера.
JSP построен поверх сервлетов и обеспечивает более простой, основанный на странице решение для создания большого количества динамического содержимого HTML для Интернета пользовательских интерфейсов. JavaServer Pages позволяет веб-разработчикам и дизайнерам просто редактировать HTML-страницы со специальными тегами для динамического Java части. JavaServer Pages работает, имея специальный сервлет, известный как контейнер JSP, который установлен на веб-сервере и обрабатывает все Запросы просмотра страницы JSP. Контейнер JSP переводит запрошенный JSP в код сервлета, который затем скомпилирован и сразу же выполняется. Последующие запросы на одну страницу просто вызовут сервлет выполнения для страницы. Если в JSP на сервере внесено изменение, запрос для его просмотра запускается другой перевод, компиляция и перезапуск сервлет времени выполнения.
JavaServer Faces - стандартная среда Java для создания пользователя интерфейсы для веб-приложений. Самое главное, это упрощает разработка пользовательского интерфейса, который часто является одним из наиболее сложные и утомительные части разработки веб-приложений.
Хотя можно создавать пользовательские интерфейсы, используя основополагающие Веб-технологии Java (такие как сервлеты Java и страницы JavaServer) без всеобъемлющей структуры, предназначенной для корпоративных веб-сайтов разработки приложений, эти основные технологии часто могут привести к проблемы развития и обслуживания. Что более важно, когда разработчики достигнут решения по качеству производства, тот же набор проблем, решаемых JSF, будет решен в нестандартный. JavaServer Faces предназначен для упрощения разработка пользовательских интерфейсов для веб-приложений Java в следующими способами:
Он обеспечивает компонентную, клиент-независимый подход к созданию веб-пользователя интерфейсов, что повышает производительность и простоту использования разработчика.
Это упрощает доступ и управление данными приложения из Веб-интерфейс пользователя.
Он автоматически управляет пользовательским интерфейсом состояния между несколькими запросами и несколькими клиентами в простой и ненавязчивый способ.
Он обеспечивает структуру разработки, которая дружелюбный к разнообразной аудитории разработчиков с различными наборами навыков.
В нем описывается стандартный набор архитектурных шаблонов для сети приложение.
Есть также ситуации, когда вы можете поддержать JSP над JSF. Характер применения должен быть решающим фактором для выбора технологии.
Если у вас богатое взаимодействие с графическим интерфейсом и много требуемых сценариев Java, то вы можете использовать JSF. В принципе, если ваша архитектура графического интерфейса похожа на компонентный, ориентированный и даже управляемый как Swing, тогда JSF является лучшим.
Если приложение является простой отправкой формы, не требуется много взаимодействия с графическим интерфейсом, тогда JSP может преуспеть, если изучение новой технологии является накладными расходами, а также сложной структурой нет необходимости.
Java Server Pages (JSP) - это технология Java, которая позволяет веб-разработчикам и дизайнерам быстро разрабатывать и легко поддерживать насыщенные информацией динамические веб-страницы, которые используют существующие бизнес-системы. Технология JSP отделяет пользовательский интерфейс от генерации контента, позволяя дизайнерам изменять общий макет страницы без изменения базового динамического контента.
Facelets - это первый не-JSP язык объявления страниц, разработанный для JSF (Java Server Faces), который предоставил разработчикам JSF более простую и мощную модель программирования по сравнению с JSP. Это решает различные проблемы, возникающие в JSP для разработки веб-приложений.
Вот таблица, которая сравнивает особенности скриптов и лицевых граней:
Jsp также имеет встроенный код сервлета, который не нуждается в какой-либо внешней компиляции, которую он может запускать напрямую. Изменения вступят в силу в jsp непосредственно в браузере.
Сервлет необходимо скомпилировать (т.е. он будет иметь определенное создание класса)
Jsf - это компонент представления MVC Framework
JSP - это компонент View MVC (Model View Controller). Контроллер принимает входящий запрос и передает его в Модель, которая может быть bean, которая делает доступ к базе данных. Затем JSP форматирует вывод с использованием HTML, CSS и JavaScript, и затем результат отправляется обратно запрашивающему.
JSP:means HTML+Java Code:
JSP имеет собственный жизненный цикл jsp_init() jsp_service() jsp_destroy
После первого запроса JSP конвертируется в.java файл. Существует три типа тегов, которые мы используем. 1.) безскриптовый
Здесь разработчик может объявить все те вещи, которые разработчик хочет взять с собой.
2.) Тег выражения
Здесь разработчик может использовать некоторые данные, относящиеся к печати
Здесь разработчик может объявить некоторые связанные с методом данные.
Servlet:
Сервл имеет собственный жизненный цикл.
Init() service() destroy()
После первого контейнера запроса будут считываться данные из файла web.xml
то после приветствия заполнение будет отображаться.
Теперь, после выполнения действия, он будет искать URL-адрес, и после этого процесса он будет искать конкретный сервлет там. будет выполняться операция обслуживания.
Последнее обновление: 02.09.2018
Представляет технологию, которая позволяет создавать динамические веб-страницы. Изначально JSP (вместе с сервлетами) на заре развития Java EE являлись доминирующим подходом к веб-разработке на языке Java. И хотя в настоящее время они уступило свое место другой технологии - JSF, тем не менее JSP продолжают широко использоваться.
По сути Java Server Page или JSP представляет собой html-код с вкраплениями кода Java. В то же время станицы jsp - это не стандартные html-страницы. Когда приходит запрос к определенной странице JSP, то сервер обрабатывает ее, генерирует из нее код html и отправляет его клиенту. В итоге пользователь после обращения к странице JSP видит в своем браузере обычную html-страницу.
Как и обычные статические веб-страницы, файлы JSP необходимо размещать на веб-сервере, к которому обычные пользователи могут обращаться по протоколу http, например, набирая в адресной строке браузера нужный адрес. Однако чтобы сервер мог обрабатывать файлы JSP, он должен использовать движок JSP (), который также называют JSP-контейнером. Есть множество движков JSP, и все они реализуют одну и ту же спецификацию и в целом работают одинаково. Однако тем не менее при переносе кода с одного веб-сервера на другой могут потребоваться небольшие изменения.
В данном случае для работы с 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 , которая была создана выше.
Запустим Apache Tomcat (если он не запущен), и обратимся к приложению по адресу http://localhost:xxxx/index.jsp , где xxxx - номер порта, по которому запущен Tomcat:
В итоге Tomcat получит запрос к странице index.jsp, обработает код на java, сгенерирует html-страницу и отправит ее пользователю.
По умолчанию Apache Tomcat настроен таким образом, что все запросы к корню приложения по умолчанию обрабатываются страницей index.jsp, поэтому мы также можем обращаться к ней по адресу
