当前位置：首页 > article >正文

Java 代理（一）静态代理

article 2025/3/31 20:24:35

学习代理的设计模式的时候，经常碰到的一个经典场景就是想统计某个方法的执行时间。

1 静态代理模式的产生

需求1. 统计方法执行时间

统计方法执行时间，在很多API/性能监控中都有这个需求。

下面以简单的计算器为例子，计算加法耗时。代码如下：


public Long add(Integer a, Integer b) {
        long result = 0;
        for(int i=0; i<100000000; i++) {
            result += i + a + b;
        }
        return result;
}

方法很简单，就是计算两数之和。这里为了方便统计耗时，所以循环了很多次。

统计耗时，那么实现起来也很简单：

public Long add(Integer a, Integer b) {

        long start = System.currentTimeMillis();

        long result = 0;
        for(int i=0; i<100000000; i++) {
            result += i + a + b;
        }

        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - start) + "ms");
        return result;
    }

统计代码和业务代码，杂糅在一起，是否是感觉有点混乱，有没有一种方法：在不影响原有业务逻辑情况下实现统计耗时的功能？

需求2.不影响原有业务逻辑，实现方法的耗时统计

很快我们想到一种方法，那就是定义一个父类，专门做耗时统计，业务代码通过抽象方法定义，子类扩展具体的业务方法即可。

代码如下：

public abstract class AbstractTime {
    public Long tickTock(Integer a, Integer b) {
        long start = System.currentTimeMillis();

        long result = calculate(a,b);

        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - start) + "ms");
        return result;
    }

    protected abstract Long add(Integer a, Integer b);
}

计算加法的耗时统计如下：

public class AddTime extends AbstractTime {
    @Override
    public Long add(Integer a, Integer b) {

        long result = 0;
        for(int i=0; i<100000000; i++) {
            result += i + a + b;
        }
        return result;
    }

    public static void main(String[] args){
        AddTime addTime = new AddTime();
        addTime.tickTock(1, 2);
    }
}

很好，实现无侵入式统计方法耗时，完成既定目标。

那么问题又来了，假如我们这个方法还需要继承另外一个类，这个时候怎么办呢？

需求3：使用接口方式，实现无侵入式统计方法耗时

我们先把需要实现的业务逻辑，通过接口的方式封装起来，定义一个接口。

public interface Calculator {
    Long add(Integer a, Integer b);
}

实现业务接口的方法类：

public class AddCalculator implements Calculator {
    @Override
    public Long calculate(Integer a, Integer b) {
        long result = 0;
        for(int i=0; i<100000000; i++) {
            result += i + a + b;
        }
        return result;
    }
}

使用接口，无侵入式实现方法耗时统计的方案就是，设计模式里的经典方案：代理模式。

这里使用代理模式，实现的代理类如下：

public class AddCalculatorProxy implements Calculator {
    private Calculator calculator;

    public AddCalculatorProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public Long calculate(Integer a, Integer b) {
        long start = System.currentTimeMillis();
        
        // 具体的业务逻辑类
        Long result = calculator.add(a, b);
        
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - start) + "ms");
        return result;
    }
    
    public static void main(String[] args) {
        Calculator calculator = new AddCalculator();
        Calculator proxy = new AddCalculatorProxy(calculator);
        proxy.add(1, 2);
    }
}

这就是静态代理模式的推演过程。

2. 静态代理模式是什么

静态代理模式是一种设计模式，用于在不修改目标对象的前提下，通过代理对象来控制对目标对象的访问。以下是关于静态代理模式的详细说明：

2.1. 定义

静态代理模式中，代理类和目标类实现相同的接口，代理类持有目标类的实例，并通过代理类间接调用目标类的方法。代理类可以在方法执行前后添加额外的逻辑。

2.2. 特点

接口：目标类和代理类都实现了同一个接口。
代理类：代理类持有一个目标类的引用，并在其方法中调用目标类的方法。
扩展性：可以在不修改目标类的情况下，通过代理类添加额外的功能（如日志记录、性能监控等）。

2.3. 代码分析

根据上面的例子，以下是对静态代理模式的实现分析：

接口定义

public interface Calculator {
    Long add(Integer a, Integer b);
}

定义了一个 Calculator 接口，包含一个 add 方法。

目标类：

public class AddCalculator implements Calculator {
    @Override
    public Long calculate(Integer a, Integer b) {
        long result = 0;
        for(int i=0; i<100000000; i++) {
            result += i + a + b;
        }
        return result;
    }
}

AddCalculator 是目标类，实现了 Calculator 接口。
提供了具体的业务逻辑（例如计算两个数的和并进行循环累加）。

代理类

public class AddCalculatorProxy implements Calculator {
    private Calculator calculator;

    public AddCalculatorProxy(Calculator calculator) {
        this.calculator = calculator;
    }

    @Override
    public Long calculate(Integer a, Integer b) {
        long start = System.currentTimeMillis();
        
        // 调用目标类的业务逻辑
        Long result = calculator.add(a, b);
        
        long end = System.currentTimeMillis();
        System.out.println("cost time: " + (end - start) + "ms");
        return result;
    }
}

AddCalculatorProxy 是代理类，也实现了 Calculator 接口。
持有一个 Calculator 类型的目标类实例。
在 calculate 方法中，代理类在调用目标类的 add 方法前后添加了时间统计的逻辑。

测试代码

public static void main(String[] args) {
    Calculator calculator = new AddCalculator();
    Calculator proxy = new AddCalculatorProxy(calculator);
    proxy.add(1, 2);
}

创建目标类实例 AddCalculator。
使用代理类 AddCalculatorProxy 包装目标类实例。
调用代理类的 add 方法时，会自动执行代理类中的额外逻辑（如性能统计）。