This tutorial explains how to download and install the Go language, configure the environment, and introduces popular Go web frameworks such as Beego, Iris, and Buffalo, followed by step‑by‑step instructions for installing Beego and creating a Hello World application.
This article compiles typical Java backend interview questions and detailed answers covering self‑introduction, personal growth, concurrency primitives, JVM memory management, GC tuning, cache design, large‑scale data storage, Spring IoC, AOP, distributed session handling, and common design patterns.
This comprehensive guide walks you through installing Redis on Linux and Windows, configuring Spring Cache annotations, setting up JSON serialization with RedisTemplate, using connection pools, and implementing a flexible RedisService with controller examples, providing all the essential steps to integrate Redis into your Spring Boot applications.
This tutorial walks through preparing a CentOS 7.5 host, installing required dependencies, creating an nginx user, downloading the source, compiling and installing Nginx 1.11.1, configuring the firewall, and using common Nginx commands to start, test, reload, and enable the service at boot.
This article introduces Nginx, compares its high‑performance features and resource efficiency with Apache, explains its core functions such as reverse proxy, load balancing and caching, provides performance test results, and details virtual‑host concepts and types for effective web server selection.
This article introduces the Hutool Java utility library, outlines its core modules such as SecureUtil, HtmlUtil, and CronUtil, provides code examples for encryption, HTML escaping, and task scheduling, and encourages developers to explore its comprehensive set of backend development tools.
Idempotency ensures that repeated execution of an operation yields the same result as a single execution, and this article explains its importance in backend systems, outlines concepts, and presents practical techniques such as unique indexes, token mechanisms, pessimistic and optimistic locks, distributed locks, and API design for reliable, duplicate‑free processing.
This article describes how Ctrip's vacation product system was modernized by migrating from a legacy .NET/SQL Server architecture to a MySQL‑based, front‑end/back‑end separated platform, detailing the challenges, step‑by‑step storage reconstruction, replication elimination, data model splitting, messaging replacement, and overall architectural improvements.
This article analyzes the interference and latency problems caused by traditional service‑level Mock tools in a microservice environment and proposes a four‑component solution—servlet agent, local Mock proxy, Mock server, and configuration client—to isolate Mock functionality, eliminate cross‑application impact, and improve test stability.
This tutorial walks through preparing the development environment, creating a Django project and app in PyCharm, configuring MySQL, adjusting Django's MySQL backend, setting up URL routing, and establishing a folder for file uploads, all illustrated with step‑by‑step screenshots.
This article explains how floating‑point calculations in Java can lose precision, especially for monetary values, and demonstrates using the BigDecimal class—particularly its String constructor—to achieve exact arithmetic in backend applications.
This article explains what Swagger is, why it benefits backend and frontend teams, and provides a step‑by‑step guide to integrate Swagger 2.7.0 into a Spring Boot project, including dependencies, configuration, annotations, controller examples, testing tips, and deployment considerations.
This article curates the ten most starred Java‑related GitHub repositories, summarizing their key features—from interview prep and design patterns to SpringBoot, Elasticsearch, and advanced concurrency—providing developers with essential open‑source resources and highlighting the impact of projects like Dubbo.
This article explains how Spring's @EnableAsync annotation activates asynchronous method execution, detailing the roles of AsyncConfigurationSelector, ProxyAsyncConfiguration, AbstractAsyncConfiguration, and AsyncAnnotationBeanPostProcessor, and showing the underlying code that creates proxies, advisors, and executors for async processing.
This article explains why retry strategies are essential for unreliable external services, introduces the flexible Guava‑Retrying library, provides detailed code examples, describes its core execution flow, shows how to add the Maven dependency, and outlines the key interfaces and strategies for configuring retries.
This article uses school‑class analogies to explain ZooKeeper’s role as a third‑party coordinator, describes its tree‑based data model, and details essential features such as watches, session handling, and ephemeral nodes for building reliable backend services.
A comprehensive survey of Java developers reveals current JDK vendor preferences, payment habits, version adoption, upgrade motivations, language distribution, Spring framework usage, IDE and build tool popularity, code repository choices, and role demographics across the industry.
This tutorial explains how to use Java NIO's FileChannel to acquire exclusive and shared file locks, covering lock types, required channel modes, code examples for FileOutputStream, RandomAccessFile, and FileInputStream, and discusses platform-specific considerations and common exceptions.
This article details the architectural redesign, fault‑tolerance mechanisms, performance optimizations, and monitoring strategies employed in JD.com’s PC homepage, illustrating how backend technologies such as OpenResty, Lua, Redis, and NGINX are orchestrated to achieve high availability and sub‑30 ms page loads.
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 article presents a comprehensive collection of Alibaba’s open‑source projects—including Spring Cloud Alibaba, Ant Design, Druid, Dubbo, JStorm, Sentinel, and many others—detailing their core features and providing repository links to help developers build scalable, high‑performance backend and cloud‑native applications.
This article reflects on the redesign of a high‑traffic transaction system, discussing the decision‑making process, programming paradigms, SOLID principles, domain‑driven design, component decomposition, and the evolution from simple state machines to flexible, maintainable backend architectures.
This guide explains how to use Alibaba Cloud Function Compute to create a serverless, elastic backend for mini‑apps, covering the challenges of high‑traffic mini‑programs, the service template workflow, authentication, data access, deployment steps, and client‑side setup.
This article provides a comprehensive beginner-friendly guide to gRPC, covering its definition, the protobuf syntax for defining messages and services, field constraints, supported data types, usage of the protoc tool, and complete Go examples for both server and client implementations.
This article demonstrates a common mistake when parsing a date string without a year in Java, shows the resulting DateTimeParseException, and provides a correct solution using DateTimeFormatterBuilder to supply a default year, complete with code examples and expected output.
This tutorial demonstrates how to add Baidu's ECharts JavaScript visualization library to a Spring Boot backend, covering project setup, Maven dependencies, controller creation, Thymeleaf template configuration, and rendering a line chart in the browser.
This article examines the business drivers behind distributed task scheduling, outlines key requirements and pain points, and provides a comprehensive comparison of Java Timer, ScheduledExecutorService, Spring Task, Quartz, XXL‑JOB, Elastic‑Job, and other open‑source frameworks, helping you choose the most suitable solution for your system.
During the COVID‑19 outbreak, Amap’s engineers and partners created a free “Medical‑Staff Ride” service for Wuhan’s medical personnel, designing, coding, testing, and launching the app‑integrated ride‑hailing feature within three days and adding a reservation function the next day, thanks to prior platform upgrades, tight cross‑functional collaboration, and rapid decision‑making.
This article explains the purpose, benefits, core APIs, implementation classes, execution flow, state management, and monitoring methods of Java thread pools, providing detailed code examples and diagrams to help developers understand and effectively use thread pooling in high‑concurrency applications.
Tencent Cloud CKafka powers Tencent Classroom’s pandemic‑era online teaching by replacing a custom queue with a high‑performance, highly available, partition‑based message bus that scales to millions of real‑time interactions, offers configurable replication and tuning for reliability, and integrates with big‑data and streaming tools for analytics.
The article shares practical insights from a year‑long experience in an internet company, comparing the work attitudes, technical foundations, and responsibilities of architects versus senior developers, and offers concrete steps and resources for engineers aiming to upgrade to an architect role.
This article examines how the Go compiler translates range loops into low‑level assembly instructions, walks through a concrete example with code and assembly output, explains each instruction’s role, and highlights recent compiler improvements that enhance safety and scheduler interaction.
This article explains why Spring Boot 2.1.x stopped printing HTTP request mappings, shows that the log level was changed from INFO to TRACE, and provides the exact configuration needed to re‑enable detailed endpoint logs during application startup.
This article explains what server concurrency means, how to measure it with throughput and stress testing, and presents practical techniques such as CPU parallelism, reducing context switches and lock contention, using persistent connections, optimizing I/O models, and scaling hardware to boost overall server performance.
This article explains how to build a simple two‑level caching solution in Java, covering generic cache interfaces, FIFO/LRU/LFU algorithms, implementing local Guava cache and distributed Redis cache, configuring Spring Boot, handling expiration, and providing a unified cache builder for seamless use.
This article explains how Spring Boot 2.x handles favicons, why the default icon can expose framework details, how to disable it, and provides step‑by‑step instructions and code snippets for adding a custom favicon using Thymeleaf or plain HTML while addressing common caching issues.
An experienced developer recounts how he transformed a cumbersome three‑tier C# data‑center management system from thousands of lines to a concise, maintainable codebase using reflection, generics, and thoughtful refactoring, while sharing practical advice on avoiding code generators, reducing duplication, and embracing unit testing.
This article provides a concise overview of the most frequently used HTTP status codes, explaining the meaning of each 1xx, 2xx, 3xx, 4xx, and 5xx series and detailing individual codes such as 200, 201, 301, 404, and 500 to help developers interpret server responses correctly.
The article provides a series of advanced MyBatis-Plus query examples, including table creation, data initialization, and four detailed cases that demonstrate the use of like, nested, in, and limit clauses with QueryWrapper, accompanied by SQL statements, Java test code, and execution screenshots.
This article presents a series of MyBatis-Plus advanced query cases, including data preparation, detailed SQL and Java QueryWrapper examples, difficulty ratings, and complete code snippets to help developers master complex query operations in a Java backend environment.
This article provides a step‑by‑step tutorial on using MyBatis‑Plus select queries, including data preparation, SQL table creation, and detailed Java code examples for retrieving specific fields and filtering by age with both simple and advanced query wrappers.
This article demonstrates how to use MyBatis-Plus for complex queries—including date filtering, sub‑queries, INNER JOIN, dynamic SQL with the apply method, and the inSql helper—while highlighting potential SQL‑injection pitfalls and providing complete runnable code examples.
This tutorial demonstrates several advanced MyBatis-Plus query scenarios—including combined AND conditions, nested expressions, IN clauses, and limiting results—by providing complete SQL setup, Java QueryWrapper code samples, execution logs, and result screenshots for each case.
This tutorial showcases MyBatis-Plus advanced query techniques through three practical case studies, providing sample data, detailed SQL conditions, and complete Java test code snippets to help developers master complex database queries.
This article explains the origins of Nginx, compares it with Apache, describes forward and reverse proxy concepts, and details Nginx's load‑balancing mechanisms and algorithms, providing a comprehensive overview of how Nginx serves as a high‑performance web and proxy server.
This article explains how message brokers like RabbitMQ use the AMQP protocol to enable efficient communication in distributed systems, covering core concepts, queue and exchange configurations, four routing patterns, and message acknowledgment strategies.
This guide continues the mica‑http tutorial, detailing the new v1.1.7 release, proxy and retry mechanisms, page crawling steps, model usage, result handling, and provides documentation links and open‑source tool recommendations for building lightweight backend crawlers.
This article details how JD.com’s engineering team designed, implemented, and optimized a user‑generated‑content platform that went from concept to production in 60 days, covering project background, system architecture, data storage with JimDB, messaging decoupling, asynchronous I/O, performance testing, and future improvements.
This article shares practical Java backend best‑practice tips—ranging from reordering conditional checks and avoiding unnecessary object creation to efficient database queries, proper logging, idempotent APIs, and smart caching—to help developers write faster, safer, and more maintainable code.
The Spring Framework 5.1.13 release introduces header support in ResponseStatusException, deprecates PathResource, enhances ClientCodecConfigurer, optimizes UriUtils, adds wildcard variable resolution, and fixes ContentDisposition parsing, while Spring Boot 2.2.3 upgrades to Framework 5.2.3 with security patches, new error handling, metric improvements, and numerous bug fixes.
This article compiles over 150 Java interview questions covering collections, JVM tuning, concurrency, Spring framework, design patterns, Spring Boot, Netty, and Redis, providing a comprehensive study guide to help candidates prepare for upcoming interview seasons.
This guide shows backend developers how to install, proxy‑configure, and extend VS Code, then use its Remote Development extension to connect to servers and set up C++, Python, and Shell debugging, plus Git, Docker, MySQL, and productivity plugins for a lightweight, powerful IDE.
Tomcat starts by Bootstrap.main reading server.xml, initializing components, then blocking in Server.await based on the shutdown port, while shutdown can be performed via the shutdown.sh script (sending a SHUTDOWN command), kill signals (preferably SIGTERM for graceful hooks), or custom JVM shutdown hooks, with the script posing security risks and often being replaced by kill‑15 combined with proper hooks in production.
This article explains Nginx’s multi‑process model, detailing the roles of master and worker processes, the HTTP connection lifecycle, event‑driven architecture, module types, and performance comparisons with Apache, while also covering I/O models like select, poll, and epoll.
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 describes the design, implementation, and practical application of a Drools-based rule engine for automating sales performance calculations, detailing the background challenges, rule definitions, data processing steps, SpringBoot integration, and code examples to achieve flexible, maintainable, and secure business logic separation.
Learn how to declare custom Servlet Filters in Spring Boot, control their execution order and URL scope using both manual bean definitions and Spring's FilterRegistrationBean, with complete code examples and best‑practice tips for secure, maintainable backend development.
The author recounts eight interview experiences across companies like Afanti, XueTang Online, Guokr, Veeva, Zhihu, Spring Rain Doctor, 360, and Toutiao, sharing detailed insights on Python fundamentals, network protocols, system design, database concepts, and personal lessons that helped secure a final offer.
This article explains why a Spring Cloud Gateway‑based microservice project encounters CORS‑related login failures, demonstrates how to reproduce the issue, and provides step‑by‑step configuration changes—including a global CORS filter and removal of duplicate filters—to resolve the problem.
The author describes how a high‑traffic promotion system using HttpClient suffered massive thread and port exhaustion due to misconfigured connection‑pool parameters, details the investigation steps—including monitoring, jstack analysis, and source code review—and outlines corrective measures and preventive testing strategies.
This article explains Nginx's origins, its event‑driven architecture, the reasons it outperformed Apache, and details its roles as a forward and reverse proxy, load‑balancing algorithms, and typical deployment scenarios, illustrating why it is the preferred high‑performance web server today.
This article explains the capabilities of Nginx without third‑party modules, covering reverse proxy, load balancing (including RR, weight, ip_hash, fair, and url_hash), HTTP static serving with static‑dynamic separation, and forward proxy, and provides concrete configuration examples for each feature.
This guide walks you through installing Flask, structuring a project with webapp, templates, and static files, writing core code and routes, using Blueprint for modularization, rendering Jinja2 templates, and running the app, providing complete code snippets and configuration tips for rapid backend development.
This guide outlines responsible web‑crawling practices, covering robots.txt compliance, legal pitfalls such as unauthorized personal data and copyrighted content, recommended request intervals, and relevant Chinese data‑security regulations, helping developers avoid server overloads and potential lawsuits.
The article examines why enums, while type‑safe and convenient for input parameters, are often criticized in API return values due to their lack of extensibility and the risk of deserialization errors when newer enum constants appear after version upgrades.
Laravel contracts are framework-provided interfaces that define core services such as queues and mail, offering low-coupling and clear dependencies; the article explains their purpose, compares them with facades, demonstrates refactoring for decoupling with code examples, and shows how to inject contracts via the service container.
This article provides a comprehensive overview of Laravel's default application folder structure, explaining the purpose of each top‑level directory such as app, bootstrap, config, database, public, resources, routes, storage, tests, and vendor, and detailing the sub‑folders within the app directory like Console, Http, and Providers.
This article provides a comprehensive overview of the most commonly used Spring Boot annotations—including core, configuration, web, and JPA annotations—explaining their purpose, typical usage, and how they replace traditional XML configuration in modern Java applications.
This guide walks you through Laravel's server requirements, installation via Composer or the Laravel installer, local development setup, essential configuration such as public path, permissions, application key, and web‑server tweaks for Apache and Nginx, providing ready‑to‑use code snippets.
This article provides a comprehensive introduction to the Spring ecosystem, covering its core concepts such as IoC and AOP, detailing each of the seven framework modules, and explaining related projects like Spring MVC, Spring Security, Spring Data, Spring Boot, and Spring Cloud for modern Java backend development.
This guide walks beginners through Laravel fundamentals, setting up development environments, hands‑on project ideas, documentation habits, team standards, job‑search strategies, and a long‑term learning path to become a well‑rounded backend engineer.
This article introduces Apache Thrift, explaining its open‑source RPC framework, IDL‑based code generation, protocol and transport layers, and its advantages for high‑performance data exchange in mobile advertising engines, while noting practical considerations such as static schema updates and usage of TFileTransport.
This article explains how to implement asynchronous requests and asynchronous method calls in Spring Boot, covering servlet‑based async, Callable, WebAsyncTask, DeferredResult, @Async annotation, thread‑pool configuration, common pitfalls, and the differences between async request and async call.
Spring Boot lets you pass configuration via command-line arguments when launching a JAR, supporting option, non‑option, and system parameters; this guide explains how to use each form, retrieve values through ApplicationArguments or @Value, and walks through the underlying source code that parses and injects these arguments.
This article walks through designing and implementing a high‑traffic like/unlike feature for a social platform using Spring Cloud, Redis caching, MySQL persistence, and a Quartz‑based scheduled job to sync data every two hours.
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 walks through building a basic round‑robin load balancer in Go, covering the underlying principles, data structures, reverse‑proxy integration, atomic indexing, concurrency handling, health‑check mechanisms, and how to extend the implementation for production use.
This article walks through building a simple Go load balancer using round‑robin distribution, reverse proxy, atomic indexing, health checks, and concurrency‑safe data structures, providing complete code examples and explanations for each component.
This tutorial walks through creating a lightweight Memcached client in Node.js, covering cluster routing with consistent hashing, low‑level TCP communication, a reusable connection‑pool implementation, and a custom protocol for get operations, complete with practical code examples.
This article explains the purpose, source code, and practical usage of Spring Boot’s @ConditionalOnProperty annotation, illustrating how it enables or disables auto‑configuration through property prefixes, names, havingValue, and matchIfMissing attributes with concrete code examples.
Apache Struts 2.5.22 GA introduces numerous bug fixes, library upgrades, and optional security enhancements for Java web applications, while maintaining the framework’s core goal of simplifying the full development lifecycle from build to deployment and maintenance.
The article shares the author's journey from manual data collection to mastering Java web crawlers, explains why Java is preferred over Python, outlines the five-step crawling workflow, covers essential Java basics, HTTP fundamentals, and provides code examples for URL queuing, time parsing, and timestamp conversion.
This article details how Ctrip builds, deploys, tests, releases, and operates Node.js applications—including engineering processes, core middleware, Docker-based deployment, multi‑process communication, monitoring, and full‑link tracing—while sharing practical lessons learned from real‑world production use.
This article explains how to extend an existing Java performance‑testing framework by adding a fixed‑time mode alongside the traditional fixed‑count mode, detailing the design of ThreadBase, ThreadLimitTimes, ThreadLimitTime classes, demo implementations for HTTP requests, and key design considerations for low‑overhead timing and early termination.
This article walks through the inner workings of Spring Security after login, explains session and token based authentication, and provides step‑by‑step guidance on customizing logout logic with LogoutFilter, LogoutConfigurer, and custom LogoutHandler and LogoutSuccessHandler implementations in Java.
Postwoman is an open‑source, free, fast, and visually appealing API builder that offers extensive features such as custom themes, authentication, GraphQL, cURL import, PWA support, and Docker integration, positioning itself as a powerful alternative to Postman for developers across platforms.
PHP 7.4 introduces a suite of powerful features—including typed properties, arrow functions, limited covariance/contravariance, array unpacking, numeric literal separators, short lambda syntax, weak references, throwable __toString() and Opcache preloading—each illustrated with concise code examples for modern backend development.
This guide shows how to instantly create a lightweight HTTP server using a single Python command, enabling fast LAN file downloads and uploads, with step‑by‑step instructions, command examples, IP discovery, and screenshots for both Python 3 and Python 2 environments.
The author, a former PHP engineer at Mafengwo, chronicles a two‑day crash‑course in Java and Spring Boot, detailing the adoption of Lombok, Druid, Maven, and various annotations while navigating pitfalls such as bean scopes, database connections, and data format mismatches before successfully launching the new service.
This guide explains how to set up DjCelery—combining Django and Celery—to create, schedule, and manage automated testing tasks such as single‑interface, API, App, and Web UI scripts, replacing Jenkins‑based cron jobs with a fully integrated backend solution.
This tutorial explains how Spring Boot handles static resources, covering the default classpath directories, a simple manual file‑stream approach, and ways to customize resource locations using Java configuration or application.yml, with code examples and practical URLs.
This article systematically explains cache fundamentals, why caching is essential for performance, where caches can be placed in the architecture, their advantages, when to adopt them, and key design considerations for building reliable, high‑throughput systems.
This tutorial demonstrates how to use Facebook’s RocksDB storage engine together with the Netty‑based RestExpress HTTP container to create a lightweight Redis‑style key/value service called kedis, covering project setup, core API implementation, route configuration, building, launching, and basic curl interactions.
This article walks through customizing Spring Security in a Spring Boot application by creating a custom security configuration class, overriding authentication manager, web security, and HttpSecurity methods, and explains the default and common HttpSecurity settings with code examples.
An in‑depth overview of the Spring ecosystem explains its core container, modules such as AOP, MVC, Data, Security, Boot and Cloud, detailing how IoC and dependency injection simplify Java enterprise development, and guides readers through configuration, architecture, and the advantages of using Spring for modern backend applications.
This article explains the Ant‑style path matching syntax, its wildcards ?, *, **, the longest‑match rule, and demonstrates how to apply these patterns in Spring MVC controller mappings and Spring Security antMatchers for precise URI access control.
This article analyzes how Xianyu's transaction chain architecture progressed through three stages—business decoupling, dual‑end integration with Flutter, and a cloud‑native one‑stop development model—highlighting the technical decisions, challenges, and efficiency gains achieved during each phase.
This article explores how Spring Security is automatically configured in Spring Boot, detailing key auto‑configuration classes such as SecurityAutoConfiguration, SpringBootWebSecurityConfiguration, WebSecurityEnablerConfiguration, and the @EnableWebSecurity annotation, while providing code snippets and explanations of their roles in the security filter chain.
This tutorial walks you through creating a custom Spring Boot starter, covering project structure, naming conventions, auto‑configuration module, property management, Maven setup, sample usage, and best practices, enabling you to package reusable cross‑cutting functionality for any Spring application.
The article explains the progression of software architecture from simple monolithic systems to distributed applications, microservices, and finally serverless platforms, outlining the advantages and disadvantages of each model for developers and organizations.
