Обзор: Расширяемый язык разметки (XML) быстро используется в отрасли. Он стал широко используемым стандартом для описания и обмена данными в формате, независимом от платформы, языка и протокола. XML и его вспомогательные спецификации могут использоваться для описания представления данных в документе, описания ограничений типов документов XML, описания связей между документами XML и ресурсами, а также описания автоматического преобразования и форматирования документов XML.
Как разработать собственную библиотеку тегов?
Я уже давно использую JSP и ASP-программирование. Среди двух методов серверного программирования я все больше считаю, что JSP гораздо более мощный. Не говоря уже обо всем остальном, библиотека тегов JSP является причиной, по которой я выбрал JSP в качестве предпочтительного инструмента разработки веб-приложений на стороне сервера. Почему? Потому что: скорость обслуживания и развития. На одной странице сервера вы можете смешивать и сочетать различные методы и объекты скриптов. Подобно «бетону», эта смесь делает серверные сценарии мощными и позволяет серверным программистам создавать очень гибкие и динамичные веб-страницы. Однако эта бесплатная смесь также имеет свои недостатки: ее очень сложно поддерживать. особенно по мере того, как проект становится больше, поскольку конечный продукт поддерживается традиционным веб-дизайнером, и, что еще хуже, скорость разработки увеличивается по мере увеличения сложности кода. крупномасштабные веб-приложения. После разработки сайту все равно потребуется найти квалифицированных программистов для поддержки этих довольно сложных кодов.
К счастью, JSP предлагает хорошее решение. Библиотеки тегов предоставляют простой способ создания повторно используемого блока кода. После создания библиотеки тегов ее можно снова использовать во многих проектах. Что ещё удобнее, так это то, что в отличие от COM и J2EE для создания библиотеки тегов не нужно изучать никаких других навыков! Если вы знаете, как писать JSP, вы можете создать библиотеку тегов. Библиотеки тегов также могут улучшить обслуживание веб-приложений. Это простой интерфейс XML благодаря настраиваемым тегам страницы JSP. Таким образом, веб-дизайнеры могут даже создавать веб-приложения JSP, не обладая никакими знаниями JSP. Эта открытая веб-разработка очень эффективна для командной работы. Программисты JSP могут создавать собственные теги и модули фонового кода, а веб-дизайнеры могут использовать собственные теги для создания веб-приложений и сосредоточиться на веб-дизайне.
1. Определение библиотеки тегов. Библиотеку тегов JSP (также называемую пользовательской библиотекой) можно рассматривать как набор методов для создания сценариев на основе XML, который поддерживается JavaBeans. Концептуально библиотеки тегов представляют собой очень простые и многократно используемые конструкции кода.
Примеры тегов и HTML-страницы, выполняющие преобразование XML/XSL
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
c:/xml/example.xml
c:/xml/example.xsl
В этом примере с помощью простых тегов для доступа к более мощному скрытому коду загружается XML, а результат генерируется через файл XSL и отправляется клиенту, и все это делается. используя простой вызов тега.
Пользовательские теги открывают возможности для создания кода, который можно легко использовать повторно в проектах JSP. Все, что вам нужно, это библиотека тегов и ее документация.
2. Компоненты тегов Хотя библиотека тегов очень проста в использовании, создать внутреннюю структуру для поддержки библиотеки тегов довольно сложно, по крайней мере, сложнее, чем создание простого JavaBean. Сложность связана с тем, что библиотека тегов состоит из нескольких частей. Однако вам нужно знать только Java и JSP.
Простой тег состоит из следующих элементов:
⑴ JavaBeans: Чтобы получить присущие Java объектно-ориентированные преимущества, повторно используемый код должен быть помещен в независимый контейнер кода. Эти JavaBeans не являются частью библиотеки тегов. Но это базовый блок кода, который ваша кодовая база использует для выполнения связанных задач.
⑵ Обработка тегов: это настоящее ядро библиотеки тегов. Обработчик тегов будет ссылаться на любые необходимые ему ресурсы (ваши JavaBeans) и получать доступ ко всей информации о вашей странице JSP (объект pageContext). Страница JSP также передаст все установленные атрибуты тега и содержимое тела тега на странице JSP процессору тегов. После того, как процессор тегов завершит обработку, он отправит выходные данные обратно на вашу JSP-страницу для обработки.
⑶ Описание библиотеки тегов (файл tld): это простой XML-файл, в котором записаны атрибуты, информация и расположение процессора тегов. Контейнер JSP использует этот файл, чтобы знать, где и как вызвать библиотеку тегов.
⑷ Файл web.xml веб-сайта. Это файл инициализации вашего веб-сайта. В этом файле вы определяете пользовательские теги, используемые на веб-сайте, а также файл tld, используемый для описания каждого пользовательского тега.
⑸ Файл дистрибутива (файл WAR или JAR): если вы хотите повторно использовать пользовательские теги, вам нужен способ перенести их из одного проекта в другой. Упаковка библиотеки тегов в файл JAR — простой и эффективный способ.
⑹ Создайте объявление библиотеки тегов в своем JSP-файле. Если вы хотите использовать этот тег, просто объявите его на странице. После этого вы можете использовать его в любом месте страницы JSP.
Кажется, что работы предстоит много, но на самом деле это не так уж и сложно. Дело не в кодировании, а в правильной организации частей. Однако такое многоуровневое расположение важно, поскольку оно делает использование этикеток более гибким и облегчает их перенос. Что еще более важно, эти уровни существуют для автоматизации процесса создания тегов с помощью JSP IDE (интегрированной среды разработки JSP). Ожидается, что будущие JSP IDE смогут автоматически выполнять большую часть работы по созданию пользовательского тега, так что вам останется только писать код и обрабатывать теги.
Примечание. Обработчик тегов определяет только один пользовательский тег; библиотека тегов представляет собой совокупность нескольких обработчиков тегов, которые выполняют одну и ту же задачу.
3. Создайте свои собственные теги. Ниже шаг за шагом вы узнаете, как создавать собственные теги. Конкретным примером является расширение JSP таким образом, чтобы у него была собственная функция кодирования HTML. Эта функция заменяет все символы < и > кодом HTML. Его можно легко расширить для выполнения другой обработки кодирования. Для упрощения в этом примере объясняются только основные элементы создания пользовательского тега.
⑴ Создайте JavaBean
Любая повторно используемая часть вашего кода должна быть помещена в JavaBean. Это важно, поскольку вы часто будете использовать этот код в других местах проекта. Любой код, помещенный внутри обработчика тега, не подлежит повторному использованию за пределами тега, поэтому важно изолировать повторно используемые части кода. В этом примере логика, закодированная для HTML, является общей и поэтому помещена в JavaBean.
⑵ HTML-кодирование JavaBean
/* HTML_Format.Java */
публичный класс HTML_Format расширяет объект, реализует Java.io.Serializable {
/** Создать новый HTML_Format */
общедоступный HTML_Format() {}
/** Заменить все символы < и > в строке HTML-кодировкой ответа */
общедоступная строка HTML_Encode (строка as_data)
{
int li_len = as_data.length();
/*Длина строкового буфера больше исходной строки*/
StringBuffer lsb_encode = новый StringBuffer(li_len + (li_len/10));
/* Цикл для замены всех символов < и >*/
for(int li_count = 0; li_count <li_len; li_count++)
{ String ls_next = String.valueOf(as_data.charAt(li_count));
if (ls_next.equals("<")) ls_next = "<";
if (ls_next.equals(">")) ls_next = ">";
lsb_encode.append(ls_next);
}
return(lsb_encode.toString());
}
}
⑶ Создайте обработчик тегов. Обработчик тегов использует следующий код:
Обработчик тегов кодирования HTML.
импортировать Java.io.IOException;
импортировать Javax.servlet.jsp.*;
импортировать Javax.servlet.jsp.tagext.*;
общедоступный класс HTML_FormatTag расширяет BodyTagSupport
{
/* 1} Эта функция будет вызвана в конце тега*/
public int doEndTag() выдает JspTagException
{
пытаться
{/* 2} Получить текст в метке */
BodyContent l_tagbody = getBodyContent();
Строка ls_output = "";
/* 3} Если тело тега содержит текст, обработайте его */
если (l_tagbody! = ноль)
{HTML_Format l_format = новый HTML_Format ();
/* 3a} Преобразование содержимого тела тега в строку */
Строка ls_html_text = l_tagbody.getString();
ls_output = l_format.HTML_Encode(ls_html_text);
}
/* 4}Записываем результаты обратно в поток данных*/
pageContext.getOut().write(ls_output.trim());
}
улов (IOException e)
{ throw new JspTagException("Ошибка тега:" + e.toString());
}
/* Позвольте JSP продолжить обработку содержимого следующих страниц*/
вернуть EVAL_PAGE;
}
}
Эта обработка очень проста и включает в себя:
o Прочитайте текст между началом и концом тега. o Вызовите функцию кодирования HTML. o Верните результат на страницу JSP.
⑷ При создании дескриптора тега необходимо описать пользовательский тег, чтобы система знала, как его обрабатывать. Суффикс этого файла описания — .tld, обычно его имя совпадает с именем процессора тегов, и он хранится в каталоге «/WEB-INF/».
Дескриптор тега кодировки HTML
<?xml version="1.0"coding="UTF-8" ?>
<!DOCTYPE библиотека тегов
ПУБЛИЧНАЯ "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
" http://Java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd ">
<ТАГЛИБ>
<TLIBVERSION>1.0</TLIBVERSION>
<JSPVERSION>1.1</JSPVERSION>
<SHORTNAME>HTML_FormatTag</SHORTNAME>
<URI></URI>
<INFO>Тег кодировки HTML </INFO>
<ТЕГ>
<NAME>HTMLEncode</NAME>
<TAGCLASS>HTML_FormatTag</TAGCLASS>
<INFO>Кодировать HTML</INFO>
</TAG>
</TAGLIB>
⑸ Обновите файл Web XML, чтобы теперь указать JSP-контейнеру использовать библиотеку тегов. Для этого вам необходимо изменить файл web.xml. В частности, вам необходимо добавить проект taglib для регистрации библиотеки тегов. Самое главное — присвойте тегу URI. URI — это уникальная ссылка, которая применяется только к этому конкретному тегу на веб-сайте. Рекомендуется использовать полный URL-адрес или имя пакета, чтобы обеспечить уникальность, поскольку тег можно использовать на разных веб-сайтах. Этот пример упрощен.
Изменить файл web.xml
<?xml version="1.0"coding="ISO-8859-1"?>
<!DOCTYPE веб-приложение
ПУБЛИЧНЫЙ "-//Sun Microsystems, Inc.//Веб-приложение DTD 2.2//EN"
" http://Java.sun.com/j2ee/dtds/web-app_2.2.dtd ">
<ВЕБ-ПРИЛОЖЕНИЕ>
<ТАГЛИБ>
<TAGLIB-URI>
HTMLEncode
</TAGLIB-URI>
<TAGLIB-LOCATION>
/WEB-INF/HTML_FormatTag.tld
</TAGLIB-LOCATION>
</TAGLIB>
</WEB-APP>
⑹ Пользовательский тег с использованием новых тегов настроен и может использоваться на странице JSP. Для этого просто объявите тег на странице с помощью директивы taglib. На тег ссылается его уникальный URI, и ему присваивается префикс пространства имен. Префикс может быть произвольным, если он не конфликтует с другими пространствами имен.
Используйте теги кодирования HTML на странице JSP:
<%@ taglib uri="HTMLEncode" prefix="Examples" %>
<ПРЕД>
<?XML:NAMESPACE PREFIX = Примеры /><Examples:HTMLEncode>
<Привет, простой образец>
</Примеры:HTMLEncode>
</PRE>
Пример вывода кода
<Привет, простой образец>
который отображается как:
<Привет, простой образец>
С помощью этого тега я закодировал весь код страницы. Интересно то, что все пользовательские теги обрабатываются на сервере. Это означает, что вы не увидите пользовательские теги на выходной странице.
Создать этикетку не сложно. Самое сложное — изучить все тонкости обработки этикеток. Это очень мощная функция, и мы затронули только основы. Поскольку этот процесс требует нескольких шагов, новые программисты JSP будут сбиты с толку при создании тегов.
Как использовать JSP для разработки приложений DOM?
DOM — это аббревиатура объектной модели документа, которая представляет собой объектную модель документа. XML организует данные в виде дерева, поэтому DOM является объектным описанием этого дерева. С точки зрения непрофессионала, это логическое построение древовидной модели для XML-документа путем анализа XML-документа, а узлы дерева являются объектами. Мы можем получить доступ к содержимому XML-документов, обратившись к этим объектам.
Давайте рассмотрим простой пример ниже, чтобы увидеть, как мы работаем с XML-документом в DOM. Это XML-документ и объект, с которым мы хотим работать:
<?xml version="1.0"coding="UTF-8"?>
<сообщения>
<message>Прощай сериализация, здравствуй Java!</message>
</messages>
Далее нам нужно проанализировать содержимое этого документа на объекты Java для использования программой. Используя JAXP, мы можем сделать это всего с помощью нескольких строк кода. Во-первых, нам нужно создать фабрику парсера, чтобы использовать эту фабрику для получения определенного объекта парсера:
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
Целью использования DocumentBuilderFactory здесь является создание программы, независимой от конкретного анализатора. Когда вызывается статический метод newInstance() класса DocumentBuilderFactory, он определяет, какой анализатор использовать, на основе системной переменной. А поскольку все парсеры подчиняются интерфейсу, определенному JAXP, код один и тот же независимо от того, какой парсер используется. Так что при переключении между разными парсерами вам нужно лишь менять значения системных переменных, не меняя никакого кода. Это преимущество завода.
DocumentBuilder db = dbf.newDocumentBuilder();
После получения объекта фабрики используйте его статический метод newDocumentBuilder(), чтобы получить объект DocumentBuilder, который представляет конкретный анализатор DOM. Но какой это парсер, Microsoft или IBM, для программы не важно.
Затем мы можем использовать этот парсер для анализа XML-документа:
Документ doc = db.parse("c:/xml/message.xml");
Метод parse() DocumentBuilder принимает имя XML-документа в качестве входного параметра и возвращает объект Document. Этот объект Document представляет древовидную модель XML-документа. Все будущие операции с XML-документами не имеют ничего общего с анализатором и могут выполняться непосредственно с этим объектом Document. Конкретный метод работы с Документом определяется DOM.
Начиная с полученного объекта Document, мы можем начать наше путешествие по DOM. Используя метод getElementsByTagName() объекта Document, мы можем получить объект NodeList. Объект Node представляет собой элемент тега в XML-документе, а объект NodeList, как видно из его имени, представляет собой объект Node.
NodeList nl = doc.getElementsByTagName("сообщение");
С помощью такого оператора мы получаем список объектов Node, соответствующих всем тегам <message> в XML-документе. Затем мы можем использовать метод item() объекта NodeList, чтобы получить каждый объект Node в списке:
Узел my_node = nl.item(0);
При создании объекта Node данные, хранящиеся в документе XML, извлекаются и инкапсулируются в файл Node. В этом примере для извлечения содержимого тега Message мы обычно используем метод getNodeValue() объекта Node:
Строковое сообщение = my_node.getFirstChild().getNodeValue();
Обратите внимание, что здесь также используется метод getFirstChild() для получения первого дочернего объекта Node под сообщением. Хотя в теге сообщения нет других подтегов или атрибутов, кроме текста, мы настаиваем на использовании здесь метода getFirseChild(), который в основном связан с определением DOM, данным W3C. W3C также определяет текстовую часть внутри тега как узел, поэтому мы должны сначала получить узел, представляющий текст, прежде чем мы сможем использовать getNodeValue() для получения содержимого текста. Теперь, когда мы смогли извлечь данные из XML-файла, мы можем использовать эти данные в соответствующем месте для создания приложения.
Пример DOM
Давайте сначала поговорим о том, что будет делать этот пример. Мы сохранили несколько URL-адресов в файле с именем link. Добавленный URL-адрес записывается в этом XML-файле. Это очень просто, но очень практично, и этого достаточно, чтобы проиллюстрировать большую часть использования DOM.
Первая программа называется xmldisplay.Java. Ее основная функция — считывать содержимое каждого узла в этом XML-файле, а затем форматировать вывод в System.out. Давайте посмотрим на эту программу:
import Javax.xml.parsers. *;
import org.w3c.dom.*;
Это необходимо для введения необходимых классов, поскольку здесь используется анализатор XML, предоставленный Sun, поэтому необходимо ввести пакет Java.xml.parsers, который содержит анализатор DOM и анализ SAX. Конкретная реализация устройства. Пакет org.w3c.dom определяет интерфейс DOM, разработанный w3c.
Фабрика DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Документ doc=builder.parse("links.xml");
doc.normalize();
В дополнение к вышесказанному, есть еще небольшая хитрость. Вызовnormalize() для объекта Document может удалить ненужные объекты Text Node, отображаемые в дереве DOM как пробелы в XML-документе как форматированное содержимое. В противном случае полученное вами DOM-дерево может оказаться не таким, как вы себе представляли. Особенно при выводе эта нормализация() более полезна.
NodeListlinks =doc.getElementsByTagName("link");
Как уже упоминалось, пробельные символы в XML-документах также будут отображаться как объекты в дереве DOM. Поэтому прямой вызов метода getChildNodes метода Node иногда вызывает некоторые проблемы, а иногда он не может вернуть ожидаемый объект NodeList. Решение состоит в том, чтобы использовать getElementByTagName(String) элемента Element, а возвращаемый NodeLise является ожидаемым объектом. Затем вы можете использовать метод item() для извлечения нужного элемента.
for (int i=0;i<links.getLength();i++){
Элемент link=(Элемент)links.item(i);
System.out.print("Содержимое: ");
System.out.println(link.getElementsByTagName("text").item(0).getFirstChild();
.getNodeValue());
...
Приведенный выше фрагмент кода завершает форматированный вывод содержимого XML-документа. Если вы обратите внимание на некоторые детали, такие как использование методов getFirstChile() и getElementsByTagName(), все будет относительно просто.
Следующий контент посвящен переписыванию дерева DOM в документ XML после его изменения. Эта программа называется xmlwrite.Java. В версии JAXP 1.0 нет прямых классов и методов, которые могут обрабатывать написание XML-документов, и вам необходимо использовать некоторые вспомогательные классы в других пакетах. В версии JAXP 1.1 была введена поддержка XSLT. Так называемый XSLT предназначен для получения новой структуры документа после преобразования XML-документа (Перевод). Используя эту недавно добавленную функцию, мы можем легко записать вновь созданное или измененное дерево DOM обратно в XML-файл. Давайте посмотрим на реализацию кода. Основная функция этого кода — добавить новый узел ссылки. Файл .xml:
импортировать Javax.xml.parsers.*;
импортировать Javax.xml.transform.*;
импортировать Javax.xml.transform.dom.DOMSource;
импортировать Javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
Несколько классов в новом пакете Java.xml.transform используются для обработки XSLT-преобразований.
Мы надеемся добавить новый узел связи в указанный выше XML-файл, поэтому нам нужно сначала прочитать файл linked.xml, построить дерево DOM, затем изменить дерево DOM (добавить узлы) и, наконец, добавить измененный DOM. Записать обратно в файл DOM. Файл linkeds.xml:
Фабрика DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Документ doc=builder.parse("links.xml");
документ.нормализовать();
//---Получим переменные----
String text="Домашняя страница Ханьчжуна";
Строка URL=" www.hzliu.com ";
Stringauthor="Гцлю Лю";
Stringdescription="Сайт от Ханьчжун Лю, преподнесите вам много сюрпризов!!!";
Чтобы четко увидеть ключевые моменты и упростить процедуру, мы жестко запрограммировали содержимое, которое будет добавлено в объект String в памяти. В процессе работы мы часто используем интерфейс для извлечения пользовательского ввода или извлечения желаемого содержимого из базы данных через JDBC.
Текстовый сегмент;
Element link=doc.createElement("link");
Прежде всего, должно быть ясно, что независимо от типа узла, будь то тип текста, тип атрибута или тип элемента, все они создаются с помощью объекта документа CreateXXX( ) в (XXX представляет конкретный тип, который необходимо создать), поэтому нам нужно добавить элемент ссылки в документ XML, сначала создайте объект ссылки:
Element linktext=doc.createElement("text");
textseg=doc.createTextNode(текст);
linktext.appendChild(textseg);
link.appendChild(текст ссылки);
...
Процесс создания узлов может быть немного единообразным, но нужно отметить, что текст, содержащийся в Element (в DOM эти тексты также представляют Node, поэтому для них также необходимо создать соответствующие узлы). Непосредственно используйте метод setNodeValue() объекта Element, чтобы установить содержимое этих текстов, и вам необходимо использовать метод setNodeValue() созданного объекта Text, чтобы установить текст, чтобы созданный элемент и его текстовое содержимое могли быть добавлен в дерево DOM. Взгляните на предыдущий код, и вы поймете это лучше:
doc.getDocumentElement().appendChild(ссылка);
Наконец, не забудьте добавить созданный узел в дерево DOM. Метод getDocumentElement() класса Document возвращает объект Element, представляющий корневой узел документа. В документе XML корневой узел должен быть уникальным.
TransformerFactory tFactory =TransformerFactory.newInstance();
Трансформатор-трансформер = tFactory.newTransformer();
Источник DOMSource = новый DOMSource (док);
Результат StreamResult = новый StreamResult(новый Java.io.File("links.xml"));
Transformer.transform(source, result);
Затем используйте XSLT для вывода дерева DOM. TransformerFactory здесь также применяет шаблон фабрики, делая конкретный код независимым от конкретного преобразователя. Метод реализации такой же, как у DocumentBuilderFactory, поэтому я не буду здесь вдаваться в подробности. Метод transfrom класса Transformer принимает два параметра: источник данных Source и целевой результат вывода. DOMSource и StreamResult используются здесь соответственно, чтобы содержимое DOM можно было вывести в выходной поток. Если выходным потоком является файл, содержимое DOM записывается в файл.
Как использовать JSP для разработки приложений SAX?
SAX — это аббревиатура Simple API for XML. Это не официальный стандарт, предложенный W3C. Его можно назвать «народным» стандартом де-факто. Фактически, это результат обсуждения в сообществе. Несмотря на это, SAX используется в XML не меньше, чем DOM, и почти все анализаторы XML поддерживают его.
По сравнению с DOM, SAX — более легкий метод. Мы знаем, что при обработке DOM нам нужно прочитать весь XML-документ, затем создать в памяти дерево DOM и сгенерировать каждый объект Node в дереве DOM. Когда документ небольшой, это не вызывает никаких проблем, но как только документ становится больше, обработка DOM становится довольно трудоемкой и трудоемкой. В частности, его требования к памяти также будут увеличиваться в геометрической прогрессии, так что использование DOM в некоторых приложениях будет нерентабельным (например, в апплетах). На данный момент лучшим альтернативным решением является SAX.
SAX концептуально полностью отличается от DOM. Прежде всего, в отличие от драйвера документа DOM, он управляем событиями, то есть ему не нужно читать весь документ, и процесс чтения документа также является процессом анализа SAX. Так называемый управляемый событиями относится к методу запуска программы, основанному на механизме обратного вызова. (Если вы имеете представление о новой модели прокси-событий Java, вы легко поймете этот механизм.) XMLReader принимает XML-документ и анализирует его в процессе чтения XML-документа, то есть в процессе чтения документа. Одновременно осуществляется процесс синтаксического анализа, что сильно отличается от DOM. Прежде чем начать синтаксический анализ, вам необходимо зарегистрировать ContentHandler с помощью XMLReader, что эквивалентно прослушивателю событий. В ContentHandler определены многие методы, такие как startDocument(), который настраивает то, что должно обрабатываться, когда документ начинает встречаться во время синтаксического анализа. процесс. Когда XMLReader считывает соответствующий контент, он генерирует соответствующее событие, делегирует мощность обработки этого события ContentHandler и вызывает соответствующий метод для ответа.
Это может быть немного сложно понять в общих чертах, но не волнуйтесь, следующие примеры помогут вам понять процесс анализа SAX. Взгляните на этот простой XML-файл:
<POEM>
.
<AUTHOR>Огден Нэш</AUTHOR>
<TITLE>Блохи</TITLE>
<LINE>Адам</LINE>
</POEM>
Когда XMLReader считывает тег <POEM>, он вызывает метод ContentHandler.startElement() и передает имя тега POEM в качестве параметра. Соответствующие действия необходимо выполнить в реализуемом вами методе startElement(), чтобы определить, что следует делать при появлении <POEM>. Каждое событие выбрасывается одно за другим вместе с процессом парсинга (то есть процессом чтения документа), а также последовательно вызываются соответствующие методы. Наконец, когда парсинг завершен и методы вызваны, документ обрабатывается. . Вот и все. В следующей таблице перечислены методы, которые последовательно вызываются при анализе приведенного выше XML-файла:
Обнаружен обратный вызов метода проекта
{document start} startDocument().
<POEM> startElement(null,"POEM",null,{Attributes})
"n" символов("<Стихотворение>n...", 6, 1)
<AUTHOR> startElement(null,"AUTHOR",null,{Attributes})
Персонажи "Огдена Нэша"("<POEM>n...", 15, 10)
</AUTHOR> endElement(null,"AUTHOR",null)
"n" символов("<Стихотворение>n...", 34, 1)
<TITLE> startElement(null,"TITLE",null,{Attributes})
Персонажи "Блохи"("<Стихотворение>n...", 42, 5)
</TITLE> endElement(null,"TITLE",null)
"n" символов("<Стихотворение>n...", 55, 1)
<LINE> startElement(null,"LINE",null,{Attributes})
Символы "Адама"("<Стихотворение>n...", 62, 4)
</LINE> endElement(null,"LINE",null)
"n" символов("<Стихотворение>n...", 67, 1)
</POEM> endElement(null,"POEM",null)
{Конец документа} endDocument()
ContentHandler на самом деле является интерфейсом. При обработке определенного XML-файла вам необходимо создать класс, реализующий ContentHandler для обработки определенных событий. Можно сказать, что это на самом деле основа обработки XML. документ. Давайте взглянем на некоторые из определенных в нем методов:
void символов(char[] ch, int start, int length): Этот метод используется для обработки строки, считанной в файле XML. Его параметром является массив символов и начальная точка считываемой строки в этом массиве. length мы можем легко использовать конструктор класса String для получения класса String этой строки: String charEncontered=new String(ch,start,length).
void startDocument(): Когда вы встретите начало документа, вызовите этот метод, чтобы выполнить некоторую работу по предварительной обработке.
void endDocument(): В соответствии с описанным выше методом, когда документ заканчивается, этот метод вызывается для выполнения некоторой последующей работы.
void startElement(String namespaceURI, String localName, String qName, Attributes atts): этот метод будет запущен при чтении начального тега. Пространства имен не поддерживаются в версии SAX1.0, но поддержка пространств имен обеспечивается в новой версии 2.0. NamespaceURI в этом параметре — это пространство имен, localName — это имя метки, а qName — это измененный префикс метки. нет. При использовании пространств имен ни один из параметров не имеет значения null. А atts — это список атрибутов, содержащихся в этом теге. С помощью atts вы можете получить все имена атрибутов и соответствующие значения. Следует отметить, что важной особенностью SAX является его потоковая обработка. При обнаружении тега он не записывает теги, встреченные ранее. Другими словами, в методе startElement() вся известная вам информация — это имя и атрибуты. Что касается вложенной структуры тега, имени верхнего тега, наличия атрибутов подэлемента и другой информации, связанной со структурой, она неизвестна и для завершения требуется ваша помощь. Это делает SAX менее удобным для программирования, чем DOM.
void endElement(String namespaceURI, String localName, String qName): этот метод соответствует описанному выше методу. Этот метод вызывается при обнаружении закрывающего тега.
Мы по-прежнему используем пример документа, который использовали, когда говорили о DOM, но сначала давайте рассмотрим более простое приложение. Мы надеемся подсчитать, сколько раз каждый тег появляется в XML-файле. Этот пример очень простой, но его достаточно, чтобы проиллюстрировать основные идеи программирования SAX. Конечно, вначале по-прежнему используется оператор импорта:
import org.xml.sax.helpers.DefaultHandler;
импортировать Javax.xml.parsers.*;
импортировать org.xml.sax.*;
импортировать org.xml.sax.helpers.*;
импортировать Java.util.*;
import Java.io.*;
Затем мы создаем класс, который наследуется от DefaultHandler. Конкретную логику программы можно пока отложить. На что следует обратить внимание, так это на структуру программы:
public class SAXCounter расширяет DefaultHandler {.
частные теги хеш-таблицы //Эта хеш-таблица используется для записи количества раз появления тега;
//Работа перед обработкой документа
public void startDocument() выдает исключение SAXException {
tags = new Hashtable();//Инициализировать Hashtable
}
//Обработка каждого атрибута начального элемента
public void startElement (String namespaceURI, String localName,
Строка rawName, атрибуты atts)
выдает исключение SAXException
{
Строковый ключ = localName;
...
Давайте посмотрим, что делает эта программа. В методе main() главное, что вы делаете, — это создаете парсер, а затем анализируете документ. По сути, здесь при создании объекта SAXParser, чтобы сделать программный код независимым от конкретного парсера, используется тот же прием проектирования, что и в DOM: создать конкретный объект SAXParser через класс SAXParserFactory, чтобы при синтаксическом анализе он отличался , все, что нужно изменить, — это значение переменной окружения, при этом код программы может оставаться неизменным. В этом идея паттерна FactoryMethod. Я не буду здесь вдаваться в подробности. Если вы все еще не понимаете, вы можете обратиться к объяснению в DOM выше.
Но здесь следует отметить одну вещь: связь между классом SAXParser и классом XMLReader. Вы можете быть немного сбиты с толку. На самом деле SAXParser — это класс-оболочка для XMLReader в JAXP, а XMLReader — это интерфейс, определенный в SAX2.0 для анализа документов. Вы также можете вызвать метод parser() в SAXParser или XMLReader для анализа документа, и эффект будет точно таким же. Однако метод parser() в SAXParser принимает больше параметров и может анализировать различные источники данных XML-документа, поэтому его удобнее использовать, чем XMLReader.
Этот пример касается только поверхности SAX, но следующий более продвинут. Функция, которую мы хотим реализовать ниже, уже реализована в примере DOM, которая заключается в чтении содержимого XML-документа и форматировании вывода. Хотя логика программы по-прежнему выглядит очень простой, SAX не лучше, чем DOM. Просто посмотрите.
Как упоминалось ранее, при обнаружении открывающего тега в методе startElement() мы не можем получить позицию тега в XML-документе. Это большая проблема при обработке XML-документов, поскольку семантика тегов в XML частично определяется их расположением. А в некоторых программах, которым необходимо проверить структуру документа, это еще большая проблема. Конечно, не существует неразрешимой проблемы. Мы можем использовать стек для записи структуры документа.
Характеристика стека — «первым пришел — первым вышел». Наша текущая идея — использовать push для добавления имени метки в стек в методе startElemnt() и извлечения его в методе endElement(). Мы знаем, что в хорошо структурированном XML структура вложенности является полной. Каждый начальный тег всегда соответствует конечному тегу, и между вложенными тегами не будет несовпадений. Следовательно, каждый вызов метода startElement() неизбежно будет соответствовать вызову метода endElement(), поэтому push и pop также появляются парами. Нам нужно только проанализировать структуру стека, чтобы легко узнать, где находится текущая метка. .. Положение в структуре документа.
Public Class Saxreader расширяет Defaulthandler {
Java.util.stack Tags = new java.util.stack ();
...
Хотя анализ стека здесь не используется, анализ стека на самом деле является очень простой задачей расположен внизу внизу. Атрибуты каждого элемента. Фактически, если мы организуем элементы стека один за другим снизу вниз, мы получим уникальный путь от корневого узла XML до текущего узла. .
До сих пор мы освоили два основных инструмента для программирования XML: DOM и SAX, а также знаем, как их использовать в программе Java. Программирование DOM относительно простое, но медленное и занимает много памяти, в то время как программирование S AX более сложное, но быстро и занимает меньше памяти. Поэтому мы должны выбрать различные методы в соответствии с различными средами. Большинство приложений XML могут быть решены в основном с использованием их. Следует отметить, что DOM и SAX на самом деле не зависят от языка и не являются уникальными для Java.