Jsp java что это

Java Server Pages JSP

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

Разработчики Java Server Pages могут использовать компоненты JavaBeans и создавать собственные библиотеки нестандартных тегов, которые инкапсулируют сложные динамические функциональные средства.

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

В дополнение к классам и интерфейсам для программирования сервлетов (пакеты javax.servlet и javax.servlet.http), в пакетах javax.servlet.jsp и javax.servlet.jsp.target содержатся классы и интерфейсы, относящиеся к программированию Java Server Pages.

Обзор технологии Java Server Pages

Технология Java Server Pages содержит четыре ключевых компонента:

1. Директивы(directive) представляют собой сообщения для контейнера JSP, дающим возможность определить параметры страницы, подключения других ресурсов, использовать собственные нестандартные библиотеки тегов.
2. Действия actions инкапсулируют функциональные возможности в предопределенных тегах, которые можно встраивать в JSP-страницу. JSP actions часто выполняются на основе информации, посылаемой на сервер в составе запроса от определенного клиента. Действия также могут создавать объекты Java для использования их в скриптлетах JSP.
3. Скриптлеты scriptlets позволяют вставлять код Java в страницы JSP, который взаимодействует с объектами страницы при обработке запроса.
4. Библиотеки тегов(tag library) являются составной частью механизма расширения тегов, допускающего разработку и использование собственных тегов.

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

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

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

Когда Web-сервер, поддерживающий технологию JSP, принимает первый запрос на JSP-страницу, контейнер JSP транслирует эту JSP-страницу в сервлет Java, который обслуживает текущий запрос и все последующие запросы к этой странице. Если при компиляции нового сервлета возникают ошибки, эти ошибки приводят к ошибкам на этапе компиляции. Контейнер JSP на этапе трансляции помещает операторы Java, которые реализует ответ JSP-страницы, в метод _jspService. Если сервлет компилируется без ошибок, контейнер JSP вызывает метод _jspService для обработки запроса.

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

Весь статический текст HTML, называемый в документации JSP шаблоном HTML (template HTML), сразу направляется в выходной поток. Выходной поток страницы буферизуется. Буферизацию обеспечивает класс JspWriter, расширяющий класс Writer. Размер буфера по умолчанию ограничен до 8 Кбайт, но его можно изменить атрибутом buffer тега . Наличие буфера позволяет заносить заголовки ответа в выходной поток совместно с выводимым текстом. В буфере заголовки будут размещены перед текстом.

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

Архитектура JSP

Базовая архитектура Java Server Pages в самом общем виде представлена на рисунке. Платформа J2EE обеспечивает базу, на которой функционирует все приложение в целом и страницы JSP, в частности, в то время, как сеть Интернет предоставляет механизм транспортировки данных.

Страница JSP располагается на Web-сервере в среде виртуальной Java-машины. Доступ к страниц JSP, как и в случае сервлета, осуществляется через Web с использованием протокола HTTP.

Страница JSP функционирует под управлением JSP Engine (среды исполнения JSP). Страница JSP может взаимодействовать с программным окружением с помощью компонентов JavaBeans, получая и устанавливая его параметры, используя теги: , , .

Компонент JavaBean сам может участвовать в других процессах, предоставляя результаты в виде своих параметров, доступных страницам JSP, участвующим в сеансе, а через них — всем пользователям, запрашивающим эти страницы JSP.

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

Основные модели архитектуры JSP

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

• JSP Model 1 (Первая модель архитектуры JSP);
• JSP Model 2 (Вторая модель архитектуры JSP);

JSP Model 1

Первая модель JSP Model 1 практически реализует базовую архитектуру JSP. В архитектурном решении JSP Model 1 полностью отвечает за получение запроса от клиента, его обработку, подготовку ответа и доставку ответа пользователю. Разделение представления и динамического содержания обеспечивается тем, что доступ к данным осуществляется через компоненты JavaBeans.

В сценарии JSP Model 1 предполагается следующая последовательность действий:

1. Запрос пользователя посылается через Web-браузер странице JSP.
2. Страница JSP компилируется в сервлет (при первом обращении).
3. Скомпилированный сервлет обращается к некоторому компоненту JavaBean, запрашивая у него информацию.
4. Компонент JavaBean, в свою очередь, осуществляет доступ к информационным ресурсам (непосредственно или через компонент Enterprise JavaBeans).
5. Полученная информация отображается в свойствах компонента JavaBeans, доступных странице JSP.
6. Формируется ответ в виде страницы HTML с комбинированным содержанием (статическое, динамическое).

Архитектура JSP Model 1 может с успехом применяться для небольших приложений. Однако использование данной модели для более сложных задач вызывает определенные трудности и не является технологичным из-за большого объема встроенных в страницу программных фрагментов. Для сложных корпоративных приложений рекомендуется применение второй модели архитектуры JSP.

JSP Model 2

Вторая модель JSP Model 2 реализует гибридный подход к обслуживанию динамического содержания Web-страницы, при котором совместно используется сервлет и страница JSP. Эта модель позволяет эффективно использовать преимущества обеих технологий: сервлет поддерживает задачи, связанные с обработкой запроса и созданием объектов JavaBeans, используемых JSP, а страница JSP отвечает за визуальное представление информации. Сервлет используется как управляющее устройство (контроллер). Схематично вторая модель представлена на рисунке.

Сценарии JSP Model 2, как правило реализует следующую типовую последовательность действий:

1. Запрос пользователя посылается через Web-браузер сервлету.
2. Сервлет обрабатывает запрос, создает и инициализирует объект JavaBean или другие объекты, используемые страницей JSP, и запрашивает динамическое содержание у компонента JavaBean.
3. Компонент JavaBean осуществляет доступ к информации непосредственно или через компонент Enterprise JavaBeans.
4. Сервлет, направляющий запрос, вызывает сервлет, скомпилированный из страницы JSP.
5. Сервлет, скомпилированный из страницы JSP, встраивает динамическое содержание в статический контекст HTML-страницы и отправляет ответ пользователю.

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

Архитектуры JSP Model 2 в большей степени, чем архитектура JSP Model 1, соответствует идее отделения представления от содержания. Эта модель позволяет четко выделить отдельные части приложения и связанные с ними роли и обязанности персонала, занятого в разработке:

• Дизайнер — разработка дизайна Web-страницы;
• Разработчик — реализация функций управления и обработки.

Чем сложнее разрабатываемая система, тем заметнее становятся преимущества архитектуры JSP Model 2.

Функционирование JSP

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

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

• фазу трансляции;
• фазу выполнения.

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

Во второй фазе осуществляется обработка запросов и подготовка ответов.

Жизненный цикл JSP

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

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

Трансляция и компиляция страницы JSP

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

• директивы, используемые для управления тем, как Web-контейнер переводит и выполняет страницу JSP;
• скриптовые элементы вставляются в класс сервлета страницы JSP;
• элементы в форме конвертируются в вызов метода для компонентов JavaBeans или вызовы API Java Servlet.

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

Когда страница оттранслирована и откомпилирована, сервлет страницы JSP в основном следует жизненному циклу сервлета, описанному на странице сервлета:

1. Если экземпляр сервлета страницы JSP не существует, контейнер:
   • загружает класс сервлета страницы JSP;
   • создает экземпляр класса сервлета;
   • инициализирует экземпляр сервлета вызовом метода jspInit.
2. Вызывает метод _jspService, передавая ему объекты запроса и отклика.

Если контейнеру нужно удалить сервлет страницы JSP, он вызывает метод jspDestroy.

Пример интеграции JSP-страницы с сервлетом и jQuery можно увидеть здесь.

Java Server Pages

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

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

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

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

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

        
Today  

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

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

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

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

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

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

JavaServer Pages

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

JSP директивы

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

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

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

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

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

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

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

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

 declaration %>  scriptlet %>  expression %>

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

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

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

 jsp comment --%>  html comment --> 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Session value for «My dog» = Ralph

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Упражнения

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

Jsp java что это

20 октября 2023

Скопировано

Java Server Pages (JSP) — технология, позволяющая создавать веб-страницы и Java-приложения со статическим и динамическим содержимым. С ее помощью разработчик может встраивать код Java в обычную HTML-страницу, используя специальные JSP-теги. JavaServer Pages была разработана компанией Sun Microsystem в 1999 году как ответ на коммерчески успешную аналогичную технологию ASP, созданную компанией Microsoft. Сегодня JSP является одним из наиболее распространенных инструментов для создания динамических веб-страниц за счет своей кроссплатформенности, переносимости и легкой масштабируемости.

Освойте профессию «Java-разработчик»

Java-разработчик

Java уже 20 лет в мировом топе языков программирования. На нем создают сложные финансовые сервисы, стриминги и маркетплейсы. Освойте технологии, которые нужны для backend-разработки, за 14 месяцев.

Профессия / 14 месяцев
Java-разработчик

Освойте востребованный язык

Что такое JSP

Типичная веб-страница представляет собой статичный HTML-документ, который в полностью готовом виде хранится на сервере. При запросе пользователя сервер просто «отдает» их его браузеру, который и отображает конечный результат. Чтобы изменить статический контент веб-страницы, необходимо иметь к нему доступ на сервере. Данная технология имеет свои преимущества — в частности, такие страницы проще создавать (не нужно знать языки программирования), они менее требовательны к характеристикам сервера, быстрее загружаются и т.д. Вместе с тем статическое содержимое труднее редактировать, так как это приходится делать постранично, то есть менять его на каждой странице.

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

Java Server Pages — технология, позволяющая объединить в одном веб-документе как статическое, так и динамическое содержимое. Первое представляет собой данные, размеченные в текстовых форматах HTML, SVG, WML, или XML. Динамическое содержимое конструируется JSP-элементами, а также с помощью JSP-тегов и скриптового языка Expression Language. Если проще, то эта технология позволяет разработчикам внедрять Java-код непосредственно в HTML-код, что работает существенно проще и быстрее, чем подгрузка динамических компонентов из отдельного файла.

Как работает JSP Java

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

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

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

• Браузер пользователя посылает на веб-сервер HTTP-запрос, как в случае обычной HTML-страницы.
• Сервер распознает, что запрос относится к JSP-странице, и отправляет его в JSP-движок (контейнер).
• Контейнер, в свою очередь, загружает JSP-файл с диска сервера и превращает его в содержимое сервлета. Это простой процесс, в котором текстовая часть шаблона преобразуется в операторы println (), а JSP-компоненты становятся Java-кодом, который отвечает за динамическую реакцию страницы.
• Далее JSP-движок компилирует сервлет в исполняемый класс и направляет пользовательский запрос уже в механизм сервлета, который загружает класс Servlet и исполняет его. В ходе этого сервлет выводит код страницы в формате HTML и перенаправляет его на веб-сервер.
• Получив ответ от сервлета, сервер направляет HTTP-ответ браузеру пользователя как статический HTML-объект.
• На конечном этапе браузер принимает ответ сервера и внутри него обрабатывает динамически генерируемую HTML-страницу аналогично обычному статическому веб-документу.

Жизненный цикл JSP-страницы включает несколько этапов.

• Перевод (трансляция). На этом этапе жизненного цикла JSP-контейнер переводит JSP-код документа в код Java. Этот процесс происходит автоматически на стороне сервера, который проверяет достоверность страницы и создает для нее сервлет — программный модуль, отвечающий за обработку запроса пользователя.
• Компиляция. Далее JSP-контейнер компилирует Java-код, то есть переводит его на бинарный машинный язык. Перед этим он проверяет необходимость выполнения процесса — она возникает, если страница до этого не компилировалась или была изменена с момента последней компиляции. Сама компиляция осуществляется в три этапа – сначала JSP-контейнер разбирает JSP-код страницы, затем превращает его в сервлет, а потом компилирует его.
• Загрузка и инициализация. JSP-контейнер загружает предварительно сгенерированный сервлет и создает экземпляр соответствующего класса. Затем он инициализирует экземпляр объекта, вызывая метод jspinit () перед обслуживанием запросов. Инициализация выполняется в большинстве случаев только один раз.
• Выполнение. После всех подготовительных этапов JSP-движок начинает обработку запросов. Это осуществляется через сервлет, который вызывает метод _jspService() с двумя параметрами — на поступающие (запрошенные) и отправляемые данные. Для каждого запроса этот метод вызывается только один раз.
• Очистка. Этот этап — логическое завершение жизненного цикла JSP. Как только запрос обработан, JSP-контейнер удаляет JSP-код и готовится повторить цикл снова для следующего запроса.

Станьте Java-разработчиком
и создавайте сложные сервисы
на востребованном языке

Структура JSP-страницы

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

• специальных JSP-тегов , которыми в общем HTML-коде обозначаются начало и конец кода, написанный на Java;
• выражений скриптового языка Expression Language, которые позволяют веб-дизайнерам, не знающим сам язык Java, записывать его код непосредственно на странице и обеспечивать таким образом доступ к Java-компонентам.

Рассмотрим простой пример структуры JSP-страницы:

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

• Фрагмент задает переменную типа String под названием header.
• Фрагмент задает конкретное значение переменной, определенной выше.
• Фрагмент

  Today просто показывает текущую дату.

Загрузим этот файл на сервер, поместив в JSP-контейнер Tomcat. Запустив его и обратившись к приложению через адресную строку браузера, получим следующий результат:

Чтобы начать программировать веб-приложения с помощью JSP, необходимы:

• cреда разработки. Это специальное программное обеспечение, в котором осуществляется создание, тестирование и отладка JSP-документов. Наиболее распространенные среды разработки для работы с Java-компонентами — NetBeans, Eclipse или Java Development Kit. Их необходимо предварительно скачать и установить на компьютер;
• JSP-контейнер. Этот компонент представляет собой сервер, отвечающий за системную поддержку сервлетов и обеспечивающий их жизненный цикл на основе правил, утвержденных в спецификациях. JSP-контейнер способен выполнять функции полноценного веб-сервера, поставлять веб-страницы для другого сервера или встраиваться в сервер приложений Java EE. Одним из самых популярных контейнеров для JSP является Apache Tomcat.

Помимо этого, чтобы разрабатывать веб-страницы на JSP, нужно установить соответствующую библиотеку и сам Java на ПК.

Структура JSP

Технология JSP использует несколько ключевых компонента для написания кода динамических страниц.

• Директивы (directive). Это сообщения для JSP-движка, определяющие, какие действия и в каком порядке он должен выполнить. Например, с их помощью можно задать характеристики страницы, подключить дополнительные ресурсы, использовать нестандартные библиотеки тегов.
• Действия (actions). Этот компонент инкапсулирует функции в тегах, которые встраиваются в код в JSP-страницы. Действия часто исполняются с учетом данных, отправляемых на сервер в запросе от конкретного пользователя. С их помощью также можно создавать Java-объекты, которые используются в скриптлетах JSP.
• Скриптлеты (scriptlets). Они применяются для вставки Java-кода в страницы JSP, взаимодействующего с объектами страницы в процессе обработки запроса.
• Библиотеки тегов (tag library). Этот компонент позволяет расширить функционал страницы за счет создания и использование собственных тегов.
• Объявления (declaration). Они задают переменные, методы, внутренние классы и другие характеристики, которые можно позже применить в коде Java в документе JSP.

Преимущества JSP

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

В сравнении с ASP. Технология активных серверных страниц была предложена в 1997 году компанией Microsoft специально для собственных серверных ОС Windows. На других операционных системах ее использование либо затруднено, либо невозможно. JSP использует Java как язык разработки динамических элементов, что, с одной стороны, упрощает работу, с другой — обеспечивает кроссплатформенность и переносимость веб-приложений на серверы других производителей.

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

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

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

Отдельно стоит сравнить JSP и другую распространенную в прошлом технологию создания динамических сайтов под названием Common Gateway Interface (Общий интерфейс шлюза). Она работает следующим образом:

• веб-сервер, получая запрос от клиентского браузера, преобразует его в CGI-форму;
• затем сервер вызывает обработчик и конвертирует его ответ из CGI-формы в форму HTTP-ответа клиенту.

Несмотря на то, что схема работы CGI выглядит проще, на практике у JSP есть немало преимуществ перед этой устаревшей технологией.

• В CGI для динамических компонентов страниц необходимо создавать отдельные файлы. Такой способ замедляет генерацию содержимого страницы. В JSP динамические компоненты можно встраивать непосредственно в HTML-код, что существенно упрощает разработку и увеличивает скорость загрузки страницы.
• JSP обязательно компилируется сервером перед обработкой, за исключением случаев, когда компиляция уже была осуществлена, а документ с тех пор не менялся. CGI же требует при запросе страницы всегда требует загрузки интерпретатора и целевого скрипта.
• Страницы JavaServer надстраиваются над API сервлетов Java, поэтому JSP доступны все мощные API-интерфейсы Enterprise Java, в том числе JDBC, JNDI, EJB, JAXP и другие.
• JSP-технологию можно комбинировать с «чистыми» сервлетами, обрабатывающими бизнес-логику, модель, которую поддерживают механизмы шаблонов сервлетов Java.

Недостатки JSP

К наиболее заметным недостаткам JSP-технологии относятся следующие.

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

Заключение

Изначально JSP была создана как ответ на коммерчески успешную ASP, разработанную компанией Microsoft, с которой корпорация Sun Microsystems конкурировала в конце 90-х годов прошлого века. Однако, со временем эта технология претерпела ряд важных изменений и превратилась в самодостаточный инструмент, который сегодня используется при разработке множества веб-приложений.

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

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

Статьи по теме: