Je vous salue, Habr!
Cet article sera utile à ceux qui ont déjà commencé à apprendre Java et ont même réussi à comprendre Java Core, et maintenant j'ai entendu le mot Spring. Et peut-être même pas une seule fois: la connaissance du cadre de printemps, au moins, apparaît dans les descriptions de nombreux postes vacants pour les javistes. Cet article vous aidera à franchir la toute première étape: comprendre l'idée générale d'un tel cadre populaire.
Commençons de loin. Il y a une chose telle que l'inversion de contrôle, en russe - l'inversion de contrôle, sous forme abrégée - IoC. L'IoC est l'un des principes qui rapproche notre code du relâchement. L'IoC est la délégation d'une partie de nos responsabilités à une composante externe.
Il existe différentes implémentations de l'approche IoC, nous nous intéressons à l'une d'entre elles - l'injection de dépendance, l'injection de dépendance. Qu'est-ce que c'est, le nom parle de lui-même, donc je vais essayer de le divulguer en utilisant un exemple. Nous écrivons une application qui automatise le fonctionnement d'une chaîne de magasins. Il existe des classes Shop (store) et Seller (seller). La classe Seller possède un champ de type Shop - le magasin dans lequel le vendeur travaille. Nous sommes donc confrontés à une dépendance: le vendeur dépend de la boutique. Réfléchissons maintenant à la façon dont l'objet Shop entre dans l'objet Seller? Il y a des options:
- Mettez-le en œuvre via le designer et indiquez immédiatement, lors de la création du vendeur, le magasin dans lequel il travaille:
public class Seller { private Shop shop; public Seller(Shop shop) { this.shop = shop; } }
- Créez un setter et, à l'aide de son appel, définissez la boutique du vendeur:
public class Seller { private Shop shop; public void setShop(Shop shop) { this.shop = shop; } }
Les deux méthodes répertoriées sont la mise en œuvre de l'injection de dépendance. Et enfin, nous sommes arrivés au printemps: il fournit une autre façon d'injecter des dépendances.
De manière générale, Spring est une très large gamme de bibliothèques pour de nombreuses occasions. Il existe Spring MVC pour créer rapidement des applications Web, Spring Security pour implémenter l'autorisation dans l'application et Spring Data pour travailler avec des bases de données et bien plus encore. Mais Spring IoC est autonome - c'est le type de ressort de base qui met en œuvre le sujet que nous étudions - l'injection de dépendance. Spring IoC mérite l'attention au tout début de l'étude des bibliothèques Spring pour une autre raison. Comme vous le verrez dans le processus de travail pratique avec d'autres types de ressorts, pour tous les autres ressorts Spring IoC est utilisé comme cadre.
Nous commencerons notre introduction à Spring IoC par le terme principal: bean. Dans les mots les plus simples
Un bean est un objet de classe créé par Spring qui peut être incorporé en tant que valeur de champ dans un autre objet.
Voulez-vous des mots plus compliqués? Et s'il vous plaît:
Un bean est un objet de classe, qui est un élément de programme complet avec une fonction métier spécifique ou une fonction Spring interne, dont le cycle de vie est contrôlé par le conteneur bin.
Comme vous l'avez déjà compris, pour que Shop puisse implémenter Shop, Shop doit devenir un bac. Il existe plusieurs façons de dire à l'application quels objets ont le droit d'être appelés beans, qui nous conduisent tous au concept d'ApplicationContext.
ApplicationContext est le cœur du printemps. En règle générale, il est créé au tout début de l'application ("monte") et contrôle le cycle de vie des beans. Par conséquent, il est également appelé conteneur bin.
Nous arrivons à l'essentiel. Comment devons-nous réécrire nos classes pour que Spring IoC et son serviteur ApplicationContext remplacent le champ Shop par l'objet Seller? Comme ça:
@Component public class Shop { }
@Component public class Seller { @Autowired private Shop shop; }
C'est simple? Beaucoup plus facile! Élégant? Tout à fait. Voici ce qui s'est passé: l'annotation Component a indiqué à Spring que la classe qu'elle avait annotée était un bac. Annotation Autowired a demandé à Spring de substituer une valeur dans le champ qu'il annote. Cette opération est appelée injection. Quelle valeur exacte sera substituée? Plus à ce sujet plus tard, nous verrons d'abord comment les classes deviennent bin en général.
Nous savons déjà qu'au début de l'application, le gardien de tous les beans ApplicationContext doit se lever. Il crée tous les bacs à la fois. Presque tout. Le fait est que par défaut, tout bean a la portée de la propriété intraspring dans la valeur singleton. Intraspringovoe, car au sens littéral du mot, il n'est pas un singleton. Il s'agit du singleton du printemps: lorsque le contexte est levé, Spring crée exactement un objet bin à partir de la classe spécifiée. Si vous voulez changer ce comportement - s'il vous plaît, Spring vous permet de contrôler l'heure de création du bean et leur nombre pour une classe, mais ce n'est plus le cas.
Ainsi, lorsque vous augmentez ApplicationContext, tous les bacs sont créés. Voyons exactement où se trouve le contexte et, surtout, comment il détermine les classes à partir desquelles créer des bacs. Il existe plusieurs options, pour plus de simplicité, nous parlerons de l'une d'entre elles: la configuration à l'aide du fichier xml. En voici un exemple:
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:beans="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <bean id="product" class="main.java.Product"></bean> <context:component-scan base-package="main"/> </beans>
Ce fichier montre comment créer des beans de deux manières. La première, disons, est manuelle. Vous voyez, il y a une balise
bean avec une indication de la classe. Ceci est le haricot. À partir de tout ce qui est enregistré dans ce fichier avec une balise de
bean , des
beans seront créés.
La deuxième façon est moins verbeuse. N'oubliez pas, au-dessus des classes, nous mettons l'annotation Component. De toutes les classes annotées avec cette annotation, des beans seront créés. Grâce à cette ligne du fichier xml:
<context:component-scan base-package="main"/>
Elle dit à spring: scannez l'ensemble du package principal et à partir de tout ce sur quoi l'annotation Component (ou d'autres annotations qui sont des composants de Component) se tiendra, créez des bacs. Compact, n'est-ce pas? Nous disons simplement quels packages contiennent les classes à partir desquelles créer les beans et annotons ces classes.
Vous pouvez augmenter le contexte à l'aide du fichier xml avec la ligne de code suivante:
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
où beans.xml est le chemin d'accès au surnom xml décrit ci-dessus.
Avec la création de haricots compris. Comment Spring remplit-il le champ Boutique lors de la création d'un vendeur? Lors de l'élévation du contexte, un objet bin de la classe Shop est créé. Un objet bin de la classe Seller est également créé; il est également annoté par Component. Il a un type de boutique annoté par Autowired. L'annotation câblée indique au printemps: vous devez injecter le bac dans ce champ. Dans notre cas, nous n'avons qu'un seul bac adapté à ce rôle, c'est-à-dire dont le type correspond au type du champ: il s'agit d'un bac - une instance de la classe Shop. Il sera injecté dans l'objet vendeur, selon les besoins. Je comprends que maintenant les questions ont grimpé comme des vers: que se passera-t-il si Spring ne trouve pas le haricot souhaité, ou en trouve plusieurs appropriés (d'autant plus que vous pouvez également injecter via l'interface, et non par classe). Le printemps est intelligent, mais il exige la même chose de notre part. Nous devons soit avoir exactement un bean dans le système qui convient à chaque Autowired, soit former Spring à agir dans de tels conflits (nous n'en parlerons pas maintenant, vous êtes déjà fatigué, attachez, l'article arrive à sa fin).
Notez que le vendeur est également un bac. Si ce n'était pas un bac, mais créé via new, rien n'y serait automatiquement injecté.
Vous vous demandez peut-être maintenant pourquoi toutes ces difficultés sont nécessaires. Mais imaginez que notre application ne soit pas de 2 classes, mais plusieurs ordres de grandeur plus grande et la gestion des dépendances n'est plus la tâche la plus triviale.
Peut-être que maintenant vous pensez à quel point Spring est beau, simple et concis vous permet d'implémenter des dépendances. Mais imaginez que quelque chose s'est mal passé et que vous devez déboguer l'application. Et ce n'est plus si facile ...
Enfin, quelques conseils:
- Si vous avez mis en œuvre le projet et que vous ne savez plus comment obtenir un bac du printemps pour le regarder, procédez comme suit:
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Seller seller = (Seller) context.getBean(Seller.class);
C'est un moyen légal d'obtenir une poubelle, bien que dans les réalités modernes, cela ne soit généralement pas fait. Mais pour une étude de cas, vous pouvez.
- Étant donné que Spring est un framework, vous devez l'inclure dans votre projet. Je crée une application en utilisant maven et j'ajoute des dépendances spring-core et spring-context au fichier pom.xml.
Spring IoC contient d'énormes opportunités pour créer, configurer et injecter des beans. Nous avons examiné une toute petite partie de la pointe de l'iceberg, l'une des façons de travailler avec le printemps, mais j'espère que nous avons pu y jeter un coup d'œil et avoir une idée générale de ce qui se passe.