Projet de création de framework Java Spring et analyse d'exemples de stockage et de lecture de Bean

1.Création du projet Spring

1.1 Créer un projet Maven

La première étape consiste à créer un projet Maven Spring est également basé sur Maven.

1.2 Ajouter une dépendance Spring

La deuxième étape consiste à ajouter le support Spring (spring-context, spring-beans) au projet Maven

Ajoutez le pom.xml Dépendances des fichiers. pom.xml文件添加依赖项。

<dependencies>
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

刷新等待加载完成。

1.3创建启动类

第三步，创建启动类与main，用来做简单的测试

在java目录创建类，写代码即可，因为这里只演示怎么创建Spring项目和介绍Spring的简单使用，就不依赖那些Tomcat什么的了，直接写一个Main类更直观。

1.4配置国内源

由于国外源不稳定，可能第二步引入spring依赖会失败，所以下面介绍如何配置国内镜像源。

现成的settings.xml文件链接：

地址1

地址2：提取码: 9thv

如果你已经有了settings文件，但没有配置mirror，配置内容如下：

<mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>        
      </mirror>

2.储存或读取Bean对象

2.1添加spring配置文件

添加spring配置文件（首次才需要，非首次可忽略此步骤）

右键resources目录，新建一个.xml配置文件，文件名推荐spring.xml或者spring-config.xml。

创建一个spring.xml配置文件，配置内容：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

2.2创建Bean对象

第一步，创建Bean对象。

比如我们要注入一个User对象，就先的创建一个User类。

package com.bean;
public class User {
    public void sayHi(String name) {
        System.out.println("你好!" + name);
    }
}

将Bean通过配置文件，注入到spring中，即在spring配置文件中通过以下语句注入。

<bean id="user" class="com.bean.User"></bean>

spring中对象的储存是通过键值对来存储的，其中key为id，value为class。

命名规范：id使用小驼峰命名，如userid，class使用大驼峰命名，如userId。

2.3读取Bean对象

想要从spring中将Bean对象读取出来，先要得到spring上下文对象，相当于得到了spring。再通过spring上下文对象提供的方法获取需要使用的Bean对象。最后就能使用Bean对象了。

import com.bean.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
    public static void main(String[] args) {
        //1.得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        //2.获取bean对象，此处是根据id获取
        User user = (User) context.getBean("user");
        //3.使用bean
        user.sayHi("zhangsan");
    }
}

运行结果：

你好!zhangsan

Process finished with exit code 0

还可以使用Bean工厂(旧)来获取Bean。

import com.bean.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class Main2 {
    public static void main(String[] args) {
        //1.得到Bean工厂
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring.xml"));
        //2.获取Bean
        User user = (User) factory.getBean("user");
        //3.使用
        user.sayHi("李四");
    }
}

虽然Bean工厂XmlBeanFactory类现在已经废弃了，但是目还能使用的，当然创建Bean工厂有新的方式，但老的方式比较直观，因此演示采用老的方式创建。

运行结果：

你好!李四

Process finished with exit code 0

发现ApplicationContext与BeanFactory都可以从容器中获取Bean，都提供了getBean方法，那问题来了，ApplicationContext与BeanFactory有什么区别？

相同点：都可以从容器中获取Bean，都提供了getBean方法。

不同点：

• BeanFactory是ApplicationContext的父类， BeanFactory只提供了基础访问Bean对象的功能，而ApplicationContext除了拥有 BeanFactory的全部功能，还有其他额外功能的实现，如国际化，资源访问等功能实现。

• 从性能方面来说是不同的， BeanFactory按需加载Bean，属于懒汉方式，ApplicationContext是饿汉方式，在创建时会将所有的Bean

  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  public class Main3 {
      public static void main(String[] args) {
          //1.得到上下文对象
          ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
      }
  }

  Actualisez et attendez la fin du chargement.

1.3 Créer la classe de démarrage🎜🎜La troisième étape consiste à créer la classe de démarrage et la classe principale pour des tests simples🎜🎜Créez la classe dans le répertoire Java et écrivez le code, car ici nous montrons uniquement comment créer un projet Spring et introduire Spring Il est simple à utiliser et ne repose pas sur Tomcat ou quoi que ce soit d'autre. Il est plus intuitif d'écrire directement une classe Main. 🎜🎜🎜 🎜1.4 Configuration des sources nationales🎜🎜En raison de l'instabilité des sources étrangères, la deuxième étape d'introduction des dépendances Spring peut échouer, c'est pourquoi ce qui suit décrit comment configurer les sources miroir nationales. 🎜🎜🎜 🎜🎜🎜 Lien du fichier settings.xml prêt à l'emploi : 🎜🎜Adresse 1🎜🎜Adresse 2 : Code d'extraction : 9thv🎜🎜Si vous disposez déjà d'un fichier de paramètres, mais ne configurez pas le miroir, le contenu de la configuration est le suivant suit：🎜

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
public class Main4 {
    public static void main(String[] args) {
        //1.得到Bean工厂
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring.xml"));
    }
}

🎜2. Stocker ou lire des objets Bean🎜🎜2.1 Ajouter un fichier de configuration Spring🎜🎜Ajouter un fichier de configuration Spring (obligatoire uniquement pour la première fois, vous pouvez ignorer cette étape si ce n'est pas la première fois)🎜🎜D'accord- cliquez sur le répertoire des ressources et créez un nouveau fichier de configuration .xml , le nom de fichier recommandé est spring.xml ou spring-config.xml. 🎜🎜🎜 🎜Créez un fichier de configuration spring.xml, contenu de configuration : 🎜

User user = (User) context.getBean("user");

🎜2.2 Créer un objet Bean🎜🎜La première étape consiste à créer un objet Bean. 🎜🎜Par exemple, si nous voulons injecter un objet User, nous créons d'abord une classe User. 🎜

User user = (User) context.getBean(User.class);

🎜Injectez Bean dans Spring via le fichier de configuration, c'est-à-dire injectez-le via l'instruction suivante dans le fichier de configuration Spring. 🎜

User user = context.getBean("user", User.class);

🎜Les objets au printemps sont stockés via des paires clé-valeur, où key est id et value est class . 🎜🎜Convention de dénomination : id est nommé en petite casse chameau, comme userid, et class est nommé en grande casse chameau, comme IDutilisateur . 🎜🎜2.3 Lecture de l'objet Bean🎜🎜Si vous souhaitez lire l'objet Bean à partir de Spring, vous devez d'abord obtenir l'objet de contexte Spring, ce qui équivaut à obtenir Spring. Obtenez ensuite l'objet Bean que vous devez utiliser via la méthode fournie par l'objet de contexte Spring. Enfin, vous pouvez utiliser l'objet Bean. 🎜rrreee🎜Résultats d'exécution :🎜

🎜Bonjour zhangsan🎜🎜Processus terminé avec le code de sortie 0🎜

🎜Vous pouvez également utiliser l'usine Bean (ancienne) pour obtenir le Bean. 🎜rrreee🎜Bien que la Bean Factory 🎜🎜Résultats d'exécution :🎜

🎜Bonjour Li Si🎜🎜Processus terminé avec le code de sortie 0🎜

🎜 J'ai constaté que ApplicationContext et BeanFactory peuvent être accessible depuis Pour obtenir Bean dans le conteneur, la méthode getBean est fournie. La question se pose alors de savoir quelle est la différence entre ApplicationContext et BeanFactory ? 🎜🎜Le même point : les deux peuvent obtenir du <code>Bean à partir du conteneur, et tous deux fournissent la méthode getBean. 🎜🎜Différences : 🎜

• 🎜BeanFactory est la classe parent de ApplicationContext, BeanFactoryFournit uniquement des fonctions de base pour accéder aux objets Bean, tandis que ApplicationContext, en plus d'avoir toutes les fonctions de BeanFactory, a également l'implémentation d'autres des fonctions supplémentaires, telles que l'internationalisation, l'accès aux ressources et d'autres fonctions, sont implémentées. 🎜🎜
• 🎜C'est différent en termes de performances. BeanFactory charge Bean à la demande, ce qui est une manière paresseuse, et ApplicationContext l'est. une méthode affamée, tous les Bean seront chargés une fois créés pour être utilisés. 🎜🎜🎜🎜Preuve :🎜

  我们在bean目录下添加一个Blog类，并完善Blog与User类的构造方法，当类被构造时会发出一些信号，在获取上下文或工厂时根据这些信号让我们感知到它是否会被构造。

  

  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  public class Main3 {
      public static void main(String[] args) {
          //1.得到上下文对象
          ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
      }
  }

  运行结果：

  

  ApplicationContext创建时，会将所有的对象都构造，饿汉的方式。

  import org.springframework.beans.factory.BeanFactory;
  import org.springframework.beans.factory.xml.XmlBeanFactory;
  import org.springframework.core.io.ClassPathResource;
  public class Main4 {
      public static void main(String[] args) {
          //1.得到Bean工厂
          BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring.xml"));
      }
  }

  

  BeanFactory创建时，什么都没有，说明是懒汉的方式。

  ApplicationContext中的多种getBean方法：

  方法1：根据 bean name获取bean。

  User user = (User) context.getBean("user");

  方法2：根据bean type获取bean。

  User user = (User) context.getBean(User.class);

  只有beans中只有一个类的实例没有问题，但是个有多个同类的实例，会有问题，即在spring中注入多个同一个类的对象，就会报错。

  我们来试一试，首先在Spring配置文件，注入多个User对象：

  

  然后我们再通过这种方式来获取对象，我们发现报错了，报错信息如下：

  Exception in thread "main" org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.bean.User' available: expected single matching bean but found 3: user,user1,user2

  抛出了一个NoUniqueBeanDefinitionException异常，表示注入的对象不是唯一的。

  方法3：综合上述两种，可以根据bean name与bean type来获取bean

  相比方法1，更加健壮。

  User user = context.getBean("user", User.class);

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!