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{
@Override
public 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)+"毫秒");
}
@Override
public 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)+"毫秒");
}
@Override
public 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{
@Override
public void generate() {
//模拟生成订单耗时
try {
Thread.sleep(1234);
System.out.println("订单已生产");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void modify() {
try {
Thread.sleep(2222);
System.out.println("订单已修改");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public 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{
@Override
public void generate() {
long start = System.currentTimeMillis();
super.generate();
long end = System.currentTimeMillis();
System.out.println("耗时"+(end-start)+"毫秒");
}
@Override
public void modify() {
long start = System.currentTimeMillis();
super.modify();
long end = System.currentTimeMillis();
System.out.println("耗时"+(end-start)+"毫秒");
}
@Override
public 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{//和目标对象应有相同的行为动作,因此实现OrderService
OrderService target;
public OrderServiceProxy(OrderService target) {
this.target = target;
}
@Override
public void generate() {//代理方法
long start = System.currentTimeMillis();
target.generate();
long end = System.currentTimeMillis();
System.out.println("耗时"+(end-start)+"毫秒");
}
@Override
public void modify() {
long start = System.currentTimeMillis();
target.modify();
long end = System.currentTimeMillis();
System.out.println("耗时"+(end-start)+"毫秒");
}
@Override
public 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 目标方法上的实参
*/
@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)+"毫秒");
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;
}
@Override
public 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() {
@Override
public 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是制动内存中生成的
文章来源：https://www.toymoban.com/news/detail-731414.html
文章来源地址https://www.toymoban.com/news/detail-731414.html
到了这里，关于Spring学习笔记11 GoF代理模式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
