1．Spring提供更好的平衡
　　
　　在河中，我学会更多地利用我的腰部和背部的肌肉来划船，因为我的手臂肌肉无法坚持整天划船。我变得更有效率，更平衡地利用自己的肌肉。通过spring,我可以在每行代码中做更多的事。通过spring你会发现更多其优势，其中最重要的是在对象持久化上。这是一个来自hibernate访问数据对象的函数。
　　
　　public List getReservations( ) {　return getHibernateTemplate( ).find("from Reservation");}
　　
　　注意那些你没看到的东西。这里没有任何事务处理。Spring允许你建立配置代码去处理它。你不一定要通过关闭session来管理资源。你不一定写你自己的配置。你不一定在这个层次上管理异常，因为这些异常是未经检查的。你可以自由地在最适当的位置去管理他们。没用spring的hibernate方法的代码会是这样的：
　　
　　public List getBikesOldWay( ) throws Exception {　List bikes = null;
　　Session s = null;
　　try {　　s = mySessionFactory.openSession( );
　　bikes = s.find("from Bike");
　　}catch (Exception ex) {　　//handle exception gracefully　}finally {　　s.close( );
　　}　return bikes;}
　　
　　Spring给我更多优势，让我编程更快，更易维护程序。
　　
　　2．Spring支持POJO编程
　　
　　在EJB 2.x彻底失败之后,我们都在寻找更多方式避免在每个bean中加入笨重的模型去表达企业服务。当然。我们需要事务，安全，持久化，有时还需要远程调用。用EJB时，我不得不去学庞大的API以及通过新的工具和部署过程来工作。结果我变成容器(container)提供的服务的奴隶。而在用Spring时，我可以选择我自己的服务和持久化框架。我在POJOs上编程并通过配置文件添加企业服务。
　　
　　在Sping:A Developer’s notebook这本书中，我建立了一个RentaBike的程序。我用我的POJOhibRentaBike取代了session bean 或者entity bean,它充当了我的数据访问对象。我还在别处添加了服务。Spring配置文件是一个XML文件，被称为上下文。它含有在容器中的所有bean以及这些bean的属性，还有这些bean需要的服务。让我们来看看下面的例子。
　　
　　Target:
　　<bean id="rentaBikeTarget" class="com.springbook.HibRentABike">
　　<property name="storeName">
　　<value>Bruce's Bikes</value>
　　</property>
　　<property name="sessionFactory">
　　<ref local="sessionFactory"/>
　　</property>
　　<property name="transactionManager">
　　<ref local="transactionManager"/>
　　</property></bean>
　　
　　Interceptor:
　　<bean name="transactionInterceptor"
　　class="org.springframework.transaction.interceptor.TransactionInterceptor">
　　<property name="transactionManager">
　　<ref local="transactionManager"/>
　　</property>
　　<property name="transactionAttributeSource">
　　<value>
　　com.springbook.RentABike.transferReservation=
　　PROPAGATION_REQUIRED,-ReservationTransferException
　　com.springbook.RentABike.save*=PROPAGATION_REQUIRED
　　com.springbook.RentABike.*=PROPAGATION_REQUIRED,readOnly
　　</value>
　　</property></bean>
　　
　　proxy：
　　<bean id="rentaBike" class="org.springframework.aop.framework.ProxyFactoryBean">　<property name="proxyInterfaces">　　<value>com.springbook.RentABike</value>　</property>　<property name="interceptorNames">　　<value>transactionInterceptor,rentaBikeTarget</value>　</property></bean>
　　
　　注意这3个不同的bean: The Proxy , The target, and The interceptors. The proxy将调用POJO，以及POJO需要的任何服务。Interceptors包含粘合各调用服务的代码，他们也说明了如何去对待The target中的每个方法。所有需要访问RantaBike的人调用The proxy，这个开始事务访问The target(The POJO)的事务拦截器。Thet target做自己的事返回给事务拦截器(提交事务的对象)，返回到proxy和proxy的调用者。
　　

　　Figure 1. POJO programming in action
　　
　　你在POJO外建立了你的程序，配置了它，Spring会隐藏其他的东西。我是一个POJO编程者。
　　
　　3．依赖注入有助易测性
　　
　　Spring通过叫依赖注入(Dependency Injection)的设计模式来提高你的易测性。当一个消费者（consumer）依赖一个从属物（我们会叫它一个服务），你会为consumer建立一个属性。Spring将会建立这个consumer和服务，以及设置这个consumer的属性为服务的值。换种说法，Spring在上下文中管理beans的生命周期，解决依赖性。这是个不通过spring的依赖注入的例子。首先是消费者(consumer),被作为程序的基本模样。
　　
　　public class CommandLineView { private RentABike rentaBike;
　　public CommandLineView( ) {rentaBike = new ArrayListRentABike("Bruce's Bikes");
　　}public void setRentABike(RentABike rentABike){　this.rentABike = rentABike;
　　}　public void printAllBikes( ) {　　System.out.println(rentaBike.toString( ));
　　Iterator iter = rentaBike.getBikes().iterator( );
　　while(iter.hasNext( )) {　　　Bike bike = (Bike)iter.next( );
　　System.out.println(bike.toString( ));
　　}　}　public static final void main(String[] args) {　　CommandLineView clv = new CommandLineView( );
　　clv.printAllBikes( );
　　}
　　
　　接着是service这个模型。这是个简单的通过数组表的实现，其依赖于在这个模型(RentaBike)。
　　
　　interface RentABike {List getBikes( );Bike getBike(String serialNo);
　　}public class ArrayListRentABike implements RentABike {　 private String storeName;
　　final List bikes = new ArrayList();
　　public ArrayListRentABike(String storeName) {　　　this.storeName = storeName;
　　bikes.add(new Bike("Shimano", "Roadmaster", 20, "11111", 15, "Fair"));
　　bikes.add(new Bike("Cannondale", "F2000 XTR", 18, "22222",12,"Excellent"));
　　bikes.add(new Bike("Trek","6000", 19, "33333", 12.4, "Fair"));
　　}　 public String toString() { return "RentABike: " + storeName;
　　}　 public List getBikes() { return bikes;
　　}　 public Bike getBike(String serialNo) {　　　Iterator iter = bikes.iterator();
　　while(iter.hasNext()) {　　　　 Bike bike = (Bike)iter.next();
　　if(serialNo.equals(bike.getSerialNo())) return bike;
　　}　　　return null;
　　}}
　　
　　这是装配程序。粗体的代码就是依赖注入。装配程序演示了服务和消费者，通过设置rentaBike的属性解决了依赖性。
　　
　　public class RentABikeAssembler {　public static final void main(String[] args) {　　CommandLineView clv = new CommandLineView( );
　　RentABike rentaBike = new ArrayListRentABike("Bruce's Bikes");
　　clv.setRentaBike(rentaBike);
　　clv.printAllBikes( );
　　}}
　　
　　当然，Spring将最终符合装配的法则。如果你将服务隐藏到接口程序中，那样你将可以向容器注入接口程序(interface)的任何实现(implementation)。
　　
　　依赖注入(Dependency injection)让你编写一个生产依赖和一个测试依赖。例如这个例子建立一个stub 对象，它让测试这个程序更轻松。（要更多地了解stubs和mocks，请看“Mocks Aren’t Stubs.”）.
　　
　　你已经看到RentaBike的Hibernate实现，以及其数组表版本。我也许不想在完全Hibernates实现的代码运行我的所有用户界面测试。而我更愿意简单地通过数组表实现接口。
　　
　　依赖注入让我联合成品版（通过HibRentaBike），开发版（通过ArrayListRentaBike列表）和测试版(通过mock对象)。当我用java编程的时候，我必须有依赖注入去取得这些mocks进入那些难以进入的位置。
　　
　　4．控制转入简化JDBC
　　
　　JDBC程序是丑陋的，冗长的和乏味的。一个好的抽象层可以改进它，Spring让你通过查询语句和匿名的inner class来定制默认JDBC方法来去除那大部分苦力工作。这是一个简单的JDBC的例子。
　　
　　JdbcTemplate template = new JdbcTemplate(dataSource);
　　final List names = new LinkedList();
　　template.query("SELECT USER.NAME FROM USER",　 new RowCallbackHandler() {
　　public void processRow(ResultSet rs) throws SQLException {
　　names.add(rs.getString(1));
　　}　});
　　
　　想想这个例子，查询如一个默认JDBC方法的方法。Spring会为结果集中的每一行执行在匿名inner class里的processRow方法的。你在上下文中设置了数据源。而不需要担心开或者关的状态，或者连接，配置数据源，或者管理事务。你不需要说明一个外部的结果集，或者在更低的层次上管理异常，因为spring将你的SQLException折叠放入一个共同的未检查的异常集。其他语言例如Ruby和smalltalk经常通过代码块使用控制转入，但是在java中不经常使用。Spring简化了艰巨的任务。
　　
　　5．Spring的社区兴旺
　　
　　虽然一些开源项目不需要变得相当活跃而使其变得有用。例如Juit做已定目标的工作。如果你喜欢编程模型的话，它有你需要的所有基本东西。而轻量级容器如Spring需要一个充满活力的社区。Spring是你可以找到的最活跃的社区之一，你可以拥有许多好处。
　　
　　服务(Service)：通过Spring你可以找到数百种不同的服务，从安全到系统管理，到工作流。在持久化上，你可以插入JDO,Hibernate,Top Link,JDBC或者OJB.
　　
　　支持和教育(Support and education)：:许多独立顾问提供Spring服务，你可以在全世界得到出色的培训。
　　
　　增强（Enhancements）:Spring一年放出数个主要的发行版。在框架内的出色的测试和清晰的（Factored 扩展）意味着每个发行版都是质量优良的。Spring以及取得正在进行中的Hbernate 3的支持，提供了一个全新的web流程框架。这所有都在最新的发行版中。
　　
　　商业上支持（Commercial support）:像我这样的作者写Spring的书。现在，你可以找到5本关于Spring的书，以及许多含有部分Spring内容的书。许多产品商也支持Spring。许多开源框架例如Geronimo和Hibernate具有对Spring的特殊支持。
　　
　　Spring社区让人们用这个框架变得更加容易。我可以雇用Spring开发人员，培训他们。我可以阅读一些书籍来补充我的知识，取得一些帮助我做那些我需要做的所有事情。我没有找到为另一个容器的社区来得如此亲近。
　　
　　资料：
　　如果你想读得更多，则有许多你可以取得地方：
　　Martinfowler.com 有一些关于stubs and mocks 及 dependency injection.的文章。
　　这里有Spring的框架。
　　我的第一本书，Better, Faster, Lighter Java, 总结了轻量(lightweight)开发方法。
　　本文源于Spring: A Developer's Notebook 及其代码。 这是一本程序员注解的书，因此请注意勘误表，当然，可以使用范例代码简化工作。
　　还有这本O'Reilly出版的书：Hibernate: A Developer's Notebook.

发表于 @ 2005年09月19日 18:05:00|评论(loading...)|编辑