`
persistC
  • 浏览: 73548 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

动态代理

阅读更多

从JDK1.3开始,Java就引入了动态代理的概念。动态代理(Dynamic Proxy)可以帮助你减少代码行数,真正提高代码的可复用度。例如,你不必为所有的类的方法里面都写上相同的Log代码行,取而代之的是实用类的动态代理类。当然,这种便利是有条件的。本文简单介绍Java动态代理的原理,并实现一个被代理的Servlet创建,和调用的过程。

1.代理模式(Proxy Pattern)
在JDK1.3以前,代理模式就已流行,所以得代理模式是生成一个和类相同接口的代理类,用户通过使用代理类来封装某个实现类。如图1,其目的是加强实现类的某个方法的功能,而不必改变原有的源代码。


2.动态代理(Dynamic Proxy)
随着Proxy的流行,Sun把它纳入到JDK1.3实现了Java的动态代理。动态代理和普通的代理模式的区别,就是动态代理中的代理类是由java.lang.reflect.Proxy类在运行期时根据接口定义,采用Java反射功能动态生成的。和java.lang.reflect.InvocationHandler结合,可以加强现有类的方法实现。如图2,图中的自定义Handler实现InvocationHandler接口,自定义Handler实例化时,将实现类传入自定义Handler对象。自定义Handler需要实现invoke方法,该方法可以使用Java反射调用实现类的实现的方法,同时当然可以实现其他功能,例如在调用实现类方法前后加入Log。而Proxy类根据Handler和需要代理的接口动态生成一个接口实现类的对象。当用户调用这个动态生成的实现类时,实际上是调用了自定义Handler的invoke方法。 
 



3.动态代理Servlet
              虽然Web Application Server的产品很多,但Servlet的处理原理是相似的:动态加载Servlet,调用Servlet的init方法(只被调用一次),并保存到Servlet容器;Servlet使用时,调用Servlet的service方法。本文动态代理Servlet接口,使其init和service被调用时会在控制台打出方法调用前后信息。
首先实现2个Servlet,DefaultServlet和UserServlet

package org.colimas.servlet;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

public class DefaultServlet extends HttpServlet implements Servlet {
              public void init() throws ServletException {
                            super.init();
                            System.out.println(DefaultServlet.class.getName()+":Running init");
              }

              public String getServletInfo() {
                            return DefaultServlet.class.getName();
              }
}

package org.colimas.servlet;

import java.io.IOException;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class UserServlet extends HttpServlet implements Servlet {

              private static final long serialVersionUID = -7016554795165038652L;
             
              public void init() throws ServletException {
                            super.init();
                            System.out.println(UserServlet.class.getName()+":Running init");
              }
              protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
                                         
                            System.out.println(UserServlet.class.getName()+":Do UserSErvlet Get");
              }
              public String getServletInfo() {
                            return UserServlet.class.getName();
              }            
             

}

然后实现InvocationHandler
package org.colimas.webapp;

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

import javax.servlet.Servlet;

public class ServletHandler implements InvocationHandler {

              private Servlet obj;
             
              public ServletHandler(Servlet obj){
                            this.obj=obj;
              }
              public Object invoke(Object arg0, Method arg1, Object[] arg2)
                                          throws Throwable {
                           
                            if(arg1.getName().compareTo("init")==0) //调用init时
                            {
                                          System.out.println(obj.getServletInfo()+":Init servlet starting..."); //增加控制台输出。
                                          arg1.invoke(obj,arg2); //调用init方法
                                          System.out.println(obj.getServletInfo()+":Init servlet ending..."); //增加控制台输出。
                            }else if(arg1.getName().compareTo("service")==0){ //调用service时
                                          System.out.println(obj.getServletInfo()+":service starting..."); //增加控制台输出。

                                          arg1.invoke(obj,arg2); //调用service方法。
                                          System.out.println(obj.getServletInfo()+":service ending..."); //增加控制台输出。
                           
                            }
                            return null;
              }

}

实现Servlet的调用
package org.colimas.webapp;

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

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;

public class ServletWrapperImp {
   
    private Class servletClass;
    private ServletConfig config;
    private String _servletname;
    private Servlet _theServlet;
              private ServletContext context;
    public ServletWrapperImp(ServletConfig config){
           this.config=config;
           this._servletname=this.config.getServletName();
           this.context=this.config.getServletContext();
    }
   
    public Servlet getServlet() throws ServletException{

                              destroy();
                              try {
                                            WebAppClassLoader loader=new WebAppClassLoader(this.getClass().getClassLoader()); //自定义class loader
                                            String name=getServletName(); //从ServletConfig中获得Servlet Name
                                            synchronized (context) {
                                                          Servlet theServlet=context.getServlet(name); //在ServletContext中查找Servlet
                                                          if(theServlet==null){         //如果ServletContext没有。              
                                                                        servletClass = loader.loadClass(name); //由Class loader 加载Servlet class。
                                                              theServlet = (Servlet) servletClass.newInstance(); //Servlet实例化。
                                                              WebAppContext.addServlet(name,theServlet); //将Servlet实例存入ServletContext。
                                                                        InvocationHandler handler=new ServletHandler(theServlet); //自定义ServletHandler,参见ServletHandler类。
                                                                        _theServlet=(Servlet)Proxy.newProxyInstance(theServlet.getClass().getClassLoader(),
                                                                                   new Class[]{Servlet.class},handler); //代理类实例化。
                                                                        _theServlet.init(config); //Servlet代理对象调用init方法。参见ServletHandler的invoke方法。
                                                                       
                                                          }else{ //ServletContext里已存在。
                                                                        InvocationHandler handler=new ServletHandler(theServlet); //自定义ServletHandler,参见ServletHandler类。
                                                                        _theServlet=(Servlet)Proxy.newProxyInstance(theServlet.getClass().getClassLoader(),
                                                                                   new Class[]{Servlet.class},handler);                 //代理Servlet接口,动态生成代理类,并实例化。                                  
                                                          }
                                            }
                                            return _theServlet; //返回Servlet代理对象
                              } catch( ClassNotFoundException ex1 ) {
                                
                              } catch( InstantiationException ex ) {
                                 
                              }catch(IllegalAccessException ex2){
                                           
                              }
                      return null;
    }
    public void destroy() {
        if (_theServlet != null) {
                      _theServlet.destroy();
        }
    }   
   
    protected String getServletName(){
           return _servletname;
    }
}

其中的ServletConfig保存Servlet相关信息。ServletContext保存所有的Servlet对象。WebAppClassLoader为自定义class loader,参见http://blog.csdn.net/tyrone1979/archive/2006/09/03/1164262.aspx。

最后编写测试类Main,该类模拟10个用户访问Servlet,5人访问DefaultServlet,5人访问UserServlet。
package org.colimas.main;

import java.io.IOException;

import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;

import org.colimas.webapp.HttpServletRequestWrapper;
import org.colimas.webapp.HttpServletResponseWrapper;
import org.colimas.webapp.ServletConfigImpl;
import org.colimas.webapp.ServletWrapper;
import org.colimas.webapp.ServletWrapperImp;
import org.colimas.webapp.WebAppContext;

public class Main {

              private ThreadGroup _threadGroup;
              private Thread[] _threads;
              String defaultServletName="org.colimas.servlet.DefaultServlet";
              String userServletName="org.colimas.servlet.UserServlet";
              WebAppContext context=WebAppContext.newInstance();     
             
              public void doStart(){
             
                            _threadGroup=new ThreadGroup("SERVLETS");
                            int i=0;
                            _threads=new ServletThread[10]; //模拟10位用户。
                            for(i=0;i<5;i++){
                                          _threads[i]=new ServletThread(_threadGroup,new Integer(i).toString(),
                                                                      defaultServletName);
                                          _threads[i].start();
                            }
                            for(i=5;i<10;i++){
                                          _threads[i]=new ServletThread(_threadGroup,new Integer(i).toString(),
                                                                      userServletName);
                                          _threads[i].start();
                            }                          
                           
              }
              /**
               * @param args
               */
              public static void main(String[] args) {
                            Main _main=new Main();
                            _main.doStart();
                           
              }
              //模拟用户线程
              private class ServletThread extends Thread{
                           
                            private String servletName;
                           
                            public ServletThread(ThreadGroup group,String threadname,String servletname){
                                          super(group,threadname);
                                          servletName=servletname;
                            }
                            //调用Servlet的service.
                            public void run() { //用户调用Servlet
                                          ServletConfig config=new ServletConfigImpl(servletName,context); //调用的Servlet信息。
                                          ServletWrapperImp wrapper=new ServletWrapperImp(config);
                                          try {
                                                        Servlet defaultServlet=wrapper.getServlet(); //获得Servlet对象,实际是Servlet的代理对象
                                                        defaultServlet.service(new HttpServletRequestWrapper(),
                                                                                    new HttpServletResponseWrapper()); 调用代理对象的service方法,参见ServletHandler的invoke方法。
                                          } catch (ServletException e) {
                                                                                                                e.printStackTrace();
                                          } catch(IOException e){
                                                       
                                          }
                            }
                           
              }
}
HttpServletRequestWrapper和HttpServletResponseWrapper实现HttpServletRequest,和HttpServletResponse。
测试结果如下
org.colimas.servlet.DefaultServlet:Init servlet starting...
org.colimas.servlet.DefaultServlet:Running init
org.colimas.servlet.DefaultServlet:Init servlet ending...
org.colimas.servlet.UserServlet:Init servlet starting...
org.colimas.servlet.UserServlet:Running init
org.colimas.servlet.UserServlet:Init servlet ending...
org.colimas.servlet.DefaultServlet:service starting...
org.colimas.servlet.DefaultServlet:service ending...
org.colimas.servlet.DefaultServlet:service starting...
org.colimas.servlet.DefaultServlet:service ending...
org.colimas.servlet.UserServlet:service starting...
org.colimas.servlet.UserServlet:Do UserSErvlet Get
org.colimas.servlet.UserServlet:service ending...
org.colimas.servlet.UserServlet:service starting...
org.colimas.servlet.UserServlet:Do UserSErvlet Get
org.colimas.servlet.UserServlet:service ending...
org.colimas.servlet.UserServlet:service starting...
org.colimas.servlet.UserServlet:Do UserSErvlet Get
org.colimas.servlet.UserServlet:service ending...
org.colimas.servlet.UserServlet:service starting...
org.colimas.servlet.DefaultServlet:service starting...
org.colimas.servlet.UserServlet:service starting...
org.colimas.servlet.DefaultServlet:service starting...
org.colimas.servlet.DefaultServlet:service starting...
org.colimas.servlet.UserServlet:Do UserSErvlet Get
org.colimas.servlet.DefaultServlet:service ending...
org.colimas.servlet.UserServlet:Do UserSErvlet Get
org.colimas.servlet.DefaultServlet:service ending...
org.colimas.servlet.DefaultServlet:service ending...
org.colimas.servlet.UserServlet:service ending...
org.colimas.servlet.UserServlet:service ending...

2个Servlet第一次Load时初始化,被调用init,之后保存到ServletContext中。第二次直接从ServletContext获得,执行service。红字表示代理类里增加的输出结果。

4.动态代理的限制
              JDK的动态代理并不能随心所欲的代理所有的类。Proxy.newProxyInstance方法的第二个参数只能是接口数组, 也就是Proxy只能代理接口。

 

分享到:
评论

相关推荐

    spring+动态代理

    在Java编程中,动态代理是一种强大的工具,它允许我们在运行时创建对象的代理,以便在调用实际方法之前或之后执行额外的操作。Spring框架提供了一种便捷的方式来实现动态代理,这使得我们可以在不修改原有代码的情况...

    动态代理设计模式 日志和源码

    动态代理设计模式是一种在运行时创建代理对象的技术,它允许我们为现有的对象提供额外的功能,如日志记录、性能监控、事务管理等,而无需修改原对象的代码。这种模式在Java和许多其他编程语言中都有应用,尤其在...

    关于jdk动态代理的源码剖析

    ### 关于JDK动态代理的源码剖析 #### 一、引言 在Java开发过程中,动态代理技术是一项非常实用的技术,它可以帮助我们实现在不修改原有代码的基础上为方法增加额外的功能,比如日志记录、权限校验等。本文将深入...

    浅谈JDK动态代理与CGLIB代理去区别

    在Java开发中,动态代理和CGLIB代理是两种常见的面向切面编程(AOP)实现方式,它们都用于在不修改原有代码的情况下,增强或扩展对象的功能。本篇文章将深入探讨JDK动态代理和CGLIB代理的区别,以及它们在实际应用中...

    JDK动态代理_JDK动态代理

    ### JDK动态代理详解 #### 一、引言 在软件工程中,代理模式是一种常见的设计模式,它通过为一个对象提供一个替代品或占位符来控制对这个对象的访问。这种模式通常用于添加额外的功能(例如日志记录、事务管理等)...

    qt qtableview动态代理

    然而,QTableView的功能可以进一步增强,通过实现动态代理(Dynamic Proxy)来扩展其交互性。动态代理允许我们在表格的单元格内嵌入其他UI元素,比如QSpinBox、QCheckBox或QComboBox,从而提供更丰富的用户交互体验...

    Java动态代理两种实现方式

    Java动态代理技术是Java编程中一个非常重要的特性,它允许我们在运行时动态创建具有特定行为的对象。这种技术常用于AOP(面向切面编程)和框架中,如Spring AOP,用于实现方法拦截、事务管理等功能。Java提供了两种...

    JVM技术,反射与动态代理

    本主题将深入探讨JVM技术,特别是反射与动态代理这两个关键特性。 一、JVM技术 1. 类加载机制:JVM通过类加载器(ClassLoader)来加载.class文件,分为启动类加载器、扩展类加载器和应用程序类加载器。类的加载...

    Jdk动态代理和cglib动态代理原理

    Java中的动态代理是一种重要的设计模式,它允许在运行时创建具有特定行为的代理对象,以扩展或增强原有对象的功能。动态代理主要分为两种技术:JDK动态代理和CGLIB动态代理。 ### JDK动态代理 JDK动态代理是Java...

    java + 动态代理 + 动态代理实际应用场景

    1:静态代理出现的实际背景,静态代理时如何演化成动态代理 2: 动态代理demo 举例实际应用场景(载入数据库驱动的时候,使用AIDL与系统Servic进行通信) 3: 动态代理使用到基础理论:ClassLoader 加载.class字节码...

    静态代理和动态代理Demo

    静态代理和动态代理是两种常见的代理模式,它们在Java中有着广泛的应用,特别是在SpringBoot等框架中。本资源提供了一个简单的Java实现,适用于JDK1.8版本,并经过了验证,对初学者理解设计模式具有指导意义。 静态...

    Java静态代理和动态代理

    Java的代理模式通过代理类提供了对委托类的扩展和控制,静态代理适合对已有代码不做修改的情况,而动态代理则提供了更高的灵活性和扩展性。在实际应用中,应根据项目需求和性能考虑选择静态代理或动态代理。对于需要...

    springboot中的 动态代理的选择测试代码

    在Spring Boot应用中,动态代理是一种非常重要的技术,主要用于实现AOP(面向切面编程)。在本场景下,"springboot中的 动态代理的选择测试代码"涉及到的是如何在Spring Boot环境中利用Java或CGLIB动态代理来实现...

    spring之AOP(动态代理)

    在Spring中,AOP主要通过两种动态代理技术实现:JDK动态代理和CGLIB动态代理。 首先,让我们详细了解一下JDK动态代理。JDK动态代理基于Java的接口实现,它适用于目标对象实现了至少一个接口的情况。在运行时,JDK...

    一篇讲动态代理的好文 <动态代理的前世今生>

    ### 动态代理的前世今生 #### 一、引言 动态代理作为一种广泛应用于软件开发中的设计模式,其重要性不言而喻。本文旨在深入探讨动态代理的概念、原理及其实现方式,并通过实例帮助读者更好地理解动态代理的应用...

    jdk动态代理技术详解

    JDK 动态代理技术详解 JDK 动态代理技术是 Java 语言自身对动态代理的支持,类似于 JDK 中在 java.util 包中提供 Observable 类和 Observer 接口提供对观察者模式的语言级支持。动态代理的优点是可以动态地为软件...

    动态代理例子

    动态代理在Java编程中是一种非常重要的技术,它允许我们在运行时创建代理类,这些代理类可以作为原有类的“中间人”,在调用原始方法之前或之后执行额外的操作。这通常用于实现AOP(面向切面编程)的概念,如日志、...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    动态代理是实现AOP的一种常用技术,它允许在运行时创建代理对象,拦截对真实对象的调用,并在调用前后添加额外的行为。 在Java开发中,反射机制是实现动态代理的关键技术之一。反射提供了在运行时访问和操作类的...

    动态代理和静态代理demo

    代理模式通常分为静态代理和动态代理两种实现方式,这里我们将详细探讨这两种代理模式,并通过一个简单的Java示例进行演示。 ### 静态代理 静态代理是最基础的代理形式,它的实现主要依靠继承或接口实现。在静态...

    JDK动态代理和CGLIB代理

    Java动态代理是Java编程中一个重要的特性,它允许我们在运行时创建对象的代理,从而实现对原对象的一些额外操作或扩展功能。JDK动态代理和CGLIB代理是两种常用的实现方式。 首先,我们来看看JDK动态代理。JDK动态...

Global site tag (gtag.js) - Google Analytics