代理的三种方式

代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。
举例：明星（XXX）---经纪人<-------用户  
              目标           （代理）

代理模式的关键点： 代理对象与目标对象。

静态代理:

1） 代理对象，要实现与目标对象一样的接口；

2） 举例:

   保存用户(模拟)

   Dao  ,  直接保存

   DaoProxy, 给保存方法添加事务处理

总结静态代理：

1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。

2）缺点：

--》  因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。

--》  一旦接口增加方法，目标对象与代理对象都要维护。

package com.sqf.a_static;

public interface IUserDao {
	
	void save();
	
}

package com.sqf.a_static;

/**
 * 目标对象
 * */
public class UserDao implements IUserDao{

	@Override
	public void save() {
		
		System.out.println("--已经保存数据--");
	}
	
	
	
}

package com.sqf.a_static;

/**
 * 代理对象 （静态代理）
 * */
public class UserDaoProxy implements IUserDao{//与目标对象实现同样的接口
	
	private IUserDao target;
	public UserDaoProxy(IUserDao target){
		this.target = target;
	}
	
	@Override
	public void save() {
		
		System.out.println("开启事务");
		
		target.save();

		System.out.println("关闭事务");
	}
}

package com.sqf.a_static;

public class App {
	
	public static void main(String[] args) {
		IUserDao target = new UserDao();
		IUserDao proxy = new UserDaoProxy(target);
		proxy.save();
	}
	
}

动态代理:

1）代理对象，不需要实现接口；

2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);

3)  动态代理， JDK代理， 接口代理；

 

JDK中生成代理对象的API：

| -- Proxy

static Object newProxyInstance(

ClassLoader loader,       指定当前目标对象使用类加载器

 Class<?>[] interfaces,     目标对象实现的接口的类型

InvocationHandler h       事件处理器

)  

动态代理总结：

代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
(class  $Proxy0  implements IuserDao)

package com.sqf.b_dynamic;

public interface IUserDao {
	
	void save();
	
}

package com.sqf.b_dynamic;

/**
 * 目标对象
 * */
public class UserDao implements IUserDao{

	@Override
	public void save() {
		
		System.out.println("--已经保存数据--");
	}
	
	
	
}

package com.sqf.b_dynamic;

/*
 * 代理对象
 * */
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFcatory {
	
	private Object target; //创建一个目标对象
	ProxyFcatory(Object target){
		this.target = target;
	}
	
	public  Object getProxyInstance(){
		System.out.println("11111111");
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
		target.getClass().getInterfaces(), //new Class[]{} 
		new InvocationHandler() {
			/**
			 *  proxy:　　指代我们所代理的那个真实对象
			 *	method:　　指代的是我们所要调用真实对象的某个方法的Method对象
			 *	args:　　指代的是调用真实对象某个方法时接受的参数
			 * */
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println("开启事务");
				
				Object retuenValue = method.invoke(target, args);
				
				System.out.println("提交事务");
				return retuenValue;
			}
		});
	}
	
}

package com.sqf.b_dynamic;

public class App {
	
	 public static void main(String[] args) {
		IUserDao target =  new UserDao();
		IUserDao proxy = (IUserDao) new ProxyFcatory(target).getProxyInstance();
		proxy.save();
	 }
}

Cglib代理

package com.sqf.c_cglib;

/**
 * 目标对象
 * */
public class UserDao  {

 	public void save() {
		
		System.out.println("--已经保存数据--");
	}
	
	
	
}

package com.sqf.c_cglib;

import java.lang.reflect.Method;

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

/**
 * Cglib子类代理工厂
 * (对UserDao 在内存中动态构建一个子类对象)
 * @author Jie.Yuan
 *
 */
public class ProxyFactory implements MethodInterceptor{
	// 维护目标对象
	private Object target;
	public ProxyFactory(Object target) {
		this.target = target;
	}
	// 给目标对象创建代理对象
	public Object getProxyInstance(){
		//1. 工具类
		Enhancer en = new Enhancer();
		//2. 设置父类
		en.setSuperclass(target.getClass());
		//3. 设置回调函数
		en.setCallback(this);
		//4. 创建子类(代理对象)
		return en.create();
	}
	
	@Override
	public Object intercept(Object arg0, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		// 执行目标对象的方法
		Object retuenValue = method.invoke(target, args);
		
		return retuenValue;
	}
	
	
	
}

package com.sqf.c_cglib;

public class App {
	
	public static void main(String[] args) {
		UserDao target = new UserDao();
		UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
		proxy.save();
	}
	
}