JSP (JavaServer Pages ) - технология, позволяющая веб-разработчикам легко создавать содержимое, которое имеет как статические, так и динамические компоненты. По сути, страница JSP является текстовым документом, который содержит текст двух типов: статические исходные данные, которые могут быть оформлены в одном из текстовых форматов HTML , SVG , WML , или XML , и JSP элементы, которые конструируют динамическое содержимое. Кроме этого могут использоваться библиотеки JSP тегов, а также (Expression Language), для внедрения Java-кода в статичное содержимое JSP-страниц.
JSP - одна из высокопроизводительных технологий, так как весь код страницы транслируется в java-код сервлета с помощью компилятора JSP страниц Jasper , и затем компилируется в байт-код виртуальной машины java (JVM). Контейнеры сервлетов , способные исполнять JSP страницы, написаны на языке Java, который может работать на различных платформах. JSP страницы загружаются на сервере и управляются из структуры специального Java server packet, который называется Java EE Web Application, в большинстве своём упакованные в файловые архивы .war и .ear .
Выгода, которую дает технология JSP в сравнении с другими веб-технологиями заключается в том, что JSP является платформонезависимой, переносимой и легко расширяемой технологией для разработки веб-приложений.
Начиная с версии 1.2, JavaServer Pages были разработаны в рамках Java Community Process . JSR 53 определяет оба стандарта JSP 1.2 и Servlet 2.3, а JSR 152 определяет спецификацию JSP 2.0. В мае 2006 года JSP спецификация 2.1 была выпущена под JSR 245 в рамках Java EE 5 . 10 декабря 2009 года была выпущена спецификация JSP 2.2 как содержание выпуска JSR 245.
Необходимо отметить, что эти версии кардинально отличаются от версий предыдущих, которые в свою очередь воспринимались больше, как ответ Java на ASP . Некоторые основные возможности и трюки прошлых версий были убраны или заменены другими. Например, возможность разрабатывать библиотеки тегов. Главной идеей было разделение кода и содержимого. Так как в больших объемах исходного кода трудно сориентироваться и отделить контент от самого кода, то пришла идея их разделить (перенести) с помощью JSP тегов таких как например
JSP 1.2 расширяет спецификацию JavaServer Pages 1.1 (JSP 1.1) следующим образом:
Новая версия спецификации JSP дополнена функциональностью увеличивающей скорость работы программиста. А именно:
Hello, ${ param.visitor } <% -- аналогично коду: Hello, <% =request.getParameter ("visitor" ) %> --%>
Платформа Java EE 5 главным образом фокусируется на простую разработку используя языковые аннотации Java, которые были введены J2SE 5.0 . JSP 2.1 поддерживает эту цель определением аннотаций для зависимых инъекций в JSP операторах и в контекстных слушателях (Listeners).
JavaServer Pages (JSP) позволяют отделить динамическую часть страниц от статического HTML . Процедура довольно проста, создаёте обычный код HTML (статический), а динамическую часть заключаете в специальные теги "<% %>" .
Имя вашего хоста: <% = request.getRemoteHost () %>
JSP страницы имеют расширение.jsp и размещаются там же, где и обычные Web страницы. Структура таких страниц может состоять из пяти конструкций: HTML , комментарии, скриптовые элементы, директивы и действия. JSP страница при компиляции преобразуется в обычный сервлет со статическим содержимым, которое направляется в поток вывода, связанный с методом service. Поэтому при первом запросе этот процесс может вызвать некую задержку, но в большинстве своём незаметную первому пользователю. Комментарии в документе или программе служат к объяснению содержимого. Они не являются причиной замедления программы, так как транслятор и исполнитель их игнорируют. Скриптовые элементы позволяют вам указать код на языке Java , который впоследствии станет частью конечного сервлета, директивы дадут вам возможность управлять всей структурой сервлета, а действия служат для задания существующих используемых компонентов, а также для контроля над поведением движка JSP. Для упрощения работы со скриптами имеются заранее определённые переменные, такие как request, response, pageContext, session, out, application, config, page, exception . Пример JSP страницы с использованием всех составляющих JSP конструкции:
Комментарии используются для пояснения исходного текста программы. В JSP-страницах комментарии можно разделить на две группы:
Комментарии исходного кода JSP отмечаются специальной последовательностью символов: <%-- в начале и --%> в конце комментария. Данный вид комментариев удаляется на этапе компиляции JSP-страницы и потому не доступны пользователям. Пример JSP-комментария:
<% -- Отобразит каталог изделий и актуальную корзину покупателя. --%>
Комментарии HTML -разметки оформляются в соответствии с правилами языка HTML. Данный вид комментариев рассматривается JSP-компилятором как статический текст и помещается в выходной HTML-документ. JSP-выражения внутри HTML-комментариев исполняются. Пример HTML-комментария:
-->
Спецификация JSP различает три типа скриптовых элементов:
Объявления обычно используются для определения переменных, методов, внутренних классов и остальных действующих Java конструкций на уровне класса. В выражения вкладываются любые действующие выражения Java. С помощью скриплетов в JSP страницы вкладываются работающие части кода Java. Все эти элементы начинаются знаками <% и заканчиваются %> . Обратите внимание и на то, что все скриптовые элементы отличаются немного записью конструкции. Объявления используют восклицательный знак (! ) в конструкции (<%! %>), а выражения знак равенства (=) (<%= %>), в то время как скриплеты используют стандартный формат записи (<% %>).
Объявления JSP позволят вам задавать переменные, методы, внутренние классы и так далее. Другими словами объявления Вы используете для определения конструкций Java, которые Вы в программе используете. Так как объявления не осуществляют вывода, то обычно они используются совместно с JSP выражениями или скриплетами. В приведённом в качестве примера фрагменте JSP отображается количество запросов к данной странице с момента загрузки сервера (или с момента последнего изменения и перезагрузки сервлета). Обратите внимание, что в примере мы используем как объявление, так и выражение и что внутри конструкции после объявления стоит точка с запятой (; ):
<%! private int accessCount = 0 ; %> Количество обращений к странице с момента загрузки сервера: <% = ++accessCount %>
Выражения JSP применяются для того, чтобы вставить значения Java непосредственно в вывод. Выражения Java вычисляются, конвертируются в строку и вставляются в страницу. Эти вычисления проходят во время выполнения (то есть при запросе страницы), а потому существует полный доступ к информации о самом запросе. В выражениях можно использовать постоянные, переменные, вызовы различных методов. Все выражения, вне зависимости от сложности их содержимого, вычисляются в один результат или число. JSP страницы полагаются на JSP Writer, который берёт любой результат выражения, переводит его в тип String (текстовый) и заносит в буферную память. Например, следующий код служит для отображения даты и времени запроса данной страницы:
Текущее время: <% = new java.util .Date () %> Имя вашего хоста: <% = request.getRemoteHost () %>
Необходимо обратить внимание на три правила:
Если вы хотите сделать что-то большее чем просто вставку выражений, то скриплеты JSP дадут вам возможность вставить любой код в метод сервлета, который будет создан при обработке данной страницы. В данном случае Вы можете использовать большинство конструкций Java. Скриплеты также имеют доступ к тем же заранее определённым переменным, что и выражения. Поэтому, например, если вы хотите вывести что-нибудь на страницу, вы должны использовать заранее определённую переменную out .
<% String queryData = request.getQueryString () ; out.println ("Дополнительные данные запроса: " + queryData) ; %>
Обратите внимание на то, что код внутри скриплета вставляется в том виде, как он был записан, и весь статический HTML (текст шаблона) до или после скриплета конвертируется при помощи оператора print . Например, следующий фрагмент JSP содержит смешанный текст шаблона и скриплета:
<% if (Math .random () < 0.5 ) { %> < B> Удачного< /B> вам дня! <% } else { %> < B> Неудачного< /B> вам дня! <% } %>
После преобразования скриплета код будет выглядеть следующим образом:
If (Math .random () < 0.5 ) { out.println ("Удачного вам дня!" ) ; } else { out.println ("Неудачного вам дня!" ) ; }
Это означает, что скриплеты не обязательно должны содержать завершённые фрагменты Java, и что оставленные открытыми блоки могут оказать влияние на статический HTML вне скриплета.
JSP страница может послать сообщение соответствующему контейнеру с указаниями какие действия необходимо провести. Эти сообщения называются директивами. Все директивы начинаются с <%@ , затем следует название директивы и один или несколько атрибутов со значениями, и заканчиваются %> . Директивы в JSP странице приводят к тому, что контейнер пошлёт заявку на исполнение определённой службы, которая в генерированном документе не объявляется. Форму записи директив можно изобразить следующим образом:
<% @ директива атрибут="значение" %>
Вы также можете объединить установку нескольких атрибутов для одной директивы:
<% @ директива атрибут1 ="значение1" атрибут2 ="значение2" ... атрибутN="значениеN" %>
Существует три основных типа директив: page , которая позволяет вам совершать такие операции, как импорт классов, изменение суперкласса сервлета, и т. п.; include , которая даёт вам возможность вставить файл в класс сервлета при трансляции JSP файла в сервлет; и taglib , позволяющий расширить множество тегов своими собственными, которые JSP контейнер способен истолковать.
Как можно догадаться из названия, данная директива предоставляет атрибуты для JSP страницы. Атрибуты, определённые в этой директиве, внедряются в данную JSP страницу и на все её вложенные статические элементы, независимо от того были ли они вставлены с помощью директивы include или с помощью действия jsp:include . Форма записи директивы page следующая:
<% @ page атрибут=“значение“ %>
В качестве примера приведём следующую запись:
<% @ page import =”java.util .* , com.myclasses .* ”, buffer=”15kb” %>
Эта директива заявляет, что JSP страница импортирует классы из двух пакетов Java, java.util и com.myclasses , а потом уточняет размер буферной памяти, которая должна быть использована для обработки данной JSP страницы.
<% @ page import ="java.util.Date, javax.text.SimpleDateFormat, com.myclasses.*" %>
<% @ page language=”java” %>
<% @ page extends =”mojPaket.PrimerHttp ” %>
<% @ page session=”false ” %>
<% @ page buffer=”12kb” %>
<% @ page buffer=”16kb” autoflush=”true ” %>
<% @ page isThreadSafe=”false ” %>
<% @ page info=” версия:1.0 ” %>
<% @ page errorPage=“/myweb/errors/myerror.jsp “ %>
<% @ page isErrorPage=”true ” %>
<% @ page contentType="text/plain" %>
Того же результата можно добиться и использованием скриплета:
<% response.setContentType ("text/plain" ) ; %>
Эта директива позволяет Вам включать файлы в сервлет в процессе трансляции JSP страницы. Использование директивы выглядит следующим образом:
<% @ include file="относительный url" %>
Заданный URL обычно интерпретируется относительно JSP страницы, на которой расположена ссылка, но, как и при использовании любых других относительных URL вы можете задать системе положение интересующего вас ресурса относительно домашнего каталога Web сервера, добавив в начало URL символ «/ ». Содержимое подключаемого файла обрабатывается как обычный текст JSP и поэтому может включать такие элементы как статический HTML , элементы скриптов, директивы и действия. Например, многие сайты используют небольшую панель навигации на каждой странице. В связи с проблемами использования фреймов HTML часто эта задача решается размещением небольшой таблицы сверху или в левой половине страницы, HTML код которой многократно повторяется для каждой страницы сайта. Директива include наиболее естественный способ решения этой задачи, избавляющий разработчика от кошмара рутины копирования HTML в каждый отдельный файл. Это происходит следующим образом:
< html> < head> < title> Тестовая страница< /title> < /head> < body> <% @ include file="/navbar.html" %> < /body> < /html>
Учтите что поскольку директива include подключает файлы в ходе трансляции страницы, то после внесения изменений в панель навигации вам потребуется повторная трансляция всех использующих её JSP страниц. Что в данном случае является хорошим компромиссом, поскольку как правило панель навигации меняется достаточно редко и процесс подключения не теряет своей эффективности. Если же подключённые файлы меняются довольно часто, вы можете использовать вместо этого действие jsp:include . Это действие подключает файл в процессе обращения к JSP.
Как уже известно, в JSP страницах элементы записываются с помощью знаков (условных знаков, меток, марок). Множество знаков, которые JSP контейнер способен истолковать, можно расширить с помощью так называемых библиотек знаков. Также к расширенному множеству знаков можно присоединять действия, вследствие чего происходит расширение самого языка JSP. Действия можно разделить на стандартные и собственные. Обобщённый способ записи может выглядеть так:
<% @ taglib uri=”URI к библиотеке знаков” prefix=“префикс знака“ %>
Библиотеку знаков необходимо идентифицировать с помощью URI адреса (уникального идентификатора ресурса). URI может быть как абсолютным так и отностительным. Уникальный идентификатор ресурса определяет расположение библиотеки знаков (TLD), который определяет собственные знаки этой библиотеки. Пример записи директивы:
<% @ taglib uri=”http://www.moywebserver.ru/naydiznaki.tld” prefix=”iskat” %>
JSP страница может содержать бесконечное кол-во директив taglib , но для каждой директивы необходимо установить различные префиксы, которые определяют содержимое библиотеки на странице. В качестве префикса можете использовать какой угодно текст, слово. В то время, как директиву taglib можно использовать где угодно на JSP странице, все собственные знаки, которые эти директивы используют, должны использоваться за ними.
Действия JSP используют конструкции с синтаксисом XML для управления работой движка сервлета. Вы можете динамически подключать файл, многократно использовать компоненты JavaBeans , направить пользователя на другую страницу или сгенерировать HTML для Java plugin. Все эти действия детально рассмотрены далее. Помните что как и во всем XML , имена элементов и атрибутов регистрозависимы. Действия можно разделить на две группы: стандартные и созданные (собственные, что создает сам программист). Допустимо применение следующих стандартных действий:
Это действие позволяет загружать JavaBean для последующего использования на JSP странице. Эта возможность позволяет многократно использовать классы Java, не отказываясь при этом от преимуществ, предоставляемых сервлетами JSP. Помимо этого, это один из способов, как большую часть обработки Java исключить из JSP страницы. Если перенести обработку Java из JSP страницы до JavaBean, то потом эти функции можно использовать и в остальных JSP страницах. Простейший синтаксис для указания используемого bean:
< jsp:useBean id="имя" class ="пакет.class" />
Как правило это означает «создание нового экземпляра объекта класса, заданного через class , и его связь с переменной с именем, заданным при помощи id ». Однако можно задать атрибут scope (принимает значения page|request|session|application , page для страницы, request для запросов, session для сессий или диалогов, application для аппликаций), который ассоциирует bean не только с текущей страницей. В таком случае, полезно получить ссылки на существующие beans , и действие jsp:useBean создает экземпляр нового объекта лишь в том случае если не существует ни одного объекта с теми же значениями id и scope . Теперь, когда у вас есть bean , вы можете изменять его свойства при помощи действия jsp:setProperty , или используя для этого скриплет и явно вызывая метод объекта с именем переменной заданном ранее через атрибут id . Recall that with beans , когда вы говорите «у этого bean есть свойство типа X с названием foo », вы на самом деле имеете ввиду «у этого класса есть метод getFoo , который возвращает данные типа X, и другой метод setFoo , которому в качестве параметра передается X.» Действие jsp:setProperty более подробно рассмотрено в следующем разделе, но сейчас вы должны запомнить что вы можете либо явно задавать value , задавая атрибут param , чтобы получить значение из соответствующего параметра запроса, или просто перечислить свойства, чтобы получить значения из параметров запроса с теми же именами что и свойства. Вы можете получить значения существующих свойств при помощи выражений JSP или скриплетов, вызвав соответствующий метод getXxx , или (чаще всего), воспользовавшись действием jsp:getProperty .
Класс, заданный для bean, должен находиться в обычном каталоге классов сервера, а не в части, зарезервированной для классов, автоматически перезагружаемых после редактирования. Например, для Java Web Server, все используемые классы должны размещаться в каталоге classes или в .jar файле каталога lib , а не в каталоге servlets . Ниже приведен простой пример, загружающий bean и устанавливающий/получающий простой строковый параметр.
BeanTest.jsp
"-//W3C//DTD HTML 4.0 Transitional//EN" > < html> < head> < title>< /title> < /head> < body> < h1> Многократное использование JavaBeans в JSP< /h1> < jsp:useBean id="test" class ="hall.SimpleBean" /> < jsp:setProperty name="test" property="message" value="Привет, WWW" /> < p> Сообщение: < jsp:getProperty name="test" property="message" /> < /p> < /body> < /html>
SimpleBean.java
Package hall ; public class SimpleBean { private String message = "Текст сообщения не задан" ; public String getMessage() { return (message) ; } public void setMessage(String message) { this .message = message; } }
Еще несколько деталей о использовании jsp:useBean . Простейший способ использовать bean - это использование конструкции:
< jsp:useBean id="имя" class ="пакет.class" />
для загрузки bean , а затем использовать jsp:setProperty и jsp:getProperty для модификации и получения его свойств (параметров). Однако существуют еще два других способа. Во-первых, вы можете использовать формат контейнера, а именно:
< jsp:useBean ...> Тело < /jsp:useBean>
для того чтобы обеспечить выполнение Тела только в том случае, если экземпляр bean создается впервые, а не тогда, когда находится и используется уже существующий bean . Как обсуждается далее, beans могут совместно использоваться, поэтому не каждое выражение jsp:useBean приводит к созданию экземпляра нового bean . Во-вторых, кроме id и class , существуют еще три других атрибута, которые вы можете использовать: scope , type , и beanName . Эти атрибуты описаны далее:
Вы можете использовать jsp:setProperty для присвоения значений свойствам ранее описанных beans . Вы можете делать это двумя способами. Во-первых, вы можете использовать jsp:setProperty после, но вне элемента jsp:useBean , так как это показано в примере:
< jsp:useBean id="myName" ... /> ... < jsp:setProperty name="myName" property="someProperty" ... />
В этом случае jsp:setProperty выполняется независимо от того, был ли найден существующий bean или был создан новый экземпляр. Другим вариантом заключается в размещении jsp:setProperty в теле элемента jsp:useBean , как это показано в другом примере:
< jsp:useBean id="myName" ... > ... < jsp:setProperty name="myName" property="someProperty" ... /> < /jsp:useBean>
При этом jsp:setProperty выполняется лишь в том случае, если был создан новый экземпляр объекта, а не тогда, когда находится уже существующий. Действие jsp:setProperty допускает применение следующих четырех атрибутов:
< jsp:setProperty name="orderBean" property="numberOfItems" param="numItems" />
Если вы не используете ни value , ни param , это приравнивается к тому, как если бы вы задали имя param совпадающее с именем property . Вы можете применить этот принцип автоматического использования свойств запроса, чьи имена совпадают с именами свойств и пойти далее, задав в качестве имени свойства «* » и опустив параметры value и param . В этом случае сервер обработает допустимые свойства и параметры запроса, на предмет совпадения их с идентичными именами. Далее приведен пример в котором используется bean для создания таблицы простых чисел. Если существует параметр numDigits в данных запроса, он передается в свойство bean numDigits . Аналогично для numPrimes . JspPrimes.jsp
"-//W3C//DTD HTML 4.0 Transitional//EN" > < html> < head> < title> Многократное использование JavaBeans в JSP< /title> < /head> < body> < h1> Многократное использование JavaBeans в JSP< /h1> < jsp:useBean id="primeTable" class ="hall.NumberedPrimes" /> < jsp:setProperty name="primeTable" property="numDigits" /> < jsp:setProperty name="primeTable" property="numPrimes" /> < p> Несколько < jsp:getProperty name="primeTable" property="numDigits" /> символьных простых чисел: < jsp:getProperty name="primeTable" property="numberedList" /> < /p> < /body> < /html>
Этот элемент определяет значение свойства bean , конвертирует его в строку и направляет в поток вывода. Для выполнения действия требуется задание двух атрибутов: имени bean , которое предварительно задается в действии jsp:useBean , и имя свойства, значение которого должно быть определено. Далее приведен пример использования этого действия:
< jsp:useBean id="itemBean" ... /> ... < UL> < LI> Количество предметов: < jsp:getProperty name="itemBean" property="numItems" /> < LI> Цена за штуку: < jsp:getProperty name="itemBean" property="unitCost" /> < /UL>
Это действие позволяет вставлять содержимое файлов в генерируемую страницу. Синтаксис действия:
< jsp:include page="относительный URL" flush="true" />
В отличие от директивы include , которая вставляет файл на этапе трансляции JSP страницы, это действие вставляет файл при запросе страницы. Это приводит к некоторой потере эффективности и исключает возможность наличия во вставляемом файле кода JSP, но зато дает существенное преимущество в гибкости.
Пример вставки содержимого четырех файлов в JSP-страницу:
"http://www.w3.org/TR/html4/strict.dtd" > < html> < head> < title> Новости< /title> < /head> < body> < h1> Новости< /h1> < p> Вот фрагменты наших четырех самых популярных статей:< /p> < ol> < li>< jsp:include page="news/Item1.html" flush="true" />< /li> < li>< jsp:include page="news/Item2.html" flush="true" />< /li> < li>< jsp:include page="news/Item3.html" flush="true" />< /li> < li>< jsp:include page="news/Item4.html" flush="true" />< /li> < /ol> < /body> < /html>
Это действие позволяет вам передать запрос другой статической HTML странице, сервлету или JSP странице. В отличие от действия jsp:include обработка актуальной страницы заканчивается. Оно использует один атрибут page , который должен содержать относительный URL и на основании которого упорядочен объект request . К исходным параметрам запроса, которой передается другой странице, можете с помощью действия jsp:param добавить и другие параметры. Значением атрибута page может быть как статическое значение, так и вычисляемое в процессе запроса, что и показано на следующих двух примерах:
< jsp:forward page="/utils/errorReporter.jsp" /> < jsp:forward page="<%= какое-нибудьВыражениеНаJava %>" />
Также с помощью действия jsp:forward можно передать управление на другую страницу, но с условием, что перед вызовом этого действия ничего не было записано в выходящую буферную память (иначе будет вызвано исключение IllegalStateException).
Это действие предоставляет информацию типа название/значение. Данное действие используется в основном вместе со знакомыми уже действиями jsp:include и jsp:forward . Кроме этого его можно использовать и вместе с действием jsp:plugin . В остальных случаях использование этого действия не имеет значения. Использование jsp:param с действиями jsp:include и jsp:forward передаться новым страницам исходный объект request , который будет расширен на новые параметры. Если Вы зададите новые значения для уже существующих параметров, то именно новые значения будут иметь преимущество. С помощью действия jsp:params можно задать сразу несколько параметров
Это действие позволяет вам вставить элемент OBJECT или EMBED (в зависимости от типа используемого браузера), необходимый для запуска аплетов, использующих plugin Java. Другими словами данное действие служит к генерированию HTML для вложения Java API в JSP страницу. Таким же образом можете вставлять URL для скачивания модулей для Java API от JavaSoft, который предоставляет возможность запускать аплеты внутри браузера. Форма записи данного действия выглядит следующим образом.
Начнем с того, где мы будем хранить наш код и как обмениваться им с друзьями. Думаю, не все начинающие знают про репозитории, и эта часть именно для них.
После всего этого у Вас будет ссылка на Ваше пространство. Чтобы понять, что это такое - нужно взять один из ваших проектов (или создайте какой нибудь пустой проект в NetBeans). Нажимаете на нем правой кнопочкой и у Вас в меню будет доступно «Управление версиями» -> «импортировать в репозиторий Subversion». После этого будет диалоговое окно, в котом будет путь к репозиторию - это ссылка которую Вы получили на сайте во вкладке «Исходный код».
Далее, полностью удалите проект, который вы закоммитили. Дальше зайдите в папку, где у вас проекты хранятся, и проверьте что реально все удалено. Потом возвращаетесь в NetBeans и ищете в панели меню вкладку Группа(на панели где Файл, Вид, Правка, Переход, Источник...) в нем есть наш Subversion. И в подменю на нем есть «Получить». Дальше в диалоговых окнах надо будет указать ссылку на репозиторий (это ссылка которую вы получили на сайте во вкладке «Исходный код».) И когда он предложит выкачивать папки, то по дереву репозитория нужно будет найти ваш проект и выбрать его, и по окончанию вы выкачаете свой проект. Вот так происходит обмен кодом.
Ваш проект будет постоянно синхронизироваться с репозиторием и помечать файлы, которые были изменены, или новые(то что отличается от версии на репозитории). Чтобы обновить, нужно вызвать контекстное меню, и в закладке «Управление Версиями» будет большой список того, что можно делать с проектом. «Обновлять» - это обновить свои файлы; «Фиксировать» - ложить код который Вы написали или изменили в репозиторий; «Сбрасывать» - возвращаться к версии на репозитории, и «Сравнивать» - отображение изменений строк которые отличаются от удаленных. Это способ командного обмена кодом, который используется всегда и нужно к нему привыкать.
Вы уже скачали NetBeans, поигрались с SVN - теперь перейдем к делу. Создаете проект. Нажимаете «Создать проект», там выбираете Maven-> Веб-приложение. Называете как хотите, это все Ваша фантазия. Итак, у нас есть веб-приложение, сборка нашего проекта идет мавеном, у нас есть цель и теперь наступило время подумать над тем, как ее осуществить. То есть Вы, как разработчик, должны подумать над тем, как будет выглядеть Ваше приложение, какую иметь архитектуру, дерево пакетов и так далее. Общее количество строк кода здесь около 4000 и лучше позаботиться о красивой архитектуре заранее, иначе потом Вы просто не будете понимать что где и как у Вас работает, каким чудом Вы, к примеру, выводите последнюю купленную вещь, как считаете общую сумму покупок. И если Вас потом попросят что-то доделать или добавить - Вы осознаете что проще написать все с нуля.
Ну и конечно нам нужно прикинуть наш план действий.
2) Создаем HibernateUtil (вообще суффикс или приставка Util подразумевает, что код в этом классе есть универсальный и используется множеством классов).
Итак, в HibernateUtil мы размещаем SessionFactory. Он тяжеловесный. Этот код, по идее, должен быть независим от всего приложения, так как он устанавливает соединение с базой данных при старте и должен нам давать только Сессии с базой данных. Еще мы в этом классе регистрируем наши классы-сущности. Подробнее про этот класс расскажу позже. Засунем его тоже в отдельный пакет, к примеру, edu.shop.model.hbutil.HibernateUtil.java
3) Пишем DAO.
Что в нем писать? Пишем то, что мы хотим получить от базы данных, но нам не нужно думать как получились эти данные, важен результат. К примеру, мы определяем интерфейс ProductDAO и пишем в нем методы
List
В чем идея? Если бы это приложение писал я и Вы, Вы бы сказали: «Миха, мне нужны от БД следующие данные: все товары что у меня есть в БД». Я отвечаю: «не вопрос». И далее следующее развитие событий: вы в своем коде, везде где нужно делать запросы к базе пишете следующее%
*здесь обращение к методу*.getAllProducts(); - и видите, что компилятор не ругается, а реализацию этого интерфейса я мог еще не успеть написать. И какой итог? У Вас все скомпилилось, а рабочего кода даже нет. Здесь мы применим Enums и паттерн Factory, и еще кое-что, но всему свое время. Именно в DAO нужно уделить особое внимание обработке исключений, хотя бы генерировать страницы с ошибками. Чтобы Вы быстро находили кусок неработающего кода. Иначе, Вы просто замучаетесь с отладкой.
3)Здесь начнется наша работа с Spring MVC. Это долгая история и этому будет посвящена отдельная статья. Сразу скажу - это самое сложное в этом приложении. Но я Вам покажу и более простой вариант, как выводить все, не особо заботясь про паттерн MVC.
Затронем использование скриплетов.
4) Здесь у нас будут вспомогательные классы, добавляющие всякие вкусности в наш проект: подсчет общей суммы покупок; последняя купленная вещь; вспомогательные переменные, которые пригодятся нам для работы метода, который, к примеру, будет выводить нам с БД вещи не дороже 5000 грн, или не дешевле 500; вывод всех ноутбуков марки Асус. Этот пункт тесно взаимосвязан с предыдущим.
Пока остановимся на этом. С остальным разберемся чуть позже. Итак, у нас есть намеченный план, приступим к его реализации.
Примечание. Корзина, в которой будут храниться наши купленные товары, будет как таблица в БД, это я сделал т.к на ней покажу некоторые основы работы с БД. Для реального случая целесообразнее будет использовать коллекции для хранения наших товаров.
1) Product
2) Notebook
3) Camera
4) Book
5) Cable
6) Customer
7) Cart
Поговорим немного о том, что такое класс-сущность.
Entity (Сущность) - POJO-класс, связанный с БД с помощью аннотации (@Entity) или через XML. К такому классу предъявляются следующие требования:
Должен иметь пустой конструктор (public или protected);
- Не может быть вложенным, интерфейсом или enum;
- Не может быть final и не может содержать final-полей/свойств;
- Должен содержать хотя бы одно @Id-поле.
При этом entity может:
Entities могут быть связаны друг с другом: один-к-одному, один-ко-многим, многие-к-одному и многие-ко-многим.
Использовать мы будем аннотации. И тут сразу у нас появляется возможность описать двумя способами. Либо мы будем писать аннотации непосредственно над полями, либо над геттерами. Скажу одно: правильно писать над геттерами, а причину Вы спросите в гугле. Не могу я все темы абсолютно здесь описать.
Есть еще одно что хочу сказать. Для этого придется показать 2 примера описания класса сущности. Итак, первый пример:
Коментарии к нему я написал в самом коде:
Import java.io.Serializable; import javax.persistence.*; import javax.validation.constraints.Size; /** * * @author Mikhail Shumenko */ @Entity //Этой аннотацией мы указываем, что данный класс является сущностью. @Table(name = "CART")// Этой аннотацией мы указываем, что за эту сущность в БД отвечает таблица с именем CART //Хочу отметить, что регистр не важен, эту анотацию можно не указывать, тогда хибернейт создаст нам БД с //именем как у класса public class CartEntity implements Serializable { //Здесь мы пишем аннотации над полями. Правильно писать над геттерами //Описываем Id таблицы @Id //Указываем, что это поле класса отвечает за столбец в таблице с именем Id //Если мы его указывать не будем, хибернейт создаст столбец с именем как у поля. @Column(name = "ID") //Здесь написать можно много)) Почему я написал здесь так? В общем можно в //@GeneratedValue(strategy=GenerationType.вместо TABLE написать AUTO) тогда //при первой загрузке таблицы, Id сгенерируются автоматически от 1 до своего максимального значения. //Если у вас 20 вещей в таблице, то сгенерируется от 1 до 20. //Но при последующих добавлениях, id у добавленной вещи будет примерно таким - 345768. //Я написал все так, чтобы последний мой id хранился в таблице и генерировался потом адекватно при последующих добавлениях. //Также есть SEQUENCE, но он не поддерживается в Derby, а работать мы будем именно с ней. //В общем, это нюансы. Можете узнать про них самостоятельно @TableGenerator(name = "cartid", table = "cartpktb", pkColumnName = "idCart", pkColumnValue = "idCartValue",allocationSize = 1) @GeneratedValue (strategy = GenerationType.TABLE, generator = "cartid") private Integer id; //Указываем максимальный размер. Это строка из 25 символов. @Size(max = 25) @Column(name = "NAMEITEM") //Если тип нашего поля String, то и создаваться будет столбец с типом VARCHAR(в Derby) //Если Integer, то будет столбец, в который поместить можно только Integer //boolean в Derby - это столбец с типом SMALLINT private String nameItem; @Column(name = "PRICE") private Integer price; public CartEntity() { } public CartEntity(String nameItem, int price) { this.nameItem = nameItem; this.price = price; } public CartEntity(Integer id,String nameItem, int price) { this.id=id; this.nameItem = nameItem; this.price = price; } public CartEntity(Integer id) { this.id = id; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getNameItem() { return nameItem; } public void setNameItem(String nameItem) { this.nameItem = nameItem; } public Integer getPrice() { return price; } public void setPrice(Integer price) { this.price = price; } }
Итак, у Вас есть два примера классов сущностей. Создайте остальные, используя эти примеры. Такие поля как: модель, год публикации, имя, стоимость - все на Вашу фантазию. Включите обязательно поле Available(в переводе наличие). Оно Вам потом пригодится. Можете сделать его булевым и добавить столбец с именем количество. Это все нам пригодится.
Его смысл:
- Весь доступ к базе данных в системе производится через DAO для инкапсуляции.
- Каждый экземпляр DAO отвечает за один первичный доменный объект или сущность. Если доменный объект имеет независимый цикл жизни, он должен иметь свой собственный DAO.
- DAO отвечает за операции создания, чтения (по первичному ключу), обновления и удаления (то есть, CRUD (create, read, update, delete)) доменного объекта.
- DAO может разрешать запросы, основанные на критерии, отличном от первичного ключа. Я ссылаюсь на такие методы как finder или finders. Метод finder обычно возвращает коллекцию доменных объектов, за которые отвечает DAO.
- DAO не занимается обработкой транзакций, сессий или соединений. Это делается вне DAO для обеспечения гибкости.
Подробнее всегда расскажет гугл.
Мы пока напишем DAO для наших продуктов.
Итак, подумаем что нам вообще нужно. Таблица Product будет иметь 4 поля Id,nameProduct,available+amount+actionForServlet. Она нам будет нужна, чтобы создать на нашем сайте категории. Над последним полем пока не заморачиваемся. Единственное что нам нужно - это получение списка продуктов.
Пишем интерфейс
public interface ProductDAO {
ProductDAO INSTANCE_PRODUCT= new ProductDAOImpl();
List
Реализация нашего интерфейса. Пояснения смотрим в коде
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package edu.shop.model.dao;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Session;
/**
*
* @author Mikhail Shumenko
*/
public class ProductDAOImpl implements ProductDAO {
@Override
public List
Итак, теперь у нас есть возможность получать данные из БД. Вы можете, используя скриплеты, создать незамысловатый цикл for-each и вывести свою продукцию на вашу страницу index.jsp
| Категория | //INSTANCE_PRODUCT что это такое? //В ProductDAO описана такая переменная, отвечает за создание ProductDAOImpl //Ну у нас все будет по-другому, можете особо не запоминать это. //ProductDAO INSTANCE_PRODUCT= new ProductDAOImpl(); <% for (Product product:ProductDAO.INSTANCE_PRODUCT.getProducts()) {%>"><%=product.getName()%> | <%}%>
|---|---|
| Наличие | <% for (Product product: ProductDAO.INSTANCE_PRODUCT.getProducts()) {%><%=product.getAvailable()%> | <%}%>
Но это на первое время, а вообще так делать плохо. Это нарушает наш паттерн MVC. Как сделать правильно я объясню в следующем уроке, если мне дадут инвайт. Во втором уроке мы займемся Spring, в третьем коснемся паттерна Factory, и углубимся в хибернейт. Для особо нетерпеливых, покажу как нужно удалять из БД, сохранять в БД и удалять полностью все из БД. Ну, а как сделать, чтобы все это взаимодействовало в целом с нашим приложением и подробное рассмотрение оставим на потом.
Также Вам нужен будет файл настройки Hibernate. Создайте в Derby БД shop. Имя и пароль пользователя root и pass соответственно. Если не получится - не расстраивайтесь - я уделю еще этому время.
О том, как заполнять наши БД поговорим позже. Можете заполнить их вручную. Либо дождаться следующего урока.
JSP (Java server pages) — это технология, которая позволяет внедрять Java-код, а также EL (expression language) в статичное содержимое страницы) и позволяющая веб-разработчикам динамически генерировать HTML, XML и другие веб-страницы. JSP является составной частью единой технологии создания бизнес-приложений J2EE.
JSP — может выполняться практически на любом веб сервере, так как эта технология основана на языке программирования Java, который не зависит от платформы. Java server pages поддерживает теги HTML, Javascript, а также собственный набор тегов.
JSP — позволяет отделить динамическую часть страницы от статической. Эта технология предусматривает вставку Java кода в страницу. Мы не будем рассматривать такой вариант использования JSP поскольку эта технология считается устаревшей и несовершенной. Причина проста: разработчики дизайнеры, которые разрабатывают внешний вид страницы не всегда могут быть знакомы с Java и это может вызвать дополнительные трудности при редактировании или поддержке веб приложений.
Вместо вставки Java кода сейчас используется библиотека тегов jstl или Javascript для совсем продвинутых. Мы рассмотрим пример именно с jstl тегами. Это очень удобная библиотека, которая имеет почти весь функционал, который необходим при создании динамических страниц. Если нужно что-то специфическое, то всегда можно написать собственный тег и вставить его содержимое на страницу.
Мы уже частично знакомы с JSP по первым . Основная часть JSP страницы это HTML, в которую вставляются теги с динамическим содержимым.
Пример JSP страницы
Очень необходимым знанием, которым мы будем пользоваться является директива JSP.
Директива JSP — это сообщение, которое страница может послать соответствующему контейнеру с указанием действий. Синтаксис директивы:<% @ атрибут = «значение» %>
Есть три основных типа директив:
Так, как код в страницу мы вставлять не будем, рассмотрим последние две директивы.
Например у нас есть страницы, которые будут иметь одинаковую верхнюю и нижнюю часть. Очень распространенный шаблон, в котором футер и хедер одинаковы для всех страниц. Для того, чтобы не писать Код этих страниц в каждом JSP файле можно вынести их код в отдельный файлы и потом подключить в нужном нам месте с помощью директивы include.
Расположение файлов в проекте:
В коде выше можно проследить использование директивы taglib. С ее помощью мы подключили библиотеку тегов jstl. С помощью этой директивы можно подключить библиотеку собственных тегов: <%@ taglib uri=»/WEB-INF/mylib.tld» prefix=»test» %>.
Заметьте, что важным атрибутом taglib является prefix. Это обязательный к использованию атрибут. С помощью prefix можно вызывать библиотеку в коде. Имя prefix можно выбирать любое. К стати, вот и использование jstl тегов на деле:
< c: forEach items= "${accounts} " var = "account" >
< tr align= "center" >
< td> ${ account. number}
< td> ${ account. balance}
< td>< c: if test= "${!account.isBlocked}" > ${ statusActive }
< c: if test= "${account.isBlocked}" > ${ statusBlocked }
< td>< c: if test= "${!account.isBlocked}" >
< a href= "?command=blockaccount&accountId=${account.accountId}" > ${ block }
< td>< a href= "?command=showinfo&accountId=${account.accountId}" > ${ showInfo }
Код выше демонстрирует вывод всех элементов списка. О том, как мы его передали на страницу будет в следующих статьях. Его синтаксис:
Это код сайдбара, который подключался выше. Как видим, здесь используется разветвления, чтобы вывести только ту информацию, которая доступна определенном типу пользователя.
Синтаксис:
a equals b
Лучше всего рассматривать теги jstl при написании реального проекта, так как я не вижу смысла учить и запоминать весь синтаксис для каждого действия. Код выше должен послужить только примером, как это используется. Не нужно ничего заучивать. Когда Вы будете писать код, тогда и обратитесь к данному синтаксису.
К стати, код проекта, с которого был взят этот код, находится тут: https://github.com/caligula95/payment-systemapp
Я выложил проект на heroku: https://payment-systemapp.herokuapp.com/ — тут используется бесплатный аккаунт, так что для первого запроса нужно подождать пару минут, чтобы проект запустился.
JavaServer Pages (JSP) позволяют вам отделить динамическую часть ваших страниц от статического HTML. Вы, как обычно, пишете обычный код в HTML, используя для этого любую программу для создания Web страниц. Затем вы заключаете динамическую часть кода в специальные таги, большинство которых начинаются с " <% " и завершаются " %> ". В качестве примера рассмотрим секцию JSP страницы, результатом которой будет что-то вроде "Спасибо за покупку Core Web Programming " по запросу с URL: http://host/OrderConfirmation.jsp?title=Core+Web+Programming:
Спасибо за покупку <%= request.getParameter("title") %>
Вы даете вашему файлу расширение.jsp и размещаете там же, где должны размещаться обычные Web страницы. Хотя то что вы написали больше похоже на обычный HTML файл чем на сервлет, просто за кадром JSP страница преобразуется в обычный сервлет с статическим HTML который просто направляется в поток вывода, связанный с методом сервлета service . Обычно это происходит при первом запросе страницы, и разработчики могут сразу после установки сами выполнить этот запрос, если хотят чтобы первый реальный пользователь при обращении к странице не столкнулся с небольшой задержкой, вызванной трансляцией JSP страницы в сервлет и его последующей компиляцией и загрузкой. Также отметим что большинство Web серверов позволяет вам задавать ссылки (aliases), так что адрес URL, указывающий на HTML файл в действительности будет указывать на сервлет или страницу JSP.
Помимо стандартных HTML конструкций существуют еще три основных типа конструкций JSP, котрые вы можете включить в страницу: элементы скриптов, директивы и действия. Элементы скриптов позволяют вам указать код на языке Java, который впоследствии станет частью в конечный сервлет, директивы дадут вам возможность управлять всей структурой сервлета, а действия служат для задания существующих используемых компонентов, а также для контроля поведением движка JSP. Для упрощения элементов скриптов, вы имеете доступ к нескольким заранее определенным переменным, таким, например, как переменная request , использованная в приведенном выше отрывке.
Обратите внимание что это руководство охватывает JSP версии 1.0. А начиная с версии 0.92 JSP претерпела множество изменений, и несмотря на то что эти изменения были лишь во благо, вы должны помнить что JSP версии 1.0 практически полностью не совместима с более ранними JSP движками. Также следует не забывать о том, что предлагаемое вашему вниманию руководство является частью более полного руководства по сервлетам и JSP доступного по адресу http://www.apl.jhu.edu/~hall/java/Servlet-Tutorial/ .
| Элемент JSP | Синтаксис | Описание | Примечание |
|---|---|---|---|
| Выражение JSP | <%= выражение %> | Выражение обрабатывается и направляется на вывод | Эквивалент на XML: expression |
| Скриплет JSP | <% код %> | Код добавляется в метод service. | Эквивалент на XML: код |
| Объявление JSP | <%! код %> | Код добавляется в тело класса сервлета, вне метода service. | Эквивалент на XML: код |
| Директива JSP page | <%@ page att="значение" %> | Директивы для движка сервлета с информацией об основных настройках. | Эквивалент на XML: import="пакет.class " contentType="MIME-Type " isThreadSafe="true |false " session="true |false" buffer="размер kb|none" autoflush="true |false" extends="пакет.class " info="сообщение" errorPage="url " isErrorPage="true|false " language="java" |
| Директива JSP include | <%@ include file="url" %> | Файл в локальной системе, подключаемый при трансляции JSP в сервлет. | Эквивалент на XML: URL должен быть относительным. Для подключения файла в процессе запроса а не в ходе трансляции используйте действие jsp:include. |
| Комментарий JSP | <%-- комментарий --%> | Комментарий; игнорируется при трансляции JSP страницы в сервлет. | Если вы хотите чтобы комментарий сохранился в конечном HTML, используйте обычный синтаксис HTML для описания комментариев: <-- комментарий -->. |
| Действие jsp:include | Подключает файл при запросе страницы. | Если вы хотите чтобы файл подключался в процессе трансляции страницы, используйте директиву page совместно с атрибутом include. Внимание: некоторые сервера требуют чтобы подключаемые файлы были в формате HTML или JSP, в зависимости от настроек сервера (обычно данное ограничение базируется на указании расширений файлов). | |
| Действие jsp:useBean | ... | Найти или создать Java Bean. | Возможные атрибуты:
id="имя " scope="page |request|session|application" class="пакет.class " type="пакет.class " beanName="пакет.class " |
| Действие jsp:setProperty | Устанавливает свойства bean, или явно, или указанием на соответствующее значение параметра, передаваемое при запросе. | Допустимые атрибуты:
name="имяBean " property="имяСвойства |*" param="имяПараметра " value="значение " |
|
| Действие jsp:getProperty | value="значение "/> | Получение и вывод свойств bean. | |
| Действие jsp:forward | Передает запрос другой странице. | ||
| Действие jsp:plugin |
... | Генерирует тэги OBJECT или EMBED, в зависимости от типа броузера, в котором будет выполнятся апплет использующий Java Plugin. |
Как правило большую часть вашей JSP страницы составляет статический HTML, называемый текстом шаблона . Во всех отношениях (кроме одного) этот HTML выглядит как обычный HTML, использующий те же правила синтаксиса, и он просто "передается" клиенту сервлетом, создаваемым для обработки страницы. При этом не только сам HTML выглядит нормальным, он может создаваться с применением тех инструментов, которые вы ранее использовали при создании Web страниц. Я, например, при создании большинства JSP страниц для этого руководства использовал Allaire"s HomeSite.
Единственным печальным исключением из правила что "текст шаблона передается в неизменном виде" является ситуация, когда в тексте вы хотите отобразить последовательность символов " <% ", для этого в тексте шаблона надо использовать сочетание символов " <\% ".
Элементы скриптов JSP позволяют вам вставлять код на Java в сервлет, создаваемый из текущей JSP страницы. Существуют три формы:
Выражения JSP применяются для того чтобы вставить значения Java непосредственно в вывод. Для этого используется следующая форма:
<%= Выражение на Java %>Выражения Java вычисляются, конвертируются в строку и вставляются в страницу. Эти вычисления происходит во время выполнения (то есть при при запросе страницы), а потому существует полный доступ к информации о самом запросе. Например, следующий код служит для отображения даты и времени запроса данной страницы:
Текущее время: <%= new java.util.Date() %>
Для того чтобы упростить эти выражения существует несколько заранее определенных переменных, которые вы можете использовать. Более детально они будут рассмотрены ниже, но тем не менее, рассматривая их применение при использовании выражений, приведем несколько наиболее важных:
Request , HttpServletRequest ;
response , HttpServletResponse ;
session , HttpSession ассоциируется с запросом (если таковой имеется);
out , PrintWriter
(буферизированный вариант типа JspWriter)
используется для отсылки выводимых
данных клиенту.
Пример: Имя вашего хоста: <%= request.getRemoteHost() %>
И, наконец, авторы, использующие XML, могут
применить альтернативный синтаксис для
выражений JSP:
Помните, что элементы XML в отличие от HTML чувствительны к регистру. Поэтому убедитесь в том, что используете строчные символы.
Если вы хотите сделать что-то большее чем вставка простых выражений, скриплеты JSP дадут вам возможность вставить любой код в метод сервлета, который будет создан при обработке данной страницы. Скриплеты имеют следующий вид:
<% Код на Java %>Скриплеты также имеют доступ к тем же автоматически определенным переменным, что и выражения. Поэтому, например, если вы хотите вывести что-нибудь на страницу, вы должны воспользоваться переменной out .
<% String queryData = request.getQueryString(); out.println("Дополнительные данные запроса: " + queryData); %>
Обратите внимание на то, что код внутри скриплета вставляется в том виде, как он записан, и весь статический HTML (текст шаблона) до или после скриплета конвертируется при помощи оператора print . Это означает что скриплеты не обязательно должны содержать завершенные фрагменты на Java, и что оставленные открытыми блоки могут оказать влияние на статический HTML вне скриплета. Например, следующий фрагмент JSP содержит смешанный текст шаблона и скриплеты:
<% if (Math.random() < 0.5) { %> Удачного Вам дня! <% } else { %> Не удачного Вам дня! <% } %> после преобразования приведет к чему-то вроде: if (Math.random() < 0.5) { out.println("Удачного вам дня!"); } else { out.println("Не удачного вам дня!"); }
Если вы хотите использовать последовательность символов " %> " внутри скриплета, вместо нее используйте " %\> ". Эквивалентом <% Код %> для XML является:
Объявления JSP позволят вам задать методы или поля, для вставки в тело класса сервлета (вне метода service , обрабатывающего запрос). Они имеют следующую форму:
<%! Код на Java %>Поскольку объявления не осуществляют вывода, обычно они используются совместно с JSP выражениями или скриплетами. В приведенном в качестве примера фрагменте JSP отображается количество запросов к данной странице с момента загрузки сервера (или с момента последнего изменения и перезагрузки сервлета):
<%! private int accessCount = 0; %> Количество обращений к странице с момента загрузки сервера: <%= ++accessCount %>
Также как и в скриплетах, если вам необходимо использовать последовательность символов " %> ", используйте для этого последовательность " %\> ". XML эквивалентом <%! Код %> является
Существуют два основных типа директив: page , которая позволяет вам совершать такие операции, как импорт классов, изменение суперкласса сервлета, и т.п.; и include , которая дает вам возможность вставить файл в класс сервлета при трансляции JSP файла в сервлет. Также следует упомянуть директиву taglib , которая не поддерживается в JSP версии 1.0, но позволяет авторам JSP задавать свои собственные тэги. Предполагается что эта директива станет основной особенностью JSP 1.1.
Эта директива позволяет вам включать файлы в процессе трансляции JSP страницы в сервлет. Использование директивы выглядит следующим образом:
<%@ include file="относительный url" %>
Заданный URL обычно интерпретируется относительно JSP страницы, на которой расположена ссылка, но, как и при использовании любых других относительных URL вы можете задать системе положение интересующего вас ресурса относительно домашнего каталога Web сервера, добавив в начало URL символ "/". Содержимое подключаемого файла обрабатывается как обычный текст JSP и поэтому может включать такие элементы как статический HTML, элементы скриптов, директивы и действия.
Например, многие сайты используют небольшую панель навигации на каждой странице. В связи с проблемами использования фреймов HTML часто эта задача решается размещением небольшой таблицы сверху или в левой половине страницы, HTML код которой многократно повторяется для каждой страницы сайта. Директива include наиболее естественный способ решения этой задачи, избавляющий разработчика от кошмара рутины копирования HTML в каждый отдельный файл. Это происходит следующим образом:
На этом простейшем примере показано использование различных конструкций JSP: выражений, скриплетов, объявлений и директив. Также вы можете скачать исходный файл или вызвать этот скриплет из Интернет .
| Использование JavaServer Pages |
|---|
Некое динамическое содержание созданное с использованием различных механизмов JSP:
Для упрощения кода в выражениях JSP и скриплетах, вам предоставлен набор их восьми автоматически определенных переменных, иногда называемых неявными объектами . Доступные переменные это request , response , out , session , application , config , pageContext и page . Далее мы рассмотрим каждую из них в отдельности
Это объект HttpServletRequest , связанный с запросом, который позволяет вам обращаться к параметрам запроса (через метод getParameter), типу запроса (GET , POST , HEAD , и т.д..), и входящим HTTP заголовкам (cookies, Referer , и т.д..). Проще говоря, request является подклассом ServletRequest и может отличаться от HttpServletRequest если используется протокол отличный от HTTP, что на практике практически никогда не встречается.
Это объект типа HttpServletResponse , связанный с ответом на запрос клиента. Обратите внимание что, поскольку поток вывода (см. out далее) буферизован, можно изменять коды состояния HTTP и заголовки ответов, даже если это недопустимо в обычном сервлете, но лишь в том случае если какие-то данные вывода уже были отправлены клиенту.
Это объект типа PrintWriter , используемый для отправки вывода клиенту. Однако, чтобы сделать объект response (см. предыдущий раздел) полезным, следует использовать буферизированный вариант PrintWriter - JspWriter . Помните что вы можете изменять размер буфера и даже отключить буферизацию, изменяя значение атрибута buffer директивы page . Этот вопрос подробно рассмотрен в . Также обратите внимание что out используется практически исключительно скриплетами, поскольку выражения JSP автоматически помещаются в поток вывода, что избавляет от необходимости явного обращения к out .
Это объект типа HttpSession , связанный с запросом. Сессии создаются автоматически, и эта переменная существует даже если нет ссылок на входящие сессии. Единственным исключением является ситуация, когда вы отключаете использование сессий используя атрибут session директивы page (см. ). В этом случае ссылки на переменную session приводят к возникновению ошибок при трансляции JSP страницы в сервлет.
В JSP представлен новый класс PageContext для изолированного использования специфических особенностей сервера, таких как более эффективные JspWriter s. Идея заключается в том, что если вы обращаетесь к ним через этот класс а не непосредственно, ваш код может исполняться на "обычных" движках сервлет/JSP.
По сути является синонимом для this , и не нужен при работе с Java. Эта переменная создавалась с расчетом на перспективу, когда возможно появятся другие языки программированя скриптов, отличные от Java.
Действия JSP используют конструкции с синтаксисом XML для управления работой движка сервлета. Вы можете динамически подключать файл, многократно использовать компоненты JavaBeans, направить пользователя на другую страницу или сгенерировать HTML для Java plugin. Допустимо применение следующих действий:
Все эти действия детально рассмотрены далее. Помните что как и во всем XML, имена элементов и атрибутов регистрозависимы.Простейший способ использовать bean
- это использование конструкции
для загрузки bean,
а затем использовать jsp:setProperty и jsp:getProperty
для модификации и получения его свойств.
Однако существуют еще два других способа.
Во-первых, вы можете использовать формат
контейнера, а именно:
Тело
для того чтобы обеспечить выполнение Тела
только в том случае, если экземпляр bean
создается впервые, а не тогда, когда находится
и используется уже существующий bean. Как
обсуждается далее, beans
могут совместно использоваться, поэтому не
каждое выражение jsp:useBean приводит к
созданию экземпляра нового bean.
Во-вторых, кроме id и class ,
существуют еще три других атрибута, которые
вы можете использовать: scope , type ,
и beanName . Эти атрибуты описаны в
следующей таблице.
| Атрибут | Применение |
|---|---|
| id | Дает имя переменной, которая ссылается на bean. Если удается найти bean с теми же самыми значениями id и scope, то вместо создания нового экземпляра используется ранее созданный объект. |
| class | Задает полное имя пакета bean. |
| scope | Задает область, в которой bean должен быть доступен. Может принимать четыре допустимых значения: page , request , session и application . По умолчанию принимает значение page , означающее что bean доступен только на текущей странице (размещается в PageContext текущей страницы). Значение request означает что bean доступен только для текущего запроса клиента (размещается в объекте ServletRequest). Значение session означает что объект доступен всем страницам на протяжении жизни текущей HttpSession . И, наконец, значение application означает что он доступен всем страницам, использующим тот же самый ServletContext . Причина необходимости этого атрибута заключается в том что jsp:useBean приводит к созданию нового экземпляра объекта в том случае, если нет уже существующего объекта с тем же id и scope . Иначе используется уже существующий объект, и все элементы jsp:setParameter или любые другие между тэгами jsp:useBean игнорируются. |
| type | Указывает тип переменной, которая ссылается на объект. Долже совпадать с именем класса, суперкласса или реализуемого интерфейса. Запомните что имя переменной задается через атрибут id . |
| beanName | Дает имя bean, которое будет использовано методом instantiate . Можно задать type и beanName , и опустить атрибут class . |
Вы можете использовать jsp:setProperty для присвоения значений свойствам ранее описанных beans. Вы можете делать это двумя способами. Во-первых, вы можете использовать jsp:setProperty после, но вне элемента jsp:useBean , так как это показано в примере:
В этом случае jsp:setProperty выполняется независимо от того, был ли найден существующий bean или был создан новый экземпляр. Другим вариантом заключается в размещении jsp:setProperty в теле элемента jsp:useBean , как это показано в другом примере:
При этом jsp:setProperty выполняется лишь в том случае, если был создан новый экземпляр объекта, а не тогда, когда находится уже существующий.
Действие jsp:setProperty допускает применение следующих четырех атрибутов:
| Атрибут | Применение |
|---|---|
| name | Этот обязательный атрибут служит для задания bean, свойства которого будут устанавливаться. Элемент jsp:useBean должен предшествовать использованию элемента jsp:setProperty . |
| property | Этот обязательный атрибут устанавливает свойство, которое вы хотите установить. Однако существует частный случай: значение "*" означает что все параметры запроса, чьи имена совпадают с именами свойств bean будут переданы соответствующему методу установки свойств. |
| value | Этот необязательный атрибут устанавливает значение свойства. Строковые значения автоматически преобразуются в числовые, boolean , Boolean , byte , Byte , char и Character с использованием стандартного метода valueOf соответствующего класса. Например, значение "true" для свойства boolean или Boolean будет конвертированно при помощи метода Boolean.valueOf , а значение "42" для свойства int или Integer будет конвертированно при помощи метода Integer.valueOf . Вы не можете одновременно использовать атрибуты value и param , но можете вообще их не использовать. Ознакомьтесь с описанием атрибута param , которое представлено ниже. |
| param | Этот необязательный атрибут
устанавливает параметр запроса,
используемый для получения свойства.
Если в текущем запросе этот параметр
отсутствует, никаких действий не
происходит: система не
передает
значение null методу
устанавливающему свойства. Таким образом,
допустимо использование в bean свойств по
умолчанию, переопределяя их лишь в том
случае если этого требуют параметры
запроса. Например, следующий фрагмент
означает следующее: "установить
свойство numberOfItems в соответствии со
значением параметра запроса numItems ,
а если такой параметр в запросе
отсутствует - никакие действия не
выполняются."
|
Для того чтобы скачать исходник JSP, щелкните правой кнопкой мыши на ссылке на исходный код . Вы можете также скачать исходный код для NumberedPrimes bean на который ссылается элемент jsp:useBean . Просмотрите каталог исходных кодов для других классов Java используемых в NumberedPrimes . Лучший способ опробовать это в сети - начать с HTML страницы, которая является внешним интерфейсом .
| Многократное использование JavaBeans в JSP |
|---|
Этот элемент определяет значение свойства bean, конвертирует его в строку и направляет в поток вывода. Для выполнения действия требуется задание двух атрибутов: имени bean, которое предварительно задается в действии jsp:useBean, и имя свойства, значение которого должно быть определено. Далее приведен пример использования этого действия. За другими примерами обратитесь к разделам и .
Это действие позволяет вам передать запрос другой странице. Оно использует один атрибут, page , который должен содержать относительный URL. Ей может быть как статическое значение, так и вычисляемое в процессе запроса, что и показано на следующих двух примерах:
Это действие позволяет вам вставить элемент OBJECT или EMBED (в зависимости от типа используемого броузера), необходимый для запуска апплетов, использующих plugin Java.
Ниже приведены несколько конструкций, которые вы можете использовать в тех случаях, когда требуется вставить комментарий или использовать символы, зарезервированные для данного тэга:
| Синтаксис | Назначение |
|---|---|
| <%-- комментарий --%> |
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-адрес, и после этого процесса он будет искать конкретный сервлет там. будет выполняться операция обслуживания.
