Tomcat Portdetection

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import javax.management.*;
import javax.servlet.http.HttpServletRequest;
import java.lang.management.ManagementFactory;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.*;

/**
 * Utility for working with Tomcat.
 *
 * @author Serhat Cinar
 */
public final class TomcatUtil2 {
    private static final Logger LOG = LogManager.getLogger(TomcatUtil2.class);
    private static TomcatUtil2 INSTANCE;
    private Map<String, Integer> portsByScheme = null;

    private TomcatUtil2() {
    }

    public static synchronized TomcatUtil2 getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new TomcatUtil2();
            try {
                INSTANCE.init();
            } catch (MalformedObjectNameException | AttributeNotFoundException |
                    InstanceNotFoundException | MBeanException |
                    ReflectionException e) {
                throw new RuntimeException(e);
            }
        }
        return INSTANCE;
    }

    /**
     * Finds all scheme / port definitiona via MBeans for Catalina.
     *
     */
    private void init() throws MalformedObjectNameException, AttributeNotFoundException,
            InstanceNotFoundException, MBeanException, ReflectionException{
        portsByScheme = new HashMap();

        final MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
        findPortsByScheme(portsByScheme, mBeanServer);
        logInfo();
    }

    private void logInfo(){
        LOG.info("Initializing scheme -> port mappings: " + portsByScheme);

        if (portsByScheme.isEmpty() || portsByScheme.get("http") == null || portsByScheme.get("https") == null) {
            final StringBuilder warning = new StringBuilder();
            if (portsByScheme.isEmpty()) {
                warning.append("No port- or schema-informations found.");
            } else {
                if (portsByScheme.get("http") == null) {
                    warning.append("No port- or schema-information found for schema HTTP.");
                }
                if (portsByScheme.get("https") == null) {
                    warning.append("No port- or schema-information found for schema HTTPS.");
                }
            }
            LOG.warn(warning.toString());
        }

    }

    /**
     * Returns a map with key = scheme (http, https) and value = port.
     *
     * @return
     */
    public Map<String, Integer> getPortsByScheme() {
        return Collections.unmodifiableMap(portsByScheme);
    }

    private static void findPortsByScheme(Map<String, Integer> portsByScheme, MBeanServer mBeanServer)
            throws MalformedObjectNameException, AttributeNotFoundException, InstanceNotFoundException, MBeanException,
            ReflectionException {

        // Filtering by scheme and protocol.
        // Protocol String contained sometimes "HTTP/1.1" and sometimes
        // the name of the class, like "org.apache.coyote.http11.Http11AprProtocol" (depending on the tomcat Version)
        final Set<ObjectName> objectNames = mBeanServer.queryNames(new ObjectName("*:type=Connector,*"),
                Query.and(
                    Query.or(
                       Query.match(Query.attr("scheme"), Query.value("http")),
                       Query.match(Query.attr("scheme"), Query.value("https"))
                    ),
                    Query.or(
                            Query.anySubString(Query.attr("protocol"), Query.value("HTTP")),
                            Query.or(
                                    Query.anySubString(Query.attr("protocol"), Query.value("Http")),
                                    Query.anySubString(Query.attr("protocol"), Query.value("http"))
                            )
                    )
                )
        );

        for (final ObjectName objectName : objectNames) {
            final String scheme = String.valueOf(mBeanServer.getAttribute(objectName, "scheme"));
            final String port = objectName.getKeyProperty("port");
            portsByScheme.put(scheme, Integer.valueOf(port));
        }
    }

    /**
     * Returns the portnumber for the given scheme (http or https).
     * 
     * @param scheme "http" or "https"
     * @return
     */
    public Integer getPortByScheme(final String scheme) {
        return getPortsByScheme().get(scheme);
    }

    /**
     * Returns a HTTP-URL for the given httpRequest, whether it's HTTP or HTTPS.<br/>
     * {@code TomcatUtil.getInstance().generateHttpUrl( myHttpRequest, "page.html") }
     * will generate "http://localhost:8080/myApp/page.html" on most default configurations,
     * when the httpRequest belongs to "myApp" and the page is set to "page.html".
     *
     * @param httpRequest
     * @param page
     * @return
     * @throws MalformedURLException
     */
    public String generateHttpUrl(final HttpServletRequest httpRequest, final String page) throws MalformedURLException {
        return generateUrl(httpRequest, page, "http");
    }

    /**
     * Returns a HTTPS-URL for the given httpRequest, whether it's HTTP or HTTPS.<br/>
     * {@code TomcatUtil.getInstance().generateHttpsUrl( myHttpRequest, "page.html") }
     * will generate "https://localhost:8443/myApp/page.html" on most default configurations,
     * when the httpRequest belongs to "myApp" and the page is set to "page.html".
     *
     * @param httpRequest
     * @param page
     * @return
     * @throws MalformedURLException
     */
    public String generateHttpsUrl(final HttpServletRequest httpRequest, final String page) throws MalformedURLException {
        return generateUrl(httpRequest, page, "https");
    }

    /**
     * Returns a HTTP/HTTPS-URL for the given httpRequest, whether it's HTTP or HTTPS.
     *
     * @param httpRequest
     * @param page
     * @return
     * @throws MalformedURLException
     * @see #generateHttpsUrl(HttpServletRequest, String)
     * @see #generateHttpUrl(HttpServletRequest, String)
     */
    public String generateUrl(final HttpServletRequest httpRequest, final String page, final String scheme) throws MalformedURLException {
        String targetPage = page;
        if (targetPage != null && !targetPage.startsWith("/")) {
            targetPage = "/" + targetPage;
        }
        final String requestUrlStr = httpRequest.getRequestURL().toString();
        final URL requestUrl = new URL(requestUrlStr);
        final URL secureUrl = new URL(scheme, requestUrl.getHost(), getPortByScheme(scheme), httpRequest.getContextPath() + targetPage);
        return secureUrl.toString();
    }

    /**
     * See {@link #generateHttpUrl(HttpServletRequest, String)}.<br/>
     * Here page will be set to {@code httpRequest.getServletPath()}.
     * 
     * @param httpRequest
     * @return
     * @throws MalformedURLException
     * @see #generateHttpUrl(HttpServletRequest, String)
     */
    public String generateHttpUrl(final HttpServletRequest httpRequest) throws MalformedURLException {
        return generateHttpUrl(httpRequest, httpRequest.getServletPath());
    }

    /**
     * See {@link #generateHttpsUrl(HttpServletRequest, String)}.<br/>
     * Here page will be set to {@code httpRequest.getServletPath()}.
     *
     * @param httpRequest
     * @return
     * @throws MalformedURLException
     * @see #generateHttpUrls(HttpServletRequest, String)
     */
    public String generateHttpsUrl(final HttpServletRequest httpRequest) throws MalformedURLException {
        return generateHttpsUrl(httpRequest, httpRequest.getServletPath());
    }
}