控制反转（Inversion of Control），又叫依赖注入（Dependency Injection）。简单来说，在未使用IOC之前，假如说有一个User类，要调用里面的方法（不是静态方法），就要new一个对象（如：User user=new User），然后进行调用。但对于Spring的IOC来说，把new对象这个过程交给了Spring来实现并进行管理，程序员只需要使用即可。

AOP：面向切面编程。

面向切面编程（Aspect Orient Programming）支持允许将一些通用的任务如安全、事务、日志、缓存等进行集中式处理，从而提供了更好的复用，AOP通常用来处理一些具有横切性质的系统级服务。

1.3 Spring的优势

（1）方便解耦，简化开发

通过Spring提供的IOC容器，可以将对象间的依赖关系交由Spring进行控制,避免硬编码所造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

（2）AOP编程的支持

通过Spring的AOP功能，方便进行面向切面编程,许多不容易用传统OOP实现的功能可以通过AOP轻松实现。

（3）声明式事务的支持

可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量。

（4）方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

（5）方便集成各种优秀框架

Spring对各种优秀框架(Struts、 Hibermnate、 Hessian、 Quart等) 的支持。

（6）降低JavaEE API的使用难度

Spring对JavaEE API (如JDBC、JavaMail、远程调用等)进行了薄薄的封装层，使这些API的使用难度大为降低。

（7） Java 源码是经典学习范例

Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

1.4 Spring的体系结构

先学Core Container核心容器部分，那么初学阶段就需要分别为Beans、Core、Context和SpEL导入四个jar包或maven坐标。

2. Spring快速入门

2.1 Spring程序开发步骤

未使用Spring之前，使用对象，都需要new一个对象才能进行调用。

代码解释：

service层要调用dao层的方法，必须new一个dao层类的对象，如UserDao userDao=new UserDao()。才能调用dao层的方法进行操作。

使用Spring之后，直接将对象的管理交给Spring来管理。

代码解释：

可以看到上面没有了new，而main方法中，那是测试。因为已经交给了Spring来管理。
只是演示，现在没必要关注代码是怎么实现的。

所以，使用Spring的开发步骤如下：

（1）导入Spring使用需要的maven坐标
（2）创建Bean对象，即dao层和service层中的类
（3）创建applicationContext.xml文件
（4）在配置文件中进行配置
（5）创建ApplicationContext对象getBean()

2.2 使用IDEA创建第一个Spring项目

2.2.1 导入Spring开发的基本包坐标

首先使用IDEA创建一个maven项目，因为这里使用的是maven坐标来引入jar包。

接着引入要使用的核心包，其maven依赖坐标如下：

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
    </dependencies>

刷新pom.xml文件，引入依赖包。

2.2.2 编写Dao接口和实现类

接着在java目录下创建com.demo.dao包，在包下创建一个UserDao.java接口，该接口代码如下：

package com.demo.dao;

public interface UserDao 
    public void save();

接着在UserDao.java同级目录下创建一个impl包，在该包下创建一个UserDaoImpl.java实现类，该接口实现类代码如下：

package com.demo.dao.impl;

import com.demo.dao.UserDao;

public class UserDaoImpl implements UserDao 

    public void save() 
        System.out.println("save running......");

2.2.3 创建Spring核心配置文件

接着需要创建Spring的核心配置文件，在resources目录下创建一个名为applicationContext.xml的配置文件，该文件的名字可以自定义命名，不过一般约定成俗取为applicationContext。

右键单击resources文件夹，然后选中New->XML Configuration File->Spring Config

生成的applicationContext.xml文件默认有一些内容：

点击Configure application context配置

就会发现IDEA旁边出现小图标，表示配置成功

2.2.4 在Spring配置文件中配置UserDaolmpl

然后在代码内添加：

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"></bean>

bean标签表示配置一个JavaBean对象，其中class是全类名，即包括包路径的类名，而id是唯一标识，标识这个类。

如果配置成功则可以在UserDaoImpl.java等类中看到小图标

2.2.5 使用Spring的API获得Bean实例

在com.demo目录下创建一个test包，然后在包下创建UserDaoTest.java类，内容如下：

package com.demo.test;

import com.demo.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoTest 
    public static void main(String[] args) 
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao=(UserDao)app.getBean("userDao");
        userDao.save();

运行main方法，控制台打印结果

到此为止第一个Spring项目成功创建。

本节代码地址：GitHub Demo

3. Spring配置文件

3.1 Bean标签基本配置

Spring中把类对象都当作Bean对象，所以都是添加在bean标签中。

因此applicationContext.xml中的<bean></bean>标签，用于将配置对象交由Spring来创建，默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

id：Bean实例在Spring容器中的唯一标识，不允许重复，由程序员自定义。
class：Bean的全限定名称，即Bean的包名加类名。

例如：

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"></bean>

3.2 Bean标签范围取值

可以在bean标签中设置scope属性，来指定Bean对象的作用范围。

scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request	web项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	web项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	web项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session

例如：

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl" scope="singleton"></bean>

测试，将UserDaoTest.java内容改为如下：

package com.demo.test;

import com.demo.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoTest 
    public static void main(String[] args) 
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        System.out.println(userDao2);

控制台打印结果：

如果把scope的值换成prototype，则控制台输入变成如下情况：

singleton表示Spring容器中存在单一对象，而prototype表示Spring容器中存在多个对象。

总结：

（1）当scope的取值为singleton时

Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件applicationContext.xml被加载时，实例化配置的Bean实例。可以在无参构造方法中添加测试代码进行测试。
Bean的生命周期:
- 对象创建：当应用加载，创建容器时，对象就被创建了
- 对象运行：只要容器在，对象一直活着
- 对象销毁：当应用卸载，销毁容器时，对象就被销毁了

（2）当scope的取值为prototype时

Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean
- 对象创建：当使用对象时，创建新的对象实例
- 对象运行：只要对象在使用中，就一直活着
- 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了

3.3 Bean的生命周期配置

还可以在<bean>标签中指定init-method和destroy-method属性。

init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

测试，在UserDaomImpl.java中添加如下两个方法：

然后在applicationContext.xml中进行配置：

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"></bean>

最后在UserDaoTest.java中进行测试

package com.demo.test;

import com.demo.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserDaoTest 
    public static void main(String[] args) 
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);
        ((ClassPathXmlApplicationContext) app).close();

控制台打印结果：

3.4 Bean实例化的三种方式

这里是以UserDao为例，原先未使用Spring时，实例化的方式是：

UserDao userDao=new UserDao();
// 通过new一个对象

而如果使用Spring有三种方式来实例化，实例化就是获得一个userDao对象，该对象是UserDao类型的，但不会是通过new得来的。

Bean实例化的三种方式：

无参构造方法实例化
工厂静态方法实例化
工厂实例方法实例化

3.4.1 无参构造方法实例化

只需要修改配置文件即可，修改为如下：

<!--无参构造方法实例化-->
<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"></bean>

3.4.2 工厂静态方法实例化

首先在com.demo目录下创建一个factory目录，在该目录下创建一个名为StaticFactory.java类，内容如下：

package com.demo.factory;

import com.demo.dao.UserDao;
import com.demo.dao.impl.UserDaoImpl;

public class StaticFactory 
    public static UserDao getUserDao() 
        return new UserDaoImpl();

接着在配置文件applicationContext.xml中将bean标签内容改为如下：

<bean id="userDao" class="com.demo.factory.StaticFactory" factory-method="getUserDao"></bean>

其中class属性该成了对应的StaticFactory类的包路径加类名，并且新增了一个factory-method属性，其值是StaticFactory类中返回UserDao实例的方法名。

3.4.3 工厂实例方法实例化

步骤：

第一步：创建一个Factory类，创建一个方法来返回实例化对象。
第二步：在applicationContext.xml配置文件中进行<bean>标签配置。

在factory目录下创建一个DynamicFactory.java类，内容如下：

package com.demo.factory;

import com.demo.dao.UserDao;
import com.demo.dao.impl.UserDaoImpl;

public class DynamicFactory 
    // 注意不是静态static的
    public UserDao getUserDao()
        return new UserDaoImpl();

接着在配置文件applicationContext.xml中将bean标签内容改为如下：

<!--工厂实例方法实例化-->
<!-- 必须先有工厂对象才能调用工厂中的方法 -->
<bean id="factory" class="com.demo.factory.DynamicFactory"></bean>
<bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>

代码解释：

id属性是程序员自定义的名称，第一个id值"factory"是第二个bean标签的factory-bean属性的值，两个值必须相同。
class属性是DynamicFactory类的路径。
第二个bean标签的id是会在UserDaoTest.java中获取用的，是getBean()的字符串参数。而factory-method属性就是DynamicFactory类中的方法名。

然后就可以下面代码来获取，即通过getBean()方法来获取。

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) app.getBean("userDao");

接着在UserDaoTest.java中直接运行main()方法即可。

3.5 Bean的依赖注入分析

上面说的都是如何进行Bean对象实例化的。

接着处理service层，在com.demo目录下创建一个service包，在该包下创建一个UserService.java类：

package com.demo.service;

public interface UserService 
    public void save();

接着在该类的同级目录下创建一个impl包，并在包下创建一个UserServiceImpl.java文件：

package com.demo.service.impl;

import com.demo.dao.UserDao;
import com.demo.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService 
    public void save() 
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    

、

以前调用service中的类都是通过实例化对象的方式，即如下：

UserService userService=new UserServiceImpl();
userService.save();

现在学了Spring容器，尝试将UserServiceImpl配置到容器中，通过容器来调用。

上面配置的UserDao类对象，而下面就需要配置UserService对象了。

所以在applicationContext.xml中添加一个bean标签，内容如下：

<bean id="userService" class="com.demo.service.impl.UserServiceImpl"></bean>

从上面的配置，可以明白是从service层调用dao层方法，而又从web层调用service层方法。

所以创建一个web目录，创建一个UserController.java来调用测试：

package com.demo.web;

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

public class UserController 
    public static void main(String[] args) 
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) app.getBean("userService");
        userService.save();

在一个对象装到另一个对象中，可以通过setXXX方法，也可以通过有参构造。

3.6 Bean的依赖注入概念【了解】

依赖注入(Dependency Injection) ：它是Spring框架核心IOC的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况（依赖的情况即一个对象的使用涉及到另一个对象的调用）。IOC解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用Spring之后，就让Spring来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取，我们执行只需要获取业务层的对象就可以了。

3.7 Bean的依赖注入方式【重要】

Bean的依赖注入的方式有两种：

构造函数（有参）
set方法

在service层需要调用dao层方法，那么该如何拿到dao层的这些方法呢？

在使用Spring之前使用的是通过new来实例化对象，如下：

学了上面的知识可以通过applicationContext.xml来配置，实例化对象，通过如下方式来调用：

但不可能每次都这样来获取bean对象，所以可以通过下面的依赖注入来获取。

3.7.1 使用set()方法实现依赖注入

步骤：

创建Bean类属性，并创建对应的set()方法。
在applicationContext.xml文件中进行配置，要在哪个类中注入就写在该类的bean标签下。

我们需要的是将dao层注入到service层中，所以在UserServiceImpl.java中先写一个UserDao的set方法，然后调用就可以直接使用userDao.save()方法了，所以UserServiceImpl.java代码变成如下形式：

package com.demo.service.impl;

import com.demo.dao.UserDao;
import com.demo.service.UserService;

public class UserServiceImpl implements UserService 
    // 通过set方法实现依赖注入
    private UserDao userDao;
    public void setUserDao(UserDao userDao) 
        this.userDao = userDao;
    

    public void save() 
        // 直接调用了，而不需要再生成UserDao对象了
        userDao.save();

但Spring容器并不清楚，所以还需要在applicationContext.xml中进行声明配置。

下面的代码就是将dao注入到service中：

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.demo.service.impl.UserServiceImpl">
    <!--是要将dao注入到service中，所以需要写到userService标签下-->
    <!--这个name是setUserDao()方法的名字，不过是去掉了set并且将大写的U改成了小写的u-->
    <!--ref是指向上面的userDao的ID，就是要被注入的dao层的类-->
    <property name="userDao" ref="userDao"></property>
</bean>

如果注入成功的话，可以在UserServiceImpl类的侧边栏上看到小图标

同样运行UserController.java中的main方法产生一样的结果。

但如果在main方法中使用new UserServiceImpl()来调用，那么就会报空指针异常了。

对于上面的配置，还可以有下面的方式p命名空间，而不需要写在标签内了：

即等价于

3.7.2 使用构造函数注入

在UserServiceImpl.java修改代码为如下：即添加一个有参构造和无参构造方法。

package com.demo.service.impl;

import com.demo.dao.UserDao;
import com.demo.service.UserService;

public class UserServiceImpl implements UserService 
    // 通过构造函数实现依赖注入
    private UserDao userDao;

    public UserServiceImpl(UserDao userDao) 
        this.userDao = userDao;
    

    public UserServiceImpl() 

    

    public void save() 
        // 直接调用了，而不需要再生成UserDao对象了
        userDao.save();

在applicationContext.xml文件中配置：

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.demo.service.impl.UserServiceImpl">
    <!--两个userDao并不是同一个意思-->
    <!--前者表示构造器的参数名为userDao-->
    <!--后者表示上面的bean标签的ID名叫userDao-->
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

它们之间的关系：

也可以在侧边栏看到一个小图标

3.8 Bean的依赖注入的数据类型【重要】

上面的操作，都是注入的引用Bean，除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

注入数据的三种数据类型：

普通数据类型
引用数据类型
集合数据类型

3.8.1 注入引用数据类型

就是上面那些注入UserDao类、UserService类，这就是注入引用数据类型，上面演示的就是这种，所以这里就不讲了。

3.8.2 注入普通数据类型

下面讲下普通数据类型使用set方法注入，通常使用set方法注入比较多，而使用构造器注入比较少，而引用数据类型的注入上面已经讲了，就是将UserDao注入到UserService中。

在UserDaoImpl.java中写普通类型注入的示例，在哪写没什么关系，只是为了演示普通数据类型的注入：

package com.demo.dao.impl;

import com.demo.dao.UserDao;

public class UserDaoImpl implements UserDao 
    // 使用set方法注入普通类型
    private String username;
    private int age;
    public void setUsername(String username) 
        this.username = username;
    
    public void setAge(int age) 
        this.age = age;
    

    public void save() 
        System.out.println(username+"======="+age);
        System.out.println("save running......");

然后需要通知Spring，所以在applicationContext.xml中配置

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl">
   <!--在UserDaoImpl类中注入普通类型，所以久写在该标签下-->
   <!--使用set方法注入都使用property标签，name属性表示UserDaoImpl类中要注入的属性名称，而value表示要注入的值，如果是引用数据类型则使用ref而不是value，普通数据类型使用value-->
   <property name="username" value="张三"></property>
   <property name="age" value="15"></property>
</bean>

它们之间的关系：

如果注入成功则可以看到小图标

运行UserControllerTest.java，可以看到打印的结果

3.8.3 注入集合数据类型

创建一个domain包，创建一个实体类User.java

package com.demo.domain;

public class User 
    private String name;
    private String addr;

    public String getName() 
        return name;
    

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

    public String getAddr() 
        return addr;
    

    public void setAddr(String addr) 
        this.addr = addr;
    

    @Override
    public String toString() 
        return "User" +
                "name='" + name + '\\'' +
                ", addr='" + addr + '\\'' +
                '';

继续在UserDaoImpl.java中注入

package com.demo.dao.impl;

import com.demo.dao.UserDao;
import com.demo.domain.User;

import java.util.List;
import java.util.Map;
import java.util.Properties;

public class UserDaoImpl implements UserDao 
    // 使用set方法注入集合类型
    private List<String> strList;
    private Map<String, User> map;
    private Properties properties;

    public void setStrList(List<String> strList) 
        this.strList = strList;
    

    public void setMap(Map<String, User> map) 
        this.map = map;
    

    public void setProperties(Properties properties) 
        this.properties = properties;
    

    public void save() 
        System.out.println(strList);
        System.out.println(map);
        System.out.println(properties);
        System.out.println("save running......");

然后告诉Spring容器，在applicationContext.xml中声明。

    <bean id="userDao" class="com.demo.dao.impl.UserDaoImpl">
        <!--注入集合数据类型中的List类型-->
        <property name="strList">
            <!--List集合其下用list标签-->
            <list>
                <!--list标签下存放要注入的集合内的数据，如果是普通数据类型，则用value标签，如果是引用数据类型，则用ref标签-->
                <value>aaa</value>
                <value>bbc</value>
                <value>ccc</value>
            </list>
        </property>
        <!--注入集合数据类型中的Map类型-->
        <property name="map">
            <!--Map集合其下用map标签-->
            <map>
                <!--map标签内是要注入的元素值，由entry标签包裹-->
                <!--key属性是键名，可以随便，而value-ref表示引用类型，需要用对应bean标签的id属性值，这里是下面的user1-->
                <entry key="u1" value-ref="user1"></entry>
                <entry key="u2" value-ref="user2"></entry>
            </map>
        </property>
        <!--注入Properties类型-->
        <property name="properties">
            <!--Properties类型使用props标签-->
            <props>
                <prop key="p1">pp1</prop>
                <prop key="p2">pp2</prop>
                <prop key="p3">pp3</prop>
            </props>
        </property>
    </bean>
    <!--需要注入实体类User-->
    <bean id="user1" class="com.demo.domain.User">
        <property name="name" value="张三"/>
        <property name="addr" value="山东"/>
    </bean>
    <bean id="user2" class="com.demo.domain.User">
        <property name="name" value="李四"/>
        <property name="addr" value="北京"/>
    </bean>

注入Map数据类型之间的关系：

注入成功也可以看到对应的小图标：

3.9 引入其他配置文件

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

例如在resources下创建如下两个文件，并在applicationContext.xml中引入：

<import resource=&#以上是关于Spring学习笔记的主要内容，如果未能解决你的问题，请参考以下文章 
 Spring4学习笔记2-配置Bean
 Spring 学习笔记03
 Spring 学习笔记——IoC容器（ApplicationContext）
 Spring学习笔记7：静态动态代理模式
 Spring学习笔记
 Spring.Net学习笔记-依赖注入