When Service A receives a message from Service Consumer A(1),the message is
processed by Component A.
This component first invokes Component B (2), which uses values from the message to query Database A in order to retrieve additional data.
Component B then returns the additional data to Component A.
Component A then invokes Component C (3), which interacts with the API of a legacy
system to retrieve a new data value. Component C then returns the data value back to
Component A.
Next, Component A sends some of the data it has accumulated to Component D (4), which
writes the data to a text file that is placed in a specific folder. Component D then waits until
this file is imported into a different system via a regularly scheduled batch import. Upon
completion of the import, Component D returns a success or failure code back to
Component A.
Component A finally sends a response to Service Consumer A (5) containing all of the data
collected so far and Service Consumer A writes all of the data to Database B (6).
Components A, B, C.
and D belong to the Service A service architecture. Database A, the legacy system, and the file folders are shared resources within the IT enterprise.

Service A is a task service that completes an entire business task on its own without having
to compose other services. However, you have received many complaints about the
reliability of Service A . Specifically, it has three problems. First, when Component B
accesses Database A, it may not receive a response for several minutes when the
database is being accessed by other applications in the IT enterprise. Secondly, the legacy
system accessed by Component C frequently crashes and therefore becomes unavailable
for extended periods of time. Third, for Component D to respond to Component A, it must
first wait for the batch import of the files to occur. This can take several minutes during
which Service Consumer A remains stateful and consumes excessive memory. What steps
can be taken to address these three problems?

• A. The Service Data Replication pattern can be applied so that Component B can access a
  replicated database instead of having to access the shared Database A directly. The
  Legacy Wrapper pattern can be applied so that Component C is separated into a separate
  service that acts as a wrapper of the legacy system API. Next, the Reliable Messaging
  pattern can be applied so that acknowledgements are issued from the new wrapper service
  to Component A, thereby enabling notifying Component A during times when the legacy
  system is unavailable. Finally, Component D is separated into a separate service and the
  Event-Driven Messaging pattern is applied to establish a publisher-subscriber relationship
  between this new service and Component A.
  The interaction between Service Consumer A and Component A is then redesigned so that Component A first interacts with Component
  B and the new wrapper service. Service A then issues a final message back to Service
  Consumer A.
• B. None of the above.
• C. The Service Data Replication pattern can be applied so that Component B can access a
  replicated database instead of having to access the shared Database A directly. The
  Legacy Wrapper pattern can be applied so that Component C is separated into a separate
  service that acts as a wrapper of the legacy system API. Next, the Asynchronous Queuing
  pattern can be applied so that a messaging queue is positioned between Component A and
  the new wrapper service, thereby enabling communication during times when the legacy
  system is unavailable. Finally, Component D is separated into a new service and the
  Event-Driven Messaging pattern is applied to establish a publisher-subscriber relationship
  between this service and Component A and between Service A and Service Consumer A.
  The interaction logic is redesigned as follows: Component A interacts with Component B,
  the new wrapper service, and then issues a request to the new event-driven service. Upon
  receiving a response triggered by the event related to the batch import, Service A responds
  to Service Consumer A.
• D. The Legacy Wrapper pattern can be applied so that Component B is separated to wrap
  the shared database, thereby allowing Component A to interact with this new service
  instead of directly interacting with the database. The Legacy Wrapper pattern can be
  applied again so that Component C is separated into a separate service that acts as a
  wrapper of the legacy system API. Component D can then be separated into a separate
  service and the Event-Driven Messaging pattern can be applied to establish a publisher-
  subscriber relationship between this new service and Component A and between Service A
  and Service Consumer A.
  The interaction between Service Consumer A and Component A is then redesigned so that Component A issues a message back to Service Consumer A
  when the event related to the batch import is triggered.

You are told that in this service composition architecture, all four services are exchanging
invoice-related data in an XML format. The services in Service Inventory A are
standardized to use a specific XML schema for invoice data. Design standards were not
applied to the service contracts used in Service Inventory B, which means that each
service uses a different XML schema for the same kind of data. Database A and Database
B can only accept data in the Comma Separated Value (CSV) format and therefore cannot
accept XML formatted data. What steps can be taken to enable the planned data exchange
between these four services?

• A. None of the above.
• B. The Data Model Transformation pattern can be applied so that data model
  transformation logic is positioned between Service A and Service C . The Protocol Bridging
  pattern can be applied so that protocol bridging logic is positioned between Service A and
  Service B and between the Service C and Service D . The Data Format Transformation
  pattern can be applied so that data format transformation logic is positioned between the
  Service B logic and Database A and between the Service D logic and Database B.
• C. The Data Model Transformation pattern can be applied so that data model
  transformation logic is positioned between Service A and Service B, between Service A
  and Service C, and between Service C and Service D . The Data Format Transformation
  pattern can be applied so that data format transformation logic is positioned between the
  Service B logic and Database A and between the Service D logic and Database B.
• D. The Data Model Transformation pattern can be applied so that data model
  transformation logic is positioned between Service A and Service C and between Service C
  and Service D . The Data Format Transformation pattern can be applied so that data
  format transformation logic is positioned between the Service B logic and Database A and
  between the Service D logic and Database B.

Currently, due to the increasing amount of concurrent access by service consumers, the
runtime performance of both the Client and Vendor services has worsened and has
therefore reduced their effectiveness as service composition members. Additionally, a
review of the logic of both services has revealed that some of the business rules used by
the Client and Vendor services are actually the same. What steps can be taken to improve
performance and reduce redundant business rule logic?

• A. The Rules Centralization pattern can be applied by extracting the business rule logic
  from the Client and Vendor services and placing it into a new Rules service, thereby
  reducing the redundancy of business rules logic. The Redundant Implementation pattern
  can then be applied to establish a scalable Rules service that is capable of supporting
  concurrent access from many service consumers.
• B. None of the above.
• C. The Rules Centralization pattern can be applied to isolate business rules logic into a
  central and reusable Rules service. Additionally, the Service Abstraction principle can be
  applied to hide the implementation details of new the Rules service.
• D. The Redundant Implementation pattern can be applied to the Client and Vendor
  services, thereby establishing duplicate service implementations that can be accessed
  when a service reaches its runtime usage threshold. The Intermediate Routing pattern can
  be further applied to provide load balancing logic that can, at runtime, determine which of
  the redundant service implementations is the least busy for a given service consumer
  request.

Service Consumer A sends Service A a message containing a business document (1). The
business document is received by Component A, which keeps the business document in
memory and forwards a copy to Component B (3). Component B first writes portions of the
business document to Database A (4).
Component B writes the entire business document to Database B and then uses some of
the data values from the business document as query parameters to retrieve new data from
Database B (5).
Next, Component B returns the new data back to Component A (6), which merges it
together with the original business document it has been keeping in memory and then
writes the combined data to Database C (7). The Service A service capability invoked by
Service Consumer A requires a synchronous request-response data exchange. Therefore,
based on the outcome of the last database update, Service A returns a message with a
success or failure code back to Service Consumer A (8).
Databases A and B are shared and Database C is dedicated to the Service A service
architecture.

There are several problems with this architecture: First, the response time of Database A is
often poor, resulting in Component B taking too much time to provide a response to
Component A.
This results in Component A consuming too many runtime resources while it
holds the business document in memory and it also causes unreasonable delays in
responding to Service Consumer A.
Additionally, Database B is being replaced with a different database product that supports a proprietary file format. This will disable the
current interaction between Component B and the new Database B.
What steps can be taken to solve these problems?

• A. The Legacy Wrapper pattern is applied so that Database B is wrapped in a standardized
  contract. This will establish a new wrapper utility service that will allow Database B to be
  replaced with a different database product without affecting Service A . The Data Format
  Transformation pattern can be applied within the new wrapper utility service to enable it to
  convert to and from the new proprietary file format. The Service Data Replication pattern is
  applied so that Component B can interact with a database that is replicated from the
  shared Database B, regardless of what database product is used to replace Database B.
  The Service Abstraction principle can be further applied to hide the implementation details,
  including the changes mentioned in this solution, from Service Consumer A.
• B. None of the above.
• C. The State Repository pattern is applied so that Component A can defer the business
  document data to a state database while it waits for a response from Component B.
  The Service Data Replication pattern is applied so that Component B can interact with a
  database that is replicated from the shared Database A.
  This will improve performance and reliability that will affect both Component A and Service Consumer A.
  Finally, the Legacy Wrapper pattern is applied so that Database B is wrapped in a standardized contract. This
  will establish a new wrapper utility service that will allow Database B to be replaced with a
  different database product without affecting Service A . Furthermore, the Data Format
  Transformation pattern can be applied within the new wrapper utility service to enable it to
  convert to and from the new proprietary file format.
• D. The State Repository pattern is applied so that Component A can defer the business
  document data to a state database while it waits for a response from Component B.
  The Asynchronous Queuing pattern can be applied so that a messaging queue is established
  between Service Consumer A and Service A, thereby guaranteeing delivery and avoiding
  Service Consumer A from being tied up too long waiting for Service A to respond. Finally,
  the Data Format Transformation pattern can be applied to enable Component B to convert
  to and from the new proprietary file format introduced by the database product that is
  replacing Database B.