RedKale

##

RedKale 入门 Convert 组件 Service 组件 Source 组件 Net 组件 Watch 组件 Javadoc API Github 源码

### Service 组件介绍

Service 是RedKale最核心的组件，依赖于Convert、SNCP协议、Resource依赖注入。Service主要处理业务逻辑和操作数据层，是微服务架构中的单一原子服务。每一个Service实例分两种模式: 本地模式和远程模式。其模式由 conf/application.xml 文件来配置。使用者在调用过程中通常不需要区分当前Service实例是哪种模式。
为了能确保本地模式与远程模式自由切换，对Service的实现类有一定的约束:
1、Service实现类会被继承，不能修饰为 final
2、带@MultiRun注解的方法会被重载，不能修饰为 final
RedKale进程启动时扫描可加载的Service实现类，根据配置文件配置的模式采用JDK 8内置的ASM技术动态生成相应的Service临时类进行实例化，并注册到ResourceFactory同其他Service、Servlet依赖注入。

### Service 本地模式

以一个简单的UserService类范例来说明动态生成的两种模式临时类。UserService提供查询用户、注册、登陆、修改用户名功能:

    public class UserService implements Service {

        //用户简单信息缓存
        private final Map<Integer, UserInfo> users = new ConcurrentHashMap<>();

        //存放手机号码与userid的对应关系
        private final Map<Long, Integer> mobileToUserids = new ConcurrentHashMap<>();

        public final String testLocalNodeName() {
            return "本地节点名";
        }

        //查询用户信息
        public UserInfo findUserInfo(int userid) {
            return users.get(userid);
        }

        //根据手机号码查询用户ID，没有返回0
        public int findUserid(long mobile) {
            Integer rs = mobileToUserids.get(mobile);
            return rs == null ? 0 : rs;
        }

        //缓存用户信息
        public void putUserInfo(UserInfo user) {
            users.put(user.getUserid(), user);
            if (user.getMobile() > 0) mobileToUserids.put(user.getMobile(), user.getUserid());
        }

        //登录
        public RetResult<UserInfo> login(LoginBean bean) {
            // 登陆逻辑
            return new RetResult<>(100);
        }

        //注册
        @MultiRun
        public void register(UserInfo user) {
            this.users.put(user.getUserid(), user);
        }

        //更新用户名
        @MultiRun(diffrun = false)
        public UserInfo updateUsername(int userid, String username) {
            UserInfo user = this.users.get(userid);
            if (user != null) user.setUsername(username);
            return user;
        }
    }

动态生成的本地模式UserService：

    @Resource(name = "")
    @SncpDyn(remote = false)
    @ResourceType({UserService.class})
    public final class _DynLocalUserService extends UserService {

        @Resource
        private BsonConvert _convert;

        private Transport _sameGroupTransport;

        private Transport[] _diffGroupTransports;

        private SncpClient _client;

        private String _selfstring;

        @Override
        public String toString() {
            return _selfstring == null ? super.toString() : _selfstring;
        }

        @Override
        public void register(UserInfo user) {
            this._register(true, true, true, user);
        }

        @SncpDyn(remote = false, index = 0)
        public void _register(boolean selfrunnable, boolean samerunnable, boolean diffrunnable, UserInfo user) {
            if (selfrunnable) super.register(user);
            if (_client == null) return;
            if (samerunnable) _client.remoteSameGroup(_convert, _sameGroupTransport, 0, true, false, false, user);
            if (diffrunnable) _client.remoteDiffGroup(_convert, _diffGroupTransports, 0, true, true, false, user);
        }

        @Override
        public UserInfo updateUsername(int userid, String username) {
            return this._updateUsername(true, true, false, userid, username);
        }

        @SncpDyn(remote = false, index = 1)
        public UserInfo _updateUsername(boolean selfrunnable, boolean samerunnable, boolean diffrunnable, int userid, String username) {
            UserInfo rs = super.updateUsername(userid, username);
            if (_client == null) return null;
            if (samerunnable) _client.remoteSameGroup(_convert, _sameGroupTransport, 1, true, false, false, userid, username);
            if (diffrunnable) _client.remoteDiffGroup(_convert, _diffGroupTransports, 1, true, true, false, userid, username);
            return rs;
        }
    }

由以上等价的代码可以看出来，本地模式Service会重载被@MultiRun注解的方法。@MultiRun有以下几个参数:

    public @interface MultiRun {

        boolean selfrun() default true; //当前本地实例是否运行指定操作；只有当指定操作的方法的返回值为void时，该值才能为true，否则忽略。

        boolean samerun() default true;  //是否同组节点运行指定操作

        boolean diffrun() default true; //是否不同组节点运行指定操作

        boolean async() default true; //分布式运行是否采用异步模式
    }

在动态生成的远程模式UserService时会根据不同参数生成相应的方法。若一个Service类没有含@MultiRun注解的方法，那么动态类只会重载toString方法。当UserService服务仅需要部署一个进程，由于没有其他等同服务的进程因此在UserService实例化时_client会赋值为null。

    <resources>
        <group name="GROUP-A">
            <node addr="192.168.10.111" port="7070"/>
            <node addr="192.168.10.112" port="7070"/>
            <node addr="192.168.10.113" port="7070"/>
        </group>
        <group name="GROUP-B">
            <node addr="192.168.20.121" port="7070"/>
            <node addr="192.168.20.122" port="7070"/>
        </group>
        <group name="GROUP-C">
            <node addr="192.168.30.131" port="7070"/>
            <node addr="192.168.30.132" port="7070"/>
        </group>
    </resources>

    <!-- 配置UserService的节点组  --->
    <service name="" value="org.redkale.demo.user.UserService" groups="GROUP-A;GROUP-B;GROUP-C"/>

如上配置，若当前进程所在IP是192.168.10.111，则UserService采用本地模式加载。执行register方法时， 先本地执行超类的register，然后远程执行同组的进程(192.168.10.112、192.168.10.113)，最后远程执行异组的进程(192.168.20.121、192.168.20.122、192.168.30.131、192.168.30.132)。若当前进程所在IP是192.168.10.100，则UserService采用远程模式加载。需要注意的一点是，每个IP所在的服务必须开通SNCP协议服务以便能接收远程的调用请求。

### Service 远程模式

动态生成的远程模式UserService：

    @Resource(name = "")
    @SncpDyn(remote = true)
    @ResourceType({UserService.class})
    public final class _DynRemoteUserService extends UserService {

        @Resource
        private BsonConvert _convert;

        private Transport _transport;

        private SncpClient _client;

        private String _selfstring;

        @Override
        public String toString() {
            return _selfstring == null ? super.toString() : _selfstring;
        }

        @SncpDyn(remote = false, index = 0)
        public void _register(boolean selfrunnable, boolean samerunnable, boolean diffrunnable, UserInfo user) {
            _client.remote(_convert, _transport, 0, selfrunnable, samerunnable, diffrunnable, user);
        }

        @SncpDyn(remote = false, index = 1)
        public UserInfo _updateUsername(boolean selfrunnable, boolean samerunnable, boolean diffrunnable, int userid, String username) {
            return _client.remote(_convert, _transport, 1, selfrunnable, samerunnable, diffrunnable, userid, username);
        }

        @Override
        public UserInfo findUserInfo(int userid) {
            return _client.remote(_convert, _transport, 2, userid);
        }

        @Override
        public int findUserid(long mobile) {
            return _client.remote(_convert, _transport, 3, mobile);
        }

        @Override
        public RetResult<UserInfo> login(LoginBean bean) {
            return _client.remote(_convert, _transport, 4, bean);
        }

        @Override
        public void putUserInfo(UserInfo user) {
            _client.remote(_convert, _transport, 5, user);
        }

        @Override
        public void register(UserInfo user) {
            _client.remote(_convert, _transport, 6, user);
        }

        @Override
        public UserInfo updateUsername(int userid, String username) {
            return _client.remote(_convert, _transport, 7, userid, username);
        }
    }

由以上代码可以看出来，远程模式Service是根据本地模式Service临时类动态生成的。远程类执行方法时通过SNCP协议将参数序列化并带上当前方法信息传输到远程服务器上，执行完后将结果流反序列化并返回, 其流程与WebService类似。

远程模式的@DynCall回调

与WebService的区别除了更具性能的二进制的数据格式，更差异的是远程模式的Service允许修改参数本身的内容。范例如下：

    /**
     * 由于该方法在处理过程中修改了参数bean的内容，为了保证本地模式与远程模式的一致性，需要提供@DynCall回调接口
     *
     * @param bean
     * @return
     */
    public RetResult<UserInfo> login(@DynCall(DynCallLoginBeanAttribute.class) LoginBean bean) {
        bean.setLogintime(System.currentTimeMillis());
        bean.setSessionid("SID" + System.currentTimeMillis());
        // 登陆逻辑
        return new RetResult<>(100);
    }

    /**  DynCallLoginBeanAttribute 的实现  **/
    public class DynCallLoginBeanAttribute implements Attribute<LoginBean, Object[]> {

        @Override
        public Object[] get(LoginBean obj) {
            return new Object[]{obj.getLogintime(), obj.getSessionid()};
        }

        @Override
        public void set(LoginBean obj, Object[] value) {
            obj.setLogintime((Long) value[0]);
            obj.setSessionid((String) value[1]);
        }

        @Override
        public Class<? extends Object[]> type() {
            return Object[].class; //
        }

        @Override
        public Class<LoginBean> declaringClass() {
            return LoginBean.class; //
        }

        @Override
        public String field() {
            return ""; //可以随意值
        }
    }

生成远程模式Service时发现参数带有@DynCall注解的方法，在远程调用返回结果时会进行回调处理。

### Service 异步调用

远程模式不仅对@DynCall注解进行处理，而且对方法含有 java.nio.channels.CompletionHandler 的参数也进行异步特殊处理。异步调用对远程模式非常有意义，可以减少同步方式对当前线程的占用时间。也给Source组件的异步调用提供了基础。

        @Override
        public <T> void update(final CompletionHandler<Void, T[]> handler, @DynAttachment final T... values) {
            source.update(values);
            if (handler != null) handler.completed(null, values);
        }

如上图DataSourceService的源码，当DataSource为本地实例时，异步接口(含CompletionHandler参数的)与同步接口执行流程相同。当DataSource为远程模式时，调用异步接口时，通信接口发到远程服务器时CompletionHandler参数的值传null，返回数据后再调用本地的CompletionHandler参数值执行。
异步调用方式是提高服务并发性的有效手段，特别是在远程模式Service比较多的情况下效果更明显。以HTTP服务为例，在Tomcat刚刚改版成NIO的时候，网上随处可见都是大谈NIO性能比BIO多好，认为BIO与NIO的不同，是BIO往往会引入多线程，每个连接一个单独的线程；NIO则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。而事实上呢，通常还是通过增加线程数来提高并发量。为什么NIO作用不大呢， 因为一个HTTP动态请求耗时最多的业务逻辑层，IO操作的耗时比重小得多，只有在静态资源请求这种纯IO操作才能体现NIO、AIO(NIO.2)的优势。举例一个很简单的数据查询请求，采用BIO方式耗时（为了方便比较将所耗时间扩大几倍）如下:
1、服务器TCP连接开始到进入HttpServlet，耗时 10ms
2、用户态判断和参数验证， 耗时 10ms
3、调用远程数据源(DataSource)查询数据，耗时 150ms
4、数据序列化与response的IO输出， 耗时 10ms
如上描述，一个请求处理耗时 180ms，同时占用一个线程的时间也是 180ms。若换成NIO使IO耗时减少，为了方便计算假设IO耗时为0(当然实际情况是不可能的), 那么步骤1、4的耗时忽略不计，线程的占用时间由180ms变成160ms。 假设数据查询接口IO操作本身耗时也是10ms，那么有140ms是用于等待。若采用DataSource异步接口， 则140ms的等待时间可以释放当前线程资源。虽然整个请求的处理时间还是180ms，但是线程的占用时间却只有20ms。可以看出减少耗时多的步骤的等待时间才能事半功倍，大幅度地提高性能。异步接口的主要作用是远程请求在等待过程中释放当前线程资源。大大减少线程数，也减少大量线程之间的切换消耗。