EUR 34,34
  • Statt: EUR 36,97
  • Sie sparen: EUR 2,63 (7%)
  • Alle Preisangaben inkl. MwSt.
Nur noch 2 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Dieses Bild anzeigen

Building J2ee Applications with the Rational Unified Process (Addison-Wesley Object Technology) (Englisch) Taschenbuch – 20. August 2002


Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Taschenbuch
"Bitte wiederholen"
EUR 34,34
EUR 32,34 EUR 0,93
9 neu ab EUR 32,34 15 gebraucht ab EUR 0,93
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Produktinformation


Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Synopsis

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.

Buchrückseite

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).



0201791668B07242002

Kundenrezensionen

Es gibt noch keine Kundenrezensionen auf Amazon.de
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Sterne

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 7 Rezensionen
10 von 12 Kunden fanden die folgende Rezension hilfreich
For all J2EE Developers 29. September 2002
Von "barney007" - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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.
4 von 4 Kunden fanden die folgende Rezension hilfreich
This is THE book for J2EE architects 30. September 2003
Von Sudipto K. Haldar - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
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!
4 von 5 Kunden fanden die folgende Rezension hilfreich
Excellent display of how to merge two valuable tools 24. Juli 2003
Von Charles Ashbacher - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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. What should be present when the activity is over.
* Steps. The operations to be performed in the activity.
I found these activity boxes of enormous help, and in most cases relied on them for the bulk of the information that I was looking for. Additional explanation appears in the text, but in many cases, I found it unnecessary.
The selection of the online auction project was a good one. It is complicated enough to provide an effective demonstration, yet simple enough to be understandable. The principles of an auction are easy to understand, so the only explanations needed are the additional rules needed to conduct one online.
This book is an effective demonstration of how to use RUP to build software. Since there is very little code, the structures are based on the organizational characteristics of J2EE rather than specific commands in the language. Therefore, it really is not necessary to understand Java to benefit from the book, and there certainly is a great deal of benefit to be gleaned from it.
Probably the best book on the subject 8. September 2005
Von GA - Veröffentlicht auf Amazon.com
Format: Taschenbuch
There are very few books describing how to practically use RUP with enterprise-scale development. From experience, I found that RUP is a vast -- and overwhelming -- process, and it is necessary for architects and developers to customize their own RUP-based simplified process, or else a software project won't get anywhere using the full RUP approach.

The book is well written. My only complaint is that it errs, occasionally, on the side of academics and betrays its vocation of being a practical engineering guide.
Best book for learning to use RUP with J2EE development 20. Februar 2004
Von Sam Courtney - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Well worth the money. It does a great job in simply describing how to follow RUP for J2EE dev. Does not go into depth, you will need more guidance, I use the RUP Plugin that is available for use with RUP that was created from the content in this book. It has been refined and much detailed has been added for real app dev use.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.