JSP.2.1.2 XML-Документ для Страницы JSP
JSP-страницы имеют эквивалент - XML-документ. XML-просмотр JSP-страницы создан для фазы трансляции (см. ниже).
JSP-страница может быть написана сразу как XML-документ. Начиная с версии JSP 1.2, XML-документ может быть направлен JSP-контейнеру для процесинга.
Нельзя смешивать стандартный синтаксис и XML-синтаксис в одном файле-источнике. Однако JSP-страница любого синтаксиса может включать JSP-страницу любого синтаксиса через директиву.
JSP.2.1.3 Фазы Трансляции и Выполнения
JSP-контейнер обслуживает две фазы существования JSP-страницы. В фазе трансляции контейнер определяет класс реализации JSP-страницы, соответствующий JSP-странице. В фазе выполнения контейнер обслуживает один или более экземпляров этого класса в ответ на запрос и другие события.
Во время фазы трансляции контейнер локализует или создаёт класс реализации JSP-страницы, соответствующий данной JSP-странице. Этот процесс определяется семантикой JSP-страницы. Контейнер интерпретирует имеющиеся на этой странице стандартные директивы и акции и специальные акции, ссылающиеся на библиотеки тэгов. Библиотека тэгов может по выбору представлять метод проверки корректности использования на JSP-странице данной библиотеки.
JSP-контейнер гибко работает с деталями класса реализации JSP-страницы, что может использоваться для адресации вопросов quality-of-service/качества-сервиса.
В фазе выполнения
JSP-контейнер направляет события объекту реализации JSP-страницы. Контейнер отвечает за инициацию объектов request и response и вызов подходящего объекта реализации JSP-страницы.
По окончании процессинга, объект response получается контейнером для соединения с клиентом.
Детали соглашения/контракта между классом реализации JSP-страницы и JSP-контейнером описаны в .
Трансляция JSP-страницы-источника в класс её реализации может произойти в любой момент между начальной публикацией JSP-страницы в JSP-контейнер и получением и процессингом запроса клиента для целевой JSP-страницы. В Разделе описывается выполнение фазы трансляции перед публикацией.
JSP.2.1.4 События на Страницах JSP
JSP-страница может отмечать обработку некоторых событий. В JSP 1.2 только события init и destroy могут быть описаны в JSP-странице.
Когда первый запрос направляется JSP-странице, метод jspInit(), если он имеется, будет вызван для подготовки страницы. Аналогично, JSP-контейнер может вызывать метод JSP jspDestroy()
для переделки ресурсов, используемых JSP-страницей, в любой момент, когда запрос не обслуживается. Это такой же жизненный цикл, что и у сервлетов.
JSP.2.1.5 Компилирование Страниц JSP
JSP-страница может быть откомпилирована в свой класс реализации, плюс информация публикации в процессе создания (JSP-страница может также компилироваться в процессе публикации).
Таким способом утилиты авторизации JSP-страниц и библиотеки тэгов JSP могут использоваться для создания сервлетов. Преимущества этого подхода таковы:
исключение задержки при старте, появляющейся из-за того, что контейнер обязан транслировать JSP-страницу после получения первого запроса;
сокращение времени, необходимого для работы JSP-контейнера, так как компилятор Java не нужен.
Компиляция JSP-страницы в контексте web-приложения предоставляет разрешение спецификаций относительных URL в директивы include (и в другом месте), ссылок на taglib и акции времени трансляции, используемых в специальных акциях.
JSP-страница может также компилироваться во время публикации.
JSP.2.1.5.1 Упаковка Страницы JSP
Когда класс реализации JSP-страницы зависит от поддержки классов (в дополнение к классам JSP 1.2 и Servlet 2.3), классы поддержки включаются в упакованный WAR-файл (как определено в спецификации Servlet 2.3) для обеспечения переносимости по JSP-контейнерам.
В Приложении есть два примера упаковки JSP-страниц в WAR'ы:
JSP-страница, направляемая в своей исходной форме (вероятно, это самый распространённый случай).
JSP-страница, оттранслированная в класс реализации плюс информация для публикации.
В информации для публикации указаны необходимые поддерживающие классы и отображение между путём оригинального URL в JSP-страницу и URL для класса реализации этой JSP-страницы.
JSP.2.1.6 Отладка Страниц JSP
Раньше утилиты отладки не имели стандартного формата для передачи информации отображения исходного кода, позволяющей использовать отладчик одного производителя с JSP-контейнером другого. Спецификация с поддержкой отладки, преодолевшая эти ограничения, разрабатывается как JSR-045 процесса JCP 2.0 под названием “Debugging Support for Non-Java Languages/Поддержка Отладки для Не-Java-Языков”.
Детали можно найти по адресу
JSP.2.1.7 Соглашение по Именованию для Файлов JSP
JSP-страница упаковывается в один или более файлов, часто - как web-приложение, и направляется утилите типа JSP-контейнера, J2EE-контейнера или IDE. Полная JSP-страница может содержаться в одном файле. В других случаях основной файл содержит другие файлы, которые содержать полные JSP-страницы или включаемые фрагменты.
Утилиты обычно требуют отделения файлов JSP-страницы от других файлов. В некоторых случаях утилиты также требуют отделения файлов верхнего уровня/top JSP от включаемых фрагментов. Например, если фрагмент может не быть правильной JSP-страницей и может не компилироваться соответствующим образом.
Определение типа файла также часто практикуется на уровне документации и обслуживания, как должно быть уже известно тем, кто работает с соглашениями “.c” и “.h” языка C.
Спецификация Servlet 2.3 использует расширение “.jsp” для обозначения JSP-страницы, но не дифференцирует основные JSP-файлы и включаемые фрагменты.
Мы рекомендуем (но не обязываем), чтобы:
“.jsp”-файлы соответствовали JSP-файлам верхнего уровня, содержащимся в JSP-странице;
включаемые фрагменты не использовали расширение “.jsp”. Любые другие расширения допустимы, хотя “.jspf” и “.jsf” кажутся осмысленными и предлагаются в качестве варианта.
JSP.2.1 Что такое Страница JSP?
JSP-страница это текстовый документ, который описывает, как создавать объект response
из объекта request для данного протокола. Процессинг JSP-страницы может включать создание и/или использование других объектов.
JSP-страница определяет класс реализации JSP-страницы который реализует семантику JSP-страницы. Этот класс является подклассом Servlet'а (см. ). Во время запроса, запрос, предназначенный для JSP-страницы, направляется объекту реализации JSP-страницы для обработки/процесинга.
HTTP является протоколом по умолчанию для запросов и ответов. Дополнительные протоколы запроса/ответа могут поддерживаться JSP-контейнерами (см. ниже). Объекты request и response по умолчанию имеют тип HttpServletRequest и HttpServletResponse, соответственно.
JSP.2.2.1 Специфицирование Относительных URL
Элементы могут использовать спецификации относительных URL, называемые “URI-пути” в спецификации Servlet 2.3. Эти пути описаны в спецификации RFC 2396. Мы имеем в виду часть path данной спецификации, а не части scheme или authority.
Некоторые примеры:
Путь относительно контекста это путь, начинающийся со знака “/”. Он интерпретируется относительно приложения, к которому принадлежит JSP-страница, то есть говорится, что её объект ServletContext предоставляет базовый контекстный URL.
Путь относительно страницы это путь, не начинающийся со знака “/”. Он интерпретируется как относительный к текущей JSP-странице или текущему JSP-файлу, в зависимости от того, где путь используется:
для директивы include (); когда путь используется в атрибуте файла - интерпретация относительно JSP-файла;
для акции jsp:include (), когда путь используется атрибуте страницы - интерпретация относительно JSP-страницы.
В обоих случаях текущая страница (или файл) обозначается некоторой частью пути, начинающейся с “/”, который (путь) затем модифицируется новой спецификацией, производящей путь с начальным “/”.
Новый путь интерпретируется через объект ServletContext. См. точную информацию об этой интерпретации в .
Спецификация JSP универсально интерпретирует пути в контексте web-сервера, где JSP-страница публикуется. Спецификация проходит через отображающую трансляцию. Семантика, обрисованная здесь, применяется к фазе времени трансляции, а не к фазе времени запроса.
JSP.2.2 Web-Приложения
Приложение web это коллекция ресурсов, которые доступны по указанным URL.
Web-приложение состоит из следующих компонентов:
Среда(ы) Java, запущенная на сервере (необходима);
JSP-страница(ы), обрабатывающие запросы и генерирующие динамическое содержимое;
Сервлет(ы), обрабатывающие запросы и генерирующие динамическое содержимое Web-Приложения;
Серверные/Server-side компоненты JavaBeans, инкапсулирующие поведение и статус;
Статические страницы HTML, DHTML, XHTML, XML и аналогичные;
Файлы ресурсов, используемых Java-классами;
Клиентские/Client-side Java-Аплеты, компоненты JavaBeans и файлы Java-классов;
Среда(ы) Java (загружаемая через Plugin и Java Web Start), запущенная на клиенте(клиентах).
Web-приложения описаны более детально в спецификации Servlet 2.3. Web-приложение содержит дескриптор публикации web.xml, содержащий информация о JSP-страницах, сервлетах и других ресурсах, используемых в этом web-приложении. Дескриптор публикации детально описан в спецификации Servlet 2.3.
JSP 1.2 требует, чтобы эти ресурсы были неявно/косвенно ассоциированы с, и доступны через, уникальный экземпляр ServletContext, доступный как неявный объект приложения ().
Приложение, которому принадлежит JSP-страница, отражается в объекте application и влияет на семантику следующих элементов:
Директива include ().
Элемент акции jsp:include ().
Акция jsp:forward ().
JSP 1.2 поддерживает переносимую упаковку и публикацию/deployment web-приложений через спецификацию Servlet 2.3. Спецификация JavaServer Pages наследует от спецификации Servlet концепцию приложений, ServletContext'ы, Sessions/Сессии, Requests/Запросы и Responses/Ответы.
JSP.2.3.1 Элементы и Шаблонные Данные
JSP-страница содержит элементы и шаблонные данные.
Элемент является экземпляром типа элемента, известного JSP-контейнеру.
Шаблонные данные это то, о чём JSP-танслятор ничего не знает.
Тип элемента описывает его синтаксис и семантику. Если элемент имеет атрибуты, тип описывает имена, верные типы атрибутов и их интерпретацию. Если элемент определяет объекты, семантика включает эти определяемые объекты и их типы.
JSP.2.3.2 Синтаксис Элемента
Имеются элементы трёх типов: директивы, элементы скриптинга и акции.
Директивы
Директивы
предоставляют глобальную информацию, которая концептуально верна, независимо от специфики запроса, полученного JSP-страницей. Директивы предоставляют информацию для фазы трансляции.
Синтаксис элемента-директивы
<%@ директива...%>
Акции
Акции предоставляют информацию для фазы обработки запроса. Интерпретация
акции может, и часто так и бывает, зависеть от специфики запроса, полученного JSP-страницей. Акции могут быть стандартными, то есть определёнными этой спецификацией, или custom/специальными, то есть предоставленными через посредство механизма развёртывания переносимых тэгов.
Элементы action следуют синтаксису XML-элемента: они имеют начальный тэг, включающий имя элемента, и могут иметь атрибуты, необязательное тело/body и соответствующий конечный тэг, или они могут быть пустыми тэгами, возможно, с атрибутами:
<mytag attr1=”значение атрибута”...>body</mytag>
и
<mytag attr1=”значение атрибута”.../>
<mytag attr1=”значение атрибута” ...></mytag>
Элемент имеет тип элемента, описывающий имя его тэга, верные атрибуты и их семантику.
Мы обращаемся к типу по имени его тэга.
JSP-тэги чувствительны к регистру, как в XML и XHTML.
Акция может создавать объекты и делать их доступными элементам скриптинга через
специфические для скриптинга переменные.
Элементы Скриптинга
Элементы Скриптинга являются связкой между шаблонным текстом и акциями.
Есть три типа элементов скриптинга: declarations\объявления, scriptlets\скриптлеты и expressions\выражения.
Объявления имеют синтаксис
<%! ... %>
скриптлеты <% ... %>
выражения
<%= ... %>
JSP.2.3.3 Начальный и Конечный Тэги
Элементы, имеющие разные начальный и конечный тэги (при наличии тела), обязаны иметь начало и конец в одном файле. Стартовый тэг не может быть в одном файле, когда конечный тэг находится в другом файле.
То же самое правило применяется к элементам с альтернативным синтаксисом. Например, скриптлет имеет синтаксис <% скриптлет %>. Открывающий <% и закрывающий %> символы обязаны находиться в одном и том же физическом файле.
Язык скриптинга может также вводить ограничения на размещение начальных и конечных тэгов для специфических конструкций скриптинга. Например, в
демонстрируется, как блоки языка Java не могут разделять начальный и конечный тэг; см. детали в .
JSP.2.3.4 Пустые Элементы
Следуя спецификации XML, элемент, описанный с использованием пустого тэга, не отличается от элемента. использующего начальный тэг, пустое тело и конечный тэг.
Вот примеры пустых тэгов:
<x:foo></x:foo>
<x:foo />
<x:foo/>
<x:foo><%-- любой комментарий --%></x:foo>
Далее - примеры непустых тэгов:
<foo> </foo>
<foo><%= выражение %></foo>
<foo><% скриптлет %></foo>
<foo><bar/></foo>
<foo><!-- комментарий --></foo>
JSP.2.3.5 Значения Атрибутов
Следуя спецификации XML, атрибуты всегда заключаются в кавычки. Одинарные или двойные кавычки могут использоваться для уменьшения необходимости ввода кавычек мнемониками; соглашения по кавычкам описаны в . Есть два типа значений атрибутов: литералы и выражения времени запроса (), но правила применения кавычек - одинаковы.
JSP.2.3.6 Правильные Имена Акций и Атрибутов
Имена акций обязаны следовать соглашению XML (т.е. обязаны быть NMTOKEN, как указано в спецификации XML 1.0). Имена атрибутов обязаны следовать соглашениям, описанным в спецификации JavaBeans.
Имена атрибутов, начинающиеся с jsp, _jsp, java или sun зарезервированы данной спецификацией.
JSP.2.3.7 Пробелы
В HTML и XML пробел обычно не является значащим, но есть исключения. Например, файл XML может начинаться символами <?xml, и, если это так, ведущих пробельных символов не должно быть.
Данная спецификация следует поведению пробелов, определённому в спецификации XML.
Пробел в теле текста документа не является значащим, но сохраняется.
Далее идут два фрагмента JSP с ассоциированным выводом.
Обратите внимание, что директивы не генерируют никаких данных и применяются глобально к JSP-странице.
Таблица 2.1: Пример 1 - Ввод
| 1 | <?xml version=”1.0” ?> |
| 2 | <%@ page buffer=”8kb” %> |
| 3 | Здесь - остальная часть документа. |
Результат:
Таблица 2.2: Пример 1 - Вывод
| 1 | <?xml version=”1.0” ?> |
| 2 | |
| 3 | Здесь - остальная часть документа. |
Следующие две таблицы - другой пример ввода и вывода:
Таблица 2.3: Пример 2 - Ввод
| 1 | <% response.setContentType(“....”); |
| 2 | что-нибудь... %><?xml version=”1.0” ?> |
| 3 | <%@ page buffer=”8kb” %> |
| 4 | Здесь - остальная часть документа. |
Результат:
Таблица 2.4: Пример 2 - Вывод
| 1 | <?xml version=”1.0” ?> |
| 2 | |
| 4 | Здесь - остальная часть документа. |
JSP.2.3 Синтаксические Элементы Страницы JSP
В этом разделе описаны базовые синтаксические правила JSP-страниц.
JSP.2.4.1 Ошибки Процесса Времени Трансляции
Трансляция JSP-страницы-источника в соответствующий класс реализации JSP-страницы JSP-контейнером может производиться в любой момент между начальной публикацией JSP-страницы в JSP-контейнер и получением и обработкой запроса клиентом целевой JSP-страницы.
Если трансляция возникает до получения клиентского запроса целевой JSP-страницы, обработка ошибок и уведомление зависят от реализации и не рассматриваются в данной спецификации. Фатальные ошибки трансляции должны в результате приводить к невозможности выполнения последующих клиентских запросов на трансляцию целевой страницы с соответствующей спецификацией ошибки: для протоколов HTTP будет возвращаться код ошибки 500 (Server Error/Ошибка Сервера).
JSP.2.4.2 Ошибки Процесса Времени Запроса
В процессе обработки запросов клиентов ошибки могут возникать в теле класса реализации JSP-страницы или в каком-либо другом коде (языка Java или других языков программирования реализации), вызываемом из тела класса реализации JSP-страницы.
Возникающие ошибки этапа прогона обрабатываются в реализации страницы, используя механизм исключений языка программирования Java для сообщения вызывающему(-им) о нарушениях.
Обратите внимание, что это не зависит от языка программирования. Данная спецификация требует, чтобы о необработанных ошибках, возникающих в среде языка скриптинга, используемого реализацией JSP-контейнера, сообщалось классу реализации JSP-страницы через механизм исключений языка Java.
Эти исключения могут отлавливаться и обрабатываться (как необходимо) в теле класса реализации JSP-страницы. Любые неотловленные исключения, вызываемые в теле класса реализации JSP-страницы, приводят к перенаправлению клиентского запроса и неотловленного исключения по URL errorPage, специфицированному этой JSP-страницей (или выполнением действий по умолчанию, если ничего не специфицировано).
Нарушающее java.lang.Throwable, описывающее появляющуюся ошибку, хранится в экземпляре javax.ServletRequest клиентского запроса, использующего метод setAttribute(), использующего имя “javax.servlet.jsp.jspException”.
Имена, начинающиеся с префиксов “java” и “javax”, зарезервированы различными спецификациями платформы Java. Префикс “javax.servlet”
зарезервирован и используется спецификациями Servlet и JSP.
Если атрибут errorPage директивы страницы именует URL, который ссылается на другую JSP и та JSP сигнализирует, что на странице имеется ошибка (установкой атрибута isErrorPage директивы страницы в true), тогда неявная переменная языка программирования “exception” этой страницы инициализируется ссылкой Throwable-нарушителя.
JSP.2.4 Обработка Ошибок
Ошибки могут появляться на этапах трансляции или запроса. В этом разделе описывается, как ошибки обрабатываются соответствующей реализацией.
JSP.2.5.1 Генерирование Комментариев при Выводе Клиенту
Для генерации комментариев, появляющихся в потоке вывода response к запрашивающему клиенту, используется следующий синтаксис комментариев HTML и XML:
<!-- комментарии ... -->
Такие комментарии рассматриваются JSP-контейнером как неизменяемый шаблонный текст. Если генерируемый комментарий должен содержать динамические данные, это может быть сделано посредством такого синтаксиса:
<!-- комментарии <%= выражение %> ещё комментарии ... -->
JSP.2.5.2 Комментарии JSP
JSP-комментарий имеет форму:
<%-- что-либо, кроме закрывающих символов --%> ... --%>
Содержимое тела комментария полностью игнорируется. Комментарии используются для документирования, а также для “закомментирования” некоторой части JSP-страницы.
Обратите внимание, что JSP-комментарии не вкладываются.
Альтернативным способом размещения "комментария" на JSP-странице является использование механизма комментария языка скриптинга. Например:
<% /** это комментарий ... **/ %>
JSP.2.5 Комментарии
В JSP-странице есть два типа комментариев:
комментарии к самой JSP-странице, документирующие действия страницы, и комментарии, предназначенные для вывода в генерируемом документе, направляемом клиенту.
JSP.2.6 Соглашения по Кавычкам и Escape-Последовательностям
В JSP-страницах применяются следующие соглашения по кавычкам:
Кавычки в Элементах Скриптинга
Литерал %> закавычивается %\>
Кавычки в Шаблонном Тексте
Литерал <% закавычивается <\%
Закавычивание Атрибутов
Закавычивание выполняется независимо от того, является значение атрибута литералом или выражением атрибута этапа запроса. Закавычивание может использоваться в значениях атрибутов независимо от того, ограничены они одинарными или двойными кавычками. Это выполняется только так, как описано ниже:
‘ записывается \’. Это необходимо делать внутри значения атрибута, ограниченного одинарными кавычками.
“ записывается \”. Это необходимо делать внутри значения атрибута, ограниченного двойными кавычками.
\ записывается \\
%> записывается %\>
<% записывается <\%
Мнемоники ' и " могут использоваться для ввода одинарных и двойных кавычек..
Примеры
В следующей строке показаны неправильные значения атрибутов:
<mytags:tag value="<%= "hi!" %>" />
В следующей строке дан верный скриптлет, но с, возможно, неожиданным результатом. Результат будет “Joe said %\>”, а не “Joe said %>”:
<%= "Joe said %\\>" %>
В следующих строках - правильное закавычивание:
<%= "Joe said %/>" %>
<%= "Joe said %\>" %>
<% String joes_statement = "hi!"; %>
<%= "Joe said \"" + joes_statement + "\"." %>
<x:tag value='<%="Joe said \\"" + joes_statement + "\\"."%>'/>
<x:tag value='<%= "hi!" %>' />
<x:tag value="<%= \"hi!\" %>" />
<x:tag value='<%= \"name\" %>' />
<x:tag value="<%= \"Joe said 'hello'\" %>"/>
<x:tag value="<%= \"Joe said \\\"hello\\\" \" %>"/>
<x:tag value="end expression %\>"/>
<% String s="abc"; %>
<x:tag value="<%= s + \"def\" + \"jkl\" + 'm' + \'n\' %>" />
<x:tag value='<%= s + \"def\" + "jkl" + \'m\' + \'n\' %>' />
Представление XML
Соглашения по кавычкам отличаются от соглашений XML. См. .
JSP.2.7 Общая Семантика Страницы JSP
Класс реализации JSP-страницыопределяет отображение метода _jspService()
из объекта request в объект response. Некоторые детали этой трансформации специфичны для используемого языка скриптинга (см. ). Некоторые детали не зависят от языка и описаны в данной главе.
Содержимое JSP-страницы большей частью описывает данные, которые записываются в поток вывода ответа. (JSP-контейнер обычно посылает эти данные обратно клиенту.) Это описание базируется на объекте JspWriter, который выводится через неявный объект out (см. , “Неявные Объекты).
Его значение варьируется:
Сначала out - это новый объект JspWriter. Этот объект может отличаться от объекта stream, возвращаемого от response.getWriter(), и может рассматриваться как вставляемый позднее в последнем, чтобы реализовать буферизацию (см. , “Директива page”). Это - начальный объект out. Авторам JSP-страниц запрещено записывать непосредственно в PrintWriter или OutputStream, ассоциированные с ServletResponse.
JSP-контейнер не должен вызывать response.getWriter() до тех пор, пока первая часть содержимого не будет переслана клиенту. Здесь поднимаются вопросы использования JSP, включая использование JSP как языка для ‘склейки’ акций, дающих бинарный контекст, или надёжного перенаправления сервлету, или динамического изменения типа содержимого ответа до генерации содержимого. См. .
В теле некоторых акций out может быть временно переназначен другому (вложенному) экземпляру объекта JspWriter. То, какой это случай, зависит от деталей семантики акции. Обычно содержимое этих временных потоков присоединяется к потоку, на который out ссылался перед этим, и out последовательно переназначается для того, чтобы ссылаться на предыдущий (внешний) поток. Такие вложенные потоки всегда буферизуются и требуют явной очистки/flushing, чтобы выгрузить вкладывающие потоки и их содержимое.
Если начальный out-объект JspWriter буферизуется, тогда, в зависимости от значения атрибута autoFlush директивы page, содержимое этого буфера будет либо автоматически очищаться перед потоком вывода ServletResponse, чтобы избежать переполнения, либо должно вызываться исключение, чтобы сигнализировать о переполнении буфера. Если начальный out-объект
JspWriter не буферизуется, тогда содержимое, записанное в него, будет передано прямо в поток вывода ServletResponse.
JSP-страница может также описывать, что должно происходить, когда возникают некоторые конкретные события. В JSP 1.2 могут быть описаны только события инициализации и ликвидации страницы. Эти события описаны с использованием “имён хорошо известных методов” в элементах обявления/declaration. (См. ).
JSP.2.8.1 Объекты и Переменные
Объект может быть сделан доступным для кода в элементах скриптинга через переменную языка скриптинга.
Элемент может определять переменные скриптинга, которые будут содержать, в процессе времени запроса, ссылку на объект, определённый этим элементом, хотя могут существовать и другие ссылки, в зависимости от области видимости объекта.
Тип элемента указывает имя и тип таких переменных, хотя в деталях имя переменной может зависеть от Языка Скриптинга.
Язык скриптинга может также влиять на то, как происходит доступ к различным свойствам объекта. Например, в спецификации JavaBeans доступ к свойствам осуществляется через методы
getter
и setter, в то время как эти свойства доступны напрямую как переменные в языке JavaScript™.
Точные правила видимости переменных зависят от языка скриптинга. В
определены правила для случая, когда атрибут language директивы page установлен в “java”.
JSP.2.8.2 Объекты и Область Видимости
JSP-страница может создавать и/или получать доступ к Java-объектам при обработке запроса. Спецификация JSP указывает, что некоторые объекты создаются неявно, возможно, как результат директивы (см. , "Неявные Объекты"). Другие объекты создаются явно через акции или непосредственно путём использования кода скрипта. Созданные объекты имеют атрибут scope, определяющий, где находится ссылка на объект и когда
эта ссылка удаляется.
Созданные объекты могут также непосредственно видимы элементам скриптинга через переменные уровня скриптинга (см. , "Неявные Объекты"). Каждая акция и объявление определяют, как часть своей семантики, какой объект они создают, с каким атрибутом scope и доступны ли они элементам скриптинга.
Объекты создаются внутри экземпляра JSP-страницы, которая отвечает объекту request.
Имеется несколько областей видимости:
page - Объекты с областью видимости
page доступны только в пределах страницы, на которой они создаются. Все ссылки на такие объекты должны быть разорваны после того, как response/ответ отослан обратно клиенту из JSP-страницы или запрос направляется куда-либо ещё. Ссылки на объекты с областью видимости page хранятся в объекте pageContext.
request - Объекты с областью видимости
request доступны со страниц, обрабатывающих этот же самый запрос там, где они были созданы. Ссылки на такой объект должны быть разорваны после обработки запроса. Конкретнее, если запрос направляется ресурсу на том же самом этапе прогона/runtime, объект остаётся доступным. Ссылки на объекты с областью видимости request
хранятся в объекте request.
session - Объекты с областью видимости
session доступны для страниц, обрабатывающих запросы, находящихся в той же сессии, что и страница, на которой они были созданы. Нельзя определять объект с областью видимости session из страницы, которая не находится в данной сессии (см. , "Директива page"). Все ссылки на такой объект должны быть разорваны после того, как ассоциированная сессия закончилась. Ссылки на объекты с областью видимости session хранятся в объекте session, ассоциированном с активацией страницы.
application - Объекты с областью видимости application доступны для страниц, обрабатывающих запросы, находящихся в в том же приложении, что и страница, на которой они были созданы. Объекты с областью видимости application могут быть определены (и быть доступными) из страниц, не находящихся в данной сессии. Ссылки на объекты с областью видимости application хранятся в объекте application, ассоциированном с активацией страницы. Объект application является контекстом сервлета, получаемым из объекта конфигурации сервлета. Все ссылки на этот объект должны быть разорваны, когда рабочая среда/runtime environment запрашивает ServletContext.
Имя/name должно ссылаться на уникальный объект из всех точек в ходе выполнения, то есть все области видимости должны в действительности вести себя как единое пространство имён. Реализация JSP-контейнера может или может не форсировать это правило явно по соображениям производительности.
JSP.2.8.3 Неявные/Implicit Объекты
Авторы JSP-страниц имеют доступ к определённым неявным (неявно создаваемым) объектам, которые всегда доступны для использования в скриптлетах и выражениях через переменные скриптинга, которые объявляются неявно в начале страницы. Все языки скриптинга должны предоставлять доступ к этим объектам.
Неявные объекты доступны обработчикам тэгов через объект pageContext (см. ниже).
Каждый неявный объект имеет тип класса или интерфейса, определённый в основной технологии Java или в пакете Java Servlet API, как показано в Таблице JSP. 2-1.
Таблица JSP.2-1 Неявные Объекты, Доступные в JSP-страницах
| request | подтип, зависящий от протокола: javax.servlet.ServletRequest, например: |
Запрос, включающий вызов сервиса/службы. Область видимости: request. |
| response | подтип, зависящий от протокола: javax.servlet.ServletResponse, например: |
Ответ на запрос. Область видимости: page. |
| pageContext | javax.servlet.jsp.PageContext | Контекст страницы для данной JSP-страницы. Область видимости: page. |
| session | javax.servlet.http.HttpSession | Объект session, созданный для запрашивающего клиента (если клиент имеется). Эта переменная верна только для протоколов Http. Область видимости: session. |
| application | javax.servlet.ServletContext | Контекст сервлета, полученный из объекта конфигурации сервлета (как при вызове getServletConfig().getContext()) Область видимости: application. |
| out | javax.servlet.jsp.JspWriter | Объект, записывающий в поток вывода. Область видимости: page. |
| config | javax.servlet.ServletConfig | ServletConfig для данной JSP-страницы. Область видимости: page. |
| page | java.lang.Object | Экземпляр класса реализации данной страницы, обрабатывающий текущий запрос. Область видимости: page. |
a. Если язык скриптинга - “java”, тогда “page” является синонимом для “this” в теле/body страницы.
Кроме того, может быть получен доступ к неявному объекту exception на странице ошибок, как указано в .
JSP.2.8.4 Объект pageContext
PageContext это объект, предоставляющий контекст для хранения ссылок на объекты, используемые страницей. Он инкапсулирует зависящие от реализации свойства и предоставляет нужные методы. Класс реализации JSP-страницы может использовать PageContext для прогона в неизменённом виде в любом подходящем JSP-контейнере, одновременно используя преимущества специфичных для реализации улучшений типа высокопроизводительного JspWriters. См. детали в .
Таблица JSP.2-2 Неявные Объекты, Доступные на Страницах Ошибок\Error Pages
| exception | java.lang.Throwable | Неотловленный Throwable, приводящий к вызову страницы информации об ошибках. Область видимости: page. |
Имена объектов с префиксами jsp, _jsp, jspx и _jspx, в любой комбинации нижнего и верхнего регистров, зарезервированы данной спецификацией JSP. См. в Разделе некоторые ненормативные соглашения для введения новых неявных объектов.
JSP.2.8 Объекты
JSP-страница может создавать и модифицировать серверные объекты/server-side и получать к ним доступ.
Объекты могут быть сделаны видимыми для акций и элементов скриптинга. Объект имеет scope\область видимости, которая описывает, какие экземпляры могут получать доступ к объекту.
Акции могут получать доступ к объекту, используя имя в объекте PageContext. Объект, видимый через переменную скриптинга, имеет область видимости в пределах страницы.
Элементы скриптинга могут получать доступ к объектам непосредственно через
переменную скриптинга.
Некоторые неявные объекты видны через переменные скриптинга на любой JSP-странице.
JSP.2.9 Семантика Шаблонного Текста
Семантика шаблонного (или неинтерпретированного) Текста очень проста: шаблонный текст передаётся текущему out\выводящему неявному объекту JspWriter после применения замен , "Соглашения по Кавычкам и Escape-Последовательностям".
JSP.2.10.1 Директива page
Директива page определяет количество свойств страницы и сообщает о них JSP-контейнеру.
Трансляционный модуль (JSP файл-источник и любые файлы, включённые директивой include) может содержать более одного экземпляра директивы page, все атрибуты будут применяться ко всему трансляционному модулю (т.е. директивы page не зависят от позиции). Однако должно быть только одно вхождение любого атрибута/значения, определённого этой директивой, в данном трансляционном модуле, исключая атрибут “import”; многократные использования этого атрибута накапливаются (с семантикой объединения упорядоченного набора/ordered set union). Другие такие множественные (пере)определения атрибута/значения приводят к фатальной ошибке трансляции. Пространство имён attribute/value зарезервировано для использования данной и последующими спецификациями JSP.
Нераспознаваемые атрибуты или значения приводят к фатальным ошибкам трансляции.
Примеры
Следующая директива предоставляет некоторую видимую пользователем информацию на данной JSP-странице:
<%@ page info=”my latest JSP Example” %>
Следующая директива запрашивает отсутствие буферизации, указывает, что страница является "безопасным потоком"/thread safe и предоставляет страницу для сообщений об ошибке:
<%@ page buffer=”none” isThreadSafe=”yes” errorPage=”/oops.jsp” %>
Следующая директива указывает, что язык скриптинга базируется на Java, что типы, объявленные в пакете com.myco, непосредственно доступны коду скриптинга и что должна использоваться буферизация в 16KB:
<%@ page language=”java” import=”com.myco.*” buffer=”16kb” %>
Синтаксис
<%@ page
список_атрибутов_директивы_page %>
список_атрибутов_директивы_page ::= { language=”scriptingLanguage\языкСкриптинга”}
{ extends=”className”}
{ import=”importList”}
{ session=”true|false” }
{ buffer=”none|sizekb” }
{ autoFlush=”true|false” }
{ isThreadSafe=”true|false” }
{ info=”info_text” }
{ errorPage=”error_url” }
{ isErrorPage=”true|false” }
{ contentType=”ctinfo” }
{ pageEncoding=”peinfo”
Далее дана детальная информация об атрибутах:
Таблица JSP.2-1
| language | Определяет язык скриптинга, используемый в скриптлетах, скриптлетах выражений и объявлениях внутри тела трансляционного модуля (JSP-страница любые файлы, включённые с использованием последующей директивы include). В JSP 1.2 единственным определённым и необходимым для данного атрибута значением языка скриптинга является “java”. Данная спецификация описывает семантику только для скриптов со значением атрибута языка “java”. Если “java” является значением языка скриптинга, фрагменты исходного кода Java Programming Language, используемые внутри данного трансляционного модуля, должны соответствовать спецификации Java Programming Language Specification так, как описано в . Все языки скриптинга обязаны предоставлять неявные объекты, которые автор JSP-страниц может использовать в объявлениях, скриптлетах и выражениях. Специфические объекты, которые могут использоваться, определены в , “Неявные Объекты.” Все языки скриптинга обязаны поддерживать Java Runtime Environment (JRE)/Среду Java. Все языки скриптинга обязаны представлять объектную модель технологии Java окружению скрипта, особенно неявные переменные, свойства компонентов JavaBeans и публичные методы. Будущие версии спецификации JSP могут определять дополнительные значения атрибута language, и все такие значения резервируются. Для директивы с атрибутом language не-”java” будет фатальной ошибкой появление после первого вычисленного элемента скриптинга. |
| extends | Значением является полное квалифицированное имя класса языка программирования Java, которое именует суперкласс класса, к которому JSP-страница трансформируется (см. ). Этот атрибут не должен использоваться без тщательного учёта ограничения им способности JSP-контейнера предоставлять специализированные суперклассы, которые могут улучшить качество службы представления. См. в Разделе альтернативный способ ввода объектов на JSP-страницу, не имеющий такого недостатка. |
| import | Атрибут import описывает типы, которые доступны среде скриптинга. Значение - такое же, как для объявления import в языке программирования Java, т.е. список (разделённых запятыми) полных квалифицированных имён типов языка программирования Java, обозначающих этот тип, или имя пакета с последующей строкой “.*”, обозначающей все публичные типы, объявленные в этом пакете. Список import должен будет импортироваться транслируемой реализацией транслируемой JSP-страницы и будет, таким образом, доступен среде скриптинга. По умолчанию список импорта - java.lang.*, javax.servlet.*, javax.servlet.jsp.* и javax.servlet.http.*. В настоящее время это значение определено только тогда, когда значением директивы language является “java”. |
| session | Означает, что данная страница требует участия в (http) сессии. Если “true”, тогда неявная переменная языка скрипта с названием “session” типа javax.servlet.http.HttpSession ссылается на текущую/новую сессию для этой страницы. Если “false” - тогда эта страница не участвует в сессии; неявная переменная “session” недоступна, и любая ссылка на неё в теле JSP-страницы является недопустимой и приводит к фатальной ошибке трансляции. По умолчанию “true”. |
| buffer | Специфицирует модель буферизации для начального “out” JspWriter для обработки содержимого вывода с этой страницы. Если “none”, тогда буферизации нет и весь вывод записывается непосредственно в ServletResponse PrintWriter. Размер может специфицироваться только в килобайтах, и суффикс “kb” является мандатным (обязательным). Если размер буфера специфицирован, тогда вывод буферизуется с размером буфера не меньше специфицированного. В зависимости от значения атрибута “autoFlush”, содержимое этого буфера автоматически очищается, или возникает исключение при появлении переполнения. По умолчанию буферизуется с размером буфера реализации не менее 8kb. |
| autoFlush | Специфицирует, должен ли буферизованный вывод очищаться автоматически (значение “true”), когда буфер заполнен, или должно вызываться исключение/exception (значение “false”), означающее переполнение буфера. По умолчанию “true”. Примечание: не допускается установка autoFlush в “false”, если “buffer=none”. |
| isThreadSafe | Обозначает уровень потока, безопасно выполняемого на странице. Если “false” - тогда JSP-контейнер должен выполнять диспетчеризацию множественных внешних запросов клиентов, по одному за раз в порядке их поступления, реализации страницы для процессинга. Если “true”, тогда JSP-контейнер может избрать одновременное направление странице множественных внешних запросов клиентов. Авторы страниц, использующие “true”, должны быть уверены, что осуществляется соответствующая синхронизация доступа к странице. По умолчанию “true”. Заметьте, что, даже если атрибут isThreadSafe имеет значение “false”, автор JSP-страницы должен иметь уверенность, что доступы к любым объектам раздельного использования/shared соответствующим образом синхронизированы. Объекты могут использоваться раздельно в ServletContext или в HttpSession. |
| info | Определяет произвольную строку, которая внедряется в транслируемую страницу, которая затем может быть получена из реализации страницы методом Servlet.getServletInfo(). |
| isErrorPage | Указывает, предназначена ли текущая JSP-страница служить целевым URL для другой JSP-страницы как errorPage. Если “true”, тогда неявная переменная языка скриптинга “exception” определяется и её значением является ссылка на нарушающий Throwable из исходной JSP-страницы, в случае ошибки. Если “false” - неявная переменная “exception” недоступна, и любая ссылка на неё в теле JSP-страницы является недопустимой и приведёт к фатальной ошибке трансляции. По умолчанию “false”. |
| errorPage | Определяет URL ресурса, которому любой объект(ы) Throwable языка программирования Java, вызываемый, но не отлавливаемый реализацией страницы, направляется для обработки ошибки. Спецификация предоставляемого URL выполняется так, как указано в . Если URL именует другую JSP-страницу, тогда неявная переменная скрипта вызываемого исключения этой JSP-страницы содержит ссылку на начальный неотловленый Throwable. URL по умолчанию зависит от реализации. Обратите внимание, что объект Throwable передаётся реализацией страницы, вызывающей исключение/throwing, реализации страницы ошибки, сохраняя ссылку на объект в обычном объекте ServletRequest путём использования метода setAttribute(), с именем “javax.servlet.jsp.jspException”. Примечание: если autoFlush=true, то, если содержимое начального Jsp-Writer было очищено для потока вывода ServletResponse, любая последующая попытка диспетчеризации неотловленного исключения из страницы-нарушителя странице errorPage может потерпеть неудачу. Если страница обработки ошибок указана также в дескрипторе web.xml, то сначала применяется JSP-страница обработки ошибок, а затем страница web.xml. |
| contentType |
Определяет кодировку символов для JSP-страницы и для JSP-страницы - ответа и тип MIME для JSP-страницы - ответа. Значения могут иметь форму “TYPE” или “TYPE; charset=CHARSET” с необязательным пробелом после “;”. CHARSET, если имеется, обязан быть значением IANA для кодировки символов. TYPE это MIME-тип: см. в регистре IANA используемые значения. Для TYPE значение по умолчанию - “text/html”; значение по умолчанию для кодировки символов - ISO-8859-1. См. в детальную информацию о кодировках символов. |
| pageEncoding | Определяет кодировку символов для JSP-страницы. Значения имеют форму “CHARSET”, который обязан быть IANA-значением для кодировки символов. Значение contentType для CHARSET используется по умолчанию, если имеется, в противном случае - ISO-8859-1. См. в детальную информацию о кодировках символов. |
JSP.2.10.2 Директива taglib
Набор значащих тэгов, интерпретируемых JSP-контейнером, может быть расширен “tag library/библиотекой тэгов”. Директива taglib на JSP-странице объявляет, что данная страница использует библиотеку тэгов, уникально идентифицирует библиотеку тэгов, используя URI, и ассоциирует префикс тэгов, который служит для отличения использования акций в этой библиотеке. Если реализация JSP-контейнера не может локализовать описание библиотеки тэгов, должна возникать фатальная ошибка трансляции. Фатальная ошибка трансляции возникнет также, если директива taglib появится после акций, использующих данный префикс.
Библиотека тэгов может включать метод проверки корректности использования JSP-страницей функциональности библиотеки тэгов. См. более конкретные детали в . Также см. замечания по реализации в .
Примеры
В следующем примере библиотека тэгов вводится и становится доступной данной странице путём использования префикса super; никакие другие библиотеки тэгов не должны вводиться на данной странице, используя этот префикс. В данном конкретном случае мы принимаем, что библиотека тэгов включает тип элемента doMagic, который используется на странице.
<%@ taglib uri=”http://www.mycorp/supertags” prefix=”super” />
...
<super:doMagic>
...
</super:doMagic>
Синтаксис
<%@ taglib uri=”tagLibraryURI” prefix=”tagPrefix” %>
где атрибуты:
Таблица JSP.2-1
| uri | Спецификация абсолютного или относительного URI, который уникально идентифицирует дескриптор библиотеки тэгов, ассоциированной с данным префиксом. URI используется для локализации описания библиотеки тэгов, как указано в . |
| tagPrefix | Определяет строку prefix в конструкции <prefix>:<tagname>, которая используется для отличения специальной акции, например, <myPrefix:myTag>. Использование префиксов, начинающихся с jsp:, jspx:, java:, javax:, servlet:, sun: и sunw:, зарезервировано. Префикс обязан следовать соглашению об именовании, специфицированному в спецификации пространств имён XML. Пустые префиксы в данной версии спецификации не допускаются. |
Фатальная ошибка трансляции возникнет, если транслятор JSP-страницы обнаруживает тэг с именем prefix: Name,
использующий префикс, введённый директивой taglib, и если Name не распознаётся соответствующей библиотекой тэгов.
JSP.2.10.3 Директива include
Директива include используется для подстановки текста и/или кода в JSP-страницу на этапе трансляции.
Директива <%@ include file=”спецификация относительного URL” %>
вставляет текст специфицированного ресурса в .jsp-файл. Включённый файл является субъектом контроля доступа, доступного JSP-контейнеру. Атрибут file рассматривается в Разделе . JSP-контейнер может включать механизм уведомления в случае изменения включённого файла, чтобы контейнер мог перекомпилировать эту JSP-страницу, однако спецификация JSP 1.2 не содержит способа указания JSP-контейнеру, что включённые файлы должны изменяться.
Примеры
В следующем примере запрашивается включение на этапе трансляции файла авторских прав/copyright.
Этот файл может содержать элементы, которые также будут обрабатываться:
<%@ include file=”copyright.html” %>
Синтаксис
<%@ include file="спецификация относительного URL" %>
JSP.2.10.4 Включение Данных в Страницы JSP
Включение данных является важной частью задач JSP-страницы. Соответственно, спецификация JSP 1.2 имеет два механизма включения для различных задач. Обобщение их семантики дано в Таблице JSP.2-1.
Таблица JSP.2-1 Обобщение Механизмов include в спецификации JSP 1.2
| <%@ include file=... %> | относительно файла | статический/static | Содержимое разбирается/parsed JSP-контейнером. | |
| <jsp:include page= /> | относительно страницы | статический и динамический | Содержимое не разбирается; оно вставляется в этом месте. |
Колонка Спецификация описывает, какой тип спецификации является верным для данного элемента. Данная спецификация JSP требует специфицировать относительный URL. Ссылка разрешается сервером web/приложений, и выполняется отображение её URL. Директивы include
интерпретируются относительно текущего JSP-файла; акции jsp:include интерпретируются относительно текущей JSP-страницы. Директива include относится к ресурсу вроде JSP-страницы как к статичному/static объекту; т.е. байты в JSP-странице включаются. Акция include относится к ресурсу вроде JSP-страницы как к динамическому/dynamic объекту; т.е. запрос направляется этому объекту, и результат процессинга включается .
JSP.2.10 Директивы
Директивы являются сообщениями JSP-контейнеру.
Синтаксис директивы:
<%@ директива { атрибут=”значение” }* %>
Могут иметься необязательные пробелы после “<%@” и перед “%>”. Это синтаксис легко вводится и понятен, но он несовместим с XML. В описано отображение директив в элементы XML.
Директивы не производят никакого вывода в текущий поток out. Есть три директивы: page и taglib описаны здесь, а директива include - в следующей главе.
JSP.2.11.1 Объявления
Объявления используются для объявления переменных и методов на языке скриптинга, используемого на данной JSP-странице. Объявление должно быть декларативным оператором или последовательность операторов, соответствующей синтаксису специфицированного языка скриптинга.
Объявления не производят никакого вывода в текущий поток вывода. Объявления инициализируются в момент инициализации JSP-страницы и становятся доступными другим объявлениям, скриптлетам и выражениям.
Примеры
Например, первое объявление здесь объявляет целое число, глобальное в пределах страницы.
Второе объявление делает то же самое и инициализирует число в нуль. Этот тип инициализации должен выполняться осторожно при наличии нескольких запросов к странице.
В третьем случае объявляется метод, глобальный в пределах страницы.
<%! int i; %>
<%! int i = 0; %>
<%! public String f(int i) { if (i<3) return(“...”); ... } %>
Синтаксис
<%! объявление(-я) %>
JSP.2.11.2 Скриптлеты
Скриптлеты могут содержать любые фрагменты кода, которые являются верными для языка скриптинга, специфицированного директивой language. Является ли фрагмент кода действующим, зависит от деталей языка скриптинга (см. ).
Скриптлеты выполняются во время обработки запроса. Производят они вывод в поток вывода или нет, зависит от кода скриптлета.
Скриптлеты могут иметь побочные эффекты, модифицируя объекты, видимые для них. Когда все фрагменты скриптлетов в данном трансляционном модуле комбинируются для появления на JSP-странице, они обязаны давать в результате верный оператор или последовательность операторов на специфицированном языке скриптинга.
Чтобы использовать последовательность символов %> как литеральные символы в скриптлете, вместо того , чтобы они оканчивали скриптлет, вводите их так %\>.
Примеры
Вот простой пример динамического изменения страницы, в зависимости от времени суток.
<% if (Calendar.getInstance().get(Calendar.AM_PM) == Calendar.AM) {%>
Good Morning
<% } else { %>
Good Afternoon
<% } %>
Скриптлет может также содержать объявление локальных переменных, например, следующий скриптлет просто объявляет и инициализирует целое число и затем отображает это число и увеличивает его.
<% int i; i= 0; %>
Привет, значение i равно <% i++ %>
Синтаксис
<% скриптлет %>
JSP.2.11.3 Выражения
Элемент expression в JSP-странице является выражением языка скриптинга, которое вычисляется, а результат приводится к String. Результат затем посылается в текущий объект вывода JspWriter. Если результат выражения не может быть приведён к String, обязаны выполняться следующие действия:
Если проблема обнаружена на этапе трансляции, должна возникать ошибка времени трансляции.
Если приведение не обнаруживается в процессе трансляции, должно вызываться исключение ClassCastException/ОшибкаПриведенияКласса во время запроса.
Язык скриптинга может поддерживать побочные эффекты в выражениях, когда выражение вычисляется.
Выражения вычисляются слева направо на JSP-странице. Если выражения появляется в более чем одном атрибуте времени выполнения, они должны вычисляться слева направо в тэге. Выражение может изменять значение объекта out, хотя это не всегда легко выполнимо. Выражение обязано быть полным выражением языка скриптинга, на котором оно написано.
Выражения вычисляются во время HTTP-процессинга.
Значение выражения конвертируется к String и вставляется в соответствующую позицию в .jsp-файл.
Примеры
Вставляется текущая дата:
<%= (new java.util.Date()).toLocaleString() %>
Синтаксис
<%= выражение %>
JSP.2.11 Элементы Скриптинга/Сценариев
Элементы скриптинга обычно используются
для манипулирования объектами и для выполнения вычислений, влияющих на генерируемое содержимое.
Есть три класса элементов скриптинга: declarations\объявления, scriptlets\скриптлеты и expressions\выражения. Язык скриптинга, используемый на данной странице, задаётся значением директивы language (см. , "Директива page"). В JSP 1.2 единственным определённым значением является “java”.
Объявления используются для объявления конструкций языка скриптинга, которые доступны всем другим элементам скриптинга.
Скриптлеты используются для описания акций, выполняемых в ответ на некоторый запрос. Скриптлеты являются фрагментами программы, которые также могут использоваться для выполнения действий типа итераций и условного выполнения других элементов на JSP-странице.
Выражения являются сложными выражениями на языке скриптинга, которые вычисляются на этапе ответа; обычно результат конвертируется в строку и вставляется в поток вывода.
Все JSP-контейнеры обязаны поддерживать элементы скриптинга, базирующиеся на языке программирования Java. Кроме того, JSP-контейнеры обязаны поддерживать другие языки скриптинга.
Все такие языки скриптинга обязаны поддерживать:
манипуляцию объектами Java,вызов методов объектов Java,отлов исключений языка Java.
Точное определение семантики скриптинга, выполняемого с использованием элементов на базе языка Java, дано в .
Семантика других языков скриптинга не определена точно в данной версии спецификации, что означает, что переносимость в разных реализациях не гарантируется. Точные определения могут быть даны для других языков в будущем.
Каждый элемент скриптинга имеет следующий синтаксис на базе “<%”:
<%! это объявление %>
<% это скриптлет %>
<%= это выражение %>
Могут иметься необязательные пробелы после “<%!”, “<%” и “<%=” и до “%>”.
Эквивалентные данным элементам скриптинга элементы XML описаны в .
JSP.2.12 Акции
Акции могут воздействовать на текущий поток вывода и использовать, модифицировать и/или создавать объекты. Акции могут зависеть от деталей конкретного объекта request/запроса, получаемого JSP-страницей.
Данная спецификация JSP содержит некоторые акции, которые являются
стандартными и обязаны реализовываться всеми соответствующими JSP-контейнерами; эти акции описываются в .
Новые акции определяются в соответствии с механизмами, описанными в Главах и , и вводятся с использованием директивы taglib.
Синтаксис элементов акций базируется на XML. Акции могут быть пустыми и непустыми.
JSP.2.13.1 Значения Атрибутов Времени Запроса
Значение атрибута в форме “<%= scriptlet_expr %>” или ‘<%= scriptlet_expr %>’ обозначает значение атрибута времени запроса. Указываемое значение является значением включаемого скриптлета. Значения атрибутов времени запроса могут использоваться только в акциях и не могут использоваться в директивах. Если в тэге имеется более одного такого атрибута, выражения вычисляются слева направо.
Закавычивание выполняется так же, как и в других значениях атрибута (). Таким способом могут обозначаться только значения атрибута (имя атрибута всегда является явно определённым именем).
Выражение обязано появляться само по себе (множественные выражений и смешивание выражений и строковых констант не допускаются).
Множественные операции обязаны выполняться внутри выражения.
Конверсия типов описана в Разделе . По умолчанию все атрибуты имеют семантику времени трансляции страницы. Попытка специфицировать выражение скриптлета как значение атрибута, который (по умолчанию или нет) имеет семантику времени трансляции, является недопустимой и приводит к фатальной ошибке трансляции.
Тип элемента action указывает, будет ли данный атрибут принимать значения атрибута времени запроса.
Большинство атрибутов стандартных акций из имеют семантику времени трансляции страницы, но следующие атрибуты принимают выражения атрибутов времени запроса:
Атрибут значения в jsp:setProperty
().
Атрибут beanName в jsp:useBean ().
Атрибут page в jsp:include
().
Атрибут page в jsp:forward ().
Атрибут значения в jsp:param ().
Атрибуты height и width в jsp:plugin ().
JSP.2.13.2 Соглашения о Типах
Мы описываем два случая конверсии типов:
JSP.2.13.2.1 Конверсия из Значений String
Значение строки может использоваться для описания значения типа не-String через конверсию. Возможна ли конверсия и, если да, какая она, зависит от типа назначения.
Значения String могут использоваться для присвоения значений типу, который имеет класс PropertyEditor, как указано в спецификации JavaBeans. Если это именно тот случай, используется метод setAs-Text(String).
Конверсия терпит неудачу, если метод вызывает исключение IllegalArgumentException.
Значения String могут также использоваться для присвоения типов, как указано в Таблице JSP.2-2. Применяется так конверсия, которая указана в таблице. Неудача конверсии ведёт к ошибке времени трансляции или времени запроса.
Таблица JSP.2-2 Конверсия из Строковых Значений в Тип Назначения
| Свойство Bean | Использовать setAsText(string-literal) |
| boolean или Boolean | Как указано в java.lang.Boolean.valueOf(String) |
| byte или Byte | Как указано в java.lang.Byte.valueOf(String) |
| char или Character | Как указано в String.charAt(0) |
| double или Double | Как указано в java.lang.Double.valueOf(String) |
| int или Integer | Как указано в java.lang.Integer.valueOf(String) |
| float или Float | Как указано в java.lang.Float.valueOf(String) |
| long или Long | Как указано в java.lang.Long.valueOf(String) |
| short или Short | Как указано в java.lang.Short.valueOf(String) |
| Object | Как если бы new String(string-literal) |
Эти конверсии являются частью общего механизма, используемого для присвоения значений атрибутам акций: когда значение атрибута, который не является атрибутом времени запроса, присваивается данному атрибуту, используется описанная здесь конверсия, использующая тип атрибута как целевой тип. Тип каждого атрибута стандартных акций описан в данной спецификации, а типы атрибутов специальных/custom акций описаны в ассоциированном с ними Дескрипторе Библиотеки Тэгов/Tag Library Descriptor.
Конкретная акция может также определять дополнительные способы использования конверсии типа/значения.
В описан механизм, используемый для стандартной акции setProperty.
JSP.2.13.2.3 Конверсия из Выражений Времени Запроса
Выражения времени запроса могут назначаться свойству любого типа.
Автоматическая конверсия не выполняется.
JSP.2.13 Семантика Интерпретации Атрибута Тэга
Интерпретация всех акций начинается с вычисления значений, данных их атрибутам, слева направо и присвоения этих значений атрибутам. В этом процессе могут производиться конверсии; правила конверсии описаны в Разделе.
Многие значения являются фиксированными ‘значениями времени трансляции’, но JSP 1.2 предоставляет также механизм описания этих значений, когда они вычисляются на этапе запроса, правила описаны в .
JSP.3.1 Кодировка Символов Страницы
Поддержка платформой Java локализованного содержимого базируется на универсальном внутреннем представлении текста как символов Unicode 2.0 (ISO010646) и поддержке нескольких кодировок символов в Unicode.
Java Virtual Machine (JVM)/Виртуальная Машина Java обязана поддерживать кодировки Unicode и Latin-1, но большинство машин поддерживают гораздо больше кодировок. Кодировки символов, поддерживаемые JVM от Sun, описаны по адресу:
JSP-страница использует кодировку символов. Кодировка может быть описана явно атрибутом pageEncoding директивы page. По умолчанию кодировка выполняется по атрибуту contentType директивы page, если она имеется, или, в противном случае, устанавливается ISO-8859-1. ISO-8859-1 известна также как Latin-1.
Верные имена кодировок символов в JSP 1.2 - те же, что и имена IANA. Они описаны по адресу:
Атрибут pageEncoding должен использоваться только тогда, когда кодировка символов JSP-страницы организована так, что символы ASCII отображают сами себя. Директива, содержащая атрибут pageEncoding, должна появляться на JSP-странице как можно раньше.
JSP-контейнер может использовать какую-нибудь зависящую от реализации эвристику и/или структуру для определения ожидаемой кодировки JSP-страницы и проверки соответствия атрибута contentType.
JSP-контейнер вызовет ошибку времени трансляции, если запрошена неподдерживаемая кодировка символов.
JSP.3.2 Статический Тип Содержимого
Большинство JSP-страниц написаны так, чтобы отправлять ответ, используя специфические тип содержимого/content type и кодировку символов. JSP-страница может использовать атрибут contentType директивы page для обозначения типа содержимого, предоставляемого в ответ на запросы. Если используется таким образом, данная страница будет всегда предоставлять содержимое одного и того же типа. Если страница определяет, что ответ должен иметь другой тип содержимого, она должна делать это “раньше”, определяя, какая иная JSP-страница или сервлет будет обрабатывать этот запрос, и направлять запрос другой JSP-странице или сервлету. Значение TYPE по умолчанию “text/html”, а значение по умолчанию для кодировки символов - ISO-8859-1. Регистр имён типов содержимого хранится в IANA.
См.:
Атрибут contentType обязан использоваться только в том случае, если кодировка символов организована так, что символы ASCII отображают сами себя, как минимум до тех пор, пока атрибут contentType не будет найден. Директива, содержащая атрибут contentType, должна появляться на JSP-странице как можно раньше.
JSP.3.3 Динамический Тип Содержимого
Некоторые JSP-страницы созданы так, что они могут направлять содержимое, используя различные типы содержимого и кодировки символов, в зависимости от ввода времени запроса. Эти страницы могут быть организованы как специальные акции или скриптлеты, которые определяют тип содержимого ответа и предоставляют ‘связку’ с другим кодом, реально генерирующим содержимое ответа.
Динамическая установка типа содержимого основана на вызове response.setcontentType(). Этот метод может быть вызван, пока никакого содержимого не было выслано в поток ответа. Данные высылаются в поток ответа при очистках буфера буферизованных страниц или при обнаружении первого содержимого (избегая пробелов) небуферизованных страниц.
Пробел в страницах JSP вводится известным трюком синтаксиса JSP, но более управляем в JSP-страницах с синтаксисом XML.
JSP.3.4 Передача Локализованного Содержимого
Спецификация JSP не предписывает определённого подхода к структурированию локализованного содержимого, поэтому возможны различные подходы.
Два обычных подхода заключаются в использовании шаблонной taglib и помещения локализованных строк из хранилища ресурсов, либо в использовании локализованных JSP-страниц. Каждый подход имеет свои преимущества и недостатки. Некоторые пользователи используют трансформацию JSP-документов для простого замещения элементов локализованными строками, обрабатывая таким образом синтаксис JSP без снижения производительности на этапе прогона. Сочетание этих трёх подходов также имеет определённый смысл.
Есть несколько подходов к наилучшему проведению локализации. Мы ожидаем появления JSR-052, стандартной библиотеки тэгов JSP, чтобы адресовать к ней некоторые из этих вопросов.
JSP.4.1 <jsp:useBean>
Акция jsp:useBean
ассоциирует экземпляр объекта языка программирования Java, определённый в данной области видимости/scope
и доступный с данным id через вновь объявленную переменную скриптинга с тем же id.
Акция jsp:useBean
весьма гибка: её точная семантика зависит от заданных атрибутов. Базовая семантика пытается найти существующий объект, используя id и область видимости. Если объект не найден, будет сделана попытка создания этого объекта с использованием других атрибутов.
Можно использовать эту акцию также для задания локального имени объекту, определённому в другом месте, например, в другой JSP-странице или Сервлете. Это может быть выполнено с помощью атрибута типа без предоставления атрибутов class или beanName. Должен быть представлен как минимум тип или класс, и неверным будет предоставление и class, и beanName. Если тип и класс имеются, class обязан быть назначен типу (в понимании Java-платформы). Невозможность его назначить является ошибкой времени трансляции.
Атрибут beanName специфицирует имя Bean'а, как указано в спецификации JavaBeans. Оно используется в качестве аргумента для метода instantiate()
класса java.beans.Beans. Оно обязано иметь форму “a.b.c” и может быть именем класса или ресурса в форме “a/b/c.ser”, которое будет разрешено в текущем ClassLoader/ЗагрузчикеКлассов. Если это не так, будет вызвано исключение времени запроса, как указано в семантике instantiate(). Значением этого атрибута может быть выражение атрибута времени запроса.
Более детально о роли id и scope говорится далее.
Атрибут id
Пара атрибут/значение id=”имя” является элементом jsp:useBean
и имеет специальное значение для JSP-контейнера во время трансляции страницы при обработке запроса клиента.
Конкретно:
имя
обязано быть уникальным в пределах трансляционного модуля и идентифицирует определённый элемент, в котором оно появляется в JSP-контейнере и странице. Дубликаты id, найденные в том же самом трансляционном модуле, приводят в фатальной ошибке времени трансляции.
JSP-контейнер будет ассоциировать объект (компонент JavaBean) с именованным значением и получать доступ по этому имени в различных контекстах через объект
page-context, описанный далее в этой спецификации.
Это name используется также для экспонирования переменной (имени) в среде языка скриптинга. Область видимости переменной языка скриптинга зависит от правил видимости и возможностей языка скриптинга, используемого на этой странице.
Заметьте, что это подразумевает, что синтаксис значения name обязан соответствовать синтаксическим правилам именования переменных языка скриптинга, используемого на этой странице.
В детально рассматривается случай, когда атрибут language - ”java”.
Пример использования правил правил области видимости, только что упомянутых, дан здесь:
<% { // вводится новый блок %>
...
<jsp:useBean id=”customer” class=”com.myco.Customer” />
<%
/*
* тэг создаёт или получает ссылку на Customer Bean,
* ассоциирует её с именем “customer”
* в PageContext и объявляет переменную языка программирования Java
* с тем же именем, которое инициализировано для ссылки на объект
* в пределах видимости этого блока.
*/
%>
...
<%= customer.getName(); %>
...
<% } // закрывает блок %>
<%
// переменная customer находится сейчас вне области видимости,
// но объект всё ещё действует (и доступ к нему осуществляется через PageContext)
%>
Атрибут scope
Пара атрибут/значение scope=”page|request|session|application” ассоциирована с (и модифицирует) поведением атрибута id, описанного выше (она (пара) имеет семантику и времени трансляции, и времени процессинга запроса клиента).
Конкретнее, она описывает пространство имён, предполагаемый жизненный цикл ссылки на объект, ассоциированной с name, и API, используемые для доступа к этой ассоциации, таким образом:
Таблица JSP.4-1
| page | Именованный объект, доступный из javax.Servlet.jsp.PageContext для данной страницы. Эта ссылка должна быть уничтожена после выполнения текущего запроса телом страницы. Не допускается изменение объекта экземпляра, ассоциированного таким образом, что его (объекта?) тип времени прогона/выполнения является поднабором типа текущего объекта, ассоциированного ранее. |
| request |
Именованный объект, доступный из объекта ServletRequest текущей страницы через использование метода getAttribute(name). Эта ссылка должна быть уничтожена после выполнения текущего клиентского запроса. Не допускается изменение значения объекта экземпляра, ассоциированного таким образом, что его (объекта?) тип времени прогона/выполнения является поднабором(-ами) типа объекта, ассоциированного ранее таким же образом. |
| session | Именованный объект, доступный из объекта HttpSession текущей страницы (который, в свою очередь, может быть получен из объекта ServletRequest) через использование методаgetAttribute(name). Эта ссылка должна быть уничтожена после аннулирования текущей сессии. Не допускается изменение значения объекта экземпляра, ассоциированного таким образом, чтобы его новый тип времени прогона был поднабором(-ами) типа объекта, ассоциированного ранее. Заметьте, что будет фатальной ошибкой трансляции попытка использовать область видимости сессии, когда JSP-страница, делающая эту попытку, объявляется через директиву <%@ page ... %> (см. далее) так, что она не участвует в сессии. |
| application | Именованный объект, доступный из объекта ServletContext текущей страницы через использование метода getAttribute(name). Эта ссылка должна быть уничтожена после использования ServletContext. Не допускается изменение значения объекта экземпляра, ассоциированного таким образом, чтобы его новый тип времени прогона был поднабором(-ами) типа объекта, ассоциированного ранее таким же образом. |
Семантика
Акциями, выполняемыми в jsp:useBean, являются:
Попытка локализовать объект на базе значениях атрибутов id и scope. Синхронно выполняется проверка пространства имён области видимости/scope для исключения недетерминистического поведения.
Переменная языка скриптинга специфицированного типа (если задан) или class/класс (если type не задан) определяется с данным id в текущей лексической области видимости языка скриптинга.
Если этот объект найден, значение переменной инициализируется ссылкой на локализованный объект, приведённый к специфицированному типу. Если приведение терпит неудачу, должно возникать исключение java.lang.ClassCastException. Это завершает работу данной акции jsp:useBean.
Если элемент jsp:useBean имел непустое тело/body, он игнорируется. Это завершает работу данной акции jsp:useBean.
Если объект не найден в специфицированной области видимости и не заданы ни class, ни beanName, должно возникать исключение java.lang.InstantiationException. Это завершает работу данной акции jsp:useBean.
Если объект не найден в специфицированной области видимости и класс/class специфицировал имена неабстрактного класса, который определяет публичный/public безаргументный конструктор, тогда создаётся экземпляр этого класса.
Ссылка на новый объект ассоциируется с переменной скриптинга и со специфицированным именем в специфицированной области видимости через использование подходящей области видимости, в зависимости от механизма ассоциирования (см. PageContext). После этого выполняется шаг 7.
Если объект не найден и класс является абстрактным классом, интерфейсом или не определён public безаргументный/no-args конструктор, тогда должно возникать исключение java.lang.InstantiationException. Это завершает работу данной акции jsp:useBean.
Если объект не найден в специфицированной области видимости и задано имя beanName, тогда метод instantiate() класса java.beans.Beans
будет вызван с Class-Loader/Загрузчиком-Классов объекта Servlet и с beanName в качестве аргументов.
Если метод выполнен успешно, новая ссылка на объект ассоциируется с переменной скриптинга и со специфицированным именем в специфицированной области видимости через использование подходящей области видимости, в зависимости от механизма ассоциирования (см. PageContext). После этого выполняется шаг 7.
Если элемент jsp:useBean имеет непустое тело/body, оно обрабатывается, переменная инициализируется и становится доступной в области видимости тела. Текст внутри тела рассматривается как обычно. Любой шаблонный текст будет передан в поток вывода. Тэги скриптлетов и акций вычисляются.
Обычно непустое тело используется для завершения инициализации созданного экземпляра. В этом случае тело, вероятно, будет содержать акции jsp:setProperty и скриптлеты, которые вычисляются. Это завершает работу данной акции jsp:useBean.
Примеры
В этом примере Bean с именем “connection” и типом “com.myco.myapp.Connection” доступен после выполнения акций в этом элементе, или потому что он уже создан и найден, или потому что он создан заново.
<jsp:useBean id=”connection” class=”com.myco.myapp.Connection” />
В следующем примере свойство timeout устанавливается в 33, если Bean был инстанциирован.
<jsp:useBean id=”connection” class=”com.myco.myapp.Connection”>
<jsp:setProperty name=”connection” property=”timeout” value=”33”>
</jsp:useBean>
В последнем примере объект должен существовать в данной сессии. Если это так, ему присваивается локальное имя wombat типа WombatType. Может возникать исключение ClassCastException, если это объект неверного класса, а InstantiationException может возникать, если объект не определён.
<jsp:useBean id=”wombat” type=”my.WombatType” scope=”session”/>
Синтаксис
Эта акция может иметь или не иметь тело/body. Если акция не имеет тела, она имеет форму:
<jsp:useBean id="name" scope="page|request|session|application" typeSpec />
typeSpec ::= class=”className” |
class=”className” type=”typeName” |
type=”typeName” class=”className” |
beanName=”beanName” type=”typeName” |
type=”typeName” beanName=”beanName” |
type=”typeName”
Если акция имеет тело, она имеет форму:
<jsp:useBean id="name" scope="page|request|session|application" typeSpec >
body
</jsp:useBean>
В этом случае тело тело будет вызвано, если Bean, обозначаемый этой акцией, создаётся. Обычно body будет содержать тэги скриптлетов или jsp:setProperty, которые будут использоваться для модификации вновь созданного объекта, но содержимое тела не ограничивается.
Тэг <jsp:useBean> имеет следующие атрибуты:
Таблица JSP.4-1
| id | Имя, используемое для идентификации экземпляра объекта в пространстве имён специфицированной области видимости, а также имя переменной скриптинга, объявленное и инициализированное вместе со ссылкой на этот объект. Специфицированное пространство имён чувствительно к регистру и должно соответствовать соглашениям текущего языка скриптинга по именованию переменных. |
| scope | Область видимости/scope, в зоне которой ссылка доступна. Значение по умолчанию - page. См. описание атрибута scope, определённого ранее здесь же. |
| class | Полное квалифицированное имя класса, определяющего реализацию объекта. Имя класса чувствительно к регистру. Если атрибуты class и beanName не специфицированы, объект обязан быть представлен в данной области видимости. |
| beanName | Имя для Bean, как предполагается методом instantiate() класса java.beans.Beans. Этот атрибут может принимать в качестве значения выражение атрибута времени запроса. |
| type | Если специфицирован, определяет тип переменной скриптинга. Это позволяет типу переменной скриптинга отличаться от (но соотноситься с) типа специфицированного класса реализации. Тип должен быть самим классом, суперклассом этого класса, либо интерфейсом, реализованным специфицированным классом. Объект, на который ссылаются, должен быть этого типа, иначе должно возникать исключение java.lang.ClassCastException во время запроса, когда делается попытка назначения объекта, на который ссылаются, переменной скриптинга. Если не специфицировано, значение будет тем же, что и значение атрибута class. |
JSP.4.2 <jsp:setProperty>
Акция jsp:setProperty
устанавливает значения свойств в Bean'е. Атрибут name, обозначающий этот Bean, обязан быть определён до появления этой акции.
Имеются два варианта акции jsp:setProperty. Оба они устанавливают значение одного или более свойств в Bean на базе типа свойств. Обычно в Bean выполняется самоанализ с целью обнаружения существующих свойств, и, для каждого из них, имени, простое оно или индексированное, его типа и методов setter и getter. Самоанализ также указывает, имеет ли тип данного свойства класс PropertyEditor.
Свойства в Bean могут быть установлены из одного или более параметров объекта request, из String-константы или из вычисленного выражения времени запроса. Простые и индексированные свойства могут быть установлены с использованием jsp:setProperty.
При установке из параметра объекта request применяется конвертация, описанная в , использующая целевое свойство для определения целевого типа.
При присвоении из значения, заданного как String-константа, применяется конвертация, описанная в , использующая целевое свойство для определения целевого типа.
При присвоении из значения, заданного как атрибут времени запроса, никакая конвертация типов не применяется, как указано в Разделе .
При присвоении значений индексированным свойствам значение обязано быть массивом/array; к элементам применяются правила, описанные в предыдущем параграфе. Неудача конверсии приводит к ошибке времени трансляции или времени запроса.
Примеры
Следующие два элемента устанавливают значение из значений параметра request:
<jsp:setProperty name=”request” property=”*” />
<jsp:setProperty name=”user” property=”user” param=”username” />
Следующие два элемента устанавливают свойство из значения:
<jsp:setProperty name=”results” property=”row” value=”<%= i+1 %>” />
Синтаксис
<jsp:setProperty name="beanName" prop_expr />
prop_expr ::=
property="*" |
property=”propertyName”|
property=”propertyName” param="parameterName"|
property=”propertyName” value=”propertyValue”
propertyValue ::= string
Значение propertyValue может также быть значением атрибута времени запроса, как описано в .
propertyValue ::= expr_scriptlet
(См. синтаксис скриптлета выражения “<%= ... %>”)
Элемент <jsp:setProperty> имеет следующие атрибуты:
Таблица JSP.4-2
| name | Имя экземпляра Bean'а, определённое элементом <jsp:useBean> или каким-либо другим элементом. Экземпляр Bean'а обязан содержать свойство, которое Вы хотите установить. Определяющий элемент обязан появиться до элемента <jsp:setProperty> в том же файле. |
| property | Имя свойства Bean'а, значение которого Вы хотите установить. Если Вы устанавливаете propertyName в *, тогда тэг будет выполнять итерацию поверх текущих параметров ServletRequest, подбирая совпадения имён параметров и типа(-ов) значений с именами свойств и типом(-ами) метода setter, устанавливая каждое совпавшее свойство в значение совпадающего параметра. Если параметр имеет значение "", соответствующее свойство не модифицируется. |
| param | Имя параметра запроса, значение которого Вы хотите дать свойству Bean'а. Имя параметра запроса приходит обычно от web-формы. Если param опущен, принимается, что имя параметра запроса - то же самое, что и имя свойства Bean'а. Если param не установлен в объекте Request или если он имеет значение ““, элемент jsp:setProperty не оказывает влияния (a noop - шо цэ такэ?). Акция может не иметь атрибутов param и value. |
| value |
Значение, присваиваемое данному свойству. Этот атрибут может принимать выражение атрибута времени запроса в качестве значения. Акция может не иметь атрибутов param и value. |
JSP.4.3 <jsp:getProperty>
Акция <jsp:getProperty> помещает значение свойства экземпляра Bean'а, конвертированное к String, в неявный объект вывода, из которого Вы можете отобразить значение в качестве вывода. Экземпляр Bean'а обязан быть определён так, как указано в атрибуте name до этой точки страницы (обычно посредством акции jsp:useBean).
Конверсия к String выполняется также, как в методах println(), т.е. метод toString() данного объекта применяется для экземпляров Object, а примитивные типы конвертируются напрямую.
Если объект не найден, вызывается исключение времени запроса.
Значение атрибута name в jsp:setProperty и jsp:getProperty будет ссылаться на объект, который получен из объекта PageContext с помощью его метода findAttribute().
Объект, именованный посредством name, обязан быть “представлен” JSP-процессору путём использования акции jsp:useBean или специальной акции с ассоциированным входом VariableInfo для данного имени.
Примечание: из предыдущего параграфа следует, что объекты, хранимые, скажем, в сессии лицевым/front компонентом, не являются автоматически видимыми акциям jsp:set-Property и jsp:getProperty на данной странице, если только акция jsp:useBean или какая-нибудь другая не делает их видимыми.
Если JSP-процессор может убедиться, что имеется альтернативный способ, гарантирующий доступ к тому же объекту, он может использовать эту информацию. Например, он может использовать переменную скриптинга, но он обязан гарантировать, что никакой вставляемый код не нарушит копию, хранимую переменной скриптинга. Верным всегда будет значение, содержащееся объектом PageContext.
Пример
<jsp:getProperty name=”user” property=”name” />
Синтаксис
<jsp:getProperty name=”name” property=”propertyName” />
Таблица JSP.4-3 Атрибуты
| name | Имя экземпляра объекта, из которого получено свойство. |
| property | Именует получаемое свойство. |
