Oracle SOA Suite 11g R1 Developer's Guide. Service-Oriented Architecture (SOA) is made easily accessible thanks to this comprehensive guide. With a logically structured approach, it gives you the expertise to start using the Oracle SOA suite in real-world applications - E-book - Antony Reynolds, Matt Wright, Matthew Wright - Moderne lernplattform

Details zum E-Book

Einloggen, wenn Sie am Inhalt des Artikels interessiert sind.

Oracle SOA Suite 11g R1 Developer's Guide. Service-Oriented Architecture (SOA) is made easily accessible thanks to this comprehensive guide. With a logically structured approach, it gives you the expertise to start using the Oracle SOA suite in real-world applications

Antony Reynolds, Matt Wright, Matthew Wright

E-book

We are moving towards a standards-based Service-Oriented Architecture (SOA), where IT infrastructure is continuously adapted to keep up with the pace of business change. Oracle is at the forefront of this vision, with the Oracle SOA Suite providing the most comprehensive, proven, and integrated tool kit for building SOA-based applications.Developers and Architects using the Oracle SOA Suite, whether working on integration projects, building composite applications, or specializing in implementations of Oracle Applications, need a hands-on guide on how best to harness and apply this technology. This book will guide you on using and applying the Oracle SOA Suite to solve real-world problems, enabling you to quickly learn and master the technology and its applications.This book is a major update to Oracle SOA Suite Developer's Guide, which covered 10gR3. It is completely updated for Oracle SOA Suite 11gR1, with 40% new material, including detailed coverage of newer components, such as: the Mediator, the new Rules Editor, the Event Delivery Network, Service Data Objects, and the Meta Data Repository. There is also a complete additional chapter on advanced SOA Architecture including message delivery, transaction handling and clustering considerations.The initial section of the book provides you with a detailed hands-on tutorial to each of the core components that make up the Oracle SOA Suite. Once you are familiar with the various pieces of the SOA Suite and what they do, the next question will typically be:What is the best way to use and combine all of these different components to implement a real-world SOA solution?Answering this question is the goal of the next section. Using a working example of an online auction site (oBay), it leads you through key SOA design considerations in implementing a robust solution that is designed for change.The final section addresses non-functional considerations and covers the packaging, deployment, and testing of SOA applications. It then details how to secure and administer SOA applications.

Oracle SOA Suite 11g R1 Developers Guide
- Table of Contents
- Oracle SOA Suite 11g R1 Developer's Guide
- Credits
- Foreword
- About the Authors
- Acknowledgement
- Acknowledgement
- About the Reviewers
- Preface
  - What this book covers
  - What you need for this book
  - Who this book is for
  - Conventions
  - Reader feedback
  - Customer support
    - Errata
    - Piracy
    - Questions
- I. Getting Started
  - 1. Introduction to Oracle SOA Suite
    - Service-oriented architecture in short
      - Service
      - Orientation
      - Architecture
    - Why SOA is different
      - Terminology
      - Interoperability
      - Extension and evolution
      - Reuse in place
    - Service Component Architecture (SCA)
      - Component
      - Service
      - Reference
      - Wire
      - Composite.xml
      - Properties
    - SOA Suite components
      - Services and adapters
      - ESB service abstraction layer
        
        Oracle Service Bus and Oracle Mediator
      - Service orchestration the BPEL process manager
      - Rules
      - Security and monitoring
        
        Active monitoring BAM
      - Business to Business B2B
      - Complex Event Processing CEP
      - Event delivery network
    - SOA Suite architecture
      - Top level
      - Component view
      - Implementation view
      - A recursive example
    - JDeveloper
    - Other components
      - Service repository and registry
        
        BPA Suite
      - The BPM Suite
      - Portals and WebCenter
      - Enterprise manager SOA management pack
    - Summary
  - 2. Writing your First Composite
    - Installing SOA Suite
    - Writing your first BPEL process
      - Creating an application
      - Creating an SOA project
      - SOA project composite templates
      - Creating a BPEL process
        
        Assigning values to variables
      - Deploying the process
      - Testing the BPEL process
      - Adding a Mediator
      - Using the Service Bus
    - Writing our first proxy service
      - Writing the Echo proxy service
      - Creating a Change Session
      - Creating a project
        
        Creating the project folders
      - Creating service WSDL
        
        Importing a WSDL
      - Creating our business service
      - Creating our proxy service
        
        Creating message flow
        
        Activating the Echo proxy service
        
        Testing our proxy service
    - Summary
  - 3. Service-enabling Existing Systems
    - Types of systems
      - Web service interfaces
      - Technology interfaces
      - Application interfaces
    - Java Connector Architecture
    - Creating services from files
      - A payroll use case
      - Reading a payroll file
        
        Starting the wizard
        
        Naming the service
        
        Identifying the operation
        
        Defining the file location
        
        Selecting specific files
        
        Detecting that the file is available
        
        Message format
        
        Defining a native format schema
        
        Using a sample file
        
        Record structure
        
        Choosing a root element
        
        Message delimiters
        
        Record type names
        
        Field properties
        
        Verifying the result
        
        Finishing the wizards
      - Throttling the file and FTP adapter
        
        Creating a dummy message type
        
        Adding an output message to the read operation
        
        Using the modified interface
      - Writing a payroll file
        
        Selecting the FTP connection
        
        Choosing the operation
        
        Selecting the file destination
        
        Completing the FTP file writer service
      - Moving, copying, and deleting files
        
        Generating an adapter
        
        Modifying the port type
        
        Modifying the binding
        
        Configuring file locations through additional header properties
      - Adapter headers
      - Testing the file adapters
    - Creating services from databases
      - Writing to a database
        
        Selecting the database schema
        
        Identifying the operation type
        
        Identifying tables to be operated on
        
        Identifying the relationship between tables
        
        Under the covers
    - Summary
  - 4. Loosely-coupling Services
    - Coupling
      - Number of input data items
      - Number of output data items
      - Dependencies on other services
      - Dependencies of other services on this service
      - Use of shared global data
      - Temporal dependencies
    - Reducing coupling in stateful services
    - Service abstraction tools in SOA Suite
      - Do you have a choice?
      - When to use the Mediator
      - When to use Oracle Service Bus
    - Oracle Service Bus design tools
      - Oracle Workshop for WebLogic
      - Oracle Service Bus Console
    - Service Bus overview
      - Service Bus message flow
    - Virtualizing service endpoints
      - Moving service location
      - Using Adapters in Service Bus
      - Selecting a service to call
    - Virtualizing service interfaces
      - Physical versus logical interfaces
      - Mapping service interfaces
      - Applying canonical form in the Service Bus
        
        An important optimization
    - Using the Mediator for virtualization
    - Summary
  - 5. Using BPEL to Build Composite Services and Business Processes
    - Basic structure of a BPEL process
      - Core BPEL process
        
        Variables
      - Partner links
      - Messaging activities
        
        Synchronous messaging
        
        Asynchronous messaging
        
        One way messaging
    - A simple composite service
      - Creating our StockQuote service
        
        Importing StockService schema
      - Calling the external web services
        
        Calling the web service
        
        Assigning values to variables
        
        Testing the process
        
        Calling the exchange rate web service
        
        Assigning constant values to variables
        
        Using the expression builder
      - Asynchronous service
        
        Using the wait activity
      - Improving the stock trade service
        
        Creating the while loop
        
        Checking the price
        
        Using the switch activity
    - Summary
  - 6. Adding in Human Workflow
    - Workflow overview
    - Leave approval workflow
      - Defining the human task
        
        Specifying task parameters
        
        Specifying task assignment and routing policy
      - Invoking our human task from BPEL
      - Creating the user interface to process the task
        
        Running the workflow process
    - Processing tasks with the worklist application
    - Improving the workflow
      - Dynamic task assignment
        
        Assigning tasks to multiple users or groups
      - Cancelling or modifying a task
        
        Withdrawing a task
        
        Modifying a task
        
        Difference between task owner and initiator
      - Requesting additional information about a task
    - Managing the assignment of tasks
      - Reassigning reportee tasks
        
        Reassigning your own task
        
        Delegating tasks
        
        Escalating tasks
      - Using rules to automatically manage tasks
        
        Setting up a sample rule
    - Summary
  - 7. Using Business Rules to Define Decision Points
    - Business rule concepts
      - XML facts
      - Decision services
    - Leave approval business rule
      - Creating a decision service
      - Implementing our business rules
      - Adding a rule to our ruleset
        
        Creating the IF clause
        
        Creating the Then clause
    - Calling a business rule from BPEL
      - Assigning facts
    - Using functions
      - Creating a function
      - Testing a function
      - Testing decision service functions
      - Invoking a function from within a rule
    - Using decision tables
      - Defining a bucket set
      - Creating a decision table
      - Conflict resolution
    - Summary
  - 8. Using Business Events
    - How EDN differs from traditional messaging
    - A sample use case
    - Event Delivery Network essentials
      - Events
      - Event publishers
        
        Publishing an event using the Mediator component
        
        Publishing an event using BPEL
        
        Publishing an event using Java
        
        Creating the event
        
        Creating the event connection
        
        Publishing the event
      - Event subscribers
        
        Consuming an event using Mediator
        
        Consuming an event using BPEL
    - EDN publishing patterns with SOA Suite
      - Publishing an event on receipt of a message
      - Publishing an event on a synchronous message response
      - Publishing an event on a synchronous message request and reply
      - Publishing an event on an asynchronous response
      - Publishing an event on an asynchronous message request and reply
      - Publishing an event on an event
    - Monitoring event processing in Enterprise Manager
    - Summary
  - 9. Building Real-time Dashboards
    - How BAM differs from traditional business intelligence
      - Oracle BAM scenarios
    - BAM architecture
      - Logical view
      - Physical view
        
        Acquire
        
        Store
        
        Process
        
        Deliver
      - Steps in using BAM
      - User interface
    - Monitoring process state
      - Defining reports and data required
      - Defining data objects
        
        A digression on populating data object fields
      - Instrumenting BPEL and SCA
        
        Invoking the BAM adapter as a regular service
        
        Creating a BAM adapter
        
        Invoking the BAM adapter
        
        Invoking the BAM adapter through BPEL sensors
      - Testing the events
      - Creating a simple dashboard
    - Monitoring process status
    - Monitoring KPIs
    - Summary
- II. Putting it All Together
  - 10. oBay Introduction
    - oBay requirements
      - User registration
        
        User login
      - Selling items
        
        List a new item
        
        Completing the sale
        
        View account
      - Buying items
        
        Search for items
        
        Bidding on items
    - Defining our blueprint for SOA
      - Architecture goals
      - Typical SOA Architecture
        
        Application services layer
        
        Virtual services layer
        
        Business services layer
        
        Functional type
        
        Service consumer
        
        Business process
        
        User interface layer
        
        One additional layer
    - Where the SOA Suite fits
      - Composite application
        
        Composite granularity
        
        Composite reusability
        
        Composite lifecycle
        
        Composite security and management policies
        
        Basic composite design pattern
      - Where to implement virtual services
        
        Mediator as a proxy for a composite
        
        Mediator as a proxy for an external reference
        
        Using a composite as a virtual service
        
        Service invocation between composite applications
        
        Centralized approach
        
        Peer-to-peer topology
        
        Hybrid approach
    - oBay high-level architecture
      - oBay application services
        
        Workflow services
        
        External web services
        
        oBay developed services
      - oBay internal virtual services
      - oBay business services
        
        oBay business processes
      - oBay user interface
    - Summary
  - 11. Designing the Service Contract
    - Using XML Schema to define business objects
      - Modeling data in XML
        
        Data decomposition
        
        Data hierarchy
        
        Data semantics
        
        Using attributes for metadata
      - Schema guidelines
        
        Element naming
        
        Name length
        
        Compound names
        
        Naming standards
        
        Namespace considerations
        
        Always specify a target namespace
        
        Default namespace
        
        Qualified or unqualified element names
        
        Qualified or unqualified attributes
        
        Namespace naming conventions
        
        Global versus local
        
        Elements versus types
      - Partitioning the canonical model
        
        Single namespace
        
        Multiple namespaces
        
        Separate common objects into their own namespaces
    - Using WSDL to define business services
      - Use Document (literal) wrapped
      - Building your abstract WSDL document
        
        WSDL namespace
        
        Defining the 'wrapper' elements
        
        Defining a schema for our wrapper elements
        
        Importing our wrapper elements
        
        Defining the 'message' elements
        
        Defining the 'PortType' Element
    - Using XML Schema and the WSDL within SOA Suite
      - Sharing XML Schemas across composites
        
        Defining an MDS connection
        
        Importing schemas from MDS
        
        Manually importing schemas
        
        Deploying schemas to the SOA infrastructure
        
        Creating a JAR file within JDeveloper
        
        Creating an SOA Bundle for a JAR file
      - Importing the WSDL document into a composite
      - Sharing XML Schemas in the Service Bus
      - Importing the WSDL document into the Service Bus
    - Strategies for managing change
      - Major and minor versions
        
        Service implementation versioning
      - Schema versioning
        
        Changing schema location
        
        Updating schema version attribute
        
        Resisting changing the schema namespace
      - WSDL versioning
        
        Incorporating changes to the canonical model
        
        Changes to the physical contract
        
        Updating the service endpoint
        
        Including version identifiers in the WSDL definition
        
        Managing the service lifecycle
    - Summary
  - 12. Building Entity Services Using Service Data Objects (SDOs)
    - Service Data Objects
      - Oracle 11g R1 support for SDO
        
        Oracle SOA Suite 11g SDO support
    - Implementing a Service Data Object
      - Overview of ADF Business Components
      - Creating our ListingSDO application
        
        Creating our Listing Business Components
        
        Defining Entity objects
        
        Defining updatable View objects
        
        Defining the application module
        
        Testing the listing ADF-BC in JDeveloper
      - Generating the primary key using an Oracle Sequence
        
        Creating the ADF extension class for EntityImpl
        
        Updating default ADF base classes
        
        Configuring Listing entity to use Oracle Sequence
      - Creating the ListingSDO service interface
        
        Enabling master detail updates
      - Deploying the Service Data Object
        
        Creating a service deployment profile
        
        Setting Web Context Root
      - Registering SDO with SOA infrastructure
        
        Registering the ListingSDO as an RMI service
        
        Configuring global JDBC data source
        
        Determining the SDO registry key
    - Using the ListingSDO in an SOA composite
      - Creating an ADF-BC Service Reference
      - Invoking the SDO from BPEL
        
        Creating an entity variable
        
        Creating a Listing entity
        
        Binding to the Listing entity
        
        Inserting a detail SDO into a master SDO
        
        Updating a detail SDO
        
        Deleting a detail SDO
        
        Deleting a Service Data Object
      - Exposing the SDO as a business service
    - Summary
  - 13. Building Validation into Services
    - Validation within a composite
    - Using XML Schema validation
      - Strongly-typed services
      - Loosely-typed services
      - Combined approach
      - Schema validation within the Mediator
        
        Using schema validation within BPEL PM
        
        Validation of BPEL variables
        
        Validation of inbound and outbound documents
        
        Setting validateXML for a partner link
      - Using schema validation within the Service Bus
        
        Validation of inbound documents
        
        Validation of outbound documents
    - Using Schematron for validation
      - Overview of Schematron
        
        Assertions
        
        Rules
        
        Using a relative context
        
        Patterns
        
        Namespaces
        
        Schema
      - Intermediate validation
        
        Cross field validation
        
        Using XPath predicates in rules
        
        Using XPath 2.0 functions
        
        Date validation
        
        Element present
      - Using Schematron within the Mediator
        
        Using the Metadata Service to hold Schematron files
        
        Returning Schematron errors
      - Using Schematron with the Service Bus
    - Putting validation in the underlying service
      - Using Business Rules for validation
      - Coding in validation
      - Returning validation failures in synchronous services
        
        Defining faults
        
        Custom fault codes
        
        Validation failures in asynchronous services
    - Layered validation considerations
      - Dangers of over validation
      - Dangers of under validation
      - Negative coupling of validation
    - Summary
  - 14. Error Handling
    - Business faults
      - Defining faults in synchronous services
      - Defining faults in asynchronous services
    - Handling business faults in BPEL
      - Catching faults
        
        Adding a catch branch
        
        Throwing faults
      - Compensation
        
        Defining compensation
        
        Triggering a Compensation handler
        
        Adding a Compensate activity
      - Returning faults
        
        Asynchronous Considerations
    - Handling business faults in Mediators
      - Synchronous Mediators
        
        System faults
      - Asynchronous Mediators
        
        Using timeouts
    - Using the fault management framework
      - Using the fault management framework in BPEL
      - Using the fault management framework in Mediator
      - Defining a fault policies file
        
        Defining a fault policy
      - Defining fault policy conditions
        
        Specifying the <faultName>
        
        Specifying the <condition>
      - Defining fault policy actions
        
        Retry action
        
        Human intervention action
        
        Abort action
        
        Rethrow action
        
        Replay scope action
        
        Java action
      - Binding fault policies
    - Defining bindings on the composite
      - Defining bindings on a component
        
        Defining bindings on an external reference
        
        Binding resolution
      - Using MDS to hold fault policy files
      - Human intervention in Fusion Middleware Control Console
    - Handling faults within the Service Bus
      - Handling faults in synchronous proxy services
        
        Raising an error
        
        Defining an error handler
        
        Adding a route error handler
        
        Checking the type of SOAP Faults
        
        Getting the qualified fault name
        
        Creating a SOAP Fault
        
        Handling unexpected faults
        
        Returning a SOAP Fault
        
        Adding a service error handler
        
        Handling permanent faults
        
        Generating alerts
        
        Enabling alerts
        
        Handling transient faults
        
        Retrying a non-responsive business service
      - Handling faults in one-way proxy services
    - Summary
  - 15. Advanced SOA Suite Architecture
    - Relationship of infrastructure to service engines
    - Composite execution and suspension
      - BPEL dehydration events
    - Threading and message delivery in SOA Suite
      - One-way message delivery
      - Immediate execution of one-way messages in BPEL
      - Activation agent threads
      - Dispatcher threads
    - Transactions
      - BPEL transactions
        
        BPEL component properties
        
        BPEL partner link properties
        
        BPEL activities
      - Transactions and thread wrinkles in BPEL
        
        Reply handling
      - Oracle Service Bus (OSB) transactions
        
        Transactional binding
        
        Non-transactional binding
        
        Non-transactional proxy
        
        Transactional proxy
      - Comparison to EJB
    - Clustering
      - Load balancing
      - JMS considerations
      - Testing considerations
      - Adapter considerations
      - Metadata repository considerations
        
        Database connections
    - Summary
  - 16. Message Interaction Patterns
    - Messaging within a composite
      - Processing of messages within the Mediator
      - Processing of messages within BPEL PM
    - Message addressing
      - Multi-protocol support
      - Message correlation
      - WS-Addressing
        
        Request message with WS-Addressing
        
        Response message with WS-Addressing
    - Using BPEL correlation sets
      - Using correlation sets for multiple process interactions
        
        Defining a correlation set property
        
        Defining correlation set
        
        Using correlation sets
        
        Initializing the correlation set
        
        Defining property aliases
    - Message aggregation
      - Message routing
        
        Correlating the callback
        
        Specifying the reply to address
      - Creating a proxy process
        
        Using the pick activity
        
        Defining the correlation sets
      - Completing the aggregation
    - Scheduling services
      - Defining the schedule file
      - Using FlowN
        
        Accessing branch-specific data in FlowN
      - Dynamic partner links
        
        Defining a common interface
        
        Defining a job partner link
        
        Creating an endpoint reference
        
        Updating the endpoint
      - Recycling the scheduling file
    - Summary
  - 17. Workflow Patterns
    - Managing multiple participants in a workflow
      - Using multiple assignment and routing policies
        
        Determining the outcome by a group vote
        
        Voting on the outcome
        
        Sharing attachments and comments
        
        Assigning participants
        
        Skipping the second step
      - Using multiple human tasks
        
        Linking individual human tasks
    - Using the workflow API
      - Defining the order fulfillment human task
        
        Specifying task parameters
        
        Specifying the routing policy
        
        Notification settings
      - Querying task instances
        
        Defining an external reference for the Task Query Service
        
        User authentication
        
        Creating the credential element
        
        Querying tasks
        
        Specifying the display column list
    - Flex fields
      - Populating flex fields
      - Accessing flex fields
      - Specifying the query predicate
      - Using flex fields in the query predicate
      - Ordering the data
    - Getting task details
    - Updating a task instance
    - Using the updateTask operation
    - Updating the task payload
    - Updating the task flex fields
    - Updating the task outcome
    - Summary
  - 18. Using Business Rules to Implement Services
    - How the rule engine works
      - Asserting facts
      - Executing the ruleset
        
        Rule activation
        
        Rule firing
      - Retrieving result
      - Session management
      - Debugging a ruleset
        
        Debugging a decision service with a test function
        
        Debugging a decision service within a composite
        
        Using the print function to add additional logging
    - Using business rules to implement auction
      - Defining our XML facts
      - Defining the business rule
        
        Configuring the decision function
        
        Deselect Check Rule Flow
        
        Asserting the XML tree
    - Using a global variable to reference the resultset
      - Defining a global variable
      - Defining a rule to initialize a global variable
    - Writing our auction rules
      - Evaluating facts in date order
        
        Checking for non-existent fact
        
        Updating the bid status
      - Using inference
        
        Processing the next valid bid
      - Using functions to manipulate XML facts
        
        Asserting a winning bid
        
        Retracting a losing bid
        
        Rules to process a new winning bid
        
        Validating the next bid
        
        Rule to process a losing bid
        
        Capping the winning bid amount
      - Complete ruleset
    - Performance considerations
      - Managing state within the BPEL process
        
        Using functions to control the assertion of facts
    - Summary
- III. Other Considerations
  - 19. Packaging and Deployment
    - The need for packaging
      - Problems with moving between environments
      - Types of interface
        
        Web interfaces
        
        Command-line interfaces
    - SOA Suite packaging
      - Oracle Service Bus
      - Oracle SOA composites
        
        Deploying a SCA composite via the EM Console
        
        Deploying a SCA composite using Ant
        
        Compile parameters (ant-sca-compile.xml)
        
        Package parameters (ant-sca-package.xml)
        
        Deploy parameters (ant-sca-deploy.xml)
        
        Test parameters (ant-sca-test.xml)
        
        Revisions and milestones
        
        The default revision
        
        Enabling web service endpoint and WSDL location alteration
        
        Enabling adapter configuration
        
        XML schema locations
        
        XSL imports
        
        Composite configuration plan framework
        
        Creating a configuration plan template
        
        Creating a configuration plan
        
        Attaching a configuration plan to an SCA archive
      - Web services security
      - Oracle rules
      - Business activity monitoring
        
        Commands
        
        Selecting items
        
        Using iCommand
    - Summary
  - 20. Testing Composite Applications
    - SOA Suite testing model
    - One-off testing
      - Testing composites
      - Testing the Service Bus
    - Automated testing
    - The composite test framework
    - Composite test suites
      - Injecting data into the test case
      - Data validation
      - Emulating components and references
      - Deploying and running test suites
    - Regression testing
    - System testing
    - Composite testing
    - Component testing
    - Unit testing
    - Performance testing
    - User interface testing
    - Summary
  - 21. Defining Security and Management Policies
    - Security and management challenges in the SOA environment
      - Evolution of security and management
      - Added complications of SOA environment
        
        Security Impacts of SOA
        
        Management and monitoring impacts of SOA
    - Securing services
      - Security outside the SOA Suite
        
        Network security
        
        Preventing message interception
        
        Restricting access to services
      - Declarative security versus explicit security
        
        Security as a facet
        
        Security as a service
      - Security model
      - Policy enforcement points
      - Policies
      - Agents and gateways
        
        Distinctive benefits of gateways and agents
        
        Benefits of gateways
        
        Drawbacks of gateways
        
        Benefits of agents
        
        Drawbacks of agents
        
        The gateway dilemma
      - Service Bus model
    - Defining policies
      - Creating a new policy to perform authentication and authorization
        
        Creating the authorization policy
        
        Oracle-recommended naming conventions for polices
        
        Creating the policy
        
        Applying a policy
      - Applying a policy through the Service Bus Console
        
        Importing a policy
        
        Applying OWSM policies in Service Bus
      - Final thoughts on security
    - Monitoring services
      - Monitoring service health in SOA Suite
        
        System up-down status
        
        System throughput view
        
        Monitoring SOA Composite performance
      - Monitoring in the Service Bus
        
        Creating an alert destination
        
        Enabling service monitoring
        
        Creating an alert rule
        
        Monitoring the service
      - What makes a good SLA
    - Summary
- Index

Titel: Oracle SOA Suite 11g R1 Developer's Guide. Service-Oriented Architecture (SOA) is made easily accessible thanks to this comprehensive guide. With a logically structured approach, it gives you the expertise to start using the Oracle SOA suite in real-world applications
Autor: Antony Reynolds, Matt Wright, Matthew Wright
Originaler Titel: Oracle SOA Suite 11g R1 Developer's Guide. Service-Oriented Architecture (SOA) is made easily accessible thanks to this comprehensive guide. With a logically structured approach, it gives you the expertise to start using the Oracle SOA suite in real-world applications.
ISBN: 9781849680196, 9781849680196
Veröffentlichungsdatum: 2010-07-01
Format: E-book
Artikelkennung: e_3b03
Verleger: Packt Publishing

wählen sie eine sprache

Kategorien

Details zum E-Book