- Taschenbuch: 572 Seiten
- Verlag: O'Reilly & Associates; Auflage: 1 (2. November 2001)
- Sprache: Englisch
- ISBN-10: 1565924525
- ISBN-13: 978-1565924529
- Größe und/oder Gewicht: 17,8 x 3 x 23,3 cm
- Durchschnittliche Kundenbewertung: 1 Kundenrezension
- Amazon Bestseller-Rang: Nr. 389.951 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
- Komplettes Inhaltsverzeichnis ansehen
Andere Verkäufer auf Amazon
+ EUR 3,00 Versandkosten
+ kostenlose Lieferung
Java RMI (JAVA SERIES) (Englisch) Taschenbuch – 2. November 2001
|Neu ab||Gebraucht ab|
Kunden, die diesen Artikel gekauft haben, kauften auch
Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.
Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.
Wenn Sie dieses Produkt verkaufen, möchten Sie über Seller Support Updates vorschlagen?
This text contains a wealth of experience in designing and implementing Java's Remote Method Invocation. Novice readers should be brought up to speed on why RMI is such a powerful yet easy to use tool for distributed programming, while experts can gain valuable experience for constructing their own enterprise and distributed systems. With this book, the reader can learn tips and tricks for making the RMI code excel. The book also provides strategies for working with serialization, threading, the RMI registry, sockets and socket factories, activation, dynamic class downloading, HTTP tunneling, distributed garbage collection, JNDI, and CORBA.
Über den Autor und weitere Mitwirkende
William Grosso is the former Chief Architect / Director of Quality Assurance and current Vice President of Technical Services for Hipbone Incorporated. He is the author of Java RMI (available from O'Reilly and Associates) and a co-author of Java Enterprise Best Practices (also available from O'Reilly and Associates). He is one of the founders of Seruku, is on the program committee of the International Semantic Web Conference, and frequently volunteers at SDForum (where he serves on the Board of Directors and helps to run the Emerging Technology SIG). A former mathematician, he got into programming because it seemed like easy money. He got into distributed computing because he noticed that client-server gurus got the big bucks. And then he started programming in Java because he figured that's where the REAL money was. Having learned the error of his ways, he decided to become management and write books instead. When not working, programming, or writing, he spends most of his time hiking and going to the theatre. You can find out more about him at wgrosso.com.
Derzeit tritt ein Problem beim Filtern der Rezensionen auf. Bitte versuchen Sie es später noch einmal.
Even the more sophisticated topics like the interaction with CORBA (RMI/IIOP), HTTP Tunneling, dynamic class load and so on is covered.
The code examples are easy to understand but you will need a certain amount of experience with the Java programming language.
It's a great book and it's great to read this book.
Die hilfreichsten Kundenrezensionen auf Amazon.com
overly perky hackers with limited communication skills; most appear to
have been hastily assembled over a few weekends from screen and code
dumps, with a smattering of text added to provide some semblance of
continuity. This book bucks that trend. Ostensibly it is a book about
RMI. However, it goes much further and provides an excellent
introduction to building distributed applications in Java using RMI as
its interface protocol. The books starts with basic distributed
programming using sockets, continues to develop its ideas using RMI, and
then progresses to more advanced topics, such as serialization,
scalability, multithreaded servers, and security policies. A lot of
nicely worked out examples are provided along the way. Highly
Quite a few interesting concepts are discussed but lack detail. Just when it starts to get interesting the discussion ends. Issues like client-side caching, security, object vs native data type passing etc. could have filled up the 100 or so pages (2 chapters) that were used on threads.
For a basic but excellent intro to RMI (and other distributed concepts) see "Network Programming" by Elliotte Rusty Harold. For an excellent (and very advanced) book on RMI you cannot beat "java.rmi" by Pitt and McNiff. A detailed (probably somewhat specific) example of a distributed 3-tier database application is in "Database Programming with JDBC and Java" by George Reese (but some issues are dealt with simplistically in Reese's book).
In short, Java RMI is unfortunately lacking the usual O'Reilly quality. It discusses a number of issues regarding distributed applications and covers some interesting ideas, but lacks the required detail.
and presentation of this book. The author gives enough substance
to all RMI components as well as enough how-to information for
a typical TMI deployment. What I apperciated most however is
that it's replete with small pieces of wisdom on distributed
systems design (e.g., scalability) that were eye-opening. It
also illustrates the distributed way of thinking through teaching to ask the right question at design phase.
It's true that it talks about more than strict RMI but that's hardly a shortcoming.
The reader wanting to see onl RMI stuff will find his way by picking the right chapters (you can't miss them).
Overall, excellent technical depth, good job.
But I'll only comment on the serialization chapter (10).
It gives some bad advice for doing serialization (read Effective Java for that), and even has this passage, commenting on the internals of java.util.ArrayList, which is serializable, and has an internal Object field marked as "transient".
"But hidden in here is a huge problem: ArrayList is a generic container class whose state is stored as an array of objects. While arrays are first-class objects in Java, they aren't serializable objects."
That's the reason he thinks it is marked as transient. Well, serializing arrays worked from day 1 (depending on the element references being serializable themselves of course), and this just reveals a big misunderstandment on the author's part about the code he read. (Surely enough, an ArrayList's internal array can be far bigger than its actual contents, so it would be a bad idea to depend on default serialization for this field).
This sort of stuff just doesn't boost my trust.