Die Anleitung zum Sping für den Anfänger

Die Vorstellung
Spring Framework
Maven project erstellen
Die Meldung der grundlegenden Spring-Bibliothek
Code Project
Spring @Configuration & IoC
Spring ApplicationContext
Der Operationsgrundsatz vom Spring
Die Web-Applikation durch Spring Boot programmieren
Der Anhang: die Bibliothek String herunterladen

1. Die Vorstellung

Die Unterlagen wird nach der Quelle von ... geschrieben

Spring Framework 4.x
Eclipse 4.6 NEON (ok for Eclipse 4.5 MARS)

Im Dokument benutze ich Maven um die Benutzung von der Bibliothek von Spring zu melden, anstatt wir Spring herunterladen und dann nach der normalen Weise melden.

Maven ist ein Tool, damit Sie die Bibliothek automatisch und effizient verwalten können und es ist so üblich dass alle Java-programmer es kennen müssen. Wenn Sie Maven noch nicht kennen, bitte spenden Sie 10 Minute zur die Gebrauchweise hier zu lernen.

Die Anleitung zum Maven für den Anfänger

Falls Sie Spring herunterladen möchten und die Bibliothek nach dem traditionalen Weg melden, können Sie den Anhang am Ende vom Unterlagen lesen

2. Spring Framework

Das folgende Beispiel bezeichnet die Strutur vom Spring Framework.

IoC Container: Das ist die wichtigste sowie grundlegende Teil vom Spring. Es spielt eine Rolle zur Konfiguration und Management des Lebenskreis (Lifecycle) vom Jave-Objekt. Das Unterlagen heute erwähnt diese Teil.
DAO, ORM, AOP, WEB: Die Module sind Tool oder Framework, die im Spring intergriert werden.

Der Begriff von Inversion of Control & Dependency Injection

Wir sehen einige folgenden Klasse um das Dinge zu verstehen.

// Interface HelloWorld
public interface HelloWorld {
    public void sayHello();
}

// Class implements HelloWorld
public class SpringHelloWorld implements HelloWorld {
   public void sayHello()  {
           System.out.println("Spring say Hello!");
   }
}

// Other class implements HelloWorld
public class StrutsHelloWorld implements HelloWorld {
   public void sayHello()  {
           System.out.println("Struts say Hello!");
   }
}


// And Service class
public class HelloWorldService {
   
     // Field type HelloWorld
     private HelloWorld helloWorld;
   
     // Constructor HelloWorldService
     // It initializes the values for the field 'helloWorld'
     public HelloWorldService()  {
           this.helloWorld = new StrutsHelloWorld();
     }

}

Es ist leich zu sehen, dass die Klasse HelloWorldService die Erstellung des Objekt HelloWorld managiert.

- Im oben Fall wenn ein Objekt HelloWorldService aus seinem Constuktor erstellt, wird das Objekt HelloWorld auch erstellt und vom StrutsHelloWorld erstellt

Hier stellt eine Frage: Sie möchten das Objekt HelloWorldService erstellen und gleichzeitig wird das Objekt HelloWorld erstellt. Aber es muss SpringHelloWorld sein.

Deshalb kontrolliert HelloWorldService gerade "object creation" vom HelloWorld. Warum lassen wir eine dritte Partei HelloWorld erstellen, anstatt wir in HelloWorldService machen. Wir haben den Begriff "inversion of control", d.h "Die Umkerung der Kontrol" (IoC).

Und IoC Container spielt eine Rolle als der Manager bei der Erstellung von HelloWorldService und HelloWorld.

IoC = Inversion of Control

IoC Container erstellt das Objekt HelloWorldService und das Objekt HelloWorld danach pass HelloWorld in HelloWorldService durch setter. Die Aufgabe, was IoC Container gerade tut, ist Dependency InjectioninHelloWorldService. Die Abhängigkeit hier bedeutet die Abhängigkeit zwischen die Objekte: HelloWorldService und HelloWorld.

Bisher haben wir IoC&DI kennengelernt. bitte machen Sie ein Beispiel HelloWorld um mehr zu verstehen.

3. Maven project erstellen

File/New/Other...

Geben Sie ein

Group Id: org.o7planning
Artifact Id: HelloSpringAnnotation
package: org.o7planning.spring

Ihr Projekt wird erstellt.

Stellen Sie sicher, dass Ihr Projekt auf Java 7 oder neure gebaut wird. Klicken Sie auf Projekt und wählen Properties.

4. Die Meldung der grundlegenden Spring-Bibliothek

Das ist das Beispiel HelloWorld Spring, deshalb benutzen wir nur die grundlegende Spring Bibliothek (Core). Öffnen Sie die File pom.xml um die benutzenden Bibliothek zu melden

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
  http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.o7planning</groupId>
  <artifactId>HelloSpringAnnotation</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>HelloSpringAnnotation</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring Core -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

        <!-- Spring Context -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

    </dependencies>
 
</project>

5. Code Project

Das ist die Bezeichnungsfoto zur Projektsstruktur:

Language.java

package org.o7planning.spring.lang;

// A Language
public interface Language {

    // Get a greeting
    public String getGreeting();

    // Get a bye
    public String getBye();

}

English.java

package org.o7planning.spring.lang.impl;

import org.o7planning.spring.lang.Language;

// English
public class English  implements Language {

 @Override
 public String getGreeting() {
     return "Hello";
 }

 @Override
 public String getBye() {
     return "Bye bye";
 }


}

Vietnamese.java

package org.o7planning.spring.lang.impl;

import org.o7planning.spring.lang.Language;

// Vietnamese
public class Vietnamese implements Language {

   @Override
   public String getGreeting() {
       return "Xin Chao";
   }

   @Override
   public String getBye() {
       return "Tam Biet";
   }

}

@Service ist eine Annotation. Es wird benutzt um auf einer Klasse zu annotieren, dass die Klasse ist eine Spring BEAN.

@Autowired wird auf einem Feld (field) um Spring zu sagen: die Wert für den Feld einkoppeln (inject)

GreetingService.java

package org.o7planning.spring.bean;

import org.o7planning.spring.lang.Language;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class GreetingService {

   @Autowired
   private Language language;

   public GreetingService() {

   }

   public void sayGreeting() {
       
       String greeting = language.getGreeting();

       System.out.println("Greeting: " + greeting);
   }

}

@Repository ist eine Annotation für das Kommentar auf einer Klasse um Spring zu sagen, dass die Klasse ein Spring BEAN ist.

MyRepository.java

package org.o7planning.spring.bean;

import java.util.Date;

import org.springframework.stereotype.Repository;

@Repository
public class MyRepository {

    public String getAppName() {
        return "Hello Spring App";
    }

    public Date getSystemDateTime() {
        return new Date();
    }
    
    
}

@Component ist eine Annotation. Sie wird auf einer Klasse um Spring zu informieren, dass die Klasse ein Spring BEAN ist.

@Autowired wird auf einem Feld (field) kommentiert um Spring zu informieren: die Wert in dem Feld einkoppeln (inject)

MyComponent

package org.o7planning.spring.bean;

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

@Component
public class MyComponent {
   
    @Autowired
    private MyRepository repository;

    public void showAppInfo() {
        System.out.println("Now is: "+ repository.getSystemDateTime());
        System.out.println("App Name: "+ repository.getAppName());
    }

}

Es gibt kein Unterschied über die Nutzung von @Service, @Component und @Repository, Sie sollen in die entsprechenden Fallen benutzen

6. Spring @Configuration & IoC

@Configuration ist eine Annotation, die auf einer Klasse kommentiert. Die Klasse definiert Spring BEAN.

@ComponentScan - sagt Spring die package um die anderen Spring BEAN zu suchen. Spring scannt (scan) die Package zur Suche

AppConfiguration.java

package org.o7planning.spring.config;

import org.o7planning.spring.lang.Language;
import org.o7planning.spring.lang.impl.Vietnamese;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan({"org.o7planning.spring.bean"})
public class AppConfiguration {

    @Bean(name ="language")
    public Language getLanguage() {

        return new Vietnamese();
    }
     
}

Erstellte Spring BEAN werden im Spring IoC Container verwaltet.

7. Spring ApplicationContext

MainProgram.java

package org.o7planning.spring;

import org.o7planning.spring.bean.GreetingService;
import org.o7planning.spring.bean.MyComponent;
import org.o7planning.spring.config.AppConfiguration;
import org.o7planning.spring.lang.Language;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainProgram {

   public static void main(String[] args) {

       // Creating a Context Application object by reading
       // the configuration of the 'AppConfiguration' class.
       ApplicationContext context = new AnnotationConfigApplicationContext(AppConfiguration.class);

       System.out.println("----------");
       Language language = (Language) context.getBean("language");
     
       System.out.println("Bean Language: "+ language);
       System.out.println("Call language.sayBye(): "+ language.getBye());
     
       System.out.println("----------");
     
       GreetingService service = (GreetingService) context.getBean("greetingService");
 

       service.sayGreeting();
 
       System.out.println("----------");
     
       MyComponent myComponent = (MyComponent) context.getBean("myComponent");
     
       myComponent.showAppInfo();
     
   }
 
}

Die Klasse MainProgram laufen

Das Ergebnis

8. Der Operationsgrundsatz vom Spring

Sie erstellen ein Objekt ApplicationContext durch das Lesen der Konfiguration in der Klasse AppConfiguration, es ist wie die folgende Code.

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfiguration.class);

Spring erstellt Spring BEAN nach der Definition in der Klasse AppConfiguration, (beachten Sie: die Klasse AppConfiguration wird durch @Configuration kommentiert).

Zunächst sucht Spring in die Package "org.o7planning.spring.bean" zur Erstellung von anderen Spring BEAN, (Das Objekt erstellen aus der Klasse, die durch @Service, @Component oder @Repository kommentiert werden).

Jetzt wird Spring BEAN erstellt und im Spring IoC enthaltet. Die Felder vom Spring BEAN, die durch @Autowired kommentiert werden, werden die Wert eingekoppelt, wie das folgende Beispiel

Die Frage "Was ist IoC?" rückkehren.
Nach dem traditionellen Weg wird ein Objekt aus einer Klasse erstellt. Seine Felder werden die Werte in der internen Klasse zugewiesen. Umgekehrt werden die Objekt im Spring erstellt und einige Felder von ihm werden die Wert von außen eingekoppelt. das wird als IoC genannt.

- IoC ist die Abkürzung von "Inversion of Control"
- IoC Container ist der Enthalter von aller in die Applikation benutzten Spring BEAN

9. Die Web-Applikation durch Spring Boot programmieren

Zunächst können Sie die Programmierung der Website-Applikation mit Spring Boot studieren

Die Anleitung zum Spring Boot für den Anfänger

10. Der Anhang: die Bibliothek String herunterladen

Sie können Spring in der Addresse von ... herunterladen

https://maven.springframework.org/release/org/springframework/spring/

Diskomprimieren Sie die heruntergeladeten Zip-File in einem Verzeichnis in der Festplatte