java动态代理

绝地灬酷狼 2022-04-23 02:36 230阅读 0赞

一、关于代理设计模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

**    意图：**为其他对象提供一种代理以控制对这个对象的访问。

**    主要解决：**在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

** 何时使用：**想在访问一个类时做一些控制。

** 如何解决：**增加中间层。

** 关键代码：**实现与被代理类组合。

** 优点：** 1、职责清晰。 2、高扩展性。 3、智能化。

** 缺点：** 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代 理模式需要额外的工作，有些代理模式的实现非常复杂。

二、静态代理

目标对象接口

public interface IPerson {
        void desc();
    }

具体目标对像

public class PersonTarget implements IPerson {
        private String  name;
        public PersonTarget(String name) {
            this.name = name;
        }
    
        @Override
        public void desc() {
            System.out.println(name+",代理会帮我执行");
        }
    }

代理对象

public class PersonProxy implements IPerson {
    
        private PersonTarget target;
    
        private String       name;
    
    
        public PersonProxy(String name){
            this.name=name;
        }
    
        @Override
        public void desc() {
            target=new PersonTarget(name);
            target.desc();
        }
    }

测试：

@Test
        public void  stu(){
            PersonProxy  personProxy=new PersonProxy("I am PersonTarget");
            personProxy.desc();
        }

三、动态代理

动态代理与代理模式原理是一样的,只是它没有具体的代理类,直接通过反射生成了一个代理对象。所谓代理就是为其他对象提供一种代理以控制对这个对象的访问。一个是真正的你要访问的对象(目标类)，另一个是代理对象,真正对象与代理对象实现同一个接口,先访问代理类再访问真正要访问的对象。

public interface IFruit {
        void  eat();
    }

具体需要代理的目标对象

public class AppleFruit  implements IFruit {
        @Override
        public void eat() {
            System.out.println("晚餐吃苹果---->AppleFruit");
        }
    }
    
    public class BananasFruit implements IFruit {
        @Override
        public void eat() {
            System.out.println("午餐吃香蕉---->BananasFruit");
        }
    }

动态代理类

public class FruitProxy {
    
        private IFruit  fruit;
    
        public FruitProxy(IFruit fruit){
            this.fruit=fruit;
        }
    
        public IFruit createInstance() {
            Class<?>[] classes = new Class[]{IFruit.class};
            return (IFruit) Proxy.newProxyInstance(IFruit.class.getClassLoader(), classes, (proxy, method, args) -> method.invoke(fruit, args));
        }
    }

测试：

@Test
        public void  stu(){
            IFruit instance = new FruitProxy(new AppleFruit()).createInstance();
            instance.eat();
    
            IFruit instance1 = new FruitProxy(new BananasFruit()).createInstance();
            instance1.eat();
        }

执行结果

晚餐吃苹果---->AppleFruit  
午餐吃香蕉---->BananasFruit