（万字长文）Spring的核心知识尽揽其中

关注哔哩哔哩海量免费架构学习视频资源
(https://space.bilibili.com/526518958)

推荐阅读：
面试不慌，阿里技术官汇总的一份SpringBoot实战文档心得，面试真的可以无所欲为

Spring简介

Spring是开源的控制反转（Ioc）和面向切面编程（AOP）的容器框架，Spring的主要功能用于默认单例模式管理Bean对象、生产Bean、声明式事务、以及AOP开发。

Spring的Ioc类图如下所示：

（万字长文）Spring的核心知识尽揽其中

在Spring中主要的核心类和接口层，也是下面文章重点讲解的核心知识，如下几个：

• BeanFactory：Bean工厂顶层接口，生产任意的Bean。
• ApplicationContext：配置对象Bean的接口。
• ClassPathXmlApplicationContext：加载类路径下的配置文件中的Bean。
• FileSystemXmlApplicationContext：用于加载系统文件中的配置文件中的Bean。

控制反转(Ioc)

控制反转由之前需要类的对象，程序员主动new(实例化)类的对象，现在将对象交给spring的工厂进行管理，现在可以让spring生产对象，程序员只需要获取对象使用。

要将Bean对象交给Spring工厂进行管理，首先需要在类路径下，新建一个文件为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" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <bean id="userService" class="com.ldc.org.service.impl.UserServiceImpl"></bean>
</beans>

Spring中默认名称为applicationContext.xml，并且配置文件的默认位置为/WEB-INF/applicationContext.xml。要想获得上面配置的Bean实例，通过以下代码就可以获得：

// 加载配置文件，初始化Bean工厂
BeanFactory bf = new ClassPathXmlApplicationContext("applicationContext.xml")
// 获取Bean对象,按类型获取
UserService userService = bf.getBean("userService");

Spring的IOC容器的工作模式看做是工厂模式的升华，可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言的的反射编程，根据配置文件中给出的类名生成相应的对象。

从实现来看，IOC是把以前在工厂方法里写死的对象生成代码，改变为由配置文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。

IOC中核心的技术就是反射(Reflection)编程，简而言之就是根据给出的全类名（字符串方式）来动态地生成对象。这种编程方式可以让对象在运行时才决定到底是哪一种对象。

Spring的配置文件的内容没有人会去记住它，很多时候，都是在原来的已有的项目中直接粘贴配置文件过来复用，若是第一个项目，这些配置文件都是在自己收藏的基础上进行使用。

依赖注入(DI)

依赖注入：Dependency Injection（DI）与控制反转（IoC），不同角度但是同一个概念。首先我们理解一点在传统方式中我们使用new的方式来创建一个对象，这会造成对象与被实例化的对象之间的耦合性增加以致不利于维护代码。

在spring框架中对象实例改由spring框架创建，spring容器负责控制程序之间的关系，这就是spring的控制反转。在spring容器的角度看来，spring容器负责将被依赖对象赋值给成员变量，这相当于为实例对象注入了它所依赖的实例,这是spring的依赖注入。

依赖注入配置文件的方式：

public class UserServiceImpl implements UserService{
      private UserDao userDao；
      public void setUserDao（UserDao userDao）{
              this.UserDao = userDao；
      }
}

配置文件中的配置：

<bean id="userService" class="com.ldc.org.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>

<bean id="userDao" class="com.ldc.org.dao.UserDao"></bean>

实际中成员属性的依赖注入很少使用配置文件的方式，直接使用注解的方式进行注入，如下所示：

public class UserServiceImpl implements UserService{
      @Autowired
      private UserDao userDao；
}

属性的依赖注入主要分为：手动注入和自动注入。

• 属性手动注入：基于xml配置注入

• 构造方法注入

• set方法注入

• 集合注入

• 对象手动注入：基于xml配置注入

• 默认构造注入

• 静态工厂注入

• 对象工厂注入

（1）构造方法注入

<!-- 通过构造器参数索引方式依赖注入 -->
    <bean id="helloBeanByIndex" class="com.lyc.cn.day04.HelloImpl">
        <constructor-arg index="0" value="小张"/>
        <constructor-arg index="1" value="3"/>
    </bean>
    <!-- 通过构造器参数名称方式依赖注入 -->
    <bean id="helloBeanByName" class="com.lyc.cn.day04.HelloImpl">
        <constructor-arg name="name" value="小王"/>
        <constructor-arg name="age" value="5"/>
    </bean>

（2）set方法注入

<!-- ====================Setter方法属性注入Begin==================== -->
<bean id="user" class="com.ldc.org.domain.User">
    <property name="name" value="小明"/>
    <property name="age" value="3"/>
</bean>

（3）集合注入

<bean id="user" class="com.ldc.org.domain.User">
    <!--注入List集合-->
    <property name="listNames">
        <!-- merge 父子bean是否合并条目 -->
        <list value-type="java.lang.String" merge="false">
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
        </list>
    </property>

    <!--注入Set集合-->
    <property name="setNames">
        <set value-type="java.lang.String" merge="true">
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
        </set>
    </property>

    <!--注入Map集合-->
    <property name="mapNames">
        <map key-type="java.lang.String" value-type="java.lang.String">
            <entry key="name" value="小明"/>
            <entry key="age" value="3"/>
        </map>
    </property>

    <!--注入数组-->
    <property name="arrayNames">
        <array value-type="java.lang.String">
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
        </array>
    </property>

    <!--注入Properties-->
    <property name="propertiesNames">
        <props value-type="java.lang.String">
            <prop key="name">小明</prop>
            <prop key="age">3</prop>
        </props>
    </property>
</bean>

（4）默认构造注入

<!--调用默认的构造函数创建对象，必须有默认的构造方法-->
<bean id="userController" class="com.ldc.org.controller.UserController"></bean>

（5）静态工厂注入

<!--静态工厂创建bean对象，factory-method指定静态方法，返回bean实例-->
<bean id="myFactory" class="com.ldc.org.bean.MyFactory" factory-method="getBean"></bean>

（6）对象工厂注入

<bean id="myFactory" class="com.ldc.org.bean.MyFactory"></bean>
<bean id="beanFactory" class="com.ldc.org.bean.BeanFactory" factory-bean="myFactory" factory-method="getBean"></bean>

• 自动注入：基于注解方式注入

• @Value

• @Autowired

• @Autowired和@Qualifier("名称")结合使用

• @Resource(name="名称")

• 按名称注入

• 按类型注入

• 普通属性的注入

相关注解可以给私有字段设置，也可以给setter方法设置。

bean的种类

• 基本bean:
• FactoryBean：是一个bean，是创建特定bean对象的工厂bean。
• BeanFactory：是一个factory，可以创建任意bean对象的工厂。

bean作用域

• singleton 单例 (默认)
• prototype 多例
• request一次请求
• session一次会话
• globalSession 全局会话

（万字长文）Spring的核心知识尽揽其中

bean生命周期

• init-method：初始化的时候执行方法
• destroy-method：指定销毁的时候执行的方法

注意：要关闭ApplicationContext对象，才会调用destory方法，只有ClassPathXmlApplicationContext才有close方法。

面向切面(AOP)

AOP（面向切面编程），可以说是OOP（面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。

当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。

例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。

这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而AOP技术则恰恰相反，它利用一种称为横切技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为Aspect，即切面。

所谓切面，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息，然后它又以巧夺天工的妙手将这些剖开的切面复原，不留痕迹。

AOP的基本概念

1. Aspect（切面）：Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的Advice。
2. Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它joint point。
3. Pointcut（切点）：表示一组 joint point，这些 joint point或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
4. Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
5. Target（目标对象）：织入 Advice 的目标对象.。
6. Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建Adviced object 的过程

通知方法:

1. 前置通知:在我们执行目标方法之前运行(@Before)
2. 后置通知:在我们目标方法运行结束之后 ,不管有没有异常(@After)
3. 返回通知:在我们的目标方法正常返回之后运行(@AfterReturning)
4. 异常通知:在我们的目标方法出现异常后运行(@AfterThrowing)
5. 环绕通知:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知,执行之后就相当于我们后置通知(@Around)

AOP代码示范

下面以一个AOP日志功能的例子进行代码的演示，具体的代码如下所示：

//日志切面类
@Aspect
public class LogAspect {
    @Pointcut("execution(* com.savage.aop.Calculator .*(..))")
    public void pointCut(){};

    //@before代表在目标方法执行前切入, 并指定在哪个方法前切入
    @Before("pointCut()")
    public void logStart(){
        System.out.println("除法运行....参数列表是:{}");
    }
    @After("pointCut()")
    public void logEnd(){
        System.out.println("除法结束......");
    }
    @AfterReturning("pointCut()")
    public void logReturn(){
        System.out.println("除法正常返回......运行结果是:{}");
    }
    @AfterThrowing("pointCut()")
    public void logException(){
        System.out.println("异常通知");
    }
    @Around("pointCut()")
    public Object Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("执行目标方法之前");
        Object obj = proceedingJoinPoint.proceed();//调用方法
        System.out.println("@Arount:执行目标方法之后...");
        return obj;
    }
}

@Pointcut("execution(* com.savage.aop.Calculator .*(..))")，括号中各个pattern分别表示：

• 第一个表示返回值匹配，可以为表示任何返回值, 全路径的类名等
• com.savage.aop表示类路径匹配
• 第二个表示方法名匹配，可以指定方法名 或者代表所有, set* 代表以set开头的所有方法
• (..)表示参数匹配：可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用""来表示匹配任意类型的参数，".."表示零个或多个任意参数。如(String)表示匹配一个String参数的方法；(,String)表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型。异常类型匹配（throws-pattern?）

目标方法：

public class Calculator {
    public int div(int i, int j){
        System.out.println("--------");
        return i/j;
    }
}

配置类：

@Configuration
@EnableAspectJAutoProxy
public class MyAspectConfig {
    @Bean
    public Calculator calculator(){
        return new Calculator();
    }

    @Bean
    public LogAspect logAspects(){
        return new LogAspect ();
    }
}

测试类：

public class TestLogAop {
    @Test
    public void test(){
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyAspectConfig .class); 
        Calculator c = app.getBean(Calculator.class);
        int result = c.div(4, 3);
        System.out.println(result);
        app.close();
    }
}