Mybatis核心源码赏析（六）

已于 2024-01-03 17:43:04 修改
阅读量2.8k 收藏 1
点赞数 4
分类专栏： java 文章标签： mybatis java kotlin
于 2022-10-21 11:10:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongjing991/article/details/127441270
版权

MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码和设置参数以及获取结果集的工作，使得开发者能够更加专注于SQL本身。

MyBatis通过简单的XML或注解来配置和映射原始类型、接口和Java POJO（Plain Old Java Objects，普通老式Java对象）为数据库中的记录。它底层使用的是原生的JDBC代码，对JDBC代码进行了封装。

MyBatis相较于JDBC的优势在于：

  1. 把SQL语句从Java代码中抽取出来，方便维护，并且修改SQL时不用修改Java代码。
  2. 无需手动设置参数和对结果集的处理，使得操作数据库更加简单，大大减少了代码量，提高了开发效率。

此外，MyBatis还有一些其他的特性，如支持事务管理、提供映射标签等。在MyBatis中，可以使用SQL片段来复用SQL片段，提高了SQL的复用性。同时，MyBatis还支持动态SQL，可以根据传入的参数动态生成SQL语句，使得查询更加灵活。

总的来说，MyBatis是一个功能强大的持久层框架，它简化了数据库操作，提高了开发效率，使得开发者能够更加专注于业务逻辑的实现。

以插入一条记录为例，赏析mybatis源码，IService，这是一个泛型接口。源码作者定义为 顶级 Service， 我们以  

 default boolean save(T entity) {
        return SqlHelper.retBool(getBaseMapper().insert(entity));
   }

为例赏析mybatis的保存数据到数据库的接口。 我们可以看都接口的方式是有具体实现的。

这其实是java8后的新特性。所以以前所说的接口只能是方法的声明没有实现，已经是过时的说法。

先看保存最外层的方法：

    /**
     * 插入一条记录（选择字段，策略插入）
     *
     * @param entity 实体对象
     */
    default boolean save(T entity) {
        return SqlHelper.retBool(getBaseMapper().insert(entity));
    }

 判断数据库是否保存成功


    /**
     * 判断数据库操作是否成功
     *
     * @param result 数据库操作返回影响条数
     * @return boolean
     */
    public static boolean retBool(Integer result) {
        return null != result && result >= 1;
    }

插入数据接口

public interface BaseMapper<T> extends Mapper<T> {

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);


/*
 * Copyright (c) 2011-2021, baomidou (jobob@qq.com).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.baomidou.mybatisplus.extension.service;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Assert;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.conditions.query.ChainQuery;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.ChainUpdate;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.UpdateChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtQueryChainWrapper;
import com.baomidou.mybatisplus.extension.kotlin.KtUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.toolkit.ChainWrappers;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 顶级 Service
 *
 * @author hubin
 * @since 2018-06-23
 */
public interface IService<T> {

    /**
     * 默认批次提交数量
     */
    int DEFAULT_BATCH_SIZE = 1000;

    /**
     * 插入一条记录（选择字段，策略插入）
     *
     * @param entity 实体对象
     */
    default boolean save(T entity) {
        return SqlHelper.retBool(getBaseMapper().insert(entity));
    }

    /**
     * 插入（批量）
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveBatch(Collection<T> entityList) {
        return saveBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 插入（批量）
     *
     * @param entityList 实体对象集合
     * @param batchSize  插入批次数量
     */
    boolean saveBatch(Collection<T> entityList, int batchSize);

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean saveOrUpdateBatch(Collection<T> entityList) {
        return saveOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 批量修改插入
     *
     * @param entityList 实体对象集合
     * @param batchSize  每次的数量
     */
    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    default boolean removeById(Serializable id) {
        return SqlHelper.retBool(getBaseMapper().deleteById(id));
    }

    /**
     * 根据实体(ID)删除
     *
     * @param entity 实体
     * @since 3.4.4
     */
    default boolean removeById(T entity) {
        return SqlHelper.retBool(getBaseMapper().deleteById(entity));
    }

    /**
     * 根据 columnMap 条件，删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    default boolean removeByMap(Map<String, Object> columnMap) {
        Assert.notEmpty(columnMap, "error: columnMap must not be empty");
        return SqlHelper.retBool(getBaseMapper().deleteByMap(columnMap));
    }

    /**
     * 根据 entity 条件，删除记录
     *
     * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default boolean remove(Wrapper<T> queryWrapper) {
        return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
    }

    /**
     * 删除（根据ID 批量删除）
     *
     * @param idList 主键ID列表
     */
    default boolean removeByIds(Collection<? extends Serializable> idList) {
        if (CollectionUtils.isEmpty(idList)) {
            return false;
        }
        return SqlHelper.retBool(getBaseMapper().deleteBatchIds(idList));
    }

    /**
     * 根据 ID 选择修改
     *
     * @param entity 实体对象
     */
    default boolean updateById(T entity) {
        return SqlHelper.retBool(getBaseMapper().updateById(entity));
    }

    /**
     * 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
     *
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    default boolean update(Wrapper<T> updateWrapper) {
        return update(null, updateWrapper);
    }

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象
     * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
     */
    default boolean update(T entity, Wrapper<T> updateWrapper) {
        return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     */
    @Transactional(rollbackFor = Exception.class)
    default boolean updateBatchById(Collection<T> entityList) {
        return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 根据ID 批量更新
     *
     * @param entityList 实体对象集合
     * @param batchSize  更新批次数量
     */
    boolean updateBatchById(Collection<T> entityList, int batchSize);

    /**
     * TableId 注解存在更新记录，否插入一条记录
     *
     * @param entity 实体对象
     */
    boolean saveOrUpdate(T entity);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    default T getById(Serializable id) {
        return getBaseMapper().selectById(id);
    }

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表
     */
    default List<T> listByIds(Collection<? extends Serializable> idList) {
        return getBaseMapper().selectBatchIds(idList);
    }

    /**
     * 查询（根据 columnMap 条件）
     *
     * @param columnMap 表字段 map 对象
     */
    default List<T> listByMap(Map<String, Object> columnMap) {
        return getBaseMapper().selectByMap(columnMap);
    }

    /**
     * 根据 Wrapper，查询一条记录 <br/>
     * <p>结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")</p>
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default T getOne(Wrapper<T> queryWrapper) {
        return getOne(queryWrapper, true);
    }

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param throwEx      有多个 result 是否抛出异常
     */
    T getOne(Wrapper<T> queryWrapper, boolean throwEx);

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    Map<String, Object> getMap(Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper，查询一条记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param mapper       转换函数
     */
    <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

    /**
     * 查询总记录数
     *
     * @see Wrappers#emptyWrapper()
     */
    default long count() {
        return count(Wrappers.emptyWrapper());
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default long count(Wrapper<T> queryWrapper) {
        return SqlHelper.retCount(getBaseMapper().selectCount(queryWrapper));
    }

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<T> list(Wrapper<T> queryWrapper) {
        return getBaseMapper().selectList(queryWrapper);
    }

    /**
     * 查询所有
     *
     * @see Wrappers#emptyWrapper()
     */
    default List<T> list() {
        return list(Wrappers.emptyWrapper());
    }

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {
        return getBaseMapper().selectPage(page, queryWrapper);
    }

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default <E extends IPage<T>> E page(E page) {
        return page(page, Wrappers.emptyWrapper());
    }

    /**
     * 查询列表
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper) {
        return getBaseMapper().selectMaps(queryWrapper);
    }

    /**
     * 查询所有列表
     *
     * @see Wrappers#emptyWrapper()
     */
    default List<Map<String, Object>> listMaps() {
        return listMaps(Wrappers.emptyWrapper());
    }

    /**
     * 查询全部记录
     */
    default List<Object> listObjs() {
        return listObjs(Function.identity());
    }

    /**
     * 查询全部记录
     *
     * @param mapper 转换函数
     */
    default <V> List<V> listObjs(Function<? super Object, V> mapper) {
        return listObjs(Wrappers.emptyWrapper(), mapper);
    }

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default List<Object> listObjs(Wrapper<T> queryWrapper) {
        return listObjs(queryWrapper, Function.identity());
    }

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     * @param mapper       转换函数
     */
    default <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
        return getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
    }

    /**
     * 翻页查询
     *
     * @param page         翻页对象
     * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
     */
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper) {
        return getBaseMapper().selectMapsPage(page, queryWrapper);
    }

    /**
     * 无条件翻页查询
     *
     * @param page 翻页对象
     * @see Wrappers#emptyWrapper()
     */
    default <E extends IPage<Map<String, Object>>> E pageMaps(E page) {
        return pageMaps(page, Wrappers.emptyWrapper());
    }

    /**
     * 获取对应 entity 的 BaseMapper
     *
     * @return BaseMapper
     */
    BaseMapper<T> getBaseMapper();

    /**
     * 获取 entity 的 class
     *
     * @return {@link Class<T>}
     */
    Class<T> getEntityClass();

    /**
     * 以下的方法使用介绍:
     *
     * 一. 名称介绍
     * 1. 方法名带有 query 的为对数据的查询操作, 方法名带有 update 的为对数据的修改操作
     * 2. 方法名带有 lambda 的为内部方法入参 column 支持函数式的
     * 二. 支持介绍
     *
     * 1. 方法名带有 query 的支持以 {@link ChainQuery} 内部的方法名结尾进行数据查询操作
     * 2. 方法名带有 update 的支持以 {@link ChainUpdate} 内部的方法名为结尾进行数据修改操作
     *
     * 三. 使用示例,只用不带 lambda 的方法各展示一个例子,其他类推
     * 1. 根据条件获取一条数据: `query().eq("column", value).one()`
     * 2. 根据条件删除一条数据: `update().eq("column", value).remove()`
     *
     */

    /**
     * 链式查询 普通
     *
     * @return QueryWrapper 的包装类
     */
    default QueryChainWrapper<T> query() {
        return ChainWrappers.queryChain(getBaseMapper());
    }

    /**
     * 链式查询 lambda 式
     * <p>注意：不支持 Kotlin </p>
     *
     * @return LambdaQueryWrapper 的包装类
     */
    default LambdaQueryChainWrapper<T> lambdaQuery() {
        return ChainWrappers.lambdaQueryChain(getBaseMapper());
    }

    /**
     * 链式查询 lambda 式
     * kotlin 使用
     *
     * @return KtQueryWrapper 的包装类
     */
    default KtQueryChainWrapper<T> ktQuery() {
        return ChainWrappers.ktQueryChain(getBaseMapper(), getEntityClass());
    }

    /**
     * 链式查询 lambda 式
     * kotlin 使用
     *
     * @return KtQueryWrapper 的包装类
     */
    default KtUpdateChainWrapper<T> ktUpdate() {
        return ChainWrappers.ktUpdateChain(getBaseMapper(), getEntityClass());
    }

    /**
     * 链式更改 普通
     *
     * @return UpdateWrapper 的包装类
     */
    default UpdateChainWrapper<T> update() {
        return ChainWrappers.updateChain(getBaseMapper());
    }

    /**
     * 链式更改 lambda 式
     * <p>注意：不支持 Kotlin </p>
     *
     * @return LambdaUpdateWrapper 的包装类
     */
    default LambdaUpdateChainWrapper<T> lambdaUpdate() {
        return ChainWrappers.lambdaUpdateChain(getBaseMapper());
    }

    /**
     * <p>
     * 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
     * 此次修改主要是减少了此项业务代码的代码量（存在性验证之后的saveOrUpdate操作）
     * </p>
     *
     * @param entity 实体对象
     */
    default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper) {
        return update(entity, updateWrapper) || saveOrUpdate(entity);
    }
}

MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis允许你在几乎不写Java代码的情况下，完全配置你的SQL语句以及结果映射。MyBatis可以使用简单的XML或注解来配置和映射原生信息，将接口和Java的POJOs(Plain Old Java Objects)映射成数据库中的记录。

1. MyBatis的核心思想

  • 定制化SQL：MyBatis允许你编写任意的SQL语句，从而满足各种复杂的查询需求。
  • 映射机制：MyBatis提供了一种简单的方法来将数据库查询的结果集映射到Java对象。
  • 灵活性：MyBatis配置文件和注解方式可以灵活切换，同时提供动态SQL。
  • 减少代码量：MyBatis可以减少大量的重复代码，并自动处理许多常见任务，例如结果集的检索和映射。

2. MyBatis的工作流程

  1. 加载配置文件：MyBatis在启动时加载配置文件，配置文件包括mybatis-config.xml和映射文件。
  2. 创建SqlSessionFactory：SqlSessionFactory是MyBatis的核心，用于创建SqlSession。SqlSessionFactory的创建是资源消耗较大的操作，因此建议SqlSessionFactory缓存起来复用。
  3. 创建SqlSession：SqlSession是执行SQL的接口，它包含了执行SQL所需要的所有方法。SqlSession实例是非线程安全的，应该避免在多线程环境下使用。
  4. Mapper执行流程：Mapper接口是用户自定义的接口，接口的方法名就是对应的SQL语句的ID。当调用Mapper的方法时，实际上是调用了对应的SQL语句并执行了操作。
  5. 事务管理：MyBatis支持声明式事务管理，只需要在mapper.xml文件中添加事务属性即可。

3. MyBatis的主要优势

  1. 减少冗余代码：MyBatis自动处理了许多与JDBC相关的重复代码，如连接管理、语句创建和结果集处理等。这使得开发人员能够专注于SQL本身，而不是其底层实现细节。
  2. 灵活性：MyBatis允许开发人员编写自己的SQL语句，这意味着可以根据特定需求进行优化，并更好地控制数据访问层的行为。此外，MyBatis还支持动态SQL，使得根据不同条件构建SQL语句变得简单。
  3. 易于维护：由于SQL语句与Java代码分离，因此更改或调试SQL语句更加方便。此外，MyBatis的映射文件通常与数据库结构保持同步，这有助于减少因数据库结构更改而导致的维护工作量。
  4. 简化事务管理：MyBatis支持声明式事务管理，这意味着开发人员可以专注于业务逻辑而不是底层的数据库事务管理。这有助于提高应用程序的可靠性和性能。
  5. 集成方便：MyBatis可以轻松地与Spring框架集成，进一步简化了应用程序的开发和管理。通过与Spring集成，开发人员可以轻松地利用Spring提供的各种功能，如依赖注入和声明式事务管理。
  6. 插件支持：MyBatis支持自定义插件，这使得开发人员可以根据需要扩展其功能。例如，可以编写自定义插件来实现性能监控、日志记录或审计等功能。
  7. 支持存储过程：除了常规的SQL查询和更新外，MyBatis还可以用于调用数据库存储过程。这使得对数据库的操作更加丰富和灵活。
  8. 易于测试：由于MyBatis将SQL与Java代码分离，使得测试更加简单和独立。开发人员可以轻松地模拟数据库操作以进行单元测试或集成测试。
  9. 丰富的映射方式：MyBatis提供了丰富的结果映射方式，如一对一、一对多、多对一等关系的映射。这使得处理复杂的数据模型变得更加容易。
  10. 强大的社区支持：由于MyBatis的流行和广泛使用，它拥有一个庞大的用户社区和支持资源。这意味着开发人员可以轻松找到相关问题的解决方案、教程和技术文章等。

4. 总结

MyBatis是一个功能强大且灵活的持久层框架，它通过简化数据库访问操作、减少冗余代码和提高开发效率等方面为应用程序开发带来了显著的优势。通过定制化SQL、映射机制和事务管理等核心功能，MyBatis能够满足各种复杂的业务需求并提高应用程序的性能和可靠性。

奋力向前123
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SQLHelper数据库处理类库
05-15
数据存取通用类，主持SQL Sever等
SqlHelper方法
weixin_43522117的博客
03-13 4478
1.SqlHelper介绍 是一个sql的辅助类，可以是代码更简洁，更有可读性！ 2. 类方法方法介绍 retBool(Integerresult):判断数据库操作是否成功 getObject(List<E>list)：从list中取第一条数据返回对应List中泛型的单个结果 fillWrapper(Page<?>page, Wrapper<?>wrapper)：填充Wrapper sqlSession(Class<?>clazz)：获取...
Mybatis-Plus中update更新操作用法
最新发布
weixin_36873225的博客
07-25 2099
本篇文章重点是通过多个案例来进行讲解，每一个案例执行出来的sql我都会放到文章当中，方便大家快速掌握并使用！Mybatis-Plus给我们提供的update根本没有全量修改的，都是只对不为空的进行修改，例如updateById和update使用Entity赋值的方法都是只对不为null的进行赋值修改。Mybatis-Plus会根据字段是否为null来判断条件是否生效，假如实体类当中使用的是基本类型，new出来的对象会赋初始值的，比如int默认就是0，这样就会导致我们并不想对他进行修改，但是最后却修改了。
mybatis plus中的save保存方法解释
liuliu0616的博客
07-05 4176
【代码】mybatis plus中的save保存方法解释。
SQLHelper及应用
格物致知
06-28 767
using System;using System.Data;using System.Configuration;using System.Linq;using System.Web;using System.Web.Security;using System.Web.UI;using System.Web.UI.HtmlControls;using System
【Day49】SQL注入攻击
Leslie
11-13 1156
首先我们了解一下，什么是sql？SQL 是一门 ANSI 的标准计算机语言，用来访问和操作数据库系统。SQL 语句用于取回和更新数据库中的数据。SQL 可与数据库程序协同工作，比如 MS Access、DB2、Informix、MS SQL Server、Oracle、Sybase 以及其他数据库系统。 那么什么是sql注入呢？ 看起来很复杂，其实很简单就能解释，SQL注入就是一种通过操作输入来修改
互联网公司常用框架源码赏析
04-27
目前开放 Spring 全家桶，Mybatis、Netty、Dubbo 框架，及 Redis、Tomcat 中间件等，让我们一起开拓新的领地，揭开这些源码的神秘面纱。 本项目主要用于记录框架及中间件源码的阅读经验、个人理解及解析，希望能够使...
毕业设计源码之基于微信小程序的在线诗歌赏析系统的设计与实现.zip
09-19
该毕业设计项目是一个基于微信小程序的在线诗歌赏析系统，它涵盖了计算机科学中的多个核心知识点，主要涉及前端开发、后端开发以及数据库管理等方面。以下是详细的技术要点： 1. **微信小程序开发**：微信小程序是...
ssm恋上诗词（源码+数据库）011431
10-19
1.诗词显示模块：展示日常生活常见且值得背诵记忆的诗词，点击进入诗词页面，应包含诗词的注释、翻译、赏析和创作背景，以便深入学习诗词。   2.搜索模块：通过搜索栏可以搜索自己喜欢的诗词进行学习。   3.收藏...
springboot诗词会系统设计与实现052339（附源码+数据库）
09-17
展示古诗，用户可以对古诗进行评论，分为译文、赏析和故事，可以点赞和收藏，可以根据诗名、作者、朝代、分类进行查询（在页面展示作者、分类、朝代） 1）所有人都可以对诗歌进行评论（译文、赏析和故事），展示这些...
springboot诗词欣赏网站的设计与实现252347（附源码+数据库）
09-17
设计诗词欣赏网站，网站精选优秀古今诗词，包括诗词介绍、诗词赏析、诗词比赛、发表区、评论区等，用户通过注册﹑登录可以浏览诗词，可以在诗词下面发表自己的见解，可以搜索诗人或诗名,可以下载诗词和赏析。...
SqlHelper中使用事务示例
07-25 1004
SqlHelper最开始出现好像是在Microsoft PetShop 作为DAL层的核心。另外关于SqlDataReader，我感觉这个东西和ADO里面的RecordSet类似，就是需要Close.如果做为参数和返回值传递是比较危险的，因为你要传出去就Close(),而究竟在哪
MyBatis-Plus 实用工具：SqlHelper 让你的数据库操作更得心应手
Hi_alan的博客
03-22 795
SqlHelper 是MyBatis-Plus的一款SQL 辅助工具类，提供了一些常用的方法，简便我们的操作，提高开发效率。
Mybatis快速入门
Just Do It
07-05 372
一、Mybatis快速 1.1 Mybatis是什么 MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 1.2为什么使用Mybatis 通俗的理解，一个接口映射一个数据库SQL。调用传参时，需要将Ja.
Mybatis-plus做分页和联表查询
热门推荐
shenshaoming的博客
02-16 2万+
前言 在 Mybatis-plus中自定义的sql语句调用QueryWrapper实现查询及分页IPage使用 一文中,我本来是用的别人写的Mybatis Plus分页,不过现在链接失效了,所以就决定自己写一下了. 以下均是在SpringBoot项目中使用MybatisPlus的示例. 示例 首先先从代码上看一下我在框架中是如何使用的分页: 注: AboutusHomepage是实体类 ...
kupdate用法详解
qq646748739的专栏
09-20 506
kupdate函数:  删除、删除+添加 指定字符串 例如: data _null_; x1=kupdate("123456",2,3); x2=kupdate("123456",2,3,"abcd"); x3=kupdate("123456",2,3,"ab");  put x1= x2= x3=; run; 结果输出如下： x1=156 x2=1abcd56 x3=1
返回树形菜单集合
江黎
08-06 357
借助hutool的Tree和TreeNode数据结构,快速构建树形集合 /** * 返回树形菜单集合 * @return 树形菜单 */ @GetMapping(value = "/tree") public R listDeptTrees() { return R.ok(sysDeptService.listDeptTrees()); } /** * 查询全部部门树 * @return 树 */ @Override public List<Tree&
【问题解决】使用pagehelper，在对数据进行对象转换之后分页失效
激进的工程师的博客
03-23 989
使用MyBatis-Plus操作数据库，使用PageHelper插件进行分页操作，直接返回Mapper的分页查询结果数据时分页状态正常，对数据对象进行转换后返回转换后的list则分页出现异常，分页数据的total变成当前返回数据list的size，页数始终为1。
Mybatis-plus配置
NewBeeMu的博客
05-26 1852
最近在使用Mybatis-plus发现一个很奇怪的现象，明明用的Mybatis-plus里面的deleteById，但是数据库里却是逻辑删除，去研究了一下Mybatis-plus的配置才弄明白 SqlHelper.retBool()方法是判断数据库操作是否成功 走到这里，其实按照正常逻辑来说，数据库里执行的应该是 delete from 表名 where id = #{id} 这样的一个sql语句，是物理删除而不是逻辑删除，但是数据库里最后执行的却是逻辑删除，所以我找到了配置文件applicatio
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

奋力向前123

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值