mybatisplus 根据时间分页查询

可以使用Mybatis-plus提供的Wrapper类和Lambda表达式来实现按时间分页查询。以下是一个示例代码：

// 假设需要查询创建时间在2021-08-01到2021-08-31之间的数据，每页10条
// currentPage为当前页码，pageSize为每页大小
Page<MyEntity> page = new Page<>(currentPage, pageSize);
LambdaQueryWrapper<MyEntity> queryWrapper = new LambdaQueryWrapper<MyEntity>()
        .between(MyEntity::getCreateTime, "2021-08-01", "2021-08-31")
        .orderByDesc(MyEntity::getCreateTime);
IPage<MyEntity> myEntities = myEntityMapper.selectPage(page, queryWrapper);

在上面的示例代码中，我们使用LambdaQueryWrapper构建了一个查询条件，指定了创建时间在2021-08-01到2021-08-31之间，并按创建时间倒序排序。然后使用Mybatis-plus提供的selectPage方法进行分页查询，返回的是一个IPage对象，包含了分页信息和查询结果。

相关问题

mybatisplus selectpage分页查询 超时

根据提供的引用内容，针对mybatisplus的selectpage分页查询超时问题，可以考虑以下解决方案：
1. 调整分页大小，减少每页查询的数据量，以减少查询时间。
2. 对查询条件进行优化，尽量减少查询的数据量，例如添加索引、优化查询语句等。
3. 调整数据库连接池的配置，增加连接池大小，以提高并发处理能力。
4. 考虑使用缓存技术，例如redis等，缓存查询结果，减少数据库查询次数。
5. 如果以上方法都无法解决问题，可以考虑升级硬件设备或者增加服务器数量，以提高系统的处理能力。

mybatisplus实现oracle分页

### 回答1：
MybatisPlus可以通过以下步骤实现Oracle分页：

1. 在pom.xml文件中添加MybatisPlus和Oracle JDBC驱动的依赖。

2. 在MybatisPlus的配置文件中配置Oracle数据库的连接信息。

3. 在Mapper接口中定义分页查询的方法，使用MybatisPlus的分页插件进行分页。

4. 在Service层中调用Mapper接口的分页查询方法，获取分页数据。

5. 在Controller层中将分页数据返回给前端页面。

具体实现细节可以参考MybatisPlus官方文档和示例代码。

### 回答2：
MybatisPlus是基于Mybatis的增强工具，可以简化Mybatis的操作，提供了很多实用的功能，其中就包括分页查询。本文将介绍如何使用MybatisPlus实现Oracle分页。

1. 为什么需要分页查询

当我们需要查询大量数据时，查询所有数据并一次性返回到前端不仅会耗费很多时间和内存，而且也会影响网站的性能。此时就需要使用分页查询，将查询结果分为若干页，每次只查询一页的数据，提高查询效率，减少内存的开销。

2. MybatisPlus中的分页查询

MybatisPlus提供了两种分页查询的方式：基于Mapper接口和基于Service层。我们可以根据实际需求选择不同的方式。

2.1 基于Mapper接口实现分页查询

基于Mapper接口实现分页查询非常简单，只需要按照以下步骤操作即可：

1）在Mapper接口中添加分页查询的方法。

例如：

public interface UserMapper extends BaseMapper<User> {

List<User> selectPageVo(Page<User> page, @Param("user") User user);

}

其中Page是MybatisPlus提供的分页对象，它包含了查询的起始行和总记录数等信息。

2）在Mapper.xml文件中编写SQL语句。

例如：

SELECT * FROM ( SELECT u.*, ROWNUM r FROM ( SELECT * FROM user WHERE name LIKE '%${user.name}%' ) u WHERE ROWNUM <= #{size,jdbcType=INTEGER} * (#{current,jdbcType=INTEGER}-1)+#{size,jdbcType=INTEGER} ) WHERE r > #{size,jdbcType=INTEGER} * (#{current,jdbcType=INTEGER}-1)

3）在Service层中调用Mapper接口的分页查询方法，获取查询结果。

例如：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

@Override
public IPage<User> getUserPage(Page<User> page, User user) {
return baseMapper.selectPageVo(page, user);
}

}

这样就可以实现基于Mapper接口的Oracle分页查询了。

2.2 基于Service层实现分页查询

基于Service层实现分页查询相比于基于Mapper接口更加灵活，可以更加方便地进行业务逻辑的处理，具体实现步骤如下：

1）创建一个实现IService接口的类，并实现其方法。

例如：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

@Override
public Page<User> getUserPage(int pageNum, int pageSize) {
Page<User> page = new Page<>(pageNum, pageSize);
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("deleted", 0);
wrapper.orderByDesc("create_time");
return baseMapper.selectPage(page, wrapper);
}

}

2）在Controller层中调用Service层的方法，并将查询结果返回到前端。

例如：

@GetMapping("/users")
public Result getUserList(@RequestParam(defaultValue = "1") int pageNum,
@RequestParam(defaultValue = "10") int pageSize) {
Page<User> page = userService.getUserPage(pageNum, pageSize);
return Result.success(page);
}

这样就可以在Spring Boot项目中使用MybatisPlus实现Oracle分页查询了。

### 回答3：
Mybatisplus是一款优秀的ORM框架，支持多种数据库操作。它通过封装JDBC操作、提供便捷的CRUD和提供分页插件等功能，极大的提高了开发效率。在Oracle数据库中实现分页查询，常见的方式是使用ROWNUM伪列和子查询。Mybatisplus提供了多种实现分页查询的方式，接下来我们以Mybatisplus实现Oracle分页为例，介绍其中的几种方法。

方法一：通过集成Mybatisplus自带的分页插件实现Oracle分页

可以通过配置Mybatisplus的分页插件，实现Oracle分页。这里使用Oracle的ROWNUM伪列来实现分页。具体步骤如下：

1.配置Mybatisplus的分页插件

Mybatisplus默认使用了PageInterceptor分页插件，可通过如下配置开启分页插件：

<!-- 开启AutoSqlInjector(自动注入CRUD) -->
<bean id="autoSqlInjector" class="com.baomidou.mybatisplus.mapper.AutoSqlInjector"></bean>

<!-- 分页插件配置 -->
<bean id="paginationInterceptor" class="com.baomidou.mybatisplus.plugins.PaginationInterceptor">
  <property name="dialectType" value="oracle"/>
</bean>

2.编写分页查询SQL

可以通过Mybatisplus提供的Wrapper类和QueryWrapper类来构造查询条件，代码如下：

@Select("select * from emp ${ew.customSqlSegment}")
IPage<Emp> selectEmpPage(Page<Emp> page, @Param(Constants.WRAPPER) Wrapper<Emp> wrapper);

其中IPage是Mybatisplus提供的分页结果集类。Page是Mybatisplus提供的分页类，可以传入当前页数和每页显示记录数。Wrapper是Mybatisplus提供的查询条件构造器，可以通过eq、like等方法构造查询条件。customSqlSegment是自定义SQL片段，需要通过wrapper的getSqlSegment方法来获取。

3.调用分页查询方法

可以通过如下代码来调用分页查询方法：

Emp emp = new Emp();
emp.setEmpName("test");
QueryWrapper<Emp> wrapper = new QueryWrapper<>(emp);
Page<Emp> page = new Page<>(1, 10);
IPage<Emp> empList = empMapper.selectEmpPage(page, wrapper);

方法二：通过自定义注解实现Oracle分页

可以通过自定义注解来实现Oracle分页，这样可以避免在每个方法中都写分页SQL。具体步骤如下：

1.定义注解

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface QueryPage {
    int pageNum() default 1;
    int pageSize() default 10;
}

2.编写PageInterceptor

继承Mybatisplus的PaginationInterceptor，重写方法intercept，使用反射来获取注解参数，并添加分页查询语句，代码如下：

public class PageInterceptor extends PaginationInterceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        Object parameter = invocation.getArgs()[1];
        BoundSql boundSql = mappedStatement.getBoundSql(parameter);
        String sql = boundSql.getSql().trim();
        Object parameterObject = boundSql.getParameterObject();
        //查找QueryPage注解
        QueryPage queryPage = null;
        MethodSignature signature = (MethodSignature) invocation.getMethod().getSignature();
        Method method = signature.getMethod();
        if (method.isAnnotationPresent(QueryPage.class)) {
            queryPage = method.getAnnotation(QueryPage.class);
        }
        //生成分页查询语句
        int pageNo = queryPage.pageNum();
        int pageSize = queryPage.pageSize();
        String pageSql = sql + " pagination where rn between ? and ?";
        int start = (pageNo - 1) * pageSize + 1;
        int end = pageNo * pageSize;
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        //添加分页参数
        List<ParameterMapping> newParameterMappings = new ArrayList<>(parameterMappings);
        newParameterMappings.add(new ParameterMapping.Builder(mappedStatement.getConfiguration(),"pageNo",Integer.class).build());
        newParameterMappings.add(new ParameterMapping.Builder(mappedStatement.getConfiguration(),"pageSize",Integer.class).build());
        MetaObject metaObject = null;
        if (parameterObject instanceof Map) {
            ((Map) parameterObject).put("pageNo",start);
            ((Map) parameterObject).put("pageSize",end);
            metaObject = SystemMetaObject.forObject(parameterObject);
        } else {
            metaObject = parameterObject == null ? null : MetaObject.forObject(parameterObject);
            if (metaObject != null) {
                metaObject.setValue("pageNo", start);
                metaObject.setValue("pageSize", end);
            }
        }
        BoundSql newBoundSql = new BoundSql(mappedStatement.getConfiguration(),
                pageSql, newParameterMappings, metaObject == null ? boundSql.getParameterObject() : metaObject.getOriginalObject());
        //替换SQL语句和参数
        MappedStatement newMs = BuildNewMappedStatement(mappedStatement, new BoundSqlSqlSource(newBoundSql));
        invocation.getArgs()[0] = newMs;
        return super.intercept(invocation);
    }

    private MappedStatement BuildNewMappedStatement(MappedStatement ms, SqlSource newSqlSource) {
        //创建一个新的MappedStatement
        MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(),
                ms.getId() + "-Pagination", newSqlSource, ms.getSqlCommandType());
        builder.resource(ms.getResource());
        builder.fetchSize(ms.getFetchSize());
        builder.statementType(ms.getStatementType());
        builder.keyGenerator(ms.getKeyGenerator());
        //把原mapper接口的返回类型修改为Page类型
        builder.resultMaps(ms.getResultMaps());
        builder.timeout(ms.getTimeout());
        builder.parameterMap(ms.getParameterMap());
        builder.cache(ms.getCache());
        builder.flushCacheRequired(ms.isFlushCacheRequired());
        builder.useCache(ms.isUseCache());
        return builder.build();
    }

}

3.使用自定义注解实现分页查询

在需要分页查询的方法上，使用自定义注解QueryPage，并调用Mybatisplus提供的selectPage方法，代码如下：

@QueryPage(pageNum = 1, pageSize = 10)
public List<Emp> selectEmpList(Map<String, Object> map, QueryWrapper<Emp> wrapper) {
    Page<Emp> page = new Page<>();
    //Mybatisplus提供的selectPage方法，会从拦截器中获取注解参数，自动添加分页查询语句
    IPage<Emp> ipage = empMapper.selectPage(page, wrapper);
    return ipage.getRecords();
}

当调用selectEmpList方法时，拦截器会自动获取注解参数，自动添加分页查询语句。这样就可以实现Oracle分页了。