Überblick

Dieses Mal werde ich zusammenfassen, wie Spring DI mit Java bzw. Kotlin geschrieben wird. Die Umgebung ist Java 1.8, Kotlin 1.2.31, Spring Boot 2.0.0.RELEASE, Spring 5.0.3.RELEASE.

Über DI im Frühjahr

Ich werde die ausführliche Erklärung zu DI weglassen. Wenn Sie mehr wissen möchten, gehen Sie zu Spring Official Reference. Lesen Sie bitte.

Im Frühjahr gibt es zwei Haupttypen von DI: "** Setter-Einspritzung " und " Konstruktor-Einspritzung **". Wenn Sie online suchen, finden Sie das Wort "Feldinjektion", aber es ist ein Begriff, der nicht in der offiziellen Referenz erscheint. Zur Erläuterung wird in diesem Artikel auch der Begriff Feldinjektion verwendet, der jedoch im Wesentlichen mit der Setter-Injektion identisch ist. Das Spring-Team empfiehlt außerdem die Konstruktorinjektion, da dadurch sichergestellt werden kann, dass das abhängige Objekt nicht null oder unveränderlich ist. Andererseits sollte die Setter-Injektion für begrenzte Zwecke verwendet werden, z. B. zum Zurücksetzen von Abhängigkeiten.

Im Folgenden wird zusammengefasst, wie diese "Feldinjektion", "Setterinjektion" und "Konstruktorinjektion" in Java und Kotlin geschrieben werden.

Field Injection Lassen Sie uns zunächst über Field Injection in Java sprechen. Die Feldinjektion wird durch Schreiben wie ↓ ausgedrückt.

@Component
class SampleComponent{

  @Autowired
  public HogeService hogeService;

  @Autowired
  public FugaService fugaService;

  public void hogehoge(){
    hogeService.hoge();
  }

  public void fugafuga(){
    fugaService.fuga();
  }
}

Als nächstes schreiben Sie in Kotlin als ↓.

@Component
class SampleComponent{
  @Autowired
  lateinit var hogeService: HogeService
  
  @Autowired
  lateinit var fugaService: FugaService

  /*Die folgenden Methoden werden weggelassen*/
}

Kotlin-Feldvariablen müssen zum Zeitpunkt der Deklaration initialisiert werden. Wenn Sie also DI angeben, müssen Sie explizit angeben, dass es sich um eine verzögerte Initialisierung mit dem Modifikator lateinit handelt. Außerdem wird in Field Injection der Wert später zugewiesen, sodass eine Variablendeklaration mit val nicht möglich ist.

Setter Injection Wenn Sie als nächstes die Setter-Injection in Java schreiben, ist dies Code wie ↓.

@Component
class SampleComponent{
 
  private HogeService hogeService;
  
  private FugaService fugaService;

  @Autowired
  public void setHoge(HogeService hogeService){
    this.hogeService = hogeService;
  }

  @Autowired
  public void setFuga(FugaService fugaService){
    this.fugaService = fugaService;
  }

  /*Die folgenden Methoden werden weggelassen*/
}

Wenn Sie eine Setter-Injektion in Kotlin schreiben, erhalten Sie ebenfalls Code wie ↓.

@Component
class SampleComponent{

  private var hogeService: HogeService? = null
    @Autowired
    set(hogeService){
      this.hogeService = hogeService
    }

  private var fugaService: FugaService? = null
    @Autowired
    set(fugaService){
      this.fugaService = fugaService
    }

  /*Die folgenden Methoden werden weggelassen*/

/*Sie können auch wie ↓ schreiben
  private lateinit var hogeService: HogeService
  
  private lateinit var fugaService: FugaService
  
  @Autowired
  fun setHogeService(hogeService: HogeService){
    this.hogeService = hogeService
  }

  @Autowired
  fun setFugaService(fugaService: FugaService){
    this.fugaService = fugaService
  }
*/
}

In kotlin wird automatisch ein Getter generiert, wenn ein Feld mit val deklariert wird, und ein Getter und ein Setter werden automatisch generiert, wenn ein Feld mit var deklariert wird. Daher wird die Variable wie die Feldinjektion mit var deklariert. Da außerdem die Verarbeitung des Setters angepasst werden muss, muss set () wie im obigen Code gezeigt geschrieben werden. Sie können es auch ähnlich wie Java schreiben, wie ich es in den Kommentaren geschrieben habe.

Constructor Injection Wenn Sie schließlich Constructor Injection in Java schreiben, sieht der Code wie folgt aus: ↓.

@Component 
class SampleComponent{

  private final HogeService hogeService;

  private final FugaService fugaService;

  @Autowired
  SampleComponent(HogeService hogeService, FugaService fugaService){
    this.hogeService = hogeService;
    this.fugaService = fugaService;
  }

  /*Die folgenden Methoden werden weggelassen*/
}

Wenn Sie nur einen Konstruktor haben, können Sie @Autowired weglassen.

@Component 
class SampleComponent{

  private final HogeService hogeService;

  private final FugaService fugaService;

  //Wenn es nur einen Konstruktor gibt@Autowired kann weggelassen werden
  SampleComponent(HogeService hogeService, FugaService fugaService){
    this.hogeService = hogeService;
    this.fugaService = fugaService;
  }
  /*Die folgenden Methoden werden weggelassen*/
}

Wenn Sie Lombok verwenden, um automatisch einen Konstruktor zu generieren, können Sie außerdem die Konstruktorinjektion ausdrücken, ohne den Konstruktor zu deklarieren.

@Component 
@AllArgsConstructor
class SampleComponent{

  private final HogeService hogeService;

  private final FugaService fugaService;

  //Es wird automatisch von Lombok generiert, sodass Sie keinen Konstruktor schreiben müssen.

  /*Die folgenden Methoden werden weggelassen*/
}

Wenn Sie als nächstes die Konstruktorinjektion in Kotlin ausdrücken, ist dies der Code von ↓.

@Component
class SampleComponent(
  private val hogeService: HogeService,
  private val fugaService: FugaService
){
  /*Die folgenden Methoden werden weggelassen*/
}

In Kotlin gibt es eine Syntax namens Primärkonstruktor, und durch Schreiben als ↑ wird der Konstruktor zur Kompilierungszeit automatisch generiert. Auf diese Weise können Sie die Konstruktorinjektion ohne Lombok-Anmerkungen darstellen.

Referenz

https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#using-boot-spring-beans-and-dependency-injection
https://docs.spring.io/spring/docs/5.0.5.RELEASE/spring-framework-reference/core.html#beans-factory-collaborators

Spring Dependency Injection mit Java, Kotlin

Überblick

Über DI im Frühjahr

Referenz