Java基础之浅谈 代理模式（反射的应用场景之一）

前面一直说反射，好像反射除了操作对象类，好像也没有什么用，其实不然，在后面的许多框架中，都是应用了反射的，其中最核心的一个逻辑就代理模式，这个是24设计模式中一种代理模式。

而下面我会摘抄一些网上的概念东西，具体如何体验，我会用代码演示。

代理模式概念

理解概念

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

其实简单的理解好比我们租房我们通过中介公司寻找合适的房子，而拥有房子的是房东，但是房东几乎不与我们见面，而是中介在其中充当了房子主人的角色与我们交流。

一般人租房为什么会找中介呢？

第一：我们没有时间精力或者能力去筛选我们相对合适的房子。

第二：一般的房东也不会，把自己的电话放在网上说，任何人都可以查询到，然后给自己打很多电话。（如果非要杠：说有人会啊，但毕竟是少数。再说了只是假设了一种情况方便理解代理模式而已，不要深究现实的个例）

那就依次套在我们使用代理模式的的原因：

1：直接访问一些对象（因为在Java中万物皆对象）的时候，由于某些原因（比如开销大或者安全控制等原因）所以我们需要一个中间的模块代理来访问这个类。

2：直接访问会给使用者或者对象类带来一些非必要的麻烦。

上面举行说明了一些代理是为了解决什么问题而存在。那么现在说一下其优缺点：

对用房屋中介：

优点：各个定位明确，房屋中介提供以及整理房屋信息，然后沟通租房和房东。以及根据两方的要求在中介进行调整，还可以推荐其他房子。

缺点：我们支付了一部分中介费，当然是很合理，不过对我们来说等于多支付了一部分额外支出，同时在签约前无法和房东直接交流（毕竟中介也怕逃单）。同时中介本身根据两方的要求也会不停的增加自己工作的难度，比如协商合同来回带着客户跑等行为。

对应代理模式：

优点：1：职责清晰，毕竟谁干谁的工作。2：高扩展性。3：方便操作也就是只能化。

缺点：由于者对接，中间出了一个代理层，意味者两者连接会有延迟，同时会额外消耗一些资源。代理层也会根据需求变得多样化，也会让代理层变得很复杂。

其实在spring框架中的aop（面向切面编程）中都使用了代理。

代码实现

上面我们只是简单的了解其代理的概念，下面用代码体验一下或者说是实现一下：

静态代理，其实就是一个java实现的简单的代理，只不过是写死的只能用在一种情况下，所以称之为静态代理，不过可以看一下代码理解代理的意义

package test;

public class staticProxy {
  public static void main(String[] args) {
	  Cat cat =new Cat();
      // 将实例的对象交过代理类，让其进行调用自己想调用的方法
	  proxyAnimal panimal=new proxyAnimal(cat);
	  panimal.eat();
	  
	
}
}


//类和代理类都需要继承的接口，因为这样才能绑定两者针对相同的行为有相同的方法
interface Animal{
	void eat();
	void play();
}


class Cat implements Animal{

	@Override
	public void eat() {
		System.out.println("我是一只猫咪，在吃东西");
		
	}

	@Override
	public void play() {
		System.out.println("我是一只猫咪，我在玩");
		
	}
	
}


class proxyAnimal implements Animal{
	Animal animal;
	public proxyAnimal(Animal animal) {
		this.animal=animal;
	}
	
	
	@Override
	public void eat() {
		System.out.println("这个是代理之前的");
		
		animal.eat();
		System.out.println("这个是代理之后的");
		
	}

	@Override
	public void play() {
System.out.println("这个是代理之前的");
		
		animal.play();
		System.out.println("这个是代理之后的");
		
	}
	
}

// 输出的是
这个是代理之前的
我是一只猫咪，在吃东西
这个是代理之后的

上面只是一个简单的代理，而后面所说的动态代理也是根据这个进行的依次拓展。先理解一些所谓的静态代理。然后再搞一下动态代理。

不过从上面我们可以看出实现代理条件：代理类和被代理类实现了同一个接口。

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

public class staticProxy {
  public static void main(String[] args) {
	  Cat cat =new Cat();
	  proxyAnimal p=new proxyAnimal();
	  p.bindObject(cat);
	  //
	  Animal pObject=(Animal) p.getProyxstInstance();//这个地方的pObject的类型只能为接口类型，因为是动态创建了一个匿名代理类，不然编译不会报错，但是运行会报误
//	  Exception in thread "main" java.lang.ClassCastException: test.$Proxy0 cannot be cast to test.Cat
	  pObject.eat();
	  
//	 可以试试是否代理其他的类
	  Humane m=new Man();
	  p=new proxyAnimal();
	  p.bindObject(m);
	  Humane phuamnObject=(Humane) p.getProyxstInstance();
	  phuamnObject.run();
	
}
}


interface Humane{
	void run();
}

class Man implements Humane{

	@Override
	public void run() {
		System.out.println("奔跑的男人");
	}
	
}


interface Animal{
	void eat();
	void play();
}


class Cat implements Animal{

	@Override
	public void eat() {
		System.out.println("我是一只猫咪，在吃东西");
		
	}

	@Override
	public void play() {
		System.out.println("我是一只猫咪，我在玩");
		
	}
	
}


class proxyAnimal implements InvocationHandler {
//	 为了重复使用，所以我们无法写某一个对象类
	private Object objectClass;
	public Object getObject() {
		return this.objectClass;
	}
	
	public void bindObject(Object objectClass) {
		this.objectClass= objectClass;
	}
	public  Object getProyxstInstance() {
        //
        //objectClass.getClass().getClassLoader() 前面说反射的的四种方式，这个就是通过第四种，通过加载器进行反射创建类的。 如果深究的话那就需要看Proxy这个类的源码了。
		return Proxy.newProxyInstance(objectClass.getClass().getClassLoader(), objectClass.getClass().getInterfaces(), this);
	}
//InvocationHandler 这个接口下的方法 自动会将我们调用的方法放入Method method,以及参数Object[] args。而proxy代表的是我们创建的一个匿名代理类
// 这个是这个接口源码定义的，所以不要纠结为什么，主要是理解这个设计思路。而方法文档截图放下面可以看一下。	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 进行业务增强
        System.out.println("动态代理前");
        // 通过反射调用方法本身
        Object invoke = method.invoke(objectClass, args);
        System.out.println("动态代理后");
        return invoke;
	}

	
}

//输出
动态代理前
我是一只猫咪，在吃东西
动态代理后
动态代理前
奔跑的男人
动态代理后

对这个，在基础了解的时候，需要了解实现的逻辑，如果晋级的话，那就需要看源码，以及源码的实现，方便自己写一些框架什么的。

当然代理模式是24设计模式之一，以后有时间的话，再简单的将其他的设计逻辑捋一遍。