Customer Reviews

Database Programming with JDBC and Java (The Java Series)

5 star:		(10)
4 star:		(7)
3 star:		(9)
2 star:		(10)
1 star:		(6)

 

 

The author does a good job of covering new concepts as relevant to Java 2 platform and JDBC 2.0. This book is vastly revamped and is better than the first edition.

Though the author rightly says in the preface that this may not be the book for the beginners, I feel it may not be an ideal JDBC reference book either. The emphasis of this book is on how to build a robust middle tier that interacts with a relational database using JDBC.

Though several examples appear in the book, they could be categorized as relevant for developing a framework than useful for learning by example. Many books that cover EJB, Servlets and JSP now a days provide excellent stand-alone examples of using JDBC.

If you are looking for a book that gives sample "design patterns" for building a middle tier, then this one is for you. If you want to learn JDBC by example, this may not be the book you would want to buy.

The best part of this book is in discussing the process of designing a distributed 3-tier application using Java. The writing is clear and elegant. Figures are impressive. Maybe JDBC itself does not have enough interesting content, the author spent much effort to explore the multiple tier computing model and RMI instead. So, the inside is not exactly what you expected from the book title. It should be, as Reese commented, Distributed 3-tier Client/Server with RMI and JDBC.

I think many people come to this book for detailed JDBC programming information. Anyone who programmed non-trivial JDBC would know that there are a lot bolts and nuts to tackle. To this effect, the book is quite thin. You should not expect this book to help you much in JDBC trouble-shootings. Nevertheless, it is a good guide to teach you design and deploy your JDBC programs on the Internet. As another comment said, I found this book a pleasant surprise, too.

As many have noted, the title of this book is probably a misnomer. It does cover JDBC to a reasonable depth in a very well executed fashion, but it does not go in depth enough to be the standard reference on the subject. However, don't let this keep you from reading this book! It's a panacea for distributed application development, object persistence, and even a dash of design patterns. RMI and JDBC are the technologies used to illustrate the excellent thought process that went into this book, and it is much more valuable than any Teach Yourself JDBC in 21 Days sort of book will ever be. You may need a more complete reference book if you will be doing a lot of JDBC programming, but this book will teach you how JDBC is best used, which in the end is much more valuable.

Once you know what you are getting into, you will find that this book meets your needs rather well.

I'm a Java Certified Programmer for the Java 2 Platform. I bought this book to begin learning additional APIs. The preface claimed that only a basic knowledge of Java and some understanding of SQL was required. The book was not as advertised. Yes, the book did cover basic and advanced JDBC in two very short chapters, and provided a summary of the features of JDBC Optional Package without giving any details in a third. After reading these chapters I feel I have had an introduction to the subject, but no real depth.

The rest of the book takes off into very difficult Java topics (RMI, JNDI, EJB, Java Patterns, Distributed Architectures, Persistence, Swing...)proportedly to demonstrate how JDBC is used in the "real world." From time to time I was actually able to understand some of it, most of the time not. The author did not provide a high level introduction to these topics, which I would have found useful. Rather, the author jumped into the bowels of these subjects in a page or two. The language the author uses is often very exacting such as one might expect to find in a specification. The exacting language and limited number of illustrations caused me to have to re-read many sections several times often to remain confused.

The majority of this book was way too ambitious for someone with the background the Prefaces the reader should have. This book may be very useful for a reader with a more advanced background. After I have read several other books covering the "unadvertised-bonus" topics which comprise most of this book more slowly, I will try to read it again.

Database Programming with JDBC and Java is first and foremost a book about database programming, and not necessarily with Java. The first three chapters are devoted to the fundamentals of database design and access, including several well elucidated design patterns that are fairly easy to implement in any language, though Reese doesn't let on as such (it helps to have prior exposure to other patterns, however; see Design Patterns: Elements of Reusable Object-Oriented Software, by the Gang of Four). He follows this with a chapter on JDBC (only one true chapter) and then a look into the best way to design database access programs with Java, the little JDBC you now know, and his patterns. The final chapter finishes off the case study used to carry the whole book by introducing RMI.

Overall, this is not a bad book. If you want an idea of how database programming works, especially with Java, this is a good read. If you're looking for information on JDBC, RMI, or Java database connectivity in general, don't look here. This book is best read by those understanding Java threads (in a cursory depth) and the AWT. It would make a good compliment to a book on Java distributed computing or JDBC.

An excellent book for at least intermediate level Java programmers. Good mention of the importance of design patterns. Very worthwhile coverage of distributed applications with JDBC and RMI. An interesting "big picture" book to read, and includes an entire well-thought out application.

As an intoduction to JDBC, this is lightweight. About 100 pages are devoted to the JDBC. There is the obligatory API reference at the end that runs to about 90 pages. In between, there are about 120 page devoted to what the author calls "applied JDBC," which is devoted largely to three-tier architecture and transaction handling.

Part I covers SQL, JDBC and the JDBC optional package. There is a smattering of sample code and a moderately extended example of an SQL terminal monitor application. The code cries out for refactoring. For example, there is a sequence of roughly 20 lines of code that centers a value within a fixed length field, truncating or padding as appropriate. The same code appears for lables and column values. It should be pulled out into a separate method. Then there are silly things like using System.out and performing a flush instead of using System.err.

Part II begins with a brief discussion of JNDI, RMI and EJBs. It then delves into architecture and the development of transaction framework. While what's wanted is largely handled by a J2EE application server, the author's approach is: what if that wasn't available and we had to do it ourselves? There is an extensive collection of code here which again cries out for refactoring.

Part III is the JDBC API reference in standard O'Reilly form.

The book is disappointing. The JDBC itself is given short shrift and the author goes off on a tangent of questionable value. If a colleague asked me to look at code similar to what's presented here, I'd mark it up with a red pencil, hand it back and tell him/her to refactor. See Martin Fowler's book "Refactoring." There are numerous bad smells here, including duplicate code, long method and large class.

The first section of the book provided a rapid overview of using JDBC. Many topics, such as establishing the actual database connection (a relatively obscure process as every database vendor writes their JDBC connection class differently) were skimmed over without nearly enough detail. It was useful enough to get a start using JDBC, but little else.

The second part of the book was called "Applied JDBC". I don't think so. The examples were weak and poorly explained. Part of the reason I bought the book was it claimed it detailed "Developing Multi-Tier Applications". There were 5 pages on a writing a 3 tier application. The text only covered enough of each topic to leave you scratching your head wondering about the actual details.

The last section was a reference to JDBC APIs, which you could find online. Most likely already out of date and obviously a filler to turn what should have been a 100 page book into a 300 page book.

Usually I swear by O'Reilly books, but it was hard to justify the expenditure for this one.

George Reese did an excellent job in this book of providing an introduction to the technologies and concepts required for developing a Persistence Framework. In particluar, I enjoyed his discussions of EJB, I found his example and text to give a better description of the main concepts (and shortfalls) of EJB than of any other book I had read, even books on EJB. I only wish the book had a better title reflecting what was discussed in the "Applied JDBC" section. If it did I would have picked it up earlier and not had to go through some of the pain that I did previously when comparing a persistent framework I work with to EJB.

This book starts strong, clearly elucidating the simple mechanics behind opening database connections and controling content updates through sql statements. It quickly drifts into something of a rambling however as the author attempts to cover too much ground in too short a span. Reese jumps from a slow introduction to JDBC and a gentle explanation of how to integrate database calls into simple applications to a mess of complex design patterns and ugly (I mean UGLY... where are his editors) code almost completely bereft of any helpful comments.

It almost seems as if the author started with the noble idea of advancing both the basic and more extensible uses of the API and then gets bored (or drunk) half-way through. The book just drops off a cliff when it gets to the 7th chapter.

The biggest crime however is that the text only devots a cursory page and a half to the high subject of Connection Pooling despite declaring (correctly) that it is absolutely essential to any successful JDBC deployment. Where does the author suggest we find information related to this topic, in a book dedicated to the discussion of Swing??

Look elsewhere... this text is under-edited, under-written and over-priced for the amount of useful information it contains; terribly dissapointing!