spring通俗演绎

标签：

学框架不学spring都不好意思跟别人说自己懂框架，而且现在好多java方面的工作要求熟练spring/myBaits等主流框架，自己学 spring也有一段时间了，做一篇博客整理下自己的思路，技术吗，不沉淀下来终究无法转化成自己的东西，之所以写的通俗一点，权且是对自己渣比的调侃吧。

　　从spring的两大思想开始：1.IOC; 2.AOP

　　IOC(inversion of control)，控制反转，这里的控制是指控制对象的创建，众所周知，java中是通过new关键字来创建对象的，有些仅仅使用一次的对象反复创建，造 成了资源的浪费，如果将对象的创建交付给容器，不仅能省去大量资源使对象复用，更能省去某些麻烦（反复new对象造成的麻烦应该不只资源浪费，猜测）。个 人感觉，设计模式的重要想法就是专门弄一项技术来处理某些专门的需求，正是对象资源的管理催生了ioc，将对象管理交给容器来管理，需要对象时候从容器里 面拿一个就好，是不是很方便，哈哈。所谓容器，实现起来就是由jvm创建和管理一块专门放对象的内存，容器的启动，初始化，销毁特性概括起来就是生命周 期，spring正是在容器的生命周期内完成对象的管理的。下面是new对象方式和ioc方式处理对象的对照:

public class Car{
        public car(){
            //汽车初始化时候也要初始化发动机
            Egnine eg=new Egnine();
    }
}
//使用时候
Car car=new Car();

使用ioc方式，把对象的关系写在xml文件中，这样汽车一初始化的时候，引擎也随之初始化，就是把它们的创建关系写在另外一个擅长逻辑关系管理的文件中，这种文件名字叫xml.
这样做的另外一个好处就是,如果一个car需要两个引擎，把xml改掉之后原来代码照样跑，有个高大上的名字叫-解耦,需要什么在bean的配置文件里面嵌套一些bean作为参数，这种
方式称之为注入.

Step 1

<bean id="Car" class="cn.usct.Car">

　　<constructor-arg ref="eg"></constructor-arg>

</bean>

<bean id="eg" class="cn.usct.Egnine"></bean>

Car和Egnine的代码照常(ioc只提供对象管理，但对象是什么样子还是靠.java文件里的类)

Step 2
Car c=ApplicationContext.get("Car");

spring3和spring2.5的一大区别就是通过id的getBean()方法还需要用a.class作为第二个参数

第一个spring使用：

1.创建项目，导入jar包，项目结构:“src”用于存放java文件；“lib”用于存放jar文件；“resources”用于存放配置文件

2.写接口和实现类

3.

1. //1、读取配置文件实例化一个IoC容器  
2.              ApplicationContext context = new ClassPathXmlApplicationContext("helloworld.xml");  
3.              //2、从容器中获取Bean，注意此处完全“面向接口编程，而不是面向实现”  
4.               HelloApi helloApi = context.getBean("hello", HelloApi.class);  
5.               //3、执行业务逻辑  
6.               helloApi.sayHello();

最常用API:Object getBean(String name) 根据名称返回一个Bean，客户端需要自己进行类型转换；

二，获取bean的方式(四种)

id，类（car.class）,名字+类

三，实例化

1.<constructor-args index="0" value="hello!"/> 为一个参数的构造方法提供了字符串类型参数

2.普通工厂实例化

1. package cn.javass.spring.chapter2;  
2. public class HelloApiInstanceFactory {  
3. public HelloApi newInstance(String message) {  
4.           return new HelloImpl2(message);  
5.    }  
6. }

　　xml

1. <!—1、定义实例工厂Bean -->  
2. <bean id="beanInstanceFactory"  
3. class="cn.javass.spring.chapter2.HelloApiInstanceFactory"/>  
4. <!—2、使用实例工厂Bean创建Bean -->  
5. <bean id="bean4"  
6. factory-bean="beanInstanceFactory"  
7.      factory-method="newInstance">  
8.  <constructor-arg index="0" value="Hello Spring!"></constructor-arg>  
9. </bean>
   

　　测试代码

1. BeanFactory beanFactory =  
2. new ClassPathXmlApplicationContext("chapter2/instantiatingBean.xml");  
3.        HelloApi bean4 = beanFactory.getBean("bean4", HelloApi.class);  
4.        bean4.sayHello();
   

四，注入

1.

构造方法注入:index,name,type

1. <!-- 通过构造器参数索引方式依赖注入 -->  
2. <bean id="byIndex" class="cn.javass.spring.chapter3.HelloImpl3">  
3. <constructor-arg index="0" value="Hello World!"/>  
4.     <constructor-arg index="1" value="1"/>  
5. </bean>  
6. <!-- 通过构造器参数类型方式依赖注入 -->  
7. <bean id="byType" class="cn.javass.spring.chapter3.HelloImpl3">  
8.    <constructor-arg type="java.lang.String" value="Hello World!"/>  
9.    <constructor-arg type="int" value="2"/>  
10. </bean>  
11. <!-- 通过构造器参数名称方式依赖注入 -->  
12. <bean id="byName" class="cn.javass.spring.chapter3.HelloImpl3">  
13.    <constructor-arg name="message" value="Hello World!"/>  
14.    <constructor-arg name="index" value="3"/>  
15. </bean>

不建议使用name注入

2.

2.1注入普通属性

setter方法注入

1.类文件

1. package cn.javass.spring.chapter3;  
2. import cn.javass.spring.chapter2.helloworld.HelloApi;  
3. public class HelloImpl4 implements HelloApi {  
4.     private String message;  
5.     private int index;  
6. //setter方法  
7.     public void setMessage(String message) {  
8.         this.message = message;  
9.     }  
10.     public void setIndex(int index) {  
11.         this.index = index;  
12.     }  
13.     @Override  
14.     public void sayHello() {  
15.         System.out.println(index + ":" + message);  
16.     }  
17. }
    

2.配置bean，主要是property

1. <!-- 通过setter方式进行依赖注入 -->  
2.     <bean id="bean" class="cn.javass.spring.chapter3.HelloImpl4">  
3.         <property name="message" value="Hello World!"/>  
4.         <property name="index">  
5.             <value>1</value>  
6.         </property>  
7.     </bean> 
   

2.2注入集合

1类

1. package cn.javass.spring.chapter3.bean;  
2. import java.util.List;  
3. public class ListTestBean {  
4.     private List<String> values;  
5.     public List<String> getValues() {  
6.         return values;  
7.     }  
8.     public void setValues(List<String> values) {  
9.         this.values = values;  
10.     }  
11. }

2注入

1. <bean id="listBean" class="cn.javass.spring.chapter3.bean.ListTestBean">  
2.     <property name="values">  
3.         <list>  
4.             <value>1</value>  
5.             <value>2</value>  
6.             <value>3</value>  
7.         </list>  
8.    </property>  
9. </bean>
   

3测试

1. @Test  
2. public void testListInject() {  
3.    BeanFactory beanFactory =  
4. new ClassPathXmlApplicationContext("chapter3/listInject.xml");  
5. ListTestBean listBean = beanFactory.getBean("listBean", ListTestBean.class);  
6. System.out.println(listBean.getValues().size());  
7. Assert.assertEquals(3, listBean.getValues().size());  
8. }

Assert.assertEquals();方法判断前后两个值是否相等

set集合类型与之相同

3

注入其他bean

1. <bean id="bean2" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">  
2.     <property name="helloApi"><ref bean=" helloApi"/></property>  
3. </bean>

注入总结

一、构造器注入：

1）常量值

简写：<constructor-arg index="0" value="常量"/>

全写：<constructor-arg index="0"><value>常量</value></constructor-arg>

2）引用

简写：<constructor-arg index="0" ref="引用"/>

全写：<constructor-arg index="0"><ref bean="引用"/></constructor-arg>

二、setter注入：      

       1）常量值

        简写：<property name="message" value="常量"/>

        全写：<property name="message"><value>常量</value></ property>

       2）引用

        简写：<property name="message" ref="引用"/>

        全写：<property name="message"><ref bean="引用"/></ property>

       3）数组：<array>没有简写形式

       4）列表：<list>没有简写形式

       5）集合：<set>没有简写形式

       6）字典

          简写：<map>

             <entry key="键常量" value="值常量"/>

             <entry key-ref="键引用" value-ref="值引用"/>

            </map>

         全写：<map>

             <entry><key><value>键常量</value></key><value>值常量</value></entry>

             <entry><key><ref bean="键引用"/></key><ref bean="值引用"/></entry>

           </map>

       7）Properties：没有简写形式

ps:null值注入

<property name="name"></null></>

(原理篇)

还有一个问题，ioc是如何实现的?

 我的理解是依靠反射，基于dom解析器的解析原理，当读到一个id时候，按照符合ioc的dtd,class里面理应是这个bean的实现类，本质上还是通过new来创建并且返回，只是spring默认的是单例模式，那么创建之前先加判断 if(instance==null){创建}

spring通俗演绎

标签：

原文地址：http://www.cnblogs.com/wuzhuangzhexuejia/p/5579792.html