代理模式的理解
- 官方概念：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用-----《百度百科》
- 我的理解：代理就是帮别人做事情，就比如生活中的留学中介、厂家代理等等
- 留学中介（代理）：帮助学校去招生，这就是这个学校的代理，功能就是帮助这个学校完成招生工作
- 代理的特点：
1. 中介和代理做的东西（功能）的一样的，就是招生
2. 中介是学校的代理，而学校则是目标
3. 学生/家长----------中介（学校的介绍，帮助办理入学手续）----------学校
4. 中介是代理，是要收取费用的
5. 代理不让你访问到目标 - 为什么要找代理：
1. 方便
2. 学生/家长没有能力去访问学校，或者学校不接受以个人形式的来访 - 在开发过程中的例子：
1. 有A类和C类，A类要调用C类的方法完成某个功能，但C类不允许A类的调用，那么就在A类和C类之间创建一个B代理，让A类访问B代理，B代理访问C类
2. 注册账号功能需要手机短信验证码，项目本身的没有这个功能的，只能找代理来完成这个工作（比如说阿里云的信息服务）
代理模式的作用
- 功能增强：在原有的基础上，增加了某些功能，增加的功能就叫功能增强
- 控制访问：代理不允许你访问到目标，例如工厂只能有代理商拿货，而个人不被允许
- 调用目标类的方法，并执行
静态代理
- 理解：代理是增加手动实现的，自己创建java类，表示代理类，同时代理目标也是自己确定的
- 优点：实现简单、理解容易
- 缺点：
- 当目标类增加，代理类可能需要成倍的增加，代理数量过多
- 当接口中的功能增加或者修改，或影响众多的实现类，厂家类和代理类都需要全部修改
- 例子：模拟一个用户淘宝购买u盘的行为
- 用户是客户端类
- 淘宝商家是代理某个U盘的代理类
- 制造U盘的厂家是目标类
- 三者的关系：用户---------->淘宝代理商---------->生产商
- 生产商和代理商完成的功能是一致的，都是买U盘
- 实现步骤：
- 创建一个接口，定义卖U盘的方法，表示生产商和代理商的功能
- 创建代理商类实现步骤1的接口
- 创建生产商类实现步骤1的接口
- 创建用户类，调用代理商购买U盘
- 目标类（生成商类）的方法调用
- 功能增强（送满减红包等等）
java反射机制（动态代理用到）
- Method类，表示方法类中的方法，通过Method可以执行某个类中的某个方法
- 创建HelloService接口
package com.zsc.test;
public interface HelloService {
public void sayHello(String name);
}
package com.zsc.test;
public class HelloServiceImpl implements HelloService {
@Override
public void sayHello(String name) {
System.out.println("您好"+name);
}
}
package com.zsc.test;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestHelloService {
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
HelloService helloService = new HelloServiceImpl();
System.out.println("通过对象调用sayHello方法");
helloService.sayHello("张三");
HelloService Service = new HelloServiceImpl();
Method method = HelloService.class.getMethod("sayHello", String.class);
System.out.println("通过反射调用sayHello方法");
Object object = method.invoke(Service,"李四");
}
}
- 结果
动态代理
- 理解：使用java的反射机制、创建对象的能力来创建代理对象，而不用自己手动的去创建代理类（java文件）；在程序执行时，调用jdk提供的方法才能创建代理类对象
- 在目标类很多的时候，可以使用动态代理
- 实现：
- jdk的动态代理（理解）：使用java反射包中的类和接口实现动态代理的功能；反射包java.lang.reflect，里面包含3个类InvocationHandler、Method、Proxy，一定要有目标类功能的接口
- cglib动态代理（了解）：cglib是第三方的工具库，cglib的原理是继承，通过继承目标类，创建它的子类，在子类中重新父类中同名的方法，实现功能的修改，从而实现动态代理；因为cglib的原理是继承，所以目标类不能是final，方法也不能是final，cglib对目标类的要求比较宽松，只需要目标类能继承就行了，在很多框架都有所用到，比如说mybatis和spring
- jdk的动态代理：
- 反射包java.lang.reflect，里面包含3个类InvocationHandler、Method、Proxy
- InvocationHandler接口（调用处理器）：Invoke()方法，（需要执行的功能，我的理解：生产商或代理商的卖货的功能，及代理商发放的优惠卷的代理类功能增强都属于要执行的功能）
package java.lang.reflect;
public interface InvocationHandler {
Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
- Method类：表示目标类的方法，和上面反射的Method类的用法一样 （执行目标类的功能，我的理解：从生产商拿货）
通过Method可以执行某个目标类的方法，method.invoke(目标对象,方法参数)，和InvocationHandler接口的invoke()方法没有任何关系，只是方法名相同而已等同于静态代理中代理执行目标类的方法
public final class Method extends Executable {
public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
}
- Proxy类：核心对象，创建代理对象，用Proxy类的方法代替new关键字的使用 （创建需要执行代理类方法的对象，我的理解：选择在哪个淘宝代理商中购买U盘）
public class Proxy implements Serializable {
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
}
- 实现步骤：
- 创建接口，定义目标类需完成的方法（功能）
- 创建目标类实现步骤1的接口
- 创建InvocationHandler接口的实现类，在invoke方法中实现代理类的方法（功能），就是调用目标类的方法和代理类的功能增强
- 使用Proxy类的静态方法newProxyInstance，创建代理对象，并把返回值转为接口类型
- 具体的代码实现（已在淘宝上买U盘为例）
- 创建UsbSell接口
package com.zsc.test.service;
public interface UsbSell {
public float sell(int amount);
}
- 创建实现UsbSell接口的目标类UsbKingFactory
package com.zsc.test.factory;
import com.zsc.test.service.UsbSell;
public class UsbKingFactory implements UsbSell {
@Override
public float sell(int amount) {
System.out.println("执行目标类方法sell");
return 85.0f;
}
}
- 创建InvocationHandler接口的实现类
package com.zsc.test.handler;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MySellHandle implements InvocationHandler {
private Object target = null;
public MySellHandle(Object target){
this.target = target;
}
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
Object res = null;
res = method.invoke(target,objects);
if (res != null){
Float price = (Float) res;
price = price + 25;
res = price;
}
System.out.println("代理商返回红包");
return res;
}
}
- 创建测试类，使用Proxy类的静态方法newProxyInstance，创建代理对象
package com.zsc.test;
import com.zsc.test.factory.UsbKingFactory;
import com.zsc.test.handler.MySellHandle;
import com.zsc.test.service.UsbSell;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class MainShop {
public static void main(String[] args) {
UsbSell factory = new UsbKingFactory();
InvocationHandler handler = new MySellHandle(factory);
UsbSell proxy =(UsbSell) Proxy.newProxyInstance(factory.getClass().getClassLoader(),
factory.getClass().getInterfaces(),handler);
float price = proxy.sell(1);
System.out.println("通过动态代理，代理商的价格为"+price);
}
}
动态代理的作用（用处）
- 可以在不改变目标方法的前提下，可以在代理中增强自己的功能代理
- 比如：在开发过程中，有一个功能是其他人写的（自己并不知道原码），只提供了一个类，需要自己创建对象去调用其中的方法，那么在自己调用的过程中发现有一个方法的功能不能满足项目的需求，这时候就通过代理的方式增强该方法的功能
动态代理的总结
- 我的理解：动态代理就是在不能修改目标类代理的时候，通过代理的方式增强目标类的方法，但要注意的是在使用jdk动态代理时目标类一个要实现实现功能接口
扫一扫
1081
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
