Wat is een Spring Bean?

1. Overzicht

Bean is een sleutelconcept van het Spring Framework. Als zodanig is het begrijpen van deze notie cruciaal om het raamwerk onder de knie te krijgen en op een effectieve manier te gebruiken.

Helaas, er zijn geen duidelijke antwoorden op een simpele vraag - wat een springboon werkelijk is. Sommige verklaringen gaan zo laag dat een groot beeld wordt gemist, terwijl andere te vaag zijn.

Deze tutorial zal proberen licht te werpen op het onderwerp, te beginnen met een beschrijving in de officiële documentatie.

2. Bean-definitie

Hier is een definitie van bonen in de Spring Framework-documentatie:

In Spring worden de objecten die de ruggengraat vormen van uw applicatie en die worden beheerd door de Spring IoC-container bonen genoemd. Een boon is een object dat wordt geïnstantieerd, geassembleerd en anderszins wordt beheerd door een Spring IoC-container.

Deze definitie is beknopt en komt ter zake, maar mist een belangrijk ding - Spring IoC-container. Laten we door het konijnenhol gaan om te zien wat het is en welke voordelen het met zich meebrengt.

3. Omkering van controle

Simpel gezegd, Inversion of Control, of kortweg IoC, is een proces waarin een object zijn afhankelijkheden definieert zonder ze te creëren. Dit object delegeert de taak om dergelijke afhankelijkheden te construeren naar een IoC-container.

Laten we beginnen met de verklaring van een aantal domeinklassen voordat we in IoC duiken.

3.1. Domein klassen

Stel dat we een klasseverklaring hebben:

openbare klasse Bedrijf {privé adresadres; openbaar bedrijf (adresadres) {this.address = adres; } // getter, setter en andere eigenschappen}

Deze klas heeft een soort medewerker nodig Adres:

openbare klasse Adres {privé Stringstraat; privé int nummer; openbaar adres (String street, int number) {this.street = street; this.number = nummer; } // getters en setters}

3.2. Traditionele aanpak

Normaal gesproken maken we objecten met de constructors van hun klassen:

Adresadres = nieuw adres ("Hoofdstraat", 1000); Bedrijf bedrijf = nieuw bedrijf (adres);

Er is niets mis met deze aanpak, maar zou het niet leuk zijn om de afhankelijkheden beter te beheren?

Stel je een applicatie voor met tientallen of zelfs honderden klassen. Soms willen we een enkele instantie van een klasse over de hele applicatie delen, soms hebben we een apart object nodig voor elk gebruik, enzovoort.

Het beheren van zoveel objecten is ronduit een nachtmerrie. Dit is waar Inversion of Control te hulp komt.

In plaats van zelf afhankelijkheden te construeren, kan een object zijn afhankelijkheden ophalen uit een IoC-container. Het enige dat we hoeven te doen, is de container voorzien van de juiste configuratiemetagegevens.

3.3. Bean-configuratie

Laten we eerst de Bedrijf klasse met de @Component annotatie:

@Component public class Company {// this body is the same as before}

Hier is een configuratieklasse die bean-metagegevens levert aan een IoC-container:

@Configuration @ComponentScan (basePackageClasses = Company.class) public class Config {@Bean public Address getAddress () {retourneer nieuw adres ("High Street", 1000); }}

De configuratieklasse produceert een soort boon Adres. Het draagt ​​ook de @BuienRadarNL annotatie, die de container instrueert om te zoeken naar bonen in het pakket met de Bedrijf klasse.

Wanneer een Spring IoC-container objecten van die typen construeert, worden alle objecten Spring Beans genoemd omdat ze worden beheerd door de IoC-container.

3.4. IoC in actie

Omdat we bonen in een configuratieklasse hebben gedefinieerd, we hebben een instantie nodig van de AnnotationConfigApplicationContext klasse om een ​​container op te bouwen:

ApplicationContext context = nieuwe AnnotationConfigApplicationContext (Config.class);

Een snelle test verifieert zowel het bestaan ​​als de eigendomswaarden van onze bonen:

Bedrijf company = context.getBean ("bedrijf", Company.class); assertEquals ("Hoofdstraat", company.getAddress (). getStreet ()); assertEquals (1000, company.getAddress (). getNumber ());

Het resultaat bewijst dat de IoC-container bonen correct heeft gemaakt en geïnitialiseerd.

4. Conclusie

Deze tutorial gaf een korte beschrijving van Spring beans en hun relatie met een IoC-container.

De volledige broncode voor deze tutorial is te vinden op GitHub.