使用C++深入学习CORBA编程

需积分: 10 84 浏览量更新于2024-07-24 1 收藏 4.77MB PDF 举报

"Advanced CORBA® Programming with C++" 是一本由 Michi Henning 和 Steve Vinoski 合著的专业书籍，由 Addison Wesley 出版社于1999年2月12日首次发行，ISBN号为0-201-37927-9，共计1120页。本书主要面向对C++编程有深入理解的软件工程师，旨在提供高级CORBA（Common Object Request Broker Architecture，公共对象请求代理架构）编程的深入理解和实践指导。在本书中，作者们深入探讨了CORBA技术在架构、设计和源代码层面的应用。他们提供了实用的设计和开发工具，帮助读者构建高效的应用程序，并通过清晰的示例帮助避免开发过程中的常见错误。这本全面的指南不仅适合初学者逐步学习，也适用于经验丰富的开发者作为参考。书中丰富的实例程序展示了如何编写更清晰、更易于维护、更可移植和更高效的代码，这些都是工业级CORBA项目成功的关键因素。通过对这些实例的分析，读者可以深入理解CORBA的核心概念，如对象接口定义（IDL）、ORB（Object Request Broker）、 Naming Service、Event Service、交易服务、安全性以及并发和线程管理等。此外，作者还涵盖了CORBA的高级主题，如性能优化、异常处理、持久化服务、多协议支持、分布式对象的时间同步和互操作性等。书中对CORBA标准的最新发展，包括IIOP（Internet Inter-ORB Protocol）和其他相关技术的使用，都有详尽的解释和讨论。 "Advanced CORBA® Programming with C++" 是一本全面且深入的教程和参考书，对于任何希望在C++环境中利用CORBA进行分布式系统开发的人来说，都是一份不可或缺的资源。通过学习本书，读者将能够熟练地运用CORBA技术来解决复杂的企业级问题，实现跨平台的无缝通信。

IT-SC book: Advanced CORBA® Programming with C++

Acknowledgments

As with any book, the authors are only part of the story, and this is the place to thank the

large number of people who have contributed to making this book possible. At Addison

Wesley Longman, Mike Hendrickson and our editor, Deborah Lafferty, believed us when

we told them that this book needed to be written. Without their faith in us, you would not

be reading this. Brian Kernighan reviewed several drafts and made us redo the job where

necessary. His clarity of thought and critical eye have greatly improved this book. John

Fuller and Genevieve Rajewski, our production editors, put up with all our naive

questions and enabled two amateurs to take a book to camera-ready stage. Our copy

editor, Betsy Hardinger, edited every page in this book with meticulous attention to detail.

Her efforts taught us more about clarity of style than we thought possible.

Particular thanks go to Colm Bergin, Jonathan Biggar, Bart Hanlon, Jishnu Mukerji, and

Doug Schmidt, our expert reviewers. They read the entire manuscript and spotted many

problems that would have otherwise gone unnoticed. Their comments kept us honest

throughout. Alan Shalloway reviewed the book from the perspective of a newcomer and

made valuable suggestions on how to improve the presentation of some of the more

difficult topics.

Todd Goldman and Tim Gill from Hewlett-Packard gave us permission to draw on earlier

ORB training material written by Michi. John Vinoski and Dan Rabideau of Green Bay

Engraving take credit for designing the Möbius strip on the cover.

We are grateful to Steve's employer, IONA Technologies, for allowing us to use the next

generation of their Orbix product (called "ART") to develop and test our code examples.

Their generosity provided us with the opportunity to make sure that our examples were

correct and functional. The fact that ART conforms to CORBA 2.3 allowed us to target

the most recent version of the CORBA specification available as of this writing.

We also would like to thank the many contributors to comp.object.corba and the corba-

dev mailing list. The discussions there have influenced much of the content of this book.

A number of people have provided feedback, corrections, and constructive criticism since

the first printing of this book. Rather than list them all here (and have to keep updating

this Preface for each new printing), we have placed a list of everyone who contributed at

<http://www.awl.com/cseng/titles/0-201-37927-9>. Our thanks go to all

these people for helping to make this a better book.

Michi's Acknowledgments

I would like to thank my former employer, DSTC Pty Ltd, for providing me with an

environment that was conducive to writing. Joachim Achtzehnter, Martin Chilvers, Wil

Evers, Ted McFadden, and Michael Neville reviewed parts of the manuscript and made

valuable suggestions for improvement. Particular thanks go to David Jackson, who read

all my drafts and made sure that loose ends were not allowed to remain hanging. Finally,

I would like to thank my wife, Jocelyn, and our son, Tyson, for their love and

IT-SC book: Advanced CORBA® Programming with C++

encouragement. Without their support and patience, this book would have never been

written.

Steve's Acknowledgments

I would like to thank my employer, IONA Technologies, for supporting my efforts to

write this book, which occasionally kept me away from the office. In particular, I would

like to thank Barry Morris for his support and encouragement, Stephen Keating for taking

up the slack when I had to miss work because of all-night writing sessions, and the whole

IONA Boston product development team for their patience and support.

I would also like to thank Bart Hanlon, who not only reviewed this book but also was my

manager at my former employer, for continually encouraging me for several years to

tackle this project and for teaching me a lot about tackling projects in general. In the

technical realm, I have learned from many people over the course of my career, but I owe

much to John Morris, Craig Bardenheuer, Denis deRuijter, Dale LaBossiere, Tom

Moreau, and Bob Kukura, who at one time or another greatly influenced my education in

the realms of distributed systems and engineering in general. I would also like to thank

my C++ Report co-columnist, Doug Schmidt, a true technical visionary whose work in

object-oriented network programming, C++ frameworks, and CORBA has paved the way

for books such as this one. He not only helped review this book, but also agreed to let me

use material from our columns in writing it.

Finally, without the support of my family, I would have never been able to even consider

writing this book. I'd like to thank my wife, Cindy, and our children, Ryan and Erin, for

putting up with my extremely long hours and days of writing and working. Thanks also to

my parents, Ed and Dooley, who have always supported me with their seemingly

limitless patience and love. I also owe my brother, John, a special thanks for his

wonderful artwork on our book cover.

Michi Henning and Steve Vinoski

October 1998

IT-SC book: Advanced CORBA® Programming with C++

Chapter 1. Introduction

1.1 Introduction

1.2 Organization of the Book

1.3 CORBA Version

1.4 Typographical Conventions

1.5 Source Code Examples

1.6 Vendor Dependencies

1.7 Contacting the Authors

1.1 Introduction

CORBA (Common Object Request Broker Architecture) is now well established in the

mainstream of software development and has found phenomenal industry acceptance.

CORBA is supported on almost every combination of hardware and operating system in

existence. It is available from a large number of vendors (even as freeware), supports a

large number of programming languages, and is now being used to create mission-critical

applications in industries as diverse as health care, telecommunications, banking, and

manufacturing. The increasing popularity of CORBA has created a corresponding

increase in demand for software engineers who are competent in the technology.

Naturally, CORBA has had to evolve and grow (sometimes painfully) to reach its current

levels of popularity and deployment. When the first version of CORBA was published in

1991, it specified how to use it only in C programs. This was a result of building CORBA

from proven technology. At that time, most production-quality distributed systems were

written in C.

By 1991, object-oriented (OO) languages such as Smalltalk, C++, and Eiffel had been in

use for years. Not surprisingly, many developers thought it strange that a language-

independent distributed OO system such as CORBA could be programmed only using C,

a non-OO, procedural language. To correct this short-coming, several development

groups at companies such as Hewlett-Packard, Sun Microsystems, HyperDesk

Corporation, and IONA Technologies started developing their own proprietary mappings

of CORBA to the C++ language. These proprietary mappings of CORBA to C++, all

invented independently, differed in many ways. As most C++ programmers know, C++ is

a multiparadigm language that supports varied approaches to application development,

including structured programming, data abstraction, OO programming, and generic

programming. The proprietary C++ mappings reflected this diversity; each of them

mapped different CORBA data types and interfaces into different (sometimes very

different) C++ types and classes. The mapping differences reflected not only the varied

backgrounds of the developers but also the ways they intended to use CORBA to build

systems as diverse as software integration middleware, operating systems, and even

desktop tool kits.

IT-SC book: Advanced CORBA® Programming with C++

When the Object Management Group (OMG) issued a Request For Proposals (RFP) for a

standard mapping of CORBA to C++, these developers and other groups submitted their

mappings to the standardization process. As is common for OMG RFP submissions, the

submitting groups joined forces to try to reach consensus and arrive at a single C++

mapping specification that would draw from the strengths of all the submitted mappings.

The process of producing a single standard C++ mapping for CORBA took

approximately 18 months, lasting from the spring of 1993 until the fall of 1994. For

technical reasons, such as the richness of C++ and its support for diverse programming

styles, the consensus-building process was not an easy one. At one point, because of the

competitive spirit and political nature of some of the parties involved (both characteristics

are inevitable in any industry standards group), the C++ mapping standardization effort

fell apart completely. However, the need for a standard C++ mapping eventually

overcame all obstacles, and the standardization was completed in the fall of 1994.

The C++ mapping was first published with CORBA 2.0. Since its adoption, the mapping

has been revised several times to fix flaws and to introduce minor new functionality.

Despite this, the mapping has remained surprisingly stable and portable even while the

C++ language was undergoing its own standardization process. The standard C++

mapping removed a major obstacle to broad acceptance of CORBA because it created

source code portability, at least for the client side. The server side still suffered from

portability problems until CORBA 2.2.

CORBA 2.0 also removed another major obstacle by providing the Internet Inter-ORB

Protocol (IIOP). IIOP guarantees that system components developed for different

vendors' ORBs can interoperate with one another, whereas before CORBA 2.0, different

system components could communicate only if all of them used the same vendor's ORB.

The C++ mapping and IIOP were key features that initiated CORBA's move into the

mainstream and made it a viable technology for many commercial companies. This

increased popularity of CORBA also meant an increased demand for extensions and bug

fixes. As a result, the specification has been revised three times since the publication of

CORBA 2.0. CORBA 2.1 was largely a cleanup release that addressed a number of

defects. CORBA 2.2 added one major new feature: the Portable Object Adapter (POA).

The POA, together with an update to the C++ mapping, removed the server-side

portability problems that existed to that point. CORBA 2.3, the most recent release, as of

this writing, fixed many minor bugs and added one major new feature, Objects-By-Value.

The OMG has now grown to more than 800 members, making it the world's largest

industry consortium, and CORBA has become the world's most popular and widely used

middleware platform. In our estimation, C++ is the dominant implementation language

for CORBA (although Java is making some inroads for client development). Demand for

CORBA-literate C++ programmers continuously outstrips supply, and it seems likely that

CORBA will remain the dominant middleware technology for at least several more years.

This book is all about making you CORBA-literate and giving you the information you

need to be able to write production-quality CORBA-based systems.

IT-SC book: Advanced CORBA® Programming with C++

1.2 Organization of the Book

The book is divided into six parts and two appendices.

Part I, Introduction to CORBA, provides an overview of CORBA and presents the source

code for a minimal CORBA application. After reading this part, you will know the basic

architecture and concepts of CORBA, understand its object and request dispatch model,

and know the basic steps required to build a CORBA application.

Part II, Core CORBA, covers the core of CORBA with C++: the Interface Definition

Language (IDL), the rules for mapping IDL into C++, how to use the POA, and how to

support object life cycle operations. This part introduces the case study we use

throughout this book; following each major section, we apply the material presented there

to the case study so that you can see how the various features and Application

Programming Interfaces (APIs) are used for a realistic application. After reading this part,

you will be able to create sophisticated CORBA applications that exploit many CORBA

features.

Part III, CORBA Mechanisms, presents an overview of the CORBA networking

protocols and shows the mechanisms that underpin CORBA's object model, such as

location transparency and protocol independence. After reading this part, you will have a

good idea of what goes on beneath the hood of an ORB and how design choices made by

various vendors influence a particular ORB's scalability, performance, and flexibility.

Part IV, Dynamic CORBA, covers dynamic aspects of CORBA: type any, type codes,

and type DynAny. After reading this part, you will know how you can use these CORBA

features to deal with values whose types are not known at compile time. This knowledge

is essential for building generic applications, such as browsers or protocol bridges.

Part V, CORBAservices, presents the most important CORBA services, namely the

Naming, Trading, and Event Services. Almost all applications use one or more of these

services. The Naming and Trading Services allow applications to locate objects of

interest, whereas the Event Service provides asynchronous communication so that clients

and servers can be decoupled from each other. After reading this part, you will

understand the purpose of these services and you will be aware of the architectural

consequences and trade-offs implied by their use.

Part VI, Power CORBA, discusses how to develop multithreaded servers and presents a

number of architectural and design issues that are important for building high-

performance applications.

Appendix A shows the source code for an instrument control protocol simulator that

you can use if you want to experiment with the source code in this book.

Appendix B contains a list of useful resources you can use to get more information

about various aspects of CORBA.

剩余884页未读，继续阅读

jiangdmdr

粉丝: 57
资源: 771

使用C++深入学习CORBA编程

Advanced CORBA® Programming with C++ students book

Advanced CORBA Programming with C++.pdf

(Addison) - Advanced CORBA Programming with C++.pdf

advanced corba庐 programming with c++

CORBA SDK怎么安装

在 EJB 中有 Stub 类与 Skeleton 类,在 DCOM 和 CORBA 中也有类似机智。.试比较这3 种框架在该机制上的异同。

. 在 EJB 中有 Stub 类与 Skeleton 类,在 DCOM 和 CORBA 中也有类似机智。.试比较这3 种框架在该机制上的异同。

怎么评价corba 3.4

undefined reference to CORBA::

glassfish corba

最新资源