Customer Reviews

Beginning J2EE 1.4: From Novice to Professional (Apress Beginner Series)

5 star:		(7)
4 star:		(6)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

This book provides an excellent start on J2EE. It covers a good set of topics, including Servlets, JSP, and the various forms of EJBs.

My only disappointment is that the book focuses on Sun's J2EE server. This server will not likely be used for production. The book provides detailed usage information for Sun's proprietary deployment tool.

In my opinion, JBoss should be used as the application server for teaching. The server is free, deployment is as simple as copying a JAR file, and the server is truly enterprise ready. Plus, the book would then provide more complete examples of deployment descriptors.

As a professional software developer, I've used some of the J2EE technologies on projects. I picked this book up to fill in knowledge gaps on some the features of J2EE that I hadn't used before. As I expected this book does a good job of covering the basics, but I was very pleasantly surprised to find that this book also covers some advanced topics. I expect that even experienced developers will find themselves referring back to this book not only for a refresher on the basics, but as a reference for advanced topics as well.

There is a little bit of tongue in cheek humor sprinkled through the book, such as one section heading called "Using JNDI to Phone Home". If you don't get the joke, read the first chapter on EJB's and you will. If you get the joke and are groaning, then you haven't hung around with enough software developers. That kind of thing constitutes high brow humor at my company. I can't wait to get back to work and use it.

The first chapter is an overview of web based applications, and where J2EE technology fits into the picture. It paints the big picture view that should be enlightening to most everyone, other than the seasoned web developer.

The second chapter is either the most, or least important of the book. It is instructions for how to setup the Sun J2EE environment on your machine, and the PointBase database. If you already have access to a J2EE 1.4 environment, then you may not need this chapter. The examples in the book are using the Sun tools, so you may want to follow the setup to make it easier to step through the examples in the book.

Chapters 3 & 4 are about JSP's and go from the basics to some pretty advanced topics, such as tag libraries, and expression language. I found quite a few bits of valuable information in these chapters.

Chapter 5 is about servlets. Servlets have been around for a quite a while now. If you aren't familiar with them, this is a good introduction to the technology.

Chapters 6 and 7 are about database access. Writing web applications really start getting fun when you start thinking about hitting the database. These are a couple of meaty chapters that start with the basics, straight JDBC/SQL, and then cover some advanced topics like stored procedures, database locking and isolation levels. I was pleased to pick up a lot of new and valuable information in these chapters.

Chapters 8 through 11 cover EJB's. Again you are taken from the basics, through advanced topics. EJB's are a tough subject, in my opinion. But, this book does spend a lot of time explaining how to configure and deploy them, which isn't obvious. If you aren't familiar with EJB's, being able to follow along with the examples in the book, having followed the chapter 2 setup, will be a big help. If you can make it through creating and deploying your EJB's, then the book covers some advanced topics like container managed relationships (CMR), EJB-QL, and EJB design patterns.

Chapters 12 and 13 cover web services. Before I read this chapter I would not have considered web services, a J2EE topic. It is certainly a web application topic, and something that seems to be emerging more often as a solution in web applications. However, I didn't realize how J2EE now makes some accommodations to support building a web services application with J2EE technologies. Again, interesting material in these chapters.

I am anticipating that I will be referring back to this book quite often.

The introduction to this book emphasises a "meat and potatoes" approach. The authors focus on describing the key points of J2EE 1.4, that most users can expect to need, most of the time. The reason this is necessary is because J2EE in this latest iteration encompasses a group of subjects, each of which can be, and has been, the sole subject of a book.

Specifically, we have Java Server Pages and Java Servlets. These are often used to make dynamic web pages, within a web server container like Tomcat, which gets an appendix of its own here, due to its importance.

As a practical matter, these JSPs/Servlets often hook up to databases. So J2EE involves using JDBC. Another 2 chapters here.

Business logic is often encapsulated using Enterprise Java Beans. These are now quite mature. Their widespread use in a J2EE context is reflected here in the 4 chapters devoted to them. These include a discussion of the recently introduced Message Driven Beans, used in JMS.

Finally, 2 chapters are given over to Web Services. Here the discussion is somewhat skimpy. Not thru any fault of the authors. Web Services are currently very inchoate. Much is being claimed for their future potential. But in terms of what is defined and available right now - well there isn't much. If you really are interested in Web Services, try a companion volume from the same publisher, "Google, Amazon and Beyond: Creating and Consuming Web Services" by Nakhimovsky and Myers.

The utility of this book is in letting you quickly come up to speed on J2EE. As a practical matter, once you have done so, you may want to get comprehensive books on the specific J2EE subjects that you will be dealing with. A virtue of this book is that it deliberately is NOT comprehensive. But it gives you the gist of each subject.

Normally I'm not the type of person that puts the effort into reviewing a product online. In fact, I believe this is my first review ever. However, the quality of this book motivated me to publicly declare my opinion and appreciation.

I've been a Software Developer for eight years, and Java only within the past year. Recently my company asked me to create an application, however this time I was to experiment with J2EE as the platform. I struggled through it, mostly via trial-and-error, javadocs, online tutorials, etc.

Then I dediced to get this book to fill in the gaps. It accomplished this task extremely well. I already knew around 60% of what the book contained, but the remaining 40% was extremely usefull. The explanations were clear and easy to understand. It followed a logical progression of topics.

What I appreciated the most about the book is the ability of the author(s) to satisfy the questions that would come up as I read the text. It's as if they put great effort into preparing for what the reader may be wondering as they read a description or example, and then answered these questions in the next paragraph. Even including the small details that would otherwise prevent me from effectively using the overall topic in the real world.

Where other books would suffice to say "This is what you do to make this happen," and maybe "This is why," this book goes the extra mile and says, "This is what happens in the background when you do this." This is extremely usefull information when it comes time to creating a real application. It gives you the insight needed to make well-informed decisions on which methods, protocols, libraries, etc. to use. Not to mention debugging.

I also appreciated how they included step-by-step examples which were very well-done. They demonstrated the topic-at-hand, without getting too wordy and involved. The exercises were also thought-provoking.

Of course, I realize that good reviews should also include what negative things the reviewer found with the product. Although the positive far outways the negative, I did find some slight grievances. There could have been more exercises. Sometimes they repeated instructions which a competent reader should be able to do on his own after the first time.

That's about it. As far as complaints, they are hardly worth mentioning. If you are a fairly new J2EE developer, do yourself a favor and get this book!

Overall a very good book except for the errors. ;-) I would've given this book a higher rating if it were not for the editing.

I read the book from cover to cover. The explanations are good but there are problems with the examples. It really is difficult to find a programming book that is not rife with poor instructions and/or examples that will not compile. This book is better than most but I am a rather unforgiving sort when it comes to code examples in a book. There is nothing more frustrating than spending hours on a problem that could've been solved at the outset with just a little more attention to detail by the editors.

My setup is a Windows XP Pro notebook, jdk1.5.0_06 installed on C:\ (the root directory) and J2EE 1.4 also stored on the root. I am using Eclipse 3.1 for an IDE (Integrated Devlopment Environment). If you can avoid it, do not put any of your Java software in directories that have spaces in their directory/folder names. This will prevent problems you will encounter when entering commands on the command-line that involve using environment variables in path names (there may be other problems avoided as well).

Here is a summary of some of the trouble I ran into. I would like to say at the outset that I DO recommend this book. Unfortunately there is no such thing as an error-less computer book especially when you are dealing with a technology that has not yet matured.

The problems begin in Chapter 3 on page 54, #5. Compiling the FaqCategories.java resulted in the following message...
Note: FaqCategories.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
To solve this problem I changed the following line of code...
private Vector categories = new Vector();
to...
private Vector<String> categories = new Vector<String>();

This problem occurred because JDK 1.5 uses generics. I guess I can't blame this one on the publishers because I am probably using a later JDK than they were. This problem comes up again in Chapter 4, page 108, Questions.java. You will need to compensate for the use of generics in JDK 1.5. So here is the source you should use for that example...
import java.util.Map;
import java.util.HashMap;

public class Questions {
private String topic;
private int numTopics;
private Map<String, String> questions = new HashMap<String, String>();

public String getTopic() { return topic; }
public void setTopic(String t) { topic = t; }

public int getNumTopics() { return numTopics; }
public void setNumTopics(int n) { numTopics = n; }

public Map getQuestions() { return questions; }
public void setQuestions(Map<String, String> m) { questions = m; }

public Questions() {
questions.put("1", "How do I use implicit objects?");
questions.put("2", "How do I use the JSTL?");
questions.put("3", "How do I use the 'empty' operator?");
setNumTopics(questions.size());
}
}


I remember having trouble with the JSTL (Java Standard Tag Library) examples in Chapter 4 but unfortunately I did not make any notes for those problems.

In Chapter 5, page 161, #3 I had a problem with the login.html page. I changed the following line...
<form action="/Ch05/Login" method="POST">
to...
<form action="Login" method="POST">
You may not have the same problem depending on your setup.

I had the same problem with the code on page 192 near the bottom of the page. I removed '/Ch05/' from the path. The explanation on page 194, #5 is not good at all. It would've helped tremendously if they had included a better explanation and a screen shot.

Want to get confused? Read the first paragraph under "How It Works" on page 204. The whole Filter topic needs to redone.

In Chapter 6, page 243, the connection string they use is just plain wrong. Look at how they refer to the same snippet of code in the middle of page 245, that is the correct connection string. I have no idea how they came up with the one on page 243.

In Chapter 7, page 263 in the middle of the page the variable declaration should be "String sql" not "String sdl". On page 274 I had problems with the command-line entries. I had to resort to using the App Server Admin Console. On page 275 the conn, stmt and rset variables are declared just before the try block and within the try block itself. I removed the words Connection, Statement and Resultset from within the try block. In the smae example I had to remove the semi-colon from <%= e.getMessage(); %>, it should read, <%= e.getMessage() %>. In page 289 replace "192.168.1.103" with "localhost". (Someone was asleep at the wheel in Chapter 7!)

In Chapter 8, page 325 the Deploytool shows a "JNDI Name" tab. My version of the Deploytool does not have a "JNDI Name" tab but the same functionality can be found through a click on the "Sun-specific Settings" button. On page 328, the command line entry shown in #2 did not work unless I rebooted my computer first. It could be that if it doesn't work for you try stopping and restarting the app server. That may be all

it needs. On page 337, #11, the second bullet, change 'Stateless' to 'Stateful' - then you will be in agreement with the session-type tag in the ejb-jar.xml file shown on page 341.

In Chapter 9, page 359 - remember, if you do not have a "JNDI Name" tab click on the "Sun-specific Settings" button. On page 389 the "Try It Out" example does not point out changes that must be made in the source code from a previous example to make this example work. I had to

download the examples from the APress web site to see that there were differences (normally I hand-poke all the source code examples to get used to the "feel" of the code - in this case that practice presented a problem).

Chapter 10 became a problem for me because as with other places in the book this chapter uses source code developed in previous examples and builds upon them. Well, if everything went well for you with the previous example then this practice is fine but if you had problems that you could not solve then you are pretty much out of business in subsequent examples. This is where the authors started leaving out detailed steps because, supposedly, you already did those in the previous example. Well, what if you were just hopping around in the book? I don't
like their practice of leaving out the detailed steps - put them back in, afterall its only a page or two here or there.

In Chapter 11, the top of page 475, the command-line entries are wrong. Each option needs to be double-hyphenated and the option 'resourcetype' needs to be changed to 'restype'. Here is what the first command-line entry should look like...
asadmin create-jms-resource --user admin --restype javax.jms.QueueConnectionFactory --property imqAddressList=localhost jms/QueueConnectionFactory

In Chapter 12 there is a very long and involved set of steps to go through to implement a web service and then invoke a client application to use that web service. I got all the way up to the next to the last step and wouldn't you know it, the client app will not compile. It looks like a seemingly easy-to-fix problem but the solution is not readily apparent. The error is "Package javax.xml.rpc does not exist" but that class is in the application's project. Strange problem but I have not found a solution to date. So that problem mows down two whole chapters because chapter 13 depends on this example too.

Being a .NET developer, I had a good idea about system architecture overall coming into this book, but admittedly little in terms of concept that were specific to Java. I feel confident about developing dynamic apps with J2EE now after reading this work. It does a great job of introducing the major concepts within Java 2 Enterprise Edition (JavaServer Pages, Enterprise
JavaBeans, servlets, XML, web services, using a variety of appServers, etc.).

The introductory chapters talk about installing J2EE, relating it to J2SE, and setting the all-important environment path variables. The examples are complete, with step-by-step instructions on coding, compiling, deploying and executing examples for console, desktop and web environments. It's not one of those books that is heavy on theory and light on pragmatic examples - the concepts are backed by real-world apps. Each example is also presented for execution in both the default documentation appServer for J2EE, as well as Tomcat. It's a nice mix that isn't married to one specific platform.

The authors enforce a strict usage tiered system design, and demonstrate how to move from simple 3-tier applications to MVC- and pattern-based n-tier architectures using complex components. On this note, I particularly enjoyed the chapters on developing EJBs, which were very healthy.

However, I thought the last two chapters on web services with Java, while helpful, were incomplete, specifically in the areas of developing multi-platform clients to access SOAP messages through JAX-RMI. I would have liked to see Swing/AWT utilities and JSP-based clients call not only Java web services, but also HTTP-SOAP services using .NET and other vendor platforms to reinforce the main advantage of decoupled distributed systems.

But nonetheless, I found this book to be a great help in my quest to get myself up to speed with modern-day Java development. I'm a better programmer for having read it, and I recommend you do, too.

I was taking a college course using Wrox press pro to pro series book on J2EE and it was kicking my butt. I purchased this book and it was invaluable in breaking down concepts in an easy to understand manner. The book is well written and a great introductory text to J2EE, I highly recommend it for anyone trying to learn this technology.

I've been programming on the web before there was Java but never really got into or saw the value in EJB's. That has changed in the latest specifications as they start mature. I found this book very helpful in getting started with EJB's but taking examples far enough to make them useful for real world problems. The text took examples to another level with good design patterns for use with EJB's. Another great bonus was the inclusion of complete code, and not just snippets. The only thing I would want to be improved or different would be examples with JBoss and eclipse. I understand its hard to write for all target platforms, but its on the wish list.

The book is a very well-balanced introduction to many J2EE topics such as JSP, Servlets, JDBC, and EJB. Examples are "as simple as possible, but no simpler", and are quite useful for understanding the various topics.
Obviously this book is now out in the newer edition that covers the much-changed and simplified (yey!) Java EE 5, but for anyone who would need to work with legacy J2EE 1.4 applications this book certainly provides good value.

The book covers all the J2EE 1.4 technologies. The authors don't assume you have a background in J2EE and they explain the concepts in a very plain language.
It has a lot of interesting information about JDBC, JSP and EJBs. Moreover, some J2EE design patterns are present in the book. The drawbacks are the poor JMS and WS content.
If you have to maintain a J2EE 1.4 project this book is a good starting point.
If you have to start a new JEE project you should upgrade to JEE 5 because it is easier, more powerful and more productive. "Java EE 5 Development using Glassfish" is a good choice to have an overview of JEE 5.