目录
说明
在代理模式(Proxy Pattern)中，我们创建具有现有对象的对象，以便向外界提供功能接口。一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
问题来源
在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。
解决方案
增加中间层，实现与被代理类组合。
优点
- 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
- 代理对象可以扩展目标对象的功能
- 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性
缺点
- 代理模式会造成系统设计中类的数量增加
- 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢
- 增加了系统的复杂度
模式结构
- 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
- 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
- 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
应用场景
- 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。
- 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。
- 安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。
- 智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。
- 延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate 中就存在属性的延迟加载和关联表的延时加载。
示例
现在有两家工厂，生产不同的东西。现在有个人来考察，需要知道生产时间。但是又不能直接控制工厂进行生产，这时，就需要引入代理人。
工厂
工厂接口
package com.designpattern.proxy.objects;
public interface Factory {
void create();
}
食品工厂
package com.designpattern.proxy.objects.factory;
import com.designpattern.proxy.objects.Factory;
import java.util.Random;
public class FoodFactory implements Factory {
@Override
public void create() {
System.out.println("[FoodFactory] Start to create food.");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("[FoodFactory] Food is created.");
}
@Override
public String toString() {
return "FoodFactory";
}
}
饮料工厂
package com.designpattern.proxy.objects.factory;
import com.designpattern.proxy.objects.Factory;
import java.util.Random;
public class DrinkFactory implements Factory {
@Override
public void create() {
System.out.println("[DrinkFactory] Start to create drink.");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("[DrinkFactory] Drink is created.");
}
@Override
public String toString() {
return "DrinkFactory";
}
}
代理模式一般有两种，静态代理和动态代理。
静态代理
静态代理其实就是实现和被代理对象相同的接口，并把被代理对象作为自身的类属性添加进来。在实现接口的方法是，除了自身的一些内容外，必须有被代理对象来执行自己的实现方法。
条件：
- 实现和被代理对象一致的接口
- 被代理对象作为自身的类属性
- 调用被代理对象的实现方法
代理工厂
package com.designpattern.proxy.staticproxy;
import com.designpattern.proxy.objects.Factory;
public class FactoryProxy implements Factory {
private Factory factory;
public FactoryProxy() {
}
public FactoryProxy(Factory factory) {
this.factory = factory;
}
public Factory getFactory() {
return factory;
}
public void setFactory(Factory factory) {
this.factory = factory;
}
@Override
public void create() {
long start = System.currentTimeMillis();
factory.create();
long end = System.currentTimeMillis();
System.out.println(factory + " costs time is " + (end - start) / 1000 + " seconds");
}
}
调用检查
package com.designpattern.proxy.staticproxy;
import com.designpattern.proxy.objects.factory.DrinkFactory;
import com.designpattern.proxy.objects.factory.FoodFactory;
public class Application {
public static void main(String[] args) {
FactoryProxy proxy = new FactoryProxy();
//需要代理谁，就把谁放进去
proxy.setFactory(new FoodFactory());
proxy.create();
proxy.setFactory(new DrinkFactory());
proxy.create();
}
}
动态代理
动态代理使用java jdk自身的Proxy类来完成，需要满足三个条件：
- 实例化被代理类
- 获取被代理类的类加载器和接口
- 实现代理处理方案接口InvocationHandler
代理处理方案
也可以使用匿名内部类来实现。
package com.designpattern.proxy.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class ProxyFactoryHandler implements InvocationHandler {
private Object factory;
public ProxyFactoryHandler(Object factory) {
this.factory = factory;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis();
proxy = method.invoke(factory, args);//使用需要被代理的对象
long end = System.currentTimeMillis();
System.out.println(method + " costs time is " + (end - start) / 1000 + " seconds");
return proxy;
}
}
调用检查
package com.designpattern.proxy.proxy;
import com.designpattern.proxy.objects.Factory;
import com.designpattern.proxy.objects.factory.DrinkFactory;
import com.designpattern.proxy.objects.factory.FoodFactory;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Application {
public static void main(String[] args) {
//Save the generate files
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
//abstract Inner Class
final Factory food = new FoodFactory();
Factory foodProxy = (Factory) Proxy.newProxyInstance(food.getClass().getClassLoader(), food.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis();
proxy = method.invoke(food, args);//使用需要被代理的对象
long end = System.currentTimeMillis();
System.out.println(method + " costs time is " + (end - start) / 1000 + " seconds");
return proxy;
}
});
foodProxy.create();
//Outer Class
Factory drink = new DrinkFactory();
Factory drinkProxy = (Factory) Proxy.newProxyInstance(drink.getClass().getClassLoader(), drink.getClass().getInterfaces(), new ProxyFactoryHandler(drink));
drinkProxy.create();
}
}
总结
代理模式主要的实际应用还是在Spring的框架中使用的比较多。使用的时候可以通过注解或者配置使用。
Spring中的代理
引入jar包：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.9.RELEASE</version>
</dependency>
<!--AOP需要引入的基类-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.6</version>
</dependency>
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjlib</artifactId>
<version>1.6.2</version>
</dependency>
<!--AOP需要引入的基类-->
第一种方式，使用xml配置
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--bean-->
<bean id="food" class="com.designpattern.proxy.objects.factory.FoodFactory"/>
<bean id="drink" class="com.designpattern.proxy.objects.factory.DrinkFactory"/>
<bean id="proxy" class="com.designpattern.proxy.springproxy.FactoryProxy"/>
<!--AOP-->
<!-- 设置AOP使用JDK自己的方式来自动生成代理 -->
<aop:aspectj-autoproxy proxy-target-class="true"/>
<aop:config>
<aop:aspect id="proxyFactory" ref="proxy">
<!--execution的参数：(返回值 方法路径(..) 参数配置)-->
<aop:pointcut id="foodCreate" expression="execution(* com.designpattern.proxy.objects.factory.FoodFactory.create(..))"/>
<aop:before method="before" pointcut-ref="foodCreate"/>
<aop:after method="after" pointcut-ref="foodCreate"/>
</aop:aspect>
</aop:config>
<aop:config>
<aop:aspect id="proxyFactory" ref="proxy">
<aop:pointcut id="drinkCreate" expression="execution(* com.designpattern.proxy.objects.factory.DrinkFactory.create(..))"/>
<aop:before method="before" pointcut-ref="drinkCreate"/>
<aop:after method="after" pointcut-ref="drinkCreate"/>
</aop:aspect>
</aop:config>
</beans>
代理类修改如下：
package com.designpattern.proxy.springproxy;
public class FactoryProxy {
long time;
public void before() {
time = System.currentTimeMillis();
}
public void after() {
System.out.println("Cost time is " + (System.currentTimeMillis() - time));
}
}
调用
package com.designpattern.proxy.springproxy;
import com.designpattern.proxy.objects.Factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Application {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("/proxy/spring/spring.xml");
Factory food = (Factory) context.getBean("food");
food.create();
Factory drink = (Factory) context.getBean("drink");
drink.create();
}
}
第二种方式，使用注解
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--bean-->
<bean id="food" class="com.designpattern.proxy.objects.factory.FoodFactory"/>
<bean id="drink" class="com.designpattern.proxy.objects.factory.DrinkFactory"/>
<bean id="proxy" class="com.designpattern.proxy.springbootproxy.ProxyFactory"/>
<aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>
代理类修改
package com.designpattern.proxy.springbootproxy;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class ProxyFactory {
long time;
@Before("pointCut()")
public void before() {
time = System.currentTimeMillis();
}
@After("pointCut()")
public void after() {
System.out.println("Cost time is " + (System.currentTimeMillis() - time));
}
@Pointcut("execution(** com.designpattern.proxy.objects.factory.*.create(..))")
public void pointCut() {
}
}
调用
package com.designpattern.proxy.springbootproxy;
import com.designpattern.proxy.objects.Factory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Application {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("/proxy/springboot/spring.xml");
Factory food = (Factory) context.getBean("food");
food.create();
Factory drink = (Factory) context.getBean("drink");
drink.create();
}
}
146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
