java 代理模式一： 静态代理

Posted 2020-08-21

代理模式：

　　代理模式的作用：为其他对象提供一种代理以控制对 特定对象  的访问。

　　某种情况下，一个客户不想或者直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用：通过代理对象引用。

代理模式一般涉及到的角色：

　　抽象角色:声明真实对象和代理对象的共同接口。可以是一个抽象类或者一个接口。

　　代理角色:代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便任何时候都能代替真实对象。

　　　　　　同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

　　真实角色:代理角色所代表的真实对象，完成实际操作。

实例1：

　　抽象类角色：

/*
 * 抽象类角色，可以定义一个接口或者抽象类
 * 这是真实对象与代理对象的共同接口
 */
public abstract class Subject {
    public abstract void request();
}

　　真实角色：

/*
 * 真实角色
 * 实现接口，完成实际工作
 */
public class RealSubject extends Subject{

    @Override
    public void request() {
        System.out.println("From Real Subject");
    }
}

　　代理角色：

/*
 * 代理角色 
 * 内部包含着对真实对象的引用，并且封装功能
 */
public class ProxySubject extends Subject {

    //代理角色对象内部含有对真实对象的引用
    private RealSubject realSubject;
    
    @Override
    public void request() {
        //在真实对象操作之前所附加的操作
        preRequest();
        
        if(null == realSubject){
            realSubject = new RealSubject();
        }
        
        //真实角色完成的事情
        realSubject.request();
        //真实角色操作之后附加的操作
        postRequest();
        
    }
    
    private void preRequest(){
        System.out.println("Pre Request");
    }

    private void postRequest(){
        System.out.println("Post Request");
    }
}

　　客户端：

public class Client {
    public static void main(String[] args) {
                //实现代理类
        Subject subject = new ProxySubject();
        subject.request();
    }
}

实例2：

　　抽象类角色：

//接口
interface ClothFactory{
    void productCloth();
}

　　被代理类(也就是真是角色)：

//被代理类，也就是真实类
class NikeClothFactory implements ClothFactory{
    @Override
    public void productCloth() {
        System.out.println("Nike工厂生产一批衣服");
    }
}

　　代理类：

class ProxyFactory implements ClothFactory{
    ClothFactory cf;
    //创建代理对象时，实际传入一个被代理类对象
    public ProxyFactory(ClothFactory cf){
        this.cf = cf;
    }
    @Override
    public void productCloth() {
        System.out.println("代理类开始执行. 收取代理费");
        cf.productCloth();
    }
}

　　客户端：

public class TestClothProduct {
    public static void main(String[] args) {
        //真实类创建
        NikeClothFactory nike = new NikeClothFactory();
        //代理类创建
        ProxyFactory proxy = new ProxyFactory(nike);
        //代理类完成真实类的工作
        proxy.productCloth();
    }
}

问题：

　　静态代理的后果是：

　　　　如果出现了大量的接口，那么代理类与真实类需要配对出现，造成类的急剧膨胀。这就需要使用java动态代理。