BestHub
Sign in
Tagged articles

reflection

340 articles · Page 1 of 4
AI Large-Model Wave and Transformation Guide
AI Large-Model Wave and Transformation Guide
Aug 16, 2026 · Artificial Intelligence

Agent Core Capabilities: A Full Breakdown from Interview Question to Agent Architecture

The article explains that interviewers expect a detailed decomposition of an Agent's architecture, covering seven tightly linked capabilities—perception, planning, memory, tool use, action, reflection, and their closed‑loop cooperation—rather than a vague claim of merely calling a large model.

AI architectureAgentMemory
0 likes · 5 min read
Agent Core Capabilities: A Full Breakdown from Interview Question to Agent Architecture
Big Data and Microservices
Big Data and Microservices
Aug 9, 2026 · Artificial Intelligence

Four Core Design Patterns that Power AI Agents

The article explains why simply using a smarter model isn’t enough, showing that applying four fundamental AI‑agent design patterns—Reflection, Tool Use, Planning, and Multi‑Agent Collaboration—can raise GPT‑3.5’s HumanEval success from 48 % to over 95 %, and outlines how each pattern works, their trade‑offs, and practical implementation guidance.

AI AgentDesign PatternsMulti-agent
0 likes · 11 min read
Four Core Design Patterns that Power AI Agents
Open Source Tech Hub
Open Source Tech Hub
Jul 29, 2026 · Backend Development

Mastering PHP Attributes: Core Principles, Practical Use Cases, and Pitfall Guide

This article explains PHP 8 attributes as structured, machine‑readable metadata, compares them with PHPDoc and config files, shows how to define, register, and consume attributes via reflection, and provides best‑practice guidelines, repeatable attribute patterns, performance considerations, testing strategies, and when to avoid them.

PHPattributesbest practices
0 likes · 22 min read
Mastering PHP Attributes: Core Principles, Practical Use Cases, and Pitfall Guide
Top Architect
Top Architect
Jul 24, 2026 · Backend Development

Stop Manually Deploying JARs: Embrace Dynamic Hot Deployment

The article demonstrates how to let users upload a JAR that implements a given interface, then hot‑replace the implementation at runtime using either reflection or Spring annotation‑based loading, covering class loading, bean registration, and cleanup with concrete code examples.

Dynamic LoadingHot DeploymentJava
0 likes · 10 min read
Stop Manually Deploying JARs: Embrace Dynamic Hot Deployment
Big Data and Microservices
Big Data and Microservices
Jul 18, 2026 · Artificial Intelligence

Ensuring Reliable AI Agents: Reflection, Error‑Correction, and Guardrail Design

The article examines how to keep AI agents reliable by introducing reflection mechanisms that let agents learn from failures, multi‑layer guardrails that prevent runaway loops, and a governance framework with permission controls, budget limits, observability, and human‑in‑the‑loop checks, illustrated with concrete benchmarks and case studies.

AI AgentsGovernanceGuardrails
0 likes · 16 min read
Ensuring Reliable AI Agents: Reflection, Error‑Correction, and Guardrail Design
ThinkingAgent
ThinkingAgent
Jul 16, 2026 · Artificial Intelligence

Agent Framework: From Personal Assistants to Process Integration and Enterprise Intelligence

The article explains how AI agents differ from chatbots, outlines four core design patterns—Reflection, Tool Use, Planning, and Multi‑Agent Collaboration—draws on insights from DeepLearning.AI, Anthropic, Google Cloud, LangChain and Microsoft, and provides a step‑by‑step roadmap for evolving agents from personal assistants to enterprise‑wide intelligent systems.

AI AgentAgentic workflowEnterprise AI
0 likes · 28 min read
Agent Framework: From Personal Assistants to Process Integration and Enterprise Intelligence
samdeepthink
samdeepthink
Jul 15, 2026 · R&D Management

How to Practice Meaningful Reflection for Better Team Management

The author argues that genuine reflection goes beyond simple post‑mortems, requiring a deep examination of one’s thinking model and the creation of new action rules, illustrated by a personal case where re‑thinking task‑assignment shifted focus from short‑term efficiency to long‑term team capability.

Leadershipcontinuous improvementreflection
0 likes · 5 min read
How to Practice Meaningful Reflection for Better Team Management
Sohu Tech Products
Sohu Tech Products
Jun 24, 2026 · Artificial Intelligence

LLM Agent Design Patterns: From ReAct to Multi‑Agent Collaboration

This article systematically reviews major LLM agent design patterns—including ReAct, CodeAct, static and dynamic planning, reflection, and human‑in‑the‑loop—detailing their core loops, code structures, trade‑offs, and practical use‑cases, and provides a decision tree to help developers choose the most suitable pattern for their tasks.

AgentCodeActLLM
0 likes · 37 min read
LLM Agent Design Patterns: From ReAct to Multi‑Agent Collaboration
Golang Shines
Golang Shines
Jun 21, 2026 · Fundamentals

Go Founder Announces Generic Methods – What It Means for Your Code

The article recounts a developer’s struggle with missing generic methods in Go, explains the language team’s proposal to allow type‑parameterized methods while forbidding their use in interfaces, illustrates the feature with practical code examples, and discusses the remaining trade‑offs such as lack of reflection support.

Gogeneric methodsgenerics
0 likes · 13 min read
Go Founder Announces Generic Methods – What It Means for Your Code
Golang Shines
Golang Shines
Jun 16, 2026 · Fundamentals

Understanding Three Key Features of Go Interfaces

The article explains Go's static typing, shows how interface types are method sets—including the empty interface—demonstrates type assertions, and walks through using the reflect package to inspect and modify values, highlighting settable constraints and struct field updates.

Goempty interfaceinterfaces
0 likes · 15 min read
Understanding Three Key Features of Go Interfaces
Golang Shines
Golang Shines
Jun 10, 2026 · Fundamentals

Master Go’s reflect Package in One Minute

This article walks beginners through Go's reflect package, covering the core functions TypeOf and ValueOf, the reflect.Kind constants, a step‑by‑step parsing flow, concrete handling of structs, maps, slices, pointers, primitive types, and the full set of Type and Value methods.

GoTypeOfValueOf
0 likes · 9 min read
Master Go’s reflect Package in One Minute
AI Engineer Programming
AI Engineer Programming
May 17, 2026 · Artificial Intelligence

ReAct, Plan‑Execute, and Reflection: How Continuous Loops Make Agent Architecture Crucial

While a single LLM call is a stateless function, real‑world tasks require dynamic information gathering, hypothesis testing, and iterative refinement, so agents must operate in a continuous loop; the article analyzes core patterns such as ReAct, Plan‑Execute, Reflection, Multi‑Agent and HITL, highlighting state management, cost, debugging, and observability challenges.

LLMMulti-agentObservability
0 likes · 21 min read
ReAct, Plan‑Execute, and Reflection: How Continuous Loops Make Agent Architecture Crucial
AI Engineer Programming
AI Engineer Programming
May 13, 2026 · Artificial Intelligence

AI Agent Architecture Patterns: How to Choose the Right Solution for Your Workload

The article analyzes how AI agent architecture choices—single‑agent versus multi‑agent, ReAct, plan‑and‑execute, orchestrator‑worker, hierarchical teams, reflection, and HITL—affect cost, reliability, and scalability, providing quantitative trade‑offs and industry examples to guide workload‑specific selection.

AI AgentsLangGraphMulti-agent
0 likes · 16 min read
AI Agent Architecture Patterns: How to Choose the Right Solution for Your Workload
IT Services Circle
IT Services Circle
May 11, 2026 · Artificial Intelligence

Can Claude’s Code Generation Replace Agent Memory Systems? Understanding CLAUDE.md, Memory, and RAG

The article explains why large language model agents need dedicated memory systems to overcome limited context windows, outlines short‑term and long‑term memory architectures, storage forms, functional categories, lifecycle operations, control‑policy research, compares leading products, and presents best‑practice engineering guidelines for building scalable, privacy‑aware agent memory pipelines.

Control PolicyLong-Term MemoryRAG
0 likes · 25 min read
Can Claude’s Code Generation Replace Agent Memory Systems? Understanding CLAUDE.md, Memory, and RAG
Java Tech Workshop
Java Tech Workshop
May 5, 2026 · Backend Development

Java Reflection: Powerful Magic or Dangerous Black Art?

The article explains Java’s reflection mechanism, showing how it lets code inspect and manipulate classes at runtime—enabling frameworks like Spring and MyBatis—while warning about performance overhead, security risks, and maintenance challenges, and offers best‑practice guidelines to use it safely.

FrameworksJavabest practices
0 likes · 14 min read
Java Reflection: Powerful Magic or Dangerous Black Art?
Java Tech Workshop
Java Tech Workshop
May 3, 2026 · Backend Development

Mastering Java Annotations: From Basic Usage to Custom Annotation Processors

This article explains the fundamentals of Java annotations, their core purposes, built‑in annotations, meta‑annotations, and provides step‑by‑step practical examples for creating a runtime @Sensitive annotation and a compile‑time @AutoGetter processor, while also dissecting how Spring leverages annotations for component scanning, dependency injection, and request mapping.

Annotation ProcessorJavaMeta‑annotations
0 likes · 27 min read
Mastering Java Annotations: From Basic Usage to Custom Annotation Processors
Big Data and Microservices
Big Data and Microservices
Apr 27, 2026 · Artificial Intelligence

How ReAct and Reflection Help AI Agents Avoid Repeating the Same Mistake

Most AI agents still fall into the same errors because they lack experience; the article explains how the ReAct loop gives step‑by‑step reasoning and observable actions, while Reflection adds a post‑task self‑review that stores concrete lessons in long‑term memory, and discusses the benefits and pitfalls of combining the two.

AI AgentsLLMReAct
0 likes · 12 min read
How ReAct and Reflection Help AI Agents Avoid Repeating the Same Mistake
Linyb Geek Road
Linyb Geek Road
Apr 22, 2026 · Artificial Intelligence

How to Design an Effective Memory Module for LLM Agents?

The article analyzes why memory is essential for practical LLM agents, categorizes four memory types, proposes a perception‑judgment‑refinement‑storage pipeline, introduces a three‑dimensional retrieval scoring model, and outlines a three‑layer architecture with reflection, merging, and forgetting mechanisms.

AgentLLMMemory Design
0 likes · 15 min read
How to Design an Effective Memory Module for LLM Agents?
Java Architect Essentials
Java Architect Essentials
Apr 11, 2026 · Backend Development

Why Java Reflection Slows You Down and How Dynamic Proxies Can Speed It Up 8×

This article analyzes why Java reflection incurs high latency due to repeated method lookups and security checks, presents benchmark data showing up to 500‑fold slowdown, and demonstrates how caching Method objects with JDK dynamic proxies can reduce overhead by up to eight times while offering practical code examples and usage tips.

Dynamic ProxyJDKbackend
0 likes · 6 min read
Why Java Reflection Slows You Down and How Dynamic Proxies Can Speed It Up 8×
AgentGuide
AgentGuide
Apr 7, 2026 · Artificial Intelligence

How Do Agents Reflect? From Self‑Feedback to External Tool Validation

The article explains how LLM‑based agents implement reflection by first generating output, then evaluating it either through self‑feedback or by invoking external tools, and finally correcting the result, detailing two self‑feedback methods and typical external‑feedback scenarios.

AgentLLMPrompt Engineering
0 likes · 5 min read
How Do Agents Reflect? From Self‑Feedback to External Tool Validation
Qborfy AI
Qborfy AI
Mar 29, 2026 · Artificial Intelligence

Mastering AI Agent Reflection: The Generate‑Reflect‑Refine Loop

This article explains the Reflection design pattern for AI agents, detailing how a three‑step generate‑reflect‑refine cycle can iteratively improve outputs, provides both a simple two‑call implementation and a structured class‑based version, and shares practical tips, benchmarks, and references to the original research.

AI AgentsLLMPrompt Engineering
0 likes · 9 min read
Mastering AI Agent Reflection: The Generate‑Reflect‑Refine Loop
Golang Shines
Golang Shines
Mar 26, 2026 · Artificial Intelligence

Essential AI Agent Design Patterns and Frameworks for Operations: Do You Know Them?

The article explains seven multi‑agent design patterns—workflow, routing, parallel, loop, aggregation, network, and hierarchy—detailing their mechanisms, use‑cases, and trade‑offs, then surveys popular agent frameworks (AutoGPT, Dify, AutoGen, CrewAI, LangGraph) and why they are needed for complex, dynamic decision‑making tasks.

AI AgentDesign PatternsMulti-agent
0 likes · 12 min read
Essential AI Agent Design Patterns and Frameworks for Operations: Do You Know Them?
Architect's Guide
Architect's Guide
Mar 17, 2026 · Backend Development

Why Lombok’s Getter/Setter Naming Breaks MyBatis Inserts and How to Fix It

This article explains how Lombok’s generation of getter/setter methods for fields whose second character is uppercase can cause MyBatis to map properties incorrectly, leading to null values, and also examines why the @Accessor(chain=true) annotation breaks EasyExcel’s reflection, offering concrete solutions for each case.

EasyExcelGetterSetterLombok
0 likes · 9 min read
Why Lombok’s Getter/Setter Naming Breaks MyBatis Inserts and How to Fix It
BirdNest Tech Talk
BirdNest Tech Talk
Feb 11, 2026 · Artificial Intelligence

How GoClaw Reimagines OpenClaw: A Go‑Powered AI Assistant Architecture

This article provides an in‑depth technical analysis of GoClaw, a Go‑based personal AI assistant that mirrors OpenClaw's design while introducing a more robust agent loop, reflective reasoning, extensible skill system, sophisticated error handling, and multi‑provider failover, complete with code excerpts, architecture diagrams, and performance trade‑offs.

AI assistantAgent LoopGo
0 likes · 19 min read
How GoClaw Reimagines OpenClaw: A Go‑Powered AI Assistant Architecture
java1234
java1234
Feb 10, 2026 · Fundamentals

Understanding Java Reflection: Core Concepts, Use Cases, and Trade‑offs

This article explains Java's reflection mechanism, covering its main uses such as dynamic class loading, handling unknown types, accessing private members, and framework development, then walks through basic steps, a complete code example, and discusses its advantages and drawbacks.

Dynamic LoadingFrameworksJava
0 likes · 6 min read
Understanding Java Reflection: Core Concepts, Use Cases, and Trade‑offs
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Feb 3, 2026 · Backend Development

Master Java Reflection with the Reflector Library: Real‑World Examples

This article introduces the Reflector library—a comprehensive Java reflection utility—covers its core features, shows how to download it from GitHub, and provides step‑by‑step code examples for accessing private fields, invoking methods, creating instances, handling annotations, copying objects, and more, all with expected output.

Code ExampleJavaReflector
0 likes · 9 min read
Master Java Reflection with the Reflector Library: Real‑World Examples
Code Wrench
Code Wrench
Jan 30, 2026 · Fundamentals

Master Go Reflection: Harness the Power and Avoid the Pitfalls

This article explains Go's reflection mechanism, presents Rob Pike's three core rules, shows practical code examples, highlights performance and safety trade‑offs, and provides concrete best‑practice guidelines to help developers decide when and how to use reflection safely.

DebuggingGobest practices
0 likes · 16 min read
Master Go Reflection: Harness the Power and Avoid the Pitfalls
java1234
java1234
Jan 9, 2026 · Backend Development

Stop Manually Deploying JARs—Dynamic Hot Deployment Made Easy

This article shows how to let users upload a JAR that implements a predefined interface, then hot‑deploy the new implementation at runtime using either Spring annotation‑based registration or plain reflection, including bean registration, removal, and a test harness.

Bean RegistrationDynamic JAR LoadingHot Deployment
0 likes · 8 min read
Stop Manually Deploying JARs—Dynamic Hot Deployment Made Easy
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 10, 2025 · Backend Development

Mastering Java MethodHandle: From Lookup to Performance Benchmarks

This article provides a comprehensive guide to Java MethodHandle, covering its differences from reflection, step‑by‑step creation (Lookup, MethodType, finding handles, invocation), advanced techniques like binding and dropping arguments, array spreading, and a JMH performance comparison with reflection, all demonstrated in a Spring Boot 3.4.2 environment.

JMHJavaMethodHandle
0 likes · 10 min read
Mastering Java MethodHandle: From Lookup to Performance Benchmarks
ITPUB
ITPUB
Nov 27, 2025 · Backend Development

Can Renaming Java Fields Really Boost Performance by 37%? A Deep Dive

A popular claim that changing a Java field name from "userName" to "usrNme" can cut API latency by dozens of milliseconds is examined, revealing why hashCode calculations, reflection, and caching have negligible impact compared to real bottlenecks like I/O, GC, and thread scheduling.

JavaSpringBoothashCode
0 likes · 5 min read
Can Renaming Java Fields Really Boost Performance by 37%? A Deep Dive
JavaGuide
JavaGuide
Nov 27, 2025 · Backend Development

Xiaomi Java Interview Insights: Reflection, Dynamic Proxies, Redis & JWT

The article starts by highlighting Xiaomi's competitive software developer salaries, then provides a detailed Java interview guide covering reflection fundamentals, static vs dynamic proxies, SPI vs API, synchronization behavior, Redis caching strategies, and JWT authentication, complete with code examples and practical comparisons.

Dynamic ProxyJWTJava
0 likes · 25 min read
Xiaomi Java Interview Insights: Reflection, Dynamic Proxies, Redis & JWT
IT Services Circle
IT Services Circle
Nov 24, 2025 · Backend Development

Do Short, Random Field Names Really Speed Up Java? A Deep Dive

A skeptical look at the claim that renaming Java fields to shorter, random names can dramatically improve API latency, examining benchmark data, the actual cost of String.hashCode, reflection mechanics, and the real factors that affect backend performance.

Javabackend developmenthashCode
0 likes · 5 min read
Do Short, Random Field Names Really Speed Up Java? A Deep Dive
macrozheng
macrozheng
Nov 21, 2025 · Backend Development

Master Java Concurrency: Locks, Singleton Patterns, ThreadLocal, Reflection and More

This article provides a comprehensive guide to Java concurrency and related concepts, covering synchronized lock upgrades, object vs class locks, lazy and double‑checked singleton implementations, ThreadLocal mechanics, reflection usage, annotation scopes, JVM class loading, and Redis cluster threading behavior.

JVMJavaRedis
0 likes · 22 min read
Master Java Concurrency: Locks, Singleton Patterns, ThreadLocal, Reflection and More
Data Party THU
Data Party THU
Nov 5, 2025 · Artificial Intelligence

How to Give LLM Agents Memory, Reflection, and Goal Tracking

This article explains why current LLM agents lose context after each conversation and presents a practical architecture—using SQLite for structured storage, a vector database for semantic retrieval, and LLM‑driven reflection—to add persistent memory, self‑evaluation, and goal‑tracking capabilities that turn agents into learning partners.

Goal TrackingLLMMemory
0 likes · 10 min read
How to Give LLM Agents Memory, Reflection, and Goal Tracking
IT Services Circle
IT Services Circle
Oct 31, 2025 · Backend Development

Master Java Concurrency, Singleton, ThreadLocal, and Reflection for Interviews

This guide covers essential Java interview topics—including synchronized lock upgrades, object vs class locking, lazy and double‑checked singleton patterns, ThreadLocal mechanics, reflection usage, annotation scopes, Redis cluster behavior, and a linear‑time algorithm challenge—providing clear explanations, code examples, and practical insights for developers preparing for technical interviews.

JavaThreadLocalconcurrency
0 likes · 20 min read
Master Java Concurrency, Singleton, ThreadLocal, and Reflection for Interviews
Ubiquitous Tech
Ubiquitous Tech
Oct 17, 2025 · Artificial Intelligence

6 Essential AI Agent Design Patterns for Efficient Workflows

This article presents six practical AI Agent design patterns—chain, parallel, routing, coordinator‑executor, generator‑evaluator (reflection), and tool‑use—explaining their concepts, typical use cases, and workflow diagrams, and shows how they improve reliability, maintainability, and performance of LLM‑driven applications.

AI AgentDesign PatternsLLM
0 likes · 20 min read
6 Essential AI Agent Design Patterns for Efficient Workflows
JakartaEE China Community
JakartaEE China Community
Oct 14, 2025 · Fundamentals

What Changed in Java 21? A Complete API Comparison for Upgrading from Java 17

This article provides a detailed comparison of Java 17 and Java 21 APIs, listing deprecated and removed features, suggested replacements, new I/O and serialization capabilities, enhanced reflection, Unicode emoji support, the preview foreign memory API, and the Generational ZGC, illustrated with real‑world code examples and usage scenarios.

API changesGarbage CollectionJava
0 likes · 15 min read
What Changed in Java 21? A Complete API Comparison for Upgrading from Java 17
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 18, 2025 · Backend Development

Master Java Reflection: 5 Essential Techniques for Dynamic Code

This article explains Java reflection—a powerful feature used by frameworks like Spring and MyBatis—covering its core concepts and demonstrating five practical ways to invoke methods, access fields, handle static and private methods, and work with superclass methods using concise code examples.

Dynamic InvocationJavabackend development
0 likes · 4 min read
Master Java Reflection: 5 Essential Techniques for Dynamic Code
Architect's Tech Stack
Architect's Tech Stack
Sep 18, 2025 · Backend Development

Master Java Spring Utilities: Assertions, Collections, IO & Reflection

This article compiles essential Spring and Java utility methods—including assertion checks, object and collection handling, file I/O, resource management, and reflection/AOP tools—providing concise code examples and usage guidelines to help developers avoid redundant code and write cleaner, more reliable applications.

CollectionsIOJava
0 likes · 13 min read
Master Java Spring Utilities: Assertions, Collections, IO & Reflection
Code Wrench
Code Wrench
Sep 11, 2025 · Fundamentals

Mastering Go Reflection: Principles, Pitfalls, and a Practical DI Container

This article thoroughly explains Go's reflection mechanism, showcases typical scenarios such as function calls, ORM mapping, and dependency injection, highlights common pitfalls and performance concerns, and provides optimization tips along with a concrete lightweight DI container example.

GoORMbest practices
0 likes · 6 min read
Mastering Go Reflection: Principles, Pitfalls, and a Practical DI Container
Java Web Project
Java Web Project
Aug 26, 2025 · Backend Development

How to Hot‑Deploy User‑Provided JAR Implementations in a Spring‑Based System

This article walks through building a simple Calculator interface, creating a dual‑mode implementation, and then dynamically loading, registering, and unloading user‑supplied JAR files at runtime using reflection or Spring annotation processing, complete with utility methods and a test harness.

Dynamic Bean RegistrationHot DeploymentJAR Loading
0 likes · 9 min read
How to Hot‑Deploy User‑Provided JAR Implementations in a Spring‑Based System
Architect's Guide
Architect's Guide
Aug 23, 2025 · Backend Development

Eliminate Repetitive Java Code: Design Patterns, Annotations & Mapping Tricks

This article explains why duplicate code harms maintainability and demonstrates three practical techniques—factory/template method patterns, annotation‑driven reflection, and bean‑mapping utilities—to refactor Java backend services and dramatically reduce redundant implementations.

Code RefactoringDesign PatternsJava
0 likes · 23 min read
Eliminate Repetitive Java Code: Design Patterns, Annotations & Mapping Tricks
Architect's Tech Stack
Architect's Tech Stack
Jul 24, 2025 · Backend Development

Why Is Reflection So Much Slower Than new? Java Object Creation Benchmarks

This article explains the fundamental differences between using the new operator and Java reflection to instantiate objects, presents a performance benchmark showing reflection’s significant overhead, analyzes the underlying reasons, and outlines practical scenarios where each approach is appropriate.

Object Creationbenchmarkperformance
0 likes · 5 min read
Why Is Reflection So Much Slower Than new? Java Object Creation Benchmarks
Su San Talks Tech
Su San Talks Tech
Jul 21, 2025 · Backend Development

How to Hot‑Deploy User‑Provided JARs with Spring and Reflection

This guide explains how to let users upload a JAR that implements a predefined interface, then hot‑deploy the new implementation at runtime using either Spring annotation‑based bean registration or pure Java reflection, complete with utility methods for loading, registering, and cleaning up beans.

Dynamic LoadingHot DeploymentJava
0 likes · 9 min read
How to Hot‑Deploy User‑Provided JARs with Spring and Reflection
Architect
Architect
Jul 18, 2025 · Backend Development

How to Implement Hot Deployment of Custom Java Interfaces with Spring and Reflection

This article explains how to let users upload a JAR containing a custom implementation of a predefined Java interface, then hot‑deploy the new implementation using either Spring annotation‑based injection or pure reflection, covering interface definition, bean registration, and cleanup.

Dynamic LoadingHot DeploymentJava
0 likes · 8 min read
How to Implement Hot Deployment of Custom Java Interfaces with Spring and Reflection
Code Ape Tech Column
Code Ape Tech Column
Jul 9, 2025 · Backend Development

Hot‑Deploy Custom Java Interfaces with JARs Using Spring and Reflection

This tutorial demonstrates how to let users upload a JAR that implements a predefined Java interface, then hot‑replace the implementation at runtime via reflection or Spring bean registration, covering interface definition, concrete classes, dynamic class loading, bean management, and testing.

Dynamic LoadingHot DeploymentSpring
0 likes · 9 min read
Hot‑Deploy Custom Java Interfaces with JARs Using Spring and Reflection
Java Web Project
Java Web Project
Jul 5, 2025 · Backend Development

How to Hot‑Deploy User‑Provided JAR Implementations with Spring and Reflection

This article walks through building a Java interface, providing two implementation styles (Spring‑managed and pure‑reflection), loading user‑uploaded JARs at runtime, dynamically registering or removing beans in the Spring container, and testing the whole hot‑deployment cycle with concrete code examples.

Dynamic LoadingHot DeploymentJava
0 likes · 9 min read
How to Hot‑Deploy User‑Provided JAR Implementations with Spring and Reflection
Programmer1970
Programmer1970
Jun 30, 2025 · Fundamentals

How Do Java Annotations Work Inside the JVM? From Compile‑time to Runtime Proxies

The article explains the complete lifecycle of Java annotations, covering how the compiler represents them in the AST, how retention policies affect bytecode generation, how the JVM parses annotation attributes during class loading, and how dynamic proxy objects are created and used at runtime, with concrete Spring framework examples.

Dynamic ProxyJVMJava
0 likes · 12 min read
How Do Java Annotations Work Inside the JVM? From Compile‑time to Runtime Proxies
Architect's Guide
Architect's Guide
Jun 19, 2025 · Mobile Development

Master Android Hooking: From API Hook to Xposed Framework

This article explains the concept of Hook in Android, demonstrates how to intercept View OnClickListener and startActivity using Java reflection and instrumentation, and introduces the Xposed framework for system‑wide method hooking, providing step‑by‑step code examples and practical deployment tips.

API HookAndroidInstrumentation
0 likes · 13 min read
Master Android Hooking: From API Hook to Xposed Framework
macrozheng
macrozheng
Jun 16, 2025 · Backend Development

Hot‑Deploying User‑Defined Interfaces in Spring Boot: Reflection vs Annotation

This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (annotation‑managed and reflection‑based), and achieve hot deployment of user‑supplied JARs in a Spring Boot application, including loading, registering, and removing beans dynamically.

Hot DeploymentJavaSpring Boot
0 likes · 9 min read
Hot‑Deploying User‑Defined Interfaces in Spring Boot: Reflection vs Annotation
Cognitive Technology Team
Cognitive Technology Team
May 14, 2025 · Fundamentals

How to Instantiate Java Objects Without Constructors Using Objenesis

This tutorial explains how Objenesis enables Java objects to be instantiated without invoking constructors, covering traditional object creation, the library’s internal mechanisms, Maven setup, usage examples with ObjenesisStd, ObjenesisSerializer, and ObjenesisHelper, advanced scenarios, best practices, and considerations for safe adoption.

JavaObject InstantiationObjenesis
0 likes · 9 min read
How to Instantiate Java Objects Without Constructors Using Objenesis
Java Captain
Java Captain
Apr 21, 2025 · Backend Development

Understanding Java Annotations and Reflection: Built‑in Annotations, Meta‑annotations, Custom Annotations, Class Loading and Runtime Reflection

This article explains Java annotations—including built‑in, meta‑ and custom annotations—covers how they are used in Spring, describes the Java reflection mechanism, class loading process, ways to obtain Class objects, and demonstrates retrieving generic and annotation information at runtime with code examples.

ClassLoaderJavaMeta-Annotation
0 likes · 15 min read
Understanding Java Annotations and Reflection: Built‑in Annotations, Meta‑annotations, Custom Annotations, Class Loading and Runtime Reflection
Top Architect
Top Architect
Apr 9, 2025 · Backend Development

Spring Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AOP Utilities

This article provides a comprehensive guide to Spring's built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AopUtils—showing their purpose, typical usage patterns, and example method signatures for developers working on Java backend projects.

AOPJavaSpring
0 likes · 17 min read
Spring Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AOP Utilities
Java Tech Enthusiast
Java Tech Enthusiast
Apr 2, 2025 · Backend Development

Java Object Creation: New vs Reflection Efficiency Comparison

The article compares Java object creation using the 'new' operator versus reflection, showing through timed code examples that reflection incurs a substantial overhead—approximately thirty times slower for 100 million instances—due to dynamic type resolution and limited JIT optimization, while also outlining typical reflection use cases such as Spring IoC and JDBC driver loading.

JavaObject Creationbackend development
0 likes · 4 min read
Java Object Creation: New vs Reflection Efficiency Comparison
AI Code to Success
AI Code to Success
Mar 6, 2025 · Artificial Intelligence

Inside the Brain Module: How AI Agents Process, Remember, and Decide

This article provides a comprehensive analysis of the Brain module in AI agents, covering its multi‑step workflow, knowledge integration, memory mechanisms, intent recognition, planning strategies, reasoning techniques, and the role of reflection and emotion in enhancing adaptability and robustness.

Brain moduleChain-of-ThoughtEmotion simulation
0 likes · 17 min read
Inside the Brain Module: How AI Agents Process, Remember, and Decide
FunTester
FunTester
Mar 5, 2025 · Backend Development

Calling Third‑Party Java Methods with Byteman in Chaos Mesh

This article demonstrates how to use Byteman’s DO execution module on the Chaos Mesh platform to invoke static or instance methods of external Java classes without modifying the original code, covering reflection, ClassLoader tricks, and a complete BTM rule example.

BytemanChaos MeshClassLoader
0 likes · 7 min read
Calling Third‑Party Java Methods with Byteman in Chaos Mesh
Fun with Large Models
Fun with Large Models
Mar 2, 2025 · Artificial Intelligence

Why 2025 Is the Year of AI Agents: Definitions, Types, and Real‑World Examples

The article explains what AI Agents are, how they differ from single large‑model systems, outlines four agent architectures—Reflection, Tool Use, Planning, and Multi‑Agent—and cites concrete examples from Grammarly, VS Code plugins, Image Describer X, ChatDev, as well as initiatives by Tencent and Google, highlighting the 2025 AI Agent boom.

ChatDevMulti-agentplanning
0 likes · 9 min read
Why 2025 Is the Year of AI Agents: Definitions, Types, and Real‑World Examples
FunTester
FunTester
Feb 21, 2025 · Backend Development

FastClasspathScanner: High-Performance Java Classpath Scanning Library Overview

FastClasspathScanner (formerly ClassGraph) is a high-performance Java library that dramatically speeds up classpath scanning by using multithreaded processing, smart caching, and efficient handling of complex hierarchies, making reflection-heavy frameworks, plugin systems, web applications, and code-analysis tools faster and more memory-efficient.

Classpath ScanningFastClasspathScannerJava
0 likes · 9 min read
FastClasspathScanner: High-Performance Java Classpath Scanning Library Overview
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Feb 4, 2025 · Backend Development

When to Use Class.forName vs. ClassLoader in Java? A Deep Dive

This article explains Java's reflection mechanisms, comparing Class.forName and ClassLoader as two primary ways to load classes, detailing their behavior, static initialization effects, code examples, and practical scenarios such as loading JDBC drivers versus custom dynamic loading.

Class.forNameClassLoaderDynamic Loading
0 likes · 6 min read
When to Use Class.forName vs. ClassLoader in Java? A Deep Dive
Ubiquitous Tech
Ubiquitous Tech
Feb 3, 2025 · Backend Development

Boost Java Development Efficiency with Equator’s Automatic Object Comparison

This article walks through the pain points of manually logging Java object changes, introduces the open‑source Equator library, explains its field‑ and getter‑based comparison strategies, shows how to integrate it via Maven, and demonstrates clean change‑log output with flexible field filtering and deep‑structure support.

EquatorJavaMaven
0 likes · 8 min read
Boost Java Development Efficiency with Equator’s Automatic Object Comparison
DataFunTalk
DataFunTalk
Jan 27, 2025 · Artificial Intelligence

Improving AI Agent Planning and Reasoning: Challenges and Practical Solutions

The article examines current limitations of AI agents in planning and complex reasoning, critiques existing methods like COT/TOT and ReAct, and proposes practical strategies—including combined COT‑Reflection approaches, structured memory algorithms, and white‑box interaction designs—to enhance agent performance within the DataFun knowledge map framework.

AI AgentCoTdata modeling
0 likes · 3 min read
Improving AI Agent Planning and Reasoning: Challenges and Practical Solutions
macrozheng
macrozheng
Jan 24, 2025 · Backend Development

How to Hot‑Deploy Custom Java Interfaces with Spring Boot and Reflection

This guide demonstrates how to enable hot deployment of user‑provided Java interface implementations in a Spring Boot application, covering both annotation‑based and reflection‑based approaches, jar uploading, dynamic bean registration, class loading, and cleanup, with complete code examples.

Dynamic Bean RegistrationHot DeploymentSpring Boot
0 likes · 8 min read
How to Hot‑Deploy Custom Java Interfaces with Spring Boot and Reflection
Radish, Keep Going!
Radish, Keep Going!
Jan 20, 2025 · Fundamentals

Boost Go Performance: When to Use Reflection and How to Optimize It

This article explains Go's reflect package, shows how reflection can simplify configuration loading, benchmarks the performance cost of reflection versus direct field access, and provides practical tips such as avoiding reflection in hot paths and using indexed field access with caching to dramatically improve speed.

GoOptimizationbenchmark
0 likes · 10 min read
Boost Go Performance: When to Use Reflection and How to Optimize It
ITPUB
ITPUB
Jan 19, 2025 · Backend Development

Why Java Reflection Slows Down Your Apps and How to Speed It Up

This article examines Java reflection's advantages and drawbacks, analyzes its core API methods, benchmarks its performance against regular calls, explains why it is slower, and demonstrates how using Hutool's ReflectUtil can dramatically improve execution speed.

HutoolJavaOptimization
0 likes · 8 min read
Why Java Reflection Slows Down Your Apps and How to Speed It Up
Raymond Ops
Raymond Ops
Jan 17, 2025 · Fundamentals

Unlocking Go’s Type System: From Basic Types to Reflection

This article explains Go’s static type system, introduces custom types and interface types, demonstrates how empty interfaces work, and shows how the reflect package can inspect and modify values at runtime, including struct fields, using concrete code examples.

interfacesprogrammingreflection
0 likes · 13 min read
Unlocking Go’s Type System: From Basic Types to Reflection
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 29, 2024 · Backend Development

Deep Dive into Spring's @Autowired Annotation: Implementation and Injection Mechanism

This article provides a comprehensive analysis of Spring's @Autowired annotation, explaining its purpose, usage in constructor, field, and method injection, and detailing the underlying bean post‑processor logic, dependency resolution, and candidate selection that enable automatic dependency injection.

AutowiredBeanPostProcessorJava
0 likes · 10 min read
Deep Dive into Spring's @Autowired Annotation: Implementation and Injection Mechanism
Top Architect
Top Architect
Nov 18, 2024 · Backend Development

Comprehensive Guide to Spring Framework Utility Classes and Their Usage

This article presents a detailed overview of Spring's utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—provides code examples for each, and also contains promotional information about ChatGPT services and a developer community.

AOPJavaSpring
0 likes · 18 min read
Comprehensive Guide to Spring Framework Utility Classes and Their Usage
21CTO
21CTO
Nov 17, 2024 · Fundamentals

Why C++26 Is the Most Transformative Update Since C++11

Herb Sutter, ISO C++ chair and former Microsoft veteran, announced at CppCon that the upcoming C++26 standard will introduce four major features—enhanced std::execution, stronger type and memory safety, powerful reflection and code generation, and contracts—aimed at boosting concurrency, safety, and compile‑time programming.

C++C++26Contracts
0 likes · 5 min read
Why C++26 Is the Most Transformative Update Since C++11
Java Tech Enthusiast
Java Tech Enthusiast
Nov 15, 2024 · Fundamentals

C++26 Reflections, Safety, and Emerging Security Guidelines

After 22 years at Microsoft, Herb Sutter departs for Citadel while staying ISO C++ chair, declaring 2024 pivotal as C++26 introduces reflection‑driven compile‑time libraries and default safety—potentially the most impactful release since C++11—while U.S. CISA and the FBI urge memory‑unsafe language users to publish safety roadmaps by January 2026.

C++C++26Safety
0 likes · 6 min read
C++26 Reflections, Safety, and Emerging Security Guidelines
DeWu Technology
DeWu Technology
Nov 11, 2024 · Backend Development

Precise Testing Platform: Architecture, Recommendation Engine, and Graph Database Implementation

The Precise Testing Platform combines a recommendation engine—featuring a link analyzer, diff analyzer, and knowledge base—to automatically construct detailed method‑call graphs from source code, extract HTTP and Dubbo APIs, handle reflections and inheritance, and store billions of nodes in Nebula Graph, thereby eliminating blind, missed, and redundant tests while boosting coverage and reducing testing costs.

ASTGraph DatabaseJava
0 likes · 54 min read
Precise Testing Platform: Architecture, Recommendation Engine, and Graph Database Implementation
Top Architect
Top Architect
Nov 5, 2024 · Backend Development

Spring Boot Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AopUtils

This article introduces a comprehensive set of Spring Boot utility classes—including assertion helpers, object and string utilities, collection operations, file and resource handling, reflection tools, and AOP utilities—providing code examples and usage guidelines for Java backend development.

File I/OJavaSpring Boot
0 likes · 16 min read
Spring Boot Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AopUtils
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 4, 2024 · Backend Development

Unveiling FastJSON 2.0.31: A Deep Dive into Its Serialization Mechanics

This article provides a comprehensive walkthrough of FastJSON 2.0.31's serialization and deserialization process, covering its core architecture, step‑by‑step execution flow, common pitfalls such as getter misuse and circular references, and practical guidance on annotations and SerializerFeature options.

ASMJavaannotations
0 likes · 20 min read
Unveiling FastJSON 2.0.31: A Deep Dive into Its Serialization Mechanics
Top Architect
Top Architect
Oct 17, 2024 · Backend Development

Spring Utility Classes Overview: Assertions, ObjectUtils, CollectionUtils, File/IO, and Reflection/AOP

This article, written by a senior architect, reviews Spring’s built‑in utility classes—including assertions, object and collection helpers, file/IO operations, and reflection/AOP tools—providing code snippets and usage notes to help developers replace redundant custom utilities and improve backend Java code quality.

JavaSpringUtility
0 likes · 15 min read
Spring Utility Classes Overview: Assertions, ObjectUtils, CollectionUtils, File/IO, and Reflection/AOP
ITPUB
ITPUB
Oct 13, 2024 · Backend Development

Why Does 1000==1000 Return False but 100==100 Return True in Java?

This article explains why the == operator yields false when comparing two Integer objects with the value 1000 but true for the value 100, covering Java's reference comparison, the IntegerCache mechanism, its performance rationale, and a reflective hack that can even make 2+2 equal 5.

IntegerJavaReference Equality
0 likes · 7 min read
Why Does 1000==1000 Return False but 100==100 Return True in Java?
macrozheng
macrozheng
Sep 24, 2024 · Backend Development

Master SpringBoot’s Built‑in Utility Classes: Assertions, Collections, IO, and More

This article provides a concise guide to SpringBoot’s built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, key methods, and offering ready‑to‑use code examples to boost development efficiency.

IOJavaSpringBoot
0 likes · 14 min read
Master SpringBoot’s Built‑in Utility Classes: Assertions, Collections, IO, and More
Top Architect
Top Architect
Sep 15, 2024 · Backend Development

Overview of Common Spring Utility Classes

This article presents a comprehensive collection of frequently used Spring framework utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AopUtils—explaining their purpose, typical use cases, and providing code snippets for each method to help developers avoid redundant implementations.

AOPJavaSpring
0 likes · 18 min read
Overview of Common Spring Utility Classes
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 10, 2024 · Fundamentals

Deep Dive into Guava: A Powerful Toolkit for Java Developers

This article provides a comprehensive guide to Google Guava, covering its core modules such as collections, concurrency, string utilities, I/O, caching, event bus, functional programming, reflection, and best‑practice code examples that demonstrate how to simplify and strengthen Java development.

CacheCollectionsEventBus
0 likes · 31 min read
Deep Dive into Guava: A Powerful Toolkit for Java Developers