Personal blog of JackSparrow414 (English posts).https://jacksparrow414.pages.dev/https://jacksparrow414.pages.dev/en/posts/163936328/https://jacksparrow414.pages.dev/en/posts/163936328/To address deserialization failures caused by Kafka message format changes, this article walks through migrating from JSON to Avro and integrating Apicurio Schema Registry. It covers schema definition, Java class generation, producer and consumer configuration, and version compatibility checks, reducing the risk of poison-pill messages.Wed, 26 Aug 2026 13:30:48 GMThttps://jacksparrow414.pages.dev/en/posts/163342943/https://jacksparrow414.pages.dev/en/posts/163342943/Introduces JavaScript obfuscation, request-body encryption, and request signing through examples, including RSA key exchange, AES-GCM encryption and decryption, and backend timestamp and nonce validation. It discusses increasing the cost of API analysis and reverse engineering, and balancing security with performance.Fri, 31 Jul 2026 00:10:01 GMThttps://jacksparrow414.pages.dev/en/posts/161901809/https://jacksparrow414.pages.dev/en/posts/161901809/This post implements a Multi-Reactor server with Java NIO and explains how Channel, Buffer, Selector, and wakeup work together. It also covers cross-thread channel registration and dynamically adjusting read/write events, and analyzes how NIO is applied in the source code of Apache HttpClient and the Kafka client.Thu, 11 Jun 2026 14:55:16 GMThttps://jacksparrow414.pages.dev/en/posts/161493642/https://jacksparrow414.pages.dev/en/posts/161493642/Uses production server configuration updates to introduce an Ansible development environment, inventory, and playbook organization. Examples cover selecting host batches, copying and editing files, restarting services, and upgrading the kernel, with explanations of variables, conditions, and concurrent execution.Sat, 30 May 2026 04:32:23 GMThttps://jacksparrow414.pages.dev/en/posts/160796261/https://jacksparrow414.pages.dev/en/posts/160796261/Starting from the limitations of polling with nonblocking I/O, this post introduces select and epoll through C examples. It explains file descriptors, level-triggered and edge-triggered notifications, then combines connection management, I/O event handling, and a business thread pool into a Multi-Reactor server.Mon, 18 May 2026 03:25:34 GMThttps://jacksparrow414.pages.dev/en/posts/160489936/https://jacksparrow414.pages.dev/en/posts/160489936/C implementations of blocking socket servers use a single process, multiple processes, multiple threads, and a thread pool to explain connection handling, file descriptors, and resource release. Comparing their concurrency and overhead establishes a foundation for nonblocking I/O and I/O multiplexing.Sat, 25 Apr 2026 09:02:48 GMThttps://jacksparrow414.pages.dev/en/posts/160345586/https://jacksparrow414.pages.dev/en/posts/160345586/For a large order dataset, Elasticsearch replaces database LIKE searches on contact information, followed by database lookups for orders. The article covers index design, historical and incremental synchronization, UTC handling, pagination, database fallback, and synchronization gaps.Tue, 21 Apr 2026 10:18:29 GMThttps://jacksparrow414.pages.dev/en/posts/148884545/https://jacksparrow414.pages.dev/en/posts/148884545/This article uses Charles to inspect a WeChat Mini Program’s API and builds a Python bot for scheduled orders, with results pushed to iOS through Bark. It also covers project scaffolding and dependency management, proxy selection, and optimizations involving multithreading, connection reuse, and request timing.Thu, 26 Jun 2025 11:40:12 GMThttps://jacksparrow414.pages.dev/en/posts/147189475/https://jacksparrow414.pages.dev/en/posts/147189475/Using an upgrade of multiple company Java applications from JDK 11 to JDK 17, this article discusses compatibility checks and a staged migration. It covers changed exception messages, reflective-access restrictions, separate runtime and compile-time transitions, and supporting changes to Tomcat, Jenkins, and development environments.Sun, 13 Apr 2025 05:34:15 GMThttps://jacksparrow414.pages.dev/en/posts/143644938/https://jacksparrow414.pages.dev/en/posts/143644938/An investigation of JMX Exporter scrape timeouts compares MBean inclusion, rule caching, and attribute filtering. Source analysis and an extension allow querying only specified MBean attributes, followed by production configuration recommendations and the experience of contributing the change upstream.Fri, 15 Nov 2024 11:32:08 GMThttps://jacksparrow414.pages.dev/en/posts/142633205/https://jacksparrow414.pages.dev/en/posts/142633205/AWS CLI scripts create an EC2 instance and internal DNS record, while properties files and User Data organize deployment parameters and initialization. Using Elasticsearch, Kibana, and OpenTelemetry as examples, this article covers server configuration, automated deployment, and verification.Sun, 29 Sep 2024 07:56:25 GMThttps://jacksparrow414.pages.dev/en/posts/141775986/https://jacksparrow414.pages.dev/en/posts/141775986/Starting with Ehcache 2 web-caching source code, this article analyzes the role of ReentrantReadWriteLock in concurrent cache loading. It then discusses an Ehcache 3 migration and how a custom Filter, cache keys, and a read-write lock cooperate to handle concurrent requests for the same page.Sun, 01 Sep 2024 02:45:07 GMThttps://jacksparrow414.pages.dev/en/posts/137611649/https://jacksparrow414.pages.dev/en/posts/137611649/A checklist for using Elasticsearch in application development, covering analyzer validation, field mappings, index planning, lifecycle management, and capacity estimates. A real logging use case illustrates performance problems caused by cleanup and writes, along with improvements using data streams, circuit breakers, and batching.Sun, 26 May 2024 05:43:02 GMThttps://jacksparrow414.pages.dev/en/posts/136917156/https://jacksparrow414.pages.dev/en/posts/136917156/Uses Docker Compose to build Elastic Stack with a three-node Elasticsearch cluster, Kibana, Filebeat, and Metricbeat, explaining TLS and monitoring configuration. Drawing on a production migration, it discusses moving from one node to a cluster through domain switching, data migration, and connection verification.Thu, 21 Mar 2024 12:51:37 GMThttps://jacksparrow414.pages.dev/en/posts/136481686/https://jacksparrow414.pages.dev/en/posts/136481686/JDBC streaming reads.Sat, 09 Mar 2024 13:02:59 GMThttps://jacksparrow414.pages.dev/en/posts/134751835/https://jacksparrow414.pages.dev/en/posts/134751835/Introduces CDC and synchronizes Oracle data to PostgreSQL through a Kafka Connect and Debezium example. It discusses database synchronization, Elasticsearch imports, and cache consistency, comparing the conditions under which different approaches are suitable.Sat, 02 Dec 2023 07:53:24 GMThttps://jacksparrow414.pages.dev/en/posts/134610052/https://jacksparrow414.pages.dev/en/posts/134610052/This largely completes a messaging system built with Kafka. The key code has been explained across the articles; see the source repository for the complete design and implementation. The next Kafka article is planned to cover synchronizing Oracle data to PostgreSQL with Kafka Connect.Sat, 25 Nov 2023 00:47:43 GMThttps://jacksparrow414.pages.dev/en/posts/134477889/https://jacksparrow414.pages.dev/en/posts/134477889/This article implements Kafka consumers for JSON messages, including shared deserialization, deduplication, retries, and offset commits. Load tests inform partition counts and consumer settings, and the template method pattern reuses the consumption flow for emails of different priorities.Sat, 18 Nov 2023 07:16:13 GMThttps://jacksparrow414.pages.dev/en/posts/134360108/https://jacksparrow414.pages.dev/en/posts/134360108/Implements a Kafka producer that sends JSON messages, using a shared serializer for different objects and configuring asynchronous sending, failure recording, and retries. Based on actual email-message sizes, it discusses how compression, batch size, request size, and waiting time affect throughput.Mon, 13 Nov 2023 12:23:42 GMThttps://jacksparrow414.pages.dev/en/posts/134221924/https://jacksparrow414.pages.dev/en/posts/134221924/Uses email delivery to explain a design that decouples a business system from an email system through Kafka. It discusses responsibility boundaries, a unified message format, sending and callback flows, and a fallback when switching between old and new systems, providing background for subsequent producer and consumer implementations.Sat, 04 Nov 2023 11:34:25 GMThttps://jacksparrow414.pages.dev/en/posts/133578940/https://jacksparrow414.pages.dev/en/posts/133578940/This article doesn't go into much detail about JMeter's components and their concepts; in my view, the official documentation is already the most essential learning material, and once you've configured a few scripts yourself you'll basically know what each component is for. If you want to learn JMeter, read the official documentation and look things up whenever a concept or setting is unclear — readers who are just getting started should also spend more time on the FAQ and Best Practices sections.Thu, 05 Oct 2023 07:13:30 GMThttps://jacksparrow414.pages.dev/en/posts/133418837/https://jacksparrow414.pages.dev/en/posts/133418837/Builds a single-node Kafka environment in KRaft mode with Docker Compose and integrates Kafka UI and Prometheus JMX Exporter. It explains listeners, roles, memory, and monitoring configuration, then covers startup verification, JMX port conflicts, and resource-related troubleshooting.Sat, 30 Sep 2023 06:43:33 GMThttps://jacksparrow414.pages.dev/en/posts/132914316/https://jacksparrow414.pages.dev/en/posts/132914316/After generating a self-signed certificate locally and configuring the browser to trust it, HTTPS hides request and response contents from Wireshark. Because I tended to forget the handshake analyses I had read, I decided to capture traffic myself and inspect the entire process.Sat, 16 Sep 2023 08:13:46 GMThttps://jacksparrow414.pages.dev/en/posts/132522581/https://jacksparrow414.pages.dev/en/posts/132522581/I frequently encounter HTTPS, TLS, and SSL. After reading a few articles, I thought I understood them, but troubleshooting showed that I barely knew the basics. This post fills in that foundational knowledge without going deeply into interpreting the various standards.Sun, 27 Aug 2023 08:26:29 GMThttps://jacksparrow414.pages.dev/en/posts/131736461/https://jacksparrow414.pages.dev/en/posts/131736461/Explains ways to use different Log4j2 output formats and configurations across environments, including SystemPropertyArbiter, property substitution, custom Lookup plugins, and ScriptAppenderSelector. It discusses the choice between startup options and code extensions in the context of project deployment workflows.Sat, 15 Jul 2023 05:01:19 GMThttps://jacksparrow414.pages.dev/en/posts/131444009/https://jacksparrow414.pages.dev/en/posts/131444009/Having used VS Code relatively little, I lacked experience developing C programs in it. This post records the steps for setting up a C development environment in VS Code.Wed, 28 Jun 2023 13:05:16 GMThttps://jacksparrow414.pages.dev/en/posts/131262047/https://jacksparrow414.pages.dev/en/posts/131262047/An introduction to Jakarta MVC and its Eclipse Krazo implementation, using page access and form submission to explain controllers, models, views, redirects, and parameter validation. Source-code analysis traces CSRF token generation and validation, followed by a custom page for validation failures.Sat, 17 Jun 2023 09:58:40 GMThttps://jacksparrow414.pages.dev/en/posts/130165318/https://jacksparrow414.pages.dev/en/posts/130165318/A collection of visualization websites and tools for understanding programming concepts, including Git practice, regular expression testing, Wireshark packet analysis, and shell command explanations. Interactive demonstrations and hands-on practice make it easier to understand how these concepts work and provide a reference for later use.Sat, 15 Apr 2023 00:55:14 GMThttps://jacksparrow414.pages.dev/en/posts/129475873/https://jacksparrow414.pages.dev/en/posts/129475873/In a log collection pipeline from CloudWatch Logs to Elasticsearch, Data Streams and ILM are used to manage index rollover and expiration-based deletion. Drawing on hands-on practice, this article describes the tuning process for Filebeat's memory queue, bulk write, and concurrency parameters, and records issues such as latency, cost, and occasional small amounts of log loss.Sun, 12 Mar 2023 08:39:30 GMThttps://jacksparrow414.pages.dev/en/posts/128504766/https://jacksparrow414.pages.dev/en/posts/128504766/Lua scripts executed and debugged in Redis implement fixed-window, sliding-window, token-bucket, and leaky-bucket rate limiting. Request-count examples explain fixed-window boundary issues and discuss where the algorithms fit in rate limiting and traffic shaping.Sat, 31 Dec 2022 08:56:50 GMThttps://jacksparrow414.pages.dev/en/posts/128487811/https://jacksparrow414.pages.dev/en/posts/128487811/An end-to-end approach to sending Tomcat access logs from AWS EC2 to ELK: CloudWatch Agent collects the logs, Filebeat pulls them from CloudWatch Logs, and Logstash parses and indexes them in Elasticsearch. It covers configuration, pipeline verification, and troubleshooting.Fri, 30 Dec 2022 01:29:31 GMThttps://jacksparrow414.pages.dev/en/posts/128436152/https://jacksparrow414.pages.dev/en/posts/128436152/Introduces Hibernate Validator alongside the Jakarta Bean Validation specification, covering constraint annotations, cascading validation, and method parameter and return-value validation. English and Chinese error-message examples demonstrate internationalization, followed by an analysis of how RESTEasy switches validation messages according to the request language.Sun, 25 Dec 2022 13:58:11 GMThttps://jacksparrow414.pages.dev/en/posts/128055470/https://jacksparrow414.pages.dev/en/posts/128055470/Database server-side programming with PL/pgSQL.Sat, 26 Nov 2022 12:43:01 GMThttps://jacksparrow414.pages.dev/en/posts/127018563/https://jacksparrow414.pages.dev/en/posts/127018563/This post records how to install various software packages with Homebrew.Fri, 23 Sep 2022 13:57:40 GMThttps://jacksparrow414.pages.dev/en/posts/126999596/https://jacksparrow414.pages.dev/en/posts/126999596/MySQL study and development notes covering connection methods, data types, primary keys and indexes, storage engines, and transaction isolation levels. Through examples it discusses dirty reads, non-repeatable reads, phantom reads, and locks, and also records execution plan analysis, SQL optimization, and the roles of common logs.Thu, 22 Sep 2022 13:10:04 GMThttps://jacksparrow414.pages.dev/en/posts/126447415/https://jacksparrow414.pages.dev/en/posts/126447415/Notes from using Docker.Sun, 21 Aug 2022 01:16:48 GMThttps://jacksparrow414.pages.dev/en/posts/125948098/https://jacksparrow414.pages.dev/en/posts/125948098/Sets up a PostgreSQL learning environment with Docker Compose, configures database options through an .env file, and persists data with a volume. It covers connecting with pgAdmin and basic operations inside the container, including creating a table, querying tables, and inserting data.Sat, 23 Jul 2022 07:23:46 GMThttps://jacksparrow414.pages.dev/en/posts/125608456/https://jacksparrow414.pages.dev/en/posts/125608456/Starting with the Search API request structure and Query DSL, this article explains how to organize Elasticsearch query conditions, sorting, returned fields, and pagination. Examples show how to convert DSL into Java API calls and enable request logging for debugging.Mon, 04 Jul 2022 12:52:22 GMThttps://jacksparrow414.pages.dev/en/posts/125379449/https://jacksparrow414.pages.dev/en/posts/125379449/Two ways to adjust Log4j2 log levels without restarting an application: changing the configuration through JMX in JConsole, or calling the programmatic configuration API through an HTTP endpoint. A production troubleshooting scenario illustrates when each approach is useful.Mon, 20 Jun 2022 11:41:15 GMThttps://jacksparrow414.pages.dev/en/posts/125014283/https://jacksparrow414.pages.dev/en/posts/125014283/Using ELK 8.2 as an example, this post walks through generating a CA certificate, configuring TLS for internode communication and HTTPS at the HTTP layer, and configuring certificates for Kibana, Logstash, and the Java client. It also covers the differences between the PEM and PKCS#12 formats and the related JDK compatibility issues.Sat, 28 May 2022 00:57:13 GMThttps://jacksparrow414.pages.dev/en/posts/124915409/https://jacksparrow414.pages.dev/en/posts/124915409/This post sorts out Log4j2's architecture and the responsibilities of each component, using UML class diagrams to explain how the configuration fits together. Through examples, it covers log output and rollover policies, uncaught exception handling, bridges from other logging frameworks, and how to enable and verify asynchronous logging.Sun, 22 May 2022 11:58:29 GMThttps://jacksparrow414.pages.dev/en/posts/124218372/https://jacksparrow414.pages.dev/en/posts/124218372/Notes on Docker’s getting-started tutorial cover building images, starting containers, persisting data, and composing multi-container applications. Topics include RUN versus CMD in Dockerfiles, named volumes and bind mounts, Docker Compose, and basic Docker Desktop operations.Sat, 16 Apr 2022 11:07:37 GMThttps://jacksparrow414.pages.dev/en/posts/123510748/https://jacksparrow414.pages.dev/en/posts/123510748/Demonstrates JMX registration, attribute queries, and JConsole operations with a custom MXBean, then introduces metrics collection through JMX Exporter, OpenTelemetry Collector, and Prometheus. It also discusses MBean filtering and scrape performance, and OpenTelemetry JMX integration options.Tue, 15 Mar 2022 12:02:20 GMThttps://jacksparrow414.pages.dev/en/posts/123253121/https://jacksparrow414.pages.dev/en/posts/123253121/Velocity references, directives, variable assignment, and resource loading are introduced through rendering order emails in Spring Boot. JavaMailSender and SMTP configuration for a 163.com mailbox demonstrate building, sending, and verifying HTML email.Thu, 03 Mar 2022 06:23:26 GMThttps://jacksparrow414.pages.dev/en/posts/122648928/https://jacksparrow414.pages.dev/en/posts/122648928/Integrating Axios into a React login form, this article centralizes the request instance, wraps API calls, and uses promises to handle responses and end the submission state. It serializes form data with qs, mocks responses with Mock.js, and verifies the interaction through console output and loading animations.Sun, 23 Jan 2022 03:29:17 GMThttps://jacksparrow414.pages.dev/en/posts/122507894/https://jacksparrow414.pages.dev/en/posts/122507894/Uses a React signup form to introduce Formik initial values, submission handling, and form validation, with touched and onBlur controlling error messages. It then uses Yup to define validation rules and getFieldProps to simplify binding input components to form state.Sat, 15 Jan 2022 03:36:08 GMThttps://jacksparrow414.pages.dev/en/posts/122442302/https://jacksparrow414.pages.dev/en/posts/122442302/Starting with Node.js environment setup, this article manually builds a basic React application with Babel, Webpack, an HTML entry point, components, and styles. It demonstrates the development server, hot updates, and bundling, and provides the project structure and example repository.Tue, 11 Jan 2022 13:40:57 GMThttps://jacksparrow414.pages.dev/en/posts/121952436/https://jacksparrow414.pages.dev/en/posts/121952436/A custom OAuth 2.0 authorization code implementation using RESTEasy, JPA, CDI, and JWT connects user consent, code generation, callbacks, and token exchange. The article shows signature and permission checks on the resource server, along with the project structure, deployment steps, and complete example code.Wed, 15 Dec 2021 06:53:56 GMThttps://jacksparrow414.pages.dev/en/posts/121714825/https://jacksparrow414.pages.dev/en/posts/121714825/Starting from Servlet and JAX-RS specifications, this post introduces RESTEasy Applications, Resources, and Providers and explains initialization in a Servlet container. Examples cover HTTP requests, forms, file transfers, and global exception responses.Sat, 04 Dec 2021 05:49:38 GMThttps://jacksparrow414.pages.dev/en/posts/121665795/https://jacksparrow414.pages.dev/en/posts/121665795/JWT structure, common claims, and the purpose of signatures are introduced with HMAC and RSA signing and verification examples using nimbus-jose-jwt. JWE content encryption then illustrates the distinction between signing and encryption and the roles of RSA public and private keys in different scenarios.Wed, 01 Dec 2021 13:55:04 GMThttps://jacksparrow414.pages.dev/en/posts/121422595/https://jacksparrow414.pages.dev/en/posts/121422595/Reading notes on the official Java EE 8 documentation, organizing concepts such as components and containers, JSF, CDI, EJB, JPA, and security, along with common terminology. The article gathers related chapters and example resources, and records Tomcat issues on Windows as well as thoughts on choosing between POST and PUT in RESTful services.Fri, 19 Nov 2021 06:59:55 GMThttps://jacksparrow414.pages.dev/en/posts/121316472/https://jacksparrow414.pages.dev/en/posts/121316472/A simple Spring Boot application demonstrates programmatic and XML configuration in Ehcache 3, including cache types, expiry policies, resource tiers, and event listeners. API calls verify cache reads, writes, and expiry events, and a configuration property switches between the two initialization approaches.Sun, 14 Nov 2021 05:05:45 GMThttps://jacksparrow414.pages.dev/en/posts/120809498/https://jacksparrow414.pages.dev/en/posts/120809498/This quick reference covers common ways to read and assign values with Spring Expression Language (SpEL), the two @Value syntaxes, and the role of the evaluation context. Java examples demonstrate property access, collection operations, method calls, null handling, and collection filtering.Sun, 17 Oct 2021 04:24:02 GMThttps://jacksparrow414.pages.dev/en/posts/120583347/https://jacksparrow414.pages.dev/en/posts/120583347/Introduces the basic idea of invoking remote methods across JVMs with Java RMI, connecting the remote interface, its implementation, the registry, and client lookup and invocation. It provides two ways to find a remote service and discusses client proxies and serialization of returned objects.Sat, 02 Oct 2021 01:20:16 GMThttps://jacksparrow414.pages.dev/en/posts/119953123/https://jacksparrow414.pages.dev/en/posts/119953123/A guide to Lua comments, variable scope, common data types, conditional expressions, arrays, and loops, with short examples of strings and functions. It also demonstrates calling Redis commands from Lua and provides references for the standard library and debugging tools.Fri, 27 Aug 2021 06:52:11 GMThttps://jacksparrow414.pages.dev/en/posts/119930685/https://jacksparrow414.pages.dev/en/posts/119930685/A Java EE 8 example walks through installing, starting, and configuring GlassFish 5 and H2. It demonstrates creating a JDBC connection pool and JNDI data source on the server, deploying the application from IntelliJ IDEA, and checking configuration through logs and application pages.Thu, 26 Aug 2021 06:28:08 GMThttps://jacksparrow414.pages.dev/en/posts/118438254/https://jacksparrow414.pages.dev/en/posts/118438254/After the previous two blog posts, we now have article data and can query it. The next step is to keep building on that foundation.Sat, 03 Jul 2021 04:09:14 GMThttps://jacksparrow414.pages.dev/en/posts/118241783/https://jacksparrow414.pages.dev/en/posts/118241783/This article focuses on data queries, an important part of working with Elasticsearch.Sat, 26 Jun 2021 01:58:02 GMThttps://jacksparrow414.pages.dev/en/posts/117533447/https://jacksparrow414.pages.dev/en/posts/117533447/Installing Elasticsearch, Logstash, and Kibana and getting started with the basics.Thu, 03 Jun 2021 12:22:10 GMThttps://jacksparrow414.pages.dev/en/posts/113803045/https://jacksparrow414.pages.dev/en/posts/113803045/Uses scenarios such as scheduled assignment publication to explain delayed messages and implements them with the RabbitMQ delayed-message plugin. It demonstrates plugin installation, declaring a delayed exchange, and setting message delays, compares Java Client and Spring AMQP code, and verifies the result through send and receive times.Sat, 13 Feb 2021 11:59:25 GMThttps://jacksparrow414.pages.dev/en/posts/113697153/https://jacksparrow414.pages.dev/en/posts/113697153/A custom framework illustrates a Spring Boot Starter’s project structure, property binding, conditional auto-configuration, and registration through spring.factories. The article demonstrates auto-configuration tests, dependency inclusion, practical usage, and overriding the framework’s default implementation with custom configuration.Fri, 05 Feb 2021 07:39:01 GMThttps://jacksparrow414.pages.dev/en/posts/113471655/https://jacksparrow414.pages.dev/en/posts/113471655/Build a thorough understanding of Maven, with practical scenarios that explain plugin configuration and reduce repeated searches for how to configure Maven plugins.Sun, 31 Jan 2021 06:24:10 GMThttps://jacksparrow414.pages.dev/en/posts/112747029/https://jacksparrow414.pages.dev/en/posts/112747029/Explains how to pass Java objects as JSON in RabbitMQ and Spring AMQP by configuring message converters on the producer and consumer. Examples cover object serialization, Content-Type and timestamp settings, and mapping received messages to Java entities with @Payload.Sun, 17 Jan 2021 07:23:20 GMThttps://jacksparrow414.pages.dev/en/posts/111874999/https://jacksparrow414.pages.dev/en/posts/111874999/Message delivery, storage, and consumption introduce publisher confirms, returned messages, durable components, and message persistence in Spring AMQP. The article demonstrates manual consumer acknowledgments, rejection, and requeuing, and explains why persistence can still leave a risk of message loss.Mon, 28 Dec 2020 13:14:58 GMThttps://jacksparrow414.pages.dev/en/posts/111463079/https://jacksparrow414.pages.dev/en/posts/111463079/Explains RabbitMQ brokers, connections, and channels, comparing the native Java client with Spring AMQP. It covers producer and consumer configuration responsibilities and pooled channel reuse, then traces listener registration, component declarations, and consumer startup through the source code.Sun, 20 Dec 2020 13:58:46 GMThttps://jacksparrow414.pages.dev/en/posts/111462964/https://jacksparrow414.pages.dev/en/posts/111462964/This article explains how producers, exchanges, routing keys, bindings, and queues relate in RabbitMQ and demonstrates virtual-host configuration and publishing from the management console. Spring AMQP examples connect exchange declarations, queue bindings, consumer listeners, and producer publishing into a basic workflow.Sun, 20 Dec 2020 13:23:53 GMThttps://jacksparrow414.pages.dev/en/posts/109658053/https://jacksparrow414.pages.dev/en/posts/109658053/A collection of common JVM diagnostic tools: use jps to obtain Java process IDs, jinfo to inspect or adjust runtime options, and jmap to view heap information. The article also introduces graphical tools such as jvisualvm and jconsole and explains how to connect to a local or remote JVM to inspect its options.Thu, 12 Nov 2020 13:20:01 GMThttps://jacksparrow414.pages.dev/en/posts/109631395/https://jacksparrow414.pages.dev/en/posts/109631395/Notes on Java bytecode, stack frames, and JVM runtime data areas, together with common startup options for heap memory, thread stacks, garbage collection, and heap dumps. Parameter conversions and capacity examples illustrate memory configuration, followed by the difference between memory leaks and running out of memory.Wed, 11 Nov 2020 13:15:50 GMThttps://jacksparrow414.pages.dev/en/posts/109430698/https://jacksparrow414.pages.dev/en/posts/109430698/This article records Arthas startup, reconnection, and common startup issues, with practical examples of finding classes, decompiling, compiling, and hot updates. It also covers changing log levels dynamically, inspecting and modifying JVM options, and cautions when using redefine.Sun, 01 Nov 2020 09:07:27 GMThttps://jacksparrow414.pages.dev/en/posts/109229772/https://jacksparrow414.pages.dev/en/posts/109229772/Explains how to combine Lock and Condition to make threads wait and notify one another, comparing await, signal, and signalAll with wait/notify. A ReentrantLock example illustrates thread coordination and the requirement to acquire the lock before waiting or notifying and release it afterward.Thu, 22 Oct 2020 12:21:29 GMThttps://jacksparrow414.pages.dev/en/posts/109211022/https://jacksparrow414.pages.dev/en/posts/109211022/Introduces lock memory semantics and the use of AQS and the Lock interface to implement custom synchronization components, including an example that allows two concurrent threads. It also compares polling with wait/notify and discusses notification, competing for a lock again, and checking conditions.Wed, 21 Oct 2020 14:03:50 GMThttps://jacksparrow414.pages.dev/en/posts/109190408/https://jacksparrow414.pages.dev/en/posts/109190408/Focusing on the object header’s Mark Word, this article explains acquisition, contention, release, and promotion of biased, lightweight, and heavyweight locks. JOL examples inspect lock flags before and after synchronized code, followed by discussion of spinning, blocking, and suitable use cases.Tue, 20 Oct 2020 13:51:25 GMThttps://jacksparrow414.pages.dev/en/posts/108836715/https://jacksparrow414.pages.dev/en/posts/108836715/An introduction to data-link frames, the maximum transmission unit, byte stuffing, and CRC error detection, followed by the role of network cards and MAC addresses. The article describes transmission and collision detection on broadcast channels and gathers related notes on modems, optical fiber, and switches.Sun, 27 Sep 2020 13:16:06 GMThttps://jacksparrow414.pages.dev/en/posts/108817087/https://jacksparrow414.pages.dev/en/posts/108817087/Starting from ports and inter-process communication, this article introduces TCP's byte-stream transmission, automatic retransmission, sliding window, and segment structure. It uses Wireshark packet captures to analyze the three-way handshake and the four-way termination, and discusses connection states such as TIME-WAIT and CLOSE-WAIT together with related troubleshooting scenarios.Sat, 26 Sep 2020 13:00:13 GMThttps://jacksparrow414.pages.dev/en/posts/108814357/https://jacksparrow414.pages.dev/en/posts/108814357/Reviews IPv4 address classes, ARP address resolution, IP datagrams, subnet masks, and routing, and explains the relationship between IP and MAC addresses. It also records troubleshooting connection failures after rebuilding AWS VPC instances and the solution of retaining network interfaces.Sat, 26 Sep 2020 09:15:40 GMThttps://jacksparrow414.pages.dev/en/posts/108561764/https://jacksparrow414.pages.dev/en/posts/108561764/This article outlines bus architectures and the roles of data, address, and control buses, with examples of bus width and bandwidth. It also describes main memory, cache, and secondary storage and explains memory reads and writes using MAR and MDR.Sun, 13 Sep 2020 05:45:05 GMThttps://jacksparrow414.pages.dev/en/posts/108561741/https://jacksparrow414.pages.dev/en/posts/108561741/This article introduces the five major hardware components and common CPU and memory registers, then uses addition to explain instruction fetch, decoding, and execution. It also demonstrates main-memory capacity calculations using address width, word length, and unit conversion.Sun, 13 Sep 2020 05:44:19 GMThttps://jacksparrow414.pages.dev/en/posts/108521566/https://jacksparrow414.pages.dev/en/posts/108521566/Uses the MyBatis call flow to analyze how ShardingJDBC 4.1.1 integrates with JDBC through custom DataSource, Connection, and PreparedStatement implementations. It traces parameter buffering, physical connection acquisition, and result-set handling, then simulates the proxy workflow with simplified code.Thu, 10 Sep 2020 11:57:42 GMThttps://jacksparrow414.pages.dev/en/posts/108349874/https://jacksparrow414.pages.dev/en/posts/108349874/Redis Sentinel configuration and logs illustrate monitoring and automatic failover, including subjective and objective down states, leader election, and selection of a new primary. The article also shows replica promotion and replication changes, and discusses deploying multiple Sentinels and configuring voting thresholds.Tue, 01 Sep 2020 12:16:56 GMThttps://jacksparrow414.pages.dev/en/posts/108349736/https://jacksparrow414.pages.dev/en/posts/108349736/This article covers Redis RDB and AOF persistence configuration and recovery, then demonstrates primary/replica replication. It explains full, incremental, and diskless replication and describes manually promoting a replica and updating replication relationships after a primary failure.Tue, 01 Sep 2020 12:13:42 GMThttps://jacksparrow414.pages.dev/en/posts/108063571/https://jacksparrow414.pages.dev/en/posts/108063571/Basic usage of the Redis server and client, with common commands for strings, hashes, lists, sets, and sorted sets illustrated through examples of key and data operations. The article also distinguishes the atomicity of individual commands from that of an entire business workflow, and discusses the role of Lua scripts.Mon, 17 Aug 2020 12:24:20 GMThttps://jacksparrow414.pages.dev/en/posts/108041353/https://jacksparrow414.pages.dev/en/posts/108041353/Connecting a GitHub project to CircleCI, with a config.yml example explaining workflows, jobs, and execution steps. Topics include Maven builds, dependency caching, saving test results, branch filtering, scheduled builds, and verification that the configuration takes effect.Sun, 16 Aug 2020 11:18:31 GMThttps://jacksparrow414.pages.dev/en/posts/107731917/https://jacksparrow414.pages.dev/en/posts/107731917/Uses ShardingProxy 4.1.1 to configure data sharding and read/write splitting across multiple MySQL instances, then verifies routing through query and insert logs. It covers starting the proxy service, connecting an application, and MySQL driver and version compatibility considerations.Sat, 01 Aug 2020 07:46:35 GMThttps://jacksparrow414.pages.dev/en/posts/107443620/https://jacksparrow414.pages.dev/en/posts/107443620/Command-line and curl examples demonstrate a complete Solr workflow: managing cores and fields, CRUD operations, pagination, and conditional queries. The article also configures HTML tag filtering for rich-text searches and explains copyField and fieldType.Sun, 19 Jul 2020 04:42:36 GMThttps://jacksparrow414.pages.dev/en/posts/107128439/https://jacksparrow414.pages.dev/en/posts/107128439/Using ShardingSphere 4.1.1, this article implements and configures custom encryption strategies and traces SPI-based encryptor registration through the source code. It demonstrates Encryptor and QueryAssistedEncryptor separately, then verifies how an assisted-query column supports queries over differing ciphertext values.Sat, 04 Jul 2020 10:32:15 GMThttps://jacksparrow414.pages.dev/en/posts/106955241/https://jacksparrow414.pages.dev/en/posts/106955241/This article answers common GitHub workflow questions: dealing with slow or failed clones, keeping a fork synchronized with upstream, submitting pull requests, and handling other practical Git issues.Thu, 25 Jun 2020 02:22:54 GMThttps://jacksparrow414.pages.dev/en/posts/106745714/https://jacksparrow414.pages.dev/en/posts/106745714/Introduces installation, configuration, and startup of SkyWalking and Elasticsearch, then configures agents for Spring Cloud microservices. Dashboards, topology, and tracing views illustrate individual services, service-to-service calls, and database access, including how to inspect SQL and its parameters in a trace.Sun, 14 Jun 2020 06:38:24 GMThttps://jacksparrow414.pages.dev/en/posts/106454228/https://jacksparrow414.pages.dev/en/posts/106454228/How can you define your own Spring Boot YAML configuration, and what conventions should you follow? This article shares the approach I developed through hands-on practice.Sun, 31 May 2020 05:13:22 GMThttps://jacksparrow414.pages.dev/en/posts/106437659/https://jacksparrow414.pages.dev/en/posts/106437659/Building on data sharding and read/write splitting, this article uses ShardingJDBC’s built-in algorithms to encrypt stored fields and decrypt query results. It verifies the configuration through inserts and queries and discusses full routing without a sharding key, including the number of tables queried and the maintainers’ explanation.Sat, 30 May 2020 03:45:09 GMThttps://jacksparrow414.pages.dev/en/posts/106341331/https://jacksparrow414.pages.dev/en/posts/106341331/Builds on a data-sharding example to configure ShardingJDBC read/write splitting for a MySQL primary-replica setup. It introduces primary and replica data sources and replica load-balancing strategies, observes queries alternating between replicas, and records the unresolved issue of a slow first query.Mon, 25 May 2020 12:52:27 GMThttps://jacksparrow414.pages.dev/en/posts/106320075/https://jacksparrow414.pages.dev/en/posts/106320075/An introduction to data sharding in ShardingSphere–ShardingJDBC, with database and table sharding demonstrated across two MySQL instances. An example selects databases by id and tables by age to observe write and query routing, and explains how sharding keys relate to full routing.Mon, 25 May 2020 11:37:52 GMThttps://jacksparrow414.pages.dev/en/posts/106171462/https://jacksparrow414.pages.dev/en/posts/106171462/An exploration of Spring IoC through bean creation and dependency injection, including constructors, factory methods, and setters. The article also traces component scanning in the source code to see how annotated classes become bean definitions and how the container manages objects and their dependencies.Sun, 17 May 2020 04:16:23 GMThttps://jacksparrow414.pages.dev/en/posts/106170205/https://jacksparrow414.pages.dev/en/posts/106170205/Analyzes Spring’s setter and constructor injection workflows through the dependency between two beans. By tracing property resolution and getBean calls, it explains how existing dependencies are reused and missing dependencies are created, and compares when the two injection methods run.Sun, 17 May 2020 03:01:23 GMThttps://jacksparrow414.pages.dev/en/posts/106163508/https://jacksparrow414.pages.dev/en/posts/106163508/Starting from XML configuration, this article uses source-code debugging to examine bean definition registration, object creation, property population, and initialization in Spring. It explains how BeanFactory stores the relevant information and compares when non-lazy singleton and prototype beans are created during container startup or actual use.Sat, 16 May 2020 12:47:33 GMThttps://jacksparrow414.pages.dev/en/posts/105916921/https://jacksparrow414.pages.dev/en/posts/105916921/Uses practical examples to introduce Spring Data Solr configuration, entity mapping, CRUD, and pagination, and demonstrates queries using @Query and SolrTemplate. It also discusses extending custom repositories, using transactions, and checking query statements through logging.Mon, 04 May 2020 06:45:05 GMThttps://jacksparrow414.pages.dev/en/posts/105902517/https://jacksparrow414.pages.dev/en/posts/105902517/Java examples introduce SolrJ dependency configuration, entities annotated with Field, and a shared SolrClient wrapper. The article demonstrates adding, updating, deleting, and querying data, verifies the results in the Solr console, and explains why the core must be specified when committing.Sun, 03 May 2020 06:36:43 GMThttps://jacksparrow414.pages.dev/en/posts/105889408/https://jacksparrow414.pages.dev/en/posts/105889408/Explains how to configure Solr DataImportHandler for full and incremental imports from MySQL and periodically refresh data with operating-system scheduled jobs. It also covers tinyint fields, multivalued fields, and Transformers, and outlines DIH components and changes in later versions.Sat, 02 May 2020 06:12:19 GMThttps://jacksparrow414.pages.dev/en/posts/105822592/https://jacksparrow414.pages.dev/en/posts/105822592/Introduces Solr installation and startup, custom cores and field configuration, and demonstrates adding, querying, and deleting data through the console and curl. It also covers stopping Solr, deleting cores, and checking the core name when copied configuration causes a CoreContainer initialization failure.Fri, 01 May 2020 01:47:52 GMThttps://jacksparrow414.pages.dev/en/posts/105666620/https://jacksparrow414.pages.dev/en/posts/105666620/Uses a branch merge that requires combining multiple commits to introduce interactive Git rebase and commit-message editing. It compares squash, fixup, commit --amend, and resetting followed by a new commit, and explains how to abort an unfinished rebase.Tue, 21 Apr 2020 13:11:17 GMThttps://jacksparrow414.pages.dev/en/posts/104740624/https://jacksparrow414.pages.dev/en/posts/104740624/Examples of communication between containers compare Docker’s default network, links, and a custom bridge network. The article shows how to inspect container IP addresses and network details, and how a custom network lets containers reach one another by name without depending on specific IP addresses.Sun, 08 Mar 2020 13:23:32 GMThttps://jacksparrow414.pages.dev/en/posts/104730024/https://jacksparrow414.pages.dev/en/posts/104730024/A rollback problem involving calls between Spring Cloud microservices introduces Seata Server installation, database storage configuration, and Eureka registration. AT mode, the undo_log table, and a global transaction annotation are then used to verify rollback after an exception in a cross-service call.Sun, 08 Mar 2020 04:53:33 GMThttps://jacksparrow414.pages.dev/en/posts/104588795/https://jacksparrow414.pages.dev/en/posts/104588795/Sets up primary-replica replication using multiple local MySQL instances and introduces replication threads, binlog formats, and configuration steps. Based on actual errors, it covers authentication failures and replicas that stop synchronizing, and discusses asynchronous and semisynchronous replication and common replication topologies.Sun, 01 Mar 2020 05:32:25 GMThttps://jacksparrow414.pages.dev/en/posts/104458459/https://jacksparrow414.pages.dev/en/posts/104458459/Using Docker on macOS, this article records building a CentOS image with a Dockerfile and configuring Java and Maven. It also covers container users, running a Java application, and saving, tagging, pushing, and pulling the custom image.Sun, 23 Feb 2020 05:29:38 GMThttps://jacksparrow414.pages.dev/en/posts/104330556/https://jacksparrow414.pages.dev/en/posts/104330556/This article records a SQL Server-to-MySQL migration with Navicat and troubleshooting when the server refuses connections. It also covers MySQL file imports and exports, directory permissions, delimiters, duplicate handling, and default field values during bulk imports.Sat, 15 Feb 2020 09:46:29 GMThttps://jacksparrow414.pages.dev/en/posts/103642847/https://jacksparrow414.pages.dev/en/posts/103642847/Analyzes how MyBatis getMapper uses JDK dynamic proxies to create proxy objects for Mapper interfaces. By tracing MapperProxy, MapperMethod, and SqlSession calls, it explains how Mapper methods become SQL operations without requiring handwritten interface implementation classes.Sat, 21 Dec 2019 05:21:47 GMThttps://jacksparrow414.pages.dev/en/posts/103547178/https://jacksparrow414.pages.dev/en/posts/103547178/This article records deploying multiple MySQL instances on a Mac, compares shared and separate configuration files, and details copying an instance, initializing its data directory, and configuring ports and sockets. It also discusses directory permissions, startup, and Navicat connection problems.Sun, 15 Dec 2019 04:40:25 GMThttps://jacksparrow414.pages.dev/en/posts/103282583/https://jacksparrow414.pages.dev/en/posts/103282583/This article revisits the proxy pattern and JDK dynamic-proxy source code to clarify interfaces, implementation classes, proxy classes, and InvocationHandler. Two usage examples explain proxy generation and method invocation, with connections to Spring AOP and MyBatis.Sat, 30 Nov 2019 06:10:18 GMThttps://jacksparrow414.pages.dev/en/posts/103189545/https://jacksparrow414.pages.dev/en/posts/103189545/Source-code debugging traces how MyBatis loads configuration and Mapper XML, and turns SQL statements and their attributes into MappedStatement objects. The article follows placeholder conversion, SqlSource creation, and registration of statement information in the global Configuration.Thu, 21 Nov 2019 13:49:12 GMThttps://jacksparrow414.pages.dev/en/posts/103169279/https://jacksparrow414.pages.dev/en/posts/103169279/Continuing the MyBatis insert flow, this article analyzes PreparedStatement creation and SQL parameter binding. It explains the relationship among BoundSql, parameter mappings, and TypeHandler, showing how values are assigned by type and how these steps correspond to traditional JDBC.Wed, 20 Nov 2019 12:44:08 GMThttps://jacksparrow414.pages.dev/en/posts/103129458/https://jacksparrow414.pages.dev/en/posts/103129458/Starting with traditional JDBC operations and MyBatis XML configuration, this article traces an insert request. Source-level debugging reveals the calls among SqlSession, executors, and StatementHandler, including obtaining a database connection, preparing a statement, and executing SQL.Tue, 19 Nov 2019 13:28:28 GMThttps://jacksparrow414.pages.dev/en/posts/102709308/https://jacksparrow414.pages.dev/en/posts/102709308/Records a debugging session involving a Spring Cloud microservice calling a Word-to-image service, covering callbacks blocked by the gateway, file-processing timeouts, and incorrect image order. The workflow is improved by updating the allowlist, using input streams directly, and sorting by numeric filename prefixes.Wed, 23 Oct 2019 12:37:28 GMThttps://jacksparrow414.pages.dev/en/posts/102523683/https://jacksparrow414.pages.dev/en/posts/102523683/During API acceptance testing, the development environment kept returning 502 errors even though the deployment team found no problem with the environment. The browser console showed that the domain resolved to the wrong IP address, so I changed my local DNS server settings.Sat, 12 Oct 2019 08:54:10 GMThttps://jacksparrow414.pages.dev/en/posts/100180327/https://jacksparrow414.pages.dev/en/posts/100180327/A two-table LEFT JOIN example compares the results of putting filter conditions in ON versus WHERE. It shows how a condition on the right-hand table in WHERE removes some left-hand records, and how moving the condition changes the join results to match the intended output.Sun, 01 Sep 2019 02:04:53 GMThttps://jacksparrow414.pages.dev/en/posts/95730177/https://jacksparrow414.pages.dev/en/posts/95730177/Using asynchronous conversion of uploaded Word documents to images as an example, this article investigates why @Async did not take effect in Spring Boot. It explains the importance of return types and calls through a proxy, and discusses similar considerations for @Transactional when methods call other methods in the same class.Sat, 13 Jul 2019 03:04:31 GMThttps://jacksparrow414.pages.dev/en/posts/90551828/https://jacksparrow414.pages.dev/en/posts/90551828/The main code for integrating Shiro, Spring Boot, and JWT: the Shiro configuration, a custom Realm, an authentication filter, and a JWT utility. Together, these four pieces show login authentication, request interception, and token creation and validation, with a look back at the session-management choices made during integration.Sat, 25 May 2019 13:52:36 GMThttps://jacksparrow414.pages.dev/en/posts/90551285/https://jacksparrow414.pages.dev/en/posts/90551285/JWT is integrated with Shiro and Spring Boot to issue tokens after login and parse, validate, and check them for expiry on subsequent requests. This article explains the JWT utility, authentication filter, and configuration properties, and traces a dependency-injection failure caused by constructing the filter manually.Sat, 25 May 2019 13:31:42 GMThttps://jacksparrow414.pages.dev/en/posts/90145603/https://jacksparrow414.pages.dev/en/posts/90145603/A custom Shiro filter validates tokens on incoming requests. The article covers returning a token after login, adding the filter to the authentication chain, and tracing filter execution order in the source code, then discusses token expiry and distributed authentication that the example has not yet implemented.Sun, 12 May 2019 14:18:22 GMThttps://jacksparrow414.pages.dev/en/posts/89820043/https://jacksparrow414.pages.dev/en/posts/89820043/Starting from login validation in traditional web applications, this article discusses the differences between sessions and tokens in storage, sharing across distributed systems, and request authentication. It compares validation approaches using a database, Redis, or no token storage to clarify design considerations for implementing token authentication with Shiro.Sat, 04 May 2019 17:02:39 GMThttps://jacksparrow414.pages.dev/en/posts/89416294/https://jacksparrow414.pages.dev/en/posts/89416294/This article walks through password hashing, salted storage, and login verification in Shiro and uses its source code to explain credential comparison. It also covers troubleshooting passwords still stored as plaintext and authentication failures after salting, including the roles of the algorithm, salt, and hash iteration count.Sat, 20 Apr 2019 07:08:57 GMThttps://jacksparrow414.pages.dev/en/posts/88901350/https://jacksparrow414.pages.dev/en/posts/88901350/This article covers Shiro session management, including session ID generation, cookie storage, SessionDAO, and expired-session cleanup. It also describes periodic validation with Quartz and disabling session ID URL rewriting to avoid exposing IDs after redirects.Fri, 29 Mar 2019 12:55:44 GMThttps://jacksparrow414.pages.dev/en/posts/88893931/https://jacksparrow414.pages.dev/en/posts/88893931/Two practical Linux command examples: using find with xargs or exec to locate and remove lastUpdated files left by failed Maven downloads, and using less to page through files too large to fit on one screen.Fri, 29 Mar 2019 07:24:18 GMThttps://jacksparrow414.pages.dev/en/posts/88892297/https://jacksparrow414.pages.dev/en/posts/88892297/This article adds practical notes on configuring and running MyBatis Generator, including output directories, database connections, and a custom generic Mapper. It discusses configuration file paths, the resources directory name, and details to check when running generation from IntelliJ IDEA.Fri, 29 Mar 2019 07:10:13 GMThttps://jacksparrow414.pages.dev/en/posts/88818827/https://jacksparrow414.pages.dev/en/posts/88818827/Introduces Shiro rememberMe configuration and automatic login on a later visit, and records a source-code investigation of cookies containing deleteMe. Making the User object used in authentication implement Serializable resolves the serialization failure that breaks the remember-me feature.Tue, 26 Mar 2019 07:42:46 GMThttps://jacksparrow414.pages.dev/en/posts/88725508/https://jacksparrow414.pages.dev/en/posts/88725508/This article introduces a basic login flow with Shiro and Spring MVC, including filter configuration, authentication in a custom Realm, and redirects after successful login. Missing accounts, incorrect passwords, and locked accounts illustrate authentication-code and login-URL configuration considerations.Thu, 21 Mar 2019 14:11:54 GMThttps://jacksparrow414.pages.dev/en/posts/88637285/https://jacksparrow414.pages.dev/en/posts/88637285/A record of installing Homebrew on macOS, switching mirrors, and troubleshooting installation errors, followed by common questions about brew tap, pinning versions, and disabling updates. The article notes changes to the old installation script and adds mirror installation documentation.Mon, 18 Mar 2019 05:51:21 GMThttps://jacksparrow414.pages.dev/en/posts/88061591/https://jacksparrow414.pages.dev/en/posts/88061591/Using entity properties and database null handling as examples, this article discusses the differences between Java primitive types and wrapper classes, particularly when double, int, and their wrappers encounter null values.Fri, 01 Mar 2019 13:10:43 GMThttps://jacksparrow414.pages.dev/en/posts/87860212/https://jacksparrow414.pages.dev/en/posts/87860212/A simple Spring MVC image-upload example covering form settings, receiving and saving files, multipart resolver configuration, and dependencies. It also describes using a MultipartFile array for multiple images, with validation left for further development.Thu, 21 Feb 2019 06:32:45 GMThttps://jacksparrow414.pages.dev/en/posts/87807275/https://jacksparrow414.pages.dev/en/posts/87807275/Troubleshooting home-page navigation to a JSP under WEB-INF, followed by an update that adjusts the DispatcherServlet mapping and the controller’s root mapping. It also covers issues with component scanning, listeners, and static resource configuration.Wed, 20 Feb 2019 09:37:58 GMThttps://jacksparrow414.pages.dev/en/posts/86479244/https://jacksparrow414.pages.dev/en/posts/86479244/Starting from a save operation that runs without writing data to the database, this post checks how method names match Spring transaction configuration. It explains REQUIRED and SUPPORTS, then covers the remaining propagation settings and their relationship to transaction rollback.Mon, 14 Jan 2019 08:51:35 GMThttps://jacksparrow414.pages.dev/en/posts/85699861/https://jacksparrow414.pages.dev/en/posts/85699861/Troubleshooting a 404 when returning a JSP view from another directory in Spring MVC. It compares specifying a view with ModelAndView and making a new request with redirect, and explains why .jsp should be omitted when the view resolver already supplies the suffix.Thu, 03 Jan 2019 08:08:33 GMThttps://jacksparrow414.pages.dev/en/posts/85639107/https://jacksparrow414.pages.dev/en/posts/85639107/Introductory Linux notes covering common directories under the root filesystem, directory navigation, archive creation and extraction, command-line shortcuts, file listings and permissions, and checking file sizes.Wed, 02 Jan 2019 13:55:58 GMThttps://jacksparrow414.pages.dev/en/posts/85638141/https://jacksparrow414.pages.dev/en/posts/85638141/Two basic Java techniques illustrated with development examples: using a string’s length to calculate the starting index for extracting a fixed-length suffix with substring, and using a labeled break to exit an outer loop.Wed, 02 Jan 2019 12:39:46 GMThttps://jacksparrow414.pages.dev/en/posts/85330301/https://jacksparrow414.pages.dev/en/posts/85330301/A basic Docker workflow using a CentOS image: obtaining an image, creating and leaving a container, committing changes, tagging the image, and pushing it to a remote repository. It also covers login issues and commands for removing containers and images.Fri, 28 Dec 2018 13:50:05 GMThttps://jacksparrow414.pages.dev/en/posts/85223279/https://jacksparrow414.pages.dev/en/posts/85223279/Notes on displaying backend data as a tree with jQuery zTree, including the HTML node, setting options, and zNodes data used for initialization. It also links to the official API and a reference on building tree data from database queries.Sun, 23 Dec 2018 07:47:27 GMThttps://jacksparrow414.pages.dev/en/posts/85107472/https://jacksparrow414.pages.dev/en/posts/85107472/A troubleshooting account of deploying a web project on a Mac with Eclipse, Tomcat 7, and JDK 7. It covers compiler versions, Servlet dependencies, IPv4 settings, and JVM options, with particular attention to repeated deployments and duplicate JAR files.Wed, 19 Dec 2018 13:16:47 GMThttps://jacksparrow414.pages.dev/en/posts/85066262/https://jacksparrow414.pages.dev/en/posts/85066262/Notes on installing and initially configuring Docker on a Mac: downloading the client, checking the installation from the terminal, and setting up an Alibaba Cloud registry mirror for use in China. It also covers checking settings after client upgrades and a problem encountered when configuring the mirror URL.Tue, 18 Dec 2018 07:29:19 GMThttps://jacksparrow414.pages.dev/en/posts/85050811/https://jacksparrow414.pages.dev/en/posts/85050811/A troubleshooting account of an Ajax request that returns a successful HTTP status but enters the error callback. It uses response details to identify a JSON parsing problem and checks @ResponseBody, then covers a case where code reads variables before an asynchronous request finishes and gets undefined.Mon, 17 Dec 2018 08:35:14 GMThttps://jacksparrow414.pages.dev/en/posts/85037409/https://jacksparrow414.pages.dev/en/posts/85037409/Steps for building a simple web project with Maven and IntelliJ IDEA on a Mac, with references for installation and IDE setup. It also explains how configuring a Maven mirror can address slow dependency downloads and lengthy builds.Sun, 16 Dec 2018 07:23:55 GMThttps://jacksparrow414.pages.dev/en/posts/84943056/https://jacksparrow414.pages.dev/en/posts/84943056/Starting with a controller-to-URL mapping error, this article traces Spring MVC’s request-processing flow. It explains the collaboration between DispatcherServlet, HandlerMapping, HandlerAdapter, and ViewResolver, including how the view and data are returned.Mon, 10 Dec 2018 09:39:35 GMThttps://jacksparrow414.pages.dev/en/posts/84874741/https://jacksparrow414.pages.dev/en/posts/84874741/This article records an ArrayList debugging experience involving capacity and apparent null entries. It discusses initial capacity, automatic growth, and the value of specifying capacity when the expected collection size is known.Fri, 07 Dec 2018 07:10:52 GMThttps://jacksparrow414.pages.dev/en/posts/84590375/https://jacksparrow414.pages.dev/en/posts/84590375/This article records three configuration mistakes: an incomplete quote around a MyBatis XML id, duplicate Spring MVC controller names, and a misspelled resultMap name. Error messages and troubleshooting steps illustrate why careful configuration checks matter.Wed, 28 Nov 2018 12:24:39 GMThttps://jacksparrow414.pages.dev/en/posts/84563141/https://jacksparrow414.pages.dev/en/posts/84563141/Links to approaches for improving responsiveness in MyEclipse and IntelliJ IDEA.Tue, 27 Nov 2018 03:33:44 GMThttps://jacksparrow414.pages.dev/en/posts/84543477/https://jacksparrow414.pages.dev/en/posts/84543477/An attempt to split a frontend value with JavaScript produced a “split is not function” error. Converting the value with toString() resolved it, although the underlying cause had not yet been investigated.Mon, 26 Nov 2018 06:57:05 GMThttps://jacksparrow414.pages.dev/en/posts/84324286/https://jacksparrow414.pages.dev/en/posts/84324286/This article investigates duplicate results from multi-table left joins without discarding legitimately identical business records. It describes using Oracle ROWID for deduplication, assigning column aliases, and converting ROWID with ROWIDTOCHAR for Java object mapping.Wed, 21 Nov 2018 08:04:55 GMThttps://jacksparrow414.pages.dev/en/posts/84247249/https://jacksparrow414.pages.dev/en/posts/84247249/This article investigates why an Ajax request returns data while the calling function returns undefined. It explains the order of callback assignment and function return in an asynchronous request, using a MiniUI example to illustrate the async setting.Mon, 19 Nov 2018 06:28:40 GMThttps://jacksparrow414.pages.dev/en/posts/83543369/https://jacksparrow414.pages.dev/en/posts/83543369/A suggestion to use MySQL’s LOCATE function.Tue, 30 Oct 2018 07:54:34 GMThttps://jacksparrow414.pages.dev/en/posts/83380928/https://jacksparrow414.pages.dev/en/posts/83380928/This article explains how deleting an entire Excel row differs from clearing its contents when importing with Apache POI. It describes checking rows, cells, and cell types to exclude empty rows and prevent empty data from being written to the database.Thu, 25 Oct 2018 08:16:22 GMThttps://jacksparrow414.pages.dev/en/posts/82898682/https://jacksparrow414.pages.dev/en/posts/82898682/A detailed introduction to Oracle window functions.Sat, 29 Sep 2018 07:53:44 GMThttps://jacksparrow414.pages.dev/en/posts/82684680/https://jacksparrow414.pages.dev/en/posts/82684680/This article recounts troubleshooting ORA-01109 and ORA-12514 after deleting Oracle tablespace files directly. It records database startup, SYSDBA login, and listener configuration issues, and concludes that tablespaces should be removed through the normal deletion procedure.Thu, 13 Sep 2018 03:11:33 GMThttps://jacksparrow414.pages.dev/en/posts/82143154/https://jacksparrow414.pages.dev/en/posts/82143154/These should be available in my bookmarks.Tue, 28 Aug 2018 02:06:00 GMThttps://jacksparrow414.pages.dev/en/posts/81975535/https://jacksparrow414.pages.dev/en/posts/81975535/This article records basic Redis operations on Windows: connecting with redis-cli, setting requirepass and authenticating with AUTH, writing data with SET, and setting key expiration in seconds or milliseconds.Thu, 23 Aug 2018 02:13:06 GMThttps://jacksparrow414.pages.dev/en/posts/81870109/https://jacksparrow414.pages.dev/en/posts/81870109/This article collects environment troubleshooting steps for web development: finding a Windows machine’s IP address and occupied ports, accessing a local project by IP, and adjusting Tomcat-related JVM memory settings in MyEclipse and IntelliJ IDEA.Mon, 20 Aug 2018 06:14:40 GMThttps://jacksparrow414.pages.dev/en/posts/81778435/https://jacksparrow414.pages.dev/en/posts/81778435/This article collects Java fundamentals that are easy to overlook: two-dimensional arrays, string concatenation and character arrays, integer parsing and numeric ranges, digit conversion, and split parameters. Examples highlight type and boundary issues encountered in practice.Fri, 17 Aug 2018 07:33:53 GMThttps://jacksparrow414.pages.dev/en/posts/81667443/https://jacksparrow414.pages.dev/en/posts/81667443/A few development reminders: log caught exceptions with a logger; consider entrySet when iterating over a map; and, when using indexof, prefer single-quoted characters over double-quoted strings.Tue, 14 Aug 2018 07:11:55 GMThttps://jacksparrow414.pages.dev/en/posts/81633571/https://jacksparrow414.pages.dev/en/posts/81633571/This article collects easily overlooked development details: avoiding null-pointer errors in string comparisons, declaring generic collections, concatenating Oracle strings, and using IS NULL or IS NOT NULL in SQL.Mon, 13 Aug 2018 09:20:58 GMThttps://jacksparrow414.pages.dev/en/posts/81536519/https://jacksparrow414.pages.dev/en/posts/81536519/This article compares IN and EXISTS through practical Oracle query issues, emphasizing the need to correlate an EXISTS subquery with the outer table. It also records considerations involving NULL, NOT IN, and execution plans.Thu, 09 Aug 2018 07:11:07 GMThttps://jacksparrow414.pages.dev/en/posts/81354642/https://jacksparrow414.pages.dev/en/posts/81354642/This article collects several JavaScript issues: converting numbers to strings before calling split, formatting numbers with thousands separators using replace and a regular expression, and setting focus on an input with jQuery.Thu, 02 Aug 2018 02:55:02 GMThttps://jacksparrow414.pages.dev/en/posts/81316742/https://jacksparrow414.pages.dev/en/posts/81316742/Using static methods for querying approval documents as an example, this article records observations about static members, direct method calls, and loading order. It also discusses questions about invocation frequency and memory use in business queries.Tue, 31 Jul 2018 09:19:09 GMThttps://jacksparrow414.pages.dev/en/posts/81302214/https://jacksparrow414.pages.dev/en/posts/81302214/This article introduces Oracle’s INSTR function through examples of its parameters, return values, and use in WHERE conditions. It then explains the padding directions of LPAD and RPAD, using a sequence value padded with zeros as an example.Tue, 31 Jul 2018 06:25:06 GMThttps://jacksparrow414.pages.dev/en/posts/81220067/https://jacksparrow414.pages.dev/en/posts/81220067/This article considers slow queries on large tables from three angles: SQL quality, table and index design, and table partitioning. These are preliminary ideas; the partitioning approach has not yet been put into practice.Thu, 26 Jul 2018 07:11:17 GMThttps://jacksparrow414.pages.dev/en/posts/81196315/https://jacksparrow414.pages.dev/en/posts/81196315/This article collects other bloggers’ views on frontend and backend engineering skills. It outlines learning areas for each role, from Java, databases, and distributed systems to browsers and build tools, along with their respective performance and user-experience goals.Wed, 25 Jul 2018 01:36:24 GMThttps://jacksparrow414.pages.dev/en/posts/81003637/https://jacksparrow414.pages.dev/en/posts/81003637/This article records a PL/SQL connection failure involving TNS errors. It covers checking connectivity with tnsping, adjusting HOST settings, restarting the listener, testing login with SQL*Plus, and configuring the Oracle home used by PL/SQL.Wed, 11 Jul 2018 09:16:50 GMThttps://jacksparrow414.pages.dev/en/posts/80983452/https://jacksparrow414.pages.dev/en/posts/80983452/This article compares static and dynamic JSP includes by considering whether the pages share a single servlet. Examples involving page encoding, duplicate variables, and generated class files illustrate the practical differences.Tue, 10 Jul 2018 03:52:39 GMThttps://jacksparrow414.pages.dev/en/posts/80007979/https://jacksparrow414.pages.dev/en/posts/80007979/Using search suggestions as an example, this article explains how Ajax communicates with a server without reloading the page. It introduces common jQuery request options and traces XMLHttpRequest creation, request sending, and response-state handling.Tue, 10 Jul 2018 02:31:07 GMThttps://jacksparrow414.pages.dev/en/posts/80976034/https://jacksparrow414.pages.dev/en/posts/80976034/This article recounts a failed condition caused by using == to compare a value received from JSP with a server-side string. It uses the incident to explain the difference between comparing string contents and comparing object references in Java.Mon, 09 Jul 2018 11:38:19 GMThttps://jacksparrow414.pages.dev/en/posts/79930769/https://jacksparrow414.pages.dev/en/posts/79930769/This article traces URL encoding and decoding in Java through URLEncoder, URLDecoder, and Charset lookup. It explains hexadecimal byte representation in percent-encoded URLs and briefly introduces chunked transfer through examples of request and response headers.Fri, 13 Apr 2018 08:48:53 GMThttps://jacksparrow414.pages.dev/en/posts/79930196/https://jacksparrow414.pages.dev/en/posts/79930196/Using String.getBytes as an example, this article traces how Java looks up a character set, creates an encoder, and converts a string to a byte array. It also outlines the similar process used to decode bytes into characters.Fri, 13 Apr 2018 08:20:30 GMT