springboot集成通用mapper（tk mybatis）

最新推荐文章于 2023-08-15 01:34:41 发布
最新推荐文章于 2023-08-15 01:34:41 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： mybatis 文章标签： tk mybatis springboot 通用mapper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24484911/article/details/103085599
版权

项目结构

base：基础结构

modules：测试代码

集成

1. pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>mapper</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mapper</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--spring-boot mybatis依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--Mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--添加tk-mapper依赖-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!--druid依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2. application.yml

server:
  port: 9999

#数据源配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: xxxxxx
    username: admin
    password: admin

mybatis:
  mapper-locations: classpath*:mapper/*Mapper.xml

# 打印sql日志
logging:
  level:
    com.example.mapper.modules.dao : debug

3. base包下的*Mapper接口

BaseMapper.java

package com.example.mapper.base;

/**
 * 基础通用mapper
 */
public interface BaseMapper<T> extends InsertMapper<T>,
        DeleteMapper<T>,
        UpdateMapper<T>,
        SelectMapper<T> {
}

DeleteMapper.java

package com.example.mapper.base;

import tk.mybatis.mapper.common.Marker;
import tk.mybatis.mapper.common.base.delete.DeleteByPrimaryKeyMapper;
import tk.mybatis.mapper.common.condition.DeleteByConditionMapper;
import tk.mybatis.mapper.common.ids.DeleteByIdsMapper;

/**
 * 基础删除功能mapper
 */
public interface DeleteMapper<T> extends Marker,
        tk.mybatis.mapper.common.base.delete.DeleteMapper<T>,
        DeleteByPrimaryKeyMapper<T>,
        DeleteByConditionMapper<T>,
        DeleteByIdsMapper<T> {
}

InsertMapper.java

package com.example.mapper.base;

import tk.mybatis.mapper.common.Marker;
import tk.mybatis.mapper.common.MySqlMapper;
import tk.mybatis.mapper.common.base.insert.InsertSelectiveMapper;

/**
 * 基础新增功能mapper
 */
public interface InsertMapper<T> extends Marker,
        tk.mybatis.mapper.common.base.BaseInsertMapper<T>,
        InsertSelectiveMapper<T>,
        MySqlMapper<T> {
}

SelectMapper.java

package com.example.mapper.base;

import tk.mybatis.mapper.common.Marker;
import tk.mybatis.mapper.common.base.select.*;
import tk.mybatis.mapper.common.condition.SelectByConditionMapper;
import tk.mybatis.mapper.common.condition.SelectCountByConditionMapper;
import tk.mybatis.mapper.common.example.SelectByExampleMapper;
import tk.mybatis.mapper.common.ids.SelectByIdsMapper;

/**
 * 基础查询功能mapper
 */
public interface SelectMapper<T> extends Marker,
        SelectOneMapper<T>,
        tk.mybatis.mapper.common.base.select.SelectMapper<T>,
        SelectAllMapper<T>,
        SelectCountMapper<T>,
        SelectByPrimaryKeyMapper<T>,
        ExistsWithPrimaryKeyMapper<T>,
        SelectByIdsMapper<T>,
        SelectByConditionMapper<T>,
        SelectCountByConditionMapper<T>,
        SelectByExampleMapper<T> {
}

UpdateMapper.java

package com.example.mapper.base;

import tk.mybatis.mapper.common.Marker;
import tk.mybatis.mapper.common.base.update.UpdateByPrimaryKeyMapper;
import tk.mybatis.mapper.common.base.update.UpdateByPrimaryKeySelectiveMapper;
import tk.mybatis.mapper.common.condition.UpdateByConditionMapper;
import tk.mybatis.mapper.common.condition.UpdateByConditionSelectiveMapper;
import tk.mybatis.mapper.common.example.UpdateByExampleSelectiveMapper;

/**
 * 基础修改功能mapper
 */
public interface UpdateMapper<T> extends Marker,
        UpdateByPrimaryKeyMapper<T>,
        UpdateByPrimaryKeySelectiveMapper<T>,
        UpdateByConditionMapper<T>,
        UpdateByConditionSelectiveMapper<T>,
        UpdateByExampleSelectiveMapper<T> {
}

测试

实体类：Teacher.java

package com.example.mapper.modules.entity;

import lombok.Data;

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;

/**
 * @Description 实体类属性类型不能是基本类型，如int要换成Integer
 */
@Data
@Table(name = "teacher")
public class Teacher implements Serializable {
    @Id
    private Integer id;
    private String name;
    private Integer age;
}

控制层：TeacherController.java

package com.example.mapper.modules.controller;

import com.example.mapper.modules.entity.Teacher;
import com.example.mapper.modules.service.ITeacherService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/mapper")
public class TeacherController {
    @Autowired
    private ITeacherService iTeacherService;

    // 查询记录
    // http://localhost:9999/mapper/selectTeacher
    @GetMapping("/selectTeacher")
    List<Teacher> selectTeacher() {
        return iTeacherService.selectTeacher();
    }

    // 添加记录
    // http://localhost:9999/mapper/insertTeacher
    @GetMapping("/insertTeacher")
    int insertTeacher() {
        return iTeacherService.insertTeacher();
    }

    // 删除记录
    // http://localhost:9999/mapper/deleteTeacher
    @GetMapping("/deleteTeacher")
    int deleteTeacher() {
        return iTeacherService.deleteTeacher();
    }

    // 修改记录
    // http://localhost:9999/mapper/updateTeacher
    @GetMapping("/updateTeacher")
    int updateTeacher() {
        return iTeacherService.updateTeacher();
    }
}

Service：ITeacherService.java

package com.example.mapper.modules.service;

import com.example.mapper.modules.entity.Teacher;

import java.util.List;

public interface ITeacherService {
    List<Teacher> selectTeacher();
    int insertTeacher();
    int deleteTeacher();
    int updateTeacher();
}

ServiceImpl：TeacherServiceImpl.java

测试了通用mapper的大部分使用方法，能满足一般需求

package com.example.mapper.modules.service;

import com.example.mapper.modules.dao.TeacherDao;
import com.example.mapper.modules.entity.Teacher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Condition;
import tk.mybatis.mapper.entity.Example;

import java.util.ArrayList;
import java.util.List;

@Service
public class TeacherServiceImpl implements ITeacherService {
    @Autowired
    private TeacherDao teacherDao;

    /**
     * @Description 查询
     *
     */
    @Override
    public List<Teacher> selectTeacher() {
        Teacher t = new Teacher();
        t.setId(1);
        t.setName("gaobo");

        /*select() 根据实体中的属性值进行查询*/
        // ==>  Preparing: SELECT id,name,age FROM teacher WHERE id = ? AND name = ?
        // ==> Parameters: 1(Integer), gaobo(String)
        List<Teacher> select = teacherDao.select(t);

        /*selectByPrimaryKey() 按照带有@id注解的字段作为条件，根据主键字段进行查询*/
        // ==>  Preparing: SELECT id,name,age FROM teacher WHERE id = ?
        // ==> Parameters: 1(Integer)
        Teacher teacher = teacherDao.selectByPrimaryKey(1);

        /*selectAll() 查询所有记录*/
        // ==>  Preparing: SELECT id,name,age FROM teacher
        List<Teacher> selectAll = teacherDao.selectAll();

        /*selectByExample() 根据Example条件进行查询*/
        Example example = new Example(Teacher.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("name","xxx");
        //==> Preparing: SELECT id,name,age FROM teacher WHERE ( name = ? )
        //==> Parameters: xxx(String)
        List<Teacher> selectByExample = teacherDao.selectByExample(example);

        /*selectCount() 根据实体中的属性查询总数*/
        // ==>  Preparing: SELECT COUNT(id) FROM teacher WHERE id = ? AND name = ?
        // ==> Parameters: 1(Integer), gaobo(String)
        int selectCount = teacherDao.selectCount(t);

        /*selectOne() 根据实体中的属性进行查询，只能有一个返回值，有多个结果是抛出异常*/
        // ==>  Preparing: SELECT id,name,age FROM teacher WHERE id = ? AND name = ?
        // ==> Parameters: 1(Integer), gaobo(String)
        Teacher selectOne = teacherDao.selectOne(t);

        /*根据主键字符串进行查询，类中只有存在一个带有@Id注解的字段*/
        // ==>  Preparing: SELECT id,name,age FROM teacher where id in (1,2)
        List<Teacher> selectByIds = teacherDao.selectByIds("1,2");

        /**
         * Condition 和Example的使用方法一模一样，即和selectByExample方法一样的
         * Condition 的出现是为了替代Example，因为Example有歧义
         */
        Condition condition = new Condition(Teacher.class);
        Condition.Criteria criteria2 = condition.createCriteria();
        criteria2.andEqualTo("name","xxx");
        List<Teacher> selectByCondition = teacherDao.selectByCondition(condition);


        return selectAll;

    }

    /**
     * @Description 添加
     *
     */
    @Override
    public int insertTeacher() {
        Teacher t = new Teacher();
        t.setId(4);
        t.setName("zhang");

        Teacher t2 = new Teacher();
        t2.setId(5);
        t2.setName("wang");

        /*
        *
        * 保存一个实体，null的属性也会保存，不会使用数据库默认值
        * ==>  Preparing: INSERT INTO teacher ( id,name,age ) VALUES( ?,?,? )
        * ==> Parameters: 4(Integer), zhang(String), null
        * */
        int insert = teacherDao.insert(t);

        List<Teacher> list = new ArrayList<>();
        list.add(t);
        list.add(t2);
        /*
         * 批量添加功能，实体必须包含`id`属性并且必须为自增列，id字段不需赋值
         * 想要测试的话，可以先暂时把id改成自增
         * 如果不是自增列不是id，见insertList源码，有解释
         * ==>  Preparing: INSERT INTO teacher ( name,age ) VALUES ( ?,? ) , ( ?,? )
         * ==> Parameters: zhang(String), null, wang(String), null
         * */
        int insertList = teacherDao.insertList(list);
        /*
         * 保存一个实体，null的属性不会保存，会使用数据库默认值
         * ==>  Preparing: INSERT INTO teacher ( id,name ) VALUES( ?,? )
         * ==> Parameters: 5(Integer), wang(String)
         * */
        int insertSelective = teacherDao.insertSelective(t2);
        /*
         * 限制为实体包含`id`属性并且必须为自增列，实体配置的主键策略无效
         * ==>  Preparing: INSERT INTO teacher ( name,age ) VALUES ( ?,? )
         * ==> Parameters: wang(String), null
         * */
        int insertUseGeneratedKeys = teacherDao.insertUseGeneratedKeys(t2);

        return 0;
    }

    @Override
    public int deleteTeacher() {
        Teacher t = new Teacher();
        t.setId(1);
        t.setName("zhang");

        /**
         * 根据实体属性作为条件进行删除
         * ==>  Preparing: DELETE FROM teacher WHERE id = ? AND name = ?
         * ==> Parameters: 1(Integer), zhang(String)
         */
        int delete = teacherDao.delete(t);

        // 参考selectByIds ==>  Preparing: DELETE FROM teacher where id in (1,2)
        int deleteByIds = teacherDao.deleteByIds("1,2");

        // 根据主键字段进行删除，即有@Id注解的字段 ==>  Preparing: DELETE FROM teacher WHERE id = ?
        int deleteByPrimaryKey = teacherDao.deleteByPrimaryKey(1);

        // 按条件删除，参考selectByCondition()
        // ==>  Preparing: DELETE FROM teacher WHERE ( name = ? )
        // ==> Parameters: xxx(String)
        Condition condition = new Condition(Teacher.class);
        Condition.Criteria criteria = condition.createCriteria();
        criteria.andEqualTo("name","xxx");
        int deleteByCondition = teacherDao.deleteByCondition(condition);

        return 0;
    }

    @Override
    public int updateTeacher() {
        Teacher t = new Teacher();
        t.setId(1);
        //t.setName("zhang");
        t.setAge(76);
        /**
         * 根据主键更新实体全部字段，null值会被更新
         * ==>  Preparing: UPDATE teacher SET id = id,name = ?,age = ? WHERE id = ?
         *  ==> Parameters: null, 76(Integer), 1(Integer)
         */
        int updateByPrimaryKey = teacherDao.updateByPrimaryKey(t);

        /**
         * 根据主键更新属性不为null的值
         * ==>  Preparing: UPDATE teacher SET id = id,age = ? WHERE id = ?
         * ==> Parameters: 76(Integer), 1(Integer)
         */
        int updateByPrimaryKeySelective = teacherDao.updateByPrimaryKeySelective(t);

        /**
         * 根据Condition条件更新实体`record`包含的全部属性，null值会被更新
         * ==>  Preparing: UPDATE teacher SET id = id,name = ?,age = ? WHERE ( name = ? )
         * ==> Parameters: null, 76(Integer), xxx(String)
         */
        Condition condition = new Condition(Teacher.class);
        Condition.Criteria criteria = condition.createCriteria();
        criteria.andEqualTo("name","xxx");
        teacherDao.updateByCondition(t,condition);

        /**
         * 根据Condition条件更新实体`record`包含的不是null的属性值
         * ==>  Preparing: UPDATE teacher SET id = id,age = ? WHERE ( name = ? )
         * ==> Parameters: 76(Integer), xxx(String)
         */
        teacherDao.updateByConditionSelective(t,condition);

        return 0;
    }
}

Dao：TeacherDao.java

package com.example.mapper.modules.dao;

import com.example.mapper.base.BaseMapper;
import com.example.mapper.modules.entity.Teacher;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

/**
 * @Description 正常的mybatis使用mapper.xml的方式编写sql语句
 *
 */
@Mapper
@Repository
public interface TeacherDao extends BaseMapper<Teacher> {

}

sql

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for teacher
-- ----------------------------
DROP TABLE IF EXISTS `teacher`;
CREATE TABLE `teacher`  (
  `id` int(9) NOT NULL,
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `age` int(3) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of teacher
-- ----------------------------
INSERT INTO `teacher` VALUES (1, 'gb', 76);

SET FOREIGN_KEY_CHECKS = 1;

 

注意

Condition condition = new Condition(UserEntity.class);
Condition.Criteria criteria = condition.createCriteria();
criteria.andEqualTo("key","123");

Condition相关的条件字段对应的是UserEntity实体类的属性，不是数据库中的字段名称，如：

key是UserEntity中的属性名，而数据库字段为KEY。

 

SD_54
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot-tkmapper:springboot集成mybatis,pageHelper,tkmapper
05-13
springboot-tkmapper springboot集成mybatis，pageHelper，tkmapper
TkMybatis的使用
zhiwenganyong的博客
03-12 1106
TKMybatis 是基于 Mybatis 框架开发的一个工具，内部实现了对单表的基本数据操作，只需要简单继承 TKMybatis 提供的接口，就能够实现无需编写任何 sql 即能完成单表操作。
这个坑踩一下：NoSuchMethodException: tk.mybatis.mapper.provider.base.BaseSelectP
lvshilei13134的专栏
07-04 262
以下是报错信息，弄了大半天，各种版本尝试都不行， tk.mybatis.spring.annotation.MapperScan; 配置方面也没有错误的。但运行就是报错。有跟我一样错误的如下 2019-07-04 15:53:42.775 [restartedMain] ERROR o.s.boot.SpringApplication -Application startup faile...
tk-mybatis使用介绍，springboot整合tk-mybatis、PageHelper实现分页查询
沐雨橙风ιε的博客
08-15 2182
目录第一步：准备数据库第二步：创建一个springboot项目 第三步：添加tk-mybatis的依赖第四步：修改配置文件第五步：创建数据库表对应的实体类第六步：持久层接口继承自Mapper接口第七步：使用tk-mybatis的API完成crud扩展：使用tk-mybatis整合PageHelper实现分页查询1、添加PageHelper依赖2、设置分页拦截器3、在所有代码之前开启分页创建数据库tkmybatis，然后执行以下脚本，为了方便起见，使用之前文章用的数据，也是我的歌单。 本篇文章将创建一个名
tk.mybatis 工具包的使用教程以及常用方法（步骤清晰，简单易懂）
桂秋拾貳
07-20 2002
tk.mybatis 工具包的使用教程以及常用方法（步骤清晰，简单易懂）
使用tk.mybatis.mapper.common下的接口方法实现类似JPA操作
qq_36599564的博客
11-07 1017
tk.mybatis.mapper.common包下提供有许多增删查改的接口方法，我们能直接使用或者对这些方法进行扩展使用来达到类似JPA操作数据库的效果。
详解Mybatis通用Mapper介绍与使用
08-27
目前通用mapper只支持对单表的操作，对单表的增删改查，无需在mapper.xml写对应的sql语句,只需要我们调用相应的接口，对于快速开发极为方便，感兴趣的小伙伴们可以参考一下
Springboot整合通用mapper过程解析
08-25
主要介绍了springboot整合通用mapper过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring-boot+tk.mybatis通用mapper
08-25
spring-boot+tk.mybatis通用mapper
TkMybatis通用Mapper逆向工程代码生成工具
08-06
TkMybatis通用Mapper逆向工程代码生成工具，Maven项目工具；
mybatis 通用mapper
11-25
mybatis 通用mapper
springboot整合tk-mybatis框架搭建
sun_luming的博客
01-11 736
项目结构截图放在文末了，图片太大怕影响观看体验，想模仿搭建项目的可以拉到底看下截图再动手不迟。 第一步：依赖 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
mysql mapper,Spring-boot集成通用Mapper（tk.mybatis）
weixin_33534991的博客
03-17 485
代码之前：如果你是搜索进来看到这里，那么说明你已经知道通用mapper了。如果你是翻到这里，并不了解通用mapper。你可以先自行百度或者看看https://gitee.com/free/Mapper，这里讲述了通用mapper的内容接下来我们看看怎样集成通用mapperstep1:引入相关依赖，这里采用springboot 【2.0.2.RELEASE】版本xsi:schemaLocation=...
【Mybatis】TKMybatis 介绍和使用
m0_67401499的博客
03-24 3911
目录 一、什么是 TKMybatis 二、TKMybatis 使用 2.1 Springboot 项目中加入依赖 2.2?使用讲解 2.2.1 实体类中使用 2.2.2 dao中使用 2.2.3 Service 层中使用 2.3 实际案例 2.3.1 dao 层使用 2.3.2 service 层使用 一、什么是 TKMybatis TKMybatis 是基于 Mybatis 框架开发的一个工具，内部实现了对单表的基本数据操作，只需要简单继承 TKMybatis 提供的接口，就能够实现无需编写任何 sql
tkmbatis 日志_TKmybatis的框架介绍及使用方法
weixin_35866747的博客
12-30 593
最近项目使用了SpringBoot+TKMytis框架，期间遇到一些问题，顺便记一下。一、框架配置配置的话非常简单，我用的是SpringBoot,直接引入：tk.mybatismapper-spring-boot-starter2.0.3-beta1tk.mybatismapper4.0.0Mybatis的以及分页插件等就不写了。创建一个BaseMapperpublic interface Bas...
MyBatis插件使用--通用Mapper
weixin_34407348的博客
02-14 361
原文链接：MyBatis插件使用--通用Mapper 通用Mapper可以简化CRUD操作，不必单独为每一Mapper指定CRUD接口所需jar包mapper-3.3.9.jar,persistence-api-1.0.jar XML配置 在spring配置文件中配置: <!-- 配置通用Mapper --> ...
springboot整合tkmybatis以及使用
热门推荐
evanYang的博客
08-27 1万+
经常用mybatis的的都知道，使用mybatis orm框架存在一个非常不友善的问题就是，就是每操作一个单表就需要自己手写一个xml文件，虽然说可以用工具生成xml和实体类可以解决这个问题，但是二次开发的时候对某个表字段进行修改的时候，生成xml文件就不现实啦。最近发现tkmybatis就非常好的解决了这个问题。在这里和大家分享一下。 框架配置 这里需要引用到的包 <!--mybat...
springboot融合redis、jpa、tkmybatis、jdbc
yang_zhong_rong的博客
08-07 270
springboot整合文件上传 @Controller public class FileController { @RequestMapping("/uploadFile") public String uploadFile(@RequestParam("fileimage")MultipartFile file , @RequestParam("userid") String userid, HttpServletRequest request) throws IOException
springboot 集成tkmybatis
最新发布
09-29
springboot集成tkmybatis的步骤很简单。首先，你需要在pom.xml文件中添加tkmybatis和mybatis-spring-boot-starter的依赖。然后，在application.properties或application.yml配置文件中配置tkmybatis的相关属性，例如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值