Hallo,

Vandaag ga ik het hebben over hoe aan de slag te gaan met Google Guice voor dependency injection in Java. Ten eerste zal ik een aantal concepten over het kader te introduceren, dan zullen we een eenvoudige toepassing te schrijven als voorbeeld.

Dependency Injection

zoals we in dit bericht hebben besproken, is dependency injection (DI) een techniek om afhankelijkheden voor clients te leveren in plaats van dat de laatste Deze expliciet verkrijgt. DI is in principe een manier om een meer algemeen doel te bereiken genaamd dependency inversion principle (DIP), die stelt:

in plaats van afhankelijk te zijn van implementaties, geeft u de voorkeur aan afhankelijk te zijn van abstracties.

bij het toepassen van DI hebben we een manier nodig om de afhankelijkheden te injecteren (wire, bind) voor de clients die erom vragen, we kunnen dit handmatig doen bij het instantiseren van de clientklasse of we kunnen vertrouwen op een raamwerk om deze taken te automatiseren en ook enkele interessante functionaliteiten toevoegen, zoals life-cycle management.

met betrekking tot Java zijn er verschillende frameworks met mogelijk voor-en nadelen, bijvoorbeeld Weld, Spring, Guice etc.

in dit bericht zullen we Guice gebruiken en in een volgend bericht zal ik het hebben over de lente, waarschijnlijk in de context van het ontwerpen van RESTful API ‘ s met Spring Boot en Spring REST.

Google Guice

Google Guice is een raamwerk om afhankelijkheid injectie te automatiseren door het verstrekken van een container waar we abstracties en implementaties in kaart kunnen brengen. Na de toewijzing worden de afhankelijkheden automatisch geïnjecteerd in clients wanneer daarom wordt gevraagd.

de mapping in Guice wordt bereikt door de implementatie van com.google.injecteren.Module die normaal gesproken wordt gedaan door het erven van de abstracte basisklasse com.google.injecteren.AbstractModule.

daarna moeten we de configure methode overschrijven en vertrouwen op een vloeiende API door bind aan te roepen en op methoden om de toewijzing tussen de abstractie (parameter van bind) en implementatie (parameter van to) te definiëren.

dan kunnen we de afhankelijkheden injecteren door uw afhankelijkheden te annoteren met com.google.injecteren.Injecteren.

ten slotte moeten we een com verkrijgen.google.injecteren.Injector uit onze eerder gedefinieerde module, dus we zijn nu in staat om de client op te halen met de getInstance methode en de afhankelijkheden worden automatisch geïnjecteerd.

voorbeeld

Dit voorbeeld bestaat uit een deel van een Java-systeem dat loginformatie verzendt over de werking ervan. Om de opname van Guice in ons project te vereenvoudigen, gaan we Maven gebruiken als een build tool.

In de pom.xml, voeg het volgende artefact toe voor Guice bij Versie 4.0 in de afhankelijkheden sectie:

<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version></versie>
</afhankelijkheid>

Laten we het maken van de interface LogSender te vertegenwoordigen op het gedrag: “stuurt de logboek een aantal medium”:

Deze dienst gebruikt zal worden door de Warmtewisselaar klasse met een verwijzing naar LogSender en de injectie zal worden gedaan door de constructor geannoteerd met @Injecteren:

De uitvoering StdoutLogSender sturen van de log naar de standaard output stroom, in dit geval de console:

Nu moeten we vertellen Guice hoe om de kaart LogSender te StdoutLogSender, en we doen het door de LoggingModule klasse:

tot slot, in de hoofdklasse Toepassing, creëren we een Injector en doorgeven onze LoggingModule aan de constructor. Dan zijn we in staat om een instantie van Exchanger te krijgen die afhankelijk is van LogSender bound:

conclusie

In dit artikel hebben we de basisprincipes besproken met betrekking tot hoe aan de slag te gaan met Google Guice voor het automatiseren van dependency injection taken in Java applicatie. We schreven een eenvoudige applicatie om te illustreren hoe de mapping tussen abstracties en implementaties te definiëren en hoe ze te injecteren in onze klanten.

Ik hoop dat u met dit basisoverzicht van Guice uw onderzoek naar dependency injection kunt voortzetten en hoe u code kunt ontwikkelen met een lager niveau van koppeling en een hoog niveau van cohesie.