目录
一、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 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"><!--配置生产UserService对象--><bean id="userService" class="com.fs.service.UserService"></bean><!--配置生产UserController对象--><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容器)）
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类代码如下。
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）
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(面向切面编程)思想。
