BestHub
Sign in
Tagged articles

mybatis-plus

232 articles · Page 1 of 3
Yumin Fish Harvest
Yumin Fish Harvest
Aug 18, 2026 · Backend Development

Distributed Snowflake ID Generation in Java: Hutool and MyBatis-Plus Demo

This article walks through the Snowflake algorithm for distributed ID generation, detailing its timestamp, workerId and sequence fields, handling clock rollback and sequence overflow, and provides a complete Java implementation with integration examples for Hutool and MyBatis‑Plus, including configuration and test code.

distributed systemshutoolid generation
0 likes · 28 min read
Distributed Snowflake ID Generation in Java: Hutool and MyBatis-Plus Demo
Java Tech Enthusiast
Java Tech Enthusiast
Aug 13, 2026 · Backend Development

6 Ways to Auto‑Fill Common Fields in SpringBoot and Stop Writing Boilerplate Code

This article reviews six practical approaches—from database column defaults to AOP interceptors—for automatically populating common fields such as timestamps, creator, and tenant IDs in SpringBoot applications, compares their pros, cons, and applicability, and offers guidance on selecting the most suitable solution.

AOPJPAMyBatis interceptor
0 likes · 21 min read
6 Ways to Auto‑Fill Common Fields in SpringBoot and Stop Writing Boilerplate Code
Java Tech Workshop
Java Tech Workshop
Aug 12, 2026 · Backend Development

6 Elegant Ways to Auto‑Fill Common Fields in SpringBoot (No Hand‑Coding Needed)

SpringBoot developers can eliminate repetitive manual setting of common fields like create_time, update_time, create_by, and update_by by using six automatic filling solutions—from database default values and MyBatis‑Plus meta‑object handlers to JPA auditing, MyBatis interceptors, AOP aspects, and controller request‑body advice—each with its own pros, cons, and ideal scenarios.

AOPAuto-fillJPA
0 likes · 19 min read
6 Elegant Ways to Auto‑Fill Common Fields in SpringBoot (No Hand‑Coding Needed)
Java Tech Workshop
Java Tech Workshop
Aug 7, 2026 · Backend Development

Mastering MyBatis-Plus IPage: A Unified Solution for Pagination and Full-Data Export

This article examines common pitfalls of MyBatis-Plus IPage pagination, explains why naive approaches like using two mapper methods or setting pageSize to Integer.MAX_VALUE cause performance and consistency issues, and presents a single‑SQL strategy with custom count handling, cursor streaming, and best‑practice configurations for seamless pagination and full‑data export.

CursorFull ExportIPage
0 likes · 20 min read
Mastering MyBatis-Plus IPage: A Unified Solution for Pagination and Full-Data Export
Java Tech Workshop
Java Tech Workshop
Jul 30, 2026 · Backend Development

Managing Statutory Holidays in Enterprise Attendance with SpringBoot & Vue3

The article explains how to avoid common pitfalls in handling statutory holidays for enterprise attendance systems by building an independent work‑day calendar service, storing daily date types in a database, providing unified SpringBoot APIs for rule evaluation, and offering a Vue3 visual calendar for HR to maintain holidays, adjustments, and custom company holidays.

Holiday CalendarSpringBootVue3
0 likes · 21 min read
Managing Statutory Holidays in Enterprise Attendance with SpringBoot & Vue3
Java Architect Handbook
Java Architect Handbook
Jul 4, 2026 · Backend Development

How to Build a Clean SpringBoot Scaffold Quickly

The article walks through creating a SpringBoot project from scratch, covering IDE setup pain points, project initialization, version compatibility between SpringBoot, Spring Cloud and Kafka, Maven dependency management, core scaffold classes such as global exception handling, logging aspect, CORS and Swagger configuration, and recommends useful tools like embedded Redis, MariaDB, Hutool, MyBatis‑Plus, MapStruct and Redisson.

KafkaMavenRedisson
0 likes · 11 min read
How to Build a Clean SpringBoot Scaffold Quickly
samdeepthink
samdeepthink
Jul 3, 2026 · Backend Development

MyBatis-Flex vs MyBatis-Plus: A Detailed Source‑Code and Feature Comparison

This article walks through a side‑by‑side examination of MyBatis‑Flex and MyBatis‑Plus, covering entity annotations, query construction, pagination, architectural differences, APT‑generated code, multi‑table joins, partial updates, and the trade‑offs of each design, helping developers choose the right ORM for their projects.

APTMulti-table joinMyBatis-Flex
0 likes · 16 min read
MyBatis-Flex vs MyBatis-Plus: A Detailed Source‑Code and Feature Comparison
Java Architect Handbook
Java Architect Handbook
Jun 30, 2026 · Backend Development

12 MyBatis‑Plus Tricks That Instantly Boost Development Efficiency

This article presents twelve practical MyBatis‑Plus techniques—including avoiding isNull checks, selecting specific fields, batch operations, EXISTS subqueries, safe ordering, LambdaQuery type safety, between clauses, index‑aware sorting, pagination limits, null‑handling, performance tracking, enum mapping, logical deletion, optimistic locking, and increment/decrement methods—to help developers write cleaner, faster, and more maintainable Java code.

Batch OperationsLambdaQueryWrapperORM
0 likes · 18 min read
12 MyBatis‑Plus Tricks That Instantly Boost Development Efficiency
Java Tech Enthusiast
Java Tech Enthusiast
Jun 13, 2026 · Backend Development

MyBatis-Plus vs MyBatis-Flex: Which One Is Better?

This article compares MyBatis-Plus and MyBatis-Flex across eight dimensions—including design philosophy, development efficiency, query flexibility, performance, database support, advanced features, dependency weight, and community ecosystem—to help developers choose the most suitable persistence framework for their projects.

ComparisonMyBatis-FlexORM
0 likes · 18 min read
MyBatis-Plus vs MyBatis-Flex: Which One Is Better?
Java Tech Workshop
Java Tech Workshop
Jun 11, 2026 · Backend Development

Building a Production-Ready SpringBoot + Vue3 Front‑End/Back‑End Separation Architecture

This article presents a step‑by‑step guide to constructing a full‑stack SpringBoot + Vue3 project with production‑grade features such as global exception handling, unified error codes, JWT authentication, multi‑environment configuration, CORS solutions, pagination, Pinia state management, on‑demand UI imports, and Nginx reverse‑proxy deployment.

CORSJWTNginx
0 likes · 17 min read
Building a Production-Ready SpringBoot + Vue3 Front‑End/Back‑End Separation Architecture
dbaplus Community
dbaplus Community
Jun 7, 2026 · Backend Development

Midnight Crash: The ‘Impossible’ MyBatis‑Plus Pitfalls That Can Break Production

The article catalogs six production‑ready pitfalls of MyBatis‑Plus—duplicate Snowflake IDs, batch‑insert disorder, enum storage errors, camel‑case mismatches, auto‑fill failures, and JSON field loss—explains their root causes with concrete examples and code, and provides practical solutions to keep the framework reliable in high‑concurrency environments.

Auto-fillBatch InsertEnum Mapping
0 likes · 16 min read
Midnight Crash: The ‘Impossible’ MyBatis‑Plus Pitfalls That Can Break Production
Su San Talks Tech
Su San Talks Tech
Jun 5, 2026 · Backend Development

A Comprehensive Guide to Java Tech Stack Skills for AI Agents

This guide curates essential AI Agent Skills for the Java ecosystem, covering backend tools like Spring Boot, MyBatis‑Plus, and Redis, frontend frameworks such as Vue and React, installation commands, custom Skill examples, and recommended full‑stack workflows to boost project productivity.

AI Agent SkillsRedisSpring Boot
0 likes · 12 min read
A Comprehensive Guide to Java Tech Stack Skills for AI Agents
Su San Talks Tech
Su San Talks Tech
Jun 2, 2026 · Backend Development

MybatisPlus Pro: Supercharging CRUD Development Efficiency

This article analyzes MybatisPlus Pro, explaining how it eliminates repetitive CRUD code in MyBatis‑Plus projects by providing a BaseController and utility classes that auto‑generate service and controller layers, while also detailing its internal mechanisms, advantages, drawbacks, suitable scenarios, and common pitfalls.

CRUDMyBatisSpring Boot
0 likes · 22 min read
MybatisPlus Pro: Supercharging CRUD Development Efficiency
Su San Talks Tech
Su San Talks Tech
May 26, 2026 · Backend Development

Mybatis-Plus vs Mybatis-Flex: Which ORM Framework Is Best for Your Project?

This article provides a detailed comparison between Mybatis-Plus and Mybatis-Flex, examining their design philosophies, core mechanisms, feature sets, performance benchmarks, database support, dependency weight, and community maturity, and offers practical guidance on choosing the right framework for different project scenarios.

Feature comparisonMyBatis-FlexORM
0 likes · 19 min read
Mybatis-Plus vs Mybatis-Flex: Which ORM Framework Is Best for Your Project?
samdeepthink
samdeepthink
May 12, 2026 · Backend Development

Three Years of DDD in Practice: Insights from the Opening Chapter

The author recounts three years of applying Domain‑Driven Design to a microservice ecosystem, sharing concrete pitfalls, code‑first modeling from database tables, and a structured 24‑article series that guides developers to refactor existing Spring Boot + MyBatis Plus projects without rewriting the framework.

AggregatesBounded ContextDomain-Driven Design
0 likes · 8 min read
Three Years of DDD in Practice: Insights from the Opening Chapter
Java Tech Enthusiast
Java Tech Enthusiast
May 2, 2026 · Backend Development

10 Common MyBatis‑Plus Pitfalls and How to Avoid Them

This article enumerates ten frequent pitfalls when using MyBatis‑Plus—such as incorrect total counts in pagination, pagination interceptor misconfiguration, logical‑delete failures, auto‑fill issues, optimistic‑lock mismatches, null handling in query wrappers, poor batch‑insert performance, enum mapping errors, type‑handler problems, and overall pros and cons—providing concrete examples, root‑cause analysis, and practical solutions for each.

BatchInsertEnumMappingLogicalDelete
0 likes · 20 min read
10 Common MyBatis‑Plus Pitfalls and How to Avoid Them
IT Services Circle
IT Services Circle
Apr 29, 2026 · Backend Development

10 Common MyBatis-Plus Pitfalls and How to Avoid Them

This article analyzes ten frequent pitfalls when using MyBatis-Plus—such as incorrect pagination totals, pagination plugin misconfiguration, logical delete failures, auto‑fill issues, optimistic‑lock mismatches, null handling in QueryWrapper, batch‑insert performance, enum mapping errors, wrapper condition overrides, and type‑handler problems—provides root‑cause explanations, concrete code examples, and practical solutions to help developers write more robust and efficient Java backend code.

Batch InsertEnum MappingLogical Delete
0 likes · 19 min read
10 Common MyBatis-Plus Pitfalls and How to Avoid Them
Java Backend Technology
Java Backend Technology
Apr 28, 2026 · Backend Development

10 Common MyBatis-Plus Pitfalls and How to Avoid Them

This article examines ten frequent pitfalls when using MyBatis-Plus—such as incorrect pagination counts, disabled pagination, logical‑delete mishandling, auto‑fill failures, optimistic‑lock issues, batch‑insert slowness, enum mapping errors, JSON type‑handler problems, and query‑wrapper quirks—explains their causes, and provides concrete code‑level solutions and best‑practice recommendations.

Batch InsertEnum MappingJSON TypeHandler
0 likes · 18 min read
10 Common MyBatis-Plus Pitfalls and How to Avoid Them
Su San Talks Tech
Su San Talks Tech
Apr 27, 2026 · Backend Development

10 Common Pitfalls in MyBatis-Plus and How to Avoid Them

The article enumerates ten typical traps when using MyBatis-Plus—such as incorrect pagination counts, ineffective pagination plugins, logical delete mishandling, auto‑fill failures, optimistic‑lock issues, null‑value conditions, batch‑insert slowness, enum mapping errors, wrapper overwrites, and type‑handler problems—explains why they occur, and provides concrete code‑level solutions and best‑practice recommendations.

Batch InsertEnum MappingLogical Delete
0 likes · 19 min read
10 Common Pitfalls in MyBatis-Plus and How to Avoid Them
Selected Java Interview Questions
Selected Java Interview Questions
Apr 18, 2026 · Backend Development

Efficient Hierarchical Menu Storage in MySQL: Adjacency List vs Closure Table

The article examines common pitfalls of using a simple parent_id column for menu hierarchies, compares three storage models—adjacency list, path enumeration, and closure table—shows their trade‑offs, and provides a SpringBoot/MyBatis‑Plus implementation that combines adjacency and closure tables for optimal read‑write performance.

Adjacency ListClosure TableMySQL
0 likes · 14 min read
Efficient Hierarchical Menu Storage in MySQL: Adjacency List vs Closure Table
Top Architect
Top Architect
Mar 30, 2026 · Backend Development

Why Upgrading to MyBatis‑Plus Breaks LocalDateTime Mapping and How to Fix It

A newcomer replaced MyBatis with MyBatis‑Plus in an old MySQL‑based project, triggering a "Conversion not supported for type java.time.LocalDateTime" error, which was traced to MyBatis 3.5.1 dropping built‑in type handling and an outdated mysql‑connector‑java, and resolved by upgrading the connector and adjusting validation logic.

ConnectorDebuggingLocalDateTime
0 likes · 10 min read
Why Upgrading to MyBatis‑Plus Breaks LocalDateTime Mapping and How to Fix It
Top Architect
Top Architect
Mar 17, 2026 · Backend Development

Why Replacing MyBatis with MyBatis‑Plus Can Break Your DateTime Handling

A newcomer replaced MyBatis with MyBatis‑Plus in an old MySQL‑based project, encountered a "Conversion not supported for type java.time.LocalDateTime" error, traced it to MyBatis 3.5.1 dropping built‑in type handling and an outdated mysql‑connector‑java driver, and resolved it by upgrading the driver while also fixing a related validation bug that caused production failures.

DatabaseDebuggingMyBatis
0 likes · 10 min read
Why Replacing MyBatis with MyBatis‑Plus Can Break Your DateTime Handling
Selected Java Interview Questions
Selected Java Interview Questions
Feb 14, 2026 · Backend Development

Master Dynamic Table Names in MyBatis‑Plus with a Simple Starter

This article introduces an open‑source MyBatis‑Plus dynamic‑table starter, explains why dynamic table names are needed for large‑scale data, outlines its key features, provides step‑by‑step installation and quick‑start instructions, demonstrates advanced usage, debugging tips, FAQs, and real‑world scenarios.

Dynamic TableSpring Bootjava
0 likes · 9 min read
Master Dynamic Table Names in MyBatis‑Plus with a Simple Starter
Java Companion
Java Companion
Feb 5, 2026 · Backend Development

Elegant Dynamic Data Source Switching in SpringBoot Using ThreadLocal and AbstractRoutingDataSource

This article walks through building an elegant dynamic data‑source switch in SpringBoot by combining ThreadLocal with AbstractRoutingDataSource, covering the context holder, custom routing class, YAML configuration, testing, annotation‑driven switching, and runtime addition of new data sources.

AOPAnnotationRuntime DataSource Registration
0 likes · 16 min read
Elegant Dynamic Data Source Switching in SpringBoot Using ThreadLocal and AbstractRoutingDataSource
Java Architect Handbook
Java Architect Handbook
Jan 20, 2026 · Backend Development

Why Replacing MyBatis with MyBatis-Plus Triggers LocalDateTime Errors—and How to Fix Them

The article details a step‑by‑step migration from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains why the conversion error for java.time.LocalDateTime appears after the switch, shows how to trace the root cause through stack traces, upgrades the mysql‑connector‑java to 5.1.37 (and later 5.1.42) to resolve the issue, and shares broader lessons about component upgrades and unexpected bugs.

DatabaseException HandlingJDBC
0 likes · 10 min read
Why Replacing MyBatis with MyBatis-Plus Triggers LocalDateTime Errors—and How to Fix Them
Coder Trainee
Coder Trainee
Jan 14, 2026 · Backend Development

How to Build a Simple ERP System in Just a Few Hours

This article walks through creating a lightweight material‑management ERP system—including login, dashboard, inventory, inbound and outbound modules—using Vue 3 for the front end and Spring Boot 3, Java 17, MySQL, and MyBatis‑Plus for the back end, highlighting the architecture and development efficiency tricks employed.

ERPMySQLSpring Boot 3
0 likes · 7 min read
How to Build a Simple ERP System in Just a Few Hours
LuTiao Programming
LuTiao Programming
Jan 10, 2026 · Backend Development

How Spring Boot 3 + Apache Calcite Eliminates Cross‑Database Chaos with a Unified Query Layer

This article explains why multi‑source data fragmentation hurts service code, introduces Apache Calcite as a query‑abstraction layer that decouples data location from query logic, and provides step‑by‑step Spring Boot 3 integration, practical code samples, common pitfalls, performance tips, and real‑world scenarios.

Apache CalciteMongoDBMulti-DataSource
0 likes · 11 min read
How Spring Boot 3 + Apache Calcite Eliminates Cross‑Database Chaos with a Unified Query Layer
Top Architect
Top Architect
Jan 8, 2026 · Backend Development

Why MyBatis‑Plus Migration Fails: LocalDateTime Conversion and Connector Version Issues

A legacy project using MySQL 5.7, MyBatis 3.5.0 and mysql‑connector‑java 5.1.26 encounters a "Conversion not supported for type java.time.LocalDateTime" error after switching to MyBatis‑Plus 3.1.1, which is traced to MyBatis 3.5.1 dropping built‑in LocalDateTime handling and the old connector not supporting the type, requiring an upgrade to mysql‑connector‑java 5.1.37 or later.

JDBC driverLocalDateTimeMyBatis
0 likes · 9 min read
Why MyBatis‑Plus Migration Fails: LocalDateTime Conversion and Connector Version Issues
Shepherd Advanced Notes
Shepherd Advanced Notes
Nov 28, 2025 · Backend Development

Hard‑Learned MyBatis‑Plus Pitfalls and How to Avoid Them in Production

The article reviews the most common MyBatis‑Plus traps encountered in large‑scale Java services—duplicate Snowflake IDs, batch‑insert reordering, enum storage mismatches, camel‑case mapping errors, auto‑fill loss, and JSON field disappearance—explaining each root cause, illustrating it with real code snippets, and providing concrete solutions to keep production systems stable.

Auto-fillBatch InsertEnum Mapping
0 likes · 19 min read
Hard‑Learned MyBatis‑Plus Pitfalls and How to Avoid Them in Production
Java Companion
Java Companion
Nov 13, 2025 · Backend Development

When a New Developer Swapped MyBatis for MyBatis‑Plus and Got Scolded by the Team Lead

The article walks through replacing MyBatis 3.5.0 with MyBatis‑Plus 3.1.1 in a legacy Java project, uncovers version‑specific LocalDateTime conversion failures, shows how upgrading mysql‑connector‑java resolves them, and reflects on the broader impact of component upgrades on production stability.

Connector UpgradeLocalDateTimeMyBatis
0 likes · 8 min read
When a New Developer Swapped MyBatis for MyBatis‑Plus and Got Scolded by the Team Lead
Su San Talks Tech
Su San Talks Tech
Nov 8, 2025 · Backend Development

Why MyBatis‑Plus Replacement Failed: Debugging LocalDateTime Issues and Connector Upgrades

This article walks through replacing MyBatis with MyBatis‑Plus in a Java project, diagnosing a Conversion not supported for java.time.LocalDateTime error, uncovering its root cause in MyBatis and mysql‑connector‑java version mismatches, and sharing lessons from subsequent validation bugs and production incidents.

DebuggingMySQLORM
0 likes · 8 min read
Why MyBatis‑Plus Replacement Failed: Debugging LocalDateTime Issues and Connector Upgrades
Top Architect
Top Architect
Nov 4, 2025 · Backend Development

Master MyBatis-Plus in Spring Boot: From Setup to Advanced Features

This tutorial walks you through integrating MyBatis-Plus with Spring Boot, covering environment preparation, Maven dependencies, configuration of data sources, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing with a REST controller.

CRUDEnum MappingLogical Delete
0 likes · 18 min read
Master MyBatis-Plus in Spring Boot: From Setup to Advanced Features
Tech Freedom Circle
Tech Freedom Circle
Nov 4, 2025 · Backend Development

Designing a Non‑Intrusive Spring Cloud SaaS Multi‑Tenant Component for Full‑Stack Data Isolation

The article presents a step‑by‑step, code‑driven design of a Spring Cloud SaaS multi‑tenant solution that balances resource sharing and strict data isolation by using a shared‑database, shared‑schema approach with tenant_id filtering, ThreadLocal context, MyBatis‑Plus interceptors, Redis key prefixing, Sa‑Token session segregation, and Spring Boot auto‑configuration.

RedisSa-TokenSaaS
0 likes · 16 min read
Designing a Non‑Intrusive Spring Cloud SaaS Multi‑Tenant Component for Full‑Stack Data Isolation
Top Architect
Top Architect
Oct 13, 2025 · Backend Development

Why Replacing MyBatis with MyBatis‑Plus Can Break Your App—and How to Fix It

The article walks through swapping MyBatis for MyBatis‑Plus in a legacy Java project, explains the LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL driver, shows how upgrading mysql‑connector‑java resolves the issue, and warns that component upgrades can trigger cascading bugs that require thorough testing.

MySQLORMbackend development
0 likes · 11 min read
Why Replacing MyBatis with MyBatis‑Plus Can Break Your App—and How to Fix It
Architect
Architect
Sep 29, 2025 · Backend Development

Implement Role‑Based Data Permissions in MyBatis‑Plus with Custom Annotations

This article explains how to add data‑permission filtering to MyBatis‑Plus by creating a custom annotation, implementing a global interceptor, wiring a permission‑handler, configuring the interceptor in the MyBatis‑Plus plugin, and extending the solution with role‑based scopes for advanced use cases.

Data PermissionInterceptorjava
0 likes · 13 min read
Implement Role‑Based Data Permissions in MyBatis‑Plus with Custom Annotations
Ray's Galactic Tech
Ray's Galactic Tech
Sep 23, 2025 · Backend Development

Master MyBatis-Plus: Quick Start, Core Features, and Best Practices

This guide walks through adding MyBatis-Plus to a Spring Boot project, configuring basic settings, using CRUD operations, condition builders, pagination, advanced features like auto‑fill, logical delete, optimistic locking, code generation, common pitfalls, and practical recommendations for effective usage.

CRUDORMSpring Boot
0 likes · 7 min read
Master MyBatis-Plus: Quick Start, Core Features, and Best Practices
Cognitive Technology Team
Cognitive Technology Team
Sep 15, 2025 · Databases

Avoid Common Pitfalls When Combining MyBatis‑Plus with ShardingSphere‑JDBC

Learn how to seamlessly integrate MyBatis‑Plus with ShardingSphere‑JDBC for high‑performance sharding, covering core principles, step‑by‑step workflow, and detailed solutions to typical pitfalls such as SQL parsing, pagination conflicts, key generation, query routing, transaction handling, broadcast tables, injection risks, and shard algorithm design.

ShardingSphere-JDBCdatabase shardingjava
0 likes · 19 min read
Avoid Common Pitfalls When Combining MyBatis‑Plus with ShardingSphere‑JDBC
Cognitive Technology Team
Cognitive Technology Team
Sep 14, 2025 · Databases

Avoid Common Pitfalls When Combining MyBatis‑Plus with ShardingSphere‑JDBC

This article explains how MyBatis‑Plus and ShardingSphere‑JDBC work together for sharding and scaling, outlines their core responsibilities, details the step‑by‑step SQL processing flow, and provides practical solutions to typical issues such as SQL parsing errors, pagination conflicts, primary‑key generation clashes, missing sharding keys, distributed transaction complexities, broadcast‑table misconfigurations, injection risks, and uneven sharding algorithms.

Java ORMShardingSphere-JDBCdatabase sharding
0 likes · 18 min read
Avoid Common Pitfalls When Combining MyBatis‑Plus with ShardingSphere‑JDBC
Architecture Digest
Architecture Digest
Aug 29, 2025 · Backend Development

Eliminate Repetitive Common Fields in Java Backends with MyBatis-Plus, AOP, and JWT

This article explains how to automate the handling of common entity fields such as creation time, update time, and user identifiers in Java backend services by using MyBatis-Plus automatic filling, custom AOP aspects, multi‑data‑source configuration, distributed ID generation, and auditing techniques, dramatically reducing boiler‑plate code and bugs.

AOPAuditingSpringBoot
0 likes · 9 min read
Eliminate Repetitive Common Fields in Java Backends with MyBatis-Plus, AOP, and JWT
Su San Talks Tech
Su San Talks Tech
Aug 29, 2025 · Backend Development

Why Switching to MyBatis‑Plus Can Break LocalDateTime Handling and How to Fix It

The article walks through replacing MyBatis with MyBatis‑Plus in a legacy project, explains the LocalDateTime conversion errors caused by version changes in MyBatis and mysql‑connector‑java, shows how upgrading the JDBC driver resolves the issue, and shares lessons on cautious component upgrades and testing.

LocalDateTimeMySQLVersion Compatibility
0 likes · 8 min read
Why Switching to MyBatis‑Plus Can Break LocalDateTime Handling and How to Fix It
Sohu Tech Products
Sohu Tech Products
Aug 28, 2025 · Backend Development

Unlock MyBatis-Plus: From Zero-Code CRUD to Secure, Scalable DAO Architecture

This article introduces MyBatis-Plus, explains its core zero‑invasion features such as effortless single‑table CRUD, powerful Lambda condition builders, and a rich plugin system, then provides practical guidelines and code examples for building secure, high‑performance DAO layers in microservice back‑ends.

CRUDDAOORM
0 likes · 16 min read
Unlock MyBatis-Plus: From Zero-Code CRUD to Secure, Scalable DAO Architecture
Cognitive Technology Team
Cognitive Technology Team
Aug 22, 2025 · Backend Development

Unlock MyBatis-Plus: From Zero-Code CRUD to Advanced Plugins

This article introduces MyBatis-Plus as a zero‑intrusion enhancement to MyBatis, explains its core values of convenience, safety, and compatibility, details CRUD methods, condition builders, plugin mechanisms, and best‑practice guidelines for building efficient, secure backend services.

CRUDLambda QueryORM
0 likes · 15 min read
Unlock MyBatis-Plus: From Zero-Code CRUD to Advanced Plugins
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 20, 2025 · Backend Development

Unlock MyBatis-Plus: From Zero-Code CRUD to Advanced Plugins

This article introduces MyBatis-Plus, explains its core zero‑injection CRUD capabilities, demonstrates powerful condition builders, plugin extensions, and best practices for secure, efficient data access, including custom query objects, micro‑service integration, and advanced mapper customization, helping developers boost backend productivity.

CRUDORMjava
0 likes · 16 min read
Unlock MyBatis-Plus: From Zero-Code CRUD to Advanced Plugins
Architect's Tech Stack
Architect's Tech Stack
Aug 15, 2025 · Backend Development

Why Upgrading to MyBatis‑Plus Triggers LocalDateTime Errors and How to Resolve Them

This article walks through a real‑world scenario where replacing MyBatis with MyBatis‑Plus caused a LocalDateTime conversion exception due to changes in MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, demonstrates how to pinpoint the root cause via stack traces, and provides step‑by‑step fixes including driver upgrades and version considerations, while also sharing lessons learned from related validation bugs.

LocalDateTimeORMVersion Compatibility
0 likes · 16 min read
Why Upgrading to MyBatis‑Plus Triggers LocalDateTime Errors and How to Resolve Them
Code Ape Tech Column
Code Ape Tech Column
Aug 6, 2025 · Backend Development

Implement Role‑Based Data Permissions in MyBatis‑Plus Using Annotations & Interceptors

This article explains how to enforce data‑access restrictions in MyBatis‑Plus by creating a custom @UserDataPermission annotation, building an InnerInterceptor that rewrites SQL queries, handling role‑based scopes, and integrating the interceptor into the MyBatis‑Plus plugin for both basic and advanced use cases.

Data PermissionInterceptorbackend development
0 likes · 17 min read
Implement Role‑Based Data Permissions in MyBatis‑Plus Using Annotations & Interceptors
macrozheng
macrozheng
Jul 30, 2025 · Backend Development

Why Replacing MyBatis with MyBatis‑Plus Can Break LocalDateTime Handling (and How to Fix It)

A developer upgraded an old Spring Boot project by swapping MyBatis for MyBatis‑Plus, ran into a Conversion not supported for java.time.LocalDateTime error, traced the root cause to MyBatis 3.5.1 delegating type conversion to an outdated mysql‑connector‑java, and resolved it by upgrading the connector and adjusting validation logic, illustrating the ripple effects of component upgrades.

MySQLORMjava
0 likes · 9 min read
Why Replacing MyBatis with MyBatis‑Plus Can Break LocalDateTime Handling (and How to Fix It)
Programmer XiaoFu
Programmer XiaoFu
Jul 14, 2025 · Backend Development

Free Your Hands: 6 SpringBoot Techniques for Automatic Common Field Filling

The article analyzes the repetitive maintenance of common fields like createTime and updateUser in SpringBoot CRUD services, presents six production‑tested strategies—including MyBatis‑Plus meta‑object handling, AOP with custom annotations, multi‑data‑source adaptation, distributed ID generation, caching, batch optimization, and audit logging—detailing implementations, pitfalls, and best‑practice recommendations that can cut code by 90% and boost development efficiency.

AOPSpringBootautomatic field filling
0 likes · 9 min read
Free Your Hands: 6 SpringBoot Techniques for Automatic Common Field Filling
JD Tech Talk
JD Tech Talk
Jul 9, 2025 · Backend Development

Boost Java Backend Performance: Combine MyBatis-Plus LambdaQueryWrapper with Spring @Async

Learn how to leverage MyBatis-Plus’s type-safe LambdaQueryWrapper together with Spring Boot’s @Async annotation to build efficient, asynchronous database operations, covering basic usage, advanced thread-pool configuration, exception handling, transaction management, and real-world scenarios for backend developers.

Asynchronous ProgrammingLambdaQueryWrapperSpring Async
0 likes · 9 min read
Boost Java Backend Performance: Combine MyBatis-Plus LambdaQueryWrapper with Spring @Async
JD Cloud Developers
JD Cloud Developers
Jul 9, 2025 · Backend Development

Boost Java Backend Performance with MyBatis-Plus LambdaQueryWrapper and Spring @Async

Learn how to combine MyBatis-Plus's type‑safe LambdaQueryWrapper with Spring Boot's @Async annotation to build readable, maintainable queries and execute them asynchronously, including configuration of custom thread pools, exception handling, transaction management, and practical use cases such as reporting and batch processing.

LambdaQueryWrapperSpring Bootasync
0 likes · 8 min read
Boost Java Backend Performance with MyBatis-Plus LambdaQueryWrapper and Spring @Async
Architect's Guide
Architect's Guide
Jul 7, 2025 · Backend Development

Dynamic Data Source Switching in Spring Boot Using ThreadLocal & AbstractRoutingDataSource

This tutorial explains how to implement dynamic data source switching in Spring Boot by combining ThreadLocal with AbstractRoutingDataSource, covering custom context holders, configuration, annotation‑driven switching, dynamic addition of data sources, and complete code examples with test results.

Dynamic Data SourceSpring BootThreadLocal
0 likes · 16 min read
Dynamic Data Source Switching in Spring Boot Using ThreadLocal & AbstractRoutingDataSource
Architect
Architect
Jul 3, 2025 · Backend Development

Eliminate Repetitive Common Fields in Java Order Services with MyBatis-Plus, AOP, and JWT

This article presents a production‑tested, six‑step automation strategy—combining MyBatis‑Plus auto‑fill, AOP interceptors, JWT‑based user retrieval, multi‑data‑source handling, distributed ID generation, and audit logging—to completely remove manual maintenance of common fields like create_time and update_by in Java order modules, boosting efficiency and reducing bugs.

AOPautomatic-fillcode optimization
0 likes · 9 min read
Eliminate Repetitive Common Fields in Java Order Services with MyBatis-Plus, AOP, and JWT
Java Captain
Java Captain
Jun 16, 2025 · Backend Development

Master MyBatis-Plus with Spring Boot: CRUD, Pagination & Multi-DataSource Guide

A comprehensive step‑by‑step tutorial shows how to integrate MyBatis‑Plus into a Spring Boot project, covering dependencies, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing.

CRUDMulti-DataSourceORM
0 likes · 13 min read
Master MyBatis-Plus with Spring Boot: CRUD, Pagination & Multi-DataSource Guide
macrozheng
macrozheng
Jun 13, 2025 · Backend Development

Why MyBatis-Plus saveBatch Triggers Unexpected Transaction Rollback and How to Fix It

This article explains a puzzling Spring Boot transaction rollback caused by MyBatis-Plus's saveBatch method, reproduces the error with nested @Transactional calls, analyzes why the rollback flag is set, and offers a practical workaround by replacing the framework batch operation with a custom mapper implementation.

SpringBootTransactionbackend
0 likes · 6 min read
Why MyBatis-Plus saveBatch Triggers Unexpected Transaction Rollback and How to Fix It
Java Tech Enthusiast
Java Tech Enthusiast
Jun 9, 2025 · Backend Development

Eliminate Repetitive Audit Fields in Java: 6 Proven Strategies with MyBatis‑Plus, AOP, and JWT

This article presents a production‑tested, six‑step solution for automatically handling common entity fields such as createTime, updateTime, createUser, and updateUser in Java backend systems, covering MyBatis‑Plus auto‑fill, AOP interception, multi‑data‑source adaptation, distributed ID generation, pitfalls avoidance, performance tuning, and audit logging.

AOPautomatic field fillingbackend development
0 likes · 9 min read
Eliminate Repetitive Audit Fields in Java: 6 Proven Strategies with MyBatis‑Plus, AOP, and JWT
Java Web Project
Java Web Project
Jun 8, 2025 · Backend Development

How to Build a Reusable CRUD BaseController with MyBatis‑Plus in Spring Boot

This tutorial walks through creating a generic BaseController that provides CRUD, list, pagination, and count operations for any entity by adding MyBatis‑Plus, writing a utility class for query building, configuring a pagination interceptor, and extending the base class in concrete controllers, all illustrated with complete Java code snippets.

BaseControllerCRUDREST API
0 likes · 8 min read
How to Build a Reusable CRUD BaseController with MyBatis‑Plus in Spring Boot
Java Web Project
Java Web Project
Jun 4, 2025 · Backend Development

How to Eliminate Repetitive Common Fields in Java Order Services with MyBatis‑Plus and AOP

This article analyzes the pain points of manually maintaining common fields in order‑related entities and presents a production‑tested solution that combines MyBatis‑Plus automatic filling, custom AOP annotations, multi‑data‑source handling, distributed ID generation, and auditing to dramatically reduce boilerplate code and bugs.

AOPAuditingAutomatic Field Fill
0 likes · 9 min read
How to Eliminate Repetitive Common Fields in Java Order Services with MyBatis‑Plus and AOP
Selected Java Interview Questions
Selected Java Interview Questions
May 27, 2025 · Backend Development

Mybatis-Plus Generator UI: A Web UI Tool for Custom Code Generation in Spring Boot

This article introduces the Mybatis-Plus Generator UI, a highly customizable web‑based code generator that wraps Mybatis‑Plus, explains its features, shows how to integrate it via Maven, run a sample main class, configure generation strategies, customize templates and naming rules, and even extend the frontend with Yarn builds.

Spring BootUIcode generation
0 likes · 11 min read
Mybatis-Plus Generator UI: A Web UI Tool for Custom Code Generation in Spring Boot
Code Ape Tech Column
Code Ape Tech Column
May 26, 2025 · Backend Development

Automated Management of Common Fields in Order Modules Using MyBatis-Plus, AOP, and JWT

This article presents a production‑validated solution that combines MyBatis‑Plus auto‑fill, AOP, JWT, multi‑data‑source handling, distributed ID generation, performance tuning, and audit logging to eliminate repetitive maintenance of common fields such as createTime, updateTime, createUser, and updateUser in Java backend order services.

AOPAutomationSpring
0 likes · 9 min read
Automated Management of Common Fields in Order Modules Using MyBatis-Plus, AOP, and JWT
Architecture Digest
Architecture Digest
May 21, 2025 · Backend Development

Automating Common Entity Fields in Java Backend with MyBatis-Plus, AOP, and JWT

This article presents a production‑tested solution for automatically handling common entity fields such as createTime, updateTime, createUser, and updateUser in Java backend systems, combining MyBatis‑Plus auto‑fill, AOP interceptors, custom annotations, multi‑datasource support, distributed ID generation, and auditing techniques to eliminate repetitive code and reduce bugs.

AOPmybatis-plus
0 likes · 9 min read
Automating Common Entity Fields in Java Backend with MyBatis-Plus, AOP, and JWT
Java Tech Enthusiast
Java Tech Enthusiast
May 15, 2025 · Backend Development

Automate CRUD with a Generic BaseController in Spring Boot

This guide shows how to create a reusable BaseController using MyBatis‑Plus, reflection utilities, and Spring Boot annotations to provide automatic CRUD, list, pagination and count endpoints for any entity with minimal code.

CRUDGeneric ControllerREST API
0 likes · 10 min read
Automate CRUD with a Generic BaseController in Spring Boot
Code Ape Tech Column
Code Ape Tech Column
May 13, 2025 · Backend Development

Elegant Multi‑Tenant Data Isolation with MyBatis‑Plus in SaaS Applications

This article explains the concept of SaaS multi‑tenant architecture, compares three data‑isolation designs, and demonstrates how to implement elegant tenant‑level data isolation in Java using MyBatis‑Plus’s tenant plugin, complete with configuration, handler code, SQL examples, and troubleshooting tips.

Data IsolationSQLSaaS
0 likes · 15 min read
Elegant Multi‑Tenant Data Isolation with MyBatis‑Plus in SaaS Applications
Java Tech Enthusiast
Java Tech Enthusiast
May 5, 2025 · Backend Development

Advanced MyBatis-Plus Features: Batch Insert, Logical Delete, Auto Field Fill, Type Handlers, Dynamic Table Names, Multi-Tenant

The article demonstrates advanced MyBatis‑Plus techniques—including high‑speed batch inserts with rewriteBatchedStatements, logical deletes via global config, automatic timestamp and user fields through MetaObjectHandler, JSON serialization with JacksonTypeHandler, dynamic table naming via an interceptor, and a brief multi‑tenant overview—to streamline development and reduce boilerplate code.

Batch InsertDynamic TableLogical Delete
0 likes · 16 min read
Advanced MyBatis-Plus Features: Batch Insert, Logical Delete, Auto Field Fill, Type Handlers, Dynamic Table Names, Multi-Tenant
Code Ape Tech Column
Code Ape Tech Column
Apr 29, 2025 · Backend Development

Custom SQL Injector in MyBatis‑Plus: Built‑in Extensions, Global Configuration, and How to Create Your Own

This article explains the concept of SQL injectors in MyBatis‑Plus, lists the built‑in injectable methods, shows how to configure them globally, demonstrates creating a custom mapper and injector with full code examples, and provides step‑by‑step testing procedures for extending MyBatis‑Plus functionality.

Custom MapperSQL InjectorSpring Boot
0 likes · 7 min read
Custom SQL Injector in MyBatis‑Plus: Built‑in Extensions, Global Configuration, and How to Create Your Own
Top Architect
Top Architect
Apr 28, 2025 · Backend Development

Replacing MyBatis with MyBatis-Plus: Debugging LocalDateTime Conversion Errors and MySQL Connector Upgrades

The article walks through migrating an old MySQL‑5.7 project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, diagnosing a LocalDateTime conversion exception caused by an outdated mysql‑connector‑java driver, and resolves it by upgrading the driver version, highlighting the need for careful component compatibility checks.

LocalDateTimeMySQLORM
0 likes · 10 min read
Replacing MyBatis with MyBatis-Plus: Debugging LocalDateTime Conversion Errors and MySQL Connector Upgrades
Java Captain
Java Captain
Apr 27, 2025 · Backend Development

Parallel Pagination Query Interceptor for MyBatis-Plus in Spring Boot

This article explains how to implement a custom MyBatis-Plus pagination interceptor that parallelizes COUNT and data queries using CompletableFuture and a configurable thread pool in Spring Boot, suitable for large single-table and complex multi-table pagination scenarios, and provides detailed configuration and code examples.

Parallel QuerySpring BootThreadPool
0 likes · 13 min read
Parallel Pagination Query Interceptor for MyBatis-Plus in Spring Boot
Java Captain
Java Captain
Apr 21, 2025 · Backend Development

MyBatis-Plus Guide: Features, Quick Start, CRUD Extensions, and Advanced Usage

This article introduces MyBatis‑Plus, an enhancement for MyBatis, outlining its lightweight features, step‑by‑step setup including database creation, Maven dependency, configuration, entity and mapper definitions, CRUD operations, pagination, optimistic locking, logical deletion, condition wrappers, and code generation utilities for rapid backend development.

CRUDORMSpring Boot
0 likes · 12 min read
MyBatis-Plus Guide: Features, Quick Start, CRUD Extensions, and Advanced Usage
Architect's Guide
Architect's Guide
Apr 12, 2025 · Backend Development

Refactoring Data Validation with Java 8 Functional Interfaces

This article demonstrates how Java 8's functional interfaces, especially Function and SFunction, can be used to abstract and reuse data‑validation logic, dramatically reducing boilerplate code, improving readability, and making validation rules easier to maintain and extend.

Functional ProgrammingLambdabackend
0 likes · 12 min read
Refactoring Data Validation with Java 8 Functional Interfaces
Architect
Architect
Mar 12, 2025 · Backend Development

DataSource Switching in Spring Boot with ThreadLocal & AbstractRoutingDataSource

Facing the need to query multiple databases in a Spring Boot application, this guide walks through building a custom dynamic datasource solution using ThreadLocal and AbstractRoutingDataSource, covering core implementations, annotation‑based switching, dynamic datasource addition, configuration, and comprehensive test results.

Spring BootThreadLocalabstractroutingdatasource
0 likes · 18 min read
DataSource Switching in Spring Boot with ThreadLocal & AbstractRoutingDataSource
Java Tech Enthusiast
Java Tech Enthusiast
Mar 7, 2025 · Backend Development

Implementing a Responsibility Chain Pattern with Spring Boot and MyBatis Plus

The article demonstrates how to build a dynamic Chain of Responsibility in a Spring Boot and MyBatis‑Plus application by defining an abstract handler, implementing concrete @Component beans that modify a shared Lombok‑based context, retrieving them via an ApplicationContext‑aware proxy utility, and invoking them in a client‑specified order through a REST endpoint, while suggesting LiteFlow as a production alternative.

Design PatternREST APISpring Boot
0 likes · 9 min read
Implementing a Responsibility Chain Pattern with Spring Boot and MyBatis Plus
Architect
Architect
Jan 15, 2025 · Backend Development

How Java 8 Functional Interfaces Can Eliminate Repetitive Validation Code

This article demonstrates how Java 8’s functional interfaces, especially Function and SFunction, can refactor repetitive data‑validation logic into a generic, reusable method, reducing boilerplate, improving readability, and enabling flexible validation scenarios such as checking column values, matching expected values, and verifying values against allowed lists.

Code RefactoringFunctional ProgrammingLambda
0 likes · 14 min read
How Java 8 Functional Interfaces Can Eliminate Repetitive Validation Code
Top Architect
Top Architect
Jan 8, 2025 · Backend Development

Implementing Data Permission Interceptor in MyBatis‑Plus with Custom Annotations

This article explains how to create a custom annotation and a MyBatis‑Plus interceptor that automatically injects data‑permission SQL conditions based on the current user's role, showing both a basic implementation and an advanced version with role‑based scope handling, complete with code examples and integration steps.

Data PermissionInterceptorbackend development
0 likes · 16 min read
Implementing Data Permission Interceptor in MyBatis‑Plus with Custom Annotations
Top Architect
Top Architect
Dec 29, 2024 · Backend Development

Replacing MyBatis with MyBatis‑Plus: Debugging Conversion Errors and Version Compatibility

This article walks through migrating an old MySQL‑5.7 project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains the "Conversion not supported for type java.time.LocalDateTime" exception, shows how upgrading mysql‑connector‑java resolves the issue, and shares lessons learned from a production bug caused by an over‑optimistic validation change.

DebuggingMySQLORM
0 likes · 10 min read
Replacing MyBatis with MyBatis‑Plus: Debugging Conversion Errors and Version Compatibility
Architect
Architect
Dec 20, 2024 · Backend Development

Boost MyBatis-Plus Batch Inserts by 2000% with rewriteBatchedStatements and ID Pre‑Generation

By configuring MySQL’s rewriteBatchedStatements=true, pre‑generating primary keys, adjusting MyBatis executor settings, and employing asynchronous multithreaded batch inserts, this guide demonstrates how to accelerate MyBatis‑Plus saveBatch operations from seconds to milliseconds, achieving up to a 2000% performance gain in large‑scale data scenarios.

Batch Insertjavamultithreading
0 likes · 20 min read
Boost MyBatis-Plus Batch Inserts by 2000% with rewriteBatchedStatements and ID Pre‑Generation
IT Services Circle
IT Services Circle
Dec 9, 2024 · Backend Development

Optimized Snowflake ID Generation with Seata: Solving MyBatis-Plus Duplicate Key Issues

This article analyzes why MyBatis-Plus generates duplicate primary keys in clustered Docker/K8S environments due to worker‑id and datacenter‑id collisions, introduces Seata's improved Snowflake algorithm that decouples from the OS clock, explains its implementation with Java code, and shows how to integrate it as a global ID generator to improve database performance and avoid page splits.

Database PerformanceSeataSnowflake algorithm
0 likes · 18 min read
Optimized Snowflake ID Generation with Seata: Solving MyBatis-Plus Duplicate Key Issues
macrozheng
macrozheng
Dec 9, 2024 · Backend Development

Why Replacing MyBatis with MyBatis-Plus Can Break Your Java App—and How to Fix It

This article walks through replacing MyBatis with MyBatis-Plus in a Spring Boot project, explains the LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL connector, and shows how upgrading the connector resolves the issue while highlighting the risks of component upgrades.

DebuggingORMSpring Boot
0 likes · 8 min read
Why Replacing MyBatis with MyBatis-Plus Can Break Your Java App—and How to Fix It
Architecture Digest
Architecture Digest
Dec 2, 2024 · Backend Development

Refactoring Data Validation with Java 8 Functional Interfaces

This article demonstrates how Java 8's functional interfaces and lambda expressions can be used to abstract and reuse data validation logic, reducing repetitive code and improving readability and maintainability in backend services.

Functional ProgrammingLambdadata validation
0 likes · 12 min read
Refactoring Data Validation with Java 8 Functional Interfaces
Zhuanzhuan Tech
Zhuanzhuan Tech
Nov 28, 2024 · Backend Development

Boosting MyBatis-Plus Batch Insert Performance by 2000% with rewriteBatchedStatements and Pre‑Generated IDs

This article explains how to dramatically improve MyBatis-Plus batch insertion speed—up to 2000%—by enabling rewriteBatchedStatements, pre‑generating primary keys to handle foreign‑key relationships, applying proper JDBC batch settings, and using asynchronous multithreaded insertion with optimized connection‑pool and executor configurations.

Batch InsertJDBCid generation
0 likes · 21 min read
Boosting MyBatis-Plus Batch Insert Performance by 2000% with rewriteBatchedStatements and Pre‑Generated IDs
Top Architect
Top Architect
Nov 2, 2024 · Backend Development

Optimizing MyBatis-Plus Batch Insert Performance with rewriteBatchedStatements and Multithreading

This article explains how to dramatically speed up MyBatis-Plus batch inserts by enabling the rewriteBatchedStatements JDBC property, creating custom batch insert/update methods, and applying multithreading, providing code examples, performance test results, and practical recommendations for handling large data synchronizations.

Batch InsertDatabasejava
0 likes · 15 min read
Optimizing MyBatis-Plus Batch Insert Performance with rewriteBatchedStatements and Multithreading
Java Architect Essentials
Java Architect Essentials
Oct 29, 2024 · Backend Development

Optimizing Batch Insert Performance with MyBatis-Plus: Configuration, Custom Methods, and Multithreading

This article explains why MyBatis-Plus's saveBatch() can be slow for large data sets, shows how enabling rewriteBatchedStatements in the JDBC URL dramatically speeds up inserts, and demonstrates custom batch insert/update methods and multithreaded execution to further improve performance, complete with code examples and test results.

Batch InsertDatabasejava
0 likes · 14 min read
Optimizing Batch Insert Performance with MyBatis-Plus: Configuration, Custom Methods, and Multithreading
macrozheng
macrozheng
Oct 14, 2024 · Backend Development

Simplify MyBatis-Plus Join Queries with MPJ: A Hands‑On Guide

This tutorial demonstrates how to use the mybatis-plus-join (MPJ) library to perform left and right join queries in a Spring Boot project without writing XML, covering dependency setup, mapper changes, query construction, pagination, and practical code examples.

Join QueryMPJORM
0 likes · 10 min read
Simplify MyBatis-Plus Join Queries with MPJ: A Hands‑On Guide
Top Architect
Top Architect
Sep 16, 2024 · Backend Development

Implementing Data Permission Interceptor in MyBatis‑Plus Using Custom Annotations

This article explains how to create a custom annotation and MyBatis‑Plus interceptor to enforce data‑permission filtering based on user roles, provides both basic and advanced implementations with complete Java code examples, and shows how to integrate the interceptor into the MyBatis‑Plus plugin configuration.

Data PermissionInterceptorSpring
0 likes · 15 min read
Implementing Data Permission Interceptor in MyBatis‑Plus Using Custom Annotations