java设计模式之代理模式

一、代理模式

（1）简介

代理（Proxy）是一种设计模式，提供了对目标对象另外的访问方式，即通过代理对象进行访问目标对象，这样做的好处是可以在目标对象实现的基础上，增强额外的功能操作,即扩展目标对象的功能.

举个例子来说明代理的作用，假设你准备结婚，这就需要联系婚庆公司，包办各种酒席啥的，来达到结婚这样一个目的，那么在这里，结婚就是一个目标对象，其他琐碎的事情交给婚庆公司来解决，这就是代理思想在现实中的应用。

代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象

（2）使用场景

当不想直接访问某个对象的时候，就可以通过代理

不想买午餐，同事帮忙带
买车不用去厂里，去4s店
去代理点买火车票，不用去车站

二、实现三种代理模式

（1）静态代理

1、如何使用？

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

下面举个例子进行说明

还是上面那个结婚的例子，定义一个结婚的接口Marry，然后让目标对象（You）实现这个接口的方法，然后再让代理对象（WeddingCompany）也实现这个接口，最后调用的时候通过调用代理对象的方法来实现目标对象的方法

示例代码：

接口 Marry.java

public interface Marry{
	void marry();
}

目标对象 You.java

public class You implements Marry{
	@Override
	public void marry() {
		 System.out.println("你结婚了！！！！");
	}
}

代理对象WeddingCompany.java

public class WeddingCompang implements Marry{
	private You you;
	
	public WeddingCompang(You you) {
		this.you = you;
	}

	@Override
	public void marry() {
		before();
		you.marry();
		after();
	}
	
	private void before() {
		System.out.println("收拾房子，发请帖");

	}
	
	private void after() {
		System.out.println("入洞房，嘿嘿嘿");

	}
	
}

测试类

public class Test {

	public static void main(String[] args) {
		// 1、创建自己的对象
		You you = new You();
		// 2、创建代理对象，将自己传给代理对象
		WeddingCompang weddingCompang = new WeddingCompang(you);
		// 3、代理对象调用方法
		weddingCompang.marry();

	}

}

2、静态代理总结

可以做到在不修改目标对象的功能前提下,对目标功能扩展.
因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.
静态代理有利有弊，我们可以使用下面的动态代理解决静态代理中的缺点

（2）JDK动态代理

1、动态代理有以下特点:

代理对象,不需要实现接口
代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
动态代理也叫做:JDK代理,接口代理

2、JDK中的代理对象API

代理类在java.lang.reflect.Proxy包下，JDK实现动态代理只需要使用Proxy类下的静态方法：

 public static Object newProxyInstance(ClassLoader loader,
                                        Class<?>[] interfaces, 
                                        InvocationHandler h)

该方法需要3个参数，分别为

ClassLoader loader：指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<?>[] interface：目标对象实现的接口的类型
InvocationHandler h：事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

3、代码示例

说明：新建一个保存学生信息的案例，在每次执行save()方法保存学生信息时进行判断是否有相应的权限保存。

目标对象 Dao 层接口 StudentDao.java

public interface StudentDao{
	public void save();
}

Dao的实现类，实现保存的具体方法 StudentDaoImpl.java

public class StudentDaoImpl implements StudentDao{
	@Override
	public void save() {
		System.out.println("已保存！");
	}
}

代理工厂 JdkProxy.java为目标类StudentDao实现动态代理

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

/**
 * 使用JDK的动态代理对userDao产生动态代理
 * @author Allan
 *
 */
public class JdkProxy implements InvocationHandler{
	
	private StudentDao studentDao;
	
	public JdkProxy(StudentDao studentDao){
		this.studentDao = studentDao;
	}
	/**
	 * 产生UserDao代理的方法
	 * @return
	 */
	public StudentDao createProxy(){
		//三个参数：类加载器、实现的接口、
		StudentDao studentDaoProxy = (StudentDao) Proxy.newProxyInstance(studentDao.getClass().getClassLoader(),
				studentDao.getClass().getInterfaces(), this);
		return studentDaoProxy;
	}
	
	//三个参数  对象、方法、方法参数
	@Override
	public Object invoke(Object object, Method method, Object[] args) throws Throwable {
		// 判断方法名是否为save
		if("save".equals(method.getName())){
			//增强该save方法
			System.out.println("===判断是否有权限保存，这是演示，无逻辑代码===");
			return method.invoke(studentDao,args);
		}
		
		return method.invoke(studentDao, args);
	}

}

测试方法，进行代理测试

@Test
	public void test(){
	  StudentDao studentDao = new StudentDaoImpl();
	  //创建代理
	  StudentDao proxy = new JdkProxy(studentDao).createProxy();
	  proxy.save();
	}

总结:
代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

（3）Cglib动态代理

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP,为他们提供方法的拦截

使用Cglib代理需要引入jar包，这里我们直接使用Spring-core核心包，因为里面集成了Cglib

代码示例

目标对象 CustomDao.java

public class CustomDao {
	
	public void save(){
		System.out.println("已保存");
	}
}

Cglib代理类 CglibProxy.java

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

class CglibProxy implements MethodInterceptor{
	
	CustomDao customDao;
	public CglibProxy(CustomDao customDao){
		this.customDao = customDao;
	}
	
	/***
	 * 使用Cglib产生代理的方法
	 */
	
	public CustomDao createProxy(){
		//1.创建Cglib的核心类
		Enhancer enhancer = new Enhancer();
		//2.设置父类
		enhancer.setSuperclass(customDao.getClass());
		//3.设置回调（类似InvocationHandler对错）
		enhancer.setCallback(this);
		//4.创建代理对象并返回
		CustomDao proxy = (CustomDao) enhancer.create();
		return proxy;
	}

	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		if ("save".equals(method.getName())) {
			//增强方法
			System.out.println("===判断是否有权限保存，这是演示，无逻辑代码===");
		}
		return methodProxy.invoke(customDao, args);
	}
	
}

测试类

import org.junit.Test;

public class CglibDemo {
	
	@Test
	//动态代理
	public void test(){
	  CustomDao customDao = new CustomDao();
	  //创建代理
      CustomDao proxy = new CglibProxy(customDao).createProxy();
      proxy.save();
	 
	}

}