Cette fois, je vais résumer comment écrire une DI pour Spring en utilisant respectivement Java et Kotlin. L'environnement est Java 1.8, Kotlin 1.2.31, Spring Boot 2.0.0.RELEASE, Spring 5.0.3.RELEASE.
Je vais omettre l'explication détaillée sur DI. Si vous voulez en savoir plus, rendez-vous sur Spring Official Reference Lisez s'il vous plaît.
Il existe deux principaux types de DI dans Spring: "** Injection Setter " et " Injection Constructor **". Le mot «Injection de champ» apparaît lorsque vous effectuez une recherche en ligne, mais c'est un terme qui n'apparaît pas dans la référence officielle. Dans un souci d'explication, cet article utilise également le terme injection de champ, mais il est essentiellement identique à l'injection de Setter. L'équipe Spring recommande également l'injection de constructeur car elle peut garantir que l'objet dépendant est non nul ou immuable. D'autre part, l'injection de Setter doit être utilisée à des fins limitées telles que la réinitialisation des dépendances.
Dans ce qui suit, nous résumerons comment écrire chacune de ces «injection de champ», «injection de Setter» et «injection de constructeur» en Java et Kotlin.
Field Injection Parlons d'abord de Field Injection en Java. L'injection de champ est exprimée en écrivant comme ↓.
@Component
class SampleComponent{
@Autowired
public HogeService hogeService;
@Autowired
public FugaService fugaService;
public void hogehoge(){
hogeService.hoge();
}
public void fugafuga(){
fugaService.fuga();
}
}
Ensuite, dans Kotlin, écrivez comme ↓.
@Component
class SampleComponent{
@Autowired
lateinit var hogeService: HogeService
@Autowired
lateinit var fugaService: FugaService
/*Les méthodes suivantes sont omises*/
}
Les variables de champ Kotlin doivent être initialisées au moment de la déclaration, donc lorsque DI vous devez indiquer explicitement qu'il s'agit d'une initialisation paresseuse avec le modificateur lateinit. En outre, dans l'injection de champ, la valeur est affectée ultérieurement, de sorte que la déclaration de variable à l'aide de val n'est pas possible.
Setter Injection Ensuite, si vous écrivez l'injection de setter en java, ce sera du code comme ↓.
@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;
}
/*Les méthodes suivantes sont omises*/
}
De même, si vous écrivez une injection de setter dans Kotlin, vous obtiendrez un code comme ↓.
@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
}
/*Les méthodes suivantes sont omises*/
/*Vous pouvez également écrire comme ↓
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
}
*/
}
Dans kotlin, un getter est automatiquement généré lorsqu'un champ est déclaré avec val, et un getter et un setter sont automatiquement générés lorsqu'un champ est déclaré avec var. Par conséquent, comme l'injection de champ, la variable est déclarée avec var. De plus, puisqu'il est nécessaire de personnaliser le traitement du setter, il est nécessaire d'écrire set () comme indiqué dans le code ci-dessus. Vous pouvez également l'écrire de la même manière que Java, comme je l'ai écrit dans les commentaires.
Constructor Injection Enfin, si vous écrivez une injection de constructeur en Java, le code ressemblera à ↓.
@Component
class SampleComponent{
private final HogeService hogeService;
private final FugaService fugaService;
@Autowired
SampleComponent(HogeService hogeService, FugaService fugaService){
this.hogeService = hogeService;
this.fugaService = fugaService;
}
/*Les méthodes suivantes sont omises*/
}
Si vous n'avez qu'un seul constructeur, vous pouvez omettre @Autowired.
@Component
class SampleComponent{
private final HogeService hogeService;
private final FugaService fugaService;
//S'il n'y a qu'un seul constructeur@Le câblage automatique peut être omis
SampleComponent(HogeService hogeService, FugaService fugaService){
this.hogeService = hogeService;
this.fugaService = fugaService;
}
/*Les méthodes suivantes sont omises*/
}
De plus, si vous utilisez Lombok pour générer automatiquement un constructeur, vous pouvez exprimer l'injection de constructeur sans déclarer le constructeur.
@Component
@AllArgsConstructor
class SampleComponent{
private final HogeService hogeService;
private final FugaService fugaService;
//Il est automatiquement généré par Lombok, vous n'avez donc pas besoin d'écrire un constructeur.
/*Les méthodes suivantes sont omises*/
}
Ensuite, si vous exprimez l'injection de constructeur dans Kotlin, ce sera le code de ↓.
@Component
class SampleComponent(
private val hogeService: HogeService,
private val fugaService: FugaService
){
/*Les méthodes suivantes sont omises*/
}
Dans Kotlin, il existe une syntaxe appelée constructeur primaire, et en écrivant comme ↑, le constructeur est automatiquement généré au moment de la compilation. Cela vous permet de représenter l'injection de constructeur sans annotations Lombok.
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
Recommended Posts