Spring框架的核心就是控制反转(Inversion of Control)和依赖注入(Dependency Injection)，通过这两方面来实现松耦合。
Spring框架的核心就是控制反转(Inversion of Control)和依赖注入(Dependency Injection)，通过这两方面来实现松耦合。
使用IoC，对象是被动的接受依赖类，而不是自己主动的去找。容器在实例化的时候主动将它的依赖类注入给它。可以这样理解：控制反转将类的主动权转移到接口上，依赖注入通过xml配置文件在类实例化时将其依赖类注入。通过下面的实例来逐步的理解：
首先假设有一个需求，类Business需要调用类Dependency的方法f()，按照日常的做法，得到下面的代码：
//**类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实例的获得该为setter方式，其次，将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;
}
}
在新的代码中，首先Business的变量d可以接收任何IDependency的实例，另外，Dependency的实例不是通过Business来获得，而是通过setter(也可以用构造器)来由外部传给它。这似乎跟我们往常的代码没什么不同，但这已经是一个良好的设计。关键就是Dependency的实例如何从外部注入给Business呢？
这就要通过xml来实现了。
创建一个SpringFirst.xml，进行简单的配置：
<beans>
<bean id = "dependency" class = "aopfirst.business.Dependency" />
<bean
id = "business"
class = "aopfirst.business.Business"
>
<property name = "dependency">
<ref bean = "dependency" />
</property>
</bean>
</beans>
这个配置文件里将Dependency类和Business类加入，并将Dependency作为Business的一个参数。
单有了这个xml文件还不够，还需要一个测试类来加载该xml文件，spring提供了现成的API，在加载上面的xml的时候，就进行了如下工作：实例化Dependency类，实例化Business类，并将Dependency的实例作为参数赋给了Business实例的
setDependency()方法。下面是该测试程序：
public class StartServer {
public static void main(String [] args) {
ClassPathResource cr = new ClassPathResource("SpringFirst.xml");
BeanFactory factory = new XmlBeanFactory(cr);
Business b = (Business)factory.getBean("business");
b.doSth();
}
}
上面的程序加载了xml以后，获得id为"business"的bean，即Business类的实例，并调用了其doSth()方法。由此可见，Business的依赖类Dependency是通过xml来注入的，而且Business是通过接口IDependency来接收Dependency实例。因此，当我们又有新的IDependency的实现时，只需要修改xml文件即可，测试程序只需要根据xml里的id值来获得需要的参数。
总结上面的例子，对控制反转和依赖注入已经能理解了。依赖类(Dependency)是通过外部(xml)来注入的，而不是由使用它的类(Business)来自己制造，这就是依赖的注入。另一方面，Business对类Dependency的依赖转移到对接口IDependency的依赖，控制权由类转移到了接口，即由"实现"转移到"抽象"中。这就是控制反转。
其实，依赖性注入(Dependency Injection)和控制反转(Inversion of Control)二者是同一个概念。具体含义是：当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring/Struct里，创建被调用者的工作不再由调用者来完成，因此称为“控制反转”；创建被调用者实例的工作通常由Spring/Struct容器来完成，然后注入调用者，因此也称为“依赖性注入”。
spring主要采用了java反射机制，
Java 反射机制是指Java程序可以在执行期载入，探知，使用编译期间完全未知的classes.这种机制对与软件框架的开发非常有效。和我以前在vb中用的callbyname等方法非常类似。
Java 反射机制主要提供了以下功能：
1.在运行时判断任意一个对象所属的类；
2.在运行时构造任意一个类的对象；
3.在运行时判断任意一个类所具有的成员变量和方法；
4.在运行时调用任意一个对象的方法；
5.生成动态代理
JDK中，实现反射机制的类在java.lang.reflect包中。
1. Class 类：代表一个类
它有以下方法
(1) getName()：
获得类的完整名字。
(2) getFields()：
获得类的public类型的属性。
(3) getDeclaredFields()：
获得类的所有属性,包括public、protected、默认和private访问级别的属性。
(4) getMethods()：
获得类的public类型的方法。
(5) getDeclaredMethods()：
获得类的所有方法。
(6) * getMethod(String name, Class[] parameterTypes)：
获得类的特定方法，name参数指定方法的名字，parameterTypes参数指定方法的参数类型。
(7) * getConstrutors()：
获得类的public类型的构造方法。
(8) * getConstrutor(Class[] parameterTypes)：
获得类的特定构造方法，parameterTypes参数指定构造方法的参数类型。
(9) newInstance()：
通过类的不带参数的构造方法创建这个类的一个对象。
2. Field 类：代表类的成员变量（类的属性）。
3. Method类：代表类的方法。
Method类的invoke(Object obj,Object args[])方法用于动态执行一个对象的特定方法，
它的第一个 obj 参数指定具有该方法的对象，第二个args 参数指定向该方法传递的参数。
4. Constructor类：代表类的构造方法。
5. Array 类：提供了动态创建数组，以及访问数组元素的静态方法。
1、spring 没有面向接口编程，其实用处不是特别大，应该逐步改进，而不是为spring而spring
2、spring也是一个容器，容器就是能够装载对象的对象
3、spring aop————面向方面编程，可以拦截方法、属性
5、spring 轻量级模型， 依赖注入
Spring与Hibernate的整合天衣无缝
可以直接配置sessionbean和hibernate xml定义文件。
