java之代理模式

静态代理：

java代理是一种模式--代理模式。采用代理模式，可以在不改变目标类代码的基础上，通过代理对象，来增加额外的功能(比如增加日志检测等)或者只需要目标对象的部分行为。

java中，代理分为静态代理和动态代理。

静态代理：我的理解是程序员自己或者用某些工具去自己创建或者生成代理类。在使用之前，代理类已经存在。

动态代理：区别于静态代理，它是动态的，不需要程序员去自己创建，只需要采用现成的动态代理类库(jdk动态代理，cglib)调用某些类的某些方法，动态生成代理类。代理类在使用之前是不存在的。什么时候使用，什么时候创建。是动态的。

静态代理:

静态代理有两种实现方式。

1.合成

即将目标类作为代理类的全局成员。需要目标类实现接口

接口:

package com.wtd.staticproxy;

public interface Moveable {
void move();
}

目标类：

package com.wtd.staticproxy;

import java.util.Random;

/**
* @desc Car:被代理对象，真实对象
* */
public class Car implements Moveable {

@Override
public void move() {
try {
System.out.println("the car is running");
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

代理类：

package com.wtd.staticproxy;

/**
* @desc 静态代理 第二种方式：合成。
* 静态代理，说白了，就是手动创建 代理类。手动创建的两种方式[继承,合成]
* */
public class Car2 implements Moveable {//代理类：必须和被代理类都实现统一的接口
Car car;//被代理类类 (真实类)
public Car2(Car car) {
super();
this.car= car;
}
@Override
public void move() {
System.out.println("the car start");//业余方法
long startTime= System.currentTimeMillis();//业余方法
car.move();//调用被代理类的功能方法
long endTime= System.currentTimeMillis();//业余方法
System.out.println("the car stop，use time："+ (endTime-startTime)+"ms");//业余方法
}

}

测试类：

package com.wtd.staticproxy;

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
Car car = new Car();//创建被代理类(真实类)
Moveable m2= new Car2(car);//创建代理类
m2.move();
}

}

output:

the car start
the car is running
the car stop，use time：681ms

2.继承

代理类继承目标类。不需要目标类继承接口。但是目标类必须不能被final修饰

目标类:

package com.wtd.staticproxy;

import java.util.Random;

/**
* @desc Car:被代理对象，真实对象
* */
public class Car {

public void move() {
try {
System.out.println("the car is running");
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

代理类：

package com.wtd.staticproxy;

/**
* @desc 静态代理有两种方式， 这是第一种：继承的方式、
* 第二种：合成
* */
public class Car1 extends Car{
@Override
public void move() {
System.out.println("汽车开始行驶");//业余方法
long startTime= System.currentTimeMillis();//业余方法
super.move();//调用父类的功能方法
long endTime= System.currentTimeMillis();//业余方法
System.out.println("汽车行驶结束，行驶了："+ (endTime- startTime)+"毫秒");//业余方法
}
}

测试类：

package com.wtd.staticproxy;

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
Car m= new Car1();
m.move();
}

}

output:

the car start
the car is running
the car stop，use time：361ms

动态代理：

原理：类似于静态代理中的合成。被代理对象必须继承某一接口

接口：

package com.wtd.dynamicproxy3;

public interface Moveable {
void move();
void run(String args);
}

目标对象(被代理对象):

package com.wtd.dynamicproxy3;

public class Car implements Moveable {

@Override
public void move() {
System.out.println("Car move()");
}

@Override
public void run(String args) {
System.out.println("Car run()"+ args);
}

}

调用处理器对象:InvocationHandler对象

package com.wtd.dynamicproxy3;

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

public class LogHandler implements InvocationHandler {
private Object proxied;
public LogHandler(Object proxied) {
this.proxied= proxied;
// TODO Auto-generated constructor stub
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println(
"----------proxy: "
+ proxy.getClass()
+ ", method: "
+ method+ ", args: "
+ args+ ", proxied: "
+ proxied.getClass());

return method.invoke(proxied, args);
}

}

测试类：

package com.wtd.dynamicproxy3;

import java.lang.reflect.Proxy;

public class TestDynamicProxy {
public static void main(String[] args) {
Car car= new Car();
Moveable m= (Moveable) Proxy.newProxyInstance(Moveable.class.getClassLoader(),
new Class<?>[]{Moveable.class},
new LogHandler(car));
m.move();
m.run("haha");
}
}

output:

----------proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.wtd.dynamicproxy3.Moveable.move(), args: null, proxied: class com.wtd.dynamicproxy3.Car
Car move()
----------proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.wtd.dynamicproxy3.Moveable.run(java.lang.String), args: [Ljava.lang.Object;@5e743399, proxied: class com.wtd.dynamicproxy3.Car
Car run()haha

cglib动态代理：

原理：类似于静态代理中的继承方式。被代理对象的类不能被final所修饰

首先需要导入jar包：cglib-nodep-x.x.x.jar。可在mvnrepository下载。

被代理类：父类：realObject:

package com.wtd.cglibproxy;

/**
* 目标类；父类；被代理类
* 不能被final所修饰
* */
public class Car {
public void move() {
System.out.println("the car running");
}
}

方法拦截器类：

package com.wtd.cglibproxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();

/**
* 设置获得代理对象(即子类对象)的方法
* 需要用到 Enhancer
* */
public Object getProxy(Class clazz){
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}

/**
* @author WesTward
* @param proxied:被代理对象，目标对象，父类对象
* @param method: 目标对象的 方法
* @param args: 目标对象的方法的参数
* @param proxy: 代理对象
* */
@Override
public Object intercept(Object proxied, Method method, Object[] args,
MethodProxy proxy) throws Throwable {
System.out.println("Log---------start");
proxy.invokeSuper(proxied, args);
System.out.println("Log---------end");
return null;
}

}

测试类：

package com.wtd.cglibproxy;

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
CglibProxy cglibProxy= new CglibProxy();
Car car = (Car) cglibProxy.getProxy(Car.class);
car.move();
}

}

output:

Log---------start
the car running
Log---------end

附：

动态代理主要运用了java的反射机制。