动态代理以及AOP代理
1.使用Proxy和InvocationHandler创建动态代理
Proxy提供了用于创建动态代理类和代理对象的静态方法，它也是所有动态代理类的父类。如果在程序中为一个或多个接口动态地生成实现类，就可以使用Proxy来创建动态代理类；如果需要为一个或多个接口动态地创建实例，也可以使用Proxy来创建动态代理实例。这里主要讲解创建动态代理实例。
使用Proxy和InvocationHandler创建动态代理，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。因此可以直接使用static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)。
因此创建一个动态代理对象的步骤如下：
InvocationHandler handler = new MyInvocationHandler(…);
Foo f = (Foo)Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[]{Foo.class},handler);
然后就可以通过动态代理对象调用接口的方法了，而动态代理对象的所有方法都会被替换成调用该invoke()方法。
Object invoke(Object proxy,Method method,Object[] args)
proxy:代表动态代理对象
method:代表正在执行的方法
args:代表调用目标方法时传入的参数
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Person{
void work();
void sayHello(String name,int age);
}
interface Foo{
void doWork(String str);
}
class MyInvokationHandler implements InvocationHandler{
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
System.out.println("----正在执行的方法："+method);
if(args!=null) {
System.out.println("下面是执行该方法时传入的实参为：");
for(Object val : args) {
System.out.println(val);
}
}
else {
System.out.println("调用该方法没有实参！");
}
return null;
}
}
public class ProxyTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
InvocationHandler handler = new MyInvokationHandler();
Person p = (Person)Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[] {Person.class,Foo.class}, handler);
p.work();
p.sayHello("孙悟空",500);
}
}
通过以上例子比较难理解代理的精髓，接下来讲的是框架中常用到的AOP，这也是一种动态代理，接下来通过例子来讲解它的实现过程，就可以体会AOP带来的好处。
2.动态代理和AOP
AOP中使用Proxy生成一个动态代理时，往往不会凭空产生一个代理，而是为指定的目标对象生成动态代理。AOP代理可代替目标对象，包含了目标对象的全部方法。
先创建一个Animal接口，因为Proxy和InvocationHandler创建的JDK动态代理只能为接口创建动态代理。
package proxy;
public interface Animal {
void info() throws InterruptedException;
void run() throws InterruptedException;
}
接下来提供两个实现类：
package proxy;
public class GunDog implements Animal {
@Override
public void info() throws InterruptedException {
// TODO Auto-generated method stub
System.out.println("我是一只猎狗");
Thread.sleep(1000);
}
@Override
public void run() throws InterruptedException {
// TODO Auto-generated method stub
System.out.println("我奔跑迅速");
Thread.sleep(1000);
}
}
package proxy;
public class Cat implements Animal {
@Override
public void info() throws InterruptedException {
// TODO Auto-generated method stub
System.out.println("我是一只花猫");
Thread.sleep(1000);
}
@Override
public void run() throws InterruptedException {
// TODO Auto-generated method stub
System.out.println("我反应敏捷");
Thread.sleep(1000);
}
}
接下来是拦截器方法，是执行对象的每个方法前后调用的拦截器方法。该方法为了获取对象方法执行前后的时间。
import java.util.Calendar;
public class AnimalUtil {
//第一个拦截器方法
public void method1() {
Calendar c = Calendar.getInstance();
System.out.println("执行当前方法前的时间是："+c.get(c.YEAR)+"年"+(c.get(c.MONTH)+1)+"月"+c.get(c.DATE)+"日"+c.get(c.HOUR_OF_DAY)+"时"+c.get(c.MINUTE)+"分"+c.get(c.SECOND)+"秒");
}
//第二个拦截器方法
public void method2() {
Calendar c = Calendar.getInstance();
System.out.println("执行当前方法后的时间是："+c.get(c.YEAR)+"年"+(c.get(c.MONTH)+1)+"月"+c.get(c.DATE)+"日"+c.get(c.HOUR_OF_DAY)+"时"+c.get(c.MINUTE)+"分"+c.get(c.SECOND)+"秒");
}
}
为了避免以硬编码的方式将拦截器方法插入到代理对象的方法中。可以使用Proxy和InvocationHandler来实现将拦截器方法自动插入到对象的方法序列中执行。即实现InvocationHandler接口，并实现invoke()方法。利用执行动态代理对象的所有方法时，都会被替换成执行invoke()方法，可以将需要插入的拦截器逻方法与代理对象方法的关系在invoke()方法中实现。
package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
public Object target;
public void setTarget(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
AnimalUtil au = new AnimalUtil();
au.method1();
//以target作为主调来执行method方法
Object result = method.invoke(target, args);
au.method2();
return result;
}
}
上面invoke()方法中Object result = method.invoke(target,args);则通过反射的方式以target作为主调来执行method方法，即回调了target对象的原有方法。
接下来创建一个工厂类，该对象专为指定的target生成动态代理实例。
import java.lang.reflect.Proxy;
//使用工厂类也可以复用代理类创建过程。
public class MyProxyFactory {
public static Object getProxy(Object target) {
MyInvocationHandler handler = new MyInvocationHandler();
//为MyInvocationHandler设置target对象
handler.setTarget(target);
//创建并返回一个动态代理
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
}
}
接下来进行测试：
import java.util.Calendar;
public class Test {
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
Animal target = new GunDog();
Animal dog = (Animal)MyProxyFactory.getProxy(target);
dog.info();
dog.run();
Animal target1= new Cat();
Animal cat = (Animal)MyProxyFactory.getProxy(target1);
cat.info();
cat.run();
}
}
结果如下：
执行当前方法前的时间是：2018年8月21日16时57分8秒
我是一只猎狗
执行当前方法后的时间是：2018年8月21日16时57分9秒
执行当前方法前的时间是：2018年8月21日16时57分9秒
我奔跑迅速
执行当前方法后的时间是：2018年8月21日16时57分10秒
执行当前方法前的时间是：2018年8月21日16时57分10秒
我是一只花猫
执行当前方法后的时间是：2018年8月21日16时57分11秒
执行当前方法前的时间是：2018年8月21日16时57分11秒
我反应敏捷
执行当前方法后的时间是：2018年8月21日16时57分12秒当动态代理对象代替target对象时，方法被替换成invoke()方法后，可以在invoke()方法实现更复杂的拦截逻辑，使得不需要用硬编码的形式为target对象ch插入拦截方法。