Что нам дают произвольные теги?

Мощь: Так как с помощью JavaBeans реальные проблемы программирования, такие как опрос баз данных или создание сложных вычислений и т. п., могут быть выполнены в Java коде со всей мощью библиотек Java за вашими плечами. Произвольные тэги JSP также позволяют вам создавать объекты, доступные автору web страницы посредством фрагментов Java кода, или "скриплеты", так что при аккуратном дизайне вы можете создать огромную функциональность, доступную через простой и ясный интерфейс.

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

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

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

Здесь, если вы помните раннее обсуждение использования Java bean из JSP в главе, посвященной JSP, вы можете спросить себя: почему это необходимо. JavaBeans в JSP также помогает нам отделить уровень представления от бизнес логики. Beans тоже могут храниться в библиотеке, они могут повторно использоваться, имеют последовательный интерфейс и могут даже взаимодействовать со скриплетами, так почему нам необходимы теги?

Ответ достаточно хитрый. Beans необходимы для разработчика приложений и очень полезны, если используются в правильном месте. Фактически, как мы увидим, beans и произвольные теги очень хорошо дополняют друг друга. Хотя различия состоят в том, что bean являются компонентами, а произвольные теги являются, в сущности, действием или обработчиком. Это необходимо понять и хорошо взвешивать в вашем дизайне, не будет ли некорректным использование бина в этом месте.

Beans, как и любые другие компоненты, имеют свойства, методы и внутреннее состояние. Что делает использование beans в JSP легким, это взаимодействие между JSP страницами и Java beans, предназначенными специально для получения и установки свойств bean. Если вы именуете методы вашего bean в соответствии с соглашением о JavaBeans, вы можете получить очень простой доступ к этим свойствам через JSP.

Давайте вспомним JavaBeans. Рассмотрим bena персоны с двумя свойствами: имя и возраст. Чтобы получить доступ к ним через JSP теги, вам необходимо использовать

<jsp:usebean …> действие и

<jsp:getProperty name=”beanName” property=”requiredProperty”> действие для каждого из этих двух значений. Если вы хотите поместить их в строки HTML таблицы, вы должны указать

..

<table>

<tr>

<td><jsp:getProperty name=”personbean” property=”name”></td>

<td><jsp:getProperty name=”personbean” property=”age”></td>

</tr>

</table>

..

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

Одна из великих сил при использовании JavaBean совместно с JSP является ограниченной. Поскольку JSP теги getProperty и setProperty легко использовать для установки и чтения свойств bean'а. Помните, что это ссылки для использования методов установки и получения. Но если вы попробуете вызвать другие методы для bean'а, вы должны сделать это напрямую и вы ограничены кодом скриплета или кодом выражения, используя тэги <% %>. При этом код начинает выглядеть немного ужасающе и непоследовательно. Рассмотрим фрагмент.

<ol>

<% while (list.hasNextElement()) {

list.nextElement();

%>

<li><jsp:getProperty name=”list” property=”currentElement”></li>

<% } %>

</ol>

В приведенном выше примере обратите внимание, что для выполнения перебора в простом цикле и отображения элементов из списка (используя воображаемый bean списка, который перебирает свои данные) первые две строки кода Java скриплета помещены в скриплетные скобки. Тэг jsp:getProperty позволяет использовать HTML'ные скобки, что дает нам последовательное представление показанного кода, но затем закрывающая скобка цикла while снова обрамляется скобками скриплета <%}%>. Теперь два тэга обрамляют единственную закрывающую скобку и, как вы можете видеть, это снова выглядит хорошо. Если вы попробуете отладить такой код, может быть очень затруднительно работать в том месте, где один цикл заканчивается, а другой начинается. Инструменты отладки JSP улучшают свое качество, но все еще не покрывают большинство желаний. Добавьте к этому тот факт, что почти невозможно достигнуть последовательных соглашений относительно ваших скобок и вы можете видеть, что это потенциальный беспорядок.

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

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

Как заманчиво это звучит, но это оборачивается очень плохой идеей, как вы вскоре увидите.

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

public class PersonDataBean {

private int age;

private String name;

 

String getCurrentRow() {

return “<tr><td>” + name + “</td><td>”+ age +

“</td></tr>”;

}

}

Теперь метод getCurrentRow() возвращает строку, которая отображает строку таблицы, а HTML, отображающий персону в таблице из двух приведенных выше примеров, становится проще:

..

<table>

jsp:getProperty name=”personbean” property=”currentRow”>

</table>

..

Таким образом, мы сокращаем HTML кодирование, но это плохой подход к дизайну по нескольким причинам. Первое, здесь создается очень плотная связь между данными и их представлением. Это имеет тенденцию покрывать туманом представление о bean'е, как об объекте, и загромождает дизайн.

С точки зрения программирования дела обстоят еще хуже. Программист, используя этот bean, должен получить назад результат в таблице, не зависимо от того подходит это ему или нет. Расположение и порядок полей не может быть изменен программно и, хотя можно использовать страницу стилей для изменения стиля вывода, будет невозможно сделать что-либо специфичное (например, показать одну колонку жирным шрифтом).

Это значит, что автор web страницы, использующий этот bean, теперь ограничен представляемыми данными в формате, определенном разработчиком bean'а. Разработчик bean'а может быть великолепным разработчиком баз данных, но может не быть тем человеком, который отвечает за финальное представление. Фактически, очень желательно, чтобы требования к расположению не были даже известны во время разработки bena'а. Bean должен быть написан с возможностью повторного использования в уме, но ни один дизайнер web страницы не одобрит работу с предварительно определенным расположением.

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

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

Понятно, что код скриплета не может быть удален их JSP страницы полностью, и это нам не нужно. Фактически, написание скриплетов с использованием JavaBeans (или использование любого другого скриптового языка с компонентами любого рода) это великолепный способ построить приложение до тех пор, пока не появится злоупотребление. До сих пор мы обнаружили две проблемы: необходимость отделить код представления от бизнес логики; и необходимость предотвратить сложности любого рода, которые вкрадываются в наш код представления при смешивании кода HTML со скриплетами. Мы также можем видеть, что не смотря на всю полезность JavaBeans, они не всегда решают эти проблемы и могут приводить к плохому дизайну. Таким образом, в игру вступают произвольные теги.

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

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

Давайте взглянем на простейший тэг, тэг "Hello World!" будет выполнен славно.

Было бы идеально, если бы тэг должен был отображать Hello World. Такой тэг должен выглядеть примерно так:

<tijtags:helloworldtag/>

Обратите внимание, что здесь употребляется пространство имен tijtags со своим именем helloworldtag. Также обратите внимание, что есть прямой слеш в конце имени тэга. Это значит, что тэг начала и тэг конца собраны в одном тэге. Таким образом, использована стенографическая нотация, определенная в XML. Это также может быть записано следующим образом:

<tijtags:helloworldtag>

</tijtags:helloworldtag>

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

1. Написать класс, который реализует интерфейс Tag, находящийся в пакете javax.servlet.jsp.tagext.Tag.

2. Реализовать методы "setPageContext(), doStartTag() и doEndTag()"

3. Создать TLD файл или дескриптор библиотеки тэга для тэга.

Давайте позаботимся о первых двух задачах:

package cx2.tags;

import javax.servlet.jsp.PageContext;

import javax.servlet.jsp.tagext.Tag;

import javax.servlet.jsp.JspException;

import java.io.IOException;

 

public class HelloWorldTag implements Tag {

PageContext pageContext;

public void setPageContext(PageContext pageContext) {

this.pageContext = pageContext;

}

public void setParent(Tag parent) {}

 

public Tag getParent() { return null; }

public int doStartTag() throws JspException {

try {

pageContext.getOut().println("Hello World!");

} catch(IOException ioe) {

ioe.printStackTrace();

}

return Tag.SKIP_BODY;

}

public int doEndTag() throws JspException {

return Tag.EVAL_PAGE;

}

public void release() {}

}

Вы заметите, что конструктор не определен, это означает, что этот класс имеет конструктор по умолчанию без параметров. Это одно из требований при написании класса, обрабатывающего тэги.

Вы заметите, что определено свойство, называемое pageContext, имеющее тип PageContext, находящийся в пакете javax.servlet.jsp. Оно инициализируется в методе setPageContext(). Контейнер вызывает его автоматически и передает в него ссылку на PageContext при первом чтении тэга. Эта ссылка должна сохраняться, потому что она понадобится позже. Спецификация JSP Tag Extension гарантирует, что метод setPageContext всегда будет вызываться до метода doStartTag().

Дале реализован метод doStartTag(). Этот метод выполняет всю работу, которую должен делать этот тэг.

С помощью объекта pageContext, который был ранее проинициализирован, запрашивается выходной поток JSP. Это выходной поток, который отправляется назад браузеру, читающему JSP страницу, и используется метод println() этого потока точно так же, как если бы вы использовали System.out.

Обратите внимание, что метод doStartTag() возвращает значение Tag.SKIP_BODY. Таким образом сообщается контейнеру, что он должен игнорировать все, что находится между начальным и конечным тэгом. Так как этот тэг не имеет тела, это все, что нам нужно в настоящий момент.

Реализация метода doEndTag() просто возвращает значение Tag.EVAL_PAGE. Это говорит контейнеру, что нужно продолжить процесс обработки JSP страницы, как это было до того, как нашли наш тэг. Опять таки, поскольку наш тэг очень прост, это все, что нужно.

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

Все, что теперь осталось сделать для тэга HelloWorld - это описать для контейнера, что ваш новый тэг вызывает и в каком классе он реализован. Чтобы сделать это, вам необходимо написать дескриптор библиотеки тэга - это XML файл, который используется контейнером для получения информации о тэге или тэгах, определенных вами. Этот файл сохраняется с расширением.tld и помещается на ваш сервер с вашими JSP файлами.

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE taglib

PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"

"http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd">

<taglib>

<tlibversion>1.0</tlibversion>

<jspversion>1.1</jspversion>

<shortname>htl</shortname>

<uri>http://www.eckelobjects.com/tagtut/tags1.0</uri>

<info> Library of tags on increasing complexity to demonstrate the use of tag libraries.</info>

<tag>

<name>helloworldtag</name>

<tagclass>cx2.tags.HelloWorldTag</tagclass>

<bodycontent>empty</bodycontent>

<info> echo's hello world to the browser.

</info>

</tag>

</taglib>

Не пугайтесь увиденного. Тэги в этом файле менее загадочны, чем это выглядит. Они будут представлены более детально позже, а пока все, о чем вам нужно побеспокоиться - это тэг tag. Этот тэг, что не удивительно, сообщает контейнеру вещи, которые ему необходимо знать о новом тэге, который вы только что создали. Есть четыре пункта, которые важны для каждого тэга: его имя, какой класс содержит реализацию тэга, какого рода содержимое должно находиться в его теле и, наконец, описание того, что делает этот тэг. Описание должно быть коротким и ясным, по типу того, которое вы можете ожидать в контекстной подсказке панели инструментов графического редактора, дающего вам возможность использовать этот тэг в вашем приложении.

Чтобы использовать новый тэг в JSP странице вы должны указать что-то наподобие этого:

<%@ taglib uri="/tijtags.tld" prefix="tijtags"%>

<b>

<tijtags:helloworldtag/>

</b>

Вот и все, что вам нужно сделать, чтобы послать "Hello World" назад в браузер!

В первой строке помещена директива JSP taglib. Атрибут uri говорит контейнеру, что ваш дескриптор библиотеки тэгов может быть найден в файле, называемом "tijtags.tld" в текущем каталоге. Атрибут prefix говорит контейнеру, какое пространство имен вы используете, чтобы ссылаться на ваши тэги.

Тэг <b> - это просто декорация, чтобы особо указать на то, что вы можете свободно использовать HTML вместе с JSP тэгами. Такая комбинация становится очень мощной, когда вы пишите тэги итераций.