BestHub
Sign in
Tagged articles
740 articles
Page 6 of 8
Top Architect
Top Architect
Aug 20, 2021 · Databases

Querying Multi‑Business Unit Product Sales Statistics with MySQL and MyBatis Dynamic SQL

This article explains how to retrieve sales statistics for multiple business units and their associated products from a MySQL table, compares several implementation approaches—including loop queries, OR concatenation, mixed filtering, and row‑comparison using MyBatis dynamic SQL—evaluates index usage, and provides the final recommended solution.

Database QueryDynamic SQLMyBatis
0 likes · 8 min read
Querying Multi‑Business Unit Product Sales Statistics with MySQL and MyBatis Dynamic SQL
Java Captain
Java Captain
Aug 15, 2021 · Databases

Querying Multi‑Business Unit Sales Statistics Using Row Comparison in MySQL

The article describes how to design a MySQL table for product sales statistics, initialize large data sets, and compare several approaches—including loop queries, OR concatenation, mixed filtering, and row‑comparison techniques—ultimately selecting row‑comparison as the most efficient solution within MyBatis dynamic SQL constraints.

Database DesignDynamic SQLMyBatis
0 likes · 6 min read
Querying Multi‑Business Unit Sales Statistics Using Row Comparison in MySQL
Top Architect
Top Architect
Aug 13, 2021 · Backend Development

Implementing Student Score Statistics with Fluent MyBatis, MyBatis, and MyBatis‑Plus

This article demonstrates how to use Fluent MyBatis, native MyBatis, and MyBatis‑Plus to query a student_score table for term‑wise statistics of English, Math, and Chinese scores, providing complete code examples, SQL statements, mapper definitions, and code‑generation configurations for each approach.

Backend DevelopmentFluent MyBatisJava
0 likes · 9 min read
Implementing Student Score Statistics with Fluent MyBatis, MyBatis, and MyBatis‑Plus
Programmer DD
Programmer DD
Aug 3, 2021 · Databases

Why MySQL Uses B+ Trees for Indexes and How to Design Effective Indexes

This article explains why MySQL chooses B+ trees for its indexes, covers the left‑most prefix rule for composite indexes, offers practical index‑design tips, discusses MyBatis caching, master‑slave replication, and sharding strategies for large‑scale databases.

B+TreeDatabase OptimizationMyBatis
0 likes · 10 min read
Why MySQL Uses B+ Trees for Indexes and How to Design Effective Indexes
Java Captain
Java Captain
Aug 1, 2021 · Backend Development

How to Write More Standardized Java Code

This article presents a comprehensive set of Java coding best‑practice guidelines—ranging from MyBatis query writing, efficient Map iteration, collection handling, StringBuilder usage, to proper enum design and exception handling—each illustrated with clear anti‑pattern and correct‑pattern code examples.

CollectionsExceptionsJava
0 likes · 14 min read
How to Write More Standardized Java Code
Programmer DD
Programmer DD
Jul 31, 2021 · Backend Development

Build a Spring Boot Web Crawler with WebMagic, MyBatis, and MySQL

This tutorial demonstrates how to combine Spring Boot, WebMagic, and MyBatis to crawl Zhihu pages, configure Maven dependencies, set up MySQL data sources, define entity and mapper classes, and schedule the crawler to run periodically, providing a complete Java web‑crawling scaffold.

JavaMyBatisScheduler
0 likes · 14 min read
Build a Spring Boot Web Crawler with WebMagic, MyBatis, and MySQL
Java Architecture Diary
Java Architecture Diary
Jul 28, 2021 · Backend Development

Unlock Enterprise‑Level Data Handling with MyBatis‑Mate 1.0.1: Features & Code Guide

The release of MyBatis‑Mate 1.0.1 introduces enterprise‑grade features such as dictionary binding, field encryption, data desensitization, automatic DDL maintenance, and dynamic multi‑datasource sharding, accompanied by code examples, future roadmap, and Maven dependencies for seamless integration into Spring Boot projects.

DDLDictionary BindingJava
0 likes · 7 min read
Unlock Enterprise‑Level Data Handling with MyBatis‑Mate 1.0.1: Features & Code Guide
Java Backend Technology
Java Backend Technology
Jul 20, 2021 · Backend Development

How to Implement Efficient MyBatis Streaming Queries in Spring

Streaming queries return an iterator instead of a full result set, reducing memory usage, but require keeping the database connection open; this guide explains MyBatis’s Cursor interface, its methods, and three practical ways—using SqlSessionFactory, TransactionTemplate, or @Transactional—to safely perform MyBatis streaming queries in Spring.

CursorDatabaseJava
0 likes · 7 min read
How to Implement Efficient MyBatis Streaming Queries in Spring
Code Ape Tech Column
Code Ape Tech Column
Jul 12, 2021 · Information Security

MyBatis SQL Injection Auditing: Common Vulnerabilities and Practical Analysis

This article explains how SQL injection can still occur in Java applications using MyBatis, describes the three typical vulnerable patterns (LIKE, IN, ORDER BY), and provides a step‑by‑step practical workflow—including code snippets and verification—to help beginners audit and remediate such issues.

Code AuditingJavaMyBatis
0 likes · 7 min read
MyBatis SQL Injection Auditing: Common Vulnerabilities and Practical Analysis
Top Architect
Top Architect
Jul 11, 2021 · Databases

Handling Duplicate Inserts in MySQL: Strategies and MyBatis Batch Example

The article discusses efficient ways to perform bulk inserts in MySQL while avoiding duplicate records, covering techniques such as INSERT IGNORE, ON DUPLICATE KEY UPDATE, INSERT…SELECT…WHERE NOT EXISTS, REPLACE INTO, and demonstrates a practical MyBatis implementation with a unique mobile_number constraint.

Batch InsertINSERT IGNOREMyBatis
0 likes · 5 min read
Handling Duplicate Inserts in MySQL: Strategies and MyBatis Batch Example
Programmer DD
Programmer DD
Jul 11, 2021 · Databases

Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close

This article demystifies MyBatis transaction handling by explaining the true JDBC methods—setAutoCommit, commit, rollback—and clarifying common misconceptions about create, begin, close, and suspend, while exploring MyBatis’s Transaction, TransactionFactory, and practical code examples that illustrate how commits, rollbacks, and connection closing behave in various scenarios.

DatabaseJDBCMyBatis
0 likes · 10 min read
Inside MyBatis Transactions: The Real Story of JDBC Commit, Rollback & Close
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 3, 2021 · Backend Development

How to Configure Master‑Slave Data Sources in Spring Boot with JPA & MyBatis

This guide walks through setting up a Spring Boot 2.1.4 application with JDK 1.8, Oracle, and HikariCP to use separate master and slave data sources, covering Maven dependencies, YAML configuration, custom property classes, JPA EntityManager factories, MyBatis SqlSession factories, mapper scanning, and sample entity definitions.

HikariCPMultiple Data SourcesMyBatis
0 likes · 19 min read
How to Configure Master‑Slave Data Sources in Spring Boot with JPA & MyBatis
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 29, 2021 · Databases

Quick Integration of ShardingSphere for Database Sharding in Spring Boot

This article explains how to use Spring Boot to quickly integrate ShardingSphere for database sharding, covering the background of massive data storage challenges, the advantages of ShardingSphere, step‑by‑step project setup, configuration of data sources and sharding strategies, and a complete test example.

Inline Sharding StrategyMyBatisSharding-JDBC
0 likes · 13 min read
Quick Integration of ShardingSphere for Database Sharding in Spring Boot
Top Architect
Top Architect
Jun 22, 2021 · Backend Development

Step-by-Step Guide to Building a Spring Boot Project with MyBatis and MySQL

This tutorial walks through creating a Spring Boot project, configuring Maven dependencies, setting up application.yml and properties, defining POJOs, MyBatis mapper XML, service and controller layers, and building simple Thymeleaf login and registration pages, with full code snippets for each step.

JavaMyBatisSpring Boot
0 likes · 10 min read
Step-by-Step Guide to Building a Spring Boot Project with MyBatis and MySQL
Programmer DD
Programmer DD
Jun 22, 2021 · Backend Development

Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue

This article presents a full‑stack Java mall project with distribution features, detailing its object‑oriented advantages, comprehensive backend and frontend technology stack, project structure, implemented modules such as member management, product editing, promotion, order and system management, deployment environment, and provides source code and documentation for developers.

Backend DevelopmentJavaMyBatis
0 likes · 6 min read
Explore a Complete Java E‑Commerce Platform with Spring, MyBatis & Vue
21CTO
21CTO
Jun 10, 2021 · Databases

Which Java DAO Framework Is Right for Your Project? A Comparative Guide

An in‑depth comparison of popular Java DAO frameworks—including JDBC, JOOQ, MyBatis, Hibernate, and Spring Data—covers their core concepts, code examples, ideal use cases, and limitations, helping developers choose the most suitable data‑access layer for their projects.

HibernateJDBCMyBatis
0 likes · 7 min read
Which Java DAO Framework Is Right for Your Project? A Comparative Guide
Java Architect Essentials
Java Architect Essentials
Jun 9, 2021 · Backend Development

Using MyBatis Generator for Code Generation and Practical CRUD Examples

This article explains how to set up the MyBatis Generator plugin in a Maven project, configure generatorConfig.xml and jdbc.properties, and demonstrates practical CRUD operations such as deleting users, updating team information, and performing fuzzy and range queries with generated Example classes.

Backend DevelopmentJavaMyBatis
0 likes · 9 min read
Using MyBatis Generator for Code Generation and Practical CRUD Examples
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 4, 2021 · Backend Development

Why Fluent MyBatis Outshines MyBatis Plus and JOOQ for Java SQL Building

This article examines the evolution of Java SQL‑mapping frameworks, compares MyBatis, MyBatis Plus, MyBatis Dynamic SQL, JOOQ and the newer Fluent MyBatis, highlights Fluent MyBatis’s code‑centric design, IDE support, dynamic table naming, and provides practical code examples to illustrate its advantages.

Fluent MyBatisJava ORMMyBatis
0 likes · 16 min read
Why Fluent MyBatis Outshines MyBatis Plus and JOOQ for Java SQL Building
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2021 · Backend Development

Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications

This article explains the Template Method design pattern, illustrating its algorithm skeleton and step customization with Java code examples, and demonstrates real‑world applications in Spring, MyBatis, and other backend frameworks, highlighting advantages, drawbacks, and practical implementation details.

Backend DevelopmentJavaMyBatis
0 likes · 12 min read
Template Method Design Pattern in Java: Theory, Implementation, and Framework Applications
vivo Internet Technology
vivo Internet Technology
May 19, 2021 · Backend Development

MyBatis-Plus SQL Auto-Injection Principle Analysis

MyBatis‑Plus enhances MyBatis by automatically injecting CRUD SQL via BaseMapper, using entity annotations and template methods to map classes to tables, eliminating repetitive manual SQL, supporting lambda queries, pagination, and performance tools, all with minimal intrusion and overhead.

BaseMapperJavaMyBatis
0 likes · 10 min read
MyBatis-Plus SQL Auto-Injection Principle Analysis
Top Architect
Top Architect
May 19, 2021 · Databases

MyBatis Streaming Query: Cursor Interface and Practical Implementations

This article explains MyBatis streaming queries using the Cursor interface, demonstrates how to define a Mapper that returns a Cursor, shows common pitfalls with closed connections, and provides three solutions—manual SqlSession handling, TransactionTemplate, and @Transactional—to keep the database connection open while iterating results.

CursorDatabaseJava
0 likes · 7 min read
MyBatis Streaming Query: Cursor Interface and Practical Implementations
Architecture Digest
Architecture Digest
May 19, 2021 · Backend Development

Why MyBatis Treats Integer 0 as an Empty String in <if> Conditions

When using MyBatis dynamic SQL to filter records by a numeric state field, the framework incorrectly evaluates the condition "state != ''" as false for the integer value 0 because its OGNL expression evaluator treats 0 as equivalent to an empty string, leading to unexpected query results.

Dynamic SQLInteger ComparisonJava
0 likes · 7 min read
Why MyBatis Treats Integer 0 as an Empty String in <if> Conditions
Java Architect Essentials
Java Architect Essentials
May 7, 2021 · Backend Development

Comprehensive Spring Boot Integration Guide: Swagger, Redis, MyBatis, Druid, Mail, CORS, AOP and More

This article provides a step‑by‑step tutorial on building a Spring Boot project, covering project generation, core starters, automatic Redis configuration, common annotations like @SpringBootApplication and @ControllerAdvice, web container and HTTPS settings, profile management, CORS, MVC interceptors, AOP, MyBatis‑Druid integration, mail sending, and Swagger API documentation.

Backend DevelopmentMailMyBatis
0 likes · 18 min read
Comprehensive Spring Boot Integration Guide: Swagger, Redis, MyBatis, Druid, Mail, CORS, AOP and More
Code Ape Tech Column
Code Ape Tech Column
May 6, 2021 · Backend Development

Why PageHelper Pagination Breaks with List Operations and How to Fix It

This article explains why PageHelper pagination yields incorrect totals when list operations are performed before or after pagination, analyzes the underlying cause that startPage only affects subsequent SQL, and provides a step‑by‑step solution that processes the list after pagination and returns a correctly populated PageInfo object.

JavaMyBatisbackend
0 likes · 6 min read
Why PageHelper Pagination Breaks with List Operations and How to Fix It
Architecture Digest
Architecture Digest
Apr 28, 2021 · Backend Development

Comprehensive Spring Boot Integration Guide: MyBatis, Druid, Redis, Swagger, Email, CORS, AOP and More

This article provides a step‑by‑step tutorial on building a Spring Boot project and configuring essential features such as starters, configuration properties, profiles, global exception handling, CORS, MVC interceptors, AOP, MyBatis‑Druid integration, Redis caching, email sending, and Swagger API documentation, complete with code examples and best‑practice tips.

EmailMyBatisSpring Boot
0 likes · 20 min read
Comprehensive Spring Boot Integration Guide: MyBatis, Druid, Redis, Swagger, Email, CORS, AOP and More
Programmer DD
Programmer DD
Apr 21, 2021 · Backend Development

Unveiling MyBatis: How Mapper Interfaces Bind and SQL Executes Internally

This article thoroughly dissects MyBatis’s internal workflow, explaining how mapper interfaces are linked to XML files, detailing the step‑by‑step SQL execution process, and demonstrating custom typeHandler creation for both parameter and result mapping, all based on MyBatis 3.5.5 source code.

JavaMyBatisSQL Execution
0 likes · 17 min read
Unveiling MyBatis: How Mapper Interfaces Bind and SQL Executes Internally
Top Architect
Top Architect
Apr 19, 2021 · Databases

Understanding MySQL Index Structures, B+ Trees, and Practical Optimization Techniques

This article explains why MySQL uses B+‑tree indexes, describes the left‑most prefix rule for composite indexes, offers practical index‑design and optimization tips, outlines MyBatis first‑ and second‑level caching, details master‑slave replication, and introduces common sharding strategies and their implementation considerations.

B+TreeDatabase OptimizationMyBatis
0 likes · 12 min read
Understanding MySQL Index Structures, B+ Trees, and Practical Optimization Techniques
Code Ape Tech Column
Code Ape Tech Column
Apr 13, 2021 · Backend Development

Implementing Sensitive Data Encryption and Decryption in Spring Boot with MyBatis Interceptors and Custom Annotations

This article demonstrates how to automatically encrypt sensitive fields such as ID numbers and phone numbers before storing them in a database and decrypt them after retrieval by using Spring Boot, MyBatis plugins, and custom annotations, eliminating manual encryption logic in business code.

InterceptorMyBatisSpringBoot
0 likes · 11 min read
Implementing Sensitive Data Encryption and Decryption in Spring Boot with MyBatis Interceptors and Custom Annotations
Top Architect
Top Architect
Apr 7, 2021 · Databases

From JDBC to MyBatis: Evolution, Design, and Optimization of a Persistence Layer Framework

This article explains how JDBC evolves into MyBatis, detailing the seven-step JDBC process, the motivations for encapsulating JDBC, the design of MyBatis components such as SqlSession, Executor, and StatementHandler, and various optimization strategies including connection pooling, SQL management, dynamic parameters, and caching.

DatabaseFrameworkJDBC
0 likes · 32 min read
From JDBC to MyBatis: Evolution, Design, and Optimization of a Persistence Layer Framework
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 7, 2021 · Backend Development

Nine MyBatis SQL Tricks for SpringBoot Web Applications (MySQL Example)

This article presents nine practical MyBatis techniques—including pagination, preset column selection, one‑to‑many and one‑to‑one associations, foreach‑in queries, dynamic where clauses, choose/otherwise logic, hidden _parameter usage, and dynamic set updates—illustrated with SpringBoot and MySQL code examples.

Backend DevelopmentDynamic SQLMyBatis
0 likes · 6 min read
Nine MyBatis SQL Tricks for SpringBoot Web Applications (MySQL Example)
Java Interview Crash Guide
Java Interview Crash Guide
Apr 2, 2021 · Backend Development

How MyBatis Leverages 9 Classic Design Patterns in Its Core

This article explores how MyBatis implements nine fundamental design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with concrete classes, code snippets, and diagrams to deepen developers' understanding of design patterns in practice.

Backend DevelopmentBuilderDecorator
0 likes · 19 min read
How MyBatis Leverages 9 Classic Design Patterns in Its Core
Selected Java Interview Questions
Selected Java Interview Questions
Apr 2, 2021 · Backend Development

Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator

This article analyses how MyBatis applies nine classic design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations and concrete Java examples to deepen understanding of software design in backend development.

Backend DevelopmentDesign PatternsJava
0 likes · 20 min read
Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator
Programmer DD
Programmer DD
Mar 26, 2021 · Backend Development

Why MyBatis Returns -2147482646 with BATCH Executor and How to Fix It

The article explains that MyBatis returns the constant -2147482646 when the executor type is set to BATCH, shows how to trace the source code to uncover this behavior, and provides a simple configuration change to restore correct update counts.

Backend DevelopmentBatchExecutorType
0 likes · 5 min read
Why MyBatis Returns -2147482646 with BATCH Executor and How to Fix It
Selected Java Interview Questions
Selected Java Interview Questions
Mar 23, 2021 · Backend Development

Understanding MyBatis: Concepts, Advantages, Disadvantages, Usage Scenarios, and Advanced Features

This article provides a comprehensive overview of MyBatis, a semi‑ORM Java framework, covering its core concepts, benefits, drawbacks, appropriate use cases, differences from Hibernate, parameter handling, dynamic SQL, caching, lazy loading, mapper binding, plugin development, and various configuration techniques.

JavaMyBatisPersistence
0 likes · 22 min read
Understanding MyBatis: Concepts, Advantages, Disadvantages, Usage Scenarios, and Advanced Features
Code Ape Tech Column
Code Ape Tech Column
Mar 18, 2021 · Backend Development

Master MyBatis: Core Concepts, Best Practices, and Advanced Techniques

This comprehensive guide explains what MyBatis is, its advantages and drawbacks, suitable use cases, differences from Hibernate, parameter handling, dynamic SQL, pagination, caching, lazy loading, and how to use mapper interfaces, XML mappings, and plugins with clear code examples.

JavaMyBatisPersistence
0 likes · 20 min read
Master MyBatis: Core Concepts, Best Practices, and Advanced Techniques
Code Ape Tech Column
Code Ape Tech Column
Mar 1, 2021 · Backend Development

Optimizing Large‑Scale Excel Import in Java: From POI to EasyExcel with Caching, Batch Inserts, and Parallel Streams

This article describes how to dramatically speed up the import of massive Excel files in a Java backend by replacing raw POI with EasyExcel, caching database lookups, using MySQL batch inserts, and employing parallel streams to achieve sub‑minute processing for hundreds of thousands of rows.

Batch InsertExcel ImportJava
0 likes · 12 min read
Optimizing Large‑Scale Excel Import in Java: From POI to EasyExcel with Caching, Batch Inserts, and Parallel Streams
Top Architect
Top Architect
Feb 28, 2021 · Backend Development

Optimizing Large Excel Import Performance in Java Backend Applications

This article details a step‑by‑step optimization of a Java backend Excel import pipeline, covering migration from POI to EasyExcel, caching database lookups, batch insertion with MySQL VALUES, and parallel processing to reduce a 100k‑row import from minutes to under two minutes.

ExcelJavaMyBatis
0 likes · 10 min read
Optimizing Large Excel Import Performance in Java Backend Applications
Java Captain
Java Captain
Feb 21, 2021 · Backend Development

Step-by-Step Guide to Building a Spring Boot Application with MyBatis and MySQL

This tutorial walks through creating a Spring Boot project, configuring Maven dependencies, setting up MySQL with MyBatis, defining entity, mapper, service, and controller layers, and building simple Thymeleaf login and registration pages, culminating in a runnable dynamic authentication demo.

JavaMyBatisSpring Boot
0 likes · 16 min read
Step-by-Step Guide to Building a Spring Boot Application with MyBatis and MySQL
Top Architect
Top Architect
Feb 17, 2021 · Backend Development

Understanding and Optimizing MyBatis PageHelper Pagination Performance

This article analyzes the performance bottlenecks of PageHelper's pagination in MyBatis, demonstrates how large offsets degrade MySQL query speed, and presents a more efficient sub‑query join solution along with suggestions for refactoring the interceptor to improve backend pagination efficiency.

JavaMyBatisPerformance
0 likes · 9 min read
Understanding and Optimizing MyBatis PageHelper Pagination Performance
Su San Talks Tech
Su San Talks Tech
Feb 14, 2021 · Fundamentals

7 Common Java String Pitfalls and How to Avoid Them

This article walks through frequent Java string‑related mistakes—including misuse of replace vs replaceAll, Integer equality pitfalls, BigDecimal precision issues, StringBuilder versus String, isEmpty vs isBlank, MyBatis mapper null checks, and indexOf logic—providing clear explanations, code examples, and best‑practice recommendations.

BigDecimalCode ReviewMyBatis
0 likes · 13 min read
7 Common Java String Pitfalls and How to Avoid Them
Top Architect
Top Architect
Jan 27, 2021 · Databases

MyBatis Streaming Query (Cursor) – Keeping the Database Connection Open

This article explains what a streaming query is, introduces MyBatis's Cursor interface and its methods, demonstrates common pitfalls such as the cursor being closed prematurely, and provides three practical solutions using SqlSessionFactory, TransactionTemplate, and @Transactional to keep the database connection alive during streaming reads.

CursorDatabase ConnectionJava
0 likes · 7 min read
MyBatis Streaming Query (Cursor) – Keeping the Database Connection Open
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Jan 26, 2021 · Backend Development

Master MyBatis: Common Return Values, Exceptions, and SQL Optimization Tips

This article shares practical MyBatis tips, detailing what different return types yield when no records match, common exceptions you may encounter, transaction lock behavior with FOR UPDATE, and essential SQL optimization strategies such as using LIMIT, proper indexing, and avoiding inefficient patterns.

Database PerformanceJava PersistenceMyBatis
0 likes · 8 min read
Master MyBatis: Common Return Values, Exceptions, and SQL Optimization Tips
Selected Java Interview Questions
Selected Java Interview Questions
Jan 17, 2021 · Backend Development

Lombok Getter/Setter Pitfalls with MyBatis and @Accessor(chain=true) Issues in EasyExcel

This article explains why Lombok-generated getter/setter methods for fields whose second character is uppercase can cause MyBatis to store null values, shows the MyBatis PropertyNamer logic that leads to the problem, and also describes how the @Accessor(chain=true) annotation interferes with EasyExcel's reflection‑based export, offering practical workarounds for both issues.

Backend DevelopmentGetterSetterJava
0 likes · 9 min read
Lombok Getter/Setter Pitfalls with MyBatis and @Accessor(chain=true) Issues in EasyExcel
Architecture Digest
Architecture Digest
Jan 16, 2021 · Backend Development

Understanding MyBatis SQL Execution Process and Custom TypeHandler Implementation

This article explains how MyBatis binds mapper interfaces to XML files, details the step‑by‑step SQL execution flow—including mapper retrieval, statement lookup, parameter handling, and result set mapping—and demonstrates how to create custom TypeHandler classes for both parameter setting and result extraction.

JavaMyBatisSQL Execution
0 likes · 16 min read
Understanding MyBatis SQL Execution Process and Custom TypeHandler Implementation
Java Captain
Java Captain
Jan 16, 2021 · Backend Development

Cinema Ticketing System Project Overview

This article presents a cinema ticketing system built with the SSM framework, MySQL, Redis, Alipay sandbox, LayUI, and Baidu ECharts, highlighting its architecture, features such as payment and seat selection, and providing source code link and screenshots.

AlipayEChartsMyBatis
0 likes · 1 min read
Cinema Ticketing System Project Overview
Programmer DD
Programmer DD
Jan 14, 2021 · Backend Development

Why Spring Data JPA Can Slow Down Team Maintenance and When to Choose MyBatis

The article compares Spring Data JPA and MyBatis, highlighting that while Spring Data JPA speeds up individual development, it can create maintenance challenges for teams, especially when tracking slow queries, and argues that MyBatis may be a better choice for collaborative projects.

Backend DevelopmentJava PersistenceMyBatis
0 likes · 3 min read
Why Spring Data JPA Can Slow Down Team Maintenance and When to Choose MyBatis
Code Ape Tech Column
Code Ape Tech Column
Jan 12, 2021 · Backend Development

Master MyBatis Streaming Queries: Avoid Cursor Closure Errors with Three Simple Solutions

This article explains the concept of streaming queries in MyBatis, describes the Cursor interface and its methods, demonstrates common pitfalls that cause cursor closure errors, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep the database connection open during iteration.

CursorJavaMyBatis
0 likes · 8 min read
Master MyBatis Streaming Queries: Avoid Cursor Closure Errors with Three Simple Solutions
Programmer DD
Programmer DD
Jan 6, 2021 · Backend Development

Master MyBatis Plugins: Configuration, Development, and Execution Explained

This article explains how MyBatis supports plugins, covering configuration, how to write an Interceptor, the runtime mechanism, registration timing, initialization process, and the principles behind pagination plugins, with detailed code examples and annotations.

Backend DevelopmentInterceptorJava
0 likes · 12 min read
Master MyBatis Plugins: Configuration, Development, and Execution Explained
Architect's Tech Stack
Architect's Tech Stack
Dec 29, 2020 · Databases

Implementing Database Read‑Write Separation with Spring Boot and MyBatis

This article explains how to implement database read‑write separation in a Spring Boot application using Druid connection pools, custom DataSource routing, a ThreadLocal context holder, and AOP‑based annotations, providing step‑by‑step configuration and usage examples with full Java code.

DataSource RoutingDatabase OptimizationMyBatis
0 likes · 11 min read
Implementing Database Read‑Write Separation with Spring Boot and MyBatis
Code Ape Tech Column
Code Ape Tech Column
Dec 29, 2020 · Backend Development

Unveiling MyBatis: How Mapper Binding and SQL Execution Work Internally

This article dissects MyBatis 3.5.5’s internal workflow, explaining how mapper interfaces bind to XML files, the step‑by‑step SQL execution process, custom typeHandler creation for parameter and result mapping, and the underlying proxy and configuration mechanisms that drive query handling.

JavaMyBatisSQL Execution
0 likes · 17 min read
Unveiling MyBatis: How Mapper Binding and SQL Execution Work Internally
macrozheng
macrozheng
Dec 28, 2020 · Backend Development

Master MyBatis Dynamic SQL: Eliminate XML Mappers and Supercharge CRUD

This tutorial explains how to replace verbose MyBatis mapper XML files with the modern Dynamic SQL API, covering setup, Maven dependencies, configuration, code generation, CRUD operations, advanced queries, subqueries, joins, conditional updates, and one‑to‑many mappings for Java backend development.

CRUDDynamic SQLJava
0 likes · 34 min read
Master MyBatis Dynamic SQL: Eliminate XML Mappers and Supercharge CRUD
macrozheng
macrozheng
Dec 21, 2020 · Backend Development

Boost Your Java Backend: Master MyBatis Generator for Automatic CRUD Code

This article explains how to integrate MyBatis Generator into a Spring Boot project, configure it to generate entity classes, mapper XML and CRUD methods, and extend its capabilities with custom comment generators, advanced queries, and one‑to‑many/one‑to‑one mappings, reducing manual coding effort.

CRUDJavaMyBatis
0 likes · 20 min read
Boost Your Java Backend: Master MyBatis Generator for Automatic CRUD Code
Top Architect
Top Architect
Dec 16, 2020 · Backend Development

Integrating PageHelper with SpringBoot and MyBatis for Efficient Pagination

This article provides a comprehensive guide on integrating PageHelper with SpringBoot and MyBatis, covering development preparation, dependency configuration, basic and advanced usage patterns, code examples, and detailed explanations of pagination mechanisms, including PageParam design and MyBatis interceptor internals.

JavaMyBatisSpringBoot
0 likes · 19 min read
Integrating PageHelper with SpringBoot and MyBatis for Efficient Pagination
Architect's Tech Stack
Architect's Tech Stack
Dec 16, 2020 · Databases

MyBatis Dynamic SQL Tutorial: Using if, choose, trim, foreach, and bind Tags with Code Examples

This article explains MyBatis dynamic SQL features—including if, choose, trim, foreach, and bind tags—by showing how to set up a Maven project, create a student table, write mapper methods, and run tests that demonstrate conditional queries, updates, inserts, batch operations, and database‑agnostic expressions.

Dynamic SQLMyBatisSQL
0 likes · 19 min read
MyBatis Dynamic SQL Tutorial: Using if, choose, trim, foreach, and bind Tags with Code Examples
Selected Java Interview Questions
Selected Java Interview Questions
Dec 11, 2020 · Databases

Implementing MyBatis Streaming Queries in Spring: Concepts, API, and Three Practical Solutions

This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three concrete solutions—using SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open and avoid cursor‑closed errors.

CursorDatabaseJava
0 likes · 7 min read
Implementing MyBatis Streaming Queries in Spring: Concepts, API, and Three Practical Solutions
Programmer DD
Programmer DD
Dec 8, 2020 · Backend Development

How to Implement Efficient MyBatis Streaming Queries in Spring

This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates common pitfalls with closed connections, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to safely perform large‑scale data retrieval in Spring applications.

CursorDatabaseJava
0 likes · 7 min read
How to Implement Efficient MyBatis Streaming Queries in Spring
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 5, 2020 · Backend Development

Master MyBatis Interview Questions: #{} vs ${}, XML Mapping, Plugins, and More

This article provides concise, interview‑style explanations of MyBatis core concepts—including the difference between #{} and ${}, additional XML tags, DAO interface mechanics, pagination, plugin development, batch operations, executors, lazy loading, enum mapping, and internal configuration mapping—helping developers ace backend Java ORM interviews.

InterviewJavaMyBatis
0 likes · 16 min read
Master MyBatis Interview Questions: #{} vs ${}, XML Mapping, Plugins, and More
ITPUB
ITPUB
Dec 4, 2020 · Backend Development

Master MyBatis Global Config: Complete Guide to All Settings

This article provides a comprehensive walkthrough of MyBatis's mybatis-config.xml, detailing the top‑level configuration nodes, property handling, settings options, type aliases, type handlers, object factories, plugins, environment definitions, transaction managers, data source types, database ID providers, and mapper registrations, with concrete XML examples and priority rules.

JavaMyBatisXML
0 likes · 18 min read
Master MyBatis Global Config: Complete Guide to All Settings
Top Architect
Top Architect
Dec 2, 2020 · Backend Development

Understanding MyBatis Plugins: Mechanisms, Use Cases, and Design Patterns

This article provides a comprehensive overview of MyBatis plugins, explaining their interception capabilities, typical use cases such as pagination, common field assignment, and performance monitoring, while detailing the underlying dynamic‑proxy implementation, configuration loading, and relevant design patterns for backend Java development.

AOPDesign PatternsInterceptor
0 likes · 9 min read
Understanding MyBatis Plugins: Mechanisms, Use Cases, and Design Patterns
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 28, 2020 · Backend Development

How to Implement Efficient MyBatis Streaming Queries in Spring

This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates common pitfalls when the database connection closes prematurely, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep the connection open for efficient data retrieval.

CursorDatabaseMyBatis
0 likes · 7 min read
How to Implement Efficient MyBatis Streaming Queries in Spring
Java Architect Essentials
Java Architect Essentials
Nov 27, 2020 · Backend Development

16 Java Coding Best Practices for Performance and Clean Code

This article presents sixteen practical Java coding best‑practice guidelines—including avoiding ‘where 1=1’ in MyBatis, using entrySet for map iteration, preferring Collection.isEmpty(), pre‑sizing collections, employing StringBuilder, leveraging Set for contains checks, static initialization blocks, and other tips—to improve performance, readability, and safety of backend applications.

Best PracticesCode OptimizationCollections
0 likes · 18 min read
16 Java Coding Best Practices for Performance and Clean Code
Top Architect
Top Architect
Nov 25, 2020 · Databases

Understanding MyBatis Transaction Mechanisms and JDBC Transaction Behavior

This article explains the real JDBC transaction methods, clarifies common misconceptions about transaction states in MyBatis, details the MyBatis Transaction and TransactionFactory interfaces, and explores special scenarios such as auto‑commit false, missing commit or close, with concrete code examples.

DatabaseJDBCJava
0 likes · 10 min read
Understanding MyBatis Transaction Mechanisms and JDBC Transaction Behavior
Programmer DD
Programmer DD
Nov 21, 2020 · Backend Development

How MyBatis Handles Logging: From SLF4J Facade to Dynamic Proxies

This article explains MyBatis's logging architecture, covering the supported log implementations, the role of SLF4J, how MyBatis selects and configures a logger via LogFactory, and the use of JDK dynamic proxies to route JDBC logging through separate logger objects.

Dynamic ProxyJavaMyBatis
0 likes · 8 min read
How MyBatis Handles Logging: From SLF4J Facade to Dynamic Proxies
Top Architect
Top Architect
Nov 16, 2020 · Backend Development

Understanding MyBatis Logging Implementation and LogFactory Mechanism

This article explains how MyBatis loads and categorizes logging implementations, details the role of SLF4J and other frameworks, describes the LogFactory adapter selection process, and shows how JDBC log proxies use dynamic proxies to output SQL execution details.

JDBCJavaLogFactory
0 likes · 8 min read
Understanding MyBatis Logging Implementation and LogFactory Mechanism
Architecture Digest
Architecture Digest
Nov 6, 2020 · Backend Development

Custom JDK Dynamic Proxy for MyBatis Automatic Mapper Implementation

This article explains how MyBatis can instantiate a mapper interface without an implementation class by using a custom JDK dynamic proxy (referred to as "投鞭断流") that intercepts method calls, creates result objects, and demonstrates the full source code and execution output.

Backend DevelopmentDynamic ProxyJava
0 likes · 7 min read
Custom JDK Dynamic Proxy for MyBatis Automatic Mapper Implementation
vivo Internet Technology
vivo Internet Technology
Nov 4, 2020 · Backend Development

Node-MyBatis: A JavaScript Full‑Stack Data Persistence Solution for the Wukong Activity Platform

The article describes how the Wukong Activity Platform’s data‑persistence layer uses Node.js as a BFF with MySQL, combines raw drivers, optional ORMs, and a custom lightweight Node‑MyBatis framework that offers dynamic SQL templating, built‑in injection protection, declarative transaction decorators, and automatic TypeScript type generation for full‑stack JavaScript development.

Backend DevelopmentMyBatisNode.js
0 likes · 28 min read
Node-MyBatis: A JavaScript Full‑Stack Data Persistence Solution for the Wukong Activity Platform
Java Architect Essentials
Java Architect Essentials
Oct 28, 2020 · Backend Development

Implementing Read/Write Splitting with Spring's AbstractRoutingDataSource

This article demonstrates how to implement read/write splitting in a Spring Boot application by configuring multiple data sources, using AbstractRoutingDataSource for dynamic routing, and applying AOP and custom annotations to direct read operations to slave databases and write operations to the master, with full Maven and MyBatis setup.

AOPDataSource RoutingMyBatis
0 likes · 17 min read
Implementing Read/Write Splitting with Spring's AbstractRoutingDataSource
Code Ape Tech Column
Code Ape Tech Column
Oct 21, 2020 · Backend Development

Mastering Spring Boot: How to Integrate Multiple Data Sources with MyBatis

This tutorial explains how to configure Spring Boot with a single Druid data source, extend it to multiple dynamic data sources using AbstractRoutingDataSource, and seamlessly integrate MyBatis, including custom annotations, AOP switching, thread‑local isolation, and transaction management for robust multi‑database applications.

Dynamic Data SourceJavaMultiple Data Sources
0 likes · 18 min read
Mastering Spring Boot: How to Integrate Multiple Data Sources with MyBatis
Java Backend Technology
Java Backend Technology
Oct 20, 2020 · Backend Development

Unlocking MyBatis Mapper Magic: Custom JDK Dynamic Proxy Explained

This article explains how a custom JDK dynamic proxy can automatically map interface methods to concrete objects, demonstrates the implementation with a User POJO and UserMapper, shows test output, analyzes MyBatis internal proxy classes, and clarifies why mapper methods cannot be overloaded.

Dynamic ProxyJavaMyBatis
0 likes · 7 min read
Unlocking MyBatis Mapper Magic: Custom JDK Dynamic Proxy Explained
Programmer DD
Programmer DD
Oct 16, 2020 · Backend Development

How Dynamic Proxies Power MyBatis Auto‑Mapper: A Deep Dive into “投鞭断流”

This article explains how Java’s dynamic proxy mechanism, dubbed “投鞭断流”, can be used to implement MyBatis’s automatic mapper functionality, providing step‑by‑step code examples for custom InvocationHandler, proxy creation, and discusses why method overloading is prohibited in mapper interfaces.

Backend DevelopmentDynamic ProxyJava
0 likes · 7 min read
How Dynamic Proxies Power MyBatis Auto‑Mapper: A Deep Dive into “投鞭断流”
Java Captain
Java Captain
Oct 6, 2020 · Backend Development

Integrating Alipay Payment into an SSM (Spring + Spring MVC + MyBatis) Framework

This tutorial walks through the complete process of configuring a sandbox Alipay environment, setting up keys and URLs, defining the database schema, implementing DAO and service layers, and integrating Alipay payment flow into a Java SSM project with detailed code examples and screenshots.

AlipayBackend DevelopmentJava
0 likes · 11 min read
Integrating Alipay Payment into an SSM (Spring + Spring MVC + MyBatis) Framework