BestHub
Sign in
Tagged articles
363 articles
Page 1 of 4
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.

BatchInsertEnumMappingJava
0 likes · 20 min read
10 Common MyBatis‑Plus Pitfalls and How to Avoid Them
Node.js Tech Stack
Node.js Tech Stack
May 2, 2026 · Databases

Why Drizzle ORM on Bun Beats Go’s Latency – Even Evan You Uses It

Drizzle ORM v1.0.0‑rc.1 introduces JIT row mappers and Effect v4 integration, delivering a benchmark where Bun + Drizzle achieves 7.3 ms latency versus Go’s 18.1 ms, with higher CPU usage, and the article analyzes the feature changes, performance trade‑offs, and migration considerations.

BenchmarkBunDrizzle ORM
0 likes · 10 min read
Why Drizzle ORM on Bun Beats Go’s Latency – Even Evan You Uses It
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 MappingJava
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 MappingJava
0 likes · 19 min read
10 Common Pitfalls in MyBatis-Plus and How to Avoid Them
Top Architect
Top Architect
Mar 30, 2026 · Databases

How MyBatis Uses Over 10 Design Patterns to Simplify ORM Architecture

The article analyzes MyBatis’s 20,000‑line source code, showing how it applies more than ten classic design patterns—such as Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to decouple complex ORM scenarios, improve extensibility, and illustrate practical implementation details.

Design PatternsJavaMyBatis
0 likes · 12 min read
How MyBatis Uses Over 10 Design Patterns to Simplify ORM Architecture
java1234
java1234
Mar 29, 2026 · Backend Development

Why MyBatis Is Called a Semi‑ORM Mapping Tool

MyBatis, a widely used Java persistence framework, blends SQL mapping with traditional JDBC, requiring developers to write SQL manually, offering greater flexibility and performance than full ORM solutions like Hibernate, while providing only persistence operations without encapsulating complex business logic.

HibernateJavaMyBatis
0 likes · 6 min read
Why MyBatis Is Called a Semi‑ORM Mapping Tool
DevOps Coach
DevOps Coach
Jan 31, 2026 · Databases

7 Overlooked PostgreSQL Architecture Mistakes That Kill Performance

The article reveals seven common PostgreSQL architectural oversights—such as neglecting vacuum, misusing UUID primary keys, treating the database as a queue, missing indexes, over‑relying on ORMs, ignoring write‑side scaling, and failing to partition large tables—that silently degrade performance and reliability, and provides concrete fixes and best‑practice configurations.

ORMPartitioningPostgreSQL
0 likes · 7 min read
7 Overlooked PostgreSQL Architecture Mistakes That Kill Performance
macrozheng
macrozheng
Jan 23, 2026 · Backend Development

Is Unified ORM Worth It? A Deep Dive into dbVisitor, Jimmer, and JdbcClient

The article critically examines the promise of a universal Java data‑access API like dbVisitor, contrasts it with specialized ORM solutions such as Jimmer, and highlights the lightweight JdbcClient approach, while considering the impact of AI‑generated SQL on traditional ORM relevance.

AIJavaJdbcClient
0 likes · 8 min read
Is Unified ORM Worth It? A Deep Dive into dbVisitor, Jimmer, and JdbcClient
Open Source Tech Hub
Open Source Tech Hub
Jan 16, 2026 · Backend Development

ThinkPHP 6.0 Update: Core & ORM Enhancements, PHP 8.5 Compatibility

The ThinkPHP 6.0 release brings extensive core and ORM improvements—including Config, routing, request/response, Redis caching, lazy collections, view model lifecycle, and query enhancements—adds new CLI tools, ensures full PHP 8.5 compatibility, and provides detailed upgrade instructions and migration notes.

BackendFrameworkORM
0 likes · 11 min read
ThinkPHP 6.0 Update: Core & ORM Enhancements, PHP 8.5 Compatibility
dbaplus Community
dbaplus Community
Dec 28, 2025 · Databases

How Treating Your Database as a Compute Engine Boosted Dashboard Speed 166×

The article explains why teams mistakenly use databases merely as storage, shows a real‑world Node.js dashboard that suffered severe latency, demonstrates how moving aggregation and filtering into SQL queries eliminated N+1 and filtering issues, and presents dramatic performance gains and best‑practice guidelines.

Node.jsORMSQL
0 likes · 17 min read
How Treating Your Database as a Compute Engine Boosted Dashboard Speed 166×
Architecture Digest
Architecture Digest
Dec 17, 2025 · Backend Development

Why MyBatis-Flex Beats MyBatis-Plus: Features, Benchmarks, and Quick Start

MyBatis-Flex is a lightweight, high-performance MyBatis enhancement offering flexible CRUD, advanced QueryWrapper, extensive database support, and benchmarked speeds up to ten times faster than MyBatis-Plus, with a step-by-step quick-start guide covering table creation, Maven setup, Spring Boot configuration, entity mapping, and usage examples.

Backend DevelopmentJavaMyBatis-Flex
0 likes · 9 min read
Why MyBatis-Flex Beats MyBatis-Plus: Features, Benchmarks, and Quick Start
IT Services Circle
IT Services Circle
Dec 4, 2025 · Backend Development

6 Python Libraries That Can Supercharge Your Development in 2025

This article introduces six cutting‑edge Python libraries—FakerX, Prefect 3.0, SQLModel, Litestar, Robocorp, and Typer—explaining the problems they solve, providing concise code examples, and offering practical steps for integrating them to dramatically improve development speed and code quality.

DevelopmentORMPython
0 likes · 12 min read
6 Python Libraries That Can Supercharge Your Development in 2025
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.

DebuggingORMmybatis-plus
0 likes · 8 min read
Why MyBatis‑Plus Replacement Failed: Debugging LocalDateTime Issues and Connector Upgrades
Code Ape Tech Column
Code Ape Tech Column
Oct 27, 2025 · Backend Development

Why MyBatis-Flex Outperforms MyBatis-Plus: Features, Benchmarks, and Quick Start

MyBatis-Flex is a lightweight, high‑performance MyBatis enhancement offering flexible query building, extensive database support, and features like multi‑table joins, logical deletion, and data auditing; the article compares it with MyBatis‑Plus, presents benchmark results, lists supported databases, and provides a step‑by‑step Spring Boot integration guide.

JavaMyBatis-FlexORM
0 likes · 13 min read
Why MyBatis-Flex Outperforms MyBatis-Plus: Features, Benchmarks, and Quick Start
Architect's Tech Stack
Architect's Tech Stack
Oct 18, 2025 · Backend Development

Why MyBatis-Flex Outperforms MyBatis-Plus: Speed, Flexibility, and Advanced Features

MyBatis-Flex is a lightweight, high‑performance MyBatis enhancement offering built‑in query wrappers, flexible relation mapping, multi‑datasource support, data masking, caching, and audit capabilities, delivering 5‑10× faster queries than MyBatis‑Plus while eliminating third‑party dependencies for more stable, flexible backend development.

BackendJavaMyBatis-Flex
0 likes · 15 min read
Why MyBatis-Flex Outperforms MyBatis-Plus: Speed, Flexibility, and Advanced Features
Su San Talks Tech
Su San Talks Tech
Oct 18, 2025 · Backend Development

MyBatis vs Spring Data JPA: Which Should Power Your Spring Boot Project?

This article compares MyBatis and Spring Data JPA, explaining their core concepts, performance, flexibility, learning curve, community support, and real‑world scenarios, and provides code examples and decision criteria to help developers choose the right data‑access framework for their Spring Boot applications.

JavaMyBatisORM
0 likes · 14 min read
MyBatis vs Spring Data JPA: Which Should Power Your Spring Boot Project?
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.

Backend DevelopmentJavaORM
0 likes · 11 min read
Why Replacing MyBatis with MyBatis‑Plus Can Break Your App—and How to Fix It
Ray's Galactic Tech
Ray's Galactic Tech
Sep 23, 2025 · Backend Development

15 MyBatis Pitfalls and How to Avoid Them

This guide lists the 15 most common MyBatis pitfalls—from SQL injection and mismatched field mappings to N+1 queries and improper pagination—paired with concrete best‑practice solutions, code snippets, and configuration tips to make your persistence layer safer, more efficient, and easier to maintain.

JavaMyBatisORM
0 likes · 8 min read
15 MyBatis Pitfalls and How to Avoid Them
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.

CRUDCode GenerationJava
0 likes · 7 min read
Master MyBatis-Plus: Quick Start, Core Features, and Best Practices
Code Wrench
Code Wrench
Sep 18, 2025 · Backend Development

Master GORM Plugins: Build an Asynchronous Audit Log Extension in Go

Learn how to extend GORM with custom plugins by implementing the Plugin interface, registering lifecycle callbacks, and creating an asynchronous audit‑log module that records Create, Update, Delete, and Query actions to a dedicated table, with configurable batch size, flush interval, and buffer settings.

GORMGoORM
0 likes · 10 min read
Master GORM Plugins: Build an Asynchronous Audit Log Extension in Go
macrozheng
macrozheng
Sep 16, 2025 · Backend Development

Simplify Elasticsearch with Easy-Es: MyBatis‑Plus‑Style ORM Tutorial

This article introduces Easy-Es, an Elasticsearch ORM that mimics MyBatis‑Plus syntax, walks through its core features, integration steps, entity annotations, mapper and service implementations, and demonstrates simple, advanced, and recommendation search scenarios, highlighting the reduction in boilerplate code.

Easy-EsElasticsearchJava
0 likes · 17 min read
Simplify Elasticsearch with Easy-Es: MyBatis‑Plus‑Style ORM Tutorial
Code Wrench
Code Wrench
Sep 14, 2025 · Backend Development

GORM Performance Hacks: Real-World Optimizations for High-Concurrency Go Apps

This article examines why GORM is popular in Go, outlines common performance pitfalls such as default transactions and N+1 queries, and provides practical optimization techniques—including disabling default transactions, selective field queries, batch processing, prepared statements, and indexing—illustrated with real‑world case studies for high‑concurrency and large‑scale data scenarios.

GORMGoORM
0 likes · 7 min read
GORM Performance Hacks: Real-World Optimizations for High-Concurrency Go Apps
Code Wrench
Code Wrench
Sep 11, 2025 · Fundamentals

Mastering Go Reflection: Principles, Pitfalls, and a Practical DI Container

This article thoroughly explains Go's reflection mechanism, showcases typical scenarios such as function calls, ORM mapping, and dependency injection, highlights common pitfalls and performance concerns, and provides optimization tips along with a concrete lightweight DI container example.

GoORMReflection
0 likes · 6 min read
Mastering Go Reflection: Principles, Pitfalls, and a Practical DI Container
Tencent Cloud Developer
Tencent Cloud Developer
Sep 3, 2025 · Databases

Deep Dive into GORM: Architecture, Internals, and Common Pitfalls

This article provides a comprehensive overview of Go's powerful GORM ORM library, covering its core concepts, architecture, internal logic, common pitfalls, practical tips, and advanced features such as soft deletes, transaction handling, batch operations, and integration with trpc-go, helping developers master GORM's inner workings.

Batch InsertGORMGo
0 likes · 26 min read
Deep Dive into GORM: Architecture, Internals, and Common Pitfalls
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.

CRUDJavaORM
0 likes · 16 min read
Unlock MyBatis-Plus: From Zero-Code CRUD to Secure, Scalable DAO Architecture
Architect's Tech Stack
Architect's Tech Stack
Aug 24, 2025 · Backend Development

Why MyBatis-Flex Beats MyBatis-Plus: Features, Performance & More

MyBatis-Flex is a lightweight, high‑performance MyBatis enhancement offering zero third‑party dependencies, flexible QueryWrapper support, superior CRUD speed, advanced relational mappings, built‑in data masking, caching, multi‑datasource handling, and customizable SQL auditing, making it a compelling alternative to MyBatis‑Plus for modern Java backend development.

DataMaskingJavaMyBatis-Flex
0 likes · 19 min read
Why MyBatis-Flex Beats MyBatis-Plus: Features, Performance & More
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.

CRUDJavaLambda Query
0 likes · 15 min read
Unlock MyBatis-Plus: From Zero-Code CRUD to Advanced Plugins
Java Architect Essentials
Java Architect Essentials
Aug 22, 2025 · Backend Development

Why MyBatis-Flex Outperforms MyBatis-Plus: Features, Performance & Quick Start

This article introduces MyBatis-Flex, a lightweight yet powerful MyBatis enhancement framework that boosts development efficiency with type‑safe QueryWrapper, extensive features like multi‑tenant and data encryption, supports dozens of databases, and delivers 5‑10× performance gains over MyBatis‑Plus, complete with a step‑by‑step quick‑start guide.

JavaMyBatis-FlexORM
0 likes · 11 min read
Why MyBatis-Flex Outperforms MyBatis-Plus: Features, Performance & Quick Start
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.

CRUDJavaORM
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.

JavaLocalDateTimeORM
0 likes · 16 min read
Why Upgrading to MyBatis‑Plus Triggers LocalDateTime Errors and How to Resolve Them
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.

JavaORMmybatis-plus
0 likes · 9 min read
Why Replacing MyBatis with MyBatis‑Plus Can Break LocalDateTime Handling (and How to Fix It)
macrozheng
macrozheng
Jul 25, 2025 · Backend Development

Boost Java Persistence with MyBatis-Flex: Features, Comparison, and Quick Start

This article introduces MyBatis-Flex, a lightweight yet powerful MyBatis enhancement framework, outlines its key characteristics, compares it with MyBatis-Plus and Fluent-MyBatis, presents performance benchmarks, lists supported databases, and provides a step‑by‑step quick‑start guide for Spring Boot integration.

Backend DevelopmentMyBatis-FlexORM
0 likes · 14 min read
Boost Java Persistence with MyBatis-Flex: Features, Comparison, and Quick Start
php Courses
php Courses
Jul 24, 2025 · Backend Development

Why Static Indexing Is Fading in Modern PHP Development

The article explains how static array indexing, once common in early PHP, has declined due to modern frameworks, stronger type systems, improved IDE support, and maintainability concerns, while outlining alternative patterns and scenarios where static indexing may still be appropriate.

Legacy CodeORMType Safety
0 likes · 4 min read
Why Static Indexing Is Fading in Modern PHP Development
Selected Java Interview Questions
Selected Java Interview Questions
Jul 15, 2025 · Backend Development

Why MyBatis-Flex Outperforms MyBatis-Plus: Features, Benchmarks, and Quick Start

MyBatis-Flex is a lightweight, high‑performance MyBatis enhancement framework that offers flexible CRUD, powerful query capabilities, extensive database support, and significant speed advantages over MyBatis‑Plus, with detailed feature comparisons, performance benchmarks, and a step‑by‑step quick‑start guide.

JavaMyBatis-FlexORM
0 likes · 9 min read
Why MyBatis-Flex Outperforms MyBatis-Plus: Features, Benchmarks, and Quick Start
Code Mala Tang
Code Mala Tang
Jul 3, 2025 · Databases

Master Peewee ORM: From Basic CRUD to Advanced Queries Compared with SQLAlchemy

This tutorial walks through Peewee’s lightweight ORM features—from creating, bulk inserting, updating, and deleting records to complex aggregations, window functions, CTEs, and PostgreSQL RETURNING clauses—while comparing its learning curve and performance to SQLAlchemy using real‑world Leapcell examples.

Advanced QueriesCRUDORM
0 likes · 17 min read
Master Peewee ORM: From Basic CRUD to Advanced Queries Compared with SQLAlchemy
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.

CRUDJavaMulti-DataSource
0 likes · 13 min read
Master MyBatis-Plus with Spring Boot: CRUD, Pagination & Multi-DataSource Guide
Programmer DD
Programmer DD
May 17, 2025 · Backend Development

Unlock Dynamic Fields in Hibernate: Master @Formula for Read‑Only Calculations

The article explains Hibernate's @Formula annotation, showing how to define dynamic, read‑only fields with SQL expressions, provides code examples for simple concatenations, aggregate calculations, and multi‑table integrations, and offers best‑practice guidelines to optimize performance and avoid common pitfalls.

@FormulaBackend DevelopmentHibernate
0 likes · 7 min read
Unlock Dynamic Fields in Hibernate: Master @Formula for Read‑Only Calculations
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 TableJava
0 likes · 16 min read
Advanced MyBatis-Plus Features: Batch Insert, Logical Delete, Auto Field Fill, Type Handlers, Dynamic Table Names, Multi-Tenant
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.

Backend DevelopmentJavaLocalDateTime
0 likes · 10 min read
Replacing MyBatis with MyBatis-Plus: Debugging LocalDateTime Conversion Errors and MySQL Connector Upgrades
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.

CRUDCode GenerationJava
0 likes · 12 min read
MyBatis-Plus Guide: Features, Quick Start, CRUD Extensions, and Advanced Usage
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 12, 2025 · Backend Development

Deep Dive into MyBatis Core Components: Executor, StatementHandler, ParameterHandler, and ResultSetHandler

This article provides a comprehensive, English-language walkthrough of MyBatis's four core components—Executor, StatementHandler, ParameterHandler, and ResultSetHandler—explaining their interfaces, default implementations, key methods, and how they collaborate to translate Java objects into SQL statements and process query results.

ExecutorJavaMyBatis
0 likes · 21 min read
Deep Dive into MyBatis Core Components: Executor, StatementHandler, ParameterHandler, and ResultSetHandler
Selected Java Interview Questions
Selected Java Interview Questions
Mar 7, 2025 · Backend Development

12 MyBatis‑Plus Optimization Tips for Efficient Database Operations

This article presents twelve practical MyBatis‑Plus optimization techniques—including avoiding isNull checks, specifying select fields, batch operations, using exists subqueries, safe ordering, lambda queries, enum mapping, logical deletion, optimistic locking, and increment/decrement methods—to improve code readability, performance, and maintainability in Java backend development.

Backend DevelopmentDatabase OptimizationMyBatisPlus
0 likes · 16 min read
12 MyBatis‑Plus Optimization Tips for Efficient Database Operations
Java Architecture Stack
Java Architecture Stack
Feb 7, 2025 · Backend Development

Master MyBatis Interview: Advanced Tips, Performance Hacks, and Real-World Code

This article walks senior Java developers through MyBatis fundamentals, core components, result mapping, the trade‑offs between #{} and ${}, dynamic SQL, second‑level caching, batch inserts, plugin creation, thread‑safety concerns, and concrete interview‑question solutions, all illustrated with real code snippets and performance numbers.

Backend DevelopmentInterview PreparationJava
0 likes · 11 min read
Master MyBatis Interview: Advanced Tips, Performance Hacks, and Real-World Code
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 29, 2025 · Backend Development

Mastering MyBatisPlus: 12 Practical Tips to Unlock New Knowledge

This article presents twelve practical MyBatisPlus optimization techniques—including avoiding isNull, specifying select fields, batch operations, using EXISTS, safe ordering, LambdaQuery, between, index‑aware sorting, pagination, null‑handling, performance tracking, enum mapping, logical deletion, and optimistic locking—to help Java developers write cleaner, more efficient backend code.

Backend DevelopmentDatabase OptimizationJava
0 likes · 14 min read
Mastering MyBatisPlus: 12 Practical Tips to Unlock New Knowledge
php Courses
php Courses
Jan 27, 2025 · Information Security

How to Prevent SQL Injection in PHP Applications

This article explains essential techniques to protect PHP applications from SQL injection attacks, covering prepared statements, input validation, ORM usage, escaping, stored procedures, permission restrictions, web application firewalls, and logging, with practical code examples for PDO, MySQLi, and Eloquent.

ORMPHPPrepared Statements
0 likes · 5 min read
How to Prevent SQL Injection in PHP Applications
Top Architecture Tech Stack
Top Architecture Tech Stack
Jan 6, 2025 · Backend Development

10 Essential MyBatis Development Tips for Efficient Backend Programming

This article presents ten practical MyBatis techniques—including dynamic SQL, resultMap, foreach, pagination, annotation proxies, second‑level cache, dynamic table names, custom type handlers, logging, and multi‑datasource configuration—to help Java developers write cleaner, safer, and more performant data‑access code.

JavaMyBatisORM
0 likes · 11 min read
10 Essential MyBatis Development Tips for Efficient Backend Programming
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.

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

12 MyBatisPlus Optimization Techniques for Efficient Database Operations

This article presents twelve practical MyBatisPlus optimization techniques—including avoiding isNull checks, specifying select fields, batch operations, using EXISTS, safe ordering, LambdaQuery, between, index-aware sorting, pagination, null handling, performance tracking, enum mapping, logical deletion, optimistic locking, and increment/decrement—to write cleaner, faster, and more maintainable backend code.

Backend DevelopmentDatabase OptimizationJava
0 likes · 16 min read
12 MyBatisPlus Optimization Techniques for Efficient Database Operations
Su San Talks Tech
Su San Talks Tech
Dec 24, 2024 · Backend Development

10 Must‑Know MyBatis Tricks to Supercharge Your Java Backend

Discover ten powerful MyBatis techniques—from dynamic SQL and resultMap customization to batch operations, pagination, annotation‑based mappers, caching, dynamic table names, custom type handlers, logging, and multi‑datasource configuration—that can dramatically improve Java backend development efficiency and code quality.

JavaORMSQL
0 likes · 10 min read
10 Must‑Know MyBatis Tricks to Supercharge Your Java Backend
Selected Java Interview Questions
Selected Java Interview Questions
Dec 20, 2024 · Backend Development

12 MyBatis‑Plus Optimization Tips for Efficient Database Operations

This article presents twelve practical MyBatis‑Plus optimization techniques—ranging from avoiding null checks and specifying select fields to batch operations, safe ordering, pagination, logical deletion, optimistic locking, and performance tracking—each illustrated with code examples and clear explanations to help backend developers write cleaner, faster, and more maintainable Java ORM queries.

BackendDatabase OptimizationJava
0 likes · 14 min read
12 MyBatis‑Plus Optimization Tips for Efficient Database Operations
DaTaobao Tech
DaTaobao Tech
Dec 13, 2024 · Databases

MyBatis Boolean vs Boolean: Unexpected 0 Value and Fix

Because MyBatis reads a primitive boolean field directly when no getter exists, the default false value is bound as 0, causing an unexpected zero in the MySQL tinyint column; changing the field to the Boolean wrapper (initialized to true) or fixing the update logic resolves the issue.

DebuggingJavaMyBatis
0 likes · 9 min read
MyBatis Boolean vs Boolean: Unexpected 0 Value and Fix
Selected Java Interview Questions
Selected Java Interview Questions
Dec 6, 2024 · Backend Development

Design and Implementation of a Lightweight Data Translation Framework for Java Backend Applications

This article introduces a lightweight, extensible Java framework that uses custom annotations to translate relational data, dictionaries, collections, and nested objects, detailing its background, architecture, core annotation design, usage examples, advanced features, Spring Boot integration, ORM support, and provides the open‑source repository link.

BackendData TranslationFramework
0 likes · 17 min read
Design and Implementation of a Lightweight Data Translation Framework for Java Backend Applications
Selected Java Interview Questions
Selected Java Interview Questions
Nov 29, 2024 · Databases

12 MyBatis‑Plus Optimization Tips for Efficient Database Operations

This article presents twelve practical MyBatis‑Plus optimization techniques—including avoiding isNull checks, specifying select fields, batch operations, using EXISTS, safe ordering, type‑safe Lambda queries, handling nulls, performance tracking, enum mapping, logical deletion, optimistic locking, and increment/decrement methods—to improve code readability, maintainability, and database query performance.

Database OptimizationJavaMyBatisPlus
0 likes · 14 min read
12 MyBatis‑Plus Optimization Tips for Efficient Database Operations
Open Source Tech Hub
Open Source Tech Hub
Nov 29, 2024 · Backend Development

Mastering ThinkPHP 4.0+ Entity Models: A Complete Backend Guide

This guide explains ThinkPHP 4.0+ entity models, covering their layered architecture, installation, entity and model definitions, automatic relation queries, new type casting, accessors, configuration options, virtual and view models, with full code examples and practical tips for backend developers.

Backend DevelopmentEntity ModelORM
0 likes · 11 min read
Mastering ThinkPHP 4.0+ Entity Models: A Complete Backend Guide
Architecture Digest
Architecture Digest
Nov 11, 2024 · Backend Development

Fluent Mybatis Tutorial: Introduction, Features, Comparison with MyBatis/MyBatis Plus, and Practical CRUD Implementation

This article introduces the Fluent Mybatis ORM framework, explains its design advantages, demonstrates how to implement a complex student‑score aggregation query using Fluent Mybatis, native MyBatis and MyBatis‑Plus, and provides end‑to‑end code examples for entity generation, configuration, and CRUD testing.

Code GenerationFluent MyBatisJava
0 likes · 16 min read
Fluent Mybatis Tutorial: Introduction, Features, Comparison with MyBatis/MyBatis Plus, and Practical CRUD Implementation
Python Programming Learning Circle
Python Programming Learning Circle
Nov 7, 2024 · Backend Development

9 Best Practices for Enterprise Python Development

This article presents nine essential best‑practice steps for building robust, maintainable Python backend applications, covering virtual environments, dependency management, logging, configuration files, testing, asynchronous I/O, Docker containerization, CI/CD automation, and ORM usage with a practical Flask example.

BackendORMPython
0 likes · 11 min read
9 Best Practices for Enterprise Python Development
Architecture Digest
Architecture Digest
Nov 3, 2024 · Backend Development

Using Easy-Query ORM for Strongly Typed OLTP and OLAP Queries in Java

This article introduces Easy-Query, a Java ORM that offers strong‑typed OLTP and OLAP query capabilities, demonstrates how to define entity classes with many‑to‑many and one‑to‑one relationships, and provides multiple code examples for complex queries, DTO generation, and automatic inclusion of related data.

Easy-QueryJavaOLAP
0 likes · 11 min read
Using Easy-Query ORM for Strongly Typed OLTP and OLAP Queries in Java
Top Architect
Top Architect
Oct 22, 2024 · Databases

EasyQuery – A High‑Performance Java ORM with Strongly Typed Query API

The article presents EasyQuery, a high‑performance, type‑safe Java ORM inspired by .NET solutions, demonstrating its query capabilities—including single‑record retrieval, pagination, joins, subqueries, streaming results, custom VO mapping, dynamic conditions, and native SQL fragments—while highlighting its advantages over MyBatis‑Plus.

JavaORMdatabase
0 likes · 15 min read
EasyQuery – A High‑Performance Java ORM with Strongly Typed Query API
Su San Talks Tech
Su San Talks Tech
Oct 15, 2024 · Backend Development

How Bean Searcher Lets You Build Complex Queries with One Line of Code

Bean Searcher is an open‑source, Apache‑2.0 licensed ORM search engine that outperforms MyBatis by up to 100×, offering one‑line multi‑table joins, pagination, dynamic sorting, field aggregation, and extensive extensibility, with simple Spring Boot integration and customizable components for rapid backend development.

JavaORMSpring Boot
0 likes · 9 min read
How Bean Searcher Lets You Build Complex Queries with One Line of Code
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.

JavaJoin QueryMPJ
0 likes · 10 min read
Simplify MyBatis-Plus Join Queries with MPJ: A Hands‑On Guide
Java Tech Enthusiast
Java Tech Enthusiast
Oct 13, 2024 · Backend Development

Fluent Mybatis Tutorial: Overview, Features, and Practical Code Examples

The article introduces Fluent Mybatis, a compile‑time code‑generating ORM that merges Mybatis‑Plus, Dynamic SQL and JPA features, eliminates XML mappers, offers a fluent, type‑safe Java API, and demonstrates through concise examples how it reduces boilerplate compared with native Mybatis and Mybatis‑Plus.

CRUDCode GenerationFluent MyBatis
0 likes · 13 min read
Fluent Mybatis Tutorial: Overview, Features, and Practical Code Examples
Java Architect Essentials
Java Architect Essentials
Oct 11, 2024 · Backend Development

Mastering EasyQuery: A Strongly Typed Java ORM with Real‑World Query Examples

This article explains why the author created the EasyQuery ORM for Java, demonstrates a wide range of query patterns—including single‑record, pagination, joins, subqueries, streaming, custom VO mapping, dynamic conditions, grouping, native SQL, function columns, and high‑performance encryption—while providing complete code snippets and links to documentation and source repositories.

BackendJavaORM
0 likes · 13 min read
Mastering EasyQuery: A Strongly Typed Java ORM with Real‑World Query Examples
FunTester
FunTester
Aug 30, 2024 · Backend Development

Choosing a Java ORM Framework: Key Factors, Popular Options, and Implementation Steps

This article explains why Java ORM frameworks are essential for simplifying database access, outlines the critical criteria for selecting the right ORM, compares popular choices such as Hibernate, JPA, EclipseLink, and DataNucleus, and provides a step‑by‑step guide for successful implementation.

BackendHibernateJava
0 likes · 14 min read
Choosing a Java ORM Framework: Key Factors, Popular Options, and Implementation Steps
Code Mala Tang
Code Mala Tang
Jul 27, 2024 · Backend Development

Master Egg‑Sequelize: From Setup to Advanced Tips for Egg.js Projects

This guide walks you through installing, configuring, and using Egg‑Sequelize in Egg.js, explains core ORM features, demonstrates model definition and CRUD operations, and covers advanced topics such as complex queries, transactions, validation, migrations, associations, and common pitfalls to avoid.

Backend DevelopmentNode.jsORM
0 likes · 13 min read
Master Egg‑Sequelize: From Setup to Advanced Tips for Egg.js Projects
Architecture Digest
Architecture Digest
Jul 8, 2024 · Backend Development

Introducing Easy-Query: A High‑Performance Java ORM with Fluent Query API

This article explains the motivation behind creating the Easy-Query ORM for Java, demonstrates its fluent query capabilities—including single‑record, list, pagination, joins, sub‑queries, group‑by, native SQL and dynamic condition features—provides extensive code examples, and shares repository links for further exploration.

Backend DevelopmentEasy-QueryJava
0 likes · 10 min read
Introducing Easy-Query: A High‑Performance Java ORM with Fluent Query API
Java Tech Enthusiast
Java Tech Enthusiast
Jun 6, 2024 · Backend Development

MyBatis Dynamic SQL and Tag Usage Guide

MyBatis dynamic SQL lets developers construct conditional queries at runtime using tags like if, where, trim, choose, set, foreach, sql, include, and bind, simplifying complex statements, avoiding manual string concatenation, supporting batch operations, reusable fragments, and one‑to‑many mappings while improving flexibility and maintainability.

Dynamic SQLJavaMyBatis
0 likes · 16 min read
MyBatis Dynamic SQL and Tag Usage Guide
Architect's Journey
Architect's Journey
May 8, 2024 · Backend Development

Mastering MyBatis JSON Field Mapping with Custom TypeHandlers

This article walks through three ways to map JSON columns to Java objects in MyBatis, explains why simple String or JSONObject approaches are fragile, and provides a complete custom TypeHandler implementation, registration, and usage example for complex entity fields.

D3BootJSONJava
0 likes · 11 min read
Mastering MyBatis JSON Field Mapping with Custom TypeHandlers
Architect
Architect
May 7, 2024 · Backend Development

MyBatis Source Code Execution Flow Explained

The article walks through MyBatis’s internal execution pipeline, from loading the configuration file and building a SqlSessionFactory, to creating a SqlSession, generating a MapperProxy for the mapper interface, and finally invoking the mapped method which triggers JDBC operations, while detailing caching and executor mechanisms.

DynamicProxyExecutorJava
0 likes · 31 min read
MyBatis Source Code Execution Flow Explained
Java Tech Enthusiast
Java Tech Enthusiast
May 6, 2024 · Backend Development

Design Patterns in MyBatis Source Code

MyBatis, a widely used Java ORM, embeds around ten classic design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template Method, Strategy, and Iterator—to modularize object creation, structure, and behavior, thereby simplifying complex data access and caching mechanisms within its architecture.

Backend DevelopmentDesign PatternsJava
0 likes · 8 min read
Design Patterns in MyBatis Source Code
Su San Talks Tech
Su San Talks Tech
May 5, 2024 · Backend Development

Fixing MyBatis‑Plus Migration Errors: Why LocalDateTime Conversion Fails and How to Resolve It

This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, explains the “Conversion not supported for type java.time.LocalDateTime” error caused by MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, and shows how upgrading the driver resolves the issue while offering debugging tips.

DebuggingJavaMyBatis
0 likes · 16 min read
Fixing MyBatis‑Plus Migration Errors: Why LocalDateTime Conversion Fails and How to Resolve It
macrozheng
macrozheng
Apr 28, 2024 · Backend Development

How to Seamlessly Replace MyBatis with MyBatis-Plus and Fix LocalDateTime Errors

This article walks through migrating an existing MySQL‑based Java project from MyBatis 3.5.x to MyBatis‑Plus 3.1.1, diagnosing the LocalDateTime conversion exception, upgrading mysql‑connector‑java, handling subsequent null‑pointer issues, and learning from a related file‑validation bug to emphasize thorough testing during component upgrades.

Connector-JavaDebuggingJava
0 likes · 9 min read
How to Seamlessly Replace MyBatis with MyBatis-Plus and Fix LocalDateTime Errors
Java Architecture Diary
Java Architecture Diary
Apr 9, 2024 · Backend Development

What’s New in MyBatis-Plus 3.5.6? Upgrade Guide and Dependency Tips

MyBatis-Plus, an enhanced MyBatis toolkit, simplifies CRUD operations and injects dynamic SQL to boost productivity; this guide outlines its core features, important upgrade notes—including MyBatis 3.5.16 and JSqlParser 4.9 versions—provides a detailed changelog, and shows Maven dependencies for Spring Boot 3.x and 2.x.

Backend DevelopmentORMSpring Boot
0 likes · 5 min read
What’s New in MyBatis-Plus 3.5.6? Upgrade Guide and Dependency Tips
WeChat Client Technology Team
WeChat Client Technology Team
Apr 9, 2024 · Databases

How WCDB Evolved: Multi‑Language Support, Powerful SQL Builder, and Ultra‑Fast Backup

This article details the major upgrades of WCDB, including expanded language support, a redesigned Winq SQL builder, robust data backup and repair mechanisms, seamless data migration, on‑the‑fly compression, automatic column addition, and performance optimizations such as interruptible transactions and WAL header improvements.

DataBackupMulti-languageORM
0 likes · 49 min read
How WCDB Evolved: Multi‑Language Support, Powerful SQL Builder, and Ultra‑Fast Backup
Java Architect Essentials
Java Architect Essentials
Mar 28, 2024 · Backend Development

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

This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, uncovers the root cause of a LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL connector, demonstrates version upgrades and code fixes, and shares a related production bug and its remediation.

BackendJavaLocalDateTime
0 likes · 15 min read
Why Switching MyBatis to MyBatis‑Plus Triggers LocalDateTime Errors—and How to Resolve Them