Books & Videos

Table of Contents

  1. Introducing Modularity in Java

    1. Chapter 1 Modularity Introduction

      1. Dealing with Increasing Complexity complexity
      2. Divide and Conquer
      3. Service Oriented Architecture All Over Again?
      4. A Better Look at Modularity and What It Really Means
      5. Modularity Solutions
      6. Choosing a Solution: OSGi
      7. Tooling
    2. Chapter 2 Basic Concepts of OSGi

      1. Hiding Implementations
      2. Import Package Myths
      3. Depending on Other Modules
      4. Service Dynamics
      5. The Bundle Format bundlesformat
      6. Running an OSGi Application
      7. The Framework Lifecycle
    3. Chapter 3 Creating the First OSGi Application

      1. Prerequisites
      2. Getting Started
      3. Creating an API Bundle
      4. Creating an OSGi Service
      5. Running the Code
      6. Using the Agenda Service
      7. Service Instances
      8. Understanding Service Dynamics
    4. Chapter 4 Advanced OSGi

      1. Semantic Versioning
      2. Integration Testing
      3. Configuring Services Configuration Admin APIconfiguring services
      4. Log Service
      5. Extender Pattern
      6. Event Admin
      7. Aspect Services
      8. The Bundle Cache
    5. Chapter 5 Pointers and Pitfalls

      1. Better Understanding OSGi Specifications
      2. Require Bundle
      3. Fragment Bundles
      4. Loading Extra System Packages
      5. Profilers, Coverage Tools, and Bootpath Delegation
      6. Dealing with Non-OSGi Libraries
      7. Transitive Dependencies transitive dependencies
      8. Classloading Problems in Libraries and Frameworks
      9. The Low-Level Service API
      10. Dynamic Classloading
  2. Developing Cloud Applications

    1. Chapter 6 Cloud Application Architecture

      1. Technology Stack
      2. The Amdatu Project
      3. The Layered Architecture
      4. Inside a Bundle
      5. API Bundles
      6. Separation of Concerns
      7. Services Are Responsible for Their Own Data
      8. Bndtools Project Structure project structure
      9. Comparing with SOA Again
      10. Remoting
    2. Chapter 7 Architectural Capabilities system capabilities

      1. Maintainability
      2. Extensibility
      3. Scalability scalability
      4. Testability mocking
    3. Chapter 8 Creating Web Applications

      1. Modular Web Applications
      2. HTTP Service
      3. Handling Web Resources Automatically X-Web-Resource-Version header
      4. Rethinking Web Applications
      5. RESTful Web Services
      6. Modular User Interfaces Using HTML 5
      7. Token Based Security
      8. Web Application Bundles
      9. OpenSocial
    4. Chapter 9 Persistence

      1. Relational Databases
      2. NoSQL
  3. Deploying Applications in the Cloud

    1. Chapter 10 Deployment

      1. Understanding OSGi Runtimes
      2. Choosing an OSGi Framework for Deployment
      3. IaaS versus PaaS versus SaaS
      4. A Modular PaaS
      5. Apache ACE provisioning
      6. Creating a Deployment
      7. Autoscaling
    2. Chapter 11 Alternative Deployment Methods

      1. Packaging an Application as an Executable JAR
      2. Application Servers Application Servers
  1. Appendix Example Application

    1. Introduction

    2. Finding and Running the Source Code

    3. Layered View

    4. Component View

    5. Development View

    6. Modularized Frontend

    7. Authentication

    8. Configuration Admin

    9. Scheduled Jobs

    10. Event Admin

    11. Testing

  2. Index

  3. Colophon