一、首先，模块的组织更加的细致，从那么多的jar分包就看的出来：

Spring的构建系统以及依赖管理使用的是Apache Ivy，从源码包看出，也使用了Maven。

Maven确实是个好东西，好处不再多言，以后希望能进一步用好它。

二、新特性如下：

Spring Expression Language （Spring表达式语言）

IoC enhancements/Java based bean metadata （Ioc增强/基于Java的bean元数据）

General-purpose type conversion system and UI field formatting system （通用类型转换系统和UI字段格式化系统）

Object to XML mapping functionality (OXM) moved from Spring Web Services project （对象到XML映射功能从Spring Web Services项目移出）

Comprehensive REST support （广泛的REST支持）

@MVC additions （@MVC增强）

Declarative model validation （声明式模型验证）

Early support for Java EE 6 （提前对Java EE6提供支持）

Embedded database support （嵌入式数据库的支持）

三、针对Java 5的核心API升级

1、BeanFactory接口尽可能返回明确的bean实例，例如：

T getBean(String name, Class requiredType)

Map getBeansOfType(Class type)

Spring3对泛型的支持，又进了一步。个人建议泛型应该多用，有百利而无一害！

2、Spring的TaskExecutor接口现在继承自java.util.concurrent.Executor：

扩展的子接口AsyncTaskExecutor支持标准的具有返回结果Futures的Callables。

任务计划，个人还是更喜欢Quartz。

3、新的基于Java5的API和SPI转换器

无状态的ConversionService 和 Converters

取代标准的JDK PropertyEditors

类型化的ApplicationListener，这是一个实现“观察者设计模式”使用的事件监听器。

基于事件的编程模式，好处多多，在项目中应该考虑使用，基于事件、状态迁移的设计思路，有助于理清软件流程，和减少项目的耦合度。

四、Spring表达式语言

Spring表达式语言是一种从语法上和统一表达式语言（Unified EL）相类似的语言，但提供更多的重要功能。它可以在基于XML配置文件和基于注解的bean配置中使用，并作为基础为跨Spring portfolio平台使用表达式语言提供支持。

接下来，是一个表达式语言如何用于配置一个数据库安装中的属性的示例：

<bean class="mycompany.RewardsTestDatabase">
    <property name="databaseName"
        value="#{systemProperties.databaseName}"/>
    <property name="keyGenerator"
        value="#{strategyBean.databaseKeyGenerator}"/>
</bean>
如果你更愿意使用注解来配置你的组件，那么这种功能同样可用：

@Repository public class RewardsTestDatabase {
      @Value("#{systemProperties.databaseName}")
      public void setDatabaseName(String dbName) { … }
     
      @Value("#{strategyBean.databaseKeyGenerator}")
      public voidsetKeyGenerator(KeyGenerator kg) { … }
}

又多一种表达式语言，造轮子的运动还在继续中！

五、基于Java的bean元数据

JavaConfig项目中的一些核心特性已经集成到了Spring中来，这意味着如下这些特性现在已经可用了：

@Configuration

@Bean

@DependsOn

@Primary

@Lazy

@Import

@Value

又来一堆的注解，无语了，感觉还是配置文件方便！：（

这儿有一个例子，关于一个Java类如何使用新的JavaConfig特性提供基础的配置信息：

package org.example.config;

@Configuration
public class AppConfig {
    private @Value("#{jdbcProperties.url}") String jdbcUrl;
    private @Value("#{jdbcProperties.username}") String username;
    private @Value("#{jdbcProperties.password}") String password;

    @Bean
    public FooService fooService() {
        return new FooServiceImpl(fooRepository());
    }

    @Bean
    public FooRepository fooRepository() {
        return new HibernateFooRepository(sessionFactory());
    }

    @Bean
    public SessionFactory sessionFactory() {
        // wire up a session factory
        AnnotationSessionFactoryBean asFactoryBean =
            new AnnotationSessionFactoryBean();
        asFactoryBean.setDataSource(dataSource());
        // additional config
        return asFactoryBean.getObject();
    }

    @Bean
    public DataSource dataSource() {
        return new DriverManagerDataSource(jdbcUrl, username, password);
    }
}为了让这段代码开始生效，我们需要添加如下组件扫描入口到最小化的应用程序上下文配置文件中：

<context:component-scan base-package="org.example.config"/>
<util:properties id="jdbcProperties" location="classpath:org/example/config/jdbc.properties"/>

六、在组件中定义bean的元数据

感觉Spring提供了越来越多的注解、元数据，复杂性已经超出了当初带来的方便本身！

七、通用类型转换系统和UI字段格式化系统

Spring3加入了一个通用的类型转换系统，目前它被SpEL用作类型转换，并且可能被一个Spring容器使用，用于当绑定bean的属性值的时候进行类型转换。

另外，还增加了一个UI字段格式化系统，它提供了更简单的使用并且更强大的功能以替代UI环境下的JavaBean的PropertyEditors，例如在SpringMVC中。

这个特性要好好研究下，通用类型转换系统如果果如所言的话，带来的好处还是很多的。

八、数据层

对象到XML的映射功能已经从Spring Web Services项目移到了Spring框架核心中。它位于org.springframework.oxm包中。

OXM?研究下！时间真不够！

九、Web层

在Web层最激动人心的新特性莫过于新增的对构件REST风格的web服务和web应用的支持！另外，还新增加了一些任何web应用都可以使用的新的注解。

服务端对于REST风格的支持，是通过扩展既有的注解驱动的MVC web框架实现的。

客户端的支持则是RestTemplate类提供的。

无论服务端还是客户端REST功能，都是使用HttpConverter来简化对HTTP请求和应答过程中的对象到表现层的转换过程。

MarshallingHttpMessageConverter使用了上面提到的“对象到XML的映射机制”。

十、@MVC增强

新增了诸如@CookieValue 和 @RequestHeaders这样的注解等。

十一、声明式模型验证

支持JSR 303，使用Hibernate Validator作为实现。

十二、提前对Java EE6提供支持

提供了使用@Async注解对于异步方法调用的支持（或者EJB 3.1里的 @Asynchronous）

另外，新增对JSR 303, JSF 2.0, JPA 2.0等的支持。

十三、嵌入式数据库的支持

对于嵌入式的Java数据库引擎提供了广泛而方便的支持，诸如HSQL, H2, 以及Derby等。

这是不是代表一种潮流呢？数据库向越来越小型化发展，甚至小型化到嵌入式了，我认为这在桌面级应用上还是很有市场的。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/abigfrog/archive/2009/10/30/4748685.aspx

HQL: Hibernate查询语言

Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态 和关联之类的概念。

from eg.Cat

from Cat

from Cat as cat

from Cat cat

from Formula, Parameter

from Formula as form, Parameter as param

from Cat as cat
inner join cat.mate as mate
left outer join cat.kittens as kitten

from Cat as cat left join cat.mate.kittens as kittens

from Formula form full join form.parameter param

from Cat as cat
join cat.mate as mate
left join cat.kittens as kitten

from Cat as cat
inner join fetch cat.mate
left join fetch cat.kittens

from Document fetch all properties order by name

from Document doc fetch all properties where lower(doc.name) like '%cats%'

select mate
from Cat as cat
inner join cat.mate as mate

select cat.mate from Cat cat

select cat.name from DomesticCat cat
where cat.name like 'fri%'

select cust.name.firstName from Customer as cust

select mother, offspr, mate.name
from DomesticCat as mother
inner join mother.mate as mate
left outer join mother.kittens as offspr

select new list(mother, offspr, mate.name)
from DomesticCat as mother
inner join mother.mate as mate
left outer join mother.kittens as offspr

select new Family(mother, mate, offspr)
from DomesticCat as mother
join mother.mate as mate
left join mother.kittens as offspr

select max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n
from Cat cat

select new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n )
from Cat cat

select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)
from Cat cat

select cat.weight + sum(kitten.weight)
from Cat cat
join cat.kittens kitten
group by cat.id, cat.weight

select firstName||' '||initial||' '||upper(lastName) from Person

select distinct cat.name from Cat cat
select count(distinct cat.name), count(cat) from Cat cat

from Cat as cat

from java.lang.Object o

from Named n, Named m where n.name = m.name

from Cat where name='Fritz'

from Cat as cat where cat.name='Fritz'

select foo
from Foo foo, Bar bar
where foo.startDate = bar.date

from Cat cat where cat.mate.name is not null

from Foo foo
where foo.bar.baz.customer.address.city is not null

from Cat cat, Cat rival where cat.mate = rival.mate

select cat, mate
from Cat cat, Cat mate
where cat.mate = mate

from Cat as cat where cat.id = 123
from Cat as cat where cat.mate.id = 69

from bank.Person person
where person.id.country = 'AU'
and person.id.medicareNumber = 123456

from bank.Account account
where account.owner.id.country = 'AU'
and account.owner.id.medicareNumber = 123456

from Cat cat where cat.class = DomesticCat

store.owner.address.city    // 正确
store.owner.address         // 错误!

from AuditLog log, Payment payment
where log.item.class = 'Payment' and log.item.id = payment.id

from DomesticCat cat where cat.name between 'A' and 'B'

from DomesticCat cat where cat.name in ( 'Foo', 'Bar', 'Baz' )

from DomesticCat cat where cat.name not between 'A' and 'B'

from DomesticCat cat where cat.name not in ( 'Foo', 'Bar', 'Baz' )

<property name="hibernate.query.substitutions">true 1, false 0</property>

from Cat cat where cat.alive = true

from Cat cat where cat.kittens.size > 0

from Cat cat where size(cat.kittens) > 0

from Calendar cal where maxelement(cal.holidays) > current date

from Order order where maxindex(order.items) > 100

from Order order where minelement(order.items) > 10000

select mother from Cat as mother, Cat as kit
where kit in elements(foo.kittens)

select p from NameList list, Person p
where p.name = some elements(list.names)

from Cat cat where exists elements(cat.kittens)

from Player p where 3 > all elements(p.scores)

from Show show where 'fizard' in indices(show.acts)

from Order order where order.items[0].id = 1234

select person from Person person, Calendar calendar
where calendar.holidays['national day'] = person.birthDay
and person.nationality.calendar = calendar

select item from Item item, Order order
where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11

select item from Item item, Order order
where order.items[ maxindex(order.items) ] = item and order.id = 11

select item from Item item, Order order
where order.items[ size(order.items) - 1 ] = item

select item, index(item) from Order order
join order.items item
where index(item) < 5

from DomesticCat cat where upper(cat.name) like 'FRI%'

select cust
from Product prod,
Store store
inner join store.customers cust
where prod.name = 'widget'
and store.location.name in ( 'Melbourne', 'Sydney' )
and prod = all elements(cust.currentOrder.lineItems)

SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order
FROM customers cust,
stores store,
locations loc,
store_customers sc,
product prod
WHERE prod.name = 'widget'
AND store.loc_id = loc.id
AND loc.name IN ( 'Melbourne', 'Sydney' )
AND sc.store_id = store.id
AND sc.cust_id = cust.id
AND prod.id = ALL(
SELECT item.prod_id
FROM line_items item, orders o
WHERE item.order_id = o.id
AND cust.current_order = o.id
)

from DomesticCat cat
order by cat.name asc, cat.weight desc, cat.birthdate

select cat.color, sum(cat.weight), count(cat)
from Cat cat
group by cat.color

select foo.id, avg(name), max(name)
from Foo foo join foo.names name
group by foo.id

select cat.color, sum(cat.weight), count(cat)
from Cat cat
group by cat.color
having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

select cat
from Cat cat
join cat.kittens kitten
group by cat
having avg(kitten.weight) > 100
order by count(kitten) asc, sum(kitten.weight) desc

DWR 3.0 上传文件

第一步：需要文件包，其实就是dwr 3.0中例子所需要的包， dwr.jar 、 commons-fileupload-1.2.jar 、 commons-io-1.3.1.jar 。

 

 

 

第二步：编辑web.xml，添加dwr-invoke

Xml代码

1. <servlet>  
2.     <display-name>DWR Sevlet</display-name>  
3.     <servlet-name>dwr-invoker</servlet-name>  
4.     <servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>  
5.     <init-param>  
6.         <description>是否打开调试功能</description>  
7.         <param-name>debug</param-name>  
8.         <param-value>true</param-value>  
9.     </init-param>  
10.     <init-param>  
11.         <description>日志级别有效值为： FATAL, ERROR, WARN (the default), INFO and DEBUG.</description>  
12.         <param-name>logLevel</param-name>  
13.         <param-value>DEBUG</param-value>  
14.     </init-param>  
15.     <init-param>  
16.         <description>是否激活反向Ajax</description>  
17.         <param-name>activeReverseAjaxEnabled</param-name>  
18.         <param-value>true</param-value>  
19.     </init-param>  
20.     <init-param>     
21.          <description>在WEB启动时是否创建范围为application的creator</description>     
22.          <param-name>initApplicationScopeCreatorsAtStartup</param-name>     
23.          <param-value>true</param-value>     
24.     </init-param>     
25.     <init-param>  
26.         <description>在WEB启动时是否创建范围为application的creator</description>     
27.         <param-name>preferDataUrlSchema</param-name>  
28.         <param-value>false</param-value>  
29.     </init-param>  
30.         <load-on-startup>1</load-on-startup>     
31.        
32. </servlet>  
33. <servlet-mapping>  
34.     <servlet-name>dwr-invoker</servlet-name>  
35.     <url-pattern>/dwr/*</url-pattern>  
36. </servlet-mapping>  

	<servlet>
<display-name>DWR Sevlet</display-name>
<servlet-name>dwr-invoker</servlet-name>
<servlet-class>org.directwebremoting.servlet.DwrServlet</servlet-class>
<init-param>
<description>是否打开调试功能</description>
<param-name>debug</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<description>日志级别有效值为： FATAL, ERROR, WARN (the default), INFO and DEBUG.</description>
<param-name>logLevel</param-name>
<param-value>DEBUG</param-value>
</init-param>
<init-param>
<description>是否激活反向Ajax</description>
<param-name>activeReverseAjaxEnabled</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<description>在WEB启动时是否创建范围为application的creator</description>
<param-name>initApplicationScopeCreatorsAtStartup</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
<description>在WEB启动时是否创建范围为application的creator</description>
<param-name>preferDataUrlSchema</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dwr-invoker</servlet-name>
<url-pattern>/dwr/*</url-pattern>
</servlet-mapping>

 第三步：创建上传类FileUpload.java，编辑代码，内容如下：

Java代码

1. package learn.dwr.upload_download;   
2.   
3. import java.awt.Color;   
4. import java.awt.Font;   
5. import java.awt.Graphics2D;   
6. import java.awt.geom.AffineTransform;   
7. import java.awt.image.AffineTransformOp;   
8. import java.awt.image.BufferedImage;   
9. import java.io.File;   
10. import java.io.FileOutputStream;   
11. import java.io.InputStream;   
12. import org.directwebremoting.WebContext;   
13. import org.directwebremoting.WebContextFactory;   
14.   
15. /**  
16.  * title: 文件上传  
17.  * @author Administrator  
18.  * @时间 2009-11-22:上午11:40:22  
19.  */  
20. public class FileUpload {   
21.   
22.     /**  
23.      * @param uploadImage 圖片文件流  
24.      * @param uploadFile 需要用简单的文本文件，如：.txt文件，不然上传会出乱码  
25.      * @param color  
26.      * @return  
27.      */  
28.     public BufferedImage uploadFiles(BufferedImage uploadImage,   
29.             String uploadFile, String color) {   
30.         // uploadImage = scaleToSize(uploadImage);   
31.         // uploadImage =grafitiTextOnImage(uploadImage, uploadFile, color);   
32.         return uploadImage;   
33.     }   
34.   
35.     /**  
36.      * 文件上传时使用InputStream类进行接收，在DWR官方例中是使用String类接收简单内容  
37.      *   
38.      * @param uploadFile  
39.      * @return  
40.      */  
41.     public String uploadFile(InputStream uploadFile, String filename)   
42.             throws Exception {   
43.         WebContext webContext = WebContextFactory.get();   
44.         String realtivepath = webContext.getContextPath() + "/upload/";   
45.         String saveurl = webContext.getHttpServletRequest().getSession()   
46.                 .getServletContext().getRealPath("/upload");   
47.         File file = new File(saveurl + "/" + filename);   
48.         // if (!file.exists()) {   
49.         // file.mkdirs();   
50.         // }   
51.         int available = uploadFile.available();   
52.         byte[] b = new byte[available];   
53.         FileOutputStream foutput = new FileOutputStream(file);   
54.         uploadFile.read(b);   
55.         foutput.write(b);   
56.         foutput.flush();   
57.         foutput.close();   
58.         uploadFile.close();   
59.         return realtivepath + filename;   
60.     }   
61.   
62.     private BufferedImage scaleToSize(BufferedImage uploadImage) {   
63.         AffineTransform atx = new AffineTransform();   
64.         atx   
65.                 .scale(200d / uploadImage.getWidth(), 200d / uploadImage   
66.                         .getHeight());   
67.         AffineTransformOp atfOp = new AffineTransformOp(atx,   
68.                 AffineTransformOp.TYPE_BILINEAR);   
69.         uploadImage = atfOp.filter(uploadImage, null);   
70.         return uploadImage;   
71.     }   
72.   
73.     private BufferedImage grafitiTextOnImage(BufferedImage uploadImage,   
74.             String uploadFile, String color) {   
75.         if (uploadFile.length() < 200) {   
76.             uploadFile += uploadFile + " ";   
77.         }   
78.         Graphics2D g2d = uploadImage.createGraphics();   
79.         for (int row = 0; row < 10; row++) {   
80.             String output = "";   
81.             if (uploadFile.length() > (row + 1) * 20) {   
82.                 output += uploadFile.substring(row * 20, (row + 1) * 20);   
83.             } else {   
84.                 output = uploadFile.substring(row * 20);   
85.             }   
86.             g2d.setFont(new Font("SansSerif", Font.BOLD, 16));   
87.             g2d.setColor(Color.blue);   
88.             g2d.drawString(output, 5, (row + 1) * 20);   
89.         }   
90.         return uploadImage;   
91.     }   
92. }  

package learn.dwr.upload_download;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import org.directwebremoting.WebContext;
import org.directwebremoting.WebContextFactory;
/**
* title: 文件上传
* @author Administrator
* @时间 2009-11-22:上午11:40:22
*/
public class FileUpload {
/**
* @param uploadImage 圖片文件流
* @param uploadFile 需要用简单的文本文件，如：.txt文件，不然上传会出乱码
* @param color
* @return
*/
public BufferedImage uploadFiles(BufferedImage uploadImage,
String uploadFile, String color) {
// uploadImage = scaleToSize(uploadImage);
// uploadImage =grafitiTextOnImage(uploadImage, uploadFile, color);
return uploadImage;
}
/**
* 文件上传时使用InputStream类进行接收，在DWR官方例中是使用String类接收简单内容
*
* @param uploadFile
* @return
*/
public String uploadFile(InputStream uploadFile, String filename)
throws Exception {
WebContext webContext = WebContextFactory.get();
String realtivepath = webContext.getContextPath() + "/upload/";
String saveurl = webContext.getHttpServletRequest().getSession()
.getServletContext().getRealPath("/upload");
File file = new File(saveurl + "/" + filename);
// if (!file.exists()) {
// file.mkdirs();
// }
int available = uploadFile.available();
byte[] b = new byte[available];
FileOutputStream foutput = new FileOutputStream(file);
uploadFile.read(b);
foutput.write(b);
foutput.flush();
foutput.close();
uploadFile.close();
return realtivepath + filename;
}
private BufferedImage scaleToSize(BufferedImage uploadImage) {
AffineTransform atx = new AffineTransform();
atx
.scale(200d / uploadImage.getWidth(), 200d / uploadImage
.getHeight());
AffineTransformOp atfOp = new AffineTransformOp(atx,
AffineTransformOp.TYPE_BILINEAR);
uploadImage = atfOp.filter(uploadImage, null);
return uploadImage;
}
private BufferedImage grafitiTextOnImage(BufferedImage uploadImage,
String uploadFile, String color) {
if (uploadFile.length() < 200) {
uploadFile += uploadFile + " ";
}
Graphics2D g2d = uploadImage.createGraphics();
for (int row = 0; row < 10; row++) {
String output = "";
if (uploadFile.length() > (row + 1) * 20) {
output += uploadFile.substring(row * 20, (row + 1) * 20);
} else {
output = uploadFile.substring(row * 20);
}
g2d.setFont(new Font("SansSerif", Font.BOLD, 16));
g2d.setColor(Color.blue);
g2d.drawString(output, 5, (row + 1) * 20);
}
return uploadImage;
}
}

 第四步：添加到dwr.xml

Java代码

1. <create creator="new">   
2.     <param name="class" value="learn.dwr.upload_download.FileUpload" />   
3. </create>  

	<create creator="new">
<param name="class" value="learn.dwr.upload_download.FileUpload" />
</create>

 第五步：添加前台html代码

Html代码

1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
2. <html xmlns="http://www.w3.org/1999/xhtml">  
3. <head>  
4. <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />  
5. <title>二进制文件处理，文件上传</title>  
6. <script type='text/javascript' src='/learnajax/dwr/interface/FileUpload.js'></script>  
7. <script type='text/javascript' src='/learnajax/dwr/engine.js'></script>  
8. <script type='text/javascript' src='/learnajax/dwr/util.js'></script>  
9. <script type='text/javascript' >  
10. function uploadFiles(){   
11.     var uploadImage = dwr.util.getValue("uploadImage");   
12.      FileUpload.uploadFiles(uploadImage, "", "", function(imageURL) {   
13.         alert(imageURL);   
14.         dwr.util.setValue('image', imageURL);   
15.   });   
16.   
17. }   
18. function uploadFile(){   
19.     var uploadFile = dwr.util.getValue("uploadFile");   
20.     //var uploadFile =document.getElementById("uploadFile").value;   
21.     var uploadFileuploadFile_temp = uploadFile.value.replace("\\","/");   
22.     var filenames = uploadFile.value.split("/");   
23.     var filename = filenames[filenames.length-1];   
24.     //var eextension = e[e.length-1];   
25.     FileUpload.uploadFile(uploadFile,filename,function(data){   
26.         var file_a= document.getElementById("file_a");   
27.         file_a.href=data;   
28.         file_a.innerHTML=data;   
29.         document.getElementById("filediv").style.display="";   
30.     });   
31. }   
32.        
33. </script>  
34. </head>  
35.   
36. <body>  
37. <table border="1" cellpadding="3" width="50%">  
38.     <tr>  
39.         <td>Image</td>  
40.         <td><input type="file" id="uploadImage" /></td>  
41.         <td><input type="button" onclick="uploadFiles()" value="upload"/><div id="image.container">&nbsp;</div></td>  
42.     </tr>  
43.     <tr>  
44.         <td>File</td>  
45.         <td><input type="file" id="uploadFile" /></td>  
46.         <td><input type="button" onclick="uploadFile()" value="upload"/><div id="file.container">&nbsp;</div></td>  
47.     </tr>  
48.     <tr>  
49.         <td colspan="3"></td>  
50.     </tr>  
51. </table>  
52. <img id="image" src="javascript:void(0);"/>  
53. <div id="filediv" style="display:none;">  
54. <a href="" id="file_a">上传的文件</a>  
55. </div>  
56. </body>  
57. </html>  

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>二进制文件处理，文件上传</title>
<script type='text/javascript' src='/learnajax/dwr/interface/FileUpload.js'></script>
<script type='text/javascript' src='/learnajax/dwr/engine.js'></script>
<script type='text/javascript' src='/learnajax/dwr/util.js'></script>
<script type='text/javascript' >
function uploadFiles(){
var uploadImage = dwr.util.getValue("uploadImage");
FileUpload.uploadFiles(uploadImage, "", "", function(imageURL) {
alert(imageURL);
dwr.util.setValue('image', imageURL);
});
}
function uploadFile(){
var uploadFile = dwr.util.getValue("uploadFile");
//var uploadFile =document.getElementById("uploadFile").value;
var uploadFile_temp = uploadFile.value.replace("\\","/");
var filenames = uploadFile.value.split("/");
var filename = filenames[filenames.length-1];
//var extension = e[e.length-1];
FileUpload.uploadFile(uploadFile,filename,function(data){
var file_a= document.getElementById("file_a");
file_a.href=data;
file_a.innerHTML=data;
document.getElementById("filediv").style.display="";
});
}
</script>
</head>
<body>
<table border="1" cellpadding="3" width="50%">
<tr>
<td>Image</td>
<td><input type="file" id="uploadImage" /></td>
<td><input type="button" onclick="uploadFiles()" value="upload"/><div id="image.container">&nbsp;</div></td>
</tr>
<tr>
<td>File</td>
<td><input type="file" id="uploadFile" /></td>
<td><input type="button" onclick="uploadFile()" value="upload"/><div id="file.container">&nbsp;</div></td>
</tr>
<tr>
<td colspan="3"></td>
</tr>
</table>
<img id="image" src="javascript:void(0);"/>
<div id="filediv" style="display:none;">
<a href="" id="file_a">上传的文件</a>
</div>
</body>
</html>

 

添加进度条么，就需要用reverse ajax 进行配合使用了。

本文转自:http://www.blogjava.net/xylz/

DWR作为Ajax远程调用的服务端得到了很多程序员的追捧，在DWR的2.x版本中已经集成了Guice的插件。

老套了，我们还是定义一个HelloWorld的服务吧，哎，就喜欢HelloWorld，不怕被别人骂！ 

1 public interface HelloWorld {
2 
3     String sayHello();
4 
5     Date getSystemDate();
6 }
7 

然后写一个简单的实现吧。 

 1 public class HelloWorldImpl implements HelloWorld {
 2 
 3     @Override
 4     public Date getSystemDate() {
 5         return new Date();
 6     }
 7 
 8     @Override
 9     public String sayHello() {
10         return "Hello, guice";
11     }
12 }
13 

然后是与dwr有关的东西了，我们写一个dwr的listener来注入我们的模块。 

 1 package cn.imxylz.study.guice.web.dwr;
 2 
 3 import org.directwebremoting.guice.DwrGuiceServletContextListener;
 4 
 5 /**
 6  * @author xylz (www.imxylz.cn)
 7  * @version $Rev: 105 $
 8  */
 9 public class MyDwrGuiceServletContextListener extends DwrGuiceServletContextListener{
10 
11     @Override
12     protected void configure() {
13         bindRemotedAs("helloworld", HelloWorld.class).to(HelloWorldImpl.class).asEagerSingleton();
14     }
15 }
16 

这里使用bindRemotedAs来将我们的服务开放出来供dwr远程调用。

剩下的就是修改web.xml，需要配置一个dwr的Servlet并且将我们的listener加入其中。看看全部的内容。 

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 4     version="2.5">
 5 
 6     <display-name>guice-dwr</display-name>
 7     <description>xylz study project - guice</description>
 8 
 9     <listener>
10         <listener-class>cn.imxylz.study.guice.web.dwr.MyDwrGuiceServletContextListener
11         </listener-class>
12     </listener>
13     <servlet>
14         <servlet-name>dwr-invoker</servlet-name>
15         <servlet-class>org.directwebremoting.guice.DwrGuiceServlet</servlet-class>
16         <init-param>
17           <param-name>debug</param-name>
18           <param-value>true</param-value>
19         </init-param>
20     </servlet>
21     <servlet-mapping>
22         <servlet-name>dwr-invoker</servlet-name>
23         <url-pattern>/dwr/*</url-pattern>
24     </servlet-mapping>
25 
26 </web-app>
27 

非常简单，也非常简洁，其中DwrGuiceServlet的debug参数只是为了调试方便才开放的，实际中就不用写了。

好了，看看我们的效果。

 1 <html>
 2 <head><title>dwr - test (www.imxylz.cn) </title>
 3   <script type='text/javascript' src='/guice-dwr/dwr/interface/helloworld.js'></script>
 4   <script type='text/javascript' src='/guice-dwr/dwr/engine.js'></script>
 5   <script type='text/javascript' src='/guice-dwr/dwr/util.js'></script>
 6   <script type='text/javascript'>
 7     var showHello = function(data){
 8         dwr.util.setValue('result',dwr.util.toDescriptiveString(data,1));   
 9     }
10     var getSystemDate = function(data){
11         dwr.util.setValue('systime',dwr.util.toDescriptiveString(data,2));   
12     }
13   </script>
14   <style type='text/css'>
15     input.button { border: 1px outset; margin: 0px; padding: 0px; }
16     span { background: #ffffdd; white-space: pre; padding-left:20px;}
17   </style>
18 </head>
19 <body onload='dwr.util.useLoadingMessage()'>
20     <p>
21     <h2>Guice and DWR</h2>
22         <input class='button' type='button' value="Call HelloWorld 'sayHello' service" onclick="helloworld.sayHello(showHello)" />
23         <span id='result' ></span>
24     </p>
25     <p>
26         <input class='button' type='button' value="Call HelloWorld 'getSystemDate' service" onclick="helloworld.getSystemDate(getSystemDate)" />
27         <span id='systime' ></span>
28     </P>
29 </body>
30 </html>

我们通过两个按钮来获取我们的远程调用的结果。

package com.leo.service;
import com.google.inject.ImplementedBy;
import com.leo.service.impl.HelloServiceImpl;
/*
* 采用annotation进行接口与实现类之间的绑定
* 注意：接口与实现类之间绑定是必须的，如果只是单独一个类，没有接口，
* 那么Guice会隐式的自动帮你注入。并且接口此是不应该声明注入域范围的，
* 应该在其实现地方声明
*
*/
@ImplementedBy(HelloServiceImpl.class)
public interface IHelloService {
public String sayHello(String str);
}

package com.leo.service.impl;
import com.google.inject.Singleton;
import com.leo.service.IHelloService;
/*
* 这里如果默认不用annotation标注其作用域，或在自定义的module也不指定的话
* 默认的创建对象的方式是类似于Spring的prototype，在此处因为仅仅是一个stateless service
* 我们用@Singleton来标注它，更多的作用域可看Guice文档
*
* 注意：与标注@Singleton等效的工作也可以在自定义的module里来实现
*/
@Singleton
public class HelloServiceImpl implements IHelloService {
public String sayHello(String str) {
return new StringBuilder("Hello " + str + " !").toString();
}
}

struts.objectFactory = guice
#如果自已想实现Module接口，则下面注释请去掉
#guice.module=com.leo.module.MyModule
struts.action.extension=

package com.leo.action;
import com.google.inject.Inject;
import com.leo.service.IHelloService;
import com.opensymphony.xwork2.ActionSupport;
public class HelloAction extends ActionSupport {
private static final long serialVersionUID = -338076402728419581L;
/*
* 通过field字段进行注入，除此之外，还有construct, method注入均可
*/
@Inject
private IHelloService helloService;
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String execute() {
message = helloService.sayHello("leo");
return SUCCESS;
}
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="default" extends="struts-default">
<action name="hello" class="com.leo.action.HelloAction">
<result>index.jsp</result>
</action>
</package>
</struts>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<filter>
<filter-name>guice</filter-name>
<filter-class>
com.google.inject.servlet.GuiceFilter
</filter-class>
</filter>
<filter>
<filter-name>struts</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>guice</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>struts</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

package com.leo.module;
import com.google.inject.Binder;
import com.google.inject.Module;
import com.google.inject.Scopes;
import com.leo.service.IHelloService;
import com.leo.service.impl.HelloServiceImpl;
/*
* 如果你觉得Annotation有种支离破碎的感觉，别急，Guice还为你提供一种统一
* 注入管理的自定义实现。在本例中，先前的IHelloService, HelloServiceImpl
* 你现在可以完全将所有的Annotation去掉，然后实现Module接口的唯一一个方法
* 实现如下
*/
public class MyModule implements Module {
public void configure(Binder binder) {
/*
* 将接口IHelloService 与其实现HelloServiceImpl 绑定在一起 并且作用域为Scopes.SINGLETON
* 在这里有多种配置方法，但因为是入门实例，不想说的太复杂。其中如果不配置作用域，默认就是类似于Spring
* 的Scope="prototype"
*/
binder.bind(IHelloService.class).to(HelloServiceImpl.class).in(
Scopes.SINGLETON);
}
}

The Example Document and Beans

In this example, we will unmarshall the same XML document that we used in the previous article:

<?xml version="1.0"?>
<catalog library="somewhere">
<book>
<author>Author 1</author>
<title>Title 1</title>
</book>
<book>
<author>Author 2</author>
<title>His One Book</title>
</book>
<magazine>
<name>Mag Title 1</name>
<article page="5">
<headline>Some Headline</headline>
</article>
<article page="9">
<headline>Another Headline</headline>
</article>
</magazine>
<book>
<author>Author 2</author>
<title>His Other Book</title>
</book>
<magazine>
<name>Mag Title 2</name>
<article page="17">
<headline>Second Headline</headline>
</article>
</magazine>
</catalog>

The bean classes are also the same, except for one important change: In the previous article, I had declared these classes to have package scope -- primarily so that I could define all of them in the same source file! Using the Digester framework, this is no longer possible; the classes need to be declared as public (as is required for classes conforming to the JavaBeans specification):

import java.util.Vector;
public class Catalog {
private Vector books;
private Vector magazines;
public Catalog() {
books = new Vector();
magazines = new Vector();
}
public void addBook( Book rhs ) {
books.addElement( rhs );
}
public void addMagazine( Magazine rhs ) {
magazines.addElement( rhs );
}
public String toString() {
String newline = System.getProperty( "line.separator" );
StringBuffer buf = new StringBuffer();
buf.append( "--- Books ---" ).append( newline );
for( int i=0; i<books.size(); i++ ){
buf.append( books.elementAt(i) ).append( newline );
}
buf.append( "--- Magazines ---" ).append( newline );
for( int i=0; i<magazines.size(); i++ ){
buf.append( magazines.elementAt(i) ).append( newline );
}
return buf.toString();
}
}

public class Book {
private String author;
private String title;
public Book() {}
public void setAuthor( String rhs ) { author = rhs; }
public void setTitle(  String rhs ) { title  = rhs; }
public String toString() {
return "Book: Author='" + author + "' Title='" + title + "'";
}
}

import java.util.Vector;
public class Magazine {
private String name;
private Vector articles;
public Magazine() {
articles = new Vector();
}
public void setName( String rhs ) { name = rhs; }
public void addArticle( Article a ) {
articles.addElement( a );
}
public String toString() {
StringBuffer buf = new StringBuffer( "Magazine: Name='" + name + "' ");
for( int i=0; i<articles.size(); i++ ){
buf.append( articles.elementAt(i).toString() );
}
return buf.toString();
}
}

public class Article {
private String headline;
private String page;
public Article() {}
public void setHeadline( String rhs ) { headline = rhs; }
public void setPage(     String rhs ) { page     = rhs; }
public String toString() {
return "Article: Headline='" + headline + "' on page='" + page + "' ";
}

}

























import org.apache.commons.digester.*;
import java.io.*;
import java.util.*;
public class DigesterDriver {
public static void main( String[] args ) {
try {
Digester digester = new Digester();
digester.setValidating( false );
digester.addObjectCreate( "catalog", Catalog.class );
digester.addObjectCreate( "catalog/book", Book.class );
digester.addBeanPropertySetter( "catalog/book/author", "author" );
digester.addBeanPropertySetter( "catalog/book/title", "title" );
digester.addSetNext( "catalog/book", "addBook" );
digester.addObjectCreate( "catalog/magazine", Magazine.class );
digester.addBeanPropertySetter( "catalog/magazine/name", "name" );
digester.addObjectCreate( "catalog/magazine/article", Article.class );
digester.addSetProperties( "catalog/magazine/article", "page", "page" );
digester.addBeanPropertySetter( "catalog/magazine/article/headline" );
digester.addSetNext( "catalog/magazine/article", "addArticle" );
digester.addSetNext( "catalog/magazine", "addMagazine" );
File input = new File( args[0] );
Catalog c = (Catalog)digester.parse( input );
System.out.println( c.toString() );
} catch( Exception exc ) {
exc.printStackTrace();
}
}
}
After instantiating the Digester, we specify that it should not validate the XML document against a DTD -- because we did not define one for our simple Catalog document. Then we specify the patterns and the associated rules: the ObjectCreateRule creates an instance of the specified class and pushes it onto the parse stack. The SetPropertiesRule sets a bean property to the value of an XML attribute of the current element -- the first argument to the rule is the name of the attribute, the second, the name of the property. 
Whereas SetPropertiesRule takes the value from an attribute, BeanPropertySetterRule takes the value from the raw character data nested inside of the current element. It is not necessary to specify the name of the property to set when using BeanPropertySetterRule: it defaults to the name of the current XML element. In the example above, this default is being used in the rule definition matching the catalog/magazine/article/headline pattern. Finally, the SetNextRule pops the object on top of the parse stack and passes it to the named method on the object below it -- it is commonly used to insert a finished bean into its parent.
Note that it is possible to register several rules for the same pattern. If this occurs, the rules are executed in the order in which they are added to the Digester -- for instance, to deal with the <article> element, found at catalog/magazine/article, we first create the appropriate article bean, then set the page property, and finally pop the completed article bean and insert it into its magazine parent.
Invoking Arbitrary Functions
It is not only possible to set bean properties, but to invoke arbitrary methods on objects in the stack. This is accomplished using the CallMethodRule to specify the method name and, optionally, the number and type of arguments passed to it. Subsequent specifications of the CallParamRule define the parameter values to be passed to the invoked functions. The values can be taken either from named attributes of the current XML element, or from the raw character data contained by the current element. For instance, rather than using the BeanPropertySetterRule in the DigesterDriver implementation above, we could have achieved the same effect by calling the property setter explicitly, and passing the data as parameter:
   digester.addCallMethod( "catalog/book/author", "setAuthor", 1 );
digester.addCallParam( "catalog/book/author", 0 );
The first line gives the name of the method to call (setAuthor()), and the expected number of parameters (1). The second line says to take the value of the function parameter from the character data contained in the <author> element and pass it as first element in the array of arguments (i.e., the array element with index 0). Had we also specified an attribute name (e.g., digester.addCallParam( "catalog/book/author", 0, "author" );), the value would have been taken from the respective attribute of the current element instead.
One important caveat: confusingly, digester.addCallMethod( "pattern", "methodName", 0 ); does not specify a call to a method taking no arguments -- instead, it specifies a call to a method taking one argument, the value of which is taken from the character data of the current XML element! We therefore have yet another way to implement a replacement for BeanPropertySetterRule:
   digester.addCallMethod( "catalog/book/author", "setAuthor", 0 );
 
To call a method that truly takes no parameters, use digester.addCallMethod( "pattern", "methodName" );.








Summary of Standard Rules




 



Below are brief descriptions of all of the standard rules.
Creational

    

    
ObjectCreateRule: Creates an object of the specified class using its default constructor and pushes it onto the stack; it is popped when the element completes. The class to instantiate can be given through a class object or the fully-qualified class name.
    

    
FactoryCreateRule: Creates an object using a specified factory class and pushes it onto the stack. This can be useful for classes that do not provide a default constructor. The factory class must implement the org.apache.commons.digester.ObjectCreationFactory interface.
    

Property Setters

    

    
SetPropertiesRule: Sets one or several named properties in the top-level bean using the values of named XML element attributes. Attribute names and property names are passed to this rule in String[] arrays. (Typically used to handle XML constructs like <article page="10">.)
    

    
BeanPropertySetterRule: Sets a named property on the top-level bean to the character data enclosed by the current XML element. (Example: <page>10</page>.)
    

    
SetPropertyRule: Sets a property on the top-level bean. Both the property name, as well as the value to which this property will be set, are given as attributes to the current XML element. (Example: <article key="page" value="10" />.)
    

Parent/Child Management

    

    
SetNextRule: Pops the object on top of the stack and passes it to a named method on the object immediately below. Typically used to insert a completed bean into its parent.
    

    
SetTopRule: Passes the second-to-top object on the stack to the top-level object. This is useful if the child object exposes a setParent method, rather than the other way around.
    

    
SetRootRule: Calls a method on the object at the bottom of the stack, passing the object on top of the stack as argument. 
    

Arbitrary Method Calls

    

    
CallMethodRule: Calls an arbitrary named method on the top-level bean. The method may take an arbitrary set of parameters. The values of the parameters are given by subsequent applications of the CallParamRule. 
    

    
CallParamRule: Represents the value of a method parameter. The value of the parameter is either taken from a named XML element attribute, or from the raw character data enclosed by the current element. This rule requires that its position on the parameter list is specified by an integer index.
    

Specifying Rules in XML: Using the xmlrules Package


    

        

            

            
Related Reading
             
            
Programming Jakarta Struts

            By Chuck Cavaness 
            

            
        
    


So far, we have specified the patterns and rules programmatically at compile time. While conceptually simple and straightforward, this feels a bit odd: the entire framework is about recognizing and handling structure and data at run time, but here we go fixing the behavior at compile time! Large numbers of fixed strings in source code typically indicate that something is being configured (rather than programmed), which could be (and probably should be) done at run time instead.
The org.apache.commons.digester.xmlrules package addresses this issue. It provides the DigesterLoader class, which reads the pattern/rule-pairs from an XML document and returns a digester already configured accordingly. The XML document configuring the Digester must comply with the digester-rules.dtd, which is part of the xmlrules package.
Below is the contents of the configuration file (named rules.xml) for the example application. I want to point out several things here. 
Patterns can be specified in two different ways: either as attributes to each XML element representing a rule, or using the <pattern> element. The pattern defined by the latter is valid for all contained rule elements. Both ways can be mixed, and <pattern> elements can be nested -- in either case, the pattern defined by the child element is appended to the pattern defined in the enclosing <pattern> element.
The <alias> element is used with the <set-properties-rule> to map an XML attribute to a bean property.
Finally, using the current release of the Digester package, it is not possible to specify the BeanPropertySetterRule in the configuration file. Instead, we are using the CallMethodRule to achieve the same effect, as explained above.
<?xml version="1.0"?>
<digester-rules>
<object-create-rule pattern="catalog" classname="Catalog" />
<set-properties-rule pattern="catalog" >
<alias attr-name="library" prop-name="library" />
</set-properties-rule>
<pattern value="catalog/book">
<object-create-rule classname="Book" />
<call-method-rule pattern="author" methodname="setAuthor"
paramcount="0" />
<call-method-rule pattern="title" methodname="setTitle"
paramcount="0" />
<set-next-rule methodname="addBook" />
</pattern>
<pattern value="catalog/magazine">
<object-create-rule classname="Magazine" />
<call-method-rule pattern="name" methodname="setName" paramcount="0" />
<pattern value="article">
<object-create-rule classname="Article" />
<set-properties-rule>
<alias attr-name="page" prop-name="page" />
</set-properties-rule>
<call-method-rule pattern="headline" methodname="setHeadline"
paramcount="0" />
<set-next-rule methodname="addArticle" />
</pattern>
<set-next-rule methodname="addMagazine" />
</pattern>
</digester-rules>
Since all the actual work has now been delegated to the Digester and DigesterLoader classes, the driver class itself becomes trivially simple. To run it, specify the catalog document as the first command line argument, and the rules.xml file as the second. (Confusingly, the DigesterLoader will not read the rules.xml file from a File or an org.xml.sax.InputSource, but requires a URL -- the File reference in the code below is therefore transformed into an equivalent URL.)
import org.apache.commons.digester.*;
import org.apache.commons.digester.xmlrules.*;
import java.io.*;
import java.util.*;
public class XmlRulesDriver {
public static void main( String[] args ) {
try {
File input = new File( args[0] );
File rules = new File( args[1] );
Digester digester = DigesterLoader.createDigester( rules.toURL() );
Catalog catalog = (Catalog)digester.parse( input );
System.out.println( catalog.toString() );
} catch( Exception exc ) {
exc.printStackTrace();
}
}
}
Conclusion
This concludes our brief overview of the Jakarta Commons Digester package. Of course, there is more. One topic ignored in this introduction are XML namespaces: Digester allows you to specify rules that only act on elements defined within a certain namespace.
We mentioned briefly the possibility of developing custom rules, by extending the Rule class. The Digester class exposes the customary push(), peek(), and pop() methods, giving the individual developer freedom to manipulate the parse stack directly.
Lastly, note that there is an additional package providing a Digester implementation which deals with RSS (Rich-Site-Summary)-formatted newsfeeds. The Javadoc tells the full story.
References

    
Jakarta Commons Digester Homepage
    
"Simple XML Parsing with SAX and DOM"
    
Jakarta Struts Homepage
    
"Java & XML Data Binding" -- XML Data Binding addresses the general problem of making XML data available in applications.
    
Programming Jakarta Struts -- the upcoming book on Jakarta Struts at O'Reilly. 

Philipp K. Janert is a software project consultant, server programmer, and architect. 

Beanutils用了魔术般的反射技术，实现了很多夸张有用的功能，都是C/C++时代不敢想的。无论谁的项目，始终一天都会用得上它。我算是后知后觉了，第一回看到它的时候居然错过。

1.属性的动态getter,setter

BeanUtils.getProperty(myBean,"code");

BeanUtils.getProperty(orderBean, "address.city");

BeanUtils.getProperty(orderBean, "customers[1].name");

2.beanCompartor 动态排序

List peoples = ...; // Person对象的列表Collections.sort(peoples, new BeanComparator("age"));

如果要支持多个属性的复合排序，如"Order By lastName,firstName"

ArrayList sortFields = new ArrayList();sortFields.add(new BeanComparator("lastName"));

sortFields.add(new BeanComparator("firstName"));

ComparatorChain multiSort = new ComparatorChain(sortFields);

Collections.sort(rows,multiSort);

其中ComparatorChain属于jakata commons-collections包。
如果age属性不是普通类型，构造函数需要再传入一个comparator对象为age变量排序。
另外, BeanCompartor本身的ComparebleComparator, 遇到属性为null就会抛出异常, 也不能设定升序还是降序。
这个时候又要借助commons-collections包的ComparatorUtils.

   Comparator mycmp = ComparableComparator.getInstance();
   mycmp = ComparatorUtils.nullLowComparator(mycmp);  //允许null
   mycmp = ComparatorUtils.reversedComparator(mycmp); //逆序
   Comparator cmp = new BeanComparator(sortColumn, mycmp);

   经常要从request,resultSet等对象取出值来赋入bean中，下面的代码谁都写腻了，如果不用MVC框架的绑定功能的话。

   String a = request.getParameter("a");   bean.setA(a);   String b = ....

不妨写一个Binder:

     MyBean bean = ...;    HashMap map = new HashMap();    Enumeration names = request.getParameterNames();    while (names.hasMoreElements())    {      String name = (String) names.nextElement();      map.put(name, request.getParameterValues(name));    }    BeanUtils.populate(bean, map);

    其中BeanUtils的populate方法或者getProperty,setProperty方法其实都会调用convert进行转换。
    但Converter只支持一些基本的类型，甚至连java.util.Date类型也不支持。而且它比较笨的一个地方是当遇到不认识的类型时，居然会抛出异常来。
    对于Date类型，我参考它的sqldate类型实现了一个Converter,而且添加了一个设置日期格式的函数。
要把这个Converter注册，需要如下语句：

    ConvertUtilsBean convertUtils = new ConvertUtilsBean();

    DateConverter dateConverter = new DateConverter();

    convertUtils.register(dateConverter,Date.class);







//因为要注册converter,所以不能再使用BeanUtils的静态方法了，必须创建BeanUtilsBean实例

BeanUtilsBean beanUtils = new BeanUtilsBean(convertUtils,new PropertyUtilsBean());

beanUtils.setProperty(bean, name, value);

     public static Class getPropertyType(Object bean, String name)

      public static Object invokeConstructor(Class klass, Object arg)

4.4 MethodUtils，动态调用方法

    MethodUtils.invokeMethod(bean, methodName, parameter);

JFreeChart类：
void setAntiAlias(boolean flag)    字体模糊边界
void setBackgroundImage(Image image)   背景图片
void setBackgroundImageAlignment(int alignment)  背景图片对齐方式（参数常量在org.jfree.ui.Align类中定义）
void setBackgroundImageAlpha(float alpha)  背景图片透明度（0.0～1.0）
void setBackgroundPaint(Paint paint)   背景色
void setBorderPaint(Paint paint)   边界线条颜色
void setBorderStroke(Stroke stroke)   边界线条笔触
void setBorderVisible(boolean visible)   边界线条是否可见

--------------------------------------------------------------------------------------

TextTitle类：
void setFont(Font font)     标题字体
void setPaint(Paint paint)    标题字体颜色
void setText(String text)    标题内容

-----------------------------------------------------------------------------------

StandardLegend(Legend)类：
void setBackgroundPaint(Paint paint)   图示背景色
void setTitle(String title)    图示标题内容
void setTitleFont(Font font)    图示标题字体
void setBoundingBoxArcWidth(int arcWidth)  图示边界圆角宽
void setBoundingBoxArcHeight(int arcHeight)  图示边界圆角高
void setOutlinePaint(Paint paint)   图示边界线条颜色
void setOutlineStroke(Stroke stroke)   图示边界线条笔触
void setDisplaySeriesLines(boolean flag)  图示项是否显示横线（折线图有效）
void setDisplaySeriesShapes(boolean flag)  图示项是否显示形状（折线图有效）
void setItemFont(Font font)    图示项字体
void setItemPaint(Paint paint)    图示项字体颜色
void setAnchor(int anchor)    图示在图表中的显示位置（参数常量在Legend类中定义）

-------------------------------------------------------------------------------------------

Axis类：
void setVisible(boolean flag)    坐标轴是否可见
void setAxisLinePaint(Paint paint)   坐标轴线条颜色（3D轴无效）
void setAxisLineStroke(Stroke stroke)   坐标轴线条笔触（3D轴无效）
void setAxisLineVisible(boolean visible)  坐标轴线条是否可见（3D轴无效）
void setFixedDimension(double dimension)  （用于复合表中对多坐标轴的设置）
void setLabel(String label)    坐标轴标题
void setLabelFont(Font font)    坐标轴标题字体
void setLabelPaint(Paint paint)    坐标轴标题颜色
void setLabelAngle(double angle)`   坐标轴标题旋转角度（纵坐标可以旋转）
void setTickLabelFont(Font font)   坐标轴标尺值字体
void setTickLabelPaint(Paint paint)   坐标轴标尺值颜色
void setTickLabelsVisible(boolean flag)   坐标轴标尺值是否显示
void setTickMarkPaint(Paint paint)   坐标轴标尺颜色
void setTickMarkStroke(Stroke stroke)   坐标轴标尺笔触
void setTickMarksVisible(boolean flag)   坐标轴标尺是否显示

--------------------------------------------------------------------------

ValueAxis(Axis)类：
void setAutoRange(boolean auto)    自动设置数据轴数据范围
void setAutoRangeMinimumSize(double size)  自动设置数据轴数据范围时数据范围的最小跨度
void setAutoTickUnitSelection(boolean flag)  数据轴的数据标签是否自动确定（默认为true）
void setFixedAutoRange(double length)   数据轴固定数据范围（设置100的话就是显示MAXVALUE到MAXVALUE-100那段数据范围）
void setInverted(boolean flag)    数据轴是否反向（默认为false）
void setLowerMargin(double margin)   数据轴下（左）边距
void setUpperMargin(double margin)   数据轴上（右）边距
void setLowerBound(double min)    数据轴上的显示最小值
void setUpperBound(double max)    数据轴上的显示最大值
void setPositiveArrowVisible(boolean visible)  是否显示正向箭头（3D轴无效）
void setNegativeArrowVisible(boolean visible)  是否显示反向箭头（3D轴无效）
void setVerticalTickLabels(boolean flag)  数据轴数据标签是否旋转到垂直
void setStandardTickUnits(TickUnitSource source) 数据轴的数据标签（可以只显示整数标签，需要将AutoTickUnitSelection设false）

---------------------------------------------------------------------------
NumberAxis(ValueAxis)类：
void setAutoRangeIncludesZero(boolean flag)  是否强制在自动选择的数据范围中包含0
void setAutoRangeStickyZero(boolean flag)  是否强制在整个数据轴中包含0，即使0不在数据范围中
void setNumberFormatOverride(NumberFormat formatter) 数据轴数据标签的显示格式
void setTickUnit(NumberTickUnit unit)   数据轴的数据标签（需要将AutoTickUnitSelection设false）

DateAxis(ValueAxis)类：
void setMaximumDate(Date maximumDate)   日期轴上的最小日期
void setMinimumDate(Date minimumDate)   日期轴上的最大日期
void setRange(Date lower,Date upper)   日期轴范围
void setDateFormatOverride(DateFormat formatter) 日期轴日期标签的显示格式
void setTickUnit(DateTickUnit unit)   日期轴的日期标签（需要将AutoTickUnitSelection设false）
void setTickMarkPosition(DateTickMarkPosition position) 日期标签位置（参数常量在org.jfree.chart.axis.DateTickMarkPosition类中定义）

CategoryAxis(Axis)类：
void setCategoryMargin(double margin)   分类轴边距
void setLowerMargin(double margin)   分类轴下（左）边距
void setUpperMargin(double margin)   分类轴上（右）边距
void setVerticalCategoryLabels(boolean flag)  分类轴标题是否旋转到垂直
void setMaxCategoryLabelWidthRatio(float ratio)  分类轴分类标签的最大宽度

-----------------------------------------------------------------------------------------------------------

Plot类：
void setBackgroundImage(Image image)   数据区的背景图片
void setBackgroundImageAlignment(int alignment)  数据区的背景图片对齐方式（参数常量在org.jfree.ui.Align类中定义）
void setBackgroundPaint(Paint paint)   数据区的背景图片背景色
void setBackgroundAlpha(float alpha)   数据区的背景透明度（0.0～1.0）
void setForegroundAlpha(float alpha)   数据区的前景透明度（0.0～1.0）
void setDataAreaRatio(double ratio)   数据区占整个图表区的百分比
void setOutLinePaint(Paint paint)   数据区的边界线条颜色
void setOutLineStroke(Stroke stroke)   数据区的边界线条笔触
void setNoDataMessage(String message)   没有数据时显示的消息
void setNoDataMessageFont(Font font)   没有数据时显示的消息字体
void setNoDataMessagePaint(Paint paint)   没有数据时显示的消息颜色

CategoryPlot(Plot)类：
void setDataset(CategoryDataset dataset)  数据区的2维数据表
void setColumnRenderingOrder(SortOrder order)  数据分类的排序方式
void setAxisOffset(Spacer offset)   坐标轴到数据区的间距
void setOrientation(PlotOrientation orientation) 数据区的方向（PlotOrientation.HORIZONTAL或PlotOrientation.VERTICAL）
void setDomainAxis(CategoryAxis axis)   数据区的分类轴
void setDomainAxisLocation(AxisLocation location) 分类轴的位置（参数常量在org.jfree.chart.axis.AxisLocation类中定义）
void setDomainGridlinesVisible(boolean visible)  分类轴网格是否可见
void setDomainGridlinePaint(Paint paint)  分类轴网格线条颜色
void setDomainGridlineStroke(Stroke stroke)  分类轴网格线条笔触
void setRangeAxis(ValueAxis axis)   数据区的数据轴
void setRangeAxisLocation(AxisLocation location) 数据轴的位置（参数常量在org.jfree.chart.axis.AxisLocation类中定义）
void setRangeGridlinesVisible(boolean visible)  数据轴网格是否可见
void setRangeGridlinePaint(Paint paint)   数据轴网格线条颜色
void setRangeGridlineStroke(Stroke stroke)  数据轴网格线条笔触
void setRenderer(CategoryItemRenderer renderer)  数据区的表示者（详见Renderer组）
void addAnnotation(CategoryAnnotation annotation) 给数据区加一个注释
void addRangeMarker(Marker marker,Layer layer)  给数据区加一个数值范围区域

PiePlot(Plot)类：
void setDataset(PieDataset dataset)   数据区的1维数据表
void setIgnoreNullValues(boolean flag)   忽略无值的分类
void setCircular(boolean flag)    饼图是否一定是正圆
void setStartAngle(double angle)   饼图的初始角度
void setDirection(Rotation direction)   饼图的旋转方向
void setExplodePercent(int section,double percent) 抽取的那块（1维数据表的分类下标）以及抽取出来的距离（0.0～1.0），3D饼图无效
void setLabelBackgroundPaint(Paint paint)  分类标签的底色
void setLabelFont(Font font)    分类标签的字体
void setLabelPaint(Paint paint)    分类标签的字体颜色
void setLabelLinkMargin(double margin)   分类标签与图的连接线边距
void setLabelLinkPaint(Paint paint)   分类标签与图的连接线颜色
void setLabelLinkStroke(Stroke stroke)   分类标签与图的连接线笔触
void setLabelOutlinePaint(Paint paint)   分类标签边框颜色
void setLabelOutlineStroke(Paint paint)   分类标签边框笔触
void setLabelShadowPaint(Paint paint)   分类标签阴影颜色
void setMaximumLabelWidth(double width)   分类标签的最大长度（0.0～1.0）
void setPieIndex(int index)    饼图的索引（复合饼图中用到）
void setSectionOutlinePaint(int section,Paint paint) 指定分类饼的边框颜色
void setSectionOutlineStroke(int section,Stroke stroke) 指定分类饼的边框笔触
void setSectionPaint(int section,Paint paint)  指定分类饼的颜色
void setShadowPaint(Paint paint)   饼图的阴影颜色
void setShadowXOffset(double offset)   饼图的阴影相对图的水平偏移
void setShadowYOffset(double offset)   饼图的阴影相对图的垂直偏移
void setLabelGenerator(PieSectionLabelGenerator generator) 分类标签的格式，设置成null则整个标签包括连接线都不显示
void setToolTipGenerator(PieToolTipGenerator generator)  MAP中鼠标移上的显示格式
void setURLGenerator(PieURLGenerator generator)   MAP中钻取链接格式

PiePlot3D(PiePlot)类：
void setDepthFactor(double factor)   3D饼图的Z轴高度（0.0～1.0）

MultiplePiePlot(Plot)类：
void setLimit(double limit)    每个饼图之间的数据关联（详细比较复杂）  
void setPieChart(JFreeChart pieChart)   每个饼图的显示方式（见JFreeChart类个PiePlot类）

-----------------------------------------------------------------------------------------------------------

AbstractRenderer类：
void setItemLabelAnchorOffset(double offset)     数据标签的与数据点的偏移
void setItemLabelsVisible(boolean visible)     数据标签是否可见
void setItemLabelFont(Font font)      数据标签的字体
void setItemLabelPaint(Paint paint)      数据标签的字体颜色
void setItemLabelPosition(ItemLabelPosition position)    数据标签位置
void setPositiveItemLabelPosition(ItemLabelPosition position)   正数标签位置
void setNegativeItemLabelPosition(ItemLabelPosition position)   负数标签位置
void setOutLinePaint(Paint paint)      图形边框的线条颜色
void setOutLineStroke(Stroke stroke)      图形边框的线条笔触
void setPaint(Paint paint)       所有分类图形的颜色
void setShape(Shape shape)       所有分类图形的形状（如折线图的点）
void setStroke(Stroke stroke)       所有分类图形的笔触（如折线图的线）
void setSeriesItemLabelsVisible(int series,boolean visible)   指定分类的数据标签是否可见
void setSeriesItemLabelFont(int series,Font font)    指定分类的数据标签的字体
void setSeriesItemLabelPaint(int series,Paint paint)    指定分类的数据标签的字体颜色
void setSeriesItemLabelPosition(int series,ItemLabelPosition position)  数据标签位置
void setSeriesPositiveItemLabelPosition(int series,ItemLabelPosition position) 正数标签位置
void setSeriesNegativeItemLabelPosition(int series,ItemLabelPosition position) 负数标签位置
void setSeriesOutLinePaint(int series,Paint paint)    指定分类的图形边框的线条颜色
void setSeriesOutLineStroke(int series,Stroke stroke)    指定分类的图形边框的线条笔触
void setSeriesPaint(int series,Paint paint)     指定分类图形的颜色
void setSeriesShape(int series,Shape shape)     指定分类图形的形状（如折线图的点）
void setSeriesStroke(int series,Stroke stroke)     指定分类图形的笔触（如折线图的线）

AbstractCategoryItemRenderer(AbstractRenderer)类：
void setLabelGenerator(CategoryLabelGenerator generator)   数据标签的格式
void setToolTipGenerator(CategoryToolTipGenerator generator)   MAP中鼠标移上的显示格式
void setItemURLGenerator(CategoryURLGenerator generator)   MAP中钻取链接格式
void setSeriesLabelGenerator(int series,CategoryLabelGenerator generator) 指定分类的数据标签的格式
void setSeriesToolTipGenerator(int series,CategoryToolTipGenerator generator) 指定分类的MAP中鼠标移上的显示格式
void setSeriesItemURLGenerator(int series,CategoryURLGenerator generator) 指定分类的MAP中钻取链接格式

BarRenderer(AbstractCategoryItemRenderer)类：
void setDrawBarOutline(boolean draw)      是否画图形边框
void setItemMargin(double percent)      每个BAR之间的间隔
void setMaxBarWidth(double percent)      每个BAR的最大宽度
void setMinimumBarLength(double min)      最短的BAR长度，避免数值太小而显示不出
void setPositiveItemLabelPositionFallback(ItemLabelPosition position)  无法在BAR中显示的正数标签位置
void setNegativeItemLabelPositionFallback(ItemLabelPosition position)  无法在BAR中显示的负数标签位置

BarRenderer3D(BarRenderer)类：
void setWallPaint(Paint paint)    3D坐标轴的墙体颜色

StackedBarRenderer(BarRenderer)类：
没有特殊的设置

StackedBarRenderer3D(BarRenderer3D)类：
没有特殊的设置

GroupedStackedBarRenderer(StackedBarRenderer)类：
void setSeriesToGroupMap(KeyToGroupMap map)  将分类自由的映射成若干个组（KeyToGroupMap.mapKeyToGroup(series,group)）

LayeredBarRenderer(BarRenderer)类：
void setSeriesBarWidth(int series,double width)  设定每个分类的宽度（注意设置不要使某分类被覆盖）

WaterfallBarRenderer(BarRenderer)类：
void setFirstBarPaint(Paint paint)   第一个柱图的颜色
void setLastBarPaint(Paint paint)   最后一个柱图的颜色
void setPositiveBarPaint(Paint paint)   正值柱图的颜色
void setNegativeBarPaint(Paint paint)   负值柱图的颜色

IntervalBarRenderer(BarRenderer)类：
需要传IntervalCategoryDataset作为数据源

GanttBarRenderer(IntervalBarRenderer)类：
void setCompletePaint(Paint paint)   完成进度颜色
void setIncompletePaint(Paint paint)   未完成进度颜色
void setStartPercent(double percent)   设置进度条在整条中的起始位置（0.0～1.0）
void setEndPercent(double percent)   设置进度条在整条中的结束位置（0.0～1.0）

StatisticBarRenderer(BarRenderer)类：
需要传StatisticCategoryDataset作为数据源

LineAndShapeRenderer(AbstractCategoryItemRenderer)类：
void setDrawLines(boolean draw)    是否折线的数据点之间用线连
void setDrawShapes(boolean draw)   是否折线的数据点根据分类使用不同的形状
void setShapesFilled(boolean filled)   所有分类是否填充数据点图形
void setSeriesShapesFilled(int series,boolean filled) 指定分类是否填充数据点图形
void setUseFillPaintForShapeOutline(boolean use) 指定是否填充数据点的Paint也被用于画数据点形状的边框

LevelRenderer(AbstractCategoryItemRenderer)类：
void setItemMargin(double percent)   每个分类之间的间隔
void setMaxItemWidth(double percent)   每个分类的最大宽度

CategoryStepRenderer(AbstractCategoryItemRenderer)类：
void setStagger(boolean shouldStagger)   不同分类的图是否交错

MinMaxCategoryRenderer(AbstractCategoryItemRenderer)类：
void setDrawLines(boolean drawLines)   是否在每个分类线间画连接线
void setGroupPaint(Paint groupPaint)   一组图形连接线的颜色
void setGroupStroke(Stroke groupStroke)   一组图形连接线的笔触
void setMaxIcon(Icon maxIcon)    最大值的ICON
void setMinIcon(Icon minIcon)    最小值的ICON
void setObjectIcon(Icon objectIcon)   所有值的ICON

AreaRender(AbstractCategoryItemRenderer)类：
没有特殊的设置

StackedAreaRender(AreaRender)类：
没有特殊的设置

JasperReports 是什么
JasperReports是一个面向开发人员设计的开源Java类库， 通过它可以为Java应用程序增加报表功能。由于 JasperReports 不是独立的工具，所以不能对它进行独立安装。而是要通过应用程序的 CLASSPATH 来包含其类库，从而把它嵌入到 Java应用程序中。JasperReports 是一个 Java类库，也就是说它不是为最终用户准备的。它的目标用户是那些需要为应用程序添加报表功能的Java
开发人员。

JasperReports采用 Lesser GNU Public Library (LGPL)许可协议，所以开放源代码的或不开放源代码的应用程序都可以使用它。通过链接来使用JasperReports 类库的应用程序不需要开放源代码，而需要对现有JasperReports 源代码进行修改的，那么所修改的内容必须也遵循 LGPL 进行发布。更详细的说明可参考 http://www.gnu.org/copyleft/lesser.html。尽管 JasperReports 主要用于通过 Servlet API 来为基于 Web 的应用程序增加报表功能，但它并不是完全依赖于 Servlet API或任何 Java EE类库。因此，它并不仅限于 Web 应用程序。用 JasperReports 来建立独立的桌面程序或命令行程序来生成报表的开发从未停止过。可是，话说又回来，JasperReports除了是一个 Java类库之外，什么都不是。它做的事情只是通过提供 API来为各种Java应用程序增加生成报表的功能。
JasperReports需要 Java Development Kit (JDK) 1.4或更新的版本来进行编译，以便和 JasperReports 的 Java 类库一同工作。同时还需要 Java Runtime Environment (JRE) 1.3或更新的版本来运行这些应用程序。早期版本的 JasperReports 需要 JDK 来运行 JasperReports 应用程序 (严格地讲，JasperReports 需要 tools.jar 被设置在 CLASSPATH 环境变量中，JDK包含了 tools.jar，而 JRE 中没有)。然而，从 0.6.4 版以后，JasperReports把 Eclipse Java Development Tools (JDT)编译器捆绑在一起，因此不再需
要 JDK 来运行部署后的应用程序。本书的例子是用 JDK1.6 开发的，但它们在JasperReports支持的任何其它 JDK 或 JRE上也应该能够顺利地编译和运行。 

JasperReports 的特点
JasperReports 除了以文本数据方式生成报表外，还可以生成包含图片、图表和图形的专业报表。JasperReports的主要特点包括: 
•  灵活的报表排版
•  多样的数据表现方式
•  多样的数据提供方式
•  支持从多种数据源接收数据
•  能够生成水印
•  能够生成子报表
此外，它还可以用许多种格式来输出报表。下面的各小节将对这些特点做简要介绍。

类库依赖
JasperReports借用了其它的开源Java类库来实现其部分功能，其中包括：
iText: 一个用于生成和处理 PDF的类库。另外，它还可以生成和处理 RTF、XML和 HTML文档。JasperReports用它来导出 PDF和 RTF 格式的报表。要获得有关 iText 的详细介绍，可以访问 http://www.lowagie.com/iText/。

JFreeChart: 一个 Java类库，可用于生成各种图表，包括：饼图、条形图、线形图、区域图、等等。JasperReports通过 JFreeChart 来实现其图表功能。有关 JFreeChart 的详细介绍可以查阅http://www.jfree.org/jfreechart/。
 
Apache POI: 一个Java类库， 用于创建和处理各种建立在Microsoft的OLE2混合文档格式基础上的Microsoft Office格式的文档。 JasperReports通过POI来导出XLS 格式的报表，更多的 Jakarta POI有关介绍可查阅http://poi.apache.org/。

JAXP: 用于解析和转换XML文档的 Java API，JasperReports用它来解析XML文件。JAXP 包含在 Java SE 5.0中。如果使用更早版本的Java SE，也可以要独立地下载它。有关 JAXP的详细介绍可以查阅https://jaxp.dev.java.net/。

Apache Commons: 一套 Java类库，提供了大量的可重用组件。JasperReports使用了其中的 Commons Digester、BeanUtils、Logging组件来辅助JAXP 解析XML。关于 Apache Commons的详细介绍可查阅http://commons.apache.org/。

典型的开发流程
下面的图形给出了用 JasperReports创建报表的典型开发流程： 

用 JasperReports进行开发时，第一步要创建报表模板，它是一个 XML文件。它可以通过手工编码来完成，也可以用图形化的报表设计软件完成。虽然JasperReports的报表模板是 XML文件，但其文件名却用.jrxml 来作为扩展名。JasperReports XML模板通常就是指 JRXML文件，本书中也使用这一术语。

jbpm概念
1 ： process definition（流程定义）：
         工作流的流程的完整定义，包括节点和节点之间的走向等关键信息。通常以xml格式提供。一个具体的系统往往是由许多个流程组成的。
2 ： process instance（流程实例）：
         每个process defination生成的业务层的实例。当process instance创建以后，代表流程的执行路径，并被定义到开始节点。
3  ： token（令牌）：
         表示了一个执行的路径，它是运行时产生的。当实例建立以后，令牌也就产生了。
4 ： node：
         表示流程中的一个节点。
5 ： transition：
         关联两个节点，用于表示节点的走向
6 ： signal：
         让一个token执行下一步。process instance也有signal，当用process instance的signal时，其实就是运行process instance根令牌（root token）的signal.   当token进入到一个node时，node会被执行，并产生一些事件，比如进入、离开节点等，这也是执行业务逻辑的地方。事件由action来表示。
7 ： 事件Event 
        Event反映的是流程执行中的各个时刻。在流程执行中JBPM引擎会在计算下一个状态的时候触发各种事件。一个事件通常和流程定义中的一个元素相关联，比如流程定义本身，节点或者转移。大部分的元素能够触发不同类型的事件，比如一个节点可以触发节点进入事件，节点离开事件。事件其实是和动作连接在一起的。每个事件维护一个动作列表。当JBPM引擎触发一个事件的时候，该事件维护的动作列表中的动作将被执行。
 

事件类型
在JBPM中事件类型是写死在事件类中的，共有16种：
EVENTTYPE_TRANSITION = "transition"; // 转移
EVENTTYPE_BEFORE_SIGNAL = "before-signal"; // 发信号前
EVENTTYPE_AFTER_SIGNAL = "after-signal"; // 发信号后
EVENTTYPE_PROCESS_START = "process-start"; // 处理开始状态
EVENTTYPE_PROCESS_END = "process-end"; // 处理结束状态
EVENTTYPE_NODE_ENTER = "node-enter"; // 进入节点
EVENTTYPE_NODE_LEAVE = "node-leave"; // 离开节点
EVENTTYPE_SUPERSTATE_ENTER = "superstate-enter"; // 进入超级状态
EVENTTYPE_SUPERSTATE_LEAVE = "superstate-leave"; // 离开超级状态
EVENTTYPE_SUBPROCESS_CREATED = "subprocess-created"; // 子流程创建
EVENTTYPE_SUBPROCESS_END = "subprocess-end"; // 子流程结束
EVENTTYPE_TASK_CREATE = "task-create"; // 任务创建
EVENTTYPE_TASK_ASSIGN = "task-assign"; // 任务分派
EVENTTYPE_TASK_START = "task-start"; // 任务启动
EVENTTYPE_TASK_END = "task-end"; // 任务结束
EVENTTYPE_TIMER = "timer"; // 定时器

常用API
ProcessInstance是ProcessDefinition的一个执行实例，想象一下对于订票流程，每个客户的订票动作都会根据订票流程定义而创建一个流程实例，也就是执行实例ProcessInstance.当一个ProcessInstance被创建后，负责执行主路径的token也被创建，这个token就是根token(root token)，根token此时位于流程定义的开始状态start state.

创建执行实例很简单有2种方式 ：
1 ： 通过 ProcessDefinition 类的 createProcessInstance() 方法

//得到 processDefinition 
ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("processdefinition.xml");
//通过 processDefinition 创建 出 processInstance
ProcessInstance  processInstance = processDefinition.createProcessInstance();

//得到 jbpmContext
JbpmContext jbpmContext = JbpmConfiguration.getInstance().createJbpmContext();

//得到 processDefinition
ProcessDefinition processDefinition = jbpmContext.getGraphSession().findLatestProcessDefinition("baoxiao");

//得到 processInstance
 ProcessInstance processInstance = new ProcessInstance(processDefinition);