com.payneteasy.startup.parameters.StartupParametersInvocationHandler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of startup-parameters Show documentation
Read system parameters and environment variable
The newest version!
package com.payneteasy.startup.parameters;

import java.io.File;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.logging.Logger;

public class StartupParametersInvocationHandler implements InvocationHandler {

    private static final Logger LOG = Logger.getLogger(StartupParametersInvocationHandler.class.getName());

    private final Map parameters;

    public  StartupParametersInvocationHandler(Class aClass) {
        parameters = new HashMap<>();

        SortedMap names = new TreeMap<>();
        for (Method method : aClass.getMethods()) {
            if(!method.isAnnotationPresent(AStartupParameter.class)) {
                continue;
            }

            AStartupParameter parameterAnnotation = method.getAnnotation(AStartupParameter.class);
            parameters.put(method.getName(), getValue(method, parameterAnnotation));
            names.put(parameterAnnotation.name(), method.getName());
        }

        int max = parameters.values().stream().map(startupParameter -> startupParameter.name.length()).max(Integer::compare).get();
        LOG.info("Startup parameters:");
        for (Map.Entry entry : names.entrySet()) {
            StartupParameter param = parameters.get(entry.getValue());
            LOG.info(String.format("    %s %s = %s", param.from, pad(param.name, max), param.value));
        }
    }

    private CharSequence pad(String aText, int aMax) {
        StringBuilder sb = new StringBuilder(aMax);
        sb.append(aText);
        while ( sb.length() < aMax) {
            sb.append(' ');
        }
        return sb;
    }

    private StartupParameter getValue(Method aMethod, AStartupParameter aAnnotation) {
        String name = aAnnotation.name();
        String defaultValue = aAnnotation.value();
        ValueFrom valueFrom = getValue(name, defaultValue);
        String textValue = valueFrom.value;

        Class type = aMethod.getReturnType();
        Object value;
        if(type == int.class) {
            value = Integer.parseInt(textValue);
        } else if (type == boolean.class) {
            value = Boolean.parseBoolean(textValue);
        } else if (type == long.class) {
            value = Long.parseLong(textValue);
        } else if(type == String.class) {
            value =  textValue;
        } else if(type == File.class) {
            value =  new File(textValue);
        } else {
            throw new IllegalStateException("Type " + type + " is unsupported for method " + aMethod);
        }

        return new StartupParameter(name, value, valueFrom.from);
    }

    private ValueFrom getValue(String aName, String aDefaultValue) {
        String value = System.getProperty(aName);
        if(hasText(value)) {
            return new ValueFrom(value, "p");
        }

        value = System.getenv(aName);
        if(hasText(value)) {
            return new ValueFrom(value, "e");
        }

        return new ValueFrom(aDefaultValue, "d");
    }

    private boolean hasText(String aText) {
        return aText != null && aText.trim().length() > 0;
    }

    @Override
    public Object invoke(Object aProxy, Method aMethod, Object[] aArgs) throws Throwable {
        return parameters.get(aMethod.getName()).value;
    }

    private static class ValueFrom {
        private final String value;
        private final String from;

        public ValueFrom(String value, String from) {
            this.value = value;
            this.from = from;
        }
    }
}