本文介绍了Java动态代理的实现方式及其与AOP的关系。通过具体示例展示了如何使用动态代理来实现对象的代理，并进一步讲解了如何通过动态代理机制实现简单的AOP拦截功能。
动态代理实例
定义一个接口
package agentMoudle;
public interface SaleInterface {
void sale();
}
实现接口
package agentMoudle;
public class WineSale implements SaleInterface{
public void sale() {
// TODO Auto-generated method stub
System.out.println("我是酒的总供应商");
}
}
实现接口2
package agentMoudle;
public class SmokeSale implements SaleInterface{
public void sale() {
// TODO Auto-generated method stub
System.out.print("我是烟的总供应商");
}
}
代理类
package agentMoudle;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//该动态代理类需要实现 invocationHandle
public class Agent implements InvocationHandler {
public Object proxy_obj;
public Agent(){}
public Agent(Object obj){
this.proxy_obj=obj;
}
//根据参数来返回代理对象
public static Object factory(Object obj){
Class cl=obj.getClass();
//创建代理类的 newProxyInstance 方法
return Proxy.newProxyInstance(cl.getClassLoader(),cl.getInterfaces(), new Agent(obj));
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
//利用发射生成真正的的对象(即烟酒总供应商)
return method.invoke(proxy_obj, args);
}
}
通过代理类调用真是对象的类
package agentMoudle;
public class Invocation {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Agent agent=new Agent();
//只需调用代理类中factory 方法 在方法中传入不同的参数 即可操作真实的对象
SaleInterface si= (SaleInterface) agent.factory(new SmokeSale());
//根据si调用的方法 来动态 管理 代理类的 的invoke方法
si.sale();
}
}
以下是转自他人博客的内容
而是实现了java的InvocationHandler接口,这样就把代理主题角色和我们的业务代码分离开来,使代理对象能通用于其他接口.
其实InvocationHandler接口就是一种拦截机制,当系统中有了代理对象以后,对原对象(真实主题)方法的调用,都会转由InvocationHandler接口来处理,并把方法信息以参数的形式传递给invoke方法,这样,我们就可以在invoke方法中拦截原对象的调用,并通过反射机制来动态调用原对象的方法.这好象也是spring aop编程的基础吧
接着,用代理模式实现一个超级简单的aop拦截机制
这个例子可以拦截我们指定的函数,并在拦截前后根据需要进行处理
Java代码
- /**
- *切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
- */
- public interface AopInterface {
- public void before(Object obj);//调用的处理
- public void end(Object obj);//调用后的处理
- }
/**
*切面接口,通过实现这个接口,我们可以对指定函数在调用前后进行处理
*/
public interface AopInterface {
public void before(Object obj);//调用的处理
public void end(Object obj);//调用后的处理
}
这个是实现了AopInterface 接口,在这里我们实现了我们的处理逻辑
Java代码
- public class AopInterfaceImp implements AopInterface{
- public void before(Object obj) {
- System.out.println("调用前拦截");
- }
- public void end(Object obj) {
- System.out.println("调用调用后处理");
- }
- }
public class AopInterfaceImp implements AopInterface{
public void before(Object obj) {
System.out.println("调用前拦截");
}
public void end(Object obj) {
System.out.println("调用调用后处理");
}
}
接着是代理类
Java代码
- public class PeoxyObject implements InvocationHandler {
- private AopInterface aop;//定义了切入时调用的方法
- private Object proxy_obj;
- private String methodName;//指定要切入的方法名
- PeoxyObject(){}
- public Object factory(Object obj){
- proxy_obj = obj;
- Class cls = obj.getClass();
- return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);
- }
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- if(this.aop == null)throw new NullPointerException("aop is null");
- if(method == null)throw new NullPointerException("method is null");
- Object o;
- //如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
- //否则当正常方法处理
- if(methodName != null && method.toString().indexOf(methodName) != -1){
- aop.before(proxy_obj);//指定方法调用前的处理
- o = method.invoke(proxy_obj, args);
- aop.end(proxy_obj);//指定方法调用后的处理
- }else{
- //没有指定的方法,以正常方法调用
- o = method.invoke(proxy_obj, args);
- }
- return o;
- }
- public AopInterface getAop() {
- return aop;
- }
- public void setAop(AopInterface aop) {
- this.aop = aop;
- }
- public String getMethodName() {
- return methodName;
- }
- public void setMethodName(String methodName) {
- this.methodName = methodName;
- }
- }
public class PeoxyObject implements InvocationHandler {
private AopInterface aop;//定义了切入时调用的方法
private Object proxy_obj;
private String methodName;//指定要切入的方法名
PeoxyObject(){}
public Object factory(Object obj){
proxy_obj = obj;
Class cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(this.aop == null)throw new NullPointerException("aop is null");
if(method == null)throw new NullPointerException("method is null");
Object o;
//如果指定了要拦截方法名,并且调用的方法和指定的方法名相同,则进行拦截处理
//否则当正常方法处理
if(methodName != null && method.toString().indexOf(methodName) != -1){
aop.before(proxy_obj);//指定方法调用前的处理
o = method.invoke(proxy_obj, args);
aop.end(proxy_obj);//指定方法调用后的处理
}else{
//没有指定的方法,以正常方法调用
o = method.invoke(proxy_obj, args);
}
return o;
}
public AopInterface getAop() {
return aop;
}
public void setAop(AopInterface aop) {
this.aop = aop;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
}
这里定义一个用来测试用的类
Java代码
- public interface SubInterface {
- public void add(String value1,String value2);
- public void acc(String value1);
- }
- public class ImpObject implements SubInterface{
- public void add(String value1,String value2) {
- System.out.println("ImpObject add(String value1,String value2)");
- }
- public void acc(String value1){
- System.out.println("ImpObject acc(String value1)");
- }
- }
public interface SubInterface {
public void add(String value1,String value2);
public void acc(String value1);
}
public class ImpObject implements SubInterface{
public void add(String value1,String value2) {
System.out.println("ImpObject add(String value1,String value2)");
}
public void acc(String value1){
System.out.println("ImpObject acc(String value1)");
}
}
这里是测试代码
Java代码
- public static void main(String agr[]){
- PeoxyObject po = new PeoxyObject();
- po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
- po.setMethodName("acc");//指定要拦截的函数
- SubInterface si = (SubInterface)po.factory(new ImpObject());
- //因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
- si.add("tt","dd");
- //acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
- //对象的两个方法
- si.acc("tt");
- }
public static void main(String agr[]){
PeoxyObject po = new PeoxyObject();
po.setAop(new AopInterfaceImp());//我们实现的拦截处理对象
po.setMethodName("acc");//指定要拦截的函数
SubInterface si = (SubInterface)po.factory(new ImpObject());
//因为add方法不是我们指定的拦截函数,AopInterfaceImp是不会被执行
si.add("tt","dd");
//acc是我们指定的拦截方法,所以调用acc的前后会先执行AopInterfaceImp
//对象的两个方法
si.acc("tt");
}
通过上面可以看出,拦截机制是代理模式的重要使用方式之一,
除了拦截,代理模式还常用于资源加载,当我们要加载的资源很大时,我们可以让真实主题角色在后台加载资源,让代理主题角色负责处理前台的等待提示信息.
还有就是授权机制,通过代理能拦截真实主题的能力,来控制真实主题的访问权限
扫一扫
168万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
