HttpClient_closeablehttpclient application-context-CSDN博客

第一步：导入依赖

<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpclient</artifactId>
  <version>4.3.5</version>
 </dependency>

第二步：httpclient和spring整合applicationContext-httpclient.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

	<!-- 定义连接管理器 -->
	<bean id="httpClientConnectionManager"
		class="org.apache.http.impl.conn.PoolingHttpClientConnectionManager"
		destroy-method="close">
		<!-- 设置最大连接数 -->
		<property name="maxTotal" value="${http.maxTotal}" />
		<!-- 设置每个主机地址的并发数 -->
		<property name="defaultMaxPerRoute" value="${http.defaultMaxPerRoute}" />
	</bean>

	<!-- Httpclient构建器 -->
	<bean id="httpClientBuilder" class="org.apache.http.impl.client.HttpClientBuilder">
		<property name="connectionManager" ref="httpClientConnectionManager" />
	</bean>

	<!-- 定义HttpClient对象 -->
	<!-- 该bean一定是多例的 -->
	<bean class="org.apache.http.impl.client.CloseableHttpClient"
		factory-bean="httpClientBuilder" factory-method="build" scope="prototype" />

	<bean id="requestConfigBuilder" class="org.apache.http.client.config.RequestConfig.Builder">
		<!-- 创建连接的最长时间 -->
		<property name="connectTimeout" value="${http.connectTimeout}" />
		<!-- 从连接池中获取到连接的最长时间 -->
		<property name="connectionRequestTimeout" value="${http.connectionRequestTimeout}" />
		<!-- 数据传输的最长时间 -->
		<property name="socketTimeout" value="${http.socketTimeout}" />
		<!-- 提交请求前测试连接是否可用 -->
		<property name="staleConnectionCheckEnabled" value="${http.staleConnectionCheckEnabled}" />
	</bean>

	<!-- 请求参数对象 -->
	<bean class="org.apache.http.client.config.RequestConfig"
		factory-bean="requestConfigBuilder" factory-method="build">
	</bean>
	<!-- 定期清理无效连接 -->
	<bean class="com.taotao.web.httpclient.IdleConnectionEvictor" destroy-method="shutdown">
		<constructor-arg index="0" ref="httpClientConnectionManager"/>
		<constructor-arg index="1" value="${http.waitTime}"/>
	</bean>
</beans>

第三步：写httpclient.properties

http.connectionRequestTimeout=500
http.connectTimeout=5000
http.socketTimeout=30000
http.staleConnectionCheckEnabled=true
http.waitTime=300000
http.maxTotal=200
http.defaultMaxPerRoute=100

第四步：spring配置文件了把httpclient.properties添加上

	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<!-- 允许JVM参数覆盖 -->
		<property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
		<!-- 忽略没有找到的资源文件 -->
		<property name="ignoreResourceNotFound" value="true" />
		<!-- 配置资源文件 -->
		<property name="locations">
			<list>
				<value>classpath:httpclient.properties</value>
				<value>classpath:env.properties</value>
			</list>
		</property>
	</bean>

第五步：写IdleConnectionEvictor类用于定期清理无效的http连接

package com.taotao.web.httpclient;

import org.apache.http.conn.HttpClientConnectionManager;

/**
 * 定期清理无效的http连接
 */
public class IdleConnectionEvictor extends Thread {

    private final HttpClientConnectionManager connMgr;
    
    private Integer waitTime;

    private volatile boolean shutdown;

    public IdleConnectionEvictor(HttpClientConnectionManager connMgr,Integer waitTime) {
        this.connMgr = connMgr;
        this.waitTime = waitTime;
        this.start();
    }

    @Override
    public void run() {
        try {
            while (!shutdown) {
                synchronized (this) {
                    wait(waitTime);
                    // 关闭失效的连接
                    connMgr.closeExpiredConnections();
                }
            }
        } catch (InterruptedException ex) {
            // 结束
        }
    }

    /**
     * 销毁释放资源
     */
    public void shutdown() {
        shutdown = true;
        synchronized (this) {
            notifyAll();
        }
    }
}

第六步：写HttpResult

package com.taotao.common.bean;

public class HttpResult {
    private Integer code;

    private String data;

    public HttpResult() {
    }

    public HttpResult(Integer code, String data) {
        this.code = code;
        this.data = data;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

第七步：封装ApiService

package com.taotao.web.service;

import java.io.IOException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.taotao.common.bean.HttpResult;

@Service
public class ApiService {

    @Autowired
    private CloseableHttpClient httpclient;

    @Autowired
    private RequestConfig requestConfig;

    /**
     * 执行GET请求，200返回响应内容，其他状态码返回null
     * 
     * @param url
     * @return
     * @throws ClientProtocolException
     * @throws IOException
     */
    public String doGet(String url) throws ClientProtocolException, IOException {
        // 创建http GET请求
        HttpGet httpGet = new HttpGet(url);
        // 设置请求参数
        httpGet.setConfig(this.requestConfig);
        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                return EntityUtils.toString(response.getEntity(), "UTF-8");
            }
        } finally {
            if (response != null) {
                response.close();
            }
        }
        return null;
    }

    /**
     * 指定带有参数的GET请求
     * 
     * @param url
     * @param param
     * @return
     * @throws ClientProtocolException
     * @throws IOException
     * @throws URISyntaxException
     */
    public String doGet(String url, Map<String, String> param) throws ClientProtocolException, IOException,
            URISyntaxException {
        URIBuilder builder = new URIBuilder(url);
        for (Map.Entry<String, String> entry : param.entrySet()) {
            builder.addParameter(entry.getKey(), entry.getValue());
        }
        return doGet(builder.build().toString());
    }

    /**
     * 带有参数的post请求
     * 
     * @param url
     * @param param
     * @return
     * @throws ClientProtocolException
     * @throws IOException
     */
    public HttpResult doPost(String url, Map<String, String> param) throws ClientProtocolException,
            IOException {
        // 创建http POST请求
        HttpPost httpPost = new HttpPost(url);
        // 设置请求参数
        httpPost.setConfig(this.requestConfig);
        if (null != param) {
            // 设置post参数
            List<NameValuePair> parameters = new ArrayList<NameValuePair>(0);
            for (Map.Entry<String, String> entry : param.entrySet()) {
                parameters.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            // 构造一个form表单式的实体
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters, "UTF-8");
            // 将请求实体设置到httpPost对象中
            httpPost.setEntity(formEntity);
        }

        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpclient.execute(httpPost);
            return new HttpResult(response.getStatusLine().getStatusCode(), EntityUtils.toString(
                    response.getEntity(), "UTF-8"));
        } finally {
            if (response != null) {
                response.close();
            }
        }
    }

    /**
     * 执行post请求
     * 
     * @param url
     * @return
     * @throws ClientProtocolException
     * @throws IOException
     */
    public HttpResult doPost(String url) throws ClientProtocolException, IOException {
        return doPost(url, null);
    }

}

第八步：EasyUIResult

package com.taotao.common.bean;

import java.util.List;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class EasyUIResult {

    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();

    private Integer total;

    private List<?> rows;

    public EasyUIResult() {
    }

    public EasyUIResult(Integer total, List<?> rows) {
        this.total = total;
        this.rows = rows;
    }

    public EasyUIResult(Long total, List<?> rows) {
        this.total = total.intValue();
        this.rows = rows;
    }

    public Integer getTotal() {
        return total;
    }

    public void setTotal(Integer total) {
        this.total = total;
    }

    public List<?> getRows() {
        return rows;
    }

    public void setRows(List<?> rows) {
        this.rows = rows;
    }

    /**
     * Object是集合转化
     * 
     * @param jsonData json数据
     * @param clazz 集合中的类型
     * @return
     */
    public static EasyUIResult formatToList(String jsonData, Class<?> clazz) {
        try {
            JsonNode jsonNode = MAPPER.readTree(jsonData);
            JsonNode data = jsonNode.get("rows");
            List<?> list = null;
            if (data.isArray() && data.size() > 0) {
                list = MAPPER.readValue(data.traverse(),
                        MAPPER.getTypeFactory().constructCollectionType(List.class, clazz));
            }
            return new EasyUIResult(jsonNode.get("total").intValue(), list);
        } catch (Exception e) {
            return null;
        }
    }

}

第九步：IndexService

package com.taotao.web.service;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.taotao.common.bean.EasyUIResult;
import com.taotao.manage.pojo.Content;

@Service
public class IndexService {
    public static final ObjectMapper MAPPER=new ObjectMapper();
    @Value("${MANAGE_TAOTAO_URL}")
    String MANAGE_TAOTAO_URL;
    @Value("${INDEX_AD1_URL}")
    String INDEX_AD1_URL;
    @Autowired
    private ApiService apiService;
//       //方法一 
//    public String getIndexAd1() {
//        // 通过调用后台系统系统的接口获取数据
//        String url = MANAGE_TAOTAO_URL + INDEX_AD1_URL;
//        try {
//            String jsonData = this.apiService.doGet(url);
//            // 解析json，获取需要的数据
//            // 封装成前端所需的格式
//
//            JsonNode jsonNode = MAPPER.readTree(jsonData);
//            ArrayNode arrayNode = (ArrayNode) jsonNode.get("rows");
//
//            List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
//
//            for (JsonNode node : arrayNode) {
//                Map<String, Object> map = new LinkedHashMap<String, Object>();
//                map.put("srcB", node.get("pic").asText());
//                map.put("height", 240);
//                map.put("alt", node.get("title").asText());
//                map.put("width", 670);
//                map.put("src", map.get("srcB"));
//                map.put("widthB", 550);
//                map.put("href", node.get("url").asText());
//                map.put("heightB", 240);
//
//                result.add(map);
//            }
//            //将java对象序列化成json
//            return MAPPER.writeValueAsString(result);
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
        //方法二
        @SuppressWarnings("unchecked")
        public String getIndexAd1() {
          // 通过调用后台系统系统的接口获取数据
          String url = MANAGE_TAOTAO_URL + INDEX_AD1_URL;
          try {
              String jsonData = this.apiService.doGet(url);
              // 解析json，获取需要的数据
              // 封装成前端所需的格式
    
              EasyUIResult easyUIResult=EasyUIResult.formatToList(jsonData, Content.class);
              List<Content> contents=(List<Content>) easyUIResult.getRows();
              List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
    
              for (Content content : contents) {
                  Map<String, Object> map = new LinkedHashMap<String, Object>();
                  map.put("srcB", content.getPic());
                  map.put("height", 240);
                  map.put("alt",content.getTitle() );
                  map.put("width", 670);
                  map.put("src", map.get("srcB"));
                  map.put("widthB", 550);
                  map.put("href", content.getUrl());
                  map.put("heightB", 240);
    
                  result.add(map);
              }
              //将java对象序列化成json
              return MAPPER.writeValueAsString(result);
    
          } catch (Exception e) {
              e.printStackTrace();
          }
          return null;
      }
}

第十步：env.properties

MANAGE_TAOTAO_URL=http://manage.taotao.com
INDEX_AD1_URL=/rest/content?categoryId=52&page=1&rows=20

第十一步：IndexController

package com.taotao.web.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.taotao.web.service.IndexService;

@Controller
public class IndexController {
    @Autowired
    private IndexService indexService;
    /**
     * 首页
     */
    @RequestMapping(value="index",method = RequestMethod.GET)
    public ModelAndView index(){
        ModelAndView mv=new ModelAndView("index");
        //查询大广告数据
        mv.addObject("indexAd1",this.indexService.getIndexAd1());
        return mv;
    }
}

第十二步：页面获取数据

${indexAd1}