实战指南：打造企业级Java模块化应用的OSGi核心技术

需积分: 9 38 浏览量更新于2024-07-19 1 收藏 21.86MB PDF 举报

"《OSGi in Action》是一本深入浅出的指南，针对当前最热门的Java企业应用开发技术——OSGi。OSGi是一种标准化的模块化开发框架，旨在实现高度灵活的应用组件管理，允许开发者在不中断整个系统的情况下安装、启动、停止、更新或卸载组件，这对于企业级应用的构建至关重要。自Sun、Spring、Oracle、BEA和IBM等大公司支持该标准以来，基于OSGi的应用需求激增。本书由资深的OSGi社区核心成员撰写，作者们拥有丰富的实践经验，包括对Apache Felix等知名OSGi实现的贡献。书中的目标是双重的：首先，通过与实际项目相关的示例，为架构师和开发者提供清晰的概念介绍；其次，深入探讨各种实际场景和技巧，解答诸如“实际应用中需要掌握多少OSGi？”、“如何将OSGi嵌入其他容器？”以及“如何迁移到OSGi的最佳实践”等问题。《OSGi in Action》不仅理论知识丰富，而且注重实践操作，帮助读者快速上手并充分利用OSGi的优势。如果你正在寻找一本全面且实用的OSGi教程，这本书无疑是学习和掌握这一技术的绝佳资源。对于想要在企业级Java应用开发中实现模块化设计和动态扩展的开发者来说，这本书是不可或缺的参考书籍。购买时，读者还可以通过Manning出版社的官方网站获取更多优惠信息。"

PREFACE

xviii

I’d been kicking around the idea of writing an OSGi book for a couple of years, but

given the enormity of the task and my life-long time deficit, I never got around to it. In

the summer of 2008, I finally got serious and began writing, only to find myself quickly

bogged down. It wasn’t until Karl and Stuart offered to help, and later David, that we

were finally able to slay the beast. Our varied

OSGi experience provided just the right

mix. Even then, it’s taken us two years, a few career changes, and the birth of several

children to see it to an end. We hope you’ll find our efforts helpful.

ICHARD S. HALL

ABOUT THIS BOOK

xxi

In part 1 of the book, we focus on explaining the most common aspects of the OSGi

core specification from the user’s perspective. We introduce OSGi according to its

three-layer architecture: module, lifecycle, and services. This isn’t the only approach

to take in explaining

OSGi; most explanations of OSGi start out with a simple bundle

implementing a simple service. The downside of this type of approach, in our view, is

that it cuts across all three

OSGi layers at once, which would require us to explain all

three layers at once.

The advantage of following a layered approach is that doing so creates a clear divi-

sion among the concepts we need to discuss. For example, the modularity chapter

focuses on modularity concepts and can largely ignore lifecycle and services. This

approach also creates a natural progression, because modularity is the foundation of

OSGi, lifecycle builds on it, and services are on top of lifecycle. We can also highlight

how to use lower layers of the OSGi architecture without using the upper layers, which

is sometimes worthwhile.

Part 2 of the book takes the knowledge about the

OSGi core specification from

part 1 and shows how you can use the technology from a more pragmatic viewpoint.

We look into converting existing

JAR files to bundles as well as testing, debugging,

and managing bundles. These first two parts of the book should be of general inter-

est to anyone wanting to learn more about using

OSGi.

Part 3 covers various advanced topics, such as service-oriented component models,

framework launching, security, and distributed computing technologies. This last part

serves as a springboard to the world of possibilities available to you in the

OSGi universe.

Roadmap

Chapter 1 presents a high-level view of OSGi technology and the issues it’s intended to

address. To keep the chapter from being totally abstract, we present a few “Hello,

world!” examples to illustrate the different layers of the

OSGi framework, but the real

meat of our OSGi discussion is in the following chapters. We also look at the state of

modularity support in Java as well as in some related technologies.

Chapter 2 explores the module layer of the

OSGi framework. We start with a general

discussion of modularity in computing and then continue by describing OSGi’s module

concept, called a bundle. We present OSGi’s declarative metadata-based approach for

creating modules and show how to use it to modularize a simple paint program. We also

investigate one of the key

OSGi tasks: bundle dependency resolution.

Chapter 3 looks at the lifecycle layer of the OSGi framework. We discuss lifecycle

management in general and describe how OSGi provides dynamic lifecycle manage-

ment of bundles. We present OSGi’s lifecycle-related APIs by creating a simple OSGi

shell and also adapt our paint program to make it lifecycle aware.

Chapter 4 examines the services layer of the

OSGi framework. We describe what

services are and discuss why and when you need them. We walk you through providing

and using services with some toy examples and then take an iterative approach to

describing how to deal with the unique aspect of service dynamism. We finish our ser-

vice discussion by adapting the paint program, this time to use dynamic services.

ABOUT THIS BOOK

xxii

Chapter 5 returns to the module layer and examines its more advanced or

nuanced capabilities. We describe additional ways for bundles to deal with dependen-

cies and content using bundle-level dependencies and bundle fragments. You also

learn how bundles can deal with execution environments and native libraries.

Chapter 6 gives practical advice for converting

JAR files into bundles, including

how to define bundle metadata, package your bundle content, and add lifecycle sup-

port. We also describe how to go about dividing an application into bundles, demon-

strating techniques on an existing open source project.

Chapter 7 shows how to test bundles and

OSGi-based applications. We look into

running your existing tests in OSGi and mocking OSGi APIs. In addition to unit and

integration testing, we discuss management testing and explore some tools to help

you along the way.

Chapter 8 follows testing by describing how to debug your bundles. We look into

simple, command-line debugging as well as debugging with the Eclipse

IDE. We show

how to set up your development environment to get you up to speed quickly. We also

explain some of the typical issues you encounter when working with

OSGi and how to

deal with them.

Chapter 9 switches gears and discusses how to manage your bundles. We explain

how to meaningfully define version numbers for packages and bundles. We look into

managing bundle configuration data and in the process describe a handful of

OSGi services. We also cover an option for triggering automatic bundle

startup and initialization.

Chapter 10 continues investigating management topics, but moves from single-

bundle issues to multi-bundle ones. We look at a couple of approaches for deploying

bundles and their dependencies. We also explain how you can control bundle

startup order.

Chapter 11 describes how component-oriented programming relates to

OSGi. As a

concrete example, we look at a standard OSGi component framework called Declara-

tive Services. We show how Declarative Services allows you to work with POJOs and sim-

plifies some aspects of dealing with service dynamism.

Chapter 12 continues investigating more advanced component frameworks for

OSGi. We look at Blueprint, which is targeted toward enterprise developers familiar

with Spring technology. We also examine the Apache Felix iPOJO component frame-

work. We show that one of the benefits of OSGi-based component frameworks is they

can all work together via services.

Chapter 13 turns away from developing bundles and looks at launching the

OSGi

framework. We describe the standard approach for configuring and creating OSGi

frameworks. We also show how you can use the standard API to embed an OSGi frame-

work into an existing application.

Chapter 14 delves into operating

OSGi in a secure environment. We describe the

issues involved and approaches to alleviating them. We explain how OSGi extends the

standard Java security architecture to make it more flexible and easier to manage. And

www.allitebooks.com

剩余572页未读，继续阅读

K.Sun

粉丝: 180
资源: 6

实战指南：打造企业级Java模块化应用的OSGi核心技术

osgi in action

OSGI in action.pdf

《OSGi in Action》PDF

android jbundle-util-osgi-wrapped-httpclient - httpclient osgi

Springboot框架如何集成OSGI

wpf实现osgi框架

怎么在idea中创建osgi项目

OSGI container

OSGi. NET 规范

idea中配置osgi开发环境

最新资源