spring Tutorial
Erste Schritte mit dem Frühling

Bemerkungen

Versionen

Setup (XML-Konfiguration)

Schritte zum Erstellen von Hello Spring:

0. Untersuchen Sie Spring Boot , um herauszufinden , ob dies Ihren Bedürfnissen besser entspricht.
1. Lassen Sie ein Projekt mit den richtigen Abhängigkeiten einrichten. Es wird empfohlen, dass Sie Maven oder Gradle verwenden .
2. Erstellen Sie eine POJO-Klasse, z. B. Employee.java
3. Erstellen Sie eine XML-Datei, in der Sie Ihre Klasse und Variablen definieren können. zB beans.xml
4. Erstellen Sie Ihre Hauptklasse, z. B. Customer.java
5. Fügen Sie Spring-Beans (und ihre transitiven Abhängigkeiten!) Als Abhängigkeit hinzu.

Employee.java :

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}

beans.xml :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>

Customer.java :

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}

Darstellung der Kernfedern am Beispiel

Beschreibung

Dies ist eine in sich geschlossene Lauf Beispiel einschließlich / Inszenierung: Mindest Abhängigkeiten benötigt, Java - Konfiguration, Bean Erklärung Annotation und Java - Konfiguration, Dependency Injection von Constructor und von Eigentum und Pre / Post Haken.

Abhängigkeiten

Diese Abhängigkeiten werden im Klassenpfad benötigt:

1. Federkern
2. Frühlingskontext
3. Frühlingsbohnen
4. Frühling-aop
5. Frühlingsausdruck
6. Commons-Protokollierung

Hauptklasse

Von Anfang an ist dies unsere Main-Klasse, die als Platzhalter für die main() Methode dient, die den Anwendungskontext durch Zeigen auf die Configuration-Klasse initialisiert und alle verschiedenen Beans lädt, die zur Darstellung bestimmter Funktionen benötigt werden.

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}

Anwendungskonfigurationsdatei

Die Konfigurationsklasse wird von @Configuration Anmerkungen @Configuration und im initialisierten Anwendungskontext als Parameter verwendet. Die Annotation @ComponentScan auf Klassenebene der Konfigurationsklasse verweist auf ein Paket, das nach Beans und Abhängigkeiten durchsucht werden soll, die mit Annotationen registriert wurden. Schließlich dient die Annotation @Bean als Bean-Definition in der Konfigurationsklasse.

package com.stackoverflow.documentation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}

Bean Deklaration von Annotation

Die @Component Annotation dient zur Abgrenzung des POJO als Spring-Bean, das beim Scannen von Komponenten für die Registrierung verfügbar ist.

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}

Bean-Deklaration nach Anwendungskonfiguration

Beachten Sie, dass wir unser POJO nicht kommentieren oder anderweitig kennzeichnen müssen, da die Bean-Deklaration / Definition in der Application Configuration-Klassendatei stattfindet.

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}

Konstruktorinjektion

Beachten Sie, dass die Annotation @Autowired auf Konstruktorebene festgelegt ist. Beachten Sie außerdem, dass die Standardeinstellung für die automatische Einstellung auf Grundlage des Typs der Bean (in diesem Fall BeanToBeInjected ) erfolgt, sofern dies nicht explizit durch den Namen definiert ist.

package com.stackoverflow.documentation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}

Immobilieninjektion

Beachten Sie, dass die Annotation @Autowired die Setter-Methode abgrenzt, deren Name dem JavaBeans-Standard entspricht.

package com.stackoverflow.documentation;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}

PostConstruct / PreDestroy-Haken

Wir können die Initialisierung und Zerstörung eines Beans durch die Haken @PostConstruct und @PreDestroy .

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}

Was ist Spring Framework, warum sollten wir uns dafür entscheiden?

Spring ist ein Framework, das eine Reihe von Klassen bereitstellt. Auf diese Weise müssen wir keine Boiler-Plattenlogik in unseren Code schreiben. Daher bietet Spring eine abstrakte Ebene auf J2ee.

Zum Beispiel ist in Simple JDBC Application ein Programmierer zuständig

1. Die Fahrerklasse wird geladen
2. Verbindung herstellen
3. Anweisungsobjekt erstellen
4. Behandlung der Ausnahmen
5. Abfrage erstellen
6. Abfrage ausführen
7. Verbindung schließen

Wird als Boilerplate-Code behandelt, da jeder Programmierer denselben Code schreibt. Der Einfachheit halber kümmert sich das Framework um die Boilerplate-Logik, und der Programmierer muss nur Geschäftslogik schreiben. Durch die Verwendung von Spring Framework können wir also Projekte mit minimalen Codezeilen schnell entwickeln, ohne Fehler, Entwicklungskosten und -zeit reduzieren.

Warum also Spring als Streben wählen, ist da

Strut ist ein Framework, das nur eine Lösung für Web-Aspekte bietet, und Struts sind in der Natur invasiv. Frühling hat viele Eigenschaften über Streben, also müssen wir Frühling wählen.

1. Der Frühling ist nicht invasiv : Das bedeutet, dass Sie keine Klassen erweitern oder Schnittstellen für Ihre Klasse implementieren müssen.
2. Frühling ist vielseitig : Das heißt, er kann in jede vorhandene Technologie in Ihrem Projekt integriert werden.
3. Spring bietet End-to-End- Projektentwicklung: Das heißt, wir können alle Module wie Business-Layer, Persistence-Layer entwickeln.
4. Frühling ist leicht : Das heißt, wenn Sie an einem bestimmten Modul arbeiten möchten, müssen Sie nicht den gesamten Frühling lernen, sondern nur das jeweilige Modul (z. B. Spring Jdbc, Spring DAO).
5. Feder unterstützt Abhängigkeitseinspritzung .
6. Spring unterstützt mehrere Projektentwicklungen, z. B .: Core Java-Anwendung, Webanwendung, Verteilte Anwendung, Unternehmensanwendung.
7. Federstützen Aspect-orientierte Programmierung für Querschnittsthemen.

Endlich können wir sagen, dass der Frühling eine Alternative zu Struts ist. Spring ist jedoch kein Ersatz für die J2EE-API. Die von Spring bereitgestellten Klassen verwenden intern J2EE-API-Klassen. Der Frühling ist ein riesiger Rahmen, der in mehrere Module aufgeteilt wurde. Kein Modul ist von einem anderen als dem Spring Core abhängig. Einige wichtige Module sind

1. Spring Core
2. Spring JDBC
3. Frühling AOP
4. Frühling Transaktion
5. Frühling ORM
6. Spring MVC