J2EE和Spring实用编程

《J2EE和Spring实用编程》由会员分享，可在线阅读，更多相关《J2EE和Spring实用编程（36页珍藏版）》请在装配图网上搜索。

1、floater Spring Web Framework J2EE 和 Spring 实用编程 Revision History Date 03/09/2005 04/01/2005 04/20/2005 By Version 0.1 0.2 0.3 Description Initial draft. Settle the content release Revised 4/20/2005 Page 1 of 38 floater Spring Web Framework Table of Contents 1 SPRING 简介 . 4 1.1 J2EE 应用软件. 4 1.2 SPRIN

2、G 框架 . 5 1.3 面向对象的准则 . 5 1.3.1 1.3.2 1.3.3 1.3.4 1.3.5 1.3.6 1.3.7 开闭原则（OCP，THE OPEN-CLOSED PRINCIPLE）. 6 依赖反向原则（DIP，DEPENDENCY INVERSION PRINCIPLE）. 6 接口分离原则（ISP，INTERFACE SEGREGATION PRINCIPLE） . 6 迪米特法则（LAW OF DEMETER） . 6 组合/继承原则（CRP，COMPOSITE REUSE PRINCIPLE） . 6 李斯可夫代换原则（LISKOV SUBSTITUTION PR

3、INCIPLE） . 6 参考资料. 6 2 SPRING 核心包(CORE)和 CONTEXT 包 . 7 2.1 BEANWRAPPER 类及其应用. 7 2.1.1 2.1.2 简单例子. 8 新的类型转换 . 9 2.2 BEANFACTORY 接口和它的实现类. 10 2.2.1 BEANFACTORY 的实现类 . 11 2.2.1.1 由 Properties 定义的 BeanFactory .11 2.2.1.2 在 BeanFactory 中对象间的引用 .11 2.2.1.3 新的类型转换.12 2.2.1.4 用 XML 来定义对象.13 2.2.1.5 用 Custom

4、EditorConfigurer 来定义数据类型转换 .14 2.2.1.6 外部配置文件.16 2.2.1.7 JVM 系统参数 .17 2.2.1.8 两个外部配置文件.18 2.2.1.9 其它的配置方式.19 2.2.2 BEANFACTORY 是一个对象容器. 20 2.2.2.1 单例和多例.20 2.2.2.2 父 Bean 和抽象 Bean .20 2.2.2.3 内部 Bean.20 2.2.2.4 别名（alias）.20 2.2.2.5 输入其它 XML 配置（Import） .21 2.2.2.6 Spring 自带的一些工厂方法 .21 2.2.2.7 BeanFac

5、toryWare 接口和 Spring 扩展 .21 2.3 APPLICATIONCONTEXT 接口和它的实现类. 29 2.3.1 2.3.2 2.3.3 同时载入几个配置文件 . 30 资源载入. 31 国际化支持. 34 Revised 4/20/2005 Page 2 of 38 floater Spring Web Framework 2.4 启动 APPLICATIONCONTEXT 的几种方式. 34 2.5 控制倒置（IOC），依赖注入（DEPENDENCY INJECTION）和轻型容器 . 35 3 SPRING 面向方面包(AOP PACKAGE). 37 4 SPR

6、ING 网页包(WEB PACKAGES). 38 5 用 JAVA 制做网页的几种技术选择. 38 6 SPRING 持久性存贮包(PERSISTENCE PACKAGES)和事务处理 . 38 7 用 JAVA 做持久性存贮的几种技术选择. 38 8 SPRING 网络包. 38 9 SPRING 其他的 J2EE 包. 38 10 J2EE 编程的几点考虑. 38 Revised 4/20/2005 Page 3 of 38 floater Spring Web Framework 1 Spring 简介 自从 J2EE 诞生以来，它已经成为大型企业应用软件的最佳平台。在 2002 年，

7、Rod Johnson 的书 Expert One- on-One J2EE Design and Development 更进一步地改变我们的 J2EE 编程。很多 JAVA 书是后学院式的讲解， 但是这本书却是经验和实践的结晶，从而成为一本经典著作。Spring 框架是在这本书中范例的基础上拓展出 来的。自从 Spring 框架 1.0 发布以来，它很快地被 J2EE 社区所接受。有人评论说，Spring 框架又把 OO 编程 带回到 J2EE 中来了。今天，Spring 框架已经相当成熟，远远超出了 Rod 在他书中所陈述的，而且它还在不断 地完善和拓展。 我们将首先陈述大型企业应用编程

8、中的一些常见问题和需求，然后解释 Spring 是如何解决这些问题和满足这 些需求的。这样做会比近乎宗教式的说教更具有针对性和实用性。Spring 框架是实践和经验的积累，不是某 个天才坐在办公室凭空想象出来的（当然，我们不排除这种可能性，某一天被苹果砸一下后会有超出寻常的想 法）。但是我们所见到的 Spring 框架已经是这些积累的抽象了，所以，了结它所解决的问题及上下文会有助 于理解和使用 Spring 框架。我们因为经验有限，不可能概括所有的方方面面，所以只讨论我们认为最常见的 和最重要的案例。如果读者想进一步探讨，请参阅其它资料或 google，以下资料应该是一个良好的开端： z Sp

9、ring 网站：，这里有 Spring 框架的下载，官方文件，讨论社区等。 z Expert One-on-One J2EE Design and Development，这是 Rod Johnson 在 2002 年下半年出版的书。这本 书所讨论的实践经验是非常具有实用价值的。 z Expert One-on-One J2EE Development Without EJB，这是 Rod Johnson 继上一本书的更新。但不是上一 本书的的替代。 z Spring in Action，作者是 Craig Walls 和 Ryan Breidenbach z Spring Live，作者是

10、Matt Raible，他的 Blog 有很多有用的技巧。 z Pro Spring 另外，Spring 的官方文件已经有中文版了，读者可以参阅。 我们假定读者具有 JDK 和 J2EE 的一般知识。为了让读者可以运行例子中的程序，我们列出了完整的程序并且 尽量使它们短小和独立，希望读者动手尝试。 1.1 J2EE 应用软件 企业应用软件不同于桌面上的应用程序，它们的要求差别很大。企业应用软件通常考虑如下的重要方面： z 应用程序的安全性（security） z 应用操作的事务（transaction）和记录（audit） z 服务的不间断性（service continuity） z 软件的

11、运行环境（runtime environment）和发布过程（deployment） z 软件的开发成本（development cost）及开发周期（development cycle） z 软件的维护成本（maintenance）和维修速度（response time） z 软件的伸缩性（scalability） J2EE 在很大程度上提供了一个良好的基础设施来可以满足这些需求。例如 JDBC，它很好的概括了数据库的操 作，使得在很大程度上简化了数据库操作的编程。在 B2C 的 Web 应用中，因为客户端用 Web 浏览器，所以几 乎不需要安装客户程序，也就没有客户程序的更新和维护了。这使

12、得软件更新和维护得到很大的简化。而且， Web 浏览器也差不多形成不是标准的标准了，能出现很大变化的余地也很小了。在 B2B 的应用中，Java 内在的 网络功能已经使它很方便，JMS 和 WebServices 更是锦上添花。 Revised 4/20/2005 Page 4 of 38 floater Spring Web Framework 1.2 Spring 框架 J2EE 尽管在企业应用中取得了很大成功，但是在许多情况下还是不尽人意，例如它只是提供了最基本的服 务，而没有更高级的功能；它的 EJB 容器经常被误用。Spring 框架正是在这种需求中开发出来的，它填补了 很多介于 J

13、2EE 的基本功能和企业应用软件的需求之间的空缺，从而使得 J2EE 编程非常简便。Spring 框架的 几个重要特点是： z Spring 框架的核心是一个具有赖注入（Dependency Injection）功能的轻型对象容器。它通过依赖注入 （Dependency Injection）来设定对象之间的依赖关系。它是无侵入性的，即不需要我们的类实现任何接 口，只需我们遵循 JavaBean 的一些规范而已。因为依赖关系的设定是由 Spring 容器来完成的，所以编程 得到大量的简化，同时耦合性也大大地降低了。从而也使得测试得到简化，因为在测试中我们可以注入 mock 对象。它也支持 AOP

14、，使得我们可以面向切面编程。 z Spring 框架集成了很多 J2EE 组件，它利用它的轻容器扩展了这些组件，提供了更高级的功能。它不仅集 成了很多 J2EE 的最佳实践，而且有的功能更是先驱性的实践，例如，无侵入性的事务，WEB 中的 Action 和 View 的抽象和分离（这使得我们可以在不更改 Action 的情况下替换 View）。它更进一步地集成了很 多成熟的工具，例如 Hibernate，iBATIS，JDO 等数据库编程工具，JSP/JSTL，Struts，Velocity， WebWork，Tapestry，Portal，Tiles 等表示层工具。 z 使得我们更便捷地遵循

15、 OOP，面向对象的原则（Object-oriented principles）。相比之下，如果我们的 编程环境和实践使得遵循 OOP 很困难或很麻烦，例如 J2EE 核心模式中的一些例子，那么人们很可能就会 在实践中放弃 OOP。所以，Spring（还有其他一些类似的工具）不仅仅是一个工具的改进，同时也是对 OOP 的编程环境和实践的极大改进和更新。它更掀起一股轻容器(Lightweight container)的热潮（轻容 器是相对于 EJB 等重容器而言的，轻重实际上是指是否易用，是否容易部署，可以快速启动）。 z 同时，Spring 框架本身很好地遵循了 OOP 原则，所以它具有很好的

16、扩展性。 当然，没有什么东西是尽善尽美的，万能的银弹（silver bullet）和圣杯（Holy Grail）是不存在的。在实际应用 中，Spring 也存在着一些问题： z 因为对象之间的依赖是在容器中设定的，当对象较多时，依赖关系不是像写在 Java 程序里那样显而易见 和易于跟踪。这多多少少只是一个习惯而已。 z 因为对象之间的依赖关系是用 XML 来描述的，所以设置的正确与否只能用运行来检验，而不能用编译来 检验。 z 当我们用 setter()来设置依赖关系时，可能会破坏数据的封装，可能会用错误的对象属性的组合或顺序，可 能会使公共界面更复杂。这一点可以通过接口来克服。 z 它的

17、XML 配置有些烦亢，不过我们可以分成数个文件来进行分类。 但是，这些很少会构成很大的问题。事实上，Spring 框架是在我们用过的所有框架中问题最少的。 Spring 框架的学习难度是和编程经验，以及对 OOP 的认识和理解成反比。所以下面我们简单地介绍一下 OOP， 有兴趣的读者请参阅其他书籍和资料，OOP 这 20 年的积累是非常丰富的。我们仅从实用出发，讲解一些要 点，为以后的讨论做些准备。 1.3 面向对象的准则 人们编写软件的目的除了使用外，另一个目的是容易修改，否则我们就改制硬件了。所以说，变更是软件的天 性。我们不应该限制软件的更新，而应该适应更新，创造环境使得容易更新，甚至预

18、计可能的变化（所以我们 才有更多的工作机会）。人们经过长期的经验积累和研究认识到，具有可重用性和可维护性的软件能够很好地 适应变化。这里，可重用性是指一个软件模块能否被用在很多不同场合；可维护性是指一个软件模块是否容易 修改，更新和扩展。在面向对象的实践中，人们为了写出具有这两个性质的模块，总结了一些原则。下面，我 们简略地介绍一下这些原则。值得指出的是，除了第一个开闭原则外，其它原则主要是针对类而言的。现在， 人们又总结了一些针对包的原则，但是因为它和我们的内容没有太多的直接关系，所以我们略去不谈。有兴趣 的读者可以参阅一下相关的资料。 Revised 4/20/2005 Page 5 of

19、 38 floater Spring Web Framework 1.3.1 开闭原则（OCP，The Open-Closed Principle） 开闭原则是说，所有软件模块都应该可以扩展，但不可以修改。遵循这个原则的关键在于抽象化。我们在写一 个模块时，不论是一个类，还是一个构件，都应该认真思考它的真正功能，它对其它模块的依赖性，输入和输 出，等等。分离出它的可变部分（例如，用接口或外部配置等），对不变部分进行封装。这些不变部分就是这 个模块的本质。这里需要说明的是，在对不变部分进行封装时，我们如何定义不变的部分。在数学中，当我们 谈到不变量时，总是要指明它是在什么变化下的不变量。否则是没

20、有意义的，因为在一种变化下的不变量很有 可能在另一种变化下就不是不变量了。所以，当我们定义不变的部分时，首先要明确它的变化范围。但是，在 软件开发中，很难事先准确的知道这些变化，很多时候是凭经验或行业知识来判断的。所以，这个原则多多少 少带有主观性，更像一个总纲而不像一个硬性的法律条文。Martin Fowler 的书 Analysis Patterns 讲解了一些实 际经验，有兴趣的读者可以参考。下面这些原则是讲如何安排依赖性使得模块具有良好的封闭性，可重用性和 可维护性。 1.3.2 依赖反向原则（DIP，Dependency Inversion Principle） 依赖反向原则是说，要

21、依赖于抽象，而不要依赖于具体。这也就是我们所说的：要针对接口编程，而不要针对 实现编程。之所以是倒置，是因为通常在开始依照需求编程时，我们几乎总是依赖于具体的实现。但是，这些 具体的实现都不易适应变化，所以要抽象出一些不变的，本质的功能，把可变的留到具体的实现中去。这种抽 象的过程是前面过程的反向，例如，当我们需要写出结果时，开始时可能会写到文件里，后来可能会写到网络 流里，等等。抽象的结果是写这个功能。针对接口编程是一个不可能过分强调的原则。接口就像高楼大厦中层 与层之间，户与户之间的防火墙；大船巨舰中的隔离舱。软件的更新有时就像水火一样难以预料和不可避免 （所以我们叫它软件而不是硬件），而

22、接口会适当地屏蔽软件更新所带来的改动扩散（连锁传播）。通常，类 的依赖性由这个原则和组合/继承原则主导，而不是由继承主导。 接口分离原则（ISP，Interface Segregation Principle） 接口分离原则是说，不相关的功能应在不同的接口里。不然，在需要一个功能时也不得不同时也依赖于另一个 没必要的功能。例如，在早期的 EJB 中，数据库调用和远程调用混在一起，在不需要远程调用时恰好是最糟糕 的组合。这个原则说的是，接口的依赖性宽度越窄越好。下面的原则说的是接口的依赖性深度越浅越好。 迪米特法则（Law of Demeter） Demeter 法则是说尽量不要有传递性，链型的

23、依赖关系。不要和陌生人交谈，只和亲属和朋友交谈。在一个类 中，可以调用类里的其它方法，可以调用类属性的方法，可以调用方法中传递变量的方法，可以调用在方法中 声明的变量的方法。但不应该调用属性的属性的方法。 组合/继承原则（CRP，Composite Reuse Principle） 组合/继承原则是说，优先使用组合而不是继承。当我们用低级对象来构造高级对象时，应该用组合。一个系 统的框架也应该是由组合和接口构成的。下面的原则说明，继承仅仅是帮助实现，而不是帮助构造新的对象 的。 李斯可夫代换原则（Liskov Substitution Principle） Liskov 代换原则是说，任何父类

24、可以出现的地方，子类也可以出现。子类在改变父类属性状态时要遵守父类的 行为（即不能有更强的先决条件，只能有更弱的先决条件）。这就意味着无法用继承来构造行为差异很大的对 象。 参考资料 读者可以参考以下资料： Revised 4/20/2005 Page 6 of 38 floater Spring Web Framework 2 Spring 核心包(Core)和 Context 包 在这一章里，我们将讨论 Spring 框架中的轻型容器。它由两个最基础的包组成，Spring 核心包和 Context 包。在这两个包里有三个最重要的接口，BeanWrapper，BeanFactory，和 Ap

25、plicationContext。我们将通过 探讨这三个接口来讲解这两个包的目的，用法，功能以及它们是如何实现这些功能的。只有明白了它们所解决 的问题和它们所用的方法，才能有效地使用它们。实际上，这三个接口和它们的实现及附属类构成了三个层 次，它们各自解决不同而相关的问题。 核心包是整个 Spring 框架的基础，它同时又是一个独立的组件，可以单独地使用。Spring 的发布包里的 dist （是英文 distribution，发布的缩写）目录下有一个文件 spring-core.jar，它大约有 240K。这个 jar 文件 可以单独使用，它不依赖其它的 Spring 包。Apache co

26、mmons-logging.jar 是它唯一依赖的第三方的包。 核心包最早是用来解决程序配置中的一些问题的，例如，程序配置方式的不统一，配置中单例模式的无限制的 调用，组件配置时接口和实现的对应，和其他相关问题。 在 Java 中，我们可以用 Properties 文件，XML 文件，JVM 初始变量，JNDI 查询，甚至是 ANT/Maven 的属性， 或其他格式及来配置应用程序中的某些属性。这些配置方式五花八门，眼花缭乱，但又各为所需。如果这些各 式各样的配置方式越多，越复杂，那么程序维护的代价就越高。如果能有一种统一的方式来配置这些属性，同 时又不限制使用哪种实现，那么开发和维护程序就会

27、容易很多，代价也会降低。Spring 提供了这种机制。如 果用前面 OOP 来说，我们仅仅是在做配置属性这一件事，尽管它有许多不同的实现方法。 核心包同时也是一个对象容器，用依赖关系的注入来设置对象的属性。在 OO 编程中， 一个很重要的准则就是 调用接口来编程，而不是调用实现来编程。如果我们不遵循这个原则，那么程序就会有很大的粘合性，也就是 说改动一个地方很有可能会波及到很多地方。例如，一个被调用的程序和调用者之中任何一个的改动都会很容 易地波及到另一个。单例模式违背了这一准则，因为它的实现和接口是在一起。而且它把这种粘合推到了极 端，因为单例可以在任何地方引用，它没有范围的限制，从而可以使

28、得任何类都依赖于它。Spring 利用对象 容器来管理单例对象的生成和多例对象的复制及生成。这个容器分离了接口和实现，使得我们可以依不同环境 而使用不同的实现机制。因为接口还是同一个接口，所以调用这个接口的程序几乎无需改动。 Spring 对象容器还有其它一些优点， 例如我们可以用接口来声明物体的类属性，而用 Spring 容器来声明类 属性的实现。所以，Spring 容器使得物体之间的调用自然地符合调用接口来编程的准则。它的另一个很大的 好处是无侵入性，换句话说，我们不需要实现任何 Spring 接口或继承任何 Spring 父类，只需要遵循 Java bean 的规则就可以了。相比之下，E

29、JB 则要求我们继承 EJB 父类。无侵入性意味着良好的可移植性，例如，我 们依然可以用程序来做同样的事，自己来管理对象的生命周期。 Context 包是核心包的补充和扩展，它增加了一些应用程序的运行环境的配置功能，例如资源的配置功能和对 象定义的覆盖。同样，它也是一个相对独立的组件，它的文件是 spring-context.jar，仅依赖于前面提到的 spring-core.jar（和 commons-logging.jar）。但要注意的是，AOP 和 CGLIB 的包可能会间接的引用。 2.1 BeanWrapper 类及其应用 BeanWrapper 接口和它的实现 BeanWrappe

30、rImpl 是整个 Spring 框架最基本的类。它们利用反射机制 （Reflection）和 JavaBeans 的标准提供一些对 Java 类属性的操作。其中最重要的操作是数据类型的转换和 嵌套属性的引用（这使人联想起 BeanUtils, OGNL 和 JSTL EL）。它们对 JavaBeans 标准的要求对调用者来说 是很容易满足的，而且它不需要调用者实现任何接口或者继承任何父类。所以，它几乎可以用在任何需要的场 合。另一方面，尽管它的要求很低，但是它的功能却非常强，容易扩展。Spring 更是尽量减少 JavaBeans 的 限制，例如，它加入了 constructor 注入的功能

31、，只要求 getter/setter 对应 property 属性即可，而不要求 它们对应类的属性。 Revised 4/20/2005 Page 7 of 38 floater Spring Web Framework 2.1.1 简单例子 我们先建一个简单的 JavaBean，Person。它有四个类属性，每个属性的类型都不同，而且都有 getter 和 setter 方法。为了测试打印方便，我们还重写（覆盖）了 toString()方法。我们将在这一章中反复使用这个 类作为例子。 package springsamples.springcore; public class Person

32、protected int age = 0; protected String name = null; protected Person spouse = null; protected String belongings = null; / getter and setter public int getAge() return age; public void setAge(int a) age = a; public String getName() return name; public void setName(String n) name = n; public Person g

33、etSpouse() return spouse; public void setSpouse(Person s) spouse = s; public void setBelongings(String p, int i) belongingsi = p; public void setBelongings(String p) belongings = p; public String getBelongings(int i) return belongingsi; public String getBelongings() return belongings; / just want to

34、 see the values public String toString() StringBuffer ret = new StringBuffer(); ret.append(name = ).append(name).append( | age = ).append(age); if (spouse != null) ret.append( | spouse = ).append(spouse.getName(). append( & ).append(spouse.getAge(); ret.append( & its sponse= + spouse.getSpouse().get

35、Name(); if (belongings != null) ret.append( | belongings = ); for (int i = 0, j = belongings.length; i j; i+) ret.append(belongingsi).append( & ); return ret.toString(); 下面我们看看怎样使用 BeanWrapper 和 BeanWrapperImpl。首先我们要引入 Spring 包，有两种办法引入 Spring 的包，一种方法是直接使用 Spring.jar，这是一种简洁的办法，不用考虑各个组件包；另一种是用同 一个目录下的

36、组件包。当然，无论那种方法，我们都必须加入所依赖的第三方的包。对于 BeanWrapper，我们 只需要 spring-core.jar 和 commons-logging.jar（在以后的发布中，这些包可能会有变化，我们现在用版本 ）。commons-logging.jar 是一个很小的日志包代理，它或者使用 log4j，或者使用 JDK 的日志包。 package springsamples.springcore.beanwrapper.simple; import org.springframework.beans.BeanWrapper; import org.springframew

37、ork.beans.BeanWrapperImpl; import springsamples.springcore.Person; public class TestBeanWrapperWithPerson public static void main(String args) throws java.beans.PropertyVetoException Revised 4/20/2005 Page 8 of 38 floater Spring Web Framework Person person = new Person(); BeanWrapper bw = new BeanWr

38、apperImpl(person); / 1. set simple properties, like int or String / set the integer field with a string value, it should be converted automatically. bw.setPropertyValue(age, 25); bw.setPropertyValue(name, John Smith); System.out.println(person: + person); / 2. set a bean object bw.setPropertyValue(s

39、pouse, new Person(); bw.setPropertyValue(spouse.name, Mary Smith); / another way to set integer bw.setPropertyValue(spouse.age, new Integer(23); bw.setPropertyValue(spouse.spouse, person); System.out.println(spouse: + person.getSpouse(); System.out.println(self: + person); / 3. set arrays bw.setProp

40、ertyValue(belongings, house, car, boat); System.out.println(bean properties: + person); 在第一步中，类属性 name 的设定很简单，把字符串John Smith赋给字符串属性 name。类属性 age 的设定 是把字符串25赋给了 int 型的属性 age，这个类型的转换是由 BeanWrapperImpl 通过 JavaBeans 的 PropertyEditor 来完成的。BeanWrapperImpl 类自动加载一些 PropertyEditor。在第二步中，BeanWrapper 甚 至可以设定我们

41、的 Person 类以及它的属性。这里，我们用到了嵌套属性 spouse.name 和 spouse.age 等。而且 还可以把配偶的配偶设置成自己。在第三步中，我们用一个逗号分开的字符串house, car, boat设置了一 个字符串型的数组 belongings。读者可以从打印结果来验证这些功能。如果要想看 Spring 的信息，读者可以 把 JDK 的 Logging 或 Log4J 设置设为 DEBUG。 新的类型转换 从这个简单的例子不难看出 BeanWrapper 的数据类型的转换和嵌套属性的引用是很方便的。现在我们举例来说 明如何加入新的类型转换。在上面的例子中，当我们设置配偶

42、时，我们设置了四个值。现在，我们将通过一次 赋值来做同样的事，为此先加入一个新的类型转换 package springsamples.springcore.beanwrapper.propertyeditors; import java.beans.PropertyEditorSupport; import java.util.*; import springsamples.springcore.Person; public class SpousePropertyEditor extends PropertyEditorSupport public void setAsText(String

43、 text) Person p = new Person(); StringTokenizer st = new StringTokenizer(text, |); p.setName(st.nextToken(); p.setAge(Integer.parseInt(st.nextToken(); setValue(p); 这是一个标准的 PropertyEditor，仅依赖于 Java 的 API 和 Person 类。它的输入是一个有|字符串，输出 是一个 Person 对象，输入字符串|前的部分作为 name，|后的部分作为 age。下面是如何使用这个扩 展的例子。 package s

44、pringsamples.springcore.beanwrapper.propertyeditors; import java.beans.PropertyEditorManager; Revised 4/20/2005 Page 9 of 38 floater Spring Web Framework import org.springframework.beans.BeanWrapper; import org.springframework.beans.BeanWrapperImpl; import springsamples.springcore.Person; class Test

45、SpousePropertyEditorWithBeanWrapper public static void main(String args) throws java.beans.PropertyVetoException Person person = new Person(); BeanWrapper bw = new BeanWrapperImpl(person); / There are two ways to register a new PropertyEditor, both works: / a. This is the standard java bean way. Pro

46、pertyEditorManager.registerEditor(Person.class, SpousePropertyEditor.class); / b. This is the special spring bean wrapper way. /bw.registerCustomEditor(Person.class, new SpousePropertyEditor(); / after register it, we can do these bw.setPropertyValue(name, John Smith); bw.setPropertyValue(age, 25);

47、/ 2. set a bean object with the new PropertyEditor bw.setPropertyValue(spouse, Mary Smith|23); bw.setPropertyValue(spouse.spouse, person); System.out.println(self: + person); System.out.println(spouse: + person.getSpouse(); 有两种方式来设定这个新的 PropertyEditor，一种是用 JavaBeans 标准的 PropertyEditorManager，一种是用 Be

48、anWrapper 的 API（读者可以都试一试）。设定这个新的 PropertyEditor 以后，我们就可以用Mary Smith|23来设 spouse 的属性了。读者有兴趣的话，可以试一试如何把一个字符串转换成 BigDecimal，把一 个字符串组转换成 int 型的数组，或者把上面的 Person 类扩充成 Parent 类，加入一个 Person 型的数组 children 作为属性，再试着如何加一个 PropertyEditor 来设置这个 children 属性。 BeanWrapper 和它的实现是一个极为优秀的思路，因为它不仅解决了数据类型的转换和（嵌套）属性的引用问 题，而且彻底地消除了这二者的依赖性（更准确的说，是把依赖性留在了 JDK 中），使得它不需改动 BeanWrapper 实现就可以扩展。在 BeanWrapper 出现之前，也有过类似的实现，但它们都很难扩展，界面不标 准且难用。最重要的扩展就是新的类型转换。BeanWrapper 由于是基于 JavaBeans 标准的，所以它克服了这些 弱点，并且扩展接口也很简单，标准。这个想法非常符合我们前面讨论过的 OOP。 当然，这个优秀的思路也不是一帆风顺的