Summer Reading B2G1 Free
 
 

Special Offers see all

Enter to WIN a $100 Credit

Subscribe to PowellsBooks.news
for a chance to win.
Privacy Policy

Visit our stores


    Recently Viewed clear list


    Original Essays | July 14, 2015

    Joshua Mohr: IMG Your Imagination, Your Fingerprint



    When I was in grad school, a teacher told our workshop that if a published novel is 300 pages, the writer had to generate 1,200 along the way. I... Continue »
    1. $17.50 Sale Hardcover add to wish list

      All This Life

      Joshua Mohr 9781593766030

    spacer

On Order

$45.50
New Trade Paper
Currently out of stock.
Add to Wishlist
available for shipping or prepaid pickup only
Qty Store Section
- Local Warehouse Computer Languages- Java

Component Development for the Java Platform (DevelopMentor)

by

Component Development for the Java Platform (DevelopMentor) Cover

 

Synopses & Reviews

Publisher Comments:

Java™ is an object-oriented language, but it is also a component-oriented platform. Java's class-loading model and rich type information makes it possible to build flexible and reusable binary components. COMPONENT DEVELOPMENT FOR THE JAVA™ PLATFORM reveals both the potential and pitfalls of developing components using the Java platform.As a platform, Java defines the services needed to connect binary components at runtime safely and reliably. To truly take advantage of all that Java has to offer, you must consider not just development but also deployment, and not just objects but also components. COMPONENT DEVELOPMENT FOR THE JAVA™ PLATFORM delves into the component-oriented features of the Java platform, thoroughly discussing class loading, reflection, serialization, native interoperation, and code generation.

KEY TOPICS INCLUDE HOW TO:

  • Use and troubleshoot Class Loaders
  • Build dynamic and generic services through reflection
  • Control an object's serialized representation
  • Load and use native code components
  • Extend the Java class format to add custom services
  • Automate development with code generation

This is a cutting-edge approach to Java programming: An emphasis on deployment can be the best way to take advantage of some of the most valuable, yet less heralded, aspects of Java technology.

0201753065B11212001

Book News Annotation:

Defining component as "an independent unit of production and deployment that is combined with other components to assemble an application," this guide shows programmers how to use Java to develop components. Chapters cover the class loader architecture, type information and reflection, serialization, customizing class loading, interoperating, and generative programming. The author assumes the reader understands object-oriented programming in Java.
Annotation c. Book News, Inc., Portland, OR (booknews.com)

About the Author

Stuart Dabbs Halloway is responsible for the Java curriculum at DevelopMentor, where he teaches the Guerrilla Java and Intensive Java courses. He writes for Sun¿s Java Developer Connection(SM) and for JavaPro magazine, and regularly speaks at industry events such as JavaOne. Stuart received his B.S. and M.P.P. degrees from Duke University.

0201753065AB06182002

Table of Contents

Preface.

1. From Objects to Components.

2. The Class Loader Architecture.

Assembling an Application.

Goals of the Class Loader Architecture.

Transparency.

Extensibility.

Capability @

Configurability.

Handling Name and Version Conflicts.

Security.

Explicit and Implicit Class Loading.

Explicit Loading with URLClassLoader.

Implicit Class Loading.

Reference Type vs. Referenced Class.

ClassLoader.loadClass vs. Class.forName.

Loading Nonclass Resources.

The Class Loader Rules.

The Consistency Rule.

The Delegation Rule.

The Visibility Rule.

Delegations as Namespaces.

Static Fields are Not Singletons.

Implicit Loading Hides Most Details.

Hot Deployment.

Using Hot Deployment.

Unloading Classes.

Making Sure Classes are Collectable.

Bootclasspath, Extensions Path, and Classpath.

The Classpath.

The Extensions Path.

The Bootstrap Loader.

Debugging Class Loading.

Instrumenting an Application.

Using -verbose:class.

Instrumenting the Core API.

Inversion and the Context Class Loader.

Onward.

Resources.

3. Type Information and Reflection.

The Binary Class Format.

Binary Compatibility.

Binary Class Metadata.

From Binary Classes to Reflection.

Reflection.

Reflecting on Fields.

The Difference between get and getDeclared.

Type Errors Occur at Runtime.

Reflecting on Methods.

Reflective Invocation.

A Reflective Launcher.

Wrapping Primitive Types.

Bypassing Language Access Rules.

Exceptions Caused by Reflective Invocation.

Dynamic Proxies.

Delegation Instead of Implementation Inheritance.

Dynamic Proxies Make Delegation Generic.

Implementing InvocationHandler.

Implementing a Forwarding Handler.

The InvocationHandler as Generic Service.

Handling Exceptions in an InvocationHandler.

Either Client or Server can Install a Proxy.

Advantages of Dynamic Proxies.

Reflection Performance.

Package Reflection.

Setting Package Metadata.

Accessing Package Metadata.

Sealing Packages.

Weaknesses of the Versioning Mechanism.

Custom Metadata.

Onward.

Resources.

4. Serialization.

Serialization and Metadata.

Serialization Basics.

Serialization Skips Some Fields.

Serialization And Class Constructors.

Using readObject and writeObject.

Matching Streams With Classes.

The serialVersionUID.

Overriding the Default SUID.

Compatible and Incompatible Changes.

Explicitly Managing Serializable Fields.

ObjectInputStream.GetField Caveats.

Writer Makes Right.

Overriding Class Metadata.

Performance Problems.

Custom Class Descriptors.

Abandoning Metadata.

Writing Custom Data After defaultWriteObject.

Externalizable.

Using writeObject to Write Raw Data Only: Bad Idea.

Object Graphs.

Pruning Graphs with Transient.

Preserving Identity.

Encouraging the Garbage Collector with Reset.

Object Replacement.

Stream-Controlled Replacement.

Class-Controlled Replacement.

Ordering Rules for Replacement.

Taking Control of Graph Ordering.

Finding Class Code.

Annotation in RMI.

RMI MarshalledObjects.

Onward.

Resources.

5. Customizing Class Loading.

Java 2 Security.

The Role of Class Loaders.

Custom Class Loaders.

Pre-Java 2 Custom Class Loaders.

Class Loading Since SDK 1.2.

A Transforming Class Loader.

Protocol Handlers.

Implementing a Handler.

Installing a Custom Handler.

Choosing Between Loaders and Handlers.

Getting Past Security to the Loader You Need.

Reading Custom Metadata.

Example: Version Attributes.

Serializable Classes as Attributes.

Reading Attributes During Class Loading.

Debugging Support.

Onward.

Resources.

6. Interop 1: JNI.

Why Interoperate?

The Dangers of Native Code.

Finding and Loading Native Code.

Name Mappings.

Type Mappings.

Overloaded Names.

Loading Native Libraries.

Class Loaders and JNI.

Common Errors Loading Native Libraries.

Troubleshooting Native Loading.

Calling Java from C++.

Minimizing Round Trips.

Performance Comparisons.

Differences Between JNI and Reflective Invocation.

Error Handling in JNI.

Failures in Native Code.

Handling C++ Exceptions.

Handling Java Exceptions from Native Code.

Throwing Java Exceptions from Native Code.

Resource Management.

Interacting with the Garbage Collector.

Managing Native Resources.

Managing Arrays.

Managing Strings.

Onward.

Resources.

7. Generative Programming.

Why Generate Code?

Object Oriented Approaches to Modeling Variabilities.

Thinking in Terms of Bind Time.

Separating Specification From Bind Time.

Choosing a Specification Language.

Reuse Requires More than One Use.

A Little Domain Analysis is a Dangerous Thing.

Why Generate Code with Java?

Type Information Acts As a Free Specification Document.

Class Loading Supports Flexible Binding Modes.

Java Source is Easy To Generate.

Java Binary Classes are Easy To Generate.

Code Generation Boosts Performance.

Levels of Commitment to Code Generation.

A Taxonomy of Bind Times and Modes.

Code Generation in RMI.

Code Generation in JSP.

Code Generation in EJB.

The Deployment Descriptor.

Alternate Implementations.

Generating Strongly Typed Collections.

Code Generation Language versus Target Language.

Generating Custom Serialization Code.

Onward.

Resources.

8. Onward.

Where We Are.

Where We Are Going.

Resources.

Appendix—Interop 2: Bridging Java and Win32/COM.

Index. 0201753065T11262001

Product Details

ISBN:
9780201753066
Foreword:
Box, Don
Author:
Box, Don
Author:
Halloway, Stuart Dabbs
Publisher:
Addison-Wesley Professional
Location:
Boston
Subject:
Programming Languages - General
Subject:
Programming - General
Subject:
Java (Computer program language)
Subject:
Programming Languages - Java
Subject:
System design
Subject:
Java
Subject:
Computer Languages-Java
Copyright:
Edition Description:
Trade paper
Series:
DevelopMentor series
Series Volume:
no. 2001-2728
Publication Date:
December 2001
Binding:
TRADE PAPER
Grade Level:
Professional and scholarly
Language:
English
Illustrations:
Yes
Pages:
368
Dimensions:
9.1 x 7.3 x 0.9 in 567 gr

Related Subjects

Computers and Internet » Computer Languages » Java
Computers and Internet » Software Engineering » Programming and Languages

Component Development for the Java Platform (DevelopMentor) New Trade Paper
0 stars - 0 reviews
$45.50 Backorder
Product details 368 pages Addison-Wesley Professional - English 9780201753066 Reviews:
spacer
spacer
  • back to top

FOLLOW US ON...

     
Powell's City of Books is an independent bookstore in Portland, Oregon, that fills a whole city block with more than a million new, used, and out of print books. Shop those shelves — plus literally millions more books, DVDs, and gifts — here at Powells.com.