[EDAS][HSF]开发 HSF 应用（EDAS SDK）

最新推荐文章于 2024-03-28 17:15:51 发布
最新推荐文章于 2024-03-28 17:15:51 发布
阅读量1.5k 收藏 5
点赞数 1
文章标签： 开发工具 测试 python
原文链接：https://my.oschina.net/u/2464371/blog/3041571
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

开发 HSF 应用（EDAS SDK）

更新时间：2019-04-19 12:01:13

  • 本页目录
    • 快速开始
    • 开发高级特性
    • 单元测试

您可以使用 EDAS-SDK 开发 HSF 应用，实现服务注册发现，还可以实现隐式传参、异步调用、泛化调用、调用链路 Filter 扩展等高级 HSF 特性，以及 HSF 单元测试。

快速开始

介绍如何使用 EDAS-SDK 快速开发 HSF 应用，完成服务注册与发现。

下载 Demo 工程

本章中介绍的代码均可以通过官方 Demo 获取。

  1. 下载 Demo 工程。
  2. 解压下载的压缩包，可以看到carshop文件夹，里面包含 itemcenter-api，itemcenter 和 detail 三个 Maven 工程文件夹。
  • itemcenter-api：提供接口定义
  • itemcenter：生产者服务
  • detail：消费者服务

说明：请使用 JDK 1.7 及以上版本。

定义服务接口

HSF 服务基于接口实现，当接口定义好之后，生产者将使用该接口实现具体的服务，消费者也是基于此接口去订阅服务。 在 Demo 的itemcenter-api工程中，定义了一个服务接口 com.alibaba.edas.carshop.itemcenter.ItemService，内容如下：

public interface ItemService {
    public Item getItemById(long id);
    public Item getItemByName(String name);
}

该服务接口将提供两个方法：getItemById 与 getItemByName。

开发生产者服务

生产者将实现服务接口以提供具体服务。同时，如果使用了 Spring 框架，还需要在 .xml 文件中配置服务属性。

说明：Demo 工程中的 itemcenter 文件夹为生产者服务的示例代码。

实现服务接口

可以参考ItemServiceImpl.java文件中的示例：

package com.alibaba.edas.carshop.itemcenter;
public class ItemServiceImpl implements ItemService {
    @Override
    public Item getItemById( long id ) {
        Item car = new Item();
        car.setItemId( 1l );
        car.setItemName( "Mercedes Benz" );
        return car;
    }
    @Override
    public Item getItemByName( String name ) {
        Item car = new Item();
        car.setItemId( 1l );
        car.setItemName( "Mercedes Benz" );
        return car;
    }
}
配置服务属性

上述示例主要实现了 com.alibaba.edas.carshop.itemcenter.ItemService，并在两个方法中返回了一个 Item 对象。 代码开发完成之后，除了在 web.xml 中进行必要的常规配置，您还需要增加相应的 Maven 依赖， 同时在 Spring 配置文件使用 <hsf /> 标签注册并发布该服务。具体内容如下： 在pom.xml中添加如下 Maven 依赖：

<dependencies>
     <!-- 添加 servlet 的依赖 -->
     <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>servlet-api</artifactId>
         <version>2.5</version>
         <scope>provided</scope>
     </dependency>
     <!-- 添加 Spring 的依赖 -->
     <dependency>
         <groupId>com.alibaba.edas.carshop</groupId>
         <artifactId>itemcenter-api</artifactId>
         <version>1.0.0-SNAPSHOT</version>
     </dependency>
     <!-- 添加服务接口的依赖 -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-web</artifactId>
         <version>2.5.6(及其以上版本)</version>
     </dependency>
     <!-- 添加 edas-sdk 的依赖 -->
     <dependency>
         <groupId>com.alibaba.edas</groupId>
        <artifactId>edas-sdk</artifactId>
         <version>1.5.0</version>
     </dependency>
</dependencies>

在 hsf-provider-beans.xml 文件中增加 Spring 关于 HSF 服务的配置。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:hsf="http://www.taobao.com/hsf"
     xmlns="http://www.springframework.org/schema/beans"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.taobao.com/hsf
     http://www.taobao.com/hsf/hsf.xsd" default-autowire="byName">
     <!-- 定义该服务的具体实现 -->
     <bean id="itemService" class="com.alibaba.edas.carshop.itemcenter.ItemServiceImpl" />
     <!-- 用 hsf:provider 标签表明提供一个服务生产者 -->
     <hsf:provider id=“itemServiceProvider"
         <!-- 用 interface 属性说明该服务为此类的一个实现 -->
         interface=“com.alibaba.edas.carshop.itemcenter.ItemService"
         <!-- 此服务具体实现的 Spring 对象 -->
         ref=“itemService"
         <!-- 发布该服务的版本号，可任意指定，默认为 1.0.0 -->
         version=“1.0.0"
     </hsf:provider>
</beans>

上面的示例为基本配置，您也可以根据您的实际需求，参考下面的生产者服务属性列表，增加其它配置。

生产者服务属性列表
属性描述
interface必须配置，类型为 [String]，为服务对外提供的接口。
version可选配置，类型为 [String]，含义为服务的版本，默认为 1.0.0。
clientTimeout该配置对接口中的所有方法生效，但是如果客户端通过 methodSpecials 属性对某方法配置了超时时间，则该方法的超时时间以客户端配置为准。其他方法不受影响，还是以服务端配置为准。
serializeType可选配置，类型为 [String(hessian｜java)]，含义为序列化类型，默认为 hessian。
corePoolSize单独针对这个服务设置核心线程池，从公用线程池中划分出来。
maxPoolSize单独针对这个服务设置线程池，从公用线程池中划分出来。
enableTXC开启分布式事务 GTS。
ref必须配置，类型为 [ref]，为需要发布为 HSF 服务的 Spring Bean ID。
methodSpecials可选配置，用于为方法单独配置超时时间(单位 ms)，这样接口中的方法可以采用不同的超时时间。该配置优先级高于上面的 clientTimeout 的超时配置，低于客户端的 methodSpecials 配置。
服务创建及发布限制
名称示例限制大小是否可调整
{服务名}:{版本号}com.alibaba.edas.testcase.api.TestCase:1.0.0最大192字节否
组名aliware最大32字节否
一个Pandora应用实例发布的服务数N/A最大800个可在应用基本信息页面单击应用设置部分右侧的设置，在下拉列表中选择JVM，在弹出的应用设置对话框中进入自定义->自定义参数，在输入框中添加 -DCC.pubCountMax=1200 属性参数（该参数值可根据应用实际发布的服务数调整）。
生产者服务属性配置示例
<bean id="impl" class="com.taobao.edas.service.impl.SimpleServiceImpl" />
    <hsf:provider id="simpleService" interface="com.taobao.edas.service.SimpleService"
        ref="impl" version="1.0.1" clientTimeout="3000" enableTXC="true"
        serializeType="hessian">
        <hsf:methodSpecials>
            <hsf:methodSpecial name="sum" timeout="2000" />
        </hsf:methodSpecials>
    </hsf:provider>

开发消费者服务

消费者订阅服务从代码编写的角度分为两个部分。

  1. Spring 的配置文件使用标签hsf:consumer/定义好一个 Bean。
  2. 在使用的时候从 Spring 的 context 中将 Bean 取出来。

说明：Demo 工程中的 detail 文件夹为消费者服务的示例代码。

配置服务属性

与生产者一样，消费者的服务属性配置分为 Maven 依赖配置与 Spring 的配置。

  1. 在pom.xml文件中添加 Maven 依赖。 Maven 依赖配置与生产者相同，详情请参见开发生产者服务的配置服务属性。
  2. 在 hsf-consumer-beans.xml 文件中添加 Spring 关于 HSF 服务的配置。 增加消费者的定义，HSF 框架将根据该配置文件去服务中心订阅所需的服务。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:hsf="http://www.taobao.com/hsf"
     xmlns="http://www.springframework.org/schema/beans"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
     http://www.taobao.com/hsf
     http://www.taobao.com/hsf/hsf.xsd" default-autowire="byName">
     <!-- 消费一个服务示例 -->
     <hsf:consumer
         <!-- Bean ID，在代码中可根据此 ID 进行注入从而获取 consumer 对象  -->
         id="item"
         <!-- 服务名，与服务提供者的相应配置对应，HSF 将根据 interface + version 查询并订阅所需服务  -->
         interface="com.alibaba.edas.carshop.itemcenter.ItemService"
         <!-- 版本号，与服务提供者的相应配置对应，HSF 将根据 interface + version 查询并订阅所需服务  -->
         version="1.0.0"
     </hsf:consumer>
</beans>
配置服务调用

可以参考StartListener.java文件中的示例：

public class StartListener implements ServletContextListener{
    @Override
    public void contextInitialized( ServletContextEvent sce ) {
        ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext( sce.getServletContext() );
        // 根据 Spring 配置中的 Bean ID “item” 获取订阅到的服务
        final ItemService itemService = ( ItemService ) ctx.getBean( "item" );
        ……
        // 调用服务 ItemService 的 getItemById 方法
        System.out.println( itemService.getItemById( 1111 ) );
        // 调用服务 ItemService 的 getItemByName 方法
        System.out.println( itemService.getItemByName( "myname is le" ) );
        ……
    }
}

上面的示例中为基本配置，您也可以根据您的实际需求，参考下面的服务属性列表，增加其它配置。

消费者服务属性列表
属性描述
interface必须配置，类型为 [String]，为需要调用的服务的接口。
version可选配置，类型为 [String]，为需要调用的服务的版本，默认为1.0.0。
methodSpecials可选配置，为方法单独配置超时时间(单位 ms)。这样接口中的方法可以采用不同的超时时间，该配置优先级高于服务端的超时配置。
target主要用于单元测试环境和开发环境中，手动地指定服务提供端的地址。如果不想通过此方式，而是通过配置中心推送的目标服务地址信息来指定服务端地址，可以在消费者端指定 -Dhsf.run.mode=0。
connectionNum可选配置，为支持设置连接到 server 连接数，默认为1。在小数据传输，要求低延迟的情况下设置多一些，会提升 TPS。
clientTimeout客户端统一设置接口中所有方法的超时时间(单位 ms)。超时时间设置优先级由高到低是：客户端 methodSpecials，客户端接口级别，服务端 methodSpecials，服务端接口级别 。
asyncallMethods可选配置，类型为 [List]，设置调用此服务时需要采用异步调用的方法名列表以及异步调用的方式。默认为空集合，即所有方法都采用同步调用。
maxWaitTimeForCsAddress配置该参数，目的是当服务进行订阅时，会在该参数指定时间内，阻塞线程等待地址推送，避免调用该服务时因为地址为空而出现地址找不到的情况。若超过该参数指定时间，地址还是没有推送，线程将不再等待，继续初始化后续内容。

注意，在应用初始化时，需要调用某个服务时才使用该参数。如果不需要调用其它服务，请勿使用该参数，会延长启动启动时间。 消费者服务属性配置示例

<hsf:consumer id="service" interface="com.taobao.edas.service.SimpleService"
      version="1.1.0" clientTimeout="3000"
      target="10.1.6.57:12200?_TIMEOUT=1000" maxWaitTimeForCsAddress="5000">
      <hsf:methodSpecials>
           <hsf:methodSpecial name="sum" timeout="2000" ></hsf:methodSpecial>
      </hsf:methodSpecials>
</hsf:consumer>

发布服务

完成代码、接口开发和服务配置后，在 Eclipse 或 IDEA 中，可直接以 Ali-Tomcat 运行该服务 （具体请参照文档开发工具准备中的配置 Eclipse 开发环境和配置 IDEA 开发环境）。

在开发环境配置时，有一些额外 JVM 启动参数来改变 HSF 的行为，具体如下： 属性 描述 -Dhsf.server.port 指定 HSF 的启动服务绑定端口，默认值为 12200。 -Dhsf.serializer 指定 HSF 的序列化方式，默认值为 hessian。 -Dhsf.server.max.poolsize 指定 HSF 的服务端最大线程池大小，默认值为 600。 -Dhsf.server.min.poolsize 指定 HSF 的服务端最小线程池大小。默认值为 50。 -DHSF_SERVER_PUB_HOST 指定对外暴露的 IP，如果不配置，使用 -Dhsf.server.ip 的值。 -DHSF_SERVER_PUB_PORT 指定对外暴露的端口，该端口必须在本机被监听，并对外开放了访问授权，默认使用 -Dhsf.server.port 的配置，如果 -Dhsf.server.port 没有配置，默认使用12200。

开发环境查询 HSF 服务

在开发调试的过程中，如果您的服务是通过轻量配置中心进行服务注册与发现，就可以通过 EDAS 控制台查询某个应用提供或调用的服务。

假设您在一台 IP 为 192.168.1.100 的机器上启动了 EDAS 配置中心。

  1. 进入 http://192.168.1.100:8080/ 。
  2. 在左侧菜单栏单击服务列表，输入服务名、服务组名或者 IP 地址进行搜索，查看对应的服务提供者以及服务调用者。

说明：配置中心启动之后默认选择第一块网卡地址做为服务发现的地址，如果开发者所在的机器有多块网卡的情况，可设置启动脚本中的 SERVER_IP 变量进行显式的地址绑定。

常见查询案例
  • 提供者列表页
    • 在搜索条件里输入 IP 地址，单击搜索即可查询该 IP 地址的机器提供了哪些服务。
    • 在搜索条件里输入服务名或服务分组，即可查询哪些 IP 地址提供了这个服务。
  • 调用者列表页
    • 在搜索条件里输入 IP 地址，单击搜索即可查询该 IP 地址的机器调用了哪些服务。
    • 在搜索条件里输入服务名或服务分组，即可查询哪些 IP 地址调用了这个服务。

开发高级特性

在您参照上面的快速开始开发完基本的应用之后，下面将向您介绍如何在上面的应用中实现隐式传参、异步调用、泛化调用和 Filter 链路扩展等 HSF 的高级特性。您可以直接下载 Demo。 隐式传参（目前仅支持字符串传输）

隐式传参一般用于传递一些简单 KV 数据，又不想通过接口方式传递，类似于 Cookie。 单个参数传递 服务消费者： RpcContext.getContext().setAttachment("key", "args test"); 服务提供者： String keyVal=RpcContext.getContext().getAttachment("key"); 多个参数传递

服务消费者：

Map<String,String> map=new HashMap<String,String>();
map.put("param1", "param1 test");
map.put("param2", "param2 test");
map.put("param3", "param3 test");
map.put("param4", "param4 test");
map.put("param5", "param5 test");
RpcContext rpcContext = RpcContext.getContext();
rpcContext.setAttachments(map);

服务提供者：

Map<String,String> map=rpcContext.getAttachments();
Set<String> set=map.keySet();
for (String key : set) {
  System.out.println("map value:"+map.get(key));
}

说明：隐式传参只对单次调用有效，当消费端调用返回后，会自动擦除 RpcContext 中的信息。

异步调用

支持 callback 和 future 两种异步调用方式。 callback 调用方式 客户端配置为 callback 方式时，需要配置一个实现了 HSFResponseCallback 接口的 listener。结果返回之后， HSF 会调用 HSFResponseCallback 中的方法。 注意：这个 HSFResponseCallback 接口的 listener 不能是内部类，否则 Pandora 的 classloader 在加载时就会报错。 XML 中的配置：

<hsf:consumer id="demoApi" interface="com.alibaba.demo.api.DemoApi"
      version="1.1.2" >
      <hsf:asyncallMethods>
          <hsf:method name="ayncTest" type="callback" 
           listener="com.alibaba.ifree.hsf.consumer.AsynABTestCallbackHandler" />
      </hsf:asyncallMethods>
</hsf:consumer>

其中 AsynABTestCallbackHandler 类实现了 HSFResponseCallback 接口。DemoApi 接口中有一个方法是 ayncTest 。 代码示例

public void onAppResponse(Object appResponse) {
  //获取到异步调用后的值
 String msg = (String)appResponse;
 System.out.println("msg:"+msg);
}

注意： 由于只用方法名字来标识方法，所以并不区分重载的方法。同名的方法都会被设置为同样的调用方式。 不支持在 call 里再发起 HSF 调用。这种做法可能导致 IO 线程挂起，无法恢复。 future 调用方式 客户端配置为 future 方式时，发起调用之后，通过 HSFResponseFuture 中的 public static Object getResponse(long timeout) 来获取返回结果。 XML 中的配置：

<hsf:consumer id="demoApi" interface="com.alibaba.demo.api.DemoApi" version="1.1.2" >
  <hsf:asyncallMethods>
         <hsf:method name="ayncTest" type="future"  />
  </hsf:asyncallMethods>
</hsf:consumer>

代码示例如下。 单个调用异步处理：

//发起调用
demoApi.ayncTest();
// 处理业务
...
//直接获得消息（若无需获得结果，可以不用操作该步骤）
String msg=(String) HSFResponseFuture.getResponse(3000);

多个调用需要并发处理： 若是多个业务需要并发处理，可以先获取 future，存储起来，等调用完毕后再使用。

//定义集合
List<HSFFuture> futures = new ArrayList<HSFFuture>();
方法内进行并行调用：
试用
//发起调用
demoApi.ayncTest();
//第一步获取 future 对象
HSFFuture future=HSFResponseFuture.getFuture();
futures.add(future);
//继续调用其他业务(同样采取异步调用)
HSFFuture future=HSFResponseFuture.getFuture();
futures.add(future);
// 处理业务
...
//获得数据并做处理
for (HSFFuture hsfFuture : futures) {
   String msg=(String) hsfFuture.getResponse(3000);
   //处理相应数据
   ...
}

泛化调用

通过泛化调用可以组合接口、方法、参数进行 RPC 调用，无需依赖任何业务 API。 步骤一：在消费者 XML 配置中加入泛化属性

<hsf:consumer id="demoApi" interface="com.alibaba.demo.api.DemoApi" generic="true"/>

说明：generic 代表泛化参数，true 表示支持泛化，false 表示不支持，默认为 false。

DemoApi 接口方法：

public String dealMsg(String msg);
public GenericTestDO dealGenericTestDO(GenericTestDO testDO);

步骤二：获取 demoApi 进行强制转换为泛化服务

导入泛化服务接口

import com.alibaba.dubbo.rpc.service.GenericService

获取泛化对象 XML 加载方式

//若 WEB 项目中，可通过 Spring bean 进行注入后强制转换，这里是单元测试，所以采用加载配置文件方式
  ClassPathXmlApplicationContext consumerContext = new ClassPathXmlApplicationContext("hsf-generic-consumer-beans.xml");
  //强制转换接口为 GenericService
  GenericService svc = (GenericService) consumerContext.getBean("demoApi");

代码订阅方式

HSFApiConsumerBean consumerBean = new HSFApiConsumerBean();  
consumerBean.setInterfaceName("com.alibaba.demo.api.DemoApi");
consumerBean.setGeneric("true"); // 设置 generic 为 true
consumerBean.setVersion("1.0.0");
consumerBean.init();
// 强制转换接口为 GenericService
GenericService svc = (GenericService) consumerBean.getObject();

步骤三：泛化接口

Object $invoke(String methodName, String[] parameterTypes, Object[] args) throws GenericException;

接口参数说明： methodName：需要调用的方法名称。 parameterTypes：需要调用方法参数的类型。 args：需要传输的参数值。

步骤四：泛化调用

String 类型参数

svc.$invoke("dealMsg", new String[] { "java.lang.String" }, new Object[] { "hello" })

对象参数，服务端和客户端需要保证相同的对象

// 第一步构造实体对象 GenericTestDO，该实体有 id、name 两个属性
  GenericTestDO genericTestDO = new GenericTestDO();
  genericTestDO.setId(1980l);
  genericTestDO.setName("genericTestDO-tst");
  // 使用 PojoUtils 生成二方包 pojo 的描述
  Object comp = PojoUtils.generalize(genericTestDO);
  // 服务泛化调用
  svc.$invoke("dealGenericTestDO",new String[] { "com.alibaba.demo.generic.domain.GenericTestDO" }, new Object[] { comp });

调用链路 Filter 扩展

下载 Demo。

基础接口

public interface ServerFilter extends RPCFilter {
}
public interface ClientFilter extends RPCFilter {
}
public interface RPCFilter {
    ListenableFuture<RPCResult> invoke(InvocationHandler invocationHandler, Invocation invocation) throws Throwable;
    void onResponse(Invocation invocation, RPCResult rpcResult);
}

实现步骤

实现 ServerFilter 进行服务端拦截。 实现 ClientFilter 进行客户端拦截。 业务通过标准的 META-INF/services/com.taobao.hsf.invocation.filter.RPCFilter 文件来注册 Filter。 实现示例

import com.taobao.hsf.invocation.Invocation;
import com.taobao.hsf.invocation.InvocationHandler;
import com.taobao.hsf.invocation.RPCResult;
import com.taobao.hsf.invocation.filter.ServerFilter;
import com.taobao.hsf.util.PojoUtils;
import com.taobao.hsf.util.concurrent.ListenableFuture;
public class HSFServerFilter implements ServerFilter {
    public ListenableFuture<RPCResult> invoke(InvocationHandler invocationHandler, Invocation invocation) throws Throwable {
        //process args
        String[]  sigs = invocation.getMethodArgSigs();
        Object [] args = invocation.getMethodArgs();
        System.out.println("#### intercept request");
        for(String sig : sigs) {
            System.out.print(sig);
            System.out.print(";");
        }
        System.out.println();
        for(Object arg : args) {
            System.out.println(PojoUtils.generalize(arg));
            System.out.print(";");
        }
        System.out.println();
        return invocationHandler.invoke(invocation);
    }
    public void onResponse(Invocation invocation, RPCResult rpcResult) {
        System.out.println("#### intercept response");
        Object resp = rpcResult.getHsfResponse().getAppResponse();
        System.out.println(PojoUtils.generalize(resp));
    }
}

配置 META-INF/services/com.taobao.hsf.invocation.filter.RPCFilter

com.alibaba.edas.carshop.itemcenter.filter.HSFServerFilter

运行效果

intercept request

long 1111 intercept response

试用 {itemId=1, itemName=Mercedes Benz, class=com.alibaba.edas.carshop.itemcenter.Item} 可选的 Filter

在一些场景下，您定制了 filter，但是只希望在某些服务上使用，这时可以使用可选的 Filter。具体做法是在对应的 Filter上 增加 @Optional 注解，如下： 试用

@Optional
@Name("HSFOptionalServerFilter")
public class HSFOptionalServerFilter implements ServerFilter {
    public ListenableFuture<RPCResult> invoke(InvocationHandler invocationHandler,
                                              Invocation invocation) throws Throwable {
        System.out.println("#### HSFOptionalServerFilter intercept request");
        return invocationHandler.invoke(invocation);
    }
    public void onResponse(Invocation invocation, RPCResult rpcResult) {
        System.out.println("#### HSFOptionalServerFilter intercept response");
    }
}

当指定服务需要使用该 Filter 时，只需要在配置的 Bean 上声明即可，配置如下：

<bean class="com.taobao.hsf.app.spring.util.HSFSpringProviderBean">
    <property name="serviceInterface" value="com.alibaba.middleware.hsf.guide.api.service.OrderService" />
    <property name="version" value="1.0.0" />
    <property name="group" value="HSF" />
    <property name="includeFilters">
        <list>
            <value>HSFOptionalServerFilter</value>
            <value>NoFilter</value>
        </list>
    </property>
    <property name="target" ref="orderService" />
</bean>

上述配置的服务，将会使用所有的非 @Optional 修饰的 ServerFilter ，并且会包括 HSFOptionalServerFilter 和 NoFilter，而 HSFOptionalServerFilter 的名称是来自于对应的 Filter 配置上的 @Name 修饰。

如果无法找到该名称的 Filter ，只会提醒您，但是不会导致您无法启动或者运行。

单元测试

在测试环境中，有两种方式做单元测试。 方式一 通过 LightApi 代码发布和订阅服务 方式二 通过 XML 配置发布订阅服务 相关样例请下载 Demo。 方式一 通过 LightApi 代码发布和订阅服务

在 Maven 中添加 LightApi 依赖。

 <dependency>
     <groupId>com.alibaba.hsf</groupId>
     <artifactId>LightApi</artifactId>
     <version>1.0.5</version>
 </dependency>

注意: 请使用 1.0.5 或以上版本的 LightApi，否则可能遇到 hsf: can not load class {com.taobao.hsf.address.AddressService} after all phase的错误。 创建 ServiceFactory。 这里需要设置 Pandora 的地址，参数是 SAR 包所在目录。如果 SAR 包地址是 /Users/Jason/Work/AliSoft/PandoraSar/DevSar/taobao-hsf.sar，则参数如下：

private static final ServiceFactory factory = ServiceFactory.getInstanceWithPath("/Users/Jason/Work/AliSoft/PandoraSar/DevSar");

通过代码进行发布和订阅服务。

 // 进行服务发布（若有发布者，无需再在这里写）
 factory.provider("helloProvider")// 参数是一个标识，初始化后，下次只需调用 provider("helloProvider")即可提供对应服务
         .service("com.alibaba.edas.unit.service.UnitTestService")// 接口全类名
         .version("1.0.0")// 版本号
         .impl(new UnitTestServiceImpl())// 对应的服务实现
         .publish();// 发布服务，至少要调用 service()和 version()才可以发布服务
 // 进行服务消费
 factory.consumer("helloConsumer")// 参数是一个标识，初始化后，下次只需调用 consumer("helloConsumer")即可直接提供对应服务
         .service("com.alibaba.edas.unit.service.UnitTestService")// 接口全类名
         .version("1.0.0")// 版本号
         .subscribe();
 factory.consumer("helloConsumer").sync();// 同步等待地址推送，最多6秒。
 UnitTestService log4jService = (UnitTestService) factory.consumer("helloConsumer").subscribe();// 用 ID 获取对应服务，subscribe()方法返回对应的接口
 // 调用服务方法
 System.out.println("bean -> msg rec success:-"+log4jService.print());

方式二 通过 XML 配置发布订阅服务

编写好 HSF 的 XML 配置。 通过代码方式加载配置文件。

//XML 方式加载服务提供者
new ClassPathXmlApplicationContext("hsf-provider-beans.xml");
//XML 方式加载服务消费者
ClassPathXmlApplicationContext consumerContext=new ClassPathXmlApplicationContext("hsf-consumer-beans.xml");
//获取 Bean
UnitTestXMLConsumer unitTestXMLConsumer=(UnitTestXMLConsumer) consumerContext.getBean("unitTestConsumer");
//服务调用 
unitTestXMLConsumer.testUnitProvider();

参考

阿里云官网 - 帮助文档： 企业级分布式应用服务 EDAS > 应用开发 > 使用 HSF 开发应用 > 使用 Ali-Tomcat 开发应用 > 开发 HSF 应用（EDAS SDK）

转载于:https://my.oschina.net/u/2464371/blog/3041571

weixin_33840661
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
阿里edas开发工具包edas-sdk
02-21
阿里edas开发工具包，
服务框架HSF分析之二Provider启动和处理
吊丝码农
12-10 2258
  上篇文章，简单介绍了HSF框架的初始化。这一篇，小编将为大家带来HSF provider的启动和服务细节。主要关注点：Server的启动，服务的注册，调用处理主流程(IO线程，业务线程)。 一.  Server的启动 在某一个HSFSpringProviderBean初始化时，启动HSF Server。在HSF默认协议使用TBRemoting作为RPC框架，TBRemotingRPCPr...
HSF:阿里RPC框架
最新发布
03-28 729
HSF（High-speed Service Framework）是一种广泛应用于阿里巴巴内部的分布式RPC服务框架。作为阿里巴巴的基础中间件，HSF连接了不同的业务系统，解耦了系统间的实现依赖。HSF从分布式应用的角度统一了服务的发布和调用方式，从而帮助用户方便快速地开发分布式应用，并提供或使用公共功能模块。它屏蔽了分布式领域中的各种复杂技术细节，如远程通信、序列化实现、性能损耗以及同步/异步调用方式的实现等。
HSF用户指南
weixin_52638824的博客
02-21 1627
响应对象会在HSF服务端线程中完成序列化，并放置到通信响应对象中。如果把这些服务都理解为资源的话，对于资源的管理就变得愈发重要，在RPC框架刚开始使用的时候，可能只有几个应用，几十个服务，如果规模扩充到上万应用，几十万个服务，RPC调用反而不是重头戏，而重要的是如何能高效的组织这些服务。软件环境分为：日常、预发和生产三种，如果只有一种，生产环境的数据在日常线下就会被访问和操作，这是不允许的，而环境的分类就需要依靠状态信息分开存储，也就是环境的区分依赖于地址注册中心和持久化配置中心（软负载体系）的区分。
HSF从部署到开发到原理分析
weixin_34104341的博客
11-12 244
1.搭建HSF环境 https://help.aliyun.com/document_detail/44158.html?spm=a2c4g.11186623.6.674.13c248fahbl8fU 2.开发HSF服务 https://help.aliyun.com/document_detail/85329.html?spm=a2c4g.11186623.6.679.16ba7549KvzWL...
HSF异步调用
cpf2016的专栏
05-18 5880
1.引入           按照前面的配置、使用方式，实际上使用的是hsf的同步调用，也就是客户端一直等待服务端返回结果。           但是有些是不需要一直等待服务端返回结果的，对于这些服务，hsf提供异步调用的方式，让客户端不必同步阻塞在hsf操作上 2.异步调用           （1）说明                     异步调用在发起调用时，HSF
EDAS-HSF-BOOT
08-15
EDAS 生产者 消费者 api 齐全 环境配好既可以使用................................................................
Springboot+HSF分布式服务框架+EDAS注册中心，实现发布订阅模式
02-12
Springboot+HSF分布式服务框架+EDAS注册中心，实现发布订阅模式
EDAS中HSF方式启动服务入门文档
05-24
EDAS中HSF方式启动服务入门文档,详细描述了EDAS中HSF方式的启动过程
EDAS开发培训(初级)v1.0.5.pptx
03-26
EDAS开发
分布式 RPC 框架HSF
博客
07-20 876
HSF (High-speed Service Framework)，高速服务框架，是在阿里巴巴内部广泛使用的分布式 RPC 服务框架。HSF 作为阿里巴巴的基础中间件，联通不同的业务系统，解耦系统间的实现依赖。HSF 从分布式应用的层面，统一了服务的发布/调用方式，从而帮助用户可以方便、快速的开发分布式应用，以及提供或使用公共功能模块。为用户屏蔽了分布式领域中的各种复杂技术细节，如：远程通讯、序列化实现、性能损耗、同步/异步调用方式的实现等。
HSF框架基本介绍
超威半导体
01-16 1万+
HSF介绍 HSF全称high speed frameworkd,是Alibaba内部使用的RPC框架，最初与Dubbo进行内部竞争，由于多方面的原因最终选择了HSF。 主要原因如下： HSF代码量少一些，轻量一些，代码量大概2/3, Dubbo设计更加全面功能更多，更容器扩展和替换开源组件。 HSF的netty + hession传输性能更高, Dubbo内部filter过多也进一步降低RPC...
谈谈HSF在Spring中的应用
zhangxing
02-05 778
谈谈HSF在Spring中的应用HSF简介HSF的应用场景什么是二方包服务提供方怎么提供服务？服务调用方怎么订阅服务？ HSF简介 HSF即高可用服务框架（High-speed Service Framework），是在阿里巴巴广泛使用的分布式RPC服务框。 HSF的应用场景 HSF调用链包括服务调用方及服务提供方，服务提供方需要提供可用服务并提供二方包给服务调用方，服务调用方需要订阅提供方的服务，通过二方包调用相应的API完成请求。 什么是二方包 公司内部的依赖库，一般指公司内部的其他项目发布的
分布式应用，response导出error on submit request on future invoke、java.lang.OutOfMemoryError: Java heap space
Colourful.的博客
08-17 1156
背景 HSF 分布式框架 ，EasyExcel 导出 ， GET请求 ， 传递 HttpServletRequest 和 HttpServletRespose ，从分布式应用 controller 到，分布式应用 service 时，异常 解决 改成 POST 导出 并上传文件服务器，返回uploadId 详细日志 com.taobao.hsf.exception.HSFException: error message : error on submit request on future invoke
分布式服务框架HSF简介
weixin_39209728的博客
02-12 2878
高速服务框架 HSF (High-speed Service Framework)，是在阿里巴巴内部广泛使用的分布式 RPC 服务框架。HSF 统一了分布式应用中服务的发布/调用方式，从而帮助您方便、快速的开发分布式应用 HSF 架构 HSF 作为一个纯客户端架构的 RPC 框架，本身是没有服务端集群的，所有的 HSF 服务调用都是服务消费方（Consumer）与服务提供方（Provider）...
Servlet中获取来访机器的IP地址
imorris的专栏
07-12 2090
在Servlet中添加下面的方法：  /** * 获取Ip地址 */ protected String getIpAddr(HttpServletRequest request) { String ip = request.getHeader("x-forwarded-for"); if (ip == null || ip.length() ==
这特么是啥系列之----HSF求求你别秀了
start_lie的博客
02-09 5778
如何发布HSF服务感觉这个hsf需要pandora环境,所以...先导依赖&lt;dependencyManagement&gt; &lt;dependencies&gt; &lt;dependency&gt; &lt;!-- Import dependency management from Spring Boot --&gt; ...
HSF入门例子
cpf2016的专栏
05-18 8474
1.搭建HSF环境         实际上就是下载hsf.sar，然后放置到tomcat的应用目录下即可 2.服务端         （1）创建web项目         （2）添加编译和打包的插件 1.6 HSFSampleLanshan maven-compiler-plug
HSF简介
热门推荐
laomumu1992的博客
01-25 4万+
     阿里巴巴集团内部使用的分布式服务框架 HSF（High Speed Framework，也有人戏称“好舒服”）已经被很多技术爱好者所熟知，目前已经支撑着近 2000 多个应用的运行。      其对应早期的开源项目 Dubbo（因为某些原因，Dubbo 项目在 2012 年年底，阿里巴巴就停止了对此开源项目的更新），则更是在互联网领域有着非常高的知名度和广泛的使用。      本文通...
分布估计算法EDAs
08-24
EDAs (Estimation of Distribution Algorithms) 是一类基于概率分布估计的进化算法，用于解决优化问题。它们通过建立和更新问题的概率模型来指导搜索过程。下面是一种常见的EDAs算法： 1. 初始化：随机生成一组个体...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值