java代理机制

最新推荐文章于 2023-05-23 09:01:47 发布

YKW_

最新推荐文章于 2023-05-23 09:01:47 发布

阅读量229

点赞数 1

文章标签： java动态代理

本文链接：https://blog.csdn.net/qq_23581569/article/details/51112926

版权

学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

最近想写一个JDBC的动态连接池，看到动态代理那里卡住了，要理解那一段首先要理解java的代理机制
（JDBC动态连接池参考文章链接感谢作者的文章
http://www.cnblogs.com/jbelial/archive/2013/07/18/3199061.html）

      //、从连接池获取连接:通过动态代理
      public Connection getConnection() throws SQLException {
          if (pool.size() > 0) {
              final Connection conn  = pool.remove() ; 
              Connection proxyCon = (Connection) Proxy.newProxyInstance(conn.getClass().getClassLoader(), conn.getClass().getInterfaces(), 
                      new InvocationHandler() {
                          //策略设计模式：
                          @Override
                          public Object invoke(Object proxy, Method  method, Object[] args)
                                  throws Throwable {
                              if("close".equals(method.getName())){
                                  //谁调用，
                                  return pool.add(conn);//当调用close方法时，拦截了，把链接放回池中了
                              }else{
                                  return method.invoke(conn, args);
                              } 
                          }
                      });
            return proxyCon ;
          }else {
              throw new RuntimeException("服务器繁忙！"); 
          }
      }

代理机制

以下内容参考自
http://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html
http://www.cnblogs.com/machine/archive/2013/02/21/2921345.html
http://langyu.iteye.com/blog/410071
（有部分删改感谢作者的文章）

我们书写执行一个功能的函数时，经常需要在其中写入与功能不是直接相关但很有必要的代码，如日志记录，信息发送，安全和事务支持等，这些枝节性代码虽然是必要的，但它会带来以下麻烦：

1 枝节性代码游离在功能性代码之外，它下是函数的目的，这是对OO是一种破坏
2 枝节性代码会造成功能性代码对其它类的依赖，加深类之间的耦合，而这是OO系统所竭力避免的
3 枝节性代码带来的耦合度会造成功能性代码移植困难，可重用性降低

简而言之就是代理机制的目的就是把函数的一些功能分离出去，让代理类去帮你做，从而降低类之间的耦合性，提高灵活性，这样符合程序设计的低耦合原则。

代理模式的作用是：为其它对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。代理模式一般涉及到三个角色：

抽象角色：声明真实对象和代理对象的共同接口
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象
代理角色：代理对象内部包含有真实角色的引用，从而可以操作真实角色，同时代理对象 与真实对象有相同的接口，能在任何时候代替真实对象，同时代理对象可以在执行真实对 象前后加入特定的逻辑以实现功能的扩展。

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

// 抽象角色：
abstract public class Subject {
    abstract public void  request();
}

// 真实角色：实现了Subject的request()方法
public class  RealSubject  extends  Subject  {
  public  RealSubject()  { }

  public void  request()  {
     System.out.println( " From real subject. " );
    }
}

// 代理角色：
public class  ProxySubject  extends  Subject  {
  // 以真实角色作为代理角色的属性
  private  Subject realSubject;

  public  ProxySubject(Subject realSubject)  {this.realSubject = realSubject }

  // 该方法封装了真实对象的request方法
  public void  request()  {
     preRequest();   //特定的逻辑以实现功能的扩展。
     realSubject.request();  // 此处执行真实对象的request方法
     postRequest();   //特定的逻辑以实现功能的扩展。
  }
  ...
}

// 客户端调用：
RealSubject real = new RealSubject();
Subject sub = new  ProxySubject(real);
Sub.request();

java动态代理

java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：

1 Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理 类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽 象方法在代理类中动态实现。
2 Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject。
2.1 Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
2.2 Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个 代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
2.3 Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用 (可使用被代理类的在Subject接口中声明过的方法)。

在使用动态代理类时，我们必须实现InvocationHandler接口，以第一节中的示例为例：

// 抽象角色(之前是抽象类，此处应改为接口)：
public  interface Subject {
  abstract  public  void request();
}

// 具体角色RealSubject：
public  class RealSubject implements Subject {
  public RealSubject() {}

  public  void request() {
    System.out.println( " From real subject. " );
 }

}

// 代理处理器：
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;

public  class DynamicSubject implements InvocationHandler {
  private Object sub;
  public DynamicSubject() {}

  public DynamicSubject(Object obj) {
    sub = obj;
  }

  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println( " before calling "  + method);
    method.invoke(sub,args);

    System.out.println( " after calling "  + method);
    return  null ;
  }
}

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的
method.invoke(sub,args);
其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些相关操作。

也就是说当你想调用RealSubject对象的request方法时，用动态代理机制的方式来实现这一过程的话就是subject.request() subject是代理对象而subject.request()就会去调用invoke（）方法 invoke()方法里面包含了method.invoke(sub,args) 和一些额外操作，这些额外的操作就是为了达到解耦的目的从真实类Realsubject剥离出来放在代理类中的。然后method.invoke(sub,args)就会去执行RealSubject对象的request方法

// 客户端：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Client {

  static public void main(String[] args) throws Throwable {
   RealSubject rs = new RealSubject();         // 在这里指定被代理类
   DynamicSubject ds = new DynamicSubject(rs);     //生成代理处理器 
   Class cls = rs.getClass();           //获取被代理类的类信息类

   // 把被代理类和代理处理器关联起来生成代理类
   Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );
   //由代理类来执行request( )方法
   subject.request();
  }
}

// 程序运行结果：
before calling public abstract void Subject.request()
From real subject.
after calling public abstract void Subject.request()