Normal view MARC view ISBD view

Mule in action / David Dossot, John D'Emic,Victor Romero, (Solutions architect)

Dossot, David.
Contributor(s): D'Emic, John.
Material type: materialTypeLabelBook; Format: print Publisher: Greenwich, CT : Manning, c2014Edition: 2ª ed.Description: xxiii, 404 p. : ill. ; 24 cm.ISBN: 9781617290824; 1617290823.Subject(s): Software Engineering | Mule (Computer file) | Computer architecture | Enterprise application integration (Computer systems) | Open source software | Ingeniería del software
Tags from this library: No tags from this library for this title. Log in to add tags.
    average rating: 0.0 (0 votes)
Item type Home library Call number Status Loan Date due Barcode Item holds
Monografías 03. BIBLIOTECA INGENIERÍA PUERTO REAL
681.3.06/DOS/mul (Browse shelf) Checked out PREST. LIBROS 31/01/2019 3742255405
Monografías 03. BIBLIOTECA INGENIERÍA PUERTO REAL
681.3.06/DOS/mul (Browse shelf) Checked out PREST. LIBROS 31/01/2019 3742258410
Total holds: 0

Enhanced descriptions from Syndetics:

Summary

Mule in Action, Second Edition is a totally-revised guide covering Mule 3 fundamentals and best practices. It starts with a quick ESB overview and then dives into rich examples covering core concepts like sending, receiving, routing, and transforming data.

About the Technology

An enterprise service bus is a way to integrate enterprise applications using a bus-like infrastructure. Mule is the leading open source Java ESB. It borrows from the Hohpe/Woolf patterns, is lightweight, can publish REST and SOAP services, integrates well with Spring, is customizable, scales well, and is cloud-ready.

About the Book

Mule in Action, Second Edition is a totally revised guide covering Mule 3 fundamentals and best practices. It starts with a quick ESB overview and then dives into rich examples covering core concepts like sending, receiving, routing, and transforming data. You'll get a close look at Mule's standard components and how to roll out custom ones. You'll also pick up techniques for testing, performance tuning, and BPM orchestration, and explore cloud API integration for SaaS applications.

Written for developers, architects, and IT managers, this book requires familiarity with Java but no previous exposure to Mule or other ESBs.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

What's Inside

Full coverage of Mule 3 Integration with cloud services Common transports, routers, and transformers Security, routing, orchestration, and transactions

About the Authors

David Dossot is a software architect and has created numerous modules and transports for Mule. John D'Emic is a principal solutions architect and Victor Romero a solutions architect, both at MuleSoft, Inc.

Table of Contents

PART 1 CORE MULE Discovering Mule Processing messages with Mule Working with connectors Transforming data with Mule Routing data with Mule Working with components and patterns PART 2 RUNNING MULE Integration architecture with Mule Deploying Mule Exception handling and transaction management with Mule Securing Mule Tuning Mule PART 3 TRAVELING FURTHER WITH MULE Developing with Mule Writing custom cloud connectors and processors Augmenting Mule with orthogonal technologies

Includes index.

Table of contents provided by Syndetics

  • Foreword (p. xv)
  • preface (p. xvii)
  • acknowledgments (p. xix)
  • about this book (p. xxi)
  • about the authors (p. xxiv)
  • about the cover illustration (p. xxv)
  • Part 1 Core Mule (p. 1)
  • 1 Discovering Mule (p. 3)
  • 1.1 Enterprise Integration Patterns and service-oriented architecture (p. 4)
  • 1.2 The Mule project (p. 6)
  • 1.3 Competition (p. 7)
  • 1.4 Mule: a quick tutorial (p. 8)
  • Installing Mule Studio (p. 9)
  • Designing the flow (p. 13)
  • 1.5 Running, testing, and deploying the application (p. 17)
  • Running the application (p. 17)
  • Testing the flow (p. 21)
  • Working with the XML configuration (p. 22)
  • Deploying to the Mule standalone server (p. 23)
  • 1.6 Summary (p. 26)
  • 2 Processing messages with Mule (p. 27)
  • 2.1 Going with the flow (p. 28)
  • The response phase (p. 30)
  • Subflows (p. 31)
  • Private flows (p. 34)
  • 2.2 Interacting with messages (p. 35)
  • Message sources (p. 36)
  • Message processors (p. 36)
  • Message exchange patterns (p. 37)
  • Endpoint URIs (p. 39)
  • 2.3 Exploring the Mule message (p. 40)
  • Message properties (p. 42)
  • Understanding property scopes (p. 42)
  • Using message attachments (p. 45)
  • 2.4 Speaking the Mule Expression Language (p. 46)
  • Using expressions (p. 47)
  • 2.5 Summary (p. 49)
  • 3 Working with connectors (p. 50)
  • 3.1 Understanding connectors (p. 51)
  • Configuring connectors with XML (p. 52)
  • Configuring connectors with Mule Studio (p. 53)
  • 3.2 Using the file transport (p. 56)
  • 3.3 Using the HTTP transport (p. 58)
  • Sending and receiving data using HTTP (p. 58)
  • Using web services with Mule (p. 61)
  • 3.4 Using the JMS transport (p. 67)
  • Sending JMS messages with the JMS outbound endpoint (p. 68)
  • Receiving JMS messages with the JMS inbound endpoint (p. 69)
  • Using selector filters on JMS endpoints (p. 70)
  • Using JMS synchronously (p. 70)
  • 3.5 Using email (p. 71)
  • Receiving email with the IMAP transport (p. 71)
  • Sending mail using the SMTP transport (p. 73)
  • 3.6 Using the FTP transport (p. 75)
  • Receiving files with inbound FTP endpoints (p. 76)
  • Sending files with outbound FTP endpoints (p. 77)
  • 3.7 Using databases (p. 77)
  • Using a JDBC inbound endpoint to perform queries (p. 78)
  • Using a JDBC outbound endpoint to perform insertions (p. 79)
  • NoSQL with MongoDB (p. 80)
  • 3.8 Using the VM transport (p. 82)
  • Introducing reliability with the VM transport (p. 83)
  • 3.9 Using the Twitter cloud connector (p. 85)
  • Twitter (p. 85)
  • 3.10 Summary (p. 86)
  • 4 Transforming data with Mule (p. 87)
  • 4.1 Working with transformers (p. 88)
  • 4.2 Configuring transformers (p. 89)
  • 4.3 Using core transformers (p. 91)
  • Dealing with bytes (p. 92)
  • Compressing data (p. 94)
  • Modifying properties, flow variables, and session variables (p. 95)
  • Transforming with expressions (p. 97)
  • Enriching messages (p. 98)
  • Automagic transformation (p. 99)
  • 4.4 Using XML transformers (p. 100)
  • XPath and Mule (p. 101)
  • Transforming format with XSL (p. 102)
  • XML object marshaling (p. 104)
  • 4.5 Transforming JSON with Mule (p. 105)
  • Querying JSON with MEL (p. 106)
  • JSON object marshaling with Mule (p. 107)
  • 4.6 Scripting transformers (p. 109)
  • 4.7 Summary (p. 112)
  • 5 Routing data with Mule (p. 113)
  • 5.1 Deciding how to route a message (p. 115)
  • Using the choice router (p. 115)
  • 5.2 Using filters (p. 118)
  • Filtering by payload type and header (p. 119)
  • Filtering text and XML (p. 120)
  • Filtering with expressions (p. 122)
  • Logical filtering (p. 124)
  • Ensuring atomic delivery with the idempotent filter (p. 125)
  • Using the message filter (p. 127)
  • 5.3 Routing to multiple recipients (p. 128)
  • Dispatching messages with the all router (p. 128)
  • Scatter/gather IO with the all router (p. 129)
  • Going async with the async processor (p. 130)
  • 5.4 Routing and processing groups of messages (p. 131)
  • Splitting up messages (p. 132)
  • Aggregating messages (p. 133)
  • Routing collections (p. 134)
  • 5.5 Guaranteed routing (p. 136)
  • Resiliency for unreliable transports (p. 136)
  • Defining failure expressions (p. 137)
  • 5.6 Summary (p. 138)
  • 6 Working with, components and patterns (p. 139)
  • 6.1 Using Mule components (p. 140)
  • Executing business logic (p. 141)
  • Resolving the entry point (p. 143)
  • Configuring the component (p. 146)
  • Annotating components (p. 148)
  • Handling workload with a pool (p. 149)
  • Scripting components (p. 151)
  • Component lifecycle (p. 155)
  • 6.2 Simplifying configuration with configuration patterns (p. 157)
  • Using the simple service pattern (p. 158)
  • Using the bridge (p. 162)
  • Using the validator (p. 164)
  • Using the HTTP proxy (p. 167)
  • Using the WS proxy (p. 168)
  • Reusing common configuration elements (p. 170)
  • 6.3 Summary (p. 172)
  • Part 2 Running Mule (p. 173)
  • 7 Integration architecture with Mule (p. 175)
  • 7.1 Structuring integration applications (p. 176)
  • Guerrilla SOA with hub and spoke (p. 176)
  • Mule as the enterprise service bus (p. 177)
  • Mule as a mediation layer (p. 178)
  • 7.2 Mule implementation patterns (p. 180)
  • Using a canonical data model (p. 180)
  • Reliability patterns with asynchronous messaging (p. 182)
  • Proxying SOAP requests with CXF (p. 185)
  • 7.3 Summary (p. 188)
  • 8 Deploying Mule (p. 189)
  • 8.1 Deploying standalone Mule applications (p. 190)
  • Packaging a standalone Mule app (p. 194)
  • Deploying applications to Mule (p. 196)
  • Configuring logs (p. 198)
  • Inter-application communication with Mule (p. 200)
  • Embedding web applications in Mule (p. 202)
  • 8.2 Deploying Mule to a web container (p. 204)
  • 8.3 Deploying applications to CloudHub (p. 206)
  • 8.4 Embedding Mule into an existing application (p. 208)
  • 8.5 Deploying Mule for high availability (p. 210)
  • High availability via fault tolerance (p. 213)
  • 8.6 Summary (p. 216)
  • 9 Exception handling and transaction management with Mule (p. 217)
  • 9.1 Dealing with errors (p. 219)
  • Using reconnection strategies (p. 219)
  • Creating reconnection strategies (p. 221)
  • Handling exceptions (p. 225)
  • Using exception strategies (p. 227)
  • 9.2 Using transactions with Mule (p. 230)
  • Single-resource transaction (p. 232)
  • Transactions against multiple resources (p. 241)
  • Transaction demarcation (p. 247)
  • 9.3 Summary (p. 249)
  • 10 Securing Mule (p. 250)
  • 10.1 Spring Security 3.0 and Mule (p. 251)
  • User security with an in-memory user service (p. 252)
  • User security with LDAP (p. 253)
  • Securing endpoints with security filters (p. 254)
  • 10.2 Securing HTTP using SSL (p. 255)
  • Setting up an HTTPS server (p. 255)
  • Setting up an HTTPS client (p. 256)
  • 10.3 Securing SOAP with Mule (p. 258)
  • 10.4 Message encryption with Mule (p. 259)
  • Using password-based payload encryption (p. 260)
  • Decrypting message pay loads with PGP (p. 261)
  • 10.5 Summary (p. 263)
  • 11 Tuning Mule (p. 264)
  • 11.1 Staged event-driven architecture (p. 265)
  • Roll your own SEDA (p. 266)
  • 11.2 Understanding thread pools and processing strategies (p. 267)
  • Processing strategies and synchronicity (p. 269)
  • Transport peculiarities (p. 272)
  • Tuning thread pools (p. 274)
  • Tuning processing strategies (p. 276)
  • 11.3 Identifying performance bottlenecks (p. 278)
  • Profiler-based investigation (p. 279)
  • Performance guidelines (p. 281)
  • 11.4 Summary (p. 284)
  • Part 3 Traveling Further with Mule (p. 285)
  • 12 Developing with Mule (p. 287)
  • 12.1 Understanding the Mule context (p. 288)
  • Accessing the Mule context (p. 289)
  • Using the Mule context (p. 290)
  • 12.2 Connecting to Mule (p. 293)
  • Reaching a local Mule application (p. 294)
  • Reaching a remote Mule application (p. 295)
  • Reaching out with transports (p. 298)
  • 12.3 Using the Mule API (p. 300)
  • Being lifecycle aware (p. 301)
  • Intercepting messages (p. 303)
  • Listening to notifications (p. 307)
  • Configuring Mule data persistence (p. 310)
  • 12.4 Testing with Mule (p. 315)
  • Functional testing (p. 315)
  • Behavior stubbing (p. 319)
  • Load testing (p. 323)
  • 12.5 Debugging with Mule (p. 328)
  • Logging messages (p. 328)
  • Step debugging a Mule application (p. 331)
  • 12.6 Summary (p. 333)
  • 13 Writing custom cloud connectors and processors (p. 334)
  • 13.1 Simplifying Mule development with the DevKit (p. 335)
  • 13.2 Introduction to authoring cloud connectors (p. 337)
  • Rendering extensions configurable (p. 339)
  • Managing connections (p. 340)
  • Creating message processors (p. 343)
  • Creating intercepting message processors (p. 344)
  • Creating simple REST consumers (p. 345)
  • Creating transformers (p. 347)
  • Creating message sources (p. 348)
  • Integrating Mule extensions with Mule Studio (p. 349)
  • 13.3 Creating a REST connector (p. 350)
  • 13.4 Summary (p. 357)
  • 14 Augmenting Mule with orthogonal technologies (p. 358)
  • 14.1 Augmenting Mule flows with business process management (p. 359)
  • 14.2 Complex event processing (p. 361)
  • Using CEP to monitor event-driven systems (p. 361)
  • Sentiment analysis using Esper and Twitter (p. 363)
  • 14.3 Using a rules^ engine with Mule (p. 365)
  • Using Drools for selective message enrichment (p. 366)
  • Message routing with Drools (p. 368)
  • 14.4 Polling and scheduling (p. 370)
  • Using the poll message processor (p. 370)
  • Scheduling with the Quartz transport (p. 371)
  • 14.5 Summary (p. 372)
  • appendix A Mule Expression Language (p. 373)
  • appendix B Component and transformer annotations quick reference (p. 380)
  • appendix C Mule Enterprise Edition (p. 383)
  • appendix D A sample Mule application (p. 385)
  • index (p. 391)

Author notes provided by Syndetics

David Dossot is a software architect and has created numerous modules and transports for Mule.
John D'Emic is a principal solutions architect and Victor Romero a solutions architect, both at MuleSoft, Inc.

There are no comments for this item.

Log in to your account to post a comment.

Powered by Koha