【静态代理】

静态代理：程序运行前就已经存在代理类的字节码文件

就是写一个类A，对另一个类B的方法进行增强。
具体的，可以把类B作为类A的成员变量，且B有A的所有方法（实现A或者继承A）；
每当调用B的方法时，我们可以调用A的对应方法去完成；在调用A之前，可以对参数进行处理，调用A之后，对返回结果进行处理。

类似于：(A对B的方法进行增强)

public class B {
    public Object method(Object args){
    	//...
    	return null;
    }
}

class A extends B{
    B b;

    public A(B b) {
        this.b = b;
    }

    @Override
    public Object method(Object args) {
        //对参数进行处理
        args = handlerArgs(args);

        Object res = super.method(args);
        
        //对结果进行处理
        res = handlerResult(res);
        
        return res;
    }

    private Object handlerResult(Object res) {
    	//...
        return null;
    }

    private Object handlerArgs(Object args) {
    	//...
        return null;
    }
}

先看一个类：Thread

• 接口类Runnable：
  
• Thread 类实现了 Runnable
  
• 有一个Runnable的成员变量
  
• 构造函数可以传Runnable
  
• 实现Runnable的run方法，调用成员变量的run：
  

这是静态代理。

现实现一个简单的静态代理：

• 有一个做饭的接口
• 厨师实现做饭接口
• 现在想要在厨师做饭前后做一些事（相当于对厨师做饭方法做增强）
  • 定义一个饭店接口
  • 在厨师做饭前准备好材料
  • 在厨师做饭后把食品提供给用户

具体代码如下：

public class Tests {
    public static void main(String[] args) {
        Hotel hotel = new Hotel(new Chef());
        hotel.cook();
    }
}

//做饭
interface Cooking {
    void cook();
}

//厨师，只管做饭
class Chef implements Cooking {
    @Override
    public void cook() {
        System.out.println("Chef 正在做饭...");
    }
}

//饭店，准备食材、厨师做饭、提供食品给顾客
class Hotel implements Cooking {
    private Cooking cooking;

	//构造函数传入接口对象
    public Hotel(Cooking cooking) {
        this.cooking = cooking;
    }

    @Override
    public void cook() {
    	//对接口对象方法做增强
        System.out.println("Hotel准备食材");
        
        cooking.cook();
        
        System.out.println("Hotel提供商品给用户");
    }
}