找到

<resin:import path=”${resin.home}/conf/app-default.xml”/>

改成  

<resin:import path=”./conf/app-default.xml”/>

或者添加环境变量

RESIN_HOME为：d:\resin-3.1.6

第二个是

 <web-app-deploy path=”webapps”/>的后面添加 <web-app-deploy path=”deploy”/>，

默认情况下，并没有这个Webapp目录，所以要添加这个目录，因为eclipse部署的WebApp都部署在这个目录下面了。

就是说在一些Object/Relation Mapping工具中，能够做到维护数据库表记录的persisent object完全是一个符合Java Bean规范的纯Java对象，没有增加别的属性和方法。全都是这样子的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class User
{    
	private long id;    
	private String name;   
	public void setId(long id) 
	{   
		this.id = id;   
	}     
	public void setName(String name) 
	{   
		this.name=name;   
	}    
	public long getId() 
	{   
		return id;   
	}     
	public String getName() 
	{    
		return name;   
	}   
}

首先要区别持久对象和POJO。
持久对象实际上必须对应数据库中的entity，所以和POJO有所区别。比如说POJO是由new创建，由GC回收。但是持久对象是insert数据库创建，由数据库delete删除的。基本上持久对象生命周期和数据库密切相关。另外持久对象往往只能存在一个数据库Connection之中，Connnection关闭以后，持久对象就不存在了，而POJO只要不被GC回收，总是存在的。
由于存在诸多差别，因此持久对象PO(Persistent Object)在代码上肯定和POJO不同，起码PO相对于POJO会增加一些用来管理数据库entity状态的属性和方法。
而ORM追求的目标就是要PO在使用上尽量和POJO一致，对于程序员来说，他们可以把PO当做POJO来用，而感觉不到PO的存在。

Hibernate的实现方法比较先进：
1、编写POJO
2、编译POJO
3、直接运行，在运行期，由Hibernate的CGLIB动态把POJO转换为PO。

由此可以看出Hibernate是在运行期把POJO的字节码转换为PO的，而JDO是在编译期转换的。一般认为JDO的方式效率会稍高，毕竟是编译期转换嘛。但是Hibernate的作者Gavin King说CGLIB的效率非常之高，运行期的PO的字节码生成速度非常之快，效率损失几乎可以忽略不计。
实际上运行期生成PO的好处非常大，这样对于程序员来说，是无法接触到PO的，PO对他们来说完全透明。可以更加自由的以POJO的概念操纵PO。另外由于是运行期生成PO，所以可以支持增量编译，增量调试。而JDO则无法做到这一点。实际上已经有很多人在抱怨JDO的编译期Enhancer问题了，而据说JBossDO将采用运行期生成PO字节码，而不采用编译期生成PO字节码。

另外一个相关的问题是，不同的JDO产品的Enhancer生成的PO字节码可能会有所不同，可能会影响在JDO产品之间的可移植性，这一点有点类似EJB的可移植性难题。

———————————————————————————–
由这个问题另外引出一个JDO的缺陷。

由于JDO的PO状态管理方式，所以当你在程序里面get/set的时候，实际上不是从PO的实例中取values，而是从JDO StateManager中取出来，所以一旦PM关闭，PO就不能进行存取了。

在JDO中，也可以通过一些办法使得PO可以在PM外面使用，比如说定义PO是transient的，但是该PO在PM关闭后就没有PO identity了。无法进行跨PM的状态管理。

而Hibernate是从PO实例中取values的，所以即使Session关闭，也一样可以get/set，可以进行跨Session的状态管理。
在分多层的应用中，由于持久层和业务层和web层都是分开的，此时Hibernate的PO完全可以当做一个POJO来用，也就是当做一个VO，在各层间自由传递，而不用去管Session是开还是关。如果你把这个POJO序列化的话，甚至可以用在分布式环境中。（不适合lazy loading的情况）
但是JDO的PO在PM关闭后就不能再用了，所以必须在PM关闭前把PO拷贝一份VO，把VO传递给业务层和web层使用。在非分布式环境中，也可以使用ThreadLocal模式确保PM始终是打开状态，来避免每次必须进行PO到VO的拷贝操作。但是不管怎么说，这总是权宜之计，不如Hibernate的功能强。

以下是我的MyEclipse快捷方式的参数:
“D:\Eclipse 3.2.2\eclipse.exe” -product com.genuitec.myeclipse.product.ide -vmargs -Duser.language=en -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M -Dosgi.splashLocation=”d:\MyEclipse 5.0GA\eclipse\MyEclipseSplash.bmp”

对于MyEclipse的话，直接修改MyEclipse在桌面的快捷方式的参数就可以啦。现在解释这些参数的意思。

-vmargs：说明后面是VM的参数
-Xms40m：虚拟机占用系统的最小内存
-Xmx256m：虚拟机占用系统的最大内存
-XX:PermSize：最小堆大小。一般报内存不足时,都是说这个太小,
堆空间剩余小于5%就会警告,建议把这个稍微设大一点,不过要视自己机器内存大小来设置
-XX:MaxPermSize：最大堆大小。这个也适当大些
-Xmx512M的5%为25.6M，理论上要求-Xmx的数值与-XX:MaxPermSize必须大于25.6M

把里面的参数改为
-vmargs
-Xms128M
-Xmx512M
-XX:PermSize=128M
-XX:MaxPermSize=256M

所以对于我而言，我只要把我的MyEclipse5.0改-XX:PermSize=128M-XX:MaxPermSize=256M，问题解决！
(个人补充一点：参数在你安装的exlipse目录下的eclipse.ini文件中)

could not interpret id generator strategy: uuid.String

查了些资料最后得出结论：

在hibernate2.1中，主键生成策略中uuid分为uuid.hex和uuid.string，但是从hibernate3.0开始已经不再支持uuid.string

正好在复习下主键策略了。

(1) assigned

主键由外部程序负责生成，无需Hibernate参与。

(2) hilo

通过hi/lo 算法实现的主键生成机制，需要额外的数据库表保存主键生成历史状态。

(3) seqhilo

与hilo 类似，通过hi/lo 算法实现的主键生成机制，只是主键历史状态保存在Sequence中，适用于支持Sequence的数据库，如Oracle。

(4) increment

主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。

这种方式可能产生的问题是：如果当前有多个实例访问同一个数据库，那么由于各个实例各自维护主键状态，不同实例可能生成同样的主键，从而造成主键重复异常。因此，如果同一数据库有多个实例访问，此方式必须避免使用。

(5) identity

采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL中的主键生成机制。

(6) sequence

采用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。

(7) native

由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式。

(8) uuid.hex

由Hibernate基于128 位唯一值产生算法生成16 进制数值（编码后以长度32 的字符串表示）作为主键。

(9) uuid.string

与uuid.hex 类似，只是生成的主键未进行编码（长度16）。在某些数据库中可能出现问题（如PostgreSQL）。

(10) foreign

使用外部表的字段作为主键。
一般而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适
应性。

另外由于常用的数据库，如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。我们可以在数据库提供的主键生成机制上，采用generator-class=native的主键生成方式。
不过值得注意的是，一些数据库提供的主键生成机制在效率上未必最佳，大量并发insert数据时可能会引起表之间的互锁。

数据库提供的主键生成机制，往往是通过在一个内部表中保存当前主键状态（如对于自增型主键而言，此内部表中就维护着当前的最大值和递增量），之后每次插入数据会读取这个最大值，然后加上递增量作为新记录的主键，之后再把这个新的最大值更新回内部表中，这样，一次Insert操作可能导致数据库内部多次表读写操作，同时伴随的还有数据的加锁解锁操作，这对性能产生了较大影响。因此，对于并发Insert要求较高的系统，推荐采用uuid.hex 作为主键生成
机制。

比如，在java 5，java.util.List 已经被泛化。当建立一个list对象时，你通过传递一个java类型建立一个List实例，此list实例只能作用于所传递的类型。这意味着如果你传递一个String ,此List实例只能拥有String对象；如果你传递一个Integer，此实例只能存贮Integer对象。除了创建参数化的类型，你还能创建参数化的函数.
     泛型的第一个好处是编译时的严格类型检查。这是集合框架最重要的特点。此外,泛型消除了绝大多数的类型转换。在JDK 5.0之前，当你使用集合框架时，你不得不进行类型转换。
     本文将教你如何操作泛型。它的第一部分是“没有泛型的日子”，先让我们回忆老版本JDK的不便。然后，举一些泛型的例子。在讨论完语法以及有界泛型的使用之后，文章最后一章将解释如何写泛型。

没有泛型的日子
    所有的java类都源自java.lang.Object,这意味着所有的JAVA对象能转换成Object。
因此，在之前的JDK的版本中，很多集合框架的函数接受一个Object参数。
所以，collections是一个能持有任何对象的多用途工具，但带来了不良的后果。

举个简单的例子，在JDK 5.0的之前版本中，类List的函数add接受一个Object参数：

1

public boolean add(java.lang.Object element)

所以你能传递任何类型给add。这是故意这么设计的。否则，它只能传递某种特定的对象，这样就会出现各种List类型，如，StringList, EmployeeList, AddressList等。

add通过Object传递能带来好处,现在我们考虑get函数(返回List中的一个元素).如下是JDK 5之前版本的定义：

1

public java.lang.Object get(int index) throws IndexOutOfBoundsException

get返回一个Object.不幸的事情从此开始了.假如你储存了两个String对象在一个List中:

1
2
3

List stringList1 = new ArrayList();
stringList1.add("Java 5");
stringList1.add("with generics");

当你想从stringList1取得一个元素时,你得到了一个Object.为了操作原来的类型元素,你不得不把它转换为String。

1

String s1 = (String) stringList1.get(0);

泛型入门

像一个函数能接受参数一样,一个泛型也能接受参数.这就是一个泛型经常被称为一个参数化类型的原因.但是不像函数用()传递参数,泛型是用<>传递参数的.声明一个泛型和声明一个普通类没有什么区别,只不过你把泛型的变量放在<>中.

比如,在JDK 5中,你可以这样声明一个java.util.List : List<E> myList;
E 称为类型变量.意味着一个变量将被一个类型替代.替代类型变量的值将被当作参数或返回类型.对于List接口来说,当一个实例被创建以后,E 将被当作一个add或别的函数的参数.E 也会使get或别的参数的返回值.下面是add和get的定义:

1
2

boolean add<E o>
E get(int index)

一个泛型在声明或例示时允许你传递特定的类型变量: E.除此之外,如果E是个类，你可以传递子类；如果E是个接口，你可以传递实现接口的类；

如果你传递一个String给一个List，比如：

1

List<String> myList;

那么mylist的add函数将接受一个String作为他的参数，而get函数将返回一个String.因为返回了一个特定的类型，所以不用类型转化了。

根据惯例，我们使用一个唯一的大写字目表示一个类型变量。为了创建一个泛型，你需在声明时传递同样的参数列表。比如，你要想创建一个ArrayList来操作String ，你必须把String放在<>中。如：

1

List<String> myList = new ArrayList<String>();

再比如，java.util.Map 是这么定义的：

1

public interface Map<K,V>

K用来声明map键(KEY)的类型而V用来表示值(VALUE)的类型。put和values是这么定义的：

1
2

V put(K key, V value)
Collection<V> values()

一个泛型不准直接的或间接的是java.lang.Throwable的子类。因为异常是在运行时抛出的,所以它不可能预言什么类型的异常将在编译时抛出.
列表1的例子将比较List在JDK 1.4 和JDK1.5的不同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import java.util.List;
import java.util.ArrayList;
 
public class GenericListTest
{
	public static void main(String[] args)
	{
		// in JDK 1.4
		List stringList1 = new ArrayList();
		stringList1.add("Java 1.0 - 5.0");
		stringList1.add("without generics");   
 
		// cast to java.lang.String
		String s1 = (String) stringList1.get(0);
		System.out.println(s1.toUpperCase());    
 
		// now with generics in JDK 5
		List stringList2 = new ArrayList();
		stringList2.add("Java 5.0");
		stringList2.add("with generics");    
 
		// no need for type casting
		String s2 = stringList2.get(0);
		System.out.println(s2.toUpperCase());
	}
 
}

在列表1中，stringList2是个泛型。声明List<String>告诉编译器List的实例能接受一个String对象。当然，在另外的情况中，你能新建能接受各种对象的List实例。注意，当从List实例中返回成员元素时，不需要对象转化，因为他返回的了你想要的类型，也就是String.

最让人感兴趣的事情是，一个泛型是个类型并且能被当作一个类型变量。比如，你想你的List储存lists of Strings,你能通过把List<String>作为他的类型变量来声明List。比如：

1

List<List<String>> myListOfListsOfStrings;

要从myList中的第一个List重新取得String，你可以这么用：

1

String s = myListOfListsOfStrings.get(0).get(0);

下一个列表中的ListOfListsTest类示范了一个List（命名为listOfLists）接受一个String List作为参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import java.util.ArrayList;
import java.util.List;
 
public class ListOfListsTest 
{  
	public static void main(String[] args) 
	{    
		List<String> listOfStrings = new ArrayList<String>();    
		listOfStrings.add("Hello again"); 
 
		List<List<String>> listOfLists = new ArrayList<List<String>>();    
		listOfLists.add(listOfStrings);    
		String s = listOfLists.get(0).get(0);    
		System.out.println(s); 
		// prints "Hello again"  
 
	}
}

另外，一个泛型接受一个或多个类型变量。比如，java.util.Map有两个类型变量s。第一个定义了键（key）的类型，第二个定义了值（value)的类型。下面的例子讲教我们如何使用个一个泛型Map.

1
2
3
4
5
6
7
8
9
10

public class MapTest
{
	public static void main(String[] args)
	{
		Map map = new HashMap();
		map.put("key1", "value1");
		map.put("key2", "value2");
		String value1 = map.get("key1");
	}
}

在这个例子中，重新得到一个key1代表的String值，我们不需要任何类型转换。

没有参数的情况下使用泛型

既然在J2SE 5.0中收集类型已经泛型化，那么，原来的使用这些类型的代码将如何呢？很幸运，他们在JAVA 5中将继续工作，因为你能使用没有参数的泛型。比如，你能继续像原来一样使用List接口，正如下面的例子一样。

1
2
3
4

List stringList1 = new ArrayList();
stringList1.add("Java 1.0 - 5.0");
stringList1.add("without generics");
String s1 = (String) stringList1.get(0);

一个没有任何参数的泛型被称为原型(raw type)。它意味着这些为JDK1.4或更早的版本而写的代码将继续在java 5中工作。

尽管如此，一个需要注意的事情是，JDK５编译器希望你使用带参数的泛型。否则，编译器将提示警告，因为他认为你可能忘了定义类型变量s。比如，编译上面的代码的时候你会看到下面这些警告，因为第一个List被认为是原型。

当你使用原型时，如果你不想看到这些警告，你有几个选择来达到目的：
1.编译时带上参数-source 1.4
2.使用@SupressWarnings(“unchecked”)注释
3.更新你的代码，使用List<Object>. List<Object>的实例能接受任何类型的对象，就像是一个原型List。然而，编译器不会报错。

使用 ? 通配符
前面提过，如果你声明了一个List<aType>, 那么这个List对aType起作用，所以你能储存下面这些类型的对象：
1.一个aType的实例
2.它的子类的实例(如果aType是个类)
3.实现aType接口的类实例(如果aType是个接口)
但是，请注意，一个泛型本身是个JAVA类型，就像java.lang.String或java.io.File一样。传递不同的类型变量给泛型可以创建不同的JAVA类型。比如，下面例子中list1和list2引用了不同的类型对象。

1
2

List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();

list1指向了一个类型变量s为java.lang.Objects 的List而list2指向了一个类型变量s为String 的List。所以传递一个List<String>给一个参数为List<Object>的函数将导致compile time错误。下面列表可以说明：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import java.util.ArrayList;
import java.util.List; 
 
public class AllowedTypeTest 
{  
	public static void doIt(List<Object> l) 
	{  }  
	public static void main(String[] args) 
	{    
		List<String> myList = new ArrayList<String>();    
		// 这里将产生一个错误    
		doIt(myList);  
	}
}

上面的代码无法编译，因为你试图传递一个错误的类型给函数doIt。doIt的参数是List<Object>二你传递的参数是List<String>。
可以使用 ? 通配符解决这个难题。List<?> 意味着一个对任何对象起作用的List。所以，doIt可以改为：

1

public static void doIt(List<?> l) {}

在某些情况下你会考虑使用 ? 通配符。比如，你有一个printList函数，这个函数打印一个List的所有成员，你想让这个函数对任何类型的List起作用时。否则，你只能累死累活的写很多printList的重载函数。下面的列表引用了使用 ? 通配符的printList函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.ArrayList;
import java.util.List; 
 
public class WildCardTest 
{   
	public static void printList(List<?> list) 
	{    
		for (Object element : list) 
		{      
			System.out.println(element);    
		}  
	}  
 
	public static void main(String[] args) 
	{    
		List<String> list1 = new ArrayList<String>();    
		list1.add("Hello");    
		list1.add("World");    
		printList(list1);  
 
		List<Integer> list2 = new ArrayList<Integer>();    
		list2.add(100);    
		list2.add(200);    
		printList(list2);  
	}
}

这些代码说明了在printList函数中，List<?>表示各种类型的List对象。然而，请注意，在声明的时候使用 ? 通配符是不合法的，像这样：

1

List<?> myList = new ArrayList<?>(); // 不合法

如果你想创建一个接收任何类型对象的List，你可以使用Object作为类型变量，就像这样：

1

List<Object> myList = new ArrayList<Object>();

在函数中使用界限通配符
在之前的章节中，你学会了通过传递不同的类型变量s来创建不同JAVA类型的泛型，但并不考虑类型变量s之间的继承关系。在很多情况下，你想一个函数有不同的List参数。比如，你有一个函数getAverage，他返回了一个List中成员的平均值。然而，如果你把List<Number>作为getAverage的参数，你就没法传递List<Integer> 或List<Double>参数，因为List<Number>和List<Integer> 和List<Double>不是同样的类型。

你能使用原型或使用通配符，但这样无法在编译时进行安全类型检查，因为你能传递任何类型的List，比如List<String>的实例。你可以使用List<Number>作为参数，但是你就只能传递List<Number>给函数。但这样就使你的函数功能减少，因为你可能更多的时候要操作List<Integer>或List<Long>，而不是List<Number>。

J2SE5.0增加了一个规则来解决了这种约束，这个规则就是允许你定义一个上界(upper bound) 类型变量.在这种方式中，你能传递一个类型或它的子类。在上面getAverage函数的例子中，你能传递一个List<Number>或它的子类的实例，比如List<Integer> or List<Float>。

使用上界规则的语法这么定义的：GenericType<? extends upperBoundType>. 比如，对getAverage函数的参数，你可以这么写List<? extends Number>. 下面例子说明了如何使用这种规则。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.ArrayList;
import java.util.List;
 
public class BoundedWildcardTest 
{  
	public static double getAverage(List<? extends Number> numberList)  
	{    
		double total = 0.0;    
		for (Number number : numberList)      
			total += number.doubleValue();    
		return total/numberList.size();  
	}   
	public static void main(String[] args) 
	{    
		List<Integer> integerList = new ArrayList<Integer>();    
		integerList.add(3);    
		integerList.add(30);    
		integerList.add(300);    
		System.out.println(getAverage(integerList)); // 111.0    
 
		List<Double> doubleList = new ArrayList<Double>();    
		doubleList.add(3.0);    
		doubleList.add(33.0);    
		System.out.println(getAverage(doubleList)); // 18.0  
	}
}

由于有了上界规则，上面例子中的getAverage函数允许你传递一个List<Number> 或一个类型变量是任何java.lang.Number子类的List。

下界规则
关键字extends定义了一个类型变量的上界。通过使用super关键字，我们可以定义一个类型变量的下界，尽管使用的情况不多。比如，如果一个函数的参数是List<? super Integer>，那么意味着你可以传递一个List<Integer>的实例或者任何java.lang.Integer的超类(superclass)。

创建泛型

前面的章节主要说明了如何使使用泛型，特别是集合框架中的类。现在我们开始学习如何写自己的泛型。

基本上，除了声明一些你想要使用的类型变量s外，一个泛型和别的类没有什么区别。这些类型变量s位于类型后面的<>中。比如，下面的Point就是个泛型。一个Point对象代表了一个系统中的点，它有横坐标和纵坐标。通过使Point泛型化，你能定义一个点实例的精确程度。比如，如果一个Point对象需要非常精确，你就把Double作为类型变量。否则，Integer 就够了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Point<T> 
{  
	T x;  //定义泛型成员变量
	T y;  
 
	public Point(T x, T y) 
	{    
		this.x = x;    
		this.y = y;  
	}  
 
	public T getX() 
	{    
		return x;  
	}  
 
	public T getY() 
	{    
		return y;  
	}  
 
	public void setX(T x) 
	{    
		this.x = x;  
	}  
 
	public void setY(T y) 
	{    
		this.y = y;  
	}
}

在这个例子中，T是Point的类型变量 。T是getX和getY的返回值类型，也是setX和setY的参数类型。此外，构造函数结合两个T参数。
使用point类就像使用别的类一样。比如，下面的例子创建了两个Point对象：ponint1和point2。前者把Integer作为类型变量，而后者把Double作为类型变量。

1
2
3
4

Point<Integer> point1 = new Point<Integer>(4, 2);
point1.setX(7);
Point<Double> point2 = new Point<Double>(1.3, 2.6);
point2.setX(109.91);

总结
泛型使代码在编译时有了更严格的类型检查。特别是在集合框架中，泛型有两个作用。第一，他们增加了对集合类型在编译时的类型检查，所以集合类所能持有的类型对传递给它的参数类型起了限制作用。比如你创建了一个持有strings的java.util.List实例，那么他就将不能接受Integers或别的类型。其次，当你从一个集合中取得一个元素时，泛型消除了类型转换的必要。
泛型能够在没有类型变量的情况下使用，比如，作为原型。这些措施让Java 5之前的代码能够运行在JRE 5中。但是，对新的应用程序，你最好不要使用原型，因为以后Java可能不支持他们。

你已经知道通过传递不同类型的类型变量给泛型可以产生不同的JAVA类型。就是说List<String>和List<Object>的类型是不同的。尽管String是java.lang.Object。但是传递一个List<String>给一个参数是List<Object>的函数会参数会产生编译错误（compile error）。函数能用 ? 通配符使其接受任何类型的参数。List<?> 意味着任何类型的对象。
最后，你已经看到了写一个泛型和别的一般JAVA类没有什么区别。你只需要在类型名称后面的<>中声明一系列的类型变量s就行了。这些类型变量s就是返回值类型或者参数类型。根据惯例，一个类型变量用一个大写字母表示。

< bean id = "userDAOProxy" class = "org.springframework.transaction.interceptor.TransactionProxyFactoryBean" > 
        < property name = "transactionManager" > 
            < ref bean = "transactionManager" /> 
        </ property > 
        < property name = "target" > 
            < ref local = "UserDAO" /> 
        </ property > 
    </ bean >

1 、用 local 属性指定目标 bean 可以利用 xml 解析器的能力在同一个文件中验证 xml id 引用 . 如果在同一个文件中没有匹 配的元素 ,xml 解析器就会产生一个 error, 所以如果目标 bean 在同一个 xml 文件中 , 那么用 local 形式是最好的选择 .

2 、可以这么说，
bean是寻找全局中的 bean;
local是寻找本 xml 文件中的 bean

3 、 提供了如下几方面的属性 :
1)bean: 在当前 Spring XML 配置文件中，或者在同一 BeanFactory(ApplicationContext) 中的其他 JavaBean 中 .

2)local: 在当前 Spring XML 配置文件中 . 其依赖的 JavaBean 必须存在于当前 Spring XML 培植文件中 . 如果借助 于 Spring IDE, 则在编译期可以对其依赖的 JavaBean 进行验证。基于 local 方式，开发者能够使用到 XML 本身提供 的优势，而进行验证。

3)parent: 用于指定其依赖的父 JavaBean 定义。

在接下来您将会了解到三种将 Struts MVC 整合到 Spring 框架的方法。我将揭示每种方法的缺陷并且对比它们的优点。 一旦您了解到所有三种方法的作用，我将会向您展示一个令人兴奋的应用程序，这个程序使用的是这三种方法中我最喜欢的一种。

使用 Spring 的 ActionSupport 类整合 Structs
使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor
将 Struts Action 管理委托给 Spring 框架

1. 使用 Spring 的 ActionSupport
手动创建一个 Spring 环境是一种整合 Struts 和 Spring 的最直观的方式。为了使它变得更简单，Spring 提供了一些帮助。为了方便地获得 Spring 环境，org.springframework.web.struts.ActionSupport 类提供了一个 getWebApplicationContext() 方法。您所做的只是从 Spring 的 ActionSupport 而不是 Struts Action 类扩展您的动作

package ca.nexcel.books.actions;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.DynaActionForm;
import org.springframework.context.ApplicationContext;
import org.springframework.web.struts.ActionSupport;
import ca.nexcel.books.beans.Book;
import ca.nexcel.books.business.BookService;
public class SearchSubmit extends ActionSupport {   |(1)
  public ActionForward execute(
    ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response)
    throws IOException, ServletException {
    DynaActionForm searchForm = (DynaActionForm) form;
    String isbn = (String) searchForm.get("isbn");
 
    //the old fashion way
    //BookService bookService = new BookServiceImpl();
 
    ApplicationContext ctx = 
      getWebApplicationContext();    |(2)
    BookService bookService = 
      (BookService) ctx.getBean("bookService");   |(3)
 
  Book book = bookService.read(isbn.trim());
    if (null == book) {
      ActionErrors errors = new ActionErrors();
      errors.add(ActionErrors.GLOBAL_ERROR,new ActionError
        ("message.notfound"));
      saveErrors(request, errors);
      return mapping.findForward("failure") ;
  }
    request.setAttribute("book", book);
    return mapping.findForward("success");
  }
}

让我们快速思考一下这里到底发生了什么。在 (1) 处，我通过从 Spring 的 ActionSupport 类而不是 Struts 的 Action 类进行扩展，创建了一个新的 Action。在 (2) 处，我使用 getWebApplicationContext() 方法获得一个 ApplicationContext。为了获得业务服务，我使用在 (2) 处获得的环境在 (3) 处查找一个 Spring bean。

这种技术很简单并且易于理解。不幸的是，它将 Struts 动作与 Spring 框架耦合在一起，对Struts的侵入性非常大。如果您想替换掉 Spring，那么您必须重写代码。并且，由于 Struts 动作不在 Spring 的控制之下，所以它不能获得 Spring AOP 的优势。当使用多重独立的 Spring 环境时，这种技术可能有用，但是在大多数情况下，这种方法不如另外两种方法合适。

2. 覆盖 RequestProcessor
将 Spring 从 Struts 动作中分离是一个更巧妙的设计选择。分离的一种方法是使用org.springframework.web.struts.DelegatingRequestProcessor 类来覆盖 Struts 的 RequestProcessor 处理程序

Struts配置文件：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
          "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
 <form-beans>
    <form-bean name="searchForm" 
      type="org.apache.struts.validator.DynaValidatorForm">
               <form-property name="isbn"    type="java.lang.String"/>
    </form-bean>
 
  </form-beans>
 <global-forwards type="org.apache.struts.action.ActionForward">
     <forward   name="welcome"                path="/welcome.do"/>
     <forward   name="searchEntry"            path="/searchEntry.do"/>
     <forward   name="searchSubmit"           path="/searchSubmit.do"/>
 </global-forwards>
 <action-mappings>
    <action    path="/welcome" forward="/WEB-INF/pages/welcome.htm"/>
    <action    path="/searchEntry" forward="/WEB-INF/pages/search.jsp"/>
    <action    path="/searchSubmit" 
               type="ca.nexcel.books.actions.SearchSubmit"
               input="/searchEntry.do"
               validate="true"
               name="searchForm">
              <forward name="success" path="/WEB-INF/pages/detail.jsp"/>
              <forward name="failure" path="/WEB-INF/pages/search.jsp"/>
    </action>  
 </action-mappings>
 <message-resources parameter="ApplicationResources"/>
 <controller processorClass="org.springframework.web.struts.
   DelegatingRequestProcessor"/> |(1)
 <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
    <set-property property="pathnames" 
      value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
 </plug-in>
 <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="csntextConfigLocation" value="/WEB-INF/beans.xml"/>
 </plug-in>
 
</struts-config>

我利用了 标记来用 DelegatingRequestProcessor 覆盖默认的 Struts RequestProcessor。下一步是在我的 Spring 配置文件中注册该动作

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
  "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
  <bean id="bookService" class="ca.nexcel.books.business.BookServiceImpl"/>
  <bean name="/searchSubmit" 
    class="ca.nexcel.books.actions.SearchSubmit"> |(1)
     <property name="bookService">
        <ref bean="bookService"/>
     </property>
  </bean>
</beans>

注意：在 (1) 处，我使用名称属性注册了一个 bean，以匹配 struts-config 动作映射名称。SearchSubmit 动作揭示了一个 JavaBean 属性，允许 Spring 在运行时填充属性

package ca.nexcel.books.actions;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.DynaActionForm;
import ca.nexcel.books.beans.Book;
import ca.nexcel.books.business.BookService;
public class SearchSubmit extends Action {
 
  private BookService bookService;
  public BookService getBookService() {
    return bookService;
  }
  public void setBookService(BookService bookService) { | (1)
    this.bookService = bookService; 
  } 
  public ActionForward execute(
    ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response)
    throws IOException, ServletException {
    DynaActionForm searchForm = (DynaActionForm) form;
    String isbn = (String) searchForm.get("isbn");
 
  Book book = getBookService().read(isbn.trim());  |(2)
    if (null == book) {
      ActionErrors errors = new ActionErrors();
      errors.add(ActionErrors.GLOBAL_ERROR,new ActionError("message.notfound"));
      saveErrors(request, errors);
      return mapping.findForward("failure") ;
  }
      request.setAttribute("book", book);
      return mapping.findForward("success");
  }
}

在 (1) 处，我创建了一个 JavaBean 属性。DelegatingRequestProcessor自动地配置这种属性。这种设计使 Struts 动作并不知道它正被 Spring 管理，并且使您能够利用 Sping 的动作管理框架的所有优点。由于您的 Struts 动作注意不到 Spring 的存在，所以您不需要重写您的 Struts 代码就可以使用其他控制反转容器来替换掉 Spring。

DelegatingRequestProcessor 方法的确比第一种方法好，但是仍然存在一些问题。如果您从写了Struts的 RequestProcessor，则需要手动整合 Spring 的 DelegatingRequestProcessor。添加的代码会造成维护的麻烦并且将来会降低您的应用程序的灵活性。此外，还有过一些使用一系列命令来代替 Struts RequestProcessor 的传闻。 这种改变将会对这种解决方法的使用寿命造成负面的影响。

3. 将动作管理委托给 Spring 的 DelegatingActionProxy类

一个更好的解决方法是将 Strut 动作管理委托给 Spring。您可以通过在 struts-config 动作映射中注册一个代理来实现。代理负责在 Spring 环境中查找 Struts 动作。由于动作在 Spring 的控制之下，所以它可以填充动作的 JavaBean 属性，并为应用诸如 Spring 的 AOP 拦截器之类的特性带来了可能。

struts-config 内容：

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
          "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
 <form-beans>
    <form-bean name="searchForm" 
      type="org.apache.struts.validator.DynaValidatorForm">
               <form-property name="isbn"    type="java.lang.String"/>
    </form-bean>
 
  </form-beans>
 <global-forwards type="org.apache.struts.action.ActionForward">
     <forward   name="welcome"                path="/welcome.do"/>
     <forward   name="searchEntry"            path="/searchEntry.do"/>
     <forward   name="searchSubmit"           path="/searchSubmit.do"/>
 </global-forwards>
 <action-mappings>
    <action    path="/welcome" forward="/WEB-INF/pages/welcome.htm"/>
    <action    path="/searchEntry" forward="/WEB-INF/pages/search.jsp"/>
    <action    path="/searchSubmit" 
             type="org.springframework.web.struts.DelegatingActionProxy" |(1)
             input="/searchEntry.do"
             validate="true"
             name="searchForm">
             <forward name="success" path="/WEB-INF/pages/detail.jsp"/>
             <forward name="failure" path="/WEB-INF/pages/search.jsp"/>
    </action>  
 </action-mappings>
 <message-resources parameter="ApplicationResources"/>
 <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
    <set-property 
    property="pathnames" 
    value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
 </plug-in>
 <plug-in 
    className="org.springframework.web.struts.ContextLoaderPlugIn">
    <set-property property="contextConfigLocation" value="/WEB-INF/beans.xml"/>
 </plug-in>
 
</struts-config>

一个典型的 struts-config.xml 文件，只有一个小小的差别。它注册 Spring 代理类的名称，而不是声明动作的类名，如（1）处所示。DelegatingActionProxy 类使用动作映射名称查找 Spring 环境中的动作。这就是我们使用 ContextLoaderPlugIn 声明的环境。

将一个 Struts 动作注册为一个 Spring bean 是非常直观的。我利用动作映射使用 标记的名称属性（在这个例子中是 “/searchSubmit”）简单地创建了一个 bean。这个动作的 JavaBean 属性像任何 Spring bean 一样被填充：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
 "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
  <bean id="bookService" class="ca.nexcel.books.business.BookServiceImpl"/>
  <bean name="/searchSubmit"   
        class="ca.nexcel.books.actions.SearchSubmit">
     <property name="bookService">
        <ref bean="bookService"/>
     </property>
  </bean>
</beans>

动作委托解决方法是这三种方法中最好的。Struts 动作不了解 Spring，不对代码作任何改变就可用于非 Spring 应用程序中。RequestProcessor 的改变不会影响它，并且它可以利用 Spring AOP 特性的优点。

动作委托的优点不止如此。一旦让 Spring 控制您的 Struts 动作，您就可以使用 Spring 给动作补充更强的活力。例如，没有 Spring 的话，所有的 Struts 动作都必须是线程安全的。如果您设置 标记的 singleton 属性为“false”，那么不管用何种方法，您的应用程序都将在每一个请求上有一个新生成的动作对象。您可能不需要这种特性，但是把它放在您的工具箱中也很好。您也可以利用 Spring 的生命周期方法。例如，当实例化 Struts 动作时， 标记的 init-method 属性被用于运行一个方法。类似地，在从容器中删除 bean 之前，destroy-method 属性执行一个方法。这些方法是管理昂贵对象的好办法，它们以一种与 Servlet 生命周期相同的方式进行管理。

另外在说下Spring容器初始化问题
初始化Spring容器也有2种方式：
一种是在web.xml中配置ContextLoaderListener

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
		/WEB-INF/acegi-config.xml,
		/WEB-INF/applicationContext.xml,
		/WEB-INF/action-servlet.xml,
		/WEB-INF/daoContext.xml,
		/WEB-INF/serviceContext.xml,	
	</param-value>
</context-param>
 
<listener>
	<listener-class>
		org.springframework.web.context.ContextLoaderListener
	</listener-class>
</listener>

另一种是在struts-config.xml中配置plug-in

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">   
       <set-property property="contextConfigLocation"  value="/WEB-INF/applicationContext.xml,/WEB-INF/action-servlet.xml,/WEB-INF/daoContext.xml,/WEB-INF/serviceContext.xml" />   
</plug-in>

这中间存在OpenSessionInView模式的失效的问题,推荐使用第一种方法。