Also starte ich ein brandneues Projekt in Java und erwäge, Spring zu verwenden. Warum denke ich über den Frühling nach? Weil mir viele Leute sagen, ich sollte Spring benutzen! Im Ernst, jedes Mal, wenn ich versucht habe, die Leute dazu zu bringen, zu erklären, was genau Frühling ist oder was er tut, können sie mir niemals eine klare Antwort geben. Ich habe die Intros auf der SpringSource-Website überprüft, und sie sind entweder sehr kompliziert oder auf Lernprogramme ausgerichtet. Keiner von ihnen gibt mir eine gute Vorstellung davon, warum ich sie verwenden sollte oder wie sie mir das Leben erleichtern werden. Manchmal werfen die Leute den Begriff "Abhängigkeitsinjektion" herum, was mich nur noch mehr verwirrt, weil ich denke, dass ich ein anderes Verständnis davon habe, was dieser Begriff bedeutet.

Wie auch immer, hier ist ein wenig über meinen Hintergrund und meine App:

Entwickelt seit einiger Zeit in Java und betreibt Back-End-Webentwicklung. Ja, ich mache eine Menge Unit-Tests. Um dies zu vereinfachen, erstelle ich normalerweise (mindestens) zwei Versionen einer Methode: eine, die Instanzvariablen verwendet, und eine, die nur Variablen verwendet, die an die Methode übergeben werden. Derjenige, der Instanzvariablen verwendet, ruft den anderen auf und liefert die Instanzvariablen. Wenn es um Unit-Tests geht, benutze ich Mockito, um die Objekte zu verspotten und rufe dann die Methode auf, die keine Instanzvariablen verwendet. Das habe ich immer unter "Abhängigkeitsinjektion" verstanden.

Meine App ist aus CS-Sicht ziemlich einfach. Kleines Projekt, 1-2 Entwickler am Anfang. Meistens CRUD-artige Operationen mit ein paar Suchvorgängen. Im Grunde genommen ein paar RESTful-Webdienste, ein Web-Front-End und schließlich einige mobile Clients. Ich denke darüber nach, das Front-End in HTML / CSS / JS / JQuery zu erstellen, daher gibt es keine konkreten Pläne für die Verwendung von JSP. Verwenden von Hibernate als ORM und Jersey zum Implementieren der Webservices.

Ich habe bereits mit dem Programmieren begonnen und bin sehr gespannt auf eine Demo, in der ich stöbern und nachsehen kann, ob jemand investieren möchte. Offensichtlich ist die Zeit entscheidend. Ich verstehe, dass Spring eine gewisse Lernkurve hat, und es sieht so aus, als ob eine ganze Reihe von XML-Konfigurationen erforderlich sind, die ich normalerweise wie die Pest zu vermeiden versuche. Aber wenn es mein Leben leichter machen kann und (besonders) wenn es die Entwicklung und das Testen beschleunigt, bin ich bereit, in die Kugel zu beißen und den Frühling zu lernen.

Also bitte. Erziehe mich. Soll ich Spring verwenden? Warum oder warum nicht?

Was macht das Spring Framework? Soll ich es benutzen? Warum oder warum nicht?

Spring ist ein Framework, mit dem Sie verschiedene Komponenten miteinander verbinden können. Dies ist am nützlichsten, wenn Sie viele Komponenten haben und diese möglicherweise auf unterschiedliche Weise kombinieren möchten oder wenn Sie es einfach haben möchten, eine Komponente durch eine andere auszutauschen, je nach den verschiedenen Einstellungen oder Umgebungen.

Das habe ich immer unter "Abhängigkeitsinjektion" verstanden.

Ich würde eine andere Definition vorschlagen:

"Gestalten Sie Ihre Objekte so, dass sie von einer externen Kraft mit dem versorgt werden, was sie benötigen, mit der Erwartung, dass diese Abhängigkeiten immer injiziert werden, bevor jemand sie auffordert, ihre gewohnten Aufgaben zu erledigen."

Vergleichen Sie das mit: "Jedes Objekt ist dafür verantwortlich, beim Start alles und jeden zu finden, was es braucht."

Es sieht so aus, als ob eine ganze Reihe von XML-Konfigurationen erforderlich sind

Nun, die meisten XML- (oder annotationsbasierten) Inhalte erzählen Frühlingsinhalte wie:

• Wenn jemand nach "HammerStore" fragt, möchte ich, dass Sie eine Instanz von erstellen example.HammerStoreund diese zurückgeben. Zwischenspeichern Sie die Instanz für das nächste Mal, da es nur einen Speicher geben muss.
• Wenn jemand nach "SomeHammer" fragt, möchte ich, dass Sie sich nach einem "HammerStore" erkundigen und das Ergebnis der Store- makeHammer()Methode zurückgeben. Sie nicht dieses Ergebnis zwischenzuspeichern.
• Wenn jemand nach "SomeWrench" fragt, soll eine Instanz von erstellt example.WrenchImplwerden. Verwenden Sie die Konfigurationseinstellung gaugeAmountund fügen Sie sie in die setWrenchSize()Eigenschaft der Instanz ein . Cache das Ergebnis nicht.
• Wenn jemand nach "LocalPlumber" fragt, möchte ich, dass Sie eine Instanz von erstellen example.PlumberImpl. setName()Fügen Sie den String "Pedro" in die Methode ein, fügen Sie einen "SomeHammer" in die setHammer()Methode ein und fügen Sie einen "SomeWrench" in die setWrench()Methode ein. Geben Sie das Ergebnis zurück und speichern Sie es für einen späteren Zeitpunkt im Cache, da wir nur einen Klempner benötigen.

Auf diese Weise können Sie mit Spring die Komponenten verbinden, beschriften, ihre Lebenszyklen / Zwischenspeicherung steuern und das Verhalten je nach Konfiguration ändern.

Um das [Testen] zu erleichtern, erstelle ich normalerweise (mindestens) zwei Versionen einer Methode: eine, die Instanzvariablen verwendet, und eine, die nur Variablen verwendet, die an die Methode übergeben werden.

Das klingt nach viel Aufwand, der mir nicht viel nützt. Stellen Sie stattdessen sicher, dass Ihre Instanzvariablen eine protectedSichtbarkeit für oder ein Paket haben , und suchen Sie die Komponententests im selben com.mycompany.whateverPaket. Auf diese Weise können Sie die Instanzvariablen jederzeit während des Tests überprüfen und ändern.

Was ist Abhängigkeitsinjektion?

Einfach. Sie haben eine Klasse, sie hat ein privates Feld (auf null gesetzt) ​​und Sie deklarieren einen öffentlichen Setter, der den Wert für dieses Feld liefert. Mit anderen Worten, die Abhängigkeit der Klasse (des Feldes) wird von einer externen Klasse (über den Setter) injiziert. Das ist es. Nichts magisches.

Zweitens kann Spring ohne XML (oder sehr wenig) verwendet werden

Wenn Sie mit Spring 3.0.5.GA oder höher eintauchen, können Sie die Abhängigkeitsinjektionsunterstützung von JDK6 + verwenden. Dies bedeutet, dass Sie Abhängigkeiten mit den Anmerkungen @Componentund @Resourceverknüpfen können.

Warum überhaupt Spring verwenden?

Die Abhängigkeitsinjektion erleichtert natürlich das Testen von Einheiten erheblich, da alle Klassen Setter für die wichtigen Abhängigkeiten haben. Diese können mithilfe Ihres bevorzugten Verspottungs-Frameworks leicht verspottet werden, um das erforderliche Verhalten zu erzielen.

Abgesehen davon bietet Spring auch eine Vielzahl von Vorlagen, die als Basisklassen fungieren, um die Verwendung der JEE-Standardtechnologien zum Kinderspiel zu machen. Zum Beispiel funktioniert das JdbcTemplate gut mit JDBC, das JpaTemplate macht gute Sachen mit JPA, JmsTemplate macht JMS ziemlich unkompliziert. Das RestTemplate ist einfach großartig in seiner Einfachheit. Zum Beispiel:

RestTemplate restTemplate = new RestTemplate();
MyJaxbObject o = restTemplate.getForObject("https://secure.example.org/results/{param1}?param2={param2}",MyJaxbObject.class,"1","2");

und du bist fertig. Die Parameter werden injiziert und Sie müssen nur JAXB-Annotationen für MyJaxbObject bereitstellen. Dies sollte keine Zeit in Anspruch nehmen, wenn Sie sie mithilfe des Maven JAXB-Plugins automatisch aus einer XSD generiert haben. Beachten Sie, dass dort kein Casting stattfand und auch kein Marshaller deklariert werden musste. Es ist alles für dich erledigt.

Ich könnte mich für immer über die Wunder des Frühlings austoben, aber vielleicht ist es das Beste, einen einfachen Code-Spike auszuprobieren, bei dem Sie versuchen, einen RESTful-Webdienst zu verkabeln, um Daten aus einem eingeschleusten DAO herauszupumpen, der Transaktionen unterstützt.

Zunächst einmal ist Ihr Verständnis der Abhängigkeitsinjektion nicht grundsätzlich falsch, sondern unterscheidet sich grundlegend von dem, was die meisten Menschen meinen, wenn sie den Begriff verwenden. Was Sie beschreiben, ist ein ziemlich seltsamer und unkonventioneller Weg, um Testbarkeit zu erreichen. Ich würde Ihnen raten, sich davon zu entfernen, da andere Entwickler von dieser Art von Code ziemlich verwirrt sein werden.

Die Abhängigkeitsinjektion, wie sie allgemein verstanden wird (und von Spring implementiert wird), bedeutet, dass die Abhängigkeiten einer Klasse (z. B. eine JDBC-Datenquelle) nicht von der Klasse selbst abgerufen werden, sondern von einem Container "injiziert" werden, wenn die Instanz erstellt wird. Sie haben also nicht zwei Versionen jeder Methode, die die Datenquelle verwendet. Stattdessen haben Sie eine Abhängigkeitsinjektionskonfiguration, in die die "echte" Datenquelle injiziert wird, und eine, in die eine Scheininjektion injiziert wird. Wenn die Injektion über den Konstruktor oder einen Getter erfolgt, kann der Testcode die Injektion explizit ausführen.

Zweitens ist Spring nicht nur eine Abhängigkeitsinjektion, obwohl dies seine Kernfunktionalität ist. Es bietet auch deklarative Transaktionen, Jobplanung, Authentifizierung und eine Reihe anderer Funktionen (einschließlich eines vollwertigen MVC-Webframeworks), die Sie möglicherweise benötigen. Es gibt andere Frameworks, die die gleiche Funktionalität bieten, aber abgesehen von Spring sind sie alle nur in Java EE integriert.

Warum Sie Spring verwenden möchten, erfahren Sie unter http://www.wrox.com/WileyCDA/Section/Why-Use-the-Spring-Framework-.id-130098.html

In Summe :

• J2EE-Anwendungen neigen dazu, übermäßige Mengen an "Installations" -Code zu enthalten. Viele Codeüberprüfungen zeigen wiederholt einen hohen Anteil an Code, der nichts bewirkt: JNDI-Suchcode, Objekte übertragen, Try / Catch-Blöcke, um JDBC-Ressourcen abzurufen und freizugeben. . . . Das Schreiben und Verwalten eines solchen Installationscodes führt zu einer erheblichen Belastung der Ressourcen, die auf die Geschäftsdomäne der Anwendung ausgerichtet sein sollten.

• Viele J2EE-Anwendungen verwenden ein verteiltes Objektmodell, bei dem dies unangemessen ist. Dies ist eine der Hauptursachen für übermäßige Vervielfältigung von Code und Code. In vielen Fällen ist es auch konzeptionell falsch. Intern verteilte Anwendungen sind komplexer als Anwendungen, die sich am selben Ort befinden, und oftmals viel weniger leistungsfähig. Wenn Ihre Geschäftsanforderungen eine verteilte Architektur vorschreiben, müssen Sie natürlich eine verteilte Architektur implementieren und den damit verbundenen Kompromiss akzeptieren (und Spring bietet Funktionen, die in solchen Szenarien hilfreich sind). Sie sollten dies jedoch nicht ohne zwingenden Grund tun.

• Das EJB-Komponentenmodell ist zu komplex. EJB wurde konzipiert, um die Komplexität bei der Implementierung von Geschäftslogik in J2EE-Anwendungen zu verringern. dies ist in der Praxis nicht gelungen.

• EJB wird überbeansprucht. EJB wurde im Wesentlichen für intern verteilte Transaktionsanwendungen entwickelt. Während es sich bei fast allen nicht-trivialen Anwendungen um transaktionale Anwendungen handelt, sollte die Verteilung nicht in das Basiskomponentenmodell integriert werden.

• Viele "J2EE-Entwurfsmuster" sind in der Tat keine Entwurfsmuster, sondern Problemumgehungen für technologische Einschränkungen. Übermäßige Verbreitung und Verwendung komplexer APIs wie EJB haben zu vielen fragwürdigen Entwurfsmustern geführt. Es ist wichtig, diese kritisch zu untersuchen und nach einfacheren, produktiveren Ansätzen zu suchen.

• J2EE-Anwendungen sind schwer zu Unit-Test. Die J2EE-APIs und insbesondere das EJB-Komponentenmodell wurden vor dem Start der agilen Bewegung definiert. Ihr Design berücksichtigt daher nicht die Einfachheit des Einheitentests. Sowohl über APIs als auch über implizite Verträge ist es überraschend schwierig, Anwendungen basierend auf EJB und vielen anderen J2EE-APIs außerhalb eines Anwendungsservers zu testen. Unit-Tests außerhalb eines Anwendungsservers sind jedoch unerlässlich, um eine hohe Testabdeckung zu erzielen und viele Fehlerszenarien zu reproduzieren, z. B. den Verlust der Verbindung zu einer Datenbank. Es ist auch wichtig sicherzustellen, dass die Tests während des Entwicklungs- oder Wartungsprozesses schnell ausgeführt werden können, um unproduktive Wartezeiten für die erneute Bereitstellung zu minimieren.

• Bestimmte J2EE-Technologien haben einfach versagt. Der Haupttäter sind Entity-Beans, die sich in Bezug auf Produktivität und Einschränkungen der Objektorientierung als wenig katastrophal erwiesen haben.

Früher haben wir einfache, effiziente, schnelle Anwendungen und Webservices mit nur Java, Servlets und JSP, HTML und XML, JDBC-API geschrieben. Es war gut genug; JUnit war ein gutes Werkzeug zum Testen. Wir ruhten uns einfach aus, dass unser Code funktionierte.

Hibernate wurde eingeführt, um SQL zu vereinfachen und eine echte Zuordnung von Datenbanktabellen zu Java-Objekten zu ermöglichen, sodass hierarchische Beziehungen in der so genannten Objektbeziehungszuordnung (Object Relations Mapping, ORM) widergespiegelt werden können. Ich liebte es. Insbesondere mussten wir das ResultSet nicht wieder einem Java-Objekt oder -Datentyp zuordnen.

Struts kamen, um das Model View Controller-Muster zu unseren Web-Apps hinzuzufügen, es war gut.

EJBs waren ein riesiger Aufwand und Schmerzen und Anmerkungen ließen Code wie Hühnchenkratzer aussehen, und nun wurde uns unschuldigen Leuten der Frühling auferlegt. Es scheint mir einfach zu übertreiben.

Zum Beispiel packen wir jetzt unsere einfache jdbc-URL user und übergeben sie zuerst an jdbc.properties, dann an hibernate properties und zum dritten Mal an Spring Beans!

Im Gegensatz dazu ist es denkbar einfach, eine Verbindung dort zu finden, wo Sie sie benötigen, wie im Folgenden gezeigt:

Connection connection = DriverManager.getConnection(url, user, pass);

Das ist an sich selbsterklärend, dass es eine große Sache ist und sich immer wieder darum dreht, eine einfache Sache schnell und einfach zu erledigen, ohne dass es wirklich große Vorteile gibt. Es ist, als würde man Tonnen und Tonnen Geschenkpapier um ein kleines nettes Geschenk wickeln, das alles ist, was Sie wirklich behalten.

Ein weiteres Beispiel ist ein Batch-Update. Mit Spring ist es kompliziert und umfasst einige Klassen und Schnittstellen, bevor Sie das JdbcTemplate verwenden können, um eine Stapelaktualisierung durchzuführen. Mit plain jdbc ist es einfach:

Statement statement = connection.createStatement();
statement.addBatch(sqlquery);
statement.executeBatch();

Einfacher und schneller geht es nicht.

Ich unterstütze diesen Rahmen nicht. Es tut uns leid. Wer in aller Welt möchte Injektionen, wenn sie etwas brauchen?

Was macht das Spring Framework?

Frühling ist wie heute nicht nur ein so genanntes einfaches Framework, sondern ein komplettes Ökosystem.

Themen des Frühlingsökosystems:

• Spring Framework (zB Dependency Injection, AOP ...)

• Frühlingswolke

• Frühlingsdaten

• Frühling Sicherheit

• Frühlingsreihe

• Frühlings-Soziales

Siehe hier für die vollständige Abdeckung des Ökosystems. Es ist möglich, Projekte auszuwählen, sodass Sie Google Guice für DI und z. B. Spring Security verwenden können, um sicherheitsrelevante Dinge zu erledigen. Sie müssen sich nicht in das gesamte Ökosystem einkaufen.

Das Spring-Framework selbst deckt heute hauptsächlich ab

• Abhängigkeitsspritze

• Aspektorientierte Programmierung, einschließlich des deklarativen Transaktionsmanagements von Spring

• Spring MVC Web Application und RESTful Web Service Framework

• Grundlegende Unterstützung für JDBC, JPA, JMS

Quelle spring.io

Im Allgemeinen kann man sagen, dass Spring eine Sammlung von im Code implementierten Mustern und Methoden ist, die dazu beitragen können, den Entwicklungszyklus von Anwendungen zu verbessern oder zu beschleunigen.

Für das, wofür es (das Core-Framework) am bekanntesten ist, sind seine Fähigkeiten im Bereich der Abhängigkeitsinjektion . Die Feder selbst hat, was als Inversion des Steuercontainers oder kurzer IoC-Container oder gar kürzer der Container bezeichnet wird (wofür manchmal auch "Feder" verwendet wird).

Was ist Abhängigkeitsinjektion?

Abhängigkeitsinjektion bedeutet, dass Ihr Objekt jede Abhängigkeit von anderen Objekten über einen ausgelagerten Mechanismus erhält.

Angenommen, Sie haben ein Auto, die typische Art und Weise, wie es implementiert wird, ist:

public class Car {

    Engine e;

    public Car() { 
        e = new Engine(); 
    }

}

Das Autoobjekt ist abhängig von einem Motor. Da der Motor als Mitglied des Autos implementiert ist, kann er nicht zB gegen einen Testmotor ausgetauscht werden.

Jetzt kommt die Abhängigkeitsinjektion ins Spiel:

public class Car {

    Engine e;

    public Car(Engine e) { 
        this.e = e; 
    }

}

Danach können Sie die Motoren wechseln. Was Sie oben sehen, wird Konstruktorinjektion genannt . Es gibt andere Arten wie zB Setter- Injection oder Method- Injection. Wie hilft Ihnen der Frühling dabei? Spring ermöglicht es, zu injizierende Komponenten mit der @AutowiredBeschriftung zu kennzeichnen, und führt die Verkabelung des injizierten Objekts automatisch durch. Es ist wahrscheinlich, dass die Komponente, die Sie injizieren möchten, selbst Abhängigkeiten aufweist. Injectables sind sozusagen mit gekennzeichnet@Component

public class Car {

    Engine e;

    @Autowired
    public Car(Engine e) { 
        this.e = e; 
    }

}

Dies ist jedoch nur eine von vielen Funktionen, die Spring zu bieten hat.

Soll ich Spring verwenden? Warum oder warum nicht?

Da der Frühling nicht sehr aufdringlich ist und viele Hilfsmittel bietet, sollten Sie den Frühling in Betracht ziehen. Vor allem für neue Projekte ist Spring Boot sehr attraktiv. start.spring.io bietet eine einfach zu bedienende Point'n'Click- Oberfläche, um eine Projektvorlage zu generieren. Es ist sogar möglich, curleine Vorlage abzurufen:

curl start.spring.io

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

:: Spring Initializr ::  https://start.spring.io

This service generates quickstart projects that can be easily customized.
Possible customizations include a project's dependencies, Java version, and
build system or build structure. See below for further details.

The services uses a HAL based hypermedia format to expose a set of resources
to interact with. If you access this root resource requesting application/json
as media type the response will contain the following links:
+-----------------+-----------------------------------------+
| Rel             | Description                             |
+-----------------+-----------------------------------------+
| gradle-build    | Generate a Gradle build file            |
| gradle-project  | Generate a Gradle based project archive |
| maven-build     | Generate a Maven pom.xml                |
| maven-project * | Generate a Maven based project archive  |
+-----------------+-----------------------------------------+

...

Auf der anderen Seite bieten Frameworks wie spark oder dropwizard einen guten Ausgangspunkt für die schnelle Erstellung von Web- Apps .

Es ist ein in Java geschriebenes Framework, das viele Dinge enthält, um Ihre Webanwendung funktionsfähig zu machen (z. B. Unterstützung für die Internationalisierung). Es bietet auch eine gute Möglichkeit, Ihre Anwendung in Ebenen zu strukturieren. Verwenden Sie es, es wird Ihnen auf lange Sicht viel Zeit sparen.

Ein gutes Buch zum Thema Frühling ist: Expert Spring MVC und Web Flow