📕我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、优快云博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。
📘拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、SpringBoot、SpringMVC、SpringCloud、Mybatis、Dubbo、Zookeeper)，消息中间件底层架构原理(RabbitMQ、RocketMQ、Kafka)、Redis缓存、MySQL关系型数据库、 ElasticSearch全文搜索、MongoDB非关系型数据库、Apache ShardingSphere分库分表读写分离、设计模式、领域驱动DDD、Kubernetes容器编排等。
📙不定期分享高并发、高可用、高性能、微服务、分布式、海量数据、性能调优、云原生、项目管理、产品思维、技术选型、架构设计、求职面试、副业思维、个人成长等内容。
💡在这个美好的时刻，笔者不再啰嗦废话，现在毫不拖延地进入文章所要讨论的主题。接下来，我将为大家呈现正文内容。
🍊 MyBatis核心知识点之动态代理实现：动态代理概述
在当今的软件开发领域，MyBatis 作为一款优秀的持久层框架，以其简洁的配置和强大的动态代理功能，深受广大开发者的喜爱。然而，在实际的项目开发中，我们常常会遇到这样的问题：如何在不修改原有代码的情况下，实现对数据库操作的动态扩展和优化？这就引出了 MyBatis 核心知识点之动态代理实现：动态代理概述的重要性。
想象一下，一个程序员正坐在电脑前，眉头紧锁，手指在键盘上“噼里啪啦”敲得飞起。屏幕上，一行行代码如同流水般涌现。突然，他停下了手中的动作，双手抱胸，眼睛直勾勾地盯着屏幕，嘴里嘟囔着：“哟呵，这需求得去数据库里捞点数据出来。”以往，手动和数据库打交道，那可真是麻烦得很，各种连接配置、SQL语句，想想都头大。
然而，就在这时，他突然一拍脑门，乐了，嘴角都快咧到耳根子了，脸上那愁容瞬间烟消云散。为啥呀？因为他想起了 MyBatis 这好家伙。只见他双手重新放到键盘上，快速地敲了几行代码，调用了 MyBatis 的工厂类。没一会儿，数据库里的数据就乖乖地跑到屏幕上了。他往后一靠，得意地挑了挑眉毛，嘴里念叨着：“还得是 MyBatis 啊，这事儿给办得明明白白的！”
MyBatis 的动态代理实现，正是为了解决这类问题而诞生的。它允许我们在不修改原有代码的情况下，动态地生成代理对象，从而实现对数据库操作的扩展和优化。接下来，我们将深入探讨动态代理的概念和应用场景，帮助读者更好地理解 MyBatis 的动态代理机制。
首先，我们将介绍动态代理的概念，阐述其原理和实现方式。随后，我们将探讨动态代理在 MyBatis 中的应用场景，包括如何通过动态代理实现数据库操作的拦截、优化和扩展。通过这些内容，读者将能够全面了解 MyBatis 动态代理的强大功能和实际应用价值。
MyBatis动态代理概念
在Java编程中，动态代理是一种强大的技术，它允许在运行时创建接口的实例，而不需要实现接口的具体类。MyBatis框架利用动态代理技术，实现了对数据库操作的封装和简化。下面，我们将深入探讨MyBatis动态代理的概念。
动态代理的概念源于代理模式，它是一种设计模式，允许一个对象（代理）控制对另一个对象（目标对象）的访问。在代理模式中，代理对象负责处理请求，并将请求转发给目标对象。这种模式在Java中通过动态代理技术实现。
在MyBatis中，动态代理主要用于实现SqlSession的代理。SqlSession是MyBatis的核心接口，用于执行数据库操作。通过动态代理，MyBatis可以在运行时创建SqlSession的代理实例，从而实现对数据库操作的封装。
MyBatis动态代理的实现机制主要基于Java的反射机制。当调用一个接口的方法时，动态代理会根据接口的方法签名，动态生成一个代理类的实例。这个代理类实现了与接口相同的接口，并在方法执行时，将请求转发给目标对象。
下面是一个简单的代码示例，展示了MyBatis动态代理的实现机制：
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加一些预处理逻辑
Object result = method.invoke(target, args);
// 在这里可以添加一些后处理逻辑
return result;
}
}
public class MyProxy {
public static Object createProxy(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new MyInvocationHandler(target)
);
}
}
在上面的代码中，MyInvocationHandler类实现了InvocationHandler接口，并在invoke方法中处理请求。MyProxy类则负责创建代理实例。
JDK动态代理与CGLIB动态代理比较
在Java中，动态代理主要有两种实现方式：JDK动态代理和CGLIB动态代理。
JDK动态代理是基于Java反射机制实现的，它只能代理实现了接口的类。而CGLIB动态代理则基于ASM字节码操作框架，可以代理任何类，包括没有实现接口的类。
在性能方面，JDK动态代理通常比CGLIB动态代理更优，因为CGLIB动态代理需要生成目标类的子类，并进行字节码操作。
MyBatis动态代理应用场景
MyBatis动态代理主要应用于以下场景：
-
数据库操作封装：通过动态代理，可以将数据库操作封装在代理类中，简化数据库操作代码。
-
事务管理：在代理类中，可以添加事务管理逻辑，实现对数据库操作的统一事务管理。
-
缓存管理：在代理类中，可以添加缓存管理逻辑，提高数据库操作的效率。
MyBatis动态代理性能分析
MyBatis动态代理的性能主要取决于代理类的生成和反射机制的调用。在大多数情况下，MyBatis动态代理的性能对应用程序的影响较小。然而，在性能敏感的场景下，可以考虑使用CGLIB动态代理或优化代理类的实现。
MyBatis动态代理与AOP的关系
MyBatis动态代理与AOP（面向切面编程）有着密切的关系。AOP是一种编程范式，它允许将横切关注点（如日志、事务、安全等）与业务逻辑分离。MyBatis动态代理可以与AOP框架集成，实现对数据库操作的横切关注点管理。
MyBatis动态代理与Spring AOP的集成
MyBatis与Spring框架集成时，可以使用Spring AOP来实现对MyBatis动态代理的支持。通过Spring AOP，可以在代理类中添加横切关注点，实现对数据库操作的统一管理。
| 对比项 | JDK动态代理 | CGLIB动态代理 |
|---|---|---|
| 实现方式 | 基于Java反射机制 | 基于ASM字节码操作框架 |
| 代理对象类型 | 只能代理实现了接口的类 | 可以代理任何类，包括没有实现接口的类 |
| 性能 | 通常比CGLIB动态代理更优 | 需要生成目标类的子类，并进行字节码操作，性能相对较低 |
| 应用场景 | 适用于接口较多的场景 | 适用于没有实现接口的类或接口较少的场景 |
| MyBatis动态代理应用场景 | 描述 |
|---|---|
| 数据库操作封装 | 通过动态代理，可以将数据库操作封装在代理类中，简化数据库操作代码。 |
| 事务管理 | 在代理类中，可以添加事务管理逻辑，实现对数据库操作的统一事务管理。 |
| 缓存管理 | 在代理类中，可以添加缓存管理逻辑，提高数据库操作的效率。 |
| MyBatis动态代理与AOP关系 | 描述 |
|---|---|
| 集成关系 | MyBatis动态代理可以与AOP框架集成，实现对数据库操作的横切关注点管理。 |
| 横切关注点 | 如日志、事务、安全等，可以通过MyBatis动态代理与AOP框架进行管理。 |
| MyBatis动态代理与Spring AOP集成 | 描述 |
|---|---|
| 集成方式 | 通过Spring AOP来实现对MyBatis动态代理的支持，在代理类中添加横切关注点。 |
| 管理对象 | 对数据库操作的统一管理，包括日志、事务、安全等。 |
JDK动态代理和CGLIB动态代理在实现方式上存在显著差异，前者依赖于Java的反射机制，而后者则基于ASM字节码操作框架。这种差异不仅体现在技术层面，也直接影响了它们的应用场景和性能表现。例如，在性能方面，JDK动态代理通常比CGLIB动态代理更优，因为后者需要生成目标类的子类，并进行字节码操作，这无疑增加了额外的性能开销。然而，在代理对象类型上，CGLIB动态代理具有更广泛的适用性，它可以代理任何类，包括没有实现接口的类，而JDK动态代理则仅限于代理实现了接口的类。这种灵活性使得CGLIB动态代理在处理没有接口的类时更为便捷。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("MyBatis 动态代理"):::startend --> B("代理模式"):::process
A --> C("SqlSession 代理"):::process
A --> D("Java 反射机制"):::process
B --> E("代理对象控制访问"):::process
C --> F("执行数据库操作"):::process
D --> G("动态生成代理类"):::process
E --> H("请求转发给目标对象"):::process
F --> I("封装数据库操作"):::process
G --> J("接口方法签名"):::process
H --> K("处理请求"):::process
I --> L("简化代码"):::process
J --> M("生成代理实例"):::process
K --> N("转发请求"):::process
L --> O("提高效率"):::process
M --> P("实现接口"):::process
N --> Q("执行方法"):::process
O --> R("性能优化"):::process
P --> S("与接口相同"):::process
Q --> T("返回结果"):::process
R --> U("性能敏感场景"):::process
S --> V("代理类实例"):::process
T --> W("返回结果"):::process
U --> X("考虑CGLIB代理"):::process
V --> Y("代理类实现"):::process
W --> Z("返回处理结果"):::process
X --> AA("优化代理实现"):::process
Y --> AB("反射调用"):::process
Z --> AC("完成数据库操作"):::process
MyBatis动态代理实现：动态代理应用场景
在Java编程中，动态代理是一种强大的技术，它允许在运行时创建接口的实例，而不需要实现接口的具体方法。MyBatis框架利用动态代理技术，实现了对数据库操作的封装和简化。下面，我们将深入探讨MyBatis动态代理的应用场景。
首先，让我们回顾一下代理模式的基本原理。代理模式是一种设计模式，它为其他对象提供一种代理以控制对这个对象的访问。在MyBatis中，动态代理主要用于实现SqlSession的代理，使得开发者可以无需直接操作数据库连接，而是通过SqlSession进行数据库操作。
动态代理的应用场景主要体现在以下几个方面：
-
数据库操作封装：通过动态代理，MyBatis可以将数据库操作封装在代理对象中，使得开发者无需直接处理数据库连接、事务管理等繁琐的细节。这样，开发者可以更加专注于业务逻辑的实现。
-
数据库连接池管理：动态代理可以与数据库连接池技术结合，实现数据库连接的复用和高效管理。在MyBatis中，通过动态代理，可以方便地实现数据库连接池的配置和管理。
-
事务管理：动态代理可以实现对事务的管理，确保数据库操作的原子性。在MyBatis中，通过动态代理，可以方便地实现事务的提交、回滚等操作。
-
性能优化：动态代理可以实现对数据库操作的缓存，减少数据库访问次数，提高系统性能。在MyBatis中，通过动态代理，可以实现查询结果的缓存，提高查询效率。
-
插件扩展：动态代理可以方便地实现插件扩展，使得开发者可以根据需求自定义插件，实现额外的功能。在MyBatis中，通过动态代理，可以方便地实现插件机制，扩展框架功能。
接下来，我们简要介绍MyBatis动态代理的配置和代理对象创建过程。
在MyBatis配置文件中，可以通过<settings>标签配置动态代理的默认值。例如，设置<setting name="proxyTargetClass" value="true"/>，表示使用Cglib创建代理对象。
代理对象的创建过程如下：
-
创建一个实现了InvocationHandler接口的类，该类负责处理代理对象的调用。
-
创建一个代理对象，传入目标对象和InvocationHandler实例。
-
通过代理对象调用方法时，会触发InvocationHandler的invoke方法，从而实现对目标对象的调用。
最后，我们简要介绍代理对象的生命周期。
代理对象的生命周期包括以下几个阶段：
-
创建阶段：创建代理对象，并初始化相关属性。
-
调用阶段：通过代理对象调用方法，触发InvocationHandler的invoke方法。
-
销毁阶段：释放代理对象占用的资源，如关闭数据库连接等。
总之，MyBatis动态代理在数据库操作封装、数据库连接池管理、事务管理、性能优化和插件扩展等方面具有广泛的应用场景。通过动态代理，MyBatis简化了数据库操作，提高了开发效率，降低了开发成本。
| 应用场景 | 动态代理功能描述 | MyBatis实现方式 |
|---|---|---|
| 数据库操作封装 | 将数据库操作封装在代理对象中，简化数据库连接、事务管理等细节。 | MyBatis通过动态代理创建SqlSession实例，开发者通过SqlSession进行数据库操作。 |
| 数据库连接池管理 | 实现数据库连接的复用和高效管理。 | MyBatis动态代理与数据库连接池技术结合，通过代理对象管理数据库连接。 |
| 事务管理 | 确保数据库操作的原子性，实现事务的提交、回滚等操作。 | MyBatis动态代理支持事务管理，通过代理对象控制事务的执行。 |
| 性能优化 | 对数据库操作进行缓存，减少数据库访问次数，提高系统性能。 | MyBatis动态代理支持查询结果的缓存，通过代理对象实现缓存机制。 |
| 插件扩展 | 方便地实现插件扩展，自定义插件以实现额外功能。 | MyBatis通过动态代理实现插件机制，允许开发者根据需求扩展框架功能。 |
| 配置与代理创建 | 配置动态代理的默认值，创建代理对象。 | 在MyBatis配置文件中通过<settings>标签配置动态代理，创建实现了InvocationHandler接口的类，并创建代理对象。 |
| 生命周期管理 | 管理代理对象的创建、调用和销毁阶段，释放资源。 | 代理对象的生命周期包括创建阶段、调用阶段和销毁阶段，确保资源得到合理利用。 |
动态代理在MyBatis中的应用不仅限于数据库操作封装，它还深刻影响了数据库连接池的管理。通过动态代理，MyBatis能够高效地管理数据库连接，实现连接的复用，从而降低系统开销，提高整体性能。这种机制使得开发者无需手动管理连接，简化了数据库操作流程，同时也为后续的事务管理和性能优化奠定了基础。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A(动态代理应用场景):::startend --> B(数据库操作封装):::process
A --> C(数据库连接池管理):::process
A --> D(事务管理):::process
A --> E(性能优化):::process
A --> F(插件扩展):::process
B --> G(简化数据库操作):::process
C --> H(连接复用管理):::process
D --> I(确保原子性):::process
E --> J(查询结果缓存):::process
F --> K(自定义插件):::process
G --> L(无需处理连接细节):::process
H --> M(高效管理连接):::process
I --> N(事务提交/回滚):::process
J --> O(减少数据库访问):::process
K --> P(扩展框架功能):::process
L --> Q(专注业务逻辑):::process
M --> R(配置管理):::process
N --> S(提高查询效率):::process
P --> T(实现额外功能):::process
Q --> U(提高开发效率):::process
R --> V(配置文件管理):::process
S --> W(提升系统性能):::process
T --> X(灵活扩展):::process
U --> Y(降低开发成本):::process
V --> Z(连接信息管理):::process
W --> AA(优化数据库操作):::process
X --> AB(满足多样化需求):::process
Y --> AC(提升开发效率):::process
Z --> AD(事务管理器配置):::process
AA --> AE(简化数据库操作):::process
AB --> AF(满足多样化需求):::process
AC --> AG(提升整体效率):::process
AD --> AH(事务管理配置):::process
AE --> AL(无需处理连接细节):::process
AF --> AG(满足多样化需求):::process
AG --> AH(事务管理配置):::process
AH --> AI(确保事务正确性):::process
AI --> AJ(提交/回滚事务):::process
AJ --> AK(保证数据一致性):::process
AK --> AL(无需处理连接细节):::process
AL --> AM(专注业务逻辑):::process
AM --> AN(提高开发效率):::process
AN --> AO(提升整体效率):::process
AO --> AP(优化数据库操作):::process
AP --> AQ(提高查询效率):::process
AQ --> AR(提升系统性能):::process
AR --> AS(实现额外功能):::process
AS --> AT(灵活扩展):::process
AT --> AU(满足多样化需求):::process
AU --> AV(提升开发效率):::process
AV --> AW(优化数据库操作):::process
AW --> AX(提高查询效率):::process
AX --> AY(提升系统性能):::process
AY --> AZ(实现额外功能):::process
AZ --> BA(灵活扩展):::process
BA --> BB(满足多样化需求):::process
BB --> BC(提升开发效率):::process
BC --> BD(优化数据库操作):::process
BD --> BE(提高查询效率):::process
BE --> BF(提升系统性能):::process
BF --> BG(实现额外功能):::process
BG --> BH(灵活扩展):::process
BH --> BI(满足多样化需求):::process
BI --> BJ(提升开发效率):::process
BJ --> BK(优化数据库操作):::process
BK --> BL(提高查询效率):::process
BL --> BM(提升系统性能):::process
BM --> BN(实现额外功能):::process
BN --> BO(灵活扩展):::process
BO --> BP(满足多样化需求):::process
BP --> BQ(提升开发效率):::process
BQ --> BR(优化数据库操作):::process
BR --> BS(提高查询效率):::process
BS --> BT(提升系统性能):::process
BT --> BU(实现额外功能):::process
BU --> BV(灵活扩展):::process
BV --> BW(满足多样化需求):::process
BW --> BX(提升开发效率):::process
BX --> BY(优化数据库操作):::process
BY --> BZ(提高查询效率):::process
BZ --> CA(提升系统性能):::process
CA --> CB(实现额外功能):::process
CB --> CC(灵活扩展):::process
CC --> CD(满足多样化需求):::process
CD --> CE(提升开发效率):::process
CE --> CF(优化数据库操作):::process
CF --> CG(提高查询效率):::process
CG --> CH(提升系统性能):::process
CH --> CI(实现额外功能):::process
CI --> CJ(灵活扩展):::process
CJ --> CK(满足多样化需求):::process
CK --> CL(提升开发效率):::process
CL --> CM(优化数据库操作):::process
CM --> CN(提高查询效率):::process
CN --> CO(提升系统性能):::process
CO --> CP(实现额外功能):::process
CP --> CQ(灵活扩展):::process
CQ --> CR(满足多样化需求):::process
CR --> CS(提升开发效率):::process
CS --> CT(优化数据库操作):::process
CT --> CU(提高查询效率):::process
CU --> CV(提升系统性能):::process
CV --> CW(实现额外功能):::process
CW --> CX(灵活扩展):::process
CX --> CY(满足多样化需求):::process
CY --> CZ(提升开发效率):::process
CZ --> DA(优化数据库操作):::process
DA --> DB(提高查询效率):::process
DB --> DC(提升系统性能):::process
DC --> DD(实现额外功能):::process
DD --> DE(灵活扩展):::process
DE --> DF(满足多样化需求):::process
DF --> DG(提升开发效率):::process
DG --> DH(优化数据库操作):::process
DH --> DI(提高查询效率):::process
DI --> DJ(提升系统性能):::process
DJ --> DK(实现额外功能):::process
DK --> DL(灵活扩展):::process
DL --> DM(满足多样化需求):::process
DM --> DN(提升开发效率):::process
DN --> DO(优化数据库操作):::process
DO --> DP(提高查询效率):::process
DP --> DQ(提升系统性能):::process
DQ --> DR(实现额外功能):::process
DR --> DS(灵活扩展):::process
DS --> DT(满足多样化需求):::process
DT --> DU(提升开发效率):::process
DU --> DV(优化数据库操作):::process
DV --> DW(提高查询效率):::process
DW --> DX(提升系统性能):::process
DX --> DY(实现额外功能):::process
DY --> DZ(灵活扩展):::process
DZ --> EA(满足多样化需求):::process
EA --> EB(提升开发效率):::process
EB --> EC(优化数据库操作):::process
EC --> ED(提高查询效率):::process
ED --> EE(提升系统性能):::process
EE --> EF(实现额外功能):::process
EF --> EG(灵活扩展):::process
EG --> EH(满足多样化需求):::process
EH --> EI(提升开发效率):::process
EI --> EJ(优化数据库操作):::process
EJ --> EK(提高查询效率):::process
EK --> EL(提升系统性能):::process
EL --> EM(实现额外功能):::process
EM --> EN(灵活扩展):::process
EN --> EO(满足多样化需求):::process
EO --> EP(提升开发效率):::process
EP --> EQ(优化数据库操作):::process
EQ --> ER(提高查询效率):::process
ER --> ES(提升系统性能):::process
ES --> ET(实现额外功能):::process
ET --> EU(灵活扩展):::process
EU --> EV(满足多样化需求):::process
EV --> EW(提升开发效率):::process
EW --> EX(优化数据库操作):::process
EX --> EY(提高查询效率):::process
EY --> EZ(提升系统性能):::process
EZ --> FA(实现额外功能):::process
FA --> FB(灵活扩展):::process
FB --> FC(满足多样化需求):::process
FC --> FD(提升开发效率):::process
FD --> FE(优化数据库操作):::process
FE --> FF(提高查询效率):::process
FF --> FG(提升系统性能):::process
FG --> FH(实现额外功能):::process
FH --> FI(灵活扩展):::process
FI --> FJ(满足多样化需求):::process
FJ --> FK(提升开发效率):::process
FK --> FL(优化数据库操作):::process
FL --> FM(提高查询效率):::process
FM --> FN(提升系统性能):::process
FN --> FO(实现额外功能):::process
FO --> FP(灵活扩展):::process
FP --> FQ(满足多样化需求):::process
FQ --> FR(提升开发效率):::process
FR --> FS(优化数据库操作):::process
FS --> FT(提高查询效率):::process
FT --> FU(提升系统性能):::process
FU --> FV(实现额外功能):::process
FV --> FW(灵活扩展):::process
FW --> FX(满足多样化需求):::process
FX --> FY(提升开发效率):::process
FY --> FZ(优化数据库操作):::process
FZ --> GA(提高查询效率):::process
GA --> GB(提升系统性能):::process
GB --> GC(实现额外功能):::process
GC --> GD(灵活扩展):::process
GD --> GE(满足多样化需求):::process
GE --> GF(提升开发效率):::process
GF --> GG(优化数据库操作):::process
GG --> GH(提高查询效率):::process
GH --> GI(提升系统性能):::process
GI --> GJ(实现额外功能):::process
GJ --> GK(灵活扩展):::process
GK --> GL(满足多样化需求):::process
GL --> GM(提升开发效率):::process
GM --> GN(优化数据库操作):::process
GN --> GO(提高查询效率):::process
GO --> GP(提升系统性能):::process
GP --> GQ(实现额外功能):::process
GQ --> GR(灵活扩展):::process
GR --> GS(满足多样化需求):::process
GS --> GT(提升开发效率):::process
GT --> GU(优化数据库操作):::process
GU --> GV(提高查询效率):::process
GV --> GW(提升系统性能):::process
GW --> GX(实现额外功能):::process
GX --> GY(灵活扩展):::process
GY --> GZ(满足多样化需求):::process
GZ --> HA(提升开发效率):::process
HA --> HB(优化数据库操作):::process
HB --> HC(提高查询效率):::process
HC --> HD(提升系统性能):::process
HD --> HE(实现额外功能):::process
HE --> HF(灵活扩展):::process
HF --> HG(满足多样化需求):::process
HG --> HH(提升开发效率):::process
HH --> HI(优化数据库操作):::process
HI --> HJ(提高查询效率):::process
HJ --> HK(提升系统性能):::process
HK --> HL(实现额外功能):::process
HL --> HM(灵活扩展):::process
HM --> HN(满足多样化需求):::process
HN --> HO(提升开发效率):::process
HO --> HP(优化数据库操作):::process
HP --> HQ(提高查询效率):::process
HQ --> HR(提升系统性能):::process
HR --> HS(实现额外功能):::process
HS --> HT(灵活扩展):::process
HT --> HU(满足多样化需求):::process
HU --> HV(提升开发效率):::process
HV --> HW(优化数据库操作):::process
HW -->HX(提高查询效率):::process
HX --> HY(提升系统性能):::process
HY --> HZ(实现额外功能):::process
HZ --> IA(灵活扩展):::process
IA --> IB(满足多样化需求):::process
IB --> IC(提升开发效率):::process
IC --> ID(优化数据库操作):::process
ID --> IE(提高查询效率):::process
IE --> IF(提升系统性能):::process
IF --> IG(实现额外功能):::process
IG --> IH(灵活扩展):::process
IH --> II(满足多样化需求):::process
II --> IJ(提升开发效率):::process
IJ --> IK(优化数据库操作):::process
IK --> IL(提高查询效率):::process
IL --> IM(提升系统性能):::process
IM --> IN(实现额外功能):::process
IN --> IO(灵活扩展):::process
IO --> IP(满足多样化需求):::process
IP --> IQ(提升开发效率):::process
IQ --> IR(优化数据库操作):::process
IR --> IS(提高查询效率):::process
IS --> IT(提升系统性能):::process
IT --> IU(实现额外功能):::process
IU --> IV(灵活扩展):::process
IV --> IW(满足多样化需求):::process
IW --> IX(提升开发效率):::process
IX --> IY(优化数据库操作):::process
IY --> IZ(提高查询效率):::process
IZ --> JA(提升系统性能):::process
JA --> JB(实现额外功能):::process
JB --> JC(灵活扩展):::process
JC --> JD(满足多样化需求):::process
JD --> JE(提升开发效率):::process
JE --> JF(优化数据库操作):::process
JF --> JG(提高查询效率):::process
JG --> JH(提升系统性能):::process
JH -->JI(实现额外功能):::process
JI --> JJ(灵活扩展):::process
JJ --> JK(满足多样化需求):::process
JK --> JL(提升开发效率):::process
JL --> JM(优化数据库操作):::process
JM --> JN(提高查询效率):::process
JN --> JO(提升系统性能):::process
JO --> JP(实现额外功能):::process
JP --> JQ(灵活扩展):::process
JQ --> JR(满足多样化需求):::process
JR --> JS(提升开发效率):::process
JS --> JT(优化数据库操作):::process
JT --> JU(提高查询效率):::process
JU --> JV(提升系统性能):::process
JV --> JW(实现额外功能):::process
JW --> JX(灵活扩展):::process
JX --> JY(满足多样化需求):::process
JY --> JZ(提升开发效率):::process
JZ --> KA(优化数据库操作):::process
KA --> KB(提高查询效率):::process
KB --> KC(提升系统性能):::process
KC --> KD(实现额外功能):::process
KD --> KE(灵活扩展):::process
KE --> KF(满足多样化需求):::process
KF --> KG(提升开发效率):::process
KG --> KH(优化数据库操作):::process
KH --> KI(提高查询效率):::process
KI --> KJ(提升系统性能):::process
KJ --> KK(实现额外功能):::process
KK --> KL(灵活扩展):::process
KL --> KM(满足多样化需求):::process
KM --> KN(提升开发效率):::process
KN --> KO(优化数据库操作):::process
KO --> KP(提高查询效率):::process
KP --> KQ(提升系统性能):::process
KQ --> KR(实现额外功能):::process
KR --> KS(灵活扩展):::process
KS --> KT(满足多样化需求):::process
KT --> KU(提升开发效率):::process
KU --> KV(优化数据库操作):::process
KV --> KW(提高查询效率):::process
KW --> KX(提升系统性能):::process
KX --> KY(实现额外功能):::process
KY --> KZ(灵活扩展):::process
KZ --> LA(满足多样化需求):::process
LA --> LB(提升开发效率):::process
LB --> LC(优化数据库操作):::process
LC --> LD(提高查询效率):::process
LD --> LE(提升系统性能):::process
LE --> LF(实现额外功能):::process
LF --> LG(灵活扩展):::process
LG --> LH(满足多样化需求):::process
LH --> LI(提升开发效率):::process
LI --> LJ(优化数据库操作):::process
LJ --> LK(提高查询效率):::process
LK --> LL(提升系统性能):::process
LL --> LM(实现额外功能):::process
LM --> LN(灵活扩展):::process
LN --> LO(满足多样化需求):::process
LO --> LP(提升开发效率):::process
LP --> LQ(优化数据库操作):::process
LQ --> LR(提高查询效率):::process
LR --> LS(提升系统性能):::process
LS --> LT(实现额外功能):::process
LT --> LU(灵活扩展):::process
LU --> LV(满足多样化需求):::process
LV --> LW(提升开发效率):::process
LW --> LX(优化数据库操作):::process
LX --> LY(提高查询效率):::process
LY --> LZ(提升系统性能):::process
LZ --> MA(实现额外功能):::process
MA --> MB(灵活扩展):::process
MB --> MC(满足多样化需求):::process
MC --> MD(提升开发效率):::process
MD --> ME(优化数据库操作):::process
ME --> MF(提高查询效率):::process
MF --> MG(提升系统性能):::process
MG --> MH(实现额外功能):::process
MH --> MI(灵活扩展):::process
MI --> MJ(满足多样化需求):::process
MJ --> MK(提升开发效率):::process
MK --> ML(优化数据库操作):::process
ML --> MM(提高查询效率):::process
MM --> MN(提升系统性能):::process
MN --> MO(实现额外功能):::process
MO --> MP(灵活扩展):::process
MP --> MQ(满足多样化需求):::process
MQ --> MR(提升开发效率):::process
MR
## 🍊 MyBatis核心知识点之动态代理实现：代理模式原理
在软件开发过程中，我们常常会遇到需要处理大量数据库操作的场景。想象一下，一个程序员正坐在电脑前，面对着满屏的代码，眉头紧锁，手指在键盘上快速敲击。他需要从数据库中获取数据，但以往的手动操作，那可真是麻烦得很。各种连接配置、SQL语句，想想都让人头疼。就在这时，他突然灵机一动，想到了MyBatis这个强大的工具。
MyBatis的核心知识点之一就是动态代理实现，其背后的代理模式原理至关重要。代理模式是一种设计模式，它允许在不需要修改原有对象的情况下，对对象进行扩展。在MyBatis中，动态代理技术被广泛应用于SQL映射和数据库操作，极大地简化了数据库操作的过程。
为什么要介绍这个知识点呢？首先，代理模式能够降低系统耦合度，使得数据库操作与业务逻辑分离，提高代码的可维护性和可扩展性。其次，通过动态代理，MyBatis能够自动生成SQL语句，减少程序员手动编写SQL语句的繁琐工作，提高开发效率。
接下来，我们将对代理模式进行深入探讨。首先，我们将会介绍代理模式的基本定义，阐述其核心思想。然后，我们将对代理模式进行分类，分析不同类型的代理模式及其适用场景。最后，我们将探讨代理模式的特点，如降低耦合度、提高代码可维护性等。
在了解了代理模式的基本概念和特点之后，我们将进一步探讨MyBatis中动态代理的实现方式。通过动态代理，MyBatis能够自动生成代理对象，实现数据库操作。我们将详细介绍动态代理的原理，以及如何在MyBatis中使用动态代理技术。
总之，MyBatis的动态代理实现和代理模式原理对于理解MyBatis的工作原理和高效使用MyBatis至关重要。通过学习这些知识点，我们能够更好地掌握MyBatis，提高数据库操作的开发效率和质量。
MyBatis动态代理实现
代理模式，作为一种常用的设计模式，在Java开发中扮演着至关重要的角色。它允许我们在不修改原始对象的情况下，对对象进行增强。在MyBatis框架中，动态代理的实现为我们提供了极大的便利。
### 🎉 代理模式定义
代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供一个代理以控制对这个对象的访问。代理模式通常分为两种：静态代理和动态代理。静态代理在编译时就已经确定代理对象，而动态代理则是在运行时动态创建代理对象。
### 🎉 代理模式原理
代理模式的核心在于代理对象和原始对象实现相同的接口。代理对象在调用原始对象的方法时，可以添加一些额外的操作，如日志记录、权限校验等。这样，我们就可以在不修改原始对象的情况下，对对象进行增强。
在Java中，动态代理的实现依赖于`java.lang.reflect.Proxy`类。该类提供了`newProxyInstance`方法，用于创建代理对象。该方法需要三个参数：类加载器、接口数组、调用处理器。
### 🎉 MyBatis代理实现细节
MyBatis框架中，动态代理的实现主要体现在`SqlSession`的创建过程中。当我们调用`SqlSessionFactory.openSession()`方法时，MyBatis会创建一个`SqlSession`代理对象。这个代理对象实现了`SqlSession`接口，并具有执行SQL语句、管理事务等功能。
在MyBatis中，动态代理的实现主要依赖于`SqlSessionManager`类。该类负责创建`SqlSession`代理对象，并管理这些代理对象的生命周期。
```java
public SqlSession openSession() {
return openSessionFromDataSource(null, false);
}
private SqlSession openSessionFromDataSource(ExecutorType execType, boolean autoCommit) {
try {
// 获取数据源
TransactionIsolationLevel level = levelHolder.getLevel();
// 创建Executor
Executor executor = transactionManager.newExecutor(tx, execType);
// 创建SqlSession
SqlSession sqlSession = new DefaultSqlSession(transactionManager, executor);
return sqlSession;
} catch (Exception e) {
// 处理异常
...
}
}
🎉 代理模式应用场景
代理模式在Java开发中有着广泛的应用场景，以下是一些常见的应用场景：
- 日志记录：在方法执行前后添加日志记录，方便追踪程序执行过程。
- 权限校验：在方法执行前进行权限校验，确保用户有权限执行该方法。
- 事务管理：在方法执行前后进行事务管理，确保数据的一致性。
- 性能监控：在方法执行前后监控性能，找出性能瓶颈。
🎉 MyBatis代理模式与Spring AOP对比
MyBatis代理模式和Spring AOP都是实现代理模式的方式，但它们在实现原理和应用场景上有所不同。
- 实现原理：MyBatis代理模式基于Java反射机制，而Spring AOP基于动态代理和字节码技术。
- 应用场景：MyBatis代理模式适用于数据库操作，而Spring AOP适用于更广泛的场景，如日志记录、权限校验等。
🎉 代理模式优缺点分析
代理模式的优点：
- 增强原始对象：在不修改原始对象的情况下，对对象进行增强。
- 降低耦合度：代理对象和原始对象解耦，降低系统复杂性。
代理模式的缺点：
- 性能开销：动态代理在创建代理对象时，需要反射机制，可能会带来一定的性能开销。
- 代码复杂度：实现代理模式需要编写额外的代码，增加代码复杂度。
🎉 代理模式在MyBatis中的应用案例
在MyBatis中，代理模式主要用于创建SqlSession代理对象。以下是一个简单的示例：
public interface UserMapper {
User getUserById(int id);
}
public class UserMapperImpl implements UserMapper {
public User getUserById(int id) {
// 查询数据库获取用户信息
...
}
}
public class MyBatisProxy {
public static <T> T getProxy(Class<T> clazz) {
return (T) Proxy.newProxyInstance(
clazz.getClassLoader(),
new Class<?>[]{clazz},
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加额外的操作，如日志记录、权限校验等
return method.invoke(new UserMapperImpl(), args);
}
}
);
}
}
public static void main(String[] args) {
UserMapper userMapper = MyBatisProxy.getProxy(UserMapper.class);
User user = userMapper.getUserById(1);
// 使用user对象
}
🎉 代理模式在Java开发中的应用实例
在Java开发中，代理模式的应用非常广泛。以下是一个简单的示例：
public interface Calculator {
int add(int a, int b);
}
public class CalculatorImpl implements Calculator {
public int add(int a, int b) {
return a + b;
}
}
public class CalculatorProxy implements Calculator {
private Calculator calculator;
public CalculatorProxy(Calculator calculator) {
this.calculator = calculator;
}
public int add(int a, int b) {
// 在这里可以添加额外的操作，如日志记录、权限校验等
return calculator.add(a, b);
}
}
public static void main(String[] args) {
Calculator calculator = new CalculatorProxy(new CalculatorImpl());
int result = calculator.add(1, 2);
// 使用result
}
通过以上示例，我们可以看到代理模式在Java开发中的应用非常灵活，可以满足各种需求。
| 对比项 | MyBatis动态代理 | Spring AOP |
|---|---|---|
| 实现原理 | 基于Java反射机制，通过java.lang.reflect.Proxy类创建代理对象。 | 基于动态代理和字节码技术，通过org.springframework.aop.framework.ProxyFactory类创建代理对象。 |
| 代理对象创建时机 | 在运行时动态创建代理对象。 | 在运行时动态创建代理对象。 |
| 代理对象接口 | 代理对象实现与原始对象相同的接口。 | 代理对象实现与原始对象相同的接口。 |
| 应用场景 | 主要用于数据库操作，如创建SqlSession代理对象。 | 适用于更广泛的场景，如日志记录、权限校验、事务管理等。 |
| 性能开销 | 由于使用反射机制，可能会带来一定的性能开销。 | 相比MyBatis动态代理，性能开销可能更大，因为涉及字节码技术。 |
| 代码复杂度 | 实现代理模式需要编写额外的代码，但相对简单。 | 实现代理模式需要编写更多的代码，但功能更强大。 |
| 配置和集成 | 需要配置MyBatis相关配置文件，如mapper.xml。 | 需要配置Spring相关配置文件，如aop.xml。 |
| 适用框架 | 主要适用于MyBatis框架。 | 主要适用于Spring框架。 |
| 优点 | 1. 增强原始对象，降低耦合度。2. 适用于数据库操作。 | 1. 功能强大，适用于更广泛的场景。2. 代码复用率高。 |
| 缺点 | 1. 性能开销。2. 代码复杂度。 | 1. 性能开销。2. 代码复杂度。 |
MyBatis动态代理与Spring AOP在实现原理上存在相似之处，都利用了Java的反射机制和动态代理技术。然而，MyBatis动态代理更专注于数据库操作，如创建
SqlSession代理对象，而Spring AOP则具有更广泛的应用场景，如日志记录、权限校验、事务管理等。尽管两者在性能和代码复杂度上存在一定的开销，但Spring AOP凭借其强大的功能和代码复用率，在复杂业务场景中更具优势。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("代理模式定义"):::startend --> B("静态代理"):::process
A --> C("动态代理"):::process
B --> D("编译时确定代理对象"):::process
C --> E("运行时创建代理对象"):::process
A --> F("代理模式原理"):::process
F --> G("代理对象与原始对象实现相同接口"):::process
F --> H("添加额外操作如日志、权限校验"):::process
A --> I("MyBatis代理实现"):::process
I --> J("SqlSession代理"):::process
I --> K("SqlSessionManager创建代理"):::process
J --> L("执行SQL语句"):::process
J --> M("管理事务"):::process
A --> N("代理模式应用场景"):::process
N --> O("日志记录"):::process
N --> P("权限校验"):::process
N --> Q("事务管理"):::process
N --> R("性能监控"):::process
A --> S("MyBatis代理与Spring AOP对比"):::process
S --> T("MyBatis基于反射"):::process
S --> U("Spring AOP基于动态代理和字节码"):::process
S --> V("MyBatis适用于数据库操作"):::process
S --> W("Spring AOP适用于更广泛场景"):::process
A --> X("代理模式优缺点"):::process
X --> Y("增强原始对象"):::process
X --> Z("降低耦合度"):::process
X --> AA("性能开销"):::process
X --> AB("代码复杂度"):::process
A --> AC("MyBatis代理应用案例"):::process
AC --> AD("UserMapper代理"):::process
AC --> AE("执行数据库操作"):::process
AC --> AF("使用代理对象"):::process
MyBatis动态代理实现
在Java编程中，代理模式是一种常用的设计模式，它允许在不需要修改原始对象的情况下，对对象进行增强。MyBatis框架中，动态代理的实现是构建其核心功能的基础。下面，我们将深入探讨MyBatis动态代理的实现，包括代理模式分类、原理、实现细节以及其在MyBatis中的应用。
代理模式分类
代理模式主要分为两大类：静态代理和动态代理。
-
静态代理：在编译时就已经确定代理类和被代理类的实现，代理类和被代理类实现相同的接口。静态代理的缺点是，如果需要代理的对象很多，那么需要为每个对象创建一个代理类，这会增加代码的复杂度。
-
动态代理：在运行时动态创建代理类，代理类和被代理类实现相同的接口。动态代理的优点是，可以减少代理类的数量，降低代码复杂度。
代理模式原理
代理模式的核心原理是“代理”和“被代理”的关系。代理类负责调用被代理类的方法，并在调用前后进行一些额外的操作。在Java中，动态代理是通过java.lang.reflect.Proxy类实现的。
MyBatis代理实现细节
MyBatis使用动态代理来实现其核心功能，如SQL映射、事务管理等。以下是MyBatis动态代理的实现细节：
-
创建代理类：MyBatis使用
Proxy.newProxyInstance方法创建代理类，该方法的参数包括被代理类的类加载器、被代理类实现的接口、一个InvocationHandler对象。 -
实现InvocationHandler：InvocationHandler是一个接口，它只有一个方法
invoke，该方法在代理类调用被代理类的方法时被调用。在MyBatis中，SqlSession和Mapper接口的代理类都实现了InvocationHandler接口。 -
调用被代理类的方法：在InvocationHandler的
invoke方法中，通过反射调用被代理类的方法，并在调用前后进行一些额外的操作，如SQL映射、事务管理等。
代理模式应用场景
代理模式在以下场景中非常有用：
-
缓存：通过代理模式实现缓存功能，减少对数据库的访问次数。
-
安全控制：在调用被代理类的方法前，进行安全检查。
-
日志记录：在调用被代理类的方法前后，记录日志信息。
MyBatis代理模式优缺点
优点：
-
降低代码复杂度：通过代理模式，可以减少代理类的数量，降低代码复杂度。
-
增强功能：可以在不修改原始对象的情况下，对对象进行增强。
缺点：
-
性能开销：动态代理在创建代理类时，会有一定的性能开销。
-
依赖反射：动态代理依赖于反射机制，可能会降低代码的可读性。
代理模式与AOP对比
AOP（面向切面编程）和代理模式都是一种编程范式，它们都可以实现代码的解耦。AOP通过切面来实现横切关注点，而代理模式通过代理类来实现横切关注点。
MyBatis代理模式与Spring AOP结合
MyBatis代理模式可以与Spring AOP结合使用，实现更强大的功能。在Spring框架中，可以通过@Aspect注解定义切面，然后在切面中使用MyBatis的代理模式实现功能。
代理模式在MyBatis中的具体应用案例
以下是一个使用MyBatis动态代理实现SQL映射的示例：
public interface UserMapper {
User getUserById(Integer id);
}
public class UserMapperProxy implements InvocationHandler {
private Object target;
public UserMapperProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在调用getUserById方法前后进行一些操作
System.out.println("Before method call");
Object result = method.invoke(target, args);
System.out.println("After method call");
return result;
}
}
public static void main(String[] args) {
UserMapper mapper = (UserMapper) Proxy.newProxyInstance(
UserMapper.class.getClassLoader(),
new Class[]{UserMapper.class},
new UserMapperProxy(new UserMapperImpl())
);
User user = mapper.getUserById(1);
System.out.println(user);
}
在这个示例中，我们创建了一个UserMapperProxy类，实现了InvocationHandler接口。在invoke方法中，我们在调用getUserById方法前后进行了一些操作。然后，我们使用Proxy.newProxyInstance方法创建了一个UserMapper的代理实例，并在main方法中调用代理实例的方法。
| 代理模式分类 | 特点 | 优点 | 缺点 |
|---|---|---|---|
| 静态代理 | 编译时确定代理类和被代理类，实现相同的接口 | 代码简单，易于理解 | 需为每个对象创建代理类，增加代码复杂度 |
| 动态代理 | 运行时动态创建代理类，实现相同的接口 | 减少代理类数量，降低代码复杂度 | 性能开销，依赖反射，可能降低代码可读性 |
| AOP（面向切面编程） | 通过切面实现横切关注点 | 实现代码解耦，提高代码复用性 | 需要额外配置，可能增加系统复杂度 |
| MyBatis代理实现细节 | 步骤 | 说明 |
|---|---|---|
| 创建代理类 | 使用Proxy.newProxyInstance方法 | 参数包括被代理类的类加载器、被代理类实现的接口、一个InvocationHandler对象 |
| 实现InvocationHandler | 实现InvocationHandler接口 | invoke方法在代理类调用被代理类的方法时被调用 |
| 调用被代理类的方法 | 在invoke方法中调用 | 通过反射调用被代理类的方法，并在调用前后进行一些额外的操作 |
| 代理模式应用场景 | 场景 | 说明 |
|---|---|---|
| 缓存 | 实现缓存功能 | 减少对数据库的访问次数 |
| 安全控制 | 安全检查 | 在调用被代理类的方法前进行安全检查 |
| 日志记录 | 记录日志信息 | 在调用被代理类的方法前后记录日志信息 |
| MyBatis代理模式优缺点 | 优点 | 缺点 |
|---|---|---|
| 降低代码复杂度 | 通过代理模式，减少代理类的数量，降低代码复杂度 | 性能开销，动态代理在创建代理类时，会有一定的性能开销 |
| 增强功能 | 在不修改原始对象的情况下，对对象进行增强 | 依赖反射，可能会降低代码的可读性 |
| 代理模式与AOP对比 | 对比项 | 静态代理 | 动态代理 | AOP |
|---|---|---|---|---|
| 实现方式 | 编译时确定 | 运行时动态创建 | 通过切面实现 | |
| 代码复杂度 | 较高 | 较低 | 较低 | |
| 性能开销 | 较低 | 较高 | 较低 | |
| 依赖反射 | 否 | 是 | 否 |
| MyBatis代理模式与Spring AOP结合 | 说明 | 优势 |
|---|---|---|
| 结合使用 | MyBatis代理模式可以与Spring AOP结合使用 | 实现更强大的功能，如事务管理、安全控制等 |
| 代理模式在MyBatis中的具体应用案例 | 步骤 | 说明 |
|---|---|---|
| 创建代理类 | 实现InvocationHandler接口 | 在invoke方法中，调用getUserById方法前后进行一些操作 |
| 创建代理实例 | 使用Proxy.newProxyInstance方法 | 创建UserMapper的代理实例 |
| 调用代理实例的方法 | 在main方法中调用 | 调用代理实例的方法，实现SQL映射功能 |
在实际应用中，代理模式能够有效地实现功能的扩展，而不需要修改原始类的代码。例如，在实现缓存功能时，可以通过静态代理在调用数据库之前先检查缓存中是否有数据，从而减少数据库的访问次数，提高系统性能。然而，静态代理需要为每个对象创建代理类，这会增加代码的复杂度。相比之下，动态代理可以在运行时动态创建代理类，减少了代理类的数量，降低了代码的复杂度，但可能会带来一定的性能开销。此外，AOP通过切面实现横切关注点，如日志记录和安全控制，它能够实现代码的解耦，提高代码的复用性，但同时也可能增加系统的复杂度。在MyBatis中，代理模式的应用使得开发者能够在不修改原始SQL映射文件的情况下，对SQL执行过程进行增强，如添加事务管理、安全控制等。这种模式与Spring AOP结合使用，可以进一步扩展其功能，实现更强大的系统管理。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("代理模式"):::startend --> B("静态代理"):::process
A --> C("动态代理"):::process
B --> D("编译时确定"):::process
B --> E("代理类和被代理类实现相同接口"):::process
C --> F("运行时创建"):::process
C --> G("代理类和被代理类实现相同接口"):::process
D --> H("代码复杂度高"):::process
E --> I("代理类数量多"):::process
F --> J("减少代理类数量"):::process
G --> K("降低代码复杂度"):::process
H --> L("静态代理缺点"):::process
I --> M("静态代理缺点"):::process
J --> N("动态代理优点"):::process
K --> O("动态代理优点"):::process
L:::decision --> P("性能开销"):::process
L:::decision --> Q("依赖反射"):::process
M:::decision --> P("性能开销"):::process
M:::decision --> Q("依赖反射"):::process
N:::decision --> R("降低代码复杂度"):::process
N:::decision --> S("增强功能"):::process
O:::decision --> R("降低代码复杂度"):::process
O:::decision --> S("增强功能"):::process
P:::process --> T("动态代理缺点"):::process
Q:::process --> T("动态代理缺点"):::process
R:::process --> U("动态代理优点"):::process
S:::process --> U("动态代理优点"):::process
T:::startend --> V("代理模式应用"):::process
V --> W("缓存"):::process
V --> X("安全控制"):::process
V --> Y("日志记录"):::process
W --> Z("减少数据库访问"):::process
X --> AA("安全检查"):::process
Y --> AB("记录日志"):::process
MyBatis动态代理实现：代理模式特点
在软件开发中，代理模式是一种常用的设计模式，它允许在不需要修改原始对象的情况下，对对象进行控制。MyBatis框架中，动态代理的实现是代理模式的一个典型应用。下面，我们将深入探讨代理模式的特点。
代理模式特点主要体现在以下几个方面：
-
增强功能：代理模式可以在不修改原始对象的情况下，增加新的功能。例如，在MyBatis中，可以通过代理实现事务管理、日志记录等功能。
-
控制访问：代理模式可以控制对原始对象的访问，例如，在MyBatis中，可以通过代理实现权限控制，防止非法访问。
-
降低耦合度：代理模式可以将客户端与原始对象解耦，降低系统之间的耦合度。在MyBatis中，通过代理，可以减少与数据库的直接交互，提高代码的可维护性。
-
提高性能：代理模式可以在不修改原始对象的情况下，提高系统的性能。例如，在MyBatis中，可以通过代理实现缓存机制，减少数据库的访问次数。
-
扩展性：代理模式具有良好的扩展性，可以在不修改原始对象的情况下，扩展新的功能。在MyBatis中，可以通过实现不同的代理类，实现不同的功能。
-
透明性：代理模式对客户端来说是透明的，客户端无需知道代理的存在。在MyBatis中，客户端通过代理调用方法，无需关心代理的实现细节。
-
动态性：代理模式可以实现动态代理，根据不同的需求，动态地创建代理对象。在MyBatis中，通过动态代理，可以实现延迟加载、懒加载等功能。
-
安全性：代理模式可以提高系统的安全性，例如，在MyBatis中，可以通过代理实现安全认证，防止恶意攻击。
总之，代理模式在MyBatis框架中的应用，充分体现了其特点。通过代理模式，MyBatis实现了对数据库操作的封装，提高了代码的可维护性和性能。在实际开发中，我们可以根据需求，灵活运用代理模式，提高系统的质量。
| 特点 | 描述 | MyBatis 应用实例 |
|---|---|---|
| 增强功能 | 在不修改原始对象的情况下，增加新的功能。 | 事务管理、日志记录、缓存机制等。 |
| 控制访问 | 控制对原始对象的访问，如权限控制。 | 通过代理实现权限控制，防止非法访问。 |
| 降低耦合度 | 将客户端与原始对象解耦，降低系统之间的耦合度。 | 通过代理减少与数据库的直接交互，提高代码的可维护性。 |
| 提高性能 | 在不修改原始对象的情况下，提高系统的性能。 | 通过代理实现缓存机制，减少数据库的访问次数。 |
| 扩展性 | 在不修改原始对象的情况下，扩展新的功能。 | 通过实现不同的代理类，实现不同的功能。 |
| 透明性 | 对客户端来说是透明的，客户端无需知道代理的存在。 | 客户端通过代理调用方法，无需关心代理的实现细节。 |
| 动态性 | 根据不同的需求，动态地创建代理对象。 | 实现延迟加载、懒加载等功能。 |
| 安全性 | 提高系统的安全性，如安全认证。 | 通过代理实现安全认证，防止恶意攻击。 |
在实际应用中，MyBatis 的代理机制不仅能够增强原有功能，还能在保证原有代码结构不变的前提下，实现功能的扩展。例如，通过代理可以轻松地实现事务管理，确保数据的一致性，同时，日志记录功能也可以通过代理轻松实现，无需修改原始代码。此外，代理机制还能有效地降低系统之间的耦合度，使得系统更加模块化，易于维护和扩展。例如，通过代理实现缓存机制，可以显著提高系统性能，减少数据库的访问次数，从而提升整体性能。这种动态性和透明性使得代理在MyBatis中的应用变得尤为重要，它不仅提高了系统的安全性，如安全认证，还能根据不同的需求动态地创建代理对象，实现系统的灵活性和可扩展性。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("代理模式"):::startend --> B("增强功能"):::process
A --> C("控制访问"):::process
A --> D("降低耦合度"):::process
A --> E("提高性能"):::process
A --> F("扩展性"):::process
A --> G("透明性"):::process
A --> H("动态性"):::process
A --> I("安全性"):::process
B --> J("事务管理"):::process
B --> K("日志记录"):::process
C --> L("权限控制"):::process
C --> M("防止非法访问"):::process
D --> N("减少数据库交互"):::process
D --> O("提高代码可维护性"):::process
E --> P("缓存机制"):::process
E --> Q("减少数据库访问"):::process
F --> R("实现不同代理类"):::process
F --> S("扩展新功能"):::process
G --> T("无需关心实现细节"):::process
H --> U("动态创建代理对象"):::process
I --> V("安全认证"):::process
I --> W("防止恶意攻击"):::process
🍊 MyBatis核心知识点之动态代理实现：JDK动态代理
在当今的软件开发领域，MyBatis 作为一款优秀的持久层框架，以其简洁的配置和强大的动态代理功能，深受广大开发者的喜爱。然而，在实际应用中，我们常常会遇到这样的场景：在执行数据库操作时，需要根据不同的业务需求动态地构建 SQL 语句。这种情况下，传统的编程方式往往需要手动编写大量的 SQL 代码，不仅效率低下，而且容易出错。为了解决这一问题，MyBatis 引入了 JDK 动态代理技术，实现了对 SQL 语句的动态构建和执行。
JDK 动态代理是 Java 语言提供的一种强大的技术，它允许我们在运行时创建一个代理对象，该代理对象能够拦截对目标对象的调用，并动态地生成新的方法来执行特定的操作。在 MyBatis 中，JDK 动态代理技术被广泛应用于 SQL 语句的构建和执行过程中，极大地提高了开发效率和代码的可维护性。
为什么需要介绍 MyBatis 核心知识点之动态代理实现：JDK 动态代理呢？首先，动态代理技术是实现 AOP（面向切面编程）的基础，它能够将横切关注点（如日志、事务等）与业务逻辑分离，从而提高代码的模块化和可复用性。其次，JDK 动态代理在 MyBatis 中的应用，使得开发者无需手动编写 SQL 语句，只需通过简单的配置即可实现数据库操作，极大地简化了开发流程。
接下来，我们将对 MyBatis 核心知识点之动态代理实现：JDK 动态代理进行深入探讨。首先，我们将介绍 JDK 动态代理的原理，包括代理对象的创建、方法拦截和目标对象的调用等。然后，我们将详细讲解 MyBatis 中 JDK 动态代理的实现步骤，包括代理对象的创建、拦截器的配置和代理方法的执行等。最后，我们将通过一个具体的示例，展示如何使用 JDK 动态代理技术实现 MyBatis 的动态 SQL 语句构建和执行。
在这个示例中，我们可以想象一位程序员正在面对一个复杂的业务需求，需要频繁地与数据库进行交互。以往，他需要手动编写 SQL 语句，并进行各种连接配置，这个过程既繁琐又容易出错。然而，自从他学会了使用 MyBatis 的动态代理技术后，他只需在配置文件中定义相应的 SQL 语句，MyBatis 就会自动生成代理对象，并动态地执行所需的数据库操作。这样一来，他的工作效率得到了显著提升，开发过程也变得更加轻松愉快。
MyBatis动态代理实现
在Java编程中，动态代理是一种强大的技术，它允许在运行时创建接口的实例，而不需要实现接口的具体方法。MyBatis框架利用动态代理技术，实现了对数据库操作的封装和简化。下面，我们将深入探讨MyBatis动态代理的实现，特别是JDK动态代理原理。
JDK动态代理原理
JDK动态代理是基于Java反射机制实现的。它允许我们创建一个代理类，该类可以拦截对目标对象的调用，并在调用前后执行特定的逻辑。JDK动态代理的核心类是Proxy，它提供了newProxyInstance方法，用于创建代理实例。
public class Proxy {
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) throws ProxyError {
// 省略部分代码
}
}
newProxyInstance方法接受三个参数：ClassLoader，Class<?>[] interfaces和InvocationHandler。ClassLoader用于加载代理类，interfaces是目标接口的数组，InvocationHandler是一个实现了InvocationHandler接口的实例，它定义了代理对象的方法调用时的逻辑。
代理模式应用
在MyBatis中，动态代理主要用于实现SqlSession接口。SqlSession是MyBatis的核心接口，用于执行数据库操作。通过动态代理，MyBatis可以在运行时创建SqlSession的代理实例，并在代理实例中拦截对数据库操作的方法调用。
MyBatis代理过程
当调用MyBatis的数据库操作方法时，如selectOne或selectList，MyBatis会使用动态代理技术创建一个代理实例。这个代理实例会拦截对数据库操作方法的调用，并在调用前后执行特定的逻辑。
代理对象创建
在创建代理对象时，MyBatis会使用Proxy类的newProxyInstance方法，传入相应的参数。这些参数包括MyBatis的SqlSession接口、SqlSession的代理类和InvocationHandler。
拦截器机制
在MyBatis中，拦截器机制用于在代理对象的方法调用前后执行特定的逻辑。拦截器通过实现Interceptor接口来实现，MyBatis提供了多种内置的拦截器，如ExecutorTypeInterceptor和ParameterHandlerInterceptor。
MyBatis配置文件解析
MyBatis的配置文件中定义了数据库连接信息、映射文件路径等配置。在创建代理对象时，MyBatis会解析配置文件，获取所需的配置信息。
代理对象调用过程
当调用代理对象的方法时，如selectOne，代理对象会拦截这个调用，并将调用传递给InvocationHandler。InvocationHandler会根据调用方法的不同，执行相应的逻辑，如执行数据库查询。
MyBatis与Spring集成
MyBatis与Spring框架集成时，可以使用Spring的SqlSessionFactoryBean来创建SqlSession。SqlSessionFactoryBean会自动解析MyBatis的配置文件，并创建代理对象。
代理性能分析
动态代理虽然提供了强大的功能，但也会带来一定的性能开销。在性能分析时，需要关注代理对象的创建、方法调用拦截和数据库操作等环节。通过优化这些环节，可以提高MyBatis的性能。
| 概念/步骤 | 描述 | 相关类/方法 |
|---|---|---|
| 动态代理 | 在运行时创建接口的实例，而不需要实现接口的具体方法 | Proxy类、newProxyInstance方法 |
| JDK动态代理原理 | 基于Java反射机制实现，拦截对目标对象的调用，并在调用前后执行特定逻辑 | Proxy类、InvocationHandler接口 |
| MyBatis动态代理实现 | MyBatis利用动态代理技术，实现数据库操作的封装和简化 | SqlSession接口、代理实例、拦截器 |
| 代理模式应用 | MyBatis中，动态代理主要用于实现SqlSession接口 | SqlSession接口、代理实例 |
| MyBatis代理过程 | 创建代理实例，拦截对数据库操作方法的调用，并执行特定逻辑 | Proxy类、newProxyInstance方法、InvocationHandler |
| 代理对象创建 | 使用Proxy类的newProxyInstance方法创建代理实例 | Proxy类、newProxyInstance方法 |
| 拦截器机制 | 在代理对象的方法调用前后执行特定逻辑 | Interceptor接口、内置拦截器（如ExecutorTypeInterceptor、ParameterHandlerInterceptor） |
| MyBatis配置文件解析 | 解析配置文件，获取数据库连接信息、映射文件路径等配置 | MyBatis配置文件 |
| 代理对象调用过程 | 代理对象拦截调用，并将调用传递给InvocationHandler执行相应逻辑 | InvocationHandler |
| MyBatis与Spring集成 | 使用Spring的SqlSessionFactoryBean创建SqlSession，并创建代理对象 | SqlSessionFactoryBean |
| 代理性能分析 | 关注代理对象的创建、方法调用拦截和数据库操作等环节，优化以提高性能 | 性能分析工具、优化策略 |
动态代理技术不仅限于Java领域，在其他编程语言中也有类似的应用，如Python的
functools.wraps和C#的System.Reflection。这些技术都旨在提供一种灵活的方式来扩展或修改对象的行为，而无需修改原始对象的代码。例如，在Python中，可以使用functools.wraps装饰器来创建一个代理，该代理可以捕获并修改函数的调用过程，从而实现日志记录、性能监控等功能。这种技术的广泛应用，反映了软件工程中对于代码复用和灵活性的追求。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("JDK 动态代理"):::startend --> B("基于反射"):::process
A --> C("创建代理类"):::process
A --> D("拦截方法调用"):::process
B --> E("Proxy 类"):::process
B --> F("newProxyInstance"):::process
C --> G("代理实例"):::process
D --> H("执行特定逻辑"):::process
E --> I("Proxy 类"):::process
F --> J("ClassLoader, interfaces, InvocationHandler"):::io
G --> K("代理对象"):::process
H --> L("调用前后逻辑"):::process
I --> M("Proxy 类"):::process
J --> N("ClassLoader"):::io
J --> O("interfaces"):::io
J --> P("InvocationHandler"):::io
K --> Q("拦截方法调用"):::process
L --> R("执行目标方法"):::process
M --> S("Proxy 类"):::process
N --> T("ClassLoader"):::io
O --> U("目标接口"):::io
P --> V("InvocationHandler"):::io
Q --> W("代理实例"):::process
R --> X("执行结果"):::process
S --> Y("Proxy 类"):::process
T --> Z("ClassLoader"):::io
U --> AA("目标接口"):::io
V --> AB("InvocationHandler"):::io
W --> AC("代理实例"):::process
X --> AD("返回结果"):::process
Y --> AE("Proxy 类"):::process
Z --> AF("ClassLoader"):::io
AA --> AG("目标接口"):::io
AB --> AH("InvocationHandler"):::io
AC --> AI("代理实例"):::process
AD --> AJ("执行结果"):::process
AE --> AK("Proxy 类"):::process
AF --> AL("ClassLoader"):::io
AG --> AM("目标接口"):::io
AH --> AN("InvocationHandler"):::io
AI --> AO("代理实例"):::process
AJ --> AP("执行结果"):::process
AK --> AQ("Proxy 类"):::process
AL --> AR("ClassLoader"):::io
AM --> AS("目标接口"):::io
AN --> AT("InvocationHandler"):::io
AO --> AU("代理实例"):::process
AP --> AV("执行结果"):::process
AQ --> AW("Proxy 类"):::process
AR --> AX("ClassLoader"):::io
AS --> AY("目标接口"):::io
AT --> AZ("InvocationHandler"):::io
AU --> BA("代理实例"):::process
AV --> BB("执行结果"):::process
AW --> BC("Proxy 类"):::process
AX --> BD("ClassLoader"):::io
AY --> BE("目标接口"):::io
AZ --> BF("InvocationHandler"):::io
BA --> BG("代理实例"):::process
BB --> BH("执行结果"):::process
BC --> BI("Proxy 类"):::process
BD --> BJ("ClassLoader"):::io
BE --> BK("目标接口"):::io
BF --> BL("InvocationHandler"):::io
BG --> BM("代理实例"):::process
BH --> BN("执行结果"):::process
BI --> BO("Proxy 类"):::process
BJ --> BK("ClassLoader"):::io
BK --> BL("目标接口"):::io
BL --> BM("InvocationHandler"):::io
BM --> BN("代理实例"):::process
BN --> BO("执行结果"):::process
BO --> BP("Proxy 类"):::process
BP --> BQ("ClassLoader"):::io
BQ --> BR("目标接口"):::io
BR --> BS("InvocationHandler"):::io
BS --> BT("代理实例"):::process
BT --> BU("执行结果"):::process
BU --> BV("执行结果"):::process
BV --> BW("执行结果"):::process
BW --> BX("执行结果"):::process
BX --> BY("执行结果"):::process
BY --> BZ("执行结果"):::process
BZ --> CA("执行结果"):::process
CA --> CB("执行结果"):::process
CB --> CC("执行结果"):::process
CC --> CD("执行结果"):::process
CD --> CE("执行结果"):::process
CE --> CF("执行结果"):::process
CF --> CG("执行结果"):::process
CG --> CH("执行结果"):::process
CH --> CI("执行结果"):::process
CI --> CJ("执行结果"):::process
CJ --> CK("执行结果"):::process
CK --> CL("执行结果"):::process
CL --> CM("执行结果"):::process
CM --> CN("执行结果"):::process
CN --> CO("执行结果"):::process
CO --> CP("执行结果"):::process
CP --> CQ("执行结果"):::process
CQ --> CR("执行结果"):::process
CR --> CS("执行结果"):::process
CS --> CT("执行结果"):::process
CT --> CU("执行结果"):::process
CU --> CV("执行结果"):::process
CV --> CW("执行结果"):::process
CW --> CX("执行结果"):::process
CX --> CY("执行结果"):::process
CY --> CZ("执行结果"):::process
CZ --> DA("执行结果"):::process
DA --> DB("执行结果"):::process
DB --> DC("执行结果"):::process
DC --> DD("执行结果"):::process
DD --> DE("执行结果"):::process
DE --> DF("执行结果"):::process
DF --> DG("执行结果"):::process
DG --> DH("执行结果"):::process
DH --> DI("执行结果"):::process
DI --> DJ("执行结果"):::process
DJ --> DK("执行结果"):::process
DK --> DL("执行结果"):::process
DL --> DM("执行结果"):::process
DM --> DN("执行结果"):::process
DN --> DO("执行结果"):::process
DO --> DP("执行结果"):::process
DP --> DQ("执行结果"):::process
DQ --> DR("执行结果"):::process
DR --> DS("执行结果"):::process
DS --> DT("执行结果"):::process
DT --> DU("执行结果"):::process
DU --> DV("执行结果"):::process
DV --> DW("执行结果"):::process
DW --> DX("执行结果"):::process
DX --> DY("执行结果"):::process
DY --> DZ("执行结果"):::process
DZ --> EA("执行结果"):::process
EA --> EB("执行结果"):::process
EB --> EC("执行结果"):::process
EC --> ED("执行结果"):::process
ED --> EE("执行结果"):::process
EE --> EF("执行结果"):::process
EF --> EG("执行结果"):::process
EG --> EH("执行结果"):::process
EH --> EI("执行结果"):::process
EI --> EJ("执行结果"):::process
EJ -->EK("执行结果"):::process
EK --> EL("执行结果"):::process
EL --> EM("执行结果"):::process
EM --> EN("执行结果"):::process
EN --> EO("执行结果"):::process
EO --> EP("执行结果"):::process
EP --> EQ("执行结果"):::process
EQ --> ER("执行结果"):::process
ER --> ES("执行结果"):::process
ES --> ET("执行结果"):::process
ET --> EU("执行结果"):::process
EU --> EV("执行结果"):::process
EV --> EW("执行结果"):::process
EW --> EX("执行结果"):::process
EX --> EY("执行结果"):::process
EY --> EZ("执行结果"):::process
EZ --> FA("执行结果"):::process
FA --> FB("执行结果"):::process
FB --> FC("执行结果"):::process
FC --> FD("执行结果"):::process
FD --> FE("执行结果"):::process
FE --> FF("执行结果"):::process
FF --> FG("执行结果"):::process
FG --> FH("执行结果"):::process
FH --> FI("执行结果"):::process
FI --> FJ("执行结果"):::process
FJ --> FK("执行结果"):::process
FK --> FL("执行结果"):::process
FL --> FM("执行结果"):::process
FM --> FN("执行结果"):::process
FN --> FO("执行结果"):::process
FO --> FP("执行结果"):::process
FP --> FQ("执行结果"):::process
FQ --> FR("执行结果"):::process
FR --> FS("执行结果"):::process
FS --> FT("执行结果"):::process
FT --> FU("执行结果"):::process
FU --> FV("执行结果"):::process
FV --> FW("执行结果"):::process
FW --> FX("执行结果"):::process
FX --> FY("执行结果"):::process
FY --> FZ("执行结果"):::process
FZ --> GA("执行结果"):::process
GA --> GB("执行结果"):::process
GB --> GC("执行结果"):::process
GC --> GD("执行结果"):::process
GD --> GE("执行结果"):::process
GE --> GF("执行结果"):::process
GF --> GG("执行结果"):::process
GG --> GH("执行结果"):::process
GH --> GI("执行结果"):::process
GI --> GJ("执行结果"):::process
GJ --> GK("执行结果"):::process
GK --> GL("执行结果"):::process
GL --> GM("执行结果"):::process
GM --> GN("执行结果"):::process
GN --> GO("执行结果"):::process
GO --> GP("执行结果"):::process
GP --> GQ("执行结果"):::process
GQ --> GR("执行结果"):::process
GR --> GS("执行结果"):::process
GS --> GT("执行结果"):::process
GT --> GU("执行结果"):::process
GU --> GV("执行结果"):::process
GV --> GW("执行结果"):::process
GW --> GX("执行结果"):::process
GX --> GY("执行结果"):::process
GY --> GZ("执行结果"):::process
GZ --> HA("执行结果"):::process
HA --> HB("执行结果"):::process
HB --> HC("执行结果"):::process
HC --> HD("执行结果"):::process
HD --> HE("执行结果"):::process
HE --> HF("执行结果"):::process
HF --> HG("执行结果"):::process
HG --> HH("执行结果"):::process
HH --> HI("执行结果"):::process
HI --> HJ("执行结果"):::process
HJ --> HK("执行结果"):::process
HK --> HL("执行结果"):::process
HL --> HM("执行结果"):::process
HM --> HN("执行结果"):::process
HN --> HO("执行结果"):::process
HO --> HP("执行结果"):::process
HP --> HQ("执行结果"):::process
HQ --> HR("执行结果"):::process
HR --> HS("执行结果"):::process
HS --> HT("执行结果"):::process
HT --> HU("执行结果"):::process
HU --> HV("执行结果"):::process
HV --> HW("执行结果"):::process
HW -->HX("执行结果"):::process
HX --> HY("执行结果"):::process
HY --> HZ("执行结果"):::process
HZ --> IA("执行结果"):::process
IA --> IB("执行结果"):::process
IB --> IC("执行结果"):::process
IC --> ID("执行结果"):::process
ID --> IE("执行结果"):::process
IE --> IF("执行结果"):::process
IF --> IG("执行结果"):::process
IG --> IH("执行结果"):::process
IH --> II("执行结果"):::process
II --> IJ("执行结果"):::process
IJ --> IK("执行结果"):::process
IK --> IL("执行结果"):::process
IL --> IM("执行结果"):::process
IM --> IN("执行结果"):::process
IN --> IO("执行结果"):::process
IO --> IP("执行结果"):::process
IP --> IQ("执行结果"):::process
IQ --> IR("执行结果"):::process
IR --> IS("执行结果"):::process
IS --> IT("执行结果"):::process
IT --> IU("执行结果"):::process
IU --> IV("执行结果"):::process
IV --> IW("执行结果"):::process
IW --> IX("执行结果"):::process
IX --> IY("执行结果"):::process
IY --> IZ("执行结果"):::process
IZ --> JA("执行结果"):::process
JA --> JB("执行结果"):::process
JB --> JC("执行结果"):::process
JC --> JD("执行结果"):::process
JD --> JE("执行结果"):::process
JE --> JF("执行结果"):::process
JF --> JG("执行结果"):::process
JG --> JH("执行结果"):::process
JH -->JI("执行结果"):::process
JI --> JK("执行结果"):::process
JK --> JL("执行结果"):::process
JL --> JM("执行结果"):::process
JM --> JN("执行结果"):::process
JN --> JO("执行结果"):::process
JO --> JP("执行结果"):::process
JP --> JQ("执行结果"):::process
JQ --> JR("执行结果"):::process
JR --> JS("执行结果"):::process
JS --> JT("执行结果"):::process
JT --> JU("执行结果"):::process
JU --> JV("执行结果"):::process
JV --> JW("执行结果"):::process
JW --> JX("执行结果"):::process
JX --> JY("执行结果"):::process
JY --> JZ("执行结果"):::process
JZ --> KA("执行结果"):::process
KA --> KB("执行结果"):::process
KB --> KC("执行结果"):::process
KC --> KD("执行结果"):::process
KD --> KE("执行结果"):::process
KE --> KF("执行结果"):::process
KF --> KG("执行结果"):::process
KG --> KH("执行结果"):::process
KH --> KI("执行结果"):::process
KI --> KJ("执行结果"):::process
KJ --> KK("执行结果"):::process
KK --> KL("执行结果"):::process
KL --> KM("执行结果"):::process
KM --> KN("执行结果"):::process
KN --> KO("执行结果"):::process
KO --> KP("执行结果"):::process
KP --> KQ("执行结果"):::process
KQ --> KR("执行结果"):::process
KR --> KS("执行结果"):::process
KS --> KT("执行结果"):::process
KT --> KU("执行结果"):::process
KU --> KV("执行结果"):::process
KV --> KW("执行结果"):::process
KW --> KX("执行结果"):::process
KX --> KY("执行结果"):::process
KY --> KZ("执行结果"):::process
KZ --> LA("执行结果"):::process
LA --> LB("执行结果"):::process
LB --> LC("执行结果"):::process
LC --> LD("执行结果"):::process
LD --> LE("执行结果"):::process
LE --> LF("执行结果"):::process
LF --> LG("执行结果"):::process
LG --> LH("执行结果"):::process
LH --> LI("执行结果"):::process
LI --> LJ("执行结果"):::process
LJ -->LK("执行结果"):::process
LK --> LL("执行结果"):::process
LL --> LM("执行结果"):::process
LM --> LN("执行结果"):::process
LN --> LO("执行结果"):::process
LO --> LP("执行结果"):::process
LP --> LQ("执行结果"):::process
LQ --> LR("执行结果"):::process
LR --> LS("执行结果"):::process
LS --> LT("执行结果"):::process
LT --> LU("执行结果"):::process
LU --> LV("执行结果"):::process
LV --> LW("执行结果"):::process
LW --> LX("执行结果"):::process
LX --> LY("执行结果"):::process
LY --> LZ("执行结果"):::process
LZ --> MA("执行结果"):::process
MA --> MB("执行结果"):::process
MB --> MC("执行结果"):::process
MC --> MD("执行结果"):::process
MD --> ME("执行结果"):::process
ME --> MF("执行结果"):::process
MF --> MG("执行结果"):::process
MG --> MH("执行结果"):::process
MH --> MI("执行结果"):::process
MI --> MJ("执行结果"):::process
MJ --> MK("执行结果"):::process
MK --> ML("执行结果"):::process
ML --> MN("执行结果"):::process
MN --> MO("执行
MyBatis核心知识点之动态代理实现：JDK动态代理实现步骤
在MyBatis框架中，动态代理是实现拦截器、插件机制等核心功能的关键技术。JDK动态代理是Java提供的一种实现动态代理的方式，它允许在运行时创建接口的实例，并为其添加额外的功能。下面将详细阐述JDK动态代理的实现步骤。
首先，我们需要明确代理的目标接口。在MyBatis中，通常是一个Mapper接口，它定义了数据库操作的抽象方法。例如，假设有一个UserMapper接口，它包含了查询用户信息的方法：
```java
public interface UserMapper {
User getUserById(Integer id);
}
接下来，创建一个实现了InvocationHandler接口的类，这个类将负责处理代理对象的请求。在MyBatis中，通常使用MyBatis的Interceptor接口来实现拦截器功能。下面是一个简单的Interceptor实现：
public class MyInterceptor implements InvocationHandler {
private Object target;
public MyInterceptor(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加拦截逻辑
System.out.println("Before method " + method.getName());
Object result = method.invoke(target, args);
System.out.println("After method " + method.getName());
return result;
}
}
然后，使用Proxy类创建代理对象。Proxy类是Java提供的一个用于创建动态代理的类，它包含了一个静态方法newProxyInstance，用于创建代理对象。下面是创建UserMapper代理对象的代码：
UserMapper proxy = (UserMapper) Proxy.newProxyInstance(
UserMapper.class.getClassLoader(),
new Class<?>[]{UserMapper.class},
new MyInterceptor(new UserMapperImpl())
);
在上面的代码中，第一个参数是类加载器，第二个参数是目标接口的Class对象数组，第三个参数是InvocationHandler对象。
创建代理对象后，就可以像调用普通对象一样调用代理对象的方法。例如，调用getUserById方法：
User user = proxy.getUserById(1);
在调用代理对象的方法时，会触发InvocationHandler的invoke方法，从而实现拦截逻辑。
总结一下，JDK动态代理实现步骤如下：
- 明确目标接口。
- 创建一个实现了InvocationHandler接口的类，用于处理代理对象的请求。
- 使用Proxy类创建代理对象。
- 调用代理对象的方法，触发InvocationHandler的invoke方法。
通过JDK动态代理，MyBatis实现了拦截器、插件机制等功能，为框架的扩展性和灵活性提供了有力支持。
| 步骤 | 描述 | 代码示例 |
|---|---|---|
| 1. 明确目标接口 | 确定需要代理的接口，通常是一个Mapper接口，它定义了数据库操作的抽象方法。 | ```java |
public interface UserMapper { User getUserById(Integer id); }
| 2. 创建实现InvocationHandler接口的类 | 创建一个类，该类将实现InvocationHandler接口，并负责处理代理对象的请求。在这个类中，可以添加拦截逻辑。 | ```java
public class MyInterceptor implements InvocationHandler {
private Object target;
public MyInterceptor(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加拦截逻辑
System.out.println("Before method " + method.getName());
Object result = method.invoke(target, args);
System.out.println("After method " + method.getName());
return result;
}
}
``` |
| 3. 使用Proxy类创建代理对象 | 使用Java的Proxy类提供的newProxyInstance方法创建代理对象。这个方法需要三个参数：类加载器、目标接口的Class对象数组、InvocationHandler对象。 | ```java
UserMapper proxy = (UserMapper) Proxy.newProxyInstance(
UserMapper.class.getClassLoader(),
new Class<?>[]{UserMapper.class},
new MyInterceptor(new UserMapperImpl())
);
``` |
| 4. 调用代理对象的方法 | 通过代理对象调用方法，实际执行的是InvocationHandler的invoke方法，从而实现拦截逻辑。 | ```java
User user = proxy.getUserById(1);
``` |
在软件开发过程中，接口代理技术是一种常用的设计模式，它允许开发者在不修改原始类代码的情况下，对类的方法调用进行拦截和处理。例如，在数据库操作中，通过接口代理可以实现对数据库访问的日志记录、权限检查等功能。
在实现接口代理时，首先需要明确目标接口，它通常是一个Mapper接口，定义了数据库操作的抽象方法。例如，`UserMapper`接口定义了根据用户ID获取用户信息的抽象方法`getUserById`。
接下来，创建一个实现`InvocationHandler`接口的类，如`MyInterceptor`，它负责处理代理对象的请求。在这个类中，可以添加拦截逻辑，例如在方法执行前后打印日志信息。这种拦截逻辑可以灵活地扩展，以适应不同的需求。
使用Java的`Proxy`类提供的`newProxyInstance`方法可以创建代理对象。这个方法需要三个参数：类加载器、目标接口的`Class`对象数组、`InvocationHandler`对象。通过这种方式，可以创建一个实现了目标接口的代理对象，而无需修改原始类的代码。
调用代理对象的方法时，实际执行的是`InvocationHandler`的`invoke`方法，从而实现拦截逻辑。这种设计模式使得代码更加灵活，易于维护和扩展。例如，可以通过修改`MyInterceptor`类中的拦截逻辑，来实现不同的功能，如性能监控、安全检查等。
总之，接口代理技术是一种强大的设计模式，它通过在方法调用过程中插入额外的逻辑，为开发者提供了极大的灵活性。在实际应用中，可以根据具体需求，灵活运用接口代理技术，以提高代码的可维护性和扩展性。
```mermaid
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("明确目标接口"):::startend --> B("创建InvocationHandler"):::process
B --> C("实现InvocationHandler"):::process
C --> D("创建代理对象"):::process
D --> E("调用代理方法"):::process
E --> F("触发invoke方法"):::process
A --> G("UserMapper接口"):::io
G --> H("getUserById"):::io
C --> I("MyInterceptor"):::io
I --> J("invoke方法"):::io
J --> K("添加拦截逻辑"):::process
D --> L("Proxy.newProxyInstance"):::io
L --> M("UserMapper代理"):::io
M --> N("getUserById(1)"):::io
MyBatis核心知识点之动态代理实现：JDK动态代理示例
在Java编程中，动态代理是一种强大的技术，它允许在运行时创建接口的实例，而不需要实现接口的具体方法。MyBatis框架中，动态代理被广泛应用于插件机制和拦截器等核心功能。本文将深入探讨MyBatis中的动态代理实现，特别是JDK动态代理的示例。
首先，我们需要了解什么是动态代理。动态代理是一种在运行时创建代理对象的技术，它允许我们拦截对目标对象的调用，并在此过程中执行额外的操作。在Java中，动态代理主要分为两种：JDK动态代理和CGLIB动态代理。本文将重点介绍JDK动态代理。
JDK动态代理利用Java的反射机制，通过实现InvocationHandler接口来创建代理对象。InvocationHandler接口中定义了一个invoke方法，该方法在代理对象上调用方法时会被调用。下面是一个简单的JDK动态代理示例：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Hello {
void sayHello();
}
class HelloImpl implements Hello {
public void sayHello() {
System.out.println("Hello, World!");
}
}
class HelloProxy implements InvocationHandler {
private Object target;
public HelloProxy(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before method call");
Object result = method.invoke(target, args);
System.out.println("After method call");
return result;
}
}
public class DynamicProxyExample {
public static void main(String[] args) {
Hello hello = new HelloImpl();
Hello proxyHello = (Hello) Proxy.newProxyInstance(
Hello.class.getClassLoader(),
new Class[]{Hello.class},
new HelloProxy(hello)
);
proxyHello.sayHello();
}
}
在上面的示例中，我们定义了一个Hello接口和一个实现该接口的HelloImpl类。然后，我们创建了一个HelloProxy类，它实现了InvocationHandler接口。在invoke方法中，我们添加了方法调用的前后逻辑。最后，我们使用Proxy.newProxyInstance方法创建了一个代理对象proxyHello，并调用其sayHello方法。
在MyBatis中，动态代理被广泛应用于插件机制和拦截器。例如，MyBatis的插件机制允许我们在执行SQL语句之前和之后添加自定义逻辑。下面是一个简单的MyBatis插件示例：
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;
import java.sql.Connection;
import java.util.Properties;
@Intercepts({
@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
public class MyBatisPlugin implements Interceptor {
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("Before SQL execution");
Object result = invocation.proceed();
System.out.println("After SQL execution");
return result;
}
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
public void setProperties(Properties properties) {
}
}
在上面的示例中，我们定义了一个MyBatis插件，它拦截了StatementHandler的prepare方法。在intercept方法中，我们添加了SQL执行的前后逻辑。
总之，MyBatis中的动态代理实现为我们提供了强大的功能，如插件机制和拦截器。通过理解JDK动态代理的原理和示例，我们可以更好地利用MyBatis框架，提高代码的可扩展性和可维护性。
| 动态代理类型 | 原理 | 优点 | 缺点 | 使用场景 |
|---|---|---|---|---|
| JDK动态代理 | 利用Java的反射机制，通过实现InvocationHandler接口来创建代理对象 | 1. 无需修改目标对象代码；2. 代理类与目标类实现相同的接口，易于理解和使用 | 1. 只能代理实现了接口的类；2. 代理类与目标类必须位于同一个类加载器中 | 1. 需要代理接口的场景；2. 需要拦截方法调用的场景 |
| CGLIB动态代理 | 利用ASM字节码操作框架，在运行时动态生成目标类的子类，并覆盖目标类的方法 | 1. 可代理任何类（包括未实现接口的类）；2. 代理类与目标类可以位于不同的类加载器中 | 1. 性能比JDK动态代理低；2. 代理类与目标类之间关系复杂，不易理解 | 1. 需要代理未实现接口的类；2. 需要拦截方法调用的场景 |
| MyBatis动态代理 | 利用JDK动态代理，在MyBatis框架中创建代理对象，实现插件机制和拦截器等功能 | 1. 提高代码的可扩展性和可维护性；2. 允许在运行时拦截方法调用，执行自定义逻辑 | 1. 依赖于JDK动态代理；2. 代理类与目标类必须位于同一个类加载器中 | 1. MyBatis插件机制；2. MyBatis拦截器 |
| 示例 | ||||
| JDK动态代理示例 | 通过实现InvocationHandler接口，在代理对象上调用方法时执行额外操作 | 1. 无需修改目标对象代码；2. 代理类与目标类实现相同的接口 | 只能代理实现了接口的类 | 需要代理接口的场景 |
| MyBatis插件示例 | 拦截StatementHandler的prepare方法，在执行SQL语句之前和之后添加自定义逻辑 | 提高代码的可扩展性和可维护性 | 依赖于JDK动态代理 | MyBatis插件机制 |
动态代理技术在Java编程中扮演着至关重要的角色，它不仅简化了代码结构，还提高了系统的灵活性和可扩展性。在JDK动态代理中，通过反射机制实现代理，使得开发者无需修改目标对象的代码即可实现功能扩展，这在遵循开闭原则的同时，也降低了代码的维护成本。然而，JDK动态代理的局限性在于它只能代理实现了接口的类，这在处理未实现接口的类时显得力不从心。此时，CGLIB动态代理便成为了一种有效的解决方案，它通过字节码操作动态生成目标类的子类，从而突破了接口的限制。尽管CGLIB动态代理在性能上略逊于JDK动态代理，但其强大的代理能力使其在许多场景下成为首选。在MyBatis框架中，动态代理技术被广泛应用于插件机制和拦截器等功能，极大地丰富了框架的功能性。通过动态代理，MyBatis能够实现运行时的方法拦截，从而为开发者提供了丰富的定制化选项。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("动态代理"):::startend --> B("JDK 动态代理"):::process
A --> C("应用场景"):::process
B --> D("InvocationHandler"):::process
B --> E("invoke 方法"):::process
C --> F("插件机制"):::process
C --> G("拦截器"):::process
D --> H("代理对象创建"):::process
E --> I("方法调用拦截"):::process
F --> J("SQL 执行前后逻辑"):::process
G --> K("StatementHandler 拦截"):::process
H --> L("Proxy.newProxyInstance"):::process
I --> M("额外操作执行"):::process
J --> N("自定义逻辑添加"):::process
K --> O("prepare 方法拦截"):::process
L --> P("Hello 接口代理"):::process
M --> Q("方法执行结果"):::process
N --> R("插件功能扩展"):::process
O --> S("SQL 执行控制"):::process
P --> T("HelloImpl 实例"):::process
Q --> U("返回结果"):::process
R --> V("框架可扩展性"):::process
S --> W("事务管理"):::process
T --> X("代理对象"):::process
U --> Y("方法调用"):::process
V --> Z("代码维护性"):::process
W --> AA("事务开启"):::process
W --> AB("事务提交"):::process
W --> AC("事务回滚"):::process
AA --> AD("开启事务"):::process
AB --> AE("提交事务"):::process
AC --> AF("回滚事务"):::process
Y --> AG("方法执行"):::process
Z --> AH("提高"):::process
🍊 MyBatis核心知识点之动态代理实现：CGLIB动态代理
在当今的软件开发领域，MyBatis 作为一款优秀的持久层框架，以其简洁的配置和强大的动态代理功能，深受广大开发者的喜爱。然而，在实际应用中，我们常常会遇到这样的场景：在执行数据库操作时，需要根据不同的业务需求动态地生成 SQL 语句。这时，传统的编程方式往往需要手动编写大量的 SQL 代码，不仅效率低下，而且容易出错。为了解决这一问题，MyBatis 引入了 CGLIB 动态代理技术，实现了对 SQL 语句的动态生成和执行。
CGLIB 动态代理是一种基于字节码生成的技术，它可以在运行时创建一个目标对象的子类，并重写目标对象的方法。通过这种方式，我们可以实现对目标对象方法的拦截和扩展，从而实现动态代理。在 MyBatis 中，CGLIB 动态代理主要用于生成 SQL 语句，提高数据库操作的效率。
为什么需要介绍 MyBatis 核心知识点之动态代理实现：CGLIB 动态代理呢？首先，CGLIB 动态代理技术是 MyBatis 框架的核心组成部分，深入理解其原理和实现步骤对于掌握 MyBatis 框架至关重要。其次，CGLIB 动态代理在 MyBatis 中的应用非常广泛，如 SQL 语句的动态生成、结果集的处理等，掌握这一技术有助于提高开发效率，降低代码复杂度。
接下来，我们将对 MyBatis 核心知识点之动态代理实现：CGLIB 动态代理进行详细阐述。首先，我们将介绍 CGLIB 动态代理的原理，包括其字节码生成机制、代理对象的创建过程等。然后，我们将讲解 MyBatis 中 CGLIB 动态代理的实现步骤，包括代理对象的创建、方法拦截、SQL 语句的动态生成等。最后，我们将通过一个示例演示如何使用 CGLIB 动态代理实现 SQL 语句的动态生成和执行。
在实际应用中，我们可以看到，通过 CGLIB 动态代理技术，MyBatis 能够根据不同的业务需求动态地生成 SQL 语句，从而简化了数据库操作的开发过程。例如，有一程序员，正猫在电脑前，眉头紧锁，手指在键盘上“噼里啪啦”敲得飞起，屏幕上那代码一行行地冒出来。突然，他停下了手中的动作，双手抱胸，眼睛直勾勾地盯着屏幕，嘴里嘟囔着：“哟呵，这需求得去数据库里捞点数据出来。” 说罢，脸上瞬间闪过一丝愁容，毕竟以往手动和数据库打交道，那可真是麻烦得很，各种连接配置、SQL 语句，想想都头大。可就在这时，他突然一拍脑门，乐了，嘴角都快咧到耳根子了，脸上那愁容瞬间烟消云散。为啥呀？嘿，因为他想起了 MyBatis 这好家伙。只见他双手重新放到键盘上，快速地敲了几行代码，调用了 MyBatis 的工厂类。没一会儿，数据库里的数据就乖乖地跑到屏幕上了。他往后一靠，得意地挑了挑眉毛，嘴里念叨着：“还得是 MyBatis 啊，这事儿给办得明明白白的！”
MyBatis动态代理实现：CGLIB动态代理原理
在Java编程中，动态代理是一种强大的技术，它允许在运行时创建接口的实例，而不需要实现接口的具体类。MyBatis框架中，动态代理技术被广泛应用于映射器接口的创建和调用。其中，CGLIB动态代理是MyBatis实现动态代理的一种方式。
CGLIB（Code Generation Library）是一个强大的高性能的代码生成类库，它可以在运行时动态生成任意类的子类。CGLIB通过继承的方式实现动态代理，它不需要接口，因此可以代理任何类，包括final类。
CGLIB动态代理原理如下：
-
创建代理类：CGLIB首先会根据目标类生成一个代理类，这个代理类是目标类的子类。代理类中包含了目标类的所有方法，并且每个方法都被CGLIB拦截，以便在方法执行前后添加自定义的逻辑。
-
方法拦截：当调用代理类的方法时，CGLIB会使用MethodInterceptor拦截方法执行。MethodInterceptor是一个接口，它定义了before()和after()两个方法，分别用于方法执行前和执行后。
-
方法执行：在拦截器中，可以自定义方法执行前的逻辑和执行后的逻辑。例如，可以在方法执行前添加日志记录，或者在方法执行后进行数据统计。
以下是一个使用CGLIB动态代理的示例代码：
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
// 方法执行前的逻辑
System.out.println("Before method execution");
// 执行目标方法
Object result = methodProxy.invokeSuper(o, objects);
// 方法执行后的逻辑
System.out.println("After method execution");
return result;
}
}
在MyBatis中，CGLIB动态代理被用于创建映射器接口的代理实例。当调用映射器接口的方法时，MyBatis会使用CGLIB动态代理技术创建代理实例，并在代理实例中执行方法。
CGLIB代理的优点：
- 无需实现接口，可以代理任何类。
- 性能较高，因为它是通过继承的方式实现的。
CGLIB代理的缺点：
- 代理类是目标类的子类，如果目标类是final类，则无法使用CGLIB代理。
- 代理类和目标类的生命周期相同，如果目标类被销毁，代理类也会被销毁。
总之，CGLIB动态代理是MyBatis实现动态代理的一种方式，它具有无需实现接口、性能高等优点。在实际应用中，可以根据需求选择合适的动态代理技术。
| 特征 | CGLIB动态代理 |
|---|---|
| 基于的技术 | 继承 |
| 代理对象 | 目标类的子类 |
| 接口支持 | 无需实现接口 |
| 类支持 | 包括final类 |
| 方法拦截 | 使用MethodInterceptor |
| 生命周期 | 与目标类相同 |
| 优点 | 1. 无需实现接口，可以代理任何类<br>2. 性能较高，因为它是通过继承的方式实现的 |
| 缺点 | 1. 代理类是目标类的子类，如果目标类是final类，则无法使用CGLIB代理<br>2. 代理类和目标类的生命周期相同，如果目标类被销毁，代理类也会被销毁 |
CGLIB动态代理在Java中是一种强大的代理技术，它通过继承目标类来创建代理对象。这种代理方式无需实现接口，因此可以代理任何类，包括final类。然而，由于代理类是目标类的子类，如果目标类是final类，则无法使用CGLIB代理。此外，CGLIB代理的性能较高，因为它通过继承的方式实现，但这也意味着代理类和目标类的生命周期相同，如果目标类被销毁，代理类也会被销毁。这种设计使得CGLIB代理在性能和灵活性之间取得了一种平衡。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("CGLIB 动态代理"):::startend --> B("创建代理类"):::process
A --> C("方法拦截"):::process
A --> D("方法执行"):::process
B --> E("生成目标类子类"):::process
C --> F("MethodInterceptor"):::process
D --> G("执行目标方法"):::process
E --> H("包含目标类方法"):::process
H --> I("方法被拦截"):::process
F --> J("before()"):::process
F --> K("after()"):::process
J --> L("方法执行前逻辑"):::process
K --> M("方法执行后逻辑"):::process
G --> N("返回结果"):::process
MyBatis动态代理实现：CGLIB动态代理实现步骤
在Java编程中，动态代理是一种强大的技术，它可以在运行时创建接口的实例，而不需要实现接口的具体方法。MyBatis框架中，动态代理技术被广泛应用于映射器接口的创建和调用。CGLIB（Code Generation Library）是Java的一个开源字节码生成框架，它提供了强大的动态代理功能。下面，我们将详细探讨CGLIB动态代理的实现步骤。
首先，我们需要定义一个接口，这个接口将被代理。例如，我们定义一个简单的Service接口：
public interface Service {
void doSomething();
}
接下来，创建一个实现了MethodInterceptor接口的拦截器类。这个拦截器类负责在代理对象的方法调用前后执行特定的逻辑。以下是一个简单的拦截器实现：
public class MyInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("Before method call");
Object result = proxy.invokeSuper(obj, args);
System.out.println("After method call");
return result;
}
}
然后，使用CGLIB的Enhancer类创建代理对象。Enhancer类提供了创建代理对象的方法，它需要代理的类、拦截器以及代理的接口。以下是如何创建代理对象的示例：
public class ProxyFactory {
public static Object getProxy(Class<?> clazz, MethodInterceptor interceptor) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(interceptor);
return enhancer.create();
}
}
最后，使用代理对象调用方法。以下是创建代理对象并调用其方法的一个示例：
public class Main {
public static void main(String[] args) {
Service proxy = (Service) ProxyFactory.getProxy(Service.class, new MyInterceptor());
proxy.doSomething();
}
}
在上述代码中，当调用proxy.doSomething()时，会先执行拦截器中的intercept方法，然后调用原始的doSomething方法，并在方法调用后再次执行拦截器中的逻辑。
CGLIB动态代理的应用场景非常广泛，例如在MyBatis框架中，用于创建映射器接口的代理对象。与JDK动态代理相比，CGLIB动态代理可以代理任何类，包括final类和没有接口的类，这使得它在某些情况下比JDK动态代理更灵活。
在性能方面，CGLIB动态代理通常比JDK动态代理慢，因为它涉及到字节码的生成和类加载。然而，对于大多数应用来说，这种性能差异是可以接受的。
总之，CGLIB动态代理是一种强大的技术，它为Java编程提供了灵活的动态代理解决方案。通过理解其实现步骤，我们可以更好地利用这一技术，提高代码的灵活性和可维护性。
| 步骤 | 描述 | 代码示例 |
|---|---|---|
| 定义接口 | 创建一个将被代理的接口，该接口定义了代理对象需要实现的方法。 | java<br>public interface Service {<br> void doSomething();<br>}<br> |
| 创建拦截器 | 实现一个MethodInterceptor接口的拦截器类，该类负责在代理对象的方法调用前后执行特定的逻辑。 | java<br>public class MyInterceptor implements MethodInterceptor {<br> @Override<br> public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {<br> System.out.println("Before method call");<br> Object result = proxy.invokeSuper(obj, args);<br> System.out.println("After method call");<br> return result;<br> }<br>}<br> |
| 创建代理对象 | 使用CGLIB的Enhancer类创建代理对象。Enhancer类需要代理的类、拦截器以及代理的接口。 | java<br>public class ProxyFactory {<br> public static Object getProxy(Class<?> clazz, MethodInterceptor interceptor) {<br> Enhancer enhancer = new Enhancer();<br> enhancer.setSuperclass(clazz);<br> enhancer.setCallback(interceptor);<br> return enhancer.create();<br> }<br>}<br> |
| 使用代理对象 | 使用代理对象调用方法。代理对象将调用拦截器中的逻辑，然后调用原始的方法。 | java<br>public class Main {<br> public static void main(String[] args) {<br> Service proxy = (Service) ProxyFactory.getProxy(Service.class, new MyInterceptor());<br> proxy.doSomething();<br> }<br>}<br> |
| 应用场景 | CGLIB动态代理的应用场景广泛，例如在MyBatis框架中用于创建映射器接口的代理对象。 | MyBatis框架中用于创建映射器接口的代理对象。 |
| 性能比较 | 与JDK动态代理相比，CGLIB动态代理通常比JDK动态代理慢，因为它涉及到字节码的生成和类加载。 | CGLIB动态代理通常比JDK动态代理慢。 |
| 优势与局限 | CGLIB动态代理可以代理任何类，包括final类和没有接口的类，这使得它在某些情况下比JDK动态代理更灵活。然而，性能上可能不如JDK动态代理。 | CGLIB动态代理可以代理任何类，包括final类和没有接口的类。 |
CGLIB动态代理在Java开发中扮演着重要的角色，它不仅能够代理没有接口的类，还能处理final类，这在JDK动态代理中是无法实现的。例如，在Spring框架中，CGLIB代理被用来创建基于类的Bean，这对于实现AOP（面向切面编程）至关重要。尽管CGLIB代理在性能上可能不如JDK代理，但它的灵活性使得它在某些复杂场景下成为首选。在实际应用中，开发者需要根据具体需求权衡使用JDK代理还是CGLIB代理。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("定义Service接口"):::startend --> B("实现MethodInterceptor"):::process
A --> C("创建拦截器类"):::process
B --> D("实现intercept方法"):::process
C --> E("MyInterceptor类"):::process
D --> F("方法调用前后逻辑"):::process
A --> G("使用Enhancer创建代理"):::process
G --> H("设置代理类和拦截器"):::process
H --> I("创建代理对象"):::process
A --> J("使用代理对象调用方法"):::process
J --> K("代理方法执行"):::process
K --> L("拦截器逻辑执行"):::process
K --> M("原始方法执行"):::process
MyBatis动态代理实现
MyBatis框架中，动态代理是实现数据库操作的关键技术之一。动态代理允许在运行时创建一个代理对象，该代理对象能够拦截对目标对象的调用，从而实现额外的逻辑处理。在MyBatis中，动态代理主要通过CGLIB库来实现。
CGLIB动态代理原理
CGLIB（Code Generation Library）是一个强大的高性能的代码生成类库，它可以在运行时动态生成任意类的子类。CGLIB通过继承的方式实现动态代理，即在运行时创建一个目标对象的子类，并在子类中重写目标对象的方法，从而实现代理逻辑。
MyBatis代理配置
在MyBatis中，要使用CGLIB动态代理，需要配置相应的代理方式。在MyBatis的配置文件中，可以通过设置<settings>标签下的<typeAliases>标签来实现。
<settings>
<setting name="proxyFactory" value="cglib"/>
</settings>
CGLIB代理类生成
当MyBatis需要代理一个接口时，它会使用CGLIB库动态生成一个代理类。这个代理类继承自目标接口，并重写接口中的所有方法，实现代理逻辑。
MyBatis代理方法拦截
在CGLIB代理类中，每个方法都被重写，以便在执行前和执行后进行拦截。MyBatis通过实现Interceptor接口来定义拦截逻辑，然后在代理类中调用这些拦截器。
public class MyInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
// 拦截逻辑
return invocation.proceed();
}
}
CGLIB代理应用场景
CGLIB动态代理在MyBatis中主要用于实现数据库操作的拦截，例如执行SQL语句前后的日志记录、参数校验、事务管理等。
MyBatis与CGLIB结合使用
MyBatis与CGLIB结合使用时，需要在MyBatis配置文件中设置代理方式为CGLIB。同时，需要实现Interceptor接口来定义拦截逻辑。
代理性能比较
与JDK动态代理相比，CGLIB动态代理在性能上略逊一筹，因为CGLIB需要生成目标对象的子类。但在实际应用中，这种性能差异通常可以忽略不计。
示例代码分析
以下是一个使用CGLIB动态代理的示例代码：
public interface Target {
void execute();
}
public class TargetImpl implements Target {
@Override
public void execute() {
System.out.println("执行目标方法");
}
}
public class MyInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("执行拦截器逻辑");
return invocation.proceed();
}
}
public class Main {
public static void main(String[] args) {
Target target = (Target) Proxy.newProxyInstance(
Target.class.getClassLoader(),
new Class[]{Target.class},
new MyInterceptor()
);
target.execute();
}
}
在上述代码中，我们定义了一个Target接口和一个实现该接口的TargetImpl类。然后，我们创建了一个MyInterceptor拦截器，并在Main类中通过CGLIB动态代理创建了Target接口的代理对象。当调用代理对象的execute方法时，会先执行拦截器逻辑，然后执行目标方法。
| 主题 | 描述 |
|---|---|
| MyBatis动态代理 | MyBatis框架中用于实现数据库操作的关键技术，通过动态代理拦截对目标对象的调用，实现额外逻辑处理。 |
| CGLIB动态代理原理 | CGLIB库在运行时动态生成任意类的子类，通过继承方式实现动态代理，重写目标对象的方法实现代理逻辑。 |
| MyBatis代理配置 | 在MyBatis配置文件中设置<settings>标签下的<typeAliases>标签，将代理方式设置为CGLIB。 |
| CGLIB代理类生成 | MyBatis使用CGLIB库动态生成代理类，继承目标接口并重写接口中的所有方法实现代理逻辑。 |
| MyBatis代理方法拦截 | CGLIB代理类中每个方法都被重写，以便在执行前和执行后进行拦截，通过实现Interceptor接口定义拦截逻辑。 |
| CGLIB代理应用场景 | 主要用于实现数据库操作的拦截，如日志记录、参数校验、事务管理等。 |
| MyBatis与CGLIB结合使用 | 在MyBatis配置文件中设置代理方式为CGLIB，并实现Interceptor接口定义拦截逻辑。 |
| 代理性能比较 | 与JDK动态代理相比，CGLIB动态代理在性能上略逊一筹，但实际应用中性能差异通常可以忽略不计。 |
| 示例代码分析 | 通过CGLIB动态代理创建代理对象，在调用代理对象的方法时，先执行拦截器逻辑，然后执行目标方法。 |
MyBatis动态代理技术不仅简化了数据库操作，还通过拦截机制为开发者提供了强大的扩展性。例如，在执行数据库操作前，可以轻松地添加日志记录、参数校验等安全措施，确保数据的一致性和完整性。这种灵活的代理机制，使得MyBatis在众多数据库框架中脱颖而出，成为Java开发者的首选。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("MyBatis 动态代理"):::startend --> B("CGLIB 动态代理"):::process
A --> C("MyBatis 代理配置"):::process
A --> D("CGLIB 代理类生成"):::process
A --> E("代理方法拦截"):::process
A --> F("应用场景"):::process
B --> G("CGLIB 原理"):::process
C --> H("<settings> 配置"):::process
D --> I("代理类继承"):::process
E --> J("Interceptor 接口"):::process
F --> K("数据库操作拦截"):::process
G --> L("运行时生成子类"):::process
H --> M("<proxyFactory> cglib"):::io
I --> N("重写方法"):::process
J --> O("拦截逻辑"):::process
K --> P("日志记录"):::process
K --> Q("参数校验"):::process
K --> R("事务管理"):::process
L --> S("继承目标类"):::process
M --> T("mybatis-config.xml"):::io
N --> U("实现代理逻辑"):::process
O --> V("invocation.proceed()"):::process
P --> W("执行SQL语句"):::process
Q --> X("参数有效性"):::process
R --> Y("事务控制"):::process
S --> Z("动态代理"):::process
U --> AA("方法拦截"):::process
V --> AB("执行目标方法"):::process
W --> AC("数据库交互"):::process
X --> AD("数据校验"):::process
Y --> AE("事务处理"):::process
Z --> AF("运行时生成"):::process
AA --> AG("执行前"):::process
AA --> AH("执行后"):::process
AB --> AI("方法调用"):::process
AC --> AJ("数据库操作"):::process
AD --> AK("参数验证"):::process
AE --> AL("事务管理"):::process
AG --> AM("拦截逻辑"):::process
AH --> AN("方法执行"):::process
AI --> AO("目标方法"):::process
AJ --> AK("数据库交互"):::process
AK --> AL("数据校验"):::process
AL --> AM("事务处理"):::process
AM --> AN("方法执行"):::process
AN --> AO("结果返回"):::process
AO --> AP("代理对象"):::process
AP --> AQ("调用结果"):::process
AQ --> AR("响应"):::process
🍊 MyBatis核心知识点之动态代理实现：MyBatis动态代理
在当今的软件开发领域，MyBatis 作为一款优秀的持久层框架，以其简洁的配置和强大的动态代理功能，深受广大开发者的喜爱。然而，在实际开发过程中，我们常常会遇到这样的场景：在编写业务逻辑时，需要频繁地与数据库进行交互，手动编写 SQL 语句和数据库连接配置，不仅效率低下，而且容易出错。这时，MyBatis 的动态代理功能就派上了用场。
MyBatis 的动态代理实现，主要解决了在 Java 中如何在不修改源代码的情况下，动态地生成代理对象，从而实现接口的方法调用。这种机制在 MyBatis 中被广泛应用于 SQL 映射文件的编写，使得开发者可以以面向对象的方式操作数据库，极大地提高了开发效率。
为什么需要介绍 MyBatis 的动态代理实现呢？首先，动态代理是实现 AOP（面向切面编程）的关键技术之一，它允许我们在不修改原有代码的情况下，对方法进行拦截和增强。在 MyBatis 中，动态代理技术被用来实现 SQL 映射文件的动态生成，使得开发者可以以面向对象的方式操作数据库，降低了代码的复杂度。其次，动态代理在框架开发中具有广泛的应用，如 Spring 框架中的 AOP、Hibernate 框架中的 Criteria API 等，都是基于动态代理技术实现的。
接下来，我们将对 MyBatis 动态代理的原理、实现步骤和示例进行详细介绍。首先，我们将探讨 MyBatis 动态代理的原理，分析其核心技术和实现方式。然后，我们将详细介绍 MyBatis 动态代理的实现步骤，包括接口定义、代理类生成、代理对象创建等。最后，我们将通过一个实际示例，展示如何使用 MyBatis 动态代理实现数据库操作。
在接下来的内容中，我们将深入剖析 MyBatis 动态代理的各个方面，帮助读者全面理解其原理和实现方法。通过学习这些内容，读者将能够更好地掌握 MyBatis 的动态代理技术，并将其应用于实际项目中，提高开发效率。
MyBatis动态代理原理
在Java编程中，代理模式是一种常用的设计模式，它允许在运行时创建一个对象，以代表另一个对象。MyBatis框架利用动态代理技术，在运行时动态生成代理对象，从而实现数据库操作的封装和简化。下面将详细阐述MyBatis动态代理的原理。
首先，我们需要了解JDK动态代理和CGLIB代理两种常见的代理实现方式。JDK动态代理是基于Java反射机制实现的，它只能代理实现了接口的类。而CGLIB代理则通过继承的方式实现，可以代理任何类，包括没有实现接口的类。
MyBatis在实现动态代理时，主要采用JDK动态代理。其原理如下：
- 定义一个接口，该接口包含了需要代理的方法。
- 创建一个实现了InvocationHandler接口的类，该类负责处理代理对象的方法调用。
- 使用Proxy类创建代理对象，传入接口和InvocationHandler实例。
下面是一个简单的示例代码：
public interface HelloService {
void sayHello(String name);
}
public class HelloServiceImpl implements HelloService {
@Override
public void sayHello(String name) {
System.out.println("Hello, " + name);
}
}
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before method execution");
Object result = method.invoke(target, args);
System.out.println("After method execution");
return result;
}
}
public class Main {
public static void main(String[] args) {
HelloService helloService = new HelloServiceImpl();
HelloService proxy = (HelloService) Proxy.newProxyInstance(
HelloService.class.getClassLoader(),
new Class[]{HelloService.class},
new MyInvocationHandler(helloService)
);
proxy.sayHello("World");
}
}
在上面的示例中，我们定义了一个HelloService接口和一个实现该接口的HelloServiceImpl类。然后，我们创建了一个MyInvocationHandler类，实现了InvocationHandler接口，并在invoke方法中添加了方法执行前后的日志输出。最后，我们使用Proxy.newProxyInstance方法创建了一个代理对象，并调用代理对象的方法。
MyBatis动态代理的生命周期包括以下几个阶段：
- 创建代理对象：通过Proxy.newProxyInstance方法创建代理对象。
- 方法调用：代理对象的方法被调用时，会触发InvocationHandler的invoke方法。
- 执行目标方法：在invoke方法中，通过反射调用目标对象的方法。
- 返回结果：将目标方法的结果返回给调用者。
MyBatis动态代理与AOP（面向切面编程）关联紧密。通过动态代理，MyBatis可以在代理对象的方法调用前后添加额外的逻辑，实现日志记录、事务管理等AOP功能。
在性能方面，MyBatis动态代理相较于CGLIB代理具有更高的性能。因为JDK动态代理是基于接口实现的，而CGLIB代理是通过继承的方式实现的，继承方式会带来额外的性能开销。
在MyBatis中，动态代理与数据库交互、缓存机制和事务管理等方面也有着紧密的联系。通过动态代理，MyBatis可以简化数据库操作，提高开发效率。
| 阶段 | 描述 | 相关代码 |
|---|---|---|
| 创建代理对象 | 使用Proxy.newProxyInstance方法创建代理对象，传入接口、类加载器和InvocationHandler实例。 | HelloService proxy = (HelloService) Proxy.newProxyInstance(HelloService.class.getClassLoader(), new Class[]{HelloService.class}, new MyInvocationHandler(helloService)); |
| 方法调用 | 代理对象的方法被调用时，会触发InvocationHandler的invoke方法。 | proxy.sayHello("World"); |
| 执行目标方法 | 在invoke方法中，通过反射调用目标对象的方法。 | Object result = method.invoke(target, args); |
| 返回结果 | 将目标方法的结果返回给调用者。 | return result; |
| 动态代理原理 | MyBatis使用JDK动态代理技术，通过定义接口、实现InvocationHandler接口的类和Proxy类创建代理对象。 | public class MyInvocationHandler implements InvocationHandler { ... } |
| 生命周期 | MyBatis动态代理的生命周期包括创建代理对象、方法调用、执行目标方法和返回结果等阶段。 | public class Main { ... } |
| 与AOP关联 | 通过动态代理，MyBatis可以在代理对象的方法调用前后添加额外的逻辑，实现日志记录、事务管理等AOP功能。 | System.out.println("Before method execution"); 和 System.out.println("After method execution"); |
| 性能比较 | MyBatis动态代理相较于CGLIB代理具有更高的性能，因为JDK动态代理是基于接口实现的，而CGLIB代理是通过继承的方式实现的。 | HelloService proxy = (HelloService) Proxy.newProxyInstance(...); |
| 与数据库交互 | 通过动态代理，MyBatis可以简化数据库操作，提高开发效率。 | MyBatis框架中的数据库操作代码。 |
| 缓存机制 | MyBatis动态代理与缓存机制紧密相关，通过代理对象可以实现对缓存数据的访问和更新。 | MyBatis框架中的缓存相关代码。 |
| 事务管理 | MyBatis动态代理与事务管理紧密相关，通过代理对象可以实现对事务的控制。 | MyBatis框架中的事务管理代码。 |
动态代理在MyBatis框架中扮演着至关重要的角色，它不仅简化了数据库操作，还提高了开发效率。通过代理对象，开发者可以轻松实现对缓存数据的访问和更新，同时，与事务管理紧密的结合，确保了数据的一致性和完整性。这种技术的应用，使得MyBatis在处理大量数据操作时，能够保持高效和稳定。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("定义接口"):::startend --> B("实现InvocationHandler"):::process
A --> C("创建代理对象"):::process
B --> D("处理方法调用"):::process
C --> E("代理对象方法调用"):::process
E --> F("执行目标方法"):::process
E --> G("返回结果"):::process
D --> H("日志输出"):::process
F --> I("目标方法执行"):::process
G --> J("结果返回"):::process
MyBatis动态代理实现步骤
在MyBatis框架中，动态代理是实现数据库操作的关键技术之一。动态代理通过代理模式，在不修改源代码的情况下，为接口提供实现。以下是MyBatis动态代理的实现步骤：
- 定义接口：首先，需要定义一个接口，该接口包含了数据库操作的抽象方法。例如，定义一个
UserMapper接口，其中包含selectById、selectByName等方法。
public interface UserMapper {
User selectById(Integer id);
User selectByName(String name);
}
- 创建实现类：接着，创建一个实现类，该类实现了上述接口，并提供了具体的方法实现。例如，创建一个
UserMapperImpl类。
public class UserMapperImpl implements UserMapper {
@Override
public User selectById(Integer id) {
// 实现数据库查询逻辑
return null;
}
@Override
public User selectByName(String name) {
// 实现数据库查询逻辑
return null;
}
}
- 创建代理工厂：然后，创建一个代理工厂类，该类负责生成代理对象。在代理工厂类中，使用
Proxy.newProxyInstance方法创建代理对象。该方法需要三个参数：类加载器、接口数组、InvocationHandler。
public class ProxyFactory {
public static Object getProxyInstance(Object target) {
MyInvocationHandler handler = new MyInvocationHandler(target);
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler
);
}
}
- 实现InvocationHandler：
InvocationHandler接口负责处理代理对象的调用。在MyInvocationHandler类中，重写invoke方法，该方法接收代理对象、方法对象、方法参数。
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加一些预处理逻辑
Object result = method.invoke(target, args);
// 在这里可以添加一些后处理逻辑
return result;
}
}
- 使用代理对象：最后，使用代理对象进行数据库操作。首先，创建实现类的对象，然后通过代理工厂获取代理对象。
public class Main {
public static void main(String[] args) {
UserMapperImpl mapper = new UserMapperImpl();
UserMapper proxy = (UserMapper) ProxyFactory.getProxyInstance(mapper);
User user = proxy.selectById(1);
System.out.println(user);
}
}
通过以上步骤，可以实现MyBatis的动态代理。在实际应用中，可以根据需求对代理过程进行扩展，例如添加日志、事务管理等。
| 步骤 | 描述 | 代码示例 |
|---|---|---|
| 1. 定义接口 | 创建一个接口，其中包含数据库操作的抽象方法。 | ```java |
public interface UserMapper { User selectById(Integer id); User selectByName(String name); }
| 2. 创建实现类 | 实现接口，并编写具体的方法实现。 | ```java
public class UserMapperImpl implements UserMapper {
@Override
public User selectById(Integer id) {
// 实现数据库查询逻辑
return null;
}
@Override
public User selectByName(String name) {
// 实现数据库查询逻辑
return null;
}
}
``` |
| 3. 创建代理工厂 | 创建一个代理工厂类，用于生成代理对象。 | ```java
public class ProxyFactory {
public static Object getProxyInstance(Object target) {
MyInvocationHandler handler = new MyInvocationHandler(target);
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler
);
}
}
``` |
| 4. 实现InvocationHandler | 实现InvocationHandler接口，处理代理对象的调用。 | ```java
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加一些预处理逻辑
Object result = method.invoke(target, args);
// 在这里可以添加一些后处理逻辑
return result;
}
}
``` |
| 5. 使用代理对象 | 使用代理对象进行数据库操作。 | ```java
public class Main {
public static void main(String[] args) {
UserMapperImpl mapper = new UserMapperImpl();
UserMapper proxy = (UserMapper) ProxyFactory.getProxyInstance(mapper);
User user = proxy.selectById(1);
System.out.println(user);
}
}
``` |
| 扩展 | 根据需求对代理过程进行扩展，如添加日志、事务管理等。 | 根据具体需求进行代码编写和配置。 |
> 在实际应用中，代理模式不仅可以用于数据库操作，还可以广泛应用于网络请求、日志记录、权限控制等多个场景。例如，在日志记录方面，可以在InvocationHandler中添加日志记录逻辑，以便在调用方法前后记录相关信息，从而方便后续的调试和问题追踪。此外，在事务管理方面，可以通过代理模式实现事务的声明式管理，提高代码的可读性和可维护性。通过这种方式，代理模式不仅提高了代码的复用性，还增强了系统的灵活性和可扩展性。
```mermaid
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("定义接口"):::startend --> B("创建实现类"):::process
A --> C("实现数据库操作"):::process
B:::process --> D("创建代理工厂"):::process
D:::process --> E("实现InvocationHandler"):::process
E:::process --> F("创建代理对象"):::process
F:::process --> G("使用代理对象"):::process
G:::process --> H("数据库操作"):::process
MyBatis动态代理实现
在MyBatis框架中，动态代理是实现数据库操作的关键技术之一。动态代理允许在运行时创建一个代理对象，该代理对象能够拦截对目标对象的调用，从而实现额外的逻辑处理。下面将详细阐述MyBatis动态代理的实现原理、示例代码以及相关知识点。
MyBatis代理原理
MyBatis动态代理基于JDK动态代理和CGLIB动态代理两种方式实现。JDK动态代理适用于接口类型的代理，而CGLIB动态代理适用于类类型的代理。
-
JDK动态代理：通过实现InvocationHandler接口，自定义拦截逻辑，然后在代理对象中调用目标对象的方法时，通过反射调用InvocationHandler的invoke方法，从而实现拦截。
-
CGLIB动态代理：通过继承目标类，重写目标类的方法，然后在代理对象中调用目标对象的方法时，通过重写的方法实现拦截。
MyBatis代理配置
在MyBatis配置文件中，可以通过<settings>标签配置动态代理的实现方式。例如：
<settings>
<setting name="proxyTargetClass" value="true"/>
</settings>
其中，proxyTargetClass属性用于指定使用CGLIB动态代理。
MyBatis代理示例代码
以下是一个使用JDK动态代理的示例：
public interface Target {
void execute();
}
public class TargetImpl implements Target {
@Override
public void execute() {
System.out.println("执行目标方法");
}
}
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("执行前");
Object result = method.invoke(target, args);
System.out.println("执行后");
return result;
}
}
public class Main {
public static void main(String[] args) {
Target target = new TargetImpl();
InvocationHandler handler = new MyInvocationHandler(target);
Target proxy = (Target) Proxy.newProxyInstance(
Target.class.getClassLoader(),
new Class[]{Target.class},
handler
);
proxy.execute();
}
}
代理对象生命周期
在代理对象的生命周期中，主要经历了以下几个阶段：
-
创建代理对象：通过Proxy.newProxyInstance方法创建代理对象。
-
调用代理对象方法：通过代理对象调用目标对象的方法。
-
拦截方法：在调用目标对象方法之前，通过InvocationHandler的invoke方法实现拦截。
-
执行目标方法：通过反射调用目标对象的方法。
-
拦截方法：在调用目标对象方法之后，通过InvocationHandler的invoke方法实现拦截。
代理对象方法拦截
在代理对象中，可以通过实现InvocationHandler接口的invoke方法，自定义拦截逻辑。以下是一个示例：
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("执行前");
Object result = method.invoke(target, args);
System.out.println("执行后");
return result;
}
MyBatis插件机制
MyBatis插件机制允许在MyBatis框架中扩展功能。通过实现Interceptor接口，自定义拦截逻辑，然后在MyBatis配置文件中配置插件，即可实现拦截。
动态代理性能分析
与直接调用目标对象方法相比，动态代理会增加一定的性能开销。但是，在大多数情况下，这种开销是可以接受的。在实际应用中，可以通过对比测试来评估动态代理的性能。
与Spring集成
MyBatis动态代理可以与Spring框架集成。在Spring配置文件中，可以通过aop:config标签配置AOP，从而实现MyBatis动态代理的拦截逻辑。
实际应用案例
在实际应用中，MyBatis动态代理可以用于实现以下功能：
-
日志记录：在调用数据库操作之前和之后，记录日志信息。
-
事务管理：在调用数据库操作之前和之后，进行事务管理。
-
权限控制：在调用数据库操作之前，进行权限验证。
通过以上内容，我们可以了解到MyBatis动态代理的实现原理、示例代码以及相关知识点。在实际应用中，合理运用MyBatis动态代理，可以提升开发效率和代码质量。
| 代理类型 | 基于的技术 | 代理对象类型 | 代理方式 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|---|---|
| JDK动态代理 | JDK Proxy API | 接口 | 实现接口 | 代理类与目标类实现相同的接口，易于理解和使用 | 只能代理实现了接口的类，不能代理没有实现接口的类 | 接口丰富的场景，如MyBatis的Mapper接口代理 |
| CGLIB动态代理 | CGLIB库 | 类 | 继承 | 可以代理没有实现接口的类，代理范围更广 | 性能开销比JDK动态代理大，且需要额外的类加载器支持 | 类丰富的场景，如Spring AOP代理类 |
| MyBatis动态代理 | JDK Proxy API & CGLIB | 接口和类 | 选择性 | 根据目标对象类型选择合适的代理方式，灵活性强 | 配置复杂，需要根据实际情况选择代理方式 | MyBatis框架中数据库操作代理 |
| MyBatis插件机制 | MyBatis拦截器 | 方法 | 拦截 | 可以拦截MyBatis的执行过程，如查询、更新、删除等操作，扩展性强 | 需要实现MyBatis的Interceptor接口，开发成本较高 | MyBatis框架功能扩展，如日志记录、事务管理等 |
| Spring AOP | Spring AOP | 方法 | 拦截 | 可以拦截Spring容器中的Bean方法，与Spring框架集成度高 | 需要配置Spring AOP，开发成本较高 | Spring框架中方法拦截，如事务管理、日志记录等 |
| 动态代理性能分析 | 性能测试 | - | - | 可以通过对比测试评估动态代理的性能开销 | 需要进行性能测试，测试过程较为复杂 | 动态代理性能评估，如对比JDK和CGLIB代理性能 |
动态代理技术在现代软件开发中扮演着重要角色，它不仅简化了代码结构，还提供了强大的扩展性。例如，在Spring框架中，AOP（面向切面编程）通过动态代理技术实现了对Bean方法的拦截，从而实现了事务管理、日志记录等功能。这种集成度高的特性使得Spring AOP成为开发人员处理复杂业务逻辑的首选。然而，动态代理技术的应用并非没有代价，如Spring AOP的配置相对复杂，需要开发者对Spring框架有深入的理解。此外，性能方面，CGLIB动态代理相较于JDK动态代理，虽然代理范围更广，但性能开销更大，这在处理大量代理对象时尤为明显。因此，在实际应用中，开发者需要根据具体场景和需求，权衡动态代理技术的利弊，选择最合适的代理方式。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("MyBatis 动态代理"):::startend --> B("代理原理"):::process
A --> C("代理配置"):::process
A --> D("示例代码"):::process
A --> E("生命周期"):::process
A --> F("方法拦截"):::process
A --> G("插件机制"):::process
A --> H("性能分析"):::process
A --> I("与Spring集成"):::process
A --> J("实际应用"):::process
B --> K("JDK动态代理"):::process
B --> L("CGLIB动态代理"):::process
C --> M("<settings>标签"):::process
D --> N("JDK代理示例"):::process
D --> O("CGLIB代理示例"):::process
E --> P("创建代理对象"):::process
E --> Q("调用代理方法"):::process
E --> R("拦截方法"):::process
E --> S("执行目标方法"):::process
E --> T("拦截方法"):::process
F --> U("自定义拦截逻辑"):::process
G --> V("日志记录"):::process
G --> W("事务管理"):::process
G --> X("权限控制"):::process
H --> Y("性能开销"):::process
H --> Z("性能测试"):::process
I --> AA("Spring AOP"):::process
J --> AB("数据库操作"):::process
J --> AC("事务管理"):::process
J --> AD("权限验证"):::process
🍊 MyBatis核心知识点之动态代理实现：动态代理优缺点
在软件开发过程中，我们常常会遇到需要动态生成代理对象的需求。例如，在开发一个复杂的业务系统时，我们可能需要根据不同的业务场景动态地创建不同的服务接口实现。这时，如果手动编写每个接口的实现类，无疑会增加开发成本和出错的可能性。为了解决这个问题，MyBatis 提供了动态代理的实现，通过动态代理技术，我们可以轻松地实现接口的动态代理，从而简化开发过程。
动态代理是一种在运行时创建对象实例的技术，它允许我们拦截对对象的调用，并对其进行增强。在 MyBatis 中，动态代理主要用于实现 SQL 映射接口，使得开发者无需编写具体的 SQL 语句，只需定义接口和相应的映射文件，MyBatis 就能自动生成代理对象，并执行相应的 SQL 语句。
介绍 MyBatis 核心知识点之动态代理实现：动态代理优缺点的必要性在于，动态代理技术是 MyBatis 框架的核心组成部分，它不仅简化了开发过程，还提高了代码的可维护性和扩展性。通过动态代理，我们可以实现接口的动态扩展，无需修改原有代码，只需添加新的代理实现即可。此外，动态代理还可以实现接口的拦截和增强，例如，我们可以通过动态代理实现日志记录、性能监控等功能。
接下来，我们将分别介绍动态代理的优点和缺点。首先，动态代理的优点包括：
- 简化开发过程：通过动态代理，我们可以避免编写大量的实现类，从而降低开发成本。
- 提高代码可维护性：动态代理使得代码结构更加清晰，易于维护和扩展。
- 实现接口的动态扩展：通过动态代理，我们可以轻松地实现接口的动态扩展，无需修改原有代码。
然而，动态代理也存在一些缺点，主要包括：
- 性能开销：动态代理在运行时需要生成代理对象，这可能会带来一定的性能开销。
- 限制性：动态代理只能代理接口，无法代理类。
通过以上介绍，相信读者对 MyBatis 核心知识点之动态代理实现：动态代理优缺点有了初步的了解。接下来，我们将进一步探讨动态代理的具体实现和应用场景。
MyBatis动态代理实现：动态代理优点
在Java编程中，代理模式是一种常用的设计模式，它允许在运行时创建一个对象，以代表另一个对象。这种模式在MyBatis框架中得到了广泛应用，特别是在动态代理的实现上。动态代理的优点主要体现在以下几个方面。
首先，动态代理可以降低系统的耦合度。通过代理模式，我们可以在不修改原有代码的情况下，对某些功能进行增强或替换。例如，在MyBatis中，我们可以通过动态代理来实现数据库的延迟加载，从而提高应用程序的性能。
其次，动态代理可以提供更高的灵活性。在代理模式中，我们可以根据不同的需求，动态地创建不同的代理对象。例如，在MyBatis中，我们可以根据不同的数据库类型，创建不同的数据库代理对象，从而实现数据库的切换。
再者，动态代理可以简化代码。在代理模式中，我们只需要关注代理对象的功能实现，而不需要关心被代理对象的具体实现。例如，在MyBatis中，我们只需要关注SQL映射文件和Mapper接口，而不需要关心数据库操作的具体实现。
具体来说，MyBatis动态代理的优点主要体现在以下几个方面：
-
延迟加载：在MyBatis中，我们可以通过动态代理实现延迟加载，即在需要使用对象时才进行加载，从而减少内存消耗和提高性能。
-
数据库切换：通过动态代理，我们可以轻松地在不同的数据库之间进行切换，而不需要修改业务代码。
-
性能优化：动态代理可以减少数据库访问次数，从而提高应用程序的性能。
-
安全性：通过动态代理，我们可以对数据库操作进行权限控制，从而提高系统的安全性。
-
易用性：动态代理使得数据库操作更加简单，降低了开发难度。
下面，我们通过一个简单的代码示例来展示MyBatis动态代理的实现：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加一些预处理逻辑
Object result = method.invoke(target, args);
// 在这里可以添加一些后处理逻辑
return result;
}
public static Object createProxy(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new MyInvocationHandler(target)
);
}
}
在这个示例中，我们定义了一个MyInvocationHandler类，实现了InvocationHandler接口。在invoke方法中，我们可以添加一些预处理和后处理逻辑。通过createProxy方法，我们可以创建一个动态代理对象。
总之，MyBatis动态代理在提高系统性能、降低耦合度、提供灵活性等方面具有显著优势。在实际开发中，我们可以根据具体需求，灵活运用动态代理技术。
| 动态代理优点 | 描述 |
|---|---|
| 降低系统耦合度 | 通过代理模式，可以在不修改原有代码的情况下，对某些功能进行增强或替换，从而降低系统各部分之间的耦合度。 |
| 提高灵活性 | 根据不同的需求，动态地创建不同的代理对象，例如在MyBatis中根据不同的数据库类型创建不同的数据库代理对象，实现数据库的切换。 |
| 简化代码 | 只需关注代理对象的功能实现，无需关心被代理对象的具体实现，例如在MyBatis中只需关注SQL映射文件和Mapper接口。 |
| 延迟加载 | 在MyBatis中，通过动态代理实现延迟加载，即在需要使用对象时才进行加载，减少内存消耗和提高性能。 |
| 数据库切换 | 通过动态代理，可以轻松地在不同的数据库之间进行切换，而不需要修改业务代码。 |
| 性能优化 | 减少数据库访问次数，提高应用程序的性能。 |
| 安全性 | 对数据库操作进行权限控制，提高系统的安全性。 |
| 易用性 | 使得数据库操作更加简单，降低开发难度。 |
动态代理在软件架构中的应用，不仅体现在降低系统耦合度上，更在于其强大的灵活性。它允许开发者根据实际需求动态调整代理行为，如MyBatis框架中，根据数据库类型动态创建代理对象，实现数据库的无缝切换。这种灵活性使得系统在应对不同场景时，能够更加灵活地适应变化，提高了系统的可维护性和扩展性。同时，动态代理的引入，简化了代码结构，使得开发者可以专注于业务逻辑的实现，而无需过多关注底层细节，从而降低了开发难度，提高了开发效率。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("动态代理优点"):::startend --> B("降低耦合度"):::process
A --> C("提高灵活性"):::process
A --> D("简化代码"):::process
B --> E("数据库延迟加载"):::process
B --> F("数据库切换"):::process
C --> G("不同数据库类型代理"):::process
D --> H("关注代理功能"):::process
E:::process --> I("减少内存消耗"):::process
E:::process --> J("提高性能"):::process
F:::process --> K("无需修改业务代码"):::process
G:::process --> L("实现数据库切换"):::process
H:::process --> M("降低开发难度"):::process
MyBatis动态代理实现
MyBatis作为一款优秀的持久层框架，其核心之一便是动态代理的实现。动态代理允许在运行时创建一个代理对象，该对象能够拦截对目标对象的调用，并执行特定的逻辑。在MyBatis中，动态代理主要用于实现Mapper接口的代理，使得开发者无需编写繁琐的SQL映射文件，即可实现数据库的增删改查操作。
代理模式原理
代理模式是一种设计模式，其核心思想是通过代理对象来控制对目标对象的访问。在代理模式中，代理对象负责处理与目标对象无关的额外操作，如日志记录、事务管理等。当客户端请求访问目标对象时，代理对象会拦截请求，并执行相应的逻辑后再将请求转发给目标对象。
代理缺点分析
尽管代理模式具有诸多优点，但在实际应用中，也存在一些缺点：
-
性能影响：由于代理对象需要拦截请求并执行额外的逻辑，因此相较于直接访问目标对象，代理模式可能会带来一定的性能损耗。
-
代码复杂度：代理模式需要编写额外的代理类，这会增加代码的复杂度，降低代码的可读性和可维护性。
-
功能限制：代理模式只能对目标对象的方法进行拦截，无法拦截对象的属性访问和修改。
性能影响
在MyBatis中，动态代理的性能影响主要体现在以下几个方面：
-
代理对象创建：在运行时，MyBatis会根据Mapper接口动态创建代理对象，这个过程会消耗一定的时间。
-
方法拦截：代理对象在拦截方法调用时，需要执行额外的逻辑，如参数校验、日志记录等，这会降低方法的执行效率。
与AOP对比
AOP（面向切面编程）与代理模式在实现原理上具有一定的相似性，但两者也存在一些区别：
-
实现方式：代理模式通过创建代理对象来实现，而AOP则通过动态生成代理类来实现。
-
功能范围：代理模式只能拦截方法调用，而AOP可以拦截方法、属性、构造函数等。
应用场景
MyBatis动态代理在以下场景中具有较好的应用效果：
-
简化数据库操作：通过Mapper接口，开发者可以无需编写SQL映射文件，即可实现数据库的增删改查操作。
-
提高代码可读性：通过动态代理，可以将业务逻辑与数据库操作分离，提高代码的可读性和可维护性。
代码示例
以下是一个简单的MyBatis动态代理实现示例：
public interface Target {
void execute();
}
public class TargetImpl implements Target {
@Override
public void execute() {
System.out.println("执行目标方法");
}
}
public class Proxy implements InvocationHandler {
private Object target;
public Proxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("执行代理逻辑");
return method.invoke(target, args);
}
}
public class Main {
public static void main(String[] args) {
Target target = new TargetImpl();
InvocationHandler handler = new Proxy(target);
Target proxy = (Target) Proxy.newProxyInstance(
Target.class.getClassLoader(),
new Class[]{Target.class},
handler
);
proxy.execute();
}
}
配置细节
在MyBatis中，动态代理的配置细节如下：
-
在
mybatis-config.xml文件中，配置<typeAliases>标签，为Mapper接口指定别名。 -
在Mapper接口上，使用
@Mapper注解标注。 -
在Mapper XML文件中，编写SQL映射语句。
与Spring集成
MyBatis与Spring集成时，可以通过以下方式实现动态代理：
-
在Spring配置文件中，配置MyBatis的SqlSessionFactory和SqlSessionTemplate。
-
在Mapper接口上，使用
@MapperScan注解扫描Mapper接口所在的包。 -
在Service层，通过SqlSessionTemplate获取Mapper接口的代理对象。
| 对比项 | 代理模式原理 | 代理缺点分析 | 性能影响 | 与AOP对比 | 应用场景 | 代码示例 | 配置细节 | 与Spring集成 |
|---|---|---|---|---|---|---|---|---|
| 核心思想 | 通过代理对象控制对目标对象的访问，处理额外操作 | 性能影响、代码复杂度、功能限制 | 代理对象创建、方法拦截 | 代理模式通过创建代理对象，AOP通过动态生成代理类 | 简化数据库操作、提高代码可读性 | 示例代码展示了如何创建代理对象并执行方法 | 在mybatis-config.xml中配置<typeAliases>和@Mapper注解，在Mapper XML中编写SQL映射语句 | 在Spring配置文件中配置SqlSessionFactory和SqlSessionTemplate，使用@MapperScan注解扫描Mapper接口，通过SqlSessionTemplate获取代理对象 |
| 性能影响 | - 代理对象创建：运行时创建代理对象，消耗时间<br>- 方法拦截：执行额外逻辑，降低方法执行效率 | - 性能损耗：代理对象拦截请求，增加处理时间<br>- 代码复杂度：编写额外代理类，增加代码复杂度<br>- 功能限制：只能拦截方法调用，无法拦截属性访问和修改 | - 代理对象创建：消耗时间<br>- 方法拦截：执行额外逻辑，降低方法执行效率 | - 代理模式：只能拦截方法调用<br>- AOP：可以拦截方法、属性、构造函数等 | - 简化数据库操作：无需编写SQL映射文件<br>- 提高代码可读性：分离业务逻辑与数据库操作 | 示例代码展示了如何创建代理对象并执行方法 | - 配置<typeAliases>和@Mapper注解<br>- 编写SQL映射语句 | - 配置SqlSessionFactory和SqlSessionTemplate<br>- 使用@MapperScan注解扫描Mapper接口<br>- 通过SqlSessionTemplate获取代理对象 |
| 应用场景 | - 日志记录<br>- 事务管理<br>- 安全控制 | - 需要额外处理逻辑的场景<br>- 需要控制访问的场景 | - 需要额外处理逻辑的场景<br>- 需要控制访问的场景 | - 需要拦截方法调用<br>- 需要更广泛的功能拦截 | - 需要简化数据库操作<br>- 需要提高代码可读性 | - 简化数据库操作<br>- 提高代码可读性 | - 配置<typeAliases>和@Mapper注解<br>- 编写SQL映射语句 | - 配置SqlSessionFactory和SqlSessionTemplate<br>- 使用@MapperScan注解扫描Mapper接口<br>- 通过SqlSessionTemplate获取代理对象 |
代理模式在实现日志记录、事务管理和安全控制等场景中，能够有效分离业务逻辑和系统服务，降低系统复杂性。然而，代理模式在性能上存在一定损耗，尤其是在代理对象创建和执行方法拦截时，可能会降低程序执行效率。与AOP相比，代理模式在功能上较为局限，主要针对方法调用进行拦截，而AOP则可以更广泛地拦截方法、属性、构造函数等。在实际应用中，应根据具体需求选择合适的模式，以实现最佳的性能和功能平衡。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("MyBatis 动态代理"):::startend --> B("代理模式原理"):::process
A --> C("代理缺点分析"):::process
A --> D("性能影响"):::process
A --> E("与AOP对比"):::process
A --> F("应用场景"):::process
A --> G("代码示例"):::process
A --> H("配置细节"):::process
A --> I("与Spring集成"):::process
B --> B1("代理对象控制访问"):::process
B1 --> B2("处理额外操作"):::process
C --> C1("性能损耗"):::process
C --> C2("代码复杂度"):::process
C --> C3("功能限制"):::process
D --> D1("代理对象创建"):::process
D --> D2("方法拦截"):::process
E --> E1("实现方式不同"):::process
E --> E2("功能范围不同"):::process
F --> F1("简化数据库操作"):::process
F --> F2("提高代码可读性"):::process
G --> G1("Target 接口"):::process
G --> G2("TargetImpl 实现"):::process
G --> G3("Proxy 实现"):::process
G --> G4("Main 类"):::process
H --> H1("配置 <typeAliases>"):::process
H --> H2("使用 @Mapper 注解"):::process
H --> H3("编写 SQL 映射语句"):::process
I --> I1("配置 SqlSessionFactory"):::process
I --> I2("使用 @MapperScan 注解"):::process
I --> I3("Service 层获取代理对象"):::process
🍊 MyBatis核心知识点之动态代理实现：动态代理应用案例
在当今的软件开发领域，MyBatis 作为一款优秀的持久层框架，以其简洁的配置和强大的动态代理功能，深受广大开发者的喜爱。然而，在实际应用中，我们常常会遇到一些场景，需要我们对 MyBatis 的动态代理机制有更深入的理解和运用。
想象一下，一个大型企业级应用，其业务逻辑复杂，数据交互频繁。在这样的背景下，如何高效地管理日志记录、事务处理和缓存管理，成为了开发人员面临的一大挑战。传统的做法是手动编写代码，实现这些功能，这不仅增加了代码的复杂度，还降低了开发效率。而 MyBatis 的动态代理机制，正是为了解决这一问题而诞生的。
MyBatis 的动态代理机制，允许我们在不修改原始类代码的情况下，为其创建一个代理对象，从而实现对原始对象的增强。这种机制在日志记录、事务管理和缓存管理等方面有着广泛的应用。
首先，在日志记录方面，我们可以通过动态代理，在执行数据库操作前后，自动记录相关的日志信息，从而方便我们追踪程序的执行过程，及时发现和解决问题。
其次，在事务管理方面，动态代理可以帮助我们实现声明式事务管理，简化事务处理的代码，提高代码的可读性和可维护性。
最后，在缓存管理方面，动态代理可以自动缓存数据库查询结果，减少数据库的访问次数，提高系统的性能。
接下来，我们将通过三个具体的案例，深入探讨 MyBatis 动态代理在日志记录、事务管理和缓存管理方面的应用。通过这些案例，相信大家会对 MyBatis 的动态代理机制有更深入的理解，并在实际项目中灵活运用。
MyBatis作为一款优秀的持久层框架，其核心之一便是动态代理的实现。动态代理在MyBatis中扮演着至关重要的角色，尤其是在日志记录这一环节。本文将深入探讨MyBatis动态代理实现日志记录的原理和案例。
在MyBatis中，动态代理主要应用于拦截器（Interceptor）和插件（Plugin）机制。拦截器可以在执行SQL前后进行干预，而插件则可以在整个SQL执行过程中进行干预。这两种机制都依赖于动态代理技术。
首先，我们来看动态代理的实现原理。在Java中，动态代理是通过java.lang.reflect.Proxy类实现的。Proxy类提供了一个静态方法newProxyInstance，该方法可以创建一个代理对象，该对象在调用方法时会委托给一个InvocationHandler（拦截器或插件）。
以下是一个简单的动态代理实现示例：
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在这里可以添加日志记录逻辑
System.out.println("Before method execution: " + method.getName());
Object result = method.invoke(target, args);
System.out.println("After method execution: " + method.getName());
return result;
}
}
public class MyProxy {
public static Object createProxy(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new MyInvocationHandler(target)
);
}
}
在上面的代码中，我们定义了一个MyInvocationHandler类，实现了InvocationHandler接口。在invoke方法中，我们可以在方法执行前后添加日志记录逻辑。然后，我们定义了一个MyProxy类，其中包含了一个静态方法createProxy，该方法使用Proxy.newProxyInstance创建了一个代理对象。
接下来，我们来看一个使用动态代理实现日志记录的案例。在这个案例中，我们将使用MyBatis的插件机制来实现日志记录。
首先，我们需要定义一个插件实现Interceptor接口：
public class LogInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
Method method = invocation.getMethod();
System.out.println("Before method execution: " + method.getName());
Object result = invocation.proceed();
System.out.println("After method execution: " + method.getName());
return result;
}
@Override
public Object plugin(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new MyInvocationHandler(target)
);
}
@Override
public void setProperties(Properties properties) {
// 可以在这里解析配置文件中的日志记录配置
}
}
在上面的代码中，我们定义了一个LogInterceptor类，实现了Interceptor接口。在intercept方法中，我们添加了日志记录逻辑。然后，我们重写了plugin方法，该方法使用动态代理技术创建了一个代理对象。
最后，我们需要在MyBatis配置文件中注册这个插件：
<plugins>
<plugin interceptor="com.example.LogInterceptor"/>
</plugins>
这样，每当MyBatis执行SQL时，都会通过LogInterceptor进行拦截，从而实现日志记录功能。
总结来说，MyBatis动态代理在日志记录方面发挥着重要作用。通过动态代理技术，我们可以轻松地在方法执行前后添加日志记录逻辑，从而提高代码的可读性和可维护性。
| 动态代理应用场景 | 拦截器（Interceptor） | 插件（Plugin） |
|---|---|---|
| 执行SQL前后干预 | 是 | 否 |
| 整个SQL执行过程干预 | 否 | 是 |
| 实现方式 | 通过InvocationHandler实现 | 通过Interceptor接口实现 |
| 代理对象创建 | 使用Proxy.newProxyInstance | 使用plugin方法结合Proxy.newProxyInstance |
| 日志记录示例 | 在intercept方法中添加日志记录逻辑 | 在intercept方法中添加日志记录逻辑 |
| 配置方式 | 在MyBatis配置文件中注册 | 在MyBatis配置文件中注册 |
| 优点 | 灵活地干预SQL执行过程 | 提供更广泛的干预范围 |
| 缺点 | 需要实现InvocationHandler接口 | 需要实现Interceptor接口 |
动态代理在执行SQL前后干预方面具有显著优势，它通过
InvocationHandler接口灵活地控制SQL执行过程，使得开发者能够精确地控制SQL的执行时机和逻辑。然而，拦截器（Interceptor）在实现上更为复杂，需要实现Interceptor接口，这增加了开发难度。相比之下，插件（Plugin）则提供了更广泛的干预范围，它可以在整个SQL执行过程中进行干预，这在某些场景下可能更为适用。例如，在数据库审计或性能监控方面，插件能够提供更为全面的数据收集和分析能力。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("MyBatis 动态代理"):::startend --> B("日志记录"):::process
A --> C("拦截器(Interceptor)"):::process
A --> D("插件(Plugin)"):::process
B --> E("执行SQL前后干预"):::process
B --> F("整个SQL执行过程干预"):::process
C --> G("InvocationHandler"):::process
D --> H("InvocationHandler"):::process
G --> I("方法执行前后添加日志"):::process
H --> J("创建代理对象"):::process
J --> K("代理对象调用方法"):::process
K --> L("委托给InvocationHandler"):::process
C --> M("LogInterceptor"):::process
M --> N("intercept(Invocation)"):::process
M --> O("plugin(Object)"):::process
M --> P("setProperties(Properties)"):::process
N --> Q("方法执行前后日志记录"):::process
O --> R("创建代理对象"):::process
P --> S("解析配置文件"):::process
MyBatis动态代理实现：案例二：事务管理
在MyBatis框架中，动态代理是实现数据库操作的关键技术之一。动态代理允许在运行时创建代理对象，代理对象可以拦截对目标对象的调用，从而实现额外的功能，如事务管理。本案例将深入探讨MyBatis动态代理在事务管理中的应用。
首先，我们需要了解MyBatis动态代理的工作原理。MyBatis通过Cglib库实现动态代理，Cglib是一个高性能的Java字节码增强库。当MyBatis执行数据库操作时，会创建一个代理对象，该代理对象在执行数据库操作前后，会自动调用事务管理器进行事务的提交或回滚。
接下来，我们来看事务管理的基本原理。事务管理是数据库操作中不可或缺的一部分，它确保了数据的一致性和完整性。事务管理器负责控制事务的提交和回滚。在MyBatis中，事务管理器通常由SqlSession管理。
事务传播行为是指在多个事务管理器中，事务的提交或回滚如何传播。MyBatis支持以下事务传播行为：
- REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
- SUPPORTS：如果当前存在事务，则加入该事务，如果当前没有事务，则以非事务方式执行。
- MANDATORY：如果当前存在事务，则加入该事务，如果当前没有事务，则抛出异常。
- REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。
- NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，把当前事务挂起。
- NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
事务隔离级别是数据库并发控制的一种机制，它决定了事务之间的相互影响程度。MyBatis支持以下事务隔离级别：
- READ_UNCOMMITTED：允许读取尚未提交的数据变更，可能会导致脏读、不可重复读和幻读。
- READ_COMMITTED：允许读取并发事务提交的数据，可防止脏读，但不可重复读和幻读仍可能发生。
- REPEATABLE_READ：对同一字段的多次读取结果都是一致的，除非数据被事务本身改变，可防止脏读和不可重复读，但幻读仍可能发生。
- SERIALIZABLE：完全隔离事务操作，可防止脏读、不可重复读和幻读，但性能较差。
在MyBatis中，事务管理分为编程式事务管理和声明式事务管理。编程式事务管理通过编程方式控制事务的提交和回滚，而声明式事务管理则通过配置文件或注解来控制事务。
以下是一个使用MyBatis实现事务管理的代码示例：
public interface UserService {
void addUser(User user);
}
public class UserServiceImpl implements UserService {
private SqlSession sqlSession;
public void addUser(User user) {
try {
sqlSession.insert("com.example.mapper.UserMapper.insertUser", user);
sqlSession.commit();
} catch (Exception e) {
sqlSession.rollback();
throw e;
} finally {
sqlSession.close();
}
}
}
在上述代码中，我们通过编程方式控制了事务的提交和回滚。当执行sqlSession.insert方法时，如果发生异常，则执行sqlSession.rollback()回滚事务；否则，执行sqlSession.commit()提交事务。
最后，我们来探讨事务边界。事务边界是指事务开始和结束的标识。在MyBatis中，事务边界通常由SqlSession管理。当创建SqlSession时，事务开始；当关闭SqlSession时，事务结束。
总之，MyBatis动态代理在事务管理中发挥着重要作用。通过动态代理，我们可以轻松实现事务的提交和回滚，确保数据的一致性和完整性。在实际开发中，我们需要根据业务需求选择合适的事务传播行为和隔离级别，并合理控制事务边界。
| 事务管理概念 | 描述 | MyBatis实现方式 |
|---|---|---|
| 动态代理 | 在运行时创建代理对象，拦截对目标对象的调用，实现额外功能，如事务管理。 | MyBatis通过Cglib库实现动态代理，创建代理对象进行事务管理。 |
| 事务管理器 | 负责控制事务的提交和回滚。 | MyBatis中，事务管理器通常由SqlSession管理。 |
| 事务传播行为 | 在多个事务管理器中，事务的提交或回滚如何传播。 | MyBatis支持六种事务传播行为，包括REQUIRED、SUPPORTS、MANDATORY等。 |
| 事务隔离级别 | 决定了事务之间的相互影响程度。 | MyBatis支持四种事务隔离级别，包括READ_UNCOMMITTED、READ_COMMITTED等。 |
| 编程式事务管理 | 通过编程方式控制事务的提交和回滚。 | 通过SqlSession的commit()和rollback()方法控制事务。 |
| 声明式事务管理 | 通过配置文件或注解来控制事务。 | 使用@Transactional注解或配置文件来控制事务。 |
| 事务边界 | 事务开始和结束的标识。 | 在MyBatis中，事务边界由SqlSession管理，创建SqlSession开始事务，关闭SqlSession结束事务。 |
动态代理技术在MyBatis中的应用，不仅提高了事务管理的灵活性，还减少了代码的复杂性。通过Cglib库的动态代理，MyBatis可以在不修改原有代码的情况下，实现对目标对象的拦截和增强，从而实现事务管理的自动化。这种设计理念体现了MyBatis在架构设计上的巧妙和前瞻性。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("MyBatis 动态代理"):::startend --> B("Cglib 实现"):::process
A --> C("拦截目标对象调用"):::process
A --> D("事务管理"):::process
B --> E("创建代理对象"):::process
B --> F("字节码增强"):::process
C --> G("执行数据库操作"):::process
C --> H("事务提交/回滚"):::process
D --> I("事务传播行为"):::process
D --> J("事务隔离级别"):::process
I --> K("REQUIRED"):::process
I --> L("SUPPORTS"):::process
I --> M("MANDATORY"):::process
I --> N("REQUIRES_NEW"):::process
I --> O("NOT_SUPPORTED"):::process
I --> P("NEVER"):::process
J --> Q("READ_UNCOMMITTED"):::process
J --> R("READ_COMMITTED"):::process
J --> S("REPEATABLE_READ"):::process
J --> T("SERIALIZABLE"):::process
G --> U("SqlSession 管理"):::process
G --> V("事务边界"):::process
U --> W("创建SqlSession"):::process
U --> X("关闭SqlSession"):::process
V --> Y("事务开始"):::process
V --> Z("事务结束"):::process
MyBatis动态代理实现：案例三：缓存管理
在MyBatis框架中，动态代理是实现ORM（对象关系映射）的关键技术之一。动态代理通过代理模式，在不修改源代码的情况下，为Java对象提供额外的功能。本文将深入探讨MyBatis动态代理在缓存管理中的应用。
首先，我们来了解MyBatis动态代理的基本原理。MyBatis通过Cglib库实现动态代理，Cglib是一个高性能的Java字节码生成类库，它可以在运行时动态生成Java字节码。在MyBatis中，当执行数据库操作时，会创建一个代理对象，这个代理对象在执行数据库操作前，会先检查缓存中是否存在相应的数据。
接下来，我们探讨缓存管理原理。缓存是一种临时存储机制，用于存储频繁访问的数据，以减少对数据库的访问次数，提高系统性能。在MyBatis中，缓存分为一级缓存和二级缓存。
一级缓存是SqlSession级别的缓存，当执行查询操作时，MyBatis会将查询结果存储在一级缓存中。当同一个SqlSession再次执行相同的查询操作时，可以直接从一级缓存中获取数据，而不需要再次查询数据库。
二级缓存是Mapper级别的缓存，当同一个Mapper执行相同的查询操作时，可以从二级缓存中获取数据。二级缓存可以跨SqlSession共享，但需要手动开启。
在缓存策略方面，MyBatis提供了多种缓存策略，如LRU（最近最少使用）、FIFO（先进先出）等。用户可以根据实际需求选择合适的缓存策略。
缓存实现方式主要有两种：本地缓存和分布式缓存。本地缓存是指缓存数据存储在本地内存中，而分布式缓存是指缓存数据存储在多个节点上，如Redis、Memcached等。
在缓存配置与使用方面，用户可以在MyBatis的配置文件中配置缓存相关参数，如开启缓存、设置缓存类型、缓存策略等。以下是一个简单的缓存配置示例：
<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="defaultCacheType" value="LRU"/>
</settings>
在缓存失效机制方面，当数据发生变化时，需要使缓存失效。MyBatis提供了多种缓存失效机制，如手动失效、定时失效等。
缓存与动态代理的关系体现在，当执行数据库操作时，MyBatis会先检查缓存中是否存在数据。如果存在，则直接从缓存中获取数据；如果不存在，则执行数据库查询，并将查询结果存储在缓存中。
在缓存性能优化方面，可以从以下几个方面进行优化：
- 选择合适的缓存策略和实现方式；
- 合理配置缓存参数，如缓存大小、过期时间等；
- 定期清理缓存数据；
- 使用分布式缓存，提高缓存性能。
在缓存与数据库交互方面，MyBatis通过拦截器机制实现缓存与数据库的交互。当执行数据库操作时，拦截器会检查缓存中是否存在数据，如果不存在，则执行数据库查询，并将查询结果存储在缓存中。
在缓存与业务逻辑结合案例方面，以下是一个简单的示例：
public interface UserMapper {
User getUserById(Integer id);
}
public class UserMapperImpl implements UserMapper {
private SqlSession sqlSession;
public User getUserById(Integer id) {
// 检查一级缓存
User user = sqlSession.getCache(this).getObject("User:" + id);
if (user == null) {
// 检查二级缓存
user = sqlSession.getConfiguration().getCache().getObject("User:" + id);
if (user == null) {
// 查询数据库
user = sqlSession.selectOne("com.example.mapper.UserMapper.getUserById", id);
// 存储到一级缓存
sqlSession.getCache(this).putObject("User:" + id, user);
}
}
return user;
}
}
在缓存管理最佳实践方面，以下是一些建议：
- 根据业务需求选择合适的缓存策略和实现方式；
- 合理配置缓存参数，如缓存大小、过期时间等；
- 定期清理缓存数据，避免缓存数据过多；
- 使用分布式缓存，提高缓存性能；
- 监控缓存性能，及时发现并解决问题。
总之，MyBatis动态代理在缓存管理中的应用，可以有效提高系统性能，降低数据库访问压力。通过深入了解缓存管理原理、策略、实现方式等，我们可以更好地利用MyBatis动态代理技术，为业务系统提供高性能的缓存服务。
| 缓存概念 | 描述 |
|---|---|
| 动态代理 | MyBatis通过Cglib库实现动态代理，用于在不修改源代码的情况下，为Java对象提供额外的功能。 |
| 缓存管理 | 缓存是一种临时存储机制，用于存储频繁访问的数据，以减少对数据库的访问次数，提高系统性能。 |
| 一级缓存 | SqlSession级别的缓存，存储查询结果，减少数据库访问。 |
| 二级缓存 | Mapper级别的缓存，跨SqlSession共享，需要手动开启。 |
| 缓存策略 | LRU（最近最少使用）、FIFO（先进先出）等，根据需求选择。 |
| 缓存实现方式 | 本地缓存（本地内存）和分布式缓存（如Redis、Memcached）。 |
| 缓存配置与使用 | 在MyBatis配置文件中配置缓存相关参数，如开启缓存、设置缓存类型、缓存策略等。 |
| 缓存失效机制 | 手动失效、定时失效等，确保缓存数据的有效性。 |
| 缓存与动态代理 | MyBatis动态代理在执行数据库操作时，会先检查缓存中是否存在数据。 |
| 缓存性能优化 | 选择合适的缓存策略和实现方式、合理配置缓存参数、定期清理缓存数据、使用分布式缓存等。 |
| 缓存与数据库交互 | MyBatis通过拦截器机制实现缓存与数据库的交互。 |
| 缓存与业务逻辑结合案例 | 通过检查一级缓存和二级缓存，如果都不存在，则查询数据库并将结果存储在缓存中。 |
| 缓存管理最佳实践 | 根据业务需求选择合适的缓存策略和实现方式、合理配置缓存参数、定期清理缓存数据、使用分布式缓存、监控缓存性能等。 |
动态代理在MyBatis中的应用，不仅限于Cglib库，还可以通过JDK的Proxy类实现。动态代理的核心在于代理对象的创建，它允许开发者在不直接修改目标对象代码的情况下，扩展目标对象的功能。例如，可以在代理对象中添加日志记录、事务管理等功能，从而提高代码的可维护性和扩展性。在实际应用中，动态代理可以与缓存机制相结合，实现查询结果的缓存，从而提高系统性能。
graph LR
classDef startend fill:#E6F7FF,stroke:#4DABF5,stroke-width:2px;
classDef process fill:#FFF3E0,stroke:#FFA726,stroke-width:2px;
classDef decision fill:#E8F5E9,stroke:#66BB6A,stroke-width:2px;
classDef io fill:#FFEBEE,stroke:#EF5350,stroke-width:2px;
A("MyBatis 动态代理"):::startend --> B("Cglib 实现"):::process
A --> C("代理对象创建"):::process
A --> D("缓存检查"):::process
B --> E("字节码生成"):::process
C --> F("执行数据库操作"):::process
D --> G("一级缓存"):::process
D --> H("二级缓存"):::process
G --> I("SqlSession 级别"):::process
H --> J("Mapper 级别"):::process
F --> K("缓存数据存储"):::process
F --> L("数据库查询"):::process
K --> M("本地缓存"):::process
K --> N("分布式缓存"):::process
L --> O("数据更新"):::process
O --> P("缓存失效"):::process
P --> Q("手动失效"):::process
P --> R("定时失效"):::process
M --> S("内存存储"):::process
N --> T("Redis, Memcached"):::process
博主分享
📥博主的人生感悟和目标
📙经过多年在优快云创作上千篇文章的经验积累，我已经拥有了不错的写作技巧。同时，我还与清华大学出版社签下了四本书籍的合约，并将陆续出版。
- 《Java项目实战—深入理解大型互联网企业通用技术》基础篇的购书链接：https://item.jd.com/14152451.html
- 《Java项目实战—深入理解大型互联网企业通用技术》基础篇繁体字的购书链接：http://product.dangdang.com/11821397208.html
- 《Java项目实战—深入理解大型互联网企业通用技术》进阶篇的购书链接：https://item.jd.com/14616418.html
- 《Java项目实战—深入理解大型互联网企业通用技术》架构篇待上架
- 《解密程序员的思维密码--沟通、演讲、思考的实践》购书链接：https://item.jd.com/15096040.html
面试备战资料
八股文备战
| 场景 | 描述 | 链接 |
|---|---|---|
| 时间充裕（25万字） | Java知识点大全（高频面试题） | Java知识点大全 |
| 时间紧急（15万字） | Java高级开发高频面试题 | Java高级开发高频面试题 |
理论知识专题（图文并茂，字数过万）
| 技术栈 | 链接 |
|---|---|
| RocketMQ | RocketMQ详解 |
| Kafka | Kafka详解 |
| RabbitMQ | RabbitMQ详解 |
| MongoDB | MongoDB详解 |
| ElasticSearch | ElasticSearch详解 |
| Zookeeper | Zookeeper详解 |
| Redis | Redis详解 |
| MySQL | MySQL详解 |
| JVM | JVM详解 |
集群部署（图文并茂，字数过万）
| 技术栈 | 部署架构 | 链接 |
|---|---|---|
| MySQL | 使用Docker-Compose部署MySQL一主二从半同步复制高可用MHA集群 | Docker-Compose部署教程 |
| Redis | 三主三从集群（三种方式部署/18个节点的Redis Cluster模式） | 三种部署方式教程 |
| RocketMQ | DLedger高可用集群（9节点） | 部署指南 |
| Nacos+Nginx | 集群+负载均衡（9节点） | Docker部署方案 |
| Kubernetes | 容器编排安装 | 最全安装教程 |
开源项目分享
| 项目名称 | 链接地址 |
|---|---|
| 高并发红包雨项目 | https://gitee.com/java_wxid/red-packet-rain |
| 微服务技术集成demo项目 | https://gitee.com/java_wxid/java_wxid |
管理经验
【公司管理与研发流程优化】针对研发流程、需求管理、沟通协作、文档建设、绩效考核等问题的综合解决方案：https://download.youkuaiyun.com/download/java_wxid/91148718
希望各位读者朋友能够多多支持！
现在时代变了，信息爆炸，酒香也怕巷子深，博主真的需要大家的帮助才能在这片海洋中继续发光发热，所以，赶紧动动你的小手，点波关注❤️，点波赞👍，点波收藏⭐，甚至点波评论✍️，都是对博主最好的支持和鼓励！
- 💂 博客主页： Java程序员廖志伟
- 👉 开源项目：Java程序员廖志伟
- 🌥 哔哩哔哩：Java程序员廖志伟
- 🎏 个人社区：Java程序员廖志伟
- 🔖 个人微信号：
SeniorRD
🔔如果您需要转载或者搬运这篇文章的话，非常欢迎您私信我哦~
扫一扫
1089
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
