This article explains Go's static type system, how types and interfaces work, the role of the empty interface, and demonstrates using the reflect package to inspect and modify values, including structs, with practical code examples and type assertions.
The article explains why Go does not support traditional monkey patching, then demonstrates two practical approaches—using interfaces with wrapper types and employing reflection—to extend a SimpleLogger with log levels without modifying its source, while discussing trade‑offs such as readability and performance.
This article explains what Java annotations are, their underlying nature as interfaces extending Annotation, the various meta‑annotations such as @Retention and @Target, how retention policies affect availability, and demonstrates how to parse SOURCE‑retention annotations using a custom AbstractProcessor with complete code examples.
This article explains Java's reflection mechanism, detailing its core concepts, how it works at runtime, common application scenarios such as framework design, plugin systems, and dynamic proxies, and highlights important performance, security, and maintainability considerations.
This article explains Go's powerful reflection feature, walks through importing the reflect package, outlines the step‑by‑step process to obtain Type and Value objects, and provides complete code examples that read, modify, and display struct fields while noting performance considerations.
The article details a high‑performance, high‑stability Android code‑coverage technique that creates a surrogate ClassLoader, copies the target PathClassLoader’s private classTable pointer, and invokes findLoadedClass on this loader to query a class’s load state without triggering Android’s native optimization that would otherwise automatically load the class.
This article demonstrates how to prevent API abuse in a Java Spring application by using a custom HandlerInterceptor combined with Redis to track request counts per IP and URI, covering basic implementation, configuration, custom annotations, reflection for flexible limits, and discusses potential pitfalls and improvements.
This article explains how to use reflection and dynamic proxies to hook the hidden Android Looper.Observer API for detailed message‑dispatch timing, demonstrates code examples for installing and removing the hook, discusses workarounds for hidden‑API restrictions and the .dex loading changes introduced in Android 14.
The article shows how to generically export any Java object's data to an Excel‑compatible CSV file by using reflection to convert objects into maps, building headers (optionally via a @JcExcelName annotation) and writing the result with a reusable utility class and Maven‑managed Apache POI, FastJSON, and Commons‑IO dependencies, illustrated through SpringBoot controller and main‑method examples.
This article explains how to automate unit conversions for Java DTOs by first using a Map to mark fields and an enum for conversion types, then enhancing the solution with a custom annotation and reflection to make the process more reusable and maintainable.
This article demonstrates a step‑by‑step method for exporting a list of unknown Java objects to an Excel/CSV file by leveraging reflection to dynamically generate headers and rows, complete with Maven dependencies, utility code, usage examples, and an extensible annotation‑based approach.
This article provides a comprehensive overview of Java annotations, covering their definition, common applications, classification into standard, meta, and custom annotations, detailed examples of built‑in annotations such as @Override, @Deprecated, @SuppressWarnings, and guidance on creating and using custom annotations with code snippets.
This article introduces EasyExcel, a Java library that simplifies high‑performance Excel read/write operations, explains its core concepts, provides practical code examples for reading, writing, and filling Excel files, and discusses performance‑optimizing techniques and important usage considerations.
This article demonstrates step‑by‑step how to prevent API abuse in a Spring MVC application by using an Interceptor combined with Redis for counting requests, customizing limits per endpoint through annotations and reflection, handling mapping rules, path‑parameter challenges, and obtaining the real client IP.
This article explains how to automate repetitive unit‑conversion tasks in Java backend code by first using a map‑based reflection utility and then enhancing it with a custom annotation to declaratively specify conversion types for DTO fields.
This article explains how to use Android's hidden Looper$Observer API via reflection and dynamic proxies to monitor long‑running messages on the main thread, classify their execution time, and bypass hidden‑API restrictions, with complete code examples and practical tips for Android 10‑14.
This tutorial demonstrates how to create a universal CSV/Excel export utility in Java that can handle objects of any class by using reflection to generate headers and rows, leveraging Apache POI and Spring Boot for seamless file generation.
This article presents a concise reference of Spring's Assert class, common ObjectUtils, StringUtils, CollectionUtils, file and stream copy helpers, as well as ReflectionUtils and AOP utilities, illustrating their purpose, typical usage scenarios, and providing ready‑to‑copy code snippets for Java backend development.
This article explains PHP 8's new Attributes feature, describing what attributes are, how to attach them to classes and methods with examples like @Table and @Route, and demonstrates retrieving attribute values via reflection to enable flexible metadata management.
This article provides a comprehensive, step‑by‑step analysis of Go’s core concepts—including nil handling, the context package, string and rune internals, unsafe pointers, memory alignment, WaitGroup, semaphores, channels, slices, map implementations, sync.Map, garbage collection, and reflection—illustrated with concrete code examples and detailed reasoning.
Herb Sutter’s latest report reveals that the upcoming C++26 standard will introduce major enhancements such as contracts, static reflection, BLAS‑based linear algebra, debugging APIs, and SIMD parallelism, while also addressing safety concerns and exploring experimental projects like Cppfront and Google’s Carbon to simplify and modernize C++.
This article explains how to reduce repetitive Java backend code by extracting common logic into abstract classes, applying the Template Method and Factory patterns, using custom annotations with reflection for API serialization, and leveraging bean‑mapping utilities to copy properties between DTOs and DOs.
This article explains PHP's reflection functions, showing how to create ReflectionFunction objects, retrieve function names, parameters, type hints, and dynamically invoke functions, with detailed code examples and practical guidance for backend developers.
This article explains PHP 8’s new Attributes feature, describing what attributes are, how to attach custom attributes such as @Table and @Route to classes and methods, and demonstrates retrieving attribute values via reflection, providing clear code examples for backend developers.
This article explains PHP 8’s new Attributes feature, showing how to define attribute classes, apply them to classes, methods, and properties, and retrieve their values using the Reflection API, with complete code examples.
This article explains PHP's reflection capabilities, detailing how developers can inspect classes, interfaces, methods, and properties at runtime, and demonstrates practical uses such as dynamic object creation, method invocation, property manipulation, and annotation parsing with code examples.
This article explains Java annotations, their purposes such as providing compiler metadata, generating code, runtime processing, and documentation, introduces built‑in and meta‑annotations, and demonstrates how to create and use custom annotations both via reflection and with Spring AOP for logging, including full code examples.
This article provides a comprehensive overview of Spring Framework utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AopUtils—explaining their purpose, key methods, and usage examples with code snippets for backend developers.
This article explains the principles behind Java dynamic proxies, demonstrates how to implement them using interfaces, InvocationHandler, and Proxy classes, and outlines common application scenarios such as logging, transaction management, and access control, helping developers extend object behavior at runtime.
This article compares creating Java objects with the new operator and with reflection, presents benchmark code showing a huge performance gap, explains the underlying reasons such as JIT optimization limits and Method#invoke overhead, and outlines practical scenarios for using each approach.
This article explains how Lombok’s unconventional getter/setter naming for fields with a lowercase‑first, uppercase‑second pattern causes MyBatis to map enum properties as null, and how the @Accessor(chain=true) annotation in EasyExcel triggers cglib reflection issues, then provides practical workarounds for both problems.
This article explains Python's reflection mechanism and dynamic attributes, presenting ten practical code examples that demonstrate how to inspect, modify, create, and delete object properties and methods at runtime for more flexible and reusable programs.
This article explains how Java objects are created using the new operator, details the JVM memory model (stack and heap), describes the generation and loading of .class files by the ClassLoader, compares Class.newInstance() with new, and outlines the initialization steps and key concepts developers must master.
The article explains Java's basic concepts of object creation, compares the execution speed of using the new operator versus reflection, analyzes why reflection is slower, and outlines typical scenarios where each method is appropriate, supported by benchmark code and results.
This article introduces three advanced PHP features—Closures, Generators, and Reflection—explaining their concepts, advantages, and providing detailed code examples that demonstrate how closures enable access to outer scope variables, generators reduce memory usage by yielding data lazily, and reflection allows runtime inspection and modification of classes and methods.
This article introduces the most commonly used Spring Boot utility classes—including assertions, object and collection helpers, file/IO utilities, reflection, and AOP support—providing code examples and usage guidelines to help Java backend developers write cleaner, more efficient code.
This article walks through building a simple Java RPC framework, covering core concepts such as service registration with Zookeeper, client-side dynamic proxies, network communication via Netty, serialization, compression, and both reflection and Javassist-based proxy generation, complete with code examples and performance comparisons.
This article explains the inner workings of JDK dynamic proxies, demonstrates a complete example with interface and handler implementations, dissects the Proxy class source code, clarifies why interfaces are mandatory, and shows alternative proxy creation techniques, providing a thorough understanding for Java developers.
This article demonstrates how to reduce repetitive Java code in business applications by applying the Template Method and Factory design patterns, leveraging Spring’s IoC for dynamic cart selection, using custom annotations with reflection to serialize API parameters, and employing bean‑mapping utilities to automate DTO‑DO conversions, thereby improving maintainability and scalability.
This article provides a comprehensive overview of Spring’s Assert utilities and a wide range of Spring Framework helper classes—including ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP utilities—detailing their purpose and key method signatures for Java backend development.
This article introduces Spring's Assert assertion utilities and provides a comprehensive reference of common Spring framework helper classes such as ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP utilities, illustrating their typical methods and usage patterns for backend Java development.
This guide walks you through creating a full‑featured Java Excel export utility using custom annotations, POI, reflection, and grouping, covering sheet configuration, titles, headers, styles, fonts, dynamic titles, column auto‑sizing, and performance considerations with complete code examples.
This article provides a detailed overview of Java backend utilities, covering Spring's Assert class for logical checks, common ObjectUtils and StringUtils methods, collection helpers, file and stream utilities, as well as reflection and AOP tools with practical code examples.
This article demonstrates how to create a generic utility that uses Java reflection to export lists of arbitrary objects to CSV or Excel files, covering dependency setup, core implementation, custom annotation support, and practical usage examples.
This article explains Java annotations as metadata introduced in Java 5, covering their definition, built‑in and custom forms, purposes such as providing metadata, compile‑time checks, code generation and runtime processing, and demonstrates how to define, apply, and process them with code examples.
This article explains how Java generics and reflection work together, why type erasure hides generic information at runtime, and demonstrates a practical technique using anonymous subclasses and the JVM's Signature attribute to recover the actual generic type.
This article explores how Lombok’s auto‑generated getter/setter methods can conflict with MyBatis property naming conventions and cause null values, examines the underlying reflection logic in MyBatis, and also reveals why the @Accessor(chain=true) annotation disrupts EasyExcel’s CGLIB‑based mapping, offering practical solutions.
This article presents a collection of Python code examples covering JSON serialization, date‑time formatting, file reading, QR‑code and barcode creation, list and JSON comparison, class method reflection, and automatic file‑size‑based cleanup, providing practical guidance for everyday scripting tasks.
This article demonstrates how to automatically convert monetary, percentage, permillage and other numeric fields in Java DTOs by marking target properties with a map or a custom annotation, then applying reflection‑based logic to perform scaling, rounding and unit changes in a reusable utility class.
This article explains how to build a generic Java utility that exports any list of objects to an Excel‑compatible CSV file by using reflection to extract field names for headers and values for rows, includes Maven dependencies, custom annotations, and practical usage examples.
This article examines common pitfalls when converting Java Beans to Map objects—such as type loss with JSON libraries and incorrect property name resolution in BeanMap utilities—and presents a robust solution using Dubbo's PojoUtils along with detailed code examples and analysis.
The article explains how to replace repetitive raw SQL and manual row scanning in Go by building a lightweight custom ORM that combines a chainable SQLBuilder for dynamic query construction with a reflection‑based Scanner that maps results to structs, also covering code generation and optional non‑reflection optimizations.
This article explains why dependency injection reduces coupling compared with direct object creation, walks through traditional instantiation, interface programming, factory methods, and reflection, and shows how Spring IoC combines these techniques to manage object lifecycles and improve code maintainability.
This article explains the principles and implementation of a lightweight Java RPC framework, covering service registration with Zookeeper, client-side dynamic proxies, serialization, compression, Netty-based network transport, and both reflection and Javassist proxy generation, with extensive code examples and performance comparison.
This article examines why duplicate code harms maintainability, then demonstrates three practical techniques—using factory and template method patterns, leveraging custom annotations with reflection, and applying bean‑copy utilities—to refactor Java business logic and dramatically reduce redundancy.
This article explains how to let users upload a JAR that implements a predefined Java interface, then dynamically load, register, and switch the implementation at runtime using both reflection‑based and Spring‑annotation‑based hot‑deployment techniques, complete with code examples and utility methods.
This article explains Java's reflection mechanism, its underlying principles involving the Class object, how to obtain Class instances, provides code examples, outlines common use cases such as dynamic loading, frameworks, and middleware, and concludes with a promotional note for an architecture learning collection.
This article introduces DeepKit, a TypeScript library that preserves type information at runtime, enabling powerful data validation, serialization, and reflection capabilities for both front‑end and back‑end JavaScript applications.
This article explains Python’s special attributes and magic methods—including __hash__, __eq__, __bool__, __repr__, __str__, and context management—showing how they affect object behavior, hashing, equality, truth testing, representation, and resource handling with clear code examples.
Through systematic benchmarks comparing direct method calls, field access, and reflective invocations in Java, this article reveals that reflection can significantly degrade performance, especially beyond 100 calls, and identifies the underlying costs of getMethod, getDeclaredField, invoke, and set operations.
This article provides a comprehensive overview of Spring Framework utility classes, covering assertion methods, object and collection utilities, string manipulation, file and resource handling, reflection, and AOP helpers, with code examples illustrating their usage for robust backend development.
This article provides a comprehensive overview of Spring’s utility classes, covering Assert assertions, ObjectUtils, StringUtils, CollectionUtils, file and I/O helpers, as well as Reflection and AOP utilities, with code examples and usage notes for Java backend development.
Reporting the process and outcomes of a modeling project, whether orally or in writing, helps you reflect on your work, sharpen communication abilities, and gain fresh perspectives that improve future modeling thinking.
This article consolidates essential Spring utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, common methods, and usage examples to help developers avoid redundant custom code and leverage built‑in functionality.
This article explains the concepts, advantages, and limitations of Java's JDK dynamic proxy and CGLIB proxy, provides step‑by‑step code examples for user registration validation, compares their mechanisms, and summarizes when to choose each approach in real‑world applications.
This article explains how to build a lightweight, single‑machine configuration center for Spring Boot micro‑services, detailing the core classes, file scanning, variable pooling, environment initialization, YAML conversion, controller endpoints, and runtime property updates, while also discussing current limitations and future improvements.
Explore a series of unconventional Java tricks—from Unicode escape hacks and bitwise tricks to reflection-based Boolean tampering and Unsafe memory manipulation—that let you deliberately obfuscate code, making it hard for teammates to read, modify, or even predict its behavior.
This article explains the hidden pitfalls when converting Java Beans to Map objects—such as type loss and incorrect property names caused by JSON libraries, BeanUtils, and CGLIB—and demonstrates reliable solutions using Dubbo's PojoUtils with clear code examples and visual debugging screenshots.
This article introduces Excel fundamentals, demonstrates how to install and use the Go tealeg library to create spreadsheets, and explains how to leverage Go reflection to convert structs, slices, or arrays into Excel files with practical code examples.
Converting Java beans to maps often leads to type loss and incorrect property names due to JSON frameworks and BeanUtils behavior, and this article examines those pitfalls, demonstrates them with code examples, analyzes underlying Java introspection mechanisms, and presents a Dubbo‑based solution to reliably preserve types and property names.
This article explains the fundamentals of TCP/UDP and HTTP, details OkHttp's interceptor chain and caching mechanisms, and demonstrates a generic offline‑upload solution using Kotlin reflection to persist and replay network calls when connectivity is restored.
This article explains how java.lang.String, traditionally considered immutable, can be altered via reflection in Java 11, how Java 17 blocks such modifications with exceptions, and demonstrates using StackTrace-based checks and other practical applications for security and debugging in Java.
This article explains Java reflection’s core concepts, how the JVM dynamically loads Class objects, and provides practical examples—including field retrieval, caching strategies, and integration with Spring—to help developers harness reflection for dynamic code manipulation while avoiding common pitfalls.
This article demonstrates how reflection can alter the internal byte array of a java.lang.String in Java 11, causing both identical literals to change, explains why the hashCode remains unchanged, and shows that Java 17 blocks such modifications with runtime exceptions.
This article provides a comprehensive guide to Java's reflection mechanism, class loading process, ClassLoader usage, and dynamic proxy techniques, illustrating how to inspect class structures, create objects, access fields and methods, retrieve generic type information, and implement both static and dynamic proxies with practical code examples.
The article examines how Log4j2’s AsyncAppender can block threads when its default 128‑entry queue fills, because creating LogEvent snapshots triggers ThrowableProxy parsing that loads reflective and lambda‑generated classes, causing class‑loader bottlenecks, and recommends custom async appenders, disabling reflection inflation, using synchronous loggers, and proper configuration to avoid these delays.
Converting Java Beans to Maps can cause type loss and incorrect property names due to JSON serialization and BeanMap implementations, but using Dubbo's PojoUtils.generalize method or custom reflection with caching can preserve types and correctly map property names, as demonstrated with code examples and analysis.
This article provides a comprehensive guide to Java annotations, covering built‑in annotations, meta‑annotations, retention policies, repeatable annotations, and how to create and apply custom annotations with reflection and AOP for practical use cases.
This article explains how to reduce repetitive Java business code by applying the factory and template‑method patterns for shopping‑cart processing, using custom annotations with reflection to generate API requests, and leveraging bean‑mapping utilities to copy properties between DTO/DO objects, while illustrating each technique with concrete code examples.
The PHP RFC introduces readonly classes, allowing all properties of a class to be immutable, prohibiting dynamic and static properties, and providing reflection support, with examples, restrictions, inheritance rules, and compatibility notes, helping developers write safer, more robust code.
The article explains that Fastjson sometimes throws a syntax‑error exception when deserializing a JSON list of StewardTipCategory objects because the JVM returns overloaded constructors in nondeterministic order, causing Fastjson to pick the wrong constructor; removing or renaming the ambiguous constructor fixes the issue.
This article demonstrates how to define a simple Java interface, provide two implementation styles (Spring‑annotation and pure‑reflection), package the implementation as a JAR, and dynamically load, register, replace, or remove the implementation at runtime using URLClassLoader and Spring's bean factory.
This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (annotation‑based Spring beans and reflection‑based classes), and dynamically load, register, and unload user‑supplied JAR files at runtime through hot‑deployment mechanisms in a Java backend system.
This article demonstrates how to define a simple Calculator interface, implement it via both Spring-managed and reflection-based approaches, and achieve hot deployment by uploading JAR files, dynamically loading classes, registering or deregistering beans in the Spring container, and testing the process.
This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (Spring annotation and reflection), and achieve hot deployment by uploading JAR files, dynamically loading classes, registering or removing beans in the Spring container, and testing the runtime behavior.
The article demonstrates how to build an offline C# reflection tool using libclang and ClangSharp by parsing C++ headers into an AST, traversing it, generating structured data, and applying Liquid templates, while introducing meta‑attributes via C++ annotate macros for fine‑grained code‑generation control.
This article demonstrates how to design a simple Calculator interface, provide both annotation‑based and reflection‑based implementations, and achieve hot deployment by loading user‑supplied JAR files at runtime, including dynamic bean registration and removal in a Spring container.
This article explains the purpose, construction, and key functionalities of Java's sun.misc.Unsafe class, covering memory management, object allocation, class definition, offset handling, array operations, thread scheduling, CAS, and memory fences, while also showing how to obtain an Unsafe instance via reflection.
The article walks through building a lightweight Java ORM framework from scratch, showing JDBC drawbacks, defining XML configuration and mapper files, implementing core components like SqlSessionFactory, SimpleExecutor, and reflection‑based parameter and result mapping, and demonstrating a working test that returns POJOs.
This article introduces Spring's Assert utilities, explains the purpose and usage of various Spring‑provided helper classes such as ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AOP utilities, and provides code snippets illustrating their typical methods for validation, conversion, and reflection tasks in Java backend development.
Reporting modeling results—whether to yourself or others—helps you organize thoughts, reflect on the process, improve communication, and gain fresh perspectives that enhance both your modeling thinking and overall expressive abilities.
This article explains Java hidden classes—runtime‑generated, reflection‑only classes—through a clear example that creates a simple class, encodes it, loads it as a hidden class, and invokes its method, demonstrating a powerful dynamic feature for frameworks.
This article walks through creating a lightweight Java logging framework—from motivation and project setup to defining constants, configuration loading, utility classes, annotation processing, asynchronous message handling, and a complete test—showing how to inject values, write logs, and package the solution as a reusable JAR.
This article demonstrates how to simplify and decouple a complex Android RecyclerView adapter by extracting view‑holder logic into a sealed BaseVH class, automatically registering subclasses via Kotlin reflection, and optionally replacing the whole approach with Jetpack Compose.
This article explains why the assumption that java.lang.Object is an instance of java.lang.Class is wrong, how Class actually extends Object, and how the JVM resolves the chicken‑egg problem through a bootstrap process that initializes core types before normal execution.
This article explains how Java annotations can be leveraged not only at runtime via reflection but also during compilation by creating custom annotation processors, illustrating the definition of an annotation, implementing a processor, configuring SPI, and demonstrating error handling with Maven.
This article provides a comprehensive guide to Spring's most useful utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AopUtils—detailing their purpose, key methods, and practical code examples for backend developers.
This article demonstrates how to create a lightweight Spring‑style IoC container in Java by parsing a properties file for XML‑like configuration, implementing annotation‑driven bean registration with a custom @Bean annotation, and adding automatic field injection using a custom @Autowired annotation, complete with full source code examples.
The article shows how to overcome extensibility limits in a Java list‑management system by creating a custom DynamicClassLoader that loads encrypted .class files at runtime, explains Java’s class‑loading stages, fixes a Tomcat deployment issue via proper parent delegation, and demonstrates dynamic invocation of new encryption modules without code changes.
This article explains how Java's compiler creates synthetic bridge methods during type erasure for generic interfaces and overridden methods, demonstrates how to identify them via reflection, and explores various scenarios where bridge methods appear, providing code examples and bytecode analysis.
