【设计模式】Proxy 代理模式

【设计模式】Proxy 代理模式

1.代理模式的定义

代理模式：为另一个对象提供一个替身或占位符以控制对这个对象的访问。

2.静态代理

首先我们通过案例来引出为什么我们需要使用代理模式。

我们给出如下一个接口Moveable 和该接口的实现类：

Moveable.java

package com.proxy;
public interface Moveable {
void move();
}

Tank.java

package com.proxy;

import java.util.Random;
public class Tank implements Moveable{
@Override
public void move() {
//long start = System.currentTimeMillis();
//System.out.println("Tank Moving...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
//long end = System.currentTimeMillis();
//System.out.println("time:"+(end-start));
}
}

需求：我们想要知道实现Moveable的实现类，move()方法的运行时间

解决：我们可以通过在Tank.java的源码中插入自己的代码（红色部分），来统计这个move()方法的运行时间。

问题：如果我们不能对源码进行修改，或者你没有源码，比如这个方法是别人提供的包中提供的class文件。

现实意义是我们对java进行性能测试，我们就需要对各个方法前后记录时间，打印日志等。

方法1：使用继承重写方法，把原来的方法前后添加一些逻辑。

对Tank2调用move()方法，它永远调用的是父类的方法，从这个角度上来说它是父类的一个代理。

Tank2.java

package com.proxy;
/**
* 通过继承的方式来实现记录方法move()的运行时间
*/
public class Tank2 extends Tank {
public void move(){
long start = System.currentTimeMillis();
super.move();
long end = System.currentTimeMillis();
System.out.println("time:"+(end-start));
}
}

Client.java 测试类

方法2：使用聚合的方式

Tank3在调用move方法的时候永远调用的是实现Moveable接口的实现类的move()方法。

在这种情况下Tank3相当于Moveable实现类的一个代理，将具体的实现替换成特定类。

Tank3.java

package com.proxy;
import com.proxy.Moveable;
public class TankTimeProxy implements Moveable {
Moveable t;
public TankTimeProxy(Moveable t) {
this.t = t;
}
public void move() {
long start = System.currentTimeMillis();
System.out.println("startTime:" + start);
this.t.move();
long end = System.currentTimeMillis();
System.out.println("time:" + (end - start));
}
}

以上两种方式聚合要好与继承的方式，

原因：当我们需要添加的事物变得比较多时（比如在方法开始结束时不仅还要记录时间，检查权限，日志等），

继承会比较多，而聚合就可以很好的处理各个功能上的叠加的情况。

假设：我们需要在调用move()方法前先记录日志，在记录时间

TankLogProxy.java

package com.proxy;
public class TankLogProxy implements Moveable{
Moveable t;
public TankLogProxy(Moveable t){
super();
this.t = t;
}
@Override
public void move() {
System.out.println("Tank Start ....");
t.move();
System.out.println("Tank Stop ....");
}

TankTimeProxy.java

package com.proxy;
public class TankTimeProxy implements Moveable {
Moveable t;
public TankTimeProxy(Moveable t){
super();
this.t = t;
}
@Override
public void move() {
long start = System.currentTimeMillis();
System.out.println("startTime:"+start);
t.move();
long end = System.currentTimeMillis();
System.out.println("time:"+(end-start));
}
}

测试类Client.java

package com.proxy;
public class Client {
public static void main (String [] args){
//先记录日志，再记录时间
Tank t = new Tank();
TankTimeProxy ttp = new TankTimeProxy(t);
TankLogProxy tlp = new TankLogProxy(ttp);
Moveable m = tlp;
m.move();

/**先记录时间，再记录日志*/
/**
Tank t = new Tank();
TankLogProxy tlp = new TankLogProxy(t);
TankTimeProxy ttp = new TankTimeProxy(tlp);
Moveable m = ttp;
m.move();
*/
}
}

运行结果：

Tank Start ....
startTime:1465278163874
Tank Moving...
time:4330
Tank Stop ....

以上就是静态代理的典型例子。但是问题来了，我们能不能动态生成一个代理，能够做为任何目标的代理（前提是代理的类和被代理的类都实现了共同的接口）。
3.代理模式类图



4.动态代理的引入
动态代理的目标：解决类太多的问题，为了可以对任意的对象、任意的接口方法，实现任意的代理。静态代理：我们的代理类是需要具体写出来的。

动态代理：不关心生成代理类的名称。用户需要的代理对象由Proxy代理类直接产生。
问题：那么这个代理类Proxy如何产生代理对象。
1.假设我们能够将一段源码的字符串进行编译（动态编译），产生一个新的类（我们实现逻辑的代理类）。

   对于以上的例子我们可以这样描述：我们在源文件中删除TankTimeProxy.java文件，把TankTimeProxy.java源码作为字符串，

   进行动态编译，就相当于产生了TankTimeProxy对象，这段代码我们想完成什么逻辑，就完成我们自己的业务逻辑。

   问题来了：我们如何动态编译这段代码

   解决：Jdk6 Complier API, CGLib, ASM
2.把这个新的类Load到内存，再由这个新的类产生新的对象（代理类生成的对象）。

例子：

下面我们来模拟下动态代理的过程（实际上字符串源码部分我们也是可以动态生成的，
为了简单起见，我们先把字符串源码写死）

package com.proxy.test;
import com.proxy.Moveable;
import com.proxy.Tank;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;
public class Test1 {
public static void main(String[] args) throws Exception {
String rt = "\r\n";
String src = "package com.proxy;" + rt +
"  public class TankTimeProxy implements Moveable {" + rt +
"       Moveable t;" + rt +
"  public TankTimeProxy(Moveable t){" + rt +
"      super();" + rt +
"      this.t = t;" + rt +
"     }" + rt +
"  @Override" + rt +
"  public void move() {" + rt +
"     long start = System.currentTimeMillis();" + rt +
"     System.out.println(\"startTime:\"+start);" + rt +
"     t.move();" + rt +
"     long end = System.currentTimeMillis();" + rt +
"     System.out.println(\"time:\"+(end-start));" + rt +
"  }" + rt +
" }";
//我们想让这段代码编译，如何做呢？
//1.首先，我们可以把这段代码写到临时文件中
String fileName = System.getProperty("user.dir") +
"/src/com/proxy/TankTimeProxy.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//2.编译生成的Java文件生成class文件
//获取此平台提供的 Java™ 编程语言编译器
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMagr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMagr.getJavaFileObjects(fileName);
JavaCompiler.CompilationTask t = compiler.getTask(null, fileMagr, null, null, null, units);
t.call();
fileMagr.close();

//3.将编译生成的class的load 到内存，生成新对象
//注意：使用ClassLoader（）必须保证那个class在classPath路径下，
//所以我们使用URLClassLoader
URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.proxy.TankTimeProxy");
System.out.println(c);

//4.生成代理类对象
Constructor ctr = c.getConstructor(Moveable.class);
Moveable m = (Moveable)ctr.newInstance(new Tank());
m.move();
}
}

运行结果：

class com.proxy.TankTimeProxy
startTime:1465283901100
Tank Moving...
time:1043

问题1：现在我们可以实现指定接口（Moveable）的动态代理，但是我们要产生实现任何接口的代理，应该怎么做？

解决：我们把接口也作为参数传进去。
问题2：对于接口的方法是不可以写死的，我们要能够使用户动态指定对接口方法的处理方式

解决：定义处理逻辑的接口InvocationHandler，对方法的处理放在实现中，由具体的子类实现代理逻辑，

封装InvocationHandler中。
下面我们来模拟JDK动态代理的实现来进行讲解。
1.定义InvocationHandler接口，我们将代理对象的方法处理逻辑放在InvocationHandler实现的子类中。
处理的具体方式是由其子类来决定的。

InvocationHandler.java

package com.proxy;
import java.lang.reflect.Method;
//为方法处理逻辑定义一个统一的接口
public interface InvocationHandler {

public void invoke(Object o, Method m);

 }

2.通过调用Proxy.newProxyInstance(Class infce,  InvocationHandler h)来产生代理类的代理对象。

问题的关键：我们如何动态产生代理对象呢？

解决：这个方法有两个参数，
Class infce：为了对不同的接口进行代理，我们把接口作为参数传递进去。
InvocationHandler h：对方法的逻辑的处理，我们通过InvocationHandler 具体子类来实现，并做为入参传递给代理类。

这样一来我们就可以对任意的对象（target）、任意的接口方法(infce)、实现任意的代理(InvocationHandler)。

Proxy.java

package com.proxy;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
public class Proxy {
public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception {
String rt = "\r\n";
String methodStr = "";
Method[] methods = infce.getMethods();
/**写一个循环，将所用的方法都拿出来*/
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
"    try {" + rt +
"    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
"    h.invoke(this, md);" + rt +
"    }catch(Exception e) {e.printStackTrace();}" + rt +
"}";
}
String src = "package com.proxy;" + rt +
"import java.lang.reflect.Method;" + rt +
"  public class $Proxy1 implements "+infce.getName()+" {" + rt +
"  com.proxy.InvocationHandler h;" + rt +
"  public $Proxy1(InvocationHandler h){" + rt +
"      this.h = h;" + rt +
"     }" + rt +
methodStr +
" }";

//1.首先，我们可以把这段代码写到临时文件中
String fileName = System.getProperty("user.dir") +
"/src/com/proxy/$Proxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();

//2.编译生成的Java文件生成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMagr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMagr.getJavaFileObjects(fileName);
JavaCompiler.CompilationTask t = compiler.getTask(null, fileMagr, null, null, null, units);
t.call();
fileMagr.close();

//3.将编译生成的class的load 到内存，生成新对象
URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.proxy.$Proxy1");
System.out.println(c);

//4.生成代理类对象
Constructor ctr = c.getConstructor(InvocationHandler.class);
Object m = ctr.newInstance(h);

return m;
}
}

3.现在我们可以通过新建一个Tank类（被代理类），InvocationHandler的实现类TimeHandler（业务逻辑的处理） 来对代理模式进行进一步的说明。

a.目标类：Tank.java

package com.proxy;

import java.util.Random;
public class Tank implements Moveable{
@Override
public void move() {
System.out.println("Tank Moving...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

b.TimeHandler类，实现的InvationHandler类，加上自己的代理逻辑，要加上被代理对象要调用的方法。

package com.proxy;
import java.lang.reflect.Method;
public class TimeHandler implements  InvocationHandler {
private Object target; //定义被代理对象的一个引用
public TimeHandler(Object target){
super();
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
long start = System.currentTimeMillis();
System.out.println("startTime :"+start);
try {
m.invoke(target);//调用被代理对象的m方法
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("endTime :"+end);
System.out.println("useTime:" + (end-start));

}
}

c.Client.java测试类

package com.proxy;
public class Client {
public static void main (String [] args) throws Exception {
Tank t = new Tank(); //定义一个被代理的对象
InvocationHandler h = new TimeHandler(t);
//调用Proxy.newProxyInstance()方法生成一个代理对象。
Moveable m = (Moveable) Proxy.newProxyInstance(Moveable.class, h);
m.move();
}
}

现在我们来梳理一下上面例子的逻辑

 我们有一个Tank对象，Tank对象实现了Moveable接口，里面有个move方法，现在我想在Tank的move()方法前后增加一些自己的处理逻辑。

 首先我们定义了自己的逻辑：这个逻辑就是，TimeHandler（自己写的代理逻辑处理类），可以将代理对象存到这个类中去我会把我定义的Tank的对象交给TimeHandler对象。

 这样TimeHandler调用Tank里面的方法的时候，会先执行自己的逻辑然后Tank的方法，最后后面的逻辑。
再举一个数据库添加记录的例子。

UserMgr.java共同的接口

package com.proxy.test2;
public interface UserMgr {
void addUser();
}

UserMgrImpl.java 被代理的类

package com.proxy.test2;
public class UserMgrImpl implements UserMgr {
@Override
public void addUser() {
System.out.println("1: 插入记录到user表");
System.out.println("2: 在另外一张表写日志");
}
}

TransactionHandler.java ,InvocationHandler具体的实现类

package com.proxy.test2;
import com.proxy.InvocationHandler;
import java.lang.reflect.Method;
public class TransactionHandler implements InvocationHandler {
private Object target;
public TransactionHandler(Object target) {
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
System.out.println("Transaction Start");
try {
m.invoke(target);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Transaction Commit");
}
}

Client.java

具体的测试案例

package com.proxy.test2;
import com.proxy.InvocationHandler;
import com.proxy.Proxy;
public class Client {
public static void main(String[] args) throws Exception {
UserMgr mgr = new UserMgrImpl();
InvocationHandler h = new TransactionHandler(mgr);
//TimeHandler h2 = new TimeHandler(h);
UserMgr u = (UserMgr) Proxy.newProxyInstance(UserMgr.class,  h);
u.addUser();
}
}

5.JDK动态代理的实现
JDK中的动态代理是通过2个类来实现的：

InvocationHandler：

InvocationHandler

是代理实例的调用处理程序 实现的接口
方法：Object invoke(Object proxy, Method method, Object [ ] args )三个参数的含义依次是：代理的对象，代理的方法， 方法的参数

Proxy：返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。Static Object newProxyInstance(ClassLoader loader, Class<?> [ ] interfaces , InvocationHandler h）
动态代理的作用：我不用修改原来的代码，我就可以在原来的代码中插入一些内容。也就是切面编程，AOP()Aspect oriented Programming ,
可插拔的【配置文件】，而且互相之间是可以叠加的。我们可以把上一个代理作为下一个代理的对象。
下面我们使用JDK动态代理举2个简单的案例：
PersonDao.java

public interface PersonDao {
public void savePerson();
}

PersonDaoImpl.java

public class PersonDaoImpl implements PersonDao{
public void savePerson() {
System.out.println("save person");
}
}

Transaction.java

public class Transaction {
public void beginTransaction(){
System.out.println("begin transaction");
}
public void commit(){
System.out.println("commit");
}
}

MyInterceptor.java

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 1、引入personDao和Transaction
* 2、完成invoke方法
*/
public class MyInterceptor implements InvocationHandler{
private Object target;
private Transaction transaction;
public MyInterceptor(Object target,Transaction transaction){
this.target = target;
this.transaction = transaction;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//在invoke()中做事务判断。
if(method.getName().equals("savePerson")||method.getName().equals("updatePerson")){
this.transaction.beginTransaction();
method.invoke(this.target, args);//调用目标类的目标方法
this.transaction.commit();
}else{
method.invoke(this.target, args);//调用目标类的目标方法
}
return null;
}
}

ProxyTest.java

import java.lang.reflect.Proxy;
import org.junit.Test;
/**
*   问题：
*      1、拦截器中的invoke方法在什么时候被调用的?
*         在代理对象调用方法的时候，进入了拦截器中的invoke方法
*      2、拦截器中的method参数是什么？在什么时候由实参传递给形参的?
*         代理对象的方法的名称是什么，method参数就是什么
*         代理对象调用方法的时候，进入了拦截器中的invoke方法，这个时候，传递参数
*      3、生成的代理对象实现了接口，代理对象的方法体的内容是什么？
*         方法体的内容就是拦截器中的invoke方法体的内容
*
* jdkproxy的优点: 动态的产生代理对象，所以只需要用一个拦截器就可以了
* jdkproxy的缺点: 如果在invoke方法中做事务的判断，将是一件很复杂的事情
* 比如我们在Service接口中有20个类 ，20个方法。30个方法不需要事务，370 个方法需要事务。
* 在invoke中做事务判断很麻烦。程序员还是写拦截器了，写拦截器中的invoke方法了，所以invoke方法还需要修改 。
* 所以这个解决方式还是不靠谱。
*
* 说明： 目标类和代理类实现了共同的接口
*/
public class ProxyTest {
@Test
public void testProxy(){
PersonDao target = new PersonDaoImpl();
Transaction transaction = new Transaction();
MyInterceptor interceptor = new MyInterceptor(target, transaction);
/**
* 第一个参数: 目标类的类加载器
* 第二个参数: 目标类实现的所有的接口
* 第三个参数: 拦截器
*/
PersonDao personDao = (PersonDao)Proxy.newProxyInstance(target.getClass().getClassLoader(),

target.getClass().getInterfaces(), interceptor);
personDao.savePerson();
}
}

运行结果：

begin transaction
save person
commit

案例2：
SalaryManager.java

public interface SalaryManager {
public void showSalary();
}

SalaryManagerImpl.java

public class SalaryManagerImpl implements SalaryManager{
public void showSalary() {
System.out.println("正在查看工资");
}
}

Logger.java

public class Logger {
public void logging(){
System.out.println("logging");
}
}

Security.java

public class Security {
public void security(){
System.out.println("security");
}
}

Privilege.java

public class Privilege {
private String access;
public String getAccess() {
return access;
}
public void setAccess(String access) {
this.access = access;
}
}

MyInterceptor.java

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInterceptor implements InvocationHandler{
private Object target;
private Logger logger;
private Security security;
private Privilege privilege;
public MyInterceptor(Object target,Logger logger, Security security, Privilege privilege) {
super();
this.target = target;
this.logger = logger;
this.security = security;
this.privilege = privilege;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//启动日志
this.logger.logging();
//安全性的框架
this.security.security();
//判断权限
if(this.privilege.getAccess().equals("admin")){
method.invoke(this.target, args);//调用目标方法
}else{
System.out.println("没有权限执行");
}
return null;
}
}

SalaryTest.java

package com.itheima11.spring.proxy.salary;

import java.lang.reflect.Proxy;

import org.junit.Test;

public class SalaryTest {
@Test
public void testSalary(){
Logger logger = new Logger();
Security security = new Security();
Privilege privilege = new Privilege();
privilege.setAccess("xvcz");
SalaryManager target = new SalaryManagerImpl();
MyInterceptor interceptor = new MyInterceptor(target, logger, security, privilege);
SalaryManager salaryManager = (SalaryManager)Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),interceptor);
salaryManager.showSalary();
}
}

运行结果：

logging
security
没有权限执行

6.CGlib动态代理
cglib动态代理需要引入第三方Jar包，他与JDK代理模式的主要区别在于，JDK代理的目标类和代理类实现共同的接口，
CGLIB动态代理则是目标类是代理类的父类。
PersonDao.java

public interface PersonDao {
public void savePerson();
}

PersonDaoImpl.java

public class PersonDaoImpl implements PersonDao{
public void savePerson() {
System.out.println("save person");
}
}

Transaction.java

public class Transaction {
public void beginTransaction(){
System.out.println("begin transaction");
}
public void commit(){
System.out.println("commit");
}
}

MyInterceptor.java

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* 1、引入personDao和Transaction
* 2、完成invoke方法
*/
public class MyInterceptor implements MethodInterceptor{
private Object target;
private Transaction transaction;
public MyInterceptor(Object target,Transaction transaction){
this.target = target;
this.transaction = transaction;
}

//产生代理对象（这是一个代码增强机制，它是在JVM内部去实现的）
public Object createProxy(){
Enhancer enhancer = new Enhancer();
enhancer.setCallback(this);//this代表拦截器对象
enhancer.setSuperclass(target.getClass());//设置代理类的父类为目标类
return enhancer.create();
}
/**
* 该方法的内容和jdkpoxy中的invoke方法的内容是一样的
*/
public Object intercept(Object arg0, Method method,  Object[] args,MethodProxy arg3) throws Throwable {
this.transaction.beginTransaction();
method.invoke(this.target, args);
this.transaction.commit();
return null;
}
}

ProxyTest.java

import org.junit.Test;
/**
* JDK代理和cglib代理的主要区别：
* Jdk代理的方式：目标类和代理类实现了共同的接口
* Cglib动态代理的方式：目标类是代理类的父类
*/
public class ProxyTest {
@Test
public void testProxy(){
PersonDaoImpl target = new PersonDaoImpl();
Transaction transaction = new Transaction();
MyInterceptor interceptor = new MyInterceptor(target, transaction);
PersonDaoImpl proxy = (PersonDaoImpl)interceptor.createProxy();
proxy.savePerson();
}
}

运行结果：

begin transaction
save person
commit