设计模式----（代理模式）

代理模式定义

代理模式就是一个对象提供一个代理，并使用这个代理对象控制对原来对象的引用。就是相当于中介的角色

代理模式中的角色

Student:抽象角色，声明真实对象和代理对象的共同接口

Proxy:代理角色，代理对象与真是对象实现相同接口，能够在任何时候都能够代理真实对象，代理角色内部包含有真实对象的引用，该操作可以操作真实对象，相当于对真实对象的分装

RealSubject:真实角色，代表着真实对象，是最终要引用的对象

1.代理模式中的静态代理

静态代理的使用：定义接口或者是父类，被代理对象和代理对象一起实现相同的接口或者是继承相同的父类

下面举例说明

package User;
/*
 * 定义接口
 * */
public interface IUser {
	void save();

}
package User;
/*
 * 实现接口
 * 目标对象
 * */
public class UserDao implements IUser {

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

}
package User;
/*
 * 代理对象，静态代理
 * */
public class UserDaoProxy implements IUser{
	//接受保存目标对象
	private IUser target;
	public UserDaoProxy(IUser target) {
		this.target=target;
	}

	@Override
	public void save() {
		System.out.println("开始执行");
		target.save();//执行目标对象的方法
		System.out.println("事务的提交");	
	}
}
package User;
/*
 * 测试类
 * */
public class Text {
	public static void main(String[] args) {
		//目标对象
		UserDao target = new UserDao();
		
		//代理对象，把目标对象传给代理对象，建立代理关系
		UserDaoProxy proxy = new UserDaoProxy(target);
		proxy.save();
	}
}

总结：

静态代理可以做到在不修改目标对象的功能前提下对目标功能进行拓展；

代理对象需要与目标对象实现一样的接口，会有很多代理类，接口增加方法目标对象与代理对象都要维护

2.动态代理

1. 代理对象，不能实现接口；
2. 利用JDK的API生成了代理对象，在内存中动态构建代理对象
3. 动态代理也叫做JDK代理或者是接口代理

JDK中生成代理对象的API：

需要使用newProxyInstance方法，需要接收三个参数：

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

ClassLoader loader:指定当前目标对象使用类加载器，获取加载器的方法是固定的

Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方法确认类型

InvocationHandler h：事件处理执行目标对象的方法时，会触发事件处理器的方法，执行目标对象的方法作为参数传入

public interface Argue {
    String talk();
}
/**
 * 目标对象
 */
class People implements Argue {
    @Override
    public String talk() {
        System.out.println("++++talk+++++");
        return "talk";
    }
}
/**
 * 动态代理
 */
class PeopleProxy implements InvocationHandler {
    private Object target;
    public PeopleProxy(Object target){
        this.target=target;
    }

    public Object getProxyInstance(){
        Class clazz = target.getClass();
       return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("======before========");
        method.invoke(target,args);
        System.out.println("======after========");
        return null;
    }
}
/**
 * 测试
 */
public class TextDemo {
    public static void main(String[] args) {
        Argue argue = (Argue) new PeopleProxy(new People()).getProxyInstance();
        argue.talk();
    }
}

Cglib代理模式

当目标对象只是一个单独的对象，并没有任何接口时，可以使用以目标对象子类的方式类实现代理

子类代理，是在内存中构建一个子类对象从而实现对目标对象的功能扩展

• 动态代理有一个限制，使用动态代理的对象必须实现一个或多个接口，代理如果没有实现接口的类，可以使用Cglib实现
• 高新能代码生成包，运行期扩展Java类实现Java接口，被AOP的框架使用
• 底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
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 obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("提交事务...");

        return returnValue;
    }
}
/**
 * 测试类
 */
public class App {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法
        proxy.save();
    }
}