IBM WebSphere eXtreme Scale 6


IBM WebSphere eXtreme Scale 6
eBook: $35.99
Formats: PDF, PacktLib, ePub and Mobi formats
$30.59
save 15%!
Print + free eBook + free PacktLib access to the book: $95.98    Print cover: $59.99
$59.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Reviews
Support
Sample Chapters
  • Get hands-on experience with eXtreme Scale APIs, and understand the different approaches to using data grids
  • Introduction to new design patterns for both eXtreme Scale and data grids in general
  • Tutorial-style guide through the major data grid features and libraries
  • Start working with a data grid through code samples and clear walkthroughs

Book Details

Language : English
Paperback : 292 pages [ 235mm x 191mm ]
Release Date : November 2009
ISBN : 1847197442
ISBN 13 : 9781847197443
Author(s) : Anthony Chaves
Topics and Technologies : All Books, Enterprise Products and Platforms, Cloud, Enterprise, IBM

Back to BOOK PAGE

Table of Contents

Preface
Chapter 1: What is a Data Grid
Chapter 2: The ObjectMap API
Chapter 3: Entities and Queries
Chapter 4: Database Integration
Chapter 5: Handling Increased Load
Chapter 6: Keeping Data Available
Chapter 7: The DataGrid API
Chapter 8: Data Grid Patterns
Chapter 9: Spring Integration
Chapter 10: Putting It All Together
Index
  • Chapter 2: The ObjectMap API
    • Different kinds of maps
    • Get and put
    • Updating objects in the grid
      • Lock strategies
      • Lock types
    • Hash map refresher (or crash course)
    • Optimistic collisions
    • Deadlocks
    • Removing objects
    • FIFO queues
    • Unsupported methods
    • Wrapping up
    • Summary
  • Chapter 3: Entities and Queries
    • Entities
      • Defining Entities
      • Persisting Entities
      • Composition versus Inheritance
      • The Find methods
        • Entity life-cycle states
      • Merge, remove, and the detached state
    • Entity relationships
      • @OneToMany, @ManyToOne
      • schemaRoot
    • The Query API
      • Joins and aggregate functions
      • IDs and Indexes
    • Summary
  • Chapter 4: Database Integration
    • You're going where?
    • Where does an IMDG fit?
    • JPALoader and JPAEntityLoader
      • The Loader's job
      • Performance and referential integrity
    • Removal versus eviction
    • Write-through and write-behind
    • BackingMap and Loader
      • Picking battles
      • JPALoader
    • Summary
  • Chapter 5: Handling Increased Load
    • The building blocks
      • Shards and partitions
      • Client/Server ObjectGrid
    • A basic deployment
      • Starting a container
    • Connecting to a distributed grid
    • Adding more containers
    • Partition placement
    • Capacity planning
    • Hitting the wall
    • Summary
  • Chapter 6: Keeping Data Available
    • Containers, shards, partitions, and replicas
      • The foundation
      • Shards
      • Map sets
      • Partitions
      • Replication
    • Shard placement
      • Shard start-up
      • Lost shards and failover
    • Physical location
      • Controlled data separation
    • Preferred zones
    • Summary
  • Chapter 7: The DataGrid API
    • What does DataGrid do for me?
    • Borrowing from functional programming
      • GridAgent and Entity
      • GridAgent with an unknown key set
    • Aggregate results
      • Using ephemeral objects in agents
      • Updates with agents
      • Scheduling agents
    • Summary
  • Chapter 8: Data Grid Patterns
    • XTP: Extreme Transaction Processing
      • The data model
      • Schema root
    • Reference data and object duplication
      • How do we duplicate objects?
    • Time-to-live keeps us out of trouble
      • Early eviction
    • Rely on partitions, not the entire grid
      • One transaction, one node
      • Object schema denormalization
    • Summary
  • Chapter 9: Spring Integration
    • Injecting ObjectGrid instances
    • Spring-managed eXtreme Scale configuration
    • Transaction management
      • Basic configuration
      • ObjectGrid client configuration
      • Remembering our patterns
    • Summary
  • Chapter 10: Putting It All Together
    • The bookmarks app
      • The data model
      • The service layer
      • Storing data how it is used
      • Grid/ORM hybrid
      • Preloading data
      • Improving responsiveness
    • Caching more than ORM
    • Summary
Back to BOOK PAGE

Anthony Chaves

Anthony writes software for customers of all sizes. He likes building scalable, robust software. Customers have thrown all kinds of different development environments at him: Java, C, Rails, mobile device platforms – but no .NET (yet).

Anthony particularly likes user/device authentication problems and applied scalability practices. Cloud-computing buzzword bingo  doesn't fly with him. He started the Boston Scalability User Group in 2007.

Submit Errata

Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.


Errata

- 2 submitted: last submission 03 Jul 2012

Errata type: Typo | Page number: 20 |

Any interaction with objects in the gird... should be: Any interaction with objects in the grid...

 

Errata type: Typo | Page number: 55 |

We've use this convention up to now because... should be: We've used this convention up to now because...

 

Sample chapters

You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

Frequently bought together

IBM WebSphere eXtreme Scale 6 +    Alfresco 3 Records Management =
50% Off
the second eBook
Price for both: $51.15

Buy both these recommended eBooks together and get 50% off the cheapest eBook.

What you will learn from this book

  • Explore different ways of interacting with data in the grid
  • Configure eXtreme Scale instances programmatically and via XML configuration files
  • Achieve extreme performance by using grid agents
  • Explore practical data grid usage patterns
  • Integrate a data grid and a database
  • Configure eXtreme Scale for long-term deployments through educated capacity planning
  • Configure an eXtreme Scale client application using Spring
  • Give your database a shock-absorber by putting a data grid in front of it
  • Support thousands of concurrent clients by adding capacity to the grid and scale out linearly
  • Protect your data by keeping it on multiple server racks and in multiple data centers
  • Explore the features of WebSphere eXtreme Scale by expanding the Entity and Query repertoire

In Detail

A data grid is a means of combining computing resources. Data grids provide a way to distribute object storage and add capacity on demand in the form of CPU, memory, and network resources from additional servers. All three resource types play an important role in how fast data can be processed, and how much data can be processed at once. WebSphere eXtreme Scale provides a solution to scalability issues through caching and grid technology. Working with a data grid requires new approaches to writing highly scalable software; this book covers both the practical eXtreme Scale libraries and design patterns that will help you build scalable software.

Starting with a blank slate, this book assumes you don't have experience with IBM WebSphere eXtreme Scale. It is a tutorial-style guide detailing the installation of WebSphere eXtreme Scale right through to using the developer libraries. It covers installation and configuration, and discusses the reasons why a data grid is a viable middleware layer. It also covers many different ways of interacting with objects in eXtreme Scale. It will also show you how to use eXtreme Scale in new projects, and integrate it with relational databases and existing applications.

This book covers the ObjectMap, Entity, and Query APIs for interacting with objects in the grid. It shows client/server configurations and interactions, as well as the powerful DataGrid API. DataGrid allows us to send code into the grid, which can be run where the data lives. Equally important are the design patterns that go alongside using a data grid. This book covers the major concepts you need to know that prevent your client application from becoming a performance bottleneck. By the end of the book, you'll be able to write software using the eXtreme Scale APIs, and take advantage of a linearly scalable middleware layer.

Web developers and Enterprise developers alike have a new tool for building high scalability into their software projects: the data grid.

Approach

This book is a real-world practical tutorial with lots of examples. The data grid concepts are clearly explained and code samples are provided. The concepts are applicable to all IMDGs, and the examples represent the eXtreme Scale approach to the problem.

Who this book is for

This book is aimed at intermediate-level JavaEE Developers who want to build applications that handle larger data sets with massive scalability requirements. No previous experience of WebSphere eXtreme Scale is required.

Code Download and Errata
Packt Anytime, Anywhere
Register Books
Print Upgrades
eBook Downloads
Video Support
Contact Us
Awards Voting Nominations Previous Winners
Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
Resources
Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software