Spring框架学习二：通过简单的HelloWorld程序理解IoC

 实现第一个 Spring HelloWorld 程序

　　接着上一次笔记，上次我们讲了使用 Spring 框架需要做的一些准备工作。现在，我们就来实现我们的第一个 Spring HelloWorld 程序，先不管为什么，我们先看效果。通过程序的效果，我们再进一步探知 Spring IoC 容器的工作原理。

　　首先我们需要新建一个 Spring 配置文件：在src下右键 new —> other —> 找到 Spring文件夹，点击 Spring Bean Configurations File，起名字叫 ApplicationContext.xml，编写如下内容

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- class属性值需要写完整的类全名 --!>
    <bean id="helloworld" class="com.bupt.springtest.beanXml.HelloWorld"/>

</beans>

package com.bupt.springtest.beanXml;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//新建一个测试类
public class HelloWorld
{
    public void greet()
    {
        System.out.println("Hello World!");
    }
    
    public static void main(String[] args)
    {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("HelloWorld.xml");
        
        HelloWorld hw = (HelloWorld) ctx.getBean("helloworld");
        
        hw.greet();
    }
}

以上程序我们可以得到结果：Hello World!

　　最后的结果 Hello World! 是怎么来的，很显然是调用了hw.greet()，而 hw 明显是 HelloWorld这个类的一个实例。但hw这个实例怎么来的？程序并没有为我们 new 出来一个HelloWorld实例。我们再来看上面两行代码，new ClassPathXmlApplicationContext("HelloWorld.xml") 这段代码，学过XML解析的同学应该会眼熟，这很像XML解析时的代码，同时结合到我们在xml文件中定义的一个 HelloWorld 类型的 bean 元素，以及ctx.getBean("helloworld")获取的对象，与 xml 中定义的 bean 的 id 值一样，我们应该可以大概得出结论：

　　解析xml文件后，将得到的各种 bean 放置到 ApplicationContext 容器中，容器对象再通过getBean()方法根据 bean id 获取对应的bean，接着就可以操作 bean 对象了。在这整个过程中，作为程序员的我们并没有任何创建对象的动作，创建 bean 实例的整个过程完全交由 Spring 框架来为我们实现，它何时创建，怎么创建我们一概不知。这时，我们再来看看IoC/DI的概念。

IoC(Inversion of Contorl)一般翻译成 "控制反转"，其思想是反转资源获取的方向。传统的资源查找方式要求组件项容器发起请求查找资源。作为回应，容器适时的返回资源。而应用了 IoC 之后，则是容器主动地将资源推送给它所管理的组件，组件所要做的仅是选择一种合适的方式来接受资源。

DI(Dependncy Injection)依赖注入：它是IoC的另一种表述方式，即组件以一些预先定义好的方式(如：setter方法)接受来自如容器的资源注入，相较于IoC而言，这种表述更直接。

　　通过概念的解释我们应该更好理解 IoC/DI 了吧，IoC就是一个容器，它为我们获取 bean 资源提供了一种方式。让我们不再手动的去 new 一个对象，而是容器自己会为我们自动生成好对象，只要把配置文件配置好。如此一来，大大降低了模块与模块之间的耦合性。因为当一个类需要持有另一类的对象时，不再需要去手动地实例化这个类，只要通过 Spring 框架为我们注入即可。当一个模块需求改变时，也不会涉及到对其他类的修改。

　　现在我们通过分析代码来实现自己的IoC容器，模拟整个 IoC/DI 过程。由前面我们知道，IoC容器会解析 xml 文件生成 bean 实例放置在容器中，xml 文件中配置有值为全类名的 class 属性。我们应该可以想到，这些 bean 实例是通过 反射生成的。所以，我们的 IoC 容器应该是：解析 xml 文件，将里面配置的 bean id 和通过反射生成的 bean 实例作为键值对放入一个Map对象中，这样我们才能通过 id 属性来获取 bean 实例。同时，我们还需要通过反射来为类中的属性赋值。下面来看代码

package com.bupt.test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * 模拟Spring的ClassPathXmlApplicationContext对象
 */
public class ClassPathXmlApplicationContext
{
    //创建Map对象用来存放beans.xml中配置的对象名(id)和对象(class.newInstance())的键值对
    private Map<String, Object> beans = new HashMap<>();
    
    public ClassPathXmlApplicationContext(String filePath) throws Exception
    {
        //获取jom4j解析器
        SAXReader sax = new SAXReader();
        //获取根节点
        Document doc = sax.read(filePath);
        //获取根元素节点beans
        Element rootElement = doc.getRootElement();
        //获取根节点元素下所有的子元素bean
        List<Element> elementList = rootElement.elements("bean");
        
        for(Element e : elementList)
        {
            //获取bean的id和class属性
            String id = e.attributeValue("id");
            String className = e.attributeValue("class");
            
            //反射获取class属性对应类的实例
            Object clazz = Class.forName(className).newInstance();
            
            beans.put(id, clazz);
            
            //获取类中定义的所有属性
            Field[] field = clazz.getClass().getDeclaredFields();
            //Map存放的是属性名和属性的class对象的键值对
            Map<String, Class<?>> map = new HashMap<>();
            //遍历属性，将属性名和属性的Class对象放入map
            for(Field f : field)
            {
                map.put(f.getName(), f.getType());
            }
            
            //获取所有叫property的子元素
            List<Element> propertyElement = e.elements("property");
            
            for(Element ele : propertyElement)
            {
                //获取property的name属性
                String name = ele.attributeValue("name");
                //拼接方法名如setName()
                String methodName = "set" + name.substring(0, 1).toUpperCase()+ name.substring(1);
                Method m = null;
                
                //获取property的bean和value属性
                String beanProperty = ele.attributeValue("bean");
                String valueProperty = ele.attributeValue("value");
                
                //若第二个属性为另一个bean的引用
                if(null != beanProperty)
                {
                    //反射获取setXxx方法对象
                    m = clazz.getClass().getMethod(methodName, new Class[]{beans.get(beanProperty).getClass().getInterfaces()[0]});
                    //执行setXxx方法
                    m.invoke(clazz, beans.get(beanProperty));
                    
                }
                //若第二个属性为value
                if(null != valueProperty)
                {
                    //根据value属性值，从map中获取setXxx方法的参数的Class对象
                    m = clazz.getClass().getMethod(methodName, new Class[]{map.get(name)});
                    
                    //判断参数类型，进行相应的类型变换，再将转换完后的参数传入invoke方法
                    if((String.class).equals(map.get(name)))
                    {
                        m.invoke(clazz, valueProperty);
                    }
                    else if((int.class).equals(map.get(name)))
                    {
                        m.invoke(clazz, Integer.parseInt(valueProperty));
                    }
                    else if((double.class).equals(map.get(name)))
                    {
                        m.invoke(clazz, Double.parseDouble(valueProperty));
                    }
                }
            }
        }
    }
    
    //通过id值返回自动生成的对象
    public Object getBean(String id)
    {
        return beans.get(id);
    }
}

下面编写测试类

package com.bupt.test;

public interface UserDAO
{
    public void save();
}

package com.bupt.test;

public class UserDAOImpl implements UserDAO
{
    @Override
    public void save()
    {
        System.out.println("a user saved!");
    }
}

package com.bupt.test;

public class UserService
{
    //持有对UserDAo的一个引用
    private UserDAO userDAO;
    private String name;
    private int age;
    private double height;
    
    public double getHeight()
    {
        return height;
    }

    public void setHeight(double height)
    {
        this.height = height;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public void add()
    {
        userDAO.save();
    }

    public UserDAO getUserDAO()
    {
        return userDAO;
    }

    public void setUserDAO(UserDAO userDAO)
    {
        this.userDAO = userDAO;
    }
}

src下创建一个 bean.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <!-- 把被引用的bean写在前面 -->
    <bean id="u" class="com.bupt.test.UserDAOImpl">
    </bean>
    <bean id="userService" class="com.bupt.test.UserService">
        <property name="userDAO" bean="u"/>    
        <property name="name" value="tom"/>
        <property name="age" value="19"/>
        <property name="height" value="178.8"/>
    </bean>
</beans>

编写执行测试类

package com.bupt.test;

public class ApplicationContextTest
{
    public static void main(String[] args) throws Exception
    {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("src/beans.xml");
        
        UserService service =(UserService)ctx.getBean("userService");
        
        service.add();
        
        System.out.println(service.getName() + ", " + service.getAge() + ", " + service.getHeight() + ", " + service.getUserDAO());
    }
}
/**
 * 结果为
 * a user saved!
 * tom, 19, 178.8, com.bupt.test.UserDAOImpl@128cdfa
 */ 

这就是模拟 IoC 容器的代码，希望通过这段代码，能加深大家对 IoC 容器的理解

关于 Spring 面试时常问的关于 IoC/DI 的问题

spring 的优点？

1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦 
2.可以使用容易提供的众多服务，如事务管理，消息服务等 
3.容器提供单例模式支持 
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能 
5.容器提供了众多的辅助类，能加快应用的开发 
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等 
7.spring属于低侵入式设计，代码的污染极低 
8.独立于各种应用服务器 
9.spring的DI机制降低了业务对象替换的复杂性 
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部

什么是DI机制？ 

依赖注入（Dependecy Injection）和控制反转（Inversion of Control）是同一个概念，具体的讲：当某个角色 
需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在spring中 
创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者 
因此也称为依赖注入。 
spring以动态灵活的方式来管理对象 ， 注入的两种方式，设置注入和构造注入。 
设置注入的优点：直观，自然 
构造注入的优点：可以在构造器中决定依赖关系的顺序。

什么是AOP？

面向切面编程（AOP）完善spring的依赖注入（DI），面向切面编程在spring中主要表现为两个方面 
1.面向切面编程提供声明式事务管理 
2.spring支持用户自定义的切面 

面向切面编程（aop）是对面向对象编程（oop）的补充， 
面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。 
AOP从程序运行角度考虑程序的结构，提取业务处理过程的切面，oop是静态的抽象，aop是动态的抽象， 
是对应用执行过程中的步骤进行抽象，，从而获得步骤之间的逻辑划分。 

aop框架具有的两个特征： 
1.各个步骤之间的良好隔离性 
2.源代码无关性