Die Anleitung zum Sping für den Anfänger

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.
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.
  1. 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.
  2. DAO, ORM, AOP, WEB: Die Module sind Tool oder Framework, die im Spring intergriert werden.

2.1- 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 Injection in HelloWorldService. 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

10- Der Anhang: die Bibliothek String herunterladen

Sie können Spring in der Addresse von ... herunterladen
Diskomprimieren Sie die heruntergeladeten Zip-File in einem Verzeichnis in der Festplatte