深入浅析Spring 的aop实现原理:
http://www.jb51.net/article/81788.htm
Java动态代理机制详解(JDK 和CGLIB,Javassist,ASM) (清晰,浅显):
http://www.360doc.com/content/14/0801/14/1073512_398598312.shtml
java动态代理(JDK和cglib):
http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html
在用Spring AOP的时候,始终不明白,其中的原理,今天一探究竟,其实Spring AOP用的就是java动态代理,今天我们来看一下java动态代理,首先看一下静态代理
定义接口:
package proxy;
public interface IHello {
/**
* 业务方法
* @param str
*/
void sayHello(String str);
}
定义接口实现类:
package proxy;
public class Hello implements IHello {
@Override
public void sayHello(String str) {
System.out.println("hello "+str);
}
}
日志切入类:
package proxy;
import java.util.Date;
public class Logger {
public static void start(){
System.out.println(new Date()+ " say hello start...");
}
public static void end(){
System.out.println(new Date()+ " say hello end");
}
}
定义静态代理类:
package proxy;
public class ProxyHello implements IHello {
private IHello hello;
public ProxyHello(IHello hello) {
super();
this.hello = hello;
}
@Override
public void sayHello(String str) {
Logger.start();//添加特定的方法
hello.sayHello(str);
Logger.end();
}
}
静态代理测试主类:
package proxy;
public class testProxy {
public static void main(String[] args) {
IHello hello = new ProxyHello(new Hello());//如果我们需要日志功能,则使用代理类
//IHello hello = new Hello();//如果我们不需要日志功能则使用目标类
hello.sayHello("明天");
}
}
控制台输出:
Thu Dec 01 09:46:35 CST 2016 say hello start...
hello 明天
Thu Dec 01 09:46:35 CST 2016 say hello end
从上面可以看出,静态代理类实现了代理接口,同时在其内部,有一个需要代理的接口句柄,通过静态代理构造方法传入;在实现接口方法中,在调用接口句柄的指定方法前,做一下Before操作,之后,做一些After操作。
下面我们来看一下动态代理:
动态代理类:
package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynaProxyHello implements InvocationHandler {
private Object target;// 目标对象
/**
* 通过反射来实例化目标对象
*
* @param object
* @return
*/
public Object bind(Object object) {
this.target = object;
return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
this.target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
Logger.start();// 添加额外的方法
// 通过反射机制来运行目标对象的方法
result = method.invoke(this.target, args);
Logger.end();
return result;
}
}
测试主类:
package proxy;
public class testDynamicProxy {
public static void main(String[] args) {
IHello hello = (IHello) new DynaProxyHello().bind(new Hello());//如果我们需要日志功能,则使用代理类
//IHello hello = new Hello();//如果我们不需要日志功能则使用目标类
hello.sayHello("今天");
}
}
控制台输出:
Thu Dec 01 09:59:01 CST 2016 say hello start...
hello 今天
Thu Dec 01 09:59:01 CST 2016 say hello end
从上面可以看出,java动态代理类需要实现InvocationHandler,重写invoke(Object proxy, Method method, Object[] args)方法,并通过 Proxy.newProxyInstance产生对应的代理类$Proxy0;当我们调用代理类时,实际调用的是动态代理代理类的invoke(Object proxy, Method method, Object[] args),$proxy为代理产生的代理类,method为对应方法,args为参数;Proxy.newProxyInstance产生对应的代理类。
上面我们在测试代理的时候,用到一个Logger日志,这是我们在模拟Spring AOP的before与after增强,其实日志功能我们也可接口化,以实现不同的日志需求:
日志接口:
package proxy;
import java.lang.reflect.Method;
public interface ILogger {
void start(Class clazz);
void end(Method method);
}
日志接口实现:
package proxy;
import java.lang.reflect.Method;
import java.util.Date;
public class DLogger implements ILogger {
@Override
public void start(Class clazz) {
System.out.println(new Date()+" Class:"+ clazz.getName() +":"+ " say hello start...");
}
@Override
public void end(Method method) {
System.out.println(new Date()+" method:"+ method.getName() +":"+ " say hello end");
}
}
动态代理类:
package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxyHello implements InvocationHandler {
// 调用对象
private Object proxy;
// 目标对象
private Object target;
public Object bind(Object target, Object proxy) {
this.target = target;
this.proxy = proxy;
return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
this.target.getClass().getInterfaces(), this);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
// 反射得到操作者的实例
Class clazz = this.proxy.getClass();
// 反射得到操作者的Start方法
Method start = clazz.getDeclaredMethod("start",
new Class[] { Class.class });
// 反射执行start方法
start.invoke(this.proxy, new Object[] {clazz});
// 执行要处理对象的原本方法
method.invoke(this.target, args);
// 反射得到操作者的end方法
Method end = clazz.getDeclaredMethod("end",
new Class[] { Method.class });
// 反射执行end方法
end.invoke(this.proxy, new Object[] { method });
return result;
}
}
测试主类:
package proxy;
public class testDynamicProxy {
public static void main(String[] args) {
// IHello hello = (IHello) new DynaProxyHello().bind(new Hello());//如果我们需要日志功能,则使用代理类
// IHello hello = new Hello();//如果我们不需要日志功能则使用目标类
// hello.sayHello("今天");
IHello hellox = (IHello) new DynamicProxyHello().bind(new Hello(),new DLogger());
hellox.sayHello("明天");
}
}
控制台输出:
Thu Dec 01 10:19:50 CST 2016 Class:proxy.DLogger: say hello start...
hello 明天
Thu Dec 01 10:19:50 CST 2016 method:sayHello: say hello end
其实java还有一些动态代理机制CGLIB,ASM等,有兴趣的可以搜一下。
总结:
静态代理类实现了代理接口,同时在其内部,有一个需要代理的接口句柄,通过静态代理构造方法传入;在实现接口方法中,在调用接口句柄的指定方法前,做一下Before操作,之后,做一些After操作。java动态代理类需要实现InvocationHandler,重写invoke(Object proxy, Method method, Object[] args)方法,并通过 Proxy.newProxyInstance产生对应的代理类$Proxy0;当我们调用代理类时,实际调用的是动态代理代理类的invoke(Object proxy, Method method, Object[] args),$proxy为代理产生的代理类,method为对应方法,args为参数;Proxy.newProxyInstance产生对应的代理类。
分享到:
相关推荐
Java动态代理是Java编程中一个重要的特性,它允许我们在运行时创建代理对象,这些代理对象可以代表并增强原对象的功能。动态代理在很多场景下都非常有用,比如日志记录、性能监控、事务管理等。本示例将带你深入理解...
Java动态代理是Java语言提供的一种在运行时创建代理对象的技术,它允许我们为已存在的接口创建代理类,以便在调用真实目标对象的方法时添加额外的功能或行为。在这个实例中,我们将深入探讨Java动态代理的核心概念,...
Java动态代理是Java编程中一个重要的特性,它允许在运行时创建代理对象,这些代理对象可以代表并增强原对象的功能。动态代理主要应用于面向切面编程(AOP)和事件监听等场景,使得代码更加模块化,易于维护。以下是...
Java动态代理技术是Java编程中一个非常重要的特性,它允许我们在运行时动态创建具有特定行为的对象。这种技术常用于AOP(面向切面编程)和框架中,如Spring AOP,用于实现方法拦截、事务管理等功能。Java提供了两种...
本篇文章将深入探讨Java动态代理的概念、原理以及如何通过一个简单的"Hello, World!"示例来理解它。 动态代理,顾名思义,是在程序运行时动态地生成代理对象。与静态代理(编译时已知)相比,动态代理更加灵活,...
JDK 动态代理JDK 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来支持动态代理。Proxy 类用于创建一个代理对象,而 InvocationHandler 接口则定义了代理对象的方法调用处理逻辑。...
Java动态代理是Java语言提供的一种在运行时创建代理对象的技术,它允许我们为已存在的接口创建代理类,以便在调用方法时添加额外的功能或控制。动态代理在很多场景下非常有用,比如日志记录、性能监控、事务管理等。...
Java动态代理机制是Java语言提供的一种强大的功能,它允许在运行时创建代理对象来实现特定接口,从而可以灵活地扩展或增强已有代码的功能。在Java中,动态代理主要通过两个类来实现:`java.lang.reflect.Proxy` 和 `...
### Java动态代理实现AOP详解 #### 一、引言 随着软件开发复杂度的提升,传统的面向对象编程(OOP)已经难以满足现代软件工程的需求。为了更好地管理跨切面的关注点,如日志记录、性能监控、安全控制等,面向切面...
java动态代理 public class HireProxy implements InvocationHandler { //被代理的真实角色 private Object obj; public HireProxy(Object obj) { super(); this.obj = obj; } //第二个参数method,被...
Java动态代理是Java提供的一种在运行时创建代理对象的技术,主要由`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口组成。在这个简单的Java动态代理实例中,我们将探讨如何利用这两个核心...
Java动态代理机制是Java语言提供的一种强大的功能,它允许在运行时创建代理对象来实现指定的接口。这一机制使得我们可以在不修改已有代码的情况下,为已有接口增加额外的功能或者增强已有功能的行为。在Java中,动态...
Java动态代理机制的优点在于灵活性和便捷性,它允许在运行时动态创建符合特定接口的代理对象,无需对原有代码做任何修改,使得我们可以方便地实现诸如日志、事务控制等跨切面的逻辑。不过,动态代理仅限于代理接口,...
Java动态代理实现AOP Java动态代理是实现Aspect Oriented Programming(AOP)的重要手段。在Java中,动态代理可以通过java.lang.reflect InvocationHandler接口和java.lang.reflect.Proxy类来实现。AOP的主要思想...
### Java动态代理知识点详解 #### 一、Java动态代理简介 在Java中,动态代理是一种非常重要的机制,它允许我们在运行时动态地创建一个接口的实现类实例。这种技术广泛应用于AOP(面向切面编程)、RPC(远程过程...
Java动态代理是Java编程中一个非常重要的特性,它允许我们在运行时创建代理对象来代替目标对象,以便在不修改原有代码的情况下对目标对象的行为进行增强或扩展。在Java.lang.reflect包下,动态代理主要涉及两个核心...
对代理模式与Java动态代理类的理解说明
总之,基于Java动态代理和反射机制实现ORM,可以有效地解耦业务逻辑和数据库操作,提高代码的可读性和可维护性。虽然现有的ORM框架如Hibernate、MyBatis已经相当成熟,但对于学习和理解Java的高级特性,这样的实践...
Java动态代理是Java语言提供的一种机制,它允许在运行时创建一个对象的代理,这个代理对象可以在调用实际方法之前和之后添加额外的功能。在Java中,动态代理主要通过`java.lang.reflect.Proxy`类和`java.lang....