Java基础--代理

画船听雨眠aa

已于 2024-09-05 14:26:44 修改

阅读量645

点赞数 16

文章标签： java 开发语言

于 2024-09-05 13:56:23 首次发布

本文链接：https://blog.csdn.net/a13641376265/article/details/141927641

版权

一、代理的基本概念

代理是一种设计模式。我们使用代理对象来代替对真实对象的访问。

举例：

我们要设计一个银行的转账系统，转账时必然会涉及以下方法。
1、对转账金额的确认和对转账双方的身份的确认
2、转账方法（核心）
3、事后服务

假设我们通过支付宝进行支付

这里我们通过支付宝（代理类）来代理银行（核心类）中的核心方法，这样就避免了许多方法在同一个类中造成功能过多，也可以避免用户直接接触核心方法。

二、代理模式的好处

1、控制访问：核心业务交给专门部门代理，不让用户直接访问核心业务。

2、功能增强：可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

三、代理模式怎么用？

实现代理模式分为静态代理和动态代理两种方式。

其中动态代理又分为基于jdk实现的动态代理和基于CGLB实现的动态代理

1、基于jdk实现的静态代理

注意：

1、代理类和核心类都必须实现同一个接口，接口在这里的作用是通知代理类所代理的核心是什么。

2、核心类也叫做目标类

静态代理举例

就以上面的转账系统为例

定义一个转账接口，里面有核心方法转账。

public interface zhuanzhang {
    public void zhuan(String A,String B,Double money);

}

银行类（核心类）

public class yinhang implements zhuanzhang{
    @Override
    public void zhuan(String A, String B, Double money) {
        System.out.println(A+"向"+B+"转账了"+money+"元");
    }
}

支付宝类（代理类）创建了核心对象，拓展了转账方法。

public class zhifubao implements zhuanzhang{
    private yinhang abank = new yinhang();
    private void yanzheng(){
        System.out.println("对A进行身份验证");
        System.out.println("对B进行身份验证");
        System.out.println("对金额进行验证");
    }
    @Override
    public void zhuan(String A, String B, Double money) {
        yanzheng();
        abank.zhuan(A,B,money);
        fuwu();
    }
    private void fuwu(){
        System.out.println("进行事后服务");
    }
}

测试类

public class test {
    public static void main(String[] args) {
        zhifubao a = new zhifubao();
        a.zhuan("zhangsan","lisi",200.0);
    }
}

运行结果

内存图解释

main方法先创建zhifubao类的对象a，在a中创建了yinhang类的abank对象，运行时调用支付宝中的zhuanzhang方法（在这个转账方法中调用了yanzheng（）和fuwu（）以及abank的转账方法），通过这个方法调用abank的转账方法。

静态代理举例2销售店（多个核心类）

创建衣服和鞋子接口与核心类

public interface Clothes {
    public void BuyClothes(String size);
}

public class ClothesFactory implements Clothes{
    @Override
    public void BuyClothes(String size) {
        System.out.println("定制一件大小为"+size+"的衣服");
    }
}

public interface Shoes {
    public void BuyShoes(String size);
}

public class ShoesFactory implements Shoes{
    @Override
    public void BuyShoes(String size) {
        System.out.println("定制鞋子的大小为"+size);
    }
}

创建销售店，进行代理

public class XSD implements Clothes,Shoes{
    //代理目标类
    private ClothesFactory clothesFactory=new ClothesFactory();
    private ShoesFactory shoesFactory=new ShoesFactory();

    private void fuwu(){
        System.out.println("销售店进行服务");
    }

    @Override
    public void BuyClothes(String size) {
        clothesFactory.BuyClothes(size);
        fuwu();
    }

    @Override
    public void BuyShoes(String size) {
        shoesFactory.BuyShoes(size);
        fuwu();
    }
}

总结

通过上面的例子我们不难发现，静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改）且麻烦(需要对每个目标类都单独写一个代理类）。实际应用场景非常非常少。如果要在不同的银行进行转账，也就是有多个核心类，就会很复杂并且会破坏一些性质。这时就需要用动态代理。

2、基于jdk实现的动态代理

代理对象一对一生成

动态代理举例，销售店

创建核心接口和核心类

public interface Clothes {
    public void BuyClothes(String size);
}

public interface Shoes {
    public void BuyShoes(String size);
}

public class ShoesFactory implements Shoes{
    @Override
    public void BuyShoes(String size) {
        System.out.println("定制鞋子的大小为"+size);
    }
}

public class ClothesFactory implements Clothes{
    @Override
    public void BuyClothes(String size) {
        System.out.println("定制一件大小为"+size+"的衣服");
    }
}

创建动态的销售店

其中getProxyInstance()方法获取目标类当中的核心方法，

invoke()方法：继承接口InvocationHandler，重写方法，在施行核心方法的过程中需要执行invoke方法

public class DTXSD implements InvocationHandler{
    private Object object;  //目标类   见内存图1
    public DTXSD(Object o) {     
        object = o;
    }

    /**
     * 动态代理实现相关接口
     * 调用该方法你就知道了目标类当中的核心方法是什么
     * @return
     */
    public Object getProxyInstance(){  //object.getClass() 获取目标类的类对象
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);
    }

    //三个参数的讲解
    //1.Object：jdk创建的代理类，无需赋值
    //2.Method：目标类当中的方法，jdk提供，无需赋值
    //3.Object[]：目标类当中的方法的参数，jdk提供，无需赋值
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.invoke(object,args);
        fuwu();
        return null;
    }
    private void fuwu(){
        System.out.println("销售店进行一系列的服务");
    }
}

测试类

public class Test {
    public static void main(String[] args) {

          ClothesFactory clothesFactory = new ClothesFactory();
          DTXSD dtxsd1 =  new DTXSD(clothesFactory);
          //已经知道了目标类当中的核心方法是什么
          Clothes clothes = (Clothes) dtxsd1.getProxyInstance();
          clothes.ByClothes("XXXL");
    }
}

运行结果

内存图（暂时）

public class XSD {
    private Object object; 
    public Shop(Object o){ 
        object = o;
    }
}

public class Test {
    public static void main(String[] args) {
        ClothesFactory clothesFactory = new ClothesFactory(); 
        XSD dtxsd = new XSD(clothesFactory);
    }
}

注意：在最后调用获取到的核心方法时必须要用clothes类调用，直接创建clothesfactory对象调用核心方法是没有用代理的。

画船听雨眠aa

关注

16
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java基础--代理

通过上面的例子我们不难发现，静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改）且麻烦(需要对每个目标类都单独写一个代理类）。实际应用场景非常非常少。如果要在不同的银行进行转账，也就是有多个核心类，就会很复杂并且会破坏一些性质。这时就需要用动态代理。
复制链接

扫一扫