Constructor-injectie in het voorjaar met Lombok

1. Inleiding

Lombok is een uiterst nuttige bibliotheek die standaardcode overwint. Als je er nog niet bekend mee bent, raad ik je ten zeerste aan om de vorige tutorial te bekijken - Inleiding tot Project Lombok.

In dit artikel demonstreren we de bruikbaarheid ervan in combinatie met Spring's Op constructeurs gebaseerde afhankelijkheidsinjectie.

2. Op constructeurs gebaseerde afhankelijkheidsinjectie

Een goede manier om afhankelijkheden in het voorjaar te bedraden met constructor-gebaseerde afhankelijkheidsinjectie. Deze benadering dwingt ons om de afhankelijkheden van componenten expliciet door te geven aan een constructor.

In tegenstelling tot Veldgebaseerde afhankelijkheidsinjectie, het biedt ook een aantal voordelen:

  • het is niet nodig om een ​​testspecifieke configuratiecomponent te maken - afhankelijkheden worden expliciet in een constructor geïnjecteerd
  • consistent ontwerp - alle vereiste afhankelijkheden worden benadrukt en verzorgd door de definitie van de constructeur
  • eenvoudige eenheidstests - verminderde overhead van Spring Framework
  • teruggewonnen vrijheid van gebruik laatste trefwoorden

Vanwege de noodzaak om een ​​constructor te schrijven, leidt dit echter tot een aanzienlijk grotere codebasis. Beschouw de twee voorbeelden van GroetService en Afscheid Service:

@Component public class GreetingService {@Autowired privé vertaler vertaler; public String produce () {return translator.translate ("hallo"); }}
@Component openbare klasse FarewellService {privé-eindvertaler vertaler; openbare FarewellService (vertaler vertaler) {this.translator = vertaler; } public String produce () {return translator.translate ("bye"); }}

In principe doen beide componenten hetzelfde: ze noemen een configureerbaar Vertaler met een taakspecifiek woord.

De tweede variant is echter veel meer versluierd vanwege de standaardplaat van de constructeur die niet echt enige waarde toevoegt aan de code.

In de nieuwste Spring-release hoeft de constructor niet te worden geannoteerd @Autowired annotatie.

3. Constructorinjectie met Lombok

Met Lombok, is het mogelijk om een ​​constructor te genereren voor alle velden van de klasse (met @AllArgsConstructor) of allemaal laatste class velden (met @BuienRadarNL). Bovendien, als u nog steeds een lege constructor nodig heeft, kunt u een extra @NoArgsConstructor annotatie.

Laten we een derde component maken, analoog aan de vorige twee:

@Component @RequiredArgsConstructor openbare klas ThankingService {privé uiteindelijke vertaler vertaler; public String produce () {return translator.translate ("dank u"); }}

De bovenstaande annotatie zal leiden tot Lombok om een ​​constructor voor ons te genereren:

@Component openbare klas ThankingService {privé finale Vertaler vertaler; public String thank () {return translator.translate ("bedankt"); } / * Gegenereerd door Lombok * / public ThankingService (vertaler vertaler) {this.translator = vertaler; }}

4. Meerdere constructeurs

Een constructor hoeft niet te worden geannoteerd zolang er maar één in een component zit en Spring kan deze ondubbelzinnig kiezen als de juiste om een ​​nieuw object te instantiëren. Zodra er meer zijn, moet u ook de annotatie toevoegen die door de IoC-container moet worden gebruikt.

Houd rekening met de ExcusesService voorbeeld:

@Component @RequiredArgsConstructor openbare klasse ApologizeService {privé uiteindelijke vertaler vertaler; privé laatste String-bericht; @Autowired openbare ApologizeService (vertaler vertaler) {this (vertaler, "sorry"); } public String produce () {return translator.translate (bericht); }}

De bovenstaande component is optioneel configureerbaar met de bericht veld dat niet kan veranderen nadat de component is gemaakt (vandaar het ontbreken van een setter). Het vereiste dus dat we twee constructors moesten leveren: de ene met volledige configuratie en de andere met een impliciete standaardwaarde van de bericht.

Tenzij een van de constructeurs met een van beide is geannoteerd @Autowired, @Injecteren of @Resource, Spring zal een foutmelding geven:

Kan niet instantiëren [...]: geen standaardconstructor gevonden;

Als we het Lombokgegenereerde constructor, zouden we de annotatie moeten doorgeven met een onConstructor parameter van de @AllArgsConstructor:

@Component @RequiredArgsConstructor (onConstructor = @__ (@ Autowired)) openbare klasse ApologizeService {// ...}

De onConstructor parameter accepteert een reeks annotaties (of een enkele annotatie zoals in dit specifieke voorbeeld) die op een gegenereerde constructor moeten worden geplaatst. Het idioom met dubbele onderstreping is geïntroduceerd vanwege de achterwaartse compatibiliteitsproblemen. Volgens de documentatie:

De reden van de rare syntaxis is om deze functie te laten werken in javac 7-compilers; de @__ type is een annotatieverwijzing naar het annotatietype __ (dubbele onderstreping) die niet echt bestaat; dit zorgt ervoor dat javac 7 het compilatieproces vertraagt ​​vanwege een fout, omdat het mogelijk is dat een annotatieprocessor later de __ type.

5. Samenvatting

In deze tutorial hebben we laten zien dat het niet nodig is om op het veld gebaseerde DI te verkiezen boven op constructeurs gebaseerde DI in termen van verhoogde boilerplate-code.

Dankzij Lombok is het mogelijk om het genereren van gemeenschappelijke code te automatiseren zonder dat dit invloed heeft op de prestaties van de runtime, door lange, onduidelijke code af te korten tot het gebruik van een annotatie met één regel.

De code die tijdens de tutorial wordt gebruikt, is beschikbaar op GitHub.


$config[zx-auto] not found$config[zx-overlay] not found