Просмотр кода страницы JavaServer Pages

{{Infobox file format
| название = JSP
| стандарт = [http://jcp.org/en/jsr/detail?id=245 JSR 245]
| последняя версия = 3.1.0 ({{start date and age|2022|05|15}})
}}
{{Стиль}}
'''JSP''' ('''JavaServer Pages''') — платформенно-независимая, переносимая и легко расширяемая технология для [[Веб-разработка|разработки веб-приложений]], работающая на [[Java Virtual Machine|виртуальной машине Java (JVM)]]. JSP позволяет веб-[[Программист|разработчикам]] создавать содержимое, состоящее из статических исходных данных, которые могут быть оформлены в одном из текстовых форматов [[HTML]], [[SVG]], [[WML]], или [[XML]], и JSP-элементов, которые конструируют динамическое содержимое. Кроме этого могут использоваться библиотеки JSP-тегов, а также [[Expression Language]] (EL), для внедрения [[Java]]-[[Исходный код|кода]] в статичное содержимое JSP-страниц.

Код JSP-страницы транслируется в Java-код [[Сервлет (Java)|сервлета]] с помощью компилятора JSP-страниц [[Apache Tomcat#Jasper|Jasper]], затем компилируется в [[байт-код]] Java, после чего [[Сервлет (Java)|сервлет]] может быть запущен в [[Контейнер сервлетов|контейнерах сервлетов]]. JSP-страницы загружаются на сервере и управляются из структуры специального Java server packet, который называется [[Java Platform, Enterprise Edition|Jakarta EE]] Web Application. Обычно страницы упакованы в [[Архив (информатика)|файловые архивы]] [[WAR (тип файла)|.war]] и [[EAR|.ear]].

== Версии ==
Начиная с версии 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 Platform, Enterprise Edition|Java EE 5]]. 10 декабря 2009 года была выпущена спецификация JSP 2.2 как содержание выпуска [[JSR 245]].

=== JSP 1.0 и JSP 1.1 ===
Эти версии кардинально отличаются от предыдущих, которые воспринимались как ответ [[Java]] на [[Active Server Pages|ASP]]. Некоторые основные возможности прошлых версий (например, возможность разрабатывать библиотеки тегов) были убраны или заменены в соответствии с принципом разделения кода и содержимого. Так как в больших объёмах [[Исходный код|исходного кода]] трудно сориентироваться и отделить контент от самого кода, то пришла идея их разделить (перенести) с помощью JSP тегов, таких как <code><jsp:useBean/></code>. Для реализации этой идеи JSP-теги разделили на три логические группы: директивы, скриптовые элементы и действия.

=== JSP 1.2 ===

JSP 1.2 расширяет спецификацию JavaServer Pages 1.1 (JSP 1.1) следующим образом:
* требуют платформы [[История версий Java|Java 2]] версии 1.2 или более поздней;
* использует [[Сервлет|Servlet 2.3]] как основу своей семантики;
* определяет синтаксис [[XML]] для страниц JSP;
* предоставляет проверку страниц JSP на этапе трансляции;
* специфицирует очистку библиотеки тегов на этапе прогона;
* улучшает контракт обработчика тегов;
* предоставляет улучшенную поддержку [[Авторизация|авторизации]] страниц;
* улучшает поддержку [[Набор символов|кодировки символов]] и локализации;
* устраняет ограничение «flush before you include» из JSP 1.1.

=== JSP 2.0 ===
Новая версия спецификации JSP дополнена следующей функциональностью:
* [[Expression Language|Expression Language (EL)]] — язык выражений, позволяет среди прочего создавать разработчикам шаблоны в стиле [[Velocity]];
* более простой и быстрый способ создавать новые теги с помощью файлов <code>.tag</code>, теперь для создания новых тегов не обязательно знать Java;
* удобный способ управления вложенными бинами ([[JavaBeans]]);
* более быстрый и лёгкий способ отображения параметров переменных:
<source lang="java5">
Hello, ${param.visitor} <%-- аналогично коду: Hello, <%=request.getParameter("visitor")%> --%>
</source>

=== JSP 2.1 ===
* аключает в себя [[JSTL]] и [[JavaServer Faces]];
* новая версия [[Expression Language|EL]] поддерживает отложенное исполнение выражений и литеральные выражения, а также [[Перечисляемый тип#Java|J5EE enumeration]].

Платформа [[Java Platform, Enterprise Edition|Java EE 5]] фокусируется на простой разработке с использованием языковых аннотаций Java, которые были введены [[Java Platform, Enterprise Edition|J2SE 5.0]]. JSP 2.1 поддерживает эту цель определением аннотаций для зависимых инъекций в JSP операторах и в контекстных слушателях (Listeners).

== Обзор ==
JavaServer Pages (JSP) позволяют отделить динамическую часть страниц от статического [[HTML]]. Динамическая часть заключается в специальные теги <code>"<% %>"</code>:
<source lang="java5">Имя вашего хоста: <%= request.getRemoteHost() %></source>

JSP страницы имеют расширение <code>.jsp</code> и размещаются там же, где и обычные Web-страницы. Структура таких страниц может состоять из пяти конструкций: [[HTML]], комментарии, скриптовые элементы, директивы и действия. JSP-страница при компиляции преобразуется в [[сервлет]] со статическим содержимым, которое направляется в поток вывода, связанный с методом [[service]]. Поэтому при первом запросе этот процесс может вызвать небольшую задержку. '''''Комментарии''''' в документе или программе не являются причиной замедления программы, так как [[транслятор]] и исполнитель их игнорируют. '''''Скриптовые элементы''''' позволяют указать код на языке [[Java]], который впоследствии станет частью конечного сервлета, '''''директивы''''' дают возможность управлять всей структурой сервлета, а '''''действия''''' служат для задания существующих используемых компонентов, а также для контроля над поведением движка JSP. Для упрощения работы со скриптами имеются заранее определённые переменные, такие как <code>request, response, pageContext, session, out, application, config, page, exception</code>.
Пример JSP страницы с использованием всех составляющих JSP:

[[Файл:JSP_example_with_cooments.JPG]]

=== Комментарии ===
[[Комментарии (программирование)|Комментарии]] используются для пояснения исходного текста программы. В JSP-страницах комментарии можно разделить на две группы:
* комментарии исходного кода JSP;
* комментарии [[HTML]]-разметки.

Комментарии исходного кода JSP отмечаются специальной последовательностью символов: <code><%--</code> в начале и <code>--%></code> в конце комментария. Данный вид комментариев удаляется на этапе компиляции JSP-страницы. Пример JSP-комментария:
<source lang="java5">
<%--
	Отобразит каталог изделий
	и актуальную корзину покупателя.
--%>
</source>

Комментарии [[HTML]]-разметки оформляются в соответствии с правилами языка HTML. Данный вид комментариев рассматривается JSP-компилятором как статический текст и помещается в выходной HTML-документ. JSP-выражения внутри HTML-комментариев исполняются. Пример HTML-комментария:
<source lang="java5">
<!-- Дата создания страницы: <%= new java.util.Date() %> -->
</source>

=== Скриптовые элементы ===
Спецификация JSP различает три типа скриптовых элементов:
* объявления <code><%!</code> одна или несколько деклараций <code>%>;</code>
* выражения <code><%=</code> одно выражение <code>%>;</code>
* скриплеты <code><%</code> скриплет <code>%>.</code>
''Объявления'' обычно используются для определения переменных, методов, внутренних классов и остальных действующих Java конструкций на уровне класса. ''Выражения'' становятся аргументами для метода out.print(). С помощью ''скриплетов'' в JSP страницы вкладываются работающие части Java-кода.

==== Объявления JSP ====
Объявления JSP позволят вам задавать переменные, методы, внутренние классы и так далее. Объявления используются для определения используемых в программе конструкций Java. Так как объявления не осуществляют вывода, обычно они используются совместно с JSP-выражениями или скриплетами. В приведённом в качестве примера фрагменте JSP отображается количество запросов к данной странице с момента загрузки сервера (или с момента последнего изменения и перезагрузки сервлета). Обратите внимание, что в примере мы используем как объявление, так и выражение и что внутри конструкции после объявления стоит [[точка с запятой]] (''';'''):
<source lang="java5">
<%! private int accessCount = 0; %>
Количество обращений к странице с момента загрузки сервера: <%= ++accessCount %>
</source>

==== Выражения JSP ====
Выражения JSP применяются для того, чтобы вставить значения Java непосредственно в вывод. Выражения Java вычисляются, конвертируются в строку и вставляются в страницу. Эти вычисления проходят во время выполнения (то есть при запросе страницы), а потому существует полный доступ к информации о самом запросе.
В выражениях можно использовать постоянные, переменные, вызовы различных методов. Все выражения, вне зависимости от сложности их содержимого, вычисляются в один результат или число. JSP страницы полагаются на [[JSP Writer]], который берёт любой результат выражения, переводит его в тип <code>String</code> (текстовый) и заносит в [[Буфер (информатика)|буферную память]]. Например, следующий код служит для отображения даты и времени запроса данной страницы:
<source lang="java5">
Текущее время: <%= new java.util.Date() %>
Имя вашего хоста: <%= request.getRemoteHost() %>
</source>
Необходимо обратить внимание на три правила:
# JSP выражения должны в себе содержать выражения Java.
# Каждое JSP выражение должно содержать только одно выражение Java.
# Выражения JSP обязаны не заканчиваться точкой с запятой (<code>;</code>), в отличие от Java объявлений.

==== Скриплеты JSP ====
Скриплеты JSP дают возможность вставить любой код в метод сервлета, который будет создан при обработке страницы, позволяя использовать большинство конструкций Java. Скриплеты также имеют доступ к тем же заранее определённым переменным, что и выражения. Поэтому, например, для вывода значения на страницу необходимо использовать заранее определённую переменную <code>out</code>.
<source lang="java5">
<% 
String queryData = request.getQueryString();
out.println("Дополнительные данные запроса: " + queryData); 
%>
</source>
Код внутри скриплета вставляется в том виде, как он был записан. Весь статический [[HTML]] (текст шаблона) до или после скриплета конвертируется при помощи оператора <code>print</code>. Например, следующий фрагмент JSP содержит смешанный текст шаблона и скриплета:
<source lang="java5">
<% if (Math.random() < 0.5) { %>
     <B>Удачного</B> вам дня!
<% } else { %>
     <B>Неудачного</B> вам дня!
<% } %>
</source>
После преобразования скриплета код будет выглядеть следующим образом:
<source lang="java5">
if (Math.random() < 0.5) { 
     out.println("<B>Удачного</B> вам дня!");
} else { 
     out.println("<B>Неудачного</B> вам дня!");
}
</source>
Это означает, что скриплеты не обязательно должны содержать завершённые фрагменты Java, и что оставленные открытыми блоки могут оказать влияние на статический [[HTML]] вне скриплета.

=== Директивы JSP ===
JSP страница может послать сообщение соответствующему контейнеру с указаниями действий, которые необходимо провести. Эти сообщения называются директивами. Все директивы начинаются с <code><%@</code>, затем следует название директивы и один или несколько атрибутов со значениями, и заканчиваются <code>%></code>. Директивы в JSP странице приводят к тому, что контейнер пошлёт заявку на исполнение определённой службы, которая в генерированном документе не объявляется. Форму записи директив можно изобразить следующим образом:
<source lang="java5">
<%@ директива атрибут="значение" %>
</source>
Вы также можете объединить установку нескольких атрибутов для одной директивы:
<source lang="java5">
<%@ директива атрибут1="значение1" 
              атрибут2="значение2"
              ...
              атрибутN="значениеN" %>
</source>
Существует три основных типа директив: '''page''', которая позволяет вам совершать такие операции, как импорт классов, изменение суперкласса сервлета, и т. п.; '''include''', которая даёт вам возможность вставить [[файл]] в класс сервлета при трансляции JSP файла в сервлет; и '''taglib''', позволяющий расширить множество тегов своими собственными, которые JSP контейнер способен истолковать.

==== Директива JSP page ====
Как можно догадаться из названия, данная директива предоставляет атрибуты для JSP страницы. Атрибуты, определённые в этой директиве, внедряются в данную JSP страницу и на все её вложенные статические элементы, независимо от того, были ли они вставлены с помощью директивы <code>include</code> или с помощью действия <code>jsp:include</code>. Форма записи директивы <code>page</code> следующая:
<source lang="java5">
<%@ page атрибут=“значение“ %>
</source>
В качестве примера приведём следующую запись:
<source lang="java5">
<%@ page import=”java.util.*, com.myclasses.*” buffer=”15kb” %>
</source>
Эта директива заявляет, что JSP страница импортирует классы из двух пакетов Java, <code>java.util</code> и <code>com.myclasses</code>, а потом уточняет размер буферной памяти, которая должна быть использована для обработки данной JSP страницы.

Далее рассмотрим атрибуты директивы <code>page</code>:
* '''<code>import="пакет.class1, пакет.class2, ..., пакет.classN".</code>''' Позволяет вам задать пакеты, которые должны быть импортированы. Это единственный атрибут, который может использоваться несколько раз в одной директиве. В список необходимо включить все классы Java, которые Вы хотите использовать и которые не являются частью исходного набора импортируемых классов. Исходный набор содержит: <code>java.lang.*, javax.servlet.*, javax.servlet.jsp.* и javax.servlet.http.*.</code> Пример использования атрибута <code>import</code>:
<source lang="java5">
<%@ page import="java.util.Date, javax.text.SimpleDateFormat, com.myclasses.*" %>
</source>
* '''<code>language="java".</code>''' Данный атрибут предназначен для задания используемого [[Язык программирования|языка программирования]]. По умолчанию принимается значение <code>"java"</code>. Этот атрибут необязательно использовать, но тем не менее проблема потом может наступить в случае, если поставщик JSP контейнера будет использовать другие языки (например, [[JavaScript]]). Пример записи данного атрибута следующий:
<source lang="java5">
<%@ page language=”java” %>
</source>
* '''<code>extends="пакет.class".</code>''' Задаёт суперкласс (родительский класс) для генерируемого сервлета. Обычно сервлет возникает расширением исходного класса. Опытные программисты могут с помощью этого атрибута создавать собственные суперклассы. Пример использования этого атрибута может выглядеть следующим образом:
<source lang="java5">
<%@ page extends=”myPackage.HttpExample” %>
</source>
* '''<code>session="true|false".</code>''' Данный атрибут может принимать значение '''true''' или '''false''', которые определяют принимает ли участие JSP страница в трансляции [[HTTP]]. Значение <code>true</code> («истина», принимается по умолчанию) сигнализирует о том, что заранее определённая переменная <code>session</code> (тип <code>HttpSession</code>) должна быть привязана к существующей сессии, если таковая имеется, в противном случае создаётся новая сессия, к которой и осуществляется привязка. Значение <code>false</code> («ложь») определяет, что сессии не будут использоваться, и попытки обращения к переменной <code>session</code> приведут к возникновению ошибки при трансляции JSP страницы в сервлет. Пример использования данного атрибута может выглядеть следующим образом:
<source lang="java5">
<%@ page session=”false” %>
</source>
* '''<code>buffer="размерkb|none".</code>''' Данный атрибут задаёт объём буферной памяти, необходимой для объекта [[JspWriter]], на который ссылается заранее определённая переменная <code>out</code>. Значение, принимаемое по умолчанию, зависит от настроек сервера, но должно превышать <code>8kb</code>. Значение задаётся либо в форме «размерkb» либо «none». Если Вы укажете значение буферной памяти как <code>none</code>, то сервлет не будет ничего сохранять в буферную память и передаст результат, записанный до переменной <code>out</code>, прямо объекту <code>PrintWriter</code>, который предоставляется вместе с объектом <code>ServletResponse.</code> Если Вы зададите значение буферной памяти на конкретную величину, то <code>JspWriter</code> будет в эту память сохранять данные, в результате чего увеличится производительность. В отличие от объекта <code>PrintWriter</code> объект <code>JspWriter</code> может вызывать исключительные ситуации <code>IOExceptions</code>. Исходная величина буферной памяти равна <code>8kB</code>. Пример записи данного атрибута может выглядеть следующим образом:
<source lang="java5">
<%@ page buffer=”12kb” %>
</source>
* '''<code>autoflush="true|false".</code>''' Данный атрибут может принимать значения '''true''' или '''false'''. Значение <code>true</code> («истина», принимаемое по умолчанию) устанавливает, что при переполнении буферной памяти он автоматически очистится. Значение <code>false</code> («ложь»), которое крайне редко используется, устанавливает что [[переполнение буфера]] должно приводить к возникновению исключительной ситуации (<code>IOExceptions</code>). Обычно атрибуты <code>buffer</code> и <code>autoflush</code> устанавливаются вместе в одной директиве. При установке значение атрибута <code>buffer="none"</code> установка значения <code>false</code> для атрибута <code>autoflush</code> недопустима. Пример может выглядеть следующим образом:
<source lang="java5">
<%@ page buffer=”16kb” autoflush=”true” %>
</source>
* '''<code>isThreadSafe="true|false".</code>''' Данный атрибут может принимать значения '''true''' или '''false'''. Значение <code>true</code> («истина», принимается по умолчанию) задаёт нормальный режим выполнения сервлета, когда множественные запросы обрабатываются одновременно с использованием одного экземпляра сервлета, исходя из соображения что автор синхронизировал доступ к переменным этого экземпляра. Значение <code>false</code> («ложь») сигнализирует о том, что сервлет должен наследовать <code>SingleThreadModel</code> (однопоточную модель), при которой последовательные или одновременные запросы обрабатываются отдельными экземплярами сервлета. Другими словами значение <code>true</code> приведёт к тому, что контейнер может посылать сервлету сразу несколько запросов, в то время как при значении <code>false</code> контейнер посылает запросы по одному. Пример использования выглядит так:
<source lang="java5">
<%@ page isThreadSafe=”false” %>
</source>
* '''<code>info="информация".</code>''' Задаёт строку, которая может быть получена при использовании метода <code>Servlet.getServletInfo().</code> Обычно этот метод возвращает информацию о сервлете (например, авторе, версии и авторских правах). Пример записи данного атрибута может выглядеть следующим образом:
<source lang="java5">
<%@ page info=”Автор: Пётр Иванович; версия:1.0” %>
</source>
* '''<code>errorPage="url".</code>''' Задаёт JSP страницу, которая вызывается в случае возникновения каких-либо событий <code>Throwables</code>, которые не обрабатываются на данной странице. Если на JSP странице случится исключение, и JSP страница не имеет собственного кода для решения этого исключения, то контейнер автоматически передаст управление на [[URL]], которую Вы задали в качестве значения атрибута <code>errorPage</code>. Пример записи выглядит так:
<source lang="java5">
<%@ page errorPage=“/myweb/errors/myerror.jsp“ %>
</source>
* '''<code>isErrorPage="true|false".</code>''' Данный атрибут может принимать значения '''true''' или '''false'''. Сигнализирует о том, может ли эта страница использоваться для обработки ошибок для других JSP страниц или нет. По умолчанию принимается значение <code>false</code> («ложь»). Пример использования данного атрибута может выглядеть следующим образом:
<source lang="java5">
<%@ page isErrorPage=”true” %>
</source>
* '''<code>contentType="MIME-Тип".</code>''' Данный атрибут задаёт тип <code>MIME</code> для вывода и по желанию можно задать кодировку знаков в ответе ([[HTML]] ответе). По умолчанию в качестве значения <code>MIME</code> используется <code>text/html</code>. Для наглядности можем использовать следующий пример:
<source lang="java5">
<%@ page contentType="text/plain" %>
</source>
Того же результата можно добиться и использованием скриплета:
<source lang="java5">
<% response.setContentType("text/plain"); %> 
</source>

==== Директива JSP include ====
Эта директива позволяет Вам включать файлы в сервлет в процессе трансляции JSP страницы. Использование директивы выглядит следующим образом:
<source lang="java5">
<%@ include file="относительный url" %>
</source>
Заданный [[URL]] обычно интерпретируется относительно JSP страницы, на которой расположена ссылка, но, как и при использовании любых других относительных [[URL]] вы можете задать системе положение интересующего вас ресурса относительно домашнего каталога [[Web сервер]]а, добавив в начало [[URL]] символ «'''/'''». Содержимое подключаемого файла обрабатывается как обычный текст JSP и поэтому может включать такие элементы как статический [[HTML]], элементы скриптов, директивы и действия.
Например, многие сайты используют небольшую панель навигации на каждой странице. В связи с проблемами использования фреймов [[HTML]] часто эта задача решается ра��мещением небольшой таблицы сверху или в левой половине страницы, [[HTML]] код которой многократно повторяется для каждой страницы сайта. Директива <code>include</code> наиболее естественный способ решения этой задачи, избавляющий разработчика от кошмара рутины копирования HTML в каждый отдельный файл. Это происходит следующим образом:
<source lang="java5">
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
  <title>Тестовая страница</title>
</head>
<body>
  <%@ include file="/navbar.html" %>

  <!-- Специфический фрагмент этой страницы ... -->

</body>
</html>
</source>
Учтите что поскольку директива <code>include</code> подключает файлы в ходе трансляции страницы, то после внесения изменений в панель навигации вам потребуется повторная трансляция всех использующих её JSP страниц. Что в данном случае является хорошим компромиссом, поскольку как правило панель навигации меняется достаточно редко и процесс подключения не теряет своей эффективности. Если же подключённые файлы меняются довольно часто, вы можете использовать вместо этого действие <code>jsp:include</code>. Это действие подключает файл в процессе обращения к JSP.

==== Директива JSP taglib ====
Как уже известно, в JSP страницах элементы зап��сываются с помощью [[Тег (языки разметки)|тегов]] (условных знаков, меток, марок). Множество тегов, которые JSP контейнер способен истолковать, можно расширить с помощью так называемых библиотек тегов. Также к расширенному множеству тегов можно присоединять действия, вследствие чего происходит расширение самого языка JSP. Теги можно разделить на стандартные и собственные. Обобщённый способ записи может выглядеть так:
<source lang="java5">
<%@ taglib uri=”URI к библиотеке тегов” prefix=“префикс знака“ %>
</source>
Библиотеку тегов необходимо идентифицировать с помощью [[URI]] адреса (уникального идентификатора ресурса). [[URI]] может быть как абсолютным так и относительным. Уникальный идентификатор ресурса определяет расположение библиотеки тегов ([[Tag Library Descriptor|TLD]]), который определяет собственные теги этой библиотеки. Пример записи директивы:
<source lang="java5">
<%@ taglib uri=”http://www.moywebserver.ru/naydiznaki.tld” prefix=”iskat” %>
</source>
JSP страница может содержать бесконечное количество директив <code>taglib</code>, но для каждой директивы необходимо установить различные префиксы, которые определяют содержимое библиотеки на странице. В качестве префикса можете использовать какой угодно текст, слово. В то время, как директиву <code>taglib</code> можно использовать где угодно на 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''''' — Генерирует код (в зависимости от типа используемого браузера), который создаёт тег <code>OBJECT</code> или <code>EMBED</code> для Java plugin;
* '''''jsp:params''''' — Группирует параметры внутри тега jsp:plugin;
* '''''jsp:fallback''''' — Указывает содержимое, которое будет использоваться браузером клиента, если подключаемый модуль не сможет запуститься. Используется внутри элемента plugin.

==== Действие jsp:useBean ====
Это действие позволяет загружать [[JavaBean]] для последующего использования на JSP странице. Эта возможность позволяет многократно использовать классы Java, не отказываясь при этом от преимуществ, предоставляемых сервлетами JSP. Помимо того, это один из способов исключения большей части обработки Java из JSP страницы. Если перенести обработку Java из JSP страницы до JavaBean, то потом эти функции можно использовать и в остальных JSP страницах. Простейший синтаксис для указания используемого bean:
<source lang="java5">
<jsp:useBean id="имя" class="пакет.class" />
</source>
Как правило это означает «создание нового экземпляра объекта класса, заданного через '''class''', и его связь с переменной с именем, заданным при помощи '''id'''». Однако можно задать атрибут '''scope''' (принимает значения <code>page|request|session|application</code>, <code>page</code> для страницы, <code>request</code> для запросов, <code>session</code> для сессий или диалогов, <code>application</code> для приложения), который ассоциирует <code>bean</code> не только с текущей страницей. В таком случае, полезно получить ссылки на существующие <code>beans</code>, и действие <code>jsp:useBean</code> создаёт экземпляр нового объекта лишь в том случае если не существует ни одного объекта с теми же значениями ''id'' и ''scope''. Теперь, когда у вас есть <code>bean</code>, вы можете изменять его свойства при помощи действия <code>jsp:setProperty</code>, или используя для этого скриплет и явно вызывая метод объекта с именем переменной заданном ранее через атрибут ''id''. ''Recall that with beans'', когда вы говорите «у этого bean есть свойство типа X с названием <code>foo</code>», вы на самом деле имеете в виду «у этого класса есть метод <code>getFoo</code>, который возвращает данные типа X, и другой метод <code>setFoo</code>, которому в качестве параметра передаётся X.» Действие <code>jsp:setProperty</code> более подробно рассмотрено в следующем разделе, но сейчас вы должны запомнить что вы можете либо явно задавать '''value''', задавая атрибут '''param''', чтобы получить значение из соответствующего параметра запроса, или просто перечислить свойства, чтобы получить значения из параметров запроса с теми же именами что и свойства. Вы можете получить значения существующих свойств при помощи выражений JSP или скриплетов, вызвав соответствующий метод <code>getXxx</code>, или (чаще всего), воспользовавшись действием <code>jsp:getProperty</code>.

Класс, заданный для bean, должен находиться в обычном каталоге классов сервера, а не в части, зарезервированной для классов, автоматически перезагружаемых после редактирования. Например, для Java Web Server, все используемые классы должны размещаться в каталоге <code>classes</code> или в [[.jar]] файле каталога <code>lib</code>, а не в каталоге <code>servlets</code>.
Ниже приведён простой пример, загружающий <code>bean</code> и устанавливающий/получающий простой строковый параметр.

'''BeanTest.jsp'''
<source lang="java5">
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
  <title>Многократное использование JavaBeans в JSP</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>
</source>
'''SimpleBean.java'''
<source lang="java5">
package hall;

public class SimpleBean {
  private String message = "Текст сообщения не задан";

  public String getMessage() {
    return(message);
  }
  public void setMessage(String message) {
    this.message = message;
  }
}
</source>
Ещё несколько деталей об использовании <code>jsp:useBean</code>. Простейший способ использовать <code>bean</code> — это использование конструкции:
<source lang="java5">
   <jsp:useBean id="имя" class="пакет.class" /> 
</source>
для загрузки <code>bean</code>, а затем использовать <code>jsp:setProperty</code> и <code>jsp:getProperty</code> для модификации и получения его свойств (параметров). Однако существуют ещё два других способа. Во-первых, вы можете использовать формат контейнера, а именно:
<source lang="java5">
  <jsp:useBean ...> 
    Тело 
  </jsp:useBean>
</source>
для того чтобы обеспечить выполнение Тела только в том случае, если экземпляр <code>bean</code> создаётся впервые, а не тогда, когда находится и используется уже существующий <code>bean</code>. Как обсуждается далее, <code>beans</code> могут совместно использоваться, поэтому не каждое выражение <code>jsp:useBean</code> приводит к созданию экземпляра нового <code>bean</code>. Во-вторых, кроме ''id'' и ''class'', существуют ещё три других атрибута, которые вы можете использовать: '''scope''', '''type''', и '''beanName'''. Эти атрибуты описаны далее:
* '''''id''''' — даёт имя переменной, которая ссылается на <code>bean</code>. Если удаётся найти <code>bean</code> с теми же самыми значениями <code>id</code> и <code>scope</code>, то вместо создания нового экземпляра используется ранее созданный объект;
* '''''class''''' — задаёт полное имя пакета <code>bean</code>;
* '''''scope''''' — задаёт область, в которой <code>bean</code> должен быть доступен. Может принимать четыре допустимых значения: '''page''', '''request''', '''session''' и '''application'''. По умолчанию принимает значение ''page'', означающее что <code>bean</code> доступен только на текущей странице (размещается в <code>PageContext</code> текущей страницы). Значение ''request'' означает что <code>bean</code> доступен только для текущего запроса клиента (размещается в объекте <code>ServletRequest</code>). Значение ''session'' означает что объект доступен всем страницам на протяжении жизни текущей <code>HttpSession</code>. И, наконец, значение ''application'' означает что он доступен всем страницам, использующим тот же самый <code>ServletContext</code>. Причина необходимости этого атрибута заключается в том что <code>jsp:useBean</code> приводит к созданию нового экземпляра объекта в том случае, если нет уже существующего объекта с тем же <code>id</code> и <code>scope</code>. Иначе используется уже существующий объект, и все элементы <code>jsp:setParameter</code> или любые другие между тегами <code>jsp:useBean</code> игнорируются.
* '''''type''''' — указывает тип переменной, которая ссылается на объект. Должен совпадать с именем класса, суперкласса или реализуемого интерфейса. Имя переменной задаётся через атрибут <code>id</code>.
* '''''beanName''''' — даёт имя <code>bean</code>, которое будет использовано методом <code>instantiate</code>. Можно задать <code>type</code> и <code>beanName</code>, и опустить атрибут <code>class</code>.

==== Действие jsp:setProperty ====
Вы можете использовать <code>jsp:setProperty</code> для присвоения значений свойствам ранее описанных <code>beans</code>. Вы можете делать это двумя способами. Во-первых, вы можете использовать <code>jsp:setProperty</code> после, но вне элемента <code>jsp:useBean</code>, так как это показано в примере:
<source lang="java5">
<jsp:useBean id="myName" ... />
...
<jsp:setProperty name="myName" 
                 property="someProperty" ... />
</source>
В этом случае <code>jsp:setProperty</code> выполняется независимо от того, был ли найден существующий <code>bean</code> или был создан новый экземпляр. Другим вариантом заключается в размещении <code>jsp:setProperty</code> в теле элемента <code>jsp:useBean</code>, как это показано в другом примере:
<source lang="java5">
<jsp:useBean id="myName" ... >
  ...
  <jsp:setProperty name="myName" 
                   property="someProperty" ... />
</jsp:useBean>
</source>
При этом <code>jsp:setProperty</code> выполняется лишь в том случае, если был создан новый экземпляр объекта, а не тогда, когда находится уже существующий. Действие <code>jsp:setProperty</code> допускает применение следующих четырёх атрибутов:
* '''''name''''' — этот обязательный атрибут служит для задания <code>bean</code>, свойства которого будут устанавливаться. Элемент <code>jsp:useBean</code> должен предшествовать использованию элемента <code>jsp:setProperty</code>.
* '''''property''''' — этот обязательный атрибут устанавливает свойство, которое вы хотите установить. Однако существует частный случай: значение «'''*'''» означает что все параметры запроса, чьи имена совпадают с именами свойств <code>bean</code> будут переданы соответствующему методу установки свойств.
* '''''value''''' — этот необязательный атрибут устанавливает значение свойства. Строковые значения автоматически преобразуются в числовые, ''boolean'', ''Boolean'', ''byte'', ''Byte'', ''char'' и ''Character'' с использованием стандартного метода <code>valueOf</code> соответствующего класса. Например, значение <code>"true"</code> для свойства <code>boolean</code> или <code>Boolean</code> будет конвертировано при помощи метода <code>Boolean.valueOf</code>, а значение «42» для свойства <code>int</code> или <code>Integer</code> будет конвертировано при помощи метода <code>Integer.valueOf</code>. Вы не можете одновременно использовать атрибуты ''value'' и ''param'', но можете вообще их не использовать. Ознакомьтесь с описанием атрибута ''param'', которое представлено ниже.
* '''''param''''' — этот необязательный атрибут устанавливает параметр запроса, используемый для получения свойства. Если в текущем запросе этот параметр отсутствует, никаких действий не происходит: система не передаёт значение <code>null</code> методу устанавливающему свойства. Таким образом, допустимо использование в <code>bean</code> свойств по умолчанию, переопределяя их лишь в том случае если этого требуют параметры запроса. Например, следующий фрагмент означает следующее: «установить свойство <code>numberOfItems</code> в соответствии со значением параметра запроса <code>numItems</code>, а если такой параметр в запросе отсутствует — никакие действия не выполняются.»
<source lang="java5">
<jsp:setProperty name="orderBean"
                 property="numberOfItems"
                 param="numItems" />
</source>
Если вы не используете ни <code>value</code>, ни <code>param</code>, это приравнивается к тому, как если бы вы задали имя <code>param</code> совпадающее с именем <code>property</code>. Вы можете применить этот принцип автоматического использования свойств запроса, чьи имена совпадают с именами свойств и пойти далее, задав в качестве имени свойства «'''*'''» и опустив параметры ''value'' и ''param''. В этом случае сервер обработает допустимые свойства и параметры запроса, на предмет совпадения их с идентичными именами. Далее приведён пример в котором используется <code>bean</code> для создания таблицы простых чисел. Если существует параметр <code>numDigits</code> в данных запроса, он передаётся в свойство <code>bean</code> <code>numDigits</code>. Аналогично для <code>numPrimes</code>.
'''JspPrimes.jsp'''
<source lang="java5">
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<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>
</source>

==== Действие jsp:getProperty ====
Этот элемент определяет значение свойства <code>bean</code>, конвертирует его в строку и направляет в поток вывода. Для выполнения действия требуется задание двух атрибутов: имени <code>bean</code>, которое предварительно задаётся в действии <code>jsp:useBean</code>, и имя свойства, значение которого должно быть определено. Далее приведён пример использования этого действия:
<source lang="java5">
<jsp:useBean id="itemBean" ... />
...
<UL>
  <LI>Количество предметов: 
      <jsp:getProperty name="itemBean" property="numItems" />
  <LI>Цена за штуку:
      <jsp:getProperty name="itemBean" property="unitCost" />
</UL>
</source>

==== Действие jsp:include ====
Это действие позволяет вставлять содержимое файлов в генерируемую страницу. Синтаксис действия:
<source lang="java5">
<jsp:include page="относительный URL" flush="true" />
</source>
В отличие от директивы <code>include</code>, которая вставляет файл на этапе трансляции JSP страницы, это действие вставляет файл при запросе страницы. Это приводит к некоторой потере эффективности и исключает возможность наличия во вставляемом файле кода JSP, но зато даёт существенное преимущество в гибкости.

Пример вставки содержимого четырёх файлов в JSP-страницу:
<source lang="java5">
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<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>
</source>

==== Действие jsp:forward ====
Это действие позволяет вам передать запрос другой статической HTML странице, сервлету или JSP странице. В отличие от действия <code>jsp:include</code> обработка актуальной страницы заканчивается. Оно использует один атрибут <code>page</code>, который должен содержать относительный [[URL]] и на основании которого упорядочен объект <code>request</code>. К исходным параметрам запроса, передаваемым другой странице, с помощью действия <code>jsp:param</code> можно добавить и другие параметры. Значением атрибута <code>page</code> может быть как статическое значение, так и вычисляемое в процессе запроса, что и показано на следующих двух примерах:
<source lang="java5">
<jsp:forward page="/utils/errorReporter.jsp" />
<jsp:forward page="<%= какое-нибудьВыражениеНаJava %>" />
</source>
Также с помощью действия <code>jsp:forward</code> можно передать управление на другую страницу, но с условием, что перед вызовом этого действия ничего не было записано в выходящую буферную память (иначе будет вызвано исключение <code>IllegalStateException</code>).

==== Действие jsp:param и действие jsp:params ====
Это действие предоставляет информацию типа название/значение. Данное действие используется в основном вместе со знакомыми уже действиями <code>jsp:include</code> и <code>jsp:forward</code>. Кроме этого его можно использовать и вместе с действием <code>jsp:plugin</code>. В остальных случаях использование этого действия не имеет значения. Использование <code>jsp:param</code> с действиями <code>jsp:include</code> и <code>jsp:forward</code> передаёт новым страницам исходный объект <code>request</code>, который будет расширен на новые параметры. Если Вы зададите новые значения для уже существующих параметров, то именно новые значения будут иметь преимущество. С помощью действия <code>jsp:params</code> можно задать сразу несколько параметров

==== Действие jsp:plugin ====
Это действие позволяет вам вставить элемент '''OBJECT''' или '''EMBED''' (в зависимости от типа используемого браузера), необходимый для запуска аплетов, использующих plugin Java. Другими словами данное действие служит к генерированию HTML для вложения Java API в JSP страницу. Таким же образом можете вставлять URL для скачивания модулей для Java API от JavaSoft, который предоставляет возможность запускать аплеты внутри браузера. Форма записи данного действия выглядит следующим образом:
<source lang="java5">
<jsp:plugin
   type="bean|applet"
   code="файл класса"
   codebase="объект CodeBase"
   align="расположение"
   archive="список архивов"
   height="высота"
   hspace="горизонтальный простор"
   jreversion="версия"
   name="название компонента"
   vspace="вертикальный простор"
   width="ширина"
   nspluginurl="url"
   iepluginurl="url">
   <jsp:params>
      <jsp:param name="название1" value="значение1" />
      <jsp:param name="название2" value="значение2" />
      ...
      <jsp:param name="названиеN" value="значениеN" />
   </jsp:params>
   <jsp:fallback> </jsp:fallback>
</jsp:plugin>
</source>
Посмотрим на пример использования данного действия в коде аплета:
<source lang="java5">
<jsp:plugin type="applet" code="Blink.class" width=300 height=100>
   <jsp:params>
      <jsp:param name=lbl value="Да это вкуснее, чем просто нарезанный хлеб!" />
      <jsp:param name=speed value="4" />
   <jsp:params>
   <jsp:fallback>Ваш браузер по непонятным причинам не может запустить этот аплет </fallback>
</jsp:plugin>
</source>

== Пример JSP-страницы, использующей XML синтаксис ==
<source lang="java5">
<?xml version="1.0" encoding="UTF-8"?>
<jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" version="2.0">
    <jsp:directive.page contentType="application/xhtml+xml; charset=UTF-8"/>
    <jsp:output doctype-root-element="html" doctype-public="-//W3C//DTD XHTML 1.1//EN"
        doctype-system="http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" omit-xml-declaration="true"/>
    <html xmlns="http://www.w3.org/1999/xhtml">
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    <title>Заголовок страницы</title>
    </head>
    <body>
    <h1>Заголовок</h1>
    <p>Текст</p>
    <jsp:scriptlet>
    out.print(Calendar.getInstance(request.getLocale()).getFirstDayOfWeek() == Calendar.SUNDAY ?
        "В вашей стране неделя начинается с воскресенья" :
        "В вашей стране неделя не начинается с воскресенья");
    </jsp:scriptlet>
    </body>
    </html>
</jsp:root>
</source>

== См. также ==
* [[Сервлет]]
* [[Active Server Pages|ASP]]
* [[Java EE]]
* [[JavaServer Faces]]
* [[JSTL]]

== Ссылки ==
* [http://java.sun.com/products/jsp Официальная домашняя страница JSP]{{ref-en}}
* [http://www.javable.com/tutorials/j2ee/JSPIntro/ Технология JavaServer Pages]{{ref-ru}}
* [http://www.codenet.ru/webmast/java/jsp.php Введение в JSP]{{ref-ru}}
* [http://www.opennet.ru/docs/RUS/jsp1_2/ Перевод руководства по JavaServer Pages JSP 1.2]{{ref-ru}}
* [https://web.archive.org/web/20100613161848/http://www.apl.jhu.edu/~hall/java/Servlet-Tutorial/ A Tutorial on Java Servlets and Java Server Pages]{{ref-en}}
* [http://java.sun.com/products/jsp/syntax/1.2/syntaxref12.html JavaServer Pages (JSP) v1.2 Syntax Reference], [http://java.sun.com/products/jsp/tags/tags.html], [http://java.sun.com/products/jsp/syntax/2.0/syntaxref20.html v2.0]{{ref-en}}
* [http://java.sun.com/products/jsp/syntax/1.2/card12.pdf JAVASERVER PAGESª (JSPª) SYNTAX version 1.2], [http://java.sun.com/products/jsp/syntax/2.0/card20.pdf version 2.0]{{ref-en}}
* [https://web.archive.org/web/20130625024440/http://javasource.ru:5050/category/jstljsp.xhtml Подборка статей по JSP]{{ref-ru}}

{{Java}}

[[Категория:Веб-программирование]]
[[Категория:Java Enterprise Edition]]
[[Категория:Запросы на спецификацию Java]]