AI 助理
文档备案控制台
开发者社区 数据库 文章 正文

Springboot整合mybatis框架（含实例Demo）

2018-06-24 3764
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 最近要交一份project项目作业，前后端分离，我负责后端，选用了Springboot+mybatis进行整合操作。一.前期准备:开发使用的IDE为IntelliJ IDEA:https://www.

最近要交一份project项目作业，前后端分离，我负责后端，选用了Springboot+mybatis进行整合操作。

一.前期准备:

开发使用的IDE为IntelliJ IDEA:https://www.jetbrains.com/idea/

maven仓库整合jar包：http://mvnrepository.com/artifact/org.apache.maven/maven-plugin-api/3.5.3

下完上述两样后，IDEA安装略，我们开始使用IDEA配置默认的maven库


img_878cb6bd184a739ea27636555d5c79d0.gif
准备.gif

从GIF中可以看到，我们点击configure菜单项下的Project Defaults来设置项目的默认配置，从settings选项中，找到Maven库一栏，选择我们刚才下载好的maven仓库的安装目录。

创建好我们的数据表。数据库名为jiguo，表名为jiguo_user。


img_a253115d4d717416df8b3a31575ad2be.jpe
数据表.JPG

以上，前期准备就准备好啦。

二.项目结构一栏以及实现步骤。

img_7d38b5715daf9f2c524207e4dc735ac6.jpe
概览.JPG

实现步骤：
1.Springboot项目创建
2.在pom.xml中，使用maven架包导入mybatis依赖dependency
3.逆向工程，配置自己的generatorConfig逆向工程的配置文件，然后使用maven插件执行出来，逆向出DAO层还有Model层
4.在application.properties中，配置我们的数据源 mybatis所需要的配置
5.MyMapper接口的创建
6.service层代码的创建
7.创建controller，处理前端的请求。
8.启动文件中设置DAO层扫描，这样就能识别出DAO层注解
@MapperScan(basePackages = "com.example.sl.xxxxx.dao")

步骤一:Springboot项目创建

img_d5ef5a8387f5659ae20b49e245ee3583.jpe
1.1.JPG
img_3a4acddcb548180d8f6b4effda5ae933.jpe
1.2.JPG
img_996d6cc297889bc553f6e30d177e555a.jpe
1.3.JPG

完成创建一个名为demospringboot的项目

步骤二:在pom.xml中，使用maven架包导入mybatis等依赖

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example.sl</groupId>
    <artifactId>demospringboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demospringboot</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <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>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--alibaba-start-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!--alibaba-end-->

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.41</version>
        </dependency>
        <!--mybatis-start-->
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!--generator-->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.2</version>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>
        <!--mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>1.2.4</version>
        </dependency>
        <!--pagehelper-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!--mybatis-end-->

        <!-- 引入 redis 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

    </dependencies>

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

            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <configuration>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.29</version>
                    </dependency>
                    <dependency>
                        <groupId>tk.mybatis</groupId>
                        <artifactId>mapper</artifactId>
                        <version>4.0.0</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>

    </build>
</project>
img_835bbf14e2a1399e244f4ef51bb77bd1.jpe
2.1.JPG

import以后，我们导入了mybatis，mysql，阿里巴巴的sql检测插件，分页插件等。

步骤三:逆向工程，配置自己的generatorConfig(resource包下)逆向工程的配置文件，然后使用maven插件执行出来，逆向出DAO层还有Model层

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <!--1.jdbcConnection设置数据库连接-->
    <!--2.javaModelGenerator设置类的生成位置-->
    <!--3.sqlMapGenerator设置生成xml的位置-->
    <!--4.javaClientGenerator设置生成dao层接口的位置-->
    <!--5.table设置要进行逆向工程的表名以及要生成的实体类的名称-->


    <context id="default" targetRuntime="MyBatis3Simple" defaultModelType="flat">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>
        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="com.example.sl.demospringboot.util.MyMapper"/>
        </plugin>

        <!-- optional，旨在创建class时，对注释进行控制 -->
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <!--jdbc的数据库连接 -->
        <jdbcConnection
                driverClass="com.mysql.jdbc.Driver"
                connectionURL="jdbc:mysql://localhost:3306/jiguo?characterEncoding=utf-8"
                userId="root"
                password="root">
        </jdbcConnection>


        <!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>


        <!-- Model模型生成器,用来生成含有主键key的类，记录类 以及查询Example类
            targetPackage     指定生成的model生成所在的包名
            targetProject     指定在该项目下所在的路径
        -->
        <!--<javaModelGenerator targetPackage="com.mmall.pojo" targetProject=".\src\main\java">-->
        <javaModelGenerator targetPackage="com.example.sl.demospringboot.model" targetProject="./src/main/java">
            <!-- 是否允许子包，即targetPackage.schemaName.tableName -->
            <property name="enableSubPackages" value="false"/>
            <!-- 是否对model添加 构造函数 -->
            <property name="constructorBased" value="false"/>
            <!-- 是否对类CHAR类型的列的数据进行trim操作 -->
            <property name="trimStrings" value="true"/>
            <!-- 建立的Model对象是否 不可改变  即生成的Model对象不会有 setter方法，只有构造方法 -->
            <property name="immutable" value="false"/>
        </javaModelGenerator>

        <!--mapper映射文件生成所在的目录 为每一个数据库的表生成对应的SqlMap文件 -->
        <!--<sqlMapGenerator targetPackage="mappers" targetProject=".\src\main\resources">-->
        <sqlMapGenerator targetPackage="mappers" targetProject="./src/main/resources">
            <property name="enableSubPackages" value="false"/>
        </sqlMapGenerator>

        <!-- 客户端代码，生成易于使用的针对Model对象和XML配置文件 的代码
                type="ANNOTATEDMAPPER",生成Java Model 和基于注解的Mapper对象
                type="MIXEDMAPPER",生成基于注解的Java Model 和相应的Mapper对象
                type="XMLMAPPER",生成SQLMap XML文件和独立的Mapper接口
        -->

        <!-- targetPackage：mapper接口dao生成的位置 -->
        <!--<javaClientGenerator type="XMLMAPPER" targetPackage="com.mmall.dao" targetProject=".\src\main\java">-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.example.sl.demospringboot.dao" targetProject="./src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>

        <table tableName="jiguo_user" domainObjectName="User" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"></table>
        <!-- geelynote mybatis插件的搭建 -->
    </context>
</generatorConfiguration>

然后执行我们的mybatis插件


img_dcd79efe66061c3e63a7c832ac34340e.jpe
3.1.JPG

就发现我们的DAO层和model层已经创建好了。对应jiguo数据库中的
jiguo_user表。

四。在application.properties中，配置我们的数据源 mybatis所需要的配置

server.port=8080//服务器的端口号
#mysql链接配置
spring.datasource.url=jdbc:mysql://localhost:3306/jiguo
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.durid.initialsize=1

#mybatis配置
#首先是实体类所在的包的名字
mybatis.type-aliases-package=com.example.sl.demospringboot.model
mybatis.mapper-locations=classpath:mappers/*.xml
#mybatis使用resources的xml来映射数据库表，这里就是resources下的mappers包的所有xml文件

#MyMapper是继承了一些封装好的方法接口 CRUD
#mapper
#mappers 多个接口时逗号隔开 通配mappers
mapper.mappers=com.example.sl.demospringboot.util.MyMapper
mapper.not-empty=false
mapper.identity=MYSQL

#pagehelper 分页插件
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql

配置了服务器端口号，数据库的链接数据，以及mybatis的映射表关系，我们发现有一个MyMapper接口，是我们之前没创建的，这是一个通配mappers（封装了一些常用CRUD操作，可以通过实现接口来进行），在maven库中添加依赖的时候，我们已经添加了相关接口的库tk.mybatis。
所以我们执行步骤五。

五.MyMapper接口的创建

util包下，创建MyMapper接口:
MyMapper：

package com.example.sl.demospringboot.util;

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;

//自定义接口集成大牛给我们写好的数据层的接口类
public interface MyMapper<T> extends Mapper<T>,MySqlMapper<T> {

}

然后在DAO层继承这个接口。
UserMapper：

package com.example.sl.demospringboot.dao;

import com.example.sl.demospringboot.model.User;
import com.example.sl.demospringboot.util.MyMapper;

public interface UserMapper extends MyMapper<User> {
}

以上我们完成了DAO层和数据库的准备，然后我们开发我们的service层，业务层。

六.service层代码的创建
我们将UserMapper使用注解的方式，生成，减少内存消耗，再调用之前别人写好的接口方法，进行CRUD操作（自己定制的CRUD操作暂略）。
UserService:

package com.example.sl.demospringboot.service;

import com.example.sl.demospringboot.model.User;

import java.util.List;

public interface UserService {
    public List<User> findAll();
}

UserServiceImpl:

package com.example.sl.demospringboot.service;

import com.example.sl.demospringboot.dao.UserMapper;
import com.example.sl.demospringboot.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("userService")
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;
    @Override
    public List<User> findAll() {
        return userMapper.selectAll();
    }
}

七.创建controller，处理前端的请求

UserController:

package com.example.sl.demospringboot.controller;

import com.example.sl.demospringboot.model.User;
import com.example.sl.demospringboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping(value = "/user")
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/findAll")
    public List<User> findAllUser(){
        List<User> userlist=userService.findAll();
        return userlist;
    }
}

八..启动文件中设置DAO层扫描，这样就能识别出DAO层注解

@MapperScan(basePackages = "com.example.sl.xxxxx.dao")

package com.example.sl.demospringboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan(basePackages = "com.example.sl.demospringboot.dao")//这个注解注意一下 放DAO层的包名 对这个包下进行注入
public class DemospringbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemospringbootApplication.class, args);
    }
}

保存~后台完成

三.自定义一个login.html进行请求测试。(由于JS要跨域，这里不进行ajax请求了 这里我们直接使用表单 PS:本地可以将一个ajax请求的页面放在本地Apache容器中来解决）

login.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>login.html</title>
</head>
<body>
<form action="/user/findAll">
    <input type="submit" value="login">
</form>
</body>
</html>

然后运行~


img_40a5e8ff6e7e173492ed5fc16d1086fe.gif
演示.gif

测试完成~终于可以睡觉啦
以上demo收录在Ricardo-L-Song的github
喜欢就给个小吧，你的支持是对博主最大的支持。

文章标签：
云数据库 RDS MySQL 版
Java
数据库连接
关系型数据库
Spring
数据库
相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发，帮助IT从业者们通过“阿里云Web应用上云解决方案”，了解一个企业级Web应用上云的常见架构，了解如何构建一个高可用、可扩展的企业级应用架构。
MySQL数据库入门学习
本课程通过最流行的开源数据库MySQL带你了解数据库的世界。 &nbsp; 相关的阿里云产品：云数据库RDS MySQL 版 阿里云关系型数据库RDS（Relational Database Service）是一种稳定可靠、可弹性伸缩的在线数据库服务，提供容灾、备份、恢复、迁移等方面的全套解决方案，彻底解决数据库运维的烦恼。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/mysql&nbsp;
若花亦晨曦
目录
相关文章
Quan_Chen
|
XML Java 数据库连接
微服务——SpringBoot使用归纳——Spring Boot集成MyBatis——基于 xml 的整合
本教程介绍了基于XML的MyBatis整合方式。首先在`application.yml`中配置XML路径，如`classpath:mapper/*.xml`，然后创建`UserMapper.xml`文件定义SQL映射，包括`resultMap`和查询语句。通过设置`namespace`关联Mapper接口，实现如`getUserByName`的方法。Controller层调用Service完成测试，访问`/getUserByName/{name}`即可返回用户信息。为简化Mapper扫描，推荐在Spring Boot启动类用`@MapperScan`注解指定包路径避免逐个添加`@Mapper`
Quan_Chen
1138 0
2G冲浪词条
|
Java 数据库连接 数据库
Spring boot 使用mybatis generator 自动生成代码插件
本文介绍了在Spring Boot项目中使用MyBatis Generator插件自动生成代码的详细步骤。首先创建一个新的Spring Boot项目，接着引入MyBatis Generator插件并配置`pom.xml`文件。然后删除默认的`application.properties`文件，创建`application.yml`进行相关配置，如设置Mapper路径和实体类包名。重点在于配置`generatorConfig.xml`文件，包括数据库驱动、连接信息、生成模型、映射文件及DAO的包名和位置。最后通过IDE配置运行插件生成代码，并在主类添加`@MapperScan`注解完成整合
2G冲浪词条
1728 1
Spring boot 使用mybatis generator 自动生成代码插件
啦啦啦191
|
Java 数据库连接 API
Java 对象模型现代化实践 基于 Spring Boot 与 MyBatis Plus 的实现方案深度解析
本文介绍了基于Spring Boot与MyBatis-Plus的Java对象模型现代化实践方案。采用Spring Boot 3.1.2作为基础框架，结合MyBatis-Plus 3.5.3.1进行数据访问层实现，使用Lombok简化PO对象，MapStruct处理对象转换。文章详细讲解了数据库设计、PO对象实现、DAO层构建、业务逻辑封装以及DTO/VO转换等核心环节，提供了一个完整的现代化Java对象模型实现案例。通过分层设计和对象转换，实现了业务逻辑与数据访问的解耦，提高了代码的可维护性和扩展性。
啦啦啦191
542 1
蓝易云
|
SQL Java 数据库
解决Java Spring Boot应用中MyBatis-Plus查询问题的策略。
保持技能更新是侦探的重要素质。定期回顾最佳实践和新技术。比如，定期查看MyBatis-Plus的更新和社区的最佳做法，这样才能不断提升查询效率和性能。
蓝易云
847 1
Unfailed_realme
|
SQL Java 数据库连接
Spring、SpringMVC 与 MyBatis 核心知识点解析
我梳理的这些内容，涵盖了 Spring、SpringMVC 和 MyBatis 的核心知识点。 在 Spring 中，我了解到 IOC 是控制反转，把对象控制权交容器；DI 是依赖注入，有三种实现方式。Bean 有五种作用域，单例 bean 的线程安全问题及自动装配方式也清晰了。事务基于数据库和 AOP，有失效场景和七种传播行为。AOP 是面向切面编程，动态代理有 JDK 和 CGLIB 两种。 SpringMVC 的 11 步执行流程我烂熟于心，还有那些常用注解的用法。 MyBatis 里，#{} 和 ${} 的区别很关键，获取主键、处理字段与属性名不匹配的方法也掌握了。多表查询、动态
Unfailed_realme
381 0
Quan_Chen
|
Java 微服务 Spring
微服务——SpringBoot使用归纳——Spring Boot中使用拦截器——拦截器使用实例
本文主要讲解了Spring Boot中拦截器的使用实例，包括判断用户是否登录和取消特定拦截操作两大场景。通过token验证实现登录状态检查，未登录则拦截请求；定义自定义注解@UnInterception实现灵活取消拦截功能。最后总结了拦截器的创建、配置及对静态资源的影响，并提供两种配置方式供选择，帮助读者掌握拦截器的实际应用。
Quan_Chen
945 0
Quan_Chen
|
XML Java 数据库连接
微服务——SpringBoot使用归纳——Spring Boot集成MyBatis——基于注解的整合
本文介绍了Spring Boot集成MyBatis的两种方式：基于XML和注解的形式。重点讲解了注解方式，包括@Select、@Insert、@Update、@Delete等常用注解的使用方法，以及多参数时@Param注解的应用。同时，针对字段映射不一致的问题，提供了@Results和@ResultMap的解决方案。文章还提到实际项目中常结合XML与注解的优点，灵活使用两者以提高开发效率，并附带课程源码供下载学习。
Quan_Chen
1200 0
潜意识Java
|
前端开发 Java 数据库连接
Java后端开发-使用springboot进行Mybatis连接数据库步骤
本文介绍了使用Java和IDEA进行数据库操作的详细步骤，涵盖从数据库准备到测试类编写及运行的全过程。主要内容包括： 1. **数据库准备**：创建数据库和表。 2. **查询数据库**：验证数据库是否可用。 3. **IDEA代码配置**：构建实体类并配置数据库连接。 4. **测试类编写**：编写并运行测试类以确保一切正常。
潜意识Java
901 2
java冯坚持
|
Java 数据库连接 Maven
mybatis使用一：springboot整合mybatis、mybatis generator，使用逆向工程生成java代码。
这篇文章介绍了如何在Spring Boot项目中整合MyBatis和MyBatis Generator，使用逆向工程来自动生成Java代码，包括实体类、Mapper文件和Example文件，以提高开发效率。
java冯坚持
875 2
mybatis使用一：springboot整合mybatis、mybatis generator，使用逆向工程生成java代码。
java冯坚持
|
SQL JSON Java
mybatis使用三：springboot整合mybatis，使用PageHelper 进行分页操作，并整合swagger2。使用正规的开发模式：定义统一的数据返回格式和请求模块
这篇文章介绍了如何在Spring Boot项目中整合MyBatis和PageHelper进行分页操作，并且集成Swagger2来生成API文档，同时定义了统一的数据返回格式和请求模块。
java冯坚持
1011 1
mybatis使用三：springboot整合mybatis，使用PageHelper 进行分页操作，并整合swagger2。使用正规的开发模式：定义统一的数据返回格式和请求模块

热门文章

最新文章

  • 1
    SpringBoot+async异步调用接口以及几个任务同时完成和异步接口实现和调用
  • 2
    Netty(一) SpringBoot 整合长连接心跳机制（下）
  • 3
    Idea启动SpringBoot程序报错：Veb server failed to start. Port 8082 was already in use；端口冲突的原理与解决方案
  • 4
    Java：SpringBoot获取所有接口的路由映射关系
  • 5
    springboot打成jar包，在windows上运行出现乱码
  • 6
    SpringBoot整合MinIO
  • 7
    SpringBoot2 整合MinIO中间件，实现文件便捷管理
  • 8
    探索 Elasticsearch 8：利用 Spring Boot 3 和 Spring Data Elasticsearch5
  • 9
    Springboot+shiro,完整教程，带你学会shiro
  • 10
    Springboot 最简单的发送邮件（文本、附件、图片）实战案例
  • 1
    Mybatis基础使用知识（注解）
    598
  • 2
    MyBatis分页
    433
  • 3
    MyBatis 持久层框架技术详解与实践指南
    431
  • 4
    MyBatis 的映射关系
    517
  • 5
    MyBatis的常见配置
    857
  • 6
    区分iBatis与MyBatis：两个Java数据库框架的比较
    878
  • 7
    通过MyBatis的XML配置实现灵活的动态SQL查询
    630
  • 8
    SSM相关问题-1--#{}和${}有什么区别吗？--Mybatis都有哪些动态sql？能简述一下动 态sql的执行原理吗？--Spring支持的几种bean的作用域 Scope
    524
  • 9
    MyBatis框架如何处理字符串相等的判断条件。
    821
  • 10
    踩坑与成长：WordPress、MyBatis-Plus 及前端依赖问题解决记录
    458

    • 相关课程

    更多
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战
  • MyBatis持久层框架入门

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！