官方文件介紹

The RandomValuePropertySource is useful for injecting random values (e.g. into secrets or test cases). It can produce integers, longs, uuids or strings, e.g.

RandomValuePropertySource 類通常用來注入 int，long，uuid 和 string 型別的隨機值。

The random.int* syntax is OPEN value (,max) CLOSE where the OPEN,CLOSE are any character and value,max are integers. If max is provided then value is the minimum value and max is the maximum (exclusive).

random.int* 的語法是 OPEN value (,max) CLOSE 。OPEN 和 CLOSE 可以是 任意字元，用來分隔方法引數。value, max 是 int 型別的整數。如果 max 引數存在，則 value 表示取值範圍的最小值，max 表示最大值（不包含 max）。

編寫配置檔案

application.properties 檔案配置：

my.value=${random.value}
my.int=${random.int}
my.long=${random.long}
my.uuid=${random.uuid}
my.int.less.than.ten
 
=${random.int(10)}
my.int.in.range=${random.int[1024,65536]}

application.yml 檔案配置：

my:
    value: ${random.value}
    int: ${random.int}
    long: ${random.long}
    uuid: ${random.uuid}
    int.less.than.ten: ${random.int(10)}
    # 100前面和1000後面可以是 -，(，[ 等任意字元
    int.in.range: ${random.int-100,1000-}

編寫 Controller 類

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/random")
public class RandomController {
    private static Logger log = LoggerFactory.getLogger(RandomController.class);

    //如果沒有編寫配置檔案，此處可以直接使用${random.value}
    @Value("${my.value}")
    private String randomValue;

    //如果沒有編寫配置檔案，此處可以直接使用${random.int}
    //int 型別也可以換成 String 型別
    @Value("${my.int}")
    private int randomInt;

    //如果沒有編寫配置檔案，此處可以直接使用${random.int(10)}
    //int 型別也可以換成 String 型別
    @Value("${my.int.less.than.ten}")
    private int randomIntLessThanTen;

    //如果沒有編寫配置檔案，此處可以直接使用${random.int[100,1000]}
    //int 型別也可以換成 String 型別
    @Value("${my.int.in.range}")
    private int randomIntRange;

    //如果沒有編寫配置檔案，此處可以直接使用${random.long}
    //long 型別也可以換成 String 型別
    @Value("${my.long}")
    private long randomLong;

    //如果沒有編寫配置檔案，此處可以直接使用${random.uuid}
    @Value("${my.uuid}")
    private String randomUUID;

    @RequestMapping("/value")
    public String getValue() {
        log.info("收到請求，randomValue : " + randomValue);
        return "randomValue : " + randomValue;
    }

    @RequestMapping("/int")
    public String getRandomInt() {
        log.info("收到請求，randomInt : " + randomInt);
        return "randomInt : " + randomInt;
    }

    @RequestMapping("/int/ten")
    public String getRandomIntLessThanTen() {
        log.info("收到請求，randomIntLessThanTen : " + randomIntLessThanTen);
        return "randomIntLessThanTen : " + randomIntLessThanTen;
    }

    @RequestMapping("/int/range")
    public String getRandomIntRange() {
        log.info("收到請求，randomIntRange : " + randomIntRange);
        return "randomIntRange : " + randomIntRange;
    }

    @RequestMapping("/long")
    public String getRandomLong() {
        log.info("收到請求，randomLong : " + randomLong);
        return "randomLong : " + randomLong;
    }

    @RequestMapping("/uuid")
    public String getRandomUUID() {
        log.info("收到請求，randomUUID : " + randomUUID);
        return "randomUUID : " + randomUUID;
    }
}

使用瀏覽器或 Postman 測試

注意事項及異常

1. 使用 @Value 註解注入的變數不能使用 static 修飾符修飾，否則變數的值無法注入成功。

   

2. 編寫配置檔案時，鍵名不能以 “random” 開頭，否則會丟擲NumberFormatException 。

   

   random:
       value: ${random.value}
       int: ${random.int}
       long: ${random.long}
       uuid: ${random.uuid}
       int.less.than.ten: ${random.int(10)}
       int.in.range: ${random.int-100,1000-}

   

   原因是 RandomValuePropertySource 在解析 ${random.int.less.than.ten} 和 ${random.int.in.range} 表示式時：

   1.會先呼叫 getProperty(String name) 方法擷取字首”random.” 後面的字串，得到”int.less.than.ten”和”int.in.range”

   2.然後會呼叫 getRandomValue(String type) 方法對剩下的字串進行匹配，發現是以 “int” 作為字首後

   3.會呼叫 getRange(String type, String prefix) 方法，擷取字首”int.”後面到 length - 1 位置的字串，得到”less.than.te”和”in.rang”

   4.最後會呼叫 getNextIntInRange(String range) 方法，將剩下的字串使用逗號分隔符切割後將返回陣列的首個物件轉換成 int 型別的數值作為 Random.nextInt(int bound) 方法的引數。

RandomValuePropertySource 類原始碼：

public class RandomValuePropertySource extends PropertySource<Random> {

    /**
     * Name of the random {@link PropertySource}.
     */
    public static final String RANDOM_PROPERTY_SOURCE_NAME = "random";

    private static final String PREFIX = "random.";

    private static final Log logger = LogFactory.getLog(RandomValuePropertySource.class);

    public RandomValuePropertySource(String name) {
        super(name, new Random());
    }

    public RandomValuePropertySource() {
        this(RANDOM_PROPERTY_SOURCE_NAME);
    }

    @Override
    public Object getProperty(String name) {
        if (!name.startsWith(PREFIX)) {
            return null;
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Generating random property for '" + name + "'");
        }
        return getRandomValue(name.substring(PREFIX.length()));
    }

    private Object getRandomValue(String type) {
        if (type.equals("int")) {
            return getSource().nextInt();
        }
        if (type.equals("long")) {
            return getSource().nextLong();
        }
        String range = getRange(type, "int");
        if (range != null) {
            return getNextIntInRange(range);
        }
        range = getRange(type, "long");
        if (range != null) {
            return getNextLongInRange(range);
        }
        if (type.equals("uuid")) {
            return UUID.randomUUID().toString();
        }
        return getRandomBytes();
    }

    private String getRange(String type, String prefix) {
        if (type.startsWith(prefix)) {
            int startIndex = prefix.length() + 1;
            if (type.length() > startIndex) {
                return type.substring(startIndex, type.length() - 1);
            }
        }
        return null;
    }

    private int getNextIntInRange(String range) {
        String[] tokens = StringUtils.commaDelimitedListToStringArray(range);
        int start = Integer.parseInt(tokens[0]);
        if (tokens.length == 1) {
            return getSource().nextInt(start);
        }
        return start + getSource().nextInt(Integer.parseInt(tokens[1]) - start);
    }

    private long getNextLongInRange(String range) {
        String[] tokens = StringUtils.commaDelimitedListToStringArray(range);
        if (tokens.length == 1) {
            return Math.abs(getSource().nextLong() % Long.parseLong(tokens[0]));
        }
        long lowerBound = Long.parseLong(tokens[0]);
        long upperBound = Long.parseLong(tokens[1]) - lowerBound;
        return lowerBound + Math.abs(getSource().nextLong() % upperBound);
    }

    private Object getRandomBytes() {
        byte[] bytes = new byte[32];
        getSource().nextBytes(bytes);
        return DigestUtils.md5DigestAsHex(bytes);
    }

    public static void addToEnvironment(ConfigurableEnvironment environment) {
        environment.getPropertySources().addAfter(
                StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
                new RandomValuePropertySource(RANDOM_PROPERTY_SOURCE_NAME));
        logger.trace("RandomValuePropertySource add to Environment");
    }

}