Cara menggunakan ungkapan SpringBoot SpringEL

1. SpringEL-Pengenalan Asas

Apakah SpringEL (SpEL)?

• Spring 3 memperkenalkan bahasa ungkapan Spring - SpringEL SpEL ialah cara yang hebat dan ringkas untuk memasang kacang

• SpringEL boleh dilalui Ungkapan itu. dilaksanakan semasa runtime menghimpunkan nilai ke dalam sifat atau pembina kami

• SpringEL boleh memanggil pemalar statik yang disediakan dalam JDK untuk mendapatkan konfigurasi dalam fail Properties luaran

Mengapa menggunakan SpringEL?

• Kacang yang biasanya disuntik melalui fail konfigurasi atau Annotaton sebenarnya boleh dipanggil suntikan statik

• Jika ada ialah pembolehubah A dalam Kacang A, nilainya perlu berdasarkan pembolehubah B Kacang B. Dalam senario ini, suntikan statik sangat tidak berkuasa untuk pemprosesan sedemikian

• SpringEL ditambah pada Spring 3 boleh memenuhi permintaan ini sepenuhnya, dan juga boleh mengira dan menetapkan nilai kepada bidang kacang yang berbeza Ia sangat berkuasa

Bagaimana untuk menggunakan SpringEL?

<. . dapatkan nilai di latar belakang dalam halaman jsp dan springel adalah untuk mendapatkan bean bekas spring dengan lebih mudah>
EL menggunakan ${}, manakala SpringEL menggunakan #{ }Istiharkan ungkapan
Perbezaan utama antara keduanya
$ ialah mencari parameter konfigurasi luaran dan menetapkan nilai

# ialah ungkapan SpEL untuk mencari kandungan pembolehubah yang sepadan
Anda juga boleh terus menggunakan @value ("constant") untuk menyuntik tanpa menggunakan EL , cara penulisan ini adalah bersamaan dengan tugasan langsung
Jika digunakan dalam Spring, anda boleh menggunakan **@PropertySource("classpath:my.properties")** untuk memuatkan yang sepadan fail konfigurasi

• 2. Ungkapan EL - penggunaan asas

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

Gunakan EL untuk menyuntik nilai mudah

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

Suntikan nilai atribut fail konfigurasi

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

Suntikan nilai lalai

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

Senarai suntikan

Tidak menyokong senarai suntikan format sintaks tatasusunan dalam fail konfigurasi langsung

Boleh mengecam konfigurasi dipisahkan koma , spring dipisahkan oleh, secara lalai

• // 错误写法：不支持直接注入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;

Rujukan lengkap adalah seperti berikut

• Fail konfigurasi

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

Konfigurasi atribut kelas

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

kepada pengawal Inject kelas konfigurasi, dan kemudian akses hasil ujian antara muka seperti berikut

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

3. Penggunaan SpringEL-Basic

1 nilai mudah pada asasnya adalah sama seperti suntikan EL biasa

2. Suntikan SpEl Peta

Fail konfigurasi perlu disertakan dalam petikan berganda, jika tidak, suntikan akan gagal kunci ialah petikan tunggal

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

pertama dalam kelas java Gunakan ${spEl.mapInject} untuk menyuntik nilai rentetan #{} akan menghuraikan nilai rentetan dan menukarnya kepada peta

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

  3. SpEl menyuntik senarai

selain daripada menyuntik listI melalui EL, anda juga boleh menggunakan #{${}.split("separator")} untuk menyuntik Senarai

ke dalam fail konfigurasi Contohnya, gunakan # untuk memisahkan

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

Dalam kelas java, gunakan ${spEl dahulu. .listInject} untuk menyuntik nilai rentetan, sertakan kandungan dalam petikan tunggal, dan kemudian gunakan kaedah pisah untuk memisahkan rentetan
• Petua: elakkan situasi kosong, Anda boleh memberikan nilai lalai rentetan kosong

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

  4. Suntikan dinamik

Suntikan di atas semuanya adalah suntikan statik SpEl menyokong maklumat suntikan daripada bekas Spring, yang dipanggil suntikan dinamik. Kelas suntikan dinamik adalah seperti berikut

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 menyokong dan tidak menyokong operasi

Menyokong kejadian suntikan dinamik, serupa dengan suntikan automatik objek

SPL tidak menyokong suntikan langsung konfigurasi dalam fail konfigurasi
Menyokong panggilan kaedah statik dan contoh
• Statik kaedah: @Value( "#{T(package.ClassName).ConstFieldName")

• Menyokong memanggil kelas statik atau pemalar

Menyokong operasi pengendali
Menyokong koleksi operasi
Menyokong pengumpulan dan unjuran penapisan pertanyaan
Suntikan operasi lengkap seperti berikut

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

  Hasil suntikan

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

Spring mengendalikan fail Sifat luaran

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

public class TestSpringEL {
 // 注意db为xml文件中声明的id
 @Value("#{db["jdbc.url"]}")
 private String propertiesValue;
}

SpringEL hanyalah rentetan apabila digunakan, yang tidak mudah untuk nyahpepijat dan menguji, dan tiada IDE untuk menyemak Tatabahasa kami, sukar untuk dikesan apabila ralat berlaku, dan tidak disyorkan untuk menyuntik ungkapan kompleks melalui SpringEL. Suntikan kompleks SpEl tidak disyorkan melainkan perlu Kod yang jelas dan boleh dibaca adalah lebih penting dan membantu untuk menyelesaikan masalah

4 Suntikan atribut automatik

Semuanya dilakukan melalui medan tertentu Untuk suntikan, anda boleh. nyatakan awalan melalui @ConfigurationProperties untuk suntikan automatik

org.springframework.boot.context.properties.ConfigurationProperties

Kelas konfigurasi

user:
  id: ${random.uuid}
  name: autowire
  address: unknown
  website: www.codecoord.com
  age: ${random.int}

Kelas suntikan sifat automatik

Tentukan hujung hadapan sebagai pengguna melalui awalan , dan kemudian jenis selepas pengguna akan disuntik mengikut nama

Perhatikan bahawa kaedah penetap
• mesti disediakan

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

Atas ialah kandungan terperinci Cara menggunakan ungkapan SpringBoot SpringEL. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!