java静态代理，动态代理

常规流程，客户端发出请求，服务器响应。

如下图：来模拟一个客户端发出插入用户信息的请求，并打印日志时间。

服务器端处理代码：

public class UserDAOImpl implements UserDAO {

	@Override
	public void delete() {
		System.out.println("start time:" +new Date());
		System.out.println("delete ... ");
		System.out.println("end time:" +new Date());
	}

	@Override
	public void insert() {
		System.out.println("start time:" +new Date());
		System.out.println("insert ... ");
		System.out.println("end time:" +new Date());
	}

	@Override
	public void select() {
		System.out.println("start time:" +new Date());
		System.out.println("select ... ");
		System.out.println("end time:" +new Date());
	}

	@Override
	public void update() {
		System.out.println("start time:" +new Date());
		System.out.println("select ... ");
		System.out.println("end time:" +new Date());
	}

}

可以看出，大量的重复性代码，当客户不需要日志时间，又需要其他功能，难道我们还的把前后代码删了？ 那过几天客户又要了呢？ 既麻烦又违背了OCP原则.

由此产生了代理.

问题:

1.什么是代理?

2.代理有几种?

3.怎么实现?

4.有什么作用?

一.简单的说，比如我们要去买房子，如果我们亲自去找房，看房，付款等，这样很麻烦，我们不如找张三，让他帮我们办这些事。那我们就可以节省时间干别的。这种模式是GOB95 的代理模式。

二.代理分为静态代理和动态代理.

三.

首先看静态代理.如图:

可以看书，目标对象只负责业务逻辑代码的操作，二打印日志时间交给代理来做，这很有意义，将来客户需要打印日志，我们就去掉代理了，符合了OCP原则.

代理设计模式(结构型)


可以进行功能扩展。（将业务代码与非业务代码分离）

角色：目标角色，代理角色，抽象角色

目标角色：表示要完成的业务操作的对象

抽象角色：表示目标角色和代理角色的共同接口

代理角色：表示代替目标对象执行业务操作的对象

接口:

package com.bjpowernode.dao;

/**
 * 抽象角色
 */
public interface UserDAO {
	public void insert();
	public void delete();
	public void update();
	public void select();
	
}

实现类:

package com.bjpowernode.dao;

/**
 * 目标角色对象
 */
public class UserDAOImpl implements UserDAO {

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

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

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

	@Override
	public void update() {
		System.out.println("select ... ");
	}

}

代理类：

import java.util.Date;

/**
 * 代理角色对象
 */
public class UserDAOProxy implements UserDAO{

	private UserDAO userDAO ;
	
	public UserDAOProxy(UserDAO userDAO){
		this.userDAO = userDAO ;
	}
	
	@Override
	public void delete() {
		System.out.println("start time:" +new Date());
		userDAO.delete();
		System.out.println("end time:" +new Date());
	}

	@Override
	public void insert() {
		System.out.println("start time:" +new Date());
		userDAO.insert();
		System.out.println("end time:" +new Date());
	}

	@Override
	public void select() {
		System.out.println("start time:" +new Date());
		userDAO.select();
		System.out.println("end time:" +new Date());
	}

	@Override
	public void update() {
		System.out.println("start time:" +new Date());
		userDAO.update();
		System.out.println("end time:" +new Date());
	}

}

冲上可以看出，在代理类中需要有一个目标对象，这个目标对象中实现数据的操作，而打印日志时间交给代理类，代理类中在调用目标对象的方法.

注意：

代理类需要时间UserDao接口，并且目标类也同样实现相同的接口。

在测试的时候，我们不要直接调用目标对象的方法，而是调用代理类的方法。

public class TestUserDAO {


<span style="white-space:pre">	</span>public static void main(String[] args) {
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//目标对象
<span style="white-space:pre">		</span>UserDAO dao = new UserDAOImpl();
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//代理对象
<span style="white-space:pre">		</span>UserDAO daoProxy = new UserDAOProxy(dao);
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//执行代理对象的方法
<span style="white-space:pre">		</span>daoProxy.insert(); 
<span style="white-space:pre">		</span>daoProxy.delete();
<span style="white-space:pre">	</span>}


}

以上的代码在有些情况下还是有问题，比如:

1.一个代理类只能代理特定的接口,这样可能产生很多个代理类,代理方法,依然会存在很多重复的代码
2.可以进行功能扩展,但不利于扩展

下面就需要动态代理:

动态代理：
动态代理解决静态代理出现的问题,可以代理任意目标对象.
动态代理要求目标对象必须有接口才能代理,如果目标对象没有实现接口,则实现不了.
动态代理类是JVM在内存中创建的,不需要管理和维护.
功能扩展交给特殊类(InvocationHandler)实现,只需要编写一次. .

如图:

要使用动态代理，我们首先需要

1.创建目标对象，

2.然后创建扩展对象(将来的扩展代码就写在扩展对象的invoke方法中),

3.调用Proxy中的newProxyInstance()方法创建代理对象

注意:newProxyInstance有三个参数

代理对象
JDK动态代理：在内存中动态的产生代理类，然后产生代理对象返回
第一个参数：传目标对象的类的加载器，用于加载代理类
第二个参数：传目标对象的实现接口，因为代理类和目标类都实现同一个抽象角色
第三个参数：InvocationHandler扩展对象，用于功能扩展，因为代理类是内存中动态产生的，所以将扩展代码要写扩展类。
当调用代理对象的代理方法时，JVM自动调用扩展对象的invoke()方法。

第一个参数: 目标对象.getClass().getClassLoader()

第二个参数; 目标对象.getClass().getClassInterfaces()

第三个参数是一个继承InvocationHandler:类的对象

看代码

/**
 * 进行功能扩展，在业务方法执行前，后打印时间日志。
 */
public class LogTimeInvocationHandler implements InvocationHandler {

	private Object targetObejct ; //目标对象

	public LogTimeInvocationHandler(Object targetObejct) {
		this.targetObejct = targetObejct ;
		
	}

	/*
	 * 第一个参数：代理对象
	 * 第二个参数：表示目标对象的业务方法对象
	 * 第三个参数：目标对象的业务方法的参数
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
		//扩展代码
		System.out.println("start time:" +new Date());
		
		//执行业务方法
		
		Object result = method.invoke(targetObejct, args); //执行目标对象业务方法
		
		//扩展代码
		System.out.println("end time:" +new Date());
		return result; //扩展对象返回的结果就是目标对象方法的返回结果
	}

}

4. 假设代理对象以创建UserDAO daoProxy = (UserDAO) Proxy.newProxyInstance(
dao.getClass().getClassLoader(), 
dao.getClass().getInterfaces(), 
handler);

第四步直接就用代理对象调用数据操作方法.这样就可以实现动态代理.

说一下动态代理的流程，也是上面的UML图:

当创建代理对象时，JVM会在内存中自动创建一个无名的代理对象，这个代理对象实现的接口和我们的目标对象实现的接口一样(所以拥有者相同的接口方法),然后会关联一个InvocationHandler对象，也就是扩展类对象.当我们用代理对象调用方法时，首先回执行扩展类对象的invoke方法，在invoke方法中，利用反射调用method.invoke()方法。这个方法需要一个目标对象，也就是我们第二步的操作，如果没有目标对象会发生异常。然后执行目标对象的方法，在返回