java代理模式——动态代理

sq1990

                                      代  理  模  式

 

 

   1 静态代理
   
 原理：

    真实对象很干净，代理对象代理真实对象需要做的事情，并且加入了一些辅助的事情

 作用：

     代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。

  代理模式一般设计到的角色：

    

    抽象角色:声明真实对象和代理对象的共同接口

    代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时

    代理对象提供了真实对象相同接口以便任何时候都能替代真实对象。同时,代理对象

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

    真实角色:代理角色所代表的真实对象,是我们最终要引用的对象。

 首先介绍下这个程序的意思：

        你要买房子，但你不认识局长，你只认识他的小蜜，因此你会去找她，让他代理你去找局长办事情。
    局长，
    小蜜，---> 代理对象
    你（买房子）---> 真实对象
  
      接口：  buyHouse();

抽象角色：
public abstract class AbstractClass {

 public abstract void buyHouse();
}

 

真实角色：

public class RealObject extends AbstractClass{
 public void buyHouse() {
  System.out.println("我是真正要买房子的人");
 }
}

代理角色：

/**
 * 小蜜
 *
 */
public class ProxyObject extends AbstractClass{

 private RealObject relObj = null;
 
 public void before(){
  
  System.out.println("买戒指，不然不办");
 }
 
 @Override
 public void buyHouse() {
  this.before();
  if(relObj == null){
   relObj = new RealObject();
  }
  relObj.buyHouse();
  this.after();
 }
 public void after(){
  System.out.println("常联系............");
 }

}

 

客户端测试：

 public class Client {

public static void main(String[] args) {

  AbstractClass absClss = new ProxyObject();
  absClss.buyHouse();
  
 }
}

2. 动态代理

为什么会有动态代理呢？

        在静态代理模式时,一个真实角色必须对应一个代理角色,如果大量使用会导致类的急剧膨胀;

1.抽象类或者接口

    public interface ISubject {
 
 public void sayHello();
}

2. 真实类（必须实现接口）

public class RealObject implements ISubject {
 public void sayHello() {

  System.out.println("hello glad to see you");
 }

}

3.动态创建代理对象的类（此时不能出现代理对象）

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxy implements InvocationHandler{

 //拿到对真实对象的引用（因为真实对象可能有很多个，因此我们必须定义成Object类型去任意匹配）

//此时实现的是对任意真实兑现给的引用。此处也是固定的写法

  private Object targetObject = null;
 
 //方法--> 用来动态的生成代理对象(通过反射在运行期分析类的能力，然后动态生成)

//注意只要是在运行期分析类的能力，都回去涉及到反射方法。
  /***
  * 1， 通过反射进入类的加载器
  * 2，和真实对象实现相同的接口
  * 3，一个对象，这个对象实现了InvocationHandler这个接口的对象的引用
  */

//这个方法也是固定的写法
 public Object createDynamicProxyObjectMethod(Object targetObject){
  this.targetObject = targetObject;//因为是要真实对象的代理，所以这块必须引入真实对象
  return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), //这个参数是得到类的加载器
           targetObject.getClass().getInterfaces(), 
           this); //此处的this急救等于 new DynaProxyObject()
 }
 
 //被系统自动调用的：只有这个方法时需要自己写的方法
 
 public Object invoke(Object proxy, Method method, Object[] args)

//注意此处的method不能是数组，若有n多接口或方法时只能是用if去判断及if（method 。equals("")）;

//参数args表示方法的参数，参数可以位任意的类型，因此用Object[]去匹配
   throws Throwable {
  
  Object resultObj = null;
  
  this.before();
  
  try {
   resultObj = method.invoke(targetObject, args);
  } catch (Exception e) {
   e.printStackTrace();
  }
  
  this.after();
  
  return resultObj;
 }

 public void before(){
  System.out.println("before---------------");
 }
 
 public void after(){
  System.out.println("after---------------");
 }
 
}

 

4。客户端测试

public class Client {
 
 public static void main(String[] args) {
  DynaProxyObject dpo = new DynaProxyObject();
  ISubject isub = (ISubject)dpo.createDynamicProxyObject(new RealObject());
  isub.sayHello();
 }
}