Java：静态代理

在Java中，代理模式是一种结构型设计模式，它允许我们通过一个代理对象来间接地访问实际对象。这样做的目的通常是为了在不改变实际对象接口的前提下，添加额外的功能或控制。在Java中，代理主要有两种实现方式：静态代理和动态代理。

静态代理（Static Proxy）

静态代理是在编译时就已经确定的代理关系，它需要开发者手动创建代理类。静态代理通常用于编译时已知的代理关系，或者当代理逻辑较为固定时。

创建静态代理的步骤：

1. 定义接口：首先，需要定义一个接口，该接口将被实际对象和代理对象共同实现。
2. 创建代理类：代理类也实现相同的接口，并在其中封装实际对象的引用。代理类中的方法通常会在适当的时候调用实际对象的对应方法，并在调用前后添加额外的行为。
3. 实现代理逻辑：在代理类中，可以添加额外的逻辑，例如权限检查、日志记录、事务处理等。
4. 使用代理对象：在客户端代码中，通过代理类实例来代替实际对象的实例，从而实现对实际对象的间接访问。

示例代码一：

// 定义一个接口
public interface ImageLoader {
    void load(String url);
}

// 实际对象
public class RealImageLoader implements ImageLoader {
    @Override
    public void load(String url) {
        System.out.println("RealImageLoader loading image from: " + url);
    }
}

// 代理类
public class ImageLoaderProxy implements ImageLoader {
    private RealImageLoader realImageLoader;

    public ImageLoaderProxy(RealImageLoader realImageLoader) {
        this.realImageLoader = realImageLoader;
    }

    @Override
    public void load(String url) {
        // 代理逻辑
        checkAccess(url);
        // 调用实际对象的方法
        realImageLoader.load(url);
        // 其他代理逻辑
        saveImage(url);
    }

    private void checkAccess(String url) {
        System.out.println("Checking access for: " + url);
    }

    private void saveImage(String url) {
        System.out.println("Saving image from: " + url);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建实际对象
        RealImageLoader realImageLoader = new RealImageLoader();
        // 创建代理对象
        ImageLoaderProxy proxy = new ImageLoaderProxy(realImageLoader);
        // 使用代理对象
        proxy.load("http://example.com/image.jpg");
    }
}

---

在这个例子中，ImageLoaderProxy是一个静态代理类，它实现了与RealImageLoader相同的ImageLoader接口。客户端代码通过ImageLoaderProxy实例来加载图片，而ImageLoaderProxy内部则调用了RealImageLoader的方法，并在调用前后添加了额外的逻辑。

---

示例代码二：

package Thread02;

//静态代理模式总结：
    /*
    真实对象和代理对象都要实现同一个接口
    代理对象要代理真实角色
    好处：
        代理对象可以做很多真实对象做不了的事情
        真实对象专注做自己的事情
     */

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany=new WeddingCompany(new You());
        weddingCompany.HappyMarry();

    }
}


interface Marry{
    void HappyMarry();
}

//真实角色，you
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("very happy!!");
    }
}

//代理角色
class WeddingCompany implements Marry{
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void before() {
        System.out.println("Before--布置");
    }

    private void after() {
        System.out.println("after--收尾款");
    }
}

总结

静态代理是一种简单直接的代理实现方式，但它的缺点是不够灵活。如果需要为多个不同的实际对象创建代理，就需要编写多个代理类，这会增加代码的复杂性。在这种情况下，可以考虑使用动态代理，它允许在运行时动态生成代理类，从而提高代码的可维护性和灵活性。