SpringBoot3整合MyBatis-Plus

已于 2024-04-21 01:59:17 修改
阅读量873 收藏 5
点赞数 8
文章标签： springboot mybatis
于 2024-04-21 01:57:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46496775/article/details/138017557
版权
  1. 准备数据
CREATE TABLE `t_user`
(
    id BIGINT NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

INSERT INTO `t_user` (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

  1. 导入依赖
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.5</version>
    <relativePath/>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <!-- 3.5.4开始，支持 Spring Boot3 使用此版本 -->
        <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
        <version>3.5.5</version>
    </dependency>
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

  1. 查看源码可知 MybatisPlusAutoConfiguration 已经为我们配置好了 SqlSessionFactory、SqlSessionTemplate 等组件。
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisPlusProperties.class)
@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisPlusLanguageDriverAutoConfiguration.class})
public class MybatisPlusAutoConfiguration implements InitializingBean {

    private final List<ConfigurationCustomizer> configurationCustomizers;

    @Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
        factory.setDataSource(dataSource);


    @Bean
    @ConditionalOnMissingBean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        ExecutorType executorType = this.properties.getExecutorType();
        if (executorType != null) {
            return new SqlSessionTemplate(sqlSessionFactory, executorType);
        } else {
            return new SqlSessionTemplate(sqlSessionFactory);
        }
    }

    @org.springframework.context.annotation.Configuration(proxyBeanMethods = false)
    @Import(AutoConfiguredMapperScannerRegistrar.class)
    @ConditionalOnMissingBean({MapperFactoryBean.class, MapperScannerConfigurer.class})
    public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {

        @Override
        public void afterPropertiesSet() {
            logger.debug(
                "Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
        }
    }

    private void applyConfiguration(MybatisSqlSessionFactoryBean factory) {
        MybatisPlusProperties.CoreConfiguration coreConfiguration = this.properties.getConfiguration();
        MybatisConfiguration configuration = null;
        if (coreConfiguration != null || !StringUtils.hasText(this.properties.getConfigLocation())) {
            configuration = new MybatisConfiguration();
        }
        if (configuration != null && coreConfiguration != null) {
            coreConfiguration.applyTo(configuration);
        }
        if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
            for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
                customizer.customize(configuration);
            }
        }
        factory.setConfiguration(configuration);
    }
}

public class SqlSessionTemplate implements SqlSession, DisposableBean {
    private final SqlSessionFactory sqlSessionFactory;
    private final ExecutorType executorType;
    private final SqlSession sqlSessionProxy;
    private final PersistenceExceptionTranslator exceptionTranslator;

    public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
    }

    public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
        this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));
    }

    public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
        Assert.notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
        Assert.notNull(executorType, "Property 'executorType' is required");
        this.sqlSessionFactory = sqlSessionFactory;
        this.executorType = executorType;
        this.exceptionTranslator = exceptionTranslator;
        this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionInterceptor());
    }

    public <T> T selectOne(String statement) {
        return this.sqlSessionProxy.selectOne(statement);
    }

    public <E> List<E> selectList(String statement, Object parameter) {
        return this.sqlSessionProxy.selectList(statement, parameter);
    }

    private class SqlSessionInterceptor implements InvocationHandler {
        private SqlSessionInterceptor() {
        }

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);

            Object unwrapped;
            try {
                Object result = method.invoke(sqlSession, args);
                if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
                    sqlSession.commit(true);
                }

                unwrapped = result;
            } catch (Throwable var11) {
                unwrapped = ExceptionUtil.unwrapThrowable(var11);
                if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
                    SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                    sqlSession = null;
                    Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);
                    if (translated != null) {
                        unwrapped = translated;
                    }
                }

                throw (Throwable)unwrapped;
            } finally {
                if (sqlSession != null) {
                    SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
                }

            }

            return unwrapped;
        }
    }
}
    

@Data
@Accessors(chain = true)
@ConfigurationProperties(prefix = "mybatis-plus")
public class MybatisPlusProperties {

    private static final ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();

    // Location of MyBatis xml config file.
    private String configLocation;

    // Locations of MyBatis mapper files.
    private String[] mapperLocations = new String[]{"classpath*:/mapper/**/*.xml"};

    // Packages to search type aliases.
    private String typeAliasesPackage;

    @Getter
    @Setter
    public static class CoreConfiguration {
        private Boolean mapUnderscoreToCamelCase;
        private Boolean callSettersOnNulls;


@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {

	private Class<? extends DataSource> type;

	private String driverClassName;

	private String url;

	private String username;

	private String password;

  1. 配置
# 配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/develop
    username: root
    password: 910199

# 以下配置也可以通过实现 ConfigurationCustomizer 接口对 MyBatis 的 Configuration 对象进行自定义配置
mybatis-plus:
  type-aliases-package: cn.xsu.boot.data.pojo		# 类型别名（typeAliases）
  configuration:
    map-underscore-to-camel-case: true	 # 开启驼峰命名自动映射
    call-setters-on-nulls: true		# 查询结果中包含空值的列，在映射的时候，不会映射这个字段

MyBatis-Plus 提供了一个 ConfigurationCustomizer 接口，允许我们在 MyBatis 的配置过程中进行自定义配置。通过实现这个接口，我们可以对 MyBatis 的 Configuration 对象进行自定义配置。

/**
 * Callback interface that can be customized a {@link MybatisConfiguration} object generated on auto-configuration.
 */
@FunctionalInterface
public interface ConfigurationCustomizer {

    /**
     * Customize the given a {@link MybatisConfiguration} object.
     *
     * @param configuration the configuration object to customize
     */
    void customize(MybatisConfiguration configuration);
}

public class MybatisConfiguration extends Configuration { 
    private static final Log logger = LogFactory.getLog(MybatisConfiguration.class);
    protected final MybatisMapperRegistry mybatisMapperRegistry;
    protected final Map<String, Cache> caches;
    protected final Map<String, ResultMap> resultMaps;
    protected final Map<String, ParameterMap> parameterMaps;
    protected final Map<String, KeyGenerator> keyGenerators;
    protected final Map<String, XNode> sqlFragments;
    protected final Map<String, MappedStatement> mappedStatements;
    private boolean useGeneratedShortKey;
}
public class Configuration {
    protected Environment environment;
    protected boolean safeRowBoundsEnabled;
    protected boolean safeResultHandlerEnabled;
    protected boolean mapUnderscoreToCamelCase;
    protected boolean aggressiveLazyLoading;
    protected boolean multipleResultSetsEnabled;
    protected boolean useGeneratedKeys;
    protected boolean useColumnLabel;
    protected boolean cacheEnabled;
    protected boolean callSettersOnNulls;
    protected boolean useActualParamName;
    protected boolean returnInstanceForEmptyRow;
    protected boolean shrinkWhitespacesInSql;
    protected boolean nullableOnForEach;
    protected boolean argNameBasedConstructorAutoMapping;
    protected String logPrefix;
    protected Class<? extends Log> logImpl;
    protected Class<? extends VFS> vfsImpl;
    protected Class<?> defaultSqlProviderType;
    protected LocalCacheScope localCacheScope;
    protected JdbcType jdbcTypeForNull;
    protected Set<String> lazyLoadTriggerMethods;
    protected Integer defaultStatementTimeout;
    protected Integer defaultFetchSize;
    protected ResultSetType defaultResultSetType;
    protected ExecutorType defaultExecutorType;
    protected AutoMappingBehavior autoMappingBehavior;
    protected AutoMappingUnknownColumnBehavior autoMappingUnknownColumnBehavior;
    protected Properties variables;
    protected ReflectorFactory reflectorFactory;
    protected ObjectFactory objectFactory;
    protected ObjectWrapperFactory objectWrapperFactory;
    protected boolean lazyLoadingEnabled;
    protected ProxyFactory proxyFactory;
    protected String databaseId;
    protected Class<?> configurationFactory;
    protected final MapperRegistry mapperRegistry;
    protected final InterceptorChain interceptorChain;
    protected final TypeHandlerRegistry typeHandlerRegistry;
    protected final TypeAliasRegistry typeAliasRegistry;
    protected final LanguageDriverRegistry languageRegistry;
    protected final Map<String, MappedStatement> mappedStatements;
    protected final Map<String, Cache> caches;
    protected final Map<String, ResultMap> resultMaps;
    protected final Map<String, ParameterMap> parameterMaps;
    protected final Map<String, KeyGenerator> keyGenerators;
    protected final Set<String> loadedResources;
    protected final Map<String, XNode> sqlFragments;
    protected final Collection<XMLStatementBuilder> incompleteStatements;
    protected final Collection<CacheRefResolver> incompleteCacheRefs;
    protected final Collection<ResultMapResolver> incompleteResultMaps;
    protected final Collection<MethodResolver> incompleteMethods;
    protected final Map<String, String> cacheRefMap;

在 Spring Boot 容器中放入一个 ConfigurationCustomizer 组件并实现自定义配置。

@Configuration
public class MyBatisConfig {

    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> {
            configuration.getTypeAliasRegistry().registerAliases("cn.xsu.boot.data.pojo");
            configuration.setMapUnderscoreToCamelCase(true);
        };
    }
}
@Configuration
public class MyBatisConfig implements ConfigurationCustomizer {

    @Override
    public void customize(MybatisConfiguration configuration) {
        configuration.getTypeAliasRegistry().registerAliases("cn.xsu.boot.data.pojo");
        configuration.setMapUnderscoreToCamelCase(true);
    }
}

  1. 编码

在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 mapper 文件夹。

@MapperScan(value = "cn.xsu.boot.data.mapper")
@SpringBootApplication
public class SpringBootDataApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext ioc = SpringApplication.run(SpringBootDataApplication.class, args);
        for (String name : ioc.getBeanDefinitionNames()) {
            System.out.println(name);
        }
    }
}

编写实体类 User：

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("t_user")
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

编写 mapper 包下的 UserMapper 接口：

public interface UserMapper extends BaseMapper<User> {
}

BaseMapper 接口通常定义了一些基本的数据库操作方法：

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

    // 插入一条记录到数据库中
    int insert(T entity);

    // 根据主键 ID 查询一条记录
    T selectById(Serializable id);

    // 根据主键 ID 删除一条记录
    int deleteById(Serializable id);

    // 根据主键 ID 更新一条记录
    int updateById(@Param("et") T entity);

    // 查询所有符合条件的记录列表
    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

    // 分页查询记录
    default <P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper) {
        page.setRecords(this.selectList(page, queryWrapper));
        return page;
    }
}

  1. 开始使用
@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @ResponseBody
    @GetMapping("/user/{id}")
    public User findUserById(@PathVariable Long id) {
        return userService.queryUserById(id);
    }
}

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryUserById(Long id) {
        return userMapper.selectById(id);
    }
}

Keqi19
关注
【SpringBoot】26、SpringBoot中整合MyBatis-Plus实现数据库操作
Asurplus
07-23 21万+
MyBatis 框架相信大家都用过，虽然 MyBatis 可以直接在 xml 中通过 SQL 语句操作数据库，很是灵活。但正其操作都要通过 SQL 语句进行，就必须写大量的 xml 文件，很是麻烦。于是 MyBatis-Plus 应运而生，作为 MyBatis 的增强工具，更是为我们开发效率得到了质的飞跃。 一、简介 1、MyBatis MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBa
SpringBoot整合MyBatis-Plus3.1详细教程
KHOST的博客
08-29 404
一.说明 Mybatis-Plus是一个Mybatis框架的增强插件,根据官方描述,MP只做增强不做改变,引入它不会对现有工程产生影响,如丝般顺滑.并且只需简单配置,即可快速进行 CRUD 操作,从而节省大量时间.代码生成,分页,性能分析等功能一应俱全,最新已经更新到了3.1.1版本了,3.X系列支持lambda语法,让我在写条件构造的时候少了很多的"魔法值",从代码结构上更简洁了. 二.项目...
spring boot3整合mybatis-plus
weixin_38716921的博客
12-18 4378
配置mybatis-plus之属性自动填充。配置mybatis-plus分页插件。编写业务逻辑测试代码。
Spring Boot3.3.X整合Mybatis-Plus
最新发布
qq_53376718的博客
08-15 1461
解决Spring boot整合mybatis-plus后不能实现mybatis-plus自带的方法，出现Invalid bound statement (not found)错误，仅需导入一个依赖轻松搞定
SpringBoot3整合Mybatis plus
qq_37170583的博客
04-13 1730
我们在main方法有个注解，配置我们的mapper类路径后，Spring Boot 会帮我们生成bean放到IOC容器中，这样我们就不用每个mapper类写一个@Mapper注解了。启动成功后，调用我们的接口，就能够获取数据了。我们使用postman调用截图如下：当我们在。
SpringBoot3整合MyBatisPlus
m0_51390969的博客
01-23 1719
甚至无法启动，摸爬滚打又游历社区后，实践后得到一套成功的版本搭配，具体如下。目前仍然处于维护升级阶段，最初。，里面使用的版本搭配如下。
Spring Boot3整合MyBatis Plus
蒾酒的博客
01-22 6961
⛰️个人主页: 蒾酒🔥系列专栏：《spring boot实战》目录1.前置条件2.导坐标3.配置数据源4.mybatis-plus基础配置5.配置mapper扫描路径6.配置分页拦截器7.MyBatis Plus代码生成器整合1.导坐标2.编写代码生成逻辑8.整合Druid连接池已经初始化好一个spring boot项目且版本为3X，项目可正常启动初始化教程：新版idea创建spring boot项目-CSDN博客https://blog.csdn.net/qq_62262918/article/
SpringBoot3整合Mybatis Plus3.5.3
一只如履薄冰的程序猿
07-06 8593
mybatis plus已经支持springboot3.x了，官方目前最新版的是3.5.3，最新版的配置更简单了一些，闲话不说，直接开干。
Spring Boot 3.x- MybatisPlus集成
laopeng301的专栏
05-09 1万+
系列文章目录 系列文章:Spring Boot 3.x 系列教程 文章目录系列文章目录简介一、快速开始1.数据库表和数据准备2.新增项目&导入依赖3.配置4.开发编码5.运行测试二、注解三、测试四、CRUDService CRUDMapper CRUD五、完整CRUD例子 简介 官网介绍: MyBatis-Plus （简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 一、快速开始 数据使用mysql 1.数据库表和数
springboot2.3 整合mybatis-plus 高级功能
08-18
Spring Boot 2.3 整合 MyBatis-Plus 高级功能 MyBatis-Plus 是一个基于 MyBatis 的增强工具，提供了许多高级功能来简化数据访问层的开发。Spring Boot 2.3 提供了完善的支持来整合 MyBatis-Plus，从而实现高效、...
SpringBoot整合Mybatis-Plus+Oracle+Mysql
01-05
本教程将深入探讨如何利用SpringBoot整合Mybatis-Plus，同时支持Oracle和MySQL数据库，并通过Nacos作为注册中心，以及使用Swagger2进行API文档的生成。 首先，让我们了解SpringBoot的核心优势。SpringBoot简化了...
SpringBoot整合MyBatis-Plus
06-17
让我们一起了解如何实现这个"SpringBoot整合MyBatis-Plus小Demo"。 首先，我们需要准备项目的基本结构。创建一个新的SpringBoot项目，引入MyBatis-Plus的相关依赖。在`pom.xml`文件中添加如下内容： ```xml ...
SpringBoot整合mybatis-plus实现多数据源的动态切换且支持分页查询.pdf
10-07
在SpringBoot项目中，整合Mybatis-Plus并实现多数据...以上就是SpringBoot整合Mybatis-Plus实现多数据源动态切换并支持分页查询的详细过程。这个实现方案能够有效地应对复杂的数据库环境，提高系统的灵活性和可扩展性。
3.基于SpringBoot3集成MybatisPlus及批量插入与分页查询及定制化代码生成器类
算法小生
08-25 917
org.springframework.boot.autoconfigure.AutoConfiguration.imports内容如下。至此，可以正常启动项目，集成MybatisPlus完毕，对于使用语法，可以去官网查询，后续我们将介绍特殊的一些用法。resources目录下新建META-INF.spring目录，然后新建文件。运行main方法根据提示创建包即可, 生成代码后我们在根据需要修改即可。在application-dev.yml配置错误打印SQL日志。欢迎关注公众号算法小生。
Spring Boot 3整合MyBatis Plus深度解析
weixin_52721608的博客
01-28 843
添加依赖配置数据源配置MyBatis Plus创建实体类、Mapper接口和Service层使用MyBatis Plus提供的便捷功能下面将详细讲解每个步骤。通过以上步骤，我们成功地在Spring Boot项目中整合了MyBatis Plus。这使得我们可以更方便地操作数据库，提高开发效率。希望本文能够帮助读者更好地理解和使用Spring Boot和MyBatis Plus。
【SpringBoot 3.x】整合Mybatis-Plus多数据源、Druid
太空眼睛的专栏
06-12 6557
查看DruidDataSourceAutoConfigure这个类的源码可以看出，需要把@Import带进来的几个类进行自动装配。由于排除了DruidDataSourceAutoConfigure类的自动装载，就需要手工指定装配以下几个类。可以看到多数据源已经配置成功了，并且加入了Druid监控。等其它类上，也可以放在具体类个方法上。注解指定使用的数据源，也可以放在。SpringBoot启动类修改。默认访问primary数据源。指定使用second数据源。
MyBatis-Plus介绍及Spring Boot 3集成指南
修己xj的博客
05-24 1149
官方地址：https://baomidou.com/github地址：https://github.com/baomidou/mybatis-plusMyBatis-Plus 是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作强大的 CRUD 操作。
springboot第三课------mybatis-plus
qq_56548971的博客
06-21 158
1.介绍 MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 但是对于联表操作还必须使用mybatis 2.特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：内置通用 Mapper、通
【SpringBoot3】Spring Boot 3.0 集成 Mybatis Plus
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
01-22 1万+
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
springboot3整合mybatis-plus
09-13
你好！要在Spring Boot中整合MyBatis-Plus，你可以按照以下步骤进行操作： 步骤1：添加依赖 在你的Spring Boot项目的pom.xml文件中，添加MyBatis-Plus的依赖： ```xml <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>最新版本号</version> </dependency> ``` 请确保将`最新版本号`替换为MyBatis-Plus最新的版本号。 步骤2：配置数据源 在application.properties（或application.yml）文件中，配置数据库连接信息，例如： ```yaml spring.datasource.url=jdbc:mysql://localhost:3306/db_example spring.datasource.username=db_username spring.datasource.password=db_password spring.datasource.driver-class-name=com.mysql.jdbc.Driver ``` 请将`db_example`、`db_username`和`db_password`分别替换为你的数据库名称、用户名和密码。 步骤3：创建实体类和Mapper接口 创建对应的实体类，并使用`@TableName`注解指定数据库表名。然后创建Mapper接口，继承自`BaseMapper`。 ```java import com.baomidou.mybatisplus.annotation.TableName; @TableName("user") public class User { private Long id; private String username; private String email; // getters and setters } ``` ```java import com.baomidou.mybatisplus.core.mapper.BaseMapper; public interface UserMapper extends BaseMapper<User> { } ``` 步骤4：编写Service和Controller层代码 在Service层中，可以通过注入Mapper对象来使用MyBatis-Plus提供的便捷方法。例如： ```java import org.springframework.stereotype.Service; import javax.annotation.Resource; @Service public class UserServiceImpl implements UserService { @Resource private UserMapper userMapper; @Override public User getUserById(Long id) { return userMapper.selectById(id); } // 其他业务逻辑方法 } ``` 在Controller层中，可以直接调用Service层的方法来处理请求。例如： ```java import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import javax.annotation.Resource; @RestController public class UserController { @Resource private UserService userService; @GetMapping("/users/{id}") public User getUserById(@PathVariable Long id) { return userService.getUserById(id); } // 其他请求处理方法 } ``` 这样，你就完成了Spring Boot与MyBatis-Plus的整合。你可以根据自己的需求，使用MyBatis-Plus提供的便捷方法来进行数据库操作。 希望对你有所帮助！如果还有其他问题，请继续提问。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值