Service A is an entity service that provides a Get capability that returns a data value that is
frequently changed.
Service Consumer A invokes Service A in order to request this data value (1). For Service
A to carry out this request, it must invoke Service B (2), a utility service that interacts (3.4)
with the database in which the data value is stored. Regardless of whether the data value
changed, Service B returns the latest value to Service A (5), and Service A returns the
latest value to Service Consumer A (6).
The data value is changed when the legacy client program updates the database (7) When
this change happens is not predictable. Note also that Service A and Service B are not
always available at the same time.
Any time the data value changes. Service Consumer A needs to receive it as soon as
possible. Therefore, Service Consumer A initiates the message exchange shown in the
Figure several times a day. When it receives the same data value as before, the response
from Service A is ignored. When Service A provides an updated data value, Service
Consumer A can process it to carry out its task.

The current service composition architecture is using up too many resources due to the
repeated invocation of Service A by Service Consumer A and the resulting message
exchanges that occur with each invocation. What steps can be taken to solve this problem?

• A. None of the above.
• B. The Event-Driven Messaging pattern can be applied by establishing a subscriber-
  publisher relationship between Service A and Service B . This way, every time the data
  value is updated, an event is triggered and Service B, acting as the publisher, can notify
  Service A, which acts as the subscriber. The Asynchronous Queuing pattern can be
  applied between Service A and Service B so that the event notification message sent out
  by Service B will be received by Service A, even when Service A is unavailable.
• C. The Event-Driven Messaging pattern can be applied by establishing a subscriber-
  publisher relationship between Service Consumer A and Service A . This way, every time
  the data value is updated, an event is triggered and Service A, acting as the publisher, can
  notify Service Consumer A, which acts as the subscriber. The Asynchronous Queuing
  pattern can be applied between Service Consumer A and Service A so that the event
  notification message sent out by Service A will be received by Service Consumer A, even
  when Service Consumer A is unavailable.
• D. The Asynchronous Queuing pattern can be applied so that messaging queues are
  established between Service A and Service B and between Service Consumer A and
  Service A . This way, messages are never lost due to the unavailability of Service A or
  Service B.

The architecture for Service A displayed in the Figure shows how the core logic of Service
A has expanded over time to connect to a database and a proprietary legacy system (1)
and to support two separate service contracts (2) that are accessed by different service
consumers.
The service contracts are fully decoupled from the service logic. The service logic is
therefore coupled to the service contracts and to the underlying implementation resources
(the database and the legacy system).
Service A currently has three service consumers. Service Consumer A and Service
Consumer B access Service A's two service contracts (3, 4). Service Consumer C
bypasses the service contracts and accesses the service logic directly (5).

You are told that the database and legacy system that are currently being used by Service
A are being replaced with different products. The two service contracts are completely
decoupled from the core service logic, but there is still a concern that the introduction of the
new products will cause the core service logic to behave differently than before. What steps
can be taken to change the Service A architecture in preparation for the introduction of the
new products so that the impact on Service Consumers A, B, and C is minimized?

• A. The Service Facade pattern can be applied to position Facade components between the
  core service logic and the two service contracts. These Facade components will be
  designed to regulate the behavior of Service A . The Contract Centralization pattern can
  also be applied to force Service Consumer C to access Service A via one of its existing
  service contracts.
• B. None of the above.
• C. The Service Abstraction principle can be applied to hide the implementation details from
  the core service logic of Service A, thereby shielding this logic from changes to the
  implementation. In support of this, the Service Facade pattern can be applied to position
  Facade components between the core service logic and Service Consumers A and B.
  These Facade components will be designed to regulate the behavior of Service A . The
  Contract Centralization pattern can be applied to force Service Consumer C to access
  Service A via one of its existing service contracts.
• D. A third service contract can be added together with the application of the Contract
  Centralization pattern. This will force Service Consumer C to access Service A via the new
  service contract. The Service Facade pattern can be applied to position a Facade
  component between the new service contract and Service Consumer C in order to regulate
  the behavior of Service A . The Service Abstraction principle can be applied to hide the
  implementation details of Service A so that no future service consumers are designed to
  access any of Service A's underlying resources directly.

Service Consumer A sends a message to Service A.
Before the message arrives with Service A, it is intercepted by Service Agent A (1). which checks the message for
compliance to Policy A that is required by Service A.
If the message fails compliance, Service Agent A will not allow it to proceed and will instead write the message contents to a
log. If the message does comply to the policy, it continues to be transmitted toward Service
A, but before it arrives it is intercepted by Service Agent B (2), which validates the security
credentials in the message header. If the security credential validation fails, the message is
rejected and a runtime exception is raised. If the security credentials are validated, the
message is sent to Service A.
Upon receiving the message, Service A retrieves a data value from a database and
populates the message header with this data value (3) prior to forwarding the message to
Service B.
Before the message arrives at Service B.
it is intercepted by Service Agent C (4) which checks the message for compliance with two policies: Policy B and Policy C.
Policy
B is identical to Policy A that was checked by Service Agent A.
To check for compliance to Policy C.
Service Agent C uses the data value added by Service A.
If the message complies with both of the policies, it is forwarded to Service B (5), which stores the message contents in its own database.

You are told that Policy B and Policy C have changed. Also, in order to carry out the
compliance check of Policy C, Service Agent C will now require a new data value from the
Service B database. How can this service composition architecture be changed to fulfill
these new requirements?

• A. The Policy Centralization pattern can be applied so that only one service agent is used
  to enforce Policy A and Policy B.
  Service Consumer A is redesigned to first query Service
  B for the value required by Service Agent C.
  This way, Service Consumer A can include this value in the message header prior to sending the message to Service A .
• B. None of the above.
• C. The Policy Centralization pattern can be applied so that only one service agent is used
  to enforce Policy A and Policy B.
  Service A is redesigned to first query Service B for the value required by Service Agent C to check the compliance of the updated Policy C.
  If the compliance check is successful, the message is sent to Service B .
• D. The Policy Centralization pattern can be applied so that only one service agent is used
  to enforce Policy A and Policy B.
  The policy enforcement logic for Policy C is removed from
  Service Agent C and instead embedded within the logic of Service B . This way, Service B
  can itself retrieve the value required to check compliance with Policy C.
  If the message received is not in compliance, Service B will reject it.

Service A is an entity service that provides a Get capability that returns a data value that is
frequently changed.
Service Consumer A invokes Service A in order to request this data value (1). For Service
A to carry out this request, it must invoke Service B (2), a utility service that interacts (3.4)
with the database in which the data value is stored, Regardless of whether the data value
changed. Service B returns the latest value to Service A (5), and Service A returns the
latest value to Service Consumer A (6).
The data value is changed when the legacy client program updates the database (7). When
this change happens is not predictable. Note also that Service A and Service B are not
always available at the same time.
Any time the data value changes. Service Consumer A needs to receive it as soon as
possible. Therefore, Service Consumer A initiates the message exchange shown in the
Figure several times a day. When it receives the same data value as before, the response
from Service A is ignored. When Service A provides an updated data value, Service
Consumer A can process it to carry out its task.

Because Service A and Service B are not always available at the same times, messages
are getting lost and several invocation attempts by Service Consumer A fail. What steps
can be taken to solve this problem?

• A. The Asynchronous Queuing pattern can be applied so that messaging queues are
  established between Service A and Service B and between Service Consumer A and
  Service A . This way, messages are never lost due to the unavailability of Service A or
  Service B .
• B. None of the above.
• C. The Asynchronous Queuing pattern can be applied so that a messaging queue is
  established between Service Consumer A and Service A.
  This way, messages are never lost due to the unavailability of Service A or Service B.
  The Service Agent pattern can be
  further applied to establish a service agent that makes a log entry each time a runtime exception occurs.
• D. The Asynchronous Queuing pattern can be applied so that a messaging queue is
  established between Service A and Service B . This way, messages are never lost due to
  the unavailability of Service A or Service B . The Service Agent pattern can be further
  applied to establish a service agent that makes a log entry and issues a notification when
  re-transmission attempts by the messaging queue exceeds a pre-determined quantity.