Spring之 Aop

最新推荐文章于 2024-11-16 22:34:09 发布
最新推荐文章于 2024-11-16 22:34:09 发布
阅读量182 收藏
点赞数
文章标签： java idea Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67368271/article/details/129386389
版权

目录

目录什么是AOPAOP应用场景Spring AOP代理机制Spring AOP的术语核心概念重要通知分类织入时期为什么使用AOPSpring AOP实现基本配置pom.xmlplugins 插件配置添加依赖web.xmlJava.classIBookBiz.javaBookBizImpl.javaresource包新建 spring.xml前置通知ProxyFactoryBean 常用属性后置通知环绕通知异常通知适配器完整代码spring.xmlDemo.java

什么是AOP

OOP三大特点：封装、继承、多态

AOP

AOP(Aspect Oriented Programming)是一种面向切面的编程思想。面向切面编程是将程序抽象成各个切面，即解剖对象的内部， 将那些影响了多个类的公共行为抽取到一个可重用模块里 ，减少系统的重复代码，降低模块间的耦合度，增强代码的可操作性和可维护性。

提取公共行为抽取到一个类中

中间是具体的核心代码（核心关注点），上边和下边为 重复代码（横切关注点）

publicvoidadd(){

Connectioncon=DBHelper.getConnection(); //获取连接对象：连接数据库

PrepareStatementps=con....

ResultSetrs=ps....

​

核心代码

​

finally{

DBHelper.close(con,ps,rs); //关闭连接

}

}

-> 交付由 AOP管理

publicvoidadd(){

<------面向切面：从横切面切入代码

​

核心代码

​

<------面向切面

}

AOP把软件系统分为两个部分：核心关注点（每一个方法中的核心功能）和横切关注点（多个方法里的公共行为）。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理、增强处理。

AOP带来的好处：让我们可以 “专心做事”

应用场景

  • 场景一：记录日志

  • 场景二：监控方法运行时间 （监控性能）

方法执行前和方法执行后，不知道核心代码需要多长时间执行完成。由 结束时间 - 开始时间 得到 核心代码时长，然后就可以根据时长进行方法调优

  • 场景三：权限控制

  • 场景四：缓存优化 （

第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）

  • 场景五：事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ）

比如：开启连接，关闭连接

publicvoidadd(){

Connectioncon=DBHelper.getConnection();

Transactiontran=conn.beginTransaction();

<------面向切面：从横切面切入代码

​

核心代码

​

<------面向切面

tran.commit()/tran.rollback();

}

Spring AOP代理机制

Spring 在运行期会为目标对象生成一个动态代理对象，并在代理对象中实现对目标对象的增强。Spring AOP 的底层是通过以下 2 种动态代理机制，为目标对象（Target Bean）执行横向织入的。

  • JDK动态代理：Spring AOP 默认的动态代理方式，若目标对象实现了若干接口，Spring 使用 JDK 的 java.lang.reflect.Proxy 类进行代理。

  • CGLIB动态代理：若目标对象没有实现任何接口，Spring 则使用 CGLIB 库生成目标对象的子类，以实现对目标对象的代理。

注意：由于被标记为 final 的方法是无法进行覆盖的，因此这类方法不管是通过 JDK 动态代理机制还是 CGLIB 动态代理机制都是无法完成代理的。

Spring AOP的术语

核心概念重要

  • Joinpoint（连接点）：

指那些被拦截到的点（程序执行过程中明确的点，如 方法的调用，或者异常的抛出），在 Spring 中，可以被动态代理拦截目标类的方法。

  • Pointcut（切入点）：

多个连接点的集合，定义了通知应该应用到哪些连接点。

  • Advice（通知）：

指拦截到 Joinpoint 之后要做的事情，即对切入点增强的内容。

  • Target（目标）：

指代理的目标对象。

  • Weaving（织入）：

指把增强代码应用到目标上，生成代理对象的过程。

  • Proxy（代理） ：

指生成的代理对象（将通知应用到目标对象后创建的对象）。

  • Aspect（切面）：

切入点和通知的结合。

术语

含义

连接点

程序执行过程中明确的点，方法的调用

切入点

多个连接点的集合，只有满足条件的才能将通知应用到目标上 （if 条件，筛选）

通知

公共行为，横切关注点

目标

具体执行核心业务的代码

代理

将通知应用到目标上所的创建对象 （通知+目标 = 代理）

切面

通知 + 切入点 【满足条件】

公共部分的代码写在哪里的？ 通知里面，只有完整的代理对象才具备 AOP的特性

通知分类

AOP 联盟为通知（Advice）定义了一个 org.aopalliance.aop.Interface.Advice 接口。

Spring AOP 按照通知（Advice）织入到目标类方法的连接点位置，为 Advice 接口提供了 6 个子接口。

通知类型

接口

描述

前置通知

org.springframework.aop.MethodBeforeAdvice

在目标方法执行前实施增强。

后置通知

org.springframework.aop.AfterAdvice

在目标方法执行后实施增强。

后置返回通知

org.springframework.aop.AfterReturningAdvice

在目标方法执行完成，并返回一个返回值后实施增强。

环绕通知

org.aopalliance.intercept.MethodInterceptor

在目标方法执行前后实施增强。

异常通知

org.springframework.aop.ThrowsAdvice

在方法抛出异常后实施增强。

引入通知

org.springframework.aop.IntroductionInterceptor

在目标类中添加一些新的方法和属性。

织入时期

织⼊（Weaving）：代理的⽣成时机（通知 + 目标）。织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程，切⾯在指定的连接点被织⼊到⽬标对象中。

在⽬标对象的⽣命周期⾥有多个点可以织⼊：

时期

说明

编译期

切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的。

类加载期

切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器（ClassLoader）,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊（load-time weaving. LTW）就⽀持以这种⽅式织⼊切⾯。

运行期

切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下，在织⼊切⾯时，AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。

为什么使用AOP

举个例子

  • 病人做手术

  1. 术前准备工作，护士和麻醉师 -> 通知 ，公共行为 （一个手术室可能有多台手术，同一时间）

  1. 病人做手术 -> 目标

  1. 做手术 -> 切入点（明确的一个点：只有做手术才会触发 准备工作、打麻药...）

  1. 护士、麻醉师和医生一起做手术 -> 代理

  1. 如果没有护士、麻醉师，医生一个人完成手术，不可能吧

  1. 如果没有医生，只有护士、麻醉师，都不知道从哪里下刀

所以，通知 + 目标 = 代理，一个完成的 代理对象才具有 AOP的特性

  1. 做完手术，清理工具 -> 通知，公共行为（做完手术都要 清理）

  1. 麻醉师打麻醉，方便做手术 -> 切面（切入点+ 通知）

  • 在指定方法被调用之前记录日志

在指定方法被调用之前记录日志。在传统方式下通过在每个方法之前先添加日志收集代码，再执行方法本身的核心业务代码

如果遇到记录日志方法业务变动的情况，后期的代码更新和维护将是一大难题。
假设有一百个方法，每个方法都要记录日志，有一个改动都要维护100次，
如果给 AOP管理，则只用修改一次

publicvoiddoSameBusiness (longlParam,StringsParam){

// 记录日志：在方法调用之前

log.info("调用 doSameBusiness方法，参数是："+lParam);

//核心方法： 输入合法性验证

if (lParam<=0){

throwsnewIllegalArgumentException("xx应该大于0");

}

if (sParam==null||sParam.trim().equals("")){

throwsnewIllegalArgumentException("xx不能为空");

}

// 异常处理

try{ ...

}catch(...){

}

// 事务控制

tx.commit();

}

Spring AOP实现

基本配置

基于idea创建maven项目，配置pom.xml并导入依赖。

pom.xml

plugins 插件配置

<!--插件-->

<plugins>

<!--第一步就是配置maven-compiler-plugin插件，其他的插件统统删除-->

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

<version>3.7.0</version>

<configuration>

<source>${maven.compiler.source}</source>

<!--jdk 1.8-->

<target>${maven.compiler.target}</target>

<encoding>${project.build.sourceEncoding}</encoding>

</configuration>

</plugin>

</plugins>

添加依赖

<!--设置版本号-->

<properties>

<junit.version>4.12</junit.version>

<spring.version>5.0.8.RELEASE</spring.version>

</properties>

​

<!--动态加载依赖-->

<dependencies>

<dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>${junit.version}</version>

<scope>test</scope>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>${spring.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-orm</artifactId>

<version>${spring.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-web</artifactId>

<version>${spring.version}</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>${spring.version}</version>

</dependency>

</dependencies>

web.xml

<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

id="WebApp_ID"version="3.0">

<display-name>Archetype Created Web Application</display-name>

</web-app>

Java.class

导入书本业务类IBookBiz、BookBizImpl

IBookBiz.java

publicinterfaceIBookBiz {

// 购书

publicbooleanbuy(StringuserName, StringbookName, Doubleprice);

// 发表书评

publicvoidcomment(StringuserName, Stringcomments);

}

BookBizImpl.java

publicclassBookBizImplimplementsIBookBiz {

publicBookBizImpl() {

super();

}

publicbooleanbuy(StringuserName, StringbookName, Doubleprice) {

// 通过控制台的输出方式模拟购书

/*if (null == price || price <= 0) {

throw new PriceException("book price exception");

}*/

System.out.println(userName+" buy "+bookName+", spend "+price);

returntrue;

}

publicvoidcomment(StringuserName, Stringcomments) {

// 通过控制台的输出方式模拟发表书评

System.out.println(userName+" say:"+comments);

}

}

resource包

新建 spring.xml

用于 AOP 管理

​

前置通知

前置通知(org.springframework.aop.MethodBeforeAdvice)：在连接点之前执行的通知。

1）创建前置通知类

packagecom.zking.spring02_aop.advice;

​

importorg.springframework.aop.MethodBeforeAdvice;

​

importjava.lang.reflect.Method;

importjava.util.Arrays;

​

/**

* 前置通知

*/

publicclassBeforeAdviceimplementsMethodBeforeAdvice {

​

​

/**

* 前置通知

* @param method 目标方法

* @param params 目标所执行的参数

* @param target 目标对象

* @throws Throwable

*/

@Override

publicvoidbefore(Methodmethod, Object[] params, Objecttarget) throwsThrowable {

//1. 获取目标方法名

StringmethodName=method.getName();

//2. 获取 目标对象的 类的全路径名

StringclassPath=target.getClass().getName();

System.out.println("【前置通知】 "+classPath+"."+methodName+"执行参数："+Arrays.toString(params));//数组类型需要 转成字符串输出

}

}

2）创建spring.xml配置ProxyFactoryBean创建代理对象

Spring 能够基于 org.springframework.aop.framework.ProxyFactoryBean 类，根据目标对象的类型（是否实现了接口）自动选择使用 JDK 动态代理或 CGLIB 动态代理机制，为目标对象（Target Bean）生成对应的代理对象（Proxy Bean）

在

<?xmlversion="1.0" encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans " target="_blank">http://www.springframework.org/schema/beans/spring-beans.xsd">

​

<!--target 目标

目标：被通知（被代理）对象 注：执行具体业务逻辑的方法对象-->

<beanid="bookTarget"class="com.zking.spring02_aop.biz.BookBizImpl"></bean>

​

<!--Advice 通知

通知：在特定连接点上执行的动作 注：完成AOP面向切面编程-->

<!--前置通知-->

<beanid="before"class="com.zking.spring02_aop.advice.BeforeAdvice"></bean>

​

​

<!--代理（Proxy) = 通知+目标-->

<beanid="proxy"class="org.springframework.aop.framework.ProxyFactoryBean">

<!--需要注入原料：通知和 目标-->

<propertyname="target">

<!--引入 目标 target:被通知的目标对象-->

<refbean="bookTarget"/>

</property>

<propertyname="interceptorNames">

<!--引入 通知，可能有多个通知-->

<list>

<!--前置通知的 id-->

<value>before</value>

</list>

</property>

​

<!--代理对象需要实现的接口 proxyInterfaces:代理接口对象（List）-->

<propertyname="interfaces">

<list>

<!--接口的路径-->

<value>com.zking.spring02_aop.biz.IBookBiz</value>

</list>

</property>

</bean>

</beans>

ProxyFactoryBean 常用属性

属性

描述

target

需要代理的目标对象（Bean）

proxyInterfaces

代理需要实现的接口，如果需要实现多个接口，可以通过 <list> 元素进行赋值。

proxyTargetClass

针对类的代理，该属性默认取值为 false（可省略）, 表示使用 JDK 动态代理；取值为 true，表示使用 CGlib 动态代理

interceptorNames

拦截器的名字，该属性的取值既可以是拦截器、也可以是 Advice（通知）类型的 Bean，还可以是切面（Advisor）的 Bean。

singleton

返回的代理对象是否为单例模式，默认值为 true。

optimize

是否对创建的代理进行优化（只适用于CGLIB）。

3）测试代码

//示例2：前置通知

// 报错： Bean named 'proxy' is expected to be of type 'com.zking.spring02_aop.biz.BookBizImpl'

// but was actually of type 'com.sun.proxy.$Proxy4' -> 强转报错：不同类型不能转换

/*BookBizImpl proxy = ac.getBean("proxy",BookBizImpl.class);

proxy.buy("饭饭","撒野",145d);

proxy.comment("饭饭","丞哥无处不在");*/

​

/*Object proxy1 = ac.getBean("proxy");

System.out.println(proxy1.getClass()); //输出 class com.sun.proxy.$Proxy4*/

​

//请使用 接口接收 代理对象!!! 代理对象实现的是 接口

IBookBizproxy=ac.getBean("proxy", IBookBiz.class);

proxy.buy("饭饭","撒野",145d);

proxy.comment("饭饭","丞哥无处不在");

使用错误方式运行代码时，出现：
Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy4 cannot be cast to com.zking.spring02.dao.BookBizImpl
提示：无法将com.sun.proxy.$Proxy4 无法转换成com.zking.spring02.dao.BookBizImpl
请使用接口接收返回的代理对象！！！请使用接口接收返回的代理对象！！！请使用接口接收返回的代理对象！！！

后置通知

后置通知(org.springframework.aop.AfterReturningAdvice)：在连接点正常完成后执行的通知。

packagecom.zking.spring02_aop.advice;

​

importorg.springframework.aop.AfterReturningAdvice;

​

importjava.lang.reflect.Method;

importjava.util.Arrays;

​

/**

* 后置通知

*/

publicclassAfterAdviceimplementsAfterReturningAdvice {

/**

*

* @param returnValue 目标方法返回值

* @param method 目标方法

* @param params 目标方法执行参数

* @param target 目标对象

* @throws Throwable

*/

@Override

publicvoidafterReturning(ObjectreturnValue, Methodmethod, Object[] params, Objecttarget) throwsThrowable {

System.out.println("【后置通知】 "+target.getClass().getName()+"."+method.getName()+"执行参数："+Arrays.toString(params)+

"返回值："+returnValue);

}

}

环绕通知

环绕通知(org.aopalliance.intercept.MethodInterceptor)：包围一个连接点的通知，最大特点是可以修改返回值，由于它在方法前后都加入了自己的逻辑代码，因此功能异常强大。它通过MethodInvocation.proceed()来调用目标方法（甚至可以不调用，这样目标方法就不会执行）。

packagecom.zking.spring02_aop.advice;

​

importorg.aopalliance.intercept.MethodInterceptor;

importorg.aopalliance.intercept.MethodInvocation;

​

importjava.lang.reflect.Method;

importjava.util.Arrays;

​

/**

* 环绕通知

*/

publicclassAroundAdviceimplementsMethodInterceptor {

/**

*

* @param methodInvocation

* @return

* @throws Throwable

*/

@Override

publicObjectinvoke(MethodInvocationmethodInvocation) throwsThrowable {

//1. 获取 目标对象

Objecttarget=methodInvocation.getThis();

//2. 获取目标方法

Methodmethod=methodInvocation.getMethod();

//3. 获取目标方法的执行参数

Object[] params=methodInvocation.getArguments();

​

//执行目标方法，并返回结果（环绕通知能控制目标方法的执行）

ObjectreturnValue=methodInvocation.proceed();

​

System.out.println("【环绕通知】 "+target.getClass().getName()+"."+method.getName()+" 执行参数："

+Arrays.toString(params)+"返回值："+returnValue);

​

returnreturnValue;

}

}

异常通知

1）创建自定义异常类

publicclassPriceExceptionextendsRuntimeException {

publicPriceException() {

super();

}

publicPriceException(Stringmessage, Throwablecause, booleanenableSuppression, booleanwritableStackTrace) {

super(message, cause, enableSuppression, writableStackTrace);

}

publicPriceException(Stringmessage, Throwablecause) {

super(message, cause);

}

publicPriceException(Stringmessage) {

super(message);

}

publicPriceException(Throwablecause) {

super(cause);

}

}

2）设置异常抛出点

BookBizImpl 的买书方法

publicbooleanbuy(StringuserName, StringbookName, Doubleprice) {

// 通过控制台的输出方式模拟购书

if (null==price||price<=0) {

thrownewPriceException("book price exception");

}

System.out.println(userName+" buy "+bookName+", spend "+price);

returntrue;

}

3）定义异常通知

publicclassMyThrowsAdviceimplementsThrowsAdvice {

publicvoidafterThrowing(PriceExceptione) {

System.out.println("[异常通知] 价格异常，撤销订单！");

}

}

4）配置异常通知

<!-- 异常通知 -->

<beanid="myThrowsAdvice"class="com.zking.spring02.action.MyThrowsAdvice">

</bean>

<!--

代理：目标+通知

将目标和通知对象注入到代理工厂对象中

target:被通知的目标对象

proxyInterfaces:代理接口对象（List）

interceptorNames:需要应用到目标对象上的通知Bean的名字（List）

-->

<beanid="bookBiz"class="org.springframework.aop.framework.ProxyFactoryBean">

<propertyname="target">

<refbean="bookBizTarget"/>

</property>

<propertyname="proxyInterfaces">

<list>

<value>com.zking.spring02.dao.IBookBiz</value>

</list>

</property>

<propertyname="interceptorNames">

<list>

<value>myThrowsAdvice</value>

</list>

</property>

</bean>

适配器

<!-- 适配器=通知+切入点 通过正则表达式的方式对调用方法进行切入 -->

<beanid="regexpMethodPointcutAdvisor"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

<propertyname="advice"ref="myAfterReturningAdvice">

</property>

<!-- 定义规则 -->

<propertyname="patterns">

<value>.*buy</value>

</property>

</bean>

<!--

代理：目标+通知

将目标和通知对象注入到代理工厂对象中

target:被通知的目标对象

proxyInterfaces:代理接口对象（List）

interceptorNames:需要应用到目标对象上的通知Bean的名字（List）

-->

<beanid="bookBiz"class="org.springframework.aop.framework.ProxyFactoryBean">

<propertyname="target">

<refbean="bookBizTarget"/>

</property>

<propertyname="proxyInterfaces">

<list>

<value>com.zking.spring02.dao.IBookBiz</value>

</list>

</property>

<propertyname="interceptorNames">

<list>

<value>myMethodBeforeAdvice</value>

<!-- 将后置通知更换成适配器 -->

<value>regexpMethodPointcutAdvisor</value>

<value>myMethodInterceptor</value>

<value>myThrowsAdvice</value>

</list>

</property>

</bean>

​

完整代码

spring.xml

<?xmlversion="1.0" encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans " target="_blank">http://www.springframework.org/schema/beans/spring-beans.xsd">

​

<!--target 目标-->

<beanid="bookTarget"class="com.zking.spring02_aop.biz.BookBizImpl"></bean>

​

<!--Advice 通知-->

<!--前置-->

<beanid="before"class="com.zking.spring02_aop.advice.BeforeAdvice"></bean>

<!--后置-->

<beanid="after"class="com.zking.spring02_aop.advice.AfterAdvice"></bean>

<!--环绕-->

<beanid="around"class="com.zking.spring02_aop.advice.AroundAdvice"></bean>

<!--异常-->

<beanid="exception"class="com.zking.spring02_aop.advice.ExceptionAdvice"></bean>

​

<!-- 适配器： 切面= 通知+目标-->

<beanid="aspect"class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

<propertyname="advice">

<refbean="after"/>

</property>

<propertyname="pattern">

<value>.*buy</value>

</property>

<!-- <property name="patterns">

<value></value>

<value></value>

</property>-->

</bean>

​

​

<!--代理（Proxy) = 通知+目标-->

<beanid="proxy"class="org.springframework.aop.framework.ProxyFactoryBean">

<!--，需要注入原料：通知和 目标-->

<propertyname="target">

<!--引入 目标-->

<refbean="bookTarget"/>

</property>

<propertyname="interceptorNames">

<!--引入 通知，可能有多个通知-->

<list>

<!--前置通知的 id-->

<!--<value>before</value>-->

<!--后置-->

<!-- <value>after</value>-->

<!--环绕-->

<!--<value>around</value>-->

<!--异常-->

<value>exception</value>

<!--适配器-->

<value>aspect</value>

</list>

</property>

​

<!--代理对象需要实现的接口-->

<propertyname="interfaces">

<list>

<!--接口的路径-->

<value>com.zking.spring02_aop.biz.IBookBiz</value>

</list>

</property>

</bean>

</beans>

Demo.java

packagecom.zking.spring02_aop.util;

​

importcom.zking.spring02_aop.biz.BookBizImpl;

importcom.zking.spring02_aop.biz.IBookBiz;

importorg.springframework.context.ApplicationContext;

importorg.springframework.context.support.ClassPathXmlApplicationContext;

​

publicclassDemo {

​

// /j enter 方法注释

publicstaticvoidmain(String[] args){

//1. 什么是 AOP

//面向切面，“专心做事”

​

//2. 核心概念

//1) 连接点（JoinPoint): 程序执行过程中明确的点。例如：方法的调用、异常的抛出

//2) 通知（advice）： 公共行为，指拦截到 Joinpoint 之后要做的事情

//3) 目标（Target）： 核心代码，指代理的目标对象

//4) 代理（Proxy）： 将通知应用到目标上所创建的对象。 通知+目标=代理

//注：公共部分的代码是写在通知中的：只有完整的代理对象才具备 AOP的特性

//5) 切入点（PointCut) ：连接点的集合

//6) 切面（Aspect）：通知+切入点（限制条件）。 只有满足条件的目标对象，才将通知应用到目标上

​

//3. 通知分类:

ApplicationContextac=newClassPathXmlApplicationContext("spring.xml");//初始化 IOC容器

​

//示例：买书、书评

/* BookBizImpl bookBiz = ac.getBean("bookTarget",BookBizImpl.class);

bookBiz.buy("饭饭","撒野",145d);

bookBiz.comment("饭饭","丞哥无处不在");*/

​

//示例2：前置通知 //示例3：后置通知 //示例4：环绕通知 //示例5：异常通知

// 报错： Bean named 'proxy' is expected to be of type 'com.zking.spring02_aop.biz.BookBizImpl'

// but was actually of type 'com.sun.proxy.$Proxy4' -> 强转报错：不同类型不能转换

/*BookBizImpl proxy = ac.getBean("proxy",BookBizImpl.class);

proxy.buy("饭饭","撒野",145d);

proxy.comment("饭饭","丞哥无处不在");*/

​

/*Object proxy1 = ac.getBean("proxy");

System.out.println(proxy1.getClass()); //输出 class com.sun.proxy.$Proxy4*/

​

//请使用 接口接收 代理对象!!! 代理对象实现的是 接口

IBookBizproxy=ac.getBean("proxy", IBookBiz.class);

proxy.buy("饭饭","撒野",145d);

proxy.comment("饭饭","丞哥无处不在");

/*

方法的调用 -> 连接点

将通知应用到我的目标上 -> 代理对象

公共代码 -> 通知

*/

​

//示例6：适配器

//只有符合条件，才会输出

//比如：只有购买书籍，才可返利 2元，书评不可以获得

}

}

youdabi
关注
spring 之aop
03-06
标题中的“Spring 之AOP”指的是在Spring框架中对面向切面编程（Aspect-Oriented Programming，简称AOP）的使用。AOP是软件设计的一种模式，它将关注点分离，使得我们可以独立地处理系统中的交叉关注点，如日志、...
spring之AOP（动态代理）
09-06
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点分离，将横切关注点（如日志、事务管理、权限检查等）与核心业务逻辑解耦。AOP的核心概念是切面、通知、连接点、切入点和织入。在...
Spring之AOP适配器模式
波波烤鸭的博客
03-06 8603
  Spring架构中涉及了很多设计模式，本文来介绍下Spring中在AOP实现时Adapter模式的使用。AOP本质上是Java动态代理模式的实现和适配器模式的使用，关于这两种设计模式的具体介绍烦请参考我之前的文章 Java代理模式 Java适配器模式(adapter) 文章目录Spring中适配器模式一、AOP案例1.相关依赖2.创建目标对象3.创建通知4.配置文件5.测试二、适配器应用解...
Spring之AOP的详细讲解
tq02的博客
04-09 5505
本文讲解的是SpringAOP，将切点、切面、通知点，逐步剖析，代码举例，配合理解！
Spring之AOP日志记录
积跬步，至千里。
10-17 1637
在Java中，可以使用注解和切面技术来实现AOP（Aspect Oriented Programming）。AOP是一种编程范式，它通过将应用程序分解为关注点的模块来提高代码的可维护性和重用性。注解可以用于标记程序元素，例如类、方法和字段，以便切面可以识别和操作这些元素。
Spring之AOP注解开发
楠黎倾风的博客
11-25 1万+
Spring之AOP注解开发
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring之aop注解实现
qq_47455973的博客
02-28 3887
Spring中的AOP1.什么是AOP2.怎么实现AOP# 2.1AOP相关的注解介绍# 2.2实现AOP的xml配置# 2.3实现AOP# 2.4对相同切入点的公共化# 2.5设置多个增强类的优先级 1.什么是AOP Aop是java的spring框架中的一种特性，aop是面向切面编程的缩写，那什么是面向切面编程呢？ 面向切面编程就是，在不对源码进行修改的情况下对源码所实现的功能进行增强。 举例说明 原本一个程序可以实现用户登入的功能，然后我想在这个功能的基础上，加入一个新的功能，就是对用户等级的判断，按
Spring之AOP入门篇
楠黎倾风的博客
11-15 1万+
spring之AOP入门篇
Spring之AOP简介
weixin_43790613的博客
01-23 5079
文章目录定义AOP 的作用及优势 定义 AOP： 全称是 Aspect Oriented Programming 即： 面向切面编程 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强 AOP 的作用及优势 作用：在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码 提高开发效率 维护方便 实现方式 使用动态代理技术 ...
Spring之AOP的原理(一)--概述
IT利刃出鞘的博客
11-18 5102
本文介绍Spring中的AOP的原理。
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
Mybatis
庸不易的博客
11-15 652
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 448
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot(五)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 919
Rest请求处理
什么是面向对象编程？什么是面向过程编程？
m0_70208894的博客
11-15 501
不同的编程范式适用于不同的场景，选择合适的范式可以提高代码的可维护性、可读性和效率。Java 和 Go 的选择反映了不同的设计哲学，Java 更加注重封装和对象的使用，而 Go 更加简洁，强调过程和函数的使用。
【JavaSE线程知识总结】
最新发布
qq_63713328的博客
11-16 726
本章主要讲解了线程几种线程的创建方式,线程安全问题出现的场景,以及线程安全的解决方式
java加锁问题详解
qq_74056922的博客
11-14 754
java(JVAM)对加锁的API进行了封装,通过使用synchronized关键字来完成加锁操作。
HashMap源码分析下
L25000的专栏
11-16 548
如果这个cap刚好是2的幂次方呢，即4,8,16,32,64等这样的，这样的数已经满足条件了，再减去1，把数变成3,7,31,63。，即hash值的第5为是1，这样在扩容到32后，取索引得出来的结果就和16的不一样了，索引位置比oldCap大了一个oldCap值；,求余数，n是一个2的幂次方数，减去1，即后面全是1，前面全是0，与上这个hash，只能保证经过运算，结果都会在。，即hash值的第5为是0，这样在扩容到32后，取索引得出来的结果还是和16的一样；cap=1，2的0次方就等于1，返回的是就是4。
Spring框架AOP初学者指南
这使得Spring框架成为企业级Java应用中的首选框架之一。 在实际应用中，Spring AOP支持多种通知类型，包括前置通知（Before）、后置通知（After）、返回后通知（After Returning）、异常后通知（After Throwing）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

youdabi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值