Spring的IOC理论

Spring

什么是Spring？

大家都知道，spring的中文意思是春天，而Spring框架，为软件开发行业带来了春天。为什么这么说呢？我们来看一看他的优点

优点

• Spring是一个开源框架，也就是说他是免费的
• Spring是一个轻量级、非侵入式框架。什么是非侵入式呢？Spring利用反射和动态调用来实例化的，代码中没有任何与spring交叉的类，哪怕把spring的jar全部去了，你的代码不受任何影响，加上其他的框架后可以继续运行
• IOC（控制反转）、AOP（面向切面）这个以后会慢慢谈
• 支持事务，也支持框架

Spring的组成

• Spring Core：这是Spring的核心容器，主要组件是BeanFactory，其作用是实现控制反转IOC，利用工厂设计模式对程序实现解耦。
• Spring context：即上下文，向Spring提供框架的上下文信息
• Spring AOP：面向切面，这个思想以后还会讲到，这里不过多深究
• Spring DAO：抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息
• Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map
• Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文
• Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。这个以后也会讲到。

Spring IOC思想

问题抛出

先问大家一个问题，如果有一天，我们去动物园，动物园里有小猫小狗，我们要观看这些动物。把我们观看的过程编写成一个程序，该怎么写？

程序实例

1、我们先创建一个Animal接口

public interface Animal {
    void info();
}

2、我们创建几只小动物类实现Animal接口
小猫类

public class Cat implements Animal {
    @Override
    public void info() {
        System.out.println("这是一个小猫");
    }
}

小鸟类

public class Bird implements Animal {
    @Override
    public void info() {
        System.out.println("这是一只小鸟");
    }
}

小狗类

public class Dog implements Animal {
    @Override
    public void info() {
        System.out.println("这是一只小狗");
    }
}

3、创建一个动物园类，现在动物园里有一只小鸟

public class Zoo {
    private Animal animal = new Bird();

    public void see(){
        animal.info();
    }
}

4、是“我”要去看小动物，那么就要创建一个我啦！

public class Me {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        zoo.see();
    }
}

好了，这个程序到这里就基本实现了，我们运行一下看一下结果

程序到这运行起来是没有问题的，但是有一个问题，我如果不看小鸟了，我想看小猫，怎么办？那只能去Zoo类里面，将Bird换成Cat了

public class Zoo {
    private Animal animal = new Cat();

    public void see(){
        animal.info();
    }
}

那如果我们想看小狗呢，动物园里可有成千上万只小动物啊，难道我们每看一次，动物园就要实例化一只动物对象给我们吗？而且不只是我，还有很多很多人要去动物园里看小动物呢！难道每次都要动物园实例化？

这显然是不可行的，这就需要我们的控制反转思想了。

先看我接下来的代码段：

Zoo类

public class Zoo {
    public void setAnimal(Animal animal) {
        this.animal = animal;
    }

    private Animal animal;

    public void see(){
        animal.info();
    }
}

Me类

public class Me {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        zoo.setAnimal(new cat());
        zoo.see();
        //现在我们想看小鸟
        zoo.setAnimal(new Bird());
        zoo.see();
    }
}

输出结果：

这个输出结果也是可以接受的，那么聪明的你，是否发现了这其中的变化呢？

你可能会说，只不过我把实例化对象的事情换成另外一个类而已嘛，结果都一样。但实际上，这已经发生了革命性的变化了。

一开始的程序，“我”只要想看一种动物，动物园就必须给我实例化一种动物，我如果要看另外一种，我就得去动物园里修改。而更新了之后的程序呢，“我”想看那一种动物，我只需要修改一下我想看的动物类型就好了。以前是动物园主动创建对象，我们被动接受，现在是我们主动创建对象，动物园被动接受。

换言之，以前一个程序，用户想要什么需求，程序就得创建什么对象，因为程序要服务每个用户，所有用户需求都需要满足；但现在，程序只需要被动接收对象，而我们需要什么需求，我们自己来创建对象即可，程序只需要向用户提供一个接口。

这种思想就是IOC（控制反转）思想的原型，运用这种思想，我们程序员再也不用管理对象的创建了，可以有更多的精力去关注业务层的实现，耦合度也大大降低。

IOC的实现

applicationContext.xml

<?xml version="1.0" encoding="GBK"?>
<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">

    <bean id="bird" class="bean.Bird"/>
    <bean id="cat" class="bean.cat"/>
    <bean id="dog" class="bean.Dog"/>
</beans>

applicationContext.xml已经代替了Zoo，现在是spring来帮助我们获取对象。

Me类

public class Me {
    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("applicationcontext.xml");
        Animal animal = beanFactory.getBean("bird",Animal.class);
        animal.info();
    }
}

使用Spring为我们提供的BeanFactory，并调用其getBean()方法，就可以获得配置文件xml中的对象。

运行结果：

IOC的理论就是这样子了，有什么不对的地方，欢迎指出或评论区讨论，有关AOP我们下次继续讨论。

学无止境，勇攀高峰！