专业免费网站建设一般多少钱,给网站做rss,搜狗推广登录平台,721网站建设结构型设计模式-1.代理设计模式
结构型设计模式#xff1a;利用类与类之间的关系#xff08;继承、组合#xff09;#xff0c;形成一种类与类之间的结构#xff0c;通过这种结构提高代码的可拓展性、可维护性和可重用性。
一、简介
代理设计模式#xff08;Proxy Des…结构型设计模式-1.代理设计模式
结构型设计模式利用类与类之间的关系继承、组合形成一种类与类之间的结构通过这种结构提高代码的可拓展性、可维护性和可重用性。
一、简介
代理设计模式Proxy Design Pattern是一种结构型设计模式它为其他对象提供一个代理以控制对这个对象的访问。根据不同时期生成的代理对象分为
静态代理指代理类在编译时就已经确定。动态代理指代理类在运行时动态生成。
代理模式可以用于实现懒加载、安全访问控制、日志记录等功能其核心就是屏蔽掉对原始对象的直接访问为原始对象的能力提高增强。 其大致流程如下 创建一个接口定义代理类和被代理类共同实现的方法。创建被代理类实现这个接口并且在其中定义实现方法。创建代理类也要实现这个接口同时在其中定义一个被代理类的对象作为成员变量。在代理类中实现接口中的方法方法中调用被代理类中的对应方法。通过创建代理对象并调用其方法方法增强。 这样被代理类的方法就会被代理类所覆盖实现了对被代理类的增强或修改。
二、静态代理
1、简介
在静态代理中需要手动创建代理类和被代理类并且它们实现相同的接口或继承相同的父类。
2、基本流程
创建一个接口 / 抽象父类 / 父类定义代理类和被代理类共同实现的方法。创建被代理类实现上述接口并在其中定义实现方法。创建代理类同样实现上述接口并在其中定义一个被代理类的对象作为成员变量。在代理类中实现接口中的方法在这些方法中调用被代理类对象的对应方法。通过创建代理对象并调用其方法实现对被代理类方法的增强或修改。
3、简单示例
当涉及到继承关系时我们可以使用静态代理来实现对继承类的功能增强。以下是一个示例代码演示了如何使用静态代理来实现继承类的功能增强
首先我们有一个基础类 BaseClass它定义了一些基本的操作
// 基础类
class BaseClass {public void performOperation() {System.out.println(Performing base operation...);}
}接下来我们创建一个代理类 ProxyClass它继承自基础类并在其方法中添加额外的逻辑
// 代理类继承自基础类
class ProxyClass extends BaseClass {Overridepublic void performOperation() {// 在调用父类方法之前添加额外的逻辑System.out.println(Before performing operation...);// 调用父类方法super.performOperation();// 在调用父类方法之后添加额外的逻辑System.out.println(After performing operation...);}
}在代理类中我们重写了基础类的 performOperation() 方法并在方法中通过调用 super.performOperation() 来执行基础类的功能。同时在调用父类方法之前和之后我们添加了额外的逻辑。
最后我们可以使用代理类来执行操作并观察功能增强的效果
public class Main {public static void main(String[] args) {ProxyClass proxy new ProxyClass();proxy.performOperation();}
}在上述示例中我们创建了 ProxyClass 的实例并调用其 performOperation() 方法。在执行该方法时代理类将在调用父类方法之前和之后添加额外的逻辑。这样我们就实现了对继承类功能的增强而不需要修改基础类的代码。
通过静态代理我们可以在继承关系中对基础类的功能进行增强而不影响基础类的原有实现。这样我们可以通过代理类在调用父类方法之前或之后添加额外的逻辑实现功能的灵活扩展。 下面是一个使用接口实现静态代理的示例代码
首先我们定义一个共同的接口 Image它包含一个方法 display()
// 共同的接口
interface Image {void display();
}接下来我们创建一个具体的接口实现类 RealImage实现了 Image 接口
// 接口实现类
class RealImage implements Image {private String filename;public RealImage(String filename) {this.filename filename;}Overridepublic void display() {System.out.println(Displaying image: filename);}
}然后我们创建一个代理类 ImageProxy它同时实现了 Image 接口并拥有一个 RealImage 对象作为成员变量
// 代理类
class ImageProxy implements Image {private RealImage realImage;public ImageProxy(String filename) {this.realImage new RealImage(filename);}Overridepublic void display() {System.out.println(Loading image: realImage.getFilename());realImage.display();}
}在代理类中我们在 display() 方法中先输出加载图片的信息然后调用 RealImage 对象的 display() 方法来显示图片。
最后我们可以使用代理类来显示图片并观察输出结果
public class Main {public static void main(String[] args) {Image image new ImageProxy(example.jpg);image.display();}
}在上述示例中我们创建了 ImageProxy 的实例并调用其 display() 方法来显示图片。在执行该方法时代理类会输出加载图片的信息并通过调用 RealImage 对象的 display() 方法来实际显示图片。
通过使用接口实现静态代理我们可以在代理类中控制对实现接口的对象的访问并在调用其方法前后添加额外的逻辑。这样我们可以对接口实现对象的方法进行增强、修改或限制以满足特定的需求。
4、优点和缺点
优点
可以在不修改原始代码的情况下通过代理对象对被代理对象进行功能增强、安全访问控制、日志记录等操作也可以在代理对象中进行一些额外的操作如记录日志、缓存等以增强被代理对象的功能。代理对象可以隐藏被代理对象的具体实现实现了客户端和被代理对象的解耦。
缺点
静态代理在编译时就已经确定代理类后续维护可能修改源代码每个被代理类都需要手动创建一个代理类当代理类较多或变动频繁时会增加代码量和维护成本。
5、使用场景 下列是使用chatgpt学习中回答的使用场景和代码示例 访问控制和安全性 静态代理可以用于控制对被代理对象的访问权限确保只有具有合适权限的客户端可以访问被代理对象。日志记录 静态代理可以用于记录对被代理对象的操作日志方便后续的分析和监控。性能监控 静态代理可以用于监控被代理对象的性能统计方法的执行时间、调用次数等指标。缓存 静态代理可以用于实现对被代理对象的结果进行缓存提高系统响应速度。事务管理 静态代理可以用于实现对被代理对象的事务管理保证操作的原子性和一致性。远程代理 静态代理可以用于实现远程对象的访问隐藏底层的网络通信细节。 **【示例-缓存代理】**当涉及到数据库查询时可以使用静态代理来实现查询缓存的功能。下面是一个简单的示例代码演示了如何使用静态代理来实现数据库查询缓存的功能
首先我们需要定义一个共同的接口代表数据库操作
// 定义数据库操作的接口
interface Database {String queryData(String query);
}然后我们创建一个具体的数据库操作类实现上述接口用于执行实际的数据库查询
// 实现数据库操作的具体类
class DatabaseImpl implements Database {Overridepublic String queryData(String query) {// 模拟执行数据库查询System.out.println(Executing database query: query);// 返回查询结果return Result for query: query;}
}接下来我们创建一个代理类用于添加查询缓存的逻辑
// 创建代理类添加查询缓存的逻辑
class DatabaseProxy implements Database {private Database database;private MapString, String cache; // 查询缓存public DatabaseProxy() {this.database new DatabaseImpl();this.cache new HashMap();}Overridepublic String queryData(String query) {// 先检查缓存中是否存在查询结果if (cache.containsKey(query)) {System.out.println(Retrieving cached result for query: query);return cache.get(query);}// 如果缓存中不存在查询结果则执行实际的数据库查询String result database.queryData(query);// 将查询结果存入缓存cache.put(query, result);return result;}
}在代理类中我们在queryData()方法中先检查缓存中是否存在查询结果。如果存在直接从缓存中返回结果如果不存在代理类会调用实际的数据库操作类执行查询并将查询结果存入缓存中。
最后我们可以使用代理类来执行数据库查询并观察缓存的效果
public class Main {public static void main(String[] args) {Database database new DatabaseProxy();// 第一次执行查询将结果存入缓存String result1 database.queryData(SELECT * FROM table1);System.out.println(Result 1: result1);// 第二次执行相同的查询从缓存中获取结果String result2 database.queryData(SELECT * FROM table1);System.out.println(Result 2: result2);}
}在上述示例中第一次执行查询时会调用实际的数据库操作类执行查询并将结果存入缓存。第二次执行相同的查询时直接从缓存中获取结果而不会再次执行数据库查询。 通过静态代理我们实现了数据库查询缓存的功能可以提高查询性能减少对数据库的访问。这样在相同的查询被频繁执行时可以直接从缓存中获取结果避免了重复的数据库查询操作。 【示例-安全代理】当涉及到安全性验证时可以使用静态代理来实现安全代理的功能。下面是一个简单的示例代码演示了如何使用静态代理来实现安全代理
首先我们需要定义一个共同的接口代表敏感操作
// 定义敏感操作的接口
interface SensitiveOperation {void performOperation();
}然后我们创建一个具体的敏感操作类实现上述接口用于执行实际的敏感操作
// 实现敏感操作的具体类
class SensitiveOperationImpl implements SensitiveOperation {Overridepublic void performOperation() {System.out.println(Performing sensitive operation...);}
}接下来我们创建一个代理类用于添加安全验证的逻辑
// 创建代理类添加安全验证的逻辑
class SecurityProxy implements SensitiveOperation {private SensitiveOperation sensitiveOperation;private String password; // 安全验证密码public SecurityProxy(String password) {this.sensitiveOperation new SensitiveOperationImpl();this.password password;}Overridepublic void performOperation() {// 进行安全验证if (authenticate()) {sensitiveOperation.performOperation();} else {System.out.println(Access denied! Invalid password.);}}private boolean authenticate() {// 进行安全验证的逻辑比较输入密码和预设密码是否匹配String inputPassword getPasswordFromUser();return inputPassword.equals(password);}private String getPasswordFromUser() {// 模拟从用户输入获取密码的逻辑Scanner scanner new Scanner(System.in);System.out.print(Enter password: );return scanner.nextLine();}
}在代理类中我们在performOperation()方法中进行安全验证。首先用户需要输入密码进行验证如果验证通过则调用实际的敏感操作类执行敏感操作如果验证失败则拒绝访问。
最后我们可以使用代理类来执行敏感操作并观察安全验证的效果
public class Main {public static void main(String[] args) {String password password123; // 设置安全验证密码SensitiveOperation operation new SecurityProxy(password);// 执行敏感操作需要通过密码验证operation.performOperation();}
}在上述示例中执行敏感操作时用户需要输入密码进行安全验证。只有当输入的密码与预设密码匹配时才能执行实际的敏感操作。否则将拒绝访问。
通过静态代理我们实现了安全代理的功能可以在执行敏感操作前进行安全验证保护敏感操作的安全性。这样在需要对敏感操作进行访问控制和验证的场景下可以使用安全代理来确保只有经过验证的用户才能执行敏感操作。 【示例-远程代理】当涉及到远程对象的访问时可以使用静态代理来实现远程代理的功能。下面是一个简单的示例代码演示了如何使用静态代理来实现远程代理
首先我们需要定义一个共同的接口代表远程服务
// 定义远程服务的接口
interface RemoteService {void performTask();
}然后我们创建一个具体的远程服务类实现上述接口用于执行实际的远程任务
// 实现远程服务的具体类
class RemoteServiceImpl implements RemoteService {Overridepublic void performTask() {System.out.println(Performing remote task...);}
}接下来我们创建一个代理类用于封装远程通信的逻辑
// 创建代理类封装远程通信的逻辑
class RemoteProxy implements RemoteService {private RemoteService remoteService;public RemoteProxy() {// 在代理类中创建远程服务对象this.remoteService new RemoteServiceImpl();}Overridepublic void performTask() {// 在代理类中添加远程通信的逻辑模拟网络请求System.out.println(Sending request to remote server...);// 调用远程服务对象的方法remoteService.performTask();// 在代理类中添加远程通信的逻辑模拟网络响应System.out.println(Received response from remote server...);}
}在代理类中我们在performTask()方法中添加远程通信的逻辑模拟网络请求和响应的过程。首先发送请求到远程服务器然后调用远程服务对象的方法执行远程任务最后接收远程服务器的响应。
最后我们可以使用代理类来执行远程任务并观察远程通信的效果
public class Main {public static void main(String[] args) {RemoteService remoteService new RemoteProxy();// 执行远程任务remoteService.performTask();}
}在上述示例中执行远程任务时代理类将负责封装远程通信的逻辑。在调用远程服务对象的方法之前和之后代理类会进行网络请求和响应的模拟操作。
通过静态代理我们实现了远程代理的功能可以封装远程通信的逻辑隐藏底层的网络细节。这样在需要访问远程对象时可以使用远程代理来进行网络请求和响应的处理简化了远程通信的操作。
三、动态代理
1、简介
动态代理Dynamic Proxy是一种在运行时动态生成代理类的设计模式。与静态代理不同动态代理不需要手动编写代理类而是通过Java的反射机制在运行时动态生成代理类从而实现对被代理对象的代理。
基于JDK实现的动态代理基于接口实现。基于CGLIB使用的动态代理基于继承实现。
2、基本流程
定义一个接口该接口是被代理类和代理类共同实现的接口。创建一个实现了InvocationHandler接口的代理处理器类该类中包含对方法的增强逻辑。使用Proxy类的静态方法newProxyInstance()来创建代理对象该方法接收三个参数类加载器、被代理类实现的接口数组、代理处理器对象。通过代理对象调用方法代理处理器中的invoke()方法会被触发并执行相应的增强逻辑。
3、优点和缺点
优点
动态代理可以在运行时动态地创建代理对象适用于不同的接口和被代理类。它允许在不修改现有代码的情况下对方法进行统一的增强或拦截比如性能监控、事务管理、缓存等。动态代理可以减少代码量避免手动编写大量的代理类。
缺点
动态代理的性能相对较低因为在运行时需要使用反射机制来生成代理类和调用方法。动态代理只能代理接口无法代理具体类因为Java的单继承限制。
4、使用场景
动态代理常用于AOP面向切面编程领域可以通过动态代理在运行时动态地为目标对象添加横切逻辑如日志记录、事务管理等。动态代理还可以用于远程方法调用RMI、缓存代理、延迟加载等场景以实现更灵活、可扩展的系统架构。
5、基于 JDK 实现的动态代理
这个例子是基于 JDK 实现的动态代理示例。它演示了如何使用动态代理在运行时为目标对象添加额外的逻辑处理而无需修改目标对象的代码
/*** Author: shawn* Description: 定义一个共同的接口代表数据库操作*/
public interface DataBase {/*** 执行数据库查询操作** param query 查询语句* return 查询结果*/String query(String query);/*** 执行数据库删除操作** param delete 删除语句* return 删除结果*/String delete(String delete);
}/*** Author: shawn* Description: 数据库操作的具体实现类*/
public class DataBaseImpl implements DataBase {Overridepublic String query(String query) {// 模拟执行数据库查询System.out.println(Executing database query: query);// 返回查询结果return Result for query: query;}Overridepublic String delete(String delete) {// 模拟执行数据库删除System.out.println(Executing database delete: delete);// 返回删除结果return Result for delete: delete;}
}/*** Author: shawn* Description: 该代理处理器类负责处理代理对象的方法调用并在方法调用前后执行额外的逻辑操作。*/
public class DatabaseInvocationHandler implements InvocationHandler {private Object target;public DatabaseInvocationHandler(Object target) {this.target target;}/*** invoke()方法用于处理代理对象的方法调用。** param proxy 代理对象本身* param method 被调用的方法对象* param args 方法的参数数组* return 方法的返回结果* throws Throwable 异常信息*/Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 在方法调用前的逻辑处理// 如:判断方法名,查看是否需要做记录日志String methodName method.getName();if (delete.equals(methodName)) {//是删除操作才做增强,不然还是调用原方法System.out.println(Recording deletion operation log);}System.out.println(Before method: methodName);System.out.println(Arguments: args[0]);// 调用被代理对象的方法Object result method.invoke(target, args);// 在方法调用后的逻辑处理System.out.println(Result: result);System.out.println(After method: method);// 返回方法的返回结果return result;}
}public class Main {public static void main(String[] args) {// 创建目标对象DataBase target new DataBaseImpl();// 创建代理处理器DatabaseInvocationHandler handler new DatabaseInvocationHandler();// 创建代理对象DataBase proxy (DataBase) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),handler);// 调用代理对象的方法String queryResult proxy.query(SELECT * FROM table);System.out.println(------------------------);String deleteResult proxy.delete(DELETE FROM table WHERE id 1);System.out.println(------------------------);// 输出方法的返回结果System.out.println(Query Result: queryResult);System.out.println(------------------------);System.out.println(Delete Result: deleteResult);}
}在上面的代码中我们使用了动态代理来为 DataBase 接口生成了一个代理类并在代理类中增加了日志记录的功能。
具体地说在 DatabaseInvocationHandler 类中的 invoke 方法中我们根据方法名进行判断只有当方法名是 delete 时才会进行日志记录。这样在调用代理对象的 delete 方法时会先输出 “Recording deletion operation log” 的提示信息表示进行了删除操作的日志记录。
其他方法比如 query 方法没有满足条件所以不会进行日志记录只会输出方法调用前的提示信息和参数信息。
通过这种方式我们实现了对原有接口的增强根据不同的方法名来决定是否进行日志记录从而实现了按需添加日志记录功能的动态代理类。这样的设计使得我们可以在不修改原有接口和实现类的情况下为特定方法或特定场景添加额外的功能。
【下列是运行输出】
Before method: query
Arguments: SELECT * FROM table
Executing database query: SELECT * FROM table
Result: Result for query: SELECT * FROM table
After method: public abstract java.lang.String structuralDesignPattern.proxy.dynamicProxy.DataBase.query(java.lang.String)
------------------------
Recording deletion operation log
Before method: delete
Arguments: DELETE FROM table WHERE id 1
Executing database delete: DELETE FROM table WHERE id 1
Result: Result for delete: DELETE FROM table WHERE id 1
After method: public abstract java.lang.String structuralDesignPattern.proxy.dynamicProxy.DataBase.delete(java.lang.String)
------------------------
Query Result: Result for query: SELECT * FROM table
------------------------
Delete Result: Result for delete: DELETE FROM table WHERE id 16、基于 CGLIB 实现的动态代理
这是一个基于CGLIB实现的动态代理示例。下面是代码的解析
public class DataBaseImpl {public String query(String query) {// 模拟执行数据库查询System.out.println(Executing database query: query);// 返回查询结果return Result for query: query;}public String delete(String delete) {// 模拟执行数据库删除System.out.println(Executing database delete: delete);// 返回删除结果return Result for delete: delete;}
}上述代码定义了一个数据库操作的具体实现类 DataBaseImpl包含了 query 和 delete 两个方法。
public class DatabaseMethodInterceptor implements MethodInterceptor {private DataBaseImpl dataBase;public DatabaseMethodInterceptor() {this.dataBase new DataBaseImpl();}public DatabaseMethodInterceptor(DataBaseImpl dataBase) {this.dataBase dataBase;}Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {// 在方法调用前的逻辑处理// 如:判断方法名,查看是否需要做记录日志String methodName method.getName();if (delete.equals(methodName)) {//是删除操作才做增强,不然还是调用原方法System.out.println(Recording deletion operation log);}System.out.println(Before method: methodName);System.out.println(Arguments: objects[0]);// 调用被代理对象的方法Object result method.invoke(dataBase, objects);// 在方法调用后的逻辑处理System.out.println(Result: result);System.out.println(After method: method);// 返回方法的返回结果return result;}
}上述代码是基于CGLIB的方法拦截器 DatabaseMethodInterceptor实现了 MethodInterceptor 接口。拦截器中的 intercept 方法用于在方法调用前后进行逻辑处理包括记录日志和调用被代理对象的方法。
public class Main {public static void main(String[] args) {//cglib通过enhancerEnhancer enhancer new Enhancer();//设置他的父类-要继承谁,给谁做代理enhancer.setSuperclass(DataBaseImpl.class);//设置方法拦截器,用于拦截方法,对方法做增强enhancer.setCallback(new DatabaseMethodInterceptor());// 创建代理对象DataBaseImpl proxy (DataBaseImpl) enhancer.create();// 调用代理对象的方法String queryResult proxy.query(SELECT * FROM table);System.out.println(--------cglib----------------);String deleteResult proxy.delete(DELETE FROM table WHERE id 1);System.out.println(--------cglib----------------);// 输出方法的返回结果System.out.println(Query Result: queryResult);System.out.println(--------cglib----------------);System.out.println(Delete Result: deleteResult);}
}上述代码是 Main 类包含了代理对象的创建和方法调用的示例。使用 Enhancer 创建代理对象并设置父类和方法拦截器最终通过 create 方法创建代理对象。然后通过代理对象调用方法。
在运行该示例代码时会输出方法调用的前后日志和结果。
请注意为了使该示例代码正常运行你需要在项目的依赖中添加 CGLIB 的相关依赖或者将项目修改为spring boot项目。你可以将以下依赖添加到你的 pom.xml 文件中
在运行代码时你将看到方法调用的输出结果和日志记录以及代理对象的增强效果。
Before method: query
Arguments: SELECT * FROM table
Executing database query: SELECT * FROM table
Result: Result for query: SELECT * FROM table
After method: public java.lang.String structuralDesignPattern.proxy.dynamicProxy.cglib.DataBaseImpl.query(java.lang.String)
--------cglib----------------
Recording deletion operation log
Before method: delete
Arguments: DELETE FROM table WHERE id 1
Executing database delete: DELETE FROM table WHERE id 1
Result: Result for delete: DELETE FROM table WHERE id 1
After method: public java.lang.String structuralDesignPattern.proxy.dynamicProxy.cglib.DataBaseImpl.delete(java.lang.String)
--------cglib----------------
Query Result: Result for query: SELECT * FROM table
--------cglib----------------
Delete Result: Result for delete: DELETE FROM table WHERE id 1
