前言

springframework 即spring框架，是spring 里面的一个开源框架,主要用户javaee的企业开发，通常也会用spring来代指spring框架，通过本文你将了解springframework 的两大核心，IoC和AOP的实现。

准备开发环境：idea、jdk8以上。
使用maven构建项目

参考视频：
楠哥的spring视频教程：https://www.bilibili.com/video/BV1XK411578C
楠哥的视频真的好，希望各位学java的同学都能了解到这位好老师。
以及linkedbear的springFramework教程：https://www.bilibili.com/video/BV1XK411578C
这位老师讲课也挺好，喜欢从java的历史发展来讲课，能把前因后果都讲明白。

1、SpringFramework是什么

SpringFramework是一个开源的、松耦合的、分层的、可配置的一站式企业级Java开发框架，它的核心是IOC和AOP，可以更容易的构建出企业级Java应用，并且可以根据应用开发的组件的需求，整合对应的技术。

• IOC：组件之间解耦
• AOP：将应用业务做统一或者特定的功能增强，能实现应用业务与增强逻辑的解耦
• 容器与事件：管理应用中使用的组件Bean，托管Bean的生命周期、事件和监听器的驱动机制
• web、事务控制、测试、与其他技术的整合

一般来说，Spring会指一系列框架的集合，也会用于指代SpringFramework。SpringFramework的两大核心是IOC和AOP，本文将从这两个核心入手，通过使用SpringFramework了解IOC和AOP。

2、IOC

IOC即控制反转，用来降低类与类之间的耦合度。控制反转通过反射机制实现。在Spring中，有一系列方法来实现控制反转。

2.1 IOC实现

1、创建maven工程，pom.xml添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.southwind</groupId><artifactId>aispringioc</artifactId><version>1.0-SNAPSHOT</version><dependencies>
<!--        上下文依赖,添加完依赖后需要在idea中添加lombok插件--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.7.RELEASE</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.6</version><scope>provided</scope></dependency></dependencies>
</project>

2、创建实体类Student

package com.southwind.entity;import lombok.Data;@Data
public class Student {private long id;private String name;private int age;
}

3、通过IOC创建对象，在resource文件夹下的配置文件中添加需要管理的对象，新建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为取出bean的标识符，class为对象所在的类 --><bean id="student" class="com.southwind.entity.Student"><!--        给对象属性赋值 --><property name="id" value="1"></property><property name="age" value="21"></property><property name="name" value="tom"></property></bean>
</beans>

4、两种方式新建对象，一是传统new个对象，二是从IOC中通过bean设置的id获取

package com.southwind.test;import com.southwind.entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test {public static void main(String[] args) {//传统构造对象Student student1 = new Student();student1.setId(1L);student1.setName("tom");student1.setAge(21);System.out.println("传统构造对象"+student1);//ioc构造对象//加载配置文件ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");Student student = (Student) applicationContext.getBean("student");System.out.println("IOC构造对象"+student);}
}

5、输出：

2.2 IOC配置文件

• 通过配置xml中的bean标签来完成对象的管理。
  bean属性： （1）id：对象名，根据id获取IOC中的对象
  （2）class：对象的模板类（所有交给IOC容器来管理的类必须有无参构造函数，因为Spring底层是通过反射机制来创建对象，调用的是无参构造方法）
• 对象的成员变量通过bean内的property标签完成赋值。
  （1）name：成员变量名。
  （2）value：变量名对应的成员变量（基本数据类型和String可以直接赋值，如果是其他引用类型则不能通过value赋值）
  （3）ref：将IoC中的另外一个bean赋给当前的成员变量（DI依赖注入）
  例：Teacher类的成员变量为student，因此要实例化Teacher要把student对象注入到teacher中。

<bean id="student" class="com.southwind.entity.Student"><property name="id" value="1"></property><property name="age" value="21"></property><property name="name" value="tom"></property></bean><bean id="teacher" class="com.southwind.entity.Teacher"><property name="student" ref="student"></property></bean>

2.3 获取bean

通过运行时类获取bean

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");Student student =  applicationContext.getBean(Student.class);System.out.println("IOC构造对象"+student);

存在问题：配置文件中一个数据类型的对象只能有一个实例，否则会抛出异常，因为没有唯一的bean。

2.4 通过有参构造创建bean

1、首先要在实体类中创建对应的有参构造函数
2、配置文件

<bean id="stu" class="com.southwind.entity.Student"><constructor-arg name="id" value="2"></constructor-arg><constructor-arg name="name" value="cat"></constructor-arg><constructor-arg name="age" value="25"></constructor-arg></bean>

constructor-arg和property区别在于constructor-arg通过构造函数注入，property通过setter对应的方法注入。

2.5 给bean注入集合

例：
User类

package com.southwind.entity;import lombok.Data;import java.util.List;@Data
public class User {private List<Address> addresses;
}

Address类

package com.southwind.entity;import lombok.Data;@Data
public class Address {private String name;private int id;
}

xml配置：

<bean id="user" class="com.southwind.entity.User"><property name="addresses" ><list><ref bean="address1"></ref><ref bean="address2"></ref></list></property></bean><bean id="address1" class="com.southwind.entity.Address"><property name="name" value="高新区"></property><property name="id" value="1"></property></bean><bean id="address2" class="com.southwind.entity.Address"><property name="name" value="工业园"></property><property name="id" value="2"></property></bean>

2.6 scope作用域

bean的作用域有四种，默认为singleton。

• singleton：单例，表示通过IoC容器获取的bean是唯一的
• prototype：原型，通过IOC容器获取的bean不同
• request：请求，表示在一次HTTP请求内有效
• session：会话，表示在一次用户会话内有效
  request和session值适用于web项目，一般使用单例和原型较多。

2.7 Spring的继承

Spring的继承是对象级别的继承，是指子对象能够继承父对象的属性值。因此要求子对象的属性值范围要比父对象的属性值要大，如果父亲有的属性如果儿子没有则会出现错误。

使用parent标签

 <bean id="student" class="com.southwind.entity.Student" scope="prototype"><constructor-arg name="id" value="1"></constructor-arg><constructor-arg name="name" value="tom"></constructor-arg><constructor-arg name="age" value="16"></constructor-arg></bean><bean id="stu" class="com.southwind.entity.Student" scope="prototype" parent="student"></bean>

2.8 Spring的依赖

依赖也是bean和bean之间的一种关系，配置依赖后，被依赖的bean一定先创建。

	<bean id="student" class="com.southwind.entity.Student" scope="prototype"><constructor-arg name="id" value="1"></constructor-arg><constructor-arg name="name" value="tom"></constructor-arg><constructor-arg name="age" value="16"></constructor-arg></bean><bean id="teacher" class="com.southwind.entity.Teacher" depends-on="student"></bean>

2.9 IoC自动装载

手动装载：IOC负责创建对象，DI负责完成对象的依赖注入，通过配置property标签的ref属性来完成。
自动装载：无需手动配置，IoC会自动选择bean完成注入。

自动装载有两种方式：

• byName：通过属性名自动装载，寻找id名等于属性名的bean注入
• byType：通过属性的数据类型自动装载

例：向User对象中注入car对象
User类：

package com.southwind.entity;
import lombok.Data;@Data
public class User {private Car car;
}

Car类：

package com.southwind.entity;
import lombok.Data;@Data
public class Car {private String name;
}

byName：

 <bean id="car" class="com.southwind.entity.Car"><property name="name" value="宝马"></property></bean><bean id="user" class="com.southwind.entity.User" autowire="byName"></bean>

byType：

<bean id="car" class="com.southwind.entity.Car"><property name="name" value="宝马"></property></bean><bean id="user" class="com.southwind.entity.User" autowire="byType"></bean>

二者区别在于，byName是识别属性名，byType是根据数据类型加载，因此如果有两个相同数据类型的bean对象存在时，使用byType将会无法选择出bean注入，从而引发异常。

2.10 Spring的p命名空间

p命名空间是对IoC/DI的简化操作，使用p命名空间可以更加方便的完成对bean的配置以及bean的依赖注入。

<?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:p="http://www.springframework.org/schema/p"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd "><bean id="student" class="com.southwind.entity.Student" p:id="1" p:name="tom" p:age="21"></bean><bean id="teacher" class="com.southwind.entity.Teacher" p:id="2"></bean></beans>

3、AOP

AOP：Aspect Oriented Programming 面向切面编程
优点：

• 降低模块之间耦合度
• 易扩展
• 提高代码复用
• 集中管理非业务代码

AOP是面对对象编程的一个补充，是指在运行时，动态地将代码切入到类的指定方法、指定位置上。把不同方法的同一个位置抽象成一个切面对象，对该切面对象进行编程就是AOP。

使用场景：对各个模块中重复率高且出现位置类似、功能类似的代码抽离，放在切面对象中，由切面对象来输出代码，提高代码的复用性。
实例：输出日志

传统实现AOP是通过动态代理来完成，Spring框架对AOP进行封装，使用Spring框架可以用面向对象的思想来实现AOP。
Spring框架只需要创建一个切面对象，把所有的非业务代码写在切面对象中完成即可，Spring框架底层会自动根据切面类以及目标类生成一个代理对象。

3.1 如何使用AOP

• 创建Maven工程
  向配置文件pom.xml添加：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.southwind</groupId><artifactId>aispringaop</artifactId><version>1.0-SNAPSHOT</version><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.7.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.2.7.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.7.RELEASE</version></dependency></dependencies></project>

• 创建一个计算器接口Cal，定义四个方法

package com.southwind.utils;public interface Cal {public int add(int num1,int num2);public int sub(int num1,int num2);public int mul(int num1,int num2);public int div(int num1,int num2);
}

• 创建接口的实现类CalImpl

package com.southwind.utils.impl;import com.southwind.utils.Cal;
import org.springframework.stereotype.Component;@Component
public class CalImpl implements Cal {//四个方法相当于业务代码public int add(int num1, int num2) {int result = num1+num2;return result;}public int sub(int num1, int num2) {int result = num1-num2;return result;}public int mul(int num1, int num2) {int result = num1*num2;return result;}public int div(int num1, int num2) {int result = num1/num2;return result;}
}

假设使用场景：已知CalImpl类有四个方法分别是加减乘除，要求在执行方法前输出各自的方法名和参数，执行方法后输出本方法已执行。（相当于业务代码执行前后输出日志信息）

• 新建LoggerAspect，作为切面对象

package com.southwind.aop;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;import java.util.Arrays;//Aspect注解 使其成为切面对象
//Component注解 相当于在xml中配置了一个bean
@Aspect
@Component
public class LoggerAspect {@Before(value = "execution(public int " +"com.southwind.utils.impl.CalImpl.*(..))")public void before(JoinPoint joinPoint){//获取方法名String name = joinPoint.getSignature().getName();//获取参数String args = Arrays.toString(joinPoint.getArgs());System.out.println(name+"方法的参数是"+ args);}@After(value = "execution(public int " +"com.southwind.utils.impl.CalImpl.*(..))")public void after(JoinPoint joinPoint){String name = joinPoint.getSignature().getName();System.out.println(name+"方法执行完毕");}@AfterReturning(returning = "result",value = "execution(public int " +"com.southwind.utils.impl.CalImpl.*(..))")public void afterReturning(JoinPoint joinPoint,Object result){String name = joinPoint.getSignature().getName();System.out.println(name+"方法的结果是"+result);}@AfterThrowing(throwing = "exception",value = "execution(public int " +"com.southwind.utils.impl.CalImpl.*(..))")public void afterThrowing(JoinPoint joinPoint,Exception exception){String name = joinPoint.getSignature().getName();System.out.println(name+"方法抛出异常"+exception);}
}

LoggerAspect类定义处添加的两个注解：
- @Aspect：表示该类是切面类
- @Component：将该类的对象注入到IoC容器中

value = "execution(public int com.southwind.utils.impl.CalImpl.*(…))"表示切入点是 com.southwind.utils 包下 CalImpl 类中的所有方法。
指定方法用：execution(public int com.southwind.utils.impl.CalImpl.add(…))

具体方法处添加的注解：
- @Before：前置通知, 在方法执行之前执行。（value表示切入点的地址）
- @After：后置通知, 在方法执行之后执行 。
- @AfterReturning：在方法有返回值之后执行 ，返回值是result（returning = “result”）
- @AfterThrowing：异常通知, 在方法抛出异常之后，抛出的异常是exception（throwing = “exception”）

• spring.xml中配置AOP（resource文件下新建spring.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"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd "><!--    自动扫描--><context:component-scan base-package="com.southwind"></context:component-scan><!--    Aspect注解生效，为目标类自动生成代理对象--><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>

原理： context:component-scan将com.southwind包中的所有类进行扫描，对添加了@Component的类添加到IOC容器中，由IOC来管理这个对象。
aop:aspectj-autoproxy让spring框架结合切面类和目标类自动生成动态代理对象。

3.1.1 几个关于AOP的名词

切面：横切关注点被模块化的抽象对象（处理非业务代码的抽象对象）
通知：切面对象完成的工作。
目标：被通知的对象，也就是被横切的对象。
代理：切面、通知、目标混合之后的对象。
连接点：通知要插入业务代码的具体位置。
切点：AOP通过切点定位到连接点。

以上就是关于SpringFramework两大核心IoC和AOP的使用，如有疑问欢迎提出。