Frühling. Lektion 4: Das Wertattribut zum Einbetten von Werten

Und so... Wir setzen unseren Frühlingskurs fort. In der letzten Lektion haben wir die Abhängigkeitsinjektion mit einem Setter untersucht. Wenn Sie es bemerkt haben, haben wir Werte mithilfe von Links zur ID implementiert. Das heißt, die Implementierung erfolgte über das ref-Attribut. Es sah ungefähr so ​​aus: Listing 1

<bean id="javaDeveloper" class="org.example.JavaDevelopment"/>

<bean id="hiringDepartment" class="org.example.HiringDepartment">
        <property name="development" ref="javaDeveloper"/>
</bean>

Hier bezieht sich die 4. Zeile auf die ID „javaDeveloper“, die den Wert der JavaDevelopment-Klasse implementiert. Was wäre, wenn wir die Werte manuell einfügen oder auf andere Weise abrufen und dann einfügen möchten? Schauen wir uns ein Beispiel an. Jeder Mitarbeiter hat eine Staatsbürgerschaft und ein Gehalt. Und lassen Sie diese Entitäten in der HiringDepartment-Klasse definieren. Sagen wir Folgendes: Listing 2

package org.example;

public class HiringDepartment {
    private Development development; //Определяем интерфейс
    private int salary;
    private String citizenship;

    public void displayInfo(){
        System.out.println("Name: " + development.getName());
        System.out.println("Job: " + development.getJob());
    }

    public void setDevelopment(Development development){
        this.development = development;
    }

    public Development getDevelopment(){
        return development;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public String getCitizenship() {
        return citizenship;
    }

    public void setCitizenship(String citizenship) {
        this.citizenship = citizenship;
    }
}

Hier haben wir 2 Felder hinzugefügt. int Gehalt und String-Staatsbürgerschaft . Wir haben auch Getter und Setter für diese Objekte definiert. Zur Erinnerung: Spring bezieht sich hinter den Kulissen auf diese Getter und Setter, um Werte an Klassenobjekte zu binden. Andere Klassen berühren wir noch nicht. Und dann werden wir die applicationContext-Datei neu erstellen, die die Beans für unsere Objekte definiert. Und es sieht so aus: Listing 3

<?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">

    <bean id="javaDeveloper" class="org.example.JavaDevelopment"/>
    <bean id="pythonDeveloper" class="org.example.PythonDevelopment"/>

    <bean id="hiringDepartment" class="org.example.HiringDepartment">
        <property name="development" ref="javaDeveloper"/>
        <property name="citizenship" value="USA"/>
        <property name="salary" value="5000"/>
    </bean>

</beans>

Im Gegensatz zu Listing 1 wurden hier zwei weitere Eigenschaften hinzugefügt (Zeilen 12 und 13). Hier kommt das Wertattribut ins Spiel , das innerhalb des Property-Tags definiert wird. Ich möchte Sie noch einmal daran erinnern, dass der Wert des Namensattributs mit dem Objekt übereinstimmen muss, auf das die Bean verweist. Und dann bestimmt Spring anhand dieser Werte unabhängig Getter und Setter. Und mithilfe des Wertattributs implementieren wir Werte für die Felder. Beachten Sie, dass beide Werte in Anführungszeichen definiert sind, obwohl dies für den Typ int ungewöhnlich ist. Aber Spring bestimmt wie immer, welcher Wert welchem ​​Typ zugeordnet werden soll. Dies geschieht aufgrund des Namensattributs . Mit dem Namen der Bean verweist Spring auf ein Objekt der Klasse und bestimmt den Typ dieses Objekts. Nun, das ist alles. Jetzt müssen wir nur noch unsere Updates in der Main-Klasse überprüfen: Listing 5

package org.example;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String ... args){
        //Определяем контекст файл в котором содержатся прописанные нами бины
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //Получем бины, которые были определены в файле applicationContext.xml
        HiringDepartment hiringDepartment = context.getBean("hiringDepartment", HiringDepartment.class);

        hiringDepartment.displayInfo();
        System.out.println("Citizenship: " + hiringDepartment.getCitizenship());
        System.out.println("Salary: " + hiringDepartment.getSalary());
        context.close(); //Контекст всегда должен закрываться
    }
}

Hier muss nicht viel geändert werden. Nur um Ergebnisse zu erhalten, rufen wir Getter der HiringDepartment-Klasse mithilfe des Standardausgabestreams auf. Als Ergebnis erhalten wir folgende Antwort:

Name: Alexa
Job: Middle Java developer
Citizenship: USA
Salary: 5000

OK. Nehmen wir an, wir haben 10 solcher Mitarbeiter, die die gleiche Staatsbürgerschaft haben und das gleiche Gehalt beziehen. Nehmen wir an, das Unternehmen hat beschlossen, seine Gehälter zu erhöhen. Dann müssen Sie alle diese 10 Werte manuell ändern. Es ist zu langweilig. Was wäre, wenn wir diese Werte in einer separaten Datei definieren und diese Werte mit Beans verknüpfen? Dann müssten wir den Wert in dieser Datei nur einmal ändern und die übrigen Beans, die auf diesen Wert verweisen, würden sich automatisch ändern. Versuchen wir es... Dazu nehmen wir einige Aktualisierungen in der Projektstruktur und in der Datei applicationContext.xml vor. Fügen Sie zunächst im Ressourcenordner eine neue Datei mit der Erweiterung .properties hinzu . Ich habe diese Datei „myApp.properties“ genannt. Nun hat die Projektstruktur folgende Form angenommen: Und in die Datei werden wir folgende Werte schreiben:

employee.citizenship="Russia"
employee.salary=6000

Links vom „=“-Zeichen stehen die Namen der Variablen (sofern man sie so nennen kann) und rechts die Werte dieser Variablen. Sie können den Namen beliebig vergeben, jedoch wie gewohnt mit Bedeutung. Und ja, der Punkt spielt hier eine strategische, keine syntaktische Rolle. Nehmen wir an, wir haben auch Manager, auch mit eigenem Gehalt. Dann können wir diese Variablen einfach etwa so benennen: manager.salary. Das heißt, die Namen der Variablen stimmen nicht überein und stören sich gegenseitig. Jetzt aktualisieren wir die Datei applicationContext.xml. Bevor Sie Bohnen deklarieren, müssen Sie die folgende Zeile schreiben:

<context:property-placeholder location="classpath:myApp.properties"/>

Hier definieren wir die Datei, die wir zum Einbetten der Werte erstellt haben. Und dann setzen wir im Wertattribut ein Dollarzeichen $ in doppelte Anführungszeichen und in geschweifte Klammern {} schreiben wir den Namen der Variablen aus der Datei myApp.properties:

<property name="salary" value="${employee.salary}"/>

Als Ergebnis sucht Spring nach dieser Variablen, ruft ihren Wert ab und hängt ihn an das Klassenobjekt an. Der vollständige Code sieht so aus: Listing 6

<?xml version="1.0" encoding="UTF-8"?>
<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"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:myApp.properties"/>

    <bean id="javaDeveloper" class="org.example.JavaDevelopment"/>
    <bean id="pythonDeveloper" class="org.example.PythonDevelopment"/>

    <bean id="hiringDepartment" class="org.example.HiringDepartment">
        <property name="development" ref="javaDeveloper"/>
        <property name="citizenship" value="${employee.citizenship}"/>
        <property name="salary" value="${employee.salary}"/>
    </bean>

</beans>

Starten wir das Programm:

Name: Alexa
Job: Middle Java developer
Citizenship: "Russia"
Salary: 6000

Wie immer ist Programmieren der beste Weg, Programmieren zu lernen. Wiederholen Sie selbst, was Sie gelernt haben, versuchen Sie, Elemente zu aktualisieren, spielen Sie mit dem Code. Kurz gesagt: Machen Sie es. Und das ist alles für mich. Vielen Dank für Ihre Aufmerksamkeit! Quellcode unter dem Link Mein GitHub Treten Sie meinem Telegram-Kanal bei Kursinhalt Fortsetzung folgt...