Spring是什么？

1. Struts是Web框架

2. Hibernate是ORM框架，处于持久层

3. Spring是容器框架，用于配置Bean，并维护Bean之间关系的一种框架。

1. Spring中有一个非常重要的概念：Bean，Bean是Java中的任何一种对象，它可以是JavaBean、可以是Service，可以是Action，也可以是DAO

2. 重要的概念：IOC（控制反转，Inverse Of Control）, DI（依赖注入，Dependency Injection），两者是一样的

入门案例

通过IDEA开发一个Spring的入门项目SpringFirst。

1. 新建项目，并且添加Spring框架支持。

接着输入项目名字SpringFirst。

点击Finish之后，IDEA会帮我们下载Spring框架的Jar包。

完成之后，项目的目录结构如下：

可以看到IDEA自动帮我们下载了Spring的支持Jar包，并添加了配置文件spring-config.xml。

1. 开发一个Bean，假设为UserService，如下代码：

public class UserService {
    private String name;

    public String getName() {
        return name;
    }

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

    public void sayHello() {
        System.out.println("Hello, " + name);
    }
}

1. 配置spring-config.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">
    <!--在容器文件中配置Bean-->
    <!--bean元素的作用是：当Spring框架加载的时候，Spring就会自动创建该Bean对象，并放入内存-->
    <bean id="userService" class="com.gavin.service.UserService">
        <!--这里体现出注入的概念，把属性的值注入到Bean对象中-->
        <property name="name">
            <value>Gavin</value>
        </property>
    </bean>
</beans>

1. 在主方法中测试：

import com.gavin.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestMain {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.sayHello();
    }
}

程序输出：

细节讨论

传统的方法和使用Spring的方法有什么区别：

1. 使用Spring，没有new对象，而是把创建对象的任务交给Spring框架

2. Spring怎么维护对象与对象之间的关系呢？ –> 利用ref属性。看下述案例。

那么，假设我们添加ByeService，并且在UserService中组合了ByeService对象。

ByeService如下：

package com.gavin.service;

public class ByeService {
    private String name;

    public String getName() {
        return name;
    }

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

    public void sayBye() {
        System.out.println("Bye, " + name);
    }
}

UserService组合ByeService如下：

package com.gavin.service;

public class UserService {
    private String name;
    private ByeService byeService;

    public String getName() {
        return name;
    }

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

    public ByeService getByeService() {
        return byeService;
    }

    public void setByeService(ByeService byeService) {
        this.byeService = byeService;
    }

    public void sayHello() {
        System.out.println("Hello, " + name);
        byeService.sayBye();
    }
}

配置文件spring-config.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">
    <!--在容器文件中配置Bean-->
    <!--bean元素的作用是：当Spring框架加载的时候，Spring就会自动创建该Bean对象，并放入内存-->
    <bean id="userService" class="com.gavin.service.UserService">
        <!--这里体现出注入的概念，把属性的值注入到Bean对象中-->
        <property name="name">
            <value>Gavin</value>
        </property>
        <!--在userService中引用配置的另外一个bean，比如byeService-->
        <property name="byeService" ref="byeService"/>
    </bean>
    <bean id="byeService" class="com.gavin.service.ByeService">
        <property name="name">
            <value>XiaoMing</value>
        </property>
    </bean>
</beans></bean>

此时我们再次执行测试，输出如下：

1. 当ClassPathXmlApplicationContext("spring-config.xml")执行的时候，Spring容器对象被创建，同时spring-config中配置的Bean就会被创建（依赖于反射机制）

2. UserService userService = (UserService)applicationContext.getBean("userService");获取Spring容器中的对象。

IOC是什么？

IOC（Inverse Of Control），控制反转。所谓控制反转，就是把创建对象（Bean）和维护对象（Bean）关系的权力从程序中转移到Spring容器中，而程序本身不再负责维护。

DI是什么？

DI（Dependency Injection），依赖注入。所谓依赖注入，实际上，DI和IOC是同一个概念，Spring设计者认为DI能更准确地表示Spring的核心技术。

重量级ApplicationContext

因为ApplicationContext是一个重量级的类，所以将其做成单态的，如下工具类代码：

final public class ApplicationContextUtil {
    private static ApplicationContext applicationContext = null;

    static{
        applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
    }

    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }

    private ApplicationContextUtil(){}
}