其他分享
首页 > 其他分享> > 利用Proxy.newProxyInstance实现AOP

利用Proxy.newProxyInstance实现AOP

作者:互联网

newProxyInstance()方法介绍

Proxy类的newInstance()方法有三个参数:
ClassLoader loader:它是类加载器类型,你不用去理睬它,你只需要知道怎么可以获得它就可以了:MyInterface.class.getClassLoader()就可以获取到ClassLoader对象,没错,只要你有一个Class对象就可以获取到ClassLoader对象;
Class[] interfaces:指定newProxyInstance()方法返回的对象要实现哪些接口,没错,可以指定多个接口,例如上面例子只我们只指定了一个接口:Class[] cs = {MyInterface.class};
InvocationHandler h:它是最重要的一个参数!它是一个接口!它的名字叫调用处理器!无论你调用代理对象的什么方法,它都是在调用InvocationHandler的invoke()方法!

图片

图片AOP介绍

Aspect Oriented Programming(AOP)是较为热门的一个话题。AOP,国内大致译作“面向切面编程”。

AOP主要功能

日志记录,性能统计,安全控制,事务处理,异常处理等等wn及扩展

AOP主要意图

将日志记录,性能统计,安全控制,事务处理,异常处理等代码从业务逻辑代码中划分出来,通过对这些行为的分离,我们希望可以将它们独立到非指导业务逻辑的方法中,进而改变这些行为的时候不影响业务逻辑的代码。

AOP实现

package org.java.base.proxy;

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

public class MainApp1 {
 public static void main(String[] args) {
 ClassLoader loader = MainApp1.class.getClassLoader();
 Class[] cs = {Waiter.class};
 Waiter target = new MyWaiter();
 MyInvocationHandler h = new MyInvocationHandler(target);
 Waiter waiter = (Waiter)Proxy.newProxyInstance(loader, cs, h);
 waiter.serve();
 }
}
class MyInvocationHandler implements InvocationHandler {
 public Waiter target;
 public MyInvocationHandler(Waiter target) {
 this.target = target;
 }
 public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
 System.out.println("您好!");
 Object result = method.invoke(target, args);
 System.out.println("很高兴为您服务!");
 return result;
 }
}
package org.java.base.proxy;
/**
 * 后置增强
 * @author Liuhaihua
 *
 */
public interface AfterAdvice {
 public void after();
}
package org.java.base.proxy;
/**
 * 前置增强
 * @author Liuhaihua
 *
 */
public interface BeforeAdvice {
 public void before();
}
package org.java.base.proxy;
public class MyWaiter implements Waiter {
 public void serve() {
 System.out.println("服务...");
 }
}
package org.java.base.proxy;
public interface Waiter {
 // 服务
 public void serve();
 }
 package org.java.base.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 它用来生成代理对象
 * 它需要所有的参数
 * * 目标对象
 * * 增强
 * @author cxf
 */
/**
 * 1. 创建代理工厂
 * 2. 给工厂设置三样东西:
 * * 目标对象:setTargetObject(xxx);
 * * 前置增强:setBeforeAdvice(该接口的实现)
 * * 后置增强:setAfterAdvice(该接口的实现)
 * 3. 调用createProxy()得到代理对象
 * * 执行代理对象方法时:
 * > 执行BeforeAdvice的before()
 * > 目标对象的目标方法
 * > 执行AfterAdvice的after()
 *
 */
public class ProxyFactory {
 private Object targetObject;//目标对象
 private BeforeAdvice beforeAdvice;//前置增强
 private AfterAdvice afterAdvice;//后置增强
 /**
 * 用来生成代理对象
 * @return
 */
 public Object createProxy() {
 /*
 * 1. 给出三大参数
 */
 ClassLoader loader = this.getClass().getClassLoader();
 Class[] interfaces = targetObject.getClass().getInterfaces();
 InvocationHandler h = new InvocationHandler() {
 public Object invoke(Object proxy, Method method, Object[] args)
 throws Throwable {
 /*
 * 在调用代理对象的方法时会执行这里的内容
 */
 // 执行前置增强
 if(beforeAdvice != null) {
 beforeAdvice.before();
 }
 
 Object result = method.invoke(targetObject, args);//执行目标对象的目标方法
 // 执行后置增强
 if(afterAdvice != null) {
 afterAdvice.after();
 }
 
 // 返回目标对象的返回值
 return result;
 }
 };
 /*
 * 2. 得到代理对象
 */
 Object proxyObject = Proxy.newProxyInstance(loader, interfaces, h);
 return proxyObject;
 }
 
 
 public Object getTargetObject() {
 return targetObject;
 }
 public void setTargetObject(Object targetObject) {
 this.targetObject = targetObject;
 }
 public BeforeAdvice getBeforeAdvice() {
 return beforeAdvice;
 }
 public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
 this.beforeAdvice = beforeAdvice;
 }
 public AfterAdvice getAfterAdvice() {
 return afterAdvice;
 }
 public void setAfterAdvice(AfterAdvice afterAdvice) {
 this.afterAdvice = afterAdvice;
 }
}


标签:java,newProxyInstance,对象,Object,Waiter,Proxy,AOP,public
来源: https://blog.51cto.com/15082402/2644350