java动态代理

最新推荐文章于 2024-11-09 12:43:52 发布
最新推荐文章于 2024-11-09 12:43:52 发布
阅读量775 收藏 21
点赞数 18
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60842098/article/details/135999170
版权
本文介绍了Java中的代理模式，包括静态代理和动态代理（JDK动态代理与CGLib），探讨了它们的原理、作用、分类以及在实际开发中的应用，如通过Maven创建项目并实现明星演唱会代理场景。
摘要由CSDN通过智能技术生成

相关笔记（先学maven，一下项目都是通过maven创建的）

maven笔记

动态代理讲义.doc

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.代理模式

目标对象不可访问，通过代理对象进行访问，而且增强式的访问，适当进行业务的扩展

生活中:
房东 ===>目标对象
房屋中介 ===>代理对象
你,我 ===>客户端对象

服务生产厂 ===>目标对象
门店(旗舰店) ===>代理对象
你,我 ===>客户端

开发中:
运营商(电信,移动,联通) ====>目标对象
第三方公司 ====>代理对象
开发的应用程序需要发送短信的功能 ===>客户端

开发的应用程序需要支付的功能

2.代理模式的作用

  1. 控制目标对象的访问

  2. 增强功能（主要功能由目标对象实现，附加功能由代理对象实现）

3.代理模式的分类

  1. 静态代理

  2. 动态代理，又分为JDK动态代理和 CGLib动态代理(子类代理)

4.什么是静态代理

它是代理模式的一种.

它具备以下特点:

  1. 目标对象和代理对象实现同一个业务接口
  2. 目标对象必须实现接口
  3. 代理对象在程序运行前就已经存在
  4. 能够灵活的进行目标对象的切换，却无法进行功能的灵活处理(使用动态代理解决此问题)
5.静态代理实现

业务功能:请明星进行节目表演.

  • 明星刘德华:目标对象(无法直接访问)

  • 刘德华助理:代理对象(我们可以访问，他可以跟明星对接)

  • 我们：客户端对象

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

代码实现

项目路径

image-20231214193218546

通过maven创建 java工程：quickstart（具体见maven笔记）

  1. 业务接口Service

    public interface Service {
    //规定的唱歌的业务功能
    void sing();
}

  2. 目标对象:

    /**

	目标对象:刘德华, 周润发。实现业务接口中的功能,进行唱歌表演
 */
public class SuperStarLiu implements Service {
    @Override
    public void sing() {
        System.out.println("我是刘德华,我正在表演唱歌............");
    }
}

public class SuperStartZhou implements Service {
    public void sing() {
        System.out.println("周润发正在唱歌");
    }
}

  3. 代理对象：

    public class Agent implements Service {
    //类中的成员变量设计为接口
    public Service target;  //目标对象

    //传入目标对象,方法的参数设计为接口(实现多态，以后不管目标对象有多少个都能用一行代码实现，不必单独为每个目标对象创建实例)
    public Agent(Service target){
        this.target = target;
    }

    @Override
    public void sing() {
        System.out.println("预订时间..........");
        System.out.println("预订场地..........");

        //切记切记:业务功能必须由目标对象亲自实现
        //        SuperStarLiu liu = new SuperStarLiu();
        //        liu.sing();
        //
        //        SuperStarZhou zhou = new SuperStarZhou();
        //        zhou.sing();
        //面向接口编程:调用时,接口指向实现类
        target.sing();

        System.out.println("结算费用..........");
    }
}

  4. 客户端对象

    public class MyTest{
    @Test
    public void testAgent1(){
        //测试功能
        //        SuperStarLiu liu = new SuperStarLiu();
        //        liu.sing();
        //        Agent agent = new Agent();
        //        agent.sing();

        //有接口和实现类,必须使用接口指向实现类(规范)
        Service agent = new Agent();
        agent.sing();
    }
    
    @Test
    public void testAgent2(){
        //测试功能
        //        SuperStarLiu liu = new SuperStarLiu();
        //        liu.sing();
        //        Agent agent = new Agent();
        //        agent.sing();

        //有接口和实现类,必须使用接口指向实现类(规范)
        Service agent = new Agent(new SuperStartZhou());
        //Service agent = new Agent(new SuperStartLiu());
        agent.sing();
    }
}
6.面向接口编程(重要)

类中的成员变量设计为接口

方法的形参设计为接口

方法的返回值设计为接口

调用时接口指向实现类（多态，动态绑定）【父类指向子类 father a = new son();】

===》如第5节中的 Service 接口

【在项目中表现为多建了一个 SuperStarZhou 类实现 Service接口，如果要调用该类的对象，必须在代理对象中 new 该类对象，这样没办法 灵活的进行目标对象的切换，于是就采取了上述的步骤，得到新的 代理对象 代码如第5节】

7.动态代理

静态代理的弊端：当 我们在 Service 接口中添加新的功能（方法）时，所有实现该接口的类必须重写该方法（目标对象，代理对象），则 就需要更改很多地方，程序失去了灵活性。所以我们需要动态代理

代理对象在程序运行的过程中动态在内存构建。可以灵活的进行业务功能的切换.

8.JDK动态代理
  1. 目标对象必须实现业务接口（与静态代理相同）
  2. JDK代理对象不需要实现业务接口（与静态代理不同）
  3. JDK动态代理的对象在程序运行前不存在，在程序运行时动态的在内存中构建
  4. JDK动态代理能够灵活的进行业务功能的切换
  5. 目标对象类中的方法(非接口中的方法)不能被代理
9.JDK动态代理用到的类和接口

它是使用现在的工具类完成JDK动态代理的实现.

  • Proxy 生成动态代理对象.
  • Method 进行目标对象的方法的反射调用
  • InvocationHandle 实现代理和业务功能的

  1. Proxy类

    它是java.lang.reflect.Proxy包下的类.

    它有一个方法Proxy.newProxyInstance(…)专门用来生成动态代理对象.

      public static Object newProxyInstance(ClassLoader loader,  // 类加载器
           Class<?>[] interfaces,  // 目标对象实现的所有接口，泛型数组
           InvocationHandler h  // 它就类似于Agent的功能,代理的功能和目标对象的业务功能调用在这
            )throws IllegalArgumentException{...}

  2. Method类
    反射用的类，用来进行目标对象的方法的反射调用.

    method对象接住我们正在调用的方法sing()，show()

    method == sing(),show()

    method.invoke();==>手工调用目标方法 sing(); show();

  3. InvocationHandler接口
    它是实现代理和业务功能的。我们在调用时使用匿名内部实现.

接口的匿名内部实现：

@Test
public testA(){
	Service service = new Servcie(){
        @Override
        public void sing(){
            System.out.println("哈哈哈哈....");
        }
    };
    service.sing();
}

代码实现:

image-20231214203140131

项目路径

  1. 业务接口

    public interface Service {
    void sing();

    String show(int age);
}

  2. 目标对象

    public class SuperStartLiu implements Service {
    public void sing() {
        System.out.println("我是刘德华，我正在唱歌。。。。");
    }

    public String show(int age) {
        System.out.println("刘德华的show。。。。" + age);
        return "liu";
    }

    // 此方法不能被代理（不能增强功能）
    public void one() {
        System.out.println("one.......");
    }
}

public class SuperStartZhou implements Service {
    public void sing() {
        System.out.println("我是周润发，我正在唱歌。。。。");
    }

    public String show(int age) {
        System.out.println("周润发的show。。。。" + age);
        return "zhou";
    }
}

  3. 获取 动态代理对象，进行封装是因为 返回动态代理对象 的代码太繁杂，在客户端获取不美观

    public class ProxyFactory {
    // 类中的成员变量设计为接口,目标对象
    Service target;
    // 传入目标对象
    public ProxyFactory(Service target){
        this.target = target;
    }

    // 返回动态代理对象
    public Object getAgent(){
        return Proxy.newProxyInstance(
            // ClassLoader loader, 类加载器,完成目标对象的加载
            target.getClass().getClassLoader(),
            
            // Class<?>[] interfaces,目标对象实现的所有接口
            target.getClass().getInterfaces(),
          	
            // InvocationHandler h,实现代理功能的接口 ,我们传入的是匿名内部实现
            new InvocationHandler() {
                @Override
                public Object invoke(
                    Object proxy,  // 创建代理对象
                    Method method,  // method就是目标方法sing(),show()
                    Object[] args  // 目标方法的参数
                		) throws Throwable {	
                    // 代理功能
                    System.out.println("预订时间........");
                    // 代理功能
                    System.out.println("预订场地........");
                    // 主业务功能实现
                    // target.sing();还是写死了方法的调用, 不成
                    // sing(),show(),one()
                    Object obj = method.invoke(target,args);
                    // 代理功能
                    System.out.println("结算费用........");
                    return obj;  //切记:这个是目标方法的返回值
                }
            }
        );
    }
}

  4. 客户端对象

    public class MyTest {
    @Test
    public void testJDK() {
        // ProxyFactoty factoty = new ProxyFactoty(new SuperStartLiu());
        ProxyFactoty factoty = new ProxyFactoty(new SuperStartLiu());
        // factoty.getAgent(); 的返回值是 Object，无法直接用它调用sing方法
        Service agent = (Service) factoty.getAgent();
        agent.sing();
    }
    @Test
    public void testJDK1() {
        // ProxyFactoty factoty = new ProxyFactoty(new SuperStartLiu());
        ProxyFactoty factoty = new ProxyFactoty(new SuperStartLiu());
        Service agent = (Service) factoty.getAgent();
        String s = agent.show(66);
        System.out.println(s);
    }

    @Test
    public void testObject() {
        ProxyFactoty factoty = new ProxyFactoty(new SuperStartLiu());
        Service agent = (Service) factoty.getAgent();
         // class com.sun.proxy.$Proxy4 代理对象类型（运行时类型） 
        System.out.println(agent.getClass()); 

        Service liu = new SuperStartLiu();
        System.out.println(liu.getClass());
    }

    @Test
    public void testJDK2() {
        // ProxyFactoty factoty = new ProxyFactoty(new SuperStartLiu());
        ProxyFactoty factoty = new ProxyFactoty(new SuperStartLiu());
        // one方法是 子类 独有的
        // Service agent = (Service) factoty.getAgent();
        // agent.one();
        
        // 类型转换异常
        // SuperStartLiu agent = (SuperStartLiu) factoty.getAgent();
        // agent.one();
    }

}

    使用动态代理，在Service中新增业务功能不用更改 ProxyFactoty类中的代码；而静态代理中，需要更改代理对象中的代码。

10.CGLib动态代理(用的少)

又称为子类。通过动态的在内存中构建子类对象，重写父类的方法进行代理功能的增强.

如果目标对象没有实现接口，则只能通过CGLib子类代理来进行功能增强.

子类代理是对象字节码框架ASM来实现的.

项目路径【自制的一个简单的CGLib代理】

注意:

  • 被代理的类不能为final， 否则报错.

  • 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

public Object getProxyInstance(){		
    //1.使用工具类
    Enhancer en=new Enhancer();
    //2.设置父类
    en.setSuperclass(target.getClass());
    //3.设置回调函数
    en.setCallback(this);
    //4.创建子类（代理）对象
    return en.create();  ===>返回的是子类代理对象
}

**

子类代理是对象字节码框架ASM来实现的.

项目路径【自制的一个简单的CGLib代理】

注意:

  • 被代理的类不能为final， 否则报错.

  • 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

public Object getProxyInstance(){		
    //1.使用工具类
    Enhancer en=new Enhancer();
    //2.设置父类
    en.setSuperclass(target.getClass());
    //3.设置回调函数
    en.setCallback(this);
    //4.创建子类（代理）对象
    return en.create();  ===>返回的是子类代理对象
}
林深归海
关注
Java 动态代理详解与实战示例
微笑听雨
06-03 5238
Java 动态代理是一种强大的技术，可以在不修改现有代码的情况下为方法调用添加额外的行为。通过使用 InvocationHandler 和 Proxy 类，可以轻松地实现各种代理模式，如日志记录、性能监控等。这种机制在很多 Java 框架（如 Spring AOP）中得到了广泛应用。
Java动态代理的原理
JavaShark的博客
05-25 1407
　Java动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。下面我们开始动态代理的学习。 动态代理的简要说明 　　在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)。 一、 Invo
Java动态代理
CVPR收割机的博客
03-21 1974
代理类代理目标类（代理）目标类是实现目标功能的类（杨超越）
JAVA动态代理
qq_32117059的博客
02-25 1543
java中有两种常见的动态代理方式 JDK原生动态代理和CGLIB动态代理使用以及原理
Java 动态代理详解
技术杠精的博客
05-26 1376
Java 动态代理详解，包括JDK动态代理和CGLIB动态代理
Java动态代理的实现方式
Mr_Richard的博客
07-08 1365
代理模式是一种设计模式，，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，。代理分为动态代理和静态代理。举例：通过中介进行的商品交易，中介就是代理，代替卖方进行商品销售。静态代理比较麻烦，需要对每个目标对象都设置专用的代理类，实际开发中很少使用。动态代理是的一种技术。**从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。
Java动态代理实现与原理详细分析
YIYIYI
12-06 1869
Java动态代理实现与原理详细分析
Java动态代理的理解
love and share
05-09 1702
1.什么是动态代理 在去深入理解动态代理之前，先来看看它的基本概念，简单来说，动态代理就是在程序运行期，创建目标对象的代理对象，对目标对象中的方法进行功能性增强的一种技术。可以看到，概念种出现了这么几种角色：①.真实角色，②.代理角色，③.方法，④.客户(访问角色)。那么访问角色本可以直接访问真实角色的某个方法，为什么在开发的过程种需要一个代理角色呢？也就说动态代理解决了什么问题。在这里我们明确一个核心概念：动态代理能够让真实对象专注于自己的核心功能，让代理对象拦截客户对真实对象的访问，...
Java 动态代理
热门推荐
qq_36511401的博客
12-09 1万+
1、介绍。 Java代理。 java代理：在不用修改源码的情况下，可以在实现类方法的前后做些额外的处理。 1）、静态代理。 在程序运行前，代理类的.class文件已存在。事先知道要代理的实现类是什么。 优点：不需要知道委托类（实现类），只需知道代理类即可。 缺点：（1）代码重复。代理类和委托类（实现类）实现了相同的接口...
Java 动态代理详解（学习资料）
06-17
JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象，而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...
一文带你搞懂Java动态代理
01-21
在说动态代理之前，先来简单看下代理模式。代理是最基本的设计模式之一。它能够插入一个用来替代“实际”对象的“代理”对象，来提供额外的或不同的操作。这些操作通常涉及与“实际”对象的通信，因此“代理”对象...
Java动态代理语法Proxy类原理详解
08-19
"Java动态代理语法Proxy类原理详解" Java动态代理语法Proxy类原理详解是Java语言中的一种非常重要的语法机制，它可以动态地生成代理对象，从而对目标对象进行增强和修改。本文将详细介绍Java动态代理语法Proxy类...
Java动态代理两种实现方式
04-27
Java动态代理技术是Java编程中一个非常重要的特性，它允许我们在运行时动态创建具有特定行为的对象。这种技术常用于AOP（面向切面编程）和框架中，如Spring AOP，用于实现方法拦截、事务管理等功能。Java提供了两种...
JAVA-01-变量
LJH_laura_li的博客
11-08 298
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 544
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 319
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 991
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
深度解析Java动态代理机制
在Java动态代理机制中，`java.lang.reflect.Proxy`是核心类，它提供了创建动态代理类和代理对象的能力。`Proxy`类的静态方法`getProxyClass`用于根据类加载器和一组接口生成对应的代理类的Class对象。而`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值