spring学习（spring的IoC思想、spring容器、spring配置文件、依赖注入(DI)、BeanProxy机制(AOP)）

目录

一、spring-IoC。

（1）spring框架。(诞生原因及核心思想)

1、为什么叫框架？

2、spring框架诞生的技术背景。

（2）控制反转（IoC）。

（3）spring的Bean工厂和IoC容器。

（4）spring配置文件(springConfig.xml)。

1、XML文档的标准声明。

2、最外层标签属性声明。

3、内层的多个标签。

4、Controller层与Service层之间的"解耦"。

ApplicationContext（IoC容器）。

BeanFactory。（Bean工厂）

二、spring-DI。(依赖注入)

（1）DI的基本概念。

（2）Setter方式注入（手动注入）。

三、spring-AOP。(面向切面编程)

（1）AOP的基本概念。

（2）图解。

四、spring框架核心思想总结。

（1）图解说明。

‌Spring Framework的核心思想主要包括三个方面：控制反转（IoC）、依赖注入（DI）和面向切面编程（AOP）

一、spring-IoC。

（1）spring框架。(诞生原因及核心思想)

1、为什么叫框架？

框架它是一种结构体。它具备通用性，且能达到快速实现产品的功能。

2、spring框架诞生的技术背景。

主要是出现在很多年前Web开发过程中遇到的重大问题。当基于三层模型开发时，在业务逻辑的代码中能看到很多的手动new对象的代码，这样会造成高度耦合。

基于上述"高耦合"问题。spring框架向我们提供了一个生产与管理对象的工厂（BeanFactory）。这样就不需要自己手动的new对象，而是将对象的管理交给spring（第三方）Bean工厂的容器。包括对象的实例化、对象间的依赖关系都由spring处理。

（2）控制反转（IoC）。

控制反转（Inversion of Control，IoC）是一种设计原则。其使用是用于降低代码之间的耦合度。

在传统的程序开发中，组件（对象）之间的依赖关系通常由程序内部进行管理，这会导致代码之间的紧密耦合，难以维护和扩展。

而spring框架中的IoC的思想就是将组件(对象)间的关系从程序内部 转移到外部容器 中进行管理。

通常通过XML文件 或注解的方式来实现。这种方式使得组件之间的依赖关系更加灵活，易于管理和扩展。

（3）spring的Bean工厂和IoC容器。

上面提到的"外部容器"，就是spring提供管理bean对象的spring容器。

spring容器是spring框架的核心。

spring容器的工作：进行实例化对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。

spring容器使用依赖注入（DI）来管理组成一个应用程序的组件。

spring-IoC 容器利用Java的 POJO(实体)类和配置元数据来生成完全配置和可执行的系统或应用程序。

IoC容器具有依赖注入功能的容器，它可以创建对象，IoC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。通常new一个实例，控制权由程序员控制！而"控制反转"是指new实例工作不由程序员来做而是交给spring容器来做。

未使用与使用IoC容器管理对象的图解。（注：该图请勿直接复制进行商用！版权问题必究）

spring提供了两种容器供我们使用。

查阅继承树，可以发现ApplicationContext容器的底层是继承至BeanFactory。因为ApplicationContext是IOC容器的更高级实现，它继承了BeanFactory的所有功能。

两种spring容器的具体使用方法在下面简单展示。使用spring容器管理bean对象涉及到spring配置文件的使用！所以请继续往下看。

（4）spring配置文件(springConfig.xml)。

如果未学过DI(依赖注入)，建议先跳过这一部分内容。当看完下方的DI(依赖注入)再往回看，因为下面内容包含一个简单的使用spring-Ioc、spring-DI思想的程序。

用于定义和管理应用程序中的Bean(对象)。如下有一个的springConfig.xml文件。
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 id="userService" class="com.fs.service.UserService">

    </bean>
    
    <bean id="userController" class="com.fs.controller.UserController">
        
        <property name="userService" ref="userService"></property>
    </bean>
</beans>
1、XML文档的标准声明。

该配置文件的第一行指定了XML版本和编码。

2、最外层标签<beans>属性声明。

定义了默认的命名空间(namespace)，用于Bean的定义。

定义了XSI命名空间，用于XML Schema实例的声明。

定义xxxLocation，指明了XML Schema的位置，用于验证XML文件是否符合Spring的Bean定义规范。

3、内层的多个<bean>标签。

主要功能：配置应用程序中的Bean(对象)以及依赖注入的完成。

<bean id="userService" class="com.fs.service.UserService">：定义了一个Bean，其ID为"userService"，类的引用为"com.fs.service.UserService"。这个Bean通常是处理业务逻辑的。将由Spring容器管理，并且可以被其他Bean("UserController")引用(依赖)。

<bean id="userController" class="com.fs.controller.UserController">：定义了另一个Bean，其ID为"userController"，类的引用为"com.fs.controller.UserController"。这个Bean通常是一个控制器，用于处理用户请求。

<property name="userService ref="userService">：在UserController的Bean中，通过<property>标签注入了对UserService的Bean的引用。

这里的name属性指定了UserController类中需要注入的属性名称，而ref属性指定了要注入的Bean的ID（在<bean>标签已定义的userServiceBean）。

这种注入方式称为按引用注入（setter注入），因为Spring会调用UserController中提供的setter()方法来设置其userService属性。

4、Controller层与Service层之间的"解耦"。

ApplicationContext（IoC容器）。

UserController类代码如下。

将"UserService类对象设置成成员属性，通过spring的工厂(依赖注入)拿取到对象，而不是通过手动new获取对象。

如下的main方法是通过spring提供的类"ApplicationContext"（IoC容器）的实现类完成Ioc与DI（依赖注入）。

在实例化类"ClassPathXmlApplicationContext"的对象时，记得传入参数（spring的配置文件名。如：springConfig.xml）

因为ApplicationContext是IOC容器的更高级实现，它继承了BeanFactory的所有功能。所以最后也是通过spring的BeanFactory提供的getBean()方法拿到对应类的对象。

总结：通过spring管理程序中的Bean对象与它们之间的关系。（容器：ApplicationContext容器(IoC容器)）
java 复制代码
package com.fs.controller;

import com.fs.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// UserController类
public class UserController {
    //通过依赖注入拿取UserService对象
    UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    //UserController类的print方法
    public void print(){
        System.out.println("UserController的print方法");
        userService.print();
    }
    public static void main(String[] args) {
        //创建容器
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("springConfig.xml");
        //通过spring工厂获取指定bean对象
        UserController userController = app.getBean("userController", UserController.class);
        /*UserController userController = new UserController(); 取消这种手动new对象的操作*/
        userController.print();
    }
}
userService类代码如下。
java 复制代码
package com.fs.service;
// UserService类
public class UserService {
    //UserService类的print方法
    public void print(){
        System.out.println("UserService的print方法");
    }
}
运行测试1如下。

BeanFactory。（Bean工厂）

如下的测试类的main方法是通过spring提供的BeanFactory（IoC容器）的实现类完成Ioc与DI（依赖注入）。

首先使用BeanFactory工厂类的实现类"DefaultListableBeanFactory"获得bean工厂的对象。

再通过new（创建）解析（读取）bean配置文件的类"XmlBeanDefinitionReader"对象，实例化对象的同时并传入之前创建的工厂对象。

再通过方法"loadBeanDefinitions("填写配置文件名。如springConfig.xml")"加载spring的配置文件。

最后通过spring的BeanFactory提供的getBean()方法拿到对应类的对象。

总结：通过spring管理程序中的Bean对象与它们之间的关系。（容器：BeanFactory）
java 复制代码
package com.fs;

import com.fs.controller.UserController;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;

public class MainApp {
    public static void main(String[] args) {
        /*创建容器(该方法是通过ApplicationContext容器实例化对象)
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("springConfig.xml");*/

        //使用BeanFactory工厂实现IoC、DI（依赖注入与控制反转）
        BeanFactory beanFactory = new DefaultListableBeanFactory();

        //使用DefaultListableBeanFactory(BeanFactory的实现类)
        DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
        //加载配置清单(文件)
        XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
        xmlBeanDefinitionReader.loadBeanDefinitions("springConfig.xml");
        Object obj = defaultListableBeanFactory.getBean("userController");
        UserController userController = (UserController) obj;
        userController.print();

    }
}
运行测试2如下。

二、spring-DI。(依赖注入)

（1）DI的基本概念。

依赖注入（Dependency Injection，DI）是实现spring-IoC的一种技术。

在spring中，依赖注入可以通过构造器、Setter方法或字段注入等方式进行。

通过依赖注入，组件之间的依赖关系由外部容器动态注入，而不是在代码中硬编码，从而降低了组件之间的耦合度，提高了代码的可测试性和可维护性。

注意：因为博主还未学完！所以这里只是简单依赖注入方式（Setter方式注入）演示。除了spring配置文件、还需手动提供setXX()方法完成操作。

（2）Setter方式注入（手动注入）。

controller层、service层对象交给spring的BeanFactory的容器进行管理。（使用spring的配置文件）

通过依赖注入技术实现IoC思想。完成bean对象的实例化以及对象间的依赖关系管理。

三、spring-AOP。(面向切面编程)

（1）AOP的基本概念。

面向切面编程（Aspect-Oriented Programming，AOP）是一种编程范式。"编程范式"它指的是一种编程风格或者编程方法论，是程序员用来编写程序的框架和方法。

"面向切面编程"它提供了一种新的方法来分离横切关注点，比如日志记录、事务管理、安全性等，这些关注点通常横跨多个模块或组件。它允许开发者将横切关注点（如日志、事务管理等）模块化，并把它们应用到多个类中。

AOP通过"切面"（aspect）和"连接点"（join point）等概念来实现这种分离，允许开发者在不修改业务逻辑代码的情况下，增加额外的功能。这种方式使得代码更加清晰，维护更加方便。

（2）图解。

在面向切面编程（AOP）中，"增强bean"通常指的是在不修改原有代码（即不增加冗余代码）的情况下，通过AOP技术为现有的bean（即Spring框架中的单例对象）添加额外的功能或行为。（日志记录、事务管理、安全性检验等）

四、spring框架核心思想总结。

（1）图解说明。

该图仅供学习，请勿直接商用，否则版权必究！

主要是3种核心思想：IoC(控制反转)思想、DI(依赖注入)思想、AOP(面向切面编程)思想。