获取当前项目的web-inf路径，加载配置文件，定时刷新

package com.demo;


import net.sf.json.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * demo
 *
 * @author lane
 * @since 2018-12-12
 */
public class DemoServlet extends HttpServlet
{
    private static final Logger LOGGER = Logger.getLogger(Thread.currentThread().getStackTrace()[1].getClassName());

    /**
     * propertiesMap缓存存储时间,每${cacheTimeOut}清除一次propertiesMap,重新读取properties,方便修改地址且无需重启项目
     */
    private Long cacheTimeOut = 60 * 100L;
    /**
     * 上一次清除时间
     */
    private Long lastClearTime = 0L;
    /**
     * 存储*.properties的map
     */
    private Map<String, String> propertiesMap = new HashMap<String, String>();

    @Override
    public void init() throws ServletException
    {
        super.init();
        new ClearThread().start();
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
    {
        try
        {
            doPost(req, resp);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException
    {
        // 获取所需的远程地址，无则重新从配置文件加载
        String url = propertiesMap.get("url");
        if (null == url)
        {
            InputStream in = this.getServletContext().getResourceAsStream("/WEB-INF/config/properties/sampleProperties.properties");
            Properties prop = new Properties();
            prop.load(in);
            // 获取请求地址
            url = prop.getProperty("url");
            propertiesMap.put("url", url);
        }

        // 设置返回内容类型
        resp.setContentType("text/html;charset=utf-8");

        // 从request里获取参数
        Map<String, Object> requestMap = getRequestParamMap(req);

        // 请求远程接口
        String resultJson = HttpClientUtil.post(url, requestMap, "utf-8");

        // 返回扫码结果到页面
        PrintWriter out = resp.getWriter();
        out.write(resultJson);
        out.flush();
        out.close();
    }

    /**
     * 获取request中的参数，并将所有参数封装成map
     *
     * @param request
     * @return
     */
    private Map<String, Object> getRequestParamMap(HttpServletRequest request)
    {
        Map<String, Object> requestMap = new HashMap<String, Object>();
        //得到枚举类型的参数名称，参数名称若有重复的只能得到第一个
        Enumeration enums = request.getParameterNames();
        while (enums.hasMoreElements())
        {
            String paramName = (String) enums.nextElement();
            String paramValue = request.getParameter(paramName);
            //形成键值对应的map
            requestMap.put(paramName, paramValue);
        }
        return requestMap;
    }

    /**
     * 定期清除缓存
     */
    private class ClearThread extends Thread
    {
        @Override
        public void run()
        {
            while (true)
            {
                try
                {
                    long currentTime = System.currentTimeMillis();

                    if (currentTime - lastClearTime >= cacheTimeOut)
                    {
                        synchronized (propertiesMap)
                        {
                            lastClearTime = currentTime;
                            propertiesMap.clear();
                        }
                    }
                    Thread.sleep(cacheTimeOut);
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 获取WEB-INF路径
     *
     * @return
     */
    private String getWebInfPath()
    {
        String path = Thread.currentThread().getContextClassLoader().getResource("").toString();
        path = path.replace("file:/", "");
        path = path.replace("classes/", "");
        return path;
    }

    static class HttpClientUtil
    {
        /**
         * 发送post请求
         *
         * @param uri     地址
         * @param data    数据
         * @param charset 编码格式(缺省:utf-8)
         * @return json字符串
         */
        public static String post(String uri, Map<String, Object> data, String charset)
        {
            HttpClient client = new DefaultHttpClient();

            String json = null;
            try
            {
                StringEntity reqEntity = new StringEntity(JSONObject.fromObject(data).toString());
                reqEntity.setContentEncoding(charset != null ? charset : "utf-8");
                reqEntity.setContentType("application/json");

                HttpPost post = new HttpPost(uri);
                post.setEntity(reqEntity);
                HttpResponse res = client.execute(post);

                if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK)
                {
                    HttpEntity entity = res.getEntity();
                    if (entity != null)
                    {
                        json = EntityUtils.toString(entity);
                    }
                }
                else
                {
                    LOGGER.info("返回http状态码[" + res.getStatusLine().getStatusCode() + "]，请检查请求报文或者请求地址是否正确");
                }
            }
            catch (Exception e)
            {
                LOGGER.error(e.getMessage());
            }
            finally
            {
                client.getConnectionManager().shutdown();
            }
            return json;
        }
    }
}