BlogJava-VIRGIN FOREST OF JAVA-文章分类-STRUTS

tiles

R.Zeus — Thu, 10 Aug 2006 06:51:00 GMT

<%@ include file=".......Taglibs.jsp" %>
虽然定义的body里有了tag，但是各自的页面还要加，因为这是动态编译以后加载,所以每个页面都应该有！

R.Zeus 2006-08-10 14:51 发表评论

ActionMessages

R.Zeus — Wed, 09 Aug 2006 04:36:00 GMT

ActionMessages msgs = new ActionMessages();
msgs.add(ActionMessages.GLOBAL_MESSAGE, new ActionMessage(strMsg, args));
//关于args，如果ApplicationMessages.properties 中有，就取对应的值；如果没有，就用这个args值

R.Zeus 2006-08-09 12:36 发表评论

struts 2个配置文件

R.Zeus — Tue, 08 Aug 2006 11:35:00 GMT

            config
            /WEB-INF/config/struts/struts-config.xml

                                  //这里表示所有以account开头的*.do都使用下面的配置文件，而在配置文件的
                                       Actionmapping不用加上account。

            config/account
            /WEB-INF/config/struts/struts-config-account.xml


                        name="AccountForm" scope="request">


                                           //注意..,表示上一层目录，因为已经在account下，所以要回去
                                                              用tiles就不需要了！

R.Zeus 2006-08-08 19:35 发表评论

三级级联下拉菜单实现

R.Zeus — Fri, 07 Oct 2005 08:35:00 GMT

三级级联下拉菜单实现
zhangv 原创 (参与分：15623，专家分：1020) 发表：2005-05-28 13:31 版本：1.0 阅读：1490次

三级级联下拉菜单实现(xml+js+struts)
derekzhangv.at.hotmail.com

好不容易实现的一个三级级联菜单,喜欢把复杂的问题简单化,所以从网上的一些方法中提取出一种相对清爽的方法 -

jsp页面里只多了2行代码.(不过多了两个文件)

项目是用struts,所以jsp为例(其实这个实现应该在任何情况下都是可以用的,无论asp,php...)生成:"1个form里含2组3级级

联菜单"
从某省某市某县
到某省某市某县

步骤:
1.xml数据源,也就是保存省市地名层次信息.
如果没有这个文件可能需要自己做一个,从数据库或者文本里提取一个xml文件出来应该不算难事吧.
再说这样的文件保存在xml文件里迟早会有用处的.
本例为:
(city.xml)
==========================































==========================

2.javascript(小弟的js学的不好,还请各位写个更好更简洁的方法)
(selectCity.js)
==========================
var from=["province","city","county"];
var to=["toprovince","tocity","tocounty"];
function selectFrom(num){
if(num==3) return;
var i,j,arrTemp=[];
for(i=0;i      arrTemp[i]=document.all(from[i]).options[document.all(from[i]).selectedIndex].text
with(document.all(from[num])){
  length=0
  var obj=document.all.xmlData.XMLDocument.childNodes[1];
  for(i=0;i      obj=obj.selectSingleNode(from[i]+'[@name="'+arrTemp[i]+'"]');
  for(i=0;i      options[length++].text=obj.childNodes[i].getAttribute("name");
  onchange=new Function("selectFrom("+(num+1)+")");
  onchange();
}
}
function selectTo(num){
if(num==3) return;
var i,j,arrTemp=[];
for(i=0;i      arrTemp[i]=document.all(to[i]).options[document.all(to[i]).selectedIndex].text
with(document.all(to[num])){
  length=0
  var obj=document.all.xmlData.XMLDocument.childNodes[1];
  for(i=0;i      obj=obj.selectSingleNode(from[i]+'[@name="'+arrTemp[i]+'"]');
  for(i=0;i      options[length++].text=obj.childNodes[i].getAttribute("name");
  onchange=new Function("selectTo("+(num+1)+")");
  onchange();
}
}
==========================

3.页面文件:(这里是struts,--这个应该没有关系)
(test.jsp)

==========================



从



到



==========================

这样的三步就构造了一个"1个form里含2组3级级联菜单",其实还是满麻烦的.之前还见过一种是在js里建一个三维数组,

R.Zeus 2005-10-07 16:35 发表评论

使用struts,ibaits和JSTL开发简便通用的文件上传系统

R.Zeus — Sat, 24 Sep 2005 16:20:00 GMT

文件上传也是一个老生常谈的问题了。struts提供了很方便的文件上传组件，利用struts，很容易开发文件上传的系统。本文结合ibatis和JSTL开发一个简便而通用的文件上传系统。通过本文，你可以学到如何在struts里配置文件上传功能、struts1.1的动态form配置和使用、如果简单的使用ibatis，如果简单使用的JSTL。

首先我们要在struts-config里加上一句，来指定临时目录以及限制大小。

然后只要在form中加上enctype="multipart/form-data" 就可以实现struts的上传了，十分简单吧？

下面我们在数据库中建立一张表。

create sequence Attachment_seq;
DROP TABLE ATTACHMENT;
create table Attachment
(
AttachID INT not null, --自动增长号 AttachFilename VARCHAR2(250) null, --文件名 AttachFileSize INT not null, --文件大小 AttachMimeType VARCHAR2(70) null, --文件类型 AttachDesc VARCHAR2(250) null, --说明 AttachCreationIP VARCHAR2(20) not null, --上传的IP AttachCreationDate TIMESTAMP not null, --创建时间 AttachModifiedDate TIMESTAMP not null, --文件保存路径 ATTACHFILEPATH VARCHAR2 (250) NOT NULL,
primary key (AttachID)
);
create or replace trigger Attach_trig_autoinc
before insert on Attachment
for each row
begin
if (:new.AttachID is null) then
select Attachment_seq.nextval into :new.AttachID from dual;
end if;
end;

字段的内容都很简单。

下面建立ibatis的SQL map文件。建立标准的insert、update、delete和find的SQL。相信看过前面系列文章的朋友对此已经很熟悉了。

insert into ATTACHMENT ( ATTACHID ATTACHFILENAME ATTACHFILEPATH ATTACHFILESIZE ATTACHMIMETYPE ATTACHDESC ATTACHCREATIONIP ATTACHCREATIONDATE ATTACHMODIFIEDDATE ) valueS (

#ATTACHID#

#ATTACHFILENAME#

#ATTACHFILEPATH#

#ATTACHFILESIZE#

#ATTACHMIMETYPE#

#ATTACHDESC#

#ATTACHCREATIONIP#

#ATTACHCREATIONDATE#

#ATTACHMODIFIEDDATE#

)

update ATTACHMENT

ATTACHID=#ATTACHID#

ATTACHFILENAME=#ATTACHFILENAME:VARCHAR#

ATTACHFILEPATH=#ATTACHFILEPATH:VARCHAR#

ATTACHFILESIZE=#ATTACHFILESIZE#

ATTACHMIMETYPE=#ATTACHMIMETYPE:VARCHAR#

ATTACHDESC=#ATTACHDESC:VARCHAR#

ATTACHCREATIONIP=#ATTACHCREATIONIP:VARCHAR#

ATTACHCREATIONDATE=#ATTACHCREATIONDATE#

ATTACHMODIFIEDDATE=#ATTACHMODIFIEDDATE#

ATTACHID=#ATTACHID#

ATTACHFILENAME=#ATTACHFILENAME:VARCHAR#

ATTACHFILEPATH=#ATTACHFILEPATH:VARCHAR#

ATTACHFILESIZE=#ATTACHFILESIZE#

ATTACHMIMETYPE=#ATTACHMIMETYPE:VARCHAR#

ATTACHDESC=#ATTACHDESC:VARCHAR#

ATTACHCREATIONIP=#ATTACHCREATIONIP:VARCHAR#

ATTACHCREATIONDATE=#ATTACHCREATIONDATE#

ATTACHMODIFIEDDATE=#ATTACHMODIFIEDDATE#

update ATTACHMENT

ATTACHID=#ATTACHID#

ATTACHFILENAME=#ATTACHFILENAME:VARCHAR#

ATTACHFILEPATH=#ATTACHFILEPATH:VARCHAR#

ATTACHFILESIZE=#ATTACHFILESIZE#

ATTACHMIMETYPE=#ATTACHMIMETYPE:VARCHAR#

ATTACHDESC=#ATTACHDESC:VARCHAR#

ATTACHCREATIONIP=#ATTACHCREATIONIP:VARCHAR#

ATTACHCREATIONDATE=#ATTACHCREATIONDATE#

ATTACHMODIFIEDDATE=#ATTACHMODIFIEDDATE#

ATTACHID=#ATTACHID#

delete from ATTACHMENT

ATTACHID=#ATTACHID#

ATTACHFILENAME=#ATTACHFILENAME#

ATTACHFILEPATH=# ATTACHFILEPATH#

ATTACHFILESIZE=#ATTACHFILESIZE#

ATTACHMIMETYPE=#ATTACHMIMETYPE#

ATTACHDESC=#ATTACHDESC#

ATTACHCREATIONIP=#ATTACHCREATIONIP#

ATTACHCREATIONDATE=#ATTACHCREATIONDATE#

ATTACHMODIFIEDDATE=#ATTACHMODIFIEDDATE#

delete from ATTACHMENT
where
ATTACHID=#ATTACHID#

select * from ATTACHMENT

ATTACHID=#ATTACHID#

ATTACHFILENAME=#ATTACHFILENAME#

ATTACHFILEPATH=#ATTACHFILEPATH#

ATTACHFILESIZE=#ATTACHFILESIZE#

ATTACHMIMETYPE=#ATTACHMIMETYPE#

ATTACHDESC=#ATTACHDESC#

ATTACHCREATIONIP=#ATTACHCREATIONIP#

ATTACHCREATIONDATE=#ATTACHCREATIONDATE#

ATTACHMODIFIEDDATE=#ATTACHMODIFIEDDATE#

$sortOrder$

select * from ATTACHMENT
where
ATTACHID=#ATTACHID#

select count(1) from ATTACHMENT

ATTACHID=#ATTACHID#

ATTACHFILENAME=#ATTACHFILENAME#

ATTACHFILEPATH=#ATTACHFILENAME#

ATTACHFILESIZE=#ATTACHFILESIZE#

ATTACHMIMETYPE=#ATTACHMIMETYPE#

ATTACHDESC=#ATTACHDESC#

ATTACHCREATIONIP=#ATTACHCREATIONIP#

ATTACHCREATIONDATE=#ATTACHCREATIONDATE#

ATTACHMODIFIEDDATE=#ATTACHMODIFIEDDATE#

下一小就是建立数据操作层的类代码

/* * Created on 2003-10-11 * * To change the template for this generated file go to * Window - Preferences - Java - Code Generation - Code and Comments */package com.ewuxi.champion.persistence.dao;
import java.util.HashMap;
import java.util.List;
import com.ewuxi.champion.exception.DaoException;
import com.ibatis.db.sqlmap.SqlMap;
/**
* @author champion
*
*attachment数据库操作对象
*/
public class AttachDb {
/**
* @param vo
* @throws DaoException
* 插入一条记录
*/
public void insert(HashMap vo) throws DaoException {
try {
SqlMap sqlMap = DaoCommon.getSqlMap(DaoCommon.getDefautDao());
sqlMap.executeUpdate("insertattachmentDao", vo);
} catch (Exception e) {
throw new DaoException(e);
}
}
/**
* @param vo
* @throws DaoException
* 删除一条记录
*/
public void delete(HashMap vo) throws DaoException {
try {
SqlMap sqlMap = DaoCommon.getSqlMap(DaoCommon.getDefautDao());
sqlMap.executeUpdate("deleteByPrimaryKeyattachmentDao", vo);
} catch (Exception e) {
throw new DaoException(e);
}
}
/**
* @param vo
* @throws DaoException
* 修改一条记录
*/
public void update(HashMap vo) throws DaoException {
try {
SqlMap sqlMap = DaoCommon.getSqlMap(DaoCommon.getDefautDao());
sqlMap.executeUpdate("updateByPrimaryKeyattachmentDao", vo);
} catch (Exception e) {
throw new DaoException(e);
}
}
/**
* @param vo
* @return
* @throws DaoException
* 查找一条记录
*/
public HashMap findByPk(HashMap vo) throws DaoException {
try {
SqlMap sqlMap = DaoCommon.getSqlMap(DaoCommon.getDefautDao());
return (HashMap) sqlMap.executeQueryForObject(
"findByPrimaryKeyattachmentDao",
vo);
} catch (Exception e) {
throw new DaoException(e);
}
}
public List find(Object vo) throws DaoException {
try {
SqlMap sqlMap = DaoCommon.getSqlMap(DaoCommon.getDefautDao());
return (List) sqlMap.executeQueryForList("findattachmentDao", vo);
} catch (Exception e) {
throw new DaoException(e);
}
}
}

这一层的代码也是多次见到的老朋友了。事实上对于大多数数据库操作，我们都只需要上面这么一点代码。然后我们建立add的action方法

public ActionForward add(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
try {

Service.initSet();
if (form instanceof DynaActionForm) {

DynaActionForm fm = (DynaActionForm) form;
FormFile ff = (FormFile) fm.get("upload");
if (ff != null && ff.getFileSize()>0) {
String fileName =
Service.getPath().substring(
0,
Service.getPath().length()
- "/WEB-INF/classes".length())
+ "file/"
+ ff.getFileName();
HashMap map = new HashMap();
map.put(Constattachment.ATTACHDESC, fm.get("desc"));
map.put(Constattachment.ATTACHFILENAME, ff.getFileName());
map.put(
Constattachment.ATTACHMIMETYPE,
ff.getContentType());
map.put(Constattachment.ATTACHCREATIONDATE, new Date());
map.put(Constattachment.ATTACHMODIFIEDDATE, new Date());
map.put(
Constattachment.ATTACHFILESIZE,
String.valueOf(ff.getFileSize()));
map.put(
Constattachment.ATTACHFILEPATH,
"/file/" + ff.getFileName());
map.put(
Constattachment.ATTACHCREATIONIP,
request.getRemoteAddr());
FileManager.saveFile(fileName, ff);
AttachDb attachDb = new AttachDb();

DaoCommon.startTransaction();
attachDb.insert(map);
DaoCommon.commit();
request.setAttribute("url", fm.get("url"));
request.setAttribute(
"fileName",
"/file/" + ff.getFileName());
log.info(ff.getFileName());
return mapping.findForward("success");
}
}
ActionErrors errors = new ActionErrors();
errors.add(
ActionErrors.GLOBAL_ERROR,
new ActionError("errors.general", "请选择一个文件!"));
saveErrors(request, errors);
return mapping.findForward("false");
} catch (DaoException e) {
log.error(e, e);
DaoCommon.rollBack();
ActionErrors errors = new ActionErrors();
errors.add(
ActionErrors.GLOBAL_ERROR,
new ActionError("errors.general", "数据库操作错误!"));
saveErrors(request, errors);
return mapping.findForward("false");
} catch (FileNotFoundException e) {
log.error(e, e);
ActionErrors errors = new ActionErrors();
errors.add(
ActionErrors.GLOBAL_ERROR,
new ActionError("errors.general", "文件保存错误!"));
saveErrors(request, errors);
return mapping.findForward("false");
} catch (IOException e) {
log.error(e, e);
ActionErrors errors = new ActionErrors();
errors.add(
ActionErrors.GLOBAL_ERROR,
new ActionError("errors.general", "文件操作错误!"));
saveErrors(request, errors);
return mapping.findForward("false");
} catch (Exception e) {
log.error(e, e);
ActionErrors errors = new ActionErrors();
errors.add(
ActionErrors.GLOBAL_ERROR,
new ActionError("errors.general", "意外错误!"));
saveErrors(request, errors);
return mapping.findForward("false");
}

}

从上面可以看出，文件的保存工作很简单，只有三句

DynaActionForm fm = (DynaActionForm) form;
FormFile ff = (FormFile) fm.get("upload");
FileManager.saveFile(fileName, ff);

此处有一个DynaActionForm，通过DynaActionForm我们可以节省一个ActionForm的工作了。当然，这也多了一个配置工作。在struts-conifg.xml里加一个

type="org.apache.struts.action.DynaActionForm">

这样，struts在页面提交以后会自动去找upload、rul和 desc这三个输入，并将它转成相应的数据类型。
所以我们很容易得到一个FormFile对象，而这个对象就包含了上传文件的所有信息。因此，我们的数据表相应的信息也有了

map.put(Constattachment.ATTACHFILENAME, ff.getFileName());
map.put( Constattachment.ATTACHMIMETYPE, ff.getContentType());
map.put( Constattachment.ATTACHFILESIZE, String.valueOf(ff.getFileSize()));
map.put( Constattachment.ATTACHFILEPATH, "/file/" + ff.getFileName());

最后我们只要简单的调用函数插入数据库

DaoCommon.startTransaction();
attachDb.insert(map);
DaoCommon.commit();

核心技术基本讲解完毕。下面讲一下实现的流程。大家可以先看一下demo。首先是一个index页面，可以选择一个上传一个图片文件直接显示出来。也可以把内容显示在input框中。

´)">
´)">

index.jsp的主要内容如上：主要特别的一点的地方就是，是JSTL的url的tag,通过它可以得到相对路径的URL。两个按钮的弹出框都是upload.do，方法是list.list的方法很少

AttachDb attachDb = new AttachDb();
DaoCommon.startTransaction();

request.setAttribute("fileslist", attachDb.find(new HashMap()));

DaoCommon.rollBack();

主要就是列出表中所有文件。放到fileslist这个对象中去。然后指到attachlist.jsp这个jsp文件去。作为view层，attachlist很简单的。

">添加文件

名称
格式
文件
选择

´);">选择 ">删除

首先我们可以看看怎么显示表格通过forEach这个tag.得到fieslist里的对象。，通过这一句也可以看到jstl显示HashMap的数据是多么容易。下面就是参数化的URL,看下面的URL。

">这里有两个参数，一个是url，是从前面的param，也就是前一页的参数取来的。另一个参数是从javaBean对象中取得。ATTACHID就是唯一键，删除的时候就只要这一个参数就可以了。

删除的代码也简单，把ATTACHID放入hashMap,然后执行删除(注，文件没有实际删除，不过要实现文件删除的代码也很简单。)。最后也是读取所有的文件，再返回到本页

AttachDb attachDb = new AttachDb();
DaoCommon.startTransaction();
HashMap delMap = new HashMap();
delMap.put(
Constattachment.ATTACHID,
request.getParameter("ATTACHID"));
attachDb.delete(delMap);

request.setAttribute("fileslist", attachDb.find(new HashMap()));

DaoCommon.commit();

添加文件指向attach.jsp。这个文件是上传的主要文件，实现一个实际的上传界面。

">文件管理器

说明：

文件：

">

提交以后执行前面所说的add方面。然后转到success.jsp。其内容就是把前面的fileName转到index页面，同时关闭自己。

R.Zeus 2005-09-25 00:20 发表评论

Struts Recipes: Hibernate and Struts

R.Zeus — Sun, 18 Sep 2005 06:11:00 GMT

Struts Recipes: Hibernate and Struts

Add the power of Hibernate to your Struts application

Summary
In this excerpt from Struts Recipes, (Manning Publications, December 2004) authors George Franciscus and Danilo Gurovich illustrate how to use Hibernate in a Struts application. They also show how to create a Struts plug-in to improve performance. (2,200 words; January 24, 2005)

By George Franciscus and Danilo Gurovich

ersistence is a fundamental piece of an application. Obviously, without persistence all work would be lost. However, persistence means different things to different people. The length of time something must be persisted is a fundamental qualifier in choosing a persistence storage medium. For example, the HTTP session may be suitable when the life of a piece of data is limited to the user's session. In contrast, persistence over several sessions, or several users, requires a database. The volume of data is another important qualifier. For example, best practices suggest large amounts of data should not be stored in an HTTP session. In those circumstances, you need to consider a database. In this recipe we target persistence in a database.

The type of database you choose has an important influence on your architecture and design. As object-oriented developers, we tend to represent data as an interconnected web of objects as a means to describe the business problem at hand—this is often called a domain model. However, the most common storage medium is based on a relational paradigm. Unless our object model mirrors a relational structure, the in-memory representation of our data is at odds with the means to persist it. This problem is called the mismatch paradigm. One of the most popular tools to address the mismatch problem is a category of tools called object-relational mappers. An object-relational mapper is software used to transform an object view of the data into a relational one, and provide persistence services, such as create, read, update, and delete (CRUD). Many good papers have been written on object-relational mappers, but in essence, they all speak to the Data Mapper pattern. One of the most popular object-relational mappers is the open source Hibernate project.

In this recipe, we show you how to employ Hibernate in a Struts application. In addition, we will show you how to create a Struts plug-in to give your Hibernate-powered Struts applications a performance boost.

Recipe
In this recipe, we use an example to illustrate everything you need to do to use Hibernate in a Struts application. We create an application to retrieve and display elements from the chemical periodic table. The application offers the user a search page to look for an element by element symbol. The application responds by searching the database for an element matching the symbol name and returns information about the element.

We'll start by showing you how to get the Hypersonic database server up and running. With the database server started, we create the table and data required to exercise the application. Once the database is ready to go, we'll create all the Hibernate artifacts required to execute this application by using the Hypersonic database server. The next step is to respond to search requests by calling upon Hibernate to handle database access from inside our Action. Because creating Hibernate factory objects is expensive, we'll create a Struts plug-in to create the factory and store it in context.

Let's start by bringing up the Hypersonic database server. You need to download Hypersonic from http://hsqldb.sourceforge.net/. Place hsqldb.jar in your classpath and launch Hypersonic by entering the following command in your DOS prompt:

java org.hsqldb.Server

Although the server's response varies from one version of Hypersonic to another, the following response is a typical indication that Hypersonic is ready to serve database requests.

Server 1.6 is running Press [Ctrl]+{c} to abort

With the database server up and running, we are ready to create the elements table and populate it with data, as shown in Listing 1.

Listing 1. Create and populate elements tables

create table elements (id integer(3) IDENTITY, name char(30), number char(30), mass char(30), symbol char(2)); CREATE UNIQUE INDEX ui_elements_pk ON elements (symbol) insert into elements ( name, number, mass, symbol) values ('Manganese','25','55','Mn'); insert into elements ( name, number, mass, symbol) values ('Zinc','30','65','Zn'); insert into elements ( name, number, mass, symbol) values ('Thulium','69','169','Tm'); insert into elements ( name, number, mass, symbol) values ('Californium','98','251','Cf'); insert into elements ( name, number, mass, symbol) values ('Gold','79','197','Au'); insert into elements ( name, number, mass, symbol) values ('Ytterbium','70','173','Yb'); insert into elements ( name, number, mass, symbol) values ('Molybdenum','42','96','Mo'); insert into elements ( name, number, mass, symbol) values ('Palladium','46','106','Pd');

Listing 1 presents the SQL commands necessary to create the elements table, create a unique index on symbol, and insert data We have only presented a few of the periodic elements. We'll leave it to you to dust off your high school chemistry textbook to create data for the remaining elements.

Listing 2 presents the Element JavaBean used to store data retrieved from the database.

Listing 2. Element JavaBean

package com.strutsrecipes.hibernate.beans; public class Element { private String name; private String symbol; private String number; private String mass; private int id; public Element() { super(); } public Element(String name, String symbol, String number, String mass) { this.name = name; this.symbol = symbol; this.number = number; this.mass = mass; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getMass() { return mass; } public String getName() { return name; } public String getNumber() { return number; } public String getSymbol() { return symbol; } public void setMass(String mass) { this.mass = mass; } public void setName(String name) { this.name = name; } public void setNumber(String number) { this.number = number; } public void setSymbol(String symbol) { this.symbol = symbol; } }

Hibernate is an object-relational mapping tool. Its job is to map objects to relational tables and vice versa. Therefore, we must tell Hibernate how to map the columns in the "elements" table to the properties of the Elements JavaBean. This is done using the Element.hbm.xml file. The information embodied in this file is required to empower Hibernate to copy data from the table to the Elements JavaBean. If we were using Hibernate to update data, the information in the Element.hbm.xml file would be used to extract data from the Elements JavaBean to generate SQL update statements. Listing 3 presents Element.hbm.xml.

Listing 3. Element.hbm.xml

"http://hibernate.sf.net/hibernate-mapping-2.0.dtd">

Let's step through Listing 3

We declare the full package name of the class to be associated with the "elements" table. We then declare the name of the table associated with that class. Next, we declare the mapping from the id JavaBean property to the id column. Because the property and column names have the same value, we could have omitted the column attribute, but we have explicitly declared the column for clarity purposes. The tag is a special tag. It is used to declare the primary key for the table. The enclosing tag instructs Hibernate to generate the key in whichever way is most appropriate for the database implementation. You should consult Hibernate documentation for more information on the tag. Finally, we declare mapping for the remaining JavaBean properties. Once again the column attribute is declared for clarification purposes.

Once the mapping file has been broken down in detail, it's all rather straightforward. It simply describes which table maps to which class and which JavaBean properties map to which column names. Later on we will tell you where to place this file.

Next, we configure Hibernate by declaring environmental information. In Listing 4, we present the hibernate.cfg.xml file.

Listing 4. hibernate.cfg.xml

"http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd"> net.sf.hibernate.dialect.HSQLDialect org.hsqldb.jdbcDriver sa jdbc:hsqldb:hsql://127.0.0.1 true

Let's step through Listing 4.

We start by specifying the database implementation dialect that allows Hibernate to take advantage of implementation-specific features. We declare the Hypersonic dialect. You should consult the Hibernate documentation to choose the appropriate dialect for your database. We then declare the database driver. You must ensure this driver is in your application's classpath. We then declare the database username, the database password, and the database connection URL. Next, we instruct Hibernate to display the SQL generated at runtime in the log.

The hibernate.cfg.xml file must be placed in your classpath.

The procedure to use Hibernate within your application requires the following steps:

Create a Hibernate configuration object
Use the Hibernate configuration object to create a Hibernate factory object
Use the Hibernate factory object to create a Hibernate session object
Use the Hibernate session object to start a transaction (optional)
Employ the Hibernate session object to create, read, update, and delete data on the database
Commit the transaction (optional)
Close the session

A Hibernate best practice is to create and cache the Hibernate factory to enhance performance. Therefore, we will create a Struts plug-in to perform Steps 1 and 2 and cache the Hibernate factory in the servlet context, as shown in Listing 5.

Listing 5. HibernatePlugin.java

package com.strutsrecipes.hibernate.plugin; import java.net.URL; import javax.servlet.ServletException; import net.sf.hibernate.HibernateException; import net.sf.hibernate.MappingException; import net.sf.hibernate.SessionFactory; import net.sf.hibernate.cfg.Configuration; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.struts.action.ActionServlet; import org.apache.struts.action.PlugIn; import org.apache.struts.config.ModuleConfig; public class HibernatePlugin implements PlugIn { private Configuration config; private SessionFactory factory; private String path = "/hibernate.cfg.xml"; private static Class clazz = HibernatePlugin.class; public static final String KEY_NAME = clazz.getName(); private static Log log = LogFactory.getLog(clazz); public void setPath(String path) { this.path = path; } public void init(ActionServlet servlet, ModuleConfig modConfig) throws ServletException { try { URL url = HibernatePlugin.class.getResource(path); config = new Configuration().configure(url); factory = config.buildSessionFactory(); servlet.getServletContext().setAttribute(KEY_NAME, factory); } catch (MappingException e) { log.error("mapping error", e); throw new ServletException(); } catch (HibernateException e) { log.error("hibernate error", e); throw new ServletException(); } } public void destroy() { try { factory.close(); } catch (HibernateException e) { log.error("unable to close factory", e); } } }

Creating a Struts plug-in requires only two steps. First, create a class implementing org.apache.struts.action.PlugIn (Listing 5). Second, define a tag in the struts-config.xml file (Listing 6).

Let's step through Listing 5.

We create a constant to hold the name of the servlet context attribute key. We have chosen to use the HibernatePlugin class name. Notice the constant is static public final. We use the HibernatePlugin class to access the key name in the Action (Listing 7). We define the path property. By default, the Hibernate-Plugin looks for the Hibernate configuration file at /hibernate.cfg.xml. You can use this property to load the Hibernate configuration file from another filename and directory anywhere on the classpath. Next, we use the classloader to find the Hibernate configuration file and then we create the Hibernate configuration object. We use the Hibernate configuration object to create a Hibernate factory object and then we store the Hibernate factory object in the servlet context. The factory is now available to any code with a reference to the servlet.

As a good practice, we close the factory in the destroy method.

Listing 6 presents the application struts-config. The only thing out of the ordinary here is the tag. This is where we declare the Hibernate plug-in, which creates and caches the Hibernate factory object.

Listing 6. struts-config.xml

"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd"> type="com.strutsrecipes.hibernate.actions.SearchAction" name="searchForm" scope="request" input="/search.jsp">

Listing 7 presents the SearchForm used to search for an element. It's very simple because the user can only search by element symbol.

Listing 7. SearchForm.java

package com.strutsrecipes.hibernate.forms; import org.apache.struts.action.ActionForm; public class SearchForm extends ActionForm { String symbol; public String getSymbol() { return symbol; } public void setSymbol(String symbol) { this.symbol = symbol; } }

Let's have a look at the SearchAction in Listing 8. Although you may decide to employ Hibernate in other areas of your application architecture, we have chosen to use it in the Action. We'll defer the discussion of the other alternatives to the discussion section.

Listing 8. SearchAction.java

package com.strutsrecipes.hibernate.actions; import java.util.List; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import net.sf.hibernate.Hibernate; import net.sf.hibernate.HibernateException; import net.sf.hibernate.Session; import net.sf.hibernate.SessionFactory; import org.apache.struts.action.Action; import org.apache.struts.action.ActionError; import org.apache.struts.action.ActionErrors; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping; import com.strutsrecipes.hibernate.beans.Element; import com.strutsrecipes.hibernate.forms.SearchForm; import com.strutsrecipes.hibernate.plugin.HibernatePlugin; public class SearchAction extends Action { private static Log log = LogFactory.getLog(SearchAction.class); final public static String HQL_FIND_ELEMENT = "from com.strutsrecipes.hibernate.beans.Element as e where e.symbol = ?"; public ActionForward execute( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception { SearchForm searchForm = (SearchForm) form; Element element = null; List elements = null; SessionFactory factory = null; Session session = null; try { factory = (SessionFactory) servlet.getServletContext() .getAttribute(HibernatePlugin.KEY_NAME); session = factory.openSession(); elements = session.find( HQL_FIND_ELEMENT, searchForm.getSymbol(), Hibernate.STRING); if (!elements.isEmpty()) { element = (Element) elements.get(0); } } catch (HibernateException e) { log.error("Hibernate error", e); } finally { log.error("Hibernate exception encountered"); session.close(); } if (element != null) { request.setAttribute("element", element); return mapping.findForward("success"); } ActionErrors errors = new ActionErrors(); errors.add(ActionErrors.GLOBAL_ERROR, new ActionError("error.notfound")); saveErrors(request, errors); return mapping.getInputForward(); } }

Let's take a quick overview of what happens in the SearchAction. The SearchAction uses the SearchForm.getSymbol() method to obtain the element symbol entered by the user on the search page. Hibernate is used to search the database and convert the data stored in the database to an Element object. The Element object is placed in request context for the JavaServer Pages (JSP) page. Let's step through Listing 8 line by line to see how it's done in detail.

First, we declare a constant to search the database. We next cast the form to SearchForm and then we obtain the Hibernate factory. Recall the Hibernate plug-in has already created the factory and cached it in the servlet context. Next, we obtain a session. The session obtains a connection to the database. Hibernate uses the configuration information we created in Listing 4 to connect to the database. We then search the database.

There are other ways to employ Hibernate to search the database, but the find method is appropriate whenever a search doesn't use the primary key. Notice, we have the HQL_FIND_ELEMENT constant declared. The SQL defined in HQL_FIND_ELEMENT looks somewhat like standard SQL, but not quite. The SQL used by Hibernate is proprietary to Hibernate and reflects an object-oriented version of SQL, rather than the relational SQL to which you are accustomed.

Let's delve into the Hibernate SQL (HQL) code snippet.

from com.strutsrecipes.hibernate.beans.Element as e where e.symbol = ?

This statement tells Hibernate to select all Element objects residing in the com.strutsrecipes.hibernate.beans package. The where clause filters the list to only those elements whose symbols match a runtime parameter. The as e indicates that e may be used as an alias elsewhere in the HQL, as we have done in the where clause. You can see that we are selecting objects, not rows, in the database. Hibernate uses the information in Listing 4 to map the class we are interested in to its associated table. In this example, the relationship between the table and the object are very close, but that does not necessarily need to be the case.

The second and third arguments to the find method are the value and data type of the HQL replacement parameter. The Hibernate reference material describes other ways to replace runtime parameters.

The find method always returns a List. In this case, we obtain a list of Element objects. We are confident that a maximum of one instance is returned because the "elements" table has a unique key constraint on the symbol column (see Listing 1).

Returning to Listing 8, we copy the element reference in the first position in the list to the element variable. To deal with any Hibernate exceptions, we have chosen to log the exception and present the user a "not found" message, but you may decide to present a different message or use declarative exception handling. Next, we close the session. Closing the session in the finally clause guarantees it is attempted even when exceptions are thrown. We store the Element object in the request context and finally we build the ActionError when the symbol can't be found. For the sake of completeness, we have presented the search.jsp (Listing 9) and the element.jsp (Listing 10).

Listing 9. Search.jsp

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

`Search for an Element`



   
      symbol

Listing 10. Element.jsp

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

`Periodic Element`


   Name: 

   Symbol: 

   Number: 

   Mass: 


   Search

Before putting Hibernate to work, consult the Hibernate documentation to ensure you have all the required Hibernate jar files in your classpath.

Discussion
Persistence of data is a tedious and laborious job. To make matters worse, a considerable effort must be spent transforming an object-oriented representation of the data to a relational one, and vice versa. Fortunately, several good object-relational mappers exist to ease this burden. In this recipe, we explored Hibernate—one of the most popular open source object-relational mappers available to Java programmers.

Hibernate is a very rich product with many unexplored features left for you to discover. Our simple example is limited to read behavior, but the rest of the CRUD family is just as easy. Update functionality is as simple as accessing the desired element, calling the desired JavaBean setter, and calling the session commit method. Hibernate takes care of generating the SQL and updating the table. A delete is also rather simple—session.delete(element) is all it takes! Finally, create only requires instantiating the object, calling the setters, and calling session.save(element).

Hibernate best practices recommend caching the Hibernate factory object. We chose to create and cache the factory using a Struts plug-in. Alternatively, you could have chosen to cache using any other means in your arsenal.

Although this recipe can serve you well, there are some drawbacks. First, we have exposed Hibernate to the Struts Action. Migrating to another persistence layer framework requires us to change every Action employing Hibernate. Second, our persistence is tightly coupled to the presentation layer. This coupling denies us the opportunity to reuse the persistence logic in some other presentation mechanism, such as a batch program.

Although there is room for improvement, this recipe is suitable when you do not expect to reuse your persistence logic. You may find yourself in this situation developing prototypes or small throwaway applications.

About the author
George Franciscus is a J2EE consultant and Struts authority. He is a coauthor of Manning's Struts in Action.

Danilo Gurovich is a manager of Web engineering at an e-commerce company. He has designed e-commerce and ERP/EAI Struts applications, and has led teams who have built them.

R.Zeus 2005-09-18 14:11 发表评论

Struts Resources

R.Zeus — Fri, 12 Aug 2005 19:57:00 GMT

Contributor Taglibs

MonkeyStruts by Arron Bates. An approach to nesting beans.

REGEXP.VALIDATOR.STRUTS by Emmanuel Boudrant - A validation component that works with Struts 1.0, to manage form validation on server-side and client-side.

Struts-WAS.jar by Christopher Assenza - Modified Struts 1.0 JAR for Websphere 3.5 or 4. Zipped for download. (For additional tips regarding Websphere 3.5 see http://jakarta.apache.org/struts/installation-was352-x.html.)

Struts Layout by Improve - An extension library to improve interfaces creation with Struts.

Indexed Tags [Also available in the nightly build] by Dave Hays - Produce indexed names such as . Link, Submit, and Select tags are included too.

Struts IF/THEN/ELSE and SWITCH tags by Niall Pemberton.

TextArea Wrapping by Matthias Bauer. Patch to HTML:TextArea tag to provide wrapping of long lines.

RowTag (ZIP file for download) - Source for a Struts-compatible tag to generate alternating row colors in a table by Niall Pemberton. [NOTE: Requires a Struts build dated after 2001-04-28]

Contributor Extensions

Pow2ACL - Access Control List library. Track of application users roles and permissions. User can be authenticated: - directly using the package API; - using custom JSP tag libraries.

Struts .. in Rose by Emmanuel.Boudrant - Use Struts with the Rational Rose UML model.

Multi-Controller by Sukachevin, Stoehr - Use more than once ActionServlet in your Struts application

JavaScript with html:errors - new Struts validation by Adam Grohs.

Scioworks Camino by Scioworks Pte Ltd. A visual tool for Struts.

Struts Console by James Holmes. The Struts Console is a Java Swing application that provides an easy to use interface for editing Struts' "struts-config.xml" configuration file.

Expresso by JCorporate. An open source application development (AD) framework integrated with Struts.

Dynamic ActionForm Properties by Jan Sorensen.

Bean Utils with Indexed Strings by Gregor Rayman.

Role-Based Actions by Nic Hobs. Set a security role for an Action from with struts-config.

Struts CodeMaker by Ravindran Ramaiah - Generate Struts application by reading configuration file or JSP files. Updated 2001-08-21.

Struts Generator by David Winterfeldt - Based on the generator.xml and a table/query an xml file is generated. Based on the generated xml file a primary key class, data bean class, jdbc class, and an ActionForm (Struts) can be generated.

ValueIterator by Ted Husted - Simple wrapper around a RowSet for use with Struts iterator tag. Also includes generic toMap(), set(map) methods for flexible data transfer.

Struts Transformer by Ron Smith - Transformations are responsible for taking an object in one form and transforming it into another. A forward transformation takes an object from its primary form to a secondary form (e.g. Date object to String). A reverse transformation takes an object from a secondary form to its primary form (e.g. String to Date).

Struts Extender by Ron Smith - Add extensions to the struts framework via entries in the Struts configuration file.

Mapper Framework by Capco - The Mapper framework can be used for automating the process of validating/converting/transferring data fields. (See README to get started. Updated 18-JUL-2001.)

Bean factory by Oleg V Alexeev - Adds the ability to easily link data bean creation to any Struts Action. All information about databeans and actions mappings stored in the standard Struts configuraton file.

Workflow Extension by Matthias Bauer - An extension to the core Struts framework which provides control flow between actions.

Struts Menu by Scott Sayles (ZIP file for download) - A Struts-compatible web menuing component (early release - work in progress) - unzip to a "struts-menu" folder, and see the README.

Struts Validator [Also in the nightly build /contrib folder] by David Winterfeldt - Perform basic validations to check if a field is required, matches a regular expression, and some basic type checking. Different validation rules can be defined for different locales. The framework has basic support for user defined constants which can be used in some field attributes. The validation routines are modifiable in the validation.xml file so custom validation routines can be created and added to the framework.

TLD to VLM by Mario Busche - Simple Java program to convert standard TLD's to the VLM format used by Homesite, CF Studio, and JRun Studio.

UltraDev 4.0 Custom Tag Library Extension - Hosted by Jakarta Taglibs.

Tiles Library for building JSP views [Also in the nightly build /contrib folder] by Cedric Dumoulin - A component is a JSP page that can be inserted in another JSP page, like templates, but can take "parameters" (URLs or 'direct' string intemplates).

Projects and Examples

Artimus by Ted Husted - Simple news poster application. Demonstrates using helper beans and a JDBC database with Struts. WAR zipped for download. Uses Scaffold package. See WEB-INF/README.txt for setup.

Scaffold by Ted Husted - Utility package of classes that can be used with various Web applications.

Struts Polls by Ted Husted - Simple poll application. Demonstrates using a database with Struts.

Struts-example modified for iPlanet Application Server SP2 by Matt Raible.

The Struts Framework by Steve Wilkinson - Excerpt from latest Wrox Professional JSP book.

Struts-Simple by Ted Husted - (WAR file zipped for download) A simple skeleton application outlining the files needs to input and re-display data. Now also demonstrates using "nested" beans.

myCart - Example Shopping Cart application using Struts - joint project with several contributors.

Sample hdml/wireless based struts application by Richard Backhouse.

Struts Login (WAR file zipped for download) by Ted Husted - A minimalist Struts application demonstrating form validation and tracking users with a session attribute (WAR file).

Tutorials

How To: (Form-Based Authentication) use the form-error page to login by Matt Raible.

WebSphere 4 Application Development Handbook - IBM "Redbook" - See "Designing with Frameworks (Chapter 7).

Struts Catalog by Ted Husted - Overview of Struts Design Patterns and Strategies.

HOWTO Setup and Debug STRUTS Example in Forte by Michael Mok.

JBuilder 5, Struts 1.0 & WebLogic 6.0, a Tutorial by Markus Colombo.

Using JBuilder5 with Struts 1.0 Release by Anthony Martin.

3148 Configuring AppServer to Work with Struts by Ken Sipe (7/25/2001)

3004 Building Extensible Web Frameworks Using XML, XSL-T, and Java by Richard Vowles 7/21/2001

Strut by Strut by Ted Husted - Building a web application from the ground up (maintenance release 2001/Aug/19).

J2EE Tutorial - Early Release chapter featuring Struts 1.0 tags.

Welcome to the Struts Framework by Bluestone Software.

An Introduction to Struts by Casey Kochmer.

Struts UML Diagrams (PDF) by Jean-Pierre Schnyder.

Blueprinting a Struts Application by Ted Husted - Sample specification and API for the Struts Example application.

Seminars

Fast Track to MVC Frameworks - 2001-Dec-2.

BravePoint - Advanced JSP Architecture for J2EE - 2001-11-19, 2001-12-10.

AvantSoft Inc. - JSP, Servlets and Struts

Articles

The Struts Framework's Action Mappings Configuration File by Wellington L.S. da Silva

Web Development Products Spreadsheet by Dan Cancro.

Layering Applications by Scott Stanchfield.

MVC and Struts by Steven Sweeting, Clive Jones, and Aaron Rustad.

Introduction to Jakarta Struts Framework by Sue Spielman.

The Struts Framework's Action Mappings Configuration File by Wellington L.S. da Silva

Is Struts Performant? by Ted Husted -- An analysis of framework components, and how they contribute to overall efficiency.

Struts for Everyone by Jonathan Asbell -- Word document zipped for download. Early release: still in working draft form.

Approaches to User Authentication and Access Control in Web Applications by Craig McClanahan. Slides from the JavaOne BOF (June 2001 #1291). Star Office Format. Zipped for download.

Support your application development with Struts [404] by McClanahan, McCay, and Bergenholtz.

Introduction to MVC and the Jakarta Struts Framework by Craig Tataryn.

Kickstart - The obligatory Struts Q&A.

Struts, an open-source MVC implementation by Malcom Davis.

Strut Your Stuff With JSP Tags, by Thor Kristmundsson.

Using the Struts Framework to Develop a Message Board by Maneesh Sahu (article requires registration with informit.com).

JSP templates by David Geary.

Books

Professional JSP Site Design - Wrox book - Features Struts throughout.
JSP and Tag Libraries for Web Development - by Wellington L. S. Da Silva. Several chapters regarding Struts.
Websphere Version 4 Application Development Handbook (PDF) - Chapter 7 covers designing with both the Struts and Websphere frameworks,
Java Server Pages and J2EE Web-based Applications for Enterprises - In German, with a Chapter regarding MVC and Struts.
Core J2EE Patterns - Many of these patterns are deployed in Struts.
Professional JSP 2nd Edition - Wrox book - long chapter on Struts.
Advanced JavaServer Pages by David Geary - features template tag library from Struts 1.0

Selected APIs, RFCs, and JSRs

HyperText Markup Language (w3c)
- HTML 4.01 Specification

Other Resource Pages

JGuru FAQ

More About Struts by Husted dot Com.

German Translation of Users Guide by Hartmut Bernecker.

Javasoft Tutorials

Javasoft Mailing Lists

Mailing List Archives

mail-archive.com.

Struts FAQ with Mailing List Threads - Clippings from the User Lists

Powered by Struts

Application-Servers.com - French site.
Clickstart Tutoring - One on one in home tutoring.
dbForms - RAD framework for database applications.
E-Involve
Enitel - French site.
Hallmark Stories - "Tell the story behind your photos".
iKnowBase - The Knowledge Engine.
IronMax - B2B site; see Equipment Information Products.
IPIPI - e-Mail to SMS delivery service.
Jcorporate.com - open source and shared source commercial applications.
Get To Hawaii - B2B Travel Service Provider
New Dawn Art - Social and spiritual art on the Internet.
Normad - Web Timesheet Management System.
Organonx
Pizza Hut Online / Sydney Metro - For pickup or delivery in the Syndey Metro area.
Povoglie [403] - Goverment regional press services news center in Russia, middle Volga.
South African Revenue Services - Directive and certificate service.
Red Galleon - Offer aggregator.
TeaTimeJ - Website and Java hosting.
WXXI Spring MarketPlace 2001 - Online auction for Public Television station.

Java / Struts ISPs

Provided as a reference only. No endorsements given or implied. To be listed, post a documentation enhancement request in Bugzilla.

Consultants

Provided as a reference only. No endorsements given or implied. To be listed, post a documentation enhancement request in Bugzilla.

AccessData - www.accessdc.com - Chris Assenza.
Bravepoint - www.bravepoint.com - Struts Info.
Creatrix - www.creatrixs.com - sami.elhini@creatrixs.com.
eBlox - www.eblox.com - andrewb@eblox.com.
Husted dot Com - www.husted.com - Ted Husted.
JATEC AG - www.jatec.ch - Sascha Urfer.
jCorporate - jcorporate.com - Sandra Cann.
Kambrium.net Technologies - kambrium.net - Dirk Gabler.
Living Logic - www.livinglogic.de - Matthias Bauer.
Multitask Consulting - www.multitask.com.au - dIon Gillard .
New Particles - www.newparticles.com/struts - Steve Wilkinson.
Raible Designs - www.raibledesigns.com - Matt Raible.
Shared Skills Ltd (UK) - www.sharedskills.com - Mike Way.
SoftwareMentor - softwareMentor.com - Tim Biernat.
Solution Array - www.solutionarray.com - Chris Kmiec.
Stonebridge Technology - www.sbti.com - John J. Thomas.
Tallan - www.tallan.com - Michael Grassotti.
Thalles Information Services - www.thales-is.ch - Markus Collumbo.
Upco -upco.co.uk - Jon Ridgeway.
viadee UNTERNEHMENSBERATUNG GmbH - www.viadee.de - Frido Budde.

R.Zeus 2005-08-13 03:57 发表评论

1. 简介

R.Zeus — Fri, 12 Aug 2005 19:51:00 GMT

1. 简介

1.0 先决条件

这份用户指南是为那些活跃的Web开发者编写的，假设读者已经了解java Web application是如何工作的。在开始之前，您应该已经掌握下列基本核心技术。

HTTP Request/Response 结构.
正式的文档在这里RFC 2616 - Hypertext Transfer Protocol (HTTP/1.1).
Java Servlets.
开始学习的一个好地方是 Sun Servlet product page 和 Sun Java Tutorials.
JavaServer Pages (JSP).
类似的，一个开始学习的好地方是 Sun JSP product page 和Sun Java Tutorials.
JavaBeans.
很多Struts的类被编写成为Javabeans.如果您没有接触过Javabeans,参阅 Sun JavaBean product page 和 Sun Java Tutorials

如果您在其他平台上开发过web applications,您也许可以继续。在需要的时候参考以上的资料。他们几乎是所有Java web开发项目需要用到的核心技术。

1.1 前言：回到从前！（也是Struts的简史）

当java servlets被发明出来的时候，很多程序员迅速意识到这是一个好东西。它比标准CGI快速强大，可以移植，并且几乎可以无限扩展。

但是无穷无尽的编写 println()语句来吧HTML送到浏览器是浪费时间并且容易造成问题。答案就是JavaServer Pages,它把编写servlet的任务倒了个个儿。现在开发者可以很容易的把HTML和Java代码混合起来，并且仍然拥有servlet的所有好处。只有天空才会限制（我们）！

Java web程序很快变成了以JSP为中心的。关于(JSP)本身并不是一件坏事，但是它并没有解决流程控制和web application的其他一些问题

显然，我们需要另一个模型...

很多聪明的程序员认识到JSP和servlets可以被一起使用来构造web程序。Servlets可以用来辅助流程控制，JSP主要关注于实现那些凌乱的HTML.在这样的过程中，一起使用JSP和servlet开始被称为Model 2.(同时只使用JSP被称为Model 1)。

当然，天底下没有新东西...很快很多人指出JSP的Model 2 遵循SmallTalk的经典的Model-View-controller设计模式。现在术语Model 2和MVC可以互相替代。

Struts工程于2000年5月由Craig R. McClanahan开始动工，来为Java社区实现一个标准的MVC框架。2001年6月，Struts 1.0发布了。从此，Model 2开发开始变得不同。

1.2 Model-View-Controller ('MVC') 设计模式

在MVC设计模式中，程序流程由一个的Controller(控制器)居中斡旋。Controller委派请求--在我们的情形中,HTTP请求--到合适的handle（处理程序）去。Handle和Model（模型）相联系，每一个handle的作用就是成为在请求和Model之间的适配器(adaptor有一个意思是电源插头--译者注)。Model 代表或者封装了一个程序的商业逻辑或者状态。通常控制由Controller重新转移到对应的View去。这个转移由一系列的映射决定，一般从数据库或者配置文件中取得。这样就为View和Model提供了一个松散的联系，编写和维护程序变得显而易见的的容易。

1.3 Struts 框架纵览

忠实的和Model-View-Controller设计模式对应，Struts程序有三个主要的部件：一个Servlet Controller,它由Struts本身提供,JSP 页面("view"),还有程序的商业逻辑("model").我们来看看他们是怎么组合到一起的。

Struts的Controller servlet把HTTP 请求打包并传送到框架中的其他对象，包括JavaServer Pages和由Struts开发者编写的org.apache.struts.action.Action的子类。当(系统)初始化的时候，Controller 解释一个配置资源文件。这个文件定义了(和其他配置一起)这个程序的org.apache.struts.action.ActionMapping。Controller用这些映射来把HTTP 请求转换为程序的actions(动作)。

一个ActionMapping通常会指出:

一个request请求的路径 (简称 "URI"),
用于处理请求的object type（对象） (Action 的子类),
和其他一些必要的属性。

Action 对象可以处理请求并响应客户端(通常是一个web browser),或者指出流程应该被指向另一个地方。例如，如果登录成功，一个login Action可能希望把流程转移到主菜单。

Action对象可以操作程序的Controller servlet,所以可以操作这个Controller的方法。当转发控制的时候，一个Action对象可以不直接的转发一个或多个共享对象，包括JavaBeans,这个过程是通过把它们放到Java servlet共享的某一个标准collection对象里去。

Action对象可以创建一个购物车Bean，在购物车里面加上一个条目，把这个bean放到session 结构里去，然后把控制转发到另一个映射。那个映射会使用一个JavaServer Page来显示用户的购物车里的内容。因为每个用户都有他自己的session,他们也会有自己的购物车。在一个Struts程序里，大部分商业逻辑都可以由JavaBeans表示。一个Action可以调用一个JavaBean的属性，不需要知道她实际上是如何工作的。这封装了商业逻辑，所以Action可以专注于错误处理和如何转发控制。

JavaBeans也可以用来管理输入的Forms.设计一个web程序的主要问题是得到并检查用户在请求中的输入。通过Struts,你可以定义你自己的Form Bean 类集合，他们都是org.apache.struts.action.ActionForm的子类，并很容易的把用户form（这里是指HTTP form--译者注）输入的内容放到这些Form bean里去。这个bean被存放到一个标准的共享上下文集合里去，所以另一个对象可以使用它，特别是指一个Action对象。（我的理解，使用ActionForm是因为这样可以标准化的检查Form里的值，也可以标准化的调用Action--译者注。）

Form bean可以被一个JSP使用来从用户收集数据...通过一个Action 对象来检查用户输入的数据...然后再通过JSP来重新显示form的字段。如果检查错误，Struts由一个公用的机制来提交和显示错误信息。

Struts 的Form bean在配置文件中声明，在一个Java文件中被定义，并且通过一个通用的属性名字来连接到一个ActionMapping去。当一个请求调用一个需要FormBean 的Action时候，Controller servlet要么从输入中获取form bean,要么自己构造一个form bean,把它传递到Action对象去。Action 对象可以在显示之前检查form bean的内容，也可以为要在form里显示的内容排队。准备好之后，Action对象返回控制权并转移到它的输入叶面去。controller就可以响应HTTP请求，并重定向到JavaServer Page去。

Struts 框架包括自定义的Tag来自动从一个formBean填充子段。JavaServer Page唯一需要知道的是确切的字段名和下一步提交form到何处。一些部件例如被Action排队的消息可以在一个自定义tag就被输出。也可以定制其他为程序定制的tag来从jsp中隐藏实现细节。

在Struts框架中的自定义tag被设计为使用Java平台内置的国际化特性。所有的字段名和消息都可以从消息资源中获取，并且Java可以自动为一个客户端的国家和语言提供想对应的资源。为了提供另一种语言的支持，只需简单的的增加另一个资源文件。

除了国际化之外，这个进步的好处还在于在不同的form中保持一样的标签名字，也可以全局化的复查所有的标签和消息。

对于最简单的程序来说，有时候一个Action对象可以处理一个请求对应的商业逻辑。但是，在大多数情况下，一个Action对象应该调用另一个对象，一般是一个JavaBean来处理实际的业务逻辑。这让Action专注于错误处理和流程控制，而非商业逻辑。为了在其他平台上重用，商业逻辑JavaBean不应该引用任何web程序的对象。Action对象应该从HTTP请求翻译必要的细节并象普通的java变量一样传递到商业逻辑对象去。

举个例子，在一个数据库程序中：

一个商业逻辑bean会连接到数据库并进行查询,
商业逻辑bean把结果传递到Action,
Action把结果保存在一个form bean中，放置到request中去,
JavaServer Page把结果显示到一个HTML Form中去。

不管是Action还是JSP都不需要知道结果是从哪儿来的。他们只需要知道如何打包和显示结果。

用户指南的其它部分非常详细的解释了Struts的不同部件。Struts发布版本也包含了一些开发者手册包含几个不同的主题，也包括例子程序，标准的Javadoc API,当然还有全部的源代码！

Struts 在Apache软件基金会协议下发布。代码拥有版权，但是可以在任何程序中自由的使用。参阅ASF license 得到详细信息.

1.4 Model（模型）: 系统状态和商业逻辑JavaBeans

基于MVC的系统中的Model(模型)部分可以被分为两个概念，系统的内部状态和可以用来改变状态的动作。从语法上来说，我们可以把状态信息看成是名词，而动作是动词（用来改变状态）。

一般来说，米的程序需要用一套包含一个或多个JavaBeans来表达内部状态，(这些)JavaBean包含了这个状态的详细属性。根据你的程序的复杂程度，他们可能是自我包含的（自己知道怎么样保留持续化信息），或者仅是一个知道必要时如何从外部数据源（如数据库）获取信息的对象。Entity Enterprise JavaBeans (Entity EJBs)一般也用于表示内部状态。

大型程序经常使用一些bean的方法来表示一组可能的商业逻辑，这些方法维护状态信息。例如，你可能有一个购物车Bean,保存在每个用户的session中，包含用户当前决定购买的条目。这个bean可能有一个checkOut()方法来取得用户信用卡的授权，发送订单到仓库去来发送。另一些系统可能把可能的动作单独包装，可能是一个Session Enterprise JavaBeans(Session EJBs).

在一些较小的程序中，相反，可能的动作会内置于Action类中，是Controller角色的一部分。当逻辑非常简单的时候，或者当重用商业逻辑不是关注点的时候这是合适的。Struts框架支持任何一种模式，但是强烈建议把商业逻辑（如何做）从Action类扮演的角色（做什么）中分开。

1.5 View（视图）: JSP页面和表示部件

基于Struts程序的View部分基本上是由JavaServer pages(JSP)技术构成的。JSP页面可以包含静态的HTML（或者XML）文本，被称为“模版文本”，再加上在特殊的标签运行时（当页面被调用的时候）插入动态内容的能力。JSP环境包含一套标准的动作标签，比如他们的用处在JavaServer Pages Specification描述了。另外，还有一种标准的方法来定义你自己的标签，他们被组织在“自定义标签库”里。

Struts包含了一个内容广泛的自定义标签库，用以帮助编写完全国际化的用户界面。它也和处于Model部分的ActionForm高度互动。关于使用这些标签的方法在后面会详细讨论。

除了JSP 页面和原有的以及自定义的标签之外，有时候让商业逻辑对象拥有把他们自己根据当前的状态渲染成HTML（或者XML）的能力也是经常需要的。这些被渲染出来的输出可以很容易的在一个结果JSP文件里面用标准动作标签引用。

1.6 Controller（控制器）: ActionServlet 和 ActionMapping

程序的Controller（控制器）部分关注于从客户端接收请求（通常是一个使用浏览器的用户），决定那个商业逻辑方法应该被执行，然后分配任务给到一个合适的view组件来制造下一步的用户界面。在Struts里面，Controller的主要部分是一个servlet,它是ActionServlet.这个servlet用一组ActionMappings来配置，一个ActionMapping定义了一个path（路径），它和用户请求的URI对应，一般会指定一个完整的Action类的类名。所有的Action类都是org.apache.struts.action.Action的子类。Action封装了商业逻辑，组装结果，并且最终分配控制权到合适的View部件来创建结果。

Struts也支持在ActionMapping中使用除了标准的框架所需之外附加的属性。这样允许你保存你的程序所特定的附加信息。除此之外，Struts还允许你定义控制转移的逻辑“名字”，这样一个Action方法可以要求“主菜单”（举例）而不需要知道对应的JSP页面的实际名字。这个功能很大的帮助你把控制逻辑(做什么）和表示逻辑(如何显示)分开。

R.Zeus 2005-08-13 03:51 发表评论

3. 构造 View （视图）部件

R.Zeus — Fri, 12 Aug 2005 19:46:00 GMT

3.1 纵览

这一章关注构造程序的View(视图)部件的任务，主要是由JavaServer Pages(JSP)技术完成的。特别的，Struts提供对编写国际化程序的支持，同时也支持和(用户)输入的Form交互。其他几个和View(视图)有关的主题也会被简要的涉及。

3.2 Internationalized Messages

几年前，程序开发者们只期望支持他们自己国家的国民，只使用一种（有时候是两种）语言，也只有一种表达日期，数字，钱币的格式。然而，基于Web技术的,在internet和其他一些可以被广泛访问的网络上的程序开发有了爆炸性的增长，让国界问题浮现在我们的眼中。这个问题被理解为对于支持国际化(经常被称为i18n,因为在"国际化"一词internationalization中i和n之间有18个字母)和本地化程序的需要。

Struts 在Java平台上编写，可以辅助支持编写国际化和本地化的程序。需要熟悉的概念有：

Locale (国籍,地区) - 支持国际化的最基本的Java类是java.util.Locale。每一个Locale表示一个特定的国家和语言(包括一种可选的不同语言),和一套对于数字，日期之类的字符串的格式化方案。
ResourceBundle (资源包) - java.util.ResourceBundle类提供了支持不同语言的信息的基本支持。参阅ResourceBundle的Javadoc和在你的JDK版本中的国际化支持的信息来得到进一步的帮助。
PropertyResourceBundle (属性资源包) - 一个ResourceBundle的标准实现，它允许你用和properties文件一样的"name=value"的格式来定义资源。这对于在web程序中准备信息资源宝石很方便的，因为大部分的信息都是文本。
MessageFormat (信息格式) - java.text.MessageFormat 类允许你在运行时用参数的方式替代一个信息字符串（在这种情况下，是从reousece bundle中取出的）。有时候你要编写一个句子，但是在不同的语言中词语出现的顺序不一样，这就很有用了。字符串中的占位符{0}会被第一个运行时参数取代，{1}会被第二个取代，其它的也是这样。
MessageResources (信息资源） - Struts类org.apache.struts.util.MessageResources让你把一套resource bundle当成数据库，允许你得到某种特定的Locale（一般是当前用户的Locale）中的特定信息字符串，而非服务器自己正在使用的Locale。

请注意在一个Struts之类的框架中i18n的支持只限于显示国际化的字符串和图像给用户。支持地区相关的输入法(在日语，中文，或者韩文之类的语言中使用)被留给客户端设备，一般是一个web浏览器。

对于一个国际化程序来说，请遵循JDK中附带的国际化文档中描述的步骤来为你的平台创建每一种语言的properties文件。下面的例子更深入的说明这一点：

假设你的源代码位于com.mycompany.mypackage包,所以它保存在com/mycompany/mypackage目录中（相对于你的源代码目录）。要创建一个名为com.mycompany.mypackage.MyResources的资源包，你应该在com/mycompany/mypackage下创建下列文件:

MyResources.properties - 包含了使用你的服务器所在的语言的文本。如果你的默认语言是英语，你可能会有如下的条目： prompt.hello=Hello
MyResources_xx.properties - 包含了ISO代码为"xx"的语言的文本（参阅ResourceBundle的Javadoc得到最新的代码列表）。对于一个上面所示文本的法语版本，你可能会有如下的条目： prompt.hello=Bonjour 你可以编写所以你愿意支持的语言的资源包。

当你配置你web程序中controller servlet的发布描述时，你需要定义的一个国际化参数是程序的基本资源包的名字。在我们上面举的例子中，它就是com.mycompany.mypackage.MyResources。


  action
  org.apache.struts.action.ActionServlet
  
    application
    com.mycompany.mypackage.MyResources
  
  <.../>

一件重要的事情是要让你的资源包在你程序可以访问的class path中。另一个方法是把MyResources.properties放在你的程序的classes目录下，你就可以简单的用“myResource”作为程序的值。但是要注意如果你的编译脚本为了保证一个“干净”的编译目标，会删除整个classes目录，这时要保证这个资源文件不被删除。

如果是这种情形，这儿有一段Ant任务可以包含在你的编译脚本中，它把src/conf目录中的内容拷贝到classes目录去。

3.3 Forms 和 FormBean 的交互

以前，大多数web开发者使用标准的HTML能力来编写Forms,比如使用标签。用户希望和程序互动，产生某种特定的行为，其中之一和错误处理有关——如果用户犯了个错误，程序应该允许他们改正需要改正的地方——而非重新填写页面上所有的字段。

使用标准的HTML和JSP页面来满足这种需求是非常繁琐和粗笨的，举个例子，一个username字段的输入框可能是这样的(在JSP里)：

如果HTML程序员并没有编程基础知识的话，这很难输入正确，而且也会对页面编辑者带来麻烦。基于JSP1.1中的自定义标签库，Struts为编写form提供了很大的方便，可以取代原始的方法。上面的例子用Struts来编写的话会是这样:

并不需要显式的引用一个JavaBean以取得初始值。框架自动完成这些事情。

HTML form有时候被用来上传一些文件。大部分浏览器通过元素来支持这一点，它会显示一个浏览文件的按钮，但是（在Server端--译者注）下面就轮到开发者来处理这些(上传)来的文件了。Struts可以用和普通的form一致的方式来处理这些"multipart" form.在下一节里，我们会谈到用Struts来创建一个简单的login页面，还包括一个简单的multipart form。

3.3.1 在Struts里编写Form

一个完整的login页面有助于展示Struts如何用比直接的HTML和标准JSP方式更轻松的方式来处理form。考虑如下的页面（基于Struts附带的示例程序），名字是logon.jsp:

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



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

根据上面的例子，下面描述了Struts里form处理的关键特性:

taglib指令告诉JSP页面编译器如何去寻找关于Struts标签库的标签库描述。在这里，我们用bean作为表示struts-bean标签库的前缀代号，而"html"是struts-html的前缀代号。你可以用任何你希望使用的前缀。
这个页面使用了几个message 来从包含这个程序所有可用资源的MessageResources对象中查找国际化信息串。下列文本关键字必须在资源文件中定义，这个页面才能正常工作:
- logon.title - logon 页面的标题
- prompt.username - "Username:" 询问用户名的标签
- prompt.password - "Password:" 询问密码的标签
- button.submit - "Submit" "提交表单"的按钮的标签
- button.reset - "Reset" "重置"按钮的标签
当用户登录的时候，程序会在用户的session中保存一个Locale对象。这个Locale对象会被用来选择合适的语言信息。这样让用户自己选择语言会变得很容易——简单的改变这个保存的Locale对象，所有的文本都会自动切换。
错误标签显示任何保存在商业逻辑部件中的可能的错误信息，如果没有错误，那么就不显示。关于这个标签，下面会详细讨论。
根据指定的属性，form标签展开为一个HTML
元素。它也让所有在这个form内部的字段值被存放到一个session范围的FormBean中去，它在session中的关键字是logonForm。Struts开发者会给出关于这个form bean的Java实现，它是一个Struts类ActionForm的字类。这个bean用来给出所有的输入字段的初始值，只要字段名和bean的属性名一致。如果合适的bean没有找到，会自动用指定的Java类名字来创建一个新的。
这个formbean也需要在Struts配置文件中指明。这里名字和类型可以被省略。参阅"Action Mappings （动作映射）配置文件"得到详细信息。
Text标签展开成为HTML里的元素，它的类型是"text"。在这里，在浏览器中显示时占据多少个字符空间也被指明了。当这个页面被执行的时候，对应的bean的username属性的值会被作为初始值（就是getUsername()的返回值）。
password 标签用起来很简单。不同之处是当用户输入自己的密码时浏览器会显示星号而非用户输入值。.
submit和reset标签生成form中对应的按钮。其上的标签文字是用message 标签生成的，所以它们显示的是国际化的字符串。

处理multipart form也是很简单的。显而易见，当你编写一个multipart form的时候你创建的form中具有至少一个"file"类型的input输入框。编写一个multipart的form的第一步是使用struts-html标签库来创建显示页面：

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

  Please Input Text:
  

  Please Input The File You Wish to Upload:

下一步是创建你的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可以看到在文件上传时它提供的处理文件的方法。也要看Javadoc里面的ActionServlet 和ActionMapping的不同的参数，你可以指定它们来指明文件如何上传。基本上你在你的Action类的perform()方法中需要调用((UploadForm) form).getMyFile()得到你的文件并且做出你的处理。

3.3.2 支持的Input 字段的类型

下面列出了Struts定义的所有的input字段的类型，带有指向手册的连接。

checkboxes 选择框
hidden fields 隐藏字段
password 密码输入框
radio 单选框
reset 重置按钮
select 列出内值的选择条目（下拉选择框）
option备选条目
options备选条目
submit 提交按钮
text 单行文本输入框
textareas 多行文本输入框

在任何情况下，字段标签都必须内置在form标签中，这样这些字段才知道用哪个bean来得到初始值。

3.3.3 其它有用的表示层标签

有好几个有用的tag用来创建表示层，请查阅它们的标签库的文档和Tag Develipers Guide得到更多的信息：

[逻辑] iterate 枚举为一个列表中的所有元素重复输出标签。（这个列表可能是 Enumeration,Hashtable, Vector, 或者对象数组）。
[逻辑] present 存在根据一个指定的属性，这个tag在当前的request中检查，如果这个属性存在的话就显示它所包含的页面内容。每次使用这个标签的时候只能指定一个属性，名字是必需的。属性可以包括cookie, header,name,parameter,property,role,scopr还有user。
[逻辑] notPresent 不存在和present作用相反的标签，当指定的属性不存在的时候显示。
[html] link 连接创建一个 HTML元素，作为一个锚点或者指向指定URL的超链接，它会自动进行URL编码，以在不支持cookie的时候维护session状态。
[html] img 图像创建一个 HTML元素，它可以动态改变"src"和"lowurl"中指定的URL，和的方式相同。
[bean] parameter 参数获取特定的request 参数的值，把结果作为一个page范围的属性，类型是字符串或者字符串数组。

3.3.4 自动form检查

除了上文提到的form和bean之间的交互之外，Struts还提供了附加的机制来检查它接收到的输入字段。要使用这个特性，在你的ActionForm中重载下面的这个类:

public ActionErrors
  validate(ActionMapping mapping,
    HttpServletRequest request);

validate() 方法在bean的属性被自动填充之后，在对应的Action类的porform()方法调用之前由controller servlet自动调用。validate()方法有下面几个选择：

进行了恰当的检查，没有发现任何问题——返回null或者长度为零的ActionError实例，Controller servlet会继续调用对应的Action类的的perform()方法。
进行了恰当的检查，发现了问题。——返回一个包含ActionError的ActionErrors实例，它包含了应该显示错误信息的关键字（位于程序的MessageResources 信息资源库中的关键字）。controller servlet会把这个数组保存为request的属性，以便标签使用，并且流程会重新转回到输入form(通过ActionMapping的input属性得到）。

前面曾经提到过，这个特性完全是可选的。默认的validate()方法返回null,controller servelt会认为对应的Action类会做必要的检查。

另一个常用的方式是在ActionForm的validate()方法中进行简单的主要的检查，在Action里面做“商业逻辑”检查。

在夜间编译包和下列地址还有一个可选的ActionForm检查的包可以使用：David Winterfeldt的网站。

3.4 其他表示层技术

虽然你的程序的观感可以完全用标准的JSP和Struts的自定义标签库创建，你也许会考虑动用其他技术来增加部件重用，减少维护工作，并且/或者减少错误。下面几节讨论了几种可选项。

3.4.1 针对程序的自定义标签

除了Struts定义的自定义标签，你针对你正在编写的程序创建标签也很容易，这会帮助你编写用户界面。通过针对下面的程序编写tag,Struts附带的示例程序描绘了基本原理：

checkLogon - 检察是否存在一个特定的session对象，并且如果没有的话就转向到登录页面。这可以防止用户在使用你的程序到一半的时候，把页面用书签记录下来，试图以后跳过登录这一步。或者防止session失效。
linkSubscription - 生成一个指向明细页面的超连接，它传递需要的主键的值作为request属性。这在列出用户拥有的订阅纪录时有用，它提供了编辑或者删除订阅信息的链接。
linkUser - 生成一个指向用户详细信息页面的超链接，把需要的主键信息作为request属性传递。

这些tag的源代码都在src/example目录下，位于org.apache.struts.example包中，和其它在程序中需要的java类在一起。

3.4.2 用Include(引用)来组合页面

用一个JSP页面（包括子定义标签和Bean来取得必要的动态数据）在生成整个表现是一个很普通的方式，在Struts的示例程序中也出现过。然而，很多程序需要在同一个页面中显示多个不同的单一逻辑部分的组合。

举例，一个门户站点可能在门户的主页上有以下几个功能部分：

显示门户的搜索引擎
一个或多个"新闻"显示部分，根据用户登记的个性文件中的兴趣组合。
显示关于这个门户的讨论主题
一个“有邮件在等待”提示，如果你的门户提供免费邮件账户。

如果你能把工作分成不同的部分，为每个部分分配不同的开发者，开发工作会容易些。那么你需要用JavaServer Pages技术中的include(包含)能力，或者Struts提供的include 标签来把不同的页面结果组合到一起去。取决于你需要在什么时候组合你的输出，有三种不同的include可供选择:

一个 <%@ include file="xxxxx" %>指令可以包含一个包括Java代码或者JSP标记的页面。其中的代码甚至可以访问父页面之前定义的变量。在JavaServer Page编译之前，这段代码已经被包含了，所以它可以包含的不只是HTML代码。
include action(动作,这里指JSP中的标准指令)()在请求时被处理，服务器会透明的处理它。除此以外，这意味着你通过在一个类似equals这样使用参数的标签中编写这条请求，可以有条件的进行包含。
bean:include读取一个"forward"参数通过一个逻辑名字映射到一个被包含的jsp页面，或者读取"id"参数，打印一个页面上下文的字符串变量到jsp页面上。

另一个方法是使用Struts Template Tag library(模版标签库）。察看Developer's Guide得到详细信息。

Tiles是一个原来的Template Tag library的替代品，提供几处增强和新功能。Tiles位于夜间编译包，或者在Cedric Dumoulin的网站。

3.4.3 图像生成部件

有一些程序需要动态生成图像，比如价格图或者股票报告等等。一般有两种不同的方法满足这个需求：

显示一个指向servlet请求的超链接。这个servlet会使用一个图像库来渲染出图像，把输出改为合适的内容类型(比如image/gif),并送出图像的字节流到浏览器。浏览器会像一个静态图像一样显示它。
生成必要的HTML代码来下载一个Java applet来创建需要的图像。通过在生成的代码中传送初始化参数，你可以决定图像。或者applet也可以自行和server连结以取得这些参数。

3.4.4 生成文字

有些程序需要动态生成文本或者打包的文本，例如XML.如果整个页面都是被生成的，可以用PrintWriter输出，从Action里可以很容易的办到:

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

R.Zeus 2005-08-13 03:46 发表评论

4. 构造 Controller （控制器）部件

R.Zeus — Fri, 12 Aug 2005 19:17:00 GMT

4. 构造 Controller （控制器）部件

4.1 纵览

现在我们已经理解如何构造你的程序的Model(模型)和View(视图)部件，现在是时候来关注Controllder部件了。Struts包含一个主要功能是映射一个请求URI到一个Action类的servlet。因此，对于Controller你的主要责任是关于:

为每一个可能接收的逻辑请求编写一个Action类（扩展自org.apache.action.Action）。
为每一个可能提交的逻辑请求在XML中配置一个ActionMapping。这个XML配置文件通常命名为struts-config.xml。
更新你的web程序的部署描述文件（在XML里）来包含需要的Struts部件。
在你的程序里增加恰当的Struts部件。

4.2 Action 类

Action类提供了两个可以被继承的方法，适应你的servlet环境:

public ActionForward perform(ActionMapping mapping,
                             ActionForm form,
                             ServletRequest request,
                             ServletResponse response)
  throws IOException, ServletException;

public ActionForward perform(ActionMapping mapping,
                             ActionForm form,
                             HttpServletRequest request,
                             HttpServletResponse response)
  throws IOException, ServletException;

大部分工程可能只需要用到"HttpServletRequest"版本。

Action类的目标是通过它的perform()方法处理一个请求，返回一个ActinForward对象表明控制权应该被转移到哪里（例如一个JSP）作为合适的相应。在MVC/Model 2设计模式中，一个典型的Action类会在perform()中执行如下逻辑：

检查当前用户session的状态（比如，检查用户是否已经成功登录）。如果Action类发现尚未登录，请求可以被转移到一个JSP页面提示让用户输入用户名和密码。当用户试图访问一个程序的“中间部分”（可能是从一个书签）的时候，或者是session已经超时，servlet容器创建了一个新的session的时候者都可能发生。
如果检查还未完成的话，继续检查form bean的属性。如果发现了问题，把相应的错误的信息关键字放在request的属性里，然后把控制权重新转到输入页面来让用户改正。
进行请求需要的操作(比如在数据库中保存一行数据）。这可能由Action内部的逻辑代码自己来完成，但是一般应该调用一个商业逻辑bean的合适的方法。
更新服务器端的对象，来创建下一步用户面对的界面（典型的是request范围或者session范围的bean,取决于你需要这些条目保存多长时间）。
返回一个合适的ActionForward对象来挑选JSP页面根据刚刚更新的bean来生成回应。典型的，你需要通过你接收到的ActionMapping的findForward()方法或者从controller servlet自身（如果你使用一个全局的逻辑名字）来得到这样的一个引用。

在编写Action类代码时请记住以下几个设计要点：

Controller servlet只创建你的Action类的一个实例，用来对对付所有的请求。所以，你需要处理好你的代码，在一个多线程环境下你的Action应该运作良好，就象你编写一个servlet的service()方法一样。
最有助于编写线程安全的程序的原则是在你的Action类中只使用本地变量(local variable)，而非实例变量(instance variable)。本地变量在堆栈中创建并依附于每一个独立的请求线程（由你的JVM处理），所以你不用担心共享它们。
你系统中表示Model(模型)的bean由可能因为访问数据库或者其他资源而抛出异常。你应该在你的perform()逻辑中捕获所有的异常，把它们记录到程序的log文件中去（同时给出对应的stack trace)。可以这样做：
servlet.log("Error message text", exception);
作为一项基本的规则，分配稀少的资源并且为每一个用户在它们的session里分配一个会导致规模问题。你应该在把你的控制转移到View（视图）部件之前就释放它们（比如数据库连接）——就算你调用的bean的方法抛出了异常也要这样。

除此之外，你还需要警惕你的Action类们变得太大。出现这种情况最容易的可能就是把功能逻辑放在Action本身，而不是在独立的商业逻辑bean。除了让Action类变得难以阅读和维护，这种方法还会让重用商业逻辑变得困难，因为它们被嵌入在部件内部（那个Action类），从而被限制在一个web程序环境中运行。

只要需要的所有属性都是在方法签名中传递的（指的是通过函数调用传递？——译者注），一个Action可以被分散在几个本地方法中。JVM把这些属性在堆栈中处理，所以它们就是是线程安全的。

Struts附带的例子程序只是设计用于展示某些原理，因为它自己的商业逻辑是被嵌入在Action类中的。这应该被理解为设计中的某种bug，而非Struts体系本身的特性，或者应该被模仿的方法。

4.3 ActionMapping 的实现

为了能成功的操作，关于如何把每一个请求URI映射到恰当的Action类，Struts controller servlet需要知道几件事情。这些需要的知识被封装在一个叫做ActionMapping的Java接口中，下列是最重要的几个属性:

type - 在这个映射中Action实现的完整java类名。
name - 这个action会用到的form bean在配置文件中使用的名字
path - 请求的URL用以选择（触发）这个映射。下面会有关于匹配如何工作的例子。
unknown - 当无法找到合适的其他action来处理请求时，某个action可以被配置为默认处理这个请求，这时候把这一项置为true。一个程序中只能有一个action作为默认处理action。
validate - 如果这个映射中涉及的action需要在调用前先调用validate()方法，把这一项置为true。
forward - 当这个映射被调用的时候，转向一个请求URI。这是type属性的一个替代品。

4.4 Action Mappings 配置文件

controller servlet是如何知道你希望的映射的？写一个小java类来创建新的ActionMapping的实例，并且调用每一个setter方法来赋值是可行的，但是非常繁琐。为了简化这个步骤，Struts包含一个Digester模块，它能够读取一段基于XML的关于需要的映射的描述，并创建合适的对象。参阅API 文档得到关于Digester的更多信息。

开发者的责任是编写一个命名为struts-config.xml的XML文件，并把它放在你的程序的WEB-INF目录下。文档的格式由"struts-config_1_0.dtd"中的描述指定。最外层的XML元素必须是。

在元素之内，有两个重要的元素被用于描述你的action:
这一段包含你的form bean的定义。你为每一个form bean使用一个元素，包含下列属性：

name: 这个bean的一个唯一的标识名，它将会被用来在action映射中引用来指定这个bean.通常，这也是把这个对象存放在request或者session中的属性的关键字。
type: 你的form bean的完整的Java类名。

这一段包含你的action的定义。你为你的每一个需要定义的action使用一个元素。每一个action元素需要定义下列的属性：

path: 这个action的程序上下文相关的路径
type: 这个Action类的完整类名
name: Action中所用到的元素的名字

示例程序中的struts-config.xml文件包含了下列的映射元素，它们是用来实现“登录”功能的，我们用它来说明需求。注意其它的Action的条目都被剔除了：

首先定义的是form bean .一个基础的"org.apache.struts.example.LogonForm"类被映射为逻辑名"logonForm"。这个名字也被用在session或者request作为这个form bean的属性名。

"global-forwards"部分用来创建全局可用的逻辑名映射。这儿的任何一个转移都可以通过调用你的action mapping的实例实现，比如actionMappingInstace.findForward("logicalName")。

你可以看到，这个映射匹配/logon路径（实际上，因为实例程序用了后缀名映射，你指定的URI请求会是由/logon.do结尾的）。当收到一个匹配这个路径的请求时，会创建一个LogonAction的实例（仅当第一次），并且使用它。controller serverl会寻找一个session范围的名为logonForm的bean,如果需要的话，创建并保存这样的一个bean。

局部的"forward" 元素是可选的但是非常实用。在实例程序中，很多action包含一个局部的"success"和/或"failure"转移作为Action mapping的一部分。

只用了两个额外的属性，示例程序中的Action类变得几乎和页面设计者用的实际JSP页面的名字无关了。页面可以在重新设计的时候被改名（举个例子），只会给Action类带来微不足道的冲击。如果“下一个”JSP页面的名字是被硬编码在Action里面的话，所有的类就必须做出改动。当然，你可以决定在你的程序中使用怎样的局部转移属性。

另一个很有用的部分是，它定义了你的程序可以使用的数据源。下面是你如何在你的程序的struts-config.xml中指定一个基本的数据源：

关于如何获取这个数据源，参阅访问关系数据库这一节。

4.5 Web 程序发布描述

设置你的程序的最后一步是配置程序的发布描述（保存在WEB-INF/web.xml文件中）来包含所有需要的Struts部件。用示例程序中的发布描述作为一个指南，我们发现下列条目需要创建或者修改。

4.5.1 配置Action servlet实例

增加一个条目来定义action servlet自己，包含合适的初始化参数。这样的一个条目可能是这样的：


  action
  
    org.apache.struts.action.ActionServlet
  
  
    application
    
      org.apache.struts.example.ApplicationResources
    
  
  
    config
    
      /WEB-INF/struts-config.xml
    
  
  
    debug
    2
  
  
    mapping
    
      org.apache.struts.example.ApplicationMapping
    
  
  2

controller servlet支持的初始化参数如下所示。（你也可以在Javadocs中查找ActionServlet类得到详细信息。）方括号表示如果你没有给出初始值时使用的默认值。

application - 程序的资源包的基础类的Java类名。 [NONE]
bufferSize - 处理文件上传的输入缓冲区大小。[4096]
config - 指向包含我们的配置信息的XML资源的相对于上下文的路径。[/WEB-INF/struts-config.xml]
content - 默认输出响应的的文档类性和字符集编码。它可以被一个转移到的servlet或者JSP重载。[text/html]
debug - 这个servlet的debug信息详细程度，它控制多少信息应该被记录。[0]
detail - 我们在initMapping()中使用的Digester的debug信息详细程度，它输出到System.out而非servlet的log。[0]
factory - 用于创建程序的MessageResources对象的MessageResourcesFactory的类名。 [org.apache.struts.util.PropertyMessageResourcesFactory]
formBean - ActionFormBean继承的根的Java类名。[org.apache.struts.action.ActionFormBean].
forward - ActionForwarder继承的根的Java类名。 [org.apache.struts.action.ActionForward]. 两个你可能选择的类是： Two convenient classes you may wish to use are:
- org.apache.struts.action.ForwardingActionForward - org.apache.struts.action.ActionForward的子类，它的 redirect属性被默认置为false(和Actionforward 默认值一样）。
- org.apache.struts.action.RedirectingActionForward - org.apache.struts.action.ActionForward的子类，它的redirect属性被默认置为true。
locale - 如果被置为 true, 并且有一个用户session,如果没有Locale对象的话，放置一个合适的java.util.Locale object (用Action.LOCALE_KEY作为标识关键字)到用户session中去。[true]
mapping - ActionMapping继承的根的Java类名。[org.apache.struts.action.ActionMapping]. 两个你可能选择的类是：
- org.apache.struts.action.RequestActionMapping - org.apache.struts.action.ActionMapping 的子类，scope属性默认是"request"。
- org.apache.struts.action.SessionActionMapping - of org.apache.struts.action.ActionMapping 的子类，scope属性默认是"session"(和ActionMapping默认值一样）。
maxFileSize - 一次上传文件可能的最大大小（单位是字节）。可以在数字后面加上"K","M',或者"G", 代表千字节，兆字节和千兆字节。[250M]
multipartClass - 用于文件上传的MultipartRequestHandler 的实现的完整Java类名。[org.apache.struts.upload.DiskMultipartRequestHandler]
nocache - 如果设置为true, 在每一个响应中加上HTTP头信息来访置我们的任何响应或者转移被浏览器缓存。[false]
null - 如果设置为true, 如果（资源）信息的关键字无法找到，返回一个null。否则，返回一个带有此关键字的错误信息。[true]
tempDir - 文件上传时的临时目录。 [这个web程序的servlet上下文属性指定的工作目录]
validate - 我们是否适用性的配置文件格式？[true]
validating - 我们是否使用一个带有校验的XML 解释器来处理配置文件（强烈建议）？ [true]

4.5.2 配置Action Servlet 映射

注意： 这一段中的材料不是针对Struts的。配置servlet映射是在Java Servlet规格书中定义的。这一段描述了最普通的针对配置一个Struts程序的方法。

又两种一般的方法来配置一个URL成为被controller servlet处理的URL - 前缀匹配和后缀匹配。每种方法相应的配置条目会在下面描述。

前缀匹配意味着你希望所有的以某一个特定值开头的URL（在上下文路径部分之后）都被送往这个servlet。这样的条目可能是这样：

  
     action
     /execute/*

就是说前面我们提到过的匹配/logon的URI请求会被这样描述：

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

这里/myapplication是你的程序部署的上下文路径。

后缀匹配映射，相反，在URL以某一个特定的字符串结尾时把URI请求匹配到action servlet.举个例子，JSP处理servlet对应到*.jsp，这样，每当一个jsp页面被访问，它都会被调用进行处理。为了使用*.do后缀名（意思是“做什么”），映射条目可能是这样的：

  
     action
     *.do

前面我们提到过的匹配/logon的URI请求会被这样描述：

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

4.5.3 配置 Struts 标签库

下一步，你必须增加一个条目来定义Struts标签库。当前Struts打包了4个标签库。

struts-bean 标签库包含访问bean和它们的属性的有用的标签，也包含利用这些访问定义新的bean以便在页面剩下的部分用脚本中的变量和页面范围的属性来访问。还有用request coolie,header和parameter的值来创建bean的便利机制。

struts-html 标签库包含用户创建struts输入表单，还有其他通常很在创建基于HTML的用户界面上很有用的标签。

struts-logic 标签库包括用于有条件的生成输出代码，循环整个对象容器来输出重复的文本，还有程序流管理。

struts-template 标签库包含定义了一个模版机制的标签。

下面是在你的程序中如何定义所有这些标签。在实际工作中你可以只指定你的程序要用到的。


  
    /WEB-INF/struts-bean.tld
  
  
    /WEB-INF/struts-bean.tld
  


  
    /WEB-INF/struts-html.tld
  
  
    /WEB-INF/struts-html.tld
  


  
    /WEB-INF/struts-logic.tld
  
  
    /WEB-INF/struts-logic.tld
  


  
    /WEB-INF/struts-template.tld
  
  
    /WEB-INF/struts-template.tld

这告诉JSP系统到哪里去寻找标签库的定义（在你的程序的WEB-INF目录，而不是Internet上的某处）。

4.5.4 把Struts部件增加到你的程序中

为了使用Struts,你必须拷贝你需要的.tld文件到你的WEB-INF目录，并且拷贝struts.jar（和其它所有的commons-*.jar文件）到你的WEB-INF/lib目录。

R.Zeus 2005-08-13 03:17 发表评论

2. 构造Model（模型）部件

R.Zeus — Fri, 12 Aug 2005 18:18:00 GMT

2. 构造Model（模型）部件

2.1 纵览

很多用于构造web程序的需求文档都是关注于View(视图)的。但是，你需要确认每一个确定的请求需要的处理也是在Model(模型)层清楚的定义的。一般说来，Model(模型）的开发者会关注如何建立满足所有功能需求的JavaBean类。一个特定的程序所需要的明确定义的bean会有很大不同，取决于他们的需求。然而他们大致上可以被归为下面会讨论的几类。然而，先做一个关于“Scope范围”这个概念的简要的回顾会是很有用的。

2.2 JavaBeans 和 scope(范围)

在一个基于web的程序中，JavaBean可以被存放在（也是获取于)几个不同的“属性”集合。每一个集合有不同的关于集合的生存期和储存在其中的bean的可视范围的规则。定义生存期和可视范围的规则共同被称为这些bean的“scope(范围)”。JavaServer pages(JSP)的规格书定义了以下的术语(在servlet API中同样的也有这些定义）:

page - Bean在一个单一的JSP页面中可见，生存期是这个请求。（service()函数的本地变量）
request - Beans 在一个单一的JSP页面中可见，包括被包含在这个页面中或者被此页面转移到的任何页面或者servlet. (Request 属性)
session - Beans 在一个特定的用户session中的所有JSP页面和Servlet中可见，跨越一个或多个请求。(Session 属性)
application - Beans 在web 程序的所有的JSP页面和servlet中可见。 (Servlet context属性)

记住同一个web程序中的JSP页面和servlet共享同样的bean集合是很重要的。例如，如下的代码在一个servlet中把一个bean加入了request的属性:

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

马上在这个servlet转移到的JSP页面中可见,通过使用一个标准的动作tag,就像这样：

class="com.mycompany.MyApp.MyCart"/>

2.3 ActionForm Beans

注意:ActionForm Beans实际上更靠近View(视图)而非Model(模型)。

Struts框架一般会假设你已经为你程序中每一个需要输入的Form定义好了一个ActionFormBean(这是一个从ActionForm继承的一个类).ActionForm beans有时候就叫做"form beans"。如果你已经在你的ActionMapping配置文件里(参阅"构造Controller（控制器）部件")生命了这些bean, Struts Controller servlet在调用合适的Action方法之前会自动为你提供如下服务:

在用户的session里面察看在恰当的键值下是否有一个合适的类的实例。
如果没有这样的session范围的bean存在，会自动创建一个新的实例并加入到user的session中。
对每一个request 参数，如果能对应于(form) bean的一个同名属性，会调用相应的setter方法。这个操作很象标准的JSP动作,当你用'*'符号来选择所有的属性的时候。
更新过的ActionFormbean 会被传递到Action 类的perform()方法，（当这个方法被调用时）这些值马上就可以使用了。

当你编写你的 ActionForm bean的时候，记住这些基本的原则：

ActionForm类本身不需要实现具体的方法。它是用来为了明确特殊的bean在整个体系中的角色的。一般来说，一个ActionFormbean 只需要属性的getter和属性的setter方法，没有商业逻辑。
ActionForm 对象也提供了一个标准的检查机制。如果你重载了一个"stud"函数，并且在标准的程序资源里给出了错误信息，Struts会自动检查输入的值（使用你的方法）。参阅"Action Form 检查" 得到详细说明。当然，你可以忽略在ActionForm中的检查而在你的Action对象中自己进行。
为每一个form中出现的字段定义一个属性(附带相应的getXxx()和setXxx()方法)。字段的命名和属性的命名必须遵循通常的JavaBeans规范。举例来说，一个输入的字段名叫username会导致setUsername()方法被调用。
设想你的ActionForm bean是HTTP和Action之间的防火墙。用validate方法来保证所有需要的书形式存在的，并且包含合理的值。一个没有通过检查的ActionForm不会被送到Action去处理。
你也可以在你的form里面放置一个bean的实例，来使用内置的属性引用。比如，你可能在你的ActionForm上有一个“customer”bean,可以在你的JSP 中使用属性"customer.name"。这会对应到你的customer bean的customer.getName()和customer.setName()方法。参阅 tag Library Develiper Guides 得到更多关于内置属性语法的说明。
警告: 如果你在你的form上放置一个以存在的bean的实例，考虑它暴露出来的属性。任何public的，接受一个单一的字符串的属性可能被一个查询字符串重置。这些bean放在一个瘦的“包装者”类里面，只暴露需要的属性可能时有所帮助的。这个包装者也可以提供一次过滤来保证运行时的属性不被置为无意义的值。

你可能注意到了一个在这里讨论的"form"，并非必须是用户界面端一个单独的JSP页面。在很多程序里都会出现跨越多个页面的"form"(从使用者的角度来说）。想一下，举例来说，在安装新程序时经常会出现的向导风格的用户界面。Struts鼓励你定义一个单独的ActionForm包含所有可能用到的属性，不管到底是在那个页面显示的。同样的，同一个form的不同页面应该被提交到同样的Action类。如果你遵循这些建议，页面设计者可以重新在页面之间安排这些字段，通常不需要修改处理逻辑。

2.4 系统状态Beans

系统的实际状态一般会表现为一套包括一个或多个JavaBean类，它们的属性定义了当前的状态。一个购物车，举例来说，会包括为每一个购物者维护一个bean,并且会（和其他属性一起）包括一些购物者当前选择的物品条目。另外，系统也会包括不同的bean来保存用户的个人资料（包括他们的信用卡号码和送货地址），还有按照他们的购物等级所能得到的可购买物品清单。

对于一个小型的系统，或者对不需要长期保存状态信息的系统来说，一套系统状态bean可能已经保存了系统所需要的全部特定细节。否则，大多数情况下，系统状态bean会把它持有的信息包村到一个外部的数据库去（比如一个CustomerBean对象对应于CUSTOMERS表中的一个特定的行），并可以在服务器的内存中按照需要创建或者删除。Entity Enterprise JavaBeans 在大规模系统也是为了这个目的使用的。

2.5 商业逻辑 Beans

你应该把你的程序的功能逻辑封装在你为此设计的JavaBean的方法调用中。这些方法可能是同一个系统状态bean,或者他们分布在不同的类中，潜在的体现了逻辑。在后一种状况中，你往往需要把系统状态bean作为参数调用以便这些方法处理。

为了最大化代码重用，商业逻辑bean因为被设计和实现为假设它们不知道会在web环境下被执行。如果你发现你在你的bean中importjavax.servlet.*，你(就知道你在)在试图把这个商业逻辑bean放置在web环境中。请考虑重新编排，让你的Action类（属于controller角色的一部分，下文将会谈到）从HTTP请求翻译所有需要的信息，通过调用你的商业逻辑bean的setter方法预置，然后调用一个execute()方法来执行。这样的商业逻辑类可以在不是最初的Web的环境下重用。

取决于你的程序的复杂程度和范围(宽广程度)，商业逻辑bean可能是普通的JavaBeans(它们和作为参数传递的系统状态bean打交道),或者是通过JDBC调用存取数据库的一般的JavaBeans。对于大规模程序来说，它们往往是被有状态的或者无状态的Enterprise JavaBeans(EJBs)所取代。

2.6 访问关系数据库

Struts可以在它的标准配置文件中为程序定义datasource.也提供一个简单的JDBC连接池。参阅Action Mappings 配置文件和Utilities Developer Guide(工具开发指南)得到更详细的信息。

当datasource被定义号之后，下面是一个在Action的perform方法中取得连接的例子。

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();

   //do what you wish with myConnection
 } catch (SQLException sqle) {
   getServlet().log("Connection.process", sqle);
 } finally {

   //enclose this in a finally block to make
   //sure the connection is closed
   try {
     myConnection.close();
   } catch (SQLException e) {
     getServlet().log("Connection.close", e);
   }
 }
}

注意Struts 普通连接池是一个可选组件。很多Struts程序使用其它连接池来获取更高的性能，特别是大流量的生产系统。

R.Zeus 2005-08-13 02:18 发表评论

struts study blog

R.Zeus — Wed, 03 Aug 2005 20:07:00 GMT

1。 type="com.yourcompany.struts.DemoAction" name="DemoForm"
scope="request" input="/index.jsp" />

一个DemoForm(继承 ActionForm)对应一个DemoAction（ extends Action）必须实现 execute
(ActionMapping mapping,ActionForm form,
HttpServletRequest request,
HttpServletResponse response)

里面的ActionForm form对应DemoForm；

2。DemoForm里面的validate(ActionMapping mapping,HttpServletRequest request)验证；

不通过转向 input="/index.jsp" /；

否则由 type="com.yourcompany.struts.DemoAction" 验证！

3。
user:

name="UserForm" scope="request" input="/failedIn.do" />

html:form对应action="/user.do">对应UserForm"

property对应UserForm"里的属性！

还可添加reset(ActionMapping mapiping,HttpServletRequest request)

logic:present:

判断userbean是否存在！存在则显示后面的内容！

5 web.xml
tomcat 启动时加载,servlet类，类中对象保存在httpcontext中，即application范围内，所有组件可共享。

1这句话不能缺少！！！！！！！！！！！

6. "/>

前一句多了个空格，导致严重错误！！！！！！！！！！！

7.DynaActionForm f = (DynaActionForm) form;
String[] s = (String[]) f.getMap().get("results");
注意getMap部分

R.Zeus 2005-08-04 04:07 发表评论

Eclipse3.0.1+Myeclipse3.8.2+tomcat5开发第一个struts应用（配置篇)

R.Zeus — Wed, 03 Aug 2005 20:06:00 GMT

最近刚刚进入STRUTS大门，学习了《STRUTS IN ACTION》，写了几个小程序，感觉必须选一个IDE来
省点力气。去GOOGLE了一下，发现很多人使用Eclipse+Easystruts插件+Tomcat插件来开发，立刻去
下了所有的程序，找了一些文章来指导配置，但用尽力气，使用了所有可能的方法都没有成功，可以
识别LOMBOZ和TOMCAT但无法识别Easystruts插件，但是在Eclipse的HELP--About Eclipse Platform
--Plug-in Details里面却有Easystruts插件，无奈！最后在网上继续找了下，发现有些人说Eclipse3.0.1
支持LOMBOZ但不能支持Easystruts（不知道真实性怎么样~），还是算了，换个方法吧。
于是我选择Eclipse3.0.1+Myeclipse3.8.2+tomcat5来开发struts，这个配置就简单多了，哈哈。

一.下载
我的环境是
JDK1.4.2
TOMCAT5.0.28
Eclipse3.0.1
Myeclipse3.8.2

二.安装
Eclipse3.0.1+Myeclipse3.8.2的安装就不多说了，很简单。
主要的Myeclipse3.8.2的破解
我在网上找到了Myeclipse3.8.2的破解程序
这是我的私人空间，我已经把破解程序上传了，方便大家。
地址是：
下完后解压到
MyEclipse\eclipse\plugins\com.genuitec.eclipse.core_3.8.2
覆盖原来的文件，
然后启动MyEclipse
填入MyEclipse3.6.4的注册信息（程序里面有，网上也很多！），就可以了。

三.基础配置

破解文件覆盖后，启动MyEclipse
进入Window--->Perferences--->MyEclipse---->Subscription输入注册信息。
然后在Window--->Perferences--->Java--->Installed JREs添加你的jdk路径
在你需要默认的jdk路径前打勾。
最后设置tomcat服务器
Window--->Perferences--->MyEclipse---->Application Servers--->tomcat5
使得tomcat server Enable
然后选择tomcat Home，还要add JDK，选你刚才在java里面设置的jdk，然后要记得apply！

这样你的环境就配置好了！

请看下篇实战篇，初学者愚见，请大侠们指点.写这些的目的是想和其他初学者一起进步

R.Zeus 2005-08-04 04:06 发表评论