Java中的代理模式和装饰者模式
1. 代理模式的原理和装饰者模式
使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
举一个简单的例子，比如一个生产羽绒服的工厂，生产羽绒服，生产完成之后就直接对消费者进行出售，虽然这款羽绒服可以保暖，但是现在人们的要求变高了要求羽绒服不但保暖还要好看，连包装都要好看。怎么办了这个羽绒服工厂只能生产羽绒服，不懂怎么包装美化。后来慢慢的有一些人看到了商机，就是做这个羽绒服的代理商，这个代理商有设备对羽绒服进行包装美化。这个代理商的负责人就对羽绒服工厂的负责人说你生产的羽绒服不要直接卖给消费者，你先给我，我给你美化包装一下，保准卖个好价钱。羽绒服工厂厂长一听感觉有道理，自己不用再去买设备来对象羽绒服进行包装美化，而且还能卖到好价钱，当然同意了。从此之后，人们只能去羽绒服的代理商买羽绒服了。
在上面的这个案例中就说明了代理模式的原理。
整个流程如下（灵魂画手，哈哈）
通过上面的描述你是否对代理模式有了一定的了解，实际上装饰者模式就是代理模式，装饰者模式就是我们对代理方法的增强。
2.静态代理
静态代理：代理类和目标对象的类都是在编译期间确定下来的代理方式。我们就以上面的买羽绒服的案例来实现一下静态代理。
- 首先创建一个工厂类。
/**
* 工厂类
*/
interface ClothFactory {
void produceCloth();
}
- 然后创建一个羽绒服工厂类
//被代理类
class NikeClothFactory implements ClothFactory {
@Override
public void produceCloth() {
System.out.println("羽绒服工厂生产一批羽绒服");
}
}
- 然后在创建一个羽绒服代理商类
//代理类
class ProxyClothFactory implements ClothFactory {
private ClothFactory factory; //用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory) {
this.factory = factory;
}
@Override
public void produceCloth() {
System.out.println("代理类工厂做一些准备工作，对产品进行包装");
factory.produceCloth();
System.out.println("代理工厂把产品进行发货");
}
}
- 下面我们创建一个StaticProxyTest类来模拟一个静态代理
public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
NikeClothFactory factory = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(factory);
proxyClothFactory.produceCloth();
}
}
运行一下这个main方法控制台输出如下，这就是一个最简单的静态代理。
3. 动态代理
首先说一下静态代理的缺点：
- 代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。
- 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
基于静态代理存在一些缺点，所以就诞生了动态代理，
动态代理的特点：
- 动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
- 抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
动态代理的实现
需要解决的两个主要问题：
- 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类实例对象
（通过Proxy.newProxyInstance()方法实现） - 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。
（通过InvokcationHandler接口的实现类及其方法invoke()）
代码实现：
- 创建一个表示人的接口
interface Human {
String getBelief();
void eat(String food);
}
- 创建一个实现 Human接口的类
//用作被代理类
class SuperMan implements Human {
@Override
public String getBelief() {
System.out.println("I believe I can fly");
return "I believe I can fly";
}
@Override
public void eat(String food) {
System.out.println("我喜欢吃" + food);
}
}
- 创建一个 HumanUtil 类用于在代理时对方法的增强
class HumanUtil {
public void method1() {
System.out.println("======== 对方法进行增强第一个功能 ========");
}
public void method2() {
System.out.println("======== 对方法进行增强第二个功能 ========");
}
}
- 创建一个 ProxyFactory 类用于解决动态代理的第一个问题
class ProxyFactory {
//调用此方法返回一个代理类的对象，解决问题一
public static Object getProxyInstance(Object obj) {//obj:被代理类的对象
MyInvocationHandler handler = new MyInvocationHandler();
handler.bind(obj);
//返回一个代理类
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
}
}
- 创建一个MyInvocationHandler类用于解决动态代理的问题二
class MyInvocationHandler implements InvocationHandler {
private Object obj;//赋值时，需要使用被代理类的对象进行赋值
public void bind(Object obj) {
this.obj = obj;
}
/**
* 解决问题二
* 当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
* 将被代理类要执行的方法a的功能就声明在invoke()方法中
* @param proxy 代理类的对象
* @param method 代理类对象要调用的方法，这里就是什么方法
* @param args 要调用的方法的参数列表
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
HumanUtil util = new HumanUtil(); // 这个对象用于对方法的修饰
util.method1();
//method：即为代理类对象调用的方法，此方法作为被代理类对象要调用的方法。
//obj就是被代理类的对象
Object returnValue = method.invoke(this.obj, args);
util.method2();
//上述方法的返回值就作为当前类中的invoke()方法的返回值。
return returnValue;
}
}
- 下面我们创建一个ProxyTest类来测试一下动态代理
public class ProxyTest {
public static void main(String[] args) {
SuperMan superMan = new SuperMan();
//proxyInstance：代理类的对象
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
//当通过代理类对象调用方法时，会自动的调用被代理类中的同名的方法
String belief = proxyInstance.getBelief();
System.out.println("使用代理对象调用方的返回值："+belief);
proxyInstance.eat("麻辣香锅");
System.out.println("*******************************");
//测试一下是否可以代理羽绒服的生产
NikeClothFactory nikeClothFactory = new NikeClothFactory();
ClothFactory nikeProxyInstance = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
nikeProxyInstance.produceCloth();
}
}
运行一下main方法，控制台输出如下，从控制台可以看出，这个代理类不但对Human可以代理，还可以代理羽绒服的生产。
2. 基于接口的动态代理
下面我们来实现一个基于接口的动态代理。
- 首先创建一个 IProducer 接口
/**
* 对厂家要求的接口
*/
public interface IProducer {
/**
* 销售
* @param money
*/
public void saleProduct(float money);
/**
* 售后
* @param money
*/
public void afterService(float money);
}
- 创建IProducer 的实现类Producer
/**
* 一个生产者
*/
public class Producer implements IProducer {
/**
* 销售
* @param money
*/
public void saleProduct(float money) {
System.out.println("销售产品，并拿到钱：" + money);
}
/**
* 售后
* @param money
*/
public void afterService(float money) {
System.out.println("提供售后服务，并拿到钱：" + money);
}
}
- 然后我们创建一个Client来模拟一个消费者
/**
* 模拟一个消费者
*/
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
// producer.saleProduct(1000f);
/*
动态代理：
特点：字节码随用随创建，随用随加载
作用：不修改源码的基础上对方法增强
分类：
基于接口的动态代理
基于子类的动态代理
基于接口的动态代理：
涉及的类：Proxy
提供者：JDK官方
如何创建代理对象：
使用Proxy类中的 newProxyInstance 方法
创建代理对象的要求：
被代理类最少实现一个接口，如果没有则不能使用
newProxyInstance 方法的参数:
ClassLoader：类加载器
它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法
Class[]：字节码数组
它是用于让代理对象和被代理对象由相同的方法。固定写法
InvocationHandler：用于提供增强的代码
它是让我们写如何代理。我们一般都是写一个接口的实现类，通常情况下都是匿名内部类，但是不是必须的
此接口的实现类都是谁用谁写。
*/
IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 作用：执行被代理对象的任何接口方法都会经过改方法
* @param proxy：代理对象的引用
* @param method：当前执行的方法
* @param args：当前执行方法所需的参数
* @return ：和被代理对象方法有相同的返回值
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float) args[0];
//2.判断当前方法是不是销售
if ("saleProduct".equals(method.getName())) { // 我们只修饰这个方法
// money * 0.8f 表示代理商抽取0.2的费用。
// 匿名内部类访问外部成员时，要求外部成员必须是 最终的，就是用final修饰的
returnValue = method.invoke(producer, money * 0.8f);
}
return returnValue;
}
});
proxyProducer.saleProduct(1000f);
}
}
执行main方法控制台输出，说明代理成功了
这种基于接口的动态代理是有一个缺点的，就是要代理的类必须实现一个接口，否则就不能被代理，不然会报代理异常的错误
3. 基于子类的动态代理
对于基于接口的动态代理的缺点又产生了基于子类的动态代理，这种方法要依赖外部jar包 cglib 。下面我们就来实现一下基于子类的动态代理，
- 修改一下Producer类，不让其实现IProduct接口。
/**
* 一个生产者
*/
public class Producer {
/**
* 销售
* @param money
*/
public void saleProduct(float money) {
System.out.println("销售产品，并拿到钱：" + money);
}
/**
* 售后
* @param money
*/
public void afterService(float money) {
System.out.println("提供售后服务，并拿到钱：" + money);
}
}
- 修改我们Client类
/**
* 模拟一个消费者
*/
public class Client {
public static void main(String[] args) {
final Producer producer = new Producer();
// producer.saleProduct(1000f);
/*
动态代理：
特点：字节码随用随创建，随用随加载
作用：不修改源码的基础上对方法增强
分类：
基于接口的动态代理
基于子类的动态代理
基于子类的动态代理：
涉及的类：Enhancer
提供者：第三方cglib库
如何创建代理对象：
使用 Enhancer 类中的 create 方法
创建代理对象的要求：
被代理类不能是最终类（就是不能用final修饰）
create 方法的参数:
Class：字节码
它是用于指定被代理对象的字节码。
Callback：用于提供增强的代码
它是让我们写如何代理。我们一般都是写一个接口的实现类，通常情况下都是匿名内部类，但是不是必须的
此接口的实现类都是谁用谁写。
我们一般写的都是该接口的子接口实现类：MethodInterceptor
*/
Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
/**
* 执行被代理对象的任何方法都会经过改方法
* @param proxy
* @param method
* @param args
* 以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
* @param methodProxy ：当前执行方法的代理对象
* @return
* @throws Throwable
*/
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//提供增强的代码
Object returnValue = null;
//1.获取方法执行的参数
Float money = (Float) args[0];
//2.判断当前方法是不是销售
if ("saleProduct".equals(method.getName())) {
// 匿名内部类访问外部成员时，要求外部成员必须是 最终的，就是用final修饰的
returnValue = method.invoke(producer, money * 0.8f);
}
return returnValue;
}
});
cglibProducer.saleProduct(1000);
}
}
运行一下Client里的main方法，控制台输出如下，说明代理成功了。
8063
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
