输入网址返回json字符串，并用httpclient去调用，spingmvc处理httpclient传过来的参数...

虽然简单，但是我这记性着实算不上好，还是在此记录下吧。

新建web工程，如下

导入需要的jar包：

用于支持json springmvc spring  httpclient  log4j

开始编写web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    
    <!-- 配置DispatchcerServlet -->
    <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>classpath:log4j.properties</param-value>
    </context-param>
    <!-- 60s 检测日志配置 文件变化 -->
    <context-param>
        <param-name>log4jRefreshInterval</param-name>
        <param-value>60000</param-value>
    </context-param>
 
    <!-- 配置Log4j监听器 -->
    <listener>
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置Spring mvc下的配置文件的位置和名称 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    
</web-app>

web.xml中加载了log4j.properties和springmvc.xml两个配置文件 ，这两个配置文件都是放在src下面的，如下:

<?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:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
        <!-- 注解驱动 -->
        <context:annotation-config />  
        <mvc:annotation-driven />
        <mvc:resources mapping="/js/**" location="/js/" />
        <!-- 配置自动扫描的包 -->
        <context:component-scan base-package="com.jackie.springmvc"></context:component-scan>
        
        <!-- 配置视图解析器 如何把handler 方法返回值解析为实际的物理视图 -->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name = "prefix" value="/WEB-INF/views/"></property>
            <property name = "suffix" value = ".jsp"></property>
        </bean>
        <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
            <property name="messageConverters">
                <list>
                    <!--json视图拦截器，读取到@ResponseBody的时候去配置它-->
                    <ref bean="mappingJacksonHttpMessageConverter"/>
                </list>
            </property>
        </bean>
        <!--json转化器，它可以将结果转化-->
        <bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="supportedMediaTypes">
                <list>
                    <value>application/json;charset=UTF-8</value>
                </list>
            </property>
        </bean>
</beans>

### \u8BBE\u7F6E###
log4j.rootLogger = INFO,stdout,D,E

### \u8F93\u51FA\u4FE1\u606F\u5230\u63A7\u5236\u62AC ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### \u8F93\u51FADEBUG \u7EA7\u522B\u4EE5\u4E0A\u7684\u65E5\u5FD7\u5230=E://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://logs/log.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG 
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### \u8F93\u51FAERROR \u7EA7\u522B\u4EE5\u4E0A\u7684\u65E5\u5FD7\u5230=E://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =E://logs/error.log 
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR 
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

现在开始写java代码

package com.jackie.springmvc.handlers;

import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloWorld {
    Map<String ,String> map = new HashMap<String ,String>();
    
    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    /**
     * 1. 使用RequestMapping注解来映射请求的URL
     * 2. 返回值会通过视图解析器解析为实际的物理视图, 对于InternalResourceViewResolver视图解析器，会做如下解析
     * 通过prefix+returnVal+suffix 这样的方式得到实际的物理视图，然后会转发操作
     * "/WEB-INF/views/success.jsp"
     * @return
     */
    @ResponseBody
    @RequestMapping("/helloworld")
    public Map<String ,String> hello(){
        public Map<String ,String> hello(){
        map.put("username", "seven1");
        map.put("password", "seven2");
        map.put("message", "seven3");
        return map;
    }
    }
    
    @RequestMapping("/helloworld1")
    //因为springmvc.xml中配置了视图解析器，所以可以跳转到/WEB-INF/views/success.jsp
    public String hello1(){
        return "success";
    }
}

现在放到Tomcat里面跑起来，在浏览器中输入http://localhost:8080/myProj/helloworld

效果如图：

第一步完成了，现在写httpclient去获取这个json字符串

package com.jackie.springmvc.handlers;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

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.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;


import net.sf.json.JSONObject;

public final class Send {
    private static Logger logger = Logger.getLogger(Send.class);  
    /**
     * 发送消息给指定的url
     * @return
     */
    public  String sendSms(String url, Map<String,String> map,String encoding){  
        //获取HttpClient请求,替换掉已被弃用的new DefaultHttpClient()方法
        CloseableHttpClient  httpclient = HttpClientBuilder.create().build();
        //配置对象
        RequestConfig config = RequestConfig.custom().setConnectTimeout(60000).setSocketTimeout(15000).build();
        HttpPost httppost = new HttpPost(url);  
        httppost.setConfig(config);
        String strResult = "";  
        CloseableHttpResponse  response =null;  
        try {  
                //装填参数
                List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
                if(map!=null){
                    for (Entry<String, String> entry : map.entrySet()) {
                        nameValuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
                    }
                }
            
                httppost.addHeader("Content-type", "application/x-www-form-urlencoded");  
                httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs,encoding));  
                 
                response = httpclient.execute(httppost);  
                if (response.getStatusLine().getStatusCode() == 200) {
                    /*读返回数据*/  
                    String conResult = EntityUtils.toString(response.getEntity(),encoding); 
                    logger.info("发送成功，返回数据为："+conResult);
                    //解析返回数据
                    JSONObject sobj = new JSONObject();  
                    sobj = JSONObject.fromObject(conResult);  
                    String result = sobj.getString("username"); 
                    logger.info("result="+result);
                } else {  
                    
                    String err = response.getStatusLine().getStatusCode()+"";  
                    strResult += "发送请求失败:"+err;  
                    logger.error("发送失败");
                }  
        } catch (ClientProtocolException e) {  
            e.printStackTrace();
            logger.error("进入catch，捕获ClientProtocolException异常："+e);
        } catch (IOException e) {  
            e.printStackTrace();  
            logger.error("进入catch，捕获IOException异常："+e);
        } finally {
            if (response != null) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    logger.error("进入finally中response不为空的情况，捕获IOException异常："+e);
                }
            }
            if (httpclient != null) {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    logger.error("进入finally中httpclient不为空的情况，捕获IOException异常："+e);
                }
            }
        }  
          
        return strResult;  
    }  
    public static void main(String[] args) {
        Send send = new Send();
        Map<String, String> map = new HashMap<String, String>();
        map.put("message1", "message11");
        map.put("message2", "message21");
        map.put("message3", "message31");
        String smsUrl="http://localhost:8080/myProj/helloworld";
        String message = send.sendSms(smsUrl, map,"utf-8");
    }
}

运行main函数，日志正常打出

该如何获取message1，message2，message3这些消息呢

这里用的是流

在HelloWorld这个类里添加一个方法hello7

    @ResponseBody
    @RequestMapping(value="/helloworld7")
    public JSONObject hello7(InputStream is, String charset) throws UnsupportedEncodingException, IOException {
        String pageString = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
        StringBuffer sb = null;
        JSONObject sobj = new JSONObject();  
        charset="UTF-8";
        try {
            isr = new InputStreamReader(is, charset);
            br = new BufferedReader(isr);
            sb = new StringBuffer();
            Map map = new HashMap();
            String line = null;
            while ((line = br.readLine()) != null) {
                sb.append(line);
            }
            pageString = sb.toString();
            String[] message = pageString.split("&");
            for(int i = 0;i<message.length;i++) {
                String[] subMessage = message[i].split("=");
                map.put(subMessage[0], subMessage[1]);
            }
            map.put("seven", "happy");
            sobj = JSONObject.fromObject(map);  
            String result = sobj.getString("message1"); 
            logger.info("result="+result);
            logger.info("pageString="+pageString);
        }catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null){
                    is.close();
                }
                if(isr!=null){
                    isr.close();
                }
                if(br!=null){
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            sb = null;
        }
        return sobj;
    }

然后在将Send类里的main函数smsUrl改为http://localhost:8080/myProj/helloworld7，运行main函数，结果如下：

控制台1：

控制台2：

铛铛铛~完成啦

转载于:https://www.cnblogs.com/seven717/p/9605558.html