Repository files navigation

Eagle是一个分布式的RPC框架，支持灵活的配置，支持分布式追踪，支持Kryo、Hessian、Protobuf等序列化协议，默认序列化使用kryo。提供Spring和SpringBoot插件，方便与Spring和SpringBoot集成。

• 借助Zookeeper实现服务注册和发现。
• 分布式ID追踪，方便排查问题。
• 基于AQS实现高性能连接池。
• 提供failover和failfast两种高可用策略。
• 支持同步和异步回调两种机制。
• 提供接口方法请求时间、tps等监控信息。
• 提供和自定义服务端过载保护策略。

运行基准测试步骤：

• cd eagle-benchmark
• mvn clean install
• cd eagle-benchmark-server/target
• tar -zxvf eagle-benchmark-server-1.8-assembly.tar.gz
• cd eagle-benchmark-server-1.8
• bin/start.sh
• cd eagle-benchmark/eagle-benchmark-client
• 在linux上运行 sh benchmark.sh，在window上运行 benchmark.cmd
• 注（修改benchmark.sh 中的 -t 参数修改线程数）

macOs上的结果（16g内存，2.5 GHz Intel Core i7），启动16个线程。

linux上的结果（64g内存，24核），启动80个线程。

内置zookeeper，仅测试使用。生产环境请更换真实zookeeper地址，使用内置zookeeper有可能会报连接警告或者异常，更换真实zk地址即可。运行要求:

• JDK 1.7 or above
• 编译工具Maven orGradle

如果是spring,添加如下:

 <dependency>     <groupId>org.jfaster.eagle</groupId>     <artifactId>eagle-core</artifactId>     <version>1.8</version> </dependency> <dependency>     <groupId>org.jfaster.eagle</groupId>     <artifactId>eagle-registry-zookeeper</artifactId>     <version>1.8</version> </dependency> <dependency>     <groupId>org.jfaster.eagle</groupId>     <artifactId>eagle-transport-netty</artifactId>     <version>1.8</version> </dependency> <dependency>     <groupId>org.jfaster.eagle</groupId>     <artifactId>eagle-spring-support</artifactId>     <version>1.8</version> </dependency>

如果是springBoot,添加如下:

 <dependency>     <groupId>org.jfaster.eagle</groupId>     <artifactId>eagle-core</artifactId>     <version>1.8</version> </dependency> <dependency>     <groupId>org.jfaster.eagle</groupId>     <artifactId>eagle-registry-zookeeper</artifactId>     <version>1.8</version> </dependency> <dependency>     <groupId>org.jfaster.eagle</groupId>     <artifactId>eagle-transport-netty</artifactId>     <version>1.8</version> </dependency> <dependency>   <groupId>org.jfaster.eagle</groupId>   <artifactId>spring-boot-starter-eagle</artifactId>   <version>1.8</version> </dependency>

在应用中一个接口通常会涉及到一系列服务的rpc调用，由于服务分布式部署导致出现问题排查相对困难。eagle框架在一次调用中生成的traceId是相同的，只要通过ELK等日志搜集系统把日志集中处理，那么输入traceId就可以获取整个链路的调用过程。          C         /    例如 A - B   A调用B，B又调用C和D，那么在一次调用中，可以通过traceId，把整个调用串联起来。traceId是根据ip+进程号+时间戳+计数，生成的全局唯一id，如果框架内部获取的ip不准确可以通过，如-Dhost=10.110.69.17指定。         \          D在业务代码中，当打印日志的时候，可以通过TraceContex.getOpaque()方法获取当前调用链中的traceId。打印出traceId，logger.info(TraceContex.getOpaque() + "xxxxxx")。这样就可以根据日志追踪整个调用过程。更简单的方式是使用eagle框架提供的日志组件，配置如下：

• 如果当前上下文中存在traceId，logback将在输出traceId，如果不存在traceId则输出N/A。用%traceId来展示traceId。

<appendername="STDOUT"class="ch.qos.logback.core.ConsoleAppender">    <encoderclass="ch.qos.logback.core.encoder.LayoutWrappingEncoder">        <layoutclass="eagle.jfaster.org.trace.logback.TraceIdPatternLogbackLayout">            <Pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%traceId] [%thread] %-5level %logger{36} -%msg%n</Pattern>        </layout>    </encoder></appender>

• 配置layout

log4j.appender.CONSOLE.layout=eagle.jfaster.org.trace.log4j.TraceIdPatternLayout

• 在layout.ConversionPattern中设置 %T来展示traceId

log4j.appender.CONSOLE.layout.ConversionPattern=%d [%T] %-5p %c{1}:%L - %m%n

• 在spring配置文件中，添加<eagle:trace/> 配置，springboot不用添加额外配置。然后在需要追踪的类或者方法上打上@Trace注解。

src/main/java/eagle/jfaster/org/controller/TraceController.java

packageeagle.jfaster.org.controller;importeagle.jfaster.org.config.annotation.Refer;importeagle.jfaster.org.service.Calculate;importeagle.jfaster.org.service.Hello;importeagle.jfaster.org.trace.annotation.Trace;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.web.bind.annotation.RequestMapping;importorg.springframework.web.bind.annotation.RequestParam;importorg.springframework.web.bind.annotation.RestController;/**     * Created by fangyanpeng on 2017/12/16.     */@RestController@RequestMapping("/")publicclassTraceController {privatestaticfinalLoggerlogger =LoggerFactory.getLogger(TraceController.class);@Refer(baseRefer ="baseRefer")privateCalculatecalculate;@Refer(baseRefer ="baseRefer")privateHellohello;@Trace@RequestMapping("/cal")publicStringcal(@RequestParaminta,@RequestParamintb,@RequestParamintcode){//log会打印出TraceIdlogger.info(hello.hello(code));intres =calculate.add(a,b);logger.info("calculate {}",res);returnString.valueOf(res);        }    }

1. 创建一个接口类。

   src/main/java/eagle/jfaster/org/service/Calculate.java

   packageeagle.jfaster.org.service;publicinterfaceCalculate {intadd(inta,intb);intsub(inta,intb);}

2. 实现接口，并暴露服务。

   src/main/java/eagle/jfaster/org/service/impl/CalculateImpl.java

   packageeagle.jfaster.org.service.impl;importeagle.jfaster.org.service.Calculate;importorg.springframework.stereotype.Service;@Service("calculate")publicclassCalculateImplimplementsCalculate {publicintadd(inta,intb) {returna+b;    }publicintsub(inta,intb) {returna-b;    }}

   src/main/resources/server.xml

   <?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:eagle="http://eagle.jfaster.org/schema/eagle"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://eagle.jfaster.org/schema/eagle                        http://eagle.jfaster.org/schema/eagle/eagle.xsd">    <context:component-scanbase-package="eagle.jfaster.org" />    <context:annotation-config/><!--注册中心配置可以多个-->    <eagle:registryname="regCenter"protocol="zookeeper"address="127.0.0.1:4181"namespace="eagle"base-sleep-time-milliseconds="1000"max-sleep-time-milliseconds="3000"max-retries="3"/><!--协议配置-->    <eagle:protocolid="proto"name="eagle"serialization="kryo"use-default="true"max-content-length="16777216"max-server-connection="20000"core-worker-thread="20"max-worker-thread="200"worker-queue-size="10"/>    <eagle:base-serviceid="baseService"group="eagleGroup"export="proto:9200"registry="regCenter"/>    <eagle:serviceinterface="eagle.jfaster.org.service.Calculate"ref="calculate"base-service="baseService"export="proto:9300,proto:9400"service-type="cglib"/>

   src/main/java/eagle/jfaster/org/Server.java

   packageeagle.jfaster.org.server;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;importjava.util.concurrent.CountDownLatch;publicclassServer {publicstaticvoidmain(String[]args)throwsInterruptedException {//启动Curator框架提供的内置zookeeper 仅供测试使用，生产环境请使用真实zookeeper地址EmbedZookeeperServer.start(4181);ApplicationContextappCtx =newClassPathXmlApplicationContext("server.xml");CountDownLatchlatch =newCountDownLatch(1);latch.await();    }}

   执行main方法，就会在9300和9400端口发布服务。同时eagle还提供了eagle.jfaster.org.container.Main类，会跟据环境变量eagle.container的设置启动不同的容器。如果没有配置会默认启动SpringContainer，会加载classpath*:META-INF/spring/*.xml的所有spring配置文件。

3. 创建和启动客户端

   src/main/resources/client_sync.xml

   <?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:eagle="http://eagle.jfaster.org/schema/eagle"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://eagle.jfaster.org/schema/eagle                        http://eagle.jfaster.org/schema/eagle/eagle.xsd">    <context:component-scanbase-package="eagle.jfaster.org" />    <context:annotation-config/><!--注册中心配置可以多个-->    <eagle:registryname="regCenter"protocol="zookeeper"address="127.0.0.1:4181"namespace="eagle"base-sleep-time-milliseconds="1000"max-sleep-time-milliseconds="3000"max-retries="3"/><!--协议配置-->    <eagle:protocolname="eagle"serialization="kryo"use-default="true"cluster="eagle"max-content-length="16777216"/>    <eagle:base-referid="baseRefer"request-timeout="300"actives="20000"actives-wait="300"loadbalance="roundrobin"ha-strategy="failfast"protocol="eagle"registry="regCenter"compress="false"group="eagleGroup"connect-timeout="10000"/>    <eagle:referid="cal"interface="eagle.jfaster.org.service.Calculate"base-refer="baseRefer"max-invoke-error="10"max-client-connection="200" />

   src/main/java/eagle/jfaster/org/client/SyncClient.java

   packageeagle.jfaster.org.client;importeagle.jfaster.org.service.Calculate;importeagle.jfaster.org.service.HelloWorld;importeagle.jfaster.org.service.Notify;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;publicclassSyncClient {publicstaticvoidmain(String[]args) {ApplicationContextappCtx =newClassPathXmlApplicationContext("client_sync.xml");Calculatecalculate =appCtx.getBean("cal",Calculate.class);System.out.println(calculate.add(1,3));System.out.println(calculate.sub(8,3));    }}

   执行main方法，就会在控制台打印出信息。

1. 异步调用只需在客户端注册一个MethodInvokeCallBack即可，服务端不用改动，在回调实例中可以引用任意spring容器中的实例。

   src/main/java/eagle/jfaster/org/callback/CalculateCallBack.java

   packageeagle.jfaster.org.callback;importeagle.jfaster.org.rpc.MethodInvokeCallBack;importjavax.annotation.Resource;publicclassCalculateCallBackimplementsMethodInvokeCallBack<Integer> {@ResourceCalculateDaocalculateDao;publicvoidonSuccess(Integerresponse) {calculateDao.insert(response);System.out.println("calculate res:"+response);    }publicvoidonFail(Exceptione) {e.printStackTrace();    }}

   src/main/java/eagle/jfaster/org/callback/CalculateDao.java

   packageeagle.jfaster.org.callback;importorg.springframework.stereotype.Service;@Service("calculateDao")publicclassCalculateDao {voidinsert(Integeri){System.out.println("-----------insert--------"+i);    }}

2. 创建和启动客户端。

   src/main/resources/client_async.xml

   <?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:eagle="http://eagle.jfaster.org/schema/eagle"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://eagle.jfaster.org/schema/eagle                        http://eagle.jfaster.org/schema/eagle/eagle.xsd">    <context:component-scanbase-package="eagle.jfaster.org" />    <context:annotation-config/><!--注册中心配置可以多个-->    <eagle:registryname="regCenter"protocol="zookeeper"address="127.0.0.1:4181"namespace="eagle"base-sleep-time-milliseconds="1000"max-sleep-time-milliseconds="3000"max-retries="3"/><!--协议配置-->    <eagle:protocolname="eagle"serialization="kryo"use-default="true"cluster="eagle"max-content-length="80000000" />    <eagle:base-referid="baseReferAsync"request-timeout="300"actives="20000"actives-wait="3000"loadbalance="roundrobin"ha-strategy="failfast"protocol="eagle"registry="regCenter"compress="false"group="eagleGroup"connect-timeout="10000"/>    <eagle:referid="calAsync"callback="eagle.jfaster.org.callback.CalculateCallBack"interface="eagle.jfaster.org.service.Calculate"base-refer="baseReferAsync"max-invoke-error="10"max-client-connection="200" /></beans>

   src/main/java/eagle/jfaster/org/client/AsyncClient.java

   packageeagle.jfaster.org.client;importeagle.jfaster.org.service.Calculate;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;importjava.util.concurrent.TimeUnit;publicclassAsyncClient {publicstaticvoidmain(String[]args)throwsInterruptedException {ApplicationContextappCtx =newClassPathXmlApplicationContext("client_async.xml");Calculatecalculate =appCtx.getBean("calAsync",Calculate.class);calculate.add(1,3);calculate.sub(34,9);//等待异步结果while (true) {TimeUnit.SECONDS.sleep(5);        }    }}

   运行结果如果成功会调用MethodInvokeCallBack的onSuccess方法，否则会调用onFail方法。不要使用异步客户端返回的值，那是不正确的，正确的值通过回调的onSuccess方法获取。

1. 创建接口

   src/main/java/eagle/jfaster/org/service/Hello.java

   packageeagle.jfaster.org.service;publicinterfaceHello {Stringhello();}

2. 实现接口，并打上Service注解。

   src/main/java/eagle/jfaster/org/anno/HelloImpl.java

   packageeagle.jfaster.org.anno;importeagle.jfaster.org.config.annotation.Service;importeagle.jfaster.org.service.Hello;@Service(baseService ="baseService",export ="proto:28000",serviceType ="cglib")publicclassHelloImplimplementsHello {publicStringhello() {return"hello eagle";    }}

3. 创建和启动服务端。

   src/main/resources/server_annotation.xml

   <?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:eagle="http://eagle.jfaster.org/schema/eagle"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://eagle.jfaster.org/schema/eagle                        http://eagle.jfaster.org/schema/eagle/eagle.xsd">    <context:component-scanbase-package="eagle.jfaster.org.anno" />    <context:annotation-config/><!--注册中心配置可以多个-->    <eagle:registryname="regCenter"protocol="zookeeper"address="127.0.0.1:4181"namespace="eagle"base-sleep-time-milliseconds="1000"max-sleep-time-milliseconds="3000"max-retries="3"/><!--协议配置-->    <eagle:protocolid="proto"name="eagle"serialization="kryo"use-default="true"max-content-length="16777216"max-server-connection="20000"core-worker-thread="20"max-worker-thread="200"worker-queue-size="10"/>    <eagle:base-serviceid="baseService"group="eagleGroup"export="proto1:9200"registry="regCenter"/>    <eagle:component-scanbase-package="eagle.jfaster.org.anno"/>

   src/main/java/eagle/jfaster/org/server/ServerAnnotation.java

   packageeagle.jfaster.org.server;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;importjava.util.concurrent.CountDownLatch;publicclassServerAnnotation {publicstaticvoidmain(String[]args)throwsInterruptedException {//启动Curator框架提供的内置zookeeper 仅供测试使用，生产环境请使用真实zookeeper地址EmbedZookeeperServer.start(4181);ApplicationContextappCtx =newClassPathXmlApplicationContext("server_annotation.xml");CountDownLatchlatch =newCountDownLatch(1);latch.await();    }}

4. 创建和启动客户端。

   src/main/resources/client_annotation.xml

   <?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:eagle="http://eagle.jfaster.org/schema/eagle"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://eagle.jfaster.org/schema/eagle                        http://eagle.jfaster.org/schema/eagle/eagle.xsd">    <context:component-scanbase-package="eagle.jfaster.org.client" />    <context:annotation-config/><!--注册中心配置可以多个-->    <eagle:registryname="regCenter"protocol="zookeeper"address="127.0.0.1:4181"namespace="eagle"base-sleep-time-milliseconds="1000"max-sleep-time-milliseconds="3000"max-retries="3"/><!--协议配置-->    <eagle:protocolname="eagle"serialization="kryo"use-default="true"cluster="eagle"max-content-length="16777216"/>    <eagle:base-referid="baseRefer"request-timeout="300"actives="20000"actives-wait="300"loadbalance="roundrobin"ha-strategy="failfast"protocol="eagle"registry="regCenter"compress="false"group="eagleGroup"connect-timeout="10000"/>    <eagle:component-scanbase-package="eagle.jfaster.org.client"/></beans>

   src/main/java/eagle/jfaster/org/client/AnnotationClient.java

   packageeagle.jfaster.org.client;importeagle.jfaster.org.config.annotation.Refer;importeagle.jfaster.org.service.Hello;importorg.springframework.context.support.ClassPathXmlApplicationContext;importorg.springframework.stereotype.Service;/** * Created by fangyanpeng on 2017/8/18. */@ServicepublicclassAnnotationClient {@Refer(baseRefer ="baseRefer")privateHellohello;publicstaticvoidmain(String[]args) {ClassPathXmlApplicationContextappCtx =newClassPathXmlApplicationContext("client_annotation.xml");appCtx.start();AnnotationClientclient =appCtx.getBean(AnnotationClient.class);System.out.println(client.hello.hello());    }}

   注解的方式同样支持同步调用和异步调用两种方式，只要在Refer注解里指定callback属性为MethodInvokeCallBack实现的全限定性名即可。Refer和Service注解里的属性与xml配置的属性一一对应。

1. 配置yml或properties文件，配置一个即可。

   src/main/resources/application.yml

   eagle:  #扫描eagle服务，多个包用逗号分隔  base-package: eagle.jfaster.org  #注册中心配置，可以配置多个  registry:    - name: regCenter      protocol: zookeeper      address: 127.0.0.1:4181      namespace: eagle      base-sleep-time-milliseconds: 1000      max-sleep-time-milliseconds: 3000      max-retries: 3  #协议配置，可以配置多个  protocol:    - id: proto      name: eagle      serialization: kryo      use-default: true      max-content-length: 16777216      max-server-connection: 20000      core-worker-thread: 20      max-worker-thread: 400      worker-queue-size: 10      cluster: eagle  #baseRefer配置，可以配置多个  base-refer:    - id: baseRefer      request-timeout: 300      actives: 20000      actives-wait: 300      loadbalance: roundrobin      ha-strategy: failfast      compress: false      group: eagleGroup      connect-timeout: 10000      protocol: proto      registry: regCenter  #baseService配置，可以配置多个  base-service:    - id: baseService      group: eagleGroup      export: proto:9200      registry: regCenter

   src/main/resources/application.properties

     #扫描eagle服务，多个包用逗号分隔  eagle.base-package=eagle.jfaster.org    #注册中心配置，可以配置多个  eagle.registry[0].name=regCenter  eagle.registry[0].protocol=zookeeper  eagle.registry[0].address=127.0.0.1:4181  eagle.registry[0].namespace=eagle  eagle.registry[0].base-sleep-time-milliseconds=1000  eagle.registry[0].max-sleep-time-milliseconds=3000  eagle.registry[0].max-retries=3    #协议配置，可以配置多个  eagle.protocol[0].id=proto  eagle.protocol[0].name=eagle  eagle.protocol[0].serialization=kryo  eagle.protocol[0].use-default=true  eagle.protocol[0].max-content-length=16777216  eagle.protocol[0].max-server-connection=20000  eagle.protocol[0].core-worker-thread=20  eagle.protocol[0].max-worker-thread=400  eagle.protocol[0].worker-queue-size=10  eagle.protocol[0].cluster=eagle    #baseRefer配置，可以配置多个  eagle.base-refer[0].id=baseRefer  eagle.base-refer[0].request-timeout=300  eagle.base-refer[0].actives=20000  eagle.base-refer[0].actives-wait=300  eagle.base-refer[0].loadbalance=roundrobin  eagle.base-refer[0].ha-strategy=failfast  eagle.base-refer[0].compress=false  eagle.base-refer[0].group=eagleGroup  eagle.base-refer[0].connect-timeout=10000  eagle.base-refer[0].protocol=proto  eagle.base-refer[0].registry=regCenter    #baseService配置，可以配置多个  eagle.base-service[0].id=baseService  eagle.base-service[0].group=eagleGroup  eagle.base-service[0].export=proto:9200  eagle.base-service[0].registry=regCenter

2. 创建接口

   src/main/java/eagle/jfaster/org/service/Calculate.java

   packageeagle.jfaster.org.service;/** * Created by fangyanpeng1 on 2017/8/9. */publicinterfaceCalculate {intadd(inta,intb);intsub(inta,intb);}

3. 实现接口，并打上Service注解。

   src/main/java/eagle/jfaster/org/service/impl/CalculateImpl.java

   packageeagle.jfaster.org.service.impl;importeagle.jfaster.org.config.annotation.Service;importeagle.jfaster.org.service.Calculate;/** * Created by fangyanpeng1 on 2017/8/9. */@Service(id ="calculateService",baseService ="baseService",export ="proto:29001")publicclassCalculateImplimplementsCalculate {publicintadd(inta,intb) {returna+b;    }publicintsub(inta,intb) {returna-b;    }}

4. 启动服务端和客户端

   src/main/java/eagle/jfaster/org/service/Calculator.java

   packageeagle.jfaster.org.service;importeagle.jfaster.org.config.annotation.Refer;importorg.springframework.stereotype.Service;/**     * Created by fangyanpeng on 2017/10/24.     */@ServicepublicclassCalculator {@Refer(baseRefer ="baseRefer")publicCalculatecalculate;        }

   src/main/java/eagle/jfaster/org/SpringBootSartup.java

   packageeagle.jfaster.org;importeagle.jfaster.org.service.Calculator;importorg.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication;importorg.springframework.context.ApplicationContext;importjava.util.concurrent.TimeUnit;/**     * Created by fangyanpeng1 on 2017/8/11.     */@SpringBootApplicationpublicclassSpringBootSartup {publicstaticvoidmain(String[]args)throwsInterruptedException {//启动Curator框架提供的内置zookeeper 仅供测试使用，生产环境请使用真实zookeeper地址EmbedZookeeperServer.start(4181);ApplicationContextctx =SpringApplication.run(SpringBootSartup.class,args);TimeUnit.SECONDS.sleep(2);Calculatorcalculator =ctx.getBean(Calculator.class);System.out.println(calculator.calculate.add(1,2));System.out.println(calculator.calculate.sub(9,5));        }    }

   SpringBoot方式同样支持同步调用和异步调用两种方式，只要在Refer注解里指定callback属性为MethodInvokeCallBack实现的全限定性名即可。Refer和Service注解里的属性与xml配置的属性一一对应。注意此例子中，由于Refer和Service在同一个工程，所以运行main方法Refer和Service就都启动了，实际生产环境中一般都是服务的调用和服务的实现部署在不同的进程中。

调用端和服务端都可以使用，以记录方法的远程调用执行时间为例。通过CurrentExecutionContext可以在拦截器的各个方法之间传递参数。异步调用由于方法调用立即返回，真正的处理逻辑在回调函数中，所以onAfter方法会在结果返回之后，回调方法调用之前执行。onBefore方法在执行调用之前执行，onAfter方法会在调用方法之后执行，onError方法在发生异常时执行。

src/main/java/eagle/jfaster/org/interceptor/ClientInterceptor.java

packageeagle.jfaster.org.interceptor;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.stereotype.Service;importeagle.jfaster.org.interceptor.context.CurrentExecutionContext;/**     * Created by fangyanpeng1 on 2018/3/31.     */@Service("clientInterceptor")publicclassClientInterceptorimplementsExecutionInterceptor {privatestaticfinalLoggerlogger =LoggerFactory.getLogger(ClientInterceptor.class);@OverridepublicvoidonBefore(StringinterfaceName,Stringmethod,Object[]args) {logger.info("{}.{} start....",interfaceName,method);CurrentExecutionContext.setVariable("begin",System.nanoTime());        }@OverridepublicvoidonAfter(StringinterfaceName,Stringmethod,Object[]args) {logger.info("{}.{} end....",interfaceName,method);longstarTime = (long)CurrentExecutionContext.getVariable("begin");logger.info("{}.{} spent {} ns",interfaceName,method,System.nanoTime() -starTime);        }@OverridepublicvoidonError(StringinterfaceName,Stringmethod,Object[]args,Throwablee) {logger.info("{}.{} error....",interfaceName,method,e);longstarTime = (long)CurrentExecutionContext.getVariable("begin");logger.info("{}.{} spent {} ns",interfaceName,method,System.nanoTime() -starTime);        }    }

1. xml配置

   <eagle:referid="calculate1"interface="eagle.jfaster.org.service.Calculate"base-refer="baseRefer1"max-invoke-error="10"max-client-connection="20"interceptor="clientInterceptor"/>

2. 如果是通过注解的方式配置，直接在注解的的属性指定即可@Refer(interceptor="clientInterceptor")或@Service(interceptor="clientInterceptor")

• name: 注册中心的名称，如果没有配置id，会用name当id。
• protocol: 注册中心协议，目前只支持zookeeper。
• address: 注册中心地址，如果是多个地址以逗号分隔，如果是多组用|或;分隔。
• namespace: zk上的命名空间，所有的信息都在该命名空间下。
• max-retries: 连接注册中心的重试次数。
• base-sleep-time-milliseconds: 重试时间间隔。
• max-sleep-time-milliseconds: 最大重试时间。
• session-timeout-milliseconds: 与注册中心的会话超时时间。
• digest: 连接注册中心的密码。

• name: 协议名称,目前只支持eagle，后续加入thrift，如果没有配置id，name会充当id。
• serialization: 序列化，支持hessian、kryo、protobuf序列化协议。
• heartbeat-factory: 心跳工厂,默认值是eagle,通过spi方式可以自定义心跳工厂。
• select-thread-size: netty处理io的线程数，尽量不要阻塞netty的io线程。
• core-worker-thread: 处理业务的核心线程数。
• max-worker-thread: 处理业务的最大线程数。
• max-content-length: rpc调用最大传输的字节数。
• max-server-connection: 一个端口支持的最大连接数。
• protect-strategy: 服务端负载保护策略，当服务端接收了过多的请求并且业务处理不过来时，进行负载保护。目前支持none、concurrent、memory 3种过载保护策略。none是默认策略，什么都不做。concurrent是并发保护策略，当并发达到max-worker-thread*3／4时，并且处理业务缓慢则拒绝接收新的请求。memory 是内存使用策略，当jvm内存使用超过90%时，拒绝接收新的请求。
• codec: 用于编码和解码的工具类，默认调用EagleCodec，可以通过spi的方式自定义codec。
• use-native: 在linux环境下，是否开启epoll。默认是true。

• group: 调用组，客户端和服务端配置要一致。
• version: 版本号，区分相同服务的不同版本，客户端与服务端的版本号一致才能调用成功。
• retries: 调用失败重试次数。
• actives: 支持的最大并发数。
• actives-wait: 并发达到最大后等待多长时间。
• check: 启动时是否检测有服务，默认false。
• registry: 注册中心，多个注册中心以逗号分隔。
• host: ip地址，一般不需要指定，系统会自动获取，如果特殊需求可自己设定。
• request-timeout: 请求超时时间。
• min-client-connection: 最小连接数。
• max-client-connection: 最大连接数。
• idle-time: 连接空闲多长时间会被回收。
• connect-timeout: 获取连接的超时时间。
• max-invoke-error: 连续调用失败的的次数，超过这个次数，这个服务设置为不可用。
• compress: 是否开启gzip压缩。
• loadbalance: 负载均衡策略，目前支持random（随机）、roundrobin（轮询）、activeWeigth（以调用量小的优先）、weight（根据配置的权重选择）。
• ha-strategy: ha策略，目前支持failover、failfast。
• interface: 服务的接口。
• callback: 回调，如果设置了回调，该服务就会变成异步。
• callback-thread: 回调执行线程池的大小。
• callback-queue-size: 回调任务队列大小。
• callback-wait-time: 回调任务执行等待时间与request-timeout不同,如果异步任务队列超过设定阈值并且任务等待时间过长，则将此服务设置为不可用，直到任务队列在合理范围内。
• base-refer: 公共的refer配置。
• stats-log: 统计log的名称，如果配置了该名称，则会把接口方法的调用时间、tps等信息写入此log，方便查看接口的性能。
• mock: 接口失败降级类的全限定名。如果配置了mock，接口调用失败，就会降级调用mock的实现。mock需要实现 eagle.jfaster.org.rpc.Mock接口。
• interceptor: 拦截器在spring中bean的名称，多个拦截器用逗号分割，实现ExecutionInterceptor接口，通过CurrentExecutionContext可以在拦截器的各个方法间传递业务参数。

• group: 调用组，客户端和服务端配置要一致。
• version: 版本号，区分相同服务的不同版本，客户端与服务端的版本号一致才能调用成功。
• registry: 注册中心，多个注册中心以逗号分隔。
• host: ip地址，一般不需要指定，系统会自动获取，如果特殊需求可自己设定。
• interface: 服务的接口。
• base-service: 公共的service配置。
• ref: 接口的实现类引用。
• class: 如果没有配置ref，会根据class加载接口实现类。
• export: 服务暴露的协议和端口号，多个用逗号分割，如proto:7000,proto:8000，proto是协议的id。
• weight: 权重，与权重负载均衡算法联合使用。
• service-type: 服务调用类型，支持jdk和cglib两种配置，默认是jdk。如果是jdk，采用反射机制调用实现类的方法；如果是cglib，采用cglib索引机制直接调用实现类的方法，性能更好。
• interceptor: 拦截器在spring中bean的名称，多个拦截器用逗号分割，实现ExecutionInterceptor接口，通过CurrentExecutionContext可以在拦截器的各个方法间传递业务参数。

• 在spring的配置文件中，增加<eagle:trace/>配置。配合@Trace注解实现追踪功能。@Trace打在类上，则这个类的所有方法被追踪。打在方法上，则只有这个方法被追踪。只需要在最外层的调用打@Trace注解即可，内层的调用会自动并入当前的调用链中。同一调用链中的日志打印会带有相同的traceId。

eagle 提供可视化的后台管理，方便查看和修改配置。启动后台的步骤

• tar -zxvf eagle-ui-1.8.tar.gz

• cd eagle-ui-1.8

• vim conf/eagle.conf 修改用户名、密码、jvm参数、日志路径、端口号等

• sh bin/eagle.sh start

  

• fangyanpeng(@fangyanpeng)