BestHub
Sign in
Tagged articles

Reflection

330 articles · Page 3 of 4
Java Tech Enthusiast
Java Tech Enthusiast
May 23, 2022 · Backend Development

Implementing a Simple Java ORM Framework from Scratch

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.

JDBCJavaMyBatis
0 likes · 12 min read
Implementing a Simple Java ORM Framework from Scratch
Top Architect
Top Architect
May 21, 2022 · Backend Development

Understanding Spring Assert and Common Utility Classes in Java

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.

AOPJavaReflection
0 likes · 13 min read
Understanding Spring Assert and Common Utility Classes in Java
Model Perspective
Model Perspective
May 14, 2022 · Fundamentals

Why Reporting Your Modeling Results Boosts Insight and Skills

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.

ReflectionReportingcommunication
0 likes · 3 min read
Why Reporting Your Modeling Results Boosts Insight and Skills
Programmer DD
Programmer DD
May 8, 2022 · Backend Development

Mastering Java Hidden Classes: A Step-by-Step Guide with Code

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.

Dynamic Class LoadingHidden ClassesJDK 15
0 likes · 5 min read
Mastering Java Hidden Classes: A Step-by-Step Guide with Code
Java Backend Technology
Java Backend Technology
Apr 27, 2022 · Backend Development

How to Build a Custom Java Logging Framework with Annotations and Queues

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.

JavaQueueReflection
0 likes · 21 min read
How to Build a Custom Java Logging Framework with Annotations and Queues
Sohu Tech Products
Sohu Tech Products
Mar 23, 2022 · Backend Development

Building a Simple Spring IOC Container: XML and Annotation‑Based Bean Assembly

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.

AnnotationDependency InjectionIOC
0 likes · 11 min read
Building a Simple Spring IOC Container: XML and Annotation‑Based Bean Assembly
vivo Internet Technology
vivo Internet Technology
Mar 16, 2022 · Fundamentals

Dynamic Class Loading Practice in Java: Solving Extensibility Challenges in List Management System

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.

Code ExtensibilityJVMJava ClassLoader
0 likes · 14 min read
Dynamic Class Loading Practice in Java: Solving Extensibility Challenges in List Management System
Code Ape Tech Column
Code Ape Tech Column
Mar 9, 2022 · Backend Development

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

This article explains how to reduce repetitive business‑level Java code by applying the Template Method and Factory patterns, leveraging custom annotations with reflection, and using bean‑mapping utilities, thereby improving maintainability, extensibility, and overall code quality.

Code RefactoringDesign PatternsJava
0 likes · 20 min read
Eliminating Code Duplication in Business Logic with Design Patterns, Annotations, Reflection, and Bean Mapping
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 6, 2022 · Fundamentals

Comprehensive Guide to Java Annotations (Detailed)

This article provides an in‑depth overview of Java annotations, covering their definition, common applications, built‑in standard annotations, meta‑annotations, functional interfaces, and step‑by‑step instructions for creating and using custom annotations with complete code examples.

Custom AnnotationsJavaMeta‑annotations
0 likes · 8 min read
Comprehensive Guide to Java Annotations (Detailed)
Top Architect
Top Architect
Mar 1, 2022 · Backend Development

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

This article provides a comprehensive reference of Spring Framework utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AopUtils—detailing their purpose, typical usage scenarios, and full method signatures for Java backend development.

FileIOJavaReflection
0 likes · 14 min read
Spring Framework Utility Classes Overview: Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, AopUtils
Java Captain
Java Captain
Mar 1, 2022 · Fundamentals

Understanding Java Integer Caching and the == Operator

This article explains why comparing Integer objects with == yields false for large values but true for small values due to Java's internal IntegerCache, demonstrates the caching mechanism with code examples, and shows how reflection can manipulate the cache, highlighting memory optimization considerations.

Integer cachingJavaMemory optimization
0 likes · 4 min read
Understanding Java Integer Caching and the == Operator
Java Backend Technology
Java Backend Technology
Feb 24, 2022 · Backend Development

Master Spring’s Core Utility Classes: Assertions, ObjectUtils, StringUtils, and More

This article provides a comprehensive overview of Spring Framework’s core utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—detailing their purpose and key method signatures for developers working on Java backend projects.

AOPJavaReflection
0 likes · 13 min read
Master Spring’s Core Utility Classes: Assertions, ObjectUtils, StringUtils, and More
Java Architect Essentials
Java Architect Essentials
Feb 20, 2022 · Backend Development

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

This article consolidates frequently used Spring utility classes—such as Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, and AopUtils—explaining their purpose, typical usage patterns, and providing code snippets to help developers avoid redundant implementations and leverage built‑in Spring functionality.

FileIOReflectionSpring
0 likes · 14 min read
Common Spring Utility Classes: Assertions, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, ReflectionUtils, AopUtils Overview
Top Architect
Top Architect
Feb 14, 2022 · Backend Development

Common Spring Framework Utility Classes: Assertions, ObjectUtils, StringUtils, CollectionUtils, File/Resource IO, Reflection and AOP Helpers

This article presents a curated collection of Spring Framework utility classes—including assertion helpers, object/array/collection utilities, file and resource IO tools, as well as reflection and AOP utilities—providing ready‑to‑use methods that replace many custom helper functions in Java backend development.

AOPBackend DevelopmentJava
0 likes · 13 min read
Common Spring Framework Utility Classes: Assertions, ObjectUtils, StringUtils, CollectionUtils, File/Resource IO, Reflection and AOP Helpers
IT Services Circle
IT Services Circle
Feb 14, 2022 · Fundamentals

Six Ways to Create Objects in Java

This article presents six Java object‑creation techniques—including direct instantiation, cloning, reflection‑based allocation, dynamic class loading, constructor invocation via reflection, and deserialization—explaining each method with code examples and practical notes for developers.

JavaLombokObject Creation
0 likes · 7 min read
Six Ways to Create Objects in Java
Programmer DD
Programmer DD
Feb 7, 2022 · Backend Development

Master Spring’s Core Utility Classes: Assertions, Collections, IO, and Reflection

This article provides a comprehensive guide to Spring's built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, common methods, and usage examples to replace redundant custom code.

JavaReflectionSpring
0 likes · 16 min read
Master Spring’s Core Utility Classes: Assertions, Collections, IO, and Reflection
IT Xianyu
IT Xianyu
Jan 24, 2022 · Fundamentals

Why does Java evaluate 1000==1000 as false while 100==100 evaluates to true?

The article explains that Java's Integer caching for values between -128 and 127 causes small integer objects to be shared, making == true for 100, whereas larger integers like 1000 are distinct objects, so == returns false, and it demonstrates this behavior with code and reflection examples.

IntegerJavaReferenceEquality
0 likes · 4 min read
Why does Java evaluate 1000==1000 as false while 100==100 evaluates to true?
JavaEdge
JavaEdge
Jan 11, 2022 · Fundamentals

Master Java Annotations: From Basics to Advanced Usage

This article explains what Java annotations are, how to define custom annotations, the built‑in meta‑annotations, annotation attributes, common built‑in annotations, and practical usage scenarios, providing code examples and runtime reflection details for developers.

JDKJavaReflection
0 likes · 13 min read
Master Java Annotations: From Basics to Advanced Usage
Java Tech Enthusiast
Java Tech Enthusiast
Jan 10, 2022 · Fundamentals

Understanding Java Generics: Classes, Methods, Type Bounds, and Erasure

The article introduces Java generics—showing how they prevent runtime ClassCastExceptions by enforcing compile-time type safety, demonstrating generic class and method definitions, type bounds (including multiple bounds), erasure effects observable via reflection, and the use of wildcards for flexible type constraints.

JavaReflectiongenerics
0 likes · 8 min read
Understanding Java Generics: Classes, Methods, Type Bounds, and Erasure
58 Tech
58 Tech
Dec 31, 2021 · Mobile Development

Swift and Objective‑C Mixed Development in 58 Group’s Real‑Estate Business: Architecture, Module Integration, and Reflection Issues

This article details the background, current status, and engineering architecture of introducing Swift into 58 Group’s real‑estate iOS apps, explains the two main mixed‑compilation approaches (bridging header and module), presents practical module setup, discusses reflection pitfalls, binding solutions, and performance comparisons between Swift and Objective‑C implementations.

Mixed DevelopmentObjective‑CPerformance
0 likes · 21 min read
Swift and Objective‑C Mixed Development in 58 Group’s Real‑Estate Business: Architecture, Module Integration, and Reflection Issues
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 28, 2021 · Fundamentals

Mastering Java Reflection: What It Is, How It Works, and Real-World Uses

Java reflection lets programs inspect and manipulate classes, methods, and fields at runtime, enabling dynamic object creation, method invocation, and flexible framework design; this guide explains its definition, benefits, underlying mechanics, practical usage with code examples, and common scenarios such as JDBC driver loading and Spring IoC.

JavaReflectioncode example
0 likes · 8 min read
Mastering Java Reflection: What It Is, How It Works, and Real-World Uses
OPPO Amber Lab
OPPO Amber Lab
Dec 23, 2021 · Information Security

How Java Deserialization Vulnerabilities Enable Remote Code Execution

This article explains Java's reflection mechanism, details how deserialization flaws in libraries like Apache Commons Collections and Fastjson allow attackers to craft malicious objects that trigger arbitrary command execution, and provides practical proof‑of‑concept steps and mitigation recommendations.

FastJSONJavaReflection
0 likes · 7 min read
How Java Deserialization Vulnerabilities Enable Remote Code Execution
FunTester
FunTester
Dec 15, 2021 · Backend Development

Mastering Java Reflection: Access and Modify Private Fields with PriUtil

This article explains how to bypass Java's private access restrictions using reflection, introduces the core Field and setAccessible APIs, provides a reusable PriUtil wrapper with get/set methods for instance and static members, and demonstrates usage through concrete test classes and scripts.

JavaPrivateFieldsReflection
0 likes · 8 min read
Mastering Java Reflection: Access and Modify Private Fields with PriUtil
Selected Java Interview Questions
Selected Java Interview Questions
Nov 21, 2021 · Fundamentals

Understanding Static and Dynamic Proxy Patterns in Java

This article explains the concept of proxy patterns, compares static and dynamic proxies in Java, provides detailed code examples for each, and discusses their advantages, disadvantages, and implementation steps, helping developers choose the appropriate proxy technique for their projects.

Design PatternsDynamic ProxyJava
0 likes · 15 min read
Understanding Static and Dynamic Proxy Patterns in Java
Laravel Tech Community
Laravel Tech Community
Aug 25, 2021 · Backend Development

Implementing Dependency Injection in PHP Using Reflection

This article explains how to build a simple PHP IoC container with reflection to automatically resolve constructor and method dependencies, demonstrates its use with example classes A, B, and C, and shows how to invoke methods with injected parameters.

Backend DevelopmentDependency InjectionDesign Patterns
0 likes · 5 min read
Implementing Dependency Injection in PHP Using Reflection
Programmer DD
Programmer DD
Aug 18, 2021 · Backend Development

How Does Spring’s @Autowired Work Under the Hood? A Deep Dive

This article explores the various ways to use Spring’s @Autowired annotation—including constructor, setter, field, and collection injection—examines its purpose, and provides a detailed analysis of its implementation in the Spring framework by dissecting the source code and related reflection mechanisms.

Dependency InjectionJavaReflection
0 likes · 17 min read
How Does Spring’s @Autowired Work Under the Hood? A Deep Dive
Taobao Frontend Technology
Taobao Frontend Technology
Jul 23, 2021 · Fundamentals

How Docs-as-Code and TypeDoc Revolutionize TypeScript Library Documentation

This article explores the motivation, design, and implementation of using Docs-as-Code with TypeDoc to generate and maintain documentation for TypeScript utility libraries, covering annotation conventions, plugin architecture, code organization, flag handling, event mechanisms, reflection generation, and practical plugin customizations.

Docs-as-CodeDocumentation GenerationReflection
0 likes · 22 min read
How Docs-as-Code and TypeDoc Revolutionize TypeScript Library Documentation
Top Architect
Top Architect
Jul 10, 2021 · Fundamentals

Reflection and Polymorphism in Java: Concepts, Implementation, and Practical Applications

This article explains Java's reflection and polymorphism mechanisms, detailing their theoretical foundations, runtime type identification (RTTI), method table implementation, practical code examples, common use cases, performance and security drawbacks, and the differences between reflection and polymorphism.

JavaJava APIObject-Oriented Programming
0 likes · 24 min read
Reflection and Polymorphism in Java: Concepts, Implementation, and Practical Applications
Code Ape Tech Column
Code Ape Tech Column
Jun 28, 2021 · Backend Development

Understanding and Implementing Spring's @Autowired Annotation

This article explains the various ways to use Spring's @Autowired annotation, examines its underlying implementation via reflection, and provides detailed code examples illustrating field, constructor, setter, and collection injection, while also discussing annotation lifecycle and best practices.

AutowiredDependency InjectionJava
0 likes · 17 min read
Understanding and Implementing Spring's @Autowired Annotation
Top Architect
Top Architect
Jun 27, 2021 · Backend Development

Understanding and Implementing Spring's @Autowired Annotation

This article explains the various ways to use Spring's @Autowired annotation, explores its underlying implementation using reflection, analyzes the core processing classes in the Spring framework, and answers common questions about its lifecycle, bean relationships, and why static injection is discouraged.

AutowiredDependency InjectionJava
0 likes · 17 min read
Understanding and Implementing Spring's @Autowired Annotation
58UXD
58UXD
Jun 16, 2021 · Fundamentals

Why and How Designers Should Do Project Post‑Mortems

This guide explains why project post‑mortems are essential for designers, outlines a simple review framework, and shares a step‑by‑step case study of creating sticker designs, offering practical tips and reflections to improve future design work.

ReflectionUXdesign
0 likes · 6 min read
Why and How Designers Should Do Project Post‑Mortems
Java Interview Crash Guide
Java Interview Crash Guide
May 12, 2021 · Fundamentals

Unlocking Java Annotations: What They Are, How They Work, and How to Create Your Own

Java annotations, introduced in Java 5, provide a metadata mechanism to associate information with program elements, enabling documentation generation, compile‑time checks, and runtime processing; this guide explains their purpose, underlying principles, meta‑annotations, common built‑in annotations, and demonstrates how to define and use custom annotations with full code examples.

Custom AnnotationsJavaMeta‑annotations
0 likes · 12 min read
Unlocking Java Annotations: What They Are, How They Work, and How to Create Your Own
FunTester
FunTester
Apr 29, 2021 · Backend Development

How to Pass Multiple Parameters to Groovy’s invokeMethod for Performance Testing

This article explains how to work around Groovy's invokeMethod limitation of accepting only a single Object argument by using String arrays or var‑args, demonstrates Java and Groovy reflection implementations, and provides complete code examples for multi‑parameter performance test scripts.

GroovyJavaMethod Invocation
0 likes · 8 min read
How to Pass Multiple Parameters to Groovy’s invokeMethod for Performance Testing
FunTester
FunTester
Apr 26, 2021 · Backend Development

Resolving IllegalAccessException When Reflectively Invoking a Static Method in a Java Test Framework

The article details a Java reflection issue where invoking a static test method via ExecuteSource caused IllegalAccessException, explains the root cause related to method visibility, and shows how adding the public modifier fixes the problem, enabling successful distributed performance testing.

Reflectionillegalaccessexceptionperformance-testing
0 likes · 5 min read
Resolving IllegalAccessException When Reflectively Invoking a Static Method in a Java Test Framework
Python Programming Learning Circle
Python Programming Learning Circle
Apr 22, 2021 · Fundamentals

Advanced Class Methods and Special Member Functions in Python

This article explains Python's advanced class features—including static methods, class methods, property decorators, special dunder methods, reflection utilities, dynamic attribute manipulation, metaclass creation, and exception handling—illustrated with clear code examples and practical usage tips.

PropertyReflectionclass-methods
0 likes · 14 min read
Advanced Class Methods and Special Member Functions in Python
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 14, 2021 · Backend Development

Various Ways to Create Objects in Java: new, newInstance, Reflection, Cloning, and Deserialization

This article explains the multiple techniques for creating objects in Java—including the new operator, Class.newInstance, reflection with Constructor, cloning via Cloneable, and deserialization—while illustrating the underlying bytecode instructions and providing concrete code examples for each method.

JavaObject CreationReflection
0 likes · 8 min read
Various Ways to Create Objects in Java: new, newInstance, Reflection, Cloning, and Deserialization
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 2, 2021 · Fundamentals

Master Java Reflection and Core Networking: From Basics to TCP/IP

An in‑depth guide covering Java reflection fundamentals, three methods to obtain Class objects, and practical code examples, followed by a comprehensive overview of computer networking layers, protocols, TCP/IP versus OSI models, transport protocols, HTTP/HTTPS differences, status codes, GET/POST, cookies, sessions, tokens, and servlet lifecycle.

HTTPJavaReflection
0 likes · 28 min read
Master Java Reflection and Core Networking: From Basics to TCP/IP
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 18, 2021 · Fundamentals

Comprehensive Guide to the Singleton Pattern in Java: Implementations, Pitfalls, and the Secure Enum Solution

This article explains various Java singleton implementations—including eager, lazy, double‑checked locking, static inner class, and enum—demonstrates their thread‑safety issues, shows how reflection and serialization can break them, and presents the enum approach as a truly safe solution.

EnumJavaReflection
0 likes · 11 min read
Comprehensive Guide to the Singleton Pattern in Java: Implementations, Pitfalls, and the Secure Enum Solution
Top Architect
Top Architect
Feb 4, 2021 · Backend Development

Performance Impact of Java Reflection: Empirical Tests and Analysis

This article empirically investigates whether Java reflection incurs performance penalties, describing a series of benchmark tests that compare direct method/field access with reflective calls, analyzing results, identifying the main cost factors, and offering practical guidelines to mitigate reflection overhead in production code.

JavaOptimizationPerformance
0 likes · 11 min read
Performance Impact of Java Reflection: Empirical Tests and Analysis
Architect
Architect
Jan 31, 2021 · Fundamentals

Investigating the Performance Impact of Java Reflection

This article presents a series of benchmarks that compare direct method and field access with reflective calls in Java, analyzes where the performance overhead originates, and offers practical guidelines to mitigate reflection‑related slowdown in real‑world applications.

JavaOptimizationPerformance
0 likes · 9 min read
Investigating the Performance Impact of Java Reflection
DevOps
DevOps
Jan 14, 2021 · R&D Management

Cold Reflections on R&D Efficiency: Lessons from The Little Prince

In this reflective piece, Robin shares three "cold thoughts" on R&D efficiency, using fables from The Little Prince to question whether productivity gains truly improve engineers' work‑life balance, and invites readers to consider small, actionable steps toward better development practices.

ReflectionThe Little Princework-life balance
0 likes · 5 min read
Cold Reflections on R&D Efficiency: Lessons from The Little Prince
macrozheng
macrozheng
Dec 30, 2020 · Backend Development

Unlocking Spring Security’s ResolvableType: Simplify Generic Reflection

This article explores Spring Security’s ResolvableType class, demonstrating how its static factory methods—such as forClass, forClassWithGenerics, forField, and forMethodParameter—simplify obtaining generic type information via reflection, and shows practical code examples that replace cumbersome traditional Java reflection techniques.

Backend DevelopmentJavaReflection
0 likes · 6 min read
Unlocking Spring Security’s ResolvableType: Simplify Generic Reflection
Programmer DD
Programmer DD
Dec 24, 2020 · Fundamentals

How to Retrieve Generic Types at Runtime with Gson’s TypeToken

This article explains Java's generic type erasure, why it exists, and demonstrates how to use Gson's TypeToken and reflection APIs to obtain actual generic type information at runtime, complete with code examples and a detailed walkthrough of the underlying mechanism.

GsonJavaReflection
0 likes · 7 min read
How to Retrieve Generic Types at Runtime with Gson’s TypeToken
FunTester
FunTester
Dec 14, 2020 · Backend Development

Running Groovy Tests in Docker: JAR Packaging vs Reflection Execution

Faced with network latency and only a Docker container available, this guide compares two practical ways to run Groovy test scripts—packaging the test class into a JAR and invoking its main method, or using a reflection utility to call methods dynamically—complete with code samples, Maven commands, and execution results.

AutomationDockerGroovy
0 likes · 10 min read
Running Groovy Tests in Docker: JAR Packaging vs Reflection Execution
Selected Java Interview Questions
Selected Java Interview Questions
Dec 1, 2020 · Backend Development

Using Annotations and Reflection to Eliminate Duplicate Java Backend Code

This article demonstrates how to replace repetitive Java backend code for constructing fixed‑length API request strings by defining POJOs, custom annotations, and a reflection‑based utility that formats parameters, pads strings, handles numeric and monetary fields, and appends an MD5 signature, thereby improving maintainability and reducing bugs.

APICode RefactoringJava
0 likes · 10 min read
Using Annotations and Reflection to Eliminate Duplicate Java Backend Code
Architecture Digest
Architecture Digest
Nov 6, 2020 · Backend Development

Custom JDK Dynamic Proxy for MyBatis Automatic Mapper Implementation

This article explains how MyBatis can instantiate a mapper interface without an implementation class by using a custom JDK dynamic proxy (referred to as "投鞭断流") that intercepts method calls, creates result objects, and demonstrates the full source code and execution output.

Backend DevelopmentDynamic ProxyJava
0 likes · 7 min read
Custom JDK Dynamic Proxy for MyBatis Automatic Mapper Implementation
Programmer DD
Programmer DD
Oct 30, 2020 · Backend Development

5 Ways to Create Java Objects: From new Keyword to Deserialization

This article explains five core techniques for instantiating Java objects—including the new keyword, Class.newInstance(), Constructor.newInstance(), clone(), and deserialization—provides code examples for each method, and demonstrates their usage in a complete program with sample output.

JavaObject CreationReflection
0 likes · 8 min read
5 Ways to Create Java Objects: From new Keyword to Deserialization
JavaEdge
JavaEdge
Oct 25, 2020 · Backend Development

How to Eliminate Duplicate Code with Factory & Template Method Patterns in Java

This article explains why duplicate code harms maintainability, then demonstrates step‑by‑step refactoring techniques—using factory and template method patterns, custom annotations with reflection, and BeanUtils—to consolidate business logic for different cart types and API calls while preserving extensibility.

Design PatternsFactory PatternJava
0 likes · 15 min read
How to Eliminate Duplicate Code with Factory & Template Method Patterns in Java
Java Backend Technology
Java Backend Technology
Oct 20, 2020 · Backend Development

Unlocking MyBatis Mapper Magic: Custom JDK Dynamic Proxy Explained

This article explains how a custom JDK dynamic proxy can automatically map interface methods to concrete objects, demonstrates the implementation with a User POJO and UserMapper, shows test output, analyzes MyBatis internal proxy classes, and clarifies why mapper methods cannot be overloaded.

Dynamic ProxyJavaMyBatis
0 likes · 7 min read
Unlocking MyBatis Mapper Magic: Custom JDK Dynamic Proxy Explained
Programmer DD
Programmer DD
Oct 14, 2020 · Backend Development

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

This article investigates whether Java reflection impacts performance by running systematic benchmarks that compare direct method calls, reflective method calls, direct field access, and reflective field access across varying iteration counts, presenting detailed results, analysis of the slow paths, and practical guidelines to mitigate any overhead.

AndroidJavaPerformance
0 likes · 12 min read
Does Java Reflection Really Slow Down Your App? A Deep Performance Test
Programmer DD
Programmer DD
Sep 16, 2020 · Backend Development

Why Does Integer == Return True for Small Numbers? Uncover Java’s Integer Cache

This article explains why the == operator returns true for small Integer values in Java, detailing the internal IntegerCache mechanism, demonstrating the behavior with code examples, and showing how reflection can manipulate the cache, highlighting both the benefits and potential pitfalls of this optimization.

Reference EqualityReflectionautoboxing
0 likes · 4 min read
Why Does Integer == Return True for Small Numbers? Uncover Java’s Integer Cache
Selected Java Interview Questions
Selected Java Interview Questions
Sep 13, 2020 · Fundamentals

Does Java Reflection Really Cause Performance Issues? Empirical Tests and Analysis

This article investigates whether Java reflection impacts performance by conducting systematic benchmarks that compare direct method/field access with reflective calls, analyzing the measured overhead, identifying the costly reflection operations, and offering practical guidelines to mitigate any performance penalties.

JavaPerformanceReflection
0 likes · 11 min read
Does Java Reflection Really Cause Performance Issues? Empirical Tests and Analysis
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 31, 2020 · Backend Development

Using Java Annotations for Log Masking and Bank API Request Simplification

This article explains how to employ custom Java annotations together with reflection to mask sensitive fields in logs, define flexible desensitization rules, and dramatically reduce repetitive code when building fixed‑length, signed bank API requests, improving maintainability and extensibility of backend services.

Backend DevelopmentBank APICode Reuse
0 likes · 21 min read
Using Java Annotations for Log Masking and Bank API Request Simplification
Programmer DD
Programmer DD
Jul 8, 2020 · Fundamentals

Unlock Java’s Power: Master Reflection for Dynamic Code

This article explains Java's reflection mechanism, showing how classes are represented by Class objects, how to obtain them at runtime, and demonstrates common reflective operations such as inspecting fields, constructors, methods, and arrays with practical code examples and typical interview questions.

Reflectionclasscode
0 likes · 16 min read
Unlock Java’s Power: Master Reflection for Dynamic Code
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 7, 2020 · Fundamentals

Introduction to Java Reflection

This article explains Java's reflection mechanism, covering how to obtain Class objects, the java.lang.reflect API, practical code examples, common use cases such as dynamic proxies, JDBC driver loading, Spring bean initialization, and discusses the advantages and performance drawbacks of using reflection.

Dynamic ProxyJDBCJava
0 likes · 13 min read
Introduction to Java Reflection
Sohu Tech Products
Sohu Tech Products
Apr 15, 2020 · Mobile Development

Swift-Based Conversion Between Realm.Object and Business Models Using Protocols

This article explains how to implement a Swift‑centric conversion framework that maps Realm.Object instances to plain business models and vice versa by defining protocols, leveraging Mirror for reflection, handling basic and complex types, and providing generic solutions for collections and optionals.

Data MappingMobile DevelopmentRealm
0 likes · 13 min read
Swift-Based Conversion Between Realm.Object and Business Models Using Protocols
Senior Brother's Insights
Senior Brother's Insights
Mar 25, 2020 · Backend Development

Master Java Reflection: From Basics to Advanced Usage

This article provides a comprehensive guide to Java's reflection mechanism, covering its definition, core capabilities, practical code examples, common API usage, and considerations such as performance and security, enabling developers to understand and apply reflection effectively in real-world projects.

APIJavaReflection
0 likes · 10 min read
Master Java Reflection: From Basics to Advanced Usage
vivo Internet Technology
vivo Internet Technology
Mar 25, 2020 · Mobile Development

Dynamic Multi-language Resource Replacement and WebView Crash Resolution in Android

To prevent translation errors and post‑release crashes in multilingual Android apps, the article describes a dynamic resource‑replacement system that loads external language packs via AssetManager, proxies Resources through reflection, integrates the proxy with ResourcesManager, and updates WebView assets, eliminating garbled text and long‑press crashes.

AndroidDynamic LocalizationHooking
0 likes · 31 min read
Dynamic Multi-language Resource Replacement and WebView Crash Resolution in Android
AI Code to Success
AI Code to Success
Jan 8, 2020 · Mobile Development

Step-by-Step Guide to Building Your Own Android Hotfix Framework

This tutorial walks through the principles of Android hotfixing, explains class loaders, and provides a complete hands‑on implementation—including a buggy class, a custom Dex loader, patch creation, and runtime injection—so developers can quickly patch bugs without releasing a full app update.

AndroidDexClassLoaderHotfix
0 likes · 11 min read
Step-by-Step Guide to Building Your Own Android Hotfix Framework
macrozheng
macrozheng
Nov 19, 2019 · Backend Development

Why Java Reflection Is Slow and How It Works Under the Hood

This article explains the internal workings of Java reflection, from obtaining Method objects via getMethod and getDeclaredMethod to the invoke process, and details why reflection incurs significant performance overhead due to argument boxing, visibility checks, parameter validation, lack of inlining, and JIT optimization limits.

JDKJITJava
0 likes · 24 min read
Why Java Reflection Is Slow and How It Works Under the Hood
Architecture Digest
Architecture Digest
Nov 17, 2019 · R&D Management

Lessons Learned from Leading a 20‑Person Development Team: Management Mistakes and Reflections

The author, a former technical director, recounts a three‑month period managing a 20‑person R&D team across four legacy projects, analyzes four critical management mistakes—including over‑estimating team skill, under‑estimating project difficulty, spreading resources too thin, and neglecting dedicated management—and shares concrete reflections and actionable lessons for future leaders.

LeadershipProject ManagementR&D
0 likes · 13 min read
Lessons Learned from Leading a 20‑Person Development Team: Management Mistakes and Reflections
Youku Technology
Youku Technology
Nov 7, 2019 · Backend Development

Bytecode‑Based Method Invocation for High‑Performance Java Middleware

The article presents a bytecode‑generation technique that creates dynamic wrapper classes to invoke arbitrary Java methods with near‑native speed, avoiding reflection’s overhead, and details the CallerWrap base, generator, and thread‑safe cache implementation that together enable high‑performance middleware calls.

CGLIBJavaMiddleware
0 likes · 11 min read
Bytecode‑Based Method Invocation for High‑Performance Java Middleware
FunTester
FunTester
Oct 24, 2019 · Backend Development

Executing Groovy Test Scripts Dynamically from Java: A Practical Guide

This article explains how to build a Java wrapper that loads and runs Groovy test scripts at runtime, covering classloader nuances, reflection-like execution, file discovery, method filtering, and provides a complete code example for a custom test framework.

GroovyJavaReflection
0 likes · 6 min read
Executing Groovy Test Scripts Dynamically from Java: A Practical Guide
Java Captain
Java Captain
Oct 18, 2019 · Backend Development

Understanding Java Annotations: Types, Benefits, Custom Creation, and Runtime Parsing

This article explains the purpose and advantages of Java annotations, categorizes built‑in, third‑party and custom annotations, describes meta‑annotations, demonstrates how to define and apply custom annotations, and shows how to parse them at runtime using reflection, complete with code examples.

CustomAnnotationJavaMetaAnnotation
0 likes · 9 min read
Understanding Java Annotations: Types, Benefits, Custom Creation, and Runtime Parsing
FunTester
FunTester
Aug 17, 2019 · Backend Development

Using Java Reflection to Execute API Test Cases in an HttpClient Framework

The article presents a Java HttpClient testing framework that leverages reflection to dynamically invoke API methods, detailing optimized functions for running all test cases of an interface, single test cases, and the core execution logic that interacts with a MySQL database and records results.

HttpClientJavaMySQL
0 likes · 5 min read
Using Java Reflection to Execute API Test Cases in an HttpClient Framework
Architect's Tech Stack
Architect's Tech Stack
Jun 10, 2019 · Backend Development

Understanding Java Reflection and Class Loading Mechanisms

This article explains Java reflection fundamentals, including Class object usage, dynamic class loading, method and field introspection, generic type handling, and detailed class loader mechanisms, providing code examples and practical insights for backend developers.

Java APIReflectionclass loading
0 likes · 8 min read
Understanding Java Reflection and Class Loading Mechanisms