精华内容
下载资源
问答
  • 静态代理
    2022-04-28 16:05:34

    使用静态代理时需要让目标对象和代理对象一起实现相同的接口或者继承相同的父类。这样做的目的就是为了通过调用代理对象中和目标对象相同的方法来实现调用目标对象的方法,从而达到代理的效果。

    第一步定义接口

    public interface IStatictProxy {
    
        void print();
    }
    

    第二步实现接口(目标对象)

    @Slf4j
    public class TargetImpl implements IStatictProxy{
        @Override
        public void print() {
            log.info("静态代理目标对象实现类打印!");
        }
    }

    第三步代理类实现接口

    代理类中注入接口,构造方法同时显示声明

    @Slf4j
    public class StaticProxyImpl implements IStatictProxy {
    
        // 通过接口聚合被代理的类
        private IStatictProxy proxy;
    
        // 构造方法
        public StaticProxyImpl(IStatictProxy proxy) {
            this.proxy = proxy;
        }
    
        @Override
        public void print() {
            log.info("代理对象中的打印方法执行开始!");
            proxy.print();
            log.info("代理对象中的打印方法执行结束!");
        }
    
        public static void main(String[] args) {
            TargetImpl target = new TargetImpl();
            StaticProxyImpl staticProxy = new StaticProxyImpl(target);
            staticProxy.print();
        }
    }
    

    第四部 运行代理类

    Connected to the target VM, address: '127.0.0.1:8238', transport: 'socket'
    15:58:58.310 [main] INFO com.hkwl.hkboot.smp.proxy.StaticProxyImpl - 代理对象中的打印方法执行开始!
    15:58:58.317 [main] INFO com.hkwl.hkboot.smp.proxy.TargetImpl - 静态代理目标对象实现类打印!
    15:58:58.317 [main] INFO com.hkwl.hkboot.smp.proxy.StaticProxyImpl - 代理对象中的打印方法执行结束!
    Disconnected from the target VM, address: '127.0.0.1:8238', transport: 'socket'
     

    从上面的实现来看,总结优缺点如下:

    优点:实现简单,容易理解,只要确保目标对象和代理对象实现共同的接口或继承相同的父类就可以在不修改目标对象的前提下进行扩展。

    缺点:代理类和目标类必须有共同接口(父类),并且需要为每一个目标类维护一个代理类,当需要代理的类很多时会创建出大量代理类。一旦接口或父类的方法有变动,目标对象和代理对象都需要作出调整。

    更多相关内容
  • statical:PHP静态代理

    2021-07-13 18:21:54
    两个示例都调用实例化视图类的 render 方法,静态代理版本使用简洁和干净的代码。 这可能是也可能不是一件好事,完全取决于您的要求、用法和观点。这个怎么运作一切都通过Statical\Manager运行。 创建每个静态代理...
  • Nginx各种配置(包括负载均衡、静态代理、动静分离)
  • 主要对Spring AOP的相关概念和简单的静态代理、动态代理以及常见的几种AOP配置方式做总结学习。主要包括:1. AOP的常见概念 2. 静态代理 3. jdk动态代理 4. Aspectj and Aspectjweaver 5. **aop-config** 6. CGLIB ...
  • 此资源为文章中《代理设计模式:静态代理和动态代理的理解、实现与区别(优缺点)》与《 AOP动态代理声明式的3种配置方式过程与区别》的案例代码,可下载参考学习。
  • 静态代理总结: 优点:可以做到在符合开闭原则的情况下对目标对象进行功能扩展。 缺点:我们得为每一个服务都得创建代理类,工作量太大,不易管理。同时接口一旦发生改变,代理类也得相应修改。
  • 设计模式之代理模式_静态代理的一个java实现的demo。主类在Client中。仅代码实现,可供初学者参考使用
  • 静态代理和动态代理详解

    千次阅读 2022-02-25 20:25:46
    1 代理 生活中的代理:比如我们生活中比较熟悉的代购、中介、商家等都是属于代理 2 什么是代理模式 代理模式是指:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用...

    1 代理

    •  生活中的代理:比如我们生活中比较熟悉的代购、中介、商家等都是属于代理

    2 什么是代理模式

    代理模式是指:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户类和目标对象之间起到中介的作用。

    换句话说,使用代理对象,是为了在不修改目标对象的基础上,增强主业务逻辑。

    客户类真正想要访问的对象是目标对象,但客户类真正可以访问的对象是代理对象。客户类对目标对象的访问是通过访问代理对象来实现的。当然,代理类与目标类要实现同一个接口。

    比如:

    有A、B、C三个类,A原来可以调用C类的方法,现在因为某种原因C类不允许A类调用其方法,但B类可以调用C类的方法。A类通过B类调用C类的方法。这里B是C的代理。

    A通过代理B访问C ,这种模式就是代理模式。

    • 原来的访问关系:

    • 通过代理的访问关系:

    3 代理模式的作用

    1. 功能增强: 在原有的功能上,增加了额外的功能,新增加的功能,叫做功能增强,
    2. 控制访问:代理类不让你访问目标,例如商家不让用户访问厂家

    4 实现代理的方式

    4.1 静态代理

    4.1.1 什么是静态代理?

    (1)代理类是自己手工实现的,自己创建一个Java类,表示代理类。

    (2)同时你所要代理的目标是确定的。

    4.1.2 静态代理的特点:

    (1)实现简单

    (2)容易理解

    4.1.3 静态代理的缺点:

    当项目中目标类和代理类很多的时候,会有以下的特点:

    (1)当目标类增加了,代理类可能也需要成倍的增加,代理类数量过多。

    (2)当你的接口中功能增加了,或者修改了,会影响众多的实现类,厂家类,代理都需要修改,影响比较多。

    4.1.4 静态代理举例:

    • 模拟一个用户购买U盘的行为

            用户:客户端类

            商家:代理,代理某个品牌的U盘

            厂家:目标类

            三者的关系:用户(客户端)  ----  商家(代理)----厂家(目标)

            商家和厂家都是卖U盘的,他们完成的功能是一致的,都是卖U盘。

    • 实现步骤:

    (1)创建一个接口,定义卖U盘的方法,表示你的厂家和商家做的事情。

    (2)创建厂家类,实现(1)步骤的接口

    (3)创建商家,就是代理,也需要实现(1)步骤中的接口

    (4)创建客户端类,调用商家的方法买一个U盘

    • 代理类完成的功能:

    (1)实现目标类中方法的调用

    (2)功能增强

    • Java代码实现如下:

    (1)创建一个接口,定义卖U盘的方法,表示你的厂家和商家做的事情。

    package com.powernode.service;
    
    /**
     * 表示功能的,厂家,商家都要完成的功能
     * 备注:下面只是定义了一个卖U盘的功能,也可以写其它的功能
     */
    public interface UsbSell {
    
        //定义方法 参数 amount:表示一次购买的数量,暂时不用
        //返回一个U盘的价格
         float sell(int amout);
         
    }
    

    (2)创建厂家类,实现(1)步骤的接口

    package com.powernode.factory;
    
    import com.powernode.service.UsbSell;
    
    //目标类:金士顿厂家.不接受用户的单独购买
    public class UsbKingFactory implements UsbSell {
        @Override
        public float sell(int amout) {
            //一个128G的U盘是85元
            return 85.0f;
        }
    }
    

    (3)创建商家,就是代理,也需要实现(1)步骤中的接口

    package com.powernode.shangjia;
    
    import com.powernode.factory.UsbKingFactory;
    import com.powernode.service.UsbSell;
    
    /**
     * 淘宝是一个商家,代理金士顿厂家U盘的销售
     */
    public class TaoBao implements UsbSell {
        private UsbKingFactory factory = new UsbKingFactory();
    
        @Override
        //实现销售U盘功能
        public float sell(int amout) {
    
            //向厂家发送订单,告诉厂家,我买了U盘,厂家发货
            float price = factory.sell(amout);//厂家的价格
    
            //商家需要加价,也就是代理需要增加价格
            //增强功能,代理类在完成目标类方法调用后,增强的功能。在目标类的方法调用后,你做的其它功能,都是增强的意思。
            price = price + 25;
            //返回增加的价格
            return price;
        }
    }
    

    (4)创建客户端类,调用商家的方法买一个U盘

    package com.powernode;
    
    import com.powernode.shangjia.TaoBao;
    
    public class ShopMain {
    
        public static void main(String[] args) {
    
            TaoBao taoBao = new TaoBao();
            float price = taoBao.sell(1);
            System.out.println("通过淘宝的商家,购买得u盘单价" + price);
        }
    }
    

    4.2 动态代理

    在静态代理中目标类很多时候,可以使用动态代理。避免静态代理的缺点。

    动态代理中目标类即使很多,

    1)代理类数量可以很少

    2)当你修改了接口中的方法时,不会影响代理类

    4.2.1 什么是动态代理

    说起动态代理,就先说下什么是动态:

    动态指的是在程序执行时,调用jdk提供的方法才能创建代理类的对象。

    动态代理是:

    在程序执行过程中,使用jdk的反射机制,创建代理类对象,并动态的指定要代理目标类(静态代理中,代理目标是固定,写死的)。而不用你创建类文件,不用写Java文件。

    动态代理其实就是jdk运行期间,动态创建class字节码并加载到JVM

    换句话说,动态代理是一种创建Java对象的能力,让你不用创建TaoBao类,就能创建代理类对象。一般创建对象是 new Xx(),那现在动态代理也可以做这个事情。

    动态代理的实现方式常用的有两种:

    1、JDK动态代理

    使用Java反射包中的类和接口实现动态代理的功能。

    1)反射,Method类,表示方法。类中的方法,通过Method可以执行某个方法。

    2)jdk动态代理的实现

    反射包 java.lang.reflect, 里面有三个类:InvocationHandler, Method, Proxy。

    (1)InvocationHandler 接口(中文意思:调用处理器):就是一个方法 invoke()

    invoke():表示代理对象要执行的功能代码,你的代理类要完成的功能就卸载invoke()方法中。

            代理类完成的功能:

                    1、调用目标方法,执行目标方法的功能

                    2、功能增强,在目标方法调用时,增加功能。

    invoke()方法原型:

    public Object invoke(Object proxy, Method method, Object[] args)

    入参介绍:

    • Object proxy:jdk创建的代理对象,无需赋值
    • Method method: 目标类中的方法,jdk提供method对象的
    • object[] args: 目标类中方法的参数

    InvocationHandler 接口 : 表示你的代理要干什么。

    怎么使用:

            1)创建类实现接口InvocationHandler

            2)重写invoke()方法,把原来静态代理中代理类要完成的功能,写到这个地方

    (2)Method类:目标类中的方法。

    作用:通过Method可以执行某个目标类的方法,Method.invoke();

            Method.invoke(目标对象, 方法的参数)

    说明:Method.invoke()就是用来执行目标方法的,等同于上面在静态代理中的

         float price = factory.sell(amout);//厂家的价格

    (3)Proxy类:核心的对象,创建代理对象,之前创建对象都是new 类的构造方法()现在我们使用Proxy类的方法,代理new的使用。

    方法: 静态方法:newProxyInstance()

    作用:创建代理对象,等同于我上述静态代理举例中的new TaoBao()= new TaoBao()

    方法原型:

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

    入参介绍:

    • ClassLoader loader :类加载器,负责向内存中加载对象的,使用反射获取对象的classLoader。 例如: 类A: A.getClass.getClassLoader(), 主要是为了获取目标对象的类加载器。
    • Class<?>[] interfaces:接口,目标对象实现的接口,也是反射获取的。
    • InvocationHandler h:是我们自己写的,代理类要完成的功能。

    出参介绍:

    Object:就是目标对象的代理对象

    4.2.2 动态代理举例

    • 实现动态代理的步骤:

    (1)创建接口,定义目标类要完成的功能

    (2)创建目标类实现接口

    (3)创建InvocationHandler接口的实现类,在invoke方法中完成代理类的功能

            1)调用目标方法

            2)增强功能

    (4)使用Proxy类的静态方法,创建代理对象。并把返回值转为接口类型

    • Java代码实现如下

    (1)创建接口,定义目标类要完成的功能

    package com.powernode.service;
    
    /**
     * 表示功能的,厂家,商家都要完成的功能
     * 备注:下面只是定义了一个卖U盘的功能,也可以写其它的功能
     */
    public interface UsbSell {
    
        //定义方法 参数 amount:表示一次购买的数量,暂时不用
        //返回一个U盘的价格
         float sell(int amout);
    
    }
    

    (2)创建目标类实现接口

    package com.powernode.factory;
    
    import com.powernode.service.UsbSell;
    
    //目标类:金士顿厂家.不接受用户的单独购买
    public class UsbKingFactory implements UsbSell {
        @Override
        public float sell(int amout) {
            //一个128G的U盘是85元
            return 85.0f;
        }
    }
    

    (3)创建InvocationHandler接口的实现类,在invoke方法中完成代理类的功能

    package com.powernode.handler;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    /**
     * 必须实现InvocationHandler接口,完成代理类要做的功能(1.调用目标方法 2.功能增强)
     */
    public class MysellHandler implements InvocationHandler {
        
        private Object  target = null;
        //动态代理:目标对象是活动的,不是固定的,需要传入进来。
        //传入是谁,就给谁创建代理
        public MysellHandler(Object target){
            this.target = target;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           // float price = factory.sell(amout);//厂家的价格
    
            //商家需要加价,也就是代理需要增加价格
            //增强功能,代理类在完成目标类方法调用后,增强的功能。在目标类的方法调用后,你做的其它功能,都是增强的意思。
            //price = price + 25;
            //返回增加的价格
    
            //(1)执行目标方法
            Object res = null;
            method.invoke(target, args);//执行目标方法,target你传入的是A,那你的目标方法就是A,你传入的是B,那目标方法就是B
            //(2)进行功能增强
            if (res != null) {
                Float price = (Float) res;
                price = price+25;
                res = price;
            }
            return res;
        }
    }
    

    (4)使用Proxy类的静态方法,创建代理对象。并把返回值转为接口类型

    package com.powernode;
    
    import com.powernode.factory.UsbKingFactory;
    import com.powernode.handler.MysellHandler;
    import com.powernode.service.UsbSell;
    import com.powernode.shangjia.TaoBao;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    public class ShopMain {
    
        public static void main(String[] args) {
            //创建代理对象,使用Proxy
            // 1、创建目标对象
           // UsbKingFactory factory = new UsbKingFactory();
            UsbSell factory = new UsbKingFactory();
    
            //2、创建InvocationHandler对象
            InvocationHandler handler = new MysellHandler(factory);
    
            //3、创建代理对象
            UsbSell proxy = (UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                    factory.getClass().getInterfaces(),
                    handler);
    
            //4、通过代理执行方法
            float price = proxy.sell(1);
            System.out.println(price);
    
        }
    }
    

    2、通过CGLIB动态代理

    cglib是第三方的工具库,创建代理对象。它可以在运行期间扩展Java类与实现Java接口,它广泛的被许多AOP的框架使用,例如Spring AOP。

    使用JDK的Proxy实现代理,要求目标类和代理类实现相同的接口。若目标类不存在接口,则无法使用该方式实现。

    但对于无接口的类,要为其创建动态代理,就要通过cglib来实现。cglib代理的生成原理是生成目标类的子类,而子类是通过增强过的,这个子类对象就是代理对象,所以,使用cglib生成动态代理,要求目标类必须能够被继承,即不能是final的类。

    cglib在很多的框架中使用。比如mybatis,spring框架中都有使用。

    在Java中,要想创建对象:

    (1)创建类文件,Java文件编译为class

    (2)使用构造方法,创建类的对象

    然而,动态代理是不用做上面的步骤(1),只需要经过步骤(2)就可以把对象创建出来

    展开全文
  • NULL 博文链接:https://wmwork2010.iteye.com/blog/631978
  • spring+静态代理

    2015-03-23 14:53:26
    结合spring框架实现的静态代理,接口回掉
  • 本资源包含了博主博客中的代码,用一个黄牛买票的例子帮助新手理解静态代理与动态代理的原理
  • 静态代理和动态代理

    2019-03-06 01:31:55
    博文链接:https://congpeixue.iteye.com/blog/159173
  • 静态代理代理模式,顾名思义就是提供一个代理类,可以访问原对象并且替原对象进行一些操作。 优点:使用代理模式可以在保证不修改原有类的同时(即满足对扩展开放,对修改关闭的原则),对原有类增加一些功能实现。
  • Java静态代理、动态代理1、静态代理2、动态代理2.1、jdk动态代理2.2、cglib动态代理 代理是一个抽象的概念,简单理解就可以理解为在一个java类上去给它增加一些新的功能,但是却不用动原来的代码,在Java中分为静态...

    代理是一个抽象的概念,简单理解就可以理解为在一个java类上去给它增加一些新的功能,但是却不用动原来的代码,在Java中分为静态代理和动态代理,然而动态代理又分为 jdk 动态代理和 cglib 动态代理,详情如下:

    1、静态代理

    方法:静态代理相当于是多写了一个代理类,在调用的时候调用的是代理类,在代理类中的处理还是原生的处理逻辑,不过在前后添加上需要添加的代码。
    缺点:需要为每一个被代理的对象都创建一个代理类。
    下面以购物举一个例子:


    1、我们现在需要写一个接口去定义购物类的方法:

    // 接口
    public interface IShopping {
        public void doShopping();
    }
    

    2、定义一个购物的实现类

    public class Shopping implements IShopping {
    
        private String name;
    
        public Shopping(String name){
            this.name = name;
        }
    
        @Override
        public void doShopping() {
            System.out.println(name + "买了火腿肠一个。");
            System.out.println(name + "买了啤酒一罐。");
            System.out.println(name + "买了剪刀一把。");
        }
    
    }
    

    3、测试类直接运行
    这里我们可以看出执行了实现类的代码

    public class MainTest {
    
        @Test
        public void test01(){
            IShopping shopping = new Shopping("小乐乐");
            shopping.doShopping();
        }
    }
    

    在这里插入图片描述


    4、现在又有了新的需求,需要我们打印出,某人进入超市购物和离开超市的时间
    由于现在我们用的是静态代理,所以我们需要写一个代理类,来包装之前的购物实现类,如下所示:
    在这个类中我们可以发现,我们真正的执行逻辑还是之前的购物逻辑,不过在购物逻辑的前后添加了一写=些日志打印

    public class ShoppingProxy implements IShopping {
    
        private String name;
        private Shopping shopping;
    
        public ShoppingProxy(String name){
            this.name = name;
            this.shopping = new Shopping(name);
        }
    
        @Override
        public void doShopping() {
            System.out.println(name + "在" + currentTime() + "到达了超市。");
            shopping.doShopping();
            System.out.println(name+"到达了超市。");
            System.out.println(name + "在" + currentTime() + "从超市出去。");
        }
    
        private String currentTime(){
            //设置日期格式
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            // new Date()为获取当前系统时间
            return df.format(new Date());
        }
    
    }
    

    5、测试类打印
    没有动之前的逻辑,我们就实现了功能需求,但是缺点就是对于每一个需要代理的类我们都需要写一个新的代理类,太繁琐。

    public class MainTest {
    
        @Test
        public void test01(){
            IShopping shopping = new ShoppingProxy("小乐乐");
            shopping.doShopping();
        }
    }
    

    在这里插入图片描述

    2、动态代理

    2.1、jdk动态代理

    Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    通过它创建动态的代理类,我们只需将别的类去调用我们实现的公共方法,就可以。
    缺点:必须要实现接口。


    1、首先我们先写一个接口,如下代码所示:

    public interface ICalculator {
    
        public Integer add(Integer i,Integer j);
    
        public Integer sub(Integer i,Integer j);
    
        public Integer mul(Integer i,Integer j);
    
        public Integer div(Integer i,Integer j);
    }
    

    2、我们写一个需要被代理的类,这个被代理的类必须要实现上面的接口(因为jdk的动态代理是必须要实现接口的),如下所示:

    public class Calculator implements ICalculator {
        @Override
        public Integer add(Integer i, Integer j) {
            Integer result = i + j;
            return result;
        }
    
        @Override
        public Integer sub(Integer i, Integer j) {
            Integer result = i - j;
            return result;
        }
    
        @Override
        public Integer mul(Integer i, Integer j) {
            Integer result = i * j;
            return result;
        }
    
        @Override
        public Integer div(Integer i, Integer j) {
            Integer result = i / j;
            return result;
        }
    }
    
    

    3、我们需要写一个代理打印日志的公共方法,这个公共方法将会给被代理的类弄一些屏障类似的东西,在执行真正的方法前后打印一些日志等等,可联系是spring中的aop进行理解,概念大致相似,代码如下所示:

    public class MyInvocationHandler implements InvocationHandler {
    
        private Object target;
    
        private String prefix = "代理类打印:";
    
        public MyInvocationHandler(Object target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            String classAndMethod = prefix + "方法名:" + method.getName();
            System.out.println(classAndMethod + ",开始执行:");
            if(args == null || args.length == 0){
                System.out.println(prefix + "没有参数");
            }else{
                System.out.println(prefix + "参数为:" + Arrays.asList(args));
            }
            /**
             * 执行被代理的方法
             * 参数
             * Object obj       被代理的对象
             * Object... args   被代理的方法参数,直接将args传进去
             */
            Object result = method.invoke(target,args);
            System.out.println(prefix + "返回值为:" + result);
            System.out.println(classAndMethod + ",执行结束。");
            return result;
        }
    }
    
    

    4、接下来,我们就需要写我们真正的需要被代理的创建 jdk 动态代理的公共方法,然后需要打印日志的处理类指向第三步的方法即可,代码如下所示:

    public class CommonProxy {
        /**
         * 公共jdk动态代理生成方法
         * Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
         * 上面这行代码就是创建一个 jdk 动态代理,我们现在只需要知道传入这三个参数即可
         * 由于这里我们可以很明显的看见,参数需要一个接口
         * 所以说, jdk 动态代理要求被代理的类得实现一个接口
         * @param object
         */
        public static Object createProxy(Object object){
            /**
             * ClassLoader loader       类加载器,通常指定的被代理类的接口的类加载器
             * Class<?>[] interfaces    类型,通常用来被指定被代理类的接口的类型
             * InvocationHandler h      委托执行的处理类:日志功能
             */
            ClassLoader classLoader = object.getClass().getClassLoader();
            Class<?>[] interfaces = object.getClass().getInterfaces();
            InvocationHandler invocationHandler = new MyInvocationHandler(object);
            // 动态创建代理类
            Object o = Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
            return o;
        }
    }
    
    

    5、最后我们来写一个测试类,去动态给我们最开始定义的 Calculator 动态生成一个代理类,代码和运行截图如下所示:

    public class MainTest {
        @Test
        public void test(){
            ICalculator o = (ICalculator)CommonProxy.createProxy(new Calculator());
            o.add(1,1);
        }
    }
    

    在这里插入图片描述

    2.2、cglib动态代理

    对于cglib的动态代理,创建代理类的时候不需要传入接口参数,所以它不需要强制实现接口。
    而是为被代理的对象创建一个子类,jdk 动态代理中的有些代码我们可以用到,这里面只需要改一下动态代理的公共方法和测试类即可。


    1、创建动态代理公共方法并实现打印日志功能:

    public class CglibCommonProxy implements MethodInterceptor {
        /**
         * 需要代理的目标对象
         */
        private Object target;
    
        public Object createProxy(Object objectTarget){
            // 将传入进来的目标对象赋值给全局变量,在后续调用拦截方法时会用到
            target = objectTarget;
            // enhancer 字面意思,增强剂,也就是给被代理类搞一个屏障
            Enhancer enhancer = new Enhancer();
            //设置父类,因为Cglib是针对指定的类生成一个子类,所以需要指定父类
            enhancer.setSuperclass(objectTarget.getClass());
            // 设置回调
            enhancer.setCallback(this);
            // 搞好这个代理类并返回
            Object result = enhancer.create();
            return result;
        }
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("Cglib动态代理,监听开始!");
            //方法执行,参数:target 目标对象 objects 参数数组
            Object invoke = method.invoke(target, objects);
            System.out.println("Cglib动态代理,监听结束!");
            return invoke;
        }
    }
    
    

    2、测试类,测试类代码以及运行截图:

    @Test
    public void cglibTest(){
        CglibCommonProxy cglibCommonProxy = new CglibCommonProxy();
        ICalculator o = (ICalculator)cglibCommonProxy.createProxy(new Calculator());
        o.add(1,1);
    }
    

    在这里插入图片描述

    展开全文
  • 静态代理理解

    2022-05-31 18:52:52
    静态代理 现在如果要对每个..

    1、什么是静态代理?

    两个对象之间的操作不直接进行,通过第三方进行代理来实现。就比如说房客租房子这件事情,租房的两个对象是房客和房东,静态代理便是,在房客和房东之间多了一个角色,这便是中介,代理便是中介,现在租房这件事情便是房客和中介,以及中介和房东之间的事情,房客不直接和房东进行租房的操作。

    2、为什么要使用静态代理?

    回到刚才租房的例子,如果不使用静态代理,后面房客的需求增加了,房东的功能也随之增加,在原有代码的基础上进行代码的改动,可能会导致代码出现问题。

    现在如果要对每个方法执行前输出一句话“今天天气真不错”,就需要对每个方法都进行更改,这样可能导致代码出现问题

    使用静态代理模式便可以很好解决这个问题

    只需要代理类在执行执行方法时进行相应的更改,这样便不会更改源代码,实现同样的需求

    3、静态代理如何使用?

    静态代理的使用首先要定义代理类实现相应的接口

    通过代理类来调用相应的方法,可以实现同样的功能,并且不修改原有代码。

    这便是静态代理,静态代理很好的实现了在不修改原有代码的基础上进行业务拓展的功能,这也是它主要的功能。

    但是静态代理是代理类在创建的时候,接口以及代理类就已经确定了,因此一个静态代理类只能代理一个类,造成代码的冗余 。


    展开全文
  • NULL 博文链接:https://liaoliu51.iteye.com/blog/581896
  • JAVA静态代理和动态代理
  • Java静态代理

    2022-06-08 16:31:19
    Java静态代理
  • NULL 博文链接:https://daxiaoli123.iteye.com/blog/940784
  • 静态代理和动态代理的区别 按照代理的创建时期,代理类可以分为两种: 静态:由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。 动态:在程序运行时运用反射...
  • java 动态代理与静态代理

    千次阅读 2021-07-24 20:21:04
    java中代理分为动态代理与静态代理,其中动态代理比较常见的有jdk动态代理和cglib动态代理。 静态代理 静态代理实现简单,但不够灵活,比较麻烦,要实现与被代理对象一样的接口,创建很多代理类。接口增加方法后...
  • 静态代理设计模式1.1 静态代理 – 实现步骤1.2 静态代理 – 逻辑图 & 源码示例1.3 静态代理 – 优缺2. 装饰者设计模式 – 类似静态代理2.1 装饰者模式 – 实现步骤2.2 装饰者模式 – 逻辑图 & 源码示例2.3 装饰者...
  • Java 静态代理模式

    2017-07-02 19:40:18
    Java 代理模式: 详见:http://blog.csdn.net/q610098308/article/details/74144046
  • java设计模式【之】静态代理【源码】【场景:帮爸爸买菜】.rar * 代理模式 * 在开发者的角度来看,创建一个代理对象,提供给用户使用,避免用户直接访问真正的对象 * 在用户角度来看,就是普通的类方法调用 * ...
  • AOP实现的关键在于AOP框架自动创建的AOP代理,AOP代理主要分为静态代理和动态代理,静态代理的代表为AspectJ;而动态代理则以Spring AOP为代表。 何为切面? 一个和业务没有任何耦合相关的代码段,诸如:调用日志,...
  • 思考:以常见的增删改查为例,在执行增删改的时候我们需要开启事务,执行完成后...于是就出现了代理模式的概念,那什么是代理模式呢? 1、什么是代理模式 简单来说:代理就是对目标方法进行增强。 什么意思呢?...
  • Java中的代理模式--静态代理和动态代理 Java中的代理模式--静态代理和动态代理
  • 代理模式在Java中特别常见,如spring AOP功能就是用代理来实现的。...一般使用代理模式我们需要先定义一个接口,静态代理只是一种简单的java代码功能扩展。而动态代理利用了反射机制,使用更简单。
  • Java代理设计模式(Proxy)的具体实现:静态代理和动态代理 实现方式一:静态代理 静态代理方式的优点 静态代理方式的缺点 Java动态代理实现方式一:InvocationHandler Java动态代理实现方式二:CGLIB 用CGLIB实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 321,291
精华内容 128,516
关键字:

静态代理