目录
3.4.3 连接点（Joinpoint）和 切入点（Pointcut）的区别：
3.4.4.1.2 后置通知（after return advice）：
3.4.4.1.3 环绕通知（around advice）：
3.4.4.1.4 方法执行后通知（after(final) advice）：
3.4.4.1.5 异常通知（after throwing advice） ：
说明：本文章列举的大部分都是我整理出来的很多spring概念性的东西 ，不喜欢看长篇类文字的可以直接不看，也有很多其他博主讲的很透彻并且带有代码示例的。
1.什么是Spring
1.1 spring简介
- Spring 框架简称String，是Pivotal团队出品（创始人：Rod Johnson）的一个用于解决企业应用开发的复杂性而创建的（简化Java企业级应用开发）开源框架。
- 它提供了开发一个结构良好的可维护的和易于测试的应用所需的基础设施。Spring帮助开发者解决了开发中基础性的问题，这使得我们只需要专注于编写应用的业务逻辑，大大提高了我们的写代码效率。你可以使用Spring框架开发独立的Java应用程序，Web应用程序，Applet或其他Java应用程序。
- Spring开放源代码的设计层面框架解决的是业务逻辑和其他各层的松耦合问题，因此Spring的面向接口的编程思想贯穿整个系统应用。
- Spring的核心是IOC控制反转，一个系统可以生成各种对象（工厂模式），这些对象都需要管理，对象之间并不是孤立的，它们之间存在依赖关系，例如一个班级由多个老师，同学组成，那么一个班级就依赖于这多个老师和多个学生，为了描述这个班级和同学的关系我们就需要一个容器。
- 在Spring中把每个需要管理的对象称为String Bean ；而Spring管理这些Bean的容器称为SpringIOC容器
- Spring的扩展利器是AOP面向切面编程，AOP可以将分散在各个业务逻辑代码通过横向切割的方式抽取到一个独立的模块，还业务逻辑一个清新的世界。
- 简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。有了Spring，你可以快速搭建Java工程，快速进行业务需求开发，有扩展的新需求也可以快速开发。
1.2 Spring面向接口的编程思想
参考文章：https://blog.csdn.net/u012402177/article/details/70145507
1.2.1 概念
- 接口是一组规则的集合，它规定了实现本接口的类或接口必须拥有的一组规则。
- 接口就是标准规范，就是定死了一个框架，你根据这个框架去执行！有了标准去遵守就容易扩展！我们只需要面向标准编程，而不用针对具体的实现类！
1.2.2 面向接口与面向对象的关系：
- 首先，面向对象思想的核心思想之一，就是模拟真实世界，把真实世界的事物抽象成类，整个程序靠各个类的实例互相通信，互相协作完成系统功能，这非常符合真实世界的运行状况，也是面向对象思想的精髓。
- 其次，面相接口编程和面对对象编程并不是平级的，它并不是比面对对象更进的一种独立的编程思想，而是附属于面对对象的思想体系，属于其一部分。或者说，它是面对对象编程体系中的思想精髓之一。
1.2.3 面向接口编程的好处：
- 更加抽象,更加面向对象
- 提高编程的灵活性
- 实现高内聚、低耦合，提高可维护性，降低系统维护成本。
1.2.4 总结：
接口（标准）作为中间方，作为制定者，为实现者与调用者提供统一的行业规范，这样大家做出来的东西就是按照统一的标准而来，协调了两者之间的关系，消除了两者的不同！
1.3 Spring 的出发点（好处）：
- 目的：提供一种贯穿始终的解决方面，将各种专用框架整合成一个连贯的整体框架，简化企业级应用的开发（有点像粘合剂）；
- 鼓励最佳实践： 例如spring将“针对接口编程”的成本降到了最小；
- 非侵入性： 应用对象尽量避免依赖框架，IoC和AOP是避免依赖的关键技术；
- 统一配置： 好的框架应该让应用配置灵活且统一；
- 易于测试： 使单元测试尽可能简单；
- 可扩展；
2. 什么是控制反转/依赖注入（IOC容器）
2.1 概念
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，一种设计思想，可以用来减低计算机代码之间的耦合度，对象之间的耦合关系在编译时通常是未知的。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
IoC模式，系统中通过引入实现了IoC模式的IoC容器，即可由IoC容器来管理对象的生命周期、依赖关系等，从而使得应用程序的配置和依赖性规范与实际的应用程序代码分离。其中一个特点就是通过文本的配置文件进行应用程序组件间相互关系的配置，而不用重新修改并编译具体的代码。
通俗来讲：控制反转就是由容器来控制程序之间的（依赖）关系，而不是传统实现中，由程序代码操控。
这也是所谓的控制烦请反转的概念所在：（依赖）控制权由应用代码转到了外部容器，控制权的转移就是反转。
详细的解释可以参考文章：http://t.csdnimg.cn/HWh4q
2.2 依赖注入（ioc）的好处
此处参考（部分）：http://t.csdnimg.cn/0trTm
-
降低了代码的耦合度：通过IOC容器管理对象的创建和依赖关系的注入，使得对象之间的关系更加松散，减少了代码的耦合度，提高了代码的可维护性和可测试性。
-
提供了更好的扩展性：IOC容器可以通过配置文件或注解来管理对象的创建和依赖关系的注入，在不修改代码的情况下，可以方便地修改配置，实现对系统的扩展和修改。
-
实现了依赖注入（DI）：IOC容器可以自动将对象的依赖关系注入到对象中，不需要手动管理对象的依赖关系，减少了代码的冗余和重复。
-
支持AOP（Aspect-Oriented Programming，面向切面编程）：通过IOC容器，可以方便地将横切逻辑（如日志、事务等）与业务逻辑分离，提高了代码的可重用性和可维护性。
-
提供了更好的测试环境：通过IOC容器，可以方便地进行单元测试和集成测试，提高了代码的可测试性，有助于及早发现和解决问题。 总的来说，Spring中的IOC容器提供了一种灵活、可扩展、可测试的开发方式，使得代码更加模块化、可维护和可重用。
以下是一个简单的示例代码，演示了Spring中IOC容器的使用：
javaCopy code// 定义一个接口
public interface MessageService {
String getMessage();
}
// 实现接口
public class HelloWorldService implements MessageService {
public String getMessage() {
return "Hello, World!";
}
}
// 在配置文件中配置Bean
// applicationContext.xml
<beans>
<bean id="messageService" class="com.example.HelloWorldService" />
</beans>
// 在代码中使用IOC容器获取Bean并使用
public class Main {
public static void main(String[] args) {
// 创建IOC容器
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从IOC容器中获取Bean
MessageService messageService = context.getBean("messageService", MessageService.class);
// 使用Bean
String message = messageService.getMessage();
System.out.println(message);
}
}2.3 依赖注入的方式：
现有的框架实际上使用以下三种基本技术的框架执行服务和部件间的绑定：
-
方式1 (基于接口): 可服务的对象需要实现一个专门的接口，该接口提供了一个对象，可以重用这个对象查找依赖(其它服务)。早期的容器Excalibur使用这种模式。
-
方式2 (基于setter): 通过JavaBean的属性(setter方法)为可服务对象指定服务。HiveMind和Spring采用这种方式。
-
方式3 (基于构造函数): 通过构造函数的参数为可服务对象指定服务。PicoContainer只使用这种方式。HiveMind和Spring也使用这种方式。
2.4 实现策略
参考至：依赖注入百度百科
IoC是一个很大的概念,可以用不同的方式实现。其主要形式有两种：
-
依赖查找：容器提供回调接口和上下文条件给组件。EJB和Apache Avalon 都使用这种方式。这样一来，组件就必须使用容器提供的API来查找资源和协作对象，仅有的控制反转只体现在那些回调方法上（也就是上面所说的 类型1）：容器将调用这些回调方法，从而让应用代码获得相关资源。
-
依赖注入：组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。容器全权负责的组件的装配，它会把符合依赖关系的对象通过JavaBean属性或者构造函数传递给需要的对象。通过JavaBean属性注射依赖关系的做法称为设值方法注入(Setter Injection)；将依赖关系作为构造函数参数传入的做法称为构造器注入（Constructor Injection）
3.什么是AOP
说明：spring的AOP大部分都是使用注解来表示类或者方法属于哪些概念（连接点，切入点等等）
参考文章（部分）：http://t.csdnimg.cn/7mjHq
3.1 概念
全称是 Aspect Oriented Programming 即：面向切面编程。是OOP的延续，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。
AOP(Aspect-Oriented Programming), 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角.
在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)。
简单的说：他就是把我们程序重复的代码抽取出来，在需要执行的时候使用动态代理技术在不修改源码的基础上，对我们的已有方法进行增强。
3.2 优势
- 减少重复代码
- 提高开发效率
- 维护方便
3.3 实现方式
动态代理
详细的动态代理实现可参考：
https://www.cnblogs.com/gonjan-blog/p/6685611.html
3.4 AOP相关专业术语
3.4.1 连接点（Joinpoint）：
所谓连接点是指那些可以被拦截到的点。即程序执行过程中明确的点，如方法的调用，或者异常的抛出；
在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
而这些连接点就是目标对象里的某一个方法或某一类方法
比如：
package com.zking.spdemo.mapper;
//目标对象的方法一般首先定义在mapper（数据访问）层的接口然后具体的实现在实现类
//这里我只定义了一个方法，连接点可以有很多。
public class IStudentMapperImpl implements IStudentMapper {
@Override
public void hello(String hel) {
System.out.println("输出："+hel);
}
}
3.4.2 切入点（Pointcut）：
多个连接点的集合，定义了通知应该应用到哪些连接点。
要对具体的那些方法进行拦截，那么这个方法就是切入点。
(也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)
切入点一般与切面相关，如果你某个功能的方法被很多其他的功能使用比如：分页；
而且功能的实现大多写在方法里，你可以将你这个方法的特点通过切面进行拦截，并且前后写扩展
而这个方法就是你分页的切点。
比如：在下面的示例里这个类是一个切面的定义（注解方式），而切点就是 ..Page的方法（也就是需要进行分页的方法）；具体实现分页的代码被抽离出来了，放在切面里，当某个连接点符合条件就会被拦截，然后利用环绕通知的原理（前后进行代码扩展也就是分页的代码实现）
package com.zking.mbdemo.aop;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import java.util.List;
//这个类是一个切面
@Component//做为spring组件的注解
@Aspect//切面注解
@EnableAspectJAutoProxy//生成代理的注解
public class PageingInterceptor {
//条件：以Service结尾的类，以Page结尾的方法
//因为mapper层主要是与数据库相关联的，Service层与业务相关联
//通常在service调用mapper层的方法获取数据
@Around(value = "execution(* *..Service.*Page(..))")//通知的注解以及拦截条件
public Object pag(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
Object[] args = proceedingJoinPoint.getArgs();
Page page = null;
for (Object a : args){
if (a instanceof Page){
page = (Page) a;
}
}
if (page != null){
PageHelper.startPage(page.getPageNum(),page.getPageSize());
}
// 调用目标方法
Object rv = proceedingJoinPoint.proceed();
if (page != null){
// 需要对目标方法的得到结果对象进行强转
PageInfo info = new PageInfo((List) rv);
page.setTotal(info.getTotal());
}
return rv;
}
}
3.4.3 连接点（Joinpoint）和 切入点（Pointcut）的区别：
在 Spring AOP 中, 所有的方法执行都是 连接点（Joinpoint）， 而 切入点（Pointcut） 是一个描述信息, 它修饰的是 连接点（Joinpoint）,
通过 切入点（Pointcut）, 我们就可以确定哪些 连接点（Joinpoint） 可以被织入 通知（Advice）. 因此 连接点（Joinpoint） 和 切入点（Pointcut）本质上就是两个不同纬度上的东西.
3.4.4 通知/增强（Advice）：
在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)
即所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知，说白了就是一段功能性的代码。
通知的使用一般在切面中。
3.4.4.1 通知的类型：
前置通知（before advice）,后置通知,异常通知,最终通知,环绕通知。
3.4.4.1.1 前置通知（before advice）
spring注解：@Before(value = “”)
在 （连接点）join point 前被执行的（通知） advice.
虽然 前置通知（before advice） 是在 join point（连接点） 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)
3.4.4.1.2 后置通知（after return advice）：
spring注解：@AfterReturning(value = “”)
在方法正常执行完成进行通知，可以访问到方法的返回值的。
3.4.4.1.3 环绕通知（around advice）：
spring注解：@Around(value = “”)
在目标对象的房方法前和目标对象的房方法前退出后都执行的 通知.
这个是最常用的 advice.
3.4.4.1.4 方法执行后通知（after(final) advice）：
spring注解：@After(value = “”)
在目标方法执行后无论是否发生异常，执行通知,不能访问目标方法的执行的结果。
3.4.4.1.5 异常通知（after throwing advice） ：
spring注解：@AfterThrowing(value = “”)
在方法出现异常时进行通知,可以访问到异常对象，且可以指定在出现特定异常时在执行 的通知。
3.4.5 目标（Target）：
被通知(被代理)的对象
3.4.6 代理 (Proxy)：
将通知应用到目标对象后创建的对象(代理=目标+通知),请注意：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的。
一个类被 AOP 织入增强后，就产生一个结果代理类。
代理对象就是对目标对象进行代理，它是你在正确配置的情况下自动生成的一个对象，它自动生成在内存里，（一个.class文件）任何类以及方法想要调用这个目标对象就必须通过代理来调用，这样就避免了耦合性以及依赖性。提高代码的复用性。
这里如果理解了动态代理的原理可以更好的理解代理(Proxy)。
3.4.7 适配器(Advisor)：
适配器=通知(Advice)+切入点(Pointcut)
3.4.8 Introduction(引介):
引介是一种特殊的通知在不修改类代码的前提下，为一个类型添加额外的方法或字段.
Spring AOP 允许我们为 目标对象 引入新的接口(和对应的实现). 例如我们可以使用 introduction 来为一个 bean 实现 IsModified 接口, 并以此来简化 caching 的实现.
3.4.9 织入(Weaving)：
将 切面（aspect ）和其他对象连接起来, 并创建 代理（Proxy） 的过程.
根据不同的实现技术, AOP织入有三种方式:
- 编译器织入, 这要求有特殊的Java编译器.
- 类装载期织入, 这需要有特殊的类装载器.
- 动态代理织入, 在运行期为目标类添加增强(Advice)生成子类的方式.
3.4.10 Aspect(切面):
aspect 由 (切点)pointcount 和 （通知）advice 组成, 它既包含了横切逻辑的定义, 也包括了连接点的定义.
Spring AOP就是负责实施切面的框架, 它将切面所定义的横切逻辑织入到切面所指定的连接点中.
AOP的工作重心在于如何将增强织入目标对象的连接点上, 这里包含两个工作:
1. 如何通过 pointcut 和 advice 定位到特定的 joinpoint 上
2. 如何在 advice 中编写切面代码.
可以简单地认为： 使用 @Aspect 注解的类就是切面.
本篇分享就到这了，后续会出Spring的其他博客，感谢你的观看与支持！
1789
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
