【redisson实现rpc】1.RRemoteService注册服务 2.客户端获通过接口去rpc调用远程服务器的实现

1)api层，只有接口声明

package com.example.api;

public interface IAPI1 {
    String api1(String name);
}

package com.example.api;

public interface IAPI2 {
    int api2(int num1, int num2);
}

package com.example.api;

import pojo.Student;

public interface IAPI3 {
    void api3(Student student);
}

package pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
}

2)gateway // 网关，负责调用微服务提供者的接口

package com.example.common.controller;


import com.example.api.IAPI1;
import com.example.api.IAPI2;
import com.example.api.IAPI3;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import pojo.Student;

@Slf4j
@RestController
@RequestMapping
public class APIController {

    @Autowired
    IAPI1 iapi1;

    @Autowired
    IAPI2 iapi2;

    @Autowired
    IAPI3 iapi3;

    private Student student = new Student("xx", 18);

    @RequestMapping("/api")
    public void api() {

        String xxx = iapi1.api1("xxx");
        log.info(xxx);

        int i = iapi2.api2(1, 2);
        log.info("num={}", i);

        iapi3.api3(student);
    }
}

package com.example.common.service;

import org.redisson.api.RRemoteService;
import org.redisson.api.RemoteInvocationOptions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class APIService {

    @Autowired
    RRemoteService rRemoteService;

    @Autowired
    RemoteInvocationOptions options;

    public <T> T getService(Class<T> t){
        return rRemoteService.get(t, options);
    }
}

package com.example.common;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CommonApplication {

    public static void main(String[] args) {
        SpringApplication.run(CommonApplication.class, args);
    }

}

3)微服务1

package com.example.service1.config;

import org.redisson.Redisson;
import org.redisson.api.RRemoteService;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Service1Config {

    @Bean
    public RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }

    @Bean
    public RRemoteService rRemoteService(RedissonClient redisson) {
        return redisson.getRemoteService();
    }
}

package com.example.service1.service;

import com.example.api.IAPI1;

public class API1 implements IAPI1 {
    @Override
    public String api1(String name) {
        return name;
    }
}

package com.example.service1;

import com.example.api.IAPI1;
import com.example.service1.service.API1;
import org.redisson.api.RRemoteService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@SpringBootApplication
public class Service1Application {
    /*** rpc业务请求处理线程池*/
    private static ExecutorService ioExecutor = Executors.newFixedThreadPool(20);

    private static RRemoteService rRemoteService;

    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Service1Application.class, args);

        rRemoteService = context.getBean(RRemoteService.class);

        // 允许同时处理1W个请求
        rRemoteService.register(IAPI1.class, new API1(), 10000, ioExecutor);
        rRemoteService.register(IAPI1.class, new API1(), 10000, ioExecutor);
    }
}

4)微服务2

package com.example.service2.config;
import org.redisson.Redisson;
import org.redisson.api.RRemoteService;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Service2Config {

    @Bean
    public RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }

    @Bean
    public RRemoteService rRemoteService(RedissonClient redisson) {
        return redisson.getRemoteService();
    }
}

package com.example.service2.service;

import com.example.api.IAPI2;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class API2 implements IAPI2 {
    @Override
    public int api2(int num1, int num2) {
        return num1 + num2;
    }
}

package com.example.service2.service;

import com.example.api.IAPI3;
import lombok.extern.slf4j.Slf4j;
import pojo.Student;

@Slf4j
public class API3 implements IAPI3 {
    @Override
    public void api3(Student student) {
        log.info("name={}", student.getName());
    }
}

package com.example.service2;

import com.example.api.IAPI2;
import com.example.api.IAPI3;
import com.example.service2.service.API2;
import com.example.service2.service.API3;
import org.redisson.api.RRemoteService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@SpringBootApplication
public class Service2Application {
    private static RRemoteService rRemoteService;

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(50);
        ApplicationContext context = SpringApplication.run(Service2Application.class, args);

        rRemoteService = context.getBean(RRemoteService.class);

        // 允许同时处理1W个请求
        // 在自己指定的线程池执行这个业务，而不是阻塞redisson所在的线程池
        rRemoteService.register(IAPI2.class, new API2(),10000, executorService);
        rRemoteService.register(IAPI3.class, new API3(),10000, executorService);
    }

}

思考：

用jmeter压测后发现，性能很低，吞吐量只有390/s左右。