Tagged articles
@Component
74 articles · Page 1 of 1
The article explains the fundamental differences between @Component and @Bean in Spring Boot 3.5.0, demonstrates how @Bean provides finer control, solves five common configuration problems, and reveals a subtle proxy‑related bug that causes multiple bean instances when @Component is misused on configuration classes.
@Bean@ComponentConfiguration
0 likes · 8 min read

A detailed analysis shows that when a class is annotated with both @Configuration/@Bean and @Component, Spring creates only one bean—the one defined by @Configuration/@Bean—overriding the @Component definition, and explains how this behavior changed across Spring and Spring Boot versions.
@ComponentBean OverridingConfiguration
0 likes · 10 min read

This article dissects three high-frequency Java/SpringBoot interview questions—String vs StringBuffer vs StringBuilder, @SpringBootApplication annotation internals, and @Component with @Autowired for MyBatis Mapper—revealing underlying mechanisms, performance trade-offs, common pitfalls, and correct usage patterns to deepen technical understanding beyond rote memorization.
@Autowired@Component@SpringBootApplication
0 likes · 10 min read

This article clarifies fintech‑specific definitions for platforms, systems, modules, and related architectural concepts such as frameworks, components, artifacts, plugins, controls, and middleware, illustrating their roles, boundaries, and relationships to guide consistent design and implementation across banking technology projects.
@ComponentPlatformSystem
0 likes · 8 min read

This article explains how to create a Vue component that supports both dragging and resizing by rendering CSS edges and corners, handling mouse events to track movement, calculating new dimensions, enforcing minimum sizes, and providing a complete template, script, and style implementation.
@ComponentCSSJavaScript
0 likes · 15 min read


JavaEdgeDec 29, 2024 · Frontend Development
This article explains how to create a robust Vue 3 form component using Element Plus, covering component hierarchy, data binding with model, rule definition with async-validator, provide/inject communication, and step‑by‑step validation logic with practical code examples.
@ComponentAsyncValidatorForm
0 likes · 19 min read

This article systematically introduces the many ways to write Vue components—including the classic Options API, the modern Composition API with setup syntax sugar, hand‑written render functions using h or createVNode, and various JSX techniques—explaining their principles, code examples, and when to choose each approach.
@ComponentJSXJavaScript
0 likes · 19 min read

This article demonstrates how to create a reusable Vue 3 component with Vite and Element‑Plus, covering two‑way data binding via v‑model, slot forwarding using the h function, and exposing child component refs through a Proxy, complete with code examples and explanations.
@ComponentV-modelVue
0 likes · 7 min read

This article details the design and evolution of a low‑code platform used for electronic menu and TV screens in retail stores, covering architecture diagrams, component decomposition, material market, plugin system, schema compatibility, data fetching optimizations, and resource caching strategies to improve scalability and stability.
@ComponentSDKarchitecture
0 likes · 22 min read

This article explains how to create a reusable Vue calendar component by designing its data structure, generating a 7×6 date matrix, implementing navigation props and events, and applying customizable styles, providing complete code examples for template, script, and scoped CSS.
@ComponentDate GenerationTypeScript
0 likes · 16 min read

This article explains why a scrollable table component misbehaves when its height changes, analyzes the root cause in the internal scroll wrapper, and demonstrates practical ways to force a Vue component to re‑render using v‑if, dynamic keys, and zero‑delay timers, complete with code examples.
@ComponentForce Updatekey
0 likes · 7 min read

This article explains the distinct roles of Spring's @Configuration and @Component annotations, demonstrates their behavior through code examples, compares bean initialization and proxy generation, and reveals how Spring's ConfigurationClassPostProcessor and related enhancers ensure singleton beans across method calls.
@ComponentAnnotationsConfiguration
0 likes · 9 min read

This article explains why a Spring Boot 2.0.3 application creates two UserManager beans when both @Configuration + @Bean and @Component are used, how the container decides which instance is injected, and how newer Spring versions allow developers to control bean‑definition overriding via configuration.
@ComponentBackend DevelopmentBean Overriding
0 likes · 8 min read

This article introduces Vue as a progressive JavaScript framework, explains its core features such as reactive data binding, component‑based development, and virtual DOM, and walks through installation methods, a simple counter example, and a brief comparison with React and Angular.
@ComponentJavaScriptVue
0 likes · 8 min read

This article demonstrates a comprehensive approach to building reusable form and table components in Vue 3 using Element‑Plus, covering the design rationale, code examples for services, dialogs, list pages, and utilities, and discusses the benefits for development efficiency, maintainability, and scalability.
@ComponentElement PlusForm
0 likes · 24 min read

This guide explains how to create a reusable EditTable component that extends ElementPlus's el-table, providing add, delete, edit, and save capabilities, custom editable columns, form validation, dynamic data loading, and a simple API for integrating editable tables into Vue applications.
@ComponentEditable TableElementPlus
0 likes · 12 min read

This article demonstrates how to add entry animations and implement seamless horizontal and vertical scrolling in a Vue 3‑based big‑screen visualization project using ECharts, Gaode map, Pinia, CSS keyframes, and the animejs library, with complete code examples and component packaging.
@ComponentAnimejsCSS Animation
0 likes · 11 min read


JD TechOct 9, 2023 · Frontend Development
This article analyzes the limitations of native navigation bars on mobile pages, proposes a reusable H5 navigation‑bar component (@pango/navigation-bar) with performance, cost, and user‑experience benefits, details its architecture, configuration, code usage, exception handling, and adaptation for foldable screens, and outlines the open‑source plan.
@ComponentConfigurationMobile Web
0 likes · 17 min read

JSONCompareUtils, a full‑JSON comparison component added to the Artemis framework, lets automated tests recursively compare large JSON responses via a Maven‑provided library with Java and Python wrappers, streamlining service‑splitting, BC‑traffic, and cross‑environment validation while dramatically cutting manual verification effort and speeding regression testing.
@ComponentAPI comparisonJSON
0 likes · 9 min read

The article explains how JD upgraded its XView platform from a simple H5 container to a component‑based visual builder that enables fast, precise, and stable creation and deployment of marketing pop‑ups for the 618 promotion, covering design, client integration, dynamic data binding, and animation optimization.
@ComponentXViewmarketing
0 likes · 8 min read

This article provides a comprehensive technical comparison between Vue and React, covering their programming and view styles, component models, routing solutions, state‑management libraries, basic feature differences, reactivity mechanisms, lifecycle hooks and side‑effect handling, with illustrative code examples.
@ComponentReactReactivity
0 likes · 15 min read

This article explains how Tubi’s engineering team uses Kustomize to simplify and scale Kubernetes Resource Manifest management by aggregating resources, applying patches, organizing bases and overlays, and leveraging reusable components to reduce duplication and improve maintainability across clusters and namespaces.
@ComponentInfrastructureKubernetes
0 likes · 15 min read

This article explains how to map design tokens—style, component, template, and file tokens—to appropriate carriers in Figma and Sketch, covering token categories, multi‑mode and multi‑business handling, component token strategies, property naming conventions, handoff methods, and version management.
@ComponentFigmaSketch
0 likes · 20 min read


政采云技术Feb 28, 2023 · Frontend Development
This article explains how to rewrite built‑in HTML and SVG tags in a uni‑app project by overriding Vue's internal tag‑resolution methods, providing step‑by‑step code examples for button and image components and discussing the underlying Vue and webpack mechanisms.
@ComponentVuecustom-element
0 likes · 13 min read

This article provides a comprehensive guide to the ProTable Vue component, detailing its features, configuration options, hooks, code implementation, and usage examples, including table rendering, search forms, pagination, custom slots, and data handling for frontend development.
@ComponentElement PlusProTable
0 likes · 28 min read

This article explains how the Wukong low‑code visual platform implements component drag‑and‑drop, covering material‑to‑canvas dragging, intra‑canvas movement, resizing via eight handles, alignment guide generation, performance optimizations using CSS transforms, and component encapsulation with Vue 3.
@ComponentDrag-and-DropVue3
0 likes · 14 min read

This article explains how to extend Ant Design Vue's Button component with a custom icon prop, create a VpButton wrapper that preserves all original button features, and develop a visual icon selector that generates an icon list from public iconfont scripts for low‑code admin interfaces.
@ComponentIconant-design-vue
0 likes · 14 min read

This article explains how Spring treats @Component and @Configuration annotations, distinguishes their LITE and FULL modes, demonstrates the proxy behavior with concrete code examples, and details the role of ConfigurationClassPostProcessor and CGLIB enhancement in implementing FULL configuration.
@ComponentConfigurationDependencyInjection
0 likes · 15 min read


HomeTechSep 6, 2022 · Frontend Development
This article explains how to create a reusable Vue component called PageTable that encapsulates Element UI table and pagination with built-in loading handling, data fetching via a parent-provided fetchData method, and slot-based column customization.
@ComponentElement UIPagination
0 likes · 6 min read

This article explains why, in Spring Boot 2.0.3, a bean defined with @Configuration + @Bean replaces a @Component‑annotated bean of the same type, shows how to verify which bean is instantiated, and describes the framework’s evolution—including the allowBeanDefinitionOverriding setting—that gives developers control over bean overriding behavior.
@ComponentBean OverridingJava
0 likes · 7 min read

This article introduces a Vue 3.0 functional popup layer library that can be invoked via functions (recommended) or templates, provides a documentation link, and details recent additions such as photo album, drawer, notify layers, new properties, callbacks, and visual examples.
@Component@layerUI
0 likes · 2 min read

This article explains why a Spring Boot application can end up with two UserManager beans—one from @Configuration + @Bean and another from @Component—by analyzing bean definition overriding, the role of ConfigurationClassPostProcessor, and the impact of the allowBeanDefinitionOverriding setting across Spring versions.
@ComponentBackend DevelopmentBean Overriding
0 likes · 9 min read

This article traces the evolution of software development—from machine language and assembly to high‑level languages—explores the two software crises, explains why software architecture emerged, and clarifies core concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
@ComponentDesign PrinciplesSoftware History
0 likes · 13 min read

An in‑depth analysis shows that in Spring Boot 2.0.3 a @Configuration class defining a @Bean can override a @Component‑annotated bean of the same type, how the Spring container registers and replaces the bean definitions, and the evolution of bean‑overriding controls in later Spring and Spring Boot releases.
@ComponentBackend DevelopmentBean Overriding
0 likes · 8 min read

This article explains why Spring Boot creates only one UserManager bean when both @Configuration + @Bean and @Component definitions exist, how the bean definition overriding mechanism works across different Spring versions, and how to control it with the allowBeanDefinitionOverriding setting.
@ComponentBackend DevelopmentBean Definition
0 likes · 8 min read

The article explains that while a Vue root instance can define its data as an object or a function, a component's data must be a function to avoid shared memory between instances, illustrating the issue with code examples and detailing Vue's option‑merge validation.
@ComponentFunctionJavaScript
0 likes · 4 min read

This article explains the fundamentals of Vue.js mixins, demonstrates how to define and apply them in components, highlights their characteristics, and compares them with Vuex state management and regular components, illustrating behavior through visual examples.
@ComponentState ManagementVue.js
0 likes · 4 min read

This article explains the fundamental concepts of software architecture—including systems, subsystems, modules, components, frameworks, and architecture itself—by defining each term, illustrating their relationships with real‑world examples, and clarifying common misconceptions for technical professionals.
@Componentarchitecture fundamentalsframework
0 likes · 10 min read

This article presents a comprehensive overview of JSX support in Vue 3, covering its origins, differences from template syntax, migration details, practical usage scenarios, handling of props and slots, performance considerations, and the underlying compilation mechanisms such as PatchFlags and SlotFlags.
@ComponentJSXVue.js
0 likes · 14 min read

This article explains the evolution of software development from machine language to high‑level languages, describes the two software crises and the emergence of structured, object‑oriented, and component‑based design, and clarifies key architectural concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.
@Componentmodulesoftware architecture
0 likes · 11 min read

This article presents a comprehensive overview of using JSX in Vue 3, covering its basic concepts, why Vue supports JSX, the changes introduced in Vue 3, practical scenarios, implementation details, and performance comparisons with the traditional template syntax.
@ComponentBabelJSX
0 likes · 13 min read

This article traces the evolution from machine code to high‑level languages, explains the two software crises, defines system, subsystem, module, component and framework, and clarifies the true purpose and goals of software architecture for modern developers.
@Componentmodulesoftware architecture
0 likes · 12 min read

This article explores the evolution of software development from machine language to high‑level languages, explains the two software crises, and defines software architecture by distinguishing systems, subsystems, modules, components, and frameworks, emphasizing architecture as a top‑level structural solution for managing complexity.
@Componentmoduleobject-oriented
0 likes · 11 min read

This article examines the evolution of front‑end component reuse, identifies the fragmented toolchains and duplicated packages that hinder efficient business component development across PC, mobile and mini‑programs, and presents a unified fusion package built with vdev that streamlines building, debugging, and publishing while reducing developer overhead.
@ComponentToolchaindevelopment
0 likes · 20 min read

This article explains how the KEMIS framework provides a universal, declarative JSON‑based solution for building Management Information System (MIS) pages, covering component declaration, data fetching via initApi and api, variable resolution, expression‑based attributes, and custom component registration with React examples.
@ComponentDataBindingJSON
0 likes · 13 min read

This article explains how classification thinking—organizing software into modules, components, and packages—forms the foundation of application architecture, illustrates the COLA framework’s evolution, and shows how proper layering and domain‑oriented packaging improve maintainability and scalability.
@ComponentCOLAClassification
0 likes · 15 min read

This article explains how front‑end “materials” – from basic components and business components to blocks, pages and full applications – are organized, developed, packaged, published, and consumed using the Iceworks CLI and VS Code integration, providing a complete workflow for reusable UI assets.
@ComponentUIdevelopment
0 likes · 16 min read

This article analyzes the challenges of front‑end event tracking, compares existing manual, visual, and full‑tracking solutions, and presents a declarative component architecture with a buffered queue that decouples tracking logic from business code while handling click and exposure events efficiently in React.
@ComponentBuffer QueueIntersectionObserver
0 likes · 12 min read

This article provides an in‑depth overview of Cocos Creator's node‑component architecture, covering node creation, hierarchy, spatial properties, touch event flow, and the detailed Visit and Render processes that transform component data into WebGL graphics for game development.
@ComponentCocos CreatorNode
0 likes · 16 min read

This guide explains the concept of front‑end material, how components, business components, blocks, pages and applications are structured, and provides a step‑by‑step workflow using Iceworks CLI to create, develop, publish and consume material collections for scalable front‑end projects.
@Componentclidevelopment
0 likes · 15 min read

To solve inconsistent PC resolutions and the lack of multiple design drafts in backend management pages, we evaluated fixed‑width, fixed‑count, Material Design, and custom grids, then built a reusable adaptive‑grid component that recalculates card width, margin, and padding on resize using CSS variables, delivering responsive card‑lists while minimizing design overhead.
@ComponentCSS-variablesGrid Layout
0 likes · 16 min read


政采云技术Jul 19, 2020 · Frontend Development
This article explains how to design and implement reusable UI components that work across jQuery, React, and Vue by using a native‑JS container, iframe isolation, and communication techniques such as domain sharing, postMessage alternatives, and Nginx proxying, while providing code examples and practical tips.
@Componentcross-frameworkfrontend
0 likes · 12 min read


JavaEdgeJul 11, 2020 · Backend Development
This article explains the purpose, usage, and underlying meta‑annotations of Spring’s core stereotype annotations—@Component, @Controller, @Repository, and @Service—showing how they enable classpath scanning, define component roles, and improve application startup performance.
@ComponentAnnotationsBackend Development
0 likes · 4 min read

This article explains the motivation, design, implementation details, code examples, and troubleshooting tips for building a NutUI video component in Vue that supports basic playback, custom controls, mobile compatibility, and various configuration options for enterprise‑level front‑end projects.
@ComponentHTML5Vue
0 likes · 18 min read

This article explains step by step how Vue.js converts a .vue component file into a virtual DOM node by using Vue.extend, createComponent, installComponentHooks, and the VNode constructor, illustrated with real source code snippets and detailed commentary.
@Componentfrontendrender
0 likes · 12 min read


政采云技术Apr 12, 2020 · Frontend Development
This article introduces a frontend building system covering its motivation, business scenarios, core modules, architecture diagram, deployment strategy, JSON Schema usage, data configuration, and visualisation, while also sharing the speaker's background and recruitment information for the team.
@ComponentJSON Schemaengineering
0 likes · 11 min read


政采云技术Nov 13, 2019 · Frontend Development
This article provides a comprehensive guide to Vue’s slot mechanism, covering default slots, named slots, and scoped slots, explains the new v-slot syntax introduced in Vue 2.6, demonstrates practical component implementations with code examples, and highlights important considerations and advanced extensions.
@ComponentSlotVue
0 likes · 12 min read

This article explains how permission control is re‑thought for front‑end/back‑end separated systems, defining resources and permissions, outlining the distinct responsibilities of the front‑end and back‑end, and providing concrete implementation examples with component‑level checks and server‑side interceptors.
@ComponentBackendJava
0 likes · 6 min read

Litho is a Facebook‑originated declarative framework for building high‑performance Android UI, replacing XML layouts with component‑based code, leveraging Yoga for async layout, flattening view hierarchies, and offering fine‑grained reuse to dramatically improve RecyclerView scrolling speed and memory consumption.
@ComponentAndroidDeclarative UI
0 likes · 17 min read

The case study shows how Qingju Bike’s high‑traffic bike‑sharing mini‑program was built with the Chameleon cross‑platform framework, delivering consistent UI across WeChat, Alipay and other entry points, meeting strict performance and security demands while cutting development time by half and simplifying maintenance.
@ComponentChameleonMini-Program
0 likes · 17 min read

This guide walks through using vue-awesome-swiper in Vue projects, covering version differences, required CSS imports, component setup, and key configuration options such as slidesPerView, centeredSlides, and the coverflow effect, plus progress callbacks and code snippets for dynamic flash‑sale carousels.
@ComponentCarouselJavaScript
0 likes · 5 min read

This article explains why lazy loading is needed for React front‑end projects, demonstrates several code‑first implementations—including a custom LazyComponent, prop‑forwarding tricks, and a higher‑order lazy() function—showing how to improve first‑screen rendering while handling state updates correctly.
@ComponentCode SplittingReact
0 likes · 7 min read

This article uses a sword metaphor to explain why front‑end engineers should focus on the underlying features of frameworks—such as declarative, data‑driven rendering and component architecture—rather than getting trapped by syntax differences, helping beginners and experienced developers choose and transition between stacks more effectively.
@ComponentBest PracticesDeclarative
0 likes · 12 min read


21CTOSep 21, 2018 · Frontend Development
This article explains how React 16 introduced new lifecycle methods, phased component lifecycles, deprecation of old methods with UNSAFE_ prefixes, error handling, and provides practical examples and best‑practice recommendations for building robust React components.
@ComponentLifecycleerror handling
0 likes · 10 min read

This guide explains how to create a Vue‑based comment system, mount it inside a traditional jQuery page, package it as a UMD library with Vue‑CLI 3.0, manage state with Vuex, integrate Element‑UI components, and extend Axios for JSONP support.
@ComponentAxiosElement UI
0 likes · 9 min read

The article explains how to render custom components in WeChat mini‑programs by compiling React render methods into template classes, using dynamic templates, wx:for directives, and helper functions like miniCreateClass to bridge the gap between React and the mini‑program environment.
@ComponentBabelJSX
0 likes · 7 min read

This article examines the challenges of using WeChat Mini Programs, proposes a React‑style component architecture by mapping Mini Program concepts such as Component, Page, and App to React's state, lifecycle, and JSX, and provides concrete code examples for definition, lifecycle handling, styling, templating, and configuration.
@ComponentJavaScriptReact
0 likes · 6 min read


JD TechApr 3, 2018 · Frontend Development
This article explains how to build a reusable Vue component for mobile drag‑and‑drop, covering Vue's advantages, component structure, touch‑event handling, data‑driven updates, optimization techniques, and differences between mobile and PC implementations, with complete code examples.
@ComponentDrag-and-DropTouch Events
0 likes · 10 min read

A correction notice clarifies that the previous Vue.js form configuration article contained an error in the 'Implementation – External Elements' section, providing the updated HTML snippet and explaining that Vue.js slots should be used as child elements within components, with an apology to readers.
@ComponentFormHTML
0 likes · 2 min read


Aotu LabJul 21, 2017 · Frontend Development
This article details the challenges of integrating dozens of APIs, complex UI interactions, and rapid multi‑version releases in a JD Kids shopping ecosystem, and explains how Vue, Vuex, Webpack, and a series of custom mixins, routing tricks, and constant management strategies were used to create a maintainable, high‑performance single‑page application.
@ComponentMixinSPA
0 likes · 16 min read

This article introduces WeChat Mini Programs, compares them with Web Apps and other lightweight app models, explains their component‑based development workflow, key APIs, routing and styling, and discusses the cost, promotion, and future prospects of building mini‑apps on the WeChat platform.
@ComponentAPIJavaScript
0 likes · 9 min read

This article outlines essential security checks for Android components—including Activity, WebView, BroadcastReceiver, Service, and ContentProvider—highlighting common vulnerabilities such as exported components, SSL handling, saved passwords, implicit intents, and unsafe broadcast APIs, and provides practical code examples and mitigation steps.
@ComponentAndroidBroadcastReceiver
0 likes · 7 min read

This article provides a comprehensive overview of ReactJS, covering its origin, virtual DOM performance benefits, component-based architecture, JSX syntax, setup instructions, and multiple code examples that illustrate rendering, state management, lifecycle methods, and component nesting for modern front‑end development.
@ComponentJSXReactJS
0 likes · 15 min read

This article walks through building a React‑based popup page by first dividing the UI into small, single‑responsibility components, creating a static version, distinguishing props from state, adding interactive state, and finally enabling component communication using Flux‑style PubSub events.
@ComponentFluxReact
0 likes · 12 min read
