This tutorial demonstrates how to integrate both Hibernate and MyBatis ORM frameworks within a single Spring Boot application, covering environment setup, project configuration, entity and repository definitions, service and controller implementation, and testing to verify concurrent operation.
This article demonstrates how to implement pagination and search pagination in a Java web project using Spring MVC, MyBatis, and standard pagination utilities, covering the creation of a Page utility class, MyBatis mapper configurations, DAO interfaces, service methods, controller handling, and JSP view integration.
This guide explains step‑by‑step how to disable the yellow background warnings that appear in MyBatis XML files within IntelliJ IDEA by adjusting the IDE's inspection and injected language settings.
This guide explains every common way to pass parameters in MyBatis—including single values, multiple arguments via indexes, @Param, Map, POJO, List, and array—showing mapper signatures, XML mappings, and sample code to help interview preparation and real‑world development.
This article explains how MyBatis dynamic SQL tags such as if, choose, trim, foreach, and bind can be used to build flexible SELECT, INSERT, UPDATE, and DELETE statements, showing code examples, test cases, and best‑practice tips for handling optional parameters and batch operations in Java backend development.
This article explains MyBatis's plugin architecture, shows how to create a custom interceptor to modify query parameters, demonstrates injection into Spring Boot, and analyzes the underlying proxy generation and execution flow, including a brief look at the popular PageHelper pagination plugin.
This article explains what MyBatis TypeHandler is, how to configure the environment, create custom handlers, register them via Spring Boot or XML, and details the internal execution flow for converting parameters and results between Java and JDBC types.
This article details how to dramatically speed up Excel‑driven fee‑record imports by replacing naïve POI row‑by‑row processing with EasyExcel, caching database look‑ups, using MySQL batch INSERTs, and finally applying parallel streams for multi‑threaded insertion, while also trimming excessive logging.
This article explains, from source‑code analysis, why MyBatis mapper methods cannot be overloaded, shows the resulting BeanCreationException, walks through the MyBatis‑SpringBoot auto‑configuration that builds SqlSessionFactory, and demonstrates how to trace a mapper method to the exact SQL statement defined in the XML mapping file.
This article thoroughly examines the MyBatis selectList() execution process—including environment setup, mapper definitions, caching executors, parameter handling, statement preparation, and result set processing—by stepping through source code and debugging traces within a Spring Boot 2.3.3 context.
This article explains how to set up the environment, identify key MyBatis components such as SqlSession, Executor, StatementHandler, ParameterHandler, TypeHandler, and ResultSetHandler, and strategically place breakpoints to effectively read and understand MyBatis 3.5 source code within a Spring Boot 2.3.3 application.
This article introduces MyBatis's underlying architecture by explaining the six core interfaces—SqlSession, Executor, StatementHandler, ParameterHandler, ResultSetHandler, and TypeHandler—detailing their roles, key methods, caching mechanisms, and how they are instantiated within a Spring Boot environment.
This article presents a collection of common Java coding pitfalls—such as using 'where 1=1' in MyBatis, inefficient Map iteration, improper collection checks, and suboptimal string handling—and provides concise, performance‑oriented best‑practice alternatives with code examples.
This article introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering ready‑made project structure, unified response handling, exception processing, code generation utilities, signature authentication, and integration guides to accelerate backend development.
This article explains MyBatis dynamic SQL, describing each core XML tag (if, choose/when/otherwise, where, foreach, set, sql, include), showing practical code snippets, and offering advanced tips such as avoiding magic numbers and referencing SQL fragments across mapper files.
This article explains MyBatis result mapping techniques—including alias mapping, camel‑case automatic mapping, explicit resultMap definitions, and advanced one‑to‑one and one‑to‑many associations—providing code examples, configuration details, and performance considerations such as the N+1 query problem.
This tutorial walks through integrating MyBatis with Spring Boot, covering Maven dependencies, datasource configuration, mapper scanning, basic CRUD XML mappings, the differences between #{ } and ${ }, auto‑generated key handling, SQL fragments, and enabling camel‑case mapping for seamless Java‑to‑database interaction.
This tutorial explains how to use MyBatis dynamic SQL tags such as if, choose, trim, foreach, and bind to build flexible SELECT, UPDATE, INSERT, and batch statements, demonstrating data preparation, conditional query construction, selective updates, conditional inserts, and advanced tag usage with complete Java test examples.
This article shows how to use MyBatis XML mappers to write MySQL queries that count employees meeting specific criteria, such as those in the current month or before today, while explaining required aliasing and date‑format handling.
This article presents a systematic performance test of Hibernate and MyBatis covering bulk inserts, single‑table queries, and various association queries on MySQL, analyzes the impact of lazy versus eager loading, caching, and data volume, and provides practical recommendations for choosing the appropriate ORM framework.
This article explains how improper use of MyBatis in Java web applications can lead to SQL injection vulnerabilities, illustrates three typical injection scenarios with code examples, and provides a step‑by‑step practical workflow for discovering and confirming such flaws in a real CMS project.
This article explains MyBatis sqlFragment, its purpose for reusable SQL snippets, demonstrates how to define and include fragments in select/insert/update/delete statements, walks through the parsing process with code examples, and visualizes the transformation steps to build complete SQL queries.
This tutorial walks through integrating SpringBoot with MyBatis, configuring the Druid connection pool, setting up multiple data sources, and enabling pagination using PageHelper, complete with Maven dependencies, property files, Java configuration classes, and sample API requests and responses.
This article walks through the typical ways MyBatis can introduce SQL injection—through misuse of # and $ in LIKE, IN, and ORDER BY clauses—provides correct code examples, and demonstrates a step‑by‑step reverse‑engineering workflow on an open‑source CMS to locate and confirm the vulnerability.
This article explains how to create a custom JDK dynamic proxy that automatically maps interface methods to objects, demonstrates the underlying MyBatis mapper implementation, and clarifies why method overloading is prohibited in mapper interfaces.
This article explains how improper use of MyBatis in Java web applications can lead to SQL injection vulnerabilities, illustrates three typical injection patterns with code examples, and provides a step‑by‑step practical methodology for locating and confirming such flaws in an open‑source CMS project.
This guide explains how to install and use a curated list of IntelliJ IDEA plugins—including Lombok, RestfulTool, MyBatis helpers, and productivity enhancers—detailing both online and offline installation methods, configuration tips, and practical examples for Java development.
This article explains common MyBatis SQL injection patterns such as fuzzy queries, improper use of the $ placeholder in IN clauses and ORDER BY statements, and provides a step‑by‑step methodology for locating, analyzing, and confirming these vulnerabilities in Java web applications.
This guide explains common MyBatis‑related SQL injection patterns such as fuzzy LIKE queries, improper IN clause handling, and unsafe ORDER BY usage, and walks through a practical step‑by‑step analysis of a real Java CMS project to locate and confirm the vulnerabilities.
This article provides a comprehensive guide to MyBatis dynamic SQL, covering essential tags such as if, choose, trim, foreach, and bind, with practical Maven project setup, full SQL examples, and JUnit tests that demonstrate conditional queries, updates, inserts, and batch operations.
The article examines a Spring‑related Twitter poll, Google Trends, and Stack Overflow statistics to compare MyBatis, Hibernate, and JPA, then argues that MyBatis’ simplicity and flexibility make it better suited for today’s fast‑paced backend development.
This article explains how to use MyBatis dynamic SQL tags such as if, choose, trim, foreach, and bind, providing detailed examples of conditional queries, updates, inserts, and batch operations with accompanying Java and XML code.
This tutorial walks through setting up a Spring Boot and MyBatis multi‑module backend project in IntelliJ IDEA, covering environment preparation, directory layout, parent and sub‑module creation, code examples, dependency configuration, MyBatis integration, and final verification of the running service.
This tutorial explains two approaches to achieve MySQL read/write splitting—first by manually implementing routing logic in Spring Boot with MyBatis interceptors and dynamic data sources, and second by configuring the MyCat middleware for automatic load balancing, fault‑tolerance, and multi‑node support, complete with code samples and configuration files.
In this technical diary I walk through three real‑world problems I hit while integrating MyBatis SQL fragments, debugging Groovy constant class compatibility, and crafting a reliable Bash startup script for Java services, sharing the root causes, error messages, and step‑by‑step fixes.
This article explains how to configure UTF-8 encoding in Gradle, capture request/response bodies in a servlet filter for logging, transform database fields into JSON using a custom MyBatis type handler, and define the corresponding resultMap and SQL query for backend services.
Learn step-by-step how to set up and test multiple data sources in a Spring Boot application using MyBatis, covering property configuration, DataSource beans, mapper scanning, entity definitions, and verification through unit tests with complete code examples and key configuration notes.
Despite pandemic‑induced remote work challenges, the author details progress on implementing test case management, focusing on MyBatis resultMap usage, bean and database design complexities, and provides the full XML mapping and SQL query for retrieving detailed test case information.
This tutorial walks through adding and initializing multiple Spring Boot data sources for JdbcTemplate, Spring Data JPA, and MyBatis, including property setup, configuration classes, bean definitions, testing code, and repository links for complete examples.
This article walks through building complex test‑case search queries using MySQL CASE WHEN, FIND_IN_SET, and MyBatis dynamic SQL, demonstrates converting asynchronous data fetches to synchronous calls with CountDownLatch in Spring, and provides complete Java bean and configuration examples.
This article demonstrates how to use MyBatis to update records with sub‑queries, batch‑insert list‑type attributes, defines the related Java bean, and implements a Spring servlet filter (with request and response wrappers) to log request parameters and response results.
An upgrade of MyBatis from 3.2.3 to 3.4.6 caused parameterType mismatches in XML mappings, turning previously ignored type declarations into enforced ones, which led to ClassCastException errors for LocalDateTime and other types, prompting a root‑cause analysis and recommendations for careful version testing and configuration alignment.
This article walks through extracting service‑host mappings from MySQL using MyBatis, handling a Long‑to‑String conversion error, and demonstrates an insert‑select SQL pattern that requires column aliases to avoid duplicate‑column errors, complete with XML and Java code examples.
The article details how to handle test user module data by converting ID fields to strings, validating optional parameters, and configuring complex MyBatis XML mappings alongside a Java bean, illustrating the full workflow from requirements to implementation and testing.
The article walks through creating a test management platform using Spring Boot, mockJS, and custom MyBatis TypeHandlers to store public data as JSON arrays, detailing the data model, handler implementations, and full mapper XML configuration for CRUD operations.
This article explains the powerful MyBatis resultMap element, covering basic getter/setter injection, constructor injection, inheritance, one-to-one and one-to-many associations, and discriminators, while providing complete XML examples and Java entity code to help developers map complex relational data efficiently.
A deep dive into recent Spring team poll results, Google Trends, Stack Overflow statistics, and expert opinions reveals why MyBatis is often preferred over Hibernate for fast‑moving, internet‑scale Java applications.
This article explains the purpose, differences, default settings, and practical verification of MyBatis first‑level and second‑level caches in Spring Boot, showing how cache scope, transaction boundaries, and mapper configuration affect cache behavior and performance.
This article explains the typical scenarios, internal implementation details, design patterns, and step‑by‑step development of MyBatis plugins, helping backend developers grasp how to intercept Executor, ParameterHandler, ResultSetHandler, and StatementHandler methods for pagination, auditing, performance monitoring, and other custom logic.
This tutorial walks through installing the EasyCode and Lombok plugins, creating a MySQL table, configuring IDEA database connections, generating entity, DAO, service, controller, and mapper code for a Spring Boot project, and setting up the required Maven dependencies and application.yml configuration.
This article explains why a MyBatis query may return zero rows even though the identical SQL run directly in the database returns data, and shows how correcting line‑break placement in the XML mapper resolves the inconsistency.
This guide shows how to integrate the MyBatis Generator Maven plugin into a Spring Boot project, configure generatorConfig.xml, run the plugin to auto‑create entity, mapper, and XML files from database tables, and use the generated code in a service layer.
This tutorial walks you through integrating MyBatis XML configuration into a Spring Boot 2.x project, covering Maven dependencies, application properties, mapper XML files, entity and mapper definitions, service implementation, and unit testing with full code examples.
This article explains the core principle of MyBatis by demonstrating how Mapper interfaces are turned into dynamic proxy objects using JDK proxy mechanisms, walks through manual simulation code, and clarifies each step of the proxy creation and method invocation process.
This comprehensive guide covers essential Spring Boot concepts—including its definition, advantages, auto‑configuration, DevTools hot‑reloading, starter projects, embedded servers, Actuator monitoring, YAML configuration, MyBatis integration, WAR packaging, and common pitfalls—providing concise answers to 40+ interview‑style questions for backend developers.
This article introduces MyBatis, a Java persistence framework that separates SQL from code, outlines its key features, explains its layered architecture, and details the core components such as SqlSessionFactory, SqlSession, MapperProxy, Executor, StatementHandler, ParameterHandler, and ResultSetHandler with code examples.
This article introduces a Spring Boot API project seed that combines MyBatis, a generic Mapper plugin, and PageHelper, offering a ready‑to‑use project structure, unified response handling, exception processing, code generation tools, and simple signature authentication to accelerate backend development.
This guide introduces ten essential IntelliJ IDEA plugins—including JRebel, Codota, Lombok, and MyBatis—that streamline Java development, enhance code quality, and accelerate productivity through features like hot deployment, AI code completion, automatic boilerplate generation, and convenient project navigation.
This tutorial explains how to integrate MyBatis into a Spring Boot project, covering the framework's basics, Maven dependencies, annotation‑based CRUD operations, XML‑based mappings, entity definitions, controller implementations, Swagger testing, and Druid monitoring, with complete code examples and download links.
This guide walks through integrating MyBatis into a Spring Boot project, covering dependency setup, MySQL configuration, entity and mapper creation, CRUD annotations, and unit testing to verify database operations, including transaction management and result mapping.
This article demonstrates how to use Apache POI in a Maven‑based Java project to read and write both XLS and XLSX Excel files, covering library setup, core APIs, data type handling, and practical import/export implementations with Spring MVC and MyBatis.
This article demonstrates how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, using AOP to switch between master and slave databases, and integrating the routing data source with MyBatis for transparent database operations.
This guide walks you through installing the EasyCode plugin in IntelliJ IDEA, setting up a MySQL database, configuring Spring Boot dependencies, and using EasyCode to automatically generate entity, controller, service, DAO, and mapper classes, complete with Maven and application.yml settings.
This guide walks through installing the EasyCode IntelliJ plugin, setting up a MySQL database, configuring a Spring Boot project, adding necessary Maven dependencies and application.yml settings, and using EasyCode to automatically generate CRUD code for the defined tables.
This article explains Java persistence technologies—including JDBC, MyBatis, JPA, and Hibernate—highlights common patterns that cause SQL injection, and provides concrete techniques such as parameterized PreparedStatement, MyBatis #{ } binding, dynamic SQL whitelisting, and proper JPA/Hibernate query parameter usage to securely handle user input.
This article outlines the essential steps for creating a traditional Java web application, covering environment preparation, Maven skeleton creation, required dependencies for logging, databases, persistence, Spring integration, DAO and service layers, unit testing, and RESTful controller configuration.
This article examines the long‑standing debate between MyBatis and JPA, analyzing usage statistics, regional preferences, and technical factors that make Chinese developers favor MyBatis and foreign teams prefer JPA, while offering practical insights for choosing the right ORM.
This tutorial provides a step‑by‑step guide on configuring the Alipay sandbox, generating keys, setting up notification URLs, creating the required database tables, and integrating the full payment flow—including DAO, service, controller, and JSP code—into a Java SSM backend project.
This article explores the nine classic design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—used throughout MyBatis, explaining each pattern's role, core classes, and how they streamline configuration, SQL execution, caching, and logging in Java backend development.
This article demystifies MyBatis transaction handling by clarifying the true JDBC transaction methods, explaining Spring's propagation concepts, detailing the MyBatis Transaction and TransactionFactory interfaces, showcasing code examples, and exploring special cases such as auto‑commit nuances and connection‑pool interactions.
This article examines how MyBatis implements numerous classic design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—through its source code, explaining each pattern's role, related classes, and code examples to deepen developers' understanding of backend architecture.
This article explores how MyBatis implements nine fundamental design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations, diagrams, and code snippets to deepen developers' understanding of practical pattern usage.
This article provides detailed answers to 18 common MyBatis interview questions, covering the differences between #{ } and ${ }, XML mapping tags, DAO interface behavior, pagination techniques, plugin development, batch operations, dynamic SQL, result mapping, association handling, lazy loading, executor types, enum mapping, and the internal configuration structure.
This article demonstrates how to implement database read‑write splitting in a Spring Boot application by configuring multiple MySQL data sources, creating a custom AbstractRoutingDataSource, using ThreadLocal routing keys, and applying AOP to switch between master and slave databases for CRUD operations.
This article explains the distinctions between Spring, Spring MVC, and Spring Boot, illustrates how Spring Boot achieves automatic configuration through annotations like @SpringBootApplication, @EnableAutoConfiguration, and @ComponentScan, and provides detailed code examples of the underlying mechanisms and related configuration classes.
This article compiles a comprehensive guide to MyBatis, covering typical mistakes such as misuse of # vs $, handling of dates and null values, multi‑parameter strategies, XML escaping, dynamic SQL pitfalls, and a balanced list of its advantages and disadvantages for Java developers.
This article explains why to use Spring Boot, how to set up the development environment, and provides step‑by‑step instructions for integrating MyBatis, Swagger2, multi‑environment profiles, and advanced Logback logging, including configuration files, Maven dependencies, code snippets, and testing procedures.
This article demonstrates how to combine Spring Boot with MyBatis, Druid connection pool, and PageHelper pagination plugin to configure multiple data sources, set up monitoring, and perform efficient paged queries, providing complete Maven dependencies, property settings, and Java configuration examples.
This article presents fifteen practical Java backend coding guidelines—including avoiding "where 1=1" in MyBatis, iterating Map entrySet, using Collection.isEmpty, pre‑sizing collections, employing StringBuilder, preferring Set for contains checks, initializing static members correctly, removing dead code, shielding utility constructors, eliminating redundant catches, using String.valueOf, avoiding BigDecimal(double), returning empty collections, calling equals on constants, securing enum fields, and escaping regex in split—each illustrated with bad and good code examples to improve readability, safety, and efficiency.
This article presents sixteen practical Java coding guidelines—ranging from avoiding "where 1=1" in MyBatis to using static blocks for collection initialization, preferring Set over List for contains checks, and returning empty collections instead of null—to help developers write more efficient, readable, and safe backend code.
The article explains a 14‑hour discrepancy between MySQL's created_time and recovery_time timestamps, analyzes JVM and driver timezone settings, traces MyBatis and MySQL driver conversions, and provides practical fixes by adjusting MySQL server and JDBC URL timezones.
This article examines how MyBatis applies classic design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by analysing source code snippets and explaining each pattern's role in the framework's configuration, execution, caching, and dynamic SQL generation.
This article explains a rare MyBatis exception caused by a concurrency issue in OGNL expression evaluation, shows the stack trace, reproduces the bug with multithreaded test code, analyzes the root cause in method accessibility, and notes that upgrading to Ognl 2.7 or MyBatis 3.3.0 resolves the problem.
This article explores six practical ways to accelerate Java development—from hand‑writing and copy‑pasting to Excel formulas, code‑generation tools, and custom generators—detailing their workflows, sample code, advantages, drawbacks, and how to choose the right method for any project.
This article introduces mall‑tiny, a lightweight SpringBoot backend skeleton that retains a full technology stack while simplifying business logic to core product and permission tables, and provides step‑by‑step setup, code structure, API conventions, and deployment instructions.
This article explains the lightweight features of the pure‑Java H2 embedded database, demonstrates its various modes—including in‑memory, file‑based, and standalone server—and provides step‑by‑step integration with SpringBoot and MyBatis for rapid development and testing.
This article explains the differences between MyBatis resultType and resultMap, outlines their common points, and provides clear usage scenarios with examples and images to help Java developers choose the appropriate mapping strategy.
Learn how to replace fragile numeric status codes with clean enum handling in Java using MyBatis TypeHandler, explore built‑in handlers like EnumOrdinalTypeHandler and EnumTypeHandler, and create custom handlers for seamless database‑Java type conversion, complete with configuration tips and practical examples.
This article walks through rebuilding an asynchronous MySQL logging service using Spring Boot and MyBatis, providing full source code for the application entry point, DAO, service, controller, MyBatis mapper, and configuration, and shows the resulting database entries.
This article explains static and dynamic proxy patterns in Java, demonstrates how to use them for recording service response times, and shows how MyBatis leverages dynamic proxies to generate mapper implementations, complete with UML diagrams and sample code.
This article examines the contrasting popularity of MyBatis in China and Hibernate abroad, using Google Trends, Stack Overflow statistics, and industry anecdotes to reveal how cultural, managerial, and risk‑aversion factors shape Java ORM choices across regions.
This guide explains why MyBatis Generator appends to existing mapper.xml files causing duplicate BaseResultMap errors, and shows how to upgrade to version 1.3.7 and add the UnmergeableXmlMappersPlugin to ensure mapper files are overwritten and the application runs smoothly.
This article explains MyBatis interceptors, showing how to intercept SQL execution, parameter setting, and result processing, and provides step‑by‑step code for custom encryption/decryption annotations, a parameter interceptor, a result‑set interceptor, and the supporting IEncryptDecrypt interface.
This article walks through MyBatis' internal workflow—from parsing the global XML configuration and building the SqlSessionFactory, to creating a SqlSession, executing a query via the Executor, handling caching, and finally mapping results—illustrated with key code snippets and a diagram.
Discover the most common MyBatis pitfalls—from # vs $ usage, handling nulls, resultMap quirks, and dynamic SQL issues—to master safe query practices, optimize performance, and avoid runtime errors, while comparing its strengths and weaknesses against Hibernate for effective Java backend development.
This article explains the difference between MyBatis #{ } and ${ } placeholders, how the misuse of ${ } can cause SQL injection and incorrect IN‑clause queries, and demonstrates a safe solution using the foreach tag to handle list parameters.
This article explains why MyBatis may execute unexpected additional SQL statements, reveals the default caching behavior, shows the required XML configuration and Serializable implementation, and offers practical steps to prevent cache clearing on inserts for more efficient backend data access.
This article explains the difference between MyBatis #{ } and ${ } placeholders, why using ${ } can cause SQL injection and IN‑clause errors, and how to safely resolve the issue with proper parameter handling and the foreach tag.
Step‑by‑step tutorial showing how to set up MySQL, configure a SpringBoot project, add dependencies, use PageHelper for pagination, generate MyBatis code with MyBatis Generator, and implement CRUD REST APIs for product brands in a Java backend.
This article provides a comprehensive tutorial on Spring Boot, covering its purpose, key advantages, project setup with Maven, essential configuration files, integration of JdbcTemplate, JPA, MyBatis, JSP, AOP, and task scheduling, all illustrated with complete Java code snippets.
