spring2.0使用手册学习笔记（一）

spring2.0使用手册学习笔记（一）

                                                            第一章 概论
1. 关于轻量重量级的解释
    夏昕说：现在的轻量级和重量级的确很难区分了，没有一个明确的衡量标准，之前有人说，有classloader的算是重量级；也有人说，超过3MB的算是重量级，spring core算是轻量级的，但是加上期于的部件，估计就得列入重量记的范畴了。
林信良说：用了spring并不等于轻量级开发。重点是您有没有采纳其精神，用了IOC就轻量级了吗？不见得。什么都来不DI，我看也是很沉重的；如果你在设计时善用IoC，即使不用spring也是轻量级。不要为了spring而spring。
2. IoC的理解
   Don't call me,I will call you!程序不依赖于实现，而是依赖与抽象接口。在设计业务类时，我们设计为它依赖于某抽象接口，具体的需要哪个实现类是由配置文件来帮我们注入的。这就是面向接口编程的思想，当业务需求发生变动时，我们只需修改其实现类的具体实现，而接口并没有改变，所以低层业务代码不做任何改动，既增加了代码的复用率，也是功能接口变得清晰。Don't call me,you should call my interface！
3. DI 依赖注入的理解
    保留抽象接口，让组件依赖抽象接口，当组件要与其他实际的对象发生依赖关系时，由抽象接口来注入依赖的实际对象。依赖注入，注入你所依赖的实现类，由spring容器帮你注入适合的实现类，而不是你自己去创建bean实例。有3种基本实现方式：Interface injection、Setter injection与Constructor injection。
4. 应用程序中获取bean

1       < bean id = " helloBean "   class = " chapter2.HelloBean " >
2           < property name = " helloWord " >
3               < value > Hello yangay !</ value >
4           </ property >
5       </ bean >

     public   static   void  main(String[] args)  {
        Resource rs = new ClassPathResource("applicationContext.xml");//从classpath下加载配置信息
        BeanFactory factory = new XmlBeanFactory(rs);//基于xml格式配置文件的实例化方式，得到一个BeanFactory
        HelloBean hello = (HelloBean)factory.getBean("helloBean");//获取id="helloBean"的bean，此时可以调用bean里定义的所有方法
        System.out.println(hello.getHelloWord());
    }

   
    这是通过beanFactory管理Bean的方式，BeanFactory负责读取Bean定义文件；管理对象的加载、生成；维护Bean对象之间的依赖关系；负责Bean的生命周期，对于简单的应用程序来说，使用BeanFactory就已经足够来管理Bean了。BeanFactory接口提供了六个方法管理Bean。
另外还可以通过ApplicationContext来获取Bean对象：

1  ApplicationContext ctx  =   new  ClassPathXmlApplicationContext( " applicationContext.xml " );//从classpath下加载配置信息
2  HelloBean hello  =  (HelloBean)ctx.getBean( " helloBean " ); // 获取id="helloBean"的bean，此时可以调用bean里定义的所有方法

                            第二章 spring IoC、AOP实例及分析
1. IoC实例一
    控制反转用得最多的是为业务类注入Bean对象，典型的应用是在结合struts开发是，为struts的action类来注入springDao，这样在业务层如action类中不再介入spring API，但同时又可以利用spring提供的所有便捷功能。低层实现细节发生的变化，对业务层来说是透明的，不但降低了程序的偶合性，而且也提高了DAO对象的重用性。在这个例子中，为了简单起见，我们只为HelloBean注入了一个字符串，而不是注入实体Bean。但这只体现出了控制反转的特点，对于依赖注入DI并没有得到明显的体现。
1）首先编写一个简单的JAVABEAN

1  public   class  HelloBean {
2       private  String helloWord;

3       public  String getHelloWord() {
4           return  helloWord;
5      }
6       public   void  setHelloWord(String helloWord) {
7           this .helloWord  =  helloWord;
8      }
9  }

2）接下来编写 Bean定义文件，定义文件告诉spring如何完成以来关系的注入等动作。我们这里命名文件为applicationContext.xml,定义文件中省略了xml文件的头

1       < bean id = " helloBean "   class = " chapter2.HelloBean " >//应用程序中用于取得bean的标志
2           < property name = " helloWord " >//设置了bean中setter的名称
3               < value > Hello yangay !</ value >//设置了将要注入的值
4           </ property >
5       </ bean >

3）最后编写一个简单的示范程序

1  public   class  SpringDemo {
2 
3       public   static   void  main(String[] args) {
4          ApplicationContext ctx  =   new  ClassPathXmlApplicationContext( " applicationContext.xml " );
5          HelloBean hello  =  (HelloBean)ctx.getBean( " helloBean " ); // 获取id="helloBean"的bean，此时可以调用bean里定义的所有方法
6          System.out.println(hello.getHelloWord());
7      }
8  }

运行之，将会看到在bean定义文件中为"helloWord"设置的值"Hello yangay!"被打印出来。
--------------------
2. 1. IoC实例二
    其实spring IoC的初衷就是降低程序的偶合性，使开发者面向接口编程，使业务层设计不以来于实现，具体依赖与哪个bean是在speing培植文件中来定义的。同样在这里写一个示范程序，包括一个接口，两个实现类，一与业务有关的Business类，Business类依赖的是接口，而不是接口的实现，具体需要哪个实现是由spring容器来实现注入的。
1）接口
只声明了一个保存的方法

1  public   interface  IDeviceWriter {
2       void  svaeToDevice();
3  }

2）第一个实现IDeviceWriter接口的类，存储到 软盘

1  public   class  FloppyWriter  implements  IDeviceWriter{
2 
3       public   void  svaeToDevice() {
4          System.out.println( " 存储至软盘 " );
5      }
6  }

3）第二个实现IDeviceWriter接口的类，存储到 硬盘

1 
2  public   class  DiskWriter  implements  IDeviceWriter{
3 
4       public   void  svaeToDevice() {
5          System.out.println( " 存储至硬盘 " );
6      }
7  }

4）业务类，依赖于抽象的IDviceWriter接口，要 存储到磁盘还是软盘是由spring配置文件来决定的

 1  public   class  Business {
 2 
 3       private  IDeviceWriter writer;
 4       public   void  save(){
 5          writer.svaeToDevice();
 6      }
 7 
 8       public  IDeviceWriter getWriter() {
 9           return  writer;
10      }
11       public   void  setWriter(IDeviceWriter writer) {
12           this .writer  =  writer;
13      }
14  }

5）bean的定义文件

1       < bean id = " floppyWriter "   class = " chapter2.FloppyWriter " />
2       < bean id = " diskWriter "   class = " chapter2.FloppyWriter " />
3       < bean id = " business "   class = " chapter2.Business " >
4           < property name = " writer " >
5               < ref bean = " floppyWriter " />
6           </ property >
7       </ bean >

    将id为writer的bean注入到business Bean中，在Business对象中可以调用FloppyWriter的所有方法，实现了将数据保存至软盘的功能。

6）测试类

1  public   class  SpringDemo2 {
2 
3       public   static   void  main(String[] args) {
4          Resource rs  =   new  ClassPathResource( " applicationContext.xml " );
5          BeanFactory factory  =   new  XmlBeanFactory(rs);
6          Business business  =  (Business) factory.getBean( " business " );
7          business.save();
8      }
9  }

    现在如果我们想要把数据保存到硬盘，而不是软盘了，我们只需要修改bean的配置文件，让业务类Business依赖于diskWriter既可，Business不做任何的修改。这也是面向接口编程的好处所在。