BestHub
Sign in
Tagged articles

Reflection

330 articles · Page 2 of 4
IT Services Circle
IT Services Circle
Jun 22, 2024 · Backend Development

Comprehensive Guide to Java Backend Interview Topics: Object Creation, Reflection, Serialization, GC, I/O Multiplexing, and Network Troubleshooting

This article provides an in-depth review of common Java backend interview questions, covering alternative object creation methods, practical reflection scenarios, serialization techniques, garbage‑collection algorithms, I/O multiplexing mechanisms, network port listening, and troubleshooting tips for server‑client communication issues.

Garbage CollectionI/O multiplexingJava
0 likes · 24 min read
Comprehensive Guide to Java Backend Interview Topics: Object Creation, Reflection, Serialization, GC, I/O Multiplexing, and Network Troubleshooting
Selected Java Interview Questions
Selected Java Interview Questions
Jun 5, 2024 · Backend Development

Analysis of MyBatis OGNL Concurrency Bug and Workarounds

This article investigates a concurrency bug in MyBatis caused by OGNL expression evaluation using reflection, explains the root cause through stack trace and source code analysis, and proposes solutions such as upgrading MyBatis or avoiding private inner‑class methods like Arrays.asList.

JavaMyBatisOGNL
0 likes · 13 min read
Analysis of MyBatis OGNL Concurrency Bug and Workarounds
DaTaobao Tech
DaTaobao Tech
May 20, 2024 · Backend Development

Reflections on 2023: A Backend Engineer's Journey Through DDD, Business Architecture, and Judgment Models

Reflecting on his 2023 technical writings, the author—prompted by the TV series 'Reply 1988'—structures his insights into chapters covering Domain‑Driven Design lessons illustrated by a Forrest Gump metaphor, business‑architecture note‑taking, judgment models drawn from everyday driving, and personal projects like the VSEF framework and the “曲径通幽” series, emphasizing curiosity, knowledge sharing, and continual growth.

2023Business ArchitectureDDD
0 likes · 11 min read
Reflections on 2023: A Backend Engineer's Journey Through DDD, Business Architecture, and Judgment Models
Ops Development & AI Practice
Ops Development & AI Practice
May 12, 2024 · Backend Development

Mastering Deep Copy in Go: A Complete Reflection-Based Implementation

This article explains how to implement a generic deep‑copy function in Go using reflection, detailing the Interface definition, the Copy and Iface wrappers, the recursive copyRecursive logic, and key techniques such as interface design and recursive traversal to produce fully independent copies of complex data structures.

Reflectiondeep copygo
0 likes · 6 min read
Mastering Deep Copy in Go: A Complete Reflection-Based Implementation
Top Architect
Top Architect
May 9, 2024 · Backend Development

Hot Deployment of User‑Implemented Java Interfaces Using Reflection and Spring

This article demonstrates how to design a simple Calculator interface in Java, implement it using both Spring‑managed and reflection‑based approaches, and achieve hot deployment by loading user‑provided JAR files at runtime, including code for class loading, bean registration, and cleanup.

Hot DeploymentJavaReflection
0 likes · 12 min read
Hot Deployment of User‑Implemented Java Interfaces Using Reflection and Spring
Java Tech Enthusiast
Java Tech Enthusiast
May 2, 2024 · Backend Development

Why Not to Use Spring BeanUtils for Object Copying and How MapperStruct Improves Performance

Spring’s BeanUtils.copyProperties is error‑prone and slow due to type mismatches, primitive‑wrapper issues, null overwrites and reflection, whereas MapStruct generates compile‑time, type‑safe mapper code that avoids these pitfalls, delivers far better performance, and integrates easily with Maven and Lombok.

BeanUtilsJavaObject Mapping
0 likes · 6 min read
Why Not to Use Spring BeanUtils for Object Copying and How MapperStruct Improves Performance
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 28, 2024 · Fundamentals

Master Java Fundamentals: OOP, Collections, Concurrency, and Design Patterns

This comprehensive guide covers Java's core concepts—including object‑oriented principles, differences from C++, polymorphism, static/final modifiers, abstract classes versus interfaces, generics, reflection, exception hierarchy, key data structures like ArrayList, LinkedList, HashMap, ConcurrentHashMap, serialization, String handling, and essential design patterns such as Singleton, Factory, and Abstract Factory—providing interview‑ready knowledge for developers.

Design PatternsReflectionconcurrency
0 likes · 19 min read
Master Java Fundamentals: OOP, Collections, Concurrency, and Design Patterns
MaGe Linux Operations
MaGe Linux Operations
Apr 27, 2024 · Fundamentals

Mastering Go Types and Interfaces: A Deep Dive into Reflection

This article explains Go's static type system, introduces custom types and interface definitions, demonstrates how interfaces store concrete values, and shows how the reflect package can inspect and modify values, covering empty interfaces, type assertions, and mutable reflect values with practical code examples.

InterfacesReflectionStatic Typing
0 likes · 14 min read
Mastering Go Types and Interfaces: A Deep Dive into Reflection
Top Architect
Top Architect
Apr 24, 2024 · Backend Development

Improving Spring Boot Code Quality with Java Reflection

This article demonstrates how to use Java reflection in Spring Boot projects to automatically enforce naming conventions and coding standards, thereby enhancing code quality, maintainability, and scalability while providing practical demo steps and code examples.

Backend DevelopmentJavaReflection
0 likes · 11 min read
Improving Spring Boot Code Quality with Java Reflection
MaGe Linux Operations
MaGe Linux Operations
Apr 15, 2024 · Fundamentals

Understanding Go Types, Interfaces, and Reflection: A Deep Dive

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.

InterfacesReflectionempty interface
0 likes · 15 min read
Understanding Go Types, Interfaces, and Reflection: A Deep Dive
Ops Development & AI Practice
Ops Development & AI Practice
Apr 6, 2024 · Backend Development

How to Simulate Monkey Patching in Go Using Interfaces and Reflection

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.

Design PatternsMonkey PatchingReflection
0 likes · 6 min read
How to Simulate Monkey Patching in Go Using Interfaces and Reflection
Smart Era Software Development
Smart Era Software Development
Apr 3, 2024 · Artificial Intelligence

Unveiling Andrew Ng’s Four AI Agent Design Patterns with Coze

The article explains Andrew Ng’s four AI agent design patterns—Reflection, Tool Use, Planning, and Multi‑agent Collaboration—illustrates each with concrete Coze workflows and real‑world examples such as automotive research briefs, milk‑tea industry reports, and high‑quality travel planning.

AI agentsCozeDesign Patterns
0 likes · 7 min read
Unveiling Andrew Ng’s Four AI Agent Design Patterns with Coze
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 18, 2024 · Fundamentals

Understanding Java Annotations: Definition, Essence, Details, and Parsing SOURCE‑Retention Annotations

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.

Annotation ProcessingJavaMeta‑annotations
0 likes · 12 min read
Understanding Java Annotations: Definition, Essence, Details, and Parsing SOURCE‑Retention Annotations
Ops Development & AI Practice
Ops Development & AI Practice
Mar 1, 2024 · Backend Development

Master Go Reflection: Read and Modify Struct Fields at Runtime

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.

Reflectiongoprogramming
0 likes · 5 min read
Master Go Reflection: Read and Modify Struct Fields at Runtime
Amap Tech
Amap Tech
Feb 28, 2024 · Mobile Development

Deep Dive into Android ClassLoader and findLoadedClass Mechanism for Code Coverage

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.

AndroidNativeReflection
0 likes · 13 min read
Deep Dive into Android ClassLoader and findLoadedClass Mechanism for Code Coverage
Architect
Architect
Feb 20, 2024 · Backend Development

Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java

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.

JavaReflectionSpring
0 likes · 19 min read
Implementing Interface Rate Limiting with Spring Interceptor and Redis in Java
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Feb 20, 2024 · Mobile Development

Hooking Android Looper Observer for Message Timing Monitoring and Bypassing Hidden APIs

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.

AndroidHidden APIHook
0 likes · 13 min read
Hooking Android Looper Observer for Message Timing Monitoring and Bypassing Hidden APIs
Java Tech Enthusiast
Java Tech Enthusiast
Feb 14, 2024 · Backend Development

Generic Excel Export for Arbitrary Java Objects via Reflection

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.

AnnotationCSVExcel Export
0 likes · 10 min read
Generic Excel Export for Arbitrary Java Objects via Reflection
Architect's Guide
Architect's Guide
Jan 25, 2024 · Backend Development

Automatic Unit Conversion in Java Using Maps and Custom Annotations

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.

JavaReflectionUnit Conversion
0 likes · 10 min read
Automatic Unit Conversion in Java Using Maps and Custom Annotations
Java Backend Technology
Java Backend Technology
Jan 24, 2024 · Backend Development

How to Export Any Java Object List to Excel Using Reflection and CSV

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.

AnnotationCSVExcel Export
0 likes · 11 min read
How to Export Any Java Object List to Excel Using Reflection and CSV
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 23, 2024 · Backend Development

Understanding Java Annotations: Types, Usage, and Implementation

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.

Backend DevelopmentJavaReflection
0 likes · 8 min read
Understanding Java Annotations: Types, Usage, and Implementation
Selected Java Interview Questions
Selected Java Interview Questions
Jan 12, 2024 · Backend Development

Efficient Excel Processing with EasyExcel in Java

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.

DataProcessingEasyExcelExcel
0 likes · 16 min read
Efficient Excel Processing with EasyExcel in Java
Java High-Performance Architecture
Java High-Performance Architecture
Jan 9, 2024 · Backend Development

How to Build a Flexible API Rate‑Limiting System with Spring Interceptor and Redis

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.

AnnotationJavaRedis
0 likes · 19 min read
How to Build a Flexible API Rate‑Limiting System with Spring Interceptor and Redis
Java Architect Essentials
Java Architect Essentials
Nov 23, 2023 · Backend Development

Overview of Spring Assertion, Utility, Reflection and AOP Helper Methods

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.

JavaReflectionSpring
0 likes · 11 min read
Overview of Spring Assertion, Utility, Reflection and AOP Helper Methods
php Courses
php Courses
Nov 21, 2023 · Backend Development

Using PHP 8 Attributes to Manage Code Metadata

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.

AttributesMetadataPHP8
0 likes · 4 min read
Using PHP 8 Attributes to Manage Code Metadata
AI Illustrated Series
AI Illustrated Series
Nov 16, 2023 · Fundamentals

Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives

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.

ContextGarbage CollectionMemory
0 likes · 30 min read
Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives
21CTO
21CTO
Nov 15, 2023 · Fundamentals

What New Features Will C++26 Bring? Contracts, Reflection, and More

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++.

C++C++26Contracts
0 likes · 5 min read
What New Features Will C++26 Bring? Contracts, Reflection, and More
Architect's Guide
Architect's Guide
Nov 4, 2023 · Backend Development

Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping

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.

Code RefactoringDesign PatternsJava
0 likes · 21 min read
Eliminating Code Duplication in Java Backend Development with Design Patterns, Annotations, and Bean Mapping
php Courses
php Courses
Nov 2, 2023 · Backend Development

Using PHP Reflection Functions: Basics and Code Examples

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.

Backend DevelopmentCode IntrospectionDynamic Invocation
0 likes · 5 min read
Using PHP Reflection Functions: Basics and Code Examples
php Courses
php Courses
Oct 23, 2023 · Backend Development

Using PHP 8 Attributes to Manage Code Metadata

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.

AttributesMetadataPHP
0 likes · 5 min read
Using PHP 8 Attributes to Manage Code Metadata
php Courses
php Courses
Oct 17, 2023 · Backend Development

Understanding PHP Reflection: Classes, Methods, Properties, and Annotations

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.

Backend DevelopmentDynamic InstantiationIntrospection
0 likes · 5 min read
Understanding PHP Reflection: Classes, Methods, Properties, and Annotations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 13, 2023 · Fundamentals

Understanding Java Annotations and Custom Annotation Usage with Spring AOP

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.

AOPCustomAnnotationJava
0 likes · 7 min read
Understanding Java Annotations and Custom Annotation Usage with Spring AOP
Selected Java Interview Questions
Selected Java Interview Questions
Oct 12, 2023 · Backend Development

Spring Framework Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, AopUtils

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.

IOJavaReflection
0 likes · 14 min read
Spring Framework Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, AopUtils
Java Captain
Java Captain
Oct 7, 2023 · Backend Development

Understanding Java Dynamic Proxies: Principles, Implementation, and Use Cases

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.

Design PatternsDynamic ProxyInvocationHandler
0 likes · 5 min read
Understanding Java Dynamic Proxies: Principles, Implementation, and Use Cases
Java Interview Crash Guide
Java Interview Crash Guide
Sep 22, 2023 · Backend Development

Why Lombok’s Getter/Setter Breaks MyBatis and EasyExcel – and How to Fix It

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.

AccessorEasyExcelGetterSetter
0 likes · 9 min read
Why Lombok’s Getter/Setter Breaks MyBatis and EasyExcel – and How to Fix It
Architect's Tech Stack
Architect's Tech Stack
Sep 16, 2023 · Fundamentals

Understanding Java Object Creation, JVM Memory, and Class Loading

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.

JVMJavaMemory Management
0 likes · 11 min read
Understanding Java Object Creation, JVM Memory, and Class Loading
php Courses
php Courses
Sep 15, 2023 · Backend Development

Advanced PHP Techniques: Closures, Generators, and Reflection

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.

Advanced TechniquesPHPReflection
0 likes · 5 min read
Advanced PHP Techniques: Closures, Generators, and Reflection
Java Architect Essentials
Java Architect Essentials
Sep 1, 2023 · Backend Development

Spring Boot Built‑in Utility Classes Overview

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.

Backend DevelopmentIOJava
0 likes · 19 min read
Spring Boot Built‑in Utility Classes Overview
Top Architect
Top Architect
Aug 29, 2023 · Backend Development

Implementing a Simple Java RPC Framework: Architecture, Service Registration, and Proxy Generation

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.

JavaJavassistNetty
0 likes · 26 min read
Implementing a Simple Java RPC Framework: Architecture, Service Registration, and Proxy Generation
Sanyou's Java Diary
Sanyou's Java Diary
Aug 10, 2023 · Fundamentals

Why Does JDK Dynamic Proxy Require an Interface? A Deep Dive into Proxy Mechanics

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.

Dynamic ProxyInvocationHandlerJDK
0 likes · 12 min read
Why Does JDK Dynamic Proxy Require an Interface? A Deep Dive into Proxy Mechanics
Java Backend Technology
Java Backend Technology
Aug 3, 2023 · Backend Development

Eliminate Java Code Duplication with Design Patterns and Annotations

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.

JavaReflectionSpring
0 likes · 21 min read
Eliminate Java Code Duplication with Design Patterns and Annotations
Java High-Performance Architecture
Java High-Performance Architecture
Jul 9, 2023 · Backend Development

Master Spring Assert & Utility Classes: Essential Java Backend Tools

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.

AOPJavaReflection
0 likes · 13 min read
Master Spring Assert & Utility Classes: Essential Java Backend Tools
Architecture Digest
Architecture Digest
Jul 3, 2023 · Backend Development

Spring Assertion and Utility Classes Overview

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.

Reflectionutilities
0 likes · 10 min read
Spring Assertion and Utility Classes Overview
IT Services Circle
IT Services Circle
May 30, 2023 · Fundamentals

Understanding Java Annotations: Concepts, Uses, and Implementation

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.

JavaMetadataReflection
0 likes · 6 min read
Understanding Java Annotations: Concepts, Uses, and Implementation
Java Interview Crash Guide
Java Interview Crash Guide
May 24, 2023 · Backend Development

Why Lombok’s Getter/Setter Breaks MyBatis and EasyExcel: Hidden Pitfalls Explained

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.

CGLIBEasyExcelGetterSetter
0 likes · 7 min read
Why Lombok’s Getter/Setter Breaks MyBatis and EasyExcel: Hidden Pitfalls Explained
Test Development Learning Exchange
Test Development Learning Exchange
May 13, 2023 · Fundamentals

Comprehensive Python Snippets: JSON Conversion, Date/Time Formatting, File I/O, QR & Barcode Generation, List & JSON Comparison, Class Reflection, and File Size Management

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.

Data ConversionFile I/OPython
0 likes · 14 min read
Comprehensive Python Snippets: JSON Conversion, Date/Time Formatting, File I/O, QR & Barcode Generation, List & JSON Comparison, Class Reflection, and File Size Management
IT Xianyu
IT Xianyu
Apr 27, 2023 · Backend Development

Automatic Unit Conversion in Java Using Reflection and Custom Annotations

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.

JavaReflectionUnit Conversion
0 likes · 10 min read
Automatic Unit Conversion in Java Using Reflection and Custom Annotations
Architect's Guide
Architect's Guide
Mar 30, 2023 · Backend Development

Universal Java Class-to-Excel Export Using Reflection and CSV Formatting

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.

Backend DevelopmentCSVExcel Export
0 likes · 9 min read
Universal Java Class-to-Excel Export Using Reflection and CSV Formatting
Java Architect Essentials
Java Architect Essentials
Feb 22, 2023 · Backend Development

Pitfalls and Solutions for Converting Java Beans to Maps

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.

Bean to MapBeanUtilsDubbo
0 likes · 12 min read
Pitfalls and Solutions for Converting Java Beans to Maps
Bilibili Tech
Bilibili Tech
Feb 21, 2023 · Databases

Building a Custom Go ORM: SQL Builder and Reflection-based Scanner

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.

ORMReflectionSQL Builder
0 likes · 17 min read
Building a Custom Go ORM: SQL Builder and Reflection-based Scanner
Top Architect
Top Architect
Feb 16, 2023 · Backend Development

Understanding Dependency Injection and IoC in Spring: From Direct Instantiation to Factory Pattern and Reflection

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.

Dependency InjectionFactory PatternIOC
0 likes · 8 min read
Understanding Dependency Injection and IoC in Spring: From Direct Instantiation to Factory Pattern and Reflection
Top Architect
Top Architect
Jan 19, 2023 · Backend Development

Implementing a Simple Java RPC Framework: Architecture, Service Registration, Proxy Generation, and Network Transport

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.

JavaJavassistNetty
0 likes · 25 min read
Implementing a Simple Java RPC Framework: Architecture, Service Registration, Proxy Generation, and Network Transport
Java Architect Essentials
Java Architect Essentials
Jan 12, 2023 · Backend Development

How to Eliminate Repetitive Java Code with Design Patterns, Annotations, and Bean Mapping

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.

Code RefactoringDesign PatternsJava
0 likes · 29 min read
How to Eliminate Repetitive Java Code with Design Patterns, Annotations, and Bean Mapping
Selected Java Interview Questions
Selected Java Interview Questions
Jan 10, 2023 · Backend Development

Hot Deployment of Java Interface Implementations Using Reflection and Spring

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.

Hot DeploymentJavaReflection
0 likes · 8 min read
Hot Deployment of Java Interface Implementations Using Reflection and Spring
MaGe Linux Operations
MaGe Linux Operations
Dec 24, 2022 · Fundamentals

Unlock Python’s Magic Methods: A Practical Guide to Special Attributes

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.

Context ManagementPythonReflection
0 likes · 14 min read
Unlock Python’s Magic Methods: A Practical Guide to Special Attributes
Java Backend Technology
Java Backend Technology
Dec 12, 2022 · Backend Development

Does Java Reflection Really Slow Down Your Apps? A Deep Performance Test

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.

JavaOptimizationReflection
0 likes · 10 min read
Does Java Reflection Really Slow Down Your Apps? A Deep Performance Test
Java Architect Essentials
Java Architect Essentials
Nov 15, 2022 · Backend Development

Spring Framework Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, and More

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.

ReflectionSpringassertions
0 likes · 10 min read
Spring Framework Utility Classes Overview: Assertions, ObjectUtils, StringUtils, CollectionUtils, and More
Programmer DD
Programmer DD
Nov 2, 2022 · Backend Development

Master Spring’s Built‑In Utility Classes: Assertions, Collections, IO, and Reflection

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.

Backend DevelopmentJavaReflection
0 likes · 17 min read
Master Spring’s Built‑In Utility Classes: Assertions, Collections, IO, and Reflection
Programmer DD
Programmer DD
Oct 9, 2022 · Backend Development

Mastering Java Dynamic Proxies: JDK vs CGLIB Implementation and Pitfalls

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.

AOPCGLIBDynamic Proxy
0 likes · 11 min read
Mastering Java Dynamic Proxies: JDK vs CGLIB Implementation and Pitfalls
Code Ape Tech Column
Code Ape Tech Column
Sep 28, 2022 · Backend Development

Design and Implementation of a Simple Single‑Node Configuration Center in Spring Boot

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.

Configuration CenterJavaMicroservices
0 likes · 13 min read
Design and Implementation of a Simple Single‑Node Configuration Center in Spring Boot
macrozheng
macrozheng
Sep 6, 2022 · Backend Development

How to Write Java Code That Even Your Colleagues Can’t Understand

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.

JavaReflectionUnsafe
0 likes · 14 min read
How to Write Java Code That Even Your Colleagues Can’t Understand
Java Backend Technology
Java Backend Technology
Aug 27, 2022 · Backend Development

Why Converting Java Beans to Maps Often Fails and How to Fix It

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.

Bean to MapBeanMapDubbo
0 likes · 14 min read
Why Converting Java Beans to Maps Often Fails and How to Fix It
Java Architect Essentials
Java Architect Essentials
Aug 17, 2022 · Backend Development

Pitfalls and Solutions for Converting Java Beans to Maps

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.

BeanDubboReflection
0 likes · 12 min read
Pitfalls and Solutions for Converting Java Beans to Maps
Java Baker
Java Baker
Aug 13, 2022 · Fundamentals

Unlock Java’s Power: Mastering Reflection for Dynamic Code

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.

JavaReflectionSpring
0 likes · 12 min read
Unlock Java’s Power: Mastering Reflection for Dynamic Code
Wukong Talks Architecture
Wukong Talks Architecture
Jul 31, 2022 · Backend Development

Understanding Java Reflection, Class Loading, and Dynamic Proxy Mechanisms

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.

AOPAnnotationDynamicProxy
0 likes · 45 min read
Understanding Java Reflection, Class Loading, and Dynamic Proxy Mechanisms
Meituan Technology Team
Meituan Technology Team
Jul 28, 2022 · Backend Development

Analyzing Log4j2 Thread Blocking Issues and Best Practices

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.

JavaLoggingReflection
0 likes · 51 min read
Analyzing Log4j2 Thread Blocking Issues and Best Practices
Architect's Tech Stack
Architect's Tech Stack
Jul 24, 2022 · Backend Development

Common Pitfalls When Converting Java Beans to Maps and Solutions Using Dubbo

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.

Bean to MapDubboJava
0 likes · 14 min read
Common Pitfalls When Converting Java Beans to Maps and Solutions Using Dubbo
Architecture & Thinking
Architecture & Thinking
Jul 19, 2022 · Backend Development

Master Java Annotations: From Basics to Custom Usage

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.

Custom AnnotationsJavaMeta‑annotations
0 likes · 22 min read
Master Java Annotations: From Basics to Custom Usage
Code Ape Tech Column
Code Ape Tech Column
Jul 15, 2022 · Backend Development

Eliminating Code Duplication in Java Business Logic with Design Patterns, Annotations, and Bean Mapping

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.

Code RefactoringFactory PatternJava
0 likes · 21 min read
Eliminating Code Duplication in Java Business Logic with Design Patterns, Annotations, and Bean Mapping
21CTO
21CTO
Jun 24, 2022 · Backend Development

Understanding PHP’s New Readonly Classes: Benefits, Syntax, and Limitations

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.

PHPReflectionimmutability
0 likes · 5 min read
Understanding PHP’s New Readonly Classes: Benefits, Syntax, and Limitations
DaTaobao Tech
DaTaobao Tech
Jun 24, 2022 · Backend Development

Random Fastjson Deserialization Failure Caused by Constructor Order

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.

ConstructorOrderFastJSONJava
0 likes · 12 min read
Random Fastjson Deserialization Failure Caused by Constructor Order
Top Architect
Top Architect
Jun 23, 2022 · Backend Development

Hot Deployment of User‑Implemented Interfaces in Java: Annotation and Reflection Approaches

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.

AnnotationDynamic Bean RegistrationHot Deployment
0 likes · 8 min read
Hot Deployment of User‑Implemented Interfaces in Java: Annotation and Reflection Approaches
Selected Java Interview Questions
Selected Java Interview Questions
Jun 20, 2022 · Backend Development

Hot Deployment of Custom Java Interface Implementations Using Reflection and Spring

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.

Dynamic Bean RegistrationHot DeploymentJAR Loading
0 likes · 8 min read
Hot Deployment of Custom Java Interface Implementations Using Reflection and Spring
Top Architect
Top Architect
Jun 17, 2022 · Backend Development

Hot Deployment of Java Interface Implementations Using Jar Packages with Spring and Reflection

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.

Dynamic Bean RegistrationHot DeploymentJAR Loading
0 likes · 10 min read
Hot Deployment of Java Interface Implementations Using Jar Packages with Spring and Reflection