五.AOP

于 2021-08-25 15:39:04 发布
阅读量127 收藏
点赞数 2
分类专栏： Spring Framework 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JACKEYLLLLLOVE/article/details/119912051
版权

代理的类型分为两种，一种为静态代理，一种为动态代理。代理的目的是为了在切面上扩展业务，而不用改变原来的功能模块，具有很高的延伸性，但是代码量会增加两倍甚至更多。

1.静态代理

    静态代理如下代码所示：

interface Shopping {
    void buy();
}

class Client implements Shopping {
    public void buy() {
        System.out.println("我想买这件商品");
    }
}

class StaticProxy implements Shopping {
    private Shopping shopping;

    public StaticProxy(Shopping shopping) {
        this.shopping = shopping;
    }

    public void buy() {
        System.out.println("降价促销，疯狂大甩卖了！");
        shopping.buy();
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        Client client = new Client();
        StaticProxy service = new StaticProxy(client);
        service.buy();
    }
}

2.动态代理

    动态代理需要通过创建继承了InvocationHandler接口的类，通过使用这个类，来创建代理，该类的代码如下：

package AOP;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler{

	private Object target;
	
	public void setTarget(Object target)
	{
		this.target=target;
	}
	
	public Object getProxy()
	{
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		Object result=method.invoke(target, args);
		return result;
	}
     
}

该类使用到了两个特征明显的方法，分别是Proxy.newProxyInstance()和method.invoke().

其中Proxy.newProxyInstance()有三个传递参数，分别为：

1.loader：该类加载器

2.interface:目标类实现的接口

3.invocationHadler:该处理器

关于Invoke方法，相当于省略了静态代理时还要重写的方法，用到了JAVA的反射机制。具体的内容看：

JAVA的Invoke方法_JACKEYLLLLLOVE的博客-CSDN博客

3.SpringAOP的配置文件

在使用AOP之前要引入一个aspectjweaver包，暂时不知道干什么的。

相应地址https://mvnrepository.com/。

<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

4.SpringAOP的基本信息

相应信息如下：

SpringAOP,通过Advice定义横切逻辑，Spring中支持五种类型的Advice.

 即Aop在不改变原有代码的情况下，去增加新的功能。

5.使用Spring实现AOP

实例类：

package SpringAop;

import org.springframework.stereotype.Component;

@Component
public class UserServiceImp implements UserService{

	@Override
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("添加了一个用户");
	}

	@Override
	public void delete() {
		// TODO Auto-generated method stub
		System.out.println("删除了一个用户");
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("更新了信息");
	}

	@Override
	public void select() {
		// TODO Auto-generated method stub
		System.out.println("选择了一个用户");
	}

}

 方式一：使用Spring的接口。

相关日志类代码如下：

package SpringAop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.stereotype.Component;

@Component
public class Log implements MethodBeforeAdvice{

	@Override
	//method:要执行的目标对象的方法
	//args:参数
	//target:目标对象
	public void before(Method method, Object[] args, Object target) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
	}

}

package SpringAop;
import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.stereotype.Component;

@Component
public class AfterLog implements AfterReturningAdvice{

	@Override
	//returnValue:返回值
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("执行了"+method.getName()+"方法.返回结果为"+returnValue);
	}

}

配置文件如下：

<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
 
  <!-- 使用注释<context:component-scan base-package="SpringAop"/> -->
    <bean id="log" class="SpringAop.Log"></bean>
    <bean id="afterLog" class="SpringAop.AfterLog"></bean>
    <bean id="userService" class="SpringAop.UserServiceImp"></bean>
     
     <!-- 方式一：使用Spring原生的API -->   
     <!-- 配置AOP -->
    <aop:config>
       <!-- 切入点:expression:表达式;execution():要执行的位置：-->
       <aop:pointcut id="point" expression="execution(* SpringAop.UserServiceImp.*(..))"/>
       <!-- 执行环绕 -->
       <aop:advisor advice-ref="log" pointcut-ref="point"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="point"/>
    </aop:config>
          

</beans>

方式二：使用自定义类实现切面。

自定义类如下：

package SpringAop;

public class DivPointCut 
{
	public void before()
	{
		System.out.println("----方法执行前----");
	}
	public void after()
	{
		System.out.println("----方法执行后----");
	}

}

Spring配置文件如下：

<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
 
  <!-- 使用注释<context:component-scan base-package="SpringAop"/> -->
    <bean id="log" class="SpringAop.Log"></bean>
    <bean id="afterLog" class="SpringAop.AfterLog"></bean>
    <bean id="userService" class="SpringAop.UserServiceImp"></bean>
     
     <!-- 方式一：使用Spring原生的API -->   
     <!-- 配置AOP -->
    <!-- <aop:config>
       切入点:expression:表达式;execution():要执行的位置：
       <aop:pointcut id="point" expression="execution(* SpringAop.UserServiceImp.*(..))"/>
       执行环绕
       <aop:advisor advice-ref="log" pointcut-ref="point"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="point"/>
    </aop:config> -->
    
    <!--方法二：自定义类 -->
    <bean id="diy" class="SpringAop.DivPointCut "></bean>
      
    <aop:config>
    <!-- 自定义切面，ref要引用的类 -->
      <aop:aspect ref="diy">
      <aop:pointcut id="point" expression="execution(* SpringAop.UserServiceImp.*(..))"></aop:pointcut>
      <aop:before pointcut-ref="point" method="before()"/>
      <aop:after pointcut-ref="point" method="after()"/>
      </aop:aspect>
    </aop:config>    

</beans>

方式三：使用注解实现AOP

Spring配置文件如下：

<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
 
  <!-- 使用注释<context:component-scan base-package="SpringAop"/> -->
    <bean id="log" class="SpringAop.Log"></bean>
    <bean id="afterLog" class="SpringAop.AfterLog"></bean>
    <bean id="userService" class="SpringAop.UserServiceImp"></bean>
     
     <!-- 方式一：使用Spring原生的API -->   
     <!-- 配置AOP -->
    <!-- <aop:config>
       切入点:expression:表达式;execution():要执行的位置：
       <aop:pointcut id="point" expression="execution(* SpringAop.UserServiceImp.*(..))"/>
       执行环绕
       <aop:advisor advice-ref="log" pointcut-ref="point"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="point"/>
    </aop:config> -->
    
    <!--方法二：自定义类 -->
    <!-- <bean id="diy" class="SpringAop.DivPointCut "></bean>
      
    <aop:config>
    自定义切面，ref要引用的类
      <aop:aspect ref="diy">
      <aop:pointcut id="point" expression="execution(* SpringAop.UserServiceImp.*(..))"></aop:pointcut>
      <aop:before pointcut-ref="point" method="before()"/>
      <aop:after pointcut-ref="point" method="after()"/>
      </aop:aspect>
    </aop:config>     -->
    
        <!--方法三：自定义类 -->
     <bean id="anotationPointCut" class="SpringAop.AnotationPointCut"></bean>  
     <!-- 开启注释支持 JDK(默认 proxy-target-class="false" cglib("true")) -->
     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

相应的实现代码如下：

package SpringAop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//方式三：使用注解方式实现AOP

@Aspect //标记这个类是一个问题
public class AnotationPointCut 
{
	@Before("execution(* SpringAop.UserServiceImp.*(..))")
	public void before()
	{
		System.out.println("----方法执行前----");
	}
	@After("execution(* SpringAop.UserServiceImp.*(..))")
	public void after()
	{
		System.out.println("----方法执行后----");
	}
	//在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
	@Around("execution(* SpringAop.UserServiceImp.*(..))")
	public void around(ProceedingJoinPoint jp) throws Throwable
	{
		System.out.println("环绕前");
		System.out.println(jp.getSignature());//获得签名
		//执行方法
		Object proceed=jp.proceed();
		System.out.println("环绕哦后");
	}

}

「已注销」
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前后端分离之后台代码以及多模块
weixin_45624614的博客
01-05 576
前后端分离之后台代码以及多模块 1.多模块 多模块可以减少代码的耦合度 多模块方便程序员有针对的改对应的代码块，减少排错和找错的事件 多模块可以将每一部分的模块打包直接扔给菜鸟 2.多模块的实现 根据项目的大小，可以将项目分成不同数量的模块 我在这里将模块分为: base-util：所有公共的工具类放入这里,如pageResult AjaxResult base-core:所有公共的代码放入...
com.springsource.org.aopalliance-1.0.0.jar.zip
08-15
五、实际应用示例 在Spring配置中，我们可以通过`<aop:config>`标签来定义切面，然后使用`<aop:advisor>`或`<aop:aspect>`来指定拦截器。例如： ```xml <aop:config> <aop:aspect id="loggingAspect" ref=...
Spring 框架的 AOP
王佳龙的博客
07-27 207
目录 Spring 框架的 AOP 一、Spring 中基于 AOP 的 XML架构   二、Spring 中基于 AOP 的 @AspectJ Spring 框架的 AOP Spring 框架的 AOP Spring 框架的一个关键组件是面向方面的编程(AOP)框架。面向方面的编程需要把程序逻辑分解成不同的部分称为所谓的关注点。跨一个应用程序的多个点的功能被称为横切关注点，这些横切关...
Spring-AOP详解及其使用
qq_43828345的博客
11-06 1204
Spring-AOP 1、AOP 基本概念 （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。​ （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能​ （3）使用登录例子说明 2、AOP（底层原理） ​ a）AOP 底层使用动态代理 ，动态代理有两种情况： 第一种 有接口情况，使用 JDK 动态代理 ；创建接口实现类代理对象，增强类的方法 第二种 没有接口情况，使用 CGLIB 动态
Spring5——AOP介绍
仰望与追逐的博客
08-09 1150
Spring5——AOP介绍1、AOP（概念）2、AOP（底层原理）3、AOP（JDK 动态代理）4、AOP（术语）5、AOP 操作（准备工作）6、AOP 操作（基于AspectJ 注解）7、AOP 操作（基于AspectJ 配置文件） 1、AOP（概念） 1、什么是 AOP （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 （3）使用
5、AOP原理
kaoa000的专栏——非淡泊无以明志，非宁静无以致远
02-08 1285
aop编程 aop（aspect oriented programming）——面向切面（方面）编程，是对所有对象或者是一类对象编程，核心是（在不增加代码的基础上，还增加新功能） 汇编（伪机器指令）面向机器，c语言（面向过程）系统软件（操作系统，数据库，杀毒软件，防火墙...），java语法（面向对象->类-对象），面向切面 spring（->aop）面向n多对象编程 aop特别提醒：aop
org.aopalliance.aop.Advice.jar
11-28
《深入理解Spring AOP：基于org.aopalliance.aop.Advice.jar的分析》 在Java世界中，Spring框架以其强大的功能和灵活的设计理念深受广大开发者喜爱。在Spring框架中，AOP（面向切面编程）是其核心特性之一，它提供...
org.springframework.aop
03-14
《Spring框架中的AOP模块详解》 在Java开发领域，Spring框架以其强大的功能和灵活性而备受推崇。在Spring框架中，AOP（Aspect Oriented Programming，面向切面编程）是其核心特性之一，它允许开发者将关注点从主...
spring_aop4.rar_aop4.com
09-19
- 通知是在特定连接点上执行的代码，有五种类型：前置通知（Before）、后置通知（After）、返回后通知（After Returning）、异常后通知（After Throwing）和环绕通知（Around）。这些通知可以使用`@Before`、`@...
springAOP.docx
04-16
Spring AOP提供了五种类型的Advice： 1. **Before**：在目标方法执行前运行，但无法阻止方法执行。 2. **After**：在目标方法执行后运行，无论方法是否正常结束，无法改变方法的结果。 3. **After Returning**：在...
spring3.0.5的aop使用
03-20
NULL 博文链接：https://phl.iteye.com/blog/871022
SpringAop.zip
11-23
本资料包"SpringAop.zip"包含了关于如何使用Spring AOP进行业务实现的相关资源。 在Spring AOP中，核心概念包括切面（Aspect）、连接点（Join Point）、通知（Advice）、引入（Introduction）、目标对象（Target ...
springaop.zip
07-17
在本示例中，"springaop.zip" 包含了一个使用XML配置的Spring AOP应用实例，可以直接运行，配合相关的博客文章学习效果更佳。 在Spring AOP中，我们首先需要了解几个核心概念： 1. **切面（Aspect）**：切面是关注...
SpringAOP.rar_springAOP
09-23
五、总结 Spring AOP通过将关注点分离，提升了代码的可读性和可维护性，简化了复杂系统的管理。理解并熟练运用Spring AOP，能够让我们编写出更加优雅、高效的企业级应用。在实际开发中，根据需求选择合适的实现方式...
spring - aop.zip
06-10
Spring支持五种类型的建议：前置通知（Before）、后置通知（After）、返回后通知（After Returning）、异常后通知（After Throwing）和环绕通知（Around）。 3. 连接点（Join Point）：连接点是在程序执行过程中...
手撕Spring5框架（五）AOP介绍
路人甲的专栏
09-01 389
基本概念 AOP,面向切面编程,利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要意图 将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。 核心思想：不通过修改源代码方式添加新功能。 实际案例分享： 例如我们现在有一个用户登录的功能，现在需要增加一个新的功能，就是登录完成
SPRING系列五之 AOP
jeysine的博客
03-30 208
AOP概念AOP说简单点就是将与业务不相关的代码进行分离，例如日志，权限，事务处理等。降低业务实现与不相关功能的耦合性，提高代码的重用性和易于维护，便是AOP所要做的事情。Java代理机制先不使用AOP，看看传统的Java代理机制，代码如下。（1）编写一个日志信息的代理类，实现InvocationHandler接口 编写一个业务接口，并实现这个接口。 import java.lang.ref
spring入门学习-5、AOP概念及特点
u013424033的博客
12-07 557
什么是AOP AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。 在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)。 AOP利用称为“横切”的技术剖解开封装的对象内部，并将那些影响了多个类的公共行为封...
【spring 5】AOP：spring中对于AOP的的实现
该怎么解释？我懒得解释
07-18 1242
在前两篇博客中，介绍了AOP实现的基础：静态代理和动态代理，这篇博客介绍spring中AOP的实现。 一、采用Annotation方式 首先引入jar包：aspectjrt.jar && aspectweaver.jar applicationContext配置文件： <beans xmlns="http://www.springframework.org/schema/beans"
Spring AOP实现原理
最新发布
03-30
Spring AOP支持五种通知类型：前置通知、后置通知、返回通知、异常通知和环绕通知。 3. 代理对象：Spring AOP使用代理对象来实现切面。代理对象包括静态代理和动态代理两种方式。Spring AOP使用JDK动态代理和CGLIB...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值