背景
地点:长沙飞思
时间:2023/12/25~29
关键字:代理模式,动态代理,静态代理
前言
代理模式是学习java中不得不评鉴的一环,它非常重要,在后面SpringBoot当中学习中也是不可或缺的,它向我们展示了另一种编程思想,即面向切面编程。
代理模式
代理是一种模式,提供了对目标对象的间接访问方式,即通过代理对象访问目标对象.如此便于在目标实现的基础上增加额外的功能操作,以满足自身的业务需求。
常用的代理方式可以粗分为:静态代理和动态代理。
静态代理
静态代理的实现比较简单:编写一个代理类,实现与目标对象相同的接口,并在内部维护一个目标对象的引用。通过构造器塞入目标对象,在代理对象中调用目标对象的同名方法,并添加前拦截,后拦截等所需的业务功能。
/**
* 目标对象实现的接口
*/
public interface BussinessInterface {
String execute();
}
/**
* 目标对象实现类
*/
public class Bussiness implements BussinessInterface{
@Override
public String execute() {
System.out.println("执行业务逻辑...");
return "完成";
}
}
/**
* 代理类,通过实现与目标对象相同的接口
* 并维护一个代理对象,通过构造器传入实际目标对象并赋值
* 执行代理对象实现的接口方法,实现对目标对象实现的干预
*/
public class BussinessProxy implements BussinessInterface{
private BussinessInterface bussinessImpl;
public BussinessProxy(BussinessInterface bussinessImpl) {
this.bussinessImpl = bussinessImpl;
}
@Override
public String execute() {
System.out.println("前拦截...");
String rs = bussinessImpl.execute();
System.out.println("后拦截...");
return rs;
}
}
静态代理总结
优点:可以做到不对目标对象进行修改的前提下,对目标对象进行功能的扩展和拦截。
缺点:
-
因为代理对象,需要实现与目标对象一样的接口,会导致代理类十分繁多,不易维护,
-
同时一旦接口增加方法,则目标对象和代理类都需要维护。
-
存在重复代码
-
硬编码在代理类中,不利于后期维护
动态代理
动态代理就是,在程序运行期,创建目标对象的代理对象,并对目标对象中的方法进行功能性增强的一种技术。在生成代理对象的过程中,目标对象不变,代理对象中的方法是目标对象方法的增强方法。可以理解为运行期间,对象中方法的动态拦截,在拦截方法的前后执行功能操作。
代理类在程序运行期间,创建的代理对象称之为动态代理对象。这种情况下,创建的代理对象,并不是事先在Java代码中定义好的。而是在运行期间,根据我们在动态代理对象中的“指示”,动态生成的。也就是说,你想获取哪个对象的代理,动态代理就会为你动态的生成这个对象的代理对象。动态代理可以对被代理对象的方法进行功能增强。有了动态代理的技术,那么就可以在不修改方法源码的情况下,增强被代理对象的方法的功能,在方法执行前后做任何你想做的事情。
private static Object getProxy(final Object target) throws Exception {
//直接调用newProxyInstance()方法得到代理对象
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),/*类加载器*/
target.getClass().getInterfaces(),/*让代理对象和目标对象实现相同接口*/
new InvocationHandler(){/*代理对象的方法最终都会被JVM导向它的invoke方法*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(method.getName() + "方法开始执行...");
Object result = method.invoke(target, args);
System.out.println(result);
System.out.println(method.getName() + "方法执行结束...");
return result;
}
}
);
return proxy;
}
使用动态代理,让我们避免手写代理类,只要给getProxy()方法传入target就可以生成对应的代理对象。但是日志打印仍是硬编码在invoke()方法中。虽然修改时只要改一处,但是别忘了“开闭原则”。所以最好是能把日志打印单独拆出来,像目标对象一样作为参数传入。
日志打印其实就是AOP里的通知概念。我打算定义一个Advice接口,并且写一个MyLogger实现该接口。
通知接口
public interface Advice {
void beforeMethod(Method method);
void afterMethod(Method method);
}
日志打印通知类
public class MyLogger implements Advice {
public void beforeMethod(Method method) {
System.out.println(method.getName() + "方法执行开始...");
}
public void afterMethod(Method method) {
System.out.println(method.getName() + "方法执行结束...");
}
}
Java 中实现动态代理方式
Java 中,实现动态代理有两种方式:
1、JDK 动态代理:java.lang.reflect 包中的 Proxy 类和 InvocationHandler 接口提供了生成动态代理类的能力。
- JDK原生动态代理是Java原生支持的,不需要外部依赖,但是它只能基于接口进行代理(需要动态代理的对象必须实现与某个接口)
2、Cglib 动态代理:Cglib (Code Generation Library )是一个第三方代码生成类库,运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。
- CGLIB通过继承的方式进行代理,要导入cglib第三方库,使用的类是Enhancer的create静态方法创建,要求被代理类不能是最终类,即不能用final修饰,如String类。
public class LogProxy {
/**
* 生成对象的代理对象,对被代理对象进行所有方法日志增强
* 参数:原始对象
* 返回值:被代理的对象
* JDK 动态代理
* 基于接口的动态代理
* 被代理类必须实现接口
* JDK提供的
*/
public static Object getObject(final Object obj){
/**
* 创建对象的代理对象
* 参数一:类加载器
* 参数二:对象的接口
* 参数三:调用处理器,代理对象中的方法被调用,都会在执行方法。对所有被代理对象的方法进行拦截
*/
Object proxyInstance = Proxy.newProxyInstance(obj.getClass().getClassLoader()
, obj.getClass().getInterfaces(), new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法执行前
long startTime = System.currentTimeMillis();
Object result = method.invoke(obj, args);//执行方法的调用
//方法执行后
long endTime = System.currentTimeMillis();
SimpleDateFormat sdf = new SimpleDateFormat();
System.out.printf(String.format("%s方法执行结束时间:%%s ;方法执行耗时:%%d%%n"
, method.getName()), sdf.format(endTime), endTime - startTime);
return result;
}
});
return proxyInstance;
}
/**
* 使用CGLib创建动态代理对象
* 第三方提供的的创建代理对象的方式CGLib
* 被代理对象不能用final修饰
* 使用的是Enhancer类创建代理对象
*/
public static Object getObjectByCGLib(final Object obj){
/**
* 使用CGLib的Enhancer创建代理对象
* 参数一:对象的字节码文件
* 参数二:方法的拦截器
*/
Object proxyObj = Enhancer.create(obj.getClass(), new MethodInterceptor() {
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//方法执行前
long startTime = System.currentTimeMillis();
Object invokeObject = method.invoke(obj, objects);//执行方法的调用
//方法执行后
long endTime = System.currentTimeMillis();
SimpleDateFormat sdf = new SimpleDateFormat();
System.out.printf(String.format("%s方法执行结束时间:%%s ;方法执行耗时:%%d%%n"
, method.getName()), sdf.format(endTime), endTime - startTime);
return invokeObject;
}
});
return proxyObj;
}
}
总结
天生我材必有用,千金散尽还复来。