Mybatis映射文件SQL-增删查改/批量增删查改/SqlSessionBatch-SqlSessionTemplateBatch/动态拼装SQL/多表连接操作属性使用-模板

置顶 已于 2023-08-31 17:53:34 修改
阅读量6.3k 收藏 4
点赞数 2
分类专栏： 框架知识 文章标签： mybatis java mysql
于 2022-08-28 17:45:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51091560/article/details/126572114
版权

增删查改/批量增删查改

<?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="com.xch.mapper.WorkMapper">

    <resultMap id="BaseResultMap" type="com.xch.pojo.Work">
        <id property="wId" jdbcType="VARCHAR" column="w_id"/>
        <result property="wDept" jdbcType="VARCHAR" column="w_dept"/>
        <result property="wPosition" jdbcType="VARCHAR" column="w_position"/>
        <result property="wSalary" jdbcType="DECIMAL" column="w_salary"/>
        <result property="wCreateTime" jdbcType="TIMESTAMP" column="w_create_time"/>
        <result property="uId" jdbcType="VARCHAR" column="u_id"/>
    </resultMap>

    <sql id="Base_Column_List">
        w_id, w_dept, w_position, w_salary, w_create_time, u_id
    </sql>

    <sql id="Alias_Column_List">
        work.w_id, work.w_dept, work.w_position, work.w_salary, work.w_create_time, work.u_id
    </sql>


    <!--单表增删查改模板-->
    <insert id="baseInsertWork" parameterType="com.xch.pojo.Work">
        insert into dynamic_sql_work
        values (
            #{wId,jdbcType=VARCHAR},
            #{wDept,jdbcType=VARCHAR},
            #{wPosition,jdbcType=VARCHAR},
            #{wSalary,jdbcType=DECIMAL},
            #{wCreateTime,jdbcType=TIMESTAMP},
            #{uId,jdbcType=VARCHAR}
        )
    </insert>

    <delete id="baseDeleteWork" parameterType="string">
        delete from dynamic_sql_work
        where w_id=#{wId,jdbcType=VARCHAR}
    </delete>

    <select id="baseSelectWork" parameterType="string" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from dynamic_sql_work
        where u_id=#{uId,jdbcType=VARCHAR}
    </select>

    <update id="baseUpdateWork" parameterType="com.xch.pojo.Work">
        update dynamic_sql_work
        set w_position=#{wPosition,jdbcType=VARCHAR},
            w_salary=#{wSalary,jdbcType=DECIMAL},
            w_create_time=#{wCreateTime,jdbcType=TIMESTAMP}
        where u_id=#{uId,jdbcType=VARCHAR}
        and w_id=#{wId,jdbcType=VARCHAR}
    </update>


    <!--单表批量增删查改模板-->
    <insert id="batchInsertWork" parameterType="list">
        insert into dynamic_sql_work
        values
        <foreach collection="workList" item="work" separator=",">
            (
                #{work.wId,jdbcType=VARCHAR},
                #{work.wDept,jdbcType=VARCHAR},
                #{work.wPosition,jdbcType=VARCHAR},
                #{work.wSalary,jdbcType=DECIMAL},
                #{work.wCreateTime,jdbcType=TIMESTAMP},
                #{work.uId,jdbcType=VARCHAR}
            )
        </foreach>
    </insert>

    <delete id="batchDeleteWork" parameterType="list">
        delete from dynamic_sql_work
        where w_id in 
        <foreach collection="wIdList" item="wId" open="(" close=")" separator=",">
            #{wId,jdbcType=VARCHAR}
        </foreach>
    </delete>

    <select id="batchSelectWork" parameterType="list" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from dynamic_sql_work
        where w_id in 
        <foreach collection="wIdList" item="wId" open="(" close=")" separator=",">
            #{wId,jdbcType=VARCHAR}
        </foreach>
    </select>

    <update id="batchUpdateWork1">
        update dynamic_sql_work
        set w_position=#{work.wPosition,jdbcType=VARCHAR},
            w_salary=#{work.wSalary,jdbcType=DECIMAL},
            w_create_time=#{work.wCreateTime,jdbcType=TIMESTAMP},
            u_id=#{work.uId,jdbcType=VARCHAR}
        where w_id in 
        <foreach collection="wIdList" item="wId" open="(" close=")" separator=",">
            #{wId,jdbcType=VARCHAR}
        </foreach>
    </update>
    
    <update id="batchUpdateWork2" parameterType="list">
        update dynamic_sql_work
        set  w_salary=
        case
        <foreach collection="workList" item="work">
            when w_id=#{work.wId,jdbcType=VARCHAR} then #{work.wSalary,jdbcType=DECIMAL}
        </foreach>
        end
        where w_id in
        <foreach collection="workList" item="work" open="(" close=")" separator=",">
            #{work.wId,jdbcType=VARCHAR}
        </foreach>
    </update>

</mapper>

SqlSessionBatch-SqlSessionTemplateBatch

package com.xch.sqlSessionTemplate;

import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author Chenghe Xu
 * @date 2022/9/5 22:58
 * 
 * 申明多个注入Bean注释，只会注入一个Bean
 * 因为注释的底层都会有@ConditionalOnMissingBean(xxx.class)，没有该Bean才创建，防止重复创建
 */
@Configuration
public class CreateSqlSessionTemplate {

    /**
     * 注入开启Batch模式的SqlSessionTemplate对象
     */
    @Bean({"sqlSessionTemplateBatch"})
    @ConditionalOnMissingBean(name = {"sqlSessionTemplateBatch"})
    @Autowired
    public SqlSessionTemplate createSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory, ExecutorType.BATCH);
    }

}
package com.xch.dao.impl;

import com.xch.dao.WorkDAO;
import com.xch.mapper.WorkMapper;
import com.xch.pojo.Work;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;

/**
 * @author Chenghe Xu
 * @date 2022/9/5 20:47
 */
@Repository
public class WorkDAOImpl implements WorkDAO {
    
    @Resource
    ApplicationContext applicationContext;

    private final SqlSessionFactory sqlSessionFactory;
    private final SqlSessionTemplate sqlSessionTemplate;
    
    /**
     * SqlSessionFactory/SqlSessionTemplate默认在Spring容器中的
     * 注入开启Batch模式的SqlSessionTemplate自定义对象splSessionTemplateBatch
     *      代替原有的SqlSessionTemplate对象
     */
    @Autowired
    public WorkDAOImpl(SqlSessionFactory sqlSessionFactory, @Qualifier("sqlSessionTemplateBatch") SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionFactory = sqlSessionFactory;
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    public void test(){
        System.out.println(sqlSessionFactory);
        System.out.println(sqlSessionTemplate);
        System.out.println(applicationContext.getBeansOfType(SqlSessionTemplate.class));
        System.out.println(Arrays.toString(applicationContext.getBeanNamesForType(SqlSessionTemplate.class)));
    }
    
    /**
     * SqlSession/SqlSessionTemplate异同：
     * 1、SqlSession需要手动commit和close流
     *    SqlSessionTemplate自动commit和close流
     * 2、SqlSession并发下线程不安全
     *    SqlSessionTemplate并发下线程安全
     * 3、SqlSessionTemplate是SqlSession的实现类
     *    其底层都是通过jdbc的PreparedStatement.executeBatch()执行批量操作的
     *    
     * 用法：
     * 业务逻辑中其它操作（删查改）混合，使用SqlSession
     * 业务逻辑中只有批量新增操作，使用SqlSessionTemplate
     */
    @Override
    public Integer advanceBatchWork1(List<Work> workList) {
        //try (AutoCloseable/Closeable 需要自动关闭的资源)
        //jdk1.7新特性：try ()中申明的流资源，在try语句结束后自动关闭
        //相当于简化了finally{ManualCloseable 需要手动关闭的资源}
        try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)){
            WorkMapper workMapper = sqlSession.getMapper(WorkMapper.class);
            workList.forEach(workMapper::baseInsertWork);
            sqlSession.commit();
            return workList.size();
        }
        //不需要捕获catch (){rollback();}，发生异常后Spring会回滚方法的执行
    }
    
    @Override
    public Integer advanceBatchWork2(List<Work> workList) {
        //SqlSessionTemplate自动管理了提交commit和关闭流close
        WorkMapper workMapper = sqlSessionTemplate.getMapper(WorkMapper.class);
        workList.forEach(workMapper::baseInsertWork);
        return workList.size();
    }
    
}

动态拼装SQL/多表连接操作属性使用

<?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="com.xch.mapper.UserMapper">
    
    <resultMap id="BaseResultMap" type="com.xch.pojo.User">
        <id property="uId" jdbcType="VARCHAR" column="u_id"/>
        <result property="uName" jdbcType="VARCHAR" column="u_name"/>
        <result property="uAge" jdbcType="INTEGER" column="u_age"/>
        <result property="uPhone" jdbcType="CHAR" column="u_phone"/>
        <result property="uCreateTime" jdbcType="TIMESTAMP" column="u_create_time"/>
    </resultMap>
    
    <sql id="Base_Column_List">
        u_id, u_name, u_age, u_phone, u_create_time
    </sql>

    <sql id="Alias_Column_List">
        user.u_id, user.u_name, user.u_age, user.u_phone, user.u_create_time
    </sql>


    <!--动态拼装SQL-->
    
    <!--if标签可以判断     not true false null '' ! == != < <= > >=   -->
    <!--if标签可以转义     eq neq lt lte &lt; &lt;= gt gte &gt; %gt;= -->
    <!--if标签可以运算     + - * / % ^ << >> >>> | &                  -->
    <!--if标签可以组合判断 || or && and ? :                           -->
    <!--if标签可以调用方法 xxx.equals() xxx.hashCode()                -->
    <select id="ifTest" parameterType="com.xch.pojo.User" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from dynamic_sql_user
        where 1=1
        <if test="uName neq null and uName != ''">
            and u_name=#{uName,jdbcType=VARCHAR}
        </if>
        <if test="uAge neq null and uAge >= 0 and uAge lte 160">
            and u_age=#{uAge,jdbcType=INTEGER}
        </if>
    </select>

    <!--where标签可以替代where/where 1=1，动态去除多余and-->
    <select id="whereTest" parameterType="com.xch.pojo.User" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from dynamic_sql_user
        <where>
            <if test="uName neq null and uName != ''">
                and u_name=#{uName,jdbcType=VARCHAR}
            </if>
            <if test="uAge neq null and uAge >= 0 and uAge lte 160">
                and u_age=#{uAge,jdbcType=INTEGER}
            </if>
        </where>
    </select>

    <!--choose when otherwise标签-->
    <select id="chooseTest" parameterType="com.xch.pojo.User" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from dynamic_sql_user
        where 1=1
        <choose>
            <when test="uName neq null and uName != ''">
                and u_name=#{uName,jdbcType=VARCHAR}
            </when>
            <when test="uAge neq null and uAge >= 0 and uAge lte 160">
                and u_age=#{uAge,jdbcType=INTEGER}
            </when>
            <otherwise>
                order by u_age, u_id
            </otherwise>
        </choose>
    </select>

    <!--set标签可以代替set，动态去除多余,-->
    <update id="setTest" parameterType="com.xch.pojo.User">
        update dynamic_sql_user
        <set>
            <if test="uName neq null and uName != ''">
                u_name=#{uName,jdbcType=VARCHAR},
            </if>
            <if test="uAge neq null and uAge >= 0 and uAge lte 160">
                and u_age=#{uAge,jdbcType=INTEGER}
            </if>
        </set>
        where u_id=#{uId,jdbcType=VARCHAR}
    </update>

    <!--trim标签可以代替where/where 1=1，动态去除多余and-->
    <select id="trimTest1" parameterType="com.xch.pojo.User" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from dynamic_sql_user
        <trim prefix="where" prefixOverrides="and">
            <if test="uName neq null and uName != ''">
                and u_name=#{uName,jdbcType=VARCHAR}
            </if>
            <if test="uAge neq null and uAge >= 0 and uAge lte 160">
                and u_age=#{uAge,jdbcType=INTEGER}
            </if>
        </trim>
    </select>
    
    <!--trim标签可以代替set，动态去除多余,-->
    <update id="trimTest2" parameterType="com.xch.pojo.User">
        update dynamic_sql_user
        <trim prefix="set" suffixOverrides=",">
            <if test="uName neq null and uName != ''">
                u_name=#{uName,jdbcType=VARCHAR},
            </if>
            <if test="uAge neq null and uAge >= 0 and uAge lte 160">
                and u_age=#{uAge,jdbcType=INTEGER}
            </if>
        </trim>
        where u_id=#{uId,jdbcType=VARCHAR}
    </update>
    
    
    <!--多表连接操作-->

    <!--association属性-一对一关联-->
    <resultMap id="BaseResultWithWorkMap1" type="com.xch.pojo.UserWithWork">
        <id property="uId" jdbcType="VARCHAR" column="u_id"/>
        <result property="uName" jdbcType="VARCHAR" column="u_name"/>
        <result property="uAge" jdbcType="INTEGER" column="u_age"/>
        <result property="uPhone" jdbcType="CHAR" column="u_phone"/>
        <result property="uCreateTime" jdbcType="TIMESTAMP" column="u_create_time"/>
        <!--说明：property是出参，jdbcType/javaType是指明类型-->
        <association property="work" javaType="com.xch.pojo.Work">
            <id property="wId" jdbcType="VARCHAR" column="w_id"/>
            <result property="wDept" jdbcType="VARCHAR" column="w_dept"/>
            <result property="wPosition" jdbcType="VARCHAR" column="w_position"/>
            <result property="wSalary" jdbcType="DECIMAL" column="w_salary"/>
            <result property="wCreateTime" jdbcType="TIMESTAMP" column="w_create_time"/>
            <result property="uId" jdbcType="VARCHAR" column="u_id"/>
        </association>
    </resultMap>
    <select id="associationTest" parameterType="string" resultMap="BaseResultWithWorkMap1">
        select <include refid="Alias_Column_List"/>,<include refid="com.xch.mapper.WorkMapper.Alias_Column_List"/>
        from dynamic_sql_user user
        left join dynamic_sql_work work
        on user.u_id=work.u_id
        where work.u_id=#{uId,jdbcType=VARCHAR}
    </select>

    <!--collection属性-一对多关联-->
    <resultMap id="BaseResultWithWorkMap2" type="com.xch.pojo.UserWithWork">
        <id property="uId" jdbcType="VARCHAR" column="u_id"/>
        <result property="uName" jdbcType="VARCHAR" column="u_name"/>
        <result property="uAge" jdbcType="INTEGER" column="u_age"/>
        <result property="uPhone" jdbcType="CHAR" column="u_phone"/>
        <result property="uCreateTime" jdbcType="TIMESTAMP" column="u_create_time"/>
        <!--说明：property是出参，jdbcType/ofType是指明类型-->
        <collection property="workList" ofType="com.xch.pojo.Work">
            <id property="wId" jdbcType="VARCHAR" column="w_id"/>
            <result property="wDept" jdbcType="VARCHAR" column="w_dept"/>
            <result property="wPosition" jdbcType="VARCHAR" column="w_position"/>
            <result property="wSalary" jdbcType="DECIMAL" column="w_salary"/>
            <result property="wCreateTime" jdbcType="TIMESTAMP" column="w_create_time"/>
            <result property="uId" jdbcType="VARCHAR" column="u_id"/>
        </collection>
    </resultMap>
    <select id="collectionTest" parameterType="string" resultMap="BaseResultWithWorkMap2">
        select <include refid="Alias_Column_List"/>,<include refid="com.xch.mapper.WorkMapper.Alias_Column_List"/>
        from dynamic_sql_user user
        left join dynamic_sql_work work
        on user.u_id=work.u_id
        where work.u_id=#{uId,jdbcType=VARCHAR}
    </select>

    <!--extend属性-继承映射关系-->
    <resultMap id="BaseResultWithWorkMap3" type="com.xch.pojo.UserWithWork" extends="BaseResultMap">
        <!--说明：property是出参，jdbcType/javaType是指明类型-->
        <association property="work" javaType="com.xch.pojo.Work">
            <id property="wId" jdbcType="VARCHAR" column="w_id"/>
            <result property="wDept" jdbcType="VARCHAR" column="w_dept"/>
            <result property="wPosition" jdbcType="VARCHAR" column="w_position"/>
            <result property="wSalary" jdbcType="DECIMAL" column="w_salary"/>
            <result property="wCreateTime" jdbcType="TIMESTAMP" column="w_create_time"/>
            <result property="uId" jdbcType="VARCHAR" column="u_id"/>
        </association>
    </resultMap>
    <select id="extendTest" parameterType="string" resultMap="BaseResultWithWorkMap3">
        select <include refid="Alias_Column_List"/>,<include refid="com.xch.mapper.WorkMapper.Alias_Column_List"/>
        from dynamic_sql_user user
        left join dynamic_sql_work work
        on user.u_id=work.u_id
        where work.u_id=#{uId,jdbcType=VARCHAR}
    </select>
    
    <!--resultMap属性-继承映射关系-->
    <resultMap id="BaseResultWithWorkMap4" type="com.xch.pojo.UserWithWork" extends="BaseResultMap">
        <!--说明：property是出参-->
        <association property="work" resultMap="com.xch.mapper.WorkMapper.BaseResultMap"/>
    </resultMap>
    <select id="resultMapTest" parameterType="string" resultMap="BaseResultWithWorkMap4">
        select <include refid="Alias_Column_List"/>,<include refid="com.xch.mapper.WorkMapper.Alias_Column_List"/>
        from dynamic_sql_user user
        left join dynamic_sql_work work
        on user.u_id=work.u_id
        where work.u_id=#{uId,jdbcType=VARCHAR}
    </select>
    
    <!--select属性-关联SQL-->
    <resultMap id="BaseResultWithWorkMap5" type="com.xch.pojo.UserWithWork" extends="BaseResultMap">
        <!--说明：property是出参，column是入参：数据库列名/{连接SQL需要的参数名=本SQL提供的数据库列名}，逗号分隔-->
        <!--写法一：数据库列名(适用于单一参数)-->
        <!--写法二：{连接SQL需要的参数名=本SQL提供的数据库列名}，逗号分隔(适用于多个参数即封装为类，需有GET/SET函数)-->
        <association property="work" column="u_id" select="com.xch.mapper.WorkMapper.baseSelectWork"/>
    </resultMap>
    <select id="selectTest" parameterType="string" resultMap="BaseResultWithWorkMap5">
        select <include refid="Base_Column_List"/>
        from dynamic_sql_user
        where u_id=#{uId,jdbcType=VARCHAR}
    </select>
    
</mapper>

多层结构树综合查询使用比较

<?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="com.xch.mapper.LevelTreeExtraMapper">

    <resultMap id="BaseResultMap" type="com.xch.pojo.LevelTreeExtra">
        <id property="id" jdbcType="INTEGER" column="id"/>
        <result property="parentId" jdbcType="INTEGER" column="parent_id"/>
        <result property="name" jdbcType="VARCHAR" column="name"/>
        <result property="otherProperties" jdbcType="VARCHAR" column="other_properties"/>
    </resultMap>
    
    <sql id="Base_Column_List">
        id, parent_id, name, other_properties
    </sql>

    <sql id="Alias_Column_List1">
        lt1.id lt1_id, lt1.parent_id lt1_parent_id, lt1.name lt1_name, lt1.other_properties lt1_other_properties
    </sql>

    <sql id="Alias_Column_List2">
        lt2.id lt2_id, lt2.parent_id lt2_parent_id, lt2.name lt2_name, lt2.other_properties lt2_other_properties
    </sql>

    <sql id="Alias_Column_List3">
        lt3.id lt3_id, lt3.parent_id lt3_parent_id, lt3.name lt3_name, lt3.other_properties lt3_other_properties
    </sql>

    <!-- Mysql连接查询语句(不能使用lt1.id形式，需要用别名区分) -->
    <resultMap id="BaseResultWithNextLevelMap" type="com.xch.pojo.LevelTreeExtra">
        <id property="id" jdbcType="INTEGER" column="lt1_id"/>
        <result property="parentId" jdbcType="INTEGER" column="lt1_parent_id"/>
        <result property="name" jdbcType="VARCHAR" column="lt1_name"/>
        <result property="otherProperties" jdbcType="VARCHAR" column="lt1_other_properties"/>
        <collection property="nextLevelTreeList" ofType="com.xch.pojo.LevelTreeExtra">
            <id property="id" jdbcType="INTEGER" column="lt2_id"/>
            <result property="parentId" jdbcType="INTEGER" column="lt2_parent_id"/>
            <result property="name" jdbcType="VARCHAR" column="lt2_name"/>
            <result property="otherProperties" jdbcType="VARCHAR" column="lt2_other_properties"/>
            <collection property="nextLevelTreeList" ofType="com.xch.pojo.LevelTreeExtra">
                <id property="id" jdbcType="INTEGER" column="lt3_id"/>
                <result property="parentId" jdbcType="INTEGER" column="lt3_parent_id"/>
                <result property="name" jdbcType="VARCHAR" column="lt3_name"/>
                <result property="otherProperties" jdbcType="VARCHAR" column="lt3_other_properties"/>
            </collection>
        </collection>
    </resultMap>
    <!-- inner效果为必须有，left效果为可以有，where效果为限定查询开始层级 -->
    <select id="selectLevelTree1" resultMap="BaseResultWithNextLevelMap">
        select <include refid="Alias_Column_List1"/>,
        <include refid="Alias_Column_List2"/>,
        <include refid="Alias_Column_List3"/>
        from level_tree lt1
        inner join level_tree lt2
        on lt1.id = lt2.parent_id
        left join level_tree lt3
        on lt2.id = lt3.parent_id
        where lt1.parent_id = -1
    </select>

    <!-- Mybatis子查询语法(写法一) -->
    <resultMap id="BaseResultWithNextLevelMap1" type="com.xch.pojo.LevelTreeExtra" extends="BaseResultMap">
        <!-- 写法一：数据库列名(适用于单一参数) -->
        <collection property="nextLevelTreeList" column="id" select="selectLevelTree2"/>
    </resultMap>
    <select id="selectLevelTree2" parameterType="com.xch.pojo.LevelTreeExtra" resultMap="BaseResultWithNextLevelMap1">
        select <include refid="Base_Column_List"/>
        from level_tree
        where parent_id = #{parentId}
    </select>
    <!-- Mybatis子查询语法(写法二) -->
    <resultMap id="BaseResultWithNextLevelMap2" type="com.xch.pojo.LevelTreeExtra" extends="BaseResultMap">
        <!-- 写法二：{连接SQL需要的参数名=本SQL提供的数据库列名}，逗号分隔(适用于多个参数即封装为类，需有GET/SET函数) -->
        <collection property="nextLevelTreeList" column="{parentId=id}" select="selectLevelTree2"/>
    </resultMap>
    <select id="selectLevelTree22" parameterType="com.xch.pojo.LevelTree" resultMap="BaseResultWithNextLevelMap2">
        select <include refid="Base_Column_List"/>
        from level_tree
        where parent_id = #{parentId}
    </select>
    
    <!-- 业务层手动组装结构树 -->
    <select id="selectLevelTree3" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from level_tree
        where parent_id is not null
        <!-- 拼装过滤有效数据条件 -->
    </select>
    
</mapper>
/**
 * 组装结构树算法工具方法(可以抽离到公共工具类中定义)
 */
public List<LevelTreeExtra> fixLevelTreeExtra(List<LevelTreeExtra> levelTreeList) {
    // 入参判断(公共的工具方法，需要做强检验，确保健壮性/兼容性/适配性)
    Assert.notEmpty(levelTreeList, "不能组装空集合");
//    if (ObjectUtil.isEmpty(levelTreeList)) {
//        // 返回不可操作的空集合
//        Collections.emptyList();
//    }
    
    // 业务逻辑
    // 先进行JDK8新特性去重再按parentId分组
    Map<Integer, List<LevelTreeExtra>> levelTreeListMapByParentId = levelTreeList.stream()
            .distinct().collect(Collectors.groupingBy(LevelTreeExtra::getParentId));
    // 再递归(DFS)批量组装
    return fixDFS(levelTreeListMapByParentId);
}

/**
 * 递归(DFS)批量组装结果树
 */
public List<LevelTreeExtra> fixDFS(Map<Integer, List<LevelTreeExtra>> levelTreeListMapByParentId) {
    List<LevelTreeExtra> levelTreeExtraList = levelTreeListMapByParentId.get(-1);
    if (ObjectUtil.isEmpty(levelTreeExtraList)) {
        return Collections.emptyList();
    }
    
    levelTreeExtraList.forEach(levelTreeExtra -> DFS(levelTreeListMapByParentId, levelTreeExtra));
    return levelTreeExtraList;
}

/**
 * 递归函数(写法一：参数传递/写法二：调用传递，仅适用于调用者是递归方法体类本身，才可以用this)
 */
public void DFS(Map<Integer, List<LevelTreeExtra>> levelTreeListMapByParentId, LevelTreeExtra levelTreeExtra) {
    // 递归出口(判断的是当前状态的内容，通常判断为结束时，不再做操作)
    List<LevelTreeExtra> nextLevelTreeList = levelTreeListMapByParentId.get(levelTreeExtra.getId());
    if (ObjectUtil.isEmpty(nextLevelTreeList)) {
        return;
    }
    
    // 递归体
    levelTreeExtra.setNextLevelTreeList(nextLevelTreeList);
    nextLevelTreeList.forEach(nextLevelTree -> DFS(levelTreeListMapByParentId, nextLevelTree));
}

其中：

1、基本数据类型可以简写(全小写)代替完整包.类名（可以通过Idea跳转测试）

2、入参有多个时，mybatis接口层用@param("xxx")标注，映射文件SQL不用写入参类型

BB-X
关注
专栏目录
使用mybatis完成单表的增删改查操作（动态sql）
wangzhigang0926的博客
03-06 1310
MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。2.能简述一下动态sql 的执行原理不？其执行原理为，使用OGNL 从sql 参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql 的功能。
SqlSessionTemplate批量增删改查
人生就像一场戏
03-31 2901
public class BaseDao { @Autowired private SqlSessionTemplate sqlSessionTemplate; private final Logger logger = LoggerFactory.getLogger(this.getClass()); void batchInsert(St...
mybatis的sqlSessionTemplate批量写库数据插入
liaomingwu的专栏
05-31 1904
mybatis的sqlSessionTemplate批量数据插入，该方法的优势在于，不依赖于数据库的批量写入语法，采用单条数据写入，利用数据库的事务特性进行批量提交。
Mybatis动态sql 批量添加、删除、修改
weixin_41925271的博客
08-31 308
一旦某条数据出错，已经执行的不会回滚。
SqlSessionTemplate 批量增、删、改、查
04-12 526
SqlSessionTemplate 批量增、删、改、查
MyBatis从入门到放弃一：从SqlSession实现增删改查
weixin_33851177的博客
03-05 174
前言      开博客这是第一次写系列文章，从内心上讲是有点担心自己写不好，写不全，毕竟是作为java/mybatis学习的过程想把学习的路线和遇到的问题都总结下来，也让知识点在脑海里能形成一个体系。      开发环境     idea2016、mybatis3、SQLServer2012   pom.xml、mybatis.xml、log4j.properties    先贴上p...
Mybatis --- 自定义映射、特殊和动态SQL
乌云的博客
03-20 380
自定义映射、特殊和动态SQL
详解MyBatis直接执行SQL查询及数据批量插入
09-02
在使用时，需要注意SQL字符串的编写规范，理解#{}和${}的区别，以及合理利用`<foreach>`标签进行批量操作。这使得MyBatis不仅简化了数据库操作，也提升了开发效率。在实际应用中，应结合业务需求，合理选择查询方式...
MyBatis-动态SQL
weixin_54093951的博客
06-05 260
动态 SQL是MyBatis强大特性之一。极大的简化我们拼装SQL的操作。 2.choose标签–多条件分支判断 3.where标签 可以自动添加where关键字，并且可以帮你去除第一个and或or 4.set标签 可以帮我们生成关键字 set 并且可以去除最后一个逗号 5.foreach标签 动态 SQL 的另外一个常用的必要操作是需要对一个集合进行遍历，通常是在构建 IN 条件语句的时候。 当迭代列表、集合等可迭代对象或者数组时 – index是当前迭代的次数，item的值是本
MyBatis动态sql_trim自定义字符串截取
zhupengqq的博客
11-25 8896
MyBatis动态sql_trim自定义字符串截取 继续上次文章http://blog.csdn.net/zhupengqq/article/details/78632444 EmployeeMapperDynamicSQL.java package com.cn.mybatis.dao; import java.util.List; import com.cn.
MyBatis系列--动态SQL
qq_43404873的博客
11-18 904
动态SQL MyBatis提供对SQL语句动态组装的功能，动态SQL是MyBatis的强大特性之一，MyBatis3采用了功能强大的基于OGNL的表达式来完成动态SQL。 < if >:判断语句，用于单条件分支判断。 < choose >( < when >、< otherwise >):用于多条件分支判断 < where >、< trim >、< set >：辅助元素，用于处理一些SQL拼装、特殊字符问题。 < f
mybatisPlus的sqlSessionTemplate批量修改（与mybatis道理一致）
weixin_45502734的博客
03-16 3761
一、简单步骤解析 ①引入SqlSessionTemplate，mapper接口 ②根据需求写一个更新数据的批量处理方法（关掉自动提交，批次commit） ③将需要修改的数据对象list，传入批处理方法中处理（实际相当于传一个update的where条件内容） ④调用接口进行数据更新 ⑤测试+日志+数据展示 二、代码模块示例 ①引入SqlSessionTemplate，mapper接口 @Autowired private SqlSessionTemplate sqlSe
Java-使用sqlSessionTemplate实现批量更新-模拟mybatis 动态sql
康世行
10-14 1164
【代码】Java-使用sqlSessionTemplate实现批量更新-模拟mybatis 动态sql。
MyBatis学习笔记——批量sqlSession
热门推荐
shen的博客
09-05 1万+
BATCH模式 在全局配置文件的setting中，有一个属性可以设置ExecutorType的类型，默认为SIMPLE，但是通常我们不会在全局配置文件中进行设置。 在使用中，通常在获取SqlSession的时候加以参数进行配置，SqlSession openSession = sqlSessionFactory.openSession(ExecutorType.BATCH);，以往我们都是使用...
JavaWeb笔记——Mybatis的xml映射文件、动态SQL
threewsl的博客
08-09 1158
JavaWeb笔记——Mybatis的xml映射文件、动态SQL
Mybatis通过SqlSessionTemplate进行批量操作
Az201706的博客
09-19 616
Mybatis通过SqlSessionTemplate进行批量操作
MyBatis批量更新等SQL
mingyonghu的博客
09-28 1382
当我们需要对MySQL数据库中的数据进行批量更新时，可以采用以下方式进行更新，以下为mybatis配置的SQL语句。
mybatis操作product表实现增删查改
最新发布
10-01
在MyBatis中操作`product`表实现增删查改，通常会涉及以下几个步骤： 1. **映射文件**（*.xml或*.java.xml）: 首先需要在Mapper接口中定义针对`product`表的方法，比如`insertProduct`, `updateProduct`, `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BB-X

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

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

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

打赏作者

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

抵扣说明：

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

余额充值