Java MyBatis 模仿 MyBatis-Plus

深色風信子

301人浏览 · 2025-09-30 15:17:46

深色風信子 · 2025-09-30 15:17:46 发布

Java MyBatis 模仿 MyBatis-Plus

1 Java
2 XML
3 POM

1 Java

1 IService.java

package com.xu.wrapper.service;

import com.xu.wrapper.lambda.AbstractWrapper;
import com.xu.wrapper.lambda.LambdaQueryChainWrapper;
import com.xu.wrapper.lambda.LambdaUpdateChainWrapper;
import org.apache.ibatis.annotations.Param;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

public interface IService<T> {

	/**
	 * 新增
	 *
	 * @param bean 类
	 * @return 结果
	 */
	boolean save(T bean);

	/**
	 * 批量新增
	 *
	 * @param beans 类
	 * @return 结果
	 */
	boolean saveBatch(Collection<T> beans);

	/**
	 * 删除(主键)
	 *
	 * @param id 主键
	 * @return 结果
	 */
	boolean removeById(Serializable id);

	/**
	 * 批量删除(主键)
	 *
	 * @param ids 主键
	 * @return 结果
	 */
	boolean removeByIds(Collection<? extends Serializable> ids);

	/**
	 * 更新(主键)
	 *
	 * @param entity 类
	 * @return 结果
	 */
	boolean updateById(T entity);

    /**
     * 批量更新(自定义条件)
     *
     * @param beans 类
     * @return 影响行数
     */
    boolean updateBatch(@Param("beans") Collection<T> beans);

    /**
     * 批量更新(自定义条件)
     *
     * @param table 表名称
     * @param beans 类
     * @return 影响行数
     */
    boolean updateBatch(@Param("table") String table, @Param("beans") Collection<T> beans);

	/**
	 * 查询
	 *
	 * @param id 主键
	 * @return 数据
	 */
	T getById(Serializable id);

	/**
	 * 查询
	 *
	 * @param ids 主键
	 * @return 数据
	 */
	List<T> getById(Collection<? extends Serializable> ids);

	/**
	 * 查询所有
	 *
	 * @return 数据
	 */
	List<T> list();

	/**
	 * 根据 Wrapper，查询列表
	 * @param queryWrapper 实体对象封装操作类
	 * @return 实体列表
	 */
	List<T> list(AbstractWrapper<T, ?> queryWrapper);

	/**
	 * 查询
	 *
	 * @param bean 类
	 * @return 数据
	 */
	List<T> list(T bean);

	/**
	 * 获取 Lambda 链式查询器
	 *
	 * @return LambdaQueryChainWrapper
	 */
	LambdaQueryChainWrapper<T> lambdaQuery();

	/**
	 * 获取 Lambda 链式更新器
	 *
	 * @return LambdaUpdateChainWrapper
	 */
	LambdaUpdateChainWrapper<T> lambdaUpdate();
	
}

2 ServiceImpl.java

package com.xu.wrapper.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.xu.wrapper.lambda.AbstractWrapper;
import com.xu.wrapper.lambda.LambdaQueryChainWrapper;
import com.xu.wrapper.lambda.LambdaUpdateChainWrapper;
import com.xu.wrapper.mapper.BaseMapper;
import com.xu.wrapper.service.IService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * 默认Service实现类
 *
 * @param <M>
 * @param <T>
 */
@Slf4j
public class ServiceImpl<M extends BaseMapper<T>, T> implements IService<T> {

	@Autowired
	protected M baseMapper;

	@Override
	public boolean save(T entity) {
		if (null == entity) {
			return false;
		}
		return baseMapper.insert(entity) > 0;
	}

	@Override
	public boolean saveBatch(Collection<T> coll) {
		if (CollUtil.isEmpty(coll)) {
			return false;
		}
		return baseMapper.insertBatch(coll) == CollUtil.size(coll);
	}

	@Override
	public boolean removeById(Serializable id) {
		if (null == id) {
			return false;
		}
		return baseMapper.deleteById(id) > 0;
	}

	@Override
	public boolean removeByIds(Collection<? extends Serializable> ids) {
		if (CollUtil.isEmpty(ids)) {
			return false;
		}
		return baseMapper.deleteByIds(ids) == CollUtil.size(ids);
	}

	@Override
	public boolean updateById(T entity) {
		if (null == entity) {
			return false;
		}
		return baseMapper.updateById(entity) > 0;
	}

    @Override
    public boolean updateBatch(Collection<T> beans) {
        return updateBatch(null, beans);
    }

    @Override
    public boolean updateBatch(String table, Collection<T> data) {
        Collection<T> beans = Optional.ofNullable(data).orElse(CollUtil.newArrayList())
                .stream().filter(Objects::nonNull).collect(Collectors.toList());
        if (CollUtil.isEmpty(beans)) {
            return false;
        }

        // 数据分批处理
        int batchSize = 500;
        int totalBatches = (beans.size() + batchSize - 1) / batchSize;

        // 使用IntStream生成批次索引，通过lambda处理每个批次
        long t1 = System.currentTimeMillis();
        int count = IntStream.range(0, totalBatches)
                .map(batchIndex -> {
                    try {
                        int start = batchIndex * batchSize;
                        int end = Math.min(start + batchSize, beans.size());
                        Collection<T> subBeans = CollUtil.sub(beans, start, end);

                        if (CollUtil.isEmpty(subBeans)) {
                            return 0;
                        }

                        return StrUtil.isBlank(table) ? baseMapper.updateBatch(subBeans) : baseMapper.updateBatch(table, subBeans);
                    } catch (Exception e) {
                        log.error("批量更新第{}批数据失败", batchIndex, e);
                        return 0;
                    }
                }).sum();
        long t2 = System.currentTimeMillis();
        log.info("批量更新数据 表:{}, 耗时:{}ms, 总数:{}, 完成:{}", table, (t2 - t1), beans.size(), count);
        return count == beans.size();
    }

	@Override
	public T getById(Serializable id) {
		if (null == id) {
			return null;
		}
		return baseMapper.selectById(id);
	}

	@Override
	public List<T> getById(Collection<? extends Serializable> ids) {
		if (CollUtil.isEmpty(ids)) {
			return null;
		}
		return baseMapper.selectByIds(ids);
	}

	@Override
	public List<T> list() {
		return baseMapper.selectAll();
	}

	@Override
	public List<T> list(AbstractWrapper<T, ?> queryWrapper) {
		return baseMapper.selectList(queryWrapper);
	}

	@Override
	public List<T> list(T bean) {
		return baseMapper.select(bean);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public LambdaQueryChainWrapper<T> lambdaQuery() {
		return new LambdaQueryChainWrapper<>(baseMapper);
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public LambdaUpdateChainWrapper<T> lambdaUpdate() {
		return new LambdaUpdateChainWrapper<>(baseMapper);
	}

}

3 BaseMapper.java

package com.xu.wrapper.mapper;

import com.xu.wrapper.lambda.AbstractWrapper;
import org.apache.ibatis.annotations.Param;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

/**
 * 基础类
 */
public interface BaseMapper<T> {

	/**
	 * 新增
	 *
	 * @param bean 类
	 * @return 影响行数
	 */
	int insert(T bean);

	/**
	 * 批量新增
	 *
	 * @param beans 类
	 * @return 影响行数
	 */
	int insertBatch(Collection<T> beans);

	/**
	 * 删除(主键)
	 *
	 * @param id 主键
	 * @return 影响行数
	 */
	int deleteById(@Param("id") Serializable id);

	/**
	 * 批量删除(主键)
	 *
	 * @param ids 主键
	 * @return 影响行数
	 */
	int deleteByIds(@Param("ids") Collection<? extends Serializable> ids);

	/**
	 * 更新(主键)
	 *
	 * @param entity 类
	 * @return 影响行数
	 */
	int updateById(T entity);

    /**
     * 批量更新(自定义条件)
     *
     * @param beans 类
     * @return 影响行数
     */
    int updateBatch(@Param("beans") Collection<T> beans);

    /**
     * 批量更新(自定义条件)
     *
     * @param table 表名称
     * @param beans 类
     * @return 影响行数
     */
    int updateBatch(@Param("table") String table, @Param("beans") Collection<T> beans);

	/**
	 * 查询
	 *
	 * @param id 主键
	 * @return 数据
	 */
	T selectById(@Param("id") Serializable id);

	/**
	 * 查询
	 *
	 * @param ids 主键
	 * @return 数据
	 */
	List<T> selectByIds(@Param("ids") Collection<? extends Serializable> ids);

	/**
	 * 查询所有
	 *
	 * @return 数据
	 */
	List<T> selectAll();

	/**
	 * 查询
	 *
	 * @param bean 类
	 * @return 数据
	 */
	List<T> select(T bean);

	/**
	 * 根据 Wrapper 条件，查询一条记录
	 *
	 * @param wrapper 实体对象封装操作类
	 * @return 实体
	 */
	T selectOne(@Param("ew") AbstractWrapper<T, ?> wrapper);

	/**
	 * 根据 Wrapper 条件，查询总记录数
	 *
	 * @param wrapper 实体对象封装操作类
	 * @return 总记录数
	 */
	Long selectCount(@Param("ew") AbstractWrapper<T, ?> wrapper);

	/**
	 * 根据 Wrapper 条件，查询全部记录
	 *
	 * @param wrapper 实体对象封装操作类
	 * @return 实体列表
	 */
	List<T> selectList(@Param("ew") AbstractWrapper<T, ?> wrapper);

	/**
	 * 根据 Wrapper 条件，更新记录
	 *
	 * @param wrapper 实体对象封装操作类
	 * @return 影响行数
	 */
	int update(@Param("ew") AbstractWrapper<T, ?> wrapper);

	/**
	 * 根据 Wrapper 条件，删除记录
	 *
	 * @param wrapper 实体对象封装操作类
	 * @return 影响行数
	 */
	int delete(@Param("ew") AbstractWrapper<T, ?> wrapper);

}

2 XML

3 POM

<?xml version="1.0" encoding="UTF-8"?>
<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 https://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>3.4.9</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<groupId>com.xu</groupId>
	<artifactId>spring-oracle</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<name>spring-oracle</name>

	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>24</java.version>
	</properties>

	<dependencies>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>

        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <version>12.2.0.1</version>
        </dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.40</version>
        </dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>3.0.5</version>
            <scope>test</scope>
        </dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<annotationProcessorPaths>
						<path>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</path>
					</annotationProcessorPaths>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

在这里插入图片描述

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

SeedVR2终极指南：如何用单步扩散模型实现专业级视频修复

还在为老旧视频的模糊画质而烦恼吗？面对抖动严重的监控录像或褪色的家庭影像，你是否曾希望有一种简单高效的修复方案？SeedVR2正是为解决这些痛点而生的一站式视频修复工具。作为字节跳动推出的先进视频修复模型，它能够在单步推理中实现专业级的视频质量提升，彻底改变了传统视频修复的工作流程。## 核心价值：为什么选择SeedVR2进行视频修复？**传统视频修复的三大瓶颈**：1. **计算成本高

AI Agent技术社区

深度解析Amlogic S9xxx电视盒子Armbian系统：从闲置设备到Linux服务器的终极实战指南

你是否拥有一台闲置的Amlogic S9xxx系列电视盒子？想让它摆脱单一的视频播放功能，变身为功能强大的Linux服务器、开发平台或家庭媒体中心？本指南将为你详细解析如何通过Armbian系统实现这一转变，让你的电视盒子重获新生，成为高性能的Linux设备。Armbian系统基于Debian/Ubuntu构建，专为ARM芯片优化，提供了完整的Linux生态支持。## 🎯 核心价值与独特优势

AI Agent技术社区

CANN/runtime Event管理API

本章节描述 CANN Runtime 的 Event 管理接口，用于事件的创建、记录、同步、计时及 IPC 跨进程共享。- [`aclError aclrtCreateEvent(aclrtEvent *event)`](#aclrtCreateEvent)：创建Event，创建出来的Event可用于统计两个Event之间的耗时、多Stream之间的任务同步等场景。- [`aclError