手写mybatis缓存

最新推荐文章于 2022-10-19 10:08:43 发布
最新推荐文章于 2022-10-19 10:08:43 发布
阅读量290 收藏 2
点赞数 2
文章标签： mybatis 缓存 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suphans/article/details/126658828
版权

目录

1.缓存篇

1.1 缓存介绍:

1.1 .1缓存是什么？

1.1.2 为什么要应用缓存？ 

1.1.3 使用缓存有什么优势和劣势?

1.2 缓存模拟

1.2.1 缓存的基础构建

        ①缓存接口设计

          ②简易缓存实现

          ③ 基于FIFO(先进先出算法)设计缓存对象的淘汰策略,代码如下.

        ④ 基于LRU(最近最少访问)算法

        ⑤Caffeine缓存的实现

1.缓存篇

1.1 缓存介绍:

1.1 .1缓存是什么？

 
        缓存是内存中存在的一个对象，可以是Map.collection等类型,利用这个对象可以对某些数据对象进行存储.对于数据库而言,这个对象也可以看作是一个临时的数据库,里面包含着实际数据库中的部分数据.


1.1.2 为什么要应用缓存？ 

        在不使用缓存时,用户每次用浏览器访问某网站获取某项服务时,网站必须从数据库中进行相应的数据增删改查的工作,流程如下

         用户的每一次请求都需要走一遍完整的过程,而当访问数量较多的时候,服务器会达到访问瓶颈,此时再进行访问时,该访问请求要么放入请求队列进行等候,要么作为无效请求.这样的结果就是系统效率低,用户体验差,造成用户流失......

        而如果使用缓存,则可以大幅度降低数据的访问量.例如浏览器的本地缓存,可以缓存用户访问过的网页的html.js,image等文件,当用户再次访问时,可以直接从本地客户端获取这些文件,不需要从服务端进行请求.   例如服务器的本地缓存和分布式缓存,都可以作为存储部分数据库数据的"小型临时数据库",当web服务器需要访问数据库获取数据时,则可以先从缓存中查询,有则直接返回结果,没有则再查询数据库获取结果(如果有分布式缓存还会查分布式缓存,之后再查实际数据库).

 

1.1.3 使用缓存有什么优势和劣势?

        使用缓存的优势总结来讲就是两点,①提高系统功能效率②减少数据库压力.

        使用缓存有优势就必然有劣势和缺点,上面提到,对于服务器缓存来讲,它就是一个"临时的小型数据库","小型"也意味着会存储部分数据,需要消耗空间资源,是一种空间换时间的做法(一般来讲是值得的),"临时"则意味着缓存的数据是经常变换更新的,并且由于缓存中只是一部分数据库的信息,这就可能会造成一些问题,这些问题大致可以分为三种,缓存穿透,缓存击穿,缓存雪崩.这三个问题此处不进行详述

1.2 缓存模拟

1.2.1 缓存的基础构建

        此处用HashMap作为缓存对象进行实现.

        ①缓存接口设计

public interface Cache {
    void putObject(Object key,Object value);
    Object getObject(Object key);
    Object removeObject(Object key);
    void clear();
    int size();
}

          ②简易缓存实现

public class PerpetualCache implements Cache{

    private HashMap<Object,Object> cache=new HashMap<Object,Object>();
    @Override
    public void putObject(Object key, Object value) {
        cache.put(key, value);
    }

    @Override
    public Object getObject(Object key) {
        return cache.get(key);
    }

    @Override
    public Object removeObject(Object key) {
        return cache.remove(key);
    }

    @Override
    public void clear() {
        cache.clear();
    }

    @Override
    public int size() {
        return cache.size();
    }

    @Override
    public String toString() {
        return "PerpetualCache{" +
                "cache=" + cache.toString() +
                '}';
    }
}

          ③ 基于FIFO(先进先出算法)设计缓存对象的淘汰策略,代码如下.

//FIFO-Cache实现
package com.cache;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

public class FifoCache implements Cache{
    /**关联Cache对象-找到可以存储数据的基层对象*/
    private Cache cache;
    /**定义Cache的最大容量*/
    private int maxCap;
    /**通过队列记录key的添加顺序*/
    private Queue<Object> queue;

    public FifoCache(Cache cache, int maxCap) {
        this.cache = cache;
        this.maxCap = maxCap;
        this.queue=new LinkedList<Object>();
    }
    @Override
    public void putObject(Object key, Object value) {
        //1.记录key的顺序(加入队列)
        queue.add(key);

        //2.判断容器是否已满，满了则移除
        if(queue.size()>maxCap){
            Object firstKey = queue.remove();
            //从cache中清除指定key对应的对象
            cache.removeObject(firstKey);
        }
        //3.向cache添加数据
        cache.putObject(key, value);
    }
    @Override
    public Object getObject(Object key) {
        return cache.getObject(key);
    }

    @Override
    public Object removeObject(Object key) {
        //1.从Cache中移除对象
        Object object = cache.removeObject(key);
        //2.从队列移除key
        queue.remove(key);
        return object;
    }
    @Override
    public void clear() {
          cache.clear();
          queue.clear();
    }

    @Override
    public int size() {
        return cache.size();
    }

    @Override
    public String toString() {
        return "FifoCache{" +
                "cache=" + cache.toString() +
                ", maxCap=" + maxCap +
                ", queue=" + queue +
                '}';
    }

    public static void main(String[] args) {
        Cache cache=new FifoCache(new PerpetualCache(), 3);
       cache.putObject("胡桃", 1);
        cache.putObject("钟离", 2);
        cache.putObject("甘雨", 3);
        cache.putObject("影", 4);
        cache.putObject("凝光", 5);
        System.out.println(cache);
    }
}

        基于FIFO进行实现,依次插入胡桃,钟离,甘雨,影,凝光五组值,由于限制大小为3,所以map会将前面插入的胡桃和钟离移除,最终剩下甘雨,影,凝光.(因为HashMap是无序的,所以cache中的值与queue中的值的序列不同)

        ④ 基于LRU(最近最少访问)算法

public class LruCache implements Cache{
    private Cache cache;
    /**
     * 通过此属性记录要移除的数据对象
     */
    private Object eldestKey;
    private int maxcap;
    /**
     * 通过此 map 记录 key 的访问顺序
     */
    private Map<Object, Object> keyMap;

    @SuppressWarnings("serial")
    public LruCache(final Cache cache, int maxCap) {
        this.cache = cache;         //LinkedHashMap 可以记录 key 的添加顺序或者访问顺序
        this.maxcap=maxCap;
        this.keyMap = new LinkedHashMap<Object, Object>(maxCap, 0.75f, true) {//accessOrder                     // 此方法每次执行 keyMap 的 put 操作时调用
            @Override
            protected boolean removeEldestEntry(java.util.Map.Entry<Object, Object> eldest) {
                boolean isFull =cache.size()>maxcap;
                if (isFull) eldestKey = eldest.getKey();
                return isFull;
            }
        };
    }

    @Override
    public void putObject(Object key, Object value) {         // 存储数据对象
        cache.putObject(key, value);         // 记录 key 的访问顺序，假如已经满了，就要从 cache 中移除数据
        keyMap.put(key, key);// 此时会执行 keyMap 对象的 removeEldestEntry
          if(eldestKey!=null) {
              cache.removeObject(eldestKey);
              eldestKey = null;
    }

}

    @Override
    public Object getObject(Object key) {
        keyMap.get(key);// 记录 key 的访问顺序
        return cache.getObject(key);
    }

    @Override
    public Object removeObject(Object key) {
        return cache.removeObject(key);
    }

    @Override
    public void clear() {
        cache.clear();
        keyMap.clear();
    }

    @Override
    public int size() {
        return cache.size();
    }

    @Override
    public String toString() {
        return cache.toString();
    }

    public static void main(String[] args) {
        LruCache cache = new LruCache(new PerpetualCache(), 3);
        cache.putObject("胡桃", 1);
        cache.putObject("钟离", 2);
        cache.putObject("甘雨", 3);

        cache.getObject("钟离");
        cache.getObject("胡桃");

        cache.putObject("影", 4);
        cache.putObject("凝光", 5);

        System.out.println(cache);

    }

}

由于最后访问了"胡桃"和"钟离",所以在进行淘汰时,优先淘汰最后访问的数据.

        ⑤Caffeine缓存的实现

这种实现比较复杂,是在spring框架中实现的,需要引入额外的依赖

<dependencies>
    <!--SpringBoot依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.3.2.RELEASE</version>
    </dependency>
    <!--本地缓存caffeine-->
    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
</dependencies>

先写配置类

@EnableCaching
@Configuration
public class CacheConfig {
    @Bean
    public CaffeineCacheManager caffeineCacheManager(){
        //1.构建缓存对象
        Caffeine caffeine = Caffeine.newBuilder()
                .initialCapacity(1) //初始大小
                .maximumSize(3)  //最大大小
                .expireAfterWrite(1, TimeUnit.HOURS); //写入/更新之后1小时过期

        //构建缓存管理器对象
        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        caffeineCacheManager.setAllowNullValues(true);
        caffeineCacheManager.setCaffeine(caffeine);
        return caffeineCacheManager;
    }

}

控制层

@RestController
public class CaffeineController {
    @Autowired
    CaffeineCacheManager caffeineCacheManager;

    static int count=1;
    @Cacheable(cacheManager = "caffeineCacheManager", value = "caffeine")
    @GetMapping("/caffeine/{id}")
    public Object selectById(@PathVariable("id") String id) {

        System.out.println("模拟数据库获取数据"+count++);
        //返回的结果会自动存入caffeineCache中
        return  "结果"+count;
    }
}

启动项目,通过.http进行测试

执行测试

GET http://localhost:8080/caffeine/1
###
GET http://localhost:8080/caffeine/2
###
GET http://localhost:8080/caffeine/3
####
GET http://localhost:8080/caffeine/2
####
GET http://localhost:8080/caffeine/4
####
GET http://localhost:8080/caffeine/1
####

结果如下,在第二次执行GET http://localhost:8080/caffeine/1请求时,由于容量设置为3,所以之前的数据被移除,只能再重新从数据库中获取.实际的Caffeine由于数据量较少,无法测出准确的性能

 

#爱屋及乌
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【笔记】手写一个缓存
HAHHANDELIVERY的博客
09-12 268
手写一个缓存，利用装饰器模式，规范类间的行为，实现了一个基于LRU淘汰算法并具有线程安全的简单缓存
手写mybatis(三)：缓存
qq_45756124的博客
11-10 272
文末附有源码地址 博客为代码完成后才开始整理，展示的代码都是最终代码 介绍： 个人学习，代码写的不够好，有点乱 通过学习mybatis源码模拟实现Mybatis(在完善) 已实现： crud（实现XML配置，注解配置写过一点，原理差不多不写了）、 事务、 数据库连接池、 动态sql(一部分，原理没问题了，以后有时间再完善)、 一级二级缓存 一、mybatis一级缓存 mybatis缓存分为一级、二级缓存。一级缓存就是 SqlSession 级别的缓存，而同一个 SqlSession 会有相同的一级缓.
手写自己的MyBatis框架-支持查询缓存
Leon_Jinhai_Sun的博客
12-15 100
定义了一个CachingExecutor ， 当全局配置中的cacheEnabled=true 时，Configuration 的newExecutor()方法会对SimpleExecutor 进行装饰，返回被装饰过的Executor。CachingExecutor 中用HashMap 维护缓存。 在DefaultSqlSession 调用Executor 时，会先走到装饰器CachingExecutor。 定义了一个CacheKey 用于计算缓存Key，主要根据SQL 语句和参数计算。 ...
手写缓存
qq_17856593的博客
08-16 308
思路分析： 1、需要一个线程写的时候不能被打断，即写操作要保证原子性 2、读写锁保证同一时刻可以多个线程读、但只能一个线程写 3、lock / sync 是独占锁、只要加了锁、其他线程就不许读了、所以不好 4、读写锁适用于多读场景 代码实现： /** * @title: MyCache * @description: 写一个模拟的分布式缓存（Redis），写的时候要求⼀个线程进去，读的时候允...
mysql缓存击穿_Mybatis中的缓存击穿
weixin_28771751的博客
02-08 320
前言之前我们探讨了Mybatis中缓存模块的基本实现，对其中CacheKey和缓存的基本实现类PerpetualCache的核心代码进行了探索。传送门：Mybatis中的缓存模块实现在上篇文章结尾的时候，留下了一个问题，就是Mybatis默认的实现类存在高并发下的缓存击穿的问题。这篇文章将解释缓存击穿以及对应的解决方案。缓存击穿是对于高并发场景下二级缓存出现的一种现象。前面的文章介绍了Mybati...
mybatis源码+练习代码+手写练习
11-16
手写MyBatis的练习是提升对MyBatis理解的好方法。首先，你需要理解MyBatis的主要功能，如动态SQL、参数映射、结果映射等。然后，尝试模仿MyBatis的架构设计，包括创建一个简单的SqlSession接口和实现，以及一个基本...
Mybatis的一些实践
05-14
2. 缓存：Mybatis提供了本地缓存和二级缓存机制，可以提高数据读取速度。本地缓存作用于单个SqlSession，而二级缓存则可跨SqlSession共享数据。 七、Mybatis的事务管理 Mybatis允许开发者自定义事务管理策略，可以...
mybatis.zip
05-14
通过手写MyBatis，我们可以深入了解其内部机制，更好地掌握如何将Java对象与数据库交互，以及如何设计高效的数据访问层。这有助于我们在实际项目中更好地应用和优化MyBatis。在创建数据表时，描述中提到的"id（int）...
mybatis-hand-writing:mybatis手写迷你版源码，jdk动态代理的运用，手写mybatis的迷你版本源码，自己实现mybatis
03-23
【标题】：mybatis-hand-writing：mybatis手写迷你版源码分析 在这个项目中，我们探讨的是如何手工编写一个简化版的MyBatis框架，它主要展示了JDK动态代理在MyBatis中的应用。MyBatis是一个轻量级的Java持久层框架...
mybatis课件和练习代码
12-23
9. **缓存机制**：MyBatis 内置了两级缓存，一级缓存是 SqlSession 级别的，二级缓存是 Mapper 级别的。合理利用缓存可以显著提高数据访问效率。 10. **事务管理**：MyBatis 支持手动和自动两种事务管理方式。在...
手写本地缓存实战2—— 打造正规军，构建通用本地缓存框架
Q54665642ljf的博客
10-19 463
有的小伙伴可能会有疑问，现在有很多成熟的开源库，比如JAVA项目、、等（这些在我们的系列文章中，后面都会逐个介绍），它们都提供了相对完善、开箱即用的本地缓存能力，为什么这里还要去自己手写本地缓存呢？这不是重复造轮子吗？是也？非也！在编码的进阶之路上，“会用”永远都只是让自己停留在入门级别。正所谓知其然更要知其所以然，通过一起探讨手写缓存的实现与设计关键点，来切身的体会蕴藏在缓存架构中的设计哲学。只有真正的掌握其原理，才能在使用中更好的去发挥其最大价值。
ReentrantReadWriteLock 实现手写缓存，并发读取、阻塞添加
cpown的博客
10-08 304
前言 我们在大多数业务中遇到并发问题，最先想到的是，Synchorized,以及 ReentrantLock，但是这两种锁是重量级的，也是阻塞的锁，一个线程获取了锁，其他线程必须阻塞，并发性能大大降低。 今天我们来介绍一下java.util.concurrent.locks包下面的另一把锁：ReadWriteLock 读写锁，顾名思义，就是可以区分读还是写操作，展现不同的锁类型，做到并发读取，阻塞写入，使性能大大提升。 案例 本文我们使用一个简单的手写缓存Demo来展示一下锁的特性以及功能。 package
手写图片缓存框架 ImageLoader
一个码农的博客
07-30 1930
图片缓存是App开发中最常见的，本篇博文给大家带来自己手写的图片缓存框，大致的思路很简单，首先从内存中获取图片，如果内存中没有，就从手机本地进行获取，如果还没有，就从网络访问进行获取。 所以，我们在ImageLoader中只需要暴露一个方法loadImage()，外部只需要调用这个方法就可以完成图片缓存的所以逻辑//加载图片到对应的控件
java手写多级缓存
weixin_30399055的博客
07-05 128
多级缓存实现类，时间有限，该类未抽取接口，目前只支持两级缓存：JVM缓存（实现 请查看上一篇：java 手写JVM高性能缓存）、redis缓存（在spring 的 redisTemplate 基础实现） package com.ws.commons.cache; import java.util.function.Supplier; import com.ws.c...
编写缓存构建业务
从0到1
04-21 217
缓存业务需求 key构建思路 访问思路 缓存过期 代码实现 代码框架如下，具体功能业务需更近一步丰富 #-*- coding: UTF-8 -*- import inspect import time import functools import datetime def cache(duration): """ Decorator for function ...
缓存一致性、缓存穿透/击穿、缓存雪崩、热点数据集中失效等问题入门
tiantiantbtb的博客
05-11 303
先理解两个概念,本地缓存与分布式缓存 缓存减少数据库访问压力 本地缓存：指的是在应用中的缓存组件，其最大的优点是应用和 cache是在同一个进程内部，请求缓存非常快速，没有过多的网络开销等，在单应用不需要集群支持或者集群情况下各节点无需互相通知的场景下使用本地缓存较合适；同时，它的缺点也是应为缓存跟应用程序耦合，多个应用程序无法直接的共享缓存，各应用或集群的各节点都需要维护自己的单独缓存，对内存是一种浪费。分布式缓存:指的是与应用分离的缓存组件或服务，其最大的优点是自身就是一个独立的应用.
mybatis中使用linkedHashMap对结果集进行排序
it佳佳的博客
10-11 4259
<!--获取表信息--> <select id="getListByTableId" parameterType="string" resultType="java.util.LinkedHashMap" > select ${columnId} from &quot;${tableId} </...
Mybatis 报错invalid comparison: java.util.LinkedHashmap and java.lang.String
xx_star1204的博客
02-19 3268
原因比较明显，是说我的比较两边类型不同而导致的错误，一个是map，一个是string
linkhashmap实现原理
weixin_34351321的博客
04-09 254
HashMap和双向链表合二为一即是LinkedHashMap。所谓LinkedHashMap，其落脚点在HashMap，因此更准确地说，它是一个将所有Entry节点链入一个双向链表的HashMap。由于LinkedHashMap是HashMap的子类，所以LinkedHashMap自然会拥有HashMap的所有特性。比如，LinkedHashMap的元素存取过程基本与HashMap基本类似，只是...
手写简单版mybatis
最新发布
05-16
Mybatis 是一款优秀的持久层框架，它可以对 JDBC 进行封装，使得开发者可以通过 XML 文件或注解来配置 SQL 语句，从而避免了手写 JDBC 代码的繁琐和重复。下面，我将简单介绍如何手写一个简单版的 Mybatis。 1. 创建配置文件 在 resources 目录下创建一个 mybatis-config.xml 文件，用于配置 Mybatis 的各种参数。其中包括数据库连接信息、mapper 文件路径、缓存配置、插件等。以下是一个简单的配置文件示例： ``` <configuration> <dataSource type="POOLED"> <property name="driver" value="${driver}"/> <property name="url" value="${url}"/> <property name="username" value="${username}"/> <property name="password" value="${password}"/> </dataSource> <mappers> <mapper resource="com/example/mapper/UserMapper.xml"/> </mappers> </configuration> ``` 2. 创建数据库连接池 在 Mybatis 中，我们可以通过数据源来获取数据库连接。下面是一个简单的数据源示例： ``` public class PooledDataSource { private static final String driver = "com.mysql.jdbc.Driver"; private static final String url = "jdbc:mysql://localhost:3306/mybatis"; private static final String username = "root"; private static final String password = "root"; private static final int initialSize = 5; private static final int maxActive = 10; private static final int maxIdle = 8; private static final int minIdle = 5; private static final long maxWait = 60000; private static DataSource dataSource; static { try { GenericObjectPoolConfig<Connection> poolConfig = new GenericObjectPoolConfig<>(); poolConfig.setMinIdle(minIdle); poolConfig.setMaxIdle(maxIdle); poolConfig.setMaxTotal(maxActive); poolConfig.setMaxWaitMillis(maxWait); ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(url, username, password); PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, null); poolableConnectionFactory.setValidationQuery("SELECT 1"); dataSource = new PoolingDataSource(poolableConnectionFactory.getPool()); } catch (Exception e) { e.printStackTrace(); } } public static DataSource getDataSource() { return dataSource; } } ``` 3. 创建 SqlSession SqlSession 是 Mybatis 中用于执行 SQL 语句的核心接口，它提供了各种方法来执行 SQL 语句、获取 Mapper 等。下面是一个简单的 SqlSession 实现： ``` public class DefaultSqlSession implements SqlSession { private final Configuration configuration; private final Executor executor; public DefaultSqlSession(Configuration configuration, Executor executor) { this.configuration = configuration; this.executor = executor; } @Override public <T> T selectOne(String statement, Object parameter) { return executor.query(statement, parameter); } @Override public <T> T getMapper(Class<T> type) { return configuration.getMapper(type, this); } } ``` 4. 创建 Executor Executor 是 Mybatis 中用于执行 SQL 语句的实现类，它提供了各种方法来执行 SQL 语句、获取结果等。下面是一个简单的 Executor 实现： ``` public class SimpleExecutor implements Executor { private final DataSource dataSource; public SimpleExecutor(DataSource dataSource) { this.dataSource = dataSource; } @Override public <T> T query(String statement, Object parameter) { Connection connection = null; PreparedStatement preparedStatement = null; ResultSet resultSet = null; try { connection = dataSource.getConnection(); preparedStatement = connection.prepareStatement(statement); preparedStatement.setString(1, parameter.toString()); resultSet = preparedStatement.executeQuery(); if (resultSet.next()) { return (T) resultSet.getString(1); } } catch (SQLException e) { e.printStackTrace(); } finally { try { resultSet.close(); preparedStatement.close(); connection.close(); } catch (SQLException e) { e.printStackTrace(); } } return null; } } ``` 5. 创建 Mapper Mapper 是 Mybatis 中用于定义 SQL 语句的接口，它包含了各种方法来执行 SQL 语句、获取结果等。下面是一个简单的 Mapper 接口示例： ``` public interface UserMapper { @Select("SELECT * FROM user WHERE id = #{id}") User selectById(Integer id); } ``` 6. 创建 Configuration Configuration 是 Mybatis 中用于配置各种参数的类，它负责解析配置文件、创建 SqlSession 和 Mapper 等。下面是一个简单的 Configuration 实现： ``` public class Configuration { private final Properties properties; private final Map<Class<?>, MapperProxyFactory<?>> mapperProxyFactoryMap = new HashMap<>(); public Configuration(Properties properties) { this.properties = properties; } public <T> T getMapper(Class<T> type, SqlSession sqlSession) { MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) mapperProxyFactoryMap.get(type); if (mapperProxyFactory == null) { mapperProxyFactory = new MapperProxyFactory<>(type); mapperProxyFactoryMap.put(type, mapperProxyFactory); } return mapperProxyFactory.newInstance(sqlSession); } } ``` 7. 创建 MapperProxyFactory 和 MapperProxy MapperProxyFactory 是 Mybatis 中用于创建 MapperProxy 的工厂类，它负责创建 MapperProxy 并维护 Mapper 接口和对应的 MapperProxy。MapperProxy 是 Mybatis 中用于动态代理 Mapper 接口的类，它负责解析 Mapper 接口中定义的 SQL 语句，并将其转化为对应的 SQL 语句执行器。下面是一个简单的 MapperProxyFactory 和 MapperProxy 实现： ``` public class MapperProxyFactory<T> { private final Class<T> mapperInterface; public MapperProxyFactory(Class<T> mapperInterface) { this.mapperInterface = mapperInterface; } public T newInstance(SqlSession sqlSession) { return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[]{mapperInterface}, new MapperProxy(sqlSession, mapperInterface)); } } public class MapperProxy<T> implements InvocationHandler { private final SqlSession sqlSession; private final Class<T> mapperInterface; public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface) { this.sqlSession = sqlSession; this.mapperInterface = mapperInterface; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Select select = method.getAnnotation(Select.class); if (select != null) { String sql = select.value()[0]; return sqlSession.selectOne(sql, args[0]); } throw new RuntimeException("No such method: " + method.getName()); } } ``` 至此，我们就手写了一个简单版的 Mybatis，它包含了配置文件、数据库连接池、SqlSession、Executor、Mapper 等核心组件。虽然这个实现比较简单，但它足以帮助我们理解 Mybatis 的核心原理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值