[JAVA] [Spring boot] J'ai pensé au code testable par DI

introduction

Comment implémenter Spring Framework (boot) sans modifier la classe à injecter en essayant de le rendre "testable code" qui est le mérite de DI? J'y ai pensé, et j'y ai pensé moi-même, alors je voudrais écrire sur son contenu.

supposition

Qu'est-ce que le printemps? Qu'est-ce que DI? Je n'en parlerai pas. Veuillez vous référer à l'explication de ici. J'ai également participé à la session d'étude mentionnée au début, mais c'était une bonne étude.

Ce que je me demandais

Même si vous rendez le code testable, même si vous créez une classe stub à tester car la classe à injecter n'est pas implémentée, vous devez réécrire au moins la partie injectée lorsque cette classe est terminée. Je pensais.

Par exemple, comme ça.

@RestController
public class DemoController {

	@Autowired
	DemoServiceStub demoService;
	//DemoService demoService;	//Changer de commentaire ici pour le test

	@GetMapping("/echo")
	public String echo() {
		return demoService.getMessage();
	}
}

public class DemoService {
	String getMessage(){
		//En cours de mise en œuvre
		return "xxx";
	}
}

public class DemoServiceStub {
	String getMessage(){
		return "foo is stub";
	}
}

Comme je l'ai écrit dans le commentaire, je dois basculer la partie injection entre la classe régulière et la classe stub. Si je ne veux tester qu'une méthode spécifique, je ne pense pas que cela m'affectera, mais je me sens toujours mal à l'aise de jouer avec le terrain.

Alors, voici ce que j'ai pensé et corrigé.

@RestController
public class DemoController {

	@Autowired
	@Qualifier("demoservice")  //Spécifiez le nom de la cible d'injection. Ne basculez pas entre régulier et stub.
	DemoService demoService;

	@GetMapping("/echo")
	public String echo() {
		return demoService.getMessage();
	}
}

//Créer une interface
public interface DemoService {
	String getMessage();
}


@Service(value = "demoserviceWIP")  //Donne lui un nom. Ne le portez pas avec un talon.
public class DemoServiceImpl implements DemoService {
	public String getMessage() {
		//En cours de mise en œuvre
		return "xxx";
	};
}

@Service(value = "demoservice")  //Donne lui un nom
public class DemoServiceImplStub implements DemoService {
	String getMessage(){
		return "foo is stub";
	}
}

Cela élimine le besoin de modifier la source sous test (DemoController dans ce cas) à la fois pour légitime et stub. Je pense que cette méthode est également efficace lorsqu'il y a plusieurs classes que vous souhaitez implémenter dans l'interface. Dans Spring, s'il existe plusieurs types (classes) qui enregistrent des beans, il n'est pas possible de déterminer lequel enregistrer, il semble donc que le nom soit résolu de cette manière. (Au contraire, j'ai l'impression d'avoir un indice pour ce cas grâce à ce mécanisme.)

la revue

• Implémentation utilisant une interface pour rendre les classes régulières et les classes stub communes «Je pense que cela devrait être le minimum en tant que DI en premier lieu. --Donner un alias à la classe injectée (attribut de valeur @ Service) --Résoudre le nom côté injection (@ Qualifier) --Le côté injection n'apporte aucun changement quel que soit l'état de mise en œuvre du côté injection.
• Changez le nom de l'injection sur le côté à injecter

finalement

C'est une méthode qui est à peine sortie même si j'ai googlé. Cela peut être trop évident ou anticonformiste. Dans ce cas, veuillez le signaler.