BlogJava-MicroFish-随笔分类-spring

《Pro Spring》学习笔记(9)－－基础进阶(4)

刘璐 — Thu, 21 Dec 2006 02:25:00 GMT

到目前为止，我们都是使用BeanFactory接口以及它的子接口来使用Spring，尽管使用BeanFactory也是一种不错的方式，但正如前面看到的，有些时候，我们还是不得不自己编写代码来调用诸如preInstantiateSingletons，postProcessBeanFactory等方法。

为了使用的方便，Spring提供了BeanFactory的一个扩展：ApplicationContext。使用ApplicationContext，我们可以减少需要编写的代码的数量，并且ApplicationContext也增加了一些新的功能。如果在Web工程中使用Spring，我们甚至可以让Spring自动加载ApplicationContext，而无需自己编写代码来创建它。

ApplicationContext具备一些BeanFactory不具备的功能：国际化（Internationalization），事件发布（Event publication），资源管理和访问（Resource management and access），更多的生命周期控制接口（Additional lifecycle interfaces）以及底层组件的自动配置（Improved automatic configuration of infrastructure components）。

Spring为ApplicationContext接口提供了三种实现：FileSystemXmlApplicationContext，ClasspathXmlApplicationContext和XmlWebApplicationContext。其中XmlWebApplicationContext是专为Web工程定制的，并且我们可以使用ContextLoaderListener或ContextLoaderServlet来自动加载ApplicationContext配置。

通常国际化是通过使用MessageSource接口来实现的，为了在ApplicationContext中使用MessageSource，我们需要配置一个类型为MessageSource，名称为messageSource的bean。

                buttons
                labels

在配置了messageSource后，我们就可以使用ApplicationContext的getMessage方法来获取资源内容了。

ApplicationContext的另一个重要特性就是对发布和接收事件的支持，ApplicationContext会在其被配置的时候自动注册所有的侦听器（listener），事件的发布是通过ApplicationContext的publishEvent方法来实现的。

//Event class

public class MessageEvent extends ApplicationEvent {
    private String msg;
    public MessageEvent(Object source, String msg) {
        super(source);
        this.msg = msg;
    }
    public String getMessage() {
        return msg;
    }
}

//Listener class

public class MessageEventListener implements ApplicationListener {
    public void onApplicationEvent(ApplicationEvent event) {
        if(event instanceof MessageEvent) {
            MessageEvent msgEvt = (MessageEvent)event;
            System.out.println("Received: " + msgEvt.getMessage());
        }
    }
}

//Publish class

public class Publisher implements ApplicationContextAware {
    private ApplicationContext ctx;
    public static void main(String[] args) {
        ApplicationContext ctx =

                new FileSystemXmlApplicationContext("./ch5/src/conf/events/events.xml");
        Publisher pub = (Publisher) ctx.getBean("publisher");
        pub.publish("Hello World!");
        pub.publish("The quick brown fox jumped over the lazy dog");
    }
    public void setApplicationContext(ApplicationContext applicationContext)

            throws BeansException {
        this.ctx = applicationContext;
    }
    public void publish(String message) {
        ctx.publishEvent(new MessageEvent(this, message));
    }
}

资源访问是我们经常碰到的，这些资源有可能存在于一个文件中，类路径中的一个jar包中，抑或是在远程服务器上。Spring为我们提供了统一的，协议无关的方式来访问各种各样的资源，这给我们访问各种资源提供了极大的方便。

public class ResourceDemo {
public static void main(String[] args) throws Exception {
ApplicationContext ctx =

                new FileSystemXmlApplicationContext("./ch5/src/conf/events/events.xml");
        Resource res1 = ctx.getResource(" file:///d:/tmp/test.txt ");
        displayInfo(res1);
        Resource res2 = ctx.getResource("classpath:lib/commons-logging.jar");
        displayInfo(res2);
        Resource res3 = ctx.getResource(" http://www.google.co.uk ");
        displayInfo(res3);
    }
    private static void displayInfo(Resource res) throws Exception {
        System.out.println(res.getClass());
        System.out.println(res.getURL().getContent());
        System.out.println("");
    }
}

刘璐 2006-12-21 10:25 发表评论

《Pro Spring》学习笔记(8)－－基础进阶(3)

刘璐 — Thu, 21 Dec 2006 02:24:00 GMT

如果bean无法简单地通过new关键字来创建怎么办，通常碰到这样的情况时，我们都会使用工厂模式来处理，Spring也提供了对FactoryBean的支持，当我们配置了一个bean为FactoryBean时，随后我们获取的则并不是该FactoryBean，Spring会通过调用FactoryBean.getObject()方法，返回真正的目标bean。FactoryBean在Spring中的最著名应用就是对声明式事务的处理。

在Spring中使用FactoryBean，我们需要编写一个实现了FactoryBean接口的类，以一个信息摘要FactoryBean为例，它主要实现根据不同的参数，创建不同的MessageDigest的实例。

public class MessageDigestFactoryBean implements FactoryBean, InitializingBean {
    private String algorithmName = "MD5";
    private MessageDigest messageDigest = null;
    public Object getObject() throws Exception {
        return messageDigest.clone();
    }
    public Class getObjectType() {
        return MessageDigest.class;
    }
    public boolean isSingleton() {

        return true;
    }
    public void afterPropertiesSet() throws Exception {
        messageDigest = MessageDigest.getInstance(algorithmName);
    }
    public void setAlgorithmName(String algorithmName) {
        this.algorithmName = algorithmName;
    }
}

getObject方法是供Spring调用，用来返回真正的bean给其它bean的（而不是FactoryBean本身），getObjectType方法可以返回null，但如果指定了类型，就可以使用Spring的自动装载功能了。isSingleton方法是指定bean是否是单例的，注意不能通过FactoryBean的配置文件来指定bean是否为单例，因为那样指定的是FactoryBean本身，而不是真正的目标bean。

FactoryBean的配置和普通bean并没有什么区别。

由于Bean配置文件中，各个属性都是以String的形式配置的（除了使用ref引用其它bean外），因此，Spring在组装bean的时候，需要把String类型的值转化成合适的类型，这就需要用到JavaBean中的概念：PropertyEditor。

Spring内置了7种预先注册的PropertyEditor：ByteArrayPropertyEditor，ClassEditor，FileEditor，LocaleEditor，PropertiesEditor，StringArrayPropertyEditor，URLEditor。通过名字，我们就能清楚地知道它们对应的类型了。

尽管内置的PropertyEditor可以处理大部分常见的类型，我们仍然会碰到需要创建自己的PropertyEditor的情况。为了简化自定义PropertyEditor的创建，Spring提供了PropertyEditorSupport类，我们只需要扩展该类，并实现其中的setAsText方法即可。

public class PatternPropertyEditor extends PropertyEditorSupport {
    public void setAsText(String text) throws IllegalArgumentException {
        Pattern pattern = Pattern.compile(text);
        setValue(pattern);
    }
}

可以看到，实现一个自定义的PropertyEditor是很容易的，但怎么才能让它起作用呢，也就是通常所说的注册PropertyEditor。Spring提供了两种注册的方式：1.通过ConfigurableBeanFactory的registerCustomEditor方法；2.在BeanFactory的配置文件中定义CustomEditorConfigurer。

class="org.springframework.beans.factory.config.CustomEditorConfigurer">

自定义的PropertyEditor是通过CustomEditorConfigurer的一个类型为Map的属性添加的，key值是自定义PropertyEditor对应的类型的全类名。

在使用时需要先调用：

CustomEditorConfigurer config =

(CustomEditorConfigurer) factory.getBean("customEditorConfigurer");
config.postProcessBeanFactory(factory);

来将所有自定义的ProperyEditor注册到BeanFactory中。

刘璐 2006-12-21 10:24 发表评论

《Pro Spring》学习笔记(6)－－基础进阶(1)

刘璐 — Thu, 21 Dec 2006 02:23:00 GMT

Spring不仅提供了基本的IOC功能，借助于BeanFactory以及其它组件，我们还可以使用其它一些更高级的功能。但是需要注意的是，使用这些高级功能，将不可避免的使得我们的工程依赖于Spring。这些高级功能大致包括：管理bean的生命周期，让bean感知Spring（Spring aware），使用方法注入，使用FactoryBean，使用PropertyEditor以及了解Spring的ApplicationContext
有时候，我们需要在bean的生命周期中的某些阶段做一些相应的操作（类似于Servlet和EJB），像其它IOC容器一样，Spring也提供了管理bean生命周期的功能。两个主要的阶段是：

post-initialization（bean初始化之后）和pre-destruction（bean销毁之前）.
post-initialization是指在Spring完成了bean的所有依赖注入以及相应的检测之后，

      pre-destruction是指在Spring销毁bean之前。
      post-initialization和pre-destruction只能应用于sigleton模式的bean，因为非sigleton的bean的生命周期并不由Spring控制（它们是由JVM控制的）。
      Spring提供了两种机制来实现bean生命周期的管理：基于接口的和基于指定方法的。

      使用基于接口的机制，我们需要实现Spring的相关接口，然后，Spring会使用回调机制在指定的阶段调用接口中定义的方法，从而实现bean生命周期的管理。而使用基于指定方法的机制，我们需要在BeanFactory的配置中指定相应的方法名称，Spring会使用Java的反射机制在指定的阶段调用我们指定的方法，从而实现bean生命周期的管理。
      选择哪种机制取决于我们的工程的需要。基于接口的机制要求我们实现Spring的接口，这会带来对Spring的依赖，但是当我们定义了很多相同类型的bean时，使用基于接口的机制可以免去我们为每个bean定义指定相应方法的麻烦。基于指定方法的机制则可以让我们避免对Spring的依赖，这在当我们使用第三方的类库（因此，我们无法修改其代码来实现Spring的接口）时是非常有用的。
      以post-initialization为例：
      使用基于接口的机制，我们需要实现Spring的InitializingBean接口的afterPropertiesSet方法
      public class SimpleBeanWithInterface implements InitializingBean {
          ...
          public void afterPropertiesSet() throws Exception {
              ...
        }
          ...
      }

                  class="com.apress.prospring.ch5.lifecycle.SimpleBeanWithInterface">
             ...


      使用基于指定方法的机制，我们只需在BeanFactory的配置中指定相应的方法名称

                    class="com.apress.prospring.ch5.lifecycle.SimpleBean"
          init-method="init">
              ...


      SimpleBean中包含对应的init方法
      public class SimpleBean {
          ...
          public void init() {
              ...
          }
          ...
      }
      需要注意的是，init方法必须不包含任何参数，尽管我们可以为init方法指定任意的返回值，但Spring会忽略它，因此最好的做法是在init方法中抛出异常来表明初始化失败了。
      我们也可以同时使用这两种机制，这时，Spring会先调用InitializingBean接口的afterPropertiesSet方法，再调用我们自己指定的init方法。
      相对的，pre-destruction使用DisposableBean接口的destroy方法和bean标签的destroy-method属性
      相对于依赖查找（Dependency Lookup），依赖注入（Dependency Injection）最大的卖点就是容器的无关性，但是有时候，我们确实需要和容器进行一些交互，例如访问BeanFactory或者是获得bean的名称等。
      为了获得bean的名称，我们需要实现Spring的BeanNameAware接口，BeanNameAware只有一个方法，void setBeanName(String name)，只要我们的bean实现了BeanNameAware接口，Spring就会在bean配置结束，其它生命周期相关的回调函数（initialization或者 destroy）调用之前，回调该方法置入bean的名称。

类似的，为了访问beanFactory，我们需要实现Spring的BeanFactoryAware接口的

void setBeanFactory(BeanFactory factory)方法。

刘璐 2006-12-21 10:23 发表评论

《Pro Spring》学习笔记(7)－－基础进阶(2)

刘璐 — Thu, 21 Dec 2006 02:23:00 GMT

Spring1.1中引入了一个很有用的IOC新特性－－方法注入（Method Injection）。这能让我们在组装bean时获得极大的灵活性。Spring的方法注入可以分为两种形式：查询方法注入（Lookup Method Injection）和方法替换（Method Replacement）。查询方法注入提供了另一种机制来让bean获取它依赖的其它bean，方法替换则可以在不修改源代码的基础上，修改任意bean的任何方法的实现。为了提供这两个功能，Spring借助了CGLIB包。

先来看看查询方法注入的使用。想象这样的情形：我们有一个singleton类型的bean A，它需要使用另一个非singleton类型的bean B来执行一些操作。由于两个bean的生命周期是不同的，因此我们不能简单的在bean A的配置中使用ref标签来要求Spring注入bean B，因为那样会让我们每次取得bean A时都使用同一个bean B的实例。回想前面介绍过的BeanFactoryAware接口，我们可以让bean A实现该接口，这样就可以在bean A内部使用beanFactory的genBean方法来获取bean B了。只要我们将bean B配置为非singleton类型，每次使用getBean方法就会得到一个新的bean B的实例。

使用查询方法注入，我可以不必实现任何的Spring的接口，也不需要在bean A中显示的使用getBean方法来获得bean B。我们只需要在bean A中申明一个查询方法，然后在bean A的配置文件中指明该查询方法，那么Spring就会自动的将bean B注入到bean A中去了。由于查询方法注入的概念相对比较复杂，因此我们还是通过具体的例子来直观的感受它是如何工作的。

在这个例子中，我们创建一个非singleton的bean和两个实现了同一个接口的singleton的bean，一个通过传统的设值方法注入获得非singleton的bean，另一个则通过查询方法注入。

//The MyHelper Bean
public class MyHelper {
    public void doSomethingHelpful() {
        // do something!
    }
}

//The DemoBean Interface

public interface DemoBean {
public MyHelper getMyHelper();
public void someOperation();
}

//The StandardLookupDemoBean

public class StandardLookupDemoBean implements DemoBean {
    private MyHelper helper;
    public void setMyHelper(MyHelper helper) {
        this.helper = helper;
    }
    public MyHelper getMyHelper() {
        return this.helper;
    }
    public void someOperation() {
        helper.doSomethingHelpful();
    }
}

//The AbstractLookupDemoBean

public abstract class AbstractLookupDemoBean implements DemoBean {
    public abstract MyHelper getMyHelper();
    public void someOperation() {
        getMyHelper().doSomethingHelpful();
    }
}

class="com.apress.prospring.ch5.mi.AbstractLookupDemoBean">

        class="com.apress.prospring.ch5.mi.StandardLookupDemoBean">

可以看到，我们使用了lookup-method来对查询方法注入进行配置，name属性告诉Spring需要覆写bean中的哪个方法，该方法必须是没有参数的，并且返回类型是我们需要获得的bean的类型，bean属性告诉Spring查询方法需要返回哪个bean。

通过DemoBean standardBean = (DemoBean)factory.getBean("standardLookupBean");获得standardBean，然后比较standardBean.getMyHelper() == standardBean.getMyHelper()，可以发现，直接使用设置方法注入，每次获得的非singleton的bean实际上是同一个实例。而使用查询方法注入，则会每次得到一个新的实例，这实际上是因为我们使用factory.getBean("abstractLookupBean")获得abstractBean时，Spring根据lookup-method的配置，覆写了查询方法，从而返回一个新的bean实例，正如前面提到的，这是通过CGLIB包来实现的。

值得注意的是，我们将查询方法定义为抽象的，这不是必须的，但这么做能防止我们忘记了配置lookup-method，从而使用了空的（当然不是我们期望的）查询方法。

好了，让我们再来看看方法替换，虽然它被划分为方法注入的一种，但它和我们以前接触到的注入方式有着很大的差异，以前我们都是注入一个bean，而方法替换则是替换bean中的方法实现。同查询方法注入一样，我们还是通过一个例子来理解方法替换的使用。

//The ReplacementTarget Class

public class ReplacementTarget {
public String formatMessage(String msg) {
return "

" + msg + "

";
    }
    public String formatMessage(Object msg) {
        return "

" + msg + "

";
}
}

现在由于某些原因，我们需要修改以String为参数的方法的实现方式，并且不能修改ReplacementTarget类的源代码，借助于Spring的方法替换，我们可以轻松地实现。

首先，创建一个实现了MethodReplacer接口的类。

public class FormatMessageReplacer implements MethodReplacer {
public Object reimplement(Object target, Method method, Object[] args)
throws Throwable {

        ...
        String msg = (String) args[0];
        return "

" + msg + "

...

}
}

        class="com.apress.prospring.ch5.mi.FormatMessageReplacer"/>
        class="com.apress.prospring.ch5.mi.ReplacementTarget">

String

class="com.apress.prospring.ch5.mi.ReplacementTarget"/>

通过replaced-method标签来配置需要替换的方法，name属性指明了需要替换的方法名，replacer属性指明了用哪个bean来实现替换操作。arg-type是用来指明需要替换的方法的参数类型的，在bean中有重载方法时（像ReplacementTarget类一样），指明参数类型可以让Spring明确知道需要替换的是哪个方法。值得注意的是，arg-type是模式匹配的，因此，String将匹配String和StringBuffer。

方法替换在很多场合都是有用的，比如我们只想为一个特殊的bean改变它所依赖的另一个bean的实现方法，而不影响其它bean的引用。最好是为每个需要替换的方法，或者是一组重载的方法定义一个替换类，而不要为众多毫不相关的方法使用同一个替换类。这可以减少很多没必要的比较，从而提高代码的执行效率。

刘璐 2006-12-21 10:23 发表评论

《Pro Spring》学习笔记(4)－－配置BeanFactory(1)

刘璐 — Thu, 21 Dec 2006 02:22:00 GMT

Spring使用spring-beans.dtd文件来定义BeanFactory的XML配置规范。可以在http://www.springframework.org/dtd/spring-beans.dtd找到该dtd文件，当然，Spring的下载文件中也已经包含了该dtd文件。它被放在dist文件夹中。

配置文件的根元素是beans，每个组件使用bean元素来定义，bean元素可以有许多属性，其中有两个是必须的：id和class（这里说的id是必须的并不意味着在配置文件中必须指定id，后面会详细说明）。id表示组件的默认名称，class表示组件的类型。

如果使用设值注入，则需要使用property子标签，来指定组件的属性。

使用构造子注入时，则使用constructor-arg子标签，来指定构造函数的参数。

This is a configurable message

当构造函数有多个参数时，可以使用constructor-arg标签的index属性，index属性的值从0开始。

first parameter

second parameter

在使用构造子注入时，需要注意的问题是要避免构造子冲突的情况发生。考虑下面的情况：

public class ConstructorConfusion {

    public ConstructorConfusion(String someValue) {
        System.out.println("ConstructorConfusion(String) called");
    }
    public ConstructorConfusion(int someValue) {
        System.out.println("ConstructorConfusion(int) called");

}

使用如下配置文件

那么，当实例化组件constructorConfusion时，将输出ConstructorConfusion(String) called，也就是说参数类型为String的构造函数被调用了，这显然不符合我们的要求。为了让Spring调用参数为int的构造函数来实例化组件constructorConfusion，我们需要在配置文件中明确的告诉Spring，需要使用哪个构造函数，这需要使用constructor-arg的type属性。

我们不仅可以构造单个BeanFactory，而且可以建立有继承关系的多个BeanFactory。只需要将父BeanFactory作为参数传给子BeanFactory的构造函数即可。

BeanFactory parent =

new XmlBeanFactory(new FileSystemResource("./ch4/src/conf/parent.xml"));
BeanFactory child =

new XmlBeanFactory(new FileSystemResource("./ch4/src/conf/beans.xml"), parent);

如果子BeanFactory和父BeanFactory中含有名称相同的Bean，那么在子BeanFactory中使用

引用的将是子BeanFactory中的bean，为了引用父BeanFactory中的bean，我们需要使用ref标签的parent属性，。

为了注入集合属性，Spring提供了list,map,set和props标签，分别对应List,Map,Set和Properties,我们甚至可以嵌套的使用它们（List of Maps of Sets of Lists）。

                Hello World!









                Rob


                Harrop





            Hello World!





            Hello World!

刘璐 2006-12-21 10:22 发表评论

《Pro Spring》学习笔记(5)－－配置BeanFactory(2)

刘璐 — Thu, 21 Dec 2006 02:22:00 GMT

BeanFactory中的每个bean都必须至少有一个唯一的名字，Spring为了灵活的支持各种情形，使用了相对复杂的命名体系。如果我们为bean指定了id属性，那么id属性的值将成为bean的名称，如果没有指定id属性，Spring将使用name属性的第一个值（多个值用逗号或者分号分隔）作为bean的名称，如果name属性也没有指定，Spring将使用bean的类名（包括package的完整类名）来作为bean的名称，对于多个bean使用相同类名的情况，Spring会在类名后面添加#2,#3等序号来加以区别。不管怎么说，使用id属性来指定bean的名称总是一个不错的选择。

在Spring中，所有bean默认都是以单例（singleton）形态存在的，也就是说我们通过BeanFactory的getBean方法获取的同一名称的bean是完全相同的，即：beanFactory.getBean("name")==beanFactory.getBean("name")。更改bean的形态为非singleton（原型的，prototype）是很容易的，只需在bean标签中，指定singleton属性为false就可以了。

...

为了简化配置，Spring还提供了自动组装（Auto-Wiring）bean的功能，有四种自动组装方式：根据名称（byName），根据类型（byType），构造子（Constructor）以及自动侦测（autodetect）。

使用根据名称自动组装时，Spring根据bean的属性的名称去寻找同名的bean配置。

使用根据类型自动组装时，Spring根据bean的属性的类型去寻找同类型的bean配置，如果有多个同类型的bean配置，那么Spring将会抛出异常，以表示无法确定使用哪个。

使用构造子自动组装和使用根据类型自动组装比较类似，需要注意的是，使用构造子自动组装时，Spring会匹配尽可能多的参数。例如，我们有一个bean拥有两个构造函数，第一个接收一个String类型的参数，第二个接收一个String类型和一个Integer类型的参数，这时，如果在beanFactory的配置文件中有一个String类型的bean配置和一个Integer类型的bean配置，那么Spring将会使用第二个拥有两个参数的构造函数。

使用自动侦测组装时，Spring会在根据类型自动组装和根据构造子自动组装之间自动作出选择，依据是：如果bean拥有默认的（无参数的）构造函数，那么Spring使用根据类型自动组装的方式，否则，使用根据构造子自动组装的方式。

有时候，我们可能会有多个bean拥有共同的类型，或是实现一些共同的接口，因此它们会有一些相同的配置，如果能将这些相同的配置提取出来，各个bean只要继承这些相同的配置，然后添加自己特有的配置，将会大大减少重复的配置，降低发生错误的可能。Spring的bean继承机制就是出于这样的目的而提供的。在Spring中，我们可以将这些相同的配置提取出来，配置成一个parent bean，然后各个bean（child bean）可以继承parent bean，在child bean中，可以覆写parent bean中的配置，也可以添加自己的配置。parent bean是通过child bean的bean标签的parent属性来指定的。

        Rob Harrop


        22


parent="inheritParent">

        35

需要注意的是，bean的继承体系并不完全等同于java的类继承体系，我们完全可以在数个拥有相同类型的bean上使用继承，这不会带来任何问题。因此，相对于java的继承体系来说，Spring 的bean继承体系更类似于模板类型。

刘璐 2006-12-21 10:22 发表评论

《Pro Spring》学习笔记(2)－－何为Spring

刘璐 — Thu, 21 Dec 2006 02:20:00 GMT

Spring通常被称为是构造Java工程的轻量级框架。这其中包含了两方面的内容：首先，你可以使用Spring构造各种Java工程，而不是像Apache的Struts那样，仅仅局限于Web工程。其次，所谓轻量级框架，并不是指类的数量或是工程的规模是轻量级的，用Spring的话说，轻量级就意味着更少的影响，你可以很容易的修改你的程序来获得Spring提供的各种好处，也可以很容易的从你的工程中去除Spring。当然，需要注意的是，这仅仅是指Spring的核心组件。Spring还提供了很多其它的组件，像数据访问等，使用这些组件，将使得你的工程与Spring框架形成耦合，但是，相比于你获得的好处而言，这些耦合根本算不得什么。

Spring框架的核心是基于控制反转(Invdersion Of Control, IOC)理论的，控制反转使得我们可以在外部来创建和管理组件之间的依赖关系。例如：类Foo依赖于一个Bar类型的实例来执行某些操作，传统的方式是，Foo使用new关键字或者从某个工厂类来创建一个Bar类的实例。然而，使用控制反转，一个Bar类型的实例将在运行时由外部程序提供。这种方式可以很形象的看作是在运行时，将依赖的组件实例注入到当前组件中。因此，在某些时候，控制反转也被称为依赖注入(Dependency Injection, DI)。在Spring中，你可以认为控制反转就等同于依赖注入。

依赖注入给我们带来的好处包括：

1.减少了组件关联的代码：你不再需要在组件内部自己创建需要使用的其它组件，它们会在运行时自动被注入进来，特别是当某些组件需要通过JNDI来获得，或是根本无法直接获得，例如远程资源时，DI带来的好处就更加明显了。

2.将依赖关系移到代码外：这会带来两点好处，首先，你可以在外部方便的管理组件间的依赖关系，而不需要重新编译代码。其次，你可以方便的切换某些依赖的实现类，例如将PostgreSQL的DAO实现切换为Oracle的DAO实现。

3.统一的依赖管理：传统的散布在工程各处的管理依赖关系的代码将不复存在，所有的依赖信息都集中在一个统一的地方，这使得维护变得容易，同时降低了发生错误的可能。

4.提高了可测试性：你可以很容易的替换依赖类的实现方式，如使用mock实现来代替真正的实现方式。假设我们需要测试业务对象(Business Object, BO)，我们就可以使用mock实现来代替真正的DAO实现，从而避免真正地访问数据库，这大大提高了测试的效率。

5.遵循良好的设计方式：使用DI通常意味着遵循面向接口的设计方式。毫无疑问，面向接口是一种良好的设计方式。

Spring框架还包括了以下这些方面的内容：

1.面向方面的编程(Aspect Oriented Programming, AOP)

2.数据访问(Accessing Data in Spring)

3.事务管理(Managing Transactions)

4.简化J2EE的整合(Simplifying and Integrating with J2EE)

5.Web层的MVC框架(MVC in the Web Tier)

6.对远程访问的支持(Remoting Support)

7.邮件支持(Mail Support)

8.任务安排的支持(Job Scheduling Support)

9.简化的异常处理(Simplified Exception Handling)

10.源代码级的元数据(Source Level Metadata)

刘璐 2006-12-21 10:20 发表评论

《Pro Spring》学习笔记(3)－－Spring中的IOC

刘璐 — Thu, 21 Dec 2006 02:20:00 GMT

控制反转包括两种类型：依赖查找（Dependency Lookup）和依赖注入（Dependency Injection），我们主要讨论的是依赖注入。

依赖注入可以分为两种类型：构造子注入（Constructor Dependency Injection）和设值注入（Setter Dependency Injection）

构造子注入，组件的依赖关系是通过构造函数来提供的，每个依赖关系对应构造函数的各个参数，IOC容器在实例化组件时，通过构造函数注入依赖关系。

public class ConstructorInjection {
private Dependency dep;

public ConstructorInjection(Dependency dep) {

this.dep = dep;
}
}

构造子注入适用于在使用某个组件之前，确保所有的依赖关系都已注入。

      设值注入，组件的依赖关系是通过JavaBean形式的setter方法注入的，IOC容器通过调用相应的set方法注入依赖关系。
public class SetterInjection {
    private Dependency dep;
    public void setMyDependency(Dependency dep) {
        this.dep = dep;
    }
}

设值注入适用于需要给某些依赖关系提供默认值的情况。

Spring IOC容器的核心是BeanFactory，BeanFactory负责管理组件以及组件间的依赖关系。术语bean在Spring中代表由容器管理的任何组件。Spring提供了两种常用的BeanFactory实现：DefaultListableBeanFactory和XmlBeanFactory。

在BeanFactory中，每个bean都至少有一个名称，作为唯一标识，如果bean拥有多个名称的话，那么除第一个名称外的其它名称都将被认为是别名。

DefaultListableBeanFactory可以使用PropertiesBeanDefinitionReader或者XmlBeanDefinitionReader（当然还可以是其它任何实现了BeanDefinitionReader接口的Bean定义读取器）来读取配置文件。

//使用PropertiesBeanDefinitionReader

private static BeanFactory getBeanFactory() throws Exception {
    // get the bean factory
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    // create a definition reader
    PropertiesBeanDefinitionReader rdr = new PropertiesBeanDefinitionReader(factory);
    // load the configuration options
    Properties props = new Properties();
    props.load(new FileInputStream("./ch2/src/conf/beans.properties"));
    rdr.registerBeanDefinitions(props);
    return factory;

}

//使用XmlBeanDefinitionReader

// load the configuration options
rdr.loadBeanDefinitions(new FileSystemResource("ch4/src/conf/beans.xml"));

return factory;

}

XmlBeanFactory继承了DefaultListableBeanFactory，在使用XML配置文件时可以简化代码的编写，这也是我们最常用的BeanFactory。

private static BeanFactory getBeanFactory() throws Exception {
XmlBeanFactory factory =

new XmlBeanFactory(new FileSystemResource("ch4/src/conf/beans.xml"));

return factory;

}

获得了BeanFactory对象后，我们就可以使用bean的名称来获取我们需要的组件对象了。

Oracle oracle = (Oracle)factoyr.get("oracle");

刘璐 2006-12-21 10:20 发表评论

(转)《Pro Spring》学习笔记(1)－－写在前面的话

刘璐 — Thu, 21 Dec 2006 02:19:00 GMT

不是刚开始接触Spring了，也用Spring做过一些东西。我的感觉是用Spring会有一种很爽的感觉，一切都是那么的简单高效，顺理成章。

在网上也看到过很多牛人对Spring的评论文章，其中不乏一些颇有微词的评论。当然，任何事务都不可能十全十美的，我只是一个普通的Java程序员，还无法站在一定的高度，看到Spring这样那样的不足。我感觉到的只是Spring给我带来的好处和便利，因此我选择了Spring。

接下来的文字，记录的只是在学习《Pro Spring》这本书的过程中，我觉得需要着重了解的部分，大部分文字属于抄书，外加一点点个人的理解。

感谢Rob Harrop和Jan Machacek给我们带来了这本通俗易懂的Spring入门书籍。

刘璐 2006-12-21 10:19 发表评论

springIDE

刘璐 — Sat, 18 Nov 2006 08:13:00 GMT

首先尝试link方式安装，无法使用。上网查询后，网友都认为应该用updata方式安装

1.打开eclipse，菜单"help"->"software updates"->"find and install"
2.在弹出的界面中选择“Search for new features to install”
3.这一步可分成两种情况：
a.如果本地已经下载SpringIDE的压缩包，请解压到一个目录（比如SpringIDE），里面有两个目录（features、plugins）和一个文件site.xml，在弹出的界面中选择"New Local Site"，指到前面的解压后目录（SpringIDE），点“OK”，在"Name"中输入“SpringIDE Update”
b.如果没有下载SpringIDE的压缩包，在弹出的界面中选择“New Remote Site”，在"Name"中输入“SpringIDE Update”，在“URL”中输入“http://springide.org/updatesite/”，点“OK”
4.选中"SpringIDE Update"，点“finish”,开始搜索站点的更新信息
5.在搜索界面的界面中选中要更新的，继续
因为我的网络有防火墙隔离，所以直接下载了springide_updatesite_1.2.1.zip在本地安装。

安装过程中，出现error retrieving “feature.xml“的错误，这时候删除了根目录的site.xml文件，就可以updata了

另外，springIDE的使用方法可以参考 http://www.volitation.net/Dynamic/print.asp?SelectID=101

刘璐 2006-11-18 16:13 发表评论

spring 编程入门十大问题解答

刘璐 — Thu, 14 Sep 2006 00:25:00 GMT

1、如何学习Spring？
你可以通过下列途径学习spring：
(1) spring下载包中doc目录下的MVC-step-by-step和sample目录下的例子都是比较好的spring开发的例子。

(2) AppFuse集成了目前最流行的几个开源轻量级框架或者工具Ant,XDoclet,Spring,Hibernate(iBATIS),JUnit,Cactus,StrutsTestCase,Canoo's WebTest,Struts Menu,Display Tag Library,OSCache,JSTL,Struts 。
你可以通过AppFuse源代码来学习spring。
AppFuse网站：http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuse

(3)Spring 开发指南(夏昕)（http://www.xiaxin.net/Spring_Dev_Guide.rar）
一本spring的入门书籍,里面介绍了反转控制和依赖注射的概念，以及spring的bean管理，spring的MVC，spring和hibernte，iBatis的结合。

(4) spring学习的中文论坛
SpringFramework中文论坛(http://spring.jactiongroup.net)
Java视线论坛(http://forum.javaeye.com)的spring栏目

2、利用Spring框架编程，console打印出log4j:WARN Please initialize the log4j system properly？
说明你的log4j.properties没有配置。请把log4j.properties放到工程的classpath中，eclipse的classpath为bin目录，由于编译后src目录下的文件会拷贝到bin目录下，所以你可以把log4j.properties放到src目录下。
这里给出一个log4j.properties的例子：

log4j.rootLogger=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%F:%L) - %m%n

3、出现 java.lang.NoClassDefFoundError?
一般情况下是由于你没有把必要的jar包放到lib中。

比如你要采用spring和hibernate（带事务支持的话），你除了spring.jar外还需要hibernat.jar、aopalliance.jar、cglig.jar、jakarta-commons下的几个jar包。

http://www.springframework.org/download.html下载spring开发包，提供两种zip包
spring-framework-1.1.3-with-dependencies.zip和spring-framework-1.1.3.zip，我建议你下载spring-framework-1.1.3-with-dependencies.zip。这个zip解压缩后比后者多一个lib目录，其中有hibernate、j2ee、dom4j、aopalliance、jakarta-commons等常用包。

4、java.io.FileNotFoundException: Could not open class path resource [....hbm.xml],提示找不到xml文件？
原因一般有两个：
(1)该xml文件没有在classpath中。
(2)applicationContext-hibernate.xml中的xml名字没有带包名。比如：




                User.hbm.xml         错，改为： com/yz/spring/domain/User.hbm.xml




         net.sf.hibernate.dialect.MySQLDialect
         true

5、org.springframework.beans.NotWritablePropertyException: Invalid property 'postDao' of bean class？
出现异常的原因是在application-xxx.xml中property name的错误。
中name的名字是与bean的set方法相关的，而且要注意大小写。
比如
public class PostManageImpl extends BaseManage implements PostManage {
    private PostDAO dao = null;
    public void setPostDAO(PostDAO postDAO){
        this.dao = postDAO;
    }
}
那么xml的定义应该是：



                    对
                            错

6、Spring中如何实现事务管理？
        首先，如果使用mysql，确定mysql为InnoDB类型。
        事务管理的控制应该放到商业逻辑层。你可以写个处理商业逻辑的JavaBean，在该JavaBean中调用DAO，然后把该Bean的方法纳入spring的事务管理。

比如：xml文件定义如下：
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">



                PROPAGATION_REQUIRED
                PROPAGATION_REQUIRED
                PROPAGATION_REQUIRED

com.yz.spring.service.implement.UserManageImpl就是我们的实现商业逻辑的JavaBean。我们通过parent元素声明其事务支持。

7、如何管理Spring框架下更多的JavaBean？
        JavaBean越多，spring配置文件就越大，这样不易维护。为了使配置清晰，我们可以将JavaBean分类管理，放在不同的配置文件中。应用启动时将所有的xml同时加载。
比如：
        DAO层的JavaBean放到applicationContext-hibernate.xml中，商业逻辑层的JavaBean放到applicationContext-service.xml中。然后启动类中调用以下代码载入所有的ApplicationContext。

String[] paths = {"com/yz/spring/dao/hibernate/applicationContext-hibernate.xml",
                        "com/yz/spring/service/applicationContext-service.xml"};
ctx = new ClassPathXmlApplicationContext(paths);

8、web应用中如何加载ApplicationContext？
可以通过定义web.xml，由web容器自动加载。

  context
  org.springframework.web.context.ContextLoaderServlet
  1

  contextConfigLocation
  /WEB-INF/applicationContext-hibernate.xml
  /WEB-INF/applicationContext-service.xml

9、在spring中如何配置的log4j?
在web.xml中加入以下代码即可。

log4jConfigLocation
/WEB-INF/log4j.properties

10、Spring框架入门的编程问题解决了，我该如何更深地领会Spring框架呢？
这两本书你该去看看。这两本书是由Spring的作者Rod Johnson编写的。
Expert One on one J2EE Design and Development
Expert One on one J2EE Development Without EJB
你也该看看martinfowler的Inversion of Control Containers and the Dependency Injection pattern。
http://www.martinfowler.com/articles/injection.html

再好好研读一下spring的文档。
http://www.jactiongroup.net/reference/html/index.html（中文版，未全部翻译）

还有就是多实践吧。

刘璐 2006-09-14 08:25 发表评论