java开源项目jremoting

 

https://github.com/jremoting/jremoting

jremoting是一个类似dubbo的rpc服务治理框架,并且可以与dubbo相互调用。jremoting的实现是参考了dubbo的许多概念，但是代码相比 dubbo更简洁，模型也更精简更灵活。底层nio通信是基于netty 4.x实现的。注册中心同开源版本的dubbo一样基于zookeeper实现。

主要功能包括

1. 透明方式的rpc调用,支持consumer端异步调用与provider的异步实现
2. 服务的动态发现
3. 负载均衡+ failover
4. 动态路由
5. 动态分组
6. 服务限流(开发中)

如何使用：

服务提供方(provider)提供的服务接口定义，并将实现通过spring定义发布到注册中心(registry)

public interface HelloService {

    String hello(String name);

}

public class HelloServiceImpl implements HelloService {



    @Override

    public String hello(String name) {

        return "hello,"+ name;

    }



}



public class TestProvider {

    public static void main(String[] args) throws IOException {

        

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("server-context.xml");

        

        

        System.in.read();

        

        context.close();

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd">

    

    <import resource="classpath:jremoting-context.xml"/>

    

    <bean id="helloServiceProvider" class="com.github.jremoting.spring.JRemotingProviderBean" init-method="start">

        <constructor-arg name="interfaceName" value="com.github.jremoting.example.HelloService" />

        <constructor-arg name="version" value="1.0" />

        <constructor-arg name="target" ref="helloService" />

        <constructor-arg name="rpcServer" ref="rpcServer" />

    </bean>

    

    <bean id="helloService" class="com.github.jremoting.example.HelloServiceImpl"></bean>

</beans>

 

服务消费方(consumer)只依赖接口(HelloService)既可以通过rpc的方式调用远程provider的实现

/*consumer端自己定义异步版本接口*/

public interface AsyncHelloService {

    /**

     * 异步方法的签名规则是同步方法名加前缀 $, 返回结果为ListenableFuture

     */

    ListenableFuture<String> $hello(String name);

}



public class TestClient {

    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {

        

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("client-context.xml");

        

        HelloService helloService = context.getBean(HelloService.class);

        

        //同步调用

        String result = helloService.hello("jremoting");

        

        System.out.println(result);

        

        //异步调用

        AsyncHelloService asyncHelloService = (AsyncHelloService)helloService;

        

        ListenableFuture<String> future = asyncHelloService.$hello("jremoting async invoke!");

        

        System.out.println(future.get());

        

        

        //异步listener方式调用，注意operationComplete是在jremoting-context.xml中配置的专门executor上执行的。也可以自己指定executor

        future = asyncHelloService.$hello("jremoting async use future listener!");

        

        future.addListener(new FutureListener<String>() {

            

            @Override

            public void operationComplete(ListenableFuture<String> future) {

                if(future.isSuccess()) {

                    System.out.println(future.result());

                }

            }

        });

        

        

        //如果consumer端，不想依赖provider定义的接口，也可以直接调用远程方法，不过要把复杂对象都用map来代替，返回结果也一样

        RpcClient rpcClient = context.getBean(RpcClient.class);

        ServiceConsumer consumer = new ServiceConsumer("com.github.jremoting.example.HelloService", "1.0", rpcClient).start();

        

        Object obj = consumer.invoke("hello", new String[]{java.lang.String.class.getName()}, new Object[]{"generic invoke!"});

        

        System.out.println(obj);

        

        

        //关闭容器退出

        System.in.read();

        context.close();

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd">

    

    <import resource="classpath:jremoting-context.xml"/>

    

    <bean id="helloService" class="com.github.jremoting.spring.JRemotingConsumerBean" init-method="start">

        <constructor-arg name="interfaceName" value="com.github.jremoting.example.HelloService" />

        <constructor-arg name="version" value="1.0" />

        <constructor-arg name="rpcClient" ref="rpcClient" />

        <property name="asyncInterfaceName" value="com.github.jremoting.example.AsyncHelloService"></property>

    </bean>

</beans>

 

jremoting注册中心基于zookeeper实现的，测试hello world例子需要安装zookeeper. jremoting-context.xml中配置了jremoting运行 定义的bean对象 以及zookeeper连接地址,已经provider端连接的监听端口。另外还有jremoting的protocal,serializer,executor,invokefilter,registrywrapper等对象定义。用户可以自己定义每个组件的实现bean

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd">

    

    <!-- 定义serializer,默认提供json与hessian序列化 -->

    <bean id="jsonSerializer" class="com.github.jremoting.serializer.JsonSerializer" ></bean>

    <bean id="hessianSerializer" class="com.github.jremoting.serializer.HessianSerializer" ></bean>





    <!-- 定义服务注册中心,底层采用zookeeper来实现，服务的动态发现与配置的动态推送。除了CacheRegistryWrapper,与ZookeeperRegistry为必选，其他实现分组，路由，权重为可选 -->

    <bean id="registry" class="com.github.jremoting.route.RouteRegistryWrapper">

        <constructor-arg>

            <bean class="com.github.jremoting.group.GroupRegistryWrapper">

                <constructor-arg>

                    <bean class="com.github.jremoting.registry.CacheRegistryWrapper">

                        <constructor-arg>

                            <bean class="com.github.jremoting.registry.ZookeeperRegistry">

                                <constructor-arg name="zookeeperConnectionString" value="127.0.0.1:2181" />

                            </bean>

                        </constructor-arg>

                    </bean>

                </constructor-arg>

            </bean>

        </constructor-arg>

    </bean>





    <!-- 定义协议 ，并给协议关联序列化与注册中心-->

    <bean id="jremotingProtocal" class="com.github.jremoting.protocal.JRemotingProtocal">

        <constructor-arg name="registry" ref="registry" />

        <constructor-arg name="serializers">

            <array>

                <ref bean="jsonSerializer"/>

                <ref bean="hessianSerializer"/>

            </array>

        </constructor-arg>

    </bean>



    <!-- 定义io线程池 底层netty处理io事件与ChannelHandler的线程池 -->

    <bean id="eventExecutor" class="com.github.jremoting.transport.EventExecutor"></bean>

    

    <!-- 定义用户线程池，可用于consumer端的异步回调处理，或者provider端的服务方法处理-->

    <bean id="executor" class="com.github.jremoting.util.concurrent.Executors" factory-method="newExecutor">

        <constructor-arg name="corePoolSize" value="3"></constructor-arg>

        <constructor-arg name="maxPoolSize" value="20"></constructor-arg>

        <constructor-arg name="queueSize" value="20"></constructor-arg>

    </bean>



    <!-- 定义rpc client对象，用户定制consumer端需要的各种组件，包括协议，默认序列化方式，异步调用线程池，调用拦截器 -->

    <bean id="rpcClient" class="com.github.jremoting.transport.DefaultRpcClient">

        <constructor-arg name="protocal" ref="jremotingProtocal" />

        <constructor-arg name="defaultSerializer" ref="hessianSerializer" />

        <constructor-arg name="eventExecutor" ref="eventExecutor" />

        <constructor-arg name="asyncInvokeExecutor" ref="executor" />

        <constructor-arg name="invokeFilters">

            <list>

                <!-- 实现重试功能的拦截器 -->

                <bean class="com.github.jremoting.invoke.RetryInvokeFilter" />

                <!-- 实现软负载与failover的拦截器 , 负载方式为在可用provider间随机调用-->

                <bean class="com.github.jremoting.invoke.ClusterInvokeFilter" />

            </list>

        </constructor-arg>

    </bean>



    <!-- 定义rpc server对象，定制server端的各种组件，包括协议，执行provider方法的线程池，调用拦截器 -->

    <bean id="rpcServer" class="com.github.jremoting.transport.DefaultRpcServer">

        <constructor-arg name="eventExecutor" ref="eventExecutor" />

        <constructor-arg name="serviceExecutor" ref="executor" />

        <constructor-arg name="protocal" ref="jremotingProtocal" />

        <constructor-arg name="port" value="8687" />

        <constructor-arg name="invokeFilters">

            <list></list>

        </constructor-arg>

    </bean>

    

    <!-- 监听spring容器的关闭事件，同时关闭jremoting需要关闭的资源，包括监听,注册中心，线程池 -->

    <bean id="jremmotingLifeCycle" class="com.github.jremoting.spring.JRemotingLifeCycleBean">

        <property name="rpcClients">

            <list>

                <ref bean="rpcClient"/>

            </list>

        </property>

        <property name="rpcServers">

            <list>

                <ref bean="rpcServer"/>

            </list>

        </property>

    </bean>

    

</beans>