ARRAY(0xa3595960)
 
Profil für Sunrise > Rezensionen

Persönliches Profil

Beiträge von Sunrise
Top-Rezensenten Rang: 65.659
Hilfreiche Bewertungen: 263

Richtlinien: Erfahren Sie mehr über die Regeln für "Meine Seite@Amazon.de".

Rezensionen verfasst von
Sunrise (München)

Anzeigen:  
Seite: 1 | 2 | 3 | 4
pixel
JBoss AS 7 Configuration, Deployment and Administration
JBoss AS 7 Configuration, Deployment and Administration
von Francesco Marchioni
  Taschenbuch
Preis: EUR 37,20

5 von 5 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Fundierte Einführung in JBoss AS 7, 12. April 2012
Relativ schnell nach den ersten Releases der neuen JBoss-Version ist vorliegendes Buch erschienen. Ein Glück für alle Java-Entwickler, die möglichst zügig auf die neue Version umsteigen wollen. Kapitel 1 erklärt, wie man JBoss AS 7 installiert & startet und welche Bedeutung die Verzeichnisse im neuen Dateisystem haben. Gegenüber den JBoss-Vorgängern hat sich hier einiges geändert. Im zweiten Kapitel werden relativ kurz einige XML-Konfigurationen erklärt, was eher zum Nachschlagen geeignet ist und beim kompletten Durchlesen etwas langweilig wirkt.
Kapitel 3 ist wieder wesentlich interessanter, denn es geht um das Einrichten von Datenbank-Verbindungen und das Konfigurieren von EJBs und JMS-Destinations. Das vierte Kapitel dreht sich vollständig um die Konfiguration des Web-Servers. Interessant dabei ist, daß ein kleines, aber nahezu vollständiges JEE-Projekt mit JSF, einem Singleton-Session-Bean und JPA-Entities aufgesetzt wird. Für einen ersten Überblick hervorragend geeignet.
Danach geht es im fünften Kapitel um das Einrichten von Domänen, einem völlig neuen Konzept in der JBoss-Welt, wohingegen sich das sechste Kapitel vollständig um das Thema Deployen dreht. Vor allem der Abschnitt über das Class-Loading ist sehr informativ geworden. Leider erst in Kapitel 7 wird das neue Kommando-Zeilen-Tool CLI erklärt. "Leider" deswegen, weil der Autor in den ersten sechs Kapiteln mehrfach Bezug auf CLI nimmt, und als JBoss AS 7-Neuling kann es dabei durchaus zu Verständnisproblemen kommen. Es wäre wesentlich sinnvoller gewesen, CLI gleich zu Beginn des Buches zu behandeln, anstatt erst in der Mitte. Daher kann ich jedem Leser nur raten, das siebte Kapitel vorzuziehen, am besten gleich nach dem ersten Kapitel. Neben CLI wird im siebten Kapitel auch die neue Web Admin-Konsole vorgestellt. Sieht auf den ersten Blick richtig gut aus.
Kapitel 8 beschäftigt sich mit Clustering, und Kapitel 9 baut darauf auf und behandelt das Load-Balancing von Web-Applikationen. Wer große, skalierbare Web-Apps bauen will, für den sind diese Kapitel Pflichtlektüre. Das neunte Kapitel stellt dabei verschiedene Möglichkeiten vor, um den Apache Web-Server mit JBoss 7 zu verbinden: mod_jk, mod_proxy und mod_cluster. Kapitel 10 ist ebenfalls essentiell, denn es geht um JEE-Security, einem ziemlich leidigen Thema im Enterprise-Umfeld. Dabei wird erklärt, wie man Security generell in JBoss AS 7 einrichtet, und wie man Web-Applikationen, EJBs und Web-Services absichert. Des weiteren wird gezeigt, wie man mit Keys und Zertifikaten umgeht. Äußerst lesenswert!
Im abschließenden Kapitel geht es um die Cloud, und auch wenn man nicht vor hat, JBoss entweder über OpenShift Express oder OpenShift Flex in der Cloud zu betreiben, sollte man das Kapitel 11 zumindestens anlesen, denn es gibt sehr aufschlußreiches Hintergrundwissen über die Cloud im Allgemeinen. Fand ich gut.
Zum Abschluß bleibt zu sagen, daß das Buch für alle Entwickler, die mit JBoss AS 7 arbeiten wollen, ein absolutes Muß darstellt, an dem kein Weg vorbei führt, denn ohne dieses Fachbuch ist man in der neuen JBoss-Welt ziemlich aufgeschmissen. Einen Wermutstropfen gibt es dennoch: Die Kapitel erwecken den Eindruck, ziemlich hastig und unter Zeitdruck zusammengestellt worden zu sein. Der Schreibstil ist teilweise furchtbar schlecht. Einige englische Sätze können definitiv nicht korrekt sein. Das ist zwar nicht sooo schlimm, denn man versteht den Inhalt trotzdem, aber das Lesen hat wirklich keinen Spaß gemacht. Daß es besser geht, sieht man am Vorgängerwerk "JBoss AS 5 Performance Tuning", das vom gleichen Autor stammt, und das einen wesentlich besseren und vor allem lesenswerteren Schreibstil aufweist. Anscheinend hat man "JBoss AS 7 Administration" entweder unter Zeitdruck so schlampig geschrieben (was wahrscheinlich ist) oder so gut wie gar nicht lektoriert. Francesco Marchionis Lieblingsphrase "as a matter of fact" (mit der er permanent um sich wirft) geht einem jedenfalls ziemlich schnell auf die Nerven. Aber inhaltlich gesehen ist das Buch erstklassig und sein Geld wert. Einen Punkt ziehe ich dennoch für den einschläfernden und holprigen Schreibstil ab.


Practical RichFaces (Expert's Voice in Java Technology)
Practical RichFaces (Expert's Voice in Java Technology)
von Max Katz
  Taschenbuch
Preis: EUR 40,90

3 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Ausgezeichnetes Buch für den Praxis-Alltag, 20. März 2012
Wer sich schon immer mal in eine Komponenten-Bibliothek für JSF einarbeiten wollte, ist mit diesem Buch gut beraten. Als Voraussetzung benötigt werden lediglich grundlegende Kenntnisse in JSF 2.0 und HTML. Aber auch wer den Umstieg von RichFaces 3.x auf RichFaces 4 plant, kann sich das Buch bedenkenlos kaufen.
Die ersten vier Kapitel sollte man auf jeden Fall am Stück lesen. Im ersten Kapitel werden allgemeingültige Dinge über JSF, Ajax und RichFaces erklärt. Für den langjährigen JSF-Entwickler ist das zwar eher irrelevant, dennoch ist der Einstieg angenehm zu lesen und mehr zum Aufwärmen geeignet als zur Wissensvermittlung. In Kapitel 2 wird beschrieben, wie man RichFaces installiert, und es gibt einen detaillierten Vergleich zwischen JSF Ajax und RichFaces Ajax. Fand ich äußerst aufschlußreich. Das dritte Kapitel ist schon etwas länger und behandelt RichFaces Ajax im Detail. Absolut essentiell. Kapitel 4 dagegen ist sehr kurz und beschreibt grundlegende Kenntnisse über Rich-Komponenten. Sollte man auf jeden Fall gelesen haben.
Ab jetzt muß man die Kapitel nicht mehr in der Reihenfolge lesen, sondern man sucht sich das Kapitel heraus, das man gerade für seine Arbeit benötigt. Ich habe die Kapitel trotzdem der Reihe nach durchgearbeitet. Das fünfte Kapitel behandelt auf ausführliche Weise Rich-Komponenten für die Daten-Eingabe und die Selektion, während sich das sechste Kapitel mit Panels und Ausgabe-Komponenten beschäftigt. Das siebte Kapitel geht sehr in die Tiefe und behandelt Tabellen und die Iteration über Collections. Dies ist das bislang komplexeste Kapitel im Buch.
Danach geht es wieder mit einfachen Komponenten weiter. Kapitel 8 dreht sich um Menü-Elemente wie Toolbars und Drop-Down-Menüs, während sich das neunte Kapitel ausschließlich um Trees kümmert. Fast schon genial fand ich Kapitel 10, welches auf sehr einfache Art und Weise Drag & Drop im Browser behandelt. Im elften Kapitel, das man als JSF-Entwickler unbedingt gelesen haben sollte, dreht sich alles um die Validierung von Eingabedaten. Hervorragend! Kapitel 12 behandelt sowohl den Aufruf der JavaScript API für Rich-Komponenten als auch den Aufruf von jQuery-Scripts auf RichFaces-Seiten, während Kapitel 13 das Verwenden, Ändern und Erstellen von Skins (Themes) erklärt. Im abschließenden Kapitel geht es um das Erstellen eigener Rich-Komponenten mit dem RichFaces CDK, was lediglich für den sehr fortgeschrittenen JSF-Entwickler von Interesse sein dürfte.
"Practical RichFaces" ist eines der wenigen Fachbücher, die ich uneingeschränkt empfehlen kann. Der Schreibstil ist einfach zu lesen und gut zu verstehen, was vor allem Einsteigern sehr zugute kommen dürfte. Alle Kapitel enthalten hervorragende Code-Beispiele, die ebenfalls leicht verständlich sind. Das Buch ist durch die Bank absolut interessant zu lesen, und man kann fast alle Kapitel für seine tägliche Arbeit nutzen (was leider nicht unbedingt auf jedes Fachbuch zutreffend ist). So macht Lesen & Lernen endlich wieder richtig Freude. Schade, daß nicht alle Programmierbücher so praxistauglich und leicht verständlich aufgebaut sind. Die Autoren haben echtes Talent im Schreiben und im Erklären von Sachverhalten. Diese Art von Büchern bekommt man viel zu selten zu lesen.


JavaServer Faces 2.0. The Complete Reference
JavaServer Faces 2.0. The Complete Reference
von Ed Burns
  Taschenbuch
Preis: EUR 34,95

2 von 2 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Ein Buch für erfahrene JSF-Entwickler, 31. August 2011
Das Buch von Ed Burns und Chris Schalk dürfte mit über 700 eng bedruckten Seiten das umfangreichste Werk über JSF 2.0 sein, was aber nicht automatisch bedeuten muß, daß es auch das beste Buch über JSF 2.0 darstellt. Das Buch ist in drei Teile aufgeteilt. Der erste Teil beschäftigt sich mit den Grundlagen:
Kapitel 1 ist eine Selbstbeweihräucherung über JSF und eher uninteressant. In Kapitel 2 wird eine kleine Beispiel-Anwendung vorgestellt, die einen ersten Eindruck über die Funktionalität von JSF vermittelt. Danach wird in Kapitel 3 der JSF-Lifecycle anschaulich erklärt, was jedoch streckenweise etwas trocken geraten ist. Im vierten Kapitel wird auf 12 Seiten das Konzept der Facelets vorgestellt. Das ist meines Erachtens nach zu wenig. Allerdings gibt es auf den Seiten 631 bis 642 eine gute Wiederholung und ein kleines, aber leichtverständliches "Faclet Example Website Project". Facelets sind in dem Buch zwar definitiv zu kurz gekommen, aber das, was über Facelets geschrieben wurde, liest sich wirklich gut.
In den Kapiteln 5 und 6 werden auf hervorragende Art und Weise "Managed Beans" und das "Navigation Model" erklärt. Bei Letzterem hätte ich mir mehr Hintergrundwissen zum Flash-Scope gewünscht. Wer zum ersten Mal damit konfrontiert wird, wird sich etwas schwer tun. Auch das "User Interface Component Model" in Kapitel 7 ist hochinteressant beschrieben worden.
Mit dem achten Kapitel über "Converting and Validating Data" flacht der erste Teil etwas ab. Das Kapitel ist zu Theorie-lastig und etwas ermüdend. Der Abschnitt "The Faces Converter System" ist zum Einschlafen langweilig und enthält kaum Beispiele, was das Verständnis enorm erschwert. Der Custom-Converter-Code auf Seite 171 wird so gut wie nicht erklärt. "The Faces Validation System" ist etwas besser, aber der Custom-Validator auf Seite 184 macht in meinen Augen wenig Sinn. Die Bean-Validation dagegen wurde gut erklärt, trotzdem ist das Kapitel insgesamt gesehen zäh geschrieben und ein ziemliches Durcheinander.
Das für den ersten Teil letzte Kapitel über das JSF Event-Model wirkt wieder wesentlich besser und wurde auch mit guten Code-Snippets versehen. Die System-Events werden allerdings etwas lieblos erklärt. Da ist den Autoren anscheinend die Lust vergangen, sich ein reales Beispiel auszudenken.
Der zweite Teil beschäftigt sich mit fortgeschrittenen Themen über JSF und startet mit einer etwas umfangreicheren Beispiel-Applikation. Anfangs noch sehr bemüht, verliert sich das zehnte Kapitel in zuvielen XHTML- und Java-Code-Listings, was ein JSF-Novize bald nicht mehr vollständig überschauen kann. Ich bin nach der Hälfte leider ausgestiegen. Man braucht sehr viel Zeit, um die Code-Beispiele Zeile für Zeile zu untersuchen und zu studieren, um zu verstehen, wie alle Code-Snippets zusammenarbeiten. Das wird im zunehmenden Verlauf des Kapitels immer schwieriger, und man muß schon JSF-Praxiserfahrung besitzen, wenn man das alles noch nachvollziehen möchte. Erschwerend kommt hinzu, daß manche Methoden nicht abgedruckt sind, jedenfalls nicht im Zusammenhang mit dem erklärenden Text. Spätestens hier steigt man als Anfänger definitiv aus. Man müßte sich die Beispiel-Applikation downloaden, die Listings komplett ausdrucken, nebeneinander legen und dann nochmal lesen, sonst wird man die Beispiel-Web-App nicht verstehen. Letztendlich habe ich das dann auch gemacht. Der Ausdruck der Listings ergab bei mir fast 70 Seiten. Am einfachsten empfand ich noch die Entities mitsamt der generischen JPA-Lösung, und ich habe mir schon überlegt, diese evtl. in eigene Projekte zu übernehmen. Die vielen Backing-Beans und XHTML-Seiten auseinanderzudröseln gleicht dagegen einer Sisyphos-Arbeit. Nichtsdestotrotz ist die Beispiel-Applikation eine interessante Vorlage, um das Zusammenspiel der JSF-Komponenten in einem Real-Life-Programm zu studieren.
Das gerade mal 19 Seiten lange Kapitel über Ajax enthält zuviel Theorie, die durch zu wenig Praxis-Beispiele untermauert worden ist. Davon hätte ich mir mehr erhofft. Leider sehr unbefriedigend! Die beiden Kapitel "Building Custom UI Componentes" und "Building Non-UI Custom Components" sind für den Einsteiger erst mal nicht so sehr von Bedeutung, darum habe ich sie nur überflogen. Ob mir diese Kapitel jedoch wirklich weiterhelfen würden, wenn ich irgendwann mal eine Custom-Component erstellen möchte, wage ich ein wenig zu bezweifeln, da mir die Erklärungen allesamt ziemlich kurz erscheinen. Auf den Seiten 643 bis 658 gibt es jedoch eine gute Wiederholung über Composite-Components und auch ein etwas ausführlicheres Beispiel-Projekt. Abgeschlossen wird der zweite Teil mit einem Kapitel über Security, das kurz & bündig geraten ist und ruhig ein wenig länger hätte ausfallen dürfen, alles in allem aber gar nicht mal so schlecht war.
Der dritte Teil bietet eine Übersicht sowohl über alle XML-Elemente für die faces-config.xml als auch für alle JSF-spezifischen XHTML-Tags. Gerade die Letzteren empfand ich als sehr interessant, weil man dadurch einen hervorragenden Überblick bekommt, welche Standard-Komponenten von JSF zur Verfügung gestellt werden. Besonders viele sind es ja nicht, und besonders weit kommt man damit in der Praxis wohl auch nicht, aber das ist nicht die Schuld der Autoren, wenn die JSF-Standard-Tags so spärlich ausgefallen sind. Die Übersicht ist jedenfalls hervorragend und hat mir sehr weitergeholfen.
Insgesamt betrachtet besteht das Buch aus starken und schwachen Abschnitten. Der erste Teil enthält ausgezeichnete Kapitel, während die Qualität im zweiten Teil ziemlich eingebrochen ist. Der dritte Teil dagegen erweist sich als informative Übersicht zum Nachschlagen. Ein paar Fehler sind natürlich ebenfalls enthalten, was bei einem Fachbuch von diesem Umfang an der Tagesordnung zu liegen scheint. Auch wenn einige Texte wirklich hervorragend geraten sind, ist das Buch für Einsteiger nur bedingt zu empfehlen, denn es gibt zwischendurch immer wieder mal grobe Aussetzer, die dem Leser das Verständnis erschweren. Als Nachschlagewerk für die tägliche Arbeit ist es jedoch relativ gut brauchbar.


JavaServer Faces 2.0: Grundlagen und erweiterte Konzepte
JavaServer Faces 2.0: Grundlagen und erweiterte Konzepte
von Martin Marinschek
  Broschiert
Preis: EUR 38,00

1 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Gelungenes Einsteigerbuch für JSF 2.0, 31. August 2011
Den Auftakt macht eine etwas oberflächliche Einführung in JSF und ein erstes Beispiel, das sehr leicht zu verstehen ist. Das zweite Kapitel dagegen bildet die eigentliche Einführung in JSF und stellt auf rund 80 Seiten verschiedene Grundlagen und Konzepte vor. Kapitel 2 besteht dabei aus Höhen und Tiefen, denn es gibt gute und weniger gute Abschnitte, so wie das eben bei den allermeisten Fachbüchern der Fall ist. Bemerkenswert finde ich jedoch folgendes: Es gibt eine sehr gute Beschreibung von Events mit Hardcopies und Code-Snippets genau an der richtigen Stelle. Auch der JSF-Lifecycle wird im Zusammenhang mit Phase-Listenern super erklärt. Nahezu perfekt und absolut lesenswert für Einsteiger. Hier gibt es wirklich einen Aha-Effekt nach dem anderen, anstatt Kopfkratzen und Rätselraten, was der Autor wohl mit seinem Text gemeint haben könnte. Der Autor, der dieses Event-Kapitel geschrieben hat, sollte ein ganzes Programmierbuch im gleichen Stil verfassen!
Kapitel 3 stellt die JSF-Standard-Komponenten vor. Auf Seite 110 werden Facets ohne Beispiel erklärt, was sich dem Leser jedoch nicht so ganz erschließt. Die Zusammenfassung der Core-Tag-Library auf den Seiten 111-113 ist sehr kurz geraten, dies wird im englischsprachigen Buch "The Complete Reference" wesentlich ausführlicher erklärt. Ab Seite 114 wird es jedoch wieder besser, denn es werden die Tags der HTML-Custom-Tag-Library jeweils anhand eines kleinen Beispiels vorgestellt. Lesenswert!
Kapitel 4 widmet sich den fortgeschrittenen JSF-Themen, und vor allem die Abschnitte über Facelets und Templating fand ich erstklassig und sehr informativ.
Das fünfte Kapitel über das Erstellen eigener Composite-Components ist für mich zunächst eher weniger von Bedeutung, darum habe ich das Kapitel nur überflogen, aber er es macht einen brauchbaren Eindruck. Im sechsten Kapitel wird es mit Ajax sehr interessant. Die Texte sind angenehm zu lesen, und auch die Beispiele fand ich klasse.
Anschließend folgen nur noch Themen, die mich wenig bis gar nicht interessiert haben. Es werden Teile aus dem Öko-System von JSF vorgestellt, aber leider nicht die Frameworks, die mich am meisten interessiert hätten. Ich favorisiere Seam und RichFaces, während die Autoren eingefleischte Apache-Fans sind. Wer sich jedoch für Spring, Orchestra oder Tobago entschieden hat, bekommt einige lesenswerte Grundlagen vermittelt.
Obwohl ich immer sehr skeptisch bin, was deutschsprachige Programmierbücher angeht, so war ich von diesem Werk positiv überrascht, auch wenn es einige Formulierungen gibt, mit denen ich zunächst so meine Schwierigkeiten hatte: Einen Button als Schaltfläche zu bezeichnen ist gewöhnungsbedürftig. Anfangs mußte ich jedesmal überlegen, um zu verstehen, was die Autoren mit dem Begriff Schaltfläche meinen. Das Wort Button hätte man nicht einzudeutschen brauchen. Noch zwei Wermutstropfen: Die View-Parameter werden leider nicht besonders gut beschrieben, und beim Erklären des Faces-Contexts kommen die Code-Beispiele zu kurz.
Ein erfahrener JSF-Entwickler wird von diesem Buch zwar nicht mehr allzu sehr profitieren, aber für einen Novizen ist es der perfekte Einstieg in die Welt von JSF. Allerdings kann man sich nach der Lektüre keinesfalls ausruhen. Ich empfehle auf jeden Fall, direkt anschließend ein englischsprachiges Werk zu lesen, sei es nun "The Complete Reference - Second Edition" von Ed Burns & Chris Schalk, oder aber "Core JSF - Third Edition" von David Geary & Cay Horstmann. Ich bevorzuge dabei ganz klar Core JSF.


Eclipse IDE - kurz & gut
Eclipse IDE - kurz & gut
von Ed Burnette
  Broschiert

3 von 3 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Ein angenehm zu lesendes Einsteigerbuch, 24. Mai 2011
Rezension bezieht sich auf: Eclipse IDE - kurz & gut (Broschiert)
Da ich schon seit einigen Jahren mit Eclipse arbeite, hätte ich das Buch eigentlich nicht benötigt. Rein interessehalber habe ich es mir trotzdem gekauft und "just for fun" gelesen.
Vieles habe ich schon gewußt, einige Dinge, die in Vergessenheit geraten waren, konnte ich wieder auffrischen, und ein paar Informationen waren selbst für mich noch neu. Alles in allem konnte ich hervorragend von dem Buch profitieren, und Eclipse-Einsteiger profitieren erst recht davon, denn es ist locker geschrieben, leicht zu lesen und höchst informativ, auch wenn es nur an der Oberfläche kratzt, aber mehr darf man von einem Buch aus der "kurz & gut"-Reihe auch nicht erwarten.
Am hilfreichsten empfand ich die Kapitel über die Tipps und Tricks sowie die Erklärungen über die wichtigsten Views. Langjährige Profis brauchen das Buch nicht unbedingt, aber Neueinsteiger können bedenkenlos zugreifen.


Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers)
Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers)
von Venkat Subramaniam
  Taschenbuch

5 von 5 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Kurzweilige Einführung in Groovy, mehr aber auch nicht!, 15. März 2011
Um sich einen Überblick über Groovy zu verschaffen ist dieses Buch perfekt, denn es vermittelt die allermeisten Grundlagen, um sofort mit der Script-Sprache starten zu können - aber auch nicht mehr! Dieses Buch geht nicht in die Tiefe, sondern in die Breite, d.h. es werden viele Themen angerissen, damit man einen schnellen Überblick erhält, was mit Groovy alles machbar ist.
Einen wirklich sehr unterhaltsamen Einblick erhält man in Kapitel 3 - "Groovy for the Java Eyes". Einige Konzepte finde ich äußerst interessant, mit anderen dagegen bin ich weniger einverstanden, z.B. halte ich es nicht für sinnvoll, auf das Keyword return zu verzichten, da dies im Code für mehr Klarheit sorgt. Auch der Einsatz von def ist mitsamt der ganzen dynamischen Typisierung für Java-Entwickler zunächst etwas ungewohnt, entfaltet mit der Zeit aber durchaus seine Vorteile.
Danach folgen Closures, die ein faszinierendes Konzept darstellen, welches manchmal auch mit Vorsicht zu genießen ist. Speziell in diesem Kapitel habe ich ein Closures-Beispiel mit ein wenig Skepsis betrachtet. Dieses erinnerte mich nämlich an die vielen konstruierten Lehrbuchbeispiele aus den Design-Patterns-Büchern, die in der Theorie oftmals sehr beeindruckend aussehen, in die Praxis dann aber nicht ganz so einfach umsetzbar sind.
In diesen Beispielen (sowohl in den Design-Patterns-Büchern als auch bei den Closures) wird eine generische Klasse zur Laufzeit mit dynamischem Code versehen, wodurch die generische Klasse den Anschein erweckt, als hätte sie ihren Typ geändert. In den Lehrbuchbeispielen sieht das immer total cool aus, und als Entwickler denkt man sich: Das verwende ich in meinem nächsten Programm ebenfalls! Aber in der Praxis habe ich dann meistens das Problem, daß es bei mehreren Anwendungsfällen einfach nicht mehr ausreicht, der generischen Klasse an nur einer Stelle dynamischen Code zu "injizieren". Beim ersten Anwendungsfall klappt das noch super, beim zweiten Use-Case würde man schon an zwei Stellen was ändern, und beim dritten Fall müßte man dann schließlich noch neue Instanzvariablen benötigen und die eine oder andere Hilfsmethode einfügen, und schon sitzt man mittendrin im Schlamassel, denn ab jetzt wird es immer schwieriger, die Generizität der Klasse aufrechtzuerhalten, und man fängt an, die Klassenstruktur hoffnungslos zu verbiegen, bis man irgendwann selber nicht mehr durchblickt. Wartbar ist das Ganze dann kaum noch.
Darum gehe ich lieber dazu über, die generische Methode nicht generisch zu machen, sondern einfach so oft zu implementieren, wie ich Anwendungsfälle habe. Das ist zwar kein schönes Design, ich habe Code-Redundanzen und verstoße auch noch gegen das DRY-Prinzip (wenn das nur mal nicht mein Chef spitz kriegt), aber ich habe zumindestens einen wartbaren und leicht änderbaren Code, dessen Methoden sich definitiv nicht in die Quere kommen. Ändere ich einen der Anwendungsfälle ab, dann muß ich mir kein Kopfzerbrechen darüber machen, daß ich die anderen Anwendungsfälle dadurch in den Wind schieße. Das ist wirklich kein schönes Design, aber es läuft stabil und robust im Praxiseinsatz (sogar, wenn ich im Urlaub bin). Nichtsdestotrotz finde ich Closures genial, aber man muß sie mit Bedacht einsetzen. In dem Buch findet man noch den Ratschlag, Closures nicht länger als ein paar Zeilen zu machen. Das klingt sinnvoll. Daß Closures ziemlich am Anfang behandelt werden ist beabsichtigt, denn im weiteren Verlauf des Buches wird fast in jedem Kapitel mit Closures gearbeitet.
Es folgen angenehm zu lesende und leicht verständliche Abschnitte zur String-Verarbeitung unter Groovy, dem richtigen Umgang mit Collections, den Groovy-spezifischen Erweiterungen zu java.lang.Object, wie man XML-Dateien erzeugt bzw. parsed sowie der Arbeit mit Datenbanken. All dies ist absolut essentielles und unverzichtbares Wissen für jeden Groovy-Novizen.
Im dritten Teil des Buches geht es dagegen um ein sehr fortgeschrittenes Thema, denn es wird gezeigt, wie man zur Laufzeit den Quellcode seines Groovy-Scriptes ändern kann. Java-Reflection kann dagegen einpacken! Groovys Meta-Object Protokoll ist ziemlich mächtig, aber für Anfänger zunächst mal eher weniger geeignet. Der Schluß des Buches verliert sich leider in einer äußerst oberflächlichen Betrachtung von Groovy-Buildern und Domain-Specific Languages (DSLs). Das hat mir nicht mehr viel gebracht.
Wie schon am Beginn meiner Rezension erwähnt, ist dies eine Einführung in Groovy, mehr aber auch nicht. Für den Einsteiger ist das Buch erste Sahne, aber wer tiefer einsteigen will, muß entweder die offizielle Groovy-Doku downloaden oder das Buch von Dierk König kaufen. Ich für meinen Teil entscheide mich für das König-Buch und warte nur noch auf die Second Edition. Alles in allem ist "Programming Groovy" eine leichte Lektüre, die viel Spaß beim Lesen macht und die Lust am Programmieren weckt.


Java Puzzlers: Traps, Pitfalls, and Corner Cases
Java Puzzlers: Traps, Pitfalls, and Corner Cases
von Joshua Bloch
  Taschenbuch
Preis: EUR 27,95

8 von 9 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Tiefe Auslotung von Javas Randbereichen, 7. Januar 2011
Auf dem Cover steht "Traps, pitfalls and corner cases", wobei der Schwerpunkt ganz klar auf den Corner-Cases liegt. Eigentlich müßte das Buch "Java Corner Cases" heißen, denn fast alle Puzzles konzentrieren sich auf die Grenzfälle von Java, die meistens nur dann zum Tragen kommen, wenn man sich in seinem Programm dermaßen verkünstelt hat, so daß eine Konstellation eintritt, für die eine von Javas Ausnahmeregeln aus den tiefsten Tiefen der Java-Spezifikation gilt, mit der man im Normalfall eher selten in Berührung kommt. Diese Eckbereiche auszuloten und als Code-Snippets darzustellen ist aus Autorensicht eine beachtliche Leistung, denn dazu muß man schon ein absoluter Experte sein, was bei den beiden Autoren auch definitiv der Fall ist.
Einige dieser Grenzfälle kannte ich bereits aus der Zeit, als ich mich auf den SCJP 1.4 vorbereitet hatte. Damals habe ich mich tagelang damit herumgeschlagen, um die Regeln zu lernen, welche auf die primitiven Datentypen byte, short, float und char sowie auf Bit-Operatoren zutreffen. Spaß hat das überhaupt keinen gemacht, und ich bin dabei mehr als einmal ins Schleudern gekommen, weshalb ich mich nach Abschluß des SCJP 1.4 dafür entschieden habe, diese Artefakte nicht in meinen Programmen zu benützen. Stattdessen verwende ich ausschließlich int, double, String und manchmal auch long, und bin damit auch all die Jahre gut gefahren. Warum soll ich mich mit den Elementen einer Programmiersprache herumärgern, die ein Minenfeld darstellen, und die ich im Grunde genommen gar nicht brauche? Sun hatte damals selbst ein Einsehen und hat deshalb die Objectives für den SCJP 5 + 6 angepaßt, indem die Bit-Operatoren und diverse, ausgefallene Sonderregeln, die fürs Casting von byte, short und float notwendig waren, rausgefallen sind (zumindestens kann ich mich nicht daran erinnern, damit konfrontiert worden zu sein).
Wie dem auch sei, mit den Java-Puzzlers hatte ich ein freudiges Wiedersehen mit diesen alten Bekannten, die mir damals schon schlaflose Nächte vor der Prüfung bereitet hatten. Natürlich sind das nicht die einzigen Schweinereien, die Joshua Bloch und Neil Gafter aus dem Hut zaubern, denn mit Java kann man noch viel mehr schräge Sachen programmieren, die man manchmal lieber nicht alle erfahren hätte. Liest man dieses Buch, entsteht leicht der Eindruck, als ob es ein unglaublich schwieriges Unterfangen sei, mit Java überhaupt irgendwas ans Laufen zu kriegen. Dem ist aber keineswegs so, denn wenn man seine Programme möglichst einfach aufbaut, wird man mit den meisten der Java-Puzzlers nicht konfrontiert werden. Trotzdem ist es für einen langjährigen Java-Entwickler höchst interessant, in die Corner-Cases seiner Lieblingssprache einzutauchen. Einfach ist das aber nicht, denn die Code-Beispiele sind mitunter schwer zu verstehen, und schnell mal in einem Rutsch durchlesen geht hier auf keinen Fall.
Einige der Puzzles empfand ich als lehrreich, manch andere wiederum als eher nutzlos und überkonstruiert. Am meisten lernt man aus den Resümees, die die Autoren aus jedem Puzzle ziehen, und dabei wird immer wieder betont, daß man auf diese Art und Weise AUF GAR KEINEN FALL programmieren sollte. Das Buch enthält sozusagen ein Sammelsurium an Java-Anti-Patterns. Für meine tägliche Praxis habe ich leider nicht ganz soviel Brauchbares erfahren wie erhofft, da ich die meisten hier beschriebenen Praktiken von vorneherein zu vermeiden versuche. Schließlich muß ich meine Software auch Jahre später noch warten und erweitern können, und für Wartungsarbeiten steht einem Entwickler in der Regel immer zu wenig Zeit zur Verfügung. Allein aus diesem Grund habe ich es mir schon seit einigen Jahren angewöhnt, meine Programme möglichst einfach zu schreiben, ohne mich in syntaktischen Spielereien zu verlieren. Die Autoren raten nicht umsonst: Strive for clarity!
Lesenswert ist das Buch aber auf jeden Fall (so wie alle Werke von Joshua Bloch), denn man weiß nach der Lektüre, was man beim Programmieren in Java vermeiden sollte, und daß die ausgefallenste Lösung in den seltensten Fällen die beste Vorgehensweise ist.


SQL Antipatterns: Avoiding the Pitfalls of Database Programming (Pragmatic Programmers)
SQL Antipatterns: Avoiding the Pitfalls of Database Programming (Pragmatic Programmers)
von Bill Karwin
  Taschenbuch
Preis: EUR 22,95

17 von 29 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Nachhilfeunterricht in Sachen SQL, 13. Dezember 2010
Meine Erfahrung mit SQL erstreckt sich jetzt schon über fast 20 Jahre, aber deswegen möchte ich mich nicht unbedingt als echten Experten bezeichnen, denn ich bin immer wieder erstaunt, was man im SELECT-Befehl alles unterbringen kann. Gerade dieses Jahr hatte ich einen Berater im Haus, der mir ein hoffnungslos umständliches Programmier-Tool installiert hatte, bei dem ich beide Hände über dem Kopf zusammengeschlagen habe. Aber die dazugehörende Datenbank des gleichen Software-Herstellers war klasse, und das mußte sie auch sein, schließlich durfte sie die Schwächen des Programmier-Tools ausgleichen. Der Berater hatte deswegen auch nichts Besseres zu tun, als fast die ganze Business-Logik in seitenlangen SELECT-Statements abzubilden. Selbst mir als eingefleischten SQL-Recken stand mehr als einmal der Angstschweiß auf der Stirn, als ich versucht habe, die Queries vollständig zu begreifen. Wartbarkeit? Vergeßt es! Erweiterbarkeit? Unmöglich! Dieser Berater war zwar sehr intelligent, aber seine Arbeit war ein einziges SQL-Antipattern.
Darum hätten seine SQL-Scripts auch hervorragend in vorliegendes Buch gepaßt, frei nach dem Motto: Wie man Queries auf gar keinen Fall schreiben sollte. Oder wie wartbar ist ein SELECT-Statement, das man als View abspeichert, welche ebenfalls auf einer View aufsetzt, die wiederum ihre Daten aus einer View bezieht? Überhaupt nicht! Als der Berater weg war, habe ich das umständliche Programmier-Tool in die Tonne getreten, die SELECT-Statements weitestgehend entzerrt und in ein Java-Programm eingebaut. Jetzt ist die Business-Logik endlich da, wo sie auch hingehört: In der Programmiersprache, und nicht in der Datenbank-Abfragesprache. Dieses Antipattern fehlt leider in Bill Karwins Buch: Lagere niemals zuviel Business-Logik in SQL aus, denn das versteht irgendwann keiner mehr (vom Anpassen ganz zu schweigen).
Aber mal abgesehen davon fand ich die "SQL Antipatterns" unheimlich spannend zu lesen. Einiges davon kannte ich bereits aus eigener Erfahrung, und ein paar Kapitel waren für mich eher uninteressant, aber etwas Neues lernt man auf jeden Fall hinzu, egal, wieviel SQL-Erfahrung man auch mitbringt. Im Laufe der Jahre war ich mit meinen SELECT-Statements ziemlich eingefahren, das heißt, ich habe immer wieder die gleichen Routinen und Techniken verwendet, dabei gibt es doch noch viele andere Tricks, die so einfach wie genial sind, und sowas lernt man, wenn man ein Fachbuch wie dieses hier liest. Der Text ist sehr angenehm geschrieben und liest sich unheimlich flüssig. Die SQL-Beispiele sind leicht verständlich und oftmals auch ziemlich lehrreich. Von diesem Buch kann wirklich jeder profitieren, sowohl der Novize als auch der Profi. Einen Punkt ziehe ich dennoch ab, denn nicht jeder Leser wird jedes Kapitel mögen. Für mich waren einige Antipatterns völlig uninteressant, aber das ist subjektiv und bei jedem Leser anders, je nachdem, welchen Erfahrungsschatz man gerade mitbringt.
Fazit: Eine klare Empfehlung für jeden SQL-Schrauber.
Kommentar Kommentare (6) | Kommentar als Link | Neuester Kommentar: Nov 13, 2013 1:06 PM CET


Core JavaServer Faces
Core JavaServer Faces
von David Geary
  Taschenbuch

12 von 14 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Das derzeit wohl beste Buch zu JSF 2.0, 13. Dezember 2010
Rezension bezieht sich auf: Core JavaServer Faces (Taschenbuch)
Von der Second Edition war ich einst ziemlich enttäuscht, weil es zu wenig Hintergrundwissen enthielt und zu viele Frameworks behandelt hat, die mit Core JSF nichts mehr zu tun hatten. Eigentlich wollte ich mir aus diesem Grund die Third Edition gar nicht mehr kaufen, habe es dann aber doch getan, weil ich von Ed Burns "The Complete Reference" doch nicht ganz so begeistert war, wie ich mir das ursprünglich erhofft hatte.
Obwohl ich mir keine allzu großen Hoffnungen von der Third Edition gemacht habe, war ich von der ersten Seite an begeistert. Die Autoren haben sich wirklich große Mühe gegeben, das Buch zu überarbeiten. Zum einen sind die Framework-Kapitel vollständig verschwunden, zum anderen wird jetzt das Buch seinem Titel endlich gerecht, denn es widmet sich voll und ganz den Konzepten hinter Core JSF.
Kapitel 1 enthält ein einfaches Beispiel, versehen mit erstaunlich wissenswerten Hintergrundinformationen. Auch die wichtigsten Einträge in der web.xml werden gezeigt und sehr gut erklärt. Selbst Ajax wird anhand eines JSF-spezifischen Beispiels kurz vorgestellt. Für ein erstes Kapitel ist dies ein außergewöhnlich guter Überblick. Lediglich der JSF-Lifecycle wird nach wie vor genauso schlecht erklärt wie in der Second Edition. Allerdings geht die Third Edition in späteren Kapiteln erneut auf den JSF-Lifecycle ein.
Im zweiten Kapitel werden Managed-Beans im Detail vorgestellt, inklusive Backing-Beans, Message-Bundles, Bean-Scopes und der EL. Äußerst interessant ist der Vergleich zwischen Managed-Beans und CDI-Beans, denn auch CDI-Beans können in JSF verwendet werden, sozusagen als Alternative zu Managed-Beans. Die CDI-relevanten Texte haben sogar mein Interesse geweckt, mich intensiver mit dem CDI-Konzept auseinanderzusetzen.
Kapitel 3 erklärt die Regeln der dynamischen Navigation zwischen JSF-Seiten. Des weiteren gibt es zwar kurze aber dennoch gute Abschnitte über Redirection, die Verwendung des Flash-Objektes, über Get-Requests und View-Parameter. Durchgehend lesenswert.
In Kapitel 4 haben die Autoren auf übersichtliche Art und Weise die Standard JSF-Tags vorgestellt. Die Tags sind intelligent gruppiert und werden mit Hardcopies und Code-Snippets vorgestellt. Teilweise wird sogar der HTML-Code gezeigt, den der JSF-Server aus den JSF-Tags generiert. Hervorragend!
Kapitel 5 enthält die beste, vollständigste und vor allem die am leichtesten zu verstehende Facelets-Dokumentation, die ich bisher gelesen habe. Erstklassig, absolut erstklassig!
Das sechste Kapitel widmet sich ausschließlich den Data-Tables mit all seinen Facetten (im wahrsten Sinne des Wortes). Höchst informativ sind die Abschnitte über editierbare Tables, Result-Sets in Data-Tables, Data-Sets mit Zeilennummern versehen sowie scroll- und sortierbare Data-Tables. Top!
Kapitel 7 - "Conversion & Validation" startet mit einem kurzen - aber guten - Abriß über den JSF-Lifecycle. Danach werden Standard-Converters und -Validators vorgestellt, gefolgt von Bean-Validation, die mir persönlich am meisten zugesagt hat. Anschließend wird es etwas aufwendiger, indem Custom Converters & Validators programmiert werden. Finde ich etwas umständlich. Beim Lesen ging mir der Begriff "cumbersome" nicht mehr aus dem Kopf. Wesentlich eleganter finde ich da schon die Validierung durch Bean-Methoden. Alles in allem ist das Kapitel aber klasse und mit wirklich guten Beispielen versehen.
Kapitel 8 behandelt das Event-Handling und startet mit Value-Change-Events und Action-Events. Es folgt eine Erklärung des Immediate-Attributs sowie verschiedene Möglichkeiten, um Daten von der UI an den Server zu übermitteln. Phase-Events werden nur kurz angerissen. Man sollte stattdessen System-Events verwenden, die anhand einiger Beispiele vorgestellt werden. Abschließend wird eine (laut Autoren-Aussage) "armselige" Implementierung des Tabbed-Pane gezeigt, das nur aus Standard-JSF-Komponenten gebaut worden ist. Sieht zwar nicht sooo toll aus, ist aber dennoch originell gelöst, sozusagen "a quick & dirty JSF-solution".
Das neunte Kapitel über Composite-Components habe ich nicht gelesen, da ich diese Erweiterungsmöglichkeit vorerst nicht benötige.
Kapitel 10 ist die beste Einführung in die Verwendung von Ajax für JSF 2.0, die ich bis dato gelesen habe. Es gibt eine sehr gute und einfache Definition für den Einsatz des f:ajax-Tags, gefolgt von einer Kurzeinführung in JSFs JavaScript-API, die von JSF verwendet wird, um f:ajax zu implementieren. Beim direkten Einsatz dieser API sind fundierte JavaScript-Kenntnisse allerdings eine notwendige Grundvoraussetzung, beim Einsatz des f:ajax-Tags dagegen nicht.
Kapitel 11 definiert zuerst den Unterschied zwischen Custom-Components und Composite-Components. Danach wird ziemlich ausführlich erklärt, wie man einen Spinner und ein "echtes" Tabbed-Pane als Custom-Komponente baut.
In Kapitel 12 werden kurz & bündig verschiedene externe Services im Zusammenspiel mit JSF dargestellt: Datenbank-Zugriff, Verwendung von JPA, Stateless Session-Beans, Stateful Session-Beans mit CDI (sehr interessant!), JEE-Security (weniger interessant), Mails versenden und der Einsatz von Web-Services. Höchst informativ und lesenswert.
Im abschließenden Kapitel 13 gibt es Tipps & Tricks im täglichen Umgang mit JSF, wobei manche Dinge nicht so ohne weiteres im Standard gelöst werden können. Hier empfiehlt sich der Einsatz einer Komponenten-Bibliothek. Ziemlich gut fand ich folgende Tipps: Data-Tables mit einem Pager versehen, generieren eines Popup-Windows mit JavaScript, Error-Pages customizen, JSF-Applikation konfigurieren und das Einbauen einer Funktion in JSF.
Die Third Edition von Core JSF ist für mich persönlich das Highlight unter den JSF-Büchern. Alle Kapitel sind durchgehend erstklassig geschrieben und leicht verständlich. Für die tägliche Arbeit kann ich das Buch uneingeschränkt empfehlen. Manche Themen werden zwar nicht so tief behandelt wie in der "Complete Reference", aber wer professionell mit JSF 2.0 programmieren möchte, der wird ohnehin beide Bücher besitzen. Dieses hier sollte man aber unbedingt zuerst lesen.


RESTful Java with JAX-RS
RESTful Java with JAX-RS
von Bill Burke
  Taschenbuch

12 von 12 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Web-Services the easy way, 8. September 2010
Rezension bezieht sich auf: RESTful Java with JAX-RS (Taschenbuch)
Um die Konzepte hinter RESTful Web-Services zu verstehen habe ich zuerst das Buch "REST und HTTP" von Stefan Tilkov gelesen, welches in der ersten Hälfte noch sehr interessant war, sich ab der zweiten Hälfte aber in zuviel Theorie verliert. Zwingend notwendig ist es zwar nicht, daß man vor Bill Burkes "RESTful Java" zuerst "REST und HTTP" liest, aber es ist immer empfehlenswert, sein Wissen aus unterschiedlichen Büchern zu schöpfen. Die REST-Konzepte werden in "RESTful Java" nämlich nur sehr rudimentär erklärt.
"RESTful Java" startet mit der üblichen Selbstbeweihräucherung, die den Auftakt von nahezu allen Framework-Büchern bildet und in etwa wie folgt lautet: "Bevor es diese Technologie gab, war die Software-Welt schwerfällig, fade und hoffnungslos umständlich, aber seitdem vorliegendes Framework das Licht der Welt erblickte, schreiben sich die Programme nahezu wie von selbst!"
Arbeitet man sich dann durch besagtes Framework, stellt man immer wieder fest, daß sich die Software leider ganz und gar nicht wie von selbst entwickelt, sondern daß auch diese Technologie genauso mit Arbeit verbunden ist und Einschränkungen unterliegt, wie alle anderen Frameworks auch. Nichtsdestotrotz finde ich RESTful Web-Services sehr elegant und leicht zu entwickeln, wohingegen ich mich mit SOAP-basierten Web-Services und der damit zwangsläufig verbundenen XML-Hell nie so recht anfreunden konnte. Die REST-Architektur gefällt mir dagegen ausgesprochen gut, und die Entwicklung mit der JBoss-Implementierung RESTEasy fiel wesentlich einfacher aus als erwartet.
Das Buch von Bill Burke liest sich, genauso wie sein Vorgängerwerk "Enterprise JavaBeans 3.0", sehr flüssig und ist auch äußerst kompetent geschrieben. Nichts anderes hatte ich von Bill Burke erwartet. Die Kapitel 3 und 4 erklären im Grunde genommen fast schon alles, was man benötigt, um mit RESTEasy ein erstes Beispielprogramm zu entwickeln. In den weiteren Kapiteln wird dieses Wissen kurz, bündig und fundiert ausgebaut. Auch der Einsatz von JAXB wird angesprochen. Des weiteren gibt es lesenswerte Kapitel über HTTP Content Negotiation, HATEOAS und HTTP-Caching. Den Abschnitt über Deployment fand ich nur mäßig aufschlußreich, denn zu diesem Zeitpunkt hatte ich RESTEasy 2.0.1 bereits unter JBoss 5.1 zum Laufen gebracht, und das ging sogar ziemlich einfach. Security wird ebenfalls angesprochen, aber dabei werden fast nur die allseits bekannten Servlet-Security-Themen behandelt. Interessanter waren die RESTful Java-Clients, und hier stehen drei zur Auswahl: Selber einen Client mit java.net.URL entwickeln, Apache HttpClient verwenden oder auf das RESTEasy Client Framework setzen. Die Auswahl bleibt jedem selbst überlassen. Abgeschlossen wird das Buch mit den vorhandenen JAX-RS-Implementierungen, die es momentan im Java-Umfeld gibt.
Genauso wie in "Enterprise JavaBeans 3.0" gibt es auch bei diesem Buch ein Workbook, in dem zu jedem Kapitel diverse Beispiele aufgeführt werden. Ich habe diese Beispiele zwar nicht ausführen lassen, aber ich habe mir trotzdem einige Code-Examples durchgelesen und als Vorlage für meine eigenen Tests genommen, und für diesen Zweck waren die Beispiele ziemlich hilfreich.
Alles in allem kann ich das Buch von Bill Burke nur empfehlen, da es praxisnah und sehr angenehm zu lesen ist. So machen neue Frameworks Spaß.


Seite: 1 | 2 | 3 | 4