《手写Mybatis渐进式源码实践》实践笔记(第七章 SQL执行器的创建和使用)

🕗 发布于 2024-12-27 11:53 mybatis 笔记 sql 模板方法模式后端

第七章 SQL执行器的定义和实现

mybatis

背景

技术背景

模板模式

模板模式（Template Method Pattern）是行为型设计模式之一，它在父类中定义了一个算法的框架，允许子类在不改变算法结构的情况下重写算法的某些特定步骤。这种模式主要用来解决代码复用的问题，它通过把一些相同步骤提取到父类中，而将不同的步骤延迟到子类中实现，从而避免代码重复。

特点

算法框架：在父类中定义算法的骨架，这些算法通常包含一系列的步骤。
扩展性：子类可以重新定义算法的某些步骤，而不影响算法的结构。
代码复用：通过提取公共代码到父类，减少代码重复。
控制反转：父类控制算法的流程，子类提供具体的实现。

结构

模板模式通常包含以下角色：

抽象类（Abstract Class）：定义模板方法和算法框架，其中模板方法是一个调用一系列抽象操作的方法。
具体类（Concrete Class）：实现抽象类中的抽象方法，这些方法可以是具体的方法，也可以是其他抽象方法。
钩子方法（Hook Method）：在抽象类中定义，可以被子类重写，但不带有抽象方法的声明。

示例代码（Java）

// 抽象类
abstract class Game {
    // 模板方法
    final void play() {
        initialize();
        startPlay();
        endPlay();
    }

    // 抽象方法，由子类实现
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();
}

// 具体类
class Cricket extends Game {
    @Override
    void initialize() {
        System.out.println("Cricket game initialized.");
    }

    @Override
    void startPlay() {
        System.out.println("Cricket game started.");
    }

    @Override
    void endPlay() {
        System.out.println("Cricket game finished.");
    }
}

// 具体类
class Football extends Game {
    @Override
    void initialize() {
        System.out.println("Football game initialized.");
    }

    @Override
    void startPlay() {
        System.out.println("Football game started.");
    }

    @Override
    void endPlay() {
        System.out.println("Football game finished.");
    }
}

// 客户端代码
public class TemplatePatternDemo {
    public static void main(String[] args) {
        Game game = new Cricket();
        game.play();

        game = new Football();
        game.play();
    }
}

在这个例子中，Game 类定义了游戏的算法框架，而 Cricket 和 Football 类分别实现了具体的游戏初始化、开始和结束的方法。这样，不同的游戏可以共享相同的游戏流程，同时保持各自的特性。

业务背景

在第6章节我们实现了连接池/非连接池的数据源，可以在调用执行SQL的时候，通过我们实现的池化技术完成数据库的操作。

那么关于池化数据源的调用、执行和结果封装，目前只是在 DefaultSqlSession 中进行发起，代码层面写死了流程，这种方式不适用于后续扩展使用，因为SqlSession 中新增定义的方法都要处理对池化数据源的调用逻辑。

 @Override
    public <T> T selectOne(String statement, Object parameter) {
        try {
            // 映射语句
            MappedStatement mappedStatement = configuration.getMappedStatement(statement);
            // 环境
            Environment environment = configuration.getEnvironment();

            // 连接
            Connection connection = environment.getDataSource().getConnection();

            BoundSql boundSql = mappedStatement.getBoundSql();
            PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSql());
            preparedStatement.setLong(1, Long.parseLong(((Object[]) parameter)[0].toString()));
            // 执行查询
            ResultSet resultSet = preparedStatement.executeQuery();

            // 结果封装
            List<T> objectList = resultSet2Obj(resultSet, Class.forName(boundSql.getResultType()));
            return objectList.get(0);

        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

解耦 DefaultSqlSession#selectOne 方法中关于对数据源的调用、执行和结果封装，提供新的功能模块替代这部分硬编码的逻辑处理。
只有提供了单独的执行方法入口，我们才能更好的扩展和应对这部分内容里的需求变化，包括了各类入参、结果封装、执行器类型、批处理等，来满足不同样式的用户需求，也就是配置到 Mapper.xml 中的具体信息。

目标

基于当前框架实现，解耦 DefaultSqlSession#selectOne 方法中关于对数据源的调用、执行和结果封装，提供SQL执行器功能模块替代这部分硬编码的逻辑处理。

设计

ORM 框架渐进式的开发过程上，逐步实现的执行动作：解析配置、代理对象、映射方法等，直至我们前面章节对数据源的包装和使用，只不过我们把数据源的操作硬编码到了 DefaultSqlSession 的执行方法上了。

为了解耦这块的功能处理，需要引入SQL执行器的服务功能，将SQL执行器随着 DefaultSqlSession 创建时传入，之后具体的方法调用就可以通过执行器来处理。
整体设计如图：

提取执行器的接口，定义执行方法、事务获取和相应提交、回滚、关闭的方法定义；
执行器是一种标准的执行过程，由抽象类进行实现，可以对过程内容进行模板模式的过程包装。在包装过程中定义抽象类，由具体的子类来实现。这一部分在下文的代码中会体现到 SimpleExecutor 简单执行器实现中;
对 SQL 的处理，使用 JDBC 执行 SQL 的时候，分为了简单处理和预处理，预处理中包括准备语句、参数化传递、执行查询，以及最后的结果封装和返回。所以我们这里也需要把 JDBC 这部分的步骤，分为结构化的类过程来实现，便于功能的拓展。具体代码主要体现在语句处理器 StatementHandler 的接口实现中。

实现

工程代码

类图

Executor 接口定义为执行器入口，确定事务操作和 SQL 执行的统一标准。用BaseExecutor抽象类处理统一共用的事务和执行SQL的标准流程，并定义执行 SQL 的抽象接口#doQuery()，后续由子类实现。
SimpleExecutor 简单SQL 执行器实现类中，处理 doQuery 方法的具体操作过程。这个过程中则会引入 SQL 语句处理器的创建，创建过程仍由 configuration 配置项提供。你会发现很多这样的生成处理，都来自于配置项
执行器开发完成后，由DefaultSqlSessionFactory 开启 openSession 的时候，随着构造函数参数传递给 DefaultSqlSession 中，这样在执行 DefaultSqlSession#selectOne 的时候就可以调用执行器进行处理了。也就由此完成解耦操作了。

实现步骤

1.执行器的定义和实现

执行器分为接口、抽象类、简单执行器实现类三部分，通常在框架的源码中对于一些标准流程的处理，都会有抽象类的存在。它负责提供共性功能逻辑，以及对接口方法的执行过程进行定义和处理，并提供抽象接口交由子类实现。这种设计模式也被定义为模板模式。

1-1. Executor定义执行器接口

在执行器中定义的接口包括事务相关的处理方法和执行SQL查询的操作，随着后续功能的迭代还会继续补充其他的方法。

public interface Executor {
    
    ResultHandler NO_RESULT_HANDLER = null;

    <E> List<E> query(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql);

    Transaction getTransaction();

    void commit(boolean required) throws Exception;

    void rollback(boolean required) throws Exception;

    void close(boolean forceRollback);
    

}

1-2.BaseExecutor执行器抽象基类

封装了执行器的全部接口，这样具体的子类继承抽象类后，就可以直接使用这些共性的方法。在 query 查询方法中，封装一些必要的流程处理，如果检测关闭等，在 Mybatis 源码中还有一些缓存的操作，这里暂时剔除掉，以核心流程为主。读者伙伴在学习的过程中可以与源码进行对照学习。

public abstract class BaseExecutor implements Executor {

    Logger logger = LoggerFactory.getLogger(BaseExecutor.class);

    protected Configuration configuration;

    protected Transaction transaction;

    protected Executor wrapper;

    private boolean closed;

    protected BaseExecutor(Configuration configuration, Transaction transaction) {
        this.configuration = configuration;
        this.transaction = transaction;
        this.wrapper = this;
    }

    // 连接关闭处理统一逻辑
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql) {
        if (closed) {
            throw new RuntimeException("Executor was closed.");
        }
        return doQuery(ms, parameter, resultHandler, boundSql);
    }

    protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql);

    @Override
    public Transaction getTransaction() {
        if (closed) {
            throw new RuntimeException("Executor was closed.");
        }
        return transaction;
    }

    @Override
    public void commit(boolean required) throws Exception {
        if (closed) {
            throw new RuntimeException("Cannot commit, transaction is already closed");
        }
        if (required) {
            transaction.commit();
        }
    }

    @Override
    public void rollback(boolean required) throws SQLException {
        if (closed) {
            throw new RuntimeException("Cannot rollback, transaction is already closed");
        }
        if (required) {
            transaction.rollback();
        }
    }

    @Override
    public void close(boolean forceRollback) {
        try {
            try {
                rollback(forceRollback);
            } finally {
                transaction.close();
            }
        } catch (SQLException e) {
            logger.warn("Unexpected exception on closing transaction.  Cause: " + e);
        } finally {
            transaction = null;
            closed = true;
        }
    }
}

1-3. SimpleExecutor 简单执行器实现

简单执行器 SimpleExecutor 继承抽象基类，实现抽象方法 doQuery，在这个方法中包装数据源的获取、语句处理器的创建，以及对 Statement 的实例化和相关参数设置。最后执行 SQL 的处理和结果的返回操作。

public class SimpleExecutor extends BaseExecutor {


    public SimpleExecutor(Configuration configuration, Transaction transaction) {
        super(configuration, transaction);
    }

    @Override
    protected <E> List<E> doQuery(MappedStatement ms, Object parameter, ResultHandler resultHandler, BoundSql boundSql) {
        //处理查询逻辑.
        try {
            //获取配置信息
            Configuration configuration = ms.getConfiguration();
            //获取StatementHandler
            StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, resultHandler, boundSql);
            //获取连接
            Connection connection = transaction.getConnection();
            Statement stmt = handler.prepare(connection);
            handler.parameterize(stmt);
            return handler.query(stmt, resultHandler);
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }
}

2.语句处理器

语句处理器是 SQL 执行器中依赖的部分，SQL 执行器封装事务、连接和检测环境等，而语句处理器则是准备语句、参数化传递、执行SQL、封装结果的处理。

2-1.StatementHandler定义语句处理接口

语句处理器的核心: 准备语句、参数化传递参数、执行查询的操作，这里对应的 Mybatis 源码中还包括了 update、批处理、获取参数处理器等。

public interface StatementHandler {

    /**
     * 准备语句
     */
    Statement prepare(Connection connection) throws SQLException;

    /**
     * 参数化
     */
    void parameterize(Statement statement) throws SQLException;

    /**
     * 执行查询
     */
    <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException;
}

2-2. BaseStatementHandler 语句处理器抽象基类

语句处理器基类中，封装参数信息、结果信息。不过这里我们暂时还不会做过多的参数处理，比如jdbc的字段类型转换等。这部分内容随着我们整个执行器的结构建设完毕后，再进行迭代开发。
对 BaseStatementHandler#prepare 方法的处理，包括定义实例化抽象方法，这个方法交由各个具体的实现子类进行处理。

public abstract class BaseStatementHandler implements StatementHandler {


    protected final Configuration configuration;

    protected final Executor executor;

    protected final MappedStatement mapperStatement;

    protected final Object parameter;

    protected final ResultSetHandler resultSetHandler;

    protected BoundSql boundSql;

    protected BaseStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
                                   ResultHandler resultHandler,
                                   BoundSql boundSql) {
        this.executor = executor;
        this.configuration = mapperStatement.getConfiguration();
        this.mapperStatement = mapperStatement;
        this.parameter = parameter;
        this.boundSql = boundSql;
        this.resultSetHandler = configuration.newResultSetHandler(executor, mapperStatement, boundSql);
    }


    @Override
    public Statement prepare(Connection connection) throws SQLException {
        Statement statement = null;
        try {
            statement = instantiateStatement(connection);
            statement.setQueryTimeout(350);
            statement.setFetchSize(10000);
            return statement;
        } catch (Exception e) {
            throw new RuntimeException("Error preparing statement.  Cause: " + e, e);
        }
    }


    protected abstract Statement instantiateStatement(Connection connection) throws SQLException;

}

2-3. SimpleStatementHandler 简单语句处理器类

SimpleStatementHandler 简单语句处理器,只是对 SQL 的最基本执行，没有参数的设置.

public class SimpleStatementHandler extends BaseStatementHandler {


    public SimpleStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
                                  ResultHandler resultHandler,
                                  BoundSql boundSql) {
        super(executor, mapperStatement, parameter, resultHandler, boundSql);
    }

    @Override
    protected Statement instantiateStatement(Connection connection) throws SQLException {
        return connection.createStatement();
    }

    @Override
    public void parameterize(Statement statement) throws SQLException {
        // N/A
    }

    @Override
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        String sql = boundSql.getSql();
        statement.execute(sql);
        return resultSetHandler.handleResultSets(statement);
    }
}

2-4. PrepareStatementHandler 预处理语句处理器类

预处理语句处理器中包括 instantiateStatement 预处理 SQL、parameterize 设置参数，以及 query 查询的执行的操作。
这里需要注意，当前 parameterize 设置参数中还是写死的，后续这部分再进行完善。
query 方法则是执行查询和对结果的封装，结果的封装目前也是比较简单的处理，只是把我们前面章节中对象的内容摘取出来进行封装，这部分暂时没有改变。都放在后续进行完善处理。

public class PreparedStatementHandler extends BaseStatementHandler {
    public PreparedStatementHandler(Executor executor, MappedStatement mapperStatement, Object parameter,
                                    ResultHandler resultHandler,
                                    BoundSql boundSql) {
        super(executor, mapperStatement, parameter, resultHandler, boundSql);
    }

    @Override
    protected Statement instantiateStatement(Connection connection) throws SQLException {
        String sql = boundSql.getSql();
        return connection.prepareStatement(sql);
    }

    @Override
    public void parameterize(Statement statement) throws SQLException {
        PreparedStatement ps = (PreparedStatement) statement;
        ps.setLong(1, Long.parseLong(((Object[]) parameter)[0].toString()));
    }

    @Override
    public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        PreparedStatement ps = (PreparedStatement) statement;
        ps.execute();
        return resultSetHandler.<E>handleResultSets(ps);
    }
}

3.执行器创建和使用

执行器开发完成以后，则需要在串联到 DefaultSqlSession 中进行使用。串联过程：在创建 DefaultSqlSession 的时候，构建出执行器，并作为参数传递到defaultSqlSession。这块涉及到 DefaultSqlSessionFactory#openSession 的处理。

3-1. 开启执行器

openSession 中开启事务tx, 用于执行器的创建，具体实现可以看 configuration.newExecutor 代码，这部分没有太多复杂的逻辑。读者可以参考源码进行学习。
在执行器创建完毕后，以参数方式传递给 DefaultSqlSession，这样就把整个过程串联起来了。

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private final Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public SqlSession openSession() {
        Transaction tx = null;
        try {
            final Environment environment = configuration.getEnvironment();
            TransactionFactory transactionFactory = environment.getTransactionFactory();
            tx = transactionFactory.newTransaction(configuration.getEnvironment().getDataSource(),
                    TransactionIsolationLevel.READ_COMMITTED,
                    false);
            // 创建执行器
            final Executor executor = configuration.newExecutor(tx);
            // 创建DefaultSqlSession
            return new DefaultSqlSession(configuration, executor);
        } catch (Exception e) {
            try {
                assert tx != null;
                tx.close();
            } catch (SQLException ignore) {
            }
            throw new RuntimeException("Error opening session.  Cause: " + e);
        }
    }
}

3-2. 使用执行器

完成上面执行器的所有实现后，就可以调用执行器进行功能解耦了。在 DefaultSqlSession#selectOne 中获取 MappedStatement 映射语句类后，则传递给执行器进行处理，那么现在这个类经过设计思想的解耦后，就变得更加干净整洁了，更易于维护和扩展了。

public class DefaultSqlSession implements SqlSession {

    /**
     * 配置项.
     */
    private Configuration configuration;

    private Executor executor;

    public DefaultSqlSession(Configuration configuration, Executor executor) {
        this.configuration = configuration;
        this.executor = executor;
    }

    public Configuration getConfiguration() {
        return configuration;
    }


    /**
     * 根据给定的执行SQL获取一条记录的封装对象.
     *
     * @param statement
     * @param <T>
     * @return
     */

    @Override
    public <T> T selectOne(String statement) {
        return this.selectOne(statement, null);
    }

    @Override
    public <T> T selectOne(String statement, Object parameter) {
        //映射语句
        MappedStatement mappedStatement = configuration.getMappedStatement(statement);
        //使用执行器.
        List<T> list = executor.query(mappedStatement, parameter, Executor.NO_RESULT_HANDLER, mappedStatement.getBoundSql());
        return list.get(0);
    }
    

    @Override
    public <T> T getMapper(Class<T> type) {
        return configuration.getMapper(type, this);
    }


}

测试

事先准备

创建库表

-- 建表
CREATE TABLE `my_user` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `user_id` varchar(9) DEFAULT NULL COMMENT '用户ID',
  `user_head` varchar(16) DEFAULT NULL COMMENT '用户头像',
  `create_time` timestamp NULL DEFAULT NULL COMMENT '创建时间',
  `update_time` timestamp NULL DEFAULT NULL COMMENT '更新时间',
  `user_name` varchar(64) DEFAULT NULL COMMENT '用户名',
  `user_password` varchar(64) DEFAULT NULL COMMENT '用户密码',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ;


-- 插入数据
INSERT INTO my_user (user_id, user_head, create_time, update_time, user_name, user_password) VALUES('1', '头像', '2024-12-13 18:00:12', '2024-12-13 18:00:12', '小苏', 's123asd');

定义一个数据库接口 IUserDao

IUserDao

public interface IUserDao {

    String queryUserInfoById(String uid);

}

配置数据源

通过 mybatis-config-datasource.xml 配置数据源信息，包括：driver、url、username、password
这里DataSource 配置的是 DRUID，因为我们实现的是这个数据源的处理方式。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>


    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="UNPOOLED">  #无池化时配置成这个类型值
            <dataSource type="POOLED">  #池化时配置城这个类型值
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useUnicode=true"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="mapper/User_Mapper.xml"/>
    </mappers>
</configuration>

定义对应的mapper xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.suwg.mybatis.test.dao.IUserDao">

    <select id="queryUserInfoById" parameterType="java.lang.Long" resultType="cn.suwg.mybatis.test.po.User">
        SELECT id, user_id, user_head, create_time
        FROM user
        where id = #{id}
    </select>

</mapper>

测试用例

单元测试，传递一个 1L 的 long 类型参数，进行方法的调用处理。通过单元测试验证执行器的处理过程，读者在学习的过程中可以进行断点测试，学习每个过程的处理内容。
mybatis-config-datasource.xml 中 dataSource 数据源类型的调整 dataSource type="DRUID/POOLED/UNPOOLED",按需配置验证.

单元测试

public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);


    // 测试SqlSessionFactory
    @Test
    public void testSqlSessionFactory() throws IOException {

        // 1.从xml文件读取mybatis配置项, 从SqlSessionFactory获取SqlSession.
        Reader reader = Resources.getResourceAsReader("mybatis-config-datasource.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        SqlSession sqlSession = sqlSessionFactory.openSession();


        // 2.获取映射器对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        // 4.测试验证
        User user = userDao.queryUserInfoById(1L);
        logger.info("测试结果：{}", JSON.toJSONString(user));

    }


}

测试结果

从输出的结果来看，我们已经顺利完成，将DefaultSqlSession#selectOne中的调用，替换成了执行器来完成整个过程，通过解耦这部分的逻辑操作，后续我们扩展就更方便了，这块的功能测试通过后，后续就可以聚焦在新的功能扩展点开发了。

总结

整个章节的实现都是在处理解耦这件事情，从DefaultSqlSession#selectOne 对数据源的处理解耦到执行器中进行操作。而执行器中又包括了对 JDBC 处理的拆解，链接、准备语句、封装参数、处理结果，所有的这些过程经过解耦后的类和方法，就都可以在以后的功能迭代中非常方便的完成扩展了。
本章节也为我们后续扩展参数的处理、结果集的封装预留出了扩展点，以及对于不同的语句处理器选择的问题，都需要在后续进行完善和补充。目前我们串联出来的是最核心的骨架结构，随着后续的渐进式开发陆续迭代完善。
对于源码的学习，读者要经历看、写、思考、应用等几个步骤的过程，才能更好的吸收这里面的思想，每一次的阅读源码，都能有新的认知和体会。不要只是Ctrl+C，Ctrl+V一遍就完事了，否则也就失去了跟着学习源码的意义。

参考书籍：《手写Mybatis渐进式源码实践》

书籍源代码：https://github.com/fuzhengwei/book-small-mybatis

原文地址：https://blog.csdn.net/weixin_37693760/article/details/144715815

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

uni-app开发收货地址管理
收货地址在个人中心的我的地址里面，点击我的地址可以查看我的收货地址列表，可以新增收货地址，点击特定收货地址可以编辑和删除该地址信息。// 加载loding。
阅读更多2024-12-27
hive的存储格式
hive5种存储格式的区别
阅读更多2024-12-27
基于 MATLAB 的图像增强技术分享
MATLAB 的图像处理工具箱提供了大量用于图像增强和处理的函数，如imread用于读取图像，imwrite用于保存图像，rgb2gray用于将彩色图像转换为灰度图像，imhist用于计算图像的直方图
阅读更多2024-12-27
taiwindcss
注意：一定通过px tailwindcss init方式创建。6.问题，如果这几个步骤发现没有实现，删除包以后重新试一下。5.因为tailwindcss是依赖于postcss。创建postcss.co
阅读更多2024-12-27
“Gold-YOLO：基于聚合与分发机制的高效目标检测新范式”
Gold-YOLO是一种新型高效的目标检测模型，它通过引入聚合和分发机制显著提升了多尺度特征融合的能力。Gold-YOLO通过其创新的GD机制，在目标检测领域实现了最佳性能，尤其是在处理多尺度物体时。
阅读更多2024-12-27
典型常见的基于知识蒸馏的目标检测方法总结一
使用feature propagation layer [29]将voxel特征转换为point feature。
阅读更多2024-12-27
CSS系列（37）-- Overscroll Behavior详解
CSS之旅第三十七站
阅读更多2024-12-27
最短路径C++，Dijkstra
第一行为有向图中点的数量n（各点从0到n-1编号）第二行为边的数量m第三行为要求其间最短路径的两个点第四行起为m条边的信息，包括起点、终点和路径长度（保证长度是整数，且绝对值不大于100），以空格隔开
阅读更多2024-12-27
题海拾贝：蓝桥杯 2020 省AB 乘法表
输出P进制下的乘法表。P 进制中大于等于 10 的数字用大写字母 A、8、C、.·表示。九九乘法表是学习乘法时必须要掌握的。在不同进制数下，需要不同的乘法表。给定 P，请输出P 进制下的乘法表。
阅读更多2024-12-27
力扣-数据结构-3【算法学习day.74】
##我做这类文章一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？建议灵神的题单和代码随想录）和记录自己的学习过程，我的解析也不会做的非常详细，只会提供思路和一些关键点，力
阅读更多2024-12-27