Java Spring Framework-Erstellungsprojekt und Bean-Speicher- und Lesebeispielanalyse

1.Erstellung eines Spring-Projekts

1.1 Maven-Projekt erstellen

Der erste Schritt besteht darin, ein Maven-Projekt zu erstellen. Spring basiert ebenfalls auf Maven.

1.2 Spring-Abhängigkeit hinzufügen

Der zweite Schritt besteht darin, Spring-Unterstützung (Spring-Context, Spring-Beans) zum Maven-Projekt hinzuzufügen

Fügen Sie die pom.xml hinzu Dateiabhängigkeiten. 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");
      }
  }

  Aktualisieren Sie und warten Sie, bis der Ladevorgang abgeschlossen ist.

1.3 Erstellen Sie die Startup-Klasse🎜🎜Der dritte Schritt besteht darin, die Startup-Klasse und die Hauptklasse für einfache Tests zu erstellen🎜🎜Erstellen Sie die Klasse im Java-Verzeichnis und schreiben Sie den Code, denn hier zeigen wir nur, wie man ein Spring-Projekt erstellt und Spring einführt Es ist einfach zu verwenden und ist nicht auf Tomcat oder irgendetwas anderes angewiesen. Es ist intuitiver, eine Hauptklasse direkt zu schreiben. 🎜🎜🎜 🎜1.4 Konfigurieren inländischer Quellen🎜🎜Aufgrund der Instabilität ausländischer Quellen kann der zweite Schritt der Einführung von Federabhängigkeiten fehlschlagen. Im Folgenden wird daher beschrieben, wie inländische Spiegelquellen konfiguriert werden. 🎜🎜🎜 🎜🎜🎜 Link zur fertigen Datei „settings.xml“: 🎜🎜Adresse 1🎜🎜Adresse 2: Extraktionscode: 9thv🎜🎜Wenn Sie bereits über eine Einstellungsdatei verfügen, aber mirror nicht konfigurieren, lautet der Konfigurationsinhalt wie folgt folgt: 🎜

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. Bean-Objekte speichern oder lesen🎜🎜2.1 Federkonfigurationsdatei hinzufügen🎜🎜Spring-Konfigurationsdatei hinzufügen (nur beim ersten Mal erforderlich, Sie können diesen Schritt ignorieren, wenn es nicht das erste Mal ist)🎜🎜Rechts- Klicken Sie auf das Ressourcenverzeichnis und erstellen Sie eine neue .xml Konfigurationsdatei. Der empfohlene Dateiname ist spring.xml oder spring-config.xml. 🎜🎜🎜 🎜Erstellen Sie eine spring.xml-Konfigurationsdatei, Konfigurationsinhalt: 🎜

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

🎜2.2 Bean-Objekt erstellen🎜🎜Der erste Schritt besteht darin, ein Bean-Objekt zu erstellen. 🎜🎜Wenn wir beispielsweise ein User-Objekt einfügen möchten, erstellen wir zunächst eine User-Klasse. 🎜

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

🎜Injizieren Sie Bean über die Konfigurationsdatei in Spring, das heißt, fügen Sie es über die folgende Anweisung in die Spring-Konfigurationsdatei ein. 🎜

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

🎜Objekte im Frühling werden über Schlüssel-Wert-Paare gespeichert, wobei key id und value class ist . 🎜🎜Namenskonvention: id wird in Großbuchstaben (z. B. userid) benannt, und class wird in Großbuchstaben (z. B. userId . 🎜🎜2.3 Bean-Objekt lesen🎜🎜Wenn Sie das Bean-Objekt aus Spring lesen möchten, müssen Sie zuerst das Spring-Kontextobjekt abrufen, was dem Abrufen von Spring entspricht. Rufen Sie dann das Bean-Objekt, das Sie verwenden müssen, über die vom Spring-Kontextobjekt bereitgestellte Methode ab. Schließlich können Sie das Bean-Objekt verwenden. 🎜rrreee🎜Laufende Ergebnisse:🎜

🎜Hallo zhangsan🎜🎜Prozess mit Exit-Code 0 abgeschlossen🎜

🎜Sie können die Bean auch über die Bean-Fabrik (alt) erhalten. 🎜rrreee🎜Obwohl die Bohnenfabrik 🎜🎜Laufendes Ergebnis: 🎜

🎜Hallo! Li Si🎜🎜Prozess mit Exit-Code 0 beendet🎜

🎜 Es wurde festgestellt, dass sowohl ApplicationContext als auch BeanFactory sein können Zugriff über Um Bean im Container zu erhalten, wird die Methode getBean bereitgestellt. Dann stellt sich die Frage, was der Unterschied zwischen ApplicationContext und BeanFactory ? 🎜🎜Derselbe Punkt: Beide können Bean aus dem Container abrufen und beide stellen die Methode getBean bereit. 🎜🎜Unterschiede: 🎜

• 🎜BeanFactory ist die übergeordnete Klasse von ApplicationContext, BeanFactoryStellt nur grundlegende Funktionen für den Zugriff auf Bean-Objekte bereit, während ApplicationContext zusätzlich zu allen Funktionen von BeanFactory auch über die Implementierung anderer verfügt Zusätzliche Funktionen wie Internationalisierung, Ressourcenzugriff und andere Funktionen sind implementiert. 🎜🎜
• 🎜Es ist anders in Bezug auf die Leistung. BeanFactory lädt Bean bei Bedarf, was eine langsame Methode ist, und ApplicationContext schon Bei einer hungrigen Methode werden alle Beans geladen, wenn sie zur Verwendung erstellt werden. 🎜🎜🎜🎜Beweis:🎜

  我们在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);

Das obige ist der detaillierte Inhalt vonJava Spring Framework-Erstellungsprojekt und Bean-Speicher- und Lesebeispielanalyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!