对spring的理解

这几天看了挺多关于Spring的IOC（Inversion of Control）和DI（Dependency
Injection）的资料，也了解了Java的内存管理、垃圾回收机制、Java反射机制以及工厂设计模式等概念。

首先在看Spring的时候，由于自己Java基础比较差，所以搞不清楚Spring究竟是怎么实现对象的创建和注入，为什么这么做，优势在哪里，还有占不占内存...一大堆的疑问。

现在就简单地理一理，把自己目前了解到的先写下来，以备以后更进。（其中一些代码示例是基于网路上其他博文修改过的。。。）

1、Spring是怎么实现IOC的：

所谓控制反转，就是将“实现类” 的控制权转移给“接口”，请看下面例子

//**类Dependency**
public class Dependency {
public void f() {};
}
//**类Business**
public  class Business {
Dependency d;
public Business() {
d = new Dependency();
}
public void doSth() {
d.f();
}
}

上面这段代码，Business对象的创建 依赖于 类Dependency的实现，为了松耦合，采用工厂模式来设计程序，将对象的依赖交予接口来实现，如下所示：

//**接口IDependency**
public interface IDependency {
void f();
}

//**类Dependency**
public class Dependency {
public void f() {};
}

//**类Business**
public  class Business {
IDependency d;
public Business() {}
public void doSth() {
d.f();
}
public void setDependency(IDependency d) {
this.d = d;
}
}

上面这段代码先定义了一个接口IDependency，由Dependency来实现这个接口，在Business类中的变量d用来接收

IDependency的实例，这个实例的创建是依靠Business类中的setter方法（也可以是构造器）从外部来传给它。

那么问题来了，为什么这么做呢，工厂模式？有什么优势呢？

这个得先从为什么会有工厂模式说起，我自己的理解是，如果每次创建一个对象都需要依赖于具体的实现类，那么

就会出现紧耦合的现象，对于升级维护非常不利，什么是紧耦合？紧耦合就是A的程序紧密耦合着B的程序，如果我们

在A程序和B程序间加多一层（也就是接口），AB通过接口来进行交互，各自都无需顾忌对方内部是怎么实现的，只需

要对方能提供的结果，这就是松耦合。前辈们为此还想出了工厂设计模式的方法，将功能类似的"实现类"放在同一个

工厂接口中（FactoryInterface），根据自身需求参数，通过creator来创建一个具体的对象。

回到问题，可见控制反转可以依靠接口来创建对象，降低了耦合性，这是优势所在。

2、Spring怎么实现依赖注入DI

然后，在写完上面这段代码后，Spring又是怎么从外部来将Dependency注入到Business类中的呢？

   我们只需在Spring的配置文件SpringConfig.xml中，进行简单的配置：

<beans>
<!--定义了一个名为dependency的bean-->
<bean id = "dependency" class = "aopfirst.business.Dependency" />
<!--定义了一个名为business的bean ,其中将名为dependency的bean所对应的类注入到类Business中的对象d-->
<bean id = "business" class = "aopfirst.business.Business">
<property name = "d"> <ref bean = "dependency" /> </property>
</bean>
</beans>

这样子设置后，容器在加载的时候就会对Spring的xml配置文件进行解析（解析函数封装在Spring的包里面），然后通过Java的反射机制，由类的路径生成对象，并注入到特定类中。
以上就是Spring的IOC和DI，借用资料里面的总结：
依赖类(Dependency)是通过外部(xml)来注入的，而不是由使用它的类(Business)来自己制造，这就是依赖的注入。另一方面，Business对类Dependency的依赖转移到对接口IDependency的依赖，控制权由类转移到了接口，即由"实现"转移到"抽象"中。这就是控制反转。

对于内存问题，因为spring它自己的introspection所使用的缓冲在分析完一个类之后会被马上从javaBeans
Introspector缓冲中清除掉，所以不用考虑托管在Spring的bean的内存占用问题。

以上是自己的学习笔记，有很多缺漏，更进中....