一、Spring框架概述

1.1 什么是 Spring？

Spring 是一个开源的、轻量级的 Java 开发框架，由 Rod Johnson 于 2003 年首次推出。它的核心目标是简化企业级应用开发，通过提供一套全面的解决方案来解决各种常见的开发难题。

Spring 是一个分层的一站式框架，这意味着它为 Java SE/EE 开发的各个层面（表现层、业务逻辑层、持久层）都提供了支持，你可以根据项目需求选择使用其中的一个或多个模块。

1.2 Spring 的核心思想

Spring 框架的两大基石是 IOC（控制反转） 和 AOP（面向切面编程）。

1.2.1 IOC (Inversion of Control, 控制反转)：

        核心思想：将对象的创建、管理和依赖关系的维护权力，从应用程序代码本身 “反转” 给 Spring 框架。

        解决问题：传统开发中，一个类需要手动 new 出它所依赖的其他类的对象，这导致了类与类之间的高耦合。IOC 将所有对象的创建交给一个中央容器（IOC 容器），应用程序只需要从容器中获取对象即可，从而大大降低了代码的耦合度。

1.2.1 AOP (Aspect-Oriented Programming, 面向切面编程)：

        核心思想：在不修改源代码的情况下，对程序的功能进行增强。

        解决问题：日志记录、性能监控、事务管理、权限控制等功能，往往会散布在业务逻辑代码的各个角落，造成代码冗余和难以维护。AOP 允许你将这些横切关注点（Cross-cutting Concerns） 从业务逻辑中分离出来，形成独立的 “切面”，然后动态地织入到目标方法中。

1.3 Spring 框架的优点

方便解耦，简化开发：通过 IOC 容器，将对象的创建和依赖关系管理交给 Spring，开发者可以更专注于业务逻辑的实现。

AOP 编程的支持：轻松实现日志、事务、权限等功能，而无需侵入业务代码。

声明式事务的支持：通过简单的配置即可实现事务管理，无需手动编写复杂的事务代码。

方便程序的测试：Spring 对 JUnit 等测试框架有很好的支持，可以方便地进行单元测试和集成测试。

方便集成各种优秀框架：Spring 不排斥任何优秀的开源框架，其内部提供了对 Struts2、Hibernate、MyBatis 等框架的直接支持。

降低 JavaEE API 的使用难度：Spring 对一些复杂的 JavaEE API（如 JDBC、JavaMail）提供了封装，使它们的使用变得更加简单。

二、创建Hello world

创建maven工程，导入坐标依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

编写demo，编写具体的实现方法

package com.qcby.service;

public class Demo {
    public void hello() {
        System.out.println("hello world");
    }
}

编写Spring核心的配置文件，在resources目录下创建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">
  	 <!--IOC管理bean-->
    <!--id:类的唯一标识符 class:类的全路径名-->
    <bean id="demo" class="com.qcby.service.Demo" />
</beans>

编写测试方法。

package com.qcby.servic;

import com.qcby.service.UserService;
import com.qcby.service.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceTest {
    //传统写法
    @Test
    public void run(){
        Demo userService = new Demo();
        userService.hello();
    }
    //spring写法
    @Test
    public void run1(){
    	//创建spring工厂，加载配置文件
    	ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    	//获取bean对象
    	Demo us = (Demo) ac.getBean("us");
    	//调用方法
    	us.hello();
    }

}

三、Spring IOC容器

3.1 IOC 思想的本质

IOC（控制反转）的核心是反转了对象的创建权。

        传统模式：A 类需要 B 类，A 类自己负责 new B()。A 与 B 强耦合。

        IOC 模式：A 类和 B 类都将自己的 “创建权” 交给 IOC 容器。A 类只需要声明它需要一个 B 类的实例，容器在创建 A 时会自动将 B 的实例注入（DI - Dependency Injection）进去。A 与 B 解耦。

IOC 解决的核心问题：降低程序的耦合度。

3.2 IOC 容器的底层原理

Spring 的 IOC 容器并非凭空产生，它的实现巧妙地结合了以下三种技术：

        XML 解析技术：如 dom4j 或 JDK 自带的 SAX，用于读取 applicationContext.xml 配置文件中的 <bean> 定义。

        工厂模式（Factory Pattern）：创建一个中央工厂类（IOC 容器的雏形），所有对象的创建都由这个工厂负责，而不是在业务代码中 new。

        反射机制（Reflection）：根据 XML 中解析出的类的全限定名（class="com.qcby.service.Demo"），使用 Class.forName(className).newInstance() 来动态创建对象实例。

首先我们需要讲一下什么是工厂模式：

在当前情况之下A类想要调用B类就必须自己在自己的内部新建B类的对象，这样的耦合度太高，那我们如何降低耦合度的呢？

创建一个工厂类，这样就能够使得A和B的耦合度降低到最小值

简易流程模拟：

1. 读取 applicationContext.xml。
2. 解析到 <bean id="demo" class="com.qcby.service.Demo" />。
3. 获取到 id 为 "demo"，class 为 "com.qcby.service.Demo"。
4. 使用反射 Class clazz = Class.forName("com.qcby.service.Demo");
5. 创建实例 Object obj = clazz.newInstance();
6. 将创建好的对象 obj 存入一个 Map 结构中，map.put("demo", obj);。这个 Map 就是最简单的 IOC 容器。
7. 当调用 context.getBean("demo") 时，实际上就是从 Map 中 get("demo")。

3.3 Spring 提供的 IOC 容器实现

3.3.1 xml配置文件，配置创建对象

<bean id="demo" class="com.qcby.service.Demo" />

3.3.2 创建工厂类

public class DemoFactory {
    //利用dom4j得到name所对应的value值
   public static Demo getDemo() throws Exception {
       //利用dom4j得到name所对应的value值
       String value="class路径";
       //通过反射创建对象
       Class clazz = Class.forName(value);
       //返回并创建demo对象
       return (Demo) clazz.newInstance();
   }
}

通过以上两步，我们基本上就可以得到我们所创建的对象。

3.3.3 IOC容器

Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：

Spring里边提供了IOC容器的实现的两种方式

(1) BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用

BeanFactroy:加载配置文件的时候不会去创建对象，在使用对象的时候才会去创建对象

(2)ApplicationContext:BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员进行使用

加载配置文件的时候会把对象创建