前面一直说反射,好像反射除了操作对象类,好像也没有什么用,其实不然,在后面的许多框架中,都是应用了反射的,其中最核心的一个逻辑就代理模式,这个是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设计模式之一,以后有时间的话,再简单的将其他的设计逻辑捋一遍。