Руководство пользователя Apache Struts

4.5.1 Configure the Action Servlet Instance

Add an entry defining the action servlet itself, along with the appropriate initialization parameters. Such an entry might look like this:

<servlet>
  <servlet-name>action</servlet-name>
  <servlet-class>
    org.apache.struts.action.ActionServlet
  </servlet-class>
  <init-param>
    <param-name>application</param-name>
    <param-value>
      org.apache.struts.example.ApplicationResources
    </param-value>
  </init-param>
  <init-param>
    <param-name>config</param-name>
    <param-value>
      /WEB-INF/struts-config.xml
    </param-value>
  </init-param>
  <init-param>
    <param-name>debug</param-name>
    <param-value>2</param-value>
  </init-param>
  <init-param>
    <param-name>mapping</param-name>
    <param-value>
      org.apache.struts.example.ApplicationMapping
    </param-value>
  </init-param>
  <load-on-startup>2</load-on-startup>
</servlet>

The initialization parameters supported by the controller servlet are described below. (You can also find these details in the Javadocs for the ActionServlet class.) Square brackets describe the default values that are assumed if you do not provide a value for that initialization parameter.

• application - Java class name of the application resources bundle base class. [NONE]

• bufferSize - The size of the input buffer used when processing file uploads. [4096]

• config - Context-relative path to the XML resource containing our configuration information. [/WEB-INF/struts-config.xml]

• content - Default content type and character encoding to be set on each response; may be overridden by a forwarded-to servlet or JSP page. [text/html]

• debug - The debugging detail level for this servlet, which controls how much information is logged. [0]

• detail - The debugging detail level for the Digester we utilize in initMapping(), which logs to System.out instead of the servlet log. [0]

• factory - The Java class name of the MessageResourcesFactory used to create the application MessageResources object. [org.apache.struts.util.PropertyMessageResourcesFactory]

• formBean - The Java class name of the ActionFormBean implementation to use [org.apache.struts.action.ActionFormBean].

• forward - The Java class name of the ActionForward implementation to use [org.apache.struts.action.ActionForward]. Two convenient classes you may wish to use are:

  • org.apache.struts.action.ForwardingActionForward - Subclass of org.apache.struts.action.ActionForward that defaults the redirect property to false (same as the ActionForward default value).

  • org.apache.struts.action.RedirectingActionForward - Subclass of org.apache.struts.action.ActionForward that defaults the redirect property to true.

• locale - If set to true, and there is a user session, identify and store an appropriate java.util.Locale object (under the standard key identified by Action.LOCALE_KEY) in the user's session if there is not a Locale object there already. [true]

• mapping - The Java class name of the ActionMapping implementation to use [org.apache.struts.action.ActionMapping]. Two convenient classes you may wish to use are:

  • org.apache.struts.action.RequestActionMapping - Subclass of org.apache.struts.action.ActionMapping that defaults the scope property to "request".

  • org.apache.struts.action.SessionActionMapping - Subclass of org.apache.struts.action.ActionMapping that defaults the scope property to "session". (Same as the ActionMapping default value).

• maxFileSize - The maximum size (in bytes) of a file to be accepted as a file upload. Can be expressed as a number followed by a "K" "M", or "G", which are interpreted to mean kilobytes, megabytes, or gigabytes, respectively. [250M]

• multipartClass - The fully qualified name of the MultipartRequestHandler implementation class to be used for processing file uploads. [org.apache.struts.upload.DiskMultipartRequestHandler]

• nocache - If set to true, add HTTP headers to every response intended to defeat browser caching of any response we generate or forward to. [false]

• null - If set to true, set our application resources to return null if an unknown message key is used. Otherwise, an error message including the offending message key will be returned. [true]

• tempDir - The temporary working directory to use when processing file uploads. [The working directory provided to this web application as a servlet context attribute]

• validate - Are we using the new configuration file format? [true]

• validating - Should we use a validating XML parse to process the configuration file (strongly recommended)? [true]

4.5.2 Configure the Action Servlet Mapping

Note: The material in this section is not specific to Struts. The configuration of servlet mappings is defined in the Java Servlet Specification. This section describes the most common means of configuring a Struts application.

There are two common approaches to defining the URLs that will be processed by the controller servlet -- prefix matching and extension matching. An appropriate mapping entry for each approach will be described below.

Prefix matching means that you want all URLs that start (after the context path part) with a particular value to be passed to this servlet. Such an entry might look like this:

  <servlet-mapping>
     <servlet-name>action</servlet-name>
     <url-pattern>/execute/*</url-pattern>
   </servlet-mapping>

which means that a request URI to match the /logon path described earlier might look like this:

http://www.mycompany.com/myapplication/execute/logon

where /myapplication is the context path under which your application is deployed.

Extension mapping, on the other hand, matches request URIs to the action servlet based on the fact that the URI ends with a period followed by a defined set of characters. For example, the JSP processing servlet is mapped to the *.jsp pattern so that it is called to process every JSP page that is requested. To use the *.do extension (which implies "do something"), the mapping entry would look like this:

  <servlet-mapping>
     <servlet-name>action</servlet-name>
     <url-pattern>*.do</url-pattern>
   </servlet-mapping>

and a request URI to match the /logon path described earlier might look like this:

http://www.mycompany.com/myapplication/logon.do

4.5.3 Configure the Struts Tag Library

Next, you must add an entry defining the Struts tag library. There are currently four taglibs that Struts is packaged with.

The struts-bean taglib contains tags useful in accessing beans and their properties, as well as defining new beans (based on these accesses) that are accessible to the remainder of the page via scripting variables and page scope attributes. Convenient mechanisms to create new beans based on the value of request cookies, headers, and parameters are also provided.

The struts-html taglib contains tags used to create struts input forms, as well as other tags generally useful in the creation of HTML-based user interfaces.

The struts-logic taglib contains tags that are useful in managing conditional generation of output text, looping over object collections for repetitive generation of output text, and application flow management.

The struts-template taglib contains tags that define a template mechanism.

Below is how you would define all taglibs for use within your application, in reality you would only specify the taglib's that your application will use:

<taglib>
  <taglib-uri>
    /WEB-INF/struts-bean.tld
  </taglib-uri>
  <taglib-location>
    /WEB-INF/struts-bean.tld
  </taglib-location>
</taglib>
<taglib>
  <taglib-uri>
    /WEB-INF/struts-html.tld
  </taglib-uri>
  <taglib-location>
    /WEB-INF/struts-html.tld
  </taglib-location>
</taglib>
<taglib>
  <taglib-uri>
    /WEB-INF/struts-logic.tld
  </taglib-uri>
  <taglib-location>
    /WEB-INF/struts-logic.tld
  </taglib-location>
</taglib>
<taglib>
  <taglib-uri>
    /WEB-INF/struts-template.tld
  </taglib-uri>
  <taglib-location>
    /WEB-INF/struts-template.tld
  </taglib-location>
</taglib>

This tells the JSP system where to find the tag library descriptor for this library (in your application's WEB-INF directory, instead of out on the Internet somewhere).

4.5.4 Add Struts Components To Your Application

To use Struts, you must copy the .tld files that you require into your WEB-INF directory, and copy struts.jar (and all of the commons-*.jar files) into your WEB-INF/lib directory.

Next: Struts Resources

2. Разработка Model-компонентов

Home

2.1 Обзор

Table of Contents

Обычно много внимания при разработке web-приложений уделяется View. Однако, вы должны гарантировать, что обработка каждого посланного пользователем запроса также ясно определена с точки зрения Model. Обычно разработчик Model-компонентов сосредотачивается на создании JavaBean-классов, которые поддерживают функциональные требования. Точные характеристики beans, требуемых конкретным приложением могут сильно меняться в зависимости от этих требований, они они в общем могут быть классифицированы и подразделены на несколько категорий, обсуждаемых ниже в этом разделе. Однако первым делом мы рассмотрим краткую концепцию термина “scope” (англ. область) и его связь с beans.

Introduction

Model Components

View Components

Controller Components

Resources

Who We Are

2.2 JavaBeans и Scope

Внутри web-приложений объекты JavaBeans могут сохраняться в (и извлекаться из) наборе различных коллекций “атрибутов”. Каждая коллекция имеет различные правила, регламентирующие время жизни коллекции и видимость объектов-beans, помещенных в нее. В совокупности, правила времени жизни и видимости beans называется scope (областью видимости) beans. Спецификация JavaServer Pages (JSP) определяет различные варианты scope, используя следующие термины (эквивалентные концепции из Servlet API приведены в круглых скобках):

• page – beans которые видимы в пределах единственной JSP-страницы, в течение времени жизни текущего запроса (это локальные переменные метода service())

• request - beans, которые видны на единственной JSP странице, а также любой странице и сервлете, который включен в эту страницу, или перенаправлен с этой странице (атрибуты запроса (Request attributes))

• session – beans, которые всем JSP страницам и сервлетам, которые участвуют в конкретной сессии пользователя, в одном и более запросах (атрибуты сессии)

• application – beans, которые видимы всем JSP-страницам и сервлетам, являющимся частью web-приложения (Servlet context attributes)

Важно помнить о том, что сервлеты и JSP-страницы в одном web-приложении совместно используют тот же самый набор коллекций beans. Например, bean, сохраненный в атрибуте запроса (request attribute) в сервлете примерно так:

MyCart mycart = new MyCart(...);
request.setAttribute("cart", mycart);

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

<jsp:useBean id="cart" scope="request"
class="com.mycompany.MyApp.MyCart"/>

2.3 ActionForm Beans

Примечание: ActionForm beans на самом деле ближе к View, чем к Model.

При использовании Struts обычно предполагается, что необходимо определить ActionForm bean (то есть, Java-класс, расширяющий класс ActionForm) для каждой формы ввода, требуемой для вашего приложения. ActionForm beans иногда называют просто “form beans” (beans для формы). Если вы определяете такие beans в конфигурационном файле ActionMapping (см. " Разработка компонентов Controller"), то сервлет-контроллер Struts автоматически выполнит для вас следующие действия, прежде чем вызвать соответствующий Action:

• Проверяет, нет ли в пользовательской сессии экземпляра bean соответствующего класса, с соответствующим ключом.

• Если в сессии нет такого Bean, то создается новый экземпляр и автоматически добавляется к пользовательской сессии (ес-но, со scope = session)

• Для каждого параметра запроса чье имя соответствует имени свойства в bean, вызывается соответствующий setter-метод (т.е. setXXX, см. спецификацию JavaBeans). Это действует примерно так же, как стандартное действие для JSP <jsp:setProperty>, когда вы используете wildcard “*” для того, чтобы выбрать все параметры.

• Обновленное ActionForm bean передается в метод perform() класса Action во время его вызова, обеспечивая немедленный доступ к его значениям

Когда вы будете программировать ваши ActionForm beans, старайтесь соблюдать следующие принципы:

• Сам по себе ActionForm класс не требует реализации никаких специфических методов. Он используется для определения роли, которую данное конкретное bean играет во всеобщей архитектуре. Обычно ActionForm bean имеет только getter и setter методы для своих свойств - и никакой бизнес-логики.

• Объект ActionForm также предлагает стандартный механизм проверки (standard validation mechanism). Если вы переопределите заглушку для метода и обеспечите сообщения об ошибках в стандартном ресурсе приложения, то Struts автоматически проверит данные, вводимые в форме (используя ваш метод). Подробнее смотрите "Автоматическая проверка Form". Конечно, вы также можете проигнорировать проверку в ActionForm и обеспечить свою собственную в объекте Action.

• Определяйте свойство (с соответствующими методами setXxx() и getXxx()) для каждого поля в html-форме. Имена полей и свойств должны соответствовать друг другу согласно обычным соглашениям JavaBean. Например, для поля с именем username будет вызван метод setUsername().

• Представляйте ваши ActionForm beans как стену (firewall) между HTTP и Action. Используйте проверку для того, чтобы гарантировать наличие всех требуемых свойств и то, что они содержат разумные значения. ActionForm, которая не прошла проверку, не будет даже передана в Action для обработки.

• Вы можете расположить экземпляр bean на вашей форме и использовать вложенные ссылки на свойства. Например, вы можете иметь bean “customer” в вашем ActionForm, и затем обращаться к свойству "customer.name" на JSP. Это будет соответствовать вызову методов customer.getName() и customer.setName(string Name) в вашем customer bean. Подробнее о синтаксисе вложенных свойств смотрите Tag Library Developer Guides (Руководства по использованию библиотек тэгов).

• Предупреждение: Если вы вкладываете существующий экземпляр bean в вашу форму (имеется в виду ActionForm, конечно), то подумайте о свойствах, которые bean предоставляет. Любое public-значение в ActionForm, которое принимает String-значение, может быть установлено с помощью строки запроса (query string). Может быть полезно помещать подобные beans в “тонкую обертку”, которая будет предоставлять (открывать) только необходимые в данном случае свойства. Также эта обертка может обеспечивать фильтр, для того чтобы быть уверенным в том, что свойства во время выполнения не установлены в неподходящие значения. (Прим. перев.: данное предупреждение относится прежде всего к вопросам безопасности – необходимо помнить о том, что HTTP request может быть сформирован не только в вашей JSP, а также другими средствами – с целью хищения информации, например, и поэтому надо всегда проверять входные данные на адекватность)

Вы должны заметить, что “form” (форма) в том смысле, как это обсуждается здесь, не обязательно соответствует единственной JSP-странице в пользовательском интерфейсе. Обычное дело во многих приложениях – это иметь “form” (c точки зрения пользователя), которая “растянута” по многим страницам. Подумайте, например, о стиле пользовательского интерфейса в виде мастеров (wizard style user interface), который обычно используется во время установки нового программного обеспечения. Struts дает возможность определить единственную ActionForm bean, которое содержит свойства для всех полей, вне зависимости от того, на какой странице они в действительности будут отображены. Аналогично, различные страницы для одной и той же формы должны быть переданы на обработку (submitted) к одному и тому классу Action.

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

2.4 System State Beans (Beans состояния системы)

Реальное состояние системы обычно представлено как набор из нескольких JavaBeans классов, чьи свойства определяют текущее состояние. Система корзины покупателя, например, будет включать bean для представления корзины, который будет храниться для каждого отдельного покупателя и будет (помимо других вещей) включать набор тех продуктов, которые покупатель в данный момент отобрал для покупки. Отдельно, система будет включать различные beans для хранения информации о профиле пользователя (включая его кредитную карту и ShipTo адрес), так же как и каталог доступных продуктов и их текущие количества на складе.

В небольших системах, или когда информацию о состоянии не нужно хранить длительное время, набор beans состояния системы может содержать все знания, которые система когда-либо имеет. Или, как это часто случается, beans состояния системы представляют информацию, которая постоянно хранится в некой внешней базе данных (например, объект CustomerBean который соответствует конкретной строчке в таблице CUSTOMERS), и создаются и уничтожаются из хранилища на сервере когда это необходимо. В очень больших приложениях для этих целей используются Entity Enterprise JavaBeans.

2.5 Business Logic Beans (Beans бизнес-логики)

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

Чтобы обеспечить максимальное повторное использование кода, beans бизнес-логики должны быть спроектированы и реализованы так, чтобы они ничего не знали о том, что они запускаются в среде web-приложения. Если вы импортируете классы из javax.servlet.* в ваш bean, то вы привязываете эту бизнес логику к среде выполнения web-приложений. Рассмотрите вопросы перестройки (rearranging things), которые выполняют ваши Action классы (часть роли Контроллера, как описано ниже): переводят всю необходимую информацию из HTTP-запроса в вызовы getter и setter-методов свойств ваших beans бизнес-логики, после чего можно вызвать метод execute(). Подобные бизнес-классы могут быть повторно использованы не только в web-приложениях, для которых они первоначально создавались.

В зависимости от сложности и масштаба вашего приложения, beans бизнес-логики могут быть обычными JavaBeans, которые взаимодействуют с beans состояния системы, передаваемые как в качестве параметров, или обычными JavaBeans, которые обращаются к базе данных используя вызовы JDBC. Для крупных приложений, вместо этих beans часто используются stateful или stateless (с сохранением состояния или без сохранения состояния)Enterprise JavaBeans (EJBs).

2.6 Доступ к реляционным базам данных

Struts могут определять datasources (источники данных) для приложения в своем стандартном конфигурационном файле. Также предусмотрен простой пул JDBC-соединений. Подробнее смотрите Конфигурационный файл Action Mappings, и Utilities Developer Guide.

После определения datasource, можно воспользоваться примером установления соединения внутри метода perform() класса Action.

public ActionForward
       perform(ActionMapping mapping,
               ActionForm form,
               HttpServletRequest request,
               HttpServletResponse response)
{
 try {
   javax.sql.DataSource dataSource =
     servlet.findDataSource(null);
   java.sql.Connection myConnection =
     dataSource.getConnection();

   //делайте что вам нужно с экземпляром myConnection
 } catch (SQLException sqle) {
   getServlet().log("Connection.process", sqle);
 } finally {

   //завершает все это блок finally, который
   //гарантирует, что connection закрыт
   try {
     myConnection.close();
   } catch (SQLException e) {
     getServlet().log("Connection.close", e);
   }
 }
}

Обратите внимание, что общий пул соединений Struts являет опциональным компонентом. Множество приложений на базе Struts использует другие пулы соединений для получения наилучшей производительности, особенно на промышленных системах большого объема.

Далее: Разработка View-компонентов

Copyright (c) 2000-2002, Apache Software Foundation

3. Разработка View-компонентов

Home

3.1 Обзор

Table of Contents

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

Introduction

Model Components

View Components

3.2 Интернационализация

Controller Components

Несколько лет назад разработчики приложений могли рассчитывать на распространение своих приложений только среди жителей собственной страны, которые используют один (иногда два) языка и единственный способ представления таких вещей, как даты, числовые и денежные значения. Однако взрывной рост разработки приложений с использованием web-технологий, также как и распространение этих приложений через Интернет, частично сделал национальные границы невидимыми. Это привело к необходимости разрабатывать приложения с поддержкой интернационализации (часто интернационализацию по-английски называют i18n (ай-эйтин), потому что в слове internationalization 18 букв между i и n) и локализации (localization).

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

• Locale – основной Java класс, который поддерживает интернационализацию - java.util.Locale. Каждая Locale представляет собой конкретный выбор страны и языка (плюс возможный вариант языка), а также набор способов форматирования таких вещей как числа и даты.

• ResourceBundle - Класс java.util.ResourceBundle обеспечивает основные инструменты для поддержки сообщений на многих языках. Подробнее смотрите Javadocs – класс ResourceBundle, а также информацию об интернационализации в документации к вашему релизу JDK.

• PropertyResourceBundle – Одна из стандартных реализаций ResourceBundle позволяет вам определять ресурсы, используя тот же синтаксис “имя=значение” ("name=value"), что используется при инициализации файлов свойств. Это очень удобно для подготовки пакетов ресурсов (resource bundles) с сообщениями, которые используются в web-приложении, потому что обычно такие сообщения представлены в виде текста.

• MessageFormat - Класс java.text.MessageFormat позволяет заменять части строки сообщения (в этом случае они извлекаются из пакета ресурсов) аргументами, определяемыми во время выполнения. Это полезно в случае, когда вы создаете предложение, но слова в нем будут появляться в различном порядке на различных языках. Строка-заменитель {0} в сообщении заменяется первым аргументом, {1} заменяется вторым аргументом и так далее.

• MessageResources – Класс Struts org.apache.struts.util.MessageResources позволяет обращаться с пакетами ресурсов как с базой данных, и позволяет запрашивать конкретную строку сообщения для конкретной Locale (обычно Locale для текущего пользователя) вместо Locale, используемой по умолчанию на сервере, где запущено данное приложение.

Обратите внимание, что поддержка i18n в средах вроде Struts ограничена представлением интернационализованного текста и изображений для пользователя. Поддержка для Locale соответствующих методов ввода (используемых в таких языках как японский, китайский и корейский) возлагается на клиентское устройство – обычно web-браузер.

Что получить интернационализованное приложение, следуйте рекомендациям, описанным в документе по интернационализации в документации JDK на вашей платформе, для того чтобы создать файл свойств (properties file), содержащий сообщения для каждого языка. Пример рассмотрен чуть ниже.

Предположим, что ваш исходный код создается в package com.mycompany.mypackage, и таким образом сохраняется в каталоге (относительно вашего каталога исходных кодов) com/mycompany/mypackage. Чтобы создать пакет ресурсов, названный com.mycompany.mypackage.MyResources, вы должны создать следующие файлы в каталоге com/mycompany/mypackage:

• MyResources.properties – содержит сообщения на языке, используемом по умолчанию на вашем сервере. Если ваш язык по умолчанию – English, то в этом файле должны содержатся строки вроде этой: prompt.hello=Hello

• MyResources_xx.properties – содержит те же самые сообщения на языке, чей ISO код = “xx” (вы найдете ссылку на список текущих языков на странице ResourceBundle Javadoc). Для французской версии сообщения, показанного выше, вы должны написать что то вроде: prompt.hello=Bonjour. Вы можете иметь пакеты ресурсов для каждого языка, который вам нужно поддерживать.

Когда вы конфигурируете сервлет-контроллер в дескрипторе для распространения web-приложения (web application deployment descriptor), одна из тех вещей, которые вы должны определить в параметрах инициализации – основное имя пакета ресурсов для вашего приложения. В случае, описанном выше, это должен быть com.mycompany.mypackage.MyResources:

<servlet>
  <servlet-name>action</servlet-name>
  <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
  <init-param>
    <param-name>application</param-name>
    <param-value>com.mycompany.mypackage.MyResources</param-value>
  </init-param>
  <.../>
</servlet>

Важно отметить, что пакет ресурсов должен находиться в class path для вашего приложения. Другой подход – сохранять MyResources.properties в каталоге классов вашего приложения. Затем вы можете просто определить "myResources" как значение в вашем приложении (as the application value). Просто будьте осторожны, чтобы этот файл не был удален вашим build-скриптом, который удаляет классы как часть "clean" target.

Если вы пользуетесь таким методом, вот Ant task, который нужно запустить во время компиляции вашего приложения, который скопирует содержимое каталога src/conf в каталог классов:

        <!-- Copy any configuration files -->
        <copy todir="classes">
            <fileset dir="src/conf"/>
        </copy>
       

Resources

Who We Are

3.3 Взаимодействие Forms и FormBean

Так или иначе, большинство разработчиков веб-приложений должны создавать формы, используя стандартные возможности HTML, такие как тэг <input>. Пользователи ожидают, что интерактивные приложения должны иметь определенное поведение, и одно из этих ожиданий связано с обработкой ошибок – если пользователь делает ошибку, приложение должно позволить ему исправить лишь то, что нужно – без необходимости вводить заново остальную (правильную) часть информации на текущей странице или форме.

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

<input type="text" name="username"
      value="<%= loginBean.getUsername() %>"/>

это трудно правильно напечатать, смущает HTML разработчиков, которые не опытны в концепциях программирования , и могут привести к проблемам с редакторами HTML. Вместо этого Struts обеспечивает исчерпывающий набор средств для создания форм, основываясь на средствах специальной библиотеки тэгов (Custom Tag Library) в JSP 1.1. Пример, показанный раньше, может быть представлен средствами Struts следующим образом:

<html:text property="username"/>

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

HTML-формы иногда используются для загрузки других файлов (upload other files). Большинство браузеров поддерживают это с помощью элемента <input type="file">, который генерирует кнопку поиска файлов (file browse button), но на совести разработчика остается то, как обработать вхлдящие файлы. Struts обрабатывает такие "multipart"-формы таким же способом, как и обычные формы. В следующем разделе мы рассмотрим использование Struts для создания простой формы входа (login form), а также простую mulitpart-форму.

3.3.1 Разработка Forms в Struts

Полный пример login-формы иллюстрирует то, что Struts взаимодействует с формами гораздо менее болезненно, чем при прямом использовании HTML и стандартных средств JSP. Рассмотрим следующую страницу logon.jsp (основанную на примере приложения, включенном в поставку Struts):

<%@ page language="java" %>
<%@ taglib uri="/WEB-INF/struts-html.tld"        prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld"        prefix="bean" %>

<html:html>
<head>
<title>
  <bean:message key="logon.title"/>
</title>

<body bgcolor="white">

<html:errors/>

<html:form action="/logon" focus="username">
<table border="0" width="100%">
  <tr>
    <th align="right">
      <html:message key="prompt.username"/>
    </th>
    <td align="left">
      <html:text property="username" size="16"/>
    </td>
  </tr>
  <tr>
    <th align="right">
      <html:message key="prompt.password"/>
    </th>
    <td align="left">
      <html:password property="password" size="16"/>
    </td>
  </tr>
  <tr>
    <td align="right">
      <html:submit>
        <bean:message key="button.submit"/>
      </html:submit>
    </td>
    <td align="right">
      <html:reset>
        <bean:message key="button.reset"/>
      </html:reset>
    </td>
  </tr>
</table>
</html:form>
</body>
</html:html>

Следующие пункты проясняют ключевые свойства обработки форм в Struts, основываясь на приведенном примере:

• Директива taglib говорит компилятору JSP-страницы, где найти дескриптор библиотеки тэгов (tag library descriptor) для библиотеки тэгов Struts. В данном случае, мы используем префикс “bean” (prefix="bean") который идентифицирует тэги из библиотеки struts-bean, и “html” как префикс, который идентифицирует тэги из библиотеки struts-html. Вы можете использовать любой удобный для вас префикс для идентификации тэгов библиотеки.

• На этой странице несколько раз появляется тэг message для того, чтобы извлечь интернационализованные сообщения из объекта MessageResources, содержащего все ресурсы данного приложения. Чтобы данная страница могла работать, следующие ключи сообщений должны быть определены в ресурсах:

  • logon.title – заголовок данной страницы входа

  • prompt.username – строка приглашения для имени пользователя- "Username:"

  • prompt.password - строка приглашения пароля: "Password:"

  • button.submit - надпись на кнопке: "Submit"

  • button.reset - надпись на кнопке:"Reset"

  Когда пользователь войдет, приложение может сохранить объект Locale в сессии пользователя. Эта Locale будет использоваться для выбора сообщений на соответствующем языке. Это делает проще реализовать возможность переключения языков – просто измените сохраненный объект Locale, и все сообщения переключатся на нужный язык автоматически.

• Тэг errors показывает любые сообщения об ошибках, которые были сохранены компонентами бизнес-логики, или ничего не показывает, если никаких ошибок не было записано. Этот тэг будет более подробно описан ниже.

• Тэг form представляет HTML элемент <form>, основываясь на заданных атрибутах. Он также связывает все поля этой формы с объектом FormBean, хранящемся в сессии под ключем logonForm. Разработчики Struts-приложения должны обеспечить Java-реализацию этого form bean, унаследовав его от класса Struts ActionForm. Этот bean используется для задания начальных значений всем полям ввода, которые имеют имена, соответствующие именам свойств в этом bean. Если соответствующий bean не найден, то новый экземпляр будет создан автоматически, используя указанное имя Java-класса. (Form beam может быть так же определен в конфигурационном файле Struts, и в этом случае атрибуты Name и Type могут быть опущены. Подробнее смотрите Конфигуарционный фай Action Mappings.)

• Тэг text представляет HTML элемент <input> с типом “text”. В этом случае также указывается число символов (длина), которое будет иметь данный элемент при отображении в браузере. Когда страница генерируется, этот элемент получит значение свойства username d соответствующем bean (то есть, значение, которое будет возвращено getUsername()).

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

• Тэги submit и reset генерируют соответствующие кнопки внизу формы. Текст на кнопках для каждой кнопки создается с использованием тэга message, также как и строки приглашений – и таким образом эти значения интернационализуются.

Обработка multipart-формы также очень проста. Очевидно, когда вы создаете multipart-форму, вы создаете форму, в которой есть хоть один элемент типа “file” (<input type=”file”>). Первым шагом в создании multipart-формы является использование на JSP-странице библиотеки тэгов Struts struts-html:

<%@page language="java">
<%@taglib uri="/WEB-INF/struts-html.tld"   prefix="html">

<html:form action="uploadAction.do">
  Please Input Text:
  <html:text property="myText"><br/>
  Please Input The File You Wish to Upload:<br/>
  <html:file property="myFile"><br />
  <html:submit />
</html:form>

Следующим шагом будет создание вашего ActionForm bean:

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.upload.FormFile;

public class UploadForm extends ActionForm {
  protected String myText;
  protected FormFile myFile;
  public void setMyText(String text) {
    myText = text;
  }
  public String getMyText() {
    return myText;
  }
  public void setMyFile(FormFile file) {
    myFile = file;
  }
  public FormFile getMyFile() {
    return myFile;
  }
}

Взгляните на Javadocs для FormFile, чтобы ознакомиться с методами, которые он представляет для манипуляции файлами при их загрузке (file uploading). Также взгляните на Javadocs для ActionServlet и ActionMapping, чтобы ознакомиться с различными параметрами, которые можно задавать, чтобы изменить процесс загрузки файлов. Обычно в методе perform() в вашем Action-классе вы должны вызвать ((UploadForm) form).getMyFile() , чтобы получить FormFile и делать с ним все, что пожелаете.

3.3.2 Поддерживаемые типы Input-полей

Struts определяет HTML-тэги для следующих типов input-полей (ссылки ведут на соответствующую справочную информацию):

• checkboxes

• hidden поля

• password input- поля

• radio кнопки

• reset кнопки

• select списки с встроенными опциями

• option

• options

• submit кнопки

• text input-поля

• textareas

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

3.3.3 Другие полезные тэги для представления данных

Есть еще несколько полезных тэгов для создания представлений. Обращайтесь к документации по каждой конкретной библиотеке тэгов вместе с изучением Tag Developers Guides.

• [logic] iterate повторяет для каждого элемента коллекции (Hashtable, Map. etc) тело тэга. Это полезно для организации цикла по всем элементам коллекции.

• [logic] present в зависимости от того, какой атрибут установлен, это тэг проверяет текущий request, и выполняет тело тэга, если в request'е присутствует это значение. Только один из атрибутов может использован при каждом использовании тэга, а если вы используете атрибут-свойство, то в этом случае также требуется указать имя атрибута. Возможные виды атрибуты включают cookie, header, name, parameter, property, role, scope, и user.

• [logic] notPresent этот тэг-антоним для present. Тэг notPresent обеспечивает ту же функциональнось, что и present, но только в случае, если указанный атрибут не присутствует в request. Тэг полезен, например, для проверки того, зарегистрировался ли пользователь в системе – и если нет, то перенаправляем управление на страницу входа.

• [html] link генерирует HTML-элемент <a> как anchor definition или как гиперссылку на указанный URL, и автоматически указывает кодировку URL чтобы управлять состоянием сессии в случае отсутствии поддержки cookies.

• [html] img генерирует HTML <img> элемент с возможностью динамически модифицировать URL, определенный атрибутами "src" и "lowsrc" – подобно тому, как это делает тэг <html:link>.

• [bean] parameter извлекает значение указанного параметра запроса (request parameter) и определяет результат как атрибут page scope с типом String или String[].

3.3.4 Автоматическая проверка Form

Помимо взаимодействия форм и beans, описанного выше, Struts предлагает дополнительные средства для проверки значений полей ввода, которые были получены от пользователя. Чтобы использовать данные средства, переопределите (override) следующий метод в вашем классе-наследнике ActionForm:

public ActionErrors  validate(ActionMapping mapping,    HttpServletRequest request);

Метод validate() вызывается сервлетом-контроллером после того, как свойства bean были заполнены и с помощью submit были посланы на сервер, но перед тем, как будет вызван соответствующий метод perform() action-класса. Метод validate() имеет следующие опции:

The validate() method is called by the controller servlet after the bean properties have been populated, but before the corresponding action class's perform() method is invoked. The validate() method has the following options:

• Если выполнили соответствующие проверки и не нашли никаких проблем – то возвращаем либо Null, либо экземпляр ActionErrors, имеющий нулевую длину, и в этом случае сервлет-контроллер вызовет метод perform() в соответствующем Action-классе.

• Если выполнили соответствующие проверки и нашли проблемы – то возвращаем экземпляр коллекции ActionErrors, содержащий набор экземпляров ActionError (без -s), где ActionError – это класс, который содержит ключи сообщений об ошибках (ключи эти расшифрованы, конечно, в пакете MessageResources приложения), которые должны быть показаны. Сервлет-контроллер сохранит этот массив ошибок в атрибуте request, удобном для использования в тэге <html:errors>, и затем возвратит управление обратно ту же форму ввода (которая идентифицируется как свойство input для данного ActionMapping). В результате получается удобное средство для обработки ошибочных ситуаций, которое дает пользователю возможность вернуться в то место, где он ошибся и исправить ошибку.

Как было указано выше, эта автоматическая проверка полей ввода является полностью опциональной. Реализация метода validate() по умолчанию возвращает null, и сервлет-контроллер предполагает, что вся требуемая проверка будет производится в action-классе.

Обычный подход – это выполнять первичные, простейшие проверки с использованием метода ActionForm validate(), а затем производить проверку с точки зрения бизнес-логики в action-классе.

Дополнительный пакет для выполнения проверок в ActionForm доступен в Nightly Build (но не забудьте проверить и текущий релиз!) и с сайта David Winterfeldt's Web site.

3.4 Другие методы представления данных

Хотя стиль вашего приложения (look and feel) может быть полностью построен на основании стандартных возможностей JSP и специфических библиотек тэгов Struts, вы можете рассмотреть возможность использования других методов, которые улучшат повторное использование компонентов, облегчат эксплуатацию приложения, и/или уменьшат количество ошибок. Несколько возможных вариантов рассмотрены ниже в этом разделе.

3.4.1 Тэги для конкретного приложения

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

• checkLogon – этот тэг проверяет существование конкретного объекта сессии, и передает управление на страницу logon, если объекта сессии не существует. Это используется для того, чтобы отловить ситуацию, когда пользователь добавил страницу из “середины” вашего приложения в закладки и пытается попасть на эту страницу, миновав диалог входа, или когда время сессии истекло.

• linkSubscription – создает гиперссылку для страницы, содержащей сведения о Subscription, которое передает требуемый первичный ключ как атрибут request'а. Это используется для вывода списка подписок для данного пользователя, и чтобы создать ссылки для их редактирования или удаления.

• linkUser – генерирует гиперссылку на страницу подробностей о пользователе, передавая требуемый первичный ключ как атрибут запроса.

Исходный код для этих тэгов находится в каталоге src/example, в package org.apache.struts.example, вместе с другими Java-классами, используемыми в данном примере.

3.4.2 Сборка страниц с помощью директивы Includes

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

Например, приложение-портал должно иметь несколько (или даже все) следующие функциональные возможности на “домашней” странице портала:

• Доступ к поисковому механизму данного портала.

• Одну или более “новостных лент”, с разделами по интересам согласно пользовательскому профилю.

• Доступ к форумам этого, связанных с разделами.

• “Индикатор ожидания почты”, если ваш портал поддерживает бесплатные email.

Разработка различных сегментов сайта становится проще, если вы разделите свою работу, и назначите различных разработчиков на различные сегменты. Затем можно будет использовать возможность include в технологии JavaServer Pages для того чтобы объединить результаты в единую результирующую страницу, или использовать тэг include, поставляемый вместе со Struts. Есть три возможных типа include, зависящих от того, когда нужно получить комбинацию результатов:

• Директива <%@ include file="xxxxx" %> может подключить файл, который содержит Java-код или JSP-тэги. Код во включаемом файле может даже ссылаться на переменные, объявленные выше во внешней JSP-странице. Код встраивается (inlined) в другую JavaServer Page до того, как он компилируется, и таким образом он определенно содержать нечто большее, чем просто HTML.

• include action (<jsp:include page="xxxxx" flush="true" />) обрабатывается во время запроса, и управляется прозрачно для сервера. Помимо всего прочего, это означает, что вы можете выполнять условную сборку страницы из подключений, если вложите их в тэг вроде equals.

• Тэг bean:include принимает в качестве аргумента либо “forward”, представляющий логическое имя, связанное с подключаемой jsp, либо аргумент “id”, который представляет String-переменную context, используемую для вывода jsp-страницы.

Другим подходом может быть использование библиотеки тэгов шаблонов Struts (Struts Template Tag library). Подробнее смотрите Руководство Разработчика.

Использование Tiles является альтернативой первоначальной библиотеки Template Tag. Tiles предлагают несколько расширений и новых возможностей. Tiles доступны в Nightly Build (но не забудьте проверить и текущий релиз!) и с сайта Cedric Dumoulin's Web site.

3.4.3 Компоненты обработки изображений

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

• Представить гиперссылку с URL, который выполнит запрос сервлета. Сервлет будет использовать графическую библиотеку чтобы представить графическое изображение, соответственно установить тип содержимого (content type) - такое, как image/gif, и возвратить сгенерированные байты обратно браузеру, который покажет точно так же, как если бы он получил статический файл.

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

3.4.4 Представление текста

Некоторые приложения требуют использование динамически сгенерированного текста или разметки, например XML. Если целая страница представляется таким образом, и есть возможность использовать PrintWriter для получения вывода, то очень просто сделать это из Action:

           response.setContentType("text/plain"); // or text/xml
           PrintWriter writer = response.getWriter();
           // use writer to render text
           return(null);
         

Далееt: Разработка Controller- компонентов

Copyright (c) 2000-2002, Apache Software Foundation

1. Введение

Home

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

Table of Contents

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

• Последовательность вызовов HTTP Request/Response.
  Канонический источник - RFC 2616 - Hypertext Transfer Protocol (HTTP/1.1).

• Java сервлеты.
  Хорошее место, с которого следует начать освоение этой технологии — Sun Servlet product page и Sun Java примеры.

• JavaServer Pages (JSP).
  Начните с Sun JSP product page и с Sun Java Tutorials.

• JavaBeans.
  Многие Struts-классы classes реализованы как JavaBeans. Если вы ранее не работали с JavaBeans, смотрите Sun JavaBean product page и Sun Java Tutorials

Если вы уже создавали 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

All work on Struts is contributed by volunteers whose only motivation is to help make Struts work even better, both for themselves and for rest of the community.

All contributions are welcome, and may be discussed and posted on the mailing lists. The final decision of what becomes part of the official distribution is made by a group of Committers. For more about Meritocracy, see the Management page on the Apache Jarakta Website.

• Arun M. Thomas
• Chris Audley
• Craig R. McClanahan
• David Geary
• Don Clasen
• Florent Carpentier
• Jeff Hutchison
• Jimmy Larsson
• Luis Arias
• Marius Barduta
• Martin Cooper
• Mike Schachter
• Niall Pemberton
• Oleg V Alexeev
• Ralph Schaer
• Rob Leland
• Sean Kelly
• Ted Husted

• Chris Assenza
• Craig R. McClanahan
• David Geary
• dIon Gillard
• Ed Burns
• Eric Wu
• John Rousseau
• John Ueltzhoeffer
• Larry McCay
• Martin Cooper
• Matthias Kerkhoff
• Mike Schachter
• Paul Runyan
• Robert Hayden
• Stanley Santiago
• Ted Husted
• Wong Kok Kai

• Craig R. McClanahan
(craigmcc at apache.org)
• Michael Schachter
(mschachter at apache.org)
• Ted Husted
(husted at apache.org)
• Rob Leland
(rleland at apache.org)
• Vincent Massol
(vmassol at apache.org)
• Cedric Dumoulin
(cedric.dumoulin at lifl.fr)
• Martin Cooper
(martinc at apache.org)
• David Winterfeldt
(dwinterfeldt at apache.org)
• Oleg Alexeev
(oalexeev at apache.org)

• David Geary
• Luis Arias
• Pierre Delilse

Craig R. McClanahan -- Committer

I've been involved with servlet and JSP technology since around 1998. It started out that I needed a way to build some web applications for several projects, and liked Java a lot better than the alternatives. I also liked the price tag of open source software, and started using Apache JServ -- later on, getting involved in the project (like many people, I was whining about the twelve months it took to get from version 0.9 to version 1.0, and my son said "Dad, you know Java -- go help them finish it!" -- so I did :-).

For quite a while, I was participating a lot on the JSP-INTEREST and SERVLET-INTEREST mailing lists, especially on the topic of good architectures for web applications. I was disgusted with the hash that many beginners created when they used (or abused) scriptlets in JSP pages, and built (for my former employer) a pretty comprehensive framework that could be considered ("Struts 0.01 without the custom tags"). It was proprietary code, but I was able to describe the concepts, and there started to be a feeling on the lists that this "Model 2" thing was pretty cool -- but there were no good examples to look at, so it was mostly hand waving types of discussions.

Over the same time period, I got involved as an individual contributor in the Java Community Process, and joined the expert group that defined the servlet 2.2 and JSP 1.1 specs. Sun was impressed enough to offer me a job as the technical lead on the team within Sun (currently five other individuals) that works on Tomcat -- the architecture for Catalina, which is the servlet container part of Tomcat 4.0, is also mine -- so I am in the really nice position of getting paid to work on open source software :-). And, participate on the expert groups for Servlet 2.3 and JSP 1.2. And, speak at various conferences, including ApacheCon and JavaOne. And, talk to groups within Sun about using Struts and JSP/servlet technology. And ... (there's some really interesting things being considered for the future).

The original design of what came to be Struts has been in my head for a long time, since those interesting mailing list discussions, but the first version of the actual code was written on my laptop on a Memorial Day weekend vacation trip (end of May, 2000) to the Oregon coast -- in between watching the surf and having the house shaken by a windstorm at night. Since then, it has gathered attention and popularity as we approach our first official release, and it delights me to see my "baby" grow up so well :-). Of course, it is no longer just me -- there have been incredible numbers of good ideas from all over, and a peek at the TODO list for 1.1 says that even more good stuff is coming in the future.

One motivation factor was Jason Hunter's article about the Problems with JSP. Jason and I get along fine, even though we have different preferences about presentation technologies. Besides being the author of a very popular book about servlets, with a second edition coming soon, Jason is also the representative for the Apache Software Foundation on the Executive Committe of the Java Community Process.

Personally, I live in Portland, Oregon (even though my team at Sun is mostly in Cupertino, CA -- staying here was part of the job deal :-). I like to support Oregon sports teams (Oregon State Beavers, Oregon Ducks, Portland Trailblazers) and work on cool software.

I figured out I was getting pretty old when I realized that 2000 was the 25th year I had been paid to work in some aspect of software development :-). I've got a son who is a full-time software developer (primarily in PHP so far, but I'm going to corrupt him with Java eventually :-), and a daughter in college. I'll happily let the other committers speak for themselves.

Mike Schachter -- Committer

I'm currently a student of computer science at Drexel University in Philadelphia, PA. I've been working at HP Middleware, formerly Bluestone Software for 3 years programming in Java and recently J2EE technologies. I'm a full time worker from September until April and a student and part time worker from April until August. In my spare time I've been known to run monkey-knife fights in a shady south philly warehouse. Err... I mean... nothing.

Ted Husted -- Committer

My primary interest in Struts is to put it to work writing lots of real-life Web applications:-) To do that effectively means having good documentation and code samples at my fingertips, so that's been my focus with the Struts product so far.

I've been writing software for hire since 1984, but only recently jumped on the Java bandwagon. My initial interest was with electronic publishing, and started by converting my various print projects to electronic media. The "Information Superhighway" was still the private stomping ground of Universities and government agencies then. The rest of us had to make do with diskettes and bulletin boards.

Between 1985 and 1994, I created and marketed several software products for publishing on disk, the most popular being "Dart" and "Iris". In 1992, Dart was awarded the Digital Quill for software excellence, featured in PC Magazine (February 1992), and bundled with McGraw Hill's bookset,"Paperless Publishing" by Colin Hayes (McGraw Hill 1994). Dart won a second Digital Quill in 1993. Several titles that used Iris for a publishing system have also won awards and been widely distributed, including "Hermitville USA." I was also fortunate to find kindred souls on CompuServe and America Online, who helped me pioneer resources areas there in 1993 and 1994 for the nascent electronic publishing industry.

I finally cut loose on the Internet in 1995, launching Epub News, an electronic newspage about electronic publishing. After taking on several private contracts, I opened the Husted dot Com Website (www.husted.com) in 1996. I've drifted away from electronic books, but have noticed that several products are now making their way into the consumer mainstream -- as usual, I was twenty minutes into the future:-)

My favorite all-time project is the Hitchhikers Guide to Science Fiction. This was one of my earliest hypertext projects (it started as a print-book idea), and I had a lot of fun bringing it forward onto the Web. (Now, if I only had time to bring it current and dress it up!)

My favorite all-time client is is WXXI Public Broadcasting Council, where I've served as the station's Webmaster. WXXI provides public broadcasting services for television and radio, and we are working to do the same online. Along with providing companion Web sites for every WXXI production, we stream both our AM and FM signals, in both Real and QuickTime, with online archives in the works. It's a long journey, but we've taken the first steps. I'm responsible for most of the regular updates to the site, and much of the overall layout and design. We're grateful to have won the PBS award for best Web site in our market for two years running.

Our most ambitious projects at WXXI have been Spring Marketplace 2000 and the NY Election Finder. For Spring Marketplace, we put our annual auction fully online for simultaneous telephone and Website bidding. On NY Election, we offered not only the usual election-finder application, but collected voter registration records from around the state, so people could also check their registration status and polling place. I developed the Web-enabled database applications for both projects.

Currently, I'm expanding the WXXI online auction software into a complete package for hosting online auctions as fund-raisers; this is to be an open-source project called Gavel, and, of course, is based on Struts.

Cedric Dumoulin -- Committer

As a dreamer / researcher I have thought a lot about a framework like Struts. But, as a lazy developer I have first checked what already exists, and I have found Struts. Struts goals fulfilled nearly all I needed for my (now old) portal project, except the capability to reuse and assemble easily pieces of pages or components. So, I have proposed the Components framework. This framework can be seen as a superset of the Templates tag library contributed by David Geary, and contains lot of interesting features.

From a professional point of view, I have a Ph.D. in computer science. I have worked for 3 years in the R&D department of a worldwide company developing Internet banking solutions. I am now a researcher at a university, and work on European research projects. My main research interest is WWW, Distributed Systems and Object Oriented Design. When developing code, I always try to first propose reusable pieces of code.

Martin Cooper -- Committer

Currently, I'm a Principal Software Engineer at Tumbleweed Communications, working on the Messaging Management System. Early last year (2000), I was working on the architecture for a new web-based administration system for the product, and headed in the direction of servlets and JSP. I joined the JSP-INTEREST and SERVLET-INTEREST mailing lists to see what was going on in those respective areas.

Before too long, some interesting discussions started up around the topic of Model 2 architectures. Model 2 sounded like the right way to go about things, and I followed those discussions closely. I was, however, still looking for a "leg up" - something to give me that core on which to build.

Then, in May, I saw a post to JSP-INTEREST from Craig McClanahan entitled something like "New Jakarta-Struts Subproject", and describing Struts, and his vision for it. I hopped right over to the Jakarta web site and signed up for the mailing list. Before long, I realised this was exactly what I had been looking for.

Now, a year or so later, we have a team of people, on which I am the technical lead, just finishing up our web-based administration system as Struts reaches its 1.0 release. And I am still firmly convinced that I made the right decision in going with Struts in the first place.

Like anyone else, my first postings to the struts-user list were questions to help me understand how to do things, and why Struts is the way it is. Over time, reading the lists and also the source code, and working on my own fairly large web application, I came to the point where I could answer questions too. Now, I'm glad to be able to give something back to the Struts community by helping others understand, and also by contributing ideas and code to help make Struts even better than it already is.

Здесь приведены ответы на обычные часто задаваемые новичками вопросы. Для того, чтобы ознакомиться с всесторонним FAQ, с возможностями поиска, посетите наших друзей на JGuru.

• Зачем нам нужен Struts?

• Как Struts работает?

• Совместим ли Struts с другими технологиями Java?

• Кто написал Struts?

• Почему он называется Struts?

• Как лицензируется Struts?

• Может ли Struts использоваться в коммерческих приложениях?

• Где я могу получить копию Struts?

• Как установить Struts?

• Когда мне нужно добавлять struts.jar в classpath?

• Где я могу получить помощь по Struts?

• Можно ли получить платную техническую поддержку?

• Существуют ли интернет-провайдеры, которые могут разместить мои Struts приложения?

• Какие Web cайты уже используют Struts(Powered by Struts)?

• В чем разница между проектами Struts и Turbine?

• Почему библиотека тэгов Struts не является частью проекта Jakarta Taglibs?

• Куда я могу посылать сообщения об ошибках и пожеланиях о новых функциях?

• Каким образом можно принять участие в разработке Struts?

• Когда будет следующий релиз?

• Как отписаться от списка рассылки?

Introduction

Model Components

View Components

Controller Components

Resources

Who We Are

Зачем нам нужен Struts?

Технологии Java оказывают разработчикам серьезную поддержку в создании и эксплуатации web-приложений для современных web-сайтов и корпоративных интранет-приложений. Struts сочетает в единой среде использование Java Servlets, Java ServerPages, библиотек тэгов и поддержку ресурсов для сообщений. В результате мы имеем кооперативную, синергетическую платформу, удобную как для командной разработки, так и для индивидуальных разработчиков.

Как Struts работает?

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

Совместим ли Struts с другими технологиями Java?

Да. Struts активно поддерживает промышленные стандарты. Наш ведущий разработчик является членом JSR052, группы экспертов компании Sun для разработки стандартной библиотеки JSP тэгов. Основной критерий проектирования – то, что Struts должен быть совместим с платформой Sun J2EE. Фактически, Struts действует как интегратор java-технологий, таким образом, что они могут быть использованы в “реальном мире”.

Кто написал Struts?

Struts был создан Craig R. McClanahan и подарен Apache Software Foundation в мае 2000. Craig является основным разработчиком и Struts и Tomcat 4, официальной справочной реализации контейнера для java-сервлетов. Используя стабильные релизы Struts и Tomcat, Craig в настоящее время работает как Implementation Engineer для компании Sun, создавая их новый Web Services Pack. Множество активных разработчиков проекта Struts вместе работают по всему земному шару. Разработчикам Java всегда рады в этом проекте. Struts является частью проекта Apache Jakarta, с обычной для этого проекта миссией “обеспечивать open source решения на платформе Java c качеством, присущим коммерческим”. 17 разработчиков работали над релизом Struts 1.0.

Почему он называется Struts?

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

Как лицензируется Struts?

Struts – это охраняемое авторским правом программное обеспечение, выпускаемое под лицензией "free-to-use-license" от Apache Software Foundation. Эта лицензия появляется в начале каждого файла с исходными кодами. Копия лицензии для справок находится здесь.

Может ли Struts использоваться в коммерческих продуктах?

Да. Единственным требованием, которое описано в лицензии Apache Software Foundation является включение в начало каждого файла с исходными кодами соответствующего текста, а также файла LICENSE в корневом каталоге дистрибутива проекта.

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

Где я могу получить копию Struts?

Наилучшим местом для загрузки Struts является jakarta.apache.org/struts. Самые последние сборки (nightly builds) в данный момент очень стабильны и рекомендуется начать использование Struts с них.

Как установить Struts?

Чтобы разрабатывать приложения с использованием Strtuts, обычно вы должны просто добавить STRUTS JAR файл в вашу среду разработки Java. После этого вы сможете использовать классы Struts как часть вашего собственного приложения. В дистрибутиве поставляется пустое приложение Struts (blank Struts application), которое вы можете использовать для осуществления своих замыслов.

Так как доступны полные исходные коды для Struts, то мы тажке поставляем полные инструкции для компилирования вашего собственного STRUTS JAR с чистого листа (В действительности это проще, чем выглядит!).

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

Когда мне нужно добавлять "struts.jar" в classpath?

Когда вы компилируете приложение, которое использует Struts, достаточно добавить "struts.jar" в classpath, который видит ваш компилятор – но не нужно включать его в переменную среды окружения CLASSPATH.

Почему мы подчеркиваем это различие? Потому, что если вы используете сервлет-контейнер на компьютере разработчика для тестирования вашего приложения, то “struts.jar” не должен быть в переменной среды окружения CLASSPATH, когда вы запускаете сервлет-контейнер. Причина этого в том, что каждое web-приложение должно иметь свою собственную копию классов Struts, и контейнер будет “смущен”, если Struts будет также в переменной среды окружения.

Есть несколько общих подходов для разрешения этой ситуации:

• Используйте ANT для сборки вашего проекта – он может легко собирать пути (classpaths) для компилятора. Именно таким образом производится сборка Struts, Tomcat и большинства других Java-проектов.

• Используйте IDE (Integrated Debugging Environment), где вы настраиваете свой "class path", отличный от содержащегося в переменной среды окружения.

• Используйте командный скрипт (shell script), который временно добавит struts.jar в classpath во время компиляции, например javac -classpath /path/to/struts.jar:$CLASSPATH $@

Где я могу получить помощь по Struts?

Пакет Struts включает в себя users guide , которое дает людям представление о этой среде и лехащих в ее основе технологиях. Различные компоненты также имеют свои собственные подробные руководства разработчика, которые рассматривают более глубокие вопросы. Подробная документация Javadocs включена в пакет наряду с полными исходными кодами проекта. Список рассылки Struts (Strut's mailing list) является очень активным, и в не всегда рады сообщениям от новых пользователей Struts.

Также существует множество примеров, статей и книг, посвященных Struts. Cмотрите страницу ресурсов Resources page чтоб получить текущий список ссылок. Два самых полезных ресурса – архив списка рассылки (mailing list archives) и форум о Struts на Jguru (Struts Forum at JGuru).

Можно ли получить платную техническую поддержку?

Не существует официальной платной техподдержки по Struts, хотя многие сторонние организации предлагают различные формы техпоодержки. Список консультантов по Struts можно найти на старнице ресурсов(resources page).

Существуют ли интернет-провайдеры, которые могут разместить мои Struts приложения?

Смотрите список провайдеров для Java&Strtuts на Resources page.

Какие web-сайты уже используют Struts (Powered by Struts)?

For a listing of some Struts-powered Web sites available to the public, visit our Resources page.

В чем разница What's the difference between Jakarta Struts and Jakarta Turbine?

Смотрите следующие ссылки:

• < http://www.mail-archive.com/struts-user@jakarta.apache.org/msg03206.html >

• < http://www.mail-archive.com/general@jakarta.apache.org/msg00495.html >

• < http://jakarta.apache.org/velocity/ymtd/ymtd.html >

Почему библиотека тэгов Struts не является частью проекта Jakarta Taglibs?

Разработку обоих продуктов началась примерно в одно и то же время. Вплоть до релиза 1.0, казалось логичнее разрабатывать библиотеку тэгов вместе с контроллером. Сейчас, когда релиз 1.0 уже выпущен, активно разрабатывается стандартная библиотека тэгов JSP (Java ServerPages Standard Taglib – JSPTL). Как только JSPTL стабилизируется, библиотека тэгов Struts будет пересмотрена. Тэги, которые напрямую не связаны со средой разработки могут поддерживаться в Jakarta Taglibs

Development of both products began about the same time. Leading up to the release of 1.0, it was thought better to continue to develop the taglibs alongside the controller. Now that 1.0 is out, the Java ServerPages Standard Taglib is in active development. Once work on the JSPTL stabilizes, the Struts taglibs will be revisited. Tags which are are not linked directly to the framework may be hosted at Jakarta Taglibs instead.

Куда я могу сообщать об ошибках и пожеланиях о новых функциях?

You can research and report outstanding fixes and feature requests using Jakarta Bugzilla.

If you are unsure if this is in actual problem, feel free to bring it up on the list first. But to be sure an issue is resolved, always report it to Bugzilla.

Struts also maintains a TODO list outlining features being planned or developed.

Каким образом принять участие в разработке Struts?

Struts распостраняется Apache Software Foundation. Это те же люди, что распостраняют web-сервер Apache. Как и все проекты ASF, Struts управляется в стиле "meritocracy", где привествуется вклад каждого. Пользователи могут помогать другим пользователям в списках рассылки, посылая сообщения об ошибках,и запрашивая новую функциональность. Разработчики могут помочь, присылая исправления, новый код и документацию. Наиболее активные разработчики могуть стать Committers, которые принимают действительные решения связанные с кодом Strutts.

Вы можете начать с присоединения к списку рассылки пользователей Struts. Если вам там понравится, то подпишитесь на список разработчиков Struts. Если вы найдете какие-либо проблемы в Struts, или обнаружите отсутсувующую, но необходимую функциональность, вы можете внести запись в базу данных Bugzilla.

Когда будет выпущен следующий релиз?

Коротко – он обязательно будет.

Here is the truth regarding releases:

Jakarta products are released on the basis of merit, and ~not~ according to a strict timetable. The volunteers devote whatever time they can to working on the product. But all volunteers have real jobs and real lives, that do take precedence. Since Struts does have have paid personnel working on the project, we simply cannot make date-orientated commitments.

All Jakarta products must circulate a public beta before release. If a beta is not in circulation, then it's a good bet that a release is not forthcoming any time soon. Products sometimes go through several betas before final release. So if this is beta 1, then it still may not be released any time soon.

The bottom line is that Jakarta takes releases very seriously. We do not compromise the quality of our software by watching the calendar (and then ship something ready or not). A release is ready when it is ready.

That may sound flip, but it ~is~ the truth. The delivery of production-quality, leading-edge software is not something anyone can prognasticate. If anyone tries, they are lying to you. That, we won't do ;-)

What we ~will~ do is release all of our development software as soon as it is developed. This way you can judge for yourself how quickly the development is proceeding, and whether what is being developed will meet your needs. If you need a feature right now, you can use the nightly build, or roll your own patch. There are no private CVS's or a private development lists. What you see is what we got. If you are following the DEV list, then you know everything the developers know. Really, you do.

Как отписаться от списка рассылки?

С того адреса, на который вы подписывалсиь на список рассылки, пошлите пустое сообщение на адрес < struts-user-unsubscribe@jakarta.apache.org>.

Далее – Введение в руководство пользователя (Users Guide)

Интернационализация (i18n) в Struts

Last updated: March 7, 2002

Автор – Aaron Rustad

Перевод – Алексей Ковязин

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

В данном начальном документе я не собираюсь углубляться в многочисленные “как” и “почему” процесса интернационализации. Я могу расширить этот документ в будущем, если люди действительно захотят узнать больше или я снова устану от работы. В любом случае, не стесняйтесь задавать мне (emal внизу страницы) вопросы.

1.

Первым делом, прочтите и поймите базовое объяснение интернационализации сообщений в Struts, затем читайте дальше.

2.

Создайте альтернативный файл ApplicationResource.properties и сохраните его в том же каталоге, что и исходный. Например, мой исходный файл выглядит вот так (MyResources.properties), а вот так – русская версия(MyResources_ru.properties). Очень важно для Struts (точнее, для Java) указать правильный ISO код языка – в данном случае это “ru”.

3.

Преобразуйте ваш альтернативный файл ApplicationResources.properties в UTF. Чтобы сделать это, используйте инструмент native2ascii, который поставляется с вашим JDK. Он преобразует файл с символами национальной кодировки (не-Латинские и не-Unicode символы) в точно такой же файл с Unicode-символами.

Я пользовался следующей командой:

native2ascii -encoding UTF-8 MyResources_ru.properties MyResources_ru.propertiesX.

Взгляните на результат (output file), и увидите, что ваши слова преобразованы в Unicode (UTF-8) и теперь ваш браузер может их прочитать!

4.

В начале каждой JSP-страницы, на которой предполагается использование i18n-сообщений, включите следующую директиву:

<%@ page contentType="text/html; charset=UTF-8" %>

Это укажет браузеру, что для отображения данной страницы следует использовать UTF-8, и ваши Unicode-символы будут соответствующе показаны

5.

Проверьте работу i18n, используя браузер, который позволяет выбирать различные языки по умолчанию:

IE

"Tools" -> "Internet Options", и выберите кнопку "Language..." внизу диалога. Смените язык на тот, который вы желаете видеть. Обновите страницу и взгляните на результат.

NS 6.3

"Edit" -> "Preferences", раскройте в дереве "Navigator" и выберите "Languages". Добавьте языки, используя кнопку "Add..." и переместите желаемый язык в верх списка. Затем обновите страницу или перезапустите браузер.

Это все, что касается отображения сообщений на JSP. Однако, проблема возникает, когда вы посылаете (submit) интернационализованные символы через формы. Шаги, приведенные ниже, показывают простое решение данной проблемы.

7.

Добавьте этот фильтр к вашему web-приложению, это часть документации Tomcat, поставляемого нашими друзьями из Jakarta Project и Apache. Обычно этот фильтр говорит вашему ActionServlet'у, что все запросы приходят к нему из форм с кодировкой UTF-8, и что посланные атрибуты должны обрабатываться именно таким образом.

NOTE:

WebSphere AS 4 не позволяет такого решения, смотрите подробности здесь.

8.

Добавьте этот код в ваш web.xml deployment descriptor, он предполагает, что ваш ActionServlet ссылается на имя action (это принято по умолчанию в дистрибутиве Struts).

<!-- Example filter to set character encoding on each request -->
<filter>
 <filter-name>Set Character Encoding</filter-name>
 <filter-class>filters.SetCharacterEncodingFilter</filter-class>
 <init-param>
  <param-name>encoding</param-name>
  <param-value>UTF-8</param-value>
 </init-param>
</filter>

<!-- Define filter mappings for the defined filters -->
<filter-mapping>
 <filter-name>Set Character Encoding</filter-name>
 <servlet-name>action</servlet-name>
</filter-mapping>

9.

Перегрузите ваш app-сервер и протестируйте его... должно работать.

Динамический выбор языка

Было бы здорово позволять пользователю динамически менять язык приложения в веб-приложении. Все что вам нужно сделать – это создать новый объект java.util.Locale и положить его в сессию. Предположительно лучше это сделать в Action-классе. Вот пример кода:

java.util.Locale newLocale = new java.util.Locale( "ru" );

request.getSession().setAttribute( Action.LOCALE_KEY, newLocale );

Note: В классе Action есть метод setLocale( HttpServletRequest, Locale ) который ликвидирует необходимость руками устанавливать класть Locale в сессию.

Ресурсы

1.

Пример Applicaction War, и Source Jar использующих Кириллицу

(проверено на Tomcat 4.0.2 и Orion 1.5.4)

Если есть вопросы, пожелания, комментарии, пожалуйста отправляйте их на arustad@anassina.com и я попытаюсь помочь вам или изменить этот документ для вящей пользы всем остальным.

Aaron Rustad.

© 2002 Anassina Inc, All Rights Reserved