SpringBoot整合Mybatis注解动态SQL增删改查

最新推荐文章于 2024-05-11 11:02:38 发布
最新推荐文章于 2024-05-11 11:02:38 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41520636/article/details/119672008
版权

零、知识介绍

动态SQL其实就是硬编码，不用xml方式，不用注解方式，可以更加灵活多变的使用java代码进行判断，业务逻辑处理生成一个SQL。
硬编码的执行速度比xml方式快，并且可以进行debug盘查错误，较全注解方式更加灵活，并且可读性高，缺点可能就是不流行，不能和xml接口一起使用，mybatis 3.4以上支持 多参数，3.4以下，只能使用map传值。
因为是生成字符串SQL，依然存在SQL注入问题，所以必须使用 " username = #{username}"，不能使用 " username = " + username 方式

一、依赖准备

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.1.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>

		<!--SpingBoot集成junit测试的起步依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!--mybatis起步依赖-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.1.1</version>
		</dependency>

		<!-- MySQL连接驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		
	</dependencies>

二、配置准备

application.yml

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123
  mvc:
    view:
      suffix: .jsp
      prefix: /
  resources:
    static-locations: classpath:templates
mybatis:
  type-aliases-package: com.hikktn.domain
  mapper-locations: classpath:mapper/*Mapper.xml
  configuration:
    map-underscore-to-camel-case: true #开启自动驼峰命名规则（camel case）映射
    lazy-loading-enabled: true #开启延时加载开关
    aggressive-lazy-loading: false #将积极加载改为消极加载（即按需加载）,默认值就是false
    lazy-load-trigger-methods: "" #阻挡不相干的操作触发，实现懒加载
    cache-enabled: true #打开全局缓存开关（二级环境），默认值就是true
logging:
  level:
   com.hikktn: debug
server:
  port: 8080
  servlet:
    context-path: /

log4j.properties

#---- global logging configuration
#---- level: FATAL,ERROR,WARN,INFO,DEBUG
#---- appender: console, file, mail
### set log levels ###
log4j.rootLogger=INFO,console
### 输出到控制台 ###
log4j.appender.stdout.encoding=UTF-8
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.out
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH\:mm\:ss} %5p %c{1}:%L - %m%n
### 输出到日志文件 ###
#log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.file.File=${webapp.root}/WEB-INF/logs/platform.log
#log4j.appender.file.DatePattern=_yyyyMMdd'.log'
#log4j.appender.file.Append = true
#log4j.appender.file.Threshold = INFO
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%-d{yyyy-MM-dd HH\:mm\:ss}  [ %t\:%r ] - [ %p ]  %m%n
### 打印SQL ###
#log4j.logger.com.ibatis=DEBUG
#log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=DEBUG
#log4j.logger.com.ibatis.common.jdbc.ScriptRunner=DEBUG
#log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
#log4j.logger.java.sql.ResultSet=DEBUG
#配置logger扫描的包路径  这样才会打印sql
log4j.logger.com.hikktn.mapper=DEBUG

三、数据准备

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'user', 'user');
INSERT INTO `user` VALUES (2, 'admin', 'admin');
INSERT INTO `user` VALUES (3, 'hikktn', 'hikktn0320');

SET FOREIGN_KEY_CHECKS = 1;

四、pojo准备

package com.hikktn.domain;

import java.io.Serializable;

public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;
    private String username;
    private String password;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

五、mapper接口准备

@Mapper
@Repository
public interface UserMapper {
    /**
	 * 动态查询
	 *
	 * @param param
	 * @return
	 */
	@SelectProvider(type = UserDynaSqlProviderBuilder.class, method = "buildSelectUserWithParam")
	public List<User> selectUserInfoWithParam(Map<String, Object> param);

	/**
	 * 动态增加,并自动获取自增主键
	 *
	 * @param user
	 * @return
	 */
	@InsertProvider(type = UserDynaSqlProviderBuilder.class, method = "buildInsertUser")
	@Options(useGeneratedKeys = true, keyColumn = "id", keyProperty = "id")
	public int insertUser(User user);

	/**
	 * 动态根据id查询
	 *
	 * @param param
	 * @return
	 */
	 @Results({
			@Result(column = "id",property = "id"),
			@Result(column = "username",property = "username"),
			@Result(column = "password",property = "password")
	})
	@SelectProvider(type = UserDynaSqlProviderBuilder.class, method = "buildSelectUserWithParam")
	public User selectUserWithId(Map<String, Object> param);

	/**
	 * 动态修改
	 *
	 * @param user
	 */
	@UpdateProvider(type = UserDynaSqlProviderBuilder.class, method = "buildUpdateUser")
	public int updateUser(User user);

	/**
	 * 动态删除
	 *
	 * @param param
	 */
	@DeleteProvider(type = UserDynaSqlProviderBuilder.class, method = "buildDeleteUser")
	public int deleteUser(Map<String, Object> param);
}

六、动态SQL准备

public class UserDynaSqlProviderBuilder {

	/**
	 * 动态查询
	 *
	 * @param param
	 * @return
	 */
	public String buildSelectUserWithParam(Map<String, Object> param) {
		return new SQL() {
			{
				SELECT("*");
				FROM("user");
				if (param.get("id") != null) {
					WHERE(" id = #{id} ");
				}
				if (param.get("username") != null) {
					WHERE(" username = #{username} ");
				}
				if (param.get("password") != null) {
					WHERE(" password = #{password} ");
				}
			}
		}.toString();
	}

	/**
	 * 动态增加
	 *
	 * @param user
	 * @return
	 */
	public String buildInsertUser(User user) {
		return new SQL() {
			{
				INSERT_INTO("user");
				if (user.getUsername() != null) {
					VALUES("username", "#{username}");
				}
				if (user.getPassword() != null) {
					VALUES("password", "#{password}");
				}
			}
		}.toString();
	}

	/**
	 * 动态修改
	 *
	 * @param user
	 * @return
	 */
	public String buildUpdateUser(User user) {
		return new SQL() {
			{
				UPDATE("user");
				if (user.getUsername() != null) {
					SET("username = #{username}");
				}
				if (user.getPassword() != null) {
					SET("password = #{password}");
				}
				WHERE(" id = #{id} ");
			}
		}.toString();
	}

	/**
	 * 动态删除
	 * @param param
	 * @return
	 */
	public String buildDeleteUser(Map<String, Object> param) {
		return new SQL() {
			{
				DELETE_FROM("user");
				if (param.get("id") != null) {
					WHERE(" id = #{id} ");
				}
				if (param.get("username") != null) {
					WHERE(" username = #{username}");
				}
			}
		}.toString();
	}
}

七、测试用例准备

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootMybatisApplication.class)
public class MybatisTest {
	@Autowired
	private UserMapper userMapper;
	/**
	 * 动态查询
	 */
	@Test
	public void testSelectUser() {
		Map<String, Object> map = new HashMap<>();
		map.put("id", "1");
		map.put("username", "user");
		map.put("password", "user");
		List<User> users = userMapper.selectUserInfoWithParam(map);
		System.out.println(users);
	}

	/**
	 * 动态增加
	 */
	@Test
	public void testInsertUser() {
		User user = new User();
		user.setUsername("hikktn");
		user.setPassword("123456");
		int result = userMapper.insertUser(user);
		System.out.println("插入成功，返回结果：" + result);
	}

	/**
	 * 动态修改
	 */
	@Test
	public void testUpdateUser() {
		Map<String, Object> map = new HashMap<>();
		map.put("id", "3");
		User user = userMapper.selectUserWithId(map);
		user.setUsername("hikktn");
		user.setPassword("hikktn0320");
		userMapper.updateUser(user);
	}

	/**
	 * 动态删除
	 */
	@Test
	public void testDeleteUser() {
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("username", "hikktn");
		userMapper.deleteUser(param);
	}
}

八、测试结果

查询结果
2021-08-13 11:56:46.283 DEBUG 400 --- [           main] c.h.m.U.selectUserInfoWithParam          : ==>  Preparing: SELECT * FROM user WHERE ( id = ? AND username = ? AND password = ? ) 
2021-08-13 11:56:46.299 DEBUG 400 --- [           main] c.h.m.U.selectUserInfoWithParam          : ==> Parameters: 1(String), user(String), user(String)
2021-08-13 11:56:46.322 DEBUG 400 --- [           main] c.h.m.U.selectUserInfoWithParam          : <==      Total: 1
[User{id=1, username='user', password='user'}]
增加结果
2021-08-13 12:12:03.155 DEBUG 796 --- [           main] com.hikktn.mapper.UserMapper.insertUser  : ==>  Preparing: INSERT INTO user (username, password) VALUES (?, ?) 
2021-08-13 12:12:03.175 DEBUG 796 --- [           main] com.hikktn.mapper.UserMapper.insertUser  : ==> Parameters: hikktn(String), 123456(String)
2021-08-13 12:12:03.181 DEBUG 796 --- [           main] com.hikktn.mapper.UserMapper.insertUser  : <==    Updates: 1
插入成功，返回结果：1
修改结果
2021-08-13 14:25:46.440 DEBUG 11172 --- [           main] c.h.mapper.UserMapper.selectUserWithId   : ==>  Preparing: SELECT * FROM user WHERE ( id = ? ) 
2021-08-13 14:25:46.458 DEBUG 11172 --- [           main] c.h.mapper.UserMapper.selectUserWithId   : ==> Parameters: 3(String)
2021-08-13 14:25:46.492 DEBUG 11172 --- [           main] c.h.mapper.UserMapper.selectUserWithId   : <==      Total: 1
2021-08-13 14:25:46.499 DEBUG 11172 --- [           main] com.hikktn.mapper.UserMapper.updateUser  : ==>  Preparing: UPDATE user SET username = ?, password = ? WHERE ( id = ? ) 
2021-08-13 14:25:46.499 DEBUG 11172 --- [           main] com.hikktn.mapper.UserMapper.updateUser  : ==> Parameters: hikktn(String), hikktn0320(String), 3(Long)
2021-08-13 14:25:46.516 DEBUG 11172 --- [           main] com.hikktn.mapper.UserMapper.updateUser  : <==    Updates: 1
删除结果
2021-08-13 14:26:49.140 DEBUG 14636 --- [           main] com.hikktn.mapper.UserMapper.deleteUser  : ==>  Preparing: DELETE FROM user WHERE ( username = ?) 
2021-08-13 14:26:49.160 DEBUG 14636 --- [           main] com.hikktn.mapper.UserMapper.deleteUser  : ==> Parameters: hikktn(String)
2021-08-13 14:26:49.170 DEBUG 14636 --- [           main] com.hikktn.mapper.UserMapper.deleteUser  : <==    Updates: 5
hikktn
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis拦截器修改sql语句
宿久
10-05 3万+
拦截器介绍 MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。 MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括： Executor (update, query, flushStatements, commit, rollback, getTransaction, close...
spring boot整合mybatis实现对MySQL数据库内容的增删改查
m0_62673956的博客
02-13 1289
1.spring boot SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程，提供了更好的体验。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。 Spring具有简单，可测试和松耦合等特点、不仅可以用于服务器端的开发，也可以应用F任何Java应用的开发中，Spring框架的主要优点如下:方便解耦，简化开发；方便集成各种优秀框架如Strut
针对springboot自定义sql语句（1）
木蒙的博客
08-13 2670
针对springboot自定义sql语句（1） 一、mapper层 在mapper层定义一个方法，加上注解@select，@insert, @update, @delete 如下图所示： @Select("SELECT `class_id` FROM `stuclass` WHERE `class_name` = #{className}") String getClassId(@Param("className") String className); 数据若返回单单一个string类型，注意得到的数
springboot整合mybatis批量插入数据至Mysql
Eddie-Wang的博客
06-21 3371
xml中sql语句如下： <insert id="batchAdd" parameterType="java.util.List"> insert into CW_PER_CON_TEMPLATES_COLS(ID, TEMPLATE_ID, CONDITON_NAME, LABEL_CODE, OPERATION, CONDITION_VALUE,...
基于 Spring-Jpa 的动态 Sql 工具类分享
最新发布
qq_45489824的博客
05-11 1227
在这里先贴一段代码如果项目用过 Spring-Jpa 的人对这种写法应该都不会陌生，反正我们公司是这样用的，每一个可能用到的查询字段都要手动写这样一段逻辑，算上 count 的话相似的逻辑要写4遍，笔者真的很讨厌这种重复度高的代码，所以在写了几次后就开始构思工具类来缓解这一情况。通过 Java 提供的反射特性动态判断每一个字段是否存在并拼装 sql使用自定义注解来标识需要查询的字段和字段对应的 sql 语句频繁获取反射方法会大大降低性能，关键的数据需要封装并存到缓存中。
springboot中给mybatis添加全局变量
cyw666a的博客
05-12 711
springboot中给mybatis添加全局变量
【Spring集成MyBatis】动态sql
passer__jw767的博客
11-24 1340
动态SQL的相关内容
SpringBoot整合MybatisPlus实战动态SQL
m0_63175850的博客
10-29 482
[]( )MyBatis的动态SQL是最令人喜欢的功能 ====================================================================================== 在了解 动态SQL之前，你首先得知道一个表达式 OGNL，这个是基础！ 面试常问问题 ： Mybatis 中$与#的区别？ #是将传入的值当做字符串的形式，select id,name,age from test where id =#{id},当把id值传入到后台的时候
Springboot 整合Mybatis +thymeleaf 实现增删改查，包含前端HTML页面
09-21
在本教程中，我们将深入探讨如何使用Spring Boot整合Mybatis和Thymeleaf来实现一个基本的CRUD（创建、读取、更新、删除）应用。这个实例特别适合初学者，因为它提供了一个从前端到后端完全功能的示例。 首先，...
SpringBoot整合MyBatis Plus实现增删改查教程
02-05
SpringBoot整合MyBatis Plus实现增删改查教程 本文将详细介绍如何使用 Spring Boot 框架和 MyBatis Plus 实现增删改查（CRUD）操作的教程。MyBatis Plus 是一个基于 MyBatis 的 ORM 框架，它提供了许多实用的功能来...
SpringBoot+mybatis+增删改查完整源码
09-02
在本项目中，我们主要探讨的是如何利用SpringBoot框架与Mybatis进行数据库的增删改查操作。SpringBoot以其简洁的配置和快速的启动能力，成为现代Java开发中的热门选择，而Mybatis作为轻量级的持久层框架，提供灵活的...
springboot+mybatis+mysql+layUI+thymeleaf实现增删改查
04-04
在本项目中，我们利用了SpringBoot、MyBatis、MySQL、LayUI和Thymeleaf这五种核心技术，构建了一个完整的Web应用程序，实现了学生信息管理系统的增删改查功能。下面将对这些技术及其在项目中的应用进行详细解释。 *...
SpringBoot+Mybatis对数据库的增删改查
09-28
本教程将深入探讨如何利用SpringBoot和Mybatis进行数据库的增删改查操作，以实现高效的数据管理。 首先，SpringBoot是由Pivotal团队提供的一个开源框架，它简化了Spring应用的初始搭建以及开发过程。SpringBoot通过...
spring + mybatis动态数据源并执行动态SQL
BT_1379716219的博客
01-16 965
在做数据采集的时候会从不同的数据库中获取数据，数据库的配置信息需要在前端页面配置后，保存到主库中，后续的采集操作需要查询主库里其他数据库的配置信息建立连接，执行指定的SQL要实现修改数据库配置后不重启服务的情况，且数据源理论上可以无限添加。
SpringBoot整合MybatisPlus实战动态SQL，保洁阿姨看完都会了
2301_77118221的博客
04-02 850
做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务的思想格局，未来你的路会走的更远。
spring整合mybatis之动态SQL
weixin_56941647的博客
10-25 885
动态SQL
MyBatis的动态拦截sql并修改
ewcc_ycl的博客
06-02 4469
动态拦截sql以注解实现
【MyBaits】SpringBoot整合MyBatis之动态SQL
qq_61903414的博客
05-13 1831
将查询语句中的where关键字使用该标签代替，通常与if标签搭配使用，它比传统的SQL中的关键字where优势是，如果所有的查询条件都没有则最终生成SQL语句时不生成没有条件的where，它会将紧跟这where的标签的第一个and删除比如where and会将and删除。如果我们要执行的SQL语句中不确定有哪些参数，此时我们如果使用传统的就必须列举所有的可能通过判断分支来解决这种问题，显示这是十分繁琐的。比如此时我们需要修改用户的信息，但是我们不知道用户修改了哪些信息时，我们就可以使用if标签。
springboot集成mybatis自定义拦截器实现SQL拼接改写
lucky_love816的博客
12-01 1283
这篇博文是项目中实战经验-代码片段
IDEA SpringBoot整合Mybatis-plus实现CRUD操作指南
"IDEA SpringBoot-Mybatis-plus 实现增删改查(CRUD)的文档主要介绍了如何在IntelliJ IDEA中使用SpringBoot集成Mybatis-plus进行数据操作，包括项目的创建、配置以及基本的CRUD操作。" 本文将详细阐述如何在IDEA中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

hikktn

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

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

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

打赏作者

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

抵扣说明：

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

余额充值