Home 

The Enterprise Architecture Blog



 

  Technology   >>  enterprise architecture   >>  service oriented architecture   >>  10 soa design patterns every architect should know

10 Soa Design Patterns Every Architect Should Know

        posted by John Spacey, Simplicable, February 11, 2011

These 10 SOA design patterns are so important and widely used that they almost seem a little obvious.

1. Agnostic Services

Agnostic services implement logic that is common to multiple business problems. Separating agnostic logic into discrete services facilitates service reuse and composability.

soa design pattern
principles: reuse, service composability

2. Agnostic Service Declaration

Agnostic services should explicitly declare that they are agnostic. This makes it clear to future designers and builders which services are designed to be reused.

architectural pattern
principles: reuse, service composability

3. Atomic Service Transaction

Services can be wrapped in atomic transactions with a rollback feature that reverses all actions and changes. Transaction management services can be implemented in the component layer and reused by multiple services.

soa design patterns
principles: service statelessness

4. Enterprise Service Bus (ESB)

An ESB acts as a message broker between consumers and services. The ESB can perform message transformations, routing and connect to applications via a variety of communication protocols.

enterprise service bus
principles: loose coupling, interoperability, endpoint abstraction

5. Service Façade

A service façade sits between a service and a contract. It eliminates the tight coupling between the service and its contract. This is intended to minimize changes to the service if the contract changes. A service can have multiple service façades to support multiple contracts.

soa example
principles: loose coupling

6. Service Callback

A service requires its consumers to call it asynchronously. If the consumer needs a response it provides a callback address. When the service reaches some milestone in processing it messages the consumer with a response. This approach frees resources and is useful when services are expected to be long running.

service oriented architecture pattern
principles: loose coupling

7. Multiple Service Contracts

A service may support multiple contracts concurrently. This can be done to support backward compatibility (so that when a service changes all the consumers do not have to be updated). It is also done to provide different views to the service for different purposes (thus facilitating reuse).

soa architecture
principles: reuse, loose coupling

8. Authentication Broker

An authentication broker assumes responsibility for authenticating consumers. Consumers are issued a token they can use to access services.

soa patterns
principles: service composability

9. Message Origin Authentication

Digital certificates are used to authenticate clients.

service oriented architecture
principles: service composability

10. Message Screening

Messages are screened for harmful data before processing.

soa security
principles: standard service contract

   

Latest 10 Soa Design Patterns Every Architect Should Know Photos
architectural-pattern
enterprise-service-bus
service-oriented-architecture-pattern
service-oriented-architecture
soa-architecture
soa-design-pattern
soa-design-patterns
soa-example
soa-patterns
soa-security


     All 10 Soa Design Patterns Every Architect Should Know photos (10)



Permalink:
http://simplicable.com/new/10-soa-design-patterns-every-architect-should-know


People who viewed this also viewed

    10 Questions That Pop Up In Every Enterprise Architecture Interview        Enterprise Architecture
    Understand Enterprise Architecture With These 7 Simple Diagrams        Saas Vs The Control Freaks
    101 Enterprise Architecture Interview Questions        The 9 Secrets Of Successful Enterprise Architecture
    7 Common Mistakes Enterprise Architects Make        Event Driven Architecture
    10 Reasons Enterprise Architecture Is The Best Investment Any Company Can Make        The Lazy Architect's Guide to Enterprise Software
Home »