Comment utiliser les expressions SpringBoot SpringEL

1. SpringEL-Basic Introduction

Qu'est-ce que SpringEL (SpEL) ?

• Spring 3 a introduit le langage d'expression Spring - SpringEL SpEL est un moyen puissant et concis d'assembler des beans

• SpringEL peut assembler des valeurs​​à nos propriétés ou constructeurs via des expressions exécutées pendant l'exécution. Parmi eux,

  .

• SpringEL peut appeler les constantes statiques fournies dans le JDK pour obtenir la configuration dans le fichier de propriétés externe

Pourquoi utiliser SpringEL ?

• Les beans qui sont généralement injectés via des fichiers de configuration ou Annotaton peuvent en fait être appelés pour de la statique injection

• S'il y a une variable A dans le Bean A, sa valeur doit être basée sur la variable B du Bean B. Dans ce scénario, l'injection statique est très impuissante pour un tel traitement

• Et Spring3 ajoute que SpringEL peut pleinement répondre à cette demande, et il peut également calculer et attribuer des valeurs aux champs de différents beans. Comment utiliser SpringEL D'après le nom, vous pouvez dire que SpringEL est similaire à EL. avec lui. L'utilisation de Spring EL est très similaire à l'utilisation des expressions EL

Les expressions EL facilitent l'obtention de la valeur en arrière-plan sur la page JSP, et SpringEL facilite l'obtention de la valeur de. le Bean dans le conteneur Spring

• EL utilise ${}, tandis que SpringEL utilise #{} pour déclarer des expressions

• La principale différence entre les deux

• $ est de trouver les paramètres configurés en externe et d'attribuer le valeurs

# C'est une expression SpEL pour trouver le contenu de la variable correspondante

• Vous pouvez également utiliser directement @value("constant") pour injecter sans utiliser EL Cette méthode d'écriture est équivalente à direct. assignation

• S'il est utilisé au Spring, il peut être utilisé **@PropertySource("classpath:my.properties")** Chargez le fichier de configuration correspondant

2. Expression EL - utilisation de base

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

  Utilisation EL pour injecter des valeurs simples

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

Injecter les valeurs d'attribut du fichier de configuration

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

Injecter La valeur par défaut

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

injection list

ne prend pas en charge la liste d'injection de format de syntaxe de tableau dans le fichier de configuration direct

peut identifier la configuration séparée par une virgule, la valeur par défaut du ressort est, séparée

• // 错误写法：不支持直接注入yml列表格式语法列表
  @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;

  La référence complète est la suivante

Fichier de configuration

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

  Classe de configuration d'attribut

  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;
  }

Injectez la classe de configuration dans le contrôleur, puis accédez au résultats des tests d'interface comme suit

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

3. Utilisation de SpringEL-Basic

1. L'utilisation de SpEL pour injecter des valeurs simples est fondamentalement la même que l'utilisation d'une injection EL ordinaire

2. La carte d'injection SpEl

doit être configurée. être placé entre guillemets doubles, sinon l'injection échouera. La clé est des guillemets simples

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

Dans la classe Java, utilisez d'abord ${spEl.mapInject} pour injecter la valeur de la chaîne #{} analysera la valeur de la chaîne et. convertissez-le en map

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

3. SpEl injecte list
En plus d'injecter listI via EL, vous pouvez également utiliser la méthode #{${}.split("separator")} d'injection dans List

fichier de configuration, par exemple, utilisez # pour séparer

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

  Dans la classe Java, utilisez d'abord ${spEl.listInject} pour injecter la valeur de chaîne, placez le contenu entre guillemets simples, puis utilisez la méthode split pour séparer le string

  Conseils : pour éviter la situation vide, vous pouvez donner une valeur par défaut de chaîne vide

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

• 4. Injection dynamique
  Les injections ci-dessus sont toutes des injections statiques. SpEl prend en charge l'injection d'informations à partir du conteneur Spring, appelée injection dynamique. . Les classes d'injection dynamique sont les suivantes

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;
    }
}

SpEl prend en charge et ne prend pas en charge les opérations

Prend en charge l'injection dynamique d'instances, similaire à l'injection automatique d'objets

SPL ne prend pas en charge l'injection directe de configurations dans les fichiers de configuration

• Prend en charge l'appel de la méthode statique et des instances

• Méthode statique : @Value("#{T(package.ClassName).ConstFieldName")
Prend en charge l'appel de classes statiques ou de constantes

• Prend en charge les opérations de l'opérateur

• Supports Collections d'opérations

• Soutien des collections et projections de filtrage de requête

• L'opération d'injection complète est la suivante des résultats

  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;
  }

injection
• rreee

  spring fonctionne à des fichiers de propriétés externes

  rrreerreea
springel est juste une chaîne lorsqu'il est utilisé, ce qui n'est pas facile à déboguer et à dépanner. Pour les tests, il n'y a pas d'EDI pour vérifier notre syntaxe. Il est difficile de détecter lorsqu'une erreur se produit. Il n'est pas recommandé d'injecter des expressions complexes via SpringEL. Il n'est pas recommandé d'utiliser l'injection complexe de SpEl à moins que cela ne soit nécessaire. Un code clair et lisible est plus important et utile pour le dépannage

4 Injection automatique de propriétés

Les éléments ci-dessus sont tous injectés via des champs spécifiés, qui peuvent être spécifiés via @ConfigurationProperties Le préfixe. est automatiquement injecté

{
 "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": [
  "深圳",
  "杭州"
 ]
}

Classe de configuration

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

Classe d'injection d'attribut automatique

Spécifiez le frontal en tant qu'utilisateur via le préfixe, puis le type après l'utilisateur sera injecté en fonction du nom

Notez qu'un la méthode de définition doit être fournie

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包内的配置类，则可能出现属性没有注入情况，所以可以指定注入

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!