dubbo学习笔记 第十章dubbo服务实现http调用

最新推荐文章于 2025-10-07 03:55:24 发布
转载 最新推荐文章于 2025-10-07 03:55:24 发布 · 2.4k 阅读 · 4 ·
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/u/3702/blog/1570415
文章标签：

#java #json #测试

本文介绍如何将Dubbo服务转换为HTTP调用，利用Spring MVC特性，通过配置POM、XML文件，以及编写核心控制类，实现从数据库获取服务名，并通过HTTP接口对外提供服务。测试类和HTTP请求工具类确保了调用的安全性和效率。最后展示了项目运行结果，返回JSON字符串。

 

      之前在网上有看一篇文章，觉得场景描述的很切合实际，就是dubbo经常是内部协作提供服务用的，但是如果涉及到对外服务调用，更多还是提供http，这样就必须实现服务转换为http调用，这篇文章设计还是很巧妙，利用了spring mvc的特性。

     文章的出处：http://blog.csdn.net/qq_18661793/article/details/71156210

     在这我们根据实际的使用，对它进行更进一步的调整，先配置pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.crossoverJie</groupId>
	<artifactId>dubbo-http</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>dubbo-http Maven Webapp</name>
	<url>http://maven.apache.org</url>


	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<build>

		<resources>
			<resource>
				<directory>src/main/resources</directory>
				<includes>
					<include>**/*.properties</include>
					<include>**/*.xml</include>
					<include>**/*.ini</include>
				</includes>
				<filtering>false</filtering>
			</resource>
			<resource>
				<directory>src/main/java</directory>
				<includes>
					<include>**/*.properties</include>
					<include>**/*.xml</include>
				</includes>
				<filtering>false</filtering>
			</resource>
		</resources>
	</build>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.7</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.tomcat</groupId>
			<artifactId>tomcat-juli</artifactId>
			<version>7.0.27</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient-cache</artifactId>
			<version>4.2.5</version>
		</dependency>
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpmime</artifactId>
			<version>4.2.5</version>
		</dependency>

		<!-- Spring 在 3.2.13版本后，要单独引用 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>


		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.18</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.7.1</version>
		</dependency>
		<dependency>
			<groupId>org.codehaus.jackson</groupId>
			<artifactId>jackson-mapper-asl</artifactId>
			<version>1.9.11</version>
		</dependency>
		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.2.2</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.16</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.1.26</version>
		</dependency>


		<!-- 其他常用包 begin -->

		<dependency>
			<groupId>commons-attributes</groupId>
			<artifactId>commons-attributes-api</artifactId>
			<version>2.1</version>
		</dependency>
		<dependency>
			<groupId>commons-attributes</groupId>
			<artifactId>commons-attributes-compiler</artifactId>
			<version>2.1</version>
		</dependency>
		<dependency>
			<groupId>ant</groupId>
			<artifactId>ant</artifactId>
			<version>1.6.5</version>
		</dependency>

		<dependency>
			<groupId>commons-beanutils</groupId>
			<artifactId>commons-beanutils-core</artifactId>
			<version>1.8.0</version>
		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>1.10</version>
		</dependency>
		<dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>3.2.2</version>
		</dependency>
		<dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.4</version>
		</dependency>
		<dependency>
			<groupId>commons-httpclient</groupId>
			<artifactId>commons-httpclient</artifactId>
			<version>3.1</version>
		</dependency>
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>2.4</version>
		</dependency>
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.6</version>
		</dependency>
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.1.3</version>
		</dependency>
		<dependency>
			<groupId>commons-pool</groupId>
			<artifactId>commons-pool</artifactId>
			<version>1.6</version>
		</dependency>
		<dependency>
			<groupId>net.sf.ezmorph</groupId>
			<artifactId>ezmorph</artifactId>
			<version>1.0.6</version>
		</dependency>

		<!-- 其他常用包 end' -->
		<dependency>
			<groupId>org.javassist</groupId>
			<artifactId>javassist</artifactId>
			<version>3.21.0-GA</version>
		</dependency>


		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>dubbo</artifactId>
			<version>2.8.5.1</version>
			<exclusions>
				<exclusion>
					<artifactId>spring</artifactId>
					<groupId>org.springframework</groupId>

				</exclusion>

			</exclusions>
		</dependency>

		<!-- redis begin -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.8.0</version>
		</dependency>
		<!-- redis end -->


		<!-- /Spring 升级4+ 依赖的JSON包 -->
		<dependency>
			<groupId>com.google.inject</groupId>
			<artifactId>guice</artifactId>
			<version>4.1.0</version>
		</dependency>
		<dependency>
			<groupId>com.netflix.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>1.1.10</version>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-framework</artifactId>
			<version>2.5.0</version>
		</dependency>

	</dependencies>
</project>

spring 相关的配置如下下图：

132538_xFY7_3702.png

dubbo的xml配置如下：spring-dubbo-config.xml的内容：

<?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:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
	   http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

	<dubbo:application name="ssm-service" />

	<dubbo:registry id="dubbo-registry" address="zookeeper://192.168.43.33:2181" username="srp" password="srp"  client="curator"
		file="/tmp/dubbo.cachr" />

	<dubbo:monitor protocol="registry" />

	<dubbo:protocol name="dubbo" port="20884" />



</beans>

spring-dubbo-provider.xml的内容：

<?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:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
	   http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

	
    <bean id="userFacade" class="com.crossoverJie.api.impl.DemoApiImpl" />
	<dubbo:service interface="com.crossoverJie.api.DemoApi" ref="userFacade"  />
    
</beans>

spring-mvc的内容：

<?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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
       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.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    

	<!-- 采用注释的方式配置bean -->
 	<context:annotation-config /> 

	<!-- 配置要扫描的包 -->
	<context:component-scan base-package="com.crossoverJie" /> 
   

    <!--dubbo服务暴露为http服务-->
    <bean class="com.crossoverJie.dubbo.http.conf.HttpProviderConf">
        <property name="usePackage">
            <list>
                <!--需要暴露服务的接口包名，可多个-->
                <value>com.crossoverJie.api</value>
            </list>
        </property>
    </bean>

    <!--处理静态资源-->
    <mvc:default-servlet-handler />

    <mvc:annotation-driven/>
 
    <!-- 定义跳转的文件的前后缀 ，视图模式配置-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

下面截图这块的内容实际使用中可以改为从数据库获取服务名的方式，

132600_wow2_3702.png

com.crossoverJie.api和spring-dubbo-provider种的“com.crossoverJie.api.DemoApi”是有对应关系的。

java代码中，有一个核心控制http请求的control类，我对其进行了改写，能更适应多参数的post请求，即把请求的参数都放入map中类似一个表单的请求。

package com.crossoverJie.api.controller;


import com.alibaba.fastjson.JSON;
import com.crossoverJie.dubbo.http.conf.HttpProviderConf;
import com.crossoverJie.dubbo.http.req.HttpRequest;
import com.crossoverJie.dubbo.http.rsp.HttpResponse;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Controller;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.lang.reflect.Field; 






@Controller
@RequestMapping({"/dubboapi"})
public class DubboController
  implements ApplicationContextAware
{
  private static final Logger logger = LoggerFactory.getLogger(DubboController.class);
  

  @Autowired
  private HttpProviderConf httpProviderConf;
  
  private final Map<String, Class<?>> cacheMap = new HashMap();
  

  protected ApplicationContext applicationContext;
  

  @ResponseBody
  @RequestMapping(value={"/{service}/{method}"}, method={org.springframework.web.bind.annotation.RequestMethod.POST})
  public String api(HttpRequest httpRequest, HttpServletRequest request, @RequestParam Map<String,String> map,@PathVariable String service, @PathVariable String method)
  {
	
    logger.debug("ip:{}-httpRequest:{}", getIP(request), JSON.toJSONString(httpRequest));
    
    String invoke = invoke(httpRequest, service, method,map);
    logger.debug("callback :" + invoke);
    return invoke;
  }
  

  private String invoke(HttpRequest httpRequest, String service, String method,Map<String,String> map)
  {
    httpRequest.setService(service);
    httpRequest.setMethod(method);
    
    HttpResponse response = new HttpResponse();
    
    logger.debug("input param:" + JSON.toJSONString(httpRequest));
    
    if (!CollectionUtils.isEmpty(httpProviderConf.getUsePackage())) {
      boolean isPac = false;
      for (String pac : httpProviderConf.getUsePackage()) {
        if (service.startsWith(pac)) {
          isPac = true;
          break;
        }
      }
      if (!isPac)
      {
        logger.error("service is not correct,service=" + service);
        response.setCode("2");
        response.setSuccess(false);
        response.setDescription("service is not correct,service=" + service);
      }
    }
    try
    {
      Class<?> serviceCla = (Class)cacheMap.get(service);
      if (serviceCla == null) {
        serviceCla = Class.forName(service);
        logger.debug("serviceCla:" + JSON.toJSONString(serviceCla));
        

        cacheMap.put(service, serviceCla);
      }
      Method[] methods = serviceCla.getMethods();
      Method targetMethod = null;
      for (Method m : methods) {
        if (m.getName().equals(method)) {
          targetMethod = m;
          break;
        }
      }
      
      if (method == null) {
        logger.error("method is not correct,method=" + method);
        response.setCode("2");
        response.setSuccess(false);
        response.setDescription("method is not correct,method=" + method);
      }
      
      Object bean = applicationContext.getBean(serviceCla);
      Object result = null;
      Class<?>[] parameterTypes = targetMethod.getParameterTypes();   
      if (parameterTypes.length == 0)
      {
        result = targetMethod.invoke(bean, new Object[0]);
      } /*else if (parameterTypes.length == 1) {
        Object json = JSON.parseObject(httpRequest.getParam(), parameterTypes[0]);
        result = targetMethod.invoke(bean, new Object[] { json });
      } */else {
    	 
    	 result = targetMethod.invoke(bean, map);
        logger.info("Can  have map parameter");
        response.setSuccess(true);
        response.setCode("1");
        response.setDescription("Can only have one parameter");
      }
      return JSON.toJSONString(result);
    }
    catch (ClassNotFoundException e) {
      logger.error("class not found", e);
      response.setSuccess(false);
      response.setCode("2");
      response.setDescription("class not found");
    } catch (InvocationTargetException e) {
      logger.error("InvocationTargetException", e);
      response.setSuccess(false);
      response.setCode("2");
      response.setDescription("InvocationTargetException");
    } catch (IllegalAccessException e) {
      logger.error("IllegalAccessException", e);
      response.setSuccess(false);
      response.setCode("2");
      response.setDescription("IllegalAccessException");
    }  catch (SecurityException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
    return JSON.toJSONString(response);
  }
  




  private String getIP(HttpServletRequest request)
  {
    if (request == null)
      return null;
    String s = request.getHeader("X-Forwarded-For");
    if ((s == null) || (s.length() == 0) || ("unknown".equalsIgnoreCase(s)))
    {
      s = request.getHeader("Proxy-Client-IP");
    }
    if ((s == null) || (s.length() == 0) || ("unknown".equalsIgnoreCase(s)))
    {
      s = request.getHeader("WL-Proxy-Client-IP");
    }
    if ((s == null) || (s.length() == 0) || ("unknown".equalsIgnoreCase(s))) {
      s = request.getHeader("HTTP_CLIENT_IP");
    }
    if ((s == null) || (s.length() == 0) || ("unknown".equalsIgnoreCase(s)))
    {
      s = request.getHeader("HTTP_X_FORWARDED_FOR");
    }
    if ((s == null) || (s.length() == 0) || ("unknown".equalsIgnoreCase(s)))
    {
      s = request.getRemoteAddr();
    }
    if (("127.0.0.1".equals(s)) || ("0:0:0:0:0:0:0:1".equals(s)))
      try {
        s = InetAddress.getLocalHost().getHostAddress();
      } catch (UnknownHostException unknownhostexception) {
        return "";
      }
    return s;
  }
  
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;
  }
}

被这个control类引用的还有：

 package com.crossoverJie.dubbo.http.conf;
 
 import java.util.List;
 
   
 public class HttpProviderConf
 {
   private List<String> usePackage;
   
   public List<String> getUsePackage()
   {
     return usePackage;
   }
   
   public void setUsePackage(List<String> usePackage) {
     this.usePackage = usePackage;
   }
  }

上面这个类跟相对应，个人觉得使用意义不是太大。

132600_wow2_3702.png

package com.crossoverJie.dubbo.http.req;


public class HttpRequest
{
  private String param;
  





  private String service;
  





  private String method;
  






  public String getParam()
  {
    return param;
  }
  
  public void setParam(String param) {
    this.param = param;
  }
  
  public String getService() {
    return service;
  }
  
  public void setService(String service) {
    this.service = service;
  }
  
  public String getMethod() {
    return method;
  }
  
  public void setMethod(String method) {
    this.method = method;
  }
}


package com.crossoverJie.dubbo.http.rsp;

import java.io.Serializable;



public class HttpResponse
  implements Serializable
{
  private static final long serialVersionUID = -552828440320737814L;
  private boolean success;
  private String code;
  private String description;
  
  public boolean isSuccess()
  {
    return success;
  }
  
  public void setSuccess(boolean success) {
    this.success = success;
  }
  
  public String getCode() {
    return code;
  }
  
  public void setCode(String code) {
    this.code = code;
  }
  
  public String getDescription() {
    return description;
  }
  
  public void setDescription(String description) {
    this.description = description;
  }
}

接下来我们写一下测试相关类：

package com.crossoverJie.api.impl;

import java.util.Map;

import com.alibaba.dubbo.config.annotation.Service;
import com.alibaba.fastjson.JSON;
import com.crossoverJie.api.DemoApi;

/**
 * Function:
 * @author chenjiec
 * Date: 2017/3/1 下午11:42
 * @since JDK 1.7
 */
@Service
public class DemoApiImpl implements DemoApi {

    /**
     * 获取用户信息
     *
     * @param userId
     * @return
     * @throws RuntimeException
     */
    public String readMsg(Map<String,String> arg) throws RuntimeException {
    	String json_str=JSON.toJSONString(arg);
        return json_str;
    }
}
package com.crossoverJie.api;

import java.util.Map;

public interface DemoApi {
	   String readMsg(Map<String,String> arg)throws RuntimeException;

}

以上是服务器接口相关类

http请求工具类

package com.crossoverJie.dto;

import java.io.BufferedReader;  
import java.io.InputStreamReader;  
import java.io.OutputStreamWriter;  
import java.net.HttpURLConnection;  
import java.net.URL;  
import java.util.Map;  
import java.util.Map.Entry;  
  
public class HttpUtil {  
  
    public static String http(String url, Map<String, String> params) {  
        URL u = null;  
        HttpURLConnection con = null;  
        // 构建请求参数  
        StringBuffer sb = new StringBuffer();  
        if (params != null) {  
            for (Entry<String, String> e : params.entrySet()) {  
                sb.append(e.getKey());  
                sb.append("=");  
                sb.append(e.getValue());  
                sb.append("&");  
            }  
            sb.substring(0, sb.length() - 1);  
        }  
        System.out.println("send_url:" + url);  
        System.out.println("send_data:" + sb.toString());  
        // 尝试发送请求  
        try {  
            u = new URL(url);  
            con = (HttpURLConnection) u.openConnection();  
            //// POST 只能为大写，严格限制，post会不识别  
            con.setRequestMethod("POST");  
            con.setDoOutput(true);  
            con.setDoInput(true);  
            con.setUseCaches(false);  
            con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");  
            OutputStreamWriter osw = new OutputStreamWriter(con.getOutputStream(), "UTF-8");  
            osw.write(sb.toString());  
            osw.flush();  
            osw.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            if (con != null) {  
                con.disconnect();  
            }  
        }  
  
        // 读取返回内容  
        StringBuffer buffer = new StringBuffer();  
        try {  
            //一定要有返回值，否则无法把请求发送给server端。  
            BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8"));  
            String temp;  
            while ((temp = br.readLine()) != null) {  
                buffer.append(temp);  
                buffer.append("\n");  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
  
        return buffer.toString();  
    }  
  
}

http请求调用类

package com.crossoverJie.api.controller;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.crossoverJie.dto.HttpUtil;

public class HttpRequestTest {
    /**
     * 向指定URL发送GET方法的请求
     * 
     * @param url
     *            发送请求的URL
     * @param param
     *            请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return URL 所代表远程资源的响应结果
     */
    public static String sendGet(String url, String param) {
        String result = "";
        BufferedReader in = null;
        try {
            String urlNameString = url + "?" + param;
            URL realUrl = new URL(urlNameString);
            // 打开和URL之间的连接
            URLConnection connection = realUrl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 建立实际的连接
            connection.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : map.keySet()) {
                System.out.println(key + "--->" + map.get(key));
            }
            // 定义 BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(
                    connection.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            System.out.println("发送GET请求出现异常！" + e);
            e.printStackTrace();
        }
        // 使用finally块来关闭输入流
        finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 向指定 URL 发送POST方法的请求
     * 
     * @param url
     *            发送请求的 URL
     * @param param
     *            请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendPost(String url, String param) {
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent",
                    "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // 获取URLConnection对象对应的输出流
            out = new PrintWriter(conn.getOutputStream());
            // 发送请求参数
            out.print(param);
            // flush输出流的缓冲
            out.flush();
            // 定义BufferedReader输入流来读取URL的响应
            in = new BufferedReader(
                    new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            System.out.println("发送 POST 请求出现异常！"+e);
            e.printStackTrace();
        }
        //使用finally块来关闭输出流、输入流
        finally{
            try{
                if(out!=null){
                    out.close();
                }
                if(in!=null){
                    in.close();
                }
            }
            catch(IOException ex){
                ex.printStackTrace();
            }
        }
        return result;
    }    
    public void testMaprequest() {  
        Map parames = new HashMap<String, String>();  
        parames.put("num", "456");  
        parames.put("id", "123");  
        parames.put("name", "srp");  
        // 如果地址栏中有aaa这个参数，则默认选择地址栏的，如果没有则选择添加的参数  
        parames.put("userid", "aaa_value");  
        String sr=HttpUtil.http("http://localhost:8080/dubbo-http/dubboapi/com.crossoverJie.api.DemoApi/readMsg", parames);  
        System.out.println(sr);
        
    }  
    public static void main(String[] args) {

             
        HttpRequestTest rs =new HttpRequestTest();
        rs.testMaprequest();
       
    }
}

上面代码中：http://localhost:8080/dubbo-http/dubboapi/com.crossoverJie.api.DemoApi/readMsg

dubbo-http是我取的项目名称，dubboapi就是对于上面那个control类的注解内容，com.crossoverJie.api.DemoApi对于接口服务，readMsg对应类中被调用的方法，parames是一个map参数。在实际使用中应该还要有证书之类的，保证接口被调用的安全性。

最后看下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_3_0.xsd"
         version="3.0">
    <display-name>Archetype Created Web Application</display-name>

    <welcome-file-list>
        <welcome-file>turnToIndex.jsp</welcome-file>
    </welcome-file-list>


    <!-- Spring和mybatis的配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:spring/*.xml</param-value>
    </context-param>
    <!-- 编码过滤器 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <async-supported>true</async-supported>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- Spring监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 防止Spring内存溢出监听器 -->
    <listener>
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    </listener>

    <!-- Spring MVC servlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <!-- 此处可以可以配置成*.do，对应struts的后缀习惯 /表示拦截所有请求 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <!-- 配置SESSION超时，单位是分钟 -->
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>




    <!-- druid 监控 -->
    <filter>
        <filter-name>DruidWebStatFilter</filter-name>
        <filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class>
        <init-param>
            <param-name>exclusions</param-name>
            <param-value>*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*,/download/*</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>DruidWebStatFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <servlet>
        <servlet-name>DruidStatView</servlet-name>
        <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
        <init-param>
            <!-- 用户名 -->
            <param-name>loginUsername</param-name>
            <param-value>druid</param-value>
        </init-param>
        <init-param>
            <!-- 密码 -->
            <param-name>loginPassword</param-name>
            <param-value>druid</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>DruidStatView</servlet-name>
        <url-pattern>/druid/*</url-pattern>
    </servlet-mapping>

    <!-- 确保静态资源可以被访问 -->
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.jpg</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.png</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.gif</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.js</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.css</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.swf</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.txt</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.ico</url-pattern>
    </servlet-mapping>

    
    <error-page>
        <error-code>404</error-code>
        <location>/notfound.jsp</location>
    </error-page>
</web-app>

整体项目运行结果如下：

134300_XyHE_3702.png

返回了一json 字符串

转载于:https://my.oschina.net/u/3702/blog/1570415

精尽 Dubbo 源码分析 —— 服务调用（三）之远程调用（HTTP）
qq_32782279的博客
04-13 639
1. 概述 基于 HTTP 表单的远程调用协议，采用 Spring 的 HttpInvoker 实现 涉及类图（红圈部分）如下： 2. AbstractProxyProtocol 现 AbstractProtocol 抽象类，Proxy 协议抽象类。为 HttpProtocol 、RestProtocol 等子类，提供公用的服务暴露、服务引用的公用方法，同时定义了如下抽象方法，用于不同子类协议实...
如何将dubbo封装成http协议
weixin_34080951的博客
07-08 2481
很多小伙伴在测试的时候发现使用现成的工具无法对dubbo协议进行调用，我们现在就来看一下如何通过封装，将dubbo封装成一个http协议，然后再使用现成的http测试工具即可实现dubbo的直接调用。 首先，我们来看dubbo是啥 Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各...
Apache Dubbo跨域调用支持：HTTP协议配置
最新发布
gitblog_01071的博客
10-07 352
在分布式系统中，跨域资源共享（CORS，Cross-Origin Resource Sharing）是实现前端与后端服务通信的关键机制。当Web应用从一个域名请求另一个域名的资源时，浏览器会执行同源策略检查，未正确配置CORS的服务将无法被正常访问。本文将详细介绍如何在Apache Dubbo框架中配置HTTP协议的跨域支持，解决前后端分离架构下的跨域通信问题。 ## CORS核心配置原理 A...
SSM-DUBBO-HTTP:dubbo提供HTTP服务
05-09
开发 预览 简介 将 dubbo 服务对外暴露出http服务。 可供其他任何语言进行调用。 安装 git clone https://github.com/crossoverJie/SSM-DUBBO-HTTP.git cd SSM-DUBBO-HTTP mvn clean mvn install 使用 <dependency> <groupId>com.crossoverJie</groupId> <artifactId>SSM-HTTP-PROVIDER</artifactId> <version>1.0.0</version> </dependency> Spring 配置 <!--dubbo服务暴露为http服务--> <bean class="com.crossoverJie.dubbo.http.conf.HttpProviderConf
dubbo泛化调用 http接口 随意调用dubbo服务
m0_67400973的博客
09-02 738
1、开发工程中 有时候想要测试dubbo接口 需要自定义用例，比较麻烦。由于dubbo支持泛化调用 所以这些问题就迎刃而解了。2、无法调用服务器上的dubbo测试。3、无法随意调用多版本的服务。dubbo支持泛化调用。
http转dubbo调用
yufeng702的博客
06-08 9574
dubbo服务是现在互联网公司比较流行的服务，一般用于内部系统间的调用。正常情况下服务消费方需要导入服务提供skeleton的jar包。因此需要对测试dubbo服务接口的人员需要一定的代码编写能力，需要写对应的消费方代码。当然这个很简单，但是为了更加简便和通用的使用dubbo接口，下面将把dubbo接口转成http接口暴露出去，这样测试人员可以直接使用postman等测试工具进行测试了。闲话不多说
dubbo学习笔记.pdf
07-28
【Dubbo学习笔记】 Dubbo是一款高性能、轻量级的Java RPC框架，它旨在提供面向接口的远程方法调用、智能容错与负载均衡、服务自动注册与发现等核心功能，帮助开发者构建分布式服务架构。以下是对Dubbo基础知识、...
dubbo:dubbo学习笔记
04-06
《Dubbo学习笔记详解》 Dubbo，作为阿里巴巴开源的一款高性能、轻量级的服务治理框架，已经在Java开发者中广受欢迎。它主要应用于分布式系统中的服务调用，提供服务注册、服务发现、负载均衡、容错处理等核心功能，...
dubbo学习笔记
02-24
3. **自动发现**：Dubbo通过注册中心（如Zookeeper、Eureka等）实现服务提供者和消费者之间的动态服务发现，服务消费者无需硬编码服务提供者的地址，只需要知道服务接口，即可找到并调用服务。 【Dubbo能做什么】 ...
dubbo学习笔记，都是一个字一个字的写的
01-25
【Dubbo学习笔记】 本文将深入探讨Dubbo框架的核心概念及其在实际应用中的工作原理，同时结合SpringBoot和SpringCloud的整合，以及RPC（Remote Procedure Call）技术的基础知识。 一、RPC原理 RPC（远程过程调用）...
如何使用http和Postman直接调用dubbo服务？
迷途菜鸟
11-22 1万+
如何使用http直接调用dubbo服务？ 我们都知道dubbo服务默认是dubbo协议，如果我们使用http直接调用dubbo服务，需要把协议改为http，如下图 我们在官方的提供的项目demo模块中，把privoder.xml中protocol改为http协议，以及http服务器改为Tomcat(默认是Jetty) 然后我们启动 启动Privoder类，我们这里启动成功，注册一个DemoService实现类 我们启动消费者,使用自己封装好的http去直接去调用 这里我们已经就调用成功,并且输出了返
dubbo集成swagger文档模拟HTTP请求
08-08
Swagger-dubbo致力于dubbo与swagger文档的集成，并且为dubbo提供rest风格的http调用方案。适用于dubbo服务接口调试、接口http请求模拟、单机验证等场景。
dubbo组成原理-http服务消费端如何调用
热门推荐
hdu09075340的博客
05-11 2万+
dubbo协议已经用的很多了，这里来稍微介绍一下http协议，官方对http协议的说明简直少的让人发指。哈哈 百度大部分都只是讲了http服务端的配置 那就先从服务端的配置说起 dubbo需要的jar包这里就不说明了，网上找些maven的pom就可以 web.xml配置servlet，注意url-pattern 是需要拦截哪些请求 dubbo com.alibaba
"Dubbo学习笔记：RPC远程过程调用原理与实践
其他方面的学习笔记包括了dubbo与springboot的整合。Spring Boot是一种创建独立的、基于生产的 Spring 应用程序的方式。它简化了Spring应用程序的初始搭建和开发过程，并使用自动化的方式进行了打包和部署。dubbo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值