设计模式——代理模式

Posted 2023-04-30

参考技术A

代理模式（Proxy Pattern）是一个使用率非常高的模式。
定义： Provide a surrogate or placeholder for another object to control access to it. (为其对象提供一种代理以控制这个对象的访问)

代理模式也叫委托模式，它是一项基本的设计技巧。许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式，而且在日常应用中，代理模式可以提供非常好的访问控制。

三个角色的定义

抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。

也叫做被委托的角色、被代理的角色。是业务逻辑的具体执行者。

也叫委托类、代理类。它负责对真实角色的应用，把所以抽象主题定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后工作。

一个代理类可以代理多个被委托者或者被代理者，因此一个代理者具体代理哪个真实主题角色，是由场景类决定的。在通常情况下，一个接口只需要一个代理类就可以了，具体代理哪个实现类由高层模块决定，也就是在代理类的构造函数中传递被代理者。

类似现实生活中买房子的中介，打官司的律师。你不想参与中间过程的是是非非。减轻用户的负担。代理模式使用场景非常多。最典型的是Spring AOP中的动态代理。

普通代理就是我们要知道代理的存在，也就是类似GamePlayerProxy这个代理类的存在，然后才能访问。
普通代理的要求就是客户端只能访问代理角色，而不能访问真实角色。以游戏代练为例子，

GamePlayer的构造函数增加了_gamePlayer参数，而代理角色则只要传入代理者名字即可，而不需要说是替哪个对象做代理

在构造函数中，传来进来一个IGaemPlayer对象，检查谁能创建真实的角色，或者做出别的限制。

仅仅修改了构造函数，传递进来一个代理者名称，即可进行代理，在这种改造下，系统更加简洁，调用者只知道代理的存在就行，不用知道代理了谁。

在该模式下，调用者只知道代理而不知道真实的角色是谁，屏蔽了真实角色的变更对高层模块的影响，真实的主题角色想怎么修改都可以，对高层次的模块没有任何的影响，只要你实现了接口所对应的方法，该模式非常适合对扩展性要求较高的场合。

强制代理是要“强制”，必须通过真实角色查找到代理角色，否则不能进行访问。无论是通过代理类还是直接new一个主题角色类，都不能访问，只有通过真实角色指定的代理类才能访问，也就是说由真实的角色管理代理角色。例如你和一个明星比较熟，你直接找明星帮忙要见导演，但是明星说她比较忙，让你找她的经纪人。你本来想绕过她的代理，谁知道她返回的还是她的代理，这就是强制代理。你可以不知道代理的存在，但是你的所作所为还是需要代理为你提供服务。

强制代理的概念就是要从真实的角色查找到代理角色，不允许直接访问真实角色。高层模块只要调用 getProxy() 就可以访问真实角色的所以方法，它根本不需要产生一个代理出来，代理的管理已经由真实角色自己完成。

一个类可以实现多个接口，完成不同任务的整合。也就是说代理类不仅仅可以实现主题接口，也可以实现其他接口完成不同的任务，而且代理的目的是在目标对象方法的基础上作增强，这种增强的本质通常就是对目标对象的方法进行拦截合过滤。

动态代理

有关java的动态代理和代理模式

有关java的动态代理和代理模式
 一， 有关设计模式
==设计模式可分为以下三类==
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
今天说构造型的代理模式，动态代理可以说是代理模式+反射了
 二，代理模式
当我们要去给一段代码最增强并保证低耦合，不破坏原有代码块的情况下代理模式是一个不错的选择
 三，静态代理
###### 接口
我们要拥有一个接口来规定实现类的行为
```java
package staticProxy;

public interface Person {

void eat();

void say();

}
```
###### 实现类
我们还需要一个实现上述接口的实现类

```java
package staticProxy;

public class PersonImp implements Person{

@Override
public void eat() {
System.out.println("调用了"+ this.getClass().getName()+"的eat方法");
}

@Override
public void say() {
System.out.println("调用了"+ this.getClass().getName()+"的say()方法");
}


}
```
###### 代理类
接下来创建代理类，

```java
package staticProxy;

import java.util.Date;

public class Proxy implements Person{

Person zhangsan;

public Proxy(Person zhangsan) {
super();
this.zhangsan = zhangsan;
}

@Override
public void eat() {

//模拟增强代码块
System.out.println(new Date());

zhangsan.eat();
}

@Override
public void say() {

//模拟增强代码块
System.out.println(new Date());

zhangsan.say();
}

}

```
思路很简单就是在代理类（另一个实现类）中调用原本实现类的方法，这样就可以达到增强代码的效果，例如，记录日志等
###### 测试

```java
package staticProxy;

public class Test {
public static void main(String[] args) {

Person zhangsan = new PersonImp();

Proxy lisi = new Proxy(zhangsan);

lisi.eat();

lisi.say();

}
}

```
###### 测试类结果

 

 

 四，动态代理
要实现动态代理我们要知道一个接口java.lang.reflect.InvocationHandler和一个静态方法java.lang.reflect.Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException，
==上代码吧==
###### 接口
动态代理同样需要一个接口来规范实现类的动作

```java
package dynamicProxy;
// 有关接口名，
// eclipse不让我用Person我也不知道为什么,
// 可能重命名???
public interface Perosn {

void eat();

void say();

}

```
###### 实现类
同样需要一个实现类来做简单实现

```java
package dynamicProxy;

public class PersonImp implements Perosn{

@Override
public void eat() {
System.out.println("调用了"+ this.getClass().getName()+"的eat()方法");
}

@Override
public void say() {
System.out.println("调用了"+ this.getClass().getName()+"的say()方法");
}

}
```
###### 代理类
这里的代理类比较难理解，但是不麻烦
简单讲，就是这个代理类个静态代理实现类不同，它不需要实现原本的Perosn接口，而需要实现java.lang.reflect.InvocationHandler接口，此接口中只有一个抽象类需要实现，public Object invoke(Object proxy,Method method, Object[] args)throws Throwable;
同时还需要一个返回代理对象的方法，具体实现：在返回代理对象的方法中调用java.lang.reflect.Proxy.newProxyInstance()方法，该方法会返还一个Object，这个Object就是代理对象

```java
package dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Date;

import javax.xml.bind.DataBindingException;

public class Proxy implements InvocationHandler {

Perosn zhangsan;

public Proxy(Perosn zhangsan) {
super();
this.zhangsan = zhangsan;
}

@Override
/*
* @param Object proxy : 代理对象
*
* @param Method method : 被代理方法
*
* @param Object[] args : 被代理方法的形式参数
*
* @return 返回被代理方法的返回值
*
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

// 模拟增强代码块
System.out.println(new Date());

Object value = method.invoke(zhangsan, args);

return value;
}

//利用该方法得到代理对象
public Object getProxy() {

/*
* 有关java.lang.reflect.Proxy.newProxyInstance(
* ClassLoader loader,
* Class<?>[] interfaces,
* InvocationHandler h) throws IllegalArgumentException方法
*
* @param ClassLoader loader : 被代理类的类加载器，利用反射
* @param Class<?>[] interfaces : 被代理类的实现接口，利用反射
* @param InvocationHandler h : 代理管理器对象，this
*/
Object lisi = java.lang.reflect.Proxy.newProxyInstance(zhangsan.getClass().getClassLoader(),
zhangsan.getClass().getInterfaces(), this);

return lisi;

}
}

```
###### 测试

```java
package dynamicProxy;

public class Test {

public static void main(String[] args) {

//得到被代理对象
Perosn zhangsan = new PersonImp();

//获得代理管理器
Proxy proxy = new Proxy(zhangsan);

//获得代理对象
Perosn lisi = (Perosn) proxy.getProxy();

lisi.eat();

lisi.say();

}

}

```
###### 结果

 

 

当然，无论是静态代理还是动态代理，都是有代理对象来调用接口中的方法
# 五，动态代理和静态代理的区别
静态代理：由程序员创建代理类生成源代码再对其编译。整个代理过程其实就是面向对象的运用。

动态代理：在程序运行时运用反射机制动态创建而成，具体代理过程与jvm完成，所以，叫动态代理？？？
虽然代码写的不怎么样，包名也不规范，**但是**，，，如果需要源码的话可以给我说
**祝大家新年快乐鸭**