В отличие от сервлетов, требующих компиляции java-файла для получения класса (файла *.class) jsp страница не требует компиляции и регистрации в дескрипторе поставки web.xml .

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

Пример Dynamic Web Project

Рассмотрим простой пример, в котором на JSP странице приветствия будут отображены текущая дата и время. Для разработки будет использована IDE Eclipse. На следующем скриншоте представлено определение типа проекта Dynamic Web Project .

Определим наименование проекта как HelloJSP и создадим в проекте файл index.jsp . Структура проекта представлена на следующем скриншоте.

Код дескриптора приложения web.xml

index.jsp

В дескрипторе приложения web.xml в качестве страницы приветствия определен JSP файл index.jsp .

Исходный код JSP страницы index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@ page import="java.util.*, java.text.*" %> <%! String getFormattedDate() { SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy hh:mm:ss"); return sdf.format(new Date()); } %>

Добро пожаловать!

Сегодня <%= getFormattedDate() %>

Последнее обновление: 02.09.2018

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

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

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

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

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

<% String header = "Apache Tomcat"; %>

<%= header %>

Today <%= new java.util.Date() %>

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

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

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

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

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

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

По умолчанию Apache Tomcat настроен таким образом, что все запросы к корню приложения по умолчанию обрабатываются страницей index.jsp, поэтому мы также можем обращаться к ней по адресу

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

JSP директивы

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

<% @ directive { attr = "value" }* %>

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

<% @ page language = "java" %>

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

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

<% @ page session = "true" import =" java . util .*" %>

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

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

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

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

<%! declaration %> <% scriptlet %> <%= expression %>

Пробелы после "<%!", "<%", "<%=" и перед "%>" не обязательны.

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

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

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

<%-- jsp comment --%>

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

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

//:! c15:jsp:Hello.jsp <%-- Этот JSP комментарий не появится в сгенерированном html -- %> <%-- Это JSP директива: -- %> <%@ page import="java.util.*" %> <%-- Эта декларации: -- %> <% ! long loadTime = System.currentTimeMillis (); Date loadDate = new Date (); int hitCount = 0 ; %> <%-- Следующие несколько строк являются результатом JSP выражений, вставленных в сгенерированный html; знак "=" указывает на JSP выражение -- %>

Эта страница была загружена <%= loadDate %>

Hello, world! It"s <%= new Date () %>

Here"s an object: <%= new Object () %>

This page has been up <%= (System.currentTimeMillis ()- loadTime )/ 1000 %> seconds

Page has been accessed <%= ++ hitCount %> times since <%= loadDate %>

<%-- "Скриплет", которые пишет на консоли сервера и на странице клиента. Обратите, что необходимо ставить ";": -- %> <% System.out.println ("Goodbye" ); out.println ("Cheerio" ); %> ///:~

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

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

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

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

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

//:! c15:jsp:DisplayFormData.jsp <%-- Извлечение данных из HTML формы. -- %> <%-- Эта JSP также генерирует форму. -- %> <%@ page import="java.util.*" %>

DisplayFormData

<% Enumeration flds = request.getParameterNames (); if (! flds.hasMoreElements ()) { // Нет полей %>

<% for (int i = 0 ; i < 10 ; i ++) { %> Field <%= i %> :
<% } %>

<% } else { while (flds.hasMoreElements ()) { String field = (String ) flds.nextElement (); String value = request.getParameter (field ); %>

<%= field %> = <%= value %>

<% } } %>

///:~

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

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

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

//:! c15:jsp:PageContext.jsp <%-- Просмотр атрибутов pageContext-- %> <%-- Обратите внимание, что вы можете включить любое количество кода внутри тэгов скриплета -- %> <%@ page import="java.util.*" %> Servlet Name: <%= config.getServletName () %>
Servlet container supports servlet version: <% out.print (application.getMajorVersion () + "." + application.getMinorVersion ()); %>
<% session.setAttribute ("My dog" , "Ralph" ); for (int scope = 1 ; scope <= 4 ; scope ++) { %>

Scope: <%= scope %>

<% Enumeration e = pageContext.getAttributeNamesInScope (scope ); while (e.hasMoreElements ()) { out.println ("\t

" + e.nextElement () + "

" ); } } %> ///:~

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

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

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

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

//:! c15:jsp:SessionObject.jsp <%-- Получение и установка значений объекта сессии -- %>

Session id: <%= session.getId () %>

This session was created at <%= session.getCreationTime () %>

Old MaxInactiveInterval = <%= () %>

<% session.setMaxInactiveInterval (5 ); %>

New MaxInactiveInterval= <%= session.getMaxInactiveInterval () %>

If the session object "My dog" is still around, this value will be non-null:

Session value for "My dog" = <%= session.getAttribute ("My dog" ) %>

<%-- Теперь добавим объект сессии "My dog" -- %> <% session.setAttribute ("My dog" , new String ("Ralph" )); %>

My dog"s name is <%= session.getAttribute ("My dog" ) %>

<%-- See if "My dog" wanders to another form -- %>

< /FORM>

///:~

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

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

Session value for "My dog" = Ralph

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

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

//:! c15:jsp:SessionObject2.jsp <%-- Объект сессии переноситься -- %>

Session id: <%= session.getId () %>

Session value for "My dog" <%= session.getValue ("My dog" ) %>

<% session.invalidate (); %> ///:~

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

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

//:! c15:jsp:SessionObject3.jsp <%-- Переход объекта сессии по страницам -- %>

Session id: <%= session.getId () %>

Session value for "My dog" <%= session.getValue ("My dog" ) %>

///:~

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

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

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

//:! c15:jsp:Cookies.jsp <%-- Эта программа ведет себя по разному в разных броузерах! -- %>

Session id: <%= session.getId () %>

<% Cookie cookies = request.getCookies (); for (int i = 0 ; i < cookies.length ; i ++) { %> Cookie name: <%= cookies [ i ]. getName () %>
value: <%= cookies [ i ]. getValue () %>
Old max age in seconds: <%= cookies [ i ]. getMaxAge () %>
<% cookies [ i ]. setMaxAge (5 ); %> New max age in seconds: <%= cookies [ i ]. getMaxAge () %>
<% } %> <% ! int count = 0 ; int dcount = 0 ; %> <% response.addCookie (new Cookie ("Bob" + count ++, "Dog" + dcount ++)); %> ///:~

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

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

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

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

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

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

Упражнения

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

   . Установите цвет этого текста случайным образом, используя код, встроенный в JSP страницу. Если у вас нет существующего JSP контейнера, вам необходимо загрузить, установить и запустить Tomcat с сайта jakarta.apache.org

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

16 ответов

Технология JSP является частью Java технологии семьи. Страницы JSP: скомпилирован в сервлеты и может вызывать Компоненты JavaBeans (beans) или Компоненты Enterprise JavaBeans (предприятие beans) для выполнения обработки на сервере. Таким образом, JSP технология является ключевым компонентом масштабируемая архитектура для веб-приложения.

A: Технология JavaServer Faces - это структура для создания пользовательских интерфейсов для веб-приложений. JavaServer Faces технология включает в себя:

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

Пользовательский тег JavaServer Pages (JSP) библиотека для выражения JavaServer Интерфейс Faces на странице JSP.

JSP - это специализированный сервлет.

JSF - это набор тегов, которые вы можете использовать с JSP.

С точки зрения браузера/клиента

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

JSF предназначен для более богатых веб-приложений, основанных на событиях. Я вижу событие более зернистым, чем запрос/ответ.

С точки зрения сервера

Страница JSP преобразуется в сервлет и имеет минимальное поведение.

Страница JSF преобразуется в дерево компонентов (специализированным FacesServlet), и он следует за жизненным циклом компонента, определенным спецификацией.

Сервлеты:

API Java Servlet позволяет разработчикам Java писать серверный код для доставки динамического веб-контента. Как и другие проприетарные веб-серверы API, API-интерфейс Java Servlet предлагает улучшенную производительность по сравнению с CGI; однако он имеет некоторые ключевые дополнительные преимущества. Поскольку сервлеты были закодированные в Java, они обеспечивают объектно-ориентированный подход (OO) и, что более важно, могут работать на любой платформе. Таким образом, код был переносимым на любой хост, поддерживающий Java. Сервлеты в значительной степени способствовали популярности Java, поскольку он стал широко использоваться технологии для разработки веб-приложений на стороне сервера.

JSP построен поверх сервлетов и обеспечивает более простой, основанный на странице решение для создания большого количества динамического содержимого HTML для Интернета пользовательских интерфейсов. JavaServer Pages позволяет веб-разработчикам и дизайнерам просто редактировать HTML-страницы со специальными тегами для динамического Java части. JavaServer Pages работает, имея специальный сервлет, известный как контейнер JSP, который установлен на веб-сервере и обрабатывает все Запросы просмотра страницы JSP. Контейнер JSP переводит запрошенный JSP в код сервлета, который затем скомпилирован и сразу же выполняется. Последующие запросы на одну страницу просто вызовут сервлет выполнения для страницы. Если в JSP на сервере внесено изменение, запрос для его просмотра запускается другой перевод, компиляция и перезапуск сервлет времени выполнения.

JavaServer Faces - стандартная среда Java для создания пользователя интерфейсы для веб-приложений. Самое главное, это упрощает разработка пользовательского интерфейса, который часто является одним из наиболее сложные и утомительные части разработки веб-приложений.
Хотя можно создавать пользовательские интерфейсы, используя основополагающие Веб-технологии Java (такие как сервлеты Java и страницы JavaServer) без всеобъемлющей структуры, предназначенной для корпоративных веб-сайтов разработки приложений, эти основные технологии часто могут привести к проблемы развития и обслуживания. Что более важно, когда разработчики достигнут решения по качеству производства, тот же набор проблем, решаемых JSF, будет решен в нестандартный. JavaServer Faces предназначен для упрощения разработка пользовательских интерфейсов для веб-приложений Java в следующими способами:
Он обеспечивает компонентную, клиент-независимый подход к созданию веб-пользователя интерфейсов, что повышает производительность и простоту использования разработчика.
Это упрощает доступ и управление данными приложения из Веб-интерфейс пользователя.
Он автоматически управляет пользовательским интерфейсом состояния между несколькими запросами и несколькими клиентами в простой и ненавязчивый способ.
Он обеспечивает структуру разработки, которая дружелюбный к разнообразной аудитории разработчиков с различными наборами навыков.
В нем описывается стандартный набор архитектурных шаблонов для сети приложение.

Есть также ситуации, когда вы можете поддержать JSP над JSF. Характер применения должен быть решающим фактором для выбора технологии.

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

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

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

Facelets - это первый не-JSP язык объявления страниц, разработанный для JSF (Java Server Faces), который предоставил разработчикам JSF более простую и мощную модель программирования по сравнению с JSP. Это решает различные проблемы, возникающие в JSP для разработки веб-приложений.

Вот таблица, которая сравнивает особенности скриптов и лицевых граней:

Jsp также имеет встроенный код сервлета, который не нуждается в какой-либо внешней компиляции, которую он может запускать напрямую. Изменения вступят в силу в jsp непосредственно в браузере.

Сервлет необходимо скомпилировать (т.е. он будет иметь определенное создание класса)

Jsf - это компонент представления MVC Framework

JSP - это компонент View MVC (Model View Controller). Контроллер принимает входящий запрос и передает его в Модель, которая может быть bean, которая делает доступ к базе данных. Затем JSP форматирует вывод с использованием HTML, CSS и JavaScript, и затем результат отправляется обратно запрашивающему.

JSP:means HTML+Java Code:

JSP имеет собственный жизненный цикл jsp_init() jsp_service() jsp_destroy

После первого запроса JSP конвертируется в.java файл. Существует три типа тегов, которые мы используем. 1.) безскриптовый

Здесь разработчик может объявить все те вещи, которые разработчик хочет взять с собой.

2.) Тег выражения

Здесь разработчик может использовать некоторые данные, относящиеся к печати

Здесь разработчик может объявить некоторые связанные с методом данные.

Servlet:

Сервл имеет собственный жизненный цикл.

Init() service() destroy()

После первого контейнера запроса будут считываться данные из файла web.xml то после приветствия заполнение будет отображаться.
Теперь, после выполнения действия, он будет искать URL-адрес, и после этого процесса он будет искать конкретный сервлет там. будет выполняться операция обслуживания.