Spring学习笔记10 JdbcTemplate_biubiubiu0706的博客-CSDN博客
新建个maven模块 static-proxy
演示静态代理
订单接口
测试
需求:统计每个业务方法的耗时
package com.example.proxy.service;/*** @author hrui* @date 2023/9/25 8:42*/
public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {long start = System.currentTimeMillis();//模拟生成订单耗时try {Thread.sleep(1234);System.out.println("订单已生产");} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void modify() {long start = System.currentTimeMillis();try {Thread.sleep(2222);System.out.println("订单已修改");} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void detail() {long start = System.currentTimeMillis();try {Thread.sleep(3333);System.out.println("查看订单详情");} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}
}
上面确实实现了功能
但是硬编码,在每个业务接口中的每一个业务方法中直接添加统计耗时的程序:
缺点:
1.违背了OCP开闭原则
2. 代码没有得到复用
--------------------------------------------------------------------------------------------------------------------
package com.example.proxy.service;/*** @author hrui* @date 2023/9/25 8:42*/
public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {//模拟生成订单耗时try {Thread.sleep(1234);System.out.println("订单已生产");} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic void modify() {try {Thread.sleep(2222);System.out.println("订单已修改");} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic void detail() {try {Thread.sleep(3333);System.out.println("查看订单详情");} catch (InterruptedException e) {e.printStackTrace();}}
}
让子类继承重写方法
package com.example.proxy.service;/*** @author hrui* @date 2023/9/25 9:48*/
public class OrderServiceImplSub extends OrderServiceImpl{@Overridepublic void generate() {long start = System.currentTimeMillis();super.generate();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void modify() {long start = System.currentTimeMillis();super.modify();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void detail() {long start = System.currentTimeMillis();super.detail();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}
}测试
上面的解决方式解决了OCP
但是这种方式会导致耦合度很高.因为采用了继承关系.继承关系是一种耦合度非常高的关系,不建议使用.
另外代码还是没有得到复用
再看下面的解决方式(静态代理)
OrderService是公共接口 OrderServiceImpl是目标对象
package com.example.proxy.service;import com.sun.org.apache.xpath.internal.operations.Or;/*** @author hrui* @date 2023/9/25 10:24*/
public class OrderServiceProxy implements OrderService{//和目标对象应有相同的行为动作,因此实现OrderServiceOrderService target;public OrderServiceProxy(OrderService target) {this.target = target;}@Overridepublic void generate() {//代理方法long start = System.currentTimeMillis();target.generate();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void modify() {long start = System.currentTimeMillis();target.modify();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void detail() {long start = System.currentTimeMillis();target.detail();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}
}
上面使用了静态代理,目标对象和代理对象都需要实现或者继承公共接口,因为需要相同的动作或行为.
解决了OCP原则问题,使用静态代理可以降低耦合度
缺点:如果程序中有多个这样业务类,那么都需要代理,类爆炸 不好维护
可以使用动态代理解决类爆炸问题
动态代理还是代理模式,只不过添加了字节码生成技术,可以在内存中动态的生成.class字节码,这个字节码就是代理类----->在内存中动态的生成字节码技术
SpringAOP底层用的不是JDK就是CGLIB
动态代理:
1.JDK代理:目标类必须实现接口(缺陷)
2.CGLIB代理:无要求,且性能比JDK代理好.底层是通过继承实现的(因动态在内存中生成,无所谓耦合度了)----->底层还有一个小而快的字节码处理框架ASM
3.javassist:动态代理
java的反射包下有个Proxy java.lang.reflect.Proxy(JDK内置的)--->帮我们在内存中动态生成字节码
新建模块 dynamic-proxy
还是同一个需求,统计每个业务方法的耗时
直接开始写
具体代码
package com.example.proxy.client;import com.example.proxy.service.OrderService;
import com.example.proxy.service.OrderServiceImpl;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author hrui* @date 2023/9/25 12:41*/
public class Client {public static void main(String[] args) {//创建目标对象OrderService target=new OrderServiceImpl();//创建代理对象/*** 1.newProxyInstance 翻译为:新建代理对象* 也就是说,通过调用这个方法可以创建代理对象* 本质上newProxyInstance()方法的执行,做了两件事:* 第一件事:在内存中动态的生成了一个代理类的字节码class* 第二件事:new对象了.通过内存中生成的代理类.class,实例化了代理对象* 2.关于newProxyInstance()方法的三个重要的参数,每一个含义,有什么用?* 第一个参数:ClassLoader loader* 类加载器 必须得和目标类得类加载器一样* 第二个参数:Class<?>[] interfaces* 代理类和目标类要实现同一个接口或同一些接口.* 第三个参数:InvocationHandler h* InvocationHandler是一个接口,称为调用处理器,需要传一个InvocationHandler实现类* 调用处理器不会导致类爆炸,这里就不做处理,以匿名内类方式*///Object proxyObj = Proxy.newProxyInstance("类加载器", "代理类要实现的接口", "调用处理器");OrderService proxyObj = (OrderService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {/*1.invoke方法是JDK负责调用的2.当代理对象调用代理方法的时候,注册在InvocationHandler调用处理器当中的invoke()会被调用3.invoke方法内的三个参数:invoke()是JDK负责调用的.参数是JDK传过来的.第一个参数:Object proxy 代理对象的引用,这个参数使用较少第二个参数:Method method 目标对象上的目标方法.(要执行的目标方法就是它)第三个参数:Object[] args 目标方法上的实参*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {long start = System.currentTimeMillis();Object retValue = method.invoke(target, args);long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");return null;}});//调用代理对象的代理方法//注意:调用代理对象的代理方法的时候,如果你要做增强的话,目标对象的目标方法得保证执行(在执行前后添加功能增强功能)proxyObj.generate();proxyObj.modify();proxyObj.detail();}
}
上面是匿名内部类写法
而且关于返回值 返回了是null
返回null,但程序依旧是可以跑的 但上面所有的方法是无返回值的,如果是有返回值的会如何
新增一个有返回值的
程序还是可以跑
但返回值能不能拿到
下面是用个实现类的写法
package com.example.proxy.client;import com.example.proxy.service.OrderService;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;/*** @author hrui* @date 2023/9/25 15:57*/
public class AInvocationHandler implements InvocationHandler {OrderService target;public AInvocationHandler(OrderService target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object invoke = method.invoke(target, method);return invoke;}
}
JDK动态代理工具类封装
public class JDKProxyUtil {public static Object newProxyInstance(Object target){//底层还是调用JDK的动态代理return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object retValue = method.invoke(target, args);return retValue;}});}
}
package com.example.proxy.client;import com.example.proxy.service.OrderService;
import com.example.proxy.service.OrderServiceImpl;
import com.example.proxy.util.JDKProxyUtil;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author hrui* @date 2023/9/25 12:41*/
public class Client {public static void main(String[] args) {//创建目标对象OrderService target=new OrderServiceImpl();//创建代理对象/*** 1.newProxyInstance 翻译为:新建代理对象* 也就是说,通过调用这个方法可以创建代理对象* 本质上newProxyInstance()方法的执行,做了两件事:* 第一件事:在内存中动态的生成了一个代理类的字节码class* 第二件事:new对象了.通过内存中生成的代理类.class,实例化了代理对象* 2.关于newProxyInstance()方法的三个重要的参数,每一个含义,有什么用?* 第一个参数:ClassLoader loader* 类加载器 必须得和目标类得类加载器一样* 第二个参数:Class<?>[] interfaces* 代理类和目标类要实现同一个接口或同一些接口.* 第三个参数:InvocationHandler h* InvocationHandler是一个接口,称为调用处理器,需要传一个InvocationHandler实现类* 调用处理器不会导致类爆炸,这里就不做处理,以匿名内类方式*///Object proxyObj = Proxy.newProxyInstance("类加载器", "代理类要实现的接口", "调用处理器");
// OrderService proxyObj = (OrderService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
//
//
//
// /*
// 1.invoke方法是JDK负责调用的
// 2.当代理对象调用代理方法的时候,注册在InvocationHandler调用处理器当中的invoke()会被调用
// 3.invoke方法内的三个参数:
// invoke()是JDK负责调用的.参数是JDK传过来的.
// 第一个参数:Object proxy 代理对象的引用,这个参数使用较少
// 第二个参数:Method method 目标对象上的目标方法.(要执行的目标方法就是它)
// 第三个参数:Object[] args 目标方法上的实参
//
// */
// @Override
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// long start = System.currentTimeMillis();
// Object retValue = method.invoke(target, args);
// long end = System.currentTimeMillis();
// System.out.println("耗时"+(end-start)+"毫秒");
// //如果代理对象调用代理方法之后,需要返回结果的话,invoke方法必须将目标对象的目标方法的返回结果继续返回
// return retValue;
// }
// });OrderService proxyObj = (OrderService)JDKProxyUtil.newProxyInstance(target);//调用代理对象的代理方法//注意:调用代理对象的代理方法的时候,如果你要做增强的话,目标对象的目标方法得保证执行(在执行前后添加功能增强功能)proxyObj.generate();proxyObj.modify();proxyObj.detail();String name = proxyObj.getName();System.out.println(name);}
}
CGLIB既可以代理接口,又可以代理类.底层采用继承的方式实现,所以被代理的目标类不能使用final修饰
使用CGLIB需要引入依赖
<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version> </dependency>
其实CGLIB和开头写的继承方式差不多,只不过一个是需要写的而CGLIB是制动内存中生成的
