SpringBoot实例:医院统一信息平台(服务间通讯)

对于微服务项目，服务间的过程调用是不可缺少的业务。如接下去要建立的患者服务，与前面建立的用户服务就会存在通讯需求。如：向用户服务获取当前登录的用户的信息。恩，下面就实现下这个需求。在其它服务中向用户服务取信息。
实现这个需求的方案有很多，webservice、RPC、spring cloud feign等等，挺多的。这里，使用rabbitmq的RPC功能。选择它的原因有以下几点：

1. 在一套微服务系统中，消息服务也必不可少的一个中间件。后面会用到消息通知，如用户信息修改后发出消息。订阅的服务都知道这件事，然后作出业务相应的处理。就是说，消息中间件已经存在规划中。
2. 这是面向医院的信息平台，有些服务是部署在医院内部的，医院有可能不提供固定IP，如果需要向院内服务器请求数据。这就要内网穿透，或者其它媒介才能访问进入。rabbitmq也是媒介，它的RPC功能就不用内网穿透而向院内服务请求数据。
   主要是以上两点的考虑。
   安装rabbitmq就不在这里描述了。这里主要是使用。即创设已经有rabbitmq服务存在。
   如前面，创建一个项目huip-patient。后续患者信息会在这个服务中实现。现在简单的用来体验RPC。

用户服务中创建RPC服务端

pom中包含amqp

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

在配置文件中增加rabbitmq服务的信息，我是在本机安装了rabbitmq服务。

  rabbitmq:
    host: localhost
    port: 5672
    username: test
    password: test

在huip-user服务中增加amqp包。关于rabbitmq相关的业务都在这个包中进行。

amqp包
类

创建两个类。
RabbitmqConfig.java实现RPC服务的配置，代码如下：

package com.biboheart.huip.user.amqp;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfig {
    @Autowired
    private ConnectionFactory connectionFactory;

    // 这个名称的通道用于接收RPC的调用
    public final static String userRpcServiceExchangeName = "rpc.exchange.huip.user";
    public final static String userLoadRpcServiceQueueName = "rpc.queue.huip.user.load";
    
    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        return rabbitTemplate;
    }
    
    /**
     * RPC服务队列
     * @return
     */
    @Bean
    public Queue userLoadRpcServiceQueue() {
        return new Queue(userLoadRpcServiceQueueName, false);
    }
    
    /**
     * RPC服务通道
     * @return
     */
    @Bean
    public DirectExchange userRpcServiceExchange() {
        return new DirectExchange(userRpcServiceExchangeName);
    }
    
    /**
     * 队列绑定到通道
     * @param userLoadRpcServiceQueue RPC服务队列
     * @param userUserRpcServiceExchange RPC服务通道
     * @return
     */
    @Bean
    @Autowired
    public Binding userLoadRpcServiceQueueBindingUserRpcServiceExchange(Queue userLoadRpcServiceQueue, DirectExchange userRpcServiceExchange) {
        return BindingBuilder.bind(userLoadRpcServiceQueue).to(userRpcServiceExchange).with("load");
    }

}

创建RpcUserService接收RPC请求并返回结果，参数统一用Map接收。

package com.biboheart.huip.user.amqp;

import java.util.Map;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.biboheart.brick.utils.CheckUtils;
import com.biboheart.brick.utils.JsonUtils;
import com.biboheart.brick.utils.MapUtils;
import com.biboheart.huip.user.domain.User;
import com.biboheart.huip.user.service.UserService;

@Component
public class RpcUserService {
    @Autowired
    private UserService userService;

    @RabbitListener(queues = RabbitmqConfig.userLoadRpcServiceQueueName)
    public String load(Map<String, Object> params) {
        System.out.println("RPC 请求用户信息");
        Long id = MapUtils.getLongValue(params, "id");
        String account = MapUtils.getStringValue(params, "account");
        if (CheckUtils.isEmpty(id) && CheckUtils.isEmpty(account)) {
            return null;
        }
        User user = userService.load(id, account);
        return JsonUtils.obj2json(user);
    }
}

这里接收客户端请求用户信息，调用UserService取到数据，转换成JSON字符串返回。也可以把User序列化返回的。但是这样的话，客户端还要创建相同User类才能接收数据。这里把它转换成JSON，客户端转换成Map后解析数据。这样更加通用些。

客户端开发

创建huip-patient服务。

huip-patient

pom中也需要包含amqp

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

RabbitmqConfig只需要配置一个Bean

package com.biboheart.huip.patient.amqp;

import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfig {
    @Autowired
    private ConnectionFactory connectionFactory;
    
    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        return rabbitTemplate;
    }

}

RpcPatientUserClient实现RPC客户端。

package com.biboheart.huip.patient.amqp;

import java.util.HashMap;
import java.util.Map;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.biboheart.brick.utils.JsonUtils;

@Component
public class RpcPatientUserClient {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @SuppressWarnings("unchecked")
    public Map<String, Object> load(Long id, String account) {
        Map<String, Object> params = new HashMap<>();
        params.put("id", id);
        params.put("account", account);
        Object response = rabbitTemplate.convertSendAndReceive("rpc.exchange.huip.user", "load", params);
        if (null == response) {
            return null;
        }
        Map<String, Object> result = (Map<String, Object>) JsonUtils.json2obj(String.valueOf(response), HashMap.class);
        return result;
    }
}

注意：

1. params中的key、value是传给服务端的参数。要对应起来。

   
   参数

2. "rpc.exchange.huip.user", "load"这两个也要对应服务端的定义。这两个在服务器的配置文件中。

   
   通道与路由
   

   完成之后，在patient的controller中写个测试API。在之前的章节中讲到过，这是spring oauth2的一个资源服务。这里的API是需要token才能访问的，而且在这里可以知道当前登录用户的account。通过account取到当前登录用户的信息。
   可以如下这么写

    @Autowired
    private RpcPatientUserClient rpcPatientUserClient;
    
    @RequestMapping(value = "/loadUser", method = {RequestMethod.POST, RequestMethod.GET})
    @ResponseBody
    public Map<String, Object> loadUser() {
        String account = null;
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (null != authentication) {
            if (!(authentication instanceof AnonymousAuthenticationToken)) {
                account = authentication.getName();
            }
        }
        if (null == account) {
            return null;
        }
        Map<String, Object> user = rpcPatientUserClient.load(null, account);
        System.out.println(user);
        return user;
    }

先获取token，这是从用户服务中获取的。端口是8180

获取token

用这个token请求当前用户信息。从patient服务中获取。端口8280

用户信息
用GET
利用Rabbitmq实现RPC的功能就通了。这两个服务只要都能访问到同一Rabbitmq服务就可以了。比如，有一个服务运行在家里，有一个服务运行在医院中。都是可以访问到阿里云的Rabbitmq服务。这样虽然两个服务的环境都没有固定外网IP，但是可以相互调用数据。