企业级OSGi实战：结合Java EE构建模块化服务架构 - CSDN文库

需积分: 0 184 浏览量更新于2024-07-19 收藏 21.76MB PDF 举报

"《Enterprise OSGi in Action》(2013.3) - Holly Cummins & Timothy Ward" 《Enterprise OSGi in Action》是一本深入探讨企业级OSGi编程模型的书籍，同时也关注如何在实际企业环境中应用OSGi。作者Holly Cummins和Timothy Ward旨在将OSGi的模块化、服务导向的方法与Java EE的成熟持久化、事务处理以及Web技术相结合，以解决那些项目组件分散在网络各处，新旧不一，甚至有些难以识别的问题。本书为应对复杂现实世界中的OSGi应用提供了大量实用技巧，涵盖了工具选择、构建、测试以及与非OSGi系统和库的集成。书中详尽地介绍了如何利用OSGi来管理项目中的模块和依赖关系，使软件架构更加清晰，易于维护。OSGi（Open Service Gateway Initiative）是一种用于Java的动态模块系统，它允许你在运行时添加、修改和删除模块，而不影响整个系统的其他部分。这对于大型企业级应用来说，能够显著提高灵活性和可扩展性。书中通过Apache Aries的例子来具体阐述OSGi的实践应用，Apache Aries是一个开源项目，提供了一系列的OSGi服务，包括服务发现、事务管理和JPA支持等，这些都对于构建企业级Java应用程序至关重要。作者在书中分享了如何将OSGi与Java EE的特性，如EJB、JPA和JSF等结合，创建可伸缩、灵活的应用程序。此外，还讨论了如何处理OSGi环境中的版本冲突、依赖管理和服务注册等问题。书中还涵盖了如何在OSGi环境中测试代码，以及与非OSGi系统的互操作性，比如使用桥接技术来连接到传统的Java库或系统。对于想要理解和应用OSGi的企业开发者来说，这本书提供了宝贵的指导。它不仅解释了OSGi的核心概念和技术，还给出了在真实项目中实施的策略和最佳实践。书中的案例研究和实战经验可以帮助读者更好地理解如何在自己的工作中有效利用OSGi的优势，解决实际问题。《Enterprise OSGi in Action》是针对那些希望提升企业应用的模块化和灵活性，同时利用Java EE生态的开发者的宝贵资源。通过阅读本书，读者可以学习到如何在复杂的企业环境中驾驭OSGi，实现更高效、更可维护的软件系统。

xv

acknowledgments

Where do we even start in thanking all the people who made this book possible? You

fed us, encouraged us, and taught us. Going back to the beginning, this project

wouldn’t even have gotten off the ground without the good folks at Manning. Thanks

to Marjan Bace, our publisher, Michael Stephens, our editor, and Sebastian Stirling

and Frank Pohlmann, our development editors. You helped us figure out what makes

a good book and guided, coaxed, and nudged us in the right direction. Thanks also to

Christina Rudloff and Nick Chase.

The quality of this book has been hugely improved by the detailed comments we

received from our reviewers. We really appreciate you taking the time to read our

efforts and tell us what we got right and wrong. Thanks to Alasdair Nottingham,

Andrew Johnson, Charles Moulliard, David Bosschaert, Felix Meschberger, John W.

Ross, Kevin Sheehan, Kin Chuen, Tang, Marcel Offermans, Mirko Jahn, Paul Flory,

Pierre De Rop, Teemu Kanstrén, and Tim Diekmann.

Thanks also to everyone who participated in the Manning Early Access Program. Spe-

cial thanks to our technical proofer, Mark Nuttall, who went over the book several times

with an eagle eye, and was patient with silly mistakes and last-minute improvements.

We couldn’t have written this book without the help of our colleagues at

IBM.

Thank you, Ian Robinson. Without your vision and commitment, it’s likely that nei-

ther of us would have had the opportunity to work so closely with enterprise

OSG

i.

Thanks to Andy Gatford and Nickie Hills for supporting us. We’d like to thank Jeremy

Hughes, Alasdair Nottingham, Graham Charters, Zoe Slattery, Valentin Mahrwald,

Emily Jiang, Tim Mitchell, Chris Wilkinson, Richard Ellis, Duane Appleby, and Erin

Schnabel for the many valuable discussions we shared with them.

ACKNOWLEDGMENTS

xvi

We borrowed the phrase “bundle flake” from Alex Mulholland, who deserves

credit for bringing the fun back into debugging

OSG

i fragments. We’d also like to give

special mention to Sarah Burwood, who possibly didn’t realize what she’d signed up

for when she offered to review the book as an

OSG

i beginner! We’ve learned loads

from all of you, so thank you.

In addition to our

IBM

colleagues, we thank the members of the

OSG

i Alliance

Expert Groups and Apache Aries. You put up with our ideas and questions and built

the enterprise

OSG

i programming model with us, many of you donating your time to

do so. There are too many names to even begin to list here, but particular thanks are

deserved by Peter Kriens and David Bosschaert, both for direct help with the book

and for their years of support building the

OSG

i Enterprise Specifications.

On a personal level, we’re indebted to our partners, Paul and Ruth, who picked up

a great deal of domestic slack, as well as provided apparently limitless encouragement

and support. At the times when this book didn’t seem possible, you persuaded us it was

(and then fed us a snack). Holly would like to apologize to Paul for the six application

servers and four

IDE

s now installed on his laptop; everyone knows not to let software

engineers touch one’s computer! Tim would like to apologize to Ruth for all the times

that “I just need to finish this paragraph” took rather longer than the implied five min-

utes; it turns out that writing prose is more like writing code than you might think...

Tim would like to thank the rest of his immediate family, Pauline, Gareth, Ron,

Eve, Sarah, and Maurice, for their interest and their unwavering belief that not only

would the book eventually be finished, but that it would also be worth reading. He

also thanks them for helping him “remember to bring the funny.” He’s sure many of

the readers will want to thank them for that, too.

Holly would also like to thank her mom, dad, John, Ioana, Heather, and Phil for help-

ing her find the time and space for writing. Acknowledgment is also owed to Laurie Hod-

kinson, who has spent many hours helping write this book, and occasionally throwing

up on the keyboard. Holly has every expectation that his first word will be “

OSG

i.”

As with many books, some of the people and things that helped make it possible

probably aren’t even aware of their contribution. The writing of this book was fueled

by coffee—lots of coffee—and cheese. Holly would like to thank the makers of her

Beco Gemini baby carrier, which is essentially a concurrency framework for infants.

Tim would like to thank the makers of his Vi-Spring mattress, which is essentially the

cure to hunching over a laptop all day.

Finally, our thanks wouldn’t be complete without thanking you, the readers, for

buying our book. We hope that you enjoy it, and that maybe you’ll end up liking

OSG

i

just as much as we do.

ABOUT

THIS

BOOK

xviii

Part 2 explains how to use these building blocks most effectively with best practices,

tools, and a deeper understanding of some subtle areas. Part 3 considers how enter-

prise

OSG

i fits in with your existing applications and systems. It covers distribution

technologies, migration tips and traps, and server options.

The appendixes provide important

OSG

i background. If you’re new to

OSG

i, you

may want to skip to the appendixes after reading chapter 1.

Chapter 1 explains what

OSG

i is, why it’s such an exciting technology, and why it’s

so relevant to the enterprise.

Chapter 2 lets you get your hands dirty with real code. It introduces the

OSG

i sand-

box you’ll use to run the samples. You’ll write an

OSG

i web application and hook it up

to backend

OSG

i services. You’ll use

JNDI

to connect

OSG

i services to legacy code, and

Blueprint dependency injection to wire together the services.

Chapter 3 introduces

JPA

persistence and

JTA

transactions, and shows how to use

them in an

OSG

i environment.

Chapter 4 shows how to group

OSG

i bundles together into coarser-grained

applications.

In part 2, chapter 5 steps back from new technologies and discusses best practices

for writing enterprise

OSG

i applications. It explains how to structure your applica-

tions, introduces some new

OSG

i-centric patterns, and discusses which familiar pat-

terns may not be such a great idea in an

OSG

i environment.

Chapter 6 investigates

OSG

i dynamism and Blueprint dependency injection in

more depth.

Chapter 7 discusses how to use OBR to dynamically provision application

dependencies.

Chapter 8 introduces a range of command-line tools for generating

OSG

i manifests

and building bundles. It also considers how to test

OSG

i bundles.

Chapter 9 continues the discussion of useful tools by comparing several

IDE

s that

support

OSG

i.

In part 3, chapter 10 explains how to use distributed

OSG

i to allow

OSG

i services to

be published and consumed across remote systems.

Chapter 11 discusses your options for migrating non-

OSG

i legacy code to

OSG

i. It

also discusses technologies for integrating

OSG

i applications with the non-

OSG

i legacy

code you haven’t yet migrated!

Chapter 12 sets out strategies for handling non-

OSG

i libraries. It shows how to turn

ordinary

JAR

s into bundles and explains how to deal with common problems, such as

classloading and logging issues.

Finally, chapter 13 compares the various commercial and open source

OSG

i run-

times and gives guidance on how you should choose a stack that’s right for you.

Appendix A covers the basics of

OSG

i. It explains why

OSG

i is such a necessary

technology, and provides grounding in versioning, bundles, bundle lifecycles, and

OSGi services. It includes some practical hints on OSGi frameworks and consoles.

剩余399页未读，继续阅读

sy59537

粉丝: 0
资源: 15

最新资源