Java设计模式：代理模式

绪论

其实很早以前就看过一些关于设计模式的文章，知道这个很重要，为此还写了一些demo，但是在实际开发过程中基本没有使用过。原因：不习惯，不记得，其实更多的是不明白什么情况下可以使用。所以导致自己的代码又臭又长，还会重复的造一些轮子，使代码看起来毫无亮点。
这次学习设计模式，更多的是分析理解，思考以往编程中哪些地方可以用到这些模式，从而可以使以后的自己在开发相同模块时可以使用。

理解

1. 结构型模型。
2. 基本概念：为其他对象提供一种代理以控制对这个对象的访问。也可以说，在出发点到目的地之间有一道中间层。
3. 为其他对象提供一种代理以控制对这个对象的访问。（这让我想起了Redis缓存服务，第一次请求可以直接访问数据库，获取数据之后可以放入缓存，等其它再次访问时，只在缓存中获取）
4. 主要解决在直接访问对象时带来的问题。
5. 优点： 1、职责清晰。 2、高扩展性。 3、智能化。4、可以做到在不修改目标对象的功能前提下,对目标功能扩展。
6. 缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。3、因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，类太多。同时，一旦接口增加方法,目标对象与代理对象都要维护。

代码

1、静态代理

IUserDao.java

public interface IUserDao {
	void save();
}

UserDaoImpl.java

public class UserDaoImpl implements IUserDao {
	@Override
	public void save() {
		System.out.println("保存数据");
	}
}

UserDaoProxy.java

public class UserDaoProxy implements IUserDao {
	private IUserDao u;
	
	public UserDaoProxy(IUserDao u) {
		this.u = u;
	}

	@Override
	public void save() {
		System.out.println("--开始事务--");
		// 执行目标对象方法
		u.save();
		System.out.println("--结束事务--");
	}
}

Main.java

public class Main {
	public static void main(String[] args) {
		IUserDao dao = new UserDaoImpl();
		UserDaoProxy proxy = new UserDaoProxy(dao);
		proxy.save();
	}
}

2、JDK代理

IUserDao.java

public interface IUserDao {
	void save();
}

UserDaoImpl.java

public class UserDaoImpl implements IUserDao {
	@Override
	public void save() {
		System.out.println("保存数据");
	}
}

ProxyFactory.java

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

public class ProxyFactory {
	// 维护目标对象
	private Object object;

	public ProxyFactory(Object obj) {
		this.object = obj;
	}

	// 给目标对象生成代理对象
	public Object getProxyInstance() {
		// ClassLoader：指定当前目标对象使用类加载器,获取加载器的方法是固定的
		// Interfaces：目标对象实现的接口的类型,使用泛型方式确认类型
		// InvocationHandler：事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
		return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),
				new InvocationHandler() {

					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						System.out.println("JDK动态代理 - 开始事务");
						// 执行目标对象方法
						Object value = method.invoke(object, args);
						System.out.println("JDK动态代理 - 结束事务");
						return value;
					}
				});
	}
}

Main.java

public class Main {
	public static void main(String[] args) {
		// 代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理
		// 目标对象
		IUserDao dao = new UserDaoImpl();
		// 给目标对象，创建代理对象
		IUserDao proxy = (IUserDao) new ProxyFactory(dao).getProxyInstance();
		// 执行方法
		proxy.save();
	}
}

3、Cglib代理

UserDao.java

public class UserDao {
	public void save() {
		System.out.println("保存数据");
	}
	
	public final void update() {
        System.out.println("修改数据");
    }
	
	public static void delete() {
        System.out.println("删除数据");
    }
}

ProxyFactoryCglib.java

import java.lang.reflect.Method;

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

//使用Spring-core.jar包
/**
* Cglib代理
* 有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理
* 代理的类不能为final,否则报错
* 目标对象的方法如果为private/final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法
* 主要为没有接口的类实现代理
*/
public class ProxyFactoryCglib implements MethodInterceptor{
	
	// 维护目标对象
	private Object object;
	
	private ProxyFactoryCglib(Object object){
		this.object = object;
	}
	
	// 给目标对象创建一个代理对象
	public static Object getProxyFactoryCglib(Object obj){
		//1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(obj.getClass());
        //3.设置回调函数
        en.setCallback(new ProxyFactoryCglib(obj));
        //4.创建子类(代理对象)
        return en.create();
	}
	
	@Override
	public Object intercept(Object arg0, Method method, Object[] arg2, MethodProxy arg3) throws Throwable {
		System.out.println("Cglib开始事务...");
        //执行目标对象的方法
        Object result = method.invoke(object, arg2);
        System.out.println("Cglib提交事务...");
        return result;
	}
}

Main.java

public class Main {
	public static void main(String[] args) {
		// 在Spring的AOP编程中:
		// 如果加入容器的目标对象有实现接口,用JDK代理
		// 如果目标对象没有实现接口,用Cglib代理
		UserDao dao = (UserDao)ProxyFactoryCglib.getProxyFactoryCglib(new UserDao());
		dao.save();
		dao.update();
		dao.delete();
	}
}

结果

1、静态代理

2、JDK代理

3、Cglib代理

（若有什么错误，请留言指正，3Q）