SpringBoot 自定义SQL执行器

最新推荐文章于 2024-05-18 22:56:20 发布
最新推荐文章于 2024-05-18 22:56:20 发布
阅读量2.6k 收藏 3
点赞数
分类专栏： 微服务springboot MyBaties(基础篇)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiwengang/article/details/102960590
版权

业务需求：自定义SQL执行器，获取当前连接MySQL8 包含多少个数据库，指定数据库包含多少个表。

先分析项目结构的构成:springboot +mybatis3 + mysql8 搭建的项目.

我惊喜的发现了一个：

根据上面的自动注入 编写自己的SQL 执行器，代码如下：


import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.builder.StaticSqlSource;
import org.apache.ibatis.exceptions.TooManyResultsException;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ResultMap;
import org.apache.ibatis.mapping.ResultMapping;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.scripting.LanguageDriver;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

/**
 * 自定义SQL 执行器
 *
 */
public class SQLActuator {
	private MSUtils msUtils = null;
	private SqlSession sqlSession = null;
	private SqlSessionFactory factory;

	public SqlSessionFactory getFactory() {
		return factory;
	}

	public void setFactory(SqlSessionFactory factory) {
		this.factory = factory;
	}

	/**
	 * 构造方法，默认缓存MappedStatement
	 *
	 * @param sqlSession
	 * @return
	 */
	public SQLActuator(SqlSessionFactory factory) {
		this.factory = factory;
		this.sqlSession = factory.openSession();
		this.msUtils = new MSUtils(sqlSession.getConfiguration());
	}

	/**
	 * 获取List中最多只有一个的数据
	 *
	 * @param list
	 *            List结果
	 * @param <T>
	 *            泛型类型
	 * @return
	 */
	private <T> T getOne(List<T> list) {
		if (list.size() == 1) {
			return list.get(0);
		} else if (list.size() > 1) {
			throw new TooManyResultsException(
					"Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
		} else {
			return null;
		}
	}

	/**
	 * 查询返回一个结果，多个结果时抛出异常
	 *
	 * @param sql
	 *            执行的sql
	 * @return
	 */
	public Map<String, Object> selectOne(String sql) {
		List<Map<String, Object>> list = selectList(sql);
		return getOne(list);
	}

	/**
	 * 查询返回一个结果，多个结果时抛出异常
	 *
	 * @param sql
	 *            执行的sql
	 * @param value
	 *            参数
	 * @return
	 */
	public Map<String, Object> selectOne(String sql, Object value) {
		List<Map<String, Object>> list = selectList(sql, value);
		return getOne(list);
	}

	/**
	 * 查询返回一个结果，多个结果时抛出异常
	 *
	 * @param sql
	 *            执行的sql
	 * @param resultType
	 *            返回的结果类型
	 * @param <T>
	 *            泛型类型
	 * @return
	 */
	public <T> T selectOne(String sql, Class<T> resultType) {
		List<T> list = selectList(sql, resultType);
		return getOne(list);
	}

	/**
	 * 查询返回一个结果，多个结果时抛出异常
	 *
	 * @param sql
	 *            执行的sql
	 * @param value
	 *            参数
	 * @param resultType
	 *            返回的结果类型
	 * @param <T>
	 *            泛型类型
	 * @return
	 */
	public <T> T selectOne(String sql, Object value, Class<T> resultType) {
		List<T> list = selectList(sql, value, resultType);
		return getOne(list);
	}

	/**
	 * 查询返回List<Map<String, Object>>
	 *
	 * @param sql
	 *            执行的sql
	 * @return
	 */
	public List<Map<String, Object>> selectList(String sql) {
		String msId = msUtils.select(sql);
		return sqlSession.selectList(msId);
	}

	/**
	 * 查询返回List<Map<String, Object>>
	 *
	 * @param sql
	 *            执行的sql
	 * @param value
	 *            参数
	 * @return
	 */
	public List<Map<String, Object>> selectList(String sql, Object value) {
		Class<?> parameterType = value != null ? value.getClass() : null;
		String msId = msUtils.selectDynamic(sql, parameterType);
		return sqlSession.selectList(msId, value);
	}

	/**
	 * 查询返回指定的结果类型
	 *
	 * @param sql
	 *            执行的sql
	 * @param resultType
	 *            返回的结果类型
	 * @param <T>
	 *            泛型类型
	 * @return
	 */
	public <T> List<T> selectList(String sql, Class<T> resultType) {
		String msId;
		if (resultType == null) {
			msId = msUtils.select(sql);
		} else {
			msId = msUtils.select(sql, resultType);
		}
		return sqlSession.selectList(msId);
	}

	/**
	 * 查询返回指定的结果类型
	 *
	 * @param sql
	 *            执行的sql
	 * @param value
	 *            参数
	 * @param resultType
	 *            返回的结果类型
	 * @param <T>
	 *            泛型类型
	 * @return
	 */
	public <T> List<T> selectList(String sql, Object value, Class<T> resultType) {
		String msId;
		Class<?> parameterType = value != null ? value.getClass() : null;
		if (resultType == null) {
			msId = msUtils.selectDynamic(sql, parameterType);
		} else {
			msId = msUtils.selectDynamic(sql, parameterType, resultType);
		}
		return sqlSession.selectList(msId, value);
	}

	/**
	 * 插入数据
	 *
	 * @param sql
	 *            执行的sql
	 * @return
	 */
	public int insert(String sql) {
		String msId = msUtils.insert(sql);
		return sqlSession.insert(msId);
	}

	/**
	 * 插入数据
	 *
	 * @param sql
	 *            执行的sql
	 * @param value
	 *            参数
	 * @return
	 */
	public int insert(String sql, Object value) {
		Class<?> parameterType = value != null ? value.getClass() : null;
		String msId = msUtils.insertDynamic(sql, parameterType);
		return sqlSession.insert(msId, value);
	}

	/**
	 * 更新数据
	 *
	 * @param sql
	 *            执行的sql
	 * @return
	 */
	public int update(String sql) {
		String msId = msUtils.update(sql);
		return sqlSession.update(msId);
	}

	/**
	 * 更新数据
	 *
	 * @param sql
	 *            执行的sql
	 * @param value
	 *            参数
	 * @return
	 */
	public int update(String sql, Object value) {
		Class<?> parameterType = value != null ? value.getClass() : null;
		String msId = msUtils.updateDynamic(sql, parameterType);
		return sqlSession.update(msId, value);
	}

	/**
	 * 删除数据
	 *
	 * @param sql
	 *            执行的sql
	 * @return
	 */
	public int delete(String sql) {
		String msId = msUtils.delete(sql);
		return sqlSession.delete(msId);
	}

	/**
	 * 删除数据
	 *
	 * @param sql
	 *            执行的sql
	 * @param value
	 *            参数
	 * @return
	 */
	public int delete(String sql, Object value) {
		Class<?> parameterType = value != null ? value.getClass() : null;
		String msId = msUtils.deleteDynamic(sql, parameterType);
		return sqlSession.delete(msId, value);
	}

	private class MSUtils {
		private Configuration configuration;
		private LanguageDriver languageDriver;

		private MSUtils(Configuration configuration) {
			this.configuration = configuration;
			languageDriver = configuration.getDefaultScriptingLanuageInstance();
		}

		/**
		 * 创建MSID
		 *
		 * @param sql
		 *            执行的sql
		 * @param sql
		 *            执行的sqlCommandType
		 * @return
		 */
		private String newMsId(String sql, SqlCommandType sqlCommandType) {
			StringBuilder msIdBuilder = new StringBuilder(sqlCommandType.toString());
			msIdBuilder.append(".").append(sql.hashCode());
			return msIdBuilder.toString();
		}

		/**
		 * 是否已经存在该ID
		 *
		 * @param msId
		 * @return
		 */
		private boolean hasMappedStatement(String msId) {
			return configuration.hasStatement(msId, false);
		}

		/**
		 * 创建一个查询的MS
		 *
		 * @param msId
		 * @param sqlSource
		 *            执行的sqlSource
		 * @param resultType
		 *            返回的结果类型
		 */
		private void newSelectMappedStatement(String msId, SqlSource sqlSource, final Class<?> resultType) {
			MappedStatement ms = new MappedStatement.Builder(configuration, msId, sqlSource, SqlCommandType.SELECT)
					.resultMaps(new ArrayList<ResultMap>() {
						{
							add(new ResultMap.Builder(configuration, "defaultResultMap", resultType,
									new ArrayList<ResultMapping>(0)).build());
						}
					}).build();
			// 缓存
			configuration.addMappedStatement(ms);
		}

		/**
		 * 创建一个简单的MS
		 *
		 * @param msId
		 * @param sqlSource
		 *            执行的sqlSource
		 * @param sqlCommandType
		 *            执行的sqlCommandType
		 */
		private void newUpdateMappedStatement(String msId, SqlSource sqlSource, SqlCommandType sqlCommandType) {
			MappedStatement ms = new MappedStatement.Builder(configuration, msId, sqlSource, sqlCommandType)
					.resultMaps(new ArrayList<ResultMap>() {
						{
							add(new ResultMap.Builder(configuration, "defaultResultMap", int.class,
									new ArrayList<ResultMapping>(0)).build());
						}
					}).build();
			// 缓存
			configuration.addMappedStatement(ms);
		}

		private String select(String sql) {
			String msId = newMsId(sql, SqlCommandType.SELECT);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			StaticSqlSource sqlSource = new StaticSqlSource(configuration, sql);
			newSelectMappedStatement(msId, sqlSource, Map.class);
			return msId;
		}

		private String selectDynamic(String sql, Class<?> parameterType) {
			String msId = newMsId(sql + parameterType, SqlCommandType.SELECT);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, parameterType);
			newSelectMappedStatement(msId, sqlSource, Map.class);
			return msId;
		}

		private String select(String sql, Class<?> resultType) {
			String msId = newMsId(resultType + sql, SqlCommandType.SELECT);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			StaticSqlSource sqlSource = new StaticSqlSource(configuration, sql);
			newSelectMappedStatement(msId, sqlSource, resultType);
			return msId;
		}

		private String selectDynamic(String sql, Class<?> parameterType, Class<?> resultType) {
			String msId = newMsId(resultType + sql + parameterType, SqlCommandType.SELECT);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, parameterType);
			newSelectMappedStatement(msId, sqlSource, resultType);
			return msId;
		}

		private String insert(String sql) {
			String msId = newMsId(sql, SqlCommandType.INSERT);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			StaticSqlSource sqlSource = new StaticSqlSource(configuration, sql);
			newUpdateMappedStatement(msId, sqlSource, SqlCommandType.INSERT);
			return msId;
		}

		private String insertDynamic(String sql, Class<?> parameterType) {
			String msId = newMsId(sql + parameterType, SqlCommandType.INSERT);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, parameterType);
			newUpdateMappedStatement(msId, sqlSource, SqlCommandType.INSERT);
			return msId;
		}

		private String update(String sql) {
			String msId = newMsId(sql, SqlCommandType.UPDATE);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			StaticSqlSource sqlSource = new StaticSqlSource(configuration, sql);
			newUpdateMappedStatement(msId, sqlSource, SqlCommandType.UPDATE);
			return msId;
		}

		private String updateDynamic(String sql, Class<?> parameterType) {
			String msId = newMsId(sql + parameterType, SqlCommandType.UPDATE);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, parameterType);
			newUpdateMappedStatement(msId, sqlSource, SqlCommandType.UPDATE);
			return msId;
		}

		private String delete(String sql) {
			String msId = newMsId(sql, SqlCommandType.DELETE);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			StaticSqlSource sqlSource = new StaticSqlSource(configuration, sql);
			newUpdateMappedStatement(msId, sqlSource, SqlCommandType.DELETE);
			return msId;
		}

		private String deleteDynamic(String sql, Class<?> parameterType) {
			String msId = newMsId(sql + parameterType, SqlCommandType.DELETE);
			if (hasMappedStatement(msId)) {
				return msId;
			}
			SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, parameterType);
			newUpdateMappedStatement(msId, sqlSource, SqlCommandType.DELETE);
			return msId;
		}
	}

}

通过配置文件实列化改SQL执行器：

import java.util.Properties;

import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.***.SQLActuator;
import com.github.pagehelper.PageHelper;

@Configuration
public class MyBatisConfig {
	@Autowired
	private SqlSessionFactory factory;
	
	/**
	 * 分页对象实列化
	 * @return
	 */
	@Bean
	public PageHelper pageHelper() {
		PageHelper pageHelper = new PageHelper();
		Properties p = new Properties();
		p.setProperty("offsetAsPageNum", "true");
		p.setProperty("rowBoundsWithCount", "true");
		p.setProperty("reasonable", "true");
		p.setProperty("dialect", "mysql");
		pageHelper.setProperties(p);
		return pageHelper;
	}
	
	/**
	 * 数据库执行SQL执行对象
	 */
	@Bean
	public SQLActuator getMapper(){
		SQLActuator mapper = new SQLActuator(factory);
		return mapper;
	}
	
}

 

在奋斗的大道
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot入门(14)：使用Mybatis-Plus轻松实现高效自定义SQL操作！
**My Coding Family**
08-20 3万+
如何使用Mybatis-Plus执行自定义SQL，一文教会你。
SpringBoot查询、自定义 SQL（多表关联查询）、添加、删除
weixin_44152682的博客
05-20 1446
查询 //mapper.selectList(null); QueryWrapper wrapper = new QueryWrapper(); // Map<String,Object> map = new HashMap<>(); // map.put("name","⼩红"); // map.put("age",3); // wrapper.allEq(map); // wrapper.gt("age",2); // wrapper.ne("name","⼩红"); // wr
在Springboot中如何直接执行SQL语句
最新发布
fengjing81的专栏
05-18 551
在Spring Boot 框架中，若要执行SQL 语句实现与数据库进行交互的操作。MyBatis-Plus支持自定义SQL方法，你可以在Mapper接口中继承BaseMapper，并定义自己的方法，然后在对应的XML文件中编写SQL语句。若依框架中MyBatis的Mapper接口通常会有对应的XML文件，你可以在这个文件中编写SQL语句。若使用框架集成了MyBatis-Plus，你可以通过Mapper接口来执行自定义的SQL语句。请根据你的实际需求选择合适的方法来执行SQL语句。
springBoot项目启动时自动执行指定sql
qq_42923605的博客
01-09 1051
创建目录 resources\db\mysql\migration 放入sql。首次运行会自动创建flyway_schema_history表格。当新的版本信息大于数据库版本信息的时候 会执行新的sql。里面会存放数据版本信息。
SpringBoot Mybatis 执行自定义SQL
weixin_30385925的博客
11-19 1538
1.XML中执行自定义SQL、 https://blog.csdn.net/u012427355/article/details/80654806 2.注解执行自定义SQL @Select("${_parameter}") @Results({ @Result(column = "id", property = "id"), @Resu...
在SpringBoot中自定义sql语句
newMan1024的博客
12-25 1万+
关于在SpringBoot中自定义Sql语句
针对springboot自定义sql语句（1）
木蒙的博客
08-13 2655
针对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实现拦截SQL分页
08-19
在 Springboot 中使用 MyBatis 实现拦截 SQL 分页可以通过自定义拦截器来实现。 MyBatis 拦截器机制 MyBatis 提供了插件机制，可以在 SQL 语句执行前、后、异常时等时刻进行拦截。插件可以拦截器可以拦截 SQL 语句...
springboot使用filter获取自定义请求头的实现代码
08-26
Filter 是一种可以在 Servlet 容器中执行的 Java 类，它可以在请求和响应之间执行某些操作。Filter 可以实现过滤请求和响应的数据，例如，检查和修改请求 headers、cookies、响应内容等。 知识点二：Spring Boot 中...
mybatis统计每条SQL的执行时间的方法示例
09-08
MyBatis虽然本身不直接提供SQL执行时间的统计功能，但我们可以利用Spring的AOP（面向切面编程）来实现。通过定义一个切面，我们可以对特定的Mapper接口方法进行拦截，在方法执行前后记录时间，从而得到执行时间。 ...
代码生成器tanghc2020 基础包 可自定义模板生成不同的代码，支持MySQL、Oracle、SQL Server
02-23
一款代码生成工具，可自定义模板生成不同的代码，支持MySQL、Oracle、SQL Server、PostgreSQL 首先联网安装docker 利用docker下载公共镜像 docker pull tanghc2020/gen:latest 下载完毕后，执行 docker run -...
spring+hibernate，自己封装了原生sql的处理，模仿mybatis使用
11-17
集成spring，hibernate，并且自写了一个sql的解析器，只有controller和service层，非常方便
mybatis慢SQL插件
07-19
拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL语句即可在数据库工具中执行。 使用方法： 找到你springboot项目中的配置文件，增加如下配置即可 application.yml 配置如下： sql: slow...
Spring Boot+MyBatis使用原生SQL，执行动态自定义SQL语句
热门推荐
益添的博客
06-08 3万+
因为项目中需要做一些操作，比如动态在数据库中创建表，动态给数据库添加字段等等；当时网上找了很多资料没看懂，后来看了一篇文章总算来了灵感，但没保存链接，所以一时没法贴出来。毕竟自己在做的过程中遇到了很多坎坷，所以就自己整理一下了。----------------------------------   割背景   -------------------------------------------...
SpringBoot项目中自己编写SQL语句并调用
于小猿的博客
04-11 10000
第一步：在 mapper 的接口中定义方法（使用到的PublishVo对象需要自己定义）： 第二步：在 mapper 对应的 xml 文件中写 SQL 语句： 注意：xml 文件中 select 标签的 id 属性就是上一步在 mapper 接口中定义的那个方法名，resultType 就是返回的类型，在上一步的 mapper 接口中的返回类型是自定义的实体类型 PublishVo，因此就写上实体类 PublishVo 的全路径。SQL语句的条件值要使用#，不能使用$，因为$会产生SQL注入问题
springboot使用EntityManager执行自定义SQL
iamlzyoco的博客
02-19 2977
1.在代码中注入 EntityManager import javax.persistence.EntityManager; @Autowired EntityManager entityManager; 2.在方法中具体使用EntityManager public List<DefColumn> findAllColumns(String table) { Query query = entityManager.createNativeQue.
SpringBoot+Mybatis实现自定义SQL,可视化SQL进行查询
Aliang的博客
07-04 813
SpringBoot+Mybatis实现自定义sql进行查询 Service接口 接口实现 Mapper.xml 共用查询Mapper 查询Service 接口调用 传参 效果图
mybaits整合springboot加载自定义sql
weixin_41673092的博客
10-13 144
mybaits加载外部sql。启动后加载sql。
sql执行器和存储引擎有啥区别
12-11
SQL执行器和存储引擎是MySQL中的两个核心组件，它们各自承担着不同的任务。 SQL执行器是MySQL的一个组件，它负责解析SQL语句，进行权限验证，生成执行计划，执行SQL语句并返回结果。SQL执行器是MySQL的核心组件之一，它的性能直接影响到MySQL的整体性能。 存储引擎是MySQL的另一个核心组件，它负责数据的存储和检索。MySQL支持多种存储引擎，如InnoDB、MyISAM等。每种存储引擎都有自己的特点和适用场景，用户可以根据自己的需求选择不同的存储引擎。 因此，SQL执行器和存储引擎是MySQL中两个不同的组件，它们各自承担着不同的任务，但是它们之间是相互协作的，SQL执行器会将查询优化器和最优的查询路径交给底层的存储引擎去真正的执行SQL语句。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值