Vous voulez voir cette page en français ? Cliquez ici.

Sign in to turn on 1-Click ordering.
Amazon Prime Free Trial required. Sign up when you check out. Learn More
More Buying Choices
Have one to sell? Sell yours here
Tell the Publisher!
I'd like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Building J2EE¿ Applications with the Rational Unified Process [Paperback]

Peter Eeles , Kelli A. Houston , Wojtek Kozaczynski
4.6 out of 5 stars  See all reviews (5 customer reviews)
List Price: CDN$ 57.99
Price: CDN$ 46.39 & FREE Shipping. Details
You Save: CDN$ 11.60 (20%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 1 left in stock (more on the way).
Ships from and sold by Amazon.ca. Gift-wrap available.
Want it delivered Friday, October 3? Choose One-Day Shipping at checkout.
Save Up to 90% on Textbooks
Hit the books in Amazon.ca's Textbook Store and save up to 90% on used textbooks and 35% on new textbooks. Learn more.
Join Amazon Student in Canada

Book Description

Aug. 20 2002 0201791668 978-0201791662 1
The first book to specifically address the intricacies of developing J2EE applications using the Rational Unified Process.
Helpful technology overview helps reader learn basics of J2EE, RUP, UML, and various critical web technologies.
Must-have information for any Java developer working in an organization that uses the RUP.
Also helps reader gain an understanding of how component architectures are applied in a systematic fashion. This book is a Rational Software Corporation-specific book focusing on the development of J2EE applications (version 1.3) within a RUP (Rational Unified Process) environment. As such, the book has a heavy dependency on UML (version 1.4). The authors aim to give the reader a basic understanding of component architectures and associated technologies, and how these component architectures and technologies are applied in the context of systematic development, specifically the Rational Unified Process. The reader will learn a set of proven best practices, guidelines, and standards that apply to systems development. It will reflect the next version of RUP which is scheduled for release during in 2002. This version of RUP will be a considerable departure from the current version.
Peter Eeles is a co-author of Building Business Objects (Wiley, 1998). Currently working for Rational in the UK, he is a process consultant helping large organizations in the use of Rational technology and process. Kelli Houston is a Senior Architecture Consultant at Rational Software. Her responsibilities include providing training, consulting and mentoring to customers on architectural representation and process. Wojtek (Voytek) Kozaczynski is the director of Architectures and Application Frameworks at Rational Software. He works on tools and processes for development and application of reusable software assets.

Special Offers and Product Promotions

  • Join Amazon Student in Canada

Product Details

Product Description

From the Inside Flap

About This Book

This book is about developing Java 2 Platform, Enterprise Edition (J2EE) applications with the Rational Unified Process (RUP) and the Unified Modeling Language (UML). There are a number of books describing the J2EE platform and its associated technologies. There are also books about software development processes and about RUP, in particular. However, we could not find a book that described and exemplified how to use a subset of RUP that contains only the most relevant parts of an otherwise large and comprehensive process, to build J2EE applications. The book bridges this gap between the RUP and J2EE technologies.

A world that combines J2EE, RUP and UML is complex. This world requires a good map if you are to successfully navigate your way through it. This book provides such a map both metaphorically and literally. It is metaphorical because the very objective of the book is to provide a description of a "safe path" through the J2EE application development activities. It is also literal because we define a "J2EE Developer Roadmap," which is a process map, to guide us. We describe the content of the book in more detail in Chapter 1, Introduction.

Who This Book Is For

While writing the book we kept three audiences in mind. The first audience is software architects, designers and developers familiar with the J2EE platform and its technologies, wanting to understand how to apply them in the context of a software development process. The second audience is development team members familiar with RUP, looking for help in applying the process to J2EE development. The third audience is software professionals who are neither familiar with J2EE nor with RUP, and are looking for an example of how to use RUP in the development of a J2EE application.

Conventions Used in This Book

The book is roughly divided into two parts. The first part, Chapters 2–5, summarizes the J2EE technologies, introduces RUP and the J2EE Developer Roadmap, and briefly describes our sample application. The rest of the book is what we refer to as the "process chapters" and contains a guided tour through a J2EE application development project.

We structured the process chapters to make them easy to read "at a glance," and to make it easy to refer to specific topics of interest. Each process chapter is organized primarily by activities. We provide diagrams that indicate the overall flow between the activities and the key artifacts that are consumed and produced by the activities. For each activity, we provide an overview table that summarizes the purpose of the activity, its input and output artifacts, and a summary of the steps performed within the activity. Following the table, we then describe the details of each of these steps, using the sample application.

In the process chapters, we use only one simple editing convention: we emphasize all references to process elements such as activities, steps, and artifacts.


From the Back Cover

Two of the most significant technological development trends of the past few years have been the Java 2 Platform, Enterprise Edition (J2EE), a platform specifically geared to the needs of enterprise systems, and the Rational Unified Process (RUP), a comprehensive development methodology.

Building J2EE™ Applications with the Rational Unified Process is the first book to bring these two key development concepts together. Featuring a non-trivial sample application, the book demonstrates a customized subset of RUP that is relevant and essential to J2EE development. The text guides readers through the entire development process, from initial requirements gathering through system implementation, illuminating real-world intricacies, complications, tradeoffs, and decision making.

The book presents a review of the latest releases of J2EE and RUP, emphasizing the rationale behind their content. A developer roadmap helps readers navigate the development process successfully, and detailed discussions of each aspect of the process reveal practical strategies and techniques.

Also provided is detailed coverage of the key aspects behind any successful software development effort:

  • Requirements, including use-case modeling and the gathering of architecturally significant requirements
  • Analysis, including the transformation of requirements into a first-cut design model and a user-experience model
  • Design, including the refinement of a design model, introducing interfaces, framework components, design classes, and use-case realizations
  • Implementation, including the creation of source code and executable code based on the design, and the production of J2EE modules necessary for deployment
  • Architectural concerns, including the production of a Software Architecture Document, Deployment Model, and Data Model
  • The use of patterns, in particular J2EE design patterns
  • The use of UML to model J2EE technologies such as Enterprise JavaBeans™

Written for anyone working in J2EE or using RUP, this book is an comprehensive guide that reveals how J2EE and the Rational Unified Process come together to produce a powerful, efficient, and effective approach to enterprise application development.

Forewords were prepared by John Crupi, Distinguished Engineer at Sun Microsystems (and coauthor of Core J2EE Patterns, Prentice Hall, 2001), and Philippe Kruchten, Director of RUP Development at Rational Software (and author of The Rational Unified Process, Addison-Wesley, 2000).


Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

Customer Reviews

3 star
2 star
1 star
4.6 out of 5 stars
4.6 out of 5 stars
Most helpful customer reviews
1 of 1 people found the following review helpful
By Charles Ashbacher TOP 1000 REVIEWER
The Rational Unified Process (RUP) is a language independent methodology that can be used to develop software. Constructed from a series of six best practice style guidelines, which are:
* Develop iteratively
* Manage requirements.
* Use component architectures.
* Model visually.
* Continuously verify quality.
* Manage change.
the RUP is a proven way to keep software projects on track. The Java 2 Platform, Enterprise Edition (J2EE) is the latest iteration of the Java language platform. Having only been introduced a few years ago, Java has undergone a phenomenal rate of adoption, which attests to the flexibility and power of the language. In this book, the two are combined, as the authors take you through a series of steps that show you how to construct the architecture of an online auction system using J2EE.
After finishing the book, I suddenly realized that I did not remember seeing any actual code. In fact there are a few lines, but only to demonstrate some of the J2EE component technologies, which is the topic of chapter 2. Code is not used in the chapters that describe the modeling of the project, which is a strong point in favor of the authors. Had they included code in this section, it would have just complicated the explanation without improving it.
Diagrams are heavily used throughout the book, which serves to clarify many of the critical points. However, the strongest area of the book is the use of Activity boxes, which are also used throughout the book. They are sections set aside having the form:
* Title. For example, Activity: Structure the use-case model.
* Overview. A brief explanation of the activity and how it is carried out.
* Input artifacts. What must be present when the activity starts.
* Resulting artifacts.
Read more ›
Was this review helpful to you?
Besides being well written, consise, and easy to understand I like this book because it fills a much needed gap. There are many books and websites that focus on implementing EJBs, Servlets, JSPs, and the like. The growing acceptance of RUP as a process framework is also reflected in a lot of books and magazine articles. And UML as the standard way to visualize software systems is commonly accepted.
But until now I haven't seen a book that combined the concepts of process, modeling, and platform architecture and described the implementation of a non-trivial application using industry best practices. "Building J2EE Applications with the Rational Unified Process" does this.
J2EE architects, developers and project managers will all get value out of this book because it sets the context for building enterprise class applications on the J2EE platform. Software development is still hard - we need to consider what we're building, how to capture and communicate that, how to structure it, and ultimately how to design and implement the system.
Combining discussions of the software lifecycle with J2EE implementation choices, the latest thoughts on design patterns, and building a J2EE system in a regular/repeatable way is not an easy task and I am happy to say that this book accomplishes the goal admirably.
Was this review helpful to you?
5.0 out of 5 stars For all J2EE Developers Sept. 29 2002
If you want one book that describes HOW to build J2EE applications successfully, then this is it. I've read a number of books that describe aspects of J2EE or UML and have always been left wanting. J2EE books describe technology, and UML books describe a standard notation for "drawing pictures". At last we now have a book (and an excellent book at that) that describes an actual PROCESS for building J2EE applications, and it doesn't disappoint.
After brief introductions to J2EE and the Rational Unified Process (RUP, which is pretty much a de-facto process standard for developing software) the reader is walked through the development of a fairly complex online auction application. I was pleased to see that the authors haven't taken the easy route of discussing a trivial application; the example used ensures that all of the "tricky" questions that would arise in a typical project are answered.
A chapter is dedicated to each of requirements, analysis, design and implementation. It was great to see the use of the Sun J2EE patterns throughout. I was also pleased to see some discussion of user-experience modeling, something that I've been struggling with in real life.
Even though there is a lot of information to absorb such as J2EE, RUP, UML and J2EE patterns, this isn't a lengthy book. At just over 250 pages I was amazed at how much useful information it contains in such a small amount of space. It's also interesting to see that this book has two forewords. The first is written by Philippe Kruchten, Director of RUP Development. The second is by John Crupi, one of the authors of Core J2EE Patterns. This tells me that the authors have done their homework, and it shows.
Was this review helpful to you?
5.0 out of 5 stars This is THE book for J2EE architects Sept. 29 2003
Get this right, this is NOT a 50-50 mix of J2EE development process and RUP, this is not for the ones doing BPR (Business Process Redesign) and book does not try to position itself as the ultimate book for RUP (I'm glad it doesn't).
This book let's you focus on only a small subset of RUP, a subset which is really relevant for developing the architecture of a J2EE application, it let's you use RUP as a tool (that's the whole point of RUP, it's a tool, not a goal in itself) to deliver your final deliverable, the software architecture document with other supporting documents.
If you are a J2EE Architect or a senior developer planning to make the move towards architect roles, this is the book for you, keep the 'J2EE Patterns' book (Deepak Alur, Dan Malks, John Crupi) by your side, and you're ready to go!
Was this review helpful to you?
Want to see more reviews on this item?

Look for similar items by category