`
Ryan200909
  • 浏览: 9331 次
社区版块
存档分类
最新评论

实现自己的可重用拦截器机制

    博客分类：
  • AOP
拦截器AOP 
阅读更多

AOP技术是spring框架的一个重要特征。通过该特性能够在函数运行之前，之后，或者异常处理的时候执行我们需要的一些操作。

下面我们就是需要抛开AOP，Spring这样成型的框架不用，而仅仅使用java反射机制中的Proxy,InvocationHandler来实现类似Spring框架的拦截器的效果。

动态代理DynamicProxy

首先，在设计这个拦截器框架之前，我们需要明白java中动态代理是什么？我想如果早就清楚请直接跳过，如果需要了解，那我想你手边最好有一个javadoc的电子书。

Java.lang.reflect.Proxy是反射包的成员之一。具体说明请查javadoc。
用法就是比如有一个对象，我们需要在调用它提供的方法之前，干点别的什么，就不能直接调用它，而是生成一个它的代理，这个代理有这个对象所提供的所有接口方法，我们通过直接调用代理的这些方法，来实现：函数既能像原来对象的那样工作，又能在函数运行过程前后加入我们自己的处理。

这个类有个非常重要的函数用来实现某个类的代理：

Java代码 复制代码 收藏代码
  1. Object java.lang.reflect.Proxy.newProxyInstance(ClassLoader loader,    
  2.              Class<?>[] interfaces,    
  3.              InvocationHandler h) throws IllegalArgumentException   
Object java.lang.reflect.Proxy.newProxyInstance(ClassLoader loader, 
             Class<?>[] interfaces, 
             InvocationHandler h) throws IllegalArgumentException



参数有点迷惑人，解释下：
ClassLoader 是类加载器，这个参数用来定义代理类，一般使用原对象的即可，也可以为null用上下文解决。
Class<?>[] 接口数组,就是我们需要这个代理能够提供原来的类的什么函数。如果全部则直接class.getInterfaces()来解决.
InvocationHandler 调用处理器，这个就是如果你调用代理的方法，那么这个处理器就会被关联过来，处理调用这个函数的整个过程。这个接口只定义了一个方法：

Java代码 复制代码 收藏代码
  1. public Object invoke(Object proxy, Method method,    
  2.                   Object[] args) throws Throwable;   
public Object invoke(Object proxy, Method method, 
                  Object[] args) throws Throwable;


参数中proxy就是你调用的代理，method指的是你调用的代理的那个方法，args是传给该方法的参数。

我们生成某个类的代理步骤，一般需要先考虑我们在调用这个类的函数的时候（之前，或者之后）如何处理某些事情，因此我们首先考虑的就是如何实现InvocationHandler这个接口。

让我们做一个实践，做这么一个调用处理器：任何使用此处理器的代理在调用它的任何方法的时候，都打印被代理的类的类名+“.”+方法名+”(“+参数+”,”+参数+...+”)”。

步骤1: 定义接口IUser

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.sample;   
  2.   
  3. public interface IUser {   
  4.     public String getName();   
  5.   
  6.     public void setName(String name);   
  7. }  
package com.cyh.proxy.sample;

public interface IUser {
    public String getName();

    public void setName(String name);
}



步骤2: 写IUser接口的实现类User

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.sample.impl;   
  2.   
  3. import com.cyh.proxy.sample.IUser;   
  4.   
  5. public class User implements IUser {   
  6.     String name;   
  7.   
  8.     public User(String name) {   
  9.     this.name = name;   
  10.     }   
  11.   
  12.     public String getName() {   
  13.     return name;   
  14.     }   
  15.   
  16.     public void setName(String name) {   
  17.     this.name = name;   
  18.     }   
  19. }  
package com.cyh.proxy.sample.impl;

import com.cyh.proxy.sample.IUser;

public class User implements IUser {
    String name;

    public User(String name) {
	this.name = name;
    }

    public String getName() {
	return name;
    }

    public void setName(String name) {
	this.name = name;
    }
}



步骤3: 写TraceHandler实现调用处理器InvocationHandler,即在invoke()方法里我们要打印被代理的类的类名+“.”+方法名+”(“+参数+”,”+参数+...+”)”。

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.sample.impl;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Method;   
  5.   
  6. public class TraceHandler implements InvocationHandler {   
  7.     private Object target;   
  8.   
  9.     public TraceHandler(Object target) {   
  10.     this.target = target;   
  11.     }   
  12.   
  13.     public Object invoke(Object proxy, Method method, Object[] args)   
  14.         throws Throwable {   
  15.   
  16.     // print implicit argument   
  17.     System.out.print(target.getClass().getName());   
  18.     // print method name   
  19.     System.out.print("." + method.getName() + "(");   
  20.     // print explicit arguments   
  21.     if (args != null) {   
  22.         for (int i = 0; i < args.length; i++) {   
  23.         System.out.print(args[i]);   
  24.         if (i < args.length - 1) {   
  25.             System.out.print(",");   
  26.         }   
  27.         }   
  28.     }   
  29.     System.out.println(")");   
  30.   
  31.     return method.invoke(this.target, args);   
  32.     }   
  33. }  
package com.cyh.proxy.sample.impl;

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

public class TraceHandler implements InvocationHandler {
    private Object target;

    public TraceHandler(Object target) {
	this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args)
	    throws Throwable {

	// print implicit argument
	System.out.print(target.getClass().getName());
	// print method name
	System.out.print("." + method.getName() + "(");
	// print explicit arguments
	if (args != null) {
	    for (int i = 0; i < args.length; i++) {
		System.out.print(args[i]);
		if (i < args.length - 1) {
		    System.out.print(",");
		}
	    }
	}
	System.out.println(")");

	return method.invoke(this.target, args);
    }
}



步骤4: 最后,让我们写测试类ProxyTest

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.sample.test;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Proxy;   
  5.   
  6. import com.cyh.proxy.sample.IUser;   
  7. import com.cyh.proxy.sample.impl.TraceHandler;   
  8. import com.cyh.proxy.sample.impl.User;   
  9.   
  10. public class ProxyTest {   
  11.     User user;   
  12.   
  13.     public ProxyTest() {   
  14.     user = new User("LaraCroft");   
  15.   
  16.     ClassLoader classLoader = user.getClass().getClassLoader();   
  17.     Class[] interfaces = user.getClass().getInterfaces();   
  18.     InvocationHandler handler = new TraceHandler(user);   
  19.     IUser proxy = (IUser) Proxy.newProxyInstance(classLoader, interfaces,   
  20.         handler);   
  21.   
  22.     proxy.setName("David Beckham");   
  23.     }   
  24.   
  25.     public static void main(String[] args) {   
  26.     new ProxyTest();   
  27.     }   
  28.   
  29. }  
package com.cyh.proxy.sample.test;

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

import com.cyh.proxy.sample.IUser;
import com.cyh.proxy.sample.impl.TraceHandler;
import com.cyh.proxy.sample.impl.User;

public class ProxyTest {
    User user;

    public ProxyTest() {
	user = new User("LaraCroft");

	ClassLoader classLoader = user.getClass().getClassLoader();
	Class[] interfaces = user.getClass().getInterfaces();
	InvocationHandler handler = new TraceHandler(user);
	IUser proxy = (IUser) Proxy.newProxyInstance(classLoader, interfaces,
		handler);

	proxy.setName("David Beckham");
    }

    public static void main(String[] args) {
	new ProxyTest();
    }

}




好了,所有代码写好了,运行一下,测试结果是:
com.cyh.proxy.impl.User.setName(David Beckham)

讲一下运行原理：
首先我们初始化了user对象，user.name = = “LaraCroft”;
然后创建了user对象的代理proxy。
注意这里：Proxy.newProxyInstance()函数的返回值使用接口IUser转型的，你或许会想到
用User来做强制类型转换，但是会抛出下面的异常
Exception in thread "main" java.lang.ClassCastException: $Proxy0 cannot be cast to com.cyh.proxy.impl.User
因为：代理类是实现了User类的所有接口，但是它的类型是$Proxy0，不是User。

最后，我们调用代理的setName()方法：
proxy.setName("David Beckham");

代理在执行此方法的时候，就好触发调用处理器 TraceHandler，并执行 TraceHandler的invoke()方法，然后就会打印：
com.cyh.proxy.impl.User.setName(David Beckham)



可重用拦截器机制的实现


好了，关于代理的知识我们讲完了，我们可以考虑如何实现这个拦截器的框架，所谓拦截器就是在函数的运行前后定制自己的处理行为，也就是通过实现InvocationHandler达到的。


设计思路


我们来理清一下思路，在使用一个拦截器的时候？什么是不变的，什么是变化的？

不变的：
每次都要创建代理
拦截的时间：函数执行之前，之后，异常处理的时候

变化的：
每次代理的对象不同
拦截器每次拦截到执行时的操作不同

好了，废话少说，看类图：



图中：
DynamicProxyFactory 和它的实现类，是一个工厂，用来创建代理

Interceptor 这个接口用来定义拦截器的拦截处理行为配合DynamicProxyInvocationHandler达到拦截效果
DynamicProxyInvocationHandler 调用处理器的实现，它有两个成员，一个是Object target指的是被代理的类，另一个是Interceptor interceptor就是在invoke()方法执行target的函数之前后，异常处理时，调用interceptor的实现来达到拦截，并处理的效果。


代码实现

步骤1: 定义接口DynamicProxyFactory

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor;   
  2.   
  3. public interface DynamicProxyFactory {   
  4.     /**  
  5.      * 生成动态代理,并且在调用代理执行函数的时候使用拦截器  
  6.      *   
  7.      * @param clazz  
  8.      *            需要实现的接口  
  9.      * @param target  
  10.      *            实现此接口的类  
  11.      * @param interceptor  
  12.      *            拦截器  
  13.      * @return  
  14.      */  
  15.     public <T> T createProxy(T target, Interceptor interceptor);   
  16. }  
package com.cyh.proxy.interceptor;

public interface DynamicProxyFactory {
    /**
     * 生成动态代理,并且在调用代理执行函数的时候使用拦截器
     * 
     * @param clazz
     *            需要实现的接口
     * @param target
     *            实现此接口的类
     * @param interceptor
     *            拦截器
     * @return
     */
    public <T> T createProxy(T target, Interceptor interceptor);
}



步骤2: 定义接口Interceptor

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor;   
  2.   
  3. import java.lang.reflect.Method;   
  4.   
  5. public interface Interceptor {   
  6.     public void before(Method method, Object[] args);   
  7.   
  8.     public void after(Method method, Object[] args);   
  9.   
  10.     public void afterThrowing(Method method, Object[] args, Throwable throwable);   
  11.   
  12.     public void afterFinally(Method method, Object[] args);   
  13. }  
package com.cyh.proxy.interceptor;

import java.lang.reflect.Method;

public interface Interceptor {
    public void before(Method method, Object[] args);

    public void after(Method method, Object[] args);

    public void afterThrowing(Method method, Object[] args, Throwable throwable);

    public void afterFinally(Method method, Object[] args);
}



步骤3: 实现接口DynamicProxyFactory

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor.impl;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Proxy;   
  5.   
  6. import com.cyh.proxy.interceptor.DynamicProxyFactory;   
  7. import com.cyh.proxy.interceptor.Interceptor;   
  8.   
  9. public class DynamicProxyFactoryImpl implements DynamicProxyFactory {   
  10.     /**  
  11.      * 生成动态代理,并且在调用代理执行函数的时候使用拦截器  
  12.      *   
  13.      * @param target  
  14.      *  需要代理的实例  
  15.      * @param interceptor  
  16.      *  拦截器实现,就是我们希望代理类执行函数的前后,  
  17.      *  抛出异常,finally的时候去做写什么  
  18.      */  
  19.     @Override  
  20.     @SuppressWarnings("unchecked")   
  21.     public <T> T createProxy(T target, Interceptor interceptor) {   
  22.     // 当前对象的类加载器   
  23.     ClassLoader classLoader = target.getClass().getClassLoader();   
  24.     // 获取此对象实现的所有接口   
  25.     Class<?>[] interfaces = target.getClass().getInterfaces();   
  26.     // 利用DynamicProxyInvocationHandler类来实现InvocationHandler   
  27.     InvocationHandler handler = new DynamicProxyInvocationHandler(target,   
  28.         interceptor);   
  29.   
  30.     return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);   
  31.     }   
  32. }  
package com.cyh.proxy.interceptor.impl;

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

import com.cyh.proxy.interceptor.DynamicProxyFactory;
import com.cyh.proxy.interceptor.Interceptor;

public class DynamicProxyFactoryImpl implements DynamicProxyFactory {
    /**
     * 生成动态代理,并且在调用代理执行函数的时候使用拦截器
     * 
     * @param target
     *  需要代理的实例
     * @param interceptor
     *  拦截器实现,就是我们希望代理类执行函数的前后,
     *  抛出异常,finally的时候去做写什么
     */
    @Override
    @SuppressWarnings("unchecked")
    public <T> T createProxy(T target, Interceptor interceptor) {
	// 当前对象的类加载器
	ClassLoader classLoader = target.getClass().getClassLoader();
	// 获取此对象实现的所有接口
	Class<?>[] interfaces = target.getClass().getInterfaces();
	// 利用DynamicProxyInvocationHandler类来实现InvocationHandler
	InvocationHandler handler = new DynamicProxyInvocationHandler(target,
		interceptor);

	return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
    }
}



步骤4: 实现调用处理器

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor.impl;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Method;   
  5.   
  6. import com.cyh.proxy.interceptor.Interceptor;   
  7.   
  8. /**  
  9.  * 动态代理的调用处理器  
  10.  *   
  11.  * @author chen.yinghua  
  12.  */  
  13. public class DynamicProxyInvocationHandler implements InvocationHandler {   
  14.     private Object target;   
  15.     private Interceptor interceptor;   
  16.   
  17.     /**  
  18.      * @param target  
  19.      *            需要代理的实例  
  20.      * @param interceptor  
  21.      *            拦截器  
  22.      */  
  23.     public DynamicProxyInvocationHandler(Object target,   
  24.                                   Interceptor interceptor) {   
  25.     this.target = target;   
  26.     this.interceptor = interceptor;   
  27.     }   
  28.   
  29.     /**  
  30.      * @param proxy  
  31.      *            所生成的代理对象  
  32.      * @param method  
  33.      *            调用的方法示例  
  34.      * @args args 参数数组  
  35.      * @Override  
  36.      */  
  37.     public Object invoke(Object proxy, Method method, Object[] args)   
  38.         throws Throwable {   
  39.     Object result = null;   
  40.   
  41.     try {   
  42.         // 在执行method之前调用interceptor去做什么事   
  43.         this.interceptor.before(method, args);   
  44.         // 在这里我们调用原始实例的method   
  45.         result = method.invoke(this.target, args);   
  46.         // 在执行method之后调用interceptor去做什么事   
  47.         this.interceptor.after(method, args);   
  48.     } catch (Throwable throwable) {   
  49.         // 在发生异常之后调用interceptor去做什么事   
  50.         this.interceptor.afterThrowing(method, args, throwable);   
  51.         throw throwable;   
  52.     } finally {   
  53.         // 在finally之后调用interceptor去做什么事   
  54.         interceptor.afterFinally(method, args);   
  55.     }   
  56.   
  57.     return result;   
  58.     }   
  59.   
  60. }  
package com.cyh.proxy.interceptor.impl;

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

import com.cyh.proxy.interceptor.Interceptor;

/**
 * 动态代理的调用处理器
 * 
 * @author chen.yinghua
 */
public class DynamicProxyInvocationHandler implements InvocationHandler {
    private Object target;
    private Interceptor interceptor;

    /**
     * @param target
     *            需要代理的实例
     * @param interceptor
     *            拦截器
     */
    public DynamicProxyInvocationHandler(Object target,
                                  Interceptor interceptor) {
	this.target = target;
	this.interceptor = interceptor;
    }

    /**
     * @param proxy
     *            所生成的代理对象
     * @param method
     *            调用的方法示例
     * @args args 参数数组
     * @Override
     */
    public Object invoke(Object proxy, Method method, Object[] args)
	    throws Throwable {
	Object result = null;

	try {
	    // 在执行method之前调用interceptor去做什么事
	    this.interceptor.before(method, args);
	    // 在这里我们调用原始实例的method
	    result = method.invoke(this.target, args);
	    // 在执行method之后调用interceptor去做什么事
	    this.interceptor.after(method, args);
	} catch (Throwable throwable) {
	    // 在发生异常之后调用interceptor去做什么事
	    this.interceptor.afterThrowing(method, args, throwable);
	    throw throwable;
	} finally {
	    // 在finally之后调用interceptor去做什么事
	    interceptor.afterFinally(method, args);
	}

	return result;
    }

}



好了，目前为止，这个框架算完成了，怎么用呢？
接下来我们完成测试包。

完成测试

步骤1： 首先，给需要代理的类定义一个接口Service

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor.test;   
  2.   
  3. public interface Service {   
  4.     public String greet(String name);   
  5. }  
package com.cyh.proxy.interceptor.test;

public interface Service {
    public String greet(String name);
}


步骤2： 实现这个接口，编写类ServiceImpl

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor.test;   
  2.   
  3. public class ServiceImpl implements Service {   
  4.     @Override  
  5.     public String greet(String name) {   
  6.     String result = "Hello, " + name;   
  7.     System.out.println(result);   
  8.     return result;   
  9.     }   
  10. }  
package com.cyh.proxy.interceptor.test;

public class ServiceImpl implements Service {
    @Override
    public String greet(String name) {
	String result = "Hello, " + name;
	System.out.println(result);
	return result;
    }
}


步骤3： 实现拦截器接口Interceptor，编写类InterceptorImpl

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor.test;   
  2.   
  3. import java.lang.reflect.Method;   
  4.   
  5. import com.cyh.proxy.interceptor.Interceptor;   
  6.   
  7. public class InterceptorImpl implements Interceptor {   
  8.     @Override  
  9.     public void after(Method method, Object[] args) {   
  10.     System.out.println("after invoking method: " + method.getName());   
  11.     }   
  12.   
  13.     @Override  
  14.     public void afterFinally(Method method, Object[] args) {   
  15.     System.out.println("afterFinally invoking method: " + method.getName());   
  16.     }   
  17.   
  18.     @Override  
  19.     public void afterThrowing(Method method, Object[] args,    
  20.                                 Throwable throwable) {   
  21.     System.out.println("afterThrowing invoking method: "  
  22.                                                 + method.getName());   
  23.     }   
  24.   
  25.     @Override  
  26.     public void before(Method method, Object[] args) {   
  27.     System.out.println("before invoking method: " + method.getName());   
  28.     }   
  29. }  
package com.cyh.proxy.interceptor.test;

import java.lang.reflect.Method;

import com.cyh.proxy.interceptor.Interceptor;

public class InterceptorImpl implements Interceptor {
    @Override
    public void after(Method method, Object[] args) {
	System.out.println("after invoking method: " + method.getName());
    }

    @Override
    public void afterFinally(Method method, Object[] args) {
	System.out.println("afterFinally invoking method: " + method.getName());
    }

    @Override
    public void afterThrowing(Method method, Object[] args, 
                                Throwable throwable) {
	System.out.println("afterThrowing invoking method: "
                                                + method.getName());
    }

    @Override
    public void before(Method method, Object[] args) {
	System.out.println("before invoking method: " + method.getName());
    }
}


步骤4：编写测试类TestDynamicProxy

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor.test;   
  2.   
  3. import com.cyh.proxy.interceptor.DynamicProxyFactory;   
  4. import com.cyh.proxy.interceptor.Interceptor;   
  5. import com.cyh.proxy.interceptor.impl.DynamicProxyFactoryImpl;   
  6.   
  7. public class TestDynamicProxy {   
  8.     public TestDynamicProxy() {   
  9.     DynamicProxyFactory dynamicProxyFactory = new DynamicProxyFactoryImpl();   
  10.     Interceptor interceptor = new InterceptorImpl();   
  11.     Service service = new ServiceImpl();   
  12.   
  13.     Service proxy = dynamicProxyFactory.createProxy(service, interceptor);   
  14.     // Service proxy = DefaultProxyFactory.createProxy(service,   
  15.     // interceptor);   
  16.     proxy.greet("iwindyforest");   
  17.     }   
  18.   
  19.     public static void main(String[] args) {   
  20.     new TestDynamicProxy();   
  21.     }   
  22. }  
package com.cyh.proxy.interceptor.test;

import com.cyh.proxy.interceptor.DynamicProxyFactory;
import com.cyh.proxy.interceptor.Interceptor;
import com.cyh.proxy.interceptor.impl.DynamicProxyFactoryImpl;

public class TestDynamicProxy {
    public TestDynamicProxy() {
	DynamicProxyFactory dynamicProxyFactory = new DynamicProxyFactoryImpl();
	Interceptor interceptor = new InterceptorImpl();
	Service service = new ServiceImpl();

	Service proxy = dynamicProxyFactory.createProxy(service, interceptor);
	// Service proxy = DefaultProxyFactory.createProxy(service,
	// interceptor);
	proxy.greet("iwindyforest");
    }

    public static void main(String[] args) {
	new TestDynamicProxy();
    }
}



好了，整个测试包完成了，让我们运行下看看运行结果：

before invoking method: greet
Hello, iwindyforest
after invoking method: greet
afterFinally invoking method: greet



完善设计

现在，让我们回顾一下：接口DynamicProxyFactory，真的需要么？
它只是一个工厂，负责生产代理的，但是我们并没有过多的要求，因此可以说它的实现基本上是不变的。鉴于此，我们在使用createProxy()函数的时候，只需要一个静态方法就可以了，没有必要再初始化整个类，这样才比较方便么。
因此，我在com.cyh.proxy.interceptor.impl包里加了一个默认的工厂DefaultProxyFactory：

Java代码 复制代码 收藏代码
  1. package com.cyh.proxy.interceptor.impl;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Proxy;   
  5.   
  6. import com.cyh.proxy.interceptor.Interceptor;   
  7.   
  8. public class DefaultProxyFactory {   
  9.     @SuppressWarnings("unchecked")   
  10.     public static <T> T createProxy(T target, Interceptor interceptor) {   
  11.     // 当前对象的类加载器   
  12.     ClassLoader classLoader = target.getClass().getClassLoader();   
  13.     // 获取此对象实现的所有接口   
  14.     Class<?>[] interfaces = target.getClass().getInterfaces();   
  15.     // 利用DynamicProxyInvocationHandler类来实现InvocationHandler   
  16.     InvocationHandler handler = new DynamicProxyInvocationHandler(target,   
  17.         interceptor);   
  18.   
  19.     return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);   
  20.     }   
  21. }  
package com.cyh.proxy.interceptor.impl;

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

import com.cyh.proxy.interceptor.Interceptor;

public class DefaultProxyFactory {
    @SuppressWarnings("unchecked")
    public static <T> T createProxy(T target, Interceptor interceptor) {
	// 当前对象的类加载器
	ClassLoader classLoader = target.getClass().getClassLoader();
	// 获取此对象实现的所有接口
	Class<?>[] interfaces = target.getClass().getInterfaces();
	// 利用DynamicProxyInvocationHandler类来实现InvocationHandler
	InvocationHandler handler = new DynamicProxyInvocationHandler(target,
		interceptor);

	return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
    }
}

 

分享到：
| Hibernate中数据库表的继承关系
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    struts2拦截器时序图

    开发者可以利用拦截器来提取Action中的可重用逻辑，从而避免代码的重复编写，提升代码的可维护性和可重用性。 拦截器的执行过程可以分为几个步骤。首先，Struts2框架初始化Action代理对象和Action对象。接着，...

    详解Struts2拦截器

    - **代码重用原则**：通过拦截器机制，可以将多个Action中需要重复指定的代码提取出来，放在拦截器类中定义，实现更好的代码复用。 - **AOP设计模式**：Struts2的拦截器体系采用的是面向切面编程（Aspect-Oriented ...

    J2EE拦截器实例

    在Struts2框架中，拦截器是基于Java的动态代理机制实现的。开发者需要创建一个实现了`com.opensymphony.xwork2.interceptor.Interceptor`接口的类，并在配置文件中声明这个拦截器，以便在动作调用链中插入。而在...

    Struts2_拦截器

    总结来说，Struts2的拦截器机制提供了强大的灵活性，允许开发者通过拦截器对Action进行预处理和后处理，从而提高了代码的复用性和可维护性。拦截器不仅能够处理通用的任务，如数据转换、校验和日志记录，还可以执行...

    java拦截器

    此外，拦截器还提供了一种提取Action中可重用部分的有效途径。 #### 二、拦截器的工作原理 拦截器的工作原理主要是通过代理机制来实现的。具体来说： 1. **代理模式**：大多数情况下，拦截器方法通过代理的方式来...

    struts2拦截器

    Struts2 拦截器是 Struts2 框架中的一个重要组成部分，它是一种设计模式，用于在请求被实际处理之前...通过深入理解并熟练使用Struts2的拦截器机制，开发者能够更有效地管理和增强应用的功能，提高代码质量和可维护性。

    详解Spring AOP 拦截器的基本实现

    AOP(面向切面编程)是一种编程范式，旨在将横切关注点（如日志、安全、事务...AOP和拦截器的使用大大提高了开发的灵活性和代码的可重用性，同时也使得日志记录、权限验证、事务处理等横切关注点的管理更为集中和高效。

    struts2拦截器详述ppt

    Struts2框架中的拦截器机制是其核心特性之一，它极大地扩展了框架的功能性和灵活性。通过理解和合理配置这些内置拦截器，开发者可以轻松地实现诸如验证、事务管理、日志记录等多种业务需求，从而提高应用程序的质量...

    使用Struts2的拦截器实现权限控制

    Struts2的拦截器机制提供了一种优雅的解决方案。拦截器是基于责任链模式的，当一个请求到达Action时，会按照定义的顺序依次调用拦截器，直到到达Action本身。如果在拦截器中发现用户没有权限，那么可以直接终止流程...

    J2EE企业级项目开发-3期（KC007） 8.3 Struts之拦截器使用技巧文档.doc

    Struts2 拦截器是Java企业级应用开发中J2EE框架Struts2的核心组件，主要用于在Action执行前后处理特定的任务，提供了一种面向...Struts2的拦截器机制是其强大功能的关键组成部分，也是理解Struts2工作原理的重要环节。

    J2EE企业级项目开发-3期（KC007） 8.3 Struts之拦截器使用技巧考试.doc

    1. 拦截器是在Action执行之前和Action执行之后进行功能处理的机制。这意味着，当一个请求被发送到Struts2框架时，拦截器会按照配置的顺序先于Action执行，完成特定任务，如日志记录、权限验证等，然后才将控制权交给...

    信息系统软件设计：第3章 Struts2.0-拦截器.ppt

    - **提高重用性**：拦截器可以被配置到不同的Action，实现功能的跨Action共享。 - **AOP实现**：Struts2通过拦截器实现了面向切面编程，可以在不修改Action代码的情况下增加新的功能。 **2. 拦截器与Action的关系**...

    jsp自定义标签，structs2 JUNIT，structs2自定义拦截器

    Structs2的拦截器机制允许开发者在Action执行前后插入自定义逻辑，如日志记录、权限检查等。自定义拦截器的实现需要继承org.apache.struts2.interceptor.StrutsInterceptor抽象类，然后在配置文件中声明并链入拦截器...

    拦截器详解

    这种设计实际上采用了责任链模式，将复杂的业务逻辑分解成多个较小的部分，每个部分负责一部分逻辑处理，同时保证了代码的高度可重用性和可扩展性。 #### 二、Interceptor执行分析 为了更好地理解Interceptor的...

    spring boot 注册拦截器过程详解

    拦截器可以使开发者定义在一个Action执行的前后执行的代码，也可以在一个Action执行前阻止其执行，同时也提供了一种可以提取Action中可重用部分的方式。 二、在Spring Boot中添加拦截器 要在Spring Boot中添加拦截...

    SpringAOP原理及拦截器.doc

    Spring AOP使用拦截器（Interceptor）机制来实现通知，拦截器按照顺序形成一个链，当目标方法被调用时，会逐个执行这些拦截器。这种设计使得我们可以灵活地插入、移除和重新排列通知，而不会影响核心业务代码。 ...

    OkHttpLemonDemo,四、截击、改型。.zip

    通过学习这个项目，我们可以深入理解OkHttp的拦截器机制，并掌握如何利用拦截器进行网络请求的调试、优化以及安全控制。 一、OkHttp简介 OkHttp是Square公司推出的一款高效、现代的HTTP客户端库，广泛应用于...

    Java web拦截器inteceptor原理及应用详解

    Java Web拦截器Interceptor是一种基于Java反射机制实现的拦截技术，依赖于具体的接口，在运行期间动态生成字节码。它提供了一种机制可以使开发者在一个Action执行的前后执行一段代码，也可以在一个Action执行前阻止...

    spring_aop_拦截实例

    本实例主要探讨如何在Spring AOP中实现拦截器。 首先，我们来理解Spring AOP的基本概念。AOP的核心是代理，Spring提供了两种代理方式：JDK动态代理和CGLIB代理。JDK动态代理基于接口，当目标对象实现了接口时使用；...

Magicbox
Global site tag (gtag.js) - Google Analytics