So , along comes Struts 2. Be careful - it’s good , but a different beast under the covers from Struts 1. It does a lot of things better - for example , the way it has Actions as normal POJO’s makes it a lot of things easier to unit test.

Struts 2 also gives you Ajax ‘out of the box’. No writing of javascript, no debugging against various browsers; just configure and go. A full description of how to setup Struts 2 to use Ajax is in this wiki article. The quick version is:

1. Setup Struts 2
2. Add the Struts-Ajax URL and Div Tag.

That’s it. Ajax without the fuss.

Even better that the Struts guys have implemented the Ajax functionality using the Prototype Ajax Library, so you get the benefit of all the improvements there.

What do you think? Will you move to Struts 2 just for the new Ajax capabilities?

These days enterprise Java could almost put you to sleep. How many hundreds of J2EE-EJB web applications have been written that capture information from a web page and store it in a database? What really keeps developers awake at night is trying to write and maintain the complex business logic in their applications. This is a problem not only for new applications, but increasingly, for long-lived, business-critical apps whose internal logic needs to change frequently, often at very short notice.

In an earlier article, "Give Your Business Logic a Framework with Drools," I introduced the Drools framework and showed how it could be used to organize complicated business logic. Drools replaced many tangled if ... then statements with a simple set of things known to be true. If you are ever in a meeting with business customers, and your head hurts with the complexity of what they want you to implement, then maybe you should consider a rule engine such as Drools. This article will show you how you can do this in an enterprise Java application.

Frameworks All the Way Down

Most enterprise Java developers already have their favorite frameworks. In no particular order, these include presentation frameworks (Struts, JSF, Cocoon, and Spring), persistence frameworks (JDO, Hibernate, Cayenne, and Entity Beans) and structural frameworks (EJB, Spring again, Pico, and Excalibur), as well as many others. Each framework does one very useful thing (or more), and gives developers a lot of instant "out of the box" functionality. Deploying an application using frameworks means you avoid a lot of the boring bits and concentrate on what is really needed.

Until now, there was a gap in what the frameworks were able to do, in that business logic had no framework. Tools like EJB and Spring are good, but have little to say about how to organize your if ... then statements! Adding Drools to your developer toolbox means that it is now possible to build an application with "frameworks all the way down." Figure 1 shows a diagram of such an application.

Figure 1. Frameworks for Java applications

This article will build on what we already know of the Drools framework and allow us to build such an application.

When Should I Use a Rule Engine?

It's almost a cliche in software engineering to say that "if you have a hammer, everything looks like a nail." While rule engines can solve a lot of problems for us, it is worth considering whether a rule engine is really appropriate for our enterprise Java application. Some questions to ask are:

• How complex is my application? For applications that shuffle data to and from a database, but not much more, it is probably best not to use a rule engine. However, where there is even a moderate amount of processing implemented in Java, it is worthwhile to consider the use of Drools. This is because most applications develop complexity over time, and Drools will let you cope easily with this.
• What is the lifetime of my application? The answer to this is often "surprisingly long"--remember the mainframe programmers who thought their applications wouldn't be around for the year 2000? Using a rule engine pays off, especially in the medium to long term. As this article demonstrates, even prototypes can benefit from the combination of Drools and agile methods to take the "prototype" into production.
• Will my application need to change? The only sure thing about your requirements is that they will change, either during or just after development. Drools helps you cope with this by specifying the business rule in one or more easy-to-configure XML files.

What About Performance?

If you're writing an enterprise application, chances are that it will need to scale to hundreds, if not thousands, of users. You know that existing Java and J2EE applications can do this, but how will a application using Drools cope with this pressure? The answer is "surprisingly well." While most developers hate to "lose control" and rely on other people's code (i.e., a framework), consider the points below--not only should your application be as fast as "traditional" coding methods, but Drools may even make your application run faster:

• Avoids badly written code: Drools guides developers to do "the right thing." You may be sure the code you are writing is good, but would you say the same for the code of your co-developers? Using a framework makes it easier to write good, fast code.
• Optimized framework: How often have you seen business logic that repeatedly accesses a database for the same information, slowing down the entire application? Used correctly, Drools can remember not only the information, but also the results of previous tests using this information, giving the entire application a speed boost.
• Rete algorithm: Many times we apply "if" conditions that we didn't really need. The Rete algorithm, as implemented by Drools, replaces all of the if ... then statements with an optimized network. It is important to note that the Rete algorithm involves a tradeoff between using more memory to reduce delays at run time. While this isn't a factor in most modern servers, we wouldn't yet recommend deploying Drools on your mobile phone!

Where Were We?

• Some sort of user interface, ideally based one of the standard web-presentation frameworks.
• A Data Access Object (DAO) to let Drools work with a database (or other back end system).

Calling the Rule Engine from a Presentation Framework

Most enterprise Java applications are accessed using a web interface, and one of the most widely adopted web-presentation frameworks is Struts, from Apache. Ideally, we'll write our application so that the presentation layer knows about the business layer underneath, but not the other way around. This has the advantage not only of allowing us to change the presentation framework at a later date (e.g., to an Ajax or web service interface), but also means the code examples give should be readily applicable to other web frameworks like Spring.

The following code snippet demonstrates how to call the business logic tier (using the rule engine) from the web presentation layer. The code uses the results to decide which page to display. In this sample, we use a Struts action, but the code is similar for any other web framework or even a servlet or a JSP page. This snippet works with a supporting struts-config.xml, JSP pages to post/display data, and a way of generating the WAR file for deployment. The snippet shows how to integrate the rule engine with the web framework.

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import BusinessLayer;
/**
* Sample Struts action with Pseudocode
*/
public class SampleStrutsAction extends Action{
/**
* Standard Struts doPerfom method
*/
public ActionForward doPerform(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws InvalidEntryPointException {
//Local Variables
StockOffer userOffer =null;
//Get any previous values from the session
userOffer=(StockOffer)request.getSession()
.getAttribute("PREVIOUS_STOCK_OFFER");
//create this object if it is null
if (null==userOffer){
userOffer = new StockOffer();
}
//Update with the incoming values
//These values match those on the form
userOffer.setStockName(request.
getParameterValue("STOCK_NAME"));
userOffer.setStockPrice(request
.getParameterValue("STOCK_PRICE"));
userOffer.setStockQuantity(request
.getParameterValue("STOCK_QTY"));
//Reset the output value
userOffer.setRecommendPurchase(null);
//Call the Business Layer
BusinessLayer
.evaluateStockPurchase(userOffer);
//Forward to the appropriate page
if ("YES".equals(
testOffer.getRecommendPurchase()){
return mapping.findForward("YES_WEB_PAGE");
}
//otherwise default to the no page
return mapping.findForward("NO_WEB_PAGE");
}
}

There are a couple of things going on this sample. Often, we build up the data we need from the user over several web pages, so this sample shows how we can achieve this by retrieving the StockOffer object that we have previously stored in the web server session. Next, we update the StockOffer with any values that the user may have changed on the web page. We then reset the recommendPurchase flag to clear any previous results before we call the business logic layer. Finally, we take the response of the business logic and use it to decide which page to forward the user to.

In this example, note how we split the business logic (yes/no on whether or not to buy a stock) from the presentation logic (decide which page to go to). This allows us to reuse our business rules across several different applications In addition, take look at how the state information (i.e., things that the user has already told us) is stored in the StockOffer object/web server session, and not in the business layer. By keeping the business layer stateless in this way, we make the entire application much more scalable and performant.

Integrating the Rule Engine with the Database Layer

So far, our application has a web presentation layer and a rules engine for the business layer, but no means of getting data to and from a database. This section gives an example of how to do this. We base our example on the Data Access Object (DAO) pattern, where we encapsulate all code that "talks" to the database (or back-end data source) in one pluggable, configurable class. As such, the example is applicable to other persistence frameworks, such as Hibernate and Cayenne.

Some important points about the way we want to organize the data layer are:

• Only the business layer should talk to the data layer; if a class in the presentation layer (front end) wants some data, it should pass through the business layer first. This helps makes our code easier to organize and read.
• As far as possible, we should keep our data layer stateless--we should hold client data elsewhere (e.g., in the server session at the web front end, as per the previous example). This is distinct from caching of data, which we can do at this level. The difference between the two is state information is often user-specific, while data we cache at the data access layer is mainly sharable across the application. Organizing our layer in this way increases performance.
• We should allow the business logic to decide if data is needed or not--if not needed, the call to get the data should not be made.

To implement our simple Data Access Object, we create three new objects: StockNameDao, DaoImplementation, and DaoFactory.

StockNameDao is an interface that defines two methods: getStockNames() returns a list of the stock names that we deal with, and isOnStockList() checks that a given stock is on the list of stocks that we deal with. Our business layer will call these methods as and when it needs the information.

DaoImplementation is an actual implementation of StockNameDao. In this case the values are hard-coded, but we could have queried a database or accessed an information system like Bloomberg via a web service.

DaoFactory is what we use to create an appropriate instance of StockNameDao. The advantage this approach has over creating the class directly is that it allows us to configure what DAO implementation we use at runtime (frameworks like Spring are especially good at this). One factory can return many types of DAOs (e.g., StockNameDao, StockPriceDao, StockHistoryDao), which means we can pass in our DaoFactory, and let the individual rules decide on the data and DAOs that they require.

Here's what the StockNameDao interface looks like:

/**
* Defines a Data Access Object - a non data
* source specific way of obtaining data.
*/
public interface StockNameDao {
/**
* Get a list of stock names for the application
* @return String[] array of stock names
*/
public String [] getStockNames();
/**
* Check if our stock is on the list
* @param stockName
* @return
*/
public boolean isOnStockList(String stockName);
}

And here's the DaoImplementation:

/**
* Concrete Definition of a Data Access Object
*/
public class DaoImplementation
implements StockNameDao {
/**
* Constructor with package level access only
* to encourage use of factory method
*
*/
DaoImplementation(){}
/**
* Get a list of stock names for the app.
* This is a hard coded sample
* normally we would get this from
* a database or other datasource.
* @return String[] array of stock names
*/
public String[] getStockNames() {
String[] stockNames=
{"XYZ","ABC","MEGACORP","SOMEOTHERCOMPANY"};
return stockNames;
}
/**
* Check if our stock is on the list
* @param stockName
* @return true / false as appropriate
*/
public boolean isOnStockList(String stockName){
//Get our list of stocks
String stockList[] = getStockNames();
//Loop and see if our stock is on it
// done this way for clarity . not speed!
for (int a=0; a<stockList.length;a++){
if(stockList[a].equals(stockName)){
return true;
}
}
//Default return value
return false;
}
}

The simple DaoFactory just returns a DaoImplementation:

package net.firstpartners.rp;
/**
* Factory Method to get the Data Access Object.
* Normally we could replace this with a
* framework like Spring or Hibernate
*/
public class DaoFactory {
/**
* Get the stock name Dao
* This sample is hardcoded - in reality
* we would make this configurable / cache
* instances of the Dao as appropriate
* @return an instance of StockNameDao
*/
public static StockNameDao getStockDao(){
return new DaoImplementation();
}
}

Now that we have our simple DAO implementation to serve as our database layer, how do we integrate it with the Drools business layer? The updated business rules file, BusinessLayer.xml, shows us how.

<?xml version="1.0"?>
<rule-set name="BusinessRulesSample"
xmlns="http://drools.org/rules"
xmlns:java="http://drools.org/semantics/java"
xmlns:xs="
http://www.w3.org/2001/XMLSchema-instance"
xs:schemaLocation="
http://drools.org/rules rules.xsd
http://drools.org/semantics/java java.xsd">
<!-- Import the Java Objects that
we refer to in our rules -->
<java:import>
java.lang.Object
</java:import>
<java:import>
java.lang.String
</java:import>
<java:import>
net.firstpartners.rp.StockOffer
</java:import>
<java:import>
net.firstpartners.rp.DaoFactory
</java:import>
<java:import>
net.firstpartners.rp.StockNameDao
</java:import>
<!-- Application Data not associated -->
<!-- with any particular rule -->
<!-- In this case it's our factory -->
<!-- object which gives us back -->
<!-- a handle to whatever Dao (Data -->
<!-- access object) that we need -->
<application-data
identifier="daoFactory">DaoFactory
</application-data>
<!-- A Java (Utility) function -->
<! we reference in our rules -->
<java:functions>
public void printStock(
net.firstpartners.rp.StockOffer stock)
{
System.out.println(
"Name:"+stock.getStockName()
+" Price: "+stock.getStockPrice()
+" BUY:"+stock.getRecommendPurchase());
}
</java:functions>
<!-- Check for XYZ Corp-->
<rule name="XYZCorp" salience="-1">
<!-- Parameters we can pass into-->
<!-- the business rule -->
<parameter identifier="stockOffer">
<class>StockOffer</class>
</parameter">
<!-- Conditions that must be met for -->
<!-- business rule to fire -->
<java:condition>
stockOffer.getStockName().equals("XYZ")
</java:condition>
<java:condition>
stockOffer.getRecommendPurchase() == null
</java:condition>
<java:condition>
stockOffer.getStockPrice() > 10
</java:condition>
<!-- What happens when the business -->
<!-- rule is activated -->
<java:consequence>
stockOffer.setRecommendPurchase(
StockOffer.NO);
printStock(stockOffer);
</java:consequence>
</rule>
<!-- Ensure that negative prices -->
<!-- are not accepted -->
<rule name="Stock Price Not Negative">
<!-- Parameters we can pass into the -->
<!-- business rule -->
<parameter identifier="stockOffer">
<class>StockOffer</class>
</parameter>
<!-- Conditions for rule to fire -->
<java:condition>
stockOffer.getStockPrice() < 0
</java:condition>
<!--When rule is activated then ... -->
<java:consequence>
stockOffer.setRecommendPurchase
(StockOffer.NO);
printStock(stockOffer);
</java:consequence>
</rule>
<!-- Check for Negative Prices-->
<rule name="Stock Price Low Enough">
<!-- Parameters for the rule -->
<parameter identifier="stockOffer">
<class>StockOffer</class>
</parameter>
<!-- Now uses Dao to get stock list -->
<java:condition>
daoFactory.getStockDao().isOnStockList(
stockOffer.getStockName())
</java:condition>
<java:condition>
stockOffer.getRecommendPurchase() == null
</java:condition>
<java:condition>
stockOffer.getStockPrice() < 100
</java:condition>
<!-- When rule is activated do this -->
<java:consequence>
stockOffer.setRecommendPurchase(
StockOffer.YES);
printStock(stockOffer);
</java:consequence>
</rule>
</rule-set>

There are several changes to this file to integrate the data access layer with our business rules:

• At the top of the file, we have several new <java:import> statements to reference the StockNameDao, DaoImplementation, and DaoFactory classes that we added to the system.
• We have a new tag, <application-data>, which assigns an instance of the DaoFactory class to a variable. <application-data> tags are similar to parameters, except they apply to all business rules, and not just one.
• The Stock Price Low Enough rule has a new condition, which uses the DaoFactory and StockNameDao to check if the stock is on the list of those that we deal with.

We run our BusinessRulesTest (simulator) again. The simulator/unit tests run OK, since even though we have changed the structure of the program, we haven't (yet) changed what it does. From looking at the output logs, we can see that our business rules are using StockNameDao as part of their evaluations, and that DaoImplementation.isOnStockList() is being called.

While this example shows the reading of information from a data source, the principles are the same for writing information, if that is what a rule has decided should be done. The differences would be that our DAO would have a setSomeInformation() method, and that the method would be called in the <java:consequence> part of the business rule, once the specific conditions had been met.

Summary

In this article, we showed that most Java server applications have three tiers: presentation, business logic, and data persistence. While the use of frameworks is widely accepted in the presentation and persistence layers, until now no framework has been available to encapsulate low-level business logic. As we've seen in the examples, Drools and JSR-94 are ideal candidates for reducing the complexity and speeding the development of Java applications. I hope that these examples inspire you to take a closer look at rule engines, and that they save many hours of development and maintenance time in your applications.

Resources

• Sample code for this article
• Drools Project home page
• Information on Drools rules
• "Introduction to Drools and Rule Engines," by the Drools project lead.
• Drools rules schema files
• JSR-94: Java Rule Engines, Overview
• Struts framework website
• Spring framework website
• Hibernate website
• JUnit test framework
• Jess Java rule engine
• Jena semantic and rule engine
• JSR-94 home page
• Jess in Action home page
• "Business Rule Thinking" (Jess-based)
• General introduction to rule systems
• "Jess implementation of the Rete algorithm"

Paul Browne , based in Dublin, Ireland, has been consulting in enterprise Java with FirstPartners.net for almost seven years.

http://hi.baidu.com/ofbase/blog/item/9acf45d05989f88ea1ec9c11.html

Added by Mark Webb, last edited by Trustin Lee on Apr 16, 2007    (view change)

1    简介

建立一个基于MINA的时间服务器，下面的内容需要先准备好。

MINA 1.1 Core
JDK 1.5 or greater
SLF4J    1.3.0 or greater
>>Log4J 1.2 users: slf4j-api.jar, slf4j-log4j12.jar, and Log4J    1.2.x
>>Log4J 1.3 users: slf4j-api.jar, slf4j-log4j13.jar, and Log4J    1.3.x
>>java.util.logging users: slf4j-api.jar and slf4j-jdk14.jar

这个程序只测试了Windows2000pro和Linux系统，并且在做的时候没有依赖于一些开发平台的环境。

2    编写MINA时间服务

下面先建立一个文件MinaTimeServer.java，代码如下：

public class MinaTimeServer {
    public static void main(String[] args) {
      // code will go here next
    }
}

下面会慢慢将这个类写完，这里先定义一个main用于启动程序。这一步结束后，还需要一个监听连接的对象，因为这个程序是基于TCP/IP的，这里将增加一个SocketAcceptor。

import org.apache.mina.common.IoAcceptor;
import org.apache.mina.transport.socket.nio.SocketAcceptor;

public class MinaTimeServer {
    public static void main(String[] args) {
      // The following two lines change the default buffer type to 'heap',
      // which yields better performance.
      ByteBuffer.setUseDirectBuffers(false);
      ByteBuffer.setAllocator(new SimpleByteBufferAllocator());
      IoAcceptor acceptor = new SocketAcceptor();
    }
}

通过这里的SocketAcceptor类，下面将把它绑定到一个端口上，如果你想增加一个线程模型到该类的话，参考"配置线程模型"部分。

import java.io.IOException;
import java.net.InetSocketAddress;
import org.apache.mina.common.IoAcceptor;
import org.apache.mina.transport.socket.nio.SocketAcceptor;

public class MinaTimeServer {
    private static final int PORT = 9123;

    public static void main(String[] args) throws IOException {
      ByteBuffer.setUseDirectBuffers(false);
      ByteBuffer.setAllocator(new SimpleByteBufferAllocator());

      IoAcceptor acceptor = new SocketAcceptor();

      SocketAcceptorConfig cfg = new SocketAcceptorConfig();
      cfg.getSessionConfig().setReuseAddress( true );
      cfg.getFilterChain().addLast( "logger", new LoggingFilter() );
      cfg.getFilterChain().addLast( "codec", new ProtocolCodecFilter(
                          new TextLineCodecFactory( Charset.forName( "UTF-8" ))));

      acceptor.bind( new InetSocketAddress(PORT), new TimeServerHandler(), cfg);
      System.out.println("MINA Time server started.");
    }
}

这里定义了一个整型的端口变量，呼叫SocketAcceptor.bind(SocketAddress,IoHandler,cfg)，第一个参数是要监听的网址，是本地的9123端口。

第二个参数传的是实现IoHandler接口的类，是服务于所有的客户端请求的。在这里，将会扩展IoHandlerAdapter类，这类遵循"适配器设计模式"的。

第三个参数是配置对象，用于配置日志和编码过滤器。每一个信息都会通过在IoAcceptor中定义的过滤器链的所有过滤器。在这风景点，将会将信息通过日志和编码过滤器。日志过滤器用SL4J库记录信息，而编码过滤器则反编码所有收到的信息，并且将所有TextLineCodecFactory发送的信息进行编码。

下面就是TimeServerHandler类的代码：

import java.util.Date;
import org.apache.mina.common.IoHandlerAdapter;
import org.apache.mina.common.IoSession;

public class TimeServerHandler extends IoHandlerAdapter {

    public void exceptionCaught(IoSession session, Throwable t) throws Exception {
      t.printStackTrace();
      session.close();
    }

    public void messageReceived(IoSession session, Object msg) throws Exception {
      String str = msg.toString();
      if( str.trim().equalsIgnoreCase("quit") ) {
        session.close();
        return;
      }
      Date date = new Date();
      session.write( date.toString() );
      System.out.println("Message written...");
    }

    public void sessionCreated(IoSession session) throws Exception {
      System.out.println("Session created...");
      if( session.getTransportType() == TransportType.SOCKET )
        ((SocketSessionConfig) session.getConfig() ).setReceiveBufferSize( 2048 );
      session.setIdleTime( IdleStatus.BOTH_IDLE, 10 );
    }
}

这里用于管理信息，覆盖了exceptionCaught，messageReceived和sessionCreated方法，如前所示，该类扩展了IoHandlerAdapter。

exceptionCaught方法将会打印错误并且关闭对话，对于大多数的情况来讲，这是标准的处理方法，除非能从异常中恢复过来。

messageReceived方法将收到从客户端发来的数据，并且写回当前时间。如果收到了"quit"，对话将被关闭。该方法将当前时间发往客户端，依赖于你使用的协议编码，发送至方法的对象（第二个参数）会有不同，发送到session.write(Object)方法的对象类同。如果你没有指定协议编码，则一般会收到ByteBuffer对象，而发送的也要是ByteBuffer对象。

sessionCreated方法用于对话初始化，在这里，先打印一条信息，然后判断对话的类型，再设置缓冲大小，这里设置的是2048个字节。空闲时间设置为10秒，如果覆盖了sessionIdle方法，则该方法每10秒被呼叫一次。

3    测试

到这里，编译程序。如果成功，那么运行，然后telnet这个程序，如下所示：

客户端内容：
user@myhost:~> telnet 127.0.0.1 9123
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
hello
Mon Apr 09 23:42:55 EDT 2007
quit
Connection closed by foreign host.
user@myhost:~>

服务端内容：
MINA Time server started.
Session created...
Message written...

4 参考文档

    Apache MINA Quick Start Guide http://mina.apache.org/documentation.html

      Added by Mark Webb, last edited by Trustin Lee on Apr 16, 2007    (view change)

http://mywicket.group.javaeye.com/group/blog_post/259300

一、概貌

Wicket是基于web应用框架的高级组件，其主要特点：

    * 在HTML和java之间的明确分隔

    * OO组件模式

    * 自动状态管理

    * 高度生产化

    * 低学习投入

    * 屏蔽Servlet API、HTTP协议细节

    * 无需XML配置文件

    * 易于构造可重用组件

Struts是以Model2 MVC 为蓝本构建的web应用框架。其工作围绕着处理HTTP请求的action类来完成。配置方式采用XML文件。

下文将对Wicket和Struts在体系、HTTP请求处理、Servlet API和HTTP协议抽取、状态管理、配置这六方面进行比较。

二、比较第一方面：体系

Struts体系基于解释每个HTTP请求并将其定向到某个处理该类型请求的指定Action类。每个Action类将处理后的结果返回，并决定下一步走向——通过转发或者重定向到另一个Action或者将控制权交给输出HTML的JSP页面。从技术较大来讲，虽然每个部分之间做到了很好的解耦，但是基于HTTP请求的处理模式可谓与时代不符（与wicket相比就是过时了）。两大原因如下：

    * Struts并不是真正意义上的纯粹面向对象，每个Action类定义了一个abstraction（抽取），但是abstraction是由HTTP协议的请求机制决定的，而并非面向对象的分析。

    * 除非我们在java代码中直接输出HTML（当然除非我们疯了），那么为了输出HTML我们就要学习另外的主流技术，比如JSP和自定义tag。使用在JSP中使用tag并非易事，尤其是当我们把这项工作交给美工小组时，这会直接导致两个结果：JSP代码被他人作的一沓糊涂，或者是我们自己完成这项任务。

而Wicket的处理方式则不同，从整体来讲应该说是更加优雅些。它采用面向对象的组件技术实现web与用户的交互（这点有些如Swing）。在Wicket中的每一页是由若干的使用组合设计模板生成的组件构成。页面和组件各自渲染自己，并直接或者间接的与markup文件（标识文件，形式就像JSP）关联。当HTTP请求到来时，这些请求被转换、传递到组件上的相应事件中来，这一点与微软的VS很相象。所以Wicket能够解决struts体系中存在的问题：

    * Wicket是完全面向对象的。我们可以利用组件的继承性设计自己的应用。这里不需要为处理HTTP协议的请求/响应而作任何工作。

    * Wicket所使用的markup文件与纯粹的HTML很接近，所以容易上手使用。Wicket在markup文件中所引入的内容非常整洁，并符合XHTML标准。任何了解HTML的开发者都可以如编辑HTML文件那样编辑Wicket的markup文件，就好似他并不知道这是Wicket的markup文件一样。

三、HTTP请求处理

在Struts中，一个HTTP请求被接收后，Struts将在配置文件中查找request path和相应的Action类。如果这些已经被配置好了，它将将提取请求参数放入到ActionForm bean中，并执行一些验证。然后HTTP请求、回应和ActionForm对象都将作为参数传入到Action类中。从这点可以看出Action的开发者掌握着应用的方方面面：他们必须处理HTTP session，维护HTTP请求和session的属性，并在action执行完时建立需要返回的信息，最后还要返回相应的ActionForward以使struts知道下一步在哪里。假如此时ActionForward将控制权交给了JSP页面，开发者就要使用struts自定义的tag库编写JSP代码。如此繁复的工作环节很容易出现错误，而且struts还需要三个位置保持一致：struts XML配置文件、java Action类、JSP自定义tag。

而在Wicket中，一个HTTP请求被接收后，Wicket将确认HTTP所请求的那个页面和在这个页面关联的组件。如果请求的目的是form，Wicket将自动提取请求参数、验证参数、进行一些预先规定好的类型转换、设置form组件中的model（模式，这里用法与MVC中类似，但有不同）值；接着转化请求为相应类型的事件、调用目标组件上的相应事件侦听器，这样就会导致事件处理代码运行来执行业务逻辑；然后，事件处理器还将指定下一步页面的位置，被指定的页面将初始化（如果页面从未被初始化的话）并自动渲染；渲染处理将按照顺序访问每个页面组件，要求它们进行自我渲染。在markup文件中能够组件仅通过名字与HTML元素进行映射。

Wicket出色的原因：

    * 每个组件知道如何处理自己事件。因此我们只需要将组件放到页面上，编写事件处理器就行了。如果一个页面中存在20个能引发事件的不同的组件，我们除了进行将它们添加到页面上的工作外没有别的工作。但如果在struts中，我们可能需要建立20个不同的Action类或者一个具有20个分支语句的Action类，并要在XML配置中逐一添加。

    * Wicket带给了我们考虑组件/事件重用的机会。而不用将注意力放到如何处理HTTP请求和回应上。

    * 与struts相比使用Wicket会降低我们的代码量，这正是重用组件带来的益处。Wicket本身不使用任何的XML配置文件。只需要修改web容器的web.xml文件中的servlet声明部分。

假如我们曾经编写过Windows API、并用过Visual Basic或者Borland Delphi的话，下面的比较会更加让人印象深刻。使用struts开发就像使用Windows API一样：接收原始消息，解码原始消息，然后再处理这些消息。由于Windows API是基于消息循环工作的，所以系统除了消息回应外不期望任何的返回值。

从另一方面看，Dephi在TApplication类中隐藏了Windows消息循环，使开发人员围绕着TApplication类建立其他的类。原始的系统消息就这样被Dephi内建类接收，被内建类解析并被确定其接纳者。消息被转换为一个事件，并被传送到某个特定的对象。

如Windows应用程序一样，Wicket应用也具有服务于文本和HTML模板的资源文件。从这点看，Wicket象用Delphi做桌面开发一样被用来做web开发。

四、Servlet API和HTTP协议的抽取

Struts没有隐藏Servlet API和HTTP协议的细节。为了使用Struts，我们必须乐于和HTTPServletRequest、HttpServletResponse 和HttpSession类打交道。并围绕着请求和回应建立应用。这便是所有Model2 MVC wen框架与生俱来的弱点。

正如上面说的，Wicket隐藏了Servlet API和HTTP协议的细节。对于一些应用，我们甚至触及不到这些细节。甚至对于非常复杂的应用，我们也仅使用适当的Wicket协议抽取类。而经常用到的是java组件类、POJO业务模型、纯HTML标记文件。

五、状态管理

使用Struts开发，我们将获得全部的状态管理权。这对于建立大规模的、高升级空间的、集群应用来讲是很好的，因为我们将获得对HttpSession上每件事物的控制权。但是对于中小型应用，我们将没有缘由编写一些额外的代码。这样将导致应用变得复杂和编写费时。

在状态管理上，Wicket可以作为一个不错的选择。Wicket框架默认代管所有的组件状态。这对于中小型应用，在状态管理上的代码量几乎为0。但是Wicket也提供了一些API使我们进行标准状态管理和实现自己的状态管理。这样，即使是大型应用，我们也能够全权掌握状态管理。事实上，即使在使用Wicket编写大型应用时，通常也是先让Wicket代管所有的状态，然后再慢慢的实现自己定义的状态管理以提高应用性能。

六、配置

不言自明，Struts需要一个XML文件：定义对HTTP请求和响应的映射和所有的ActionForm对象等。这个文件可能非常大而且复杂。而新版本的Struts提供了将这个文件分解为多个模块的方法，虽然这样可以将模块分类，但是这样同样要维护许多的小文件。

Wicket不需要配置文件。Wicket通过一个简单的应用配置类或者通过编写web容器的web.xml文件中Servlet init参数来完成程序的初始化。而HTTP请求到组件事件的映射、组件如何输出HTML等被包含在了Wicket的应用逻辑里，从而极大地简化了配置。

七、参考资料
http://wicket.sourceforge.net/
http://www.wicket-wiki.org.uk/wiki/index.php/Newuserguide

http://www.blogjava.net/tommyjian/archive/2007/06/10/123202.html

感谢Tommy Jian

为什么是Wicket？

    如果您正在寻求使用Java开发Web应用程序，目前，您有很多的选择。实际上，存在如此众多的Web应用程序框架显得有点搞笑。来自于互联网一个博客站点的问题：您能说出多少Java Web应用框架的名字？他们展现的结果如下：

    框架，到处都是框架，参看后面附带的表格。

为什么要“重新发明轮子”？

    从这个角度看，您对于“另一个Web应用程序框架有多好”这个问题总是耿耿于怀？确实，为什们要“重新发明轮子”呢？对这个古老的谚语的答复是：因为这一次可以使轮子更圆！

    但是对于高质量的期待并不是构建Wicket框架的唯一动因。甚至有很多的观点，认为没有其他的Web工具集填补这一空白，而Wicket做到了。实际上，Wicket与上面提及的众多框架不太一样。

    与Wicket最相近的或许是Tapestry和Echo，但是这种相似性也很有限。和Tapestry一样，Wicket使用特定的HTML属性来标识组件（Components）声明，这可以方便使用一般的HTML编辑器进行文件编辑。和Echo一样，Wicket拥有一流的组件模型。但是基于Wicket的应用程序和那些基于Tapestry和Echo的应用程序不一样，这是因为从Wicket框架中两方面都可以受益。您获得了一流的组件模型和对HTML没有干扰所带来的益处。在很多情况下，这种复合的好处可以带来非常重要的开发优势。

    理解了构建Wicket的动机有助于您理解为什么Wicket会表现的不一样。

动机

    目前存在的大多数Web框架对于服务端的状态管理都仅仅提供了较弱的支持。

    这就意味着在Web应用程序中存在着很多特殊的代码来处理和维护繁复的状态管理机制。虽然Wicket并不允许对服务端的状态完全不考虑，但是它在状态管理的简便性和透明化方面做了很多的工作。

    在Wicket中，所有服务端的状态都被纳入了自动的管理。您始终不需要直接使用HttpSession对象或者类似的封装对象去存储状态信息。相反，状态信息已经都与组件关联起来，而在组件后端的数据模型都是传统的Java对象（POJO）。Wicket在每个用户会话期内维护着页面的映射表（Map）。这个页面映射表（以及每个一面内的组件层次）的目的在于使得框架隐藏了组件以及数据模型访问的细节。您只需要处理简单而熟悉的Java对象，而Wicket则处理诸如URL、会话期标识以及GET/POST请求的任务。

    您接着也会发现这种结构良好的服务端状态使得解决令人恐惧的“后退按钮问题”变得十分的容易。实际上，针对页面内组件数据模型的结构性变化带来的数据过期，Wicket提供了通用而且健壮的解决方案，这个方案可以有效地对浏览器缓存页面进行甄别和过期检测。

    最后，Wicket在设计的时候就考虑与诸如JDO和Hibernate的普通Java对象（POJO）序列化框架协同工作。这一点使得构建数据驱动的Web应用程序显得非常简单。

    对于很多应用程序来说，必须在额外服务端状态导致服务器负载增加和其带来的好处之间进行权衡，服务端状态管理可以降低开发成本、减少维护成本、加快对市场的响应时间以及生产高质量的软件。这里提出的基本观点是：软件是十分昂贵、复杂的，而来自于E-machines和Dell的服务器则相对便宜。

    在效率和生产性方面，Wicket对JSP的优越性则犹如Java语言对C语言一样。您使用Wicket可以实现的功能使用JSP也都可以实现。甚至于在内存和CPU消耗方面效率也非常的高。但是使用JSP开发应用程序则需要耗费您更多的时间。最后，因为在JSP中进行状态管理时使用了特别的方式，您可能发现不少的安全问题，也能看到到处蹦出来的错误。上面提及的大部分框架在这方面仅仅提供了有限的辅助。

大部分现存的框架需要特定的HTML代码

    JSP具有最深的侵入性，它允许将Java代码直接嵌入Web页面中。但是，上面列示的框架（除了Tapestry）都不同程度地针对HTML代码引入了特殊的语法。

    因为特殊语法改变了单纯而简单的HTML标记的实质，而Web设计者对于这一点是十分的熟悉，所以特殊语法并不是十分得人心。而且预览、编辑和理解这种包含特殊语法的HTML也是十分困难的事情。

    Wicket并没引入任何新的HTML语法。相反，它通过Wicket命名空间（namespace）的标准兼容方式扩展了HTML，这完全兼容XHTML标准。这意味这您可以使用Macromedia Dreamweaver、Microsoft Frontpage、Word、Adobe Go Live以及其他现有的HTML编辑器来编辑您的Web页面，并且可以和Wicket的组件协同工作。为了实现这个目标，Wicket始终在Wicket命名空间内使用单个id属性（“wicket:id”）来标识那些需要框架进行特殊处理的标签。如果您并不喜欢将有Wicket命名空间修饰的标签和属性展示给您的最终用户，通过简单的设置就可以完全消除它们，从而得到普通的与标准兼容的HTML代码。

    HTML中没有特殊的语法意味着设计者可以直接模拟页面，而您可以在开发的过程中直接使用这些页面。向HTML页面中添加Java组件就和设置组件的名称属性一样简单。然后，您可以直接将这些页面交给Web设计人员，他们可以充满信心地对其进行修改。

    与其他的应用框架相比，Wicket在各方面的分离上提供更多的支持。Web设计者在对应用程序代码不甚了解的情况下就可以编辑HTML（当然，他们不能移除组件名称标签，而且不能任意改变组件嵌套的层次，其他的事情都是可以的）。另一方面，编程者只需要关注与HTML混在一起的Java组件，而不需要了解页面的最终陈现是什么样子。通过这种职能清楚的工作方式，每个人都可以工作得更为顺畅。

现存的框架易用性不好

    目前存在的大部分框架工具在对象模型方面做得不够。在一些框架中，对象模型是通过特定的XML来定义的。这些语法令人生厌，而且还需要特定的工具来编辑这些配置信息。由于这些框架并不是单一的Java类库，您就不能使用包含编辑器、调试器和编译器的IDE工具来编辑它们。

    Wicket是化繁为简的代表。在学习Wicket的过程中不需要了解任何配置文件。Wicket就是组件结构良好的普通的类库。在Wicket中，您的Web应用程序与普通的Swing应用程序类似，而不是JSP应用程序。如果您熟悉Java（特别是如果您熟悉Swing），那么您就已经对Wicket有不少的了解了。

现存的框架可复用性不好

    Tapestry和JSF虽然有可以重用的组件模型，但是您将发现与Wicket相比这并不是特别容易做到的事情。Wicket从设计之初就十分地注重组件的复用。在Wicket中，从现有的组件扩展编制诸如SignInPanel或者AddressForm的复合组件是十分简单的事情。相对来说，针对浏览器的新特性编制新的组件也是十分容易的事情。Wicket的组件可以使用JAR格式进行打包，直接通过库引用的方式就可以实现重用——不需要任何配置文件！

    Web编程应该更关注编程乐趣！

    这就是我编写Wicket的个人方面的目标。现存的框架在实现开发的直接性、快捷性和简易性方面真正地吸引我。我希望Wicket在Web应用程序开发的建议性和乐趣方面能够迈出重要的一步。

目标

基于上面的这些动机，下面是Wicket的目标：

1. 简单（易用性、一致性、易懂性）
•  以POJO为核心
• 所有代码均使用Java编写
• 最小的概念域
• 避免过度地使用XML配置文件
• 全面解决“向后按钮”问题
• 最大限度地类型安全以及编译检查
• 最大限度地分析运行时错误
• 对特定工具集的最小依赖
• 组件、容器和惯例始终保持一致性
2. 复用
• 使用Wicket编制的组件具备高度的复用性
• 可复用的组件可以使用JAR文件发布
3. 无侵入
• HTML以及其他标记性文件不会编程语法所干涉
• 在标记方面只有一个简单的标签
•  与任何普通的HTML编辑器兼容
•  图形开发人员很容易识别并避免修改框架标签
•  如果设计者不小心删除了标签，则很容易恢复它
4. 安全
• 默认情况下代码都是安全的
• 在页面和URL中，只有显式的声明的链接才能公布数据状态
• 具备最大限度类型安全逻辑
• 很容易集成到Java安全框架
5. 富有效率，可伸缩性
• 在不牺牲其他目标的前提下保证效率和轻量级
• 可依附的优选会话期支持集群
• 通过与可分离模型的协作，会话复制形成的集群很容易实现和调整
6. 完整
• Wicket团队乐于为开发Java Web应用贡献可用的且特性齐全的框架。核心框架是由本篇文档的作者Jonathan Locke编写和贡献的。目前的团队包括了很多经验丰富的程序员，他们中的一些人还是上面提及的其他框架的开发者，他们也都拥有构建大型Java Web应用的经验。我们对自己的处境十分的了解，因此也更能从框架使用者的角度来开发Wicket。

开发Wicket的一些网站和资料

1      Wicket

Wicket框架的大本营，在这里你可以通过Wiki了解更多关于Wicket开发的概念和技巧，还可以下载相关的资源，如Wicket核心包，Wicket的扩展包，还有Wicket自带的例子。

http://gocom.primeton.com/modules/newbb/viewforum41.htm(本文作者主持的中文论坛)

http://wicket.sourceforge,net（这是Wicket在sourceforge的根据地）

http://www.wicketframework.org（这是Wicket的独立域名）

2      Wicket-Stuff

因为Wicket作为一个Web框架，只可能提供最核心的功能，但是在实际的开发中，需要更多的控件以及辅助的功能，如与Hibernate的整合，数据分布列表控件等，Wicket-Stuff就是一个致力于开发Wicket扩展功能的站点，目前已经提供了以下的扩展功能:

v       整合Dojo

v       整合Hibernate的控件Hibernate (2.1 and 3) components

v       支持客户端数据验证的控件

v       支持Groovy脚本编程

v       Velocity控件面板

v       整合Freemarker

v       整合JasperReports

v       整合TinyMCE这个Html编辑器

v       整合Yahoo Ajax UI控件

http://wicket-stuff.sourceforge.net/

3      Wicket-Quickstart

Wicket虽然入门门框不高，但是许多热心的开发人员还是提供了许多详细的教程，帮助开发人员学习如何在各种IDE环境下开发Wicket应用程序。

http://wicketframework.org/wicket-quickstart/index.htmlHtml

4      Wicket-Library

Wicket-Library也是一个类似于Wicket-Stuff的站点，它的目的也是为了提供更多的Wicket控件，为开发人员服务，但是目前并没有提供什么有用的控件。

它的网站上提供了Wicket例子的在线演示，如果你不想在本机上安装Tomcat，JDK等软件，就可以在这个网站上看Wicket提供的例子。

http://www.wicket-library.com/

5      DataBinder

DataBinder是一个将Hibernate整合到Wicket中的一个扩展功能，对于那些以数据驱动为开发目的的Web程序，它是不二之选。

http://databinder.net/

6      Hibernate

Hibernate本身与Wicket并没有关系，但是Wicket-Stuff和DataBinder都已经提供了Hibernate的扩展功能，所以把Hibernate也放入这个列表，方便大家使用Hibernate。

http://www.hibernate.org/

7      QWicket

QWicket是一些热心的Wicket开发人员，为了让更多的开发人员了解Wicket，所以提供了一个很完整的应用程序，它是Wicket世界中的Appfuse。

http://www.antwerkz.com/qwicket/

8      Wicket Bench

Wicket Bench是一个用来辅助Wicket进行开发的Eclipse插件工具。前面已经对它进行了详细的介绍。

http://www.laughingpanda.org/mediawiki/index.php/Wicket_Bench

9      Mail-Archive

Mail-Archive本身不是一个与技术有关的网站，它是一个邮件组归档的站点，常用的邮件组在上面都有归档，如Jakarta小组的开源软件，Wicket也在上面，还有许多，在上面可以查看许多Wicket的讨论，非常的精彩。

你可以通过下面的网址直接访问Mail-Archive网站上Wicket邮件组的归档:

http://www.mail-archive.com/wicket-user%40lists.sourceforge.net/

10 一些Blog

Wicket的开发人员和Wicket一些资深用户将自己关于Wicket的开发经验放在自己的Blog上，与大家共享:

v       A Wicket Diary - Martijn Dashorst

v       Chillenious! - Eelco Hillenius

v       Jonathan - Jonathan Locke

v       N8than - Nathan Hamblen

v       Antwerkz - Justin Lee

v       System Mobile - Nick Heudecker

v       Geertjan - Geertjan Wielenga

1、首先下载 Liferay Portal Professional 4.2.1 (Bundled with Tomcat for JDK 5.0)

2、使用其默认的 HSQL 数据库，即不去更改其数据库配置。

3、下载 liferay-portal-servicemix-4.2.1.war 和 iferay-portal-jbpm-4.2.1.war
http://www.liferay.com/web/guest/downloads

4、把下载的这两个包分别更名为jbpm-web.war 和 servicemix-web.war

5、把 jbpm-web.war 和 servicemix-web.war 拷贝到 Tomcat 的 webapps 目录中

6、把 webapps\jbpm-web\WEB-INF\sql  目录中的 hsqldb.create.jbpm.3.1.sql 文件更名为 jbpm.script  ，并把它放入 tomcat 的 bin 目录。

7、运行 Tomcat 的 startup.bat

8、打开 http://localhost:8080/ ，并使用 test@liferay.com 用户登录 （密码为 test）

9、增加  workflow portlet 项，选择其中的 definitions 标签，选择 add 按钮。

10、在  text area 中输入工作流定义，如：

1
 2<?xml version="1.0" encoding="UTF-8"?>
 3
 4<process-definition xmlns="urn:jbpm.org:jpdl-3.1" name="Example Process">
 5    <start-state name="start">
 6        <task>
 7            <assignment class="com.liferay.jbpm.handler.IdentityAssignmentHandler" >
 8                <companyId>liferay.com</companyId>
 9                <type>user</type>
10                <name>test@liferay.com</name>
11            </assignment>
12            <controller>
13                <variable name="text:color" />
14                <variable name="text:size" />
15            </controller>
16        </task>
17        <transition name="to_t" to="t"/>
18
19    </start-state>
20
21    <task-node name="t">
22        <task name="t" >
23            <controller >
24                <variable name="text:color" access="read" />
25                <variable name="text:size"  access="read"/>
26            </controller>
27            <assignment class="com.liferay.jbpm.handler.IdentityAssignmentHandler" >
28                <companyId>liferay.com</companyId>
29                <type>user</type>
30                <name>test@liferay.com</name>
31            </assignment>
32        </task>
33        <transition name="to_end" to='end' />
34    </task-node>
35    <end-state name="end"></end-state>
36</process-definition>

11、提交此示例，则生成一个工作流程。

12、在  tasks view ，选择 "manage" 来执行此 tasks 。

1. Create a Web project.
2. Create or import an artifact to be turned into a Web service.
3. Create a Web service.
4. Publish a business entity.
5. Publish a Web service.

首先介绍一下top-down方式：

1. Switch to the J2EE perspective (Window > Open Perspective > J2EE).
2. In the Project Explorer view, select the WSDL file that you created or imported into the Web Content folder of your Web project.
3. Click File > New > Other. Select Web Services in order to display the various Web service wizards. Select the Web Service wizard. Click Next.
4. Web Services page: select Top down Java bean Web service as your Web service type. You can optionally choose to do the following:
   • Start the Web service in a Web project - if you do not select this option you will have to manually start the Web service. You must select this option to enable the other options on this page.
   • Launch the Web Services Explorer to publish your Web service to a UDDI registry.
   • Generate a Java?bean client proxy to the Web service. The Java bean client proxy that is generated provides a remote procedure call interface to the Web service.
   • Test the Web service - this allows you to test the Web service in the Web Service Explorer before a proxy is generated.
   • Send the Web service traffic through the TCP/IP Monitor, which allows you to watch the SOAP traffic generated by the Web service and to test this traffic for WS-I compliance. Note that this is only supported for Tomcat v4.0 and v4.1. If you are using Tomcat v5.0 and want to monitor the Web service traffic, you need to manually set up a TCP/IP monitor 
5. Web Service Selection page: Enter the URI to the WSDL, WSIL, or HTML file that will be used to generate the Java bean. If you have selected the WSDL file before starting the wizard, this information should be prefilled. You can optionally generate a WSIL file from this file as well. Ensure that there are no spaces at the beginning of the URI or you may generate a null pointer exception.
6. Service Deployment Configuration page: specify the server and client deployment settings.
   1. Click Edit and select the Apache Axis run-time environment and select the server on which you want to run your Web service and Web service client.
   2. Select the Web project in which you want your Web service created. The wizard will create this for you if they do not already exist.
   3. Select the type and name of project in which you want the Web service client created. If you enter the name of an existing project, the project type field must match that of the existing project. If you enter a name of a project that does not already exist, the wizard will create the project for you. Note that the only project type supported for Axis and SOAP run-time clients is a Web project. If you want the client to be created in a Java, EJB, or Application Client project, you must select the WebSphere   run-time environment for your client.
7. Web Services Skeleton Java Bean Configuration page: Select the folder where the generated Java will be stored. If you want to review or edit the mappings between packages and namespaces, select the Define custom mapping for namespace to package check box. Click Next.
8. Web Service Namespace to Package Mappings page: if you selected Define custom mapping for package to namespace on the previous panel, you can enter your custom mapping pairs on this panel by clicking Add. Click Next.
9. Web Service Test page: If you selected to test the Web service, select the test facility for the generated Web service. This will open the Web service in the Web Services Explorer. Select the operation you want to test, enter the required information, and click Go. The result will display in the Status pane. Click Next.
10. Web Service Proxy page: If you have selected to generate a proxy, this page shows the options for the proxy. It lists the folder where the proxy will be generated, and you can optionally create custom mappings between namespaces and packages. Click Next.
11. Web Service Client Test page: Use this page to select the following options:
    1. Select your test facility. You can test the generated proxy in the Universal Test Client or the Web Service Explorer, or you can generate a sample Web service JSP.
    2. If you selected to test the proxy through a JSP, you can select the folder where the JSP will be located, and you can select the methods that will be included in the JSP.
    3. Select Run test on server to start the server for you automatically.
12. Web Service Publication page: If you have selected to publish your Web service to a UDDI registry, use this page to launch the Web Services Explorer and select the UDDI registry to which the Web service will be published. Click Finish.

bottom-up方式：

1. Switch to the J2EE perspective ( Window > Open Perspective > J2EE).
2. In the Project Explorer view, select the bean that you created or imported into the source folder of your Web project.
3. Click File > New > Other. SelectWeb Services in order to display the various Web service wizards. Select the Web Service wizard. Click Next.
4. Web Services page: select Bottom up Java bean Web service as your Web service type. You can optionally choose to do the following:
   • Start the Web service in a Web project - if you do not select this option you will have to manually start the Web service. You must select this option to enable the other options on this page.
   • Launch the Web Services Explorer to publish your Web service to a UDDI registry.
   • Generate a Java bean client proxy to the Web service. The Java bean client proxy that is generated provides a remote procedure call interface to the Web service.
   • Test the Web service - this allows you to test the Web service in the Web Service Explorer before a proxy is generated.
   • Send the Web service traffic through the TCP/IP Monitor, which allows you to watch the SOAP traffic generated by the Web service and to test this traffic for WS-I compliance. Note that this is only supported for Tomcat v4.0 and v4.1. If you are using Tomcat v5.0 and want to monitor the Web service traffic, you need to manually set up a TCP/IP monitor 
5. Object selection page: select the Java bean from which the Web service will be created.
6. Service Deployment Configuration page: specify the server and client deployment settings.
   1. Click Edit and select the Apache Axis run-time environment and select the server on which you want to run your Web service and Web service client.
   2. Select the Web project in which you want your Web service created, and the EAR with which it will be associated. The wizard will create these for you if they do not already exist.
   3. Select the type and name of project in which you want the Web service client created. If you enter the name of an existing project, the project type field must match that of the existing project. If you enter a name of a project that does not already exist, the wizard will create the project for you. Note that the only project type supported for Axis and SOAP run-time clients is a Web project. If you want the client to be created in a Java, EJB, or Application Client project, you must select the WebSphere  run-time environment for your client.
   4. Select an existing EAR or enter a unique name to associate the Web service client with a different EAR than the Web service EAR. Note: Selecting different EARs for the Web service and Web service client can reduce the chance of encountering run time errors, but will use more system resources.
7. A message will display stating that you have made a WS-I non-compliant selection. The Apache Axis run-time environment is not WS-I compliant. Select Ignore.
8. Web Service Java Bean Identity page: the Web service URI and WSDL name will be listed. You?have the following options:
   • Select the methods to expose.
   • Select the encoding style. RPC/Encoded is the recommended encoding style for the Axis run-time environment. This encoding method is not WS-I compliant.
   • Select if you want to customize the package to namespace mappings.
   Click Next
9. Web Service Package to Namespace Mappings page: if you selected Define custom mapping for package to namespace on the previous panel, you can enter your custom mapping pairs on this panel by clicking Add.
10. Web Service Test page: If you selected to test the Web service, select the test facility for the generated Web service. This will open the Web service in the Web Services Explorer. Select the operation you want to test, enter the required information, and clickGo. The result will display in the Status pane. Click Next.
11. Web Service Proxy page: if you have selected to generate a proxy, select if you want to customize the package to namespace mappings.
12. Web Service Client Test page: Use this page to select the following options:
    1. Select your test facility. You can test the generated proxy in the Universal Test Client or the Web Service Explorer, or you can generate a sample Web service JSP.
    2. If you selected to test the proxy through a JSP, you can select the folder where the JSP will be located, and you can select the methods that will be included in the JSP.
    3. Select Run test on server to start the server for you automatically.
13. Web Service Publication page: Select whether or not you want to publish this Web service to a UDDI registry. Click Finish . Note: you may see a warning stating Error in generating WSDL from Java. ClassNotFound: <bean name>. This error can be safely ignored.

最后我们可建立Web Service Client来验证Web Service 的使用。

首先需要发现Web services，步骤如下：

从UDDI 查找：

1. Launch the Web Services Explorer
2. Click UDDI Main.
3. In the Actions pane select a registry from the drop-down list and click Go.
4. In the Actions pane toolbar click the Find icon .
5. In the Actions pane, enter the name of the query, what you are searching for, the type of search that you want to perform, and any query information:
   1. Search for  This list allows you to search for businesses, services, or service interfaces.
      • Businesses Once you locate a business in the registry, use the icons in the Action pane toolbar to do the following:
        • View and edit business details
        • Get the services associated with that business
        • Publish a service
        • Manage referenced services
        • Manage publisher assertions
        • Add the business to Favorites
        • Unpublish the business
      • Services Once you locate a service in the registry, use the icons in the Action pane toolbar to do the following:
        • View and edit service details
        • Get the business associated with that service
        • Get the service interfaces associated with that service
        • Import the service WSDL file to the Eclipse workbench
        • Import the service WSDL file to the file system
        • Launch the Web Service wizards
        • Add the service to Favorites
        • Unpublish the service
      • Service interfaces Once you locate a service interface in the registry, use the icons in the Action pane toolbar to do the following:
        • View and edit interface details
        • Get the services associated with that service interface
        • Get the businesses associated with that service interface
        • Import the service interface WSDL file to the Eclipse workbench
        • Import the service interface WSDL file to the file system
        • Launch the Web Service wizards
        • Add the service interface to Favorites
        • Unpublish the service interface
   2. Type of search  These radio buttons allow you to specify a simple or advanced search, or a search by a Universal Unique Identifier (UUID).

      Simple

      Type the name of the businesses, services, or service interfaces for which you are searching. Note: The search set size is set to 100 and the maximum number of returned results is set to 10 by default.  If you would like to override the defaults, use the Advanced search.

      Advanced

      Allows you to enter more search options to focus the scope of your search. Select this option if you would like to search for multiple businesses or services.

      UUID

      Allow you to enter the UUID key.  The UUID key is the identifier that is associated with the published object.

6. Once you have searched and discovered the business service description you desired, select the service or the service interface and click the Import icon to:
   • import the WSDL document into your Web project
   • import the WSDL document into the WSDL Explorer for testing
   • launch the Web Service Skeleton Creation wizard or Web Service Client wizard directly from the Web Services Explorer.

从WSIL 查找：

1. From the Web Services Explorer toolbar, click the WSIL Page icon .
2. In the Navigator pane, click WSIL Main.
3. In the URL to document field of the Actions pane enter the URL to the WSIL document or HTTP document that contains links to a WSIL document. Details on how an HTTP file can contain links to WSIL can be found here: http://www.ibm.com/developerworks/webservices/library/ws-wsilspec.html
4. Once you have located the WSIL document, use the icons in the Action pane toolbar to do the following:
   • View WSIL document details
   • List all of the WSDL services associated with that WSIL document
   • List all of the UDDI services associated with that WSIL document
   • List all of the UDDI businesses associated with that WSIL document
   • List all of the WSIL links associated with that WSIL document
   • Import the WSIL document to the file system
   • Add the WSIL document to Favorites
   Important: If the IBM Web Services Explorer does not display the project that you would like to import your WSDL file to, ensure that you have created the project and/or click the Refresh icon.

建立Web Service Client：

1. Switch to the J2EE perspective (Window > Open Perspective > J2EE).
2. In the Navigator view, select the Web project in which you want to generate a sample application.
3. Click File > New > Other. Select Web Services in order to display the various Web service wizards. Select the Web Service Client wizard. Click Next.