So verwenden Sie SpringBoot SpringEL-Ausdrücke

1. SpringEL-Grundlegende Einführung

Was ist SpringEL (SpEL)?

• Frühlingsausdruckssprache – SpringEL wurde in Spring 3 eingeführt. SpEL ist eine leistungsstarke und prägnante Möglichkeit, Bohnen zusammenzustellen

#🎜🎜 ## 🎜🎜#SpringEL kann durch zur Laufzeit ausgeführte Ausdrücke Werte in unsere Eigenschaften oder Konstruktoren einbauen.
SpringEL kann im JDK bereitgestellte statische Konstanten aufrufen und die Konfiguration im abrufen externe Eigenschaftendatei
Warum SpringEL verwenden?

Normalerweise über die Konfigurationsdatei Oder von Annotaton injizierte Beans können eigentlich als statische Injektion bezeichnet werden
Wenn es in Bean A eine Variable A gibt, muss ihr Wert auf der B-Variablen von Bean B basieren. In diesem Szenario ist es statisch Die Injektion ist für eine solche Verarbeitung sehr leistungsfähig. Die Funktion ist sehr leistungsfähig etwas mit EL zu tun. Die Verwendung von Spring EL ist der Verwendung von EL-Ausdrücken sehr ähnlich Hintergrund, und SpringEL dient dazu, den Wert der Bean im Spring-Container bequemer zu ermitteln.
EL verwendet ${}, während SpringEL #{} für Ausdrücke verwendet Die Anweisung von
Der Hauptunterschied zwischen den beiden besteht darin, die Parameter der externen Konfiguration zu finden und den Wert zuzuweisen Komm vorbei

# ist ein SpEL-Ausdruck, um den Inhalt der entsprechenden Variablen zu finden.
Sie können @ auch direkt verwenden. Wert("Konstante"), bei der Injektion wird kein EL verwendet , diese Schreibmethode entspricht der direkten Zuweisung
Bei Verwendung im Frühjahr können Sie **@PropertySource("classpath: my.properties")**Laden Sie die entsprechende Konfigurationsdatei

• 2. EL-Ausdruck – grundlegende Verwendung

# 配置文件
com:
  codecoord:
    el:
      num: 1001
      name: el
      language:
        - java
        - spring
        - mysql
        - linux
      # 逗号分隔可以注入列表
      language02: java,spring,mysql,linux

Verwenden Sie EL, um einfache Werte einzufügen

/**
 * 注入简单值，直接注入不使用EL，EL不支持直接指定常量
 * 直接在EL中指定的常量会当做配置处理，和直接赋值等价
 */
@Value("1432516744")
private Integer no;

Attribut der Injektionskonfigurationsdatei value

/**
 * 注入整型属性值
 */
@Value("${com.codecoord.el.num}")
private Integer num;
/**
 * 注入字符属性值
 */
@Value("${com.codecoord.el.name}")
private String name;

• Injection default value

  /**
   * 注入字符不存在属性值并指定默认值，默认值使用过冒号分隔 :
   * 注入常量其实就可以指定一个不存在的配置然后使用默认值，此处skill的值为java
   */
  @Value("${com.codecoord.el.skill:java}")
  private String skill;

  Injection list

• Nicht unterstützt Die Array-Syntaxformat-Injection-Liste in der Die direkte Konfigurationsdatei

• kann durch Kommas getrennte Konfigurationen identifizieren. Standardmäßig wird Spring durch

#🎜🎜 #

// 错误写法：不支持直接注入yml列表格式语法列表
@Value("${com.codecoord.el.language}")
private List<String> listLanguage;
@Value("${com.codecoord.el.language}")
private String[] strLanguage;

rrree

getrennt Die Referenz lautet wie folgt

Konfigurationsdatei

/**
 * 支持,分隔的注入列表
 */
@Value("${com.codecoord.el.language02}")
private List<String> listLanguage02;
@Value("${com.codecoord.el.language02}")
private String[] strLanguage02;

Attributkonfigurationsklasse

server:
  port: 8888
com:
  codecoord:
    el:
      num: 1001
      name: el
      language:
        - java
        - spring
        - mysql
        - linux
      # 逗号分隔可以注入列表
      language02: java,spring,mysql,linux

Injizieren Sie die Konfigurationsklasse in den Controller und greifen Sie dann auf die Schnittstelle zu. Die Testergebnisse sind wie folgt

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.List;

@Data
@Component
public class ElConfig {
    /**
     * 注入简单值，直接注入不使用EL，EL不支持直接指定常量
     * 直接在EL中指定的常量会当做配置处理，和直接赋值等价
     */
    @Value("1432516744")
    private Integer no;
    /**
     * 注入整型属性值
     */
    @Value("${com.codecoord.el.num}")
    private Integer num;
    /**
     * 注入字符属性值
     */
    @Value("${com.codecoord.el.name}")
    private String name;
    /**
     * 注入字符不存在属性值并指定默认值，默认值使用过冒号分隔 :
     * 注入常量其实就可以指定一个不存在的配置然后使用默认值，此处skill的值为java
     */
    @Value("${com.codecoord.el.skill:java}")
    private String skill;
    /// 不支持直接注入列表
    /*@Value("${com.codecoord.el.language}")
    private List<String> listLanguage;
    @Value("${com.codecoord.el.language}")
    private String[] strLanguage;*/
    /**
     * 支持,分隔的注入列表
     */
    @Value("${com.codecoord.el.language02}")
    private List<String> listLanguage02;
    @Value("${com.codecoord.el.language02}")
    private String[] strLanguage02;
}

3. SpringEL-grundlegende Verwendung

1. Die Verwendung von SpEL zur Injektion einfacher Werte ist im Grunde dasselbe wie die normale EL-Injektion.

2 . SpEl-Injektionskarte# 🎜🎜#

Die Konfigurationsdatei muss in doppelte Anführungszeichen gesetzt werden, sonst schlägt die Injektion fehl.

• {
   "no": 1432516744,
   "num": 1001,
   "name": "el",
   "skill": "java",
   "listLanguage02": [
    "java",
    "spring",
    "mysql",
    "linux"
   ],
   "strLanguage02": [
    "java",
    "spring",
    "mysql",
    "linux"
   ]
  }

  #🎜 🎜#In der Java-Klasse verwenden Sie zuerst ${spEl.mapInject}, um den String-Wert einzufügen. #{} analysiert den String-Wert und konvertiert ihn in eine Karte

# SpEl
spEl:
  mapInject: "{"name": "SpEl", "website": "http://www.codeocord.com"}"

• 3. SpEl-Injektionsliste

  #🎜 🎜#

Zusätzlich zur Injektion von listI über EL können Sie auch #{${}.split("separator")} verwenden, um List# zu injizieren 🎜🎜#

#🎜🎜 #

Verwenden Sie beispielsweise # in der Konfigurationsdatei, um

@Value("#{${spEl.mapInject}}")
private Map<String, String> mapInject;

In der Java-Klasse zuerst zu verwenden ${spEl.listInject}, um den Zeichenfolgenwert einzufügen und den Inhalt in einfache Anführungszeichen zu setzen. Verwenden Sie dann die Split-Methode, um die Zeichenfolge

zu trennen. Tipp: Um die Leersituation zu vermeiden, können Sie einen Standardwert angeben der leeren Zeichenfolge

spEl:
  listInject: "44#11#99#100"

4. Dynamische Injektion

Die oben genannten Injektionen sind alle statischen Injektionen, die die Injektion von Informationen aus dem Spring-Container unterstützen. Dynamische Injektionsklassen sind wie folgt

@Value("#{"${spEl.listInject:}".split("#")}")
 private List<String> listInject;

SpEl unterstützt und unterstützt keine Operationen

• Unterstützt dynamische Injektionsinstanzen, ähnlich der automatischen Objektinjektion#🎜 🎜## 🎜🎜#

SPL unterstützt keine direkte Injektion der Konfiguration in die Konfigurationsdatei

Unterstützt den Aufruf statischer und Instanzmethoden#🎜 🎜##🎜🎜 #

• Statische Methode: @Value("#{T(package.ClassName).ConstFieldName")

# ?? Sammlung#🎜🎜 #

• Unterstützt die Abfragefilterung von Sammlungen und Projektionen

Der vollständige Injektionsvorgang ist wie folgt

import lombok.AllArgsConstructor;
import lombok.Data;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
@Data
public class SpElConstant {
    private String name = "SpElConstant-name";
    private String nickname = "tianxin";
    private int num = 100;
    private List<String> product = new ArrayList<String>() {{
        add("huaweiMate30Pro");
        add("xiaomi10x5g");
    }};
    private Map<String, String> productMap = new HashMap<String, String>() {{
        put("huaweiMate30Pro", "5999");
        put("xiaomi10x5g", "4999");
    }};
    private List<City> cityList = new ArrayList<City>() {{
        add(new City("深圳", 1000L));
        add(new City("杭州", 2000L));
        add(new City("贵阳", 900L));
    }};

    public String showProperty() {
        return "showProperty-无参数";
    }

    public String showProperty(String name) {
        return "showProperty-" + name;
    }

    @Data
    @AllArgsConstructor
    static class City {
        private String name;
        private long population;
    }
}

Injektionsergebnisse

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

@Data
@Component
public class SpElConfig {
    /// 不支持直接注入配置文件值
    /*@Value("#{com.codecoord.el.num}")
    private Integer num;*/
    /**
     * 对象注入
     */
    @Value("#{spElConstant}")
    private SpElConstant spElConstant;
    /**
     * 注入ID为spElConstant Bean中的STR常量/变量
     */
    @Value("#{spElConstant.name}")
    private String name;
    /**
     * 调用无参方法
     */
    @Value("#{spElConstant.showProperty()}")
    private String method1;
    /**
     * 有参接收字符串的方法
     */
    @Value("#{spElConstant.showProperty("Hell SpringEL")}")
    private String method2;
    /**
     * 方法返回的String为大写
     */
    @Value("#{spElConstant.showProperty().toUpperCase()}")
    private String method3;
    /**
     * 若使用method3这种方式，若果showProperty返回为null
     * 将会抛出NullPointerException,可以使用以下方式避免
     * 使用?.符号代表若然左边的值为null，将不执行右边方法
     */
    @Value("#{spElConstant.showProperty()?.toUpperCase()}")
    private String method4;
    /**
     * 注入math常量
     */
    @Value("#{T(java.lang.Math).PI}")
    private double pi;
    /**
     * 用random方法获取返回值
     */
    @Value("#{T(java.lang.Math).random()}")
    private double random;
    /**
     * 获取文件路径符号
     */
    @Value("#{T(java.io.File).separator}")
    private String separator;
    /**
     * 拼接字符串
     */
    @Value("#{spElConstant.nickname + " " + spElConstant.name}")
    private String concatString;
    /**
     * 对数字类型进行运算,spElConstant拥有num属性
     */
    @Value("#{3 * T(java.lang.Math).PI + spElConstant.num}")
    private double operation;
    /**
     * 进行逻辑运算
     */
    @Value("#{spElConstant.num > 100 and spElConstant.num <= 200}")
    private boolean logicOperation;
    /**
     * 进行或非逻辑操作
     */
    @Value("#{not (spElConstant.num == 100) or spElConstant.num <= 200}")
    private boolean logicOperation2;
    /**
     * 使用三元运算符
     */
    @Value("#{spElConstant.num > 100 ? spElConstant.num : spElConstant.num + 100}")
    private Integer logicOperation3;
    /**
     * 获取下标为0的元素
     */
    @Value("#{spElConstant.product[0]}")
    private String str;
    /**
     * 获取下标为0元素的大写形式
     */
    @Value("#{spElConstant.product[0]?.toUpperCase()}")
    private String upperStr;
    /**
     * 获取map中key为hello的value
     */
    @Value("#{spElConstant.productMap["hello"]}")
    private String mapValue;
    /**
     * 根据product下标为0元素作为key获取testMap的value
     */
    @Value("#{spElConstant.productMap[spElConstant.product[0]]}")
    private String mapStrByproduct;
    /**
     * 注入人口大于等于1000人口的城市
     */
    @Value("#{spElConstant.cityList.?[population >= 1000]}")
    private List<SpElConstant.City> cityList;
    /**
     * 注入人口等于900人口的城市
     */
    @Value("#{spElConstant.cityList.?[population == 900]}")
    private SpElConstant.City city;
    /**
     * 注入人口大于等于1000人口的城市，且只保留城市名称
     */
    @Value("#{spElConstant.cityList.?[population >= 1000].![name]}")
    private List<String> cityName;
}

Spring betreibt externe Eigenschaftendateien

{
 "spElConstant": {
  "name": "SpElConstant-name",
  "nickname": "tianxin",
  "num": 100,
  "product": [
   "huaweiMate30Pro",
   "xiaomi10x5g"
  ],
  "productMap": {
   "xiaomi10x5g": "4999",
   "huaweiMate30Pro": "5999"
  },
  "cityList": [
   {
    "name": "深圳",
    "population": 1000
   },
   {
    "name": "杭州",
    "population": 2000
   },
   {
    "name": "贵阳",
    "population": 900
   }
  ]
 },
 "name": "SpElConstant-name",
 "method1": "showProperty-无参数",
 "method2": "showProperty-Hell SpringEL",
 "method3": "SHOWPROPERTY-无参数",
 "method4": "SHOWPROPERTY-无参数",
 "pi": 3.141592653589793,
 "random": 0.19997238292235787,
 "separator": "",
 "concatString": "tianxin SpElConstant-name",
 "operation": 109.42477796076938,
 "logicOperation": false,
 "logicOperation2": true,
 "logicOperation3": 200,
 "str": "huaweiMate30Pro",
 "upperStr": "HUAWEIMATE30PRO",
 "mapValue": null,
 "mapStrByproduct": "5999",
 "cityList": [
  {
   "name": "深圳",
   "population": 1000
  },
  {
   "name": "杭州",
   "population": 2000
  }
 ],
 "city": {
  "name": "贵阳",
  "population": 900
 },
 "cityName": [
  "深圳",
  "杭州"
 ]
}

<!-- 首先通过applicaContext.xml中<util:properties>增加properties文件 -->
<!-- 注意需要引入Spring的util schemea命名空间和注意id属性,id属性将在SpringEL中使用 -->
<util:properties id="db" location="classpath:application.properties"/>

SpringEL ist bei Verwendung nur eine Zeichenfolge, die nicht einfach zu debuggen und zu testen ist, und das gibt es Keine IDE zum Überprüfen unserer Syntax, wenn sie angezeigt wird. Es ist schwierig, Fehler zu erkennen, und es wird nicht empfohlen, komplexe Ausdrücke über SpringEL einzufügen. Es wird nicht empfohlen, die komplexe Injektion von SpEl zu verwenden, es sei denn, dies ist für die Fehlerbehebung wichtiger und hilfreicher.

4. Automatische Attributinjektion

• Das alles ist es Wird durch Angabe von Feldern injiziert und kann automatisch durch Angabe des Präfixes über @ConfigurationProperties eingefügt werden. 🎜 🎜#

  Geben Sie das Frontend als Benutzer durch Präfix an, und dann wird der Typ nach Benutzer entsprechend dem Namen eingefügt.

• Beachten Sie, dass der Setter Methode muss bereitgestellt werden#🎜 🎜#

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "user")
@Data
public class UserConfig {
    private String id;
    private String name;
    private String address;
    private String website;
    private Integer age;
}

可以通过@EnableConfigurationProperties(value = UserConfig.class)将UserConfig再次强制注入，问题出现在如果UserConfig为第三方jar包内的配置类，则可能出现属性没有注入情况，所以可以指定注入

Das obige ist der detaillierte Inhalt vonSo verwenden Sie SpringBoot SpringEL-Ausdrücke. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!