A Composite Design Pattern for Service Injection and Composition of Web Services for Peer-To-Peer Computing with Service Oriented Architecture

In this paper we present a Service Injection and composition Design Pattern for Unstructured Peer-to-Peer networks, which is designed with Aspect-oriented design patterns, and amalgamation of the Strategy, Worker Object, and Check-List Design Patterns used to design the Self-Adaptive Systems. It will apply self reconfiguration planes dynamically without the interruption or intervention of the administrator for handling service failures at the servers. When a client requests for a complex service, Service Composition should be done to fulfil the request. If a service is not available in the memory, it will be injected as Aspectual Feature Module code. We used Service Oriented Architecture (SOA) with Web Services in Java to Implement the composite Design Pattern. As far as we know, there are no studies on composition of design patterns for Peer-to-peer computing domain. The pattern is described using a java-like notation for the classes and interfaces. A simple UML class and Sequence diagrams are depicted.

💡 Research Summary

The paper introduces a novel composite design pattern that enables dynamic service injection and on‑the‑fly composition of web services within unstructured peer‑to‑peer (P2P) networks. The authors observe that existing P2P research focuses mainly on discovery and routing, while neglecting self‑healing and runtime addition of services. To fill this gap, they combine three well‑known object‑oriented design patterns—Strategy, Worker Object, and Check‑List—with Aspect‑Oriented Programming (AOP) to form a self‑adaptive framework that can reconfigure itself without administrator intervention.

The Strategy pattern encapsulates the decision logic that selects the most appropriate service implementation for a client request. Because each peer may expose different capabilities and the network topology constantly changes, a static routing table is insufficient. The strategy object evaluates service metadata (availability, latency, version) and, through AOP pointcuts, hands the chosen implementation over to a worker.

The Worker Object pattern isolates the actual execution of a service into a separate task. A composite request may involve several sub‑services that are executed concurrently or sequentially; the worker aggregates the results and returns a single response. If a sub‑service fails, the worker aborts the task and an AOP‑based retry advice is triggered automatically.

The Check‑List pattern acts as a pre‑condition verifier for composite services. It maintains a list of required sub‑services, checks their presence and compatibility across the network, and, when a needed service is missing, triggers dynamic injection of that service as an Aspectual Feature Module (AFM). AFM is essentially a bundle of code (advice, interceptors, and implementation classes) that can be loaded at runtime and woven into the existing service chain without restarting the peer. Class‑loader isolation and a metadata registry prevent version clashes.

All components are built on top of a Service‑Oriented Architecture (SOA). Service interfaces are described with WSDL, and concrete implementations are exposed via Java JAX‑WS and RMI. Each peer maintains a local service registry and participates in a distributed hash‑table‑like exchange of service descriptors. When a client issues a composite request, the following sequence occurs:

1. Check‑List verification – ensures all required sub‑services are discoverable.
2. Strategy selection – chooses the optimal providers based on current metrics.
3. Worker execution – launches asynchronous tasks for each sub‑service.
4. AOP advice – monitors execution, performs retries, and injects AFMs if a service is unavailable.
5. Result aggregation – the worker compiles sub‑responses and returns the final composite result.

UML class and sequence diagrams are provided to illustrate the relationships among Strategy, Worker, Check‑List, ServiceRegistry, and AspectualFeatureModule, as well as the runtime interaction flow.

Performance experiments compare the proposed pattern with a conventional static binding approach. The composite pattern reduces average response time by roughly 23 % and cuts service‑failure recovery time by about 40 %. Memory consumption also drops by ~15 % because only the services required at a given moment are loaded into the JVM. These figures demonstrate that the pattern simultaneously improves scalability, self‑healing, and resource efficiency.

The authors acknowledge several limitations. Dynamic loading of AFMs can lead to class‑loading conflicts if not carefully isolated, and the proliferation of AOP pointcuts may increase maintenance complexity. To mitigate these issues, future work will explore integration with OSGi‑style modular frameworks for robust version management and will develop meta‑programming tools that automatically generate pointcut definitions from high‑level service contracts. Security considerations for runtime code injection are also mentioned as an area for further study.

In conclusion, the paper presents a comprehensive, pattern‑driven methodology for achieving adaptive service injection and composition in P2P environments. By weaving together Strategy, Worker Object, Check‑List, and AOP, the authors deliver a system capable of dynamic reconfiguration, automatic fault recovery, and on‑demand service extension—capabilities that are increasingly relevant for modern distributed architectures such as micro‑services, edge computing, and decentralized cloud platforms.