spring 学习入门基础- AOP
Spring学习笔记五： AOP入门
Spring学习笔记五：AOP入门一、AOP术语切面(aspect):要实现的交叉功能，是系统模块化的一个切面或领域。
如日志记录。
连接点:应用程序执行过程中插入切面的地点，可以是方法调用，异常抛出，或者要修改的字段。
通知:切面的实际实现，他通知系统新的行为。
如在日志通知包含了实现日志功能的代码，如向日志文件写日志。
通知在连接点插入到应用系统中。
切入点:定义了通知应该应用在哪些连接点，通知可以应用到AOP框架支持的任何连接点。
引入:为类添加新方法和属性。
目标对象:被通知的对象。
既可以是你编写的类也可以是第三方类。
代理:将通知应用到目标对象后创建的对象，应用系统的其他部分不用为了支持代理对象而改变。
织入:将切面应用到目标对象从而创建一个新代理对象的过程。
织入发生在目标对象生命周期的多个点上：编译期：切面在目标对象编译时织入.这需要一个特殊的编译器.类装载期：切面在目标对象被载入JVM时织入.这需要一个特殊的类载入器.运行期：切面在应用系统运行时织入。
二、Spring AOP实现在spring中所有的通知都是以Java类的形式编写的。
切入点定义在配置文件中编写，所以切面代码和配置文件对我们来说都很熟悉。
对于其他框架(Aspectj)，需要特定的语法编写，如果使用的话，还需学习新的语言。
spring的运行时通知对象spring在运行期创建代理,不需要特殊的编译器.spring有两种代理方式：若目标对象实现了若干接口，spring使用ng.reflect.Proxy类代理。
该类让spring 动态产生一个新类，它实现了所需的接口，织入了通知，并且代理对目标对象的所有请求。
若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。
使用该方式时需要注意:2.1对接口创建代理优于对类创建代理，因为会产生更加松耦合的系统。
对类代理是让遗留系统或无法实现接口的第三方类库同样可以得到通知，这种方式应该是备用方案。
Spring AOP技术
Spring AOP技术主要内容：1、AOP概述2、从代理机制初探AOP3、图解AOP术语4、Spring支持的增强5、Spring具体实现AOP技术1、AOP概述1.1 什么AOP？AOP，是Aspect Oriented Programming的缩写，意思是面向切面（方面）编程。
AOP是在实现业务处理阶段，降低代码（或模块）之间的耦合度。
AOP技术是通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态添加辅助功能的技术。
AOP的应用场合是受限的，它一般只适用于具有横切业务逻辑的应用场合，比如事务管理、日志管理、访问权限管理和性能监测管理等。
1.2 AOP理解从OOP和AOP两方面，考虑软件重构问题：面向对象编程OOP，如果在多个类当中出现过个相同的属性和方法时，考虑定义一个共同抽象类，将这些相同的代码抽取到抽象类中。
这种实现方式叫继承，纵向抽取重复代码。
查看下面一段代码：public void newStudent(Student s){ //权限验证操作checkQualify();//开始事务操作beginTransaction();//核心业务处理save(s);//结束事务--提交操作endTransaction();//添加日志操作log();} public void deleteStudent(Student s){ //权限验证操作checkQualify();//开始事务操作beginTransaction();/核心业务处理delete(s);//结束事务--提交操作endTransaction();/添加日志操作log();}考虑：代码里面存在重复代码，该怎么考虑重构？图1业务代码横向抽取将重复的横切业务逻辑从核心业务逻辑中提取出来封装到几个类中容易，但如何将这些抽取的逻辑在适当的时机融合到核心逻辑并形成完整的应用，这才是事情的关键，AOP就是解决这个问题。
Spring之AOP
【Spring之AOP】什么是AOP？-面向切面编程-它是一种思想，可在不改变程序源码的情况下为程序添加额外的功能。
-允许通过分离应用的业务逻辑与系统级服务进行内聚性的开发。
应用对象只实现业务逻辑即可，并不负责其他的系统级关注点。
-AOP专门用于处理系统中分布于各个模块中的交叉关注点的问题，在J2EE应用中，常常通过AOP来处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等，AOP已经成为一种非常常用的解决方案。
AOP的发展过程？-静态AOP：Aspect形式，通过特定的编译器，将实现后的Aspect编译并织入到系统的静态类中-动态AOP：AOP的织入过程在系统运行开始之后进行，而不是预先编译到系统中AOP术语？-连接点：程序执行的某个特定位置，比如类初始化前、类初始化后、方法调用前、方法调用后等-切点：通过切点来定位特定的连接点-增强：织入到目标类连接点上的一段程序代码-目标对象：增强逻辑的织入目标类-引介：是一种特殊的增强，它为类添加一些属性和方法-织入：为增强添加目标类的具体连接点上的过程-代理：一个类被AOP织入增强后，会产生一个结果类，该类融合了原类和增强逻辑的代理类-切面：由切点和增强组成，既包括了横切逻辑的定义，也包括了连接点的定义AOP的原理剖析？-AOP代理其实是由AOP框架动态生成的一个对象，该对象可作为目标对象使用，AOP代理所包含的方法与目标对象的方法如下图所示：使用AOP的步骤是：定义普通业务组件--->定义切入点--->定义增强处理代理对象的方法= 增强处理+ 被代理对象的方法AOP的通俗理解？-一个组件A，不关心其他常用的服务组件B，但是这个组件A使用组件B的时候，不是组件A自身去调用，而是通过配置等其他方式，比如Spring中可以通过xml配置文件。
这样就使得A压根就不需要知道服务组件B是怎样的，爱存在不存在，爱怎么存在都与A无关。
Spring之AOP基本概念及配置AOP
Spring之AOP基本概念及配置AOP 为什么使用AOP传统方法AOP前前奏首先考虑一个问题，假设我们要设计一个计算器，有如下两个需求：- 在程序运行期间追踪正在放生的活动- 希望计算器只能处理正数的运算通常我们会用如下代码进行实现：定义一个接口：public interface ArithmeticCalculator {int add(int i, int j);int sub(int i, int j);int mul(int i, int j);int div(int i, int j);}实现类（在实现类中加入具体方法的实现，即正数的操作和日志功能，通过System.out.println 输出实现）：public class ArithmeticCalculatorLoggingImpl implements ArithmeticCalculator {@Overridepublic int add(int i, int j) {System.out.println("The method add begins with [" + i + "," + j + "]");int result = i + j;System.out.println("The method add ends with " + result);return result;}@Overridepublic int sub(int i, int j) {System.out.println("The method sub begins with [" + i + "," + j + "]");int result = i - j;System.out.println("The method sub ends with " + result);return result;}@Overridepublic int mul(int i, int j) {System.out.println("The method mul begins with [" + i + "," + j + "]");int result = i * j;System.out.println("The method mul ends with " + result);return result;}@Overridepublic int div(int i, int j) {System.out.println("The method div begins with [" + i + "," + j + "]");int result = i / j;System.out.println("The method div ends with " + result);return result;}}传统方法存在的问题- 代码混乱：越来越多的非业务需求(日志和验证等)加入后, 原有的业务方法急剧膨胀. 每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点. - 代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块（方法）里多次重复相同的日志代码. 如果日志需求发生变化, 必须修改所有模块.使用动态代理解决上述问题代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上./*** 动态代理* @author Megustas**/public class ArithmeticCalculatorLoggingProxy {//要代理的对象private ArithmeticCalculator target;public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {super();this.target = target;}//返回代理对象public ArithmeticCalculator getLoggingProxy(){ArithmeticCalculator proxy = null;//代理对象由哪一个类加载器加载ClassLoader loader = target.getClass().getClassLoader();//代理对象的类型，即其中有哪些方法Class [] interfaces = new Class[]{ArithmeticCalculator.class};//当调用代理对象其中的方法时，该执行的代码InvocationHandler h = new InvocationHandler() {/*** proxy:正在返回的那个代理对象，一般情况下，在invoke方法中不使用该对象* method: 正在被调用的方法* args: 调用方法传入的参数*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {String methodName = method.getName();//打印日志，此种方式对日志进行维护和更改就十分简洁System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));//调用目标方法Object result = null;try {//前置通知//invoke：通过函数名反射相应的函数result = method.invoke(target, args);//返回通知, 可以访问到方法的返回值} catch (NullPointerException e) {e.printStackTrace();//异常通知, 可以访问到方法出现的异常}//后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值//打印日志System.out.println("[after] The method ends with " + result);return result;}};/*** loader: 代理对象使用的类加载器。
spring入门教程
spring入门教程Spring是一个开源的Java框架，用于构建企业级应用。
它提供了一种基于IoC（控制反转）和AOP（面向切面编程）的方式来管理对象和解决各种企业级应用开发中的常见问题。
在正式开始学习Spring之前，我们需要先了解一些基本概念和术语。
1. IoC（控制反转）：IoC是Spring框架的核心概念之一，它通过将对象的创建和依赖关系的维护交给Spring容器来实现。
在传统的开发方式中，我们需要手动去创建对象并维护它们之间的关系，而在Spring中，我们只需要定义好对象的配置信息，Spring容器就会负责创建和管理对象。
2. AOP（面向切面编程）：AOP是另一个重要的概念，它提供了一种在程序运行时动态地将代码切入到方法的过程中的方式。
通过AOP，我们可以将一些与核心业务逻辑无关的功能（如事务管理、日志记录等）从业务逻辑中分离出来，提高代码的重用性和可维护性。
3. Spring容器：Spring容器是一个用于管理和组织Spring应用中的对象的运行环境。
它负责创建、装配和管理对象，并提供了一些额外的功能，如依赖注入、AOP等。
Spring容器有两种主要的实现方式：BeanFactory和ApplicationContext。
BeanFactory是Spring最基本的容器，而ApplicationContext是BeanFactory的子接口，它提供了更丰富的功能，如国际化支持、事件发布等。
接下来，我们将一步步学习如何使用Spring构建一个简单的应用。
首先，我们需要将Spring框架的相关依赖添加到项目中，可以通过Maven或Gradle来管理依赖。
在项目的配置文件（如application.properties或application.yml）中，我们需要配置Spring的相关信息，如数据库连接、日志配置等。
然后，我们可以开始定义我们的业务逻辑了。
首先，我们需要定义一个POJO类（纯Java对象），它代表了我们的业务实体。
spring aop的原理
spring aop的原理
Spring AOP（面向切面编程）是Spring框架的一个重要功能，用于在程序运行期间动态地实现横向切面的功能。
AOP的原
理是通过动态代理机制，在不改变原有代码的情况下，将横向切面的逻辑与业务逻辑进行解耦。
Spring AOP采用的是基于代理的AOP实现，具体的原理如下：
1. 声明要切入的切面逻辑，通常使用注解来定义切面。
例如，在需要事务管理的方法上使用事务注解声明事务切面。
2. 在Spring IOC容器中注册这些切面，使得Spring能够识别
并自动在合适的时机应用切面逻辑。
3. 当程序运行到目标方法时，Spring会检查是否有与该方法匹
配的切面。
4. 如果存在匹配的切面，Spring会自动为该方法创建一个动态
代理对象，代理对象包含了目标对象的引用和切面逻辑的引用。
5. 当方法调用到达代理对象时，代理对象会按照事先定义的切面逻辑进行处理。
例如，前置通知会在方法调用前执行，后置通知会在方法调用后执行。
6. 代理对象将调用传递给目标对象，并在合适的时机执行切面逻辑。
7. 切面逻辑执行完毕后，代理对象将返回结果给调用方。
通过以上步骤，Spring AOP实现了横切关注点与业务逻辑的
解耦，提供了一种便捷的方式来统一管理横切逻辑。
同时，Spring AOP的代理机制也保证了对现有代码的兼容性，不会
对现有代码产生任何影响。
SpringAOP的原理和应用场景
SpringAOP的原理和应用场景SpringAOP（Aspect-Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种通过预定义的方式，将横切关注点（Cross-cutting Concerns）与业务逻辑进行解耦的机制。
本文将介绍SpringAOP的原理及其在实际应用场景中的应用。
一、SpringAOP的原理SpringAOP基于代理模式（Proxy Pattern）实现。
在SpringAOP中，通过生成与原始类（被代理类）具有相同接口的代理类，将横切逻辑编织到业务逻辑中。
在运行时，当调用代理类的方法时，会在方法执行前、后或异常抛出时插入相应的横切逻辑代码。
具体而言，SpringAOP使用了以下几个核心概念：1. 切面（Aspect）：切面是横切逻辑的模块化单元，它包含了一组通知（Advice）和切点（Pointcut）。
2. 通知（Advice）：通知定义了实际的横切逻辑代码，并规定了何时执行该代码。
SpringAOP提供了五种类型的通知：前置通知（Before）、后置通知（After）、返回通知（After-returning）、异常通知（After-throwing）和环绕通知（Around）。
3. 切点（Pointcut）：切点指定了在哪些连接点（Join Point）上执行通知。
连接点可以是方法调用、属性访问等程序执行的点。
4. 连接点（Join Point）：连接点是程序执行过程中的一个特定点，如方法调用前、方法调用后等。
通知通过切点来选择连接点。
5. 织入（Weaving）：织入是将切面应用到目标对象，并创建代理对象的过程。
织入可以在编译时、类加载时或运行时进行。
二、SpringAOP的应用场景SpringAOP可应用于各种场景，用于解决跨越多个模块或类的横切关注点问题。
以下是一些常见的SpringAOP应用场景：1. 日志记录：通过在关键方法的前后插入日志代码，实现对系统运行状态的监控和记录。
springaop原理
springaop原理AOP（面向切面编程）是Java编程开发中一种重要的技术，可以实现代码重用和更强的结构化编程。
AOP可以帮助程序员实现功能，比如日志记录，性能监控，安全控制和异常处理，而不影响应用程序的原有业务逻辑。
Spring AOP是基于代理的面向切面编程框架，允许程序员在Java 应用程序中实现AOP的功能。
Spring AOP可以实施在应用程序中的所有模块中，包括核心层，应用层和数据访问层。
Spring AOP的基本原理是在一个方法（target object）调用之前，增加执行额外行为（aspect），它封装了与原有方法相关的非核心逻辑，比如日志记录，性能监控，安全控制，以及异常处理，这些aspect都是以类的形式加入到target object之中。
Spring AOP同时允许程序员为每个class或method编写定制的aspect。
Spring AOP的工作原理是：当调用target object中的方法时，Spring AOP会首先检查是否有相关的aspect，如果有，则会在调用target object的方法之前，调用aspect的before方法。
接着，target object的方法会继续执行，在调用target object的方法之后，aspect 的after方法会被调用。
Spring AOP使用不同类型的代理技术，允许程序员将aspect应用于常规类和接口，比如JDK动态代理和CGLIB动态代理。
在Spring AOP中，两种最常用的代理技术是JDK动态代理和CGLIB动态代理，它们的工作原理是：在target object的方法调用之前，Spring AOP会创建一个带有aspect的代理对象，代理对象会拦截所有的methods，然后在方法调用之前，会根据代理对象的类型来调用aspect的before和after的方法。
Spring AOP的另一个主要特点是可以将aspect和target object 中的方法关联起来。
SpringAOP简单快速理解介绍
SPRING AOP介绍Posted on 2007-11-16 14:06 wigalos阅读(2801) 评论(3)编辑收藏最近在学习spring，做了一些关于Spring AOP的总结和例子，参考书籍是李刚老师著的《轻量级J2EE企业应用实战》。
如下：Spring AOP介绍Spring的AOP是上面代理模式的深入。
使用Spring AOP，开发者无需实现业务逻辑对象工厂，无需实现代理工厂，这两个工厂都由Spring容器充当。
Spring AOP不仅允许使用XML文件配置目标方法，ProxyHandler也允许使用依赖注入管理，Spring AOP提供了更多灵活的选择。
在下面Spring AOP的示例中，InvocationHandler采用动态配置，需要增加的方法也采用动态配置，一个目标对象可以有多个拦截器（类似于代理模式中的代理处理器）。
下面是原始的目标对象：//目标对象的接口public interface Person{//该接口声明了两个方法void info();void run();}下面是原始目标对象的实现类，实现类的代码如下：//目标对象的实现类，实现类实现Person接口public class PersonImpl implements Person{//两个成员属性private String name;private int age;//name属性的setter方法public void setName(String name){ = name;}//age属性的setter方法public void setAge(int age){this.age = age;}//info方法，该方法仅仅在控制台打印一行字符串public void info(){"我的名字是: " + name + " , 今年年龄为: " + age);}//run方法，该方法也在控制台打印一行字符串。
spring aop 原理
spring aop 原理Spring AOP（面向切面编程）是Spring框架的一个核心模块，用于提供在方法执行前、后、抛出异常等关键节点进行拦截的能力。
它通过使用动态代理机制，在运行时将切面逻辑织入到目标对象的方法中，从而实现对目标方法的增强。
Spring AOP的实现原理主要基于Java的动态代理机制。
当我们在配置文件中定义了一个切面时，Spring容器会根据该配置信息生成一个代理对象，该代理对象包装了目标对象，并且在目标对象的相应方法执行前、后等关键节点执行切面的逻辑。
这样一来，我们就可以通过配置的方式将切面逻辑与目标对象进行解耦，从而实现对目标方法的增强。
具体而言，Spring AOP主要通过以下几个步骤实现：1. 定义切面：切面是对一系列连接点和切点的描述，用于定义切面逻辑。
通常，我们可以通过使用注解或XML配置来定义切面。
2. 定义通知（Advice）：通知是切面逻辑的具体实现，包括方法执行前、方法执行后等不同的拦截点。
Spring AOP提供了以下几种类型的通知：前置通知（Before Advice）、后置通知（After Advice）、返回通知（After Returning Advice）、抛出异常通知（After Throwing Advice）以及环绕通知（Around Advice）。
3. 定义切点：切点是我们希望在目标方法中执行切面逻辑的特定位置。
我们可以通过使用注解或XML配置来定义切点，将切点与具体的目标方法关联起来。
4. 生成代理对象：当Spring容器启动时，会根据配置信息自动在运行时生成代理对象。
该代理对象将切面逻辑织入到目标对象的方法中，从而实现对目标方法的增强。
5. 执行增强逻辑：在目标方法被调用时，代理对象会根据切点的定义，执行相应的切面逻辑。
例如，在方法执行前，代理对象会首先执行前置通知，然后执行目标方法，最后执行后置通知等等。
总之，Spring AOP的原理是基于动态代理机制，通过生成代理对象并将切面逻辑织入到目标方法中，实现对目标方法的增强。
SpringAOP用法详解
//匹配com.aop.service.impl.ProductServiceImpl类下方法名以select或delete开头的所有方法 @Pointcut("execution(* com.aop.service.impl.ProductServiceImpl.select*(..)) || " +
if("100".equals(id.toString())) { System.out.println("查询商品成功！");
} else { System.out.println("查询商品失败！"); throw new RuntimeException("该商品不存在！");
} } }
1.使用within表达式匹配包类型
运行结果（只有deleteProductById方法拦截成功）：
查询商品成功！ 删除商品名称为衣服的商品成功！ before 前置通知......
ng.RuntimeException: 该用户无此权限！
at com.aop.service.impl.AuthServiceImpl.checkAccess(AuthServiceImpl.java:15) at com.aop.security.SecurityAspect.before(SecurityAspect.java:50)
@Autowired private AuthService authService;
@Override public Long deleteProductById(Long id) {
spring aop原理
spring aop原理
Spring AOP原理Spring AOP（面向切面编程）是针对一
个特定类方法设计的一种编程模式，它可以让开发者使用特定的代码模块来拦截或改变类中的方法行为。
AOP可以用于实
现诸如日志记录、安全管理、事务管理等功能。
1、Spring AOP是基于Java动态代理技术实现的，AOP
代理由Spring创建，它使用Java反射机制来拦截方法的调用。
2、Spring AOP的实现过程是，首先Spring会根据提供的AspectJ切点表达式，从源类中查找需要被拦截的方法。
接着，根据指定的切面定义，Spring会为该方法创建一个代理，然后
将该代理对象替换原始类中的方法。
最后，每当调用该方法时，代理对象会拦截该方法，并在调用原始方法前后执行一些额外操作。
3、Spring AOP可以在多种不同的类型中应用，包括普通类、构造函数、接口、注解等。
4、Spring AOP可以拦截四种不同类型的方法调用，分别
是方法调用、构造函数调用、字段访问和异常处理器调用。
5、Spring AOP支持多种不同的切面定义，包括前置通知、后置通知、环绕通知和异常处理通知等。
总之，Spring AOP是一种非侵入式的编程模式，它可以让开发者通过切面来拦截类中的方法，并在调用原始方法前后执行一些额外的操作，从而简化代码的编写。
Spring框架——AOP（面向切面编程）详解
Spring框架——AOP（⾯向切⾯编程）详解1 AOP概述●AOP(Aspect-Oriented Programming，⾯向切⾯编程)：是⼀种新的⽅法论，是对传统 OOP(Object-Oriented Programming，⾯向对象编程)的补充。
●AOP编程操作的主要对象是切⾯(aspect)，⽽切⾯模块化横切关注点。
●在应⽤AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能应⽤在哪⾥，以什么⽅式应⽤，并且不必修改受影响的类。
这样⼀来横切关注点就被模块化到特殊的类⾥——这样的类我们通常称之为“切⾯”。
●AOP的好处：○每个事物逻辑位于⼀个位置，代码不分散，便于维护和升级○业务模块更简洁，只包含核⼼业务代码2 AOP术语2.1 横切关注点 从每个⽅法中抽取出来的同⼀类⾮核⼼业务。
（抽离到⽅法中处理⾮核⼼业务）2.2 切⾯(Aspect) 封装横切关注点信息的类，每个关注点体现为⼀个通知⽅法。
2.3 通知(Advice) 切⾯必须要完成的各个具体⼯作2.4 ⽬标(Target) 被通知的对象2.5 代理(Proxy) 向⽬标对象应⽤通知之后创建的代理对象2.6 连接点(Joinpoint) 横切关注点在程序代码中的具体体现，对应程序执⾏的某个特定位置。
例如：类某个⽅法调⽤前、调⽤后、⽅法捕获到异常后等。
在应⽤程序中可以使⽤横纵两个坐标来定位⼀个具体的连接点：2.7 切⼊点(pointcut)： 定位连接点的⽅式。
每个类的⽅法中都包含多个连接点，所以连接点是类中客观存在的事物。
如果把连接点看作数据库中的记录，那么切⼊点就是查询条件——AOP可以通过切⼊点定位到特定的连接点。
切点通过org.springframework.aop.Pointcut 接⼝进⾏描述，它使⽤类和⽅法作为连接点的查询条件。
3 AspectJ3.1 简介AspectJ：Java社区⾥最完整最流⾏的AOP框架。
Spring第二章AOP
Spring第二章AOP1.IOC复习控制反转，对象由Spring框架来创建，这个对象的控制权发生了反转，由外部框架Spring 来管理。
换一个角度，也叫依赖注入(DI)，程序中不创建对象，如果要使用某对象，对象依赖Spring框架的IOC容器注入。
导入Spring相关的Jar包，添加配置文件，在配置文件中创建Bean（对象），其实在开发中，很少在配置文件中创建Bean，如果创建也只是创建一些系统内部的Bean。
我们开发的源文件件要实例化Bean，基本上都采用注解+扫描的方式来创建Bean.如果一个源文件要扫描到IOC容器中，则在这个源文件前面加上注解就可以了，因为源文件在不同层的包中，建议不同层的源文件采用合适的注解来处理。
@Repository (value="student") 建议用在持久层的源文件上,value:是创建的对象的ID值@Service(value="studentService") 建议用在业务逻辑层的源文件上。
@Controller(value="studentController")建议用在控制层的源文件上。
@Component当某个源文件不知归纳到某个层中，则用此注解，表示是一个组件。
在IOC容器中创建的时候，默认加载所有配置的Bean，包括扫描的Bean。
默认这些Bean 是单例模式，可以配置为非单例模式。
在Bean中添加scope属性，或添加@Scope(scopeName="prototype") 注解。
Bean的生命周期，因为Bean由IOC容器创建，控制权归IOC容器，一旦Bean创建，则一直驻扎在IOC容器中，要到IOC容器销毁或程序结束，Bean对象才销毁。
Bean 对象的依赖对象的注入。
当一个类中有另一个类的对象。
可以采用外部Bean，用ref引用就可以了。
也可以采用内部Bean的方式，但是内部Bean的作用域只是这个Bean 里有用，其它的Bean是不能引用内部Bean的。
SpringAOP学习笔记
Spring AOP学习笔记需明确的几个概念：通知(Advice)：用于告知系统将有哪些新的行为。
切入点(Pointcut):定义了通知应该在应用到那些连接点。
目标对象(Target)：被通知的对象。
代理(Proxy)：将通知应用到目标对象后创建的对象。
需明确的几个概念:l 通知(Advice)：用于告知系统将有哪些新的行为。
l 切入点(Pointcut):定义了通知应该在应用到那些连接点。
l 目标对象(Target)：被通知的对象。
l 代理(Proxy)：将通知应用到目标对象后创建的对象。
Spring有两种代理创建方式：1. 如果目标对象实现了一个或多个接口暴露的方法，Spring将使用JDK的ng.reflect.Proxy创建代理。
这个类让Spring动态产生一个新的类，它实现了所需的接口，织入了通知，并且代理目标的所有请求。
（这篇主要介绍这个方式）2. 如果目标对象没有实现任何接口，Spring使用CGLIB库生成目标对象的子类。
在创建这个子类的时候，Spring将通知织入，并且将对目标对象的调用委托给这个子类。
下面以一个实例说明Spring AOP的基本开发方法：一．创建通知Spring连接点模型是建立在方法拦截上，这意味着你编写的Spring通知会在方法调用周围的各个地方织入系统中。
TestAopServiceAdvice实现了接口MethodBeforeAdvice(前置通知)，并实现它的惟一的方法before，这个类就可以在调用目标对象前被调用。
同样的还有AfterReturningAdvice(后置通知)，MethodInterceptor(环绕通知)，异常通知(ThrowsAdvice)，引入通知等。
在这个方法中我们输出了一个字符串TestAopServiceAdvice，用于验证这个方法是否在目标对象前调用了。
注意：我们无法改变before方法中的参数args和target中的值，args中存的是原来要传入目标对象的变量，target即指目标对象。
springaop的原理及常见应用
Spring AOP的原理及常见应用概述Spring AOP（Aspect-Oriented Programming）是一种面向切面编程的技术，可以在应用的不同层次上定义和管理软件系统的横切关注点。
它通过在不修改原有代码的情况下，向往常的业务流程中插入额外的行为逻辑，从而达到对系统进行功能增强或横切逻辑的复用。
原理Spring AOP的原理基于动态代理技术和反射机制。
它通过运行时创建代理对象，将切面逻辑织入到目标对象中，在目标对象的方法执行前、后或异常时执行切面代码，实现额外的行为。
Spring AOP主要通过以下两种方式来实现切面逻辑的织入：1. 基于动态代理：使用JDK动态代理或CGLIB来生成代理对象，并将切面逻辑织入到代理对象中。
2. 基于字节码提前增强：通过继承或重写目标方法的方式，在目标类加载时，通过工具将切面逻辑编织入字节码中。
常见应用Spring AOP提供了一种简洁灵活的方式来应用切面逻辑，常见的应用包括：1. 日志记录通过切面逻辑，在方法执行前后记录日志信息，可以帮助我们追踪应用的执行流程，以及定位潜在的问题。
2. 安全校验在方法执行前进行身份认证和权限校验，确保只有授权用户才能访问敏感操作或受限资源。
3. 事务管理通过在方法执行前后进行事务开启、提交、回滚操作，可以保证数据库操作的一致性和可靠性。
4. 缓存处理在方法执行前先查询缓存，如果有缓存则直接返回结果，避免了不必要的数据库查询，提高系统性能。
5. 异常处理通过捕获方法执行过程中的异常，并进行统一处理，可以实现全局的异常日志记录、错误信息转换等。
6. 性能监控在方法执行前后记录方法的执行时间，并统计次数，从而对系统的性能进行监控和分析。
7. 限流熔断通过在方法执行前进行限流计数和熔断措施，可以保护系统免受恶意攻击或突发高并发请求的影响。
8. 动态路由通过切面逻辑实现动态的路由策略，可以根据业务需要将请求转发到不同的服务实例或集群。
Spring AOP
Spring AOP1 AOP概述2 Spring AOP所涉及的java基础知识3 Spring AOP的增强类型4 SpringAOP的切面类型5 通过自动代理技术创建切面1 AOP概述AOP：面向切面编程。
当无法通过抽象父类的方式（纵向）消除代码的重复性时，可以通过横向抽取来消除代码的重复。
AOP通过横向抽取来实现无法纵向继承的代码的横向切分。
AOP术语：通知：切面的工作称为通知：AOP有5种通知：●Before：在方法调用前通知●After：在方法完成之后通知，无论方法是否成功。
●After-returning：在方法成功执行后通知●After-throwing：在方法抛出异常后通知●Around：通知包裹了被通知的方法。
在被通知的方法执行之前和之后执行自定义方法连接点：一个类或者一段程序拥有的具有边界性质的点。
Spring仅支持方法的连接点，即只能在方法调用前，调用后抛出异常时以及方法调用前后这行程序执行点织入增强。
切点：A OP通过切点定位到具体连接点（方法）一个切点对应多个连接点增强：织入到目标类连接点上的一段程序代码。
目标对象：增强逻辑织入的目标类引介：一种特殊的增强，为类添加一些属性和方法。
这样，即使一个业务类原本没有实现某一接口，也可以通过引介额方式实现增强的逻辑。
织入：将增强添加到具体连接点的过程。
三种织入方式：1）编译器织入（需要特殊java编译器）2）类装载期织入，3）动态代理织入。
Spring 采用动态代理织入，AspectJ采用编译期织入和装载期织入。
代理：切面：由切点和增强（引介）组成。
目前实现AOP的主要有：Spring AOP 、AspectJ、JBoss AOP2 Spring AOP所涉及的java基础知识Spring AOP使用了两种代理机制：1）基于jdk的动态代理2）基于CGLIB的动态代理之所以需要两种，是因为jdk本身只提供接口代理，而不支持类代理Spring提供了4中AOP支持：●基于代理的AOP●@AspectJ注解驱动切面●纯POJO切面●注入式AspecJ切面2.1 横切逻辑实例3 Spring AOP的增强类型4 SpringAOP的切面类型5 通过自动代理技术创建切面。
【预习资料】一步一步手绘Spring AOP运行时序图
预习资料
课程目标
1、通过分析Spring源码，深刻掌握核心原理和设计思想。
2、通过本课的学习，完全掌握Spring AOP的重要细节。
3、手绘Spring AOP运行时序图。
内容定位
1、Spring使用不熟练者不适合学习本章内容。
2、先掌握执行流程，再理解设计思想，这个过程至少要花1个月。
3、Spring源码非常经典，体系也非常庞大，看一遍是远远不够的。
课程大纲
第一章：Spring AOP初体验
1.1、再述Spring AOP应用场景
1.2、AOP中必须明白的几个概念
1.2.1、切面（Aspect）
1.2.2、通知（Advice）
1.2.3、切入点（Pointcut）
1.2.4、目标对象（Target Object）
1.2.5、AOP代理（AOP Proxy）
1.2.6、前置通知（Before advice）
1.2.7、后置通知（After advice）
1.2.8、返回通知（After return advice）
1.2.9、环绕通知（Around advice）
1.2.10、异常通知（After throwing advice）第二章Spring AOP源码分析
2.1、寻找入口
2.2、AOP代理策略分析
课前准备
1、下载并构建中文注释版Spring源码。
2、重新梳理一遍Spring源码的包结构。
3、亲手完成手写Spring mini版本。
4、推荐书籍：《Spring 5核心原理与30个类手写实战》。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
spring 学习(1.2) 入门基础- AOP
一、AOP 概念
Joinpoint：它定义在哪里加入你的逻辑功能，对于Spring AOP，Jointpoint指的就是Method。
Advice：特定的Jointpoint处运行的代码，对于Spring AOP 来讲，有Before advice、AfterreturningAdvice、ThrowAdvice、AroundAdvice(MethodInteceptor)等。
Pointcut：一组Joinpoint，就是说一个Advice可能在多个地方织入，
Aspect：这个我一直迷惑，它实际是Advice和Pointcut的组合，但是Spring AOP 中的Advisor 也是这样一个东西，但是Spring中为什么叫Advisor而不叫做Aspect。
Weaving：将Aspect加入到程序代码的过程，对于Spring AOP，由ProxyFactory或者ProxyFactoryBean负责织入动作。
Target：这个很容易理解，就是需要Aspect功能的对象。
Introduction：引入，就是向对象中加入新的属性或方法，一般是一个实例一个引用对象。
当然如果不引入属性或者引入的属性做了线程安全性处理或者只读属性，则一个Class一个引用也是可以的（自己理解）。
Per-class lifecycle or per-instance life cycle
二、AOP 种类
1、静态织入：指在编译时期就织入Aspect代码，AspectJ好像是这样做的。
2、动态织入：在运行时期织入，Spring AOP属于动态织入，动态织入又分静动两种，静则指织入过程只在第一次调用时执行；动则指根据代码动态运行的中间状态来决定如何操作，每次调用Target的时候都执行（性能较差）。
三、Spring AOP 代理原理
Spring AOP 是使用代理来完成的，Spring 会使用下面两种方式的其中一种来创建代理：
1、JDK动态代理，特点只能代理接口，性能相对较差，需要设定一组代理接口。
2、CGLIB 代理，可代理接口和类（final method除外），性能较高(生成字节码)。
四、Spring AOP 通知类型
1、BeforeAdvice：前置通知需实现MethodBeforeAdvice，但是该接口的Parent是BeforeAdvice，致于什么用处我想可能是扩展性需求的设计吧。
或者Spring未来也并不局限于Method的JoinPoint（胡乱猜测）。
BeforeAdvice可以修改目标的参数，也可以通过抛出异常来阻止目标运行。
2、AfterreturningAdvice：实现AfterreturningAdvice，我们无法修改方法的返回值，但是可以通过抛出异常阻止方法运行。
3、AroundAdvice：Spring 通过实现MethodInterceptor(aopalliance)来实现包围通知，最大特点是可以修改返回值，当然它在方法前后都加入了自己的逻辑代码，因此功能异常强大。
通
过MethodInvocation.proceed()来调用目标方法（甚至可以不调用）。
4、ThrowsAdvice：通过实现若干afterThrowing()来实现。
5、IntroductionInterceptor：Spring 的默认实现为DelegatingIntroductionInterceptor
五、Spring AOP Pointcut
以上只是Advice，如果不指定切入点，Spring 则使用所有可能的Jointpoint进行织入（当然如果你在Advice中进行方法检查除外）。
因此切入点在AOP中扮演一个十分重要的角色。
Spring 2.0 推荐使用AspectJ的Annocation的切入点表达式来定义切入点，或者使用<aop:xxx/>来定义AOP，这方面本篇不做考虑。
1、Pointcut：它是Spring AOP Pointcut的核心，定义了getClassFilter()和getMethodMatcher()两个方法。
2、ClassFilter：定义了matches(Class cls)一个方法。
3、MethodMatcher() 定义了matches(Method，Class)，isRuntime()，matches(Mathod，Class，Object[])三个方法，如果isRuntime()返回true则表示为动态代理（实际是动态代理的动态代理），则调用第三个方法（每访问一次调用一次），否则调用第一个方法（并且只调用一次）
4、Spring AOP静态切入点的几个实现。
ComposablePointcut 太复杂一个切入点无法表达就用这个,union MethodMatcher和ClassFilter或者intersection MethodMatcher、ClassFilter和Pointcut。
为什么不实现union Pointcut? 而只能通过Pointcuts类对Pointcut进行union操作。
ControlFlowPointcut 想对程序的运行过程进行追踪就用这个
DynamicMatchMatcherPointcut 想用动态AOP 就用这个
JdkRegexpMethodPointcut 想使用正则表达式就用这个
Perl5RegexpMethodPointcut
NameMatchMethodPointcut 想用方法名字来匹配就用这个
StaticMethodMatcherPointcut 静态切入点就用这个
没有人反对你直接实现Pointcut：）。
六、Spring AOP 中的Advisor其实就是Aspect
1、PointcutAdvisor
其实一般使用DefaultPointcutAdvisor就足够了，给它Advice和Pointcut。
当然如果想少写那么几行代码也可以使用NameMatchMethodPointcutAdvisor，RegexpMethodPointcutAdvisor等。
更多Advisor可以查看API文档。
2、IntroductionAdvisor
默认实现为DefaultIntroductionAdvisor。
七、AOP ProxyFactory
使用代码实现AOP 可使用ProxyFactory
声明式AOP 可使用ProxyFactoryBean
ProxyFactoryBean 需要设定target，interceptorNames（可以是Advice或者Advisor，注意顺序）
对接口代理需设置proxyInterfaces
八、自动代理
BeanNameAutoProxyCreator
代码
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"> <property name="beanNames"><value>jdk*,onlyJdk</value></property>
<property name="interceptorNames">
<list>
<value>myInterceptor</value>
</list>
</property>
</bean>
DefaultAdvisorAutoProxyCreator
代码
<bean
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
<bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"> <property name="transactionInterceptor" ref="transactionInterceptor"/>
</bean>
<bean id="customAdvisor" class="com.mycompany.MyAdvisor"/>
<bean id="businessObject1" class="com.mycompany.BusinessObject1">
<!-- Properties omitted -->
</bean>
<bean id="businessObject2" class="com.mycompany.BusinessObject2"/>。