Developing Java Beans

Developing Java Beans
Robert Englander | 1997-06-01 00:00:00 | O'Reilly Media | 316 | Java
Java Beans is the most important development in Java this year. It gives Java developers the ability to work with sophisticated graphical development tools and to integrate Java software into projects using other component technologies, such as Microsoft's ActiveX. Developing Java Beans gives you a firm grounding in every aspect of the Java Beans component architecture. You'll learn how to create components that can be manipulated by tools like Borland's JBuilder or IBM's VisualAge for Java, enabling others to build entire applications by using and reusing these building blocks. Beyond the basics, Developing Java Beans teaches you how to create Beans that can be saved and restored properly; how to take advantage of introspection to provide more information about a Bean's capabilities; how to provide property editors and customizers that manipulate a Bean in sophisticated ways; and how to integrate Java Beans into ActiveX projects. If you're a Java developer, you'll want to take advantage of Java's component architecture. Developing Java Beans gives you a comprehensive introduction to this exciting new technology. The book covers:

• Events, event listeners, and adapters
• Properties, indexed properties, bound properties, and vetoable property changes
• Persistence, serialization, versioning, and object validation
• Packaging Beans using JAR files
• The BeanBox, a prototypical development tool
• Reflection and introspection
• Property editors and customizers
• The ActiveX bridge; using Java Beans in Visual Basic programs

Reviews
A nice little text with useful snippets of code, and advice on

applying them. However, the order of presentation can be a little

confusing. Also, some of the topics were a little beyond what I

needed it for, though that is not a bad thing.



What I found annoying at times was that it did not always address a

question I may have had about how to apply a particular class.

Having "Learning Java: 2nd Edition" helped somewhat to alleviate

this as it had more in the way of explanations than this book.



For the absolute beginner I would probably recommend another book.

However, if the reader has background knowledge in Java, or other

programming languages then this book will probably prove to be

useful.
Reviews
I've been programming for 10 years, and I have 2 bookcases full of ORA and ADW books. I have to say that this is among the most confusing programming books I've seen.

I'm in the same position as the guy below who's confused after 3 chapters. The first couple of chapters of this book seem to be a tutorial about event handling, and applet creation. Applets? I have no idea where the author is going with this stuff. It's not that I don't understand the concept of event handling, it's just that this guy does not explain what the heck handlers and listeners have to do with beans. I'm sure they do, somehow...

Perhaps if the author provided an an explanation up front about where he's going with the code, I'd stick with the program. Even better, how about an overview of why beans are so great and useful, with some trivial examples. Then progress to the 'real world' stuff.

I'm dissapointed with this book because I need to learn about Beans... fast. 3 chapters of working bean code and good examples would have been enough for my instincts to kick in and take me the rest of the way. I don't have the time to search for answers, I thought that a $30.00 investment in an ORA book would have saved me hours of searching. Well, not this time.

If you can get the applets from chapters 1 and/or 2 working, please post how in this forum. You'd be doing a lot of folks a favor. Good luck figuring out if you should be compiling *.java.1 or *.java.2 examples.

That's enough about this one... Now I have to find a GOOD beans book.
Reviews
This is not a good tutorial about Java Beans. In order to explain the Java Bean concept you have to start with the Java Beans specifications of Sun. This would answer question about which things are relevant and why they are relevant in JavaBeans development. Now the the reader almost jumps into a long winded explanation about events and adapters, wondering why this is relevant and what the writer wants to explain. To make matters worse: the example contains errors! Basically, after the first three chapters I was utterly confused.

This book also needs a clearer description about the use of Java Beans. In a next update we definitely need a chapter about how JavaBeans are used in Java Server Pages.
Reviews
This book is titled "Developing Java Beans". It spends lots of time to talk about the detailed architecture of Event model and other important topics used in Beans. It is well written and easy to follow. However, may not be the good book for those poeple in a rush just want to how to write a Java Beans.
Reviews
Actually I bought this book about two years ago, and at that time Java Beans were gaining popularity as an instance of component model for distributed computing. I was at that time interested in Enterprise Java Beans rather than client side beans. So I did not really use the book that much. However, from the limited reading I did, it seemed like a very well written book for the uninitiated, gave a good view of the Beans, how to create the client side beans etc. However, since then I have moved my field of interest from Java to some thing else, and in the mean time EJB have taken an increasingly important role in the server side component model. So I hope this book is updated or the same authors write a separate book on EJB (more meaningful to do the latter).

Download this book!

Free Ebooks Download

Java and JMX: Building Manageable Systems

Java and JMX: Building Manageable Systems
| 1969-12-31 00:00:00 | | 0 | Java


Comprehensive coverage-from APIs, programming techniques, and pitfalls, to the integration of JMX applications into J2EE and Web services. The definitive JMX reference. Softcover.

User review
Excellent Resource
This book is divided into three parts. The first section is a history of managing computer applications and an explanation of why JMX is needed for Java applications. The second part goes into detail about JMX and the third section is about JMX applications.

The first section is an informative history of managing computer applications from mainframes to present day applications. I the reader can skip this section, if he or she just wants to understand JMX.

The second section explains Means and the tools behind JMX-based management. MBeans represent a resource that a management system will monitor and control. The MBean is the resource according to the management server. The book goes into great detail in creating and using MBeans, including the MBean notification events. In this part, as throughout the book, the explanations are clear and comprehensive. The examples fully show the user how it works and are explained completely by the authors.

This book has a serious and comprehensive style. The authors assume that the reader has a fairly extensive knowledge of Java. This book is an excellent introduction to JMX and is comprehensive in its coverage of all topics related to JMX. I would recommend this book for anyone interested in learning about JMX.

User review
Not just a cookbook
Unlike `JMX in Action` from Manning, this book goes beyond the How To of JMX.
It introduces the reader to the fundamental problems of systems management, before jumping into concrete implementations.
It explains the history of the industry from the days when hundreds of people shared one mainframe and sys-admin was the same as god, to the present days when everyone has access to hundreds of computers.
It also gives an overview of the numerous system management standards and explains why some of them were successful while others were not.
Before I got to the JMX chapters I understood how the veterans in the industry with decades of experience distilled the scope of systems management to a few basic concepts that define it.
It helped me make a better choice when thinking about which parts of an application should be manageable.
Very strong book.
Just be aware that it is not a very fun reading. The book uses a tight, dry and fast style. You better be serious about it before turning the front page.

User review
Easy to understand
Remember when java burst onto the scene on 1996, and you could write cool applets that showed animations on a web page? Well things have progressed vastly since then, and especially after the dotcom crash, being essential is far more important than being cool. The emphasis with java has shifted from towards backend, web server-type applications, when you have to interact with legacy databases and management tools. The problem with the latter is that if you are writing a java application that is to be controlled by some management level software, this latter item could be furnished by several companies. It is expensive to customise your code for each management package; but not to do so may severely restrict your sales.

JMX, Java Management Extensions, arose to solve this puzzle. It is still fairly new, and not many java programmers may be familiar with it. If so, this new book [2003 vintage] will help educate you. The authors point out a simple analogy that may clarify. Shortly after java was introduced, there was a need to let java programs access data in databases made by various
vendors. The solution was an industry standard API, called JDBC. Each database vendor wrote an implementation of this API, which was hence called a JDBC driver. This let java programmers program to that interface and ignore any lower level details.

So if you can understand that, you can understand JMX. The difference is that here your java application will be controlled by some management software, whereas with JDBC, your java program would have been the controlling entity.

The bulk of the book goes into the details of the JMX API. [Ok, it may not be literally an application programmable interface, but conceptually you can think of it that way.] The exposition is straightforward and logical.

A nice resource for the aspiring JMX developer.

Java: Practical Guide for Programmers

Java: Practical Guide for Programmers
| 2002-12-23 00:00:00 | | 150 | Java


If you're an experienced programmer, you already have a rock-solid foundation for learning Java. All you need is a resource that takes your experience into account and explains Java's key principles and techniques in an intelligent, efficient way.

Java: Practical Guide for Programmers is precisely that resource. Here, you won't have to wade through hundreds of pages of overly simplistic material to learn the basics of Java programming. Instead, you get highly focused instruction in the core elements of Java 1.4, accompanied by carefully chosen examples and line-by-line analyses that are right to the point. You'll be astonished at how soon you can begin productive coding in Java, and how quickly your skills will progress.

Web resources:
Source code from the book is no longer available at
http://www.zm.sikora.btinternet.co.uk/source.html
Please press the 'Companion Page' button on the upper right side of this page to access a zip file containing it.

Sun J2SE download page
http://java.sun.com/j2se/downloads.html

Sun J2SE API documentation
http://java.sun.com/j2se/1.4.1/docs/index.html

* Written expressly for people who already know a procedural or object-oriented programming language.
* Takes a concise approach designed to make the most of the experience you already have.
* Covers the core elements of Java 1.4, including language syntax, OO features, collections, exception handling, input/output, threads, event handling, and Swing components.
* Filled with incisive coding examples and line-by-line analyses.
* Via a companion Web site, provides downloadable example code and links to additional resources.

User review
A CONCISE Java Grammar!
I love this little one. From time to time, between working through and losing myself in half dozen or more heavy tomes of Java book, I would come back to this little one to get a grip of fundamentals and essentials. The book is concise and no nonsense. I also like the banking application sample code. Practical enough. Who doesn't bank?

User review
Good for experienced coders
As the book's title shows, it's just a guide, a simple guide that you can not expect too much details out from it. Before learning Java, I am a Delphi coder. So, I was looking for some book to transfer me from Delphi to Java quickly. Within merely 170-odd pages, Sikora brings you an overview of the Java language. I think this guide just right fits my taste. Another thing to be mentioned, if you are a serious coder, a detailed reference is necessary. As what I am doing now, Java 2, The Complete Reference is by far the most suitable book for me, after I have an bird's eye view from Sikora's guide.

User review
quickly learn Java?
Indeed, Sikora offers a quick start to learning Java. He eshews an exhaustive enumeration of every core class in J2SE. Instead, he takes several high level topics and explains which common classes deal with these. A question arises. Can you indeed learn Java from so slender a book? Perhaps. Sikora teaches a core functionality. Made easier if you have already programmed in some other language.


For graphics, he leads you right into Swing. No time wasted on the earlier and inferior AWT classes.


For input/output, Java is more powerful than C or C++, but concomitantly harder to use. The coding is far more verbose, compared to a simple printf() or scanf() in C, for example. The minimal descriptions in Java given here are admirable in how he found the essence of enough to be useful.

User review
Java for self-starters
If I could only recommend one book to an experienced programmer who wanted to learn Java it would be this one. It's only 170 pages long and it doesn't contain anything that's unnecessary. But it does cover syntax, flow control, classes and methods, inheritance, exception handling, file I/O, GUI's, collections and threads. That's genuinely Java in a nutshell.

The author can offer such a stripped-down book, of course, because he assumes that the reader already understands programmatic flow control and objects, and can follow a basic inheritance hierarchy without tedious explanation.

Java isn't a difficult language: it can merely be made to seem so by textbooks that bury simple facts under mountains of verbiage. I hope other authors will take Zbigniew Sikora's `Java: Practical Guide for Programmers` as a model for textbooks for busy people.