MyBatis 3.5 now supports Java's Optional in mapper methods, allowing developers to replace verbose null‑checking code with concise, expressive calls, while noting that MyBatis Generator and some third‑party mappers have not yet adopted this feature.
This article explains MyBatis fundamentals including the difference between #{} and ${} placeholders, various pagination approaches, logical versus physical pagination, first‑ and second‑level caching, lazy‑loading mechanisms, executor types, pagination plugin principles, and how to create a custom MyBatis plugin with code examples.
This article explores Java enums in depth, covering their basic definition, typical usage patterns such as iteration and switch statements, implementing singletons, integrating with databases via MyBatis type handlers, and addressing common misconceptions about memory consumption, illustrating each concept with clear code examples.
This article provides a step‑by‑step tutorial on using MyBatis3 annotation‑based CRUD, mapping, and provider annotations to replace XML configuration in a Spring Boot project, covering basic annotations, result mapping, dynamic SQL, Maven dependencies, configuration files, entity classes, database scripts, controller code, and testing procedures.
This article explains the complete MyBatis initialization process, detailing how the XML configuration file is parsed into a Configuration object, how SqlSessionFactory and SqlSession are built, and highlights the Builder design pattern used throughout the setup, with code examples for manual configuration loading.
This article compiles common interview questions and concise answers about Spring, Spring MVC, and MyBatis, covering core concepts such as IoC, AOP, transaction management, controller behavior, annotation usage, design patterns, MyBatis configuration, mapping techniques, pagination, and integration with Ajax.
This article explains how to use pessimistic (FOR UPDATE) and optimistic (version field) database locks in a Java SSM red‑packet application to prevent over‑issuance, details implementation steps, code changes, performance testing, and the trade‑offs between lock types.
This article demonstrates how to build a high‑concurrency red‑packet (抢红包) system using Java backend technologies—including MySQL table design, POJOs, MyBatis DAOs, Spring services with transaction management, and a web layer, and discusses performance testing, data consistency issues, and solutions such as pessimistic and optimistic locking.
This article provides a step‑by‑step guide to creating a Spring Boot application, generating a project template, adding a MyBatis‑based persistence layer, implementing service and controller layers, configuring the database, and running the application to expose REST endpoints.
This tutorial walks through creating a lightweight Java web project using Maven, Spring, SpringMVC, MyBatis, and SpringBoot in IntelliJ IDEA, covering project setup, datasource configuration, Spring annotations, MyBatis integration, deployment settings, and optional Redis and Druid components.
This article explains how MyBatis uses JDK dynamic proxies—specifically a custom “投鞭断流” approach—to automatically create mapper interface implementations, walks through code examples, analyzes core source files, and clarifies why method overloading is prohibited in mapper interfaces.
This article systematically outlines the essential steps and considerations for creating a classic Java web application, covering environment preparation, Maven scaffolding, logging and database dependencies, DAO design with MyBatis, Spring integration, service-layer best practices, and RESTful controller implementation.
Through detailed debugging and source code analysis, the author discovers that MyBatis's SqlSession.clearCache() does clear the first‑level cache, but the observed stale query results are caused by MySQL's default REPEATABLE‑READ isolation level, which can be resolved by setting the transaction isolation to READ COMMITTED.
This tutorial provides a step‑by‑step guide for configuring the Alipay sandbox, generating keys, setting up the required database tables, and integrating Alipay payment APIs into a Java SSM project, complete with code snippets, configuration details, and troubleshooting tips.
This article explains how a JavaEE project integrates JSP front‑end with Struts2, Spring, and MyBatis on the backend, describes the three‑tier architecture, the role of each layer, database communication with Oracle, and the evolution from classic MVC to Web 2.0 approaches.
This article provides a detailed tutorial for creating a Spring Boot project with MyBatis, including environment setup, Maven dependencies, configuration files, database creation, MyBatis generator usage, and sample controller, service, and mapper code, enabling pagination with PageHelper and testing via HTTP requests.
This tutorial demonstrates how to quickly build a modern Java web application using Spring Boot, integrate MyBatis as the ORM, configure Redis as a second‑level cache, and write unit tests with H2, providing step‑by‑step code and configuration details for backend developers.
This article explains the SSM framework, detailing how Spring MVC, Spring, and MyBatis are integrated into a standard MVC architecture, describing their roles, underlying principles, and step‑by‑step guidance for building a functional feature with entities, mappers, services, controllers, and JSP views.
The article analyzes a StackOverflowError that occurs during Spring application startup after upgrading to JDK 8, tracing the deep bean‑creation call chain caused by extensive use of @Autowired with MyBatis MapperFactoryBean, and recommends upgrading mybatis‑spring and switching to @Resource to prevent the overflow.
This article introduces MyBatis as a lightweight persistence framework for Java, explains its history and core concepts, compares it with Hibernate, and provides a step‑by‑step guide with configuration files, entity classes, mapper interfaces, XML mappings, utility classes, and a test service to perform basic CRUD operations.
This article provides a comprehensive introduction to essential Java backend technologies—including Spring MVC, Spring IoC/AOP, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro—and outlines basic design‑pattern concepts, helping developers understand their roles, core mechanisms, and practical usage.
This article introduces core Java backend concepts such as reflection and annotations, explains ORM principles, and provides concise overviews of major frameworks—including Hibernate, MyBatis, Struts2, Spring, and Spring MVC—along with related tools like JUnit, SVN, and Maven.
This article provides a step‑by‑step tutorial on building a Spring container, configuring Spring MVC with DispatcherServlet, setting up essential beans such as multipartResolver, custom handler mapping, handler adapter, view resolver, component scanning, and finally integrating MyBatis with SqlSessionFactoryBean and SqlSessionTemplate for a complete Java backend solution.
This article dissects the root cause of the ReflectionException thrown when using #{array.length} in MyBatis XML, explains how MyBatis parses XML tags, OGNL expressions, and parameter placeholders, and presents three practical solutions to avoid the error.
This article demonstrates how to implement page-based data retrieval in a Java web application using Spring MVC, MyBatis, and a custom Page utility class, covering the creation of the pagination class, mapper XML, DAO interfaces, service logic, controller handling, and JSP pagination controls.
This article examines the thread‑unsafe nature of MyBatis's DefaultSqlSession, explains how SqlSessionTemplate and SqlSessionManager use proxy and ThreadLocal mechanisms to provide safe database access in Spring‑integrated environments, and presents related interview questions for deeper understanding.
The article thoroughly examines MyBatis’s first‑level (session) and second‑level (namespace) caches, detailing their configurations, internal workflows, source‑code implementations, experimental behaviors, common pitfalls such as stale or dirty data, and advises disabling built‑in caching in favor of dedicated solutions for production.
This guide shows how to combine Spring Security and MyBatis to implement username‑password authentication backed by a MariaDB database, covering repository cloning, database setup, Maven execution, and a deep dive into the underlying authentication filter and provider classes with code examples.
This tutorial walks through creating a Maven project in IntelliJ IDEA, configuring Maven settings, adding required dependencies, setting up Spring, MyBatis, FreeMarker, Log4j, and web.xml, and integrating Spring MVC to build a complete SSM framework application.
This article compares Hibernate and MyBatis across development speed, workload, SQL optimization, object management, and caching mechanisms, highlighting their respective strengths, weaknesses, and suitable project scenarios for Java backend development.
This article walks through diagnosing a sluggish Oracle search query with many optional filters, removing unnecessary joins and function calls, applying conditional MyBatis joins, and creating composite indexes to dramatically lower the execution plan cost from 13902 to under 100.
This article explains why MySQL throws "Incorrect string value" when storing emojis, how utf8mb4 solves the problem, and provides step‑by‑step instructions—including table conversion, my.cnf changes, connector upgrades, and runtime workarounds—for reliable emoji storage.
This tutorial walks through implementing one-to-one and one-to-many relationships in MyBatis, showing database tables, entity classes, XML mapping files, key configuration attributes, and test results with clear diagrams and code snippets.
This article explains how to scale MySQL for large‑scale, high‑concurrency applications by using business splitting, master‑slave replication, database sharding and partitioning, and provides practical implementation strategies, code examples, and references to useful tools and middleware.
This article explains the concept of read/write splitting in distributed databases, outlines two implementation methods—static dual data sources and dynamic AOP-based switching—provides a complete Spring‑MyBatis demo with configuration files, code snippets, and guidance on setting up master and slave connections.
This article provides a thorough overview of MyBatis, covering its core concepts, architecture, Spring integration, configuration elements, SQL mapping techniques, dynamic SQL tags, and practical usage tips such as type aliases, ResultMap, caching, and the differences between #{} and ${} placeholders.
This article introduces the ufind-businesslog framework, explains its improvements over the original Koala project, and provides step‑by‑step guidance on configuring annotations, Groovy log templates, thread pools, and custom exporters to achieve non‑intrusive, asynchronous business logging in Java applications.
This article explains how to address repetitive enum TypeHandler implementations in MyBatis by using inheritance and annotation-based approaches, presents concrete code examples, discusses their advantages and limitations, and compares them with MyBatis's built‑in EnumTypeHandler.
