web.xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
version="2.4"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<!-- spring 监听-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- spring 字符集过滤 -->
<filter>
<filter-name>CharacterEncoding</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter
</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncoding</filter-name>
<url-pattern>*.action</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>CharacterEncoding</filter-name>
<url-pattern>*.htm</url-pattern>
</filter-mapping>
<!-- spring mvc -->
<servlet>
<servlet-name>http</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:conf/freemarker-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>http</servlet-name>
<url-pattern>*.action</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>http</servlet-name>
<url-pattern>*.htm</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>120</session-timeout>
</session-config>
<!-- welcome file -->
<welcome-file-list>
<welcome-file>homePage.htm</welcome-file>
</welcome-file-list>
<!-- error-page -->
<error-page>
<!-- 400错误 请求无效 -->
<error-code>400</error-code>
<location>/400.htm</location>
</error-page>
<error-page>
<!-- 404页面不存在 -->
<error-code>404</error-code>
<location>/404.htm</location>
</error-page>
<error-page>
<!-- 405无效链接 -->
<error-code>405</error-code>
<location>/405.htm</location>
</error-page>
<error-page>
<!-- 500 服务器内部错误 -->
<error-code>500</error-code>
<location>/500.htm</location>
</error-page>
</web-app>
applicationContext.xml配置文件：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd"
default-lazy-init="false">
<!-- 资源文件 -->
<context:property-placeholder location="classpath:/conf/setting-web.properties" />
<!-- DB2 dataSource-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- 定义事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="insert*" propagation="REQUIRED" read-only="false"
rollback-for="java.lang.Exception" />
<tx:method name="save*" propagation="REQUIRED" read-only="false"
rollback-for="java.lang.Exception" />
<tx:method name="update*" propagation="REQUIRED" read-only="false"
rollback-for="java.lang.Exception" />
<tx:method name="modify*" propagation="REQUIRED" read-only="false"
rollback-for="java.lang.Exception" />
<tx:method name="delete*" propagation="REQUIRED" read-only="false"
rollback-for="java.lang.Exception" />
<tx:method name="find*" propagation="SUPPORTS" />
<tx:method name="get*" propagation="SUPPORTS" />
<tx:method name="select*" propagation="SUPPORTS" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="bizMethods"
expression="execution(* org.apache.ecity.*.service.*.*(..)) or execution(* org.apache.ecity.*.*.service.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="bizMethods" />
</aop:config>
<!-- service 层Bean -->
<import resource="classpath*:/conf/bean/*-bean.xml" />
<context:annotation-config />
</beans>
freemarker-servlet.xml SpringMVC配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!-- 引入资源文件 -->
<context:property-placeholder location="classpath:/conf/setting-web.properties" />
<!-- Spring 扫描使用注解的包路径 -->
<context:component-scan
base-package="org.apache.remote.httpclient" />
<!-- 注解依赖的适配器 AnnotationMethodHandlerAdapter -->
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="messageConverters">
<list>
<ref bean="mappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>
<!-- 注解依赖的适配器 DefaultAnnotationHandlerMapping -->
<bean
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
</bean>
<!-- Spring @AutoWired 依赖自动注入,不需要setter方法 -->
<bean
class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />
<!-- FreeMarker模板配置 -->
<bean id="freemarkerConfig"
class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
<!-- FreeMarker模板路径前缀,Controller方法返回FTL文件路径是可以省略前缀,比如/WEB-INF/ftl/sys/province/main.ftl,只需要返回 sys/province/main-->
<property name="templateLoaderPath" value="/WEB-INF/ftl/" />
<property name="defaultEncoding" value="UTF-8" />
</bean>
<!-- FreeMarker视图解析器 -->
<bean
class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
<property name="cache" value="true" />
<property name="prefix" value="" />
<property name="suffix" value=".ftl" />
<property name="exposeSpringMacroHelpers" value="true" />
<property name="exposeRequestAttributes" value="true" />
<property name="exposeSessionAttributes" value="true" />
<property name="requestContextAttribute" value="request" />
<property name="contentType" value="text/html; charset=utf-8" />
</bean>
<!-- Spring JSON 格式转换依赖的Jar -->
<bean id="mappingJacksonHttpMessageConverter"
class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</beans>
import java.io.IOException;
import java.io.InputStream;
import java.net.ConnectException;
import java.net.SocketTimeoutException;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.params.HttpParams;
import org.testng.annotations.Test;
/**
* 〈一句话功能简述〉<br>
* 〈功能详细描述〉
*
* @see [相关类/方法]（可选）
* @since [产品/模块版本] （可选）
*/
public class HttpClientTest {
/**
*
* 测试Get请求,无请求实体，仅仅是通过URL发送请求 <br>
* 〈功能详细描述〉
*
* @throws RscException
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@Test
public void testGetHttpRequest(){
HttpGet httpGet=new HttpGet("http://lxf.cnsuning.com:8080/sel-web/cm/tesGetRequest.action?param1=1¶m1=2¶m3=3");
try {
HttpClient httpClient=new DefaultHttpClient();
HttpParams httpParams= httpClient.getParams();
// 设置Http协议的版本
httpParams.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
// 设置请求连接超时时间
httpParams.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 1000);
// 设置请求响应超时时间
httpParams.setParameter(CoreConnectionPNames.SO_TIMEOUT, 5000);
//以Get方式发送Http请求
HttpResponse httpResponse=httpClient.execute(httpGet);
HttpEntity httpEntity=httpResponse.getEntity();
InputStream inputStream=httpEntity.getContent();
byte[] b=new byte[2048];
int length=0;
StringBuffer responseContent=new StringBuffer();
while((length=inputStream.read(b))!=-1){
responseContent.append(new String(b,0,length));
}
System.out.println(responseContent.toString());
} catch (Exception e) {
//释放连接
if(httpGet!=null){
httpGet.abort();
}
if(SocketTimeoutException.class.isInstance(e)){
throw new RuntimeException("Http请求响应超时",e);
}
else if(ConnectTimeoutException.class.isInstance(e)){
throw new RuntimeException("Http请求连接超时", e);
}
else if(ConnectException.class.isInstance(e)){
throw new RuntimeException("Http请求异常", e);
}else{
throw new RuntimeException("其他异常", e);
}
}
}
}
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@RequestMapping(value = "/cm")
@Controller
@SuppressWarnings("unchecked")
public class TestHttpClientController {
/**
*
* 测试get请求 <br>
* 〈功能详细描述〉
*
* @param request
* @param reponse
* @throws IOException
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@SuppressWarnings("rawtypes")
@RequestMapping(value = "tesGetRequest.action")
public void tesGetRequest(HttpServletRequest request, HttpServletResponse reponse) throws IOException {
// 获取请求参数
Map params = getRequestMap(request);
System.out.println(params);
// 响应的报文,需要根据业务去拼装响应报文
String responseXml = "响应报文";
// 返回响应报文,响应报文要根据实际业务来决定是否返回响应报文给请求方
reponse.getOutputStream().write(responseXml.getBytes());
}
/**
*
* 根据request将请求参数转化为Map<br>
* 〈功能详细描述〉
*
* @param request
* @return
* @see [相关类/方法](可选)
* @since [产品/模块版本](可选)
*/
@SuppressWarnings("rawtypes")
private Map<String, Object> getRequestMap(HttpServletRequest request) {
// 获取请求参数
Map parameterMap = request.getParameterMap();
Set<Map.Entry<String, String[]>> entrySet = parameterMap.entrySet();
// 定义转化后的请求Map
Map<String, Object> params = new HashMap<String, Object>();
for (Entry<String, String[]> entry : entrySet) {
// 如果请求的参数的值是数组
if (entry.getValue().length > 1) {
params.put(entry.getKey(), entry.getValue());
} else {
params.put(entry.getKey(), entry.getValue()[0]);
}
}
return params;
}
}
分享到：
相关推荐
### Java HttpClient 发送GET请求和带有表单参数的POST请求详解 #### 一、概述 在Java编程中，处理HTTP请求是一项常见的需求，特别是在与Web服务进行交互时。Apache HttpClient库提供了一种强大的方法来执行HTTP...
同时，通过阅读如"HttpClient发送get请求和post请求"这样的博客，你可以获取更多关于HttpClient实战中的技巧和最佳实践。在提供的压缩包文件中，`test-demo`和`httpclient-demo`可能包含了这些示例的源码，供你...
4. **执行请求**：通过HttpClient的`execute()`方法发送请求。 5. **处理响应**：获取`HttpResponse`对象，解析响应码和响应内容。 ### GET请求 GET请求用于从服务器获取资源，其使用方式比POST简单： 1. **创建...
以下是一个使用HttpClient发送GET请求的Java代码示例： ```java import org.apache.http.HttpResponse; import org.apache.http.client.methods.HttpGet; import org.apache.http.impl.client.CloseableHttpClient;...
4. 使用HttpClient的execute()方法发送请求，并获取HttpResponse对象。 5. 解析HttpResponse，获取状态码、响应头和实体内容。 6. 清理资源，关闭连接。 在实际开发中，你可能还需要考虑错误处理、重试策略、连接池...
1. GET请求：HttpClientUtil中的GET方法通常会创建一个HttpGet对象，设置请求的URL，并通过HttpClient的execute方法发送请求。响应结果可以通过HttpEntity获取，然后解析成字符串或者特定的对象，例如JSON或XML。 2...
以下是一个简单的GET请求示例： ```java CloseableHttpClient httpClient = HttpClients.createDefault(); HttpGet httpGet = new HttpGet("http://example.com"); CloseableHttpResponse response = httpClient....
本文将详细介绍如何使用Apache HttpClient发送POST和GET请求，并处理请求的结果。 #### 二、HttpClient简介 Apache HttpClient是一个高效、功能丰富的客户端HTTP组件，用于构建基于HTTP的应用程序。它支持多种协议...
例如，为执行GET请求，可以创建一个`HttpGet`对象，并设置目标URL。 4. **配置请求头**：如果接口需要特定的请求头，比如Content-Type或Authorization，可以在请求对象上设置这些头。 5. **执行请求**：使用...
- 如果需要发送 JSON 数据，可以使用 `StringEntity`，设置合适的 Content-Type，如 `ContentType.APPLICATION_JSON`，然后将其设置为请求实体。 5. **处理响应**： 在执行请求后，通常需要处理 `HttpResponse`。...
例如，要发送GET请求，可以这样创建： ```java HttpGet httpGet = new HttpGet("http://example.com"); ``` 对于POST请求，我们可以在`HttpPost`对象中设置请求参数： ```java HttpPost httpPost = new HttpPost...
// 发送HTTPS GET请求 public static String sendHttpGet(String url) throws Exception { CloseableHttpClient httpClient = HttpClients.createDefault(); HttpGet httpGet = new HttpGet(url); ...
首先，理解POST请求：与GET请求不同，POST请求通常用于向服务器发送数据，例如提交表单或上传文件。在我们的场景中，我们发送的是JSON（JavaScript Object Notation）数据，这是一种轻量级的数据交换格式，易于人...
在 Java 中发送 GET 和 POST 请求是非常常见的操作，今天我们将通过使用 Apache HttpClient 库来实现这些操作。 什么是 Apache HttpClient 库？ Apache HttpClient 库是 Apache 软件基金会提供的一个开源库，用于...
GET请求通常用于获取服务器上的资源，它将参数附加到URL中，具有可缓存、可被书签、地址栏可见等特性。POST请求则用于向服务器提交数据，常用于创建或更新资源，其参数包含在请求体中，对用户相对隐蔽。 HttpClient...
- **构建HttpGet请求**：使用`HttpGet`类创建一个HTTP GET请求，指定要下载的URL作为参数。 - **设置请求头**（可选）：如果URL需要身份验证或其他特定头信息，可以通过`setHeader()`方法添加。 - **执行请求**：...
2. **创建请求实体**：可以使用`StringEntity`、`UrlEncodedFormEntity`等类创建请求实体，填充要发送的数据。 3. **设置请求头**：如`Content-Type`，表明数据格式，可能是`application/x-www-form-urlencoded`...
这里我们详细探讨一下如何使用`HttpClient`发送POST请求，以及这个过程中的关键知识点。 首先，我们创建一个`CloseableHttpClient`对象，这相当于在编程环境中模拟了一个浏览器。`HttpClients.createDefault()`方法...
使用HttpClient的`execute(HttpUriRequest request)`方法发送请求。这个方法会返回一个`HttpResponse`对象，其中包含了服务器的响应。 5. **处理响应**： 从`HttpResponse`中获取状态码（`getStatusLine()....