java回顾总结--代理模式

---

一、代理模式

1.1 静态代理

代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。比如你按照小卡片上的电话打过去寻求服务，一般不是由本人，可能是一个成年雄性接听电话，然而真正做事情的可能是另一个小姐姐。
目的:

• (1)通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性
• (2)通过代理对象对访问进行控制;

代理模式一般会有三个角色：

• 抽象角色：

指代理角色和真实角色对外提供的公共方法，一般为一个接口

• 代理角色:

需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理

• 真实角色（被代理角色）：

需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业务逻辑在此。

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。一般来说，被代理对象和代理对象是一对一的关系，当然一个代理对象对应多个被代理对象也是可以的。

• 一对一情况下：
  静态代理对象数量多：在一对一的情况下，如果每个接口或类都需要一个对应的代理类，那么随着业务逻辑的增加，代理对象的数量也会随之增加。这样会导致代码量大，因为每个接口或类都需要一个对应的代理类，从而增加了代码的复杂性。
  代码量大、可维护性差：由于静态代理需要为每个被代理对象创建一个代理对象，当业务逻辑变得复杂时，代理对象的数量会快速增加，导`致代码量庞大。这样会使得代码难以维护，因为每个代理对象都需要单独管理，增加了代码的复杂性和维护成本。
• 一对多情况下：
  代理对象扩展能力差：在一对多的情况下，如果需要为多个接口或类创建统一的代理对象，这样可能会导致代理对象的扩展能力较差。因为代理对象需要同时处理多个接口或类的请求，如果后续需要对某个接口或类的代理逻辑进行修改或扩展，可能会影响到其他接口或类的代理逻辑。

为了解决上述问题，可以考虑使用动态代理模式来代替静态代理。动态代理可以减少代理类的数量，提高代码的复用性和可维护性。

示例

/**
 * 代理抽象角色： 定义了服务的接口
 */
public interface Massage {
    void massage();
}

/**
 * 足浴
 */
public interface Wash {
    void wash();
}

/**
 *  实现类： 提供服务的proxy1
 */
public class proxy1 implements Massage, Wash {

    @Override
    public void massage() {

        System.out.println("精通各种按摩手法");
    }

    @Override
    public void wash() {

    }
}

/**
 * 实现类： 提供服务的proxy2
 */
public class proxy2 implements Massage {

    @Override
    public void massage() {
        System.out.println("36D，手法一流");
    }
}
/**
 * 代理对象：经纪人
 */
public class Agent implements Massage {

    private final Massage massage;

    public Agent(Massage massage) {
        this.massage = massage;
    }

    //....前置处理
    public void before() {
        System.out.println("一条龙服务,包君满意");
    }

    //....后置处理
    public void after() {
        System.out.println("满意度调查");
    }

    @Override
    public void massage() {
        before();
        massage.massage();
        after();
    }
}

public class MyClass {
    public static void main(String[] args){
        //静态代理
        Massage message = new proxy2();
        Agent agent = new Agent(message);
        agent.massage();
		}
}

输出：

---

1.2 动态代理

在运行时再创建代理类和其实例，因此显然效率更低。要完成这个场景，需要在运行期动态创建一个Class。JDK提供了 Proxy 来完成这件事情。实际上， Proxy.newProxyInstance 会创建一个Class，与静态代理不同，这个Class不是由具体的.java源文件编译而来，即没有真正的文件，只是在内存中按照Class格式生成了一个Class。

示例

/**
 * 足浴
 */
public interface Wash {

    void wash();
}
/**
 * 代理抽象角色： 定义了服务的接口
 */
public interface Massage {
    void massage();
}

public class proxy1 implements Massage, Wash {
    @Override
    public void massage() {

        System.out.println("精通各种按摩手法");
    }

    @Override
    public void wash() {
    	 System.out.println("精通各种洗脚手法");
    }
}

public class proxy2 implements Massage {

    @Override
    public void massage() {
        System.out.println("36D，手法一流");
    }
}

public class MyClass {
    public static void main(String[] args) throws Exception {        
        //动态代理
        proxy1 proxy1 = new proxy1();

        Object o = Proxy.newProxyInstance(MyClass.class.getClassLoader(),
                new Class[]{Massage.class,Wash.class}, new InvocationHandler() {
                    @Override
                    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                        //System.out.println(o.toString());  //会报栈溢出
                        return method.invoke(proxy1,objects);
                    }
                });

        Massage massage = (Massage) o;
        massage.massage();

        Wash wash = (Wash) o;
        wash.wash();
    }
}

输出：

---

二、总结

静态代理在一对一情况下可能会导致代码量大、可维护性差，而在一对多情况下可能会出现代理对象扩展能力差的问题。为了解决这些问题，可以考虑使用动态代理以及其他设计模式来提高代码的灵活性和可维护性。