The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Каталог документации / Раздел "Web мастеру, CGI, Perl, PHP, Apache" / Оглавление документа


Quick Links

1. Введение

Home

1.0 Предварительные требования

Table of Contents

Данное Руководство пользователя написано для активных WEB-разработчиков и предполагает наличие практических знаний о том, как работают web-приложения на Java. Перед тем как начать, вы должны разбираться в основах следующих базовых технологий:
Если вы уже создавали WEB-приложения на других платформах, то скорее всего можете двигаться дальше по этому руководству и обращаться к указанным выше ссылкам при возникновении необходимости. Эти базовые технологии используются почти во всех областях Java Web приложений.

Introduction

Model Components

View Components

Controller Components

Resources

Who We Are

1.1 Введение: Вперед в прошлое! (или краткая история Struts)

Когда были изобретены Java сервлеты, многие программисты быстро осознали, что это Хорошая Вещь. Сервлеты были быстрее и мощнее стандартных CGI, переносимые и бесконечно расширяемые.
Но написание HTML-кода в бесконечных предложениях println() было утомительным и порождало проблемы. Ответом на эти трудности стали JavaServer Pages (JSP), которые перевернули написание написание сервлетов с ног на голову. Теперь разработчики легко смешивают HTML и Java код, и имеют все преимущества сервлетов.
Java web-приложения быстро стали “JSP-centric” - то есть “ориентированными на JSP”. Это само себе не было Плохой Вещью, но это мало помогало в разрешении проблем управления потоком выполнения приложений и порождало другие проблемы.
Очевидна, нужна была иная модель построения приложений...
Множество умных разработчиков осознало, что JSP И сервлеты могут быть использованы вместе для разработки и распространения web-приложений. Сервлеты могут помочь в управлении потоком выполнения приложений, а JSP помогут сфокусироваться на неприятном деле написания HTML-кода. В свое время совместное использование JSP и сервлетов стало известно как Model 2 (использование только JSP – Model 1).
Конечно, нет ничего нового под солнцем... и многие люди сразу указали на то, что Model 2 соответствует классическому паттерну проектирования Model-View-Controller, известному еще в языке Smalltalk. Теперь термины Model 2 и MVC являются взаимозаменяемыми терминами.
Проект Struts был запущен в мае 2000 года Craig R. McClanahan для того, чтобы обеспечить Java – разработчиков стандартной MVC-средой. В июле 2001 был выпущен релиз Struts 1.0, и, по нашему скромному мнению, Java Model 2 разработка никогда не будет прежней.

1.2 Паттерн проектирования Model-View-Controller ('MVC') Design Pattern

В паттерне MVC поток выполнения приложения всегда проходит через центральный контроллер. Контроллер перенаправляет запросы – в нашем случае, это HTTP запросы – к соответствующему обработчику. Обработчики привязаны к Модели, и каждый разработчик действует как адаптер между запросом и Моделью. Модель представляет, или инкапсулирует, бизнес-логику или состояние приложения. Управление обычно передается обратно через Контроллер соответствующему Представлению (View). Перенаправление осуществляется путем обращения к набору соответствий (mappings) между Моделью и представлением; причем этот набор обычно загружается из базы данных или из конфигурационного файла. Такая схема обеспечивает слабое связывание между Представлением и Моделью, что может сделать разработку и сопровождение приложения значительно проще.

1.3 Обзор среды Struts

Согласно паттерну Model-View-Controller, Struts имеет 3 основных компонента: сервлет контроллер, который входит в Struts, JSP страницы (это “представление”) и бизнес-логику приложения (“модель”). Давайте рассмотрим, как это все взаимодействует.
Struts'овский сервлет-контроллер связывает и перенаправляет HTTP запросы к другим объектам среды, включая JavaServer Pages и наследники класса org.apache.struts.action.Action , которые поставляются разработчиком приложения. Во время инициализации контроллер разбирает (parses) конфигурационный файл struts-config.xml. Конфигурационный файл определяет (помимо других вещей) соответствия org.apache.struts.action.ActionMapping s для данного приложения. Контроллер использует эти соответствия для превращения HTTP-запросов в действия приложения.
Обычно ActionMapping определяет:
  • Путь запроса (или “URI”)
  • тип объекта (наследника класса Action) для обработки запроса
  • и другие необходимые свойства

Объект Action может обработать запрос и ответить клиенту (обычно Web-браузеру), или указать, что управление должно быть передано куда-то дальше. Например, если проверка имени и пароля пользователя прошла успешно, Action для обработки этого события может пожелать перенаправить запрос на главное меню.
Объекты Action имеют доступ сервлету-контроллеру приложения, и таким образом имеют доступ к методам сервлета. Во время перенаправления запроса, объект Action может неявно перенаправить один или более совместно используемых (shared) объектов, включая JavaBeans, помещая их в одну из стандартных коллекций, которые совместно используются Java-сервлетами.
Объект Action может создать Bean, представляющий корзину покупателя, поместить этот bean в коллекцию сессии, и затем передать управление на другой mapping. Mapping'у может быть сопоставлен (mapping может использовать) JavaServer Page, отображающей содержимое корзины. Так как каждый клиент имеет собственную сессию, каждый из них будет иметь свою собственную корзину. В приложении Struts большинство элементов бизнес-логики может быть представлено с использованием JavaBeans. Объект Action может обращаться к свойствам JavaBean без углубления в детали реализации. Это инкапсулирует бизнес логику и таким образом Action может сфокусироваться на обработке ошибок и перенаправлении потока управления.
JavaBeans так же могут быть использованы для управления html-формами ввода (input forms). Ключевой проблемой при проектировании web-приложений является хранение и проверка того, что ввел пользователь, в промежутках между запросами. Используя Struts, вы можете определить свой собственный набор классов form bean, унаследовав их от o rg.apache.struts.action.ActionFor m , и легко сохранять данные для форм ввода в этих form bean. Эти beans сохраняются в одной из стандартных совместно используемых сервлетами коллекций, и могут быть использованы другими объектами, особенно объектами Action.
Form bean могут быть использованы в JSP для сбора данных, вводимых пользователем; объектами Action для проверки введенных пользователями данных; и опять в JSP для заполнения полей html-форм. В случае обработки ошибок, Struts имеет совместно используемый механизм для возбуждения и отображения сообщений об ошибках.
Struts form bean объявляются в конфигурационном файле, определяются в исходных Java-кодах, и привязываются к ActionMapping, используя общее имя свойства. Когда запрос вызывает Action, которое использует form bean, сервлет-контроллер либо извлекает, либо создает вновь form bean, и передает его объекту Action. Объект Action может затем проверить содержимое form bean перед тем, как форма ввода для данного form bean будет показана, а также поставить в очередь те сообщения, которые будут обработаны формой. Когда дело сделано, объект Action может вернуть управление, перенаправив его на форму ввода, обычно JSP. После этого контроллер может ответить на HTTP-запрос и направить клиента на JavaServer Page.
Среда Struts включает библиотеки специальных тэгов, которые могут автоматически поместить значения свойств form bean в поля html-форм. Единственная вещь, которую большинство JSP должны знать об остальной части среды это соответствующие имена полей и где надо сделать submit. Компоненты вроде сообщений, которые ставятся в очередь объектами Action могут быть отображены с помощью одного лишь тэга. Могут определяться другие тэги, зависящие от конкретного приложения, для того, чтобы скрыть детали реализации от JSP.
Специальные тэги среды Struts спроектированы для использования свойств интернационализации, которые встроены в платформу Java. Все метки, поля и сообщения могут извлекаться из ресурса сообщений (message resource), и Java может автоматически использовать правильный ресурс в зависимости от страны и языка клиента. Чтобы обеспечить сообщения на дополнительном языке, просто добавьте еще один файл ресурсов.
Помимо интернационализации, другими преимуществами такого подхода являются единое именование меток на различных формах, а также возможность просматривать и изменять все метки и сообщения в централизованном виде.
Для простейших приложений, объект Action иногда может обрабатывать бизнес-логику, связанную с запросом. Однако в большинстве случаев объект Action должен вызывать другой объект, обычно JavaBean, для выполнения операций реальной бизнес-логики. Это позволяет объектам Action сфокусироваться на обработке ошибок и управлении приложением, а не реализацией бизнес-логики. Чтобы быть легко переносимыми на другие платформы, JavaBean не должны ссылаться ни на какие объекты web-приложений. Объект Action должен извлекать/переводить необходимые детали из HTTP-запросов и передавать их объектам классов бизнес-логики в виде обычных Java-переменных.
В приложениях баз данных, например:
  • Bean бизнес-логики соединяется с базой данных и посылает запросы.
  • Bean бизнес-логики возвратит результат объекту Action
  • Объект Action сохранит результат в form bean в запросе (т.е. поместит form bean в context collection – прим.перев.)
  • JavaServer Page отобразит результат в виде HTML-формы
Никогда ни Action, ни JSP не нужно беспокоиться (или заботиться) о том, откуда пришел результат. Они должны знать как упаковать и показать его.
Остальная часть Руководства Пользователя более детально объясняет различные компоненты Struts. Релиз Struts также включает несколько Руководств разработчика, которые описывают различные аспекты среды, вместе с приложениями-примерами, стандартной API-документацией, и конечно, полными исходными кодами!
Struts распространяется под Apache Software Foundation license. Исходный код защищен законами от незаконного копирования, но бесплатен для использования в любых приложениях. Подробнее смотрите ASF license.

1.4 Model (Модель): Состояние системы и бизнес-логика в JavaBeans

Часть Model в системе, основанной на MVC, может быть под разделена на отдельные понятия – внутреннее состояние системы, и действия, которые могут предприниматься для изменения состояния. В терминах грамматики, мы должны думать о информации состояния как о существительных (вещах) и о действиях как о глаголах (изменение состояния этих вещей).
Обычно, ваше приложение будет представлять внутреннее состояние системы как набор одного или более JavaBean, со свойствами, которые представляют подробности состояния. В зависимости от сложности приложения, эти beans могут быть самодостаточны (и знать о том, как сохранять их состояние как-нибудь постоянно), или они могут быть фасадами, которые знают, как извлекать информацию из внешних источников (таких как базы данных), когда их запрашивают. Entity Enterprise JavaBeans (Entity EJBs) также обычно используются для представления внутреннего состояния.
Крупномасштабные приложения часто представляют набор возможных действий бизнес-логики как методы beans, обслуживающих информацию о состоянии. Например, вы можете иметь bean для корзины покупателя, сохраняемый в коллекции сессии для каждого текущего пользователя, со свойствами которые представляют текущий набор продуктов, которые клиент решил купить. Bean также может иметь метод checkOut(), который авторизует кредитную карту пользователя, и посылает заказ на склад, чтобы собрать его и доставить. Другие системы представляют доступные действия раздельно, например через Session Enterprise JavaBeans (Session EJBs).
В небольших приложениях , с другой стороны, возможные действия могут быть включены внутрь классов Action, которые являются частью роли Контроллера. Это нормально, когда логика очень простая, или там, где повторное использование бизнес-логики в других средах не предусматривается. Среда Struts поддерживает любой из этих подходов к разработке приложений, но сильно рекомендуется отделять бизнес-логику (“как это делается”) от той роли, которую играют классы Action (“что делать”).

1.5 View (Представление): JSP страницы и компоненты для представления

View-часть приложения на Struts обычно строится с использованием технологии JavaServer Pages (JSP). JSP-страницы могут содержать статический HTML (или XML) текст, называемый “текстом шаблона” (template text), плюс возможность вставлять динамического содержания, основанного на интерпретации (в момент вызова запроса) специальных тэгов действий (action tags). Среда JSP включает набор стандартных тэгов действий, таких как <jsp:useBean>; их назначение описано в спецификации JavaServer Pages Specification. Помимо этого, предоставляется стандартное средство для определения своих собственных тэгов, которые организуются в “специальные библиотеки тэгов”.
Struts включает расширенную библиотеку тэгов, которые облегчает создание пользовательских интерфейсов, которые полностью интернационализованы, и которые грациозно взаимодействуют с ActionForm beans, являющимися Model-частью системы. Использование этих тэгов подробно обсуждается позже.
В добавление к JSP-страницам, Action и библиотекам специальных тэгов, для бизнес-объектов часто необходимо преобразовать их в HTML (или XML), основываясь на текущем состоянии системы в момент запроса. Преобразованное представление таких объектов может быть легко включено в результирующие JSP при помощи стандартного тэга действия <jsp:include>.

1.6 Controller( Контроллер ): ActionServlet и ActionMapping

Часть Контроллер приложения фокусируется на получении запросов от клиента (обычно пользователя, работающего через web-браузер), принятии решения о том, какая функция бизнес-логики должна быть выполнена, и затем передача ответственности за производство следующей фазы пользовательского интерфейса на соответствующий View-компонент. В Struts главный компонент Контроллера – это сервлет класса ActionServlet. Этот сервлет конфигурируется с помощью определения набора ActionMappings. ActionMapping определяет путь, который соотвествует запрошенному URI из входящего запроса, и обычно определяет полностью заданное имя класса Action. Все Actions унаследованы от org.apache.struts.action.Action. Actions инкапсулируют бизнес-логику, интерпретируют результат, и окончательно передают управление к соответствующему View-компоненту для формирования ответа.
Struts также поддерживает возможность использовать ActionMapping классы, которые имеют дополнительные свойства помимо стандартных, требуемых для функционирования среды. Это позволяет сохранять дополнительную информацию, требуемую для вашего приложения, но в то же время пользоваться остальными функциями среды. Кроме того, Struts позволяет вам определять логические “имена”, используемые для передачи управления на них – таким образом, метод может запросить страницу “MainMenu” (т.е. Главное меню), не имея понятия о том, на какой в действительности JSP странице располагается главное меню.
Эти функции очень здорово помогает в отделении логики управления (что делать) от логики представления (как это показывать).
Далее: Разработка Model-компонентов

Copyright (c) 2000-2002, Apache Software Foundation






Спонсоры:
Inferno Solutions
Hosting by Hoster.ru
Хостинг:

Закладки на сайте
Проследить за страницей
Created 1996-2021 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру