BestHub
Sign in
Tagged articles

ORM

377 articles · Page 1 of 4
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 OperationsJavaLambdaQueryWrapper
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.

ComparisonJavaMyBatis-Flex
0 likes · 18 min read
MyBatis-Plus vs MyBatis-Flex: Which One Is Better?
macrozheng
macrozheng
Jun 13, 2026 · Backend Development

How MybatisPlus Pro Supercharges CRUD Development Efficiency

The article explains how MybatisPlus Pro extends MybatisPlus to eliminate repetitive Service and Controller code, provides a ready‑to‑use BaseController, automatic QueryWrapper generation, and deepens the understanding of its dynamic proxy, interceptor chain and SQL injection mechanisms, while also outlining its strengths, limitations, suitable scenarios and common pitfalls.

CRUDJavaMybatisPlus
0 likes · 22 min read
How MybatisPlus Pro Supercharges CRUD Development Efficiency
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
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.

JavaMyBatis-FlexORM
0 likes · 19 min read
Mybatis-Plus vs Mybatis-Flex: Which ORM Framework Is Best for Your Project?
Tencent Architect
Tencent Architect
May 11, 2026 · Backend Development

How Adding Two Brackets Made a Django API 8× Faster: A Real‑World Performance Debugging Tale

When a high‑traffic Django endpoint that returned a 7 MB JSON payload slowed dramatically, the author traced the bottleneck to a misuse of StreamingHttpResponse that iterated over the response string character‑by‑character, and fixing it with a simple list wrapper or HttpResponse yielded up to an eight‑fold speedup.

DjangoORMOptimization
0 likes · 17 min read
How Adding Two Brackets Made a Django API 8× Faster: A Real‑World Performance Debugging Tale
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.

BunDrizzle ORMGo
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
Golang Shines
Golang Shines
Apr 18, 2026 · Backend Development

Master Beego: Build High‑Performance Go Web Apps from Scratch

This article presents a comprehensive Chinese guide to the Beego framework, covering installation, configuration, routing, controllers, models, views, advanced features, deployment options, and real‑world examples, making it a practical resource for Go backend developers at any skill level.

Backend DevelopmentGoMVC
0 likes · 6 min read
Master Beego: Build High‑Performance Go Web Apps from Scratch
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.

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

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

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

DatabasesNode.jsORM
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.

ORMPythonRPA
0 likes · 12 min read
6 Python Libraries That Can Supercharge Your Development in 2025
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
Senior Xiao Ying
Senior Xiao Ying
Nov 11, 2025 · Backend Development

Boost Spring Boot Queries with Hibernate’s Powerful @Formula Annotation

This article explains how Hibernate’s @Formula annotation lets Spring Boot developers define read‑only computed fields directly in entity classes, provides concrete code examples for single‑table calculations, sub‑queries, and conditional logic, and outlines compatibility and performance considerations.

@FormulaComputed FieldsHibernate
0 likes · 7 min read
Boost Spring Boot Queries with Hibernate’s Powerful @Formula Annotation
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.

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

JavaMyBatis-FlexORM
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.

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

Dependency InjectionGoORM
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.

JavaORMVersion Compatibility
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 CodeORMstatic indexing
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 DevelopmentJavaORM
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.

CRUDJavaORM
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 DevelopmentMybatisPlusORM
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 DevelopmentJavaMyBatis
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 DevelopmentJavaMybatisPlus
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.

JavaORMVersion Compatibility
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 DevelopmentJavaMybatisPlus
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.

JavaMybatisPlusORM
0 likes · 14 min read
12 MyBatis‑Plus Optimization Tips for Efficient Database Operations
Top Architect
Top Architect
Dec 16, 2024 · Backend Development

Replacing MyBatis with MyBatis‑Plus: Version Compatibility, Debugging, and Lessons Learned

This article walks through the process of swapping MyBatis for MyBatis‑Plus in a legacy Java project, explains why upgrading MyBatis to 3.5.1 triggers a LocalDateTime conversion error, shows how updating mysql‑connector‑java resolves the issue, and shares the broader pitfalls of component upgrades and bug fixes.

JavaORMVersion Compatibility
0 likes · 10 min read
Replacing MyBatis with MyBatis‑Plus: Version Compatibility, Debugging, and Lessons Learned
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.

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

AnnotationData TranslationJava
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.

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

Fluent-MyBatisJavaMyBatis
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.

CI/CDORMPython
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.

CRUDFluent-MyBatisJava
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.

JavaORMSQL
0 likes · 13 min read
Mastering EasyQuery: A Strongly Typed Java ORM with Real‑World Query Examples
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