SpringBoot整合MyBatis中的技巧(基本的AOP配置以及创建自己的分页拦截器)

最新推荐文章于 2024-09-08 03:27:24 发布
最新推荐文章于 2024-09-08 03:27:24 发布
阅读量930 收藏 2
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45492007/article/details/104875764
版权

1.声明

当前的内容中主要是为了本人更加深度的学习并了解MyBatis中的内容，以及部分的SpringBoot中的内容！

1.实现目标创建自己的分页插件，分析使用Aspect方式实现和当前基于Mybatis的区别和优缺点

2.由于本人最近正在手动创建项目，所以只有部分代码！

1.1 pom文件

<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>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.5.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>SystemModel</groupId>
	<artifactId>SystemModel</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>SystemModel</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>RELEASE</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.46</version>
			<scope>runtime</scope>
		</dependency>
		<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.21</version>
		</dependency>
	</dependencies>
</project>

2.分析当前分页的参数传递

  1. 前台传递到Controller需要的参数为pageSize,currentPageNo;分别表示每页显示的条数，以及当前的页码
  2. Controller层接收到这个参数并调用Service层中的内容，最后Service层一般都会调用Mapper层中的内容，最后执行对应的XML文件
  3. 分析分页的SQL：一般表现形式为：Select ... from table 条件 limit startNum,pageSize
  4. 所以出现一个问题需要startNum参数，如果采用@Param方式注入参数需要写入两个参数，所以需要在传递参数的时候计算这个值

总结

1.我们可以通过拦截Controller层或者Service层以及Mapper层执行操作实现分页，但是需要实现分页的很多，有的需要条件，有的不需要条件，所以优点复杂，所以本人默认实现Map<String,Object>作为参数

3.本人的解决方案

1.由于Spring提供了AspectJ(切面)，通过创建需要分页的注解@Paged，来定制特定的方法拦截（本人拦截Controller方法），通过拦截获取的分页参数实现通用的参数注入，通过计算方式实现该分页结果(本人已经实现成功)

2.由于本人整合的是Mybatis，所以可以通过实现特定的拦截器方式实现分页操作，不需要特定的分页参数

4.基于本人解决方案一实现的分页结果

1.创建注解@Paged

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
/**
 * 	@description
 * 	当前注解用在那些需要被分页的数据中，
 * 	提供参数currentPageNo 表示当前的页码
 * 	提供参数pageSize 表示当前每页显示的条数
 * 	提供参数startNum 表示起始行
 * @author hy
 * @date 2020-03-11
 */
public @interface Paged {

}

2.在需要的Controller上添加注解@Paged

3.创建AOP切面类

@Slf4j
@Configuration
@Aspect
@Order(value = 3)
public class PagedAspectConfig {
	private static final String PAGED_ANNOTATAION_STRING = "com.hy.commons.systemmodel.annotataion.Paged";

	@Pointcut("@annotation(" + PAGED_ANNOTATAION_STRING + ")")
	void pagePointCut() {
	}

	@Autowired
	ServletRequest request;

	@Around("pagePointCut()")
	Object handlerBeforePaged(ProceedingJoinPoint pointcut) throws Throwable {
			// 主要通过request获取和处理分页参数和设定分页参数，pageSize,currentPageNo、statNum
			return pointcut.proceed();
	}

}

4.编写分页操作以及分页的sql

结果确实是实现的，但是缺点就是:每个SQL中还是要写#{startNum},#{pageSize}，而且当前的Mapper参数中还是需要@Param注解,并且在执行的时候，也会执行Count方法！缺点太多，不灵活，这个不推荐使用！

5.基于实现MyBatis的拦截器方式的参数(推荐使用这个)

1.创建需要配置的拦截器类，查看当前的MyBatis官方文档：MyBatis中Plugs的创建和添加
在这里插入图片描述

具体实现如下：

@Slf4j
@Intercepts({ @Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class,
		RowBounds.class, ResultHandler.class }) })
public class PageInterceptor implements Interceptor {
	@Autowired
	ServletRequest request;

	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		Object[] args = invocation.getArgs();
		MappedStatement mappedStatement = (MappedStatement) args[0];
		String fullExecutorString = mappedStatement.getId();
		if (fullExecutorString.contains("Page")) {
			// 我们就认为这个方法是一个需要被分页的方法
			args[2] = getCurrentRowBounds();
		}
		Object result = invocation.proceed();// 这里是让程序继续执行下去，并返回结果
		log.info("<==     Result:" + result);
		return result;
	}

	private RowBounds getCurrentRowBounds() {
		// 这里返回startNum和pageSize
		return new RowBounds((currentPageNo - 1) * pageSize, pageSize);
	}

这里我拦截的是Executor类中的query方法并且参数为：MappedStatement.class, Object.class,
RowBounds.class, ResultHandler.class

2.接下来配置这个拦截器,(主要在配置类中实现)

@Configuration
@PropertySource(value = { "db.properties" })
@MapperScan(basePackages = { "com.hy.commons.systemmodel.mapper" })
@EnableTransactionManagement
@ServletComponentScan 
public class SystemModelAppConfig {
	@Value("${url}")
	private String url;
	@Value("${dbname}")
	private String dbname;
	@Value("${dbpwd}")
	private String dbpwd;
	@Value("${driverClassName}")
	private String driverClassName;

	@Bean
	public DataSource configDataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setDriverClassName(driverClassName);
		dataSource.setUrl(url);
		dataSource.setUsername(dbname);
		dataSource.setPassword(dbpwd);
		return dataSource;
	}

	@Value("${mybatisTypeAliasesPackage}")
	private String mybatisTypeAliasesPackage;

	// 配置当前sql会话工厂
	@Bean
	public SqlSessionFactoryBean configSqlSessionFactoryBean() throws Exception {
		SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
		sqlSessionFactoryBean.setPlugins(configPageInterceptor());// 添加分页的插件
		sqlSessionFactoryBean.setDataSource(configDataSource());
		sqlSessionFactoryBean.setTypeAliasesPackage(mybatisTypeAliasesPackage);
		return sqlSessionFactoryBean;
	}
	
	@Bean
	public PageInterceptor configPageInterceptor() {
		return new PageInterceptor();
	}
}

修改SQL:Select … from table 条件，(我们直接使用这个就可以实现分页效果)

结果：
在这里插入图片描述
在这里插入图片描述

6.分析RowBounds的作用和用法

前面通过替换RowBounds的方式实现分页，发现SQL中没有LIMIT,所以可以发现当前的查询中可能出现先查询所有的数据然后跳过,导致的结果就是:数据量大跳过的数据量大，出现性能问题！

现在开始通过查看哪里使用了RowBounds
在这里插入图片描述
在这里插入图片描述

查看这个handleRowValues方法
在这里插入图片描述
然后分别查看handleRowValuesForNestedResultMap和handleRowValuesForSimpleResultMap方法，发现相同的问题

在这里插入图片描述
在这里插入图片描述

发现具有相同的方法shipRows方法，这个因该就是按照当前的条数实现跳过的方法
在这里插入图片描述
结果，就是这个样子，从返回的结果中获得指定的条数，通过跳过的方式实现，这个性能不好！会有问题！

7.替换MappedStatement来实现分页

@Slf4j
@Intercepts({ 
	@Signature(type = Executor.class, method = "query", args = { MappedStatement.class, Object.class,
		RowBounds.class, ResultHandler.class })
})
/*
 * @Signature(type = Executor.class, method = "query", args = {
 * MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class,
 * CacheKey.class, BoundSql.class })
 */
public class PageInterceptor implements Interceptor {
	@Autowired
	ServletRequest request;

	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		Object[] args = invocation.getArgs();
		MappedStatement mappedStatement = (MappedStatement) args[0];
		String fullExecutorString = mappedStatement.getId();
		if (!fullExecutorString.contains("Page")) {
			return invocation.proceed();
		}
		// 处理不是select的查询或者是
		if (SqlCommandType.SELECT != mappedStatement.getSqlCommandType()
				|| StatementType.CALLABLE == mappedStatement.getStatementType()) {
			return invocation.proceed();
		}
		Object result;

		// 我们就认为这个方法是一个需要被分页的方法
		/* args[2] = getCurrentRowBounds(); */

		// 修改当前的执行的statement

		args[0] = createNewMappedStatement(mappedStatement, args[1]);
		result = invocation.proceed();
		// 这里是让程序继续执行下去，并返回结果
		// 方法
		/* Object result = replaceWay(invocation); */
		log.info("<==     Result:" + result);
		return result;
	}

	private BoundSql createNewBoundSql(MappedStatement mappedStatement, BoundSql oldBoundSql, Object parameterObject) {
		String oldSql = oldBoundSql.getSql();
		List<ParameterMapping> parameterMappings = oldBoundSql.getParameterMappings();
		return createNewBoundSql(mappedStatement, oldSql, parameterMappings, parameterObject);
	}

	private BoundSql createNewBoundSql(MappedStatement mappedStatement, String oldSql,
			List<ParameterMapping> parameterMappings, Object parameterObject) {
		String createNewSql = concatPageSql(oldSql);
		return new BoundSql(mappedStatement.getConfiguration(), createNewSql, parameterMappings, parameterObject);
	}

	// 创建新的sql
	private String createNewSql(BoundSql boundSql) {
		String sqlString = boundSql.getSql();
		String pageSqlString = concatPageSql(sqlString);
		return pageSqlString;
	}

	private MappedStatement createNewMappedStatement(MappedStatement mappedStatement, Object parameterObject) {
		SqlSource sqlSource = mappedStatement.getSqlSource();
		BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
		String pageSqlString = createNewSql(boundSql);
		/* String pageSqlString = concatPageSql(sqlString); */

		List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
		// sqlSource一旦创建不能修改
		SqlSource newStaticSqlSource = new StaticSqlSource(mappedStatement.getConfiguration(), pageSqlString,
				parameterMappings);
		MappedStatement newMappedStatement = new MappedStatement.Builder(mappedStatement.getConfiguration(),
				mappedStatement.getId(), newStaticSqlSource, mappedStatement.getSqlCommandType())
						.resultMaps(mappedStatement.getResultMaps()).build();
		setMappedStatementProperty(mappedStatement, newMappedStatement);// 需要添加的配置
		return newMappedStatement;
	}

	private void setMappedStatementProperty(MappedStatement oldStatement, MappedStatement newStatement) {
		// current None properties
	}

	private String concatPageSql(String sql) {
		if (sql.contains(";")) {
			sql = sql.replace(";", "");
		}
		Map<String, Integer> pageMap = PageUtils.getPageMap(request);
		Integer pageSize = pageMap.get(PageUtils.PAGESIZE_STRING);
		Integer currentPageNo = pageMap.get(PageUtils.CURRENTPAGENO_STRING);
		log.info("==> PageParameters: " + PageUtils.PAGESIZE_STRING + "=" + pageSize + ","
				+ PageUtils.CURRENTPAGENO_STRING + "=" + currentPageNo);
		return new StringBuffer(sql).append("\n LIMIT " + ((currentPageNo - 1) * pageSize) + "," + pageSize).toString();
	}

	/*
	 * private RowBounds getCurrentRowBounds() { Map<String, Integer> pageMap =
	 * PageUtils.getPageMap(request); Integer pageSize =
	 * pageMap.get(PageUtils.PAGESIZE_STRING); Integer currentPageNo =
	 * pageMap.get(PageUtils.CURRENTPAGENO_STRING); log.info("==> PageParameters: "
	 * + PageUtils.PAGESIZE_STRING + "=" + pageSize + "," +
	 * PageUtils.CURRENTPAGENO_STRING + "=" + currentPageNo); return new
	 * RowBounds((currentPageNo - 1) * pageSize, pageSize); }
	 */
}

结果为：
在这里插入图片描述
发现实现了分页效果！但是需要重新构建当前的SqlSource(一旦构建就不能修改)和MappedStatement，其中MappedStatement中可能需要配置其他的参数,具有其他的可变性

8.使用executor方式实现分页效果

@Slf4j
@Intercepts(
	    {
	        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
	    }
	)
public class PageInterceptor implements Interceptor {
	@Autowired
	ServletRequest request;

	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		Object[] args = invocation.getArgs();
		MappedStatement mappedStatement = (MappedStatement) args[0];
		String fullExecutorString = mappedStatement.getId();
		if (!fullExecutorString.contains("Page")) {
			return invocation.proceed();
		}
		// 处理不是select的查询或者是
		if (SqlCommandType.SELECT != mappedStatement.getSqlCommandType()
				|| StatementType.CALLABLE == mappedStatement.getStatementType()) {
			return invocation.proceed();
		}
		
		Object parameterObject = args[1];
		RowBounds rowBounds = (RowBounds) args[2];
		@SuppressWarnings("rawtypes")
		ResultHandler resultHandler = (ResultHandler) args[3];
		Executor executor = (Executor) invocation.getTarget();
		Object result;
		BoundSql boundSql = mappedStatement.getBoundSql(parameterObject);
		CacheKey cacheKey = executor.createCacheKey(mappedStatement, parameterObject, rowBounds, boundSql);			
			// 使用替换方式执行
			/*
			 * args[0] = createNewMappedStatement(mappedStatement, args[1]); result =
			 * invocation.proceed();
			 */
		
		BoundSql newBoundSql = createNewBoundSql(mappedStatement, boundSql, parameterObject);
		result = executor.query(mappedStatement, parameterObject, rowBounds, resultHandler, cacheKey, newBoundSql);
		log.info("<==     Result:" + result);
		return result;
	}

	private BoundSql createNewBoundSql(MappedStatement mappedStatement, BoundSql oldBoundSql, Object parameterObject) {
		String oldSql = oldBoundSql.getSql();
		List<ParameterMapping> parameterMappings = oldBoundSql.getParameterMappings();
		return createNewBoundSql(mappedStatement, oldSql, parameterMappings, parameterObject);
	}

	private BoundSql createNewBoundSql(MappedStatement mappedStatement, String oldSql,
			List<ParameterMapping> parameterMappings, Object parameterObject) {
		String createNewSql = concatPageSql(oldSql);
		log.debug(createNewSql);
		return new BoundSql(mappedStatement.getConfiguration(), createNewSql, parameterMappings, parameterObject);
	}

	private String concatPageSql(String sql) {
		if (sql.contains(";")) {
			sql = sql.replace(";", "");
		}
		Map<String, Integer> pageMap = PageUtils.getPageMap(request);
		Integer pageSize = pageMap.get(PageUtils.PAGESIZE_STRING);
		Integer currentPageNo = pageMap.get(PageUtils.CURRENTPAGENO_STRING);
		log.info("==> PageParameters: " + PageUtils.PAGESIZE_STRING + "=" + pageSize + ","
				+ PageUtils.CURRENTPAGENO_STRING + "=" + currentPageNo);
		return new StringBuffer(sql).append("\n LIMIT " + ((currentPageNo - 1) * pageSize) + "," + pageSize).toString();
	}

	/*
	 * private RowBounds getCurrentRowBounds() { Map<String, Integer> pageMap =
	 * PageUtils.getPageMap(request); Integer pageSize =
	 * pageMap.get(PageUtils.PAGESIZE_STRING); Integer currentPageNo =
	 * pageMap.get(PageUtils.CURRENTPAGENO_STRING); log.info("==> PageParameters: "
	 * + PageUtils.PAGESIZE_STRING + "=" + pageSize + "," +
	 * PageUtils.CURRENTPAGENO_STRING + "=" + currentPageNo); return new
	 * RowBounds((currentPageNo - 1) * pageSize, pageSize); }
	 */
}

结果与上面的一致，但是这个方法比上面的要简单而且方便(本人建议使用这个方式)

9.总结

1.通过这个基本的分页操作发现，使用的时候应该尽量向使用的数据库工具靠近，可以很容易的达到自己的要求(例如使用MyBatis拦截器)，不要轻易地使用AOP编程(可能会导致其他的结果导致代码冗余)

2.通过编写自己的MyBatis拦截器，发现实现起来还是很容易的，一定要注意低耦合

3.编写程序的时候一定要先思考，会采用哪几种解决方案，最后再测试，发现各个方案的不足之处和各自的优点

4.尽量不要使用RowBounds方式实现分页，使用executor方式实现的分页效果好！

以上纯属个人见解，如有问题请联系本人！

编程写手
关注
专栏目录
【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拦截器
maying0124的博客
10-26 2026
mybatis 拦截器
mybatis 拦截器 + spring aop切面 + spring事务+ 反射工具类
02-10
内含有mybatis 拦截器实现的分页代码，spring 的事务和aop 测试、和反射工具类
Spring Boot实践 --Mybatis Interceptor 拦截器应用
造梦先森Kai的专栏
10-21 1144
通过 MyBatis 提供的强大机制，使用插件是非常简单的，只需实现 Interceptor 接口，并指定想要拦截的方法签名即可。//拦截器具体实现//拦截器的代理类//添加属性@Intercepts // 描述：标志该类是一个拦截器@Signature // 描述：指明该拦截器需要拦截哪一个接口的哪一个方法// @Signature注解中属性:type;// 四种类型接口中的某一个接口，如Executor.class；method;
springboot整合mybatis拦截器分页
最新发布
2401_86401114的博客
09-08 672
/ 当设置为true的时候，如果page size设置为0（或RowBounds的limit=0），就不执行分页，返回全部结果。// 详见 com.github.pagehelper.page.PageParams。log.info(“-------获取关注列表-------”);// RowBounds是否进行count查询 - 默认不查询。// 是否支持接口参数来传递分页参数，默认false。// 设置数据库方言 ， 也可以不设置，会动态获取。//获取自己关注列表。
SpringBoot中使用aop与mybatis实现日志管理
weixin_44294245的博客
08-04 657
Aop面向切面编程技术来实现接口日志监听，在不侵入业务代码逻辑的前提下实现了接口使用信息的监听与统计。并使用了mybatis将记录存储至数据库中，提高了代码的可复用性。
Spring Boot：2种实现MyBatis aop、手动动态数据源
HHM
07-10 1346
背景 mybatis、aop动态获取数据源方式比较简单，网上也有很多资料，结合我目前的项目有点不同，项目用的mybatis的前身ibatis。ibatis使用起来不如mybatis方便，还是需要orm框架。 首先说下场景，各大电商平台数据推送到各种财务系统，客户会使用erp把各平台的数据同步下来，我们所做的事情就是把erp的数据推送到各种财务系统（例：kingdee、kis、海典）。 我们会对每一个客户的数据进行处理，每个客户使用的系统和数据库都是不一样的。目前的做法是mysql数据库配置客户的数据库地址，
springBoot+mybatis读写分离（AOP）
04-02
springBoot+mybatis+AOP实现读写分离，在代码层面直接实现，无需任何插件，简单易懂，非常适合作为解决数据库并发大的解决方案
SpringBoot 整合Mybatis 创建临时表
02-06
下面我们将详细探讨如何在SpringBoot项目中整合Mybatis，以实现创建临时表的功能。 首先，我们需要在SpringBoot项目中引入Mybatis的相关依赖。在`pom.xml`文件中，添加如下Mybatis和其Spring Boot Starter的依赖： ...
springboot整合mybatis集成分页查询事务配置，页面模板
09-20
在本项目中，我们主要探讨的是如何在SpringBoot框架下整合MyBatis，实现数据库的分页查询，事务管理，并配置前端页面模板。下面将详细阐述这些知识点。 首先，SpringBoot是一个快速开发框架，它简化了Spring应用的...
Springboot整合myBatis（附加pagehelper分页插件）
weixin_43890267的博客
06-13 2784
Spring boot整合myBatis（附加pagehelper分页插件）前提第一步，创建spring boot，导入maven依赖第二步，进行appliction配置第三步，将springboot启动类进行扫描接口配置第四步创建三层架构项目第四步，运行项目，访问Controller接口分页插件pagehelper总结 前提 大家好，我在身边的人当着发现对spring boot整合mybatis...
springboot-mybatis整合多数据源方式之一AOP法
04-03
springboot-mybatis整合多数据源方式之一aop法，动态切换数据源，在sprintboot 1.5.9下测试通过
SpringBoot整合Mybatis完整详细版含注册、登录、拦截器配置
09-28
SpringBoot整合Mybatis完整详细版含注册、登录、拦截器配置功能
springboot+mybatis多数据源，aop动态切换
05-06
springboot+mybatis结合，多数据源配置，并实现注解aop动态切换，可实现读写分离，maven结构。
Spingboot-使用AOP实现动态自动切换Mybatis数据源+分页
wang704987562的博客
03-28 2329
目标：使用AOP实现动态自动切换Mybatis数据源，分页插件使用PageHelper。 项目使用Springboot搭建。 application.yml配置文件 server: port: 8086 db1: datasource: url: jdbc:mysql://localhost:3306/demo?characterEncoding=UTF-8&chara...
SpringBoot + MyBatis + MySql利用 aop 实现读写分离
qq_40453068的博客
07-03 463
前几个月做了一个项目，但是目前只部署到了一台服务器上面，所以我总感觉会出点问题，特别是数据库那一块，后期数据量大起来了以后，这一块应该是一个比较大的瓶颈，所以未雨绸缪，先把AOP实现读写分离那一块实现了，以后需要的时候再加上去就行了。 本人菜鸡，本科还没毕业，希望各位大佬嘴下留情。 SpringBoot 版本： <parent> <groupId>org.spr...
MyBatis 执行器 Executor
春风化雨
12-24 551
MyBatis 有三种基本的Executor执行器： 1、SimpleExecutor 每执行一次 update 或 select 就开启一个 Statement 对象，用完立刻关闭 Statement 对象； 2、ReuseExecutor 执行 update 或 select，以 SQL 作为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后不关闭 Statement 对象，而是放置于 Map 内供下一次使用。简言之，就是重复使用 Statement 对象； 3、Bat
SpringBoot之优化分页拦截器以及自定义方法参数解析器
编程学习者的博客
04-16 1564
1.声明 由于前面自定义并实现了分页拦截器，以及通过Spring的AOP方式获取每个分页中的参数，通过一段时间的使用和反思发现，该方式实现具有高耦合的情况 本人自定义的拦截器：SpringBoot整合MyBatis中的技巧(基本的AOP配置以及创建自己的分页拦截器) 前面使用方式的缺点： 存在高耦合的，应该使用分页接口方式实现 参数的获取通过AOP方式实现，发现每次需要传递到map集合中，取出的...
Spring使用AOP实现PageHelper分页
旧城以西的博客
09-15 5012
AOP实现分页有什么好处 利用AOP实现分页功能可以达到零代码入侵的目的，只需要在请求方法上传入对应的分页请求数据即可，SQL的编写以及后台业务与分页代码无关。 PageHelper PageHelper是Mybatis的一款分页插件，利用ThreadLocal实现分页功能。PageHelper先是根据你即将发出的SQL命令获取count值(也就是数据总量)，然后获取当前线程上的线程变量进行...
SpringBoot整合MyBatis XML配置详解
"这篇教程详细解析了如何在SpringBoot项目中集成MyBatis，并采用XML配置方式来管理SQL语句。...在实际开发中，可以根据项目需求调整配置，例如添加拦截器、配置分页插件等，以提高开发效率和应用性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值