Aop和动态代理的使用

已于 2022-07-08 08:35:28 修改
阅读量321 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
于 2022-07-08 08:34:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44720982/article/details/125665762
版权

1.问题提出:

在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。
虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，
但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。
这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。
这不但增加了开发人员的工作量，而且提高了代码的出错率。

2.解决办法

 (1)抽取个方法。如果方法很多，还需要在很多地方调用。
 (2)动态代理: 实现方式有两种:
 		 [1]JDK原生动态代理----缺点:必须基于接口完成 
 		 [2]cglib动态代理
  (3)AOP面向切面编程：AOP的底层实现就是基于动态代理。

3.动态代理解决问题

3.1 JDK原生动态代理

（我们仅仅建立一个maven工程不需要web即可）
第一步：建立一个接口及实现类

public interface MathService {

    public double add(double a, double b);

    public double sub(double a, double b);

    public double mul(double a, double b);

    public double div(double a, double b);
}

public class MathServiceImpl implements MathService {
    public double add(double a, double b) {
        double result=a+b;
        return result;
    }

    public double sub(double a, double b) {
        double result=a-b;
        return result;
    }

    public double mul(double a, double b) {
        double result=a*b;
        return result;
    }

    public double div(double a, double b) {
        double result=a/b;
        int c = 2/0;
        return result;
    }
}

第二步：创建代理类

public class ProxyFactory {
    //被代理对象
    private Object target;

    public ProxyFactory(Object object) {
        this.target = object;
    }
    //获取代理对象
    /**
     * ClassLoader loader, 被代理对象的类加载器
     * Class<?>[] interfaces, 被代理对象实现的接口
     * InvocationHandler h: 当代理对象执行被代理的方法时，会触发该对象中的invoke功能
     */
    public Object getProxy(){
        /*固定语法*/
        ClassLoader loader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();

        InvocationHandler h = new InvocationHandler(){
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /*这里是运行之前执行 method.getName() 得到方法名 Arrays.asList(args)转化为能看的懂的数组   */
                System.out.println(method.getName()+"\nbefore=========="+ Arrays.asList(args)); //根据个人写自己的业务需求
                Object result = method.invoke(target, args);//代理对象回调该方法 固定写法
                /*运行之后执行*/
                System.out.println("after======="); //根据个人写自己的业务需求
                return result;
            }
        };
       return  Proxy.newProxyInstance(loader,interfaces,h);
    }
}

第三步:测试

public class Test {
    public static void main(String[] args) {
        MathServiceImpl mathService = new MathServiceImpl();
        ProxyFactory proxyFactory = new ProxyFactory(mathService);
        MathService proxy = (MathService)proxyFactory.getProxy();
        Object r = proxy.add(5, 6);
        System.out.println(r);
    }
}

运行结果
在这里插入图片描述
所以在不修改源代码的情况下 可以加入自己想加入的业务需求

3.2 cjlib动态代理

步骤:第一步 引入依赖

 		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>repMaven.cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.5</version>
        </dependency>

第二步：创建代理工厂

/**
 *    （1）引入cglib的jar包.
 *    (2)创建一个代理类工厂并实现接口MethodInterceptor
 **/
public class ProxyFactory  implements MethodInterceptor {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }
    //获取代理对象
    public Object getProxy(){
        Enhancer enhancer=new Enhancer();
        //指定被代理对象的父类
        enhancer.setSuperclass(target.getClass()); 
        //指定回调类
        enhancer.setCallback(this);
        //创建代理对象
        return enhancer.create();
    }

    //当代理对象执行代理方法时触发的方法
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("before*************************");//这里书写自己的业务代码
        Object r = method.invoke(target, args);//固定写法
        System.out.println("after===========================");//这里书写自己的业务代码
        return r;
    }
}

第三步：测试

public class Test {
    public static void main(String[] args) {
        MathServiceImpl mathService=new MathServiceImpl();
        ProxyFactory proxyFactory=new ProxyFactory(mathService);
        MathServiceImpl proxy = (MathServiceImpl) proxyFactory.getProxy();
       Object r= proxy.sub(10,5);
        System.out.println(r);
    }
}

在这里插入图片描述
两者区别:cjlib可以不实现接口 但jdk必须要实现接口

3.3 AOP动态代理
AOP(Aspect-Oriented Programming, 面向切面编程): 
是一种新的方法论, 是对传统 OOP(Object-OrientedProgramming, 面向对象编程)的补充.

AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点在应用 AOP 编程时, 
仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 
以什么方式应用, 并且不必修改受影响的类. 
这样一来横切关注点就被模块化到特殊的对象(切面)里.

AOP 的好处: 每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级 业务模块更简洁, 
只包含核心业务代码.

AOP中的方法
	before 目标方法执行前执行，前置通知
	after 目标方法执行后执行，后置通知
	afterReturning 目标方法返回时执行 ，后置返回通知
	afterThrowing 目标方法抛出异常时执行 异常通知
	around 在目标函数执行中执行，可控制目标函数是否执行，环绕通知

步骤
（1）引入依赖

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>
         <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>

（2）修改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:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
       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 http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--包扫描-->
    <context:component-scan base-package="com.wx" />
    <!--开启切面驱动-->
    <aop:aspectj-autoproxy />
</beans>

（3）创建代理工厂

/*这里注解必须要加 因为要交给spring管理 所以在service层 还要加上@Service*/
@Component
@Aspect
public class ProxyFactory  {

    /*目标方法之前调用执行*/
    @Before(value = "execution(* com.wx.service.impl.MathServiceImpl.add(..))")
    public void MathBefore(){
        System.out.println("before=====");
    }

    /*目标方法之后调用执行*/
    @After(value = "execution(* com.wx.service.impl.MathServiceImpl.add(..))")
    public void MathAfter(){
        System.out.println("after=====");
    }

    /*有异常的时候调用执行*/
    @AfterThrowing(value = "execution(* com.wx.service.impl.MathServiceImpl.div(..))")
    public void MathAfterThrowing(){
        System.out.println("afterThrowing=====");
    }

    //有返回值的时候调用
    @AfterReturning(value = "execution(* com.wx.service.impl.MathServiceImpl.*(..))",returning = "r")
    public void MathAfterReturning(JoinPoint joinPoint,Object r){
        Object[] args = joinPoint.getArgs();
        System.out.println("参数:"+ Arrays.asList(args));
        System.out.println(r);
        System.out.println("AfterReturning=====");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        MathService ms = (MathService)app.getBean("mathServiceImpl");
        //System.out.println(ms.div(2, 5));
        //System.out.println(ms.div(2,0));
        double add = ms.mul(1, 2);
        System.out.println(add);
    }
}

AOP的底层实现就是基于动态代理。

最不会程序的程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态代理（AOP）
weixin_70676044的博客
03-28 1772
AOP（Aspect Oriented Programming）即面向切面编程，是一种编程思想和技术。在传统的编程中，我们会将系统的业务逻辑分散在各个模块或类中，导致代码重复、难以维护。而 AOP 则通过将系统的横切关注点（如日志、事务、安全等）抽取出来，形成一组切面，然后将这些切面应用到系统中的多个模块或类中，从而实现了代码的复用和解耦。
Spring框架学习三AOP动态代理
Q53100的博客
03-29 636
代理模式是GOF23设计模式之一，代理模式中存在代理者和被代理者，代理者和被代理者都具有相同的功能，并且代理者执行功能时会附加一些额外的操作如：手机工厂和代理商都具有卖东西的功能，手机代理商除了帮工厂卖手机外，还能在卖手机前打广告推销，卖手机后还可以进行售后服务代理者和被代理者都实现了相同的接口（或继承相同的父类）代理者包含了一个被代理者的对象调用功能时，代理者会调用被代理者的功能，同时附加新的操作。
AOP动态代理
qq_50896786的博客
07-06 4476
目录1.IOC、AOP概念2.为何使用动态代理2.1 JDK原生动态代理 2.1.1 MathService接口类2.1.2 MathServiceImpl实现接口类2.1.3 ProxyFactory动态代理工厂2.1.4 测试类2.2 cglib动态代理 2.2.1 MathServiceImpl类2.2.2 ProxyFactory动态代理工厂2.2.3 测试类3.AOP动态代理3.1 添加对应依赖3.2 配置spring.xml文件3.3 MathService接口类 3.4 MathService
动态代理--基础--04--AOP
最新发布
zhou920786312的博客
05-01 28
在Spring中的before织入。负责递归调用所有的拦截的织入。
AOP&SpringAOP&两种动态代理
逐梦苍穹的博客
08-13 716
本文介绍AOP思想及其底层两种动态代理实现方式
AOP的动态代理
weixin_46075209的博客
04-17 1995
本文主要介绍的是spring的核心功能AOP中的动态代理，分别介绍了CGLIB和JDK的动态代理，希望能对各位小伙伴有帮助
动态代理和AOP
weixin_70647138的博客
03-30 138
动态代理有两种类型：基于接口的动态代理和基于类的动态代理。基于接口的动态代理需要目标对象实现一个或多个接口，而基于类的动态代理则需要目标对象继承一个或多个类。在Java开发中如果一个类中的方法在基本功能之外需要进行功能扩充或者功能增强，如：事务控制、权限判断、日志记录等等操作，此时可以使用动态代理机制。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Spring AOP里的静态代理和动态代理用法详解
08-18
Spring AOP里的静态代理和动态代理用法详解 Spring AOP里的静态代理和动态代理用法详解是关于 Spring AOP里的静态代理和动态代理的详细介绍。代理是一种设计模式，通过创建一个代理对象来控制对委托类对象的直接...
Spring框架+SpringAOP动态代理
03-22
Spring AOP 使用的动态代理主要有两种方式：JDK 动态代理和 CGLIB 代理。 JDK 动态代理：用于代理实现了接口的类。Spring 会使用 java.lang.reflect.Proxy 类来创建代理对象。 CGLIB 代理：用于代理没有实现接口的...
spring之AOP（动态代理）
09-06
在Spring中，AOP主要通过两种动态代理技术实现：JDK动态代理和CGLIB动态代理。 首先，让我们详细了解一下JDK动态代理。JDK动态代理基于Java的接口实现，它适用于目标对象实现了至少一个接口的情况。在运行时，JDK...
springAOP配置动态代理实现
03-28
综上所述，通过理解Spring AOP的配置和动态代理机制，我们可以灵活地在项目中添加横切关注点，提升代码的模块化和可维护性。在实际开发中，结合使用XML配置、注解配置以及适当的动态代理策略，可以使AOP功能更好地...
Spring AOP与动态代理
12-22
Spring AOP提供了两种动态代理方式：JDK动态代理和CGLIB动态代理。 1. **JDK动态代理**：适用于目标类实现了接口的情况。JDK动态代理通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口...
动态代理及AOP
hongto57的专栏
07-17 1370
动态代理 AOP：面向切面编程。
SpringAOP动态代理的实现和原理
一个后端菜鸟的博客
11-26 1769
AOP .常见面试题 说下你对Spring AOP理解 基于Java的AOP实现有哪些？AspectJ,Spring AOP,JBoss AOP AOP的使用场景： 权限，错误处理，记录跟踪 优化 校准，同步，事务 动态代理 动态代理有以下特点: 1.代理对象：必须实现接口 2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对 象/目标对象实现的接口的类型) 相关的类和接口： java.lang.reflect.Proxy：这是 Java 动态代理机制的主类
Spring-AOP的基本介绍以及通过先动态代理方式实现
业精于勤，荒于嬉
05-02 1105
里面有一个方法run@OverrideSystem.out.println("交通工具开始运行了...");System.out.println("小汽车在公路 running..");System.out.println("交通工具停止运行了...");@OverrideSystem.out.println("交通工具开始运行了...");System.out.println("大轮船在水上 running..");System.out.println("交通工具停止运行了...");
细说Spring——AOP详解和动态代理
m0_68758365的博客
03-28 883
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP与动态代理
weixin_61605998的博客
09-02 86
AOP和动态代理是两种不同的技术，它们在实现方式和使用场景上有所区别。AOP适用于横切关注点的模块化处理，而动态代理适用于在方法调用前后添加额外逻辑的情况。在Java开发中，可以根据具体需求选择使用AOP或动态代理。
【Spring04】Aop动态代理的使用和原理
qq_42247619的博客
08-30 1077
AOP动态代理的使用及其@EnableAspectJAutoProxy 开启AOP切面自动代理功能及其实现原理
AOP的动态代理和静态代理
08-19
AOP（面向切面编程）可以使用动态代理和静态代理来实现增强功能。动态代理是在内存中临时生成一个AOP对象，该对象包含了目标对象的全部方法，并在特定的切点做了增强处理，并回调目标对象的方法。JDK动态代理和cglib动态代理是常用的动态代理方式。JDK动态代理要求被代理的类必须实现接口，而cglib动态代理则是面向类代理，判断被代理的类是否有实现接口，如果实现了接口就采用JDK动态代理，如果没有实现接口就采用cglib动态代理。 对于动态代理，Spring AOP使用的是动态代理。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [AOP静态代理与动态代理](https://blog.csdn.net/L_Dream_IT/article/details/107035717)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值