接受入參工具類ParameterTool

一、Flink中的ParameterTool工具類

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.flink.api.java.utils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.flink.annotation.Public;
import org.apache.flink.annotation.PublicEvolving;
import org.apache.flink.api.common.ExecutionConfig.GlobalJobParameters;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.util.Preconditions;

@Public
public class ParameterTool extends GlobalJobParameters implements Serializable, Cloneable {
    private static final long serialVersionUID = 1L;
    protected static final String NO_VALUE_KEY = "__NO_VALUE_KEY";
    protected static final String DEFAULT_UNDEFINED = "<undefined>";
    protected final Map<String, String> data;
    protected transient Map<String, String> defaultData;
    protected transient Set<String> unrequestedParameters;

    public static ParameterTool fromArgs(String[] args) {
        Map<String, String> map = new HashMap(args.length / 2);
        int i = 0;

        while(true) {
            while(i < args.length) {
                String key;
                if (args[i].startsWith("--")) {
                    key = args[i].substring(2);
                } else {
                    if (!args[i].startsWith("-")) {
                        throw new IllegalArgumentException(String.format("Error parsing arguments '%s' on '%s'. Please prefix keys with -- or -.", Arrays.toString(args), args[i]));
                    }

                    key = args[i].substring(1);
                }

                if (key.isEmpty()) {
                    throw new IllegalArgumentException("The input " + Arrays.toString(args) + " contains an empty argument");
                }

                ++i;
                if (i >= args.length) {
                    map.put(key, "__NO_VALUE_KEY");
                } else if (NumberUtils.isNumber(args[i])) {
                    map.put(key, args[i]);
                    ++i;
                } else if (!args[i].startsWith("--") && !args[i].startsWith("-")) {
                    map.put(key, args[i]);
                    ++i;
                } else {
                    map.put(key, "__NO_VALUE_KEY");
                }
            }

            return fromMap(map);
        }
    }

    public static ParameterTool fromPropertiesFile(String path) throws IOException {
        File propertiesFile = new File(path);
        return fromPropertiesFile(propertiesFile);
    }

    public static ParameterTool fromPropertiesFile(File file) throws IOException {
        if (!file.exists()) {
            throw new FileNotFoundException("Properties file " + file.getAbsolutePath() + " does not exist");
        } else {
            FileInputStream fis = new FileInputStream(file);
            Throwable var2 = null;

            ParameterTool var3;
            try {
                var3 = fromPropertiesFile((InputStream)fis);
            } catch (Throwable var12) {
                var2 = var12;
                throw var12;
            } finally {
                if (fis != null) {
                    if (var2 != null) {
                        try {
                            fis.close();
                        } catch (Throwable var11) {
                            var2.addSuppressed(var11);
                        }
                    } else {
                        fis.close();
                    }
                }

            }

            return var3;
        }
    }

    public static ParameterTool fromPropertiesFile(InputStream inputStream) throws IOException {
        Properties props = new Properties();
        props.load(inputStream);
        return fromMap(props);
    }

    public static ParameterTool fromMap(Map<String, String> map) {
        Preconditions.checkNotNull(map, "Unable to initialize from empty map");
        return new ParameterTool(map);
    }

    public static ParameterTool fromSystemProperties() {
        return fromMap(System.getProperties());
    }

    private ParameterTool(Map<String, String> data) {
        this.data = Collections.unmodifiableMap(new HashMap(data));
        this.defaultData = new ConcurrentHashMap(data.size());
        this.unrequestedParameters = Collections.newSetFromMap(new ConcurrentHashMap(data.size()));
        this.unrequestedParameters.addAll(data.keySet());
    }

    public boolean equals(Object o) {
        if (this == o) {
            return true;
        } else if (o != null && this.getClass() == o.getClass()) {
            ParameterTool that = (ParameterTool)o;
            return Objects.equals(this.data, that.data) && Objects.equals(this.defaultData, that.defaultData) && Objects.equals(this.unrequestedParameters, that.unrequestedParameters);
        } else {
            return false;
        }
    }

    public int hashCode() {
        return Objects.hash(new Object[]{this.data, this.defaultData, this.unrequestedParameters});
    }

    @PublicEvolving
    public Set<String> getUnrequestedParameters() {
        return Collections.unmodifiableSet(this.unrequestedParameters);
    }

    public int getNumberOfParameters() {
        return this.data.size();
    }

    public String get(String key) {
        this.addToDefaults(key, (String)null);
        this.unrequestedParameters.remove(key);
        return (String)this.data.get(key);
    }

    public String getRequired(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.get(key);
        if (value == null) {
            throw new RuntimeException("No data for required key '" + key + "'");
        } else {
            return value;
        }
    }

    public String get(String key, String defaultValue) {
        this.addToDefaults(key, defaultValue);
        String value = this.get(key);
        return value == null ? defaultValue : value;
    }

    public boolean has(String value) {
        this.addToDefaults(value, (String)null);
        this.unrequestedParameters.remove(value);
        return this.data.containsKey(value);
    }

    public int getInt(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.getRequired(key);
        return Integer.parseInt(value);
    }

    public int getInt(String key, int defaultValue) {
        this.addToDefaults(key, Integer.toString(defaultValue));
        String value = this.get(key);
        return value == null ? defaultValue : Integer.parseInt(value);
    }

    public long getLong(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.getRequired(key);
        return Long.parseLong(value);
    }

    public long getLong(String key, long defaultValue) {
        this.addToDefaults(key, Long.toString(defaultValue));
        String value = this.get(key);
        return value == null ? defaultValue : Long.parseLong(value);
    }

    public float getFloat(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.getRequired(key);
        return Float.valueOf(value);
    }

    public float getFloat(String key, float defaultValue) {
        this.addToDefaults(key, Float.toString(defaultValue));
        String value = this.get(key);
        return value == null ? defaultValue : Float.valueOf(value);
    }

    public double getDouble(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.getRequired(key);
        return Double.valueOf(value);
    }

    public double getDouble(String key, double defaultValue) {
        this.addToDefaults(key, Double.toString(defaultValue));
        String value = this.get(key);
        return value == null ? defaultValue : Double.valueOf(value);
    }

    public boolean getBoolean(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.getRequired(key);
        return Boolean.valueOf(value);
    }

    public boolean getBoolean(String key, boolean defaultValue) {
        this.addToDefaults(key, Boolean.toString(defaultValue));
        String value = this.get(key);
        return value == null ? defaultValue : Boolean.valueOf(value);
    }

    public short getShort(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.getRequired(key);
        return Short.valueOf(value);
    }

    public short getShort(String key, short defaultValue) {
        this.addToDefaults(key, Short.toString(defaultValue));
        String value = this.get(key);
        return value == null ? defaultValue : Short.valueOf(value);
    }

    public byte getByte(String key) {
        this.addToDefaults(key, (String)null);
        String value = this.getRequired(key);
        return Byte.valueOf(value);
    }

    public byte getByte(String key, byte defaultValue) {
        this.addToDefaults(key, Byte.toString(defaultValue));
        String value = this.get(key);
        return value == null ? defaultValue : Byte.valueOf(value);
    }

    protected void addToDefaults(String key, String value) {
        String currentValue = (String)this.defaultData.get(key);
        if (currentValue == null) {
            if (value == null) {
                value = "<undefined>";
            }

            this.defaultData.put(key, value);
        } else if (currentValue.equals("<undefined>") && value != null) {
            this.defaultData.put(key, value);
        }

    }

    public Configuration getConfiguration() {
        Configuration conf = new Configuration();
        Iterator var2 = this.data.entrySet().iterator();

        while(var2.hasNext()) {
            Entry<String, String> entry = (Entry)var2.next();
            conf.setString((String)entry.getKey(), (String)entry.getValue());
        }

        return conf;
    }

    public Properties getProperties() {
        Properties props = new Properties();
        props.putAll(this.data);
        return props;
    }

    public void createPropertiesFile(String pathToFile) throws IOException {
        this.createPropertiesFile(pathToFile, true);
    }

    public void createPropertiesFile(String pathToFile, boolean overwrite) throws IOException {
        File file = new File(pathToFile);
        if (file.exists()) {
            if (!overwrite) {
                throw new RuntimeException("File " + pathToFile + " exists and overwriting is not allowed");
            }

            file.delete();
        }

        Properties defaultProps = new Properties();
        defaultProps.putAll(this.defaultData);
        OutputStream out = new FileOutputStream(file);
        Throwable var6 = null;

        try {
            defaultProps.store(out, "Default file created by Flink's ParameterUtil.createPropertiesFile()");
        } catch (Throwable var15) {
            var6 = var15;
            throw var15;
        } finally {
            if (out != null) {
                if (var6 != null) {
                    try {
                        out.close();
                    } catch (Throwable var14) {
                        var6.addSuppressed(var14);
                    }
                } else {
                    out.close();
                }
            }

        }

    }

    protected Object clone() throws CloneNotSupportedException {
        return new ParameterTool(this.data);
    }

    public ParameterTool mergeWith(ParameterTool other) {
        Map<String, String> resultData = new HashMap(this.data.size() + other.data.size());
        resultData.putAll(this.data);
        resultData.putAll(other.data);
        ParameterTool ret = new ParameterTool(resultData);
        HashSet<String> requestedParametersLeft = new HashSet(this.data.keySet());
        requestedParametersLeft.removeAll(this.unrequestedParameters);
        HashSet<String> requestedParametersRight = new HashSet(other.data.keySet());
        requestedParametersRight.removeAll(other.unrequestedParameters);
        ret.unrequestedParameters.removeAll(requestedParametersLeft);
        ret.unrequestedParameters.removeAll(requestedParametersRight);
        return ret;
    }

    public Map<String, String> toMap() {
        return this.data;
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        this.defaultData = new ConcurrentHashMap(this.data.size());
        this.unrequestedParameters = Collections.newSetFromMap(new ConcurrentHashMap(this.data.size()));
    }
}

 

二、調用示例

import org.apache.flink.api.java.utils.ParameterTool;

public class TestParameterTool {
    public static void main(String[] args) {
        ParameterTool param = ParameterTool.fromArgs(args);
        System.out.println(param.toMap());
        String name = param.get("name");
        String gender = param.get("gender");
        System.out.println(name+gender);
    }
}

輸入：

輸出：

也可以使用文件來進入輸入，如文件內容：

--name yuanhua \
--age 30 \
--minTime.minutes 5 \
--isMan true