Skip to content
Tagged articles

Exception Handling

441 articles · Page 1 of 5
LuTiao Programming
LuTiao Programming
Nov 13, 2026 · Backend Development

Java 27 Structured Concurrency: Replacing CompletableFuture for Parallel Homepage Aggregation

The article demonstrates migrating a homepage aggregation API from CompletableFuture to Java 27's StructuredTaskScope, showing how structured concurrency simplifies parallel downstream calls by automatically managing task lifecycle, cancellation on failure, scope-level timeouts, virtual threads, and observability—reducing exception handling code by half while making concurrency semantics match business intent.

CompletableFutureException HandlingJava 27
0 likes · 17 min read
Java 27 Structured Concurrency: Replacing CompletableFuture for Parallel Homepage Aggregation
Data Bricklaying Diary
Data Bricklaying Diary
Nov 12, 2026 · R&D Management

Beyond the Happy Path: Rigorous Acceptance Testing for Knowledge-Graph Replenishment Pilots

This article details a comprehensive acceptance framework for a knowledge-graph-based replenishment assistant pilot, covering scope definition, version tracking, six distinct verification layers (model, data, suggestions, permissions, execution recovery, handover), independent expected-result calculation, systematic abnormal-case testing, effect measurement including wait and rework time, and capability gating based on test results.

Acceptance TestingException HandlingKnowledge Graph
0 likes · 17 min read
Beyond the Happy Path: Rigorous Acceptance Testing for Knowledge-Graph Replenishment Pilots
Digital Planet
Digital Planet
Nov 11, 2026 · Industry Insights

How MOOS Bridges Enterprise Rules and Frontline Action in AI-Driven Execution

When AI participates in business execution, an error in the first step can propagate through subsequent actions; MOOS addresses this by linking task contracts, accountability networks, and protocols so that rules, facts, resources, and authorizations align in each action, enabling reliable commitments and adaptive exception handling.

AI in business executionBusiness Scenario Reconstruction (BSR)Exception Handling
0 likes · 33 min read
How MOOS Bridges Enterprise Rules and Frontline Action in AI-Driven Execution
Java Tech Workshop
Java Tech Workshop
Nov 9, 2026 · Backend Development

Spring MVC @ControllerAdvice: Exception Matching Order, Coverage Scope & Source-Code Deep Dive

This article explains how Spring MVC's @ControllerAdvice selects exception handlers by inheritance depth, how @Order prioritizes multiple advice classes, which scope attributes limit coverage, and why Filter exceptions, 404 errors, and afterCompletion interceptor exceptions escape global handling.

@ControllerAdvice@ExceptionHandler@Order
0 likes · 17 min read
Spring MVC @ControllerAdvice: Exception Matching Order, Coverage Scope & Source-Code Deep Dive
Old Zhao – Management Systems Only
Old Zhao – Management Systems Only
Nov 3, 2026 · Industry Insights

8 Essential Supply Chain Tables: A 10-Year Practitioner's Framework for Demand, Inventory, Procurement & Cost Control

A supply chain veteran shares the eight core tables — demand planning, inventory turnover, procurement planning, supplier delivery, order tracking, procurement receipt, exception handling, and cost variation — that form a complete management loop from demand to profit, with key metrics, formulas, and practical examples for each.

Exception HandlingJianDaoYunSupply Chain Management
0 likes · 14 min read
8 Essential Supply Chain Tables: A 10-Year Practitioner's Framework for Demand, Inventory, Procurement & Cost Control
Data Bricklaying Diary
Data Bricklaying Diary
Nov 2, 2026 · Product Management

Ontology Built: Must AI Auto-Execute? Scoping Safe Procurement Automation

The article argues that building an ontology doesn't mandate full AI automation; instead, procurement automation should be scoped per task across four levels—query, suggest, per-order approval, and pre-authorized auto-execution—with rigorous checks on objects, data, permissions, quotas, idempotency, and exception handling, plus pause/resume procedures and holistic testing that counts rework and maintenance costs.

AI automationException HandlingIdempotency
0 likes · 14 min read
Ontology Built: Must AI Auto-Execute? Scoping Safe Procurement Automation
Baobao Algorithm Notes
Baobao Algorithm Notes
Nov 1, 2026 · Artificial Intelligence

Super-Agent Design Philosophy: Organizing AI Workers to Liberate Human Attention

The article presents a Super-Agent architecture that separates a persistent Router layer from ephemeral Worker sessions, manages context via Inline/Spill caching and chain recall, uses speculative execution to hide latency, and applies exception-management principles to minimize human attention while maximizing autonomous task execution.

AI agent architectureException HandlingHuman-AI Interaction
0 likes · 15 min read
Super-Agent Design Philosophy: Organizing AI Workers to Liberate Human Attention
Digital Planet
Digital Planet
Oct 29, 2026 · Industry Insights

AI Can Do It, But Should It? The Responsibility Gap in Enterprise AI Adoption

This article argues that technical capability and authorization are distinct hurdles for enterprise AI adoption, proposing a five-question framework to decide which actions can be delegated to AI, distinguishing verification from acceptance, and outlining how to redesign responsibility and exception handling in human-AI workflows.

AI governanceException HandlingHuman-AI Collaboration
0 likes · 29 min read
AI Can Do It, But Should It? The Responsibility Gap in Enterprise AI Adoption
Data Bricklaying Diary
Data Bricklaying Diary
Oct 26, 2026 · Artificial Intelligence

Why a Single Correction Shouldn't Become an Agent's Long-Term Memory

The article argues that agent long-term memory must distinguish personal preferences, task facts, and enterprise rules, requiring corrections to capture provenance, approval, scope, permissions, and expiry; it details a structured metadata schema, validation across applicable, inapplicable, and revoked scenarios, and propagation of invalidation to indexes, caches, and in-flight tasks while preserving audit history.

AI agentsAgent MemoryException Handling
0 likes · 9 min read
Why a Single Correction Shouldn't Become an Agent's Long-Term Memory
Architect's Guide
Architect's Guide
Sep 22, 2026 · Fundamentals

Try-Catch Inside vs Outside For Loops: Behavior, Performance & When to Use Each

This article explains the critical behavioral difference when placing try-catch inside versus outside a for loop: outside placement terminates the loop on exception, while inside allows continuation. It also analyzes performance implications, showing negligible overhead when no exceptions occur but increased memory consumption if many iterations throw exceptions, and details the JVM exception table mechanics that underlie this behavior.

Exception HandlingJavabytecode
0 likes · 6 min read
Try-Catch Inside vs Outside For Loops: Behavior, Performance & When to Use Each
Frontline Investigation
Frontline Investigation
Sep 21, 2026 · Artificial Intelligence

AI Summaries Are Getting Better—But Which Exceptions Are Silently Dropped?

The article explores how AI-generated summaries tend to flatten uncertainties, conflicting judgments, unconventional actions, and evolving contexts—four types of exceptions that signal unresolved issues. It argues for preserving 'undecided positions' in summaries to maintain traceability, enable judgment relay, and prevent overconfidence in smoothed-over conclusions, citing NIST and OWASP risk frameworks.

AI summarizationAI trustworthinessException Handling
0 likes · 10 min read
AI Summaries Are Getting Better—But Which Exceptions Are Silently Dropped?
Frontline Investigation
Frontline Investigation
Sep 17, 2026 · R&D Management

AI Flowcharts Look Perfect—Why Collaboration Gets Messier

AI-generated flowcharts create polished visuals but often hide ambiguous handoffs, missing decision verbs, and unclear exception paths, leading teams to mistake visual connectivity for real collaboration clarity; the article urges distinguishing information, suggestions, and decisions on arrows while mapping task, judgment, and feedback layers to prevent offline rework.

AI-generated flowchartsException HandlingNIST AI 600-1
0 likes · 11 min read
AI Flowcharts Look Perfect—Why Collaboration Gets Messier
Java Tech Enthusiast
Java Tech Enthusiast
Sep 9, 2026 · Backend Development

Does try-catch Impact Java Performance? Bytecode & JIT Benchmark Analysis

The article debunks the myth that try-catch hurts Java performance by analyzing JVM exception tables, bytecode, and running benchmarks under interpreted and compiled modes, showing negligible overhead when no exception is thrown and that JIT compilation eliminates even minor goto costs.

BenchmarkException HandlingJIT
0 likes · 18 min read
Does try-catch Impact Java Performance? Bytecode & JIT Benchmark Analysis
Frontline Investigation
Frontline Investigation
Sep 6, 2026 · Operations

Why Smoother Automation Makes Exception Handoffs Harder

This article explores how highly automated workflows isolate exceptions, stripping context needed for human judgment, and argues for designing exception handoffs as structured re-judgment tasks with complete context packages, proper human placement at decision forks, and metrics focused on recovery quality rather than failure rates.

Exception HandlingNIST AI RMFRPA
0 likes · 13 min read
Why Smoother Automation Makes Exception Handoffs Harder
Frontline Investigation
Frontline Investigation
Aug 23, 2026 · Artificial Intelligence

Why Exception Queues Become the Bottleneck After AI Accelerates Workflows

When AI speeds up standard workflow steps, uncertainty concentrates in exception queues, requiring a design framework that classifies exceptions by actionability, enables context-rich handoffs between AI, RPA, and humans, and turns exceptions into a learning system rather than a technical backlog.

AI automationException HandlingHuman-AI Collaboration
0 likes · 10 min read
Why Exception Queues Become the Bottleneck After AI Accelerates Workflows
Java Tech Workshop
Java Tech Workshop
Aug 21, 2026 · Backend Development

SpringBoot Core Annotations: @ControllerAdvice, @RestControllerAdvice, @Validated

SpringBoot developers often misuse @ControllerAdvice, @RestControllerAdvice, and @Validated, leading to uncaught exceptions, ambiguous responses, and validation errors; this article explains each annotation’s underlying mechanism, proper usage for global exception handling, data binding, request preprocessing, and group‑based validation, and provides production‑ready code examples.

@ControllerAdvice@ValidatedException Handling
0 likes · 20 min read
SpringBoot Core Annotations: @ControllerAdvice, @RestControllerAdvice, @Validated
samdeepthink
samdeepthink
Aug 20, 2026 · Fundamentals

Why Good Code Should Require Minimal Maintenance

The article argues that truly good code is measured by how rarely developers need to revisit and modify it, emphasizing design and programming techniques that make systems resilient to exceptions and adaptable to business changes without frequent code changes.

Exception Handlingcode qualitymaintainability
0 likes · 5 min read
Why Good Code Should Require Minimal Maintenance
samdeepthink
samdeepthink
Aug 13, 2026 · Fundamentals

How I Evaluate Whether Code Is Quality‑OK: Ensuring Stability and Clarity

The article explains how to judge code quality by focusing on stability—handling exceptions, retries, and alerts—and clarity—organizing logic into readable, maintainable steps—illustrated with a real‑world document‑sync example and simple function patterns.

Exception Handlingcode qualitymaintainability
0 likes · 5 min read
How I Evaluate Whether Code Is Quality‑OK: Ensuring Stability and Clarity
Java Tech Workshop
Java Tech Workshop
Aug 13, 2026 · Backend Development

Is Your SpringBoot @Scheduled Task Reliable? A Full‑Stack Breakdown

This article examines the hidden pitfalls of SpringBoot’s @Scheduled annotation—such as duplicate runs in clusters, single‑thread blocking, uncaught exceptions, and lack of monitoring—and provides a step‑by‑step guide to configuring custom thread pools, distributed locks, timeout handling, dynamic task management, and observability for production‑grade reliability.

Dynamic ConfigurationException HandlingRedis Lock
0 likes · 19 min read
Is Your SpringBoot @Scheduled Task Reliable? A Full‑Stack Breakdown
Frontline Investigation
Frontline Investigation
Aug 9, 2026 · Artificial Intelligence

LLMs in Workflows: Why Exception Handling Matters More Than Efficiency

When large language models automate workflows, the real challenge isn't efficiency but handling exceptions—information gaps, rule conflicts, and responsibility mismatches—that require transparent handoffs to humans, preserving context and enabling safe rollback to maintain trust and continuability.

AI governanceAI safetyContinuability
0 likes · 10 min read
LLMs in Workflows: Why Exception Handling Matters More Than Efficiency
Frontline Investigation
Frontline Investigation
Aug 6, 2026 · Industry Insights

Why Cheaper LLMs Make Industry AI Projects Harder to Cost

This article analyzes why industry AI projects become harder to cost as model prices drop, identifying four hidden cost categories—context preparation, continuous evaluation, exception handling, and accountability—and argues that sustainable AI systems require shifting focus from per-call pricing to the cost of an acceptable business outcome.

AI accountabilityAI governanceAI-evaluation
0 likes · 12 min read
Why Cheaper LLMs Make Industry AI Projects Harder to Cost
Frontline Investigation
Frontline Investigation
Aug 2, 2026 · Artificial Intelligence

Why Rule Engines Matter More As LLMs Get Better at Reasoning

As large language models excel at interpreting unstructured inputs, rule engines grow more vital for enforcing deterministic, auditable boundaries on automated actions, ensuring reliable execution in high-stakes business workflows.

AI governanceAI safetyBusiness Process Automation
0 likes · 12 min read
Why Rule Engines Matter More As LLMs Get Better at Reasoning
Data Integration and Governance
Data Integration and Governance
Jul 31, 2026 · Operations

Ensuring Data Sync Is No‑Duplicate, No‑Loss, Accurate – Full‑Load, Incremental, Validation, Exception Handling

The article explains why reliable data synchronization must answer three questions—preventing duplicates, avoiding missing data, and preserving correct content—and details practical solutions for full‑load and incremental sync, idempotent writes, CDC, handling late, out‑of‑order and breakpoint failures, multi‑layer validation, and categorized exception recovery.

CDCException HandlingIdempotency
0 likes · 15 min read
Ensuring Data Sync Is No‑Duplicate, No‑Loss, Accurate – Full‑Load, Incremental, Validation, Exception Handling
samdeepthink
samdeepthink
Jul 30, 2026 · Backend Development

Live Refactor: Turning a Messy Java Registration Method into Intent‑Clear Code

The article demonstrates how a convoluted Java user‑registration method—filled with magic error codes, inline regex checks, deep nesting, and mutable parameters—can be systematically refactored by introducing meaningful exception types, extracting password validation, applying early‑return style, and using immutable request records to produce clear, intent‑driven code.

Best PracticesClean CodeException Handling
0 likes · 7 min read
Live Refactor: Turning a Messy Java Registration Method into Intent‑Clear Code
samdeepthink
samdeepthink
Jul 18, 2026 · Fundamentals

Decade-Long Coding Habits That Boost Code Quality

After years of writing code, the author shares three disciplined habits—anticipating non‑functional scenarios, structuring code to reflect business flow, and adopting spec‑driven development—to improve code quality and resilience in production systems.

Business LogicException HandlingSpec-Driven Development
0 likes · 6 min read
Decade-Long Coding Habits That Boost Code Quality
Java Tech Workshop
Java Tech Workshop
Jul 11, 2026 · Backend Development

Mastering @Valid and @Validated: Practical Group Validation in Spring

This article explains the fundamental differences between Spring's @Valid and @Validated annotations, demonstrates how to apply group validation, nested object checks, and custom validation annotations, and provides a complete strategy for global exception handling and production‑grade best practices.

Custom AnnotationException HandlingJava
0 likes · 17 min read
Mastering @Valid and @Validated: Practical Group Validation in Spring
Java Tech Workshop
Java Tech Workshop
Jun 24, 2026 · Backend Development

Mastering Spring AOP: All Four Types of Advice Explained

Spring AOP provides five distinct advice types—@Before, @AfterReturning, @AfterThrowing, @After, and @Around—each with specific execution timing; this guide explains their purposes, execution order, common pitfalls, and offers a complete SpringBoot example with code, Maven setup, and logging demonstrations.

AOPAspect-Oriented ProgrammingBackend
0 likes · 13 min read
Mastering Spring AOP: All Four Types of Advice Explained
Architecture Breakthrough
Architecture Breakthrough
Jun 18, 2026 · R&D Management

Mastering a Legacy System: A Step‑by‑Step Guide for Architects

The article outlines a practical, four‑step process for architects to fully understand and redesign an aging legacy system, covering business knowledge, the four core functional modules, comprehensive data‑model analysis, and handling of business exceptions, while noting the limited role of AI assistance.

Exception Handlingbusiness analysisdata modeling
0 likes · 5 min read
Mastering a Legacy System: A Step‑by‑Step Guide for Architects
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 1, 2026 · Backend Development

20 Essential Exception‑Handling Rules to Prevent Crashes in Java

This article presents twenty practical rules for handling exceptions in Java, covering why catching RuntimeException is discouraged, how to avoid using exceptions for control flow, proper use of finally blocks, logging best practices, custom exception design, and early input validation to keep applications stable and maintainable.

Best PracticesException HandlingJava
0 likes · 19 min read
20 Essential Exception‑Handling Rules to Prevent Crashes in Java
Xiaolin Talks Programming
Xiaolin Talks Programming
May 31, 2026 · Backend Development

Spring Boot Parameter Validation: From Basic Annotations to Custom Validators & Group Validation

This guide covers Spring Boot parameter validation using Bean Validation annotations, demonstrating basic setup with @Valid/@Validated, custom validator creation for phone numbers, group validation for create/update scenarios, global exception handling for MethodArgumentNotValidException and ConstraintViolationException, and best practices like DTO separation and nested object validation.

Bean ValidationException HandlingHibernate Validator
0 likes · 12 min read
Spring Boot Parameter Validation: From Basic Annotations to Custom Validators & Group Validation
Java Tech Workshop
Java Tech Workshop
May 22, 2026 · Fundamentals

Proper Use of Java's Scanner Class for Console Input

This article explains the Scanner class in java.util, outlines a four‑step usage pattern, details its API for reading and validation, addresses the common nextInt/nextLine line‑skip issue with two reliable solutions, and provides best‑practice guidelines and example code to avoid resource leaks and input errors.

Best PracticesConsole InputException Handling
0 likes · 10 min read
Proper Use of Java's Scanner Class for Console Input
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 21, 2026 · Backend Development

10 Most Valuable Features in Spring Boot Practice

This article presents ten highly valuable Spring Boot features—including global exception handling, MVC interceptors, programmatic bean access, @Import usage, startup runners, BeanDefinition modification, bean lifecycle callbacks, and custom scopes—each illustrated with concrete code examples and explanations for building cleaner, more maintainable Java backend applications.

BeanFactoryCommandLineRunnerCustom Scope
0 likes · 13 min read
10 Most Valuable Features in Spring Boot Practice
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 13, 2026 · Backend Development

Beyond try‑catch: 3 Elegant Fault‑Tolerance Patterns Every Senior Developer Needs

The article explains why simple try‑catch is insufficient for production stability and introduces three advanced fault‑tolerance patterns—retry with exponential back‑off, circuit breaker using Resilience4j, and idempotency design—each illustrated with concrete Spring Boot 3.5.0 code examples and best‑practice guidelines.

Circuit BreakerException HandlingIdempotency
0 likes · 12 min read
Beyond try‑catch: 3 Elegant Fault‑Tolerance Patterns Every Senior Developer Needs
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 9, 2026 · Backend Development

9 Essential Java Code Optimizations to Eliminate Bad Practices

This article presents nine practical Java code‑optimization techniques—including string formatting, loop refactoring, resource management, buffered I/O, multithreading, enums, exception handling, and third‑party libraries—each illustrated with before‑and‑after code samples and clear explanations of why the improved version is more readable, efficient, and maintainable.

Best PracticesException HandlingJava
0 likes · 14 min read
9 Essential Java Code Optimizations to Eliminate Bad Practices
Smart Workplace Lab
Smart Workplace Lab
May 9, 2026 · R&D Management

How Middle Managers Can Survive AI Disruption: Leveraging Exception Management

The article analyzes why middle managers lose relevance when AI automates routine tasks, redefines their role as interfaces for standards and exceptions, and presents a three‑step lever‑control framework—including a task‑allocation matrix, automation rules, and an exception‑interception checklist—to restore strategic impact.

AIException HandlingManagement Levers
0 likes · 7 min read
How Middle Managers Can Survive AI Disruption: Leveraging Exception Management
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 2, 2026 · Backend Development

Beyond Controller Validation: 90% Miss Spring’s Advanced Validation Techniques

The article explains how standard Spring Boot controller‑level validation leaves service methods unchecked, and demonstrates using @Validated with MethodValidationPostProcessor, custom exception handling, and a MethodValidationExcludeFilter to apply, convert, and selectively disable validation across the application.

Custom FilterException HandlingJava
0 likes · 7 min read
Beyond Controller Validation: 90% Miss Spring’s Advanced Validation Techniques
Java Tech Workshop
Java Tech Workshop
May 1, 2026 · Backend Development

Exception Handling Best Practices: From try‑catch to Custom Exceptions

This article explores Java exception handling from basic try‑catch‑finally syntax, through multi‑catch and try‑with‑resources, to designing custom business exceptions, offering concrete code examples, logging tips, global handlers, and performance considerations for robust backend development.

Exception HandlingJavacustom exceptions
0 likes · 18 min read
Exception Handling Best Practices: From try‑catch to Custom Exceptions
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 30, 2026 · Backend Development

5 Common Spring Boot Anti‑Patterns You Must Avoid

The article examines five high‑frequency Spring Boot anti‑patterns—field injection, returning entities from controllers, overusing @Transactional, generic exception handling, and embedding business logic in controllers—showing problematic code snippets, real‑world consequences, and concise refactored examples to improve testability, performance, and maintainability.

Anti-PatternController DesignException Handling
0 likes · 9 min read
5 Common Spring Boot Anti‑Patterns You Must Avoid
Architecture & Thinking
Architecture & Thinking
Apr 29, 2026 · Backend Development

Must‑Know CompletableFuture: Usage, Best Practices, and Real‑World Scenarios

This article explains why CompletableFuture replaces traditional Future in high‑concurrency Java applications, demonstrates core APIs such as runAsync, supplyAsync, thenApply, allOf, anyOf, thenCombine, and exception handling, and provides detailed code examples—including serial, parallel, aggregation, and an e‑commerce order‑processing case—to guide robust asynchronous programming.

Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 26 min read
Must‑Know CompletableFuture: Usage, Best Practices, and Real‑World Scenarios
Top Architect
Top Architect
Apr 26, 2026 · Backend Development

Why the Service Layer Should Not Return a Result Object in Java

The article explains why returning a Result wrapper from the Service layer couples business and presentation logic, reduces reusability, complicates testing and transaction handling, and suggests keeping services pure by returning domain objects and handling errors via exceptions.

Exception HandlingJavaService Layer
0 likes · 12 min read
Why the Service Layer Should Not Return a Result Object in Java
Cloud Architecture
Cloud Architecture
Apr 19, 2026 · Backend Development

Spring Boot Enterprise Guide: Implementing Four Unified Standards from API Contracts to High‑Concurrency Governance

This article presents a comprehensive, production‑grade guide for Spring Boot enterprise projects, detailing why and how to adopt four unified standards—response structure, exception handling, logging, and parameter validation—to ensure stable contracts, clear error semantics, observable systems, and robust input boundaries even under high concurrency.

API DesignException HandlingLogging
0 likes · 39 min read
Spring Boot Enterprise Guide: Implementing Four Unified Standards from API Contracts to High‑Concurrency Governance
Selected Java Interview Questions
Selected Java Interview Questions
Apr 14, 2026 · Backend Development

Mastering Java Exception Hierarchy: From Checked to Unchecked and Best Practices

This guide explains Java's exception inheritance tree, the design intent behind checked and unchecked exceptions, proper handling strategies, common pitfalls, and interview‑ready answers to high‑frequency questions, helping developers write robust, maintainable backend code.

Checked ExceptionException HandlingInterview Preparation
0 likes · 8 min read
Mastering Java Exception Hierarchy: From Checked to Unchecked and Best Practices
java1234
java1234
Mar 3, 2026 · Backend Development

One‑Line Java Time Tracker: Millisecond Precision and Up to 300% Faster Performance

The article shows how to replace repetitive System.currentTimeMillis() timing code with a concise TimeTracker utility that leverages try‑with‑resources, functional interfaces, and flexible exception handling to achieve millisecond‑level measurement and dramatically improve code readability and performance.

Exception HandlingFunctional InterfaceJava
0 likes · 13 min read
One‑Line Java Time Tracker: Millisecond Precision and Up to 300% Faster Performance
Top Architect
Top Architect
Feb 21, 2026 · Backend Development

Mastering Unified Exception Handling in Spring: Clean Code, Enums, and Assertions

This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling strategy that leverages @ControllerAdvice, custom enums, and assertion utilities, providing clean, maintainable code, internationalized error messages, and consistent response structures for both business and system errors.

BackendException HandlingJava
0 likes · 21 min read
Mastering Unified Exception Handling in Spring: Clean Code, Enums, and Assertions
java1234
java1234
Feb 7, 2026 · Backend Development

Why Service Layer Should Not Return a Result Object in Java

The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.

Design PrinciplesException HandlingJava
0 likes · 13 min read
Why Service Layer Should Not Return a Result Object in Java
Java Companion
Java Companion
Feb 7, 2026 · Backend Development

Why Should the Service Layer in Java Not Return a Result Object Directly?

The article explains that returning a Result wrapper from the Service layer mixes business logic with presentation concerns, leading to tighter coupling, reduced reusability, cumbersome error handling, harder testing, poorer DDD alignment, limited interface flexibility, and ambiguous transaction boundaries.

Exception HandlingJavaResult Wrapper
0 likes · 11 min read
Why Should the Service Layer in Java Not Return a Result Object Directly?
Java Architect Handbook
Java Architect Handbook
Jan 20, 2026 · Backend Development

Why Replacing MyBatis with MyBatis-Plus Triggers LocalDateTime Errors—and How to Fix Them

The article details a step‑by‑step migration from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains why the conversion error for java.time.LocalDateTime appears after the switch, shows how to trace the root cause through stack traces, upgrades the mysql‑connector‑java to 5.1.37 (and later 5.1.42) to resolve the issue, and shares broader lessons about component upgrades and unexpected bugs.

Exception HandlingJDBCJava
0 likes · 10 min read
Why Replacing MyBatis with MyBatis-Plus Triggers LocalDateTime Errors—and How to Fix Them
Java Web Project
Java Web Project
Jan 14, 2026 · Backend Development

How to Turn Bloated Spring Controllers into Clean, Maintainable Code

The article analyzes why Spring MVC controllers often become massive with repetitive validation, logging, and business logic, demonstrates an ugly controller example, then shows step‑by‑step refactoring using @Valid, assertion utilities, and a global exception handler to dramatically reduce code size and improve readability.

@ValidClean CodeController Refactoring
0 likes · 8 min read
How to Turn Bloated Spring Controllers into Clean, Maintainable Code
macrozheng
macrozheng
Jan 13, 2026 · Backend Development

Master Spring Boot Validation: 10 Essential Tips for Secure APIs

This guide explains why parameter validation is crucial for Spring Boot applications and walks through ten practical techniques—including built‑in annotations, custom constraints, server‑side checks, meaningful error messages, i18n, validation groups, cross‑field validation, exception handling, testing, and client‑side considerations—to help developers build robust, secure APIs.

AnnotationsCustom ConstraintException Handling
0 likes · 14 min read
Master Spring Boot Validation: 10 Essential Tips for Secure APIs
java1234
java1234
Jan 13, 2026 · Backend Development

How to Write Elegant Spring Controllers and Slash Your Blood Pressure

The article shows how cluttered Spring controllers filled with try‑catch blocks, manual field checks, and business logic can be refactored into concise, readable code by using @Valid, assertion utilities, and a global exception handler, cutting the code size roughly in half.

@ValidControllerException Handling
0 likes · 9 min read
How to Write Elegant Spring Controllers and Slash Your Blood Pressure
Data Party THU
Data Party THU
Jan 8, 2026 · Fundamentals

Master Python Context Managers: Write Safer, Cleaner Code

Learn how Python’s context manager protocol works, explore both class‑based and generator‑based implementations, and see practical examples—from file handling and database transactions to async operations—so you can prevent resource leaks, ensure exception safety, and write more maintainable code.

Exception Handlingasyncbest-practices
0 likes · 11 min read
Master Python Context Managers: Write Safer, Cleaner Code
SpringMeng
SpringMeng
Jan 3, 2026 · Backend Development

Elegant Exception Handling in Spring: Unified @ControllerAdvice, Assertions, and Enum‑Based Errors

The article demonstrates how to replace scattered try‑catch blocks with a clean, unified exception handling strategy in Spring, using @ControllerAdvice, custom BaseException, enum‑driven error codes, and Assert utilities, while also standardizing API responses and handling common MVC errors such as 404.

BackendEnumException Handling
0 likes · 22 min read
Elegant Exception Handling in Spring: Unified @ControllerAdvice, Assertions, and Enum‑Based Errors
Alibaba Cloud Observability
Alibaba Cloud Observability
Dec 29, 2025 · Mobile Development

How to Build a Robust iOS Crash Monitoring System with KSCrash

This article explains the layered iOS exception architecture, common crash causes, and a comprehensive monitoring solution that captures Mach exceptions, Unix signals, runtime NSException and C++ exceptions, and application‑level issues like deadlocks and zombie objects, with detailed implementation steps and code examples.

Crash MonitoringException HandlingKSCrash
0 likes · 18 min read
How to Build a Robust iOS Crash Monitoring System with KSCrash
AndroidPub
AndroidPub
Dec 25, 2025 · Fundamentals

13 Common Kotlin Coroutine Exception Scenarios and How to Fix Them

This article walks through thirteen typical Kotlin coroutine exception pitfalls, explains why errors propagate in structured concurrency, shows wrong and correct code patterns for launch, async, coroutineScope, supervisorScope, and other utilities, and provides concrete examples with outputs to help developers write robust coroutine code.

CoroutinesException HandlingKotlin
0 likes · 19 min read
13 Common Kotlin Coroutine Exception Scenarios and How to Fix Them
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 24, 2025 · Fundamentals

Understanding Java’s final, finally, and finalize: Usage, Pitfalls, and Best Practices

This article explains the distinct purposes of Java's final keyword, finally block, and finalize method, shows how to use them with classes, methods, and variables, highlights scenarios where finally may not run, discusses finalize deprecation, and recommends modern resource‑management techniques like try‑with‑resources.

Exception HandlingFinalFinalize
0 likes · 5 min read
Understanding Java’s final, finally, and finalize: Usage, Pitfalls, and Best Practices
Alibaba Cloud Native
Alibaba Cloud Native
Dec 24, 2025 · Mobile Development

Mastering iOS Crash Monitoring: From Mach Exceptions to KSCrash Implementation

This article explains why iOS apps crash after release, outlines common coding mistakes that cause crashes, introduces a layered iOS exception architecture, and provides detailed implementation steps for Mach exception, Unix signal, runtime, and application‑level monitoring using KSCrash with code samples and diagrams.

Crash MonitoringException HandlingKSCrash
0 likes · 18 min read
Mastering iOS Crash Monitoring: From Mach Exceptions to KSCrash Implementation
LuTiao Programming
LuTiao Programming
Dec 18, 2025 · Backend Development

Think You Understand Exceptions? Senior Java Engineers’ Real Exception‑Handling Practices (99% Get It Wrong)

Most Java developers mistakenly equate writing try‑catch blocks with proper exception handling, leading to lost context, noisy logs, and fragile code, while senior engineers employ custom unchecked exceptions, a layered hierarchy, global handlers, RFC‑7807 responses, and observability tools to build predictable, traceable, and recoverable systems.

BackendException HandlingGlobalExceptionHandler
0 likes · 8 min read
Think You Understand Exceptions? Senior Java Engineers’ Real Exception‑Handling Practices (99% Get It Wrong)
php Courses
php Courses
Dec 4, 2025 · Backend Development

Master PHP Debugging: Essential Tips and Best Practices

This guide walks through practical PHP debugging techniques—including enabling error reporting, logging errors, setting Xdebug breakpoints, handling exceptions with try‑catch, and using var_dump/print_r—to help developers quickly locate and fix runtime problems.

DebuggingError ReportingException Handling
0 likes · 5 min read
Master PHP Debugging: Essential Tips and Best Practices
Su San Talks Tech
Su San Talks Tech
Nov 30, 2025 · Backend Development

Does try…catch Really Slow Down Java? Deep Dive and Benchmarks

This article examines whether Java's try…catch blocks affect performance by exploring their historical origins, JVM exception mechanisms, detailed micro‑benchmarks, and modern JVM optimizations, ultimately revealing that only exception creation and throwing incur noticeable costs while normal execution remains virtually unaffected.

BenchmarkException HandlingJVM
0 likes · 19 min read
Does try…catch Really Slow Down Java? Deep Dive and Benchmarks
macrozheng
macrozheng
Nov 8, 2025 · Backend Development

Should try‑catch Be Inside or Outside a for Loop? Pros, Cons, and Performance

This article explains how placing a try‑catch block inside or outside a Java for loop affects exception handling, loop termination, and performance, providing code examples, execution results, memory analysis, and practical guidance for choosing the appropriate approach based on business needs.

Exception Handlingfor loopperformance
0 likes · 5 min read
Should try‑catch Be Inside or Outside a for Loop? Pros, Cons, and Performance
Code Ape Tech Column
Code Ape Tech Column
Oct 30, 2025 · Backend Development

Boost Spring Boot APIs with Graceful Response: Unified Error Handling & Response Wrapping

This article introduces Graceful Response, a Spring Boot component that provides one‑stop unified response wrapping, global exception handling, and custom error codes, showing how to integrate it via Maven, enable it with annotations, and simplify controller and service code while improving readability and reducing boilerplate.

APIException HandlingGraceful Response
0 likes · 12 min read
Boost Spring Boot APIs with Graceful Response: Unified Error Handling & Response Wrapping
JavaGuide
JavaGuide
Oct 27, 2025 · Backend Development

OPPO 2026 Campus Hiring: Salary Insights and In‑Depth Java Exception & Concurrency Guide

The article reviews OPPO’s 2026 campus hiring salaries for backend and algorithm roles, outlines the interview stages, and provides a comprehensive Java guide covering exceptions, checked vs unchecked, reference types, HashMap concurrency issues, ConcurrentHashMap internals, and the differences between synchronized and volatile.

ConcurrencyException HandlingHashMap
0 likes · 17 min read
OPPO 2026 Campus Hiring: Salary Insights and In‑Depth Java Exception & Concurrency Guide
macrozheng
macrozheng
Oct 20, 2025 · Backend Development

Simplify Spring Boot APIs with Graceful Response: A Quick Guide

This article introduces the Graceful Response component for Spring Boot, explaining how it provides unified response wrapping, global exception handling, and custom error codes to eliminate boilerplate, improve readability, and streamline API development with practical code examples and configuration tips.

APIException HandlingGraceful Response
0 likes · 11 min read
Simplify Spring Boot APIs with Graceful Response: A Quick Guide
ITPUB
ITPUB
Oct 14, 2025 · Backend Development

How to Eliminate 95% of Try‑Catch Blocks with Unified Exception Handling in Spring

This article explains how to replace repetitive try‑catch blocks in Spring applications by using @ControllerAdvice, custom Assert utilities, and enum‑based exception definitions, providing a clean, unified error‑handling mechanism with consistent response structures and environment‑aware messaging.

@ControllerAdviceBackendException Handling
0 likes · 25 min read
How to Eliminate 95% of Try‑Catch Blocks with Unified Exception Handling in Spring
Architect
Architect
Oct 4, 2025 · Backend Development

How Graceful Response Simplifies Spring Boot API Development

This article introduces Graceful Response, a Spring Boot library that provides unified response wrapping, global exception handling, and validation support, showing how it reduces boilerplate code, improves readability, and standardizes error codes across controllers and services.

API responseException HandlingGraceful Response
0 likes · 12 min read
How Graceful Response Simplifies Spring Boot API Development
Architecture Digest
Architecture Digest
Sep 24, 2025 · Backend Development

Streamlining Spring Controllers with Unified Responses and Validation

This article explains how to simplify Spring MVC controller code by introducing a unified response format, leveraging ResponseBodyAdvice for automatic wrapping, applying JSR‑303 validation for request parameters, creating custom validators, and handling exceptions globally to keep business logic clean and maintainable.

ControllerException HandlingJava
0 likes · 15 min read
Streamlining Spring Controllers with Unified Responses and Validation
21CTO
21CTO
Sep 18, 2025 · Backend Development

What’s New in PHP 8.5? Explore Pipelines, NoDiscard, Array Helpers & More

PHP 8.5 arrives with a suite of developer‑friendly enhancements—including a pipeline operator that eliminates temporary variables, a NoDiscard attribute that enforces return‑value usage, new array_first/array_last helpers, constant‑expression closures, global constant attributes, an exception‑handler getter, IntlListFormatter, CLI diff tools, a build‑date constant, and refined final property syntax—making everyday coding cleaner, safer, and more efficient.

Exception HandlingPHPPHP 8.5
0 likes · 9 min read
What’s New in PHP 8.5? Explore Pipelines, NoDiscard, Array Helpers & More
Python Crawling & Data Mining
Python Crawling & Data Mining
Sep 18, 2025 · Fundamentals

Master Python’s With Statement: Build Elegant Context Managers for Safer Code

This tutorial explains why traditional try‑finally resource handling is cumbersome, introduces Python’s with statement and the underlying __enter__/__exit__ magic methods, provides practical examples such as timers, database connections, temporary directories, and shows how to simplify custom managers with contextlib while covering best practices and performance considerations.

Exception HandlingPythoncontext manager
0 likes · 10 min read
Master Python’s With Statement: Build Elegant Context Managers for Safer Code
IT Services Circle
IT Services Circle
Sep 7, 2025 · Fundamentals

Should try‑catch Be Inside or Outside a Loop? Pros, Cons & When to Use

This article examines the trade‑offs of placing try‑catch blocks inside versus outside loops in Java, illustrating each approach with code snippets, discussing efficiency impacts, referencing Alibaba’s Java Development Manual, and outlining scenarios where each placement is appropriate.

Best PracticesException HandlingJava
0 likes · 4 min read
Should try‑catch Be Inside or Outside a Loop? Pros, Cons & When to Use
Java Architect Essentials
Java Architect Essentials
Sep 4, 2025 · Backend Development

Refactoring Spring Controllers: Unified Responses, Validation, and Global Exception Handling

This article explains how to redesign Spring MVC controllers by introducing a unified response wrapper, leveraging ResponseBodyAdvice for automatic packaging, fixing String conversion issues, applying JSR‑303 validation with custom rules, and implementing global exception handling to keep controller code clean and maintainable.

ControllerException HandlingResponseBodyAdvice
0 likes · 20 min read
Refactoring Spring Controllers: Unified Responses, Validation, and Global Exception Handling
Python Programming Learning Circle
Python Programming Learning Circle
Sep 1, 2025 · Fundamentals

Why Python Dictionary Keys Overwrite Each Other: Hashing, Equality & Identity

This article explores three Python quirks: how dictionary keys with equal numeric values overwrite each other due to hashing and equality rules, why a return statement inside a try block is superseded by a return in the finally clause, and how object identity and id values behave, including hash collisions and memory reuse.

Exception HandlingPythondictionary
0 likes · 4 min read
Why Python Dictionary Keys Overwrite Each Other: Hashing, Equality & Identity
php Courses
php Courses
Sep 1, 2025 · Fundamentals

Mastering C++ Standard Exceptions: From Basics to Custom Errors

This article explains why using C++ standard exception classes is essential, outlines the exception hierarchy, details common logical and runtime error types, demonstrates throwing and catching exceptions with code examples, and shows how to create custom exception classes for robust error handling.

C++Exception Handlingerror handling
0 likes · 11 min read
Mastering C++ Standard Exceptions: From Basics to Custom Errors
Java Architect Essentials
Java Architect Essentials
Aug 28, 2025 · Backend Development

Mastering Unified Exception Handling in Spring Boot: Clean Code & Best Practices

Learn how to replace repetitive try‑catch blocks with a clean, unified exception handling strategy in Spring Boot, using @ControllerAdvice, custom Assert utilities, and enum‑based error codes, while also standardizing API responses and supporting internationalization for robust backend development.

BackendException HandlingUnified Error Handling
0 likes · 21 min read
Mastering Unified Exception Handling in Spring Boot: Clean Code & Best Practices
macrozheng
macrozheng
Aug 25, 2025 · Backend Development

How to Refactor Spring Boot Controllers for Clean, Consistent Responses

This article explains why controllers are essential yet often over‑engineered, identifies common problems such as tangled validation and inconsistent responses, and demonstrates how to unify return structures, handle String conversion, apply JSR‑303 validation, create custom validators, and centralize exception handling using Spring Boot features.

ControllerException HandlingJava
0 likes · 19 min read
How to Refactor Spring Boot Controllers for Clean, Consistent Responses
Selected Java Interview Questions
Selected Java Interview Questions
Aug 15, 2025 · Backend Development

Master Spring Boot Controllers: Design Patterns, Best Practices & Code Samples

This comprehensive guide explains how to design high‑quality Spring Boot controller layers, covering architecture planning, RESTful API conventions, parameter validation, unified response structures, exception handling, logging, security, testing, asynchronous processing, and performance optimization with practical code examples and clear best‑practice recommendations.

Best PracticesControllerException Handling
0 likes · 15 min read
Master Spring Boot Controllers: Design Patterns, Best Practices & Code Samples
AndroidPub
AndroidPub
Jul 17, 2025 · Fundamentals

Mastering Kotlin’s runCatching: A Cleaner Alternative to try‑catch

This article explores Kotlin’s runCatching function, compares it with traditional try‑catch‑finally, demonstrates its usage with practical code examples, explains the Result type and its methods, and provides best‑practice guidelines for resource management and when to prefer runCatching over classic exception handling.

Exception HandlingKotlinfunctional programming
0 likes · 14 min read
Mastering Kotlin’s runCatching: A Cleaner Alternative to try‑catch
Java Backend Technology
Java Backend Technology
Jul 10, 2025 · Backend Development

Unlock Spring’s Power: Global Exception Handling, Custom Interceptors, and Thread‑Local Scopes

Explore Spring’s extensibility by mastering global exception handling with @RestControllerAdvice, creating custom MVC interceptors, accessing the container via BeanFactoryAware, importing configurations, adding startup logic, modifying BeanDefinitions, using initialization callbacks, and defining a thread‑local custom scope for per‑thread bean instances.

ApplicationRunnerBean LifecycleCustom Scope
0 likes · 10 min read
Unlock Spring’s Power: Global Exception Handling, Custom Interceptors, and Thread‑Local Scopes
Cognitive Technology Team
Cognitive Technology Team
Jul 8, 2025 · Backend Development

Why Your Spring @Transactional Doesn’t Rollback: AOP Aspect Order Conflict Explained

An in‑depth analysis of a Spring transaction failure caused by a custom AOP aspect interfering with the default TransactionInterceptor, detailing the symptom, root cause, and step‑by‑step solutions—including adjusting aspect order, rethrowing exceptions, and manual rollback—to ensure reliable transaction management.

AOPAspect PriorityException Handling
0 likes · 8 min read
Why Your Spring @Transactional Doesn’t Rollback: AOP Aspect Order Conflict Explained
Top Architect
Top Architect
Jul 2, 2025 · Backend Development

Quickly Bootstrap a Spring Boot Project and Dodge Version Compatibility Issues

This guide walks you through initializing a Spring Boot project, handling IDE setup frustrations, managing Spring Cloud and Kafka version compatibility, leveraging Maven for dependencies, implementing global exception handling, logging, CORS, and Swagger configurations, and recommends essential tools for efficient backend development.

Exception HandlingMavenSpring Boot
0 likes · 10 min read
Quickly Bootstrap a Spring Boot Project and Dodge Version Compatibility Issues
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 26, 2025 · Backend Development

Avoid Common Spring Boot Mistakes and Write Cleaner Backend Code

This article highlights common pitfalls in Spring Boot development—such as exposing sensitive data, neglecting records, field injection, using RestTemplate, bloated controllers, and poor exception handling—and provides concise, code‑driven solutions to write cleaner, more secure, and maintainable backend applications.

Best PracticesDTOException Handling
0 likes · 8 min read
Avoid Common Spring Boot Mistakes and Write Cleaner Backend Code
Java Captain
Java Captain
Jun 8, 2025 · Backend Development

How to Refactor Bloated Spring Controllers into Clean, Maintainable Code

The article critiques overly large and tangled Spring MVC controllers, demonstrates ugly examples filled with try‑catch blocks, field validations, and business logic, then presents streamlined, elegant alternatives using @Valid, @Autowired, proper exception handling, and best‑practice guidelines to dramatically reduce code size and improve readability.

Best PracticesController RefactoringException Handling
0 likes · 10 min read
How to Refactor Bloated Spring Controllers into Clean, Maintainable Code
macrozheng
macrozheng
Jun 6, 2025 · Backend Development

Master 10 Essential Spring Boot Extension Points for Robust Backend Development

This guide walks through ten crucial Spring Boot extension points—including global exception handling, custom interceptors, container access, configuration imports, startup runners, bean definition tweaks, initialization hooks, bean post‑processing, graceful shutdown, and custom scopes—providing clear explanations and ready‑to‑use code samples for building resilient backend services.

Bean LifecycleCustom ScopeException Handling
0 likes · 15 min read
Master 10 Essential Spring Boot Extension Points for Robust Backend Development
macrozheng
macrozheng
Jun 5, 2025 · Backend Development

How to Refactor Spring Boot Controllers for Cleaner, More Maintainable Code

This article compares messy and elegant Spring Boot controller implementations, demonstrates how to use @Valid for input validation, introduces a concise global exception handler, and provides practical refactoring steps and open‑source resources to dramatically reduce controller code size and improve maintainability.

@ValidControllerException Handling
0 likes · 10 min read
How to Refactor Spring Boot Controllers for Cleaner, More Maintainable Code
Top Architect
Top Architect
Jun 3, 2025 · Backend Development

Best Practices for Spring MVC Controller Design: Unified Response, Validation, and Exception Handling

This article explains how to design Spring MVC controllers with a unified response structure, implement request validation using JSR‑303 and custom annotations, handle exceptions uniformly, and resolve issues with ResponseBodyAdvice and HttpMessageConverters to improve code clarity and maintainability.

ControllerException HandlingJava
0 likes · 18 min read
Best Practices for Spring MVC Controller Design: Unified Response, Validation, and Exception Handling