一、首先，模塊的組織更加的細致，從那么多的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.aygfsteel.com/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加入其中?？纯慈康膬热荨?nbsp;

 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
    

    
Jakarta Struts Homepage
    
 -- 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);