基于docker部署的微服务架构（二）： 服务提供者和调用者

前言

前一篇 已经成功创建了一个服务注册中心，现在我们创建一个简单的微服务，让这个服务在服务注册中心注册。然后再创建一个调用者，调用此前创建的微服务。

创建微服务

新建一个maven工程，修改pom.xml引入 spring cloud 依赖:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.2.RELEASE</version></parent><dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency></dependencies><dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Camden.SR2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies></dependencyManagement>

在 resources 目录中创建 application.yml 配置文件，在配置文件内容:

spring:
  application:
    name: @project.artifactId@

server:
  port: 8100eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8000/eureka/

这里eureka的注册地址为上一篇中设置的defaultZone。
在 java 目录中创建一个包 demo ，在包中创建启动入口 AddServiceApplication.java

@EnableDiscoveryClient@SpringBootApplicationpublic class AddServiceApplication {    public static void main(String[] args) {
        SpringApplication.run(AddServiceApplication.class, args);
    }
}

在demo包下新建一个子包controller，在controller子包下创建一个controller对外提供接口。

@RestController
public class AddController {
    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public Map<String, Object> add(Integer a, Integer b) {
        System.out.println("端口为8100的实例被调用");        Map<String, Object> returnMap = new HashMap<>();
        returnMap.put("code", 200);
        returnMap.put("msg", "操作成功");
        returnMap.put("result", a + b);        return returnMap;
    }
}

在服务注册中心已经运行的情况下，运行 AddServiceApplication.java 中的 main 方法，启动微服务。
访问服务注册中心页面 http://localhost:8000， 可以看到已经成功注册了 ADD-SERVICE-DEMO 服务。

服务注册中心

启动第二个实例，修改端口为 8101 ，修改 AddController.java 中的输出信息为

System.out.println("端口为8101的实例被调用");

再次运行 AddServiceApplication.java 中的 main 方法。
访问服务注册中心页面 http://localhost:8000， 可以看到已经成功注册了两个 ADD-SERVICE-DEMO 服务，端口分别为 8100 和 8101。服务注册中心2

demo源码 spring-cloud-1.0/add-service-demo

ribbon方式调用服务

新建一个maven工程，修改pom.xml引入 spring cloud 依赖:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.2.RELEASE</version></parent><dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency></dependencies><dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Camden.SR2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies></dependencyManagement>

在 resources 目录中创建 application.yml 配置文件，在配置文件内容:

spring:
  application:
    name: @project.artifactId@

server:
  port: 8200eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8000/eureka/

在 java 目录中创建一个包 demo ，在包中创建启动入口 RibbonClientApplication.java

@EnableDiscoveryClient@SpringBootApplicationpublic class RibbonClientApplication {    public static void main(String[] args) {
        SpringApplication.run(RibbonClientApplication.class, args);
    }    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {        return new RestTemplate();
    }
}

这里配置了一个可以从服务注册中心读取服务列表，并且实现了负载均衡的 restTemplate。

在demo包下新建一个子包controller，在controller子包下创建一个controller对外提供接口。

@RestControllerpublic class RibbonController {    @Autowired
    RestTemplate restTemplate;    @RequestMapping(value = "/add", method = RequestMethod.GET)    public String add(Integer a, Integer b) {        return restTemplate.getForEntity("http://ADD-SERVICE-DEMO/add?a="+a+"&b=" + b, String.class).getBody();
    }
    
}

可以看到这里的请求url用了服务注册中心对应的 Application。

运行 RibbonClientApplication.java 中的 main 方法，启动项目。
在浏览器中访问 http://localhost:8200/add?a=1&b=2 ，得到返回结果：

{    msg: "操作成功",
    result: 3,
    code: 200}

多次访问，查看 AddServiceApplication 的控制台，可以看到两个 ADD-SERVICE-DEMO 被负载均衡的调用。
demo源码 spring-cloud-1.0/ribbon-client-demo

feign方式调用服务

新建一个maven工程，修改pom.xml引入 spring cloud 依赖:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.2.RELEASE</version></parent><dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-feign</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency></dependencies><dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Camden.SR2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies></dependencyManagement>

在 resources 目录中创建 application.yml 配置文件，在配置文件内容:

spring:
  application:
    name: @project.artifactId@

server:
  port: 8300eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8000/eureka/

在 java 目录中创建一个包 demo ，在包中创建启动入口 FeignClientApplication.java

@EnableDiscoveryClient@SpringBootApplication@EnableFeignClientspublic class FeignClientApplication {    public static void main(String[] args) {
        SpringApplication.run(FeignClientApplication.class, args);
    }

}

在demo包下新建一个子包service，在service子包下创建一个接口 AddService.java 调用之前创建的微服务 ADD-SERVICE-DEMO。

@FeignClient("ADD-SERVICE-DEMO")
public interface AddService {
    @RequestMapping(method = RequestMethod.GET, value = "/add")
    String add(@RequestParam(value = "a") Integer a, @RequestParam(value = "b") Integer b);
}

这里 @FeignClient 注解中的参数为服务注册中心对应的 Application。

在demo包下再新建一个子包controller，在controller子包下创建一个 FeignController.java 对外提供接口。

@RestControllerpublic class FeignController {    @Autowired
    private AddService addService;    @RequestMapping(value = "/add", method = RequestMethod.GET)    public String add(Integer a, Integer b) {        return addService.add(a, b);
    }

}

FeignController 里注入了刚才创建的 AddService 接口。

运行 FeignClientApplication.java 中的 main 方法，启动项目。
在浏览器中访问 http://localhost:8300/add?a=1&b=2 ，得到返回结果：

{    msg: "操作成功",
    result: 3,
    code: 200}

多次访问，查看 AddServiceApplication 的控制台，可以看到两个 ADD-SERVICE-DEMO 被负载均衡的调用。
demo源码 spring-cloud-1.0/feign-client-demo

使用docker-maven-plugin打包并生成docker镜像

以 add-service-demo 为例，
复制 application.yml，重命名为 application-docker.yml，修改 defaultZone为：

eureka:
  client:
    serviceUrl:
      defaultZone: http://service-registry:8000/eureka/

这里修改了 defaultZone 的访问url，如何修改取决于部署docker容器时的 --link 参数， --link 可以让两个容器之间互相通信。

修改 application.yml 中的 spring 节点为：

spring:
  application:
    name: @project.artifactId@
  profiles:
    active: @activatedProperties@

这里增加了 profiles 的配置，在maven打包时选择不同的profile，加载不同的配置文件。

在pom.xml文件中增加：

<properties>
    <java.version>1.8</java.version> <!-- 指定java版本 -->
    <!-- 镜像前缀，推送镜像到远程库时需要，这里配置了一个阿里云的私有库 -->
    <docker.image.prefix>
        registry.cn-hangzhou.aliyuncs.com/ztecs    </docker.image.prefix>
    <!-- docker镜像的tag -->
    <docker.tag>demo</docker.tag>

    <!-- 激活的profile -->
    <activatedProperties></activatedProperties></properties><profiles>
    <!-- docker环境 -->
    <profile>
        <id>docker</id>

        <properties>
            <activatedProperties>docker</activatedProperties>
            <docker.tag>docker-demo-${project.version}</docker.tag>
        </properties>
    </profile></profiles><build>
    <defaultGoal>install</defaultGoal>
    <finalName>${project.artifactId}</finalName>

    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>

    <plugins>
        <!-- 配置spring boot maven插件，把项目打包成可运行的jar包 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <executable>true</executable>
            </configuration>
        </plugin>

        <!-- 打包时跳过单元测试 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
                <skipTests>true</skipTests>
            </configuration>
        </plugin>

        <!-- 配置docker maven插件，绑定install生命周期，在运行maven install时生成docker镜像 -->
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>0.4.13</version>
            <executions>
                <execution>
                    <phase>install</phase>
                    <goals>
                        <goal>build</goal>
                        <goal>tag</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <!-- 修改这里的docker节点ip，需要打开docker节点的远程管理端口2375，
                具体如何配置可以参照之前的docker安装和配置的文章 -->
                <dockerHost>http://docker节点ip:2375</dockerHost>
                <imageName>${docker.image.prefix}/${project.build.finalName}</imageName>
                <baseImage>java</baseImage>
                <!-- 这里的entryPoint定义了容器启动时的运行命令，容器启动时运行
                java -jar 包名 , -Djava.security.egd这个配置解决tomcat8启动时，
因为需要收集环境噪声来生成安全随机数导致启动过慢的问题-->
                <entryPoint>
                    ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/${project.build.finalName}.jar"]                </entryPoint>
                <resources>
                    <resource>
                        <targetPath>/</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
                <image>${docker.image.prefix}/${project.build.finalName}</image>
                <newName>${docker.image.prefix}/${project.build.finalName}:${docker.tag}</newName>
                <forceTags>true</forceTags>
                <!-- 如果需要在生成镜像时推送到远程库，pushImage设为true -->
                <pushImage>false</pushImage>
            </configuration>
        </plugin>
    </plugins></build>

选择 docker profile，运行 mvn install -P docker ，打包项目并生成docker镜像，注意docker-maven-plugin中的 <entryPoint> 标签里的内容不能换行，否则在生成docker镜像的时候会报错。
运行成功后，登录docker节点，运行 docker images 应该可以看到刚才打包生成的镜像了。

启动docker容器并注册服务

在前一篇中，已经创建了一个 service-registry-demo 的docker镜像，这里先把这个镜像运行起来。

docker run -d --name service-registry-demo --publish 8000:8000 \
 --volume /etc/localtime:/etc/localtime \
 registry.cn-hangzhou.aliyuncs.com/ztecs/service-registry-demo:docker-demo-1.0

对这条命令做个简单说明， -d 指定当前容器运行在后台， --name 指定容器名称， --publish 指定端口映射到宿主机， --volume 这个挂载是为了解决容器内的时区和宿主机不一致的问题，让容器使用宿主机设置的时区，最后指定使用的docker镜像，镜像名称和标签需要根据自己的情况做修改。
运行这条命令之后，service-registry-demo 的容器就启动了。访问 http://宿主机IP:8000，打开注册中心的页面。
下边启动 add-service-demo 容器，

docker run -d --name add-service-demo --link service-registry-demo:service-registry --publish 8100:8100 \
 --volume /etc/localtime:/etc/localtime \
 registry.cn-hangzhou.aliyuncs.com/ztecs/add-service-demo:docker-demo-1.0

这条命令和上一条差不多，只是增加了一个 --link 参数，--link 指定容器间的连接，命令格式 --link 容器名:别名，这里连接了之前创建的名为 service-registry-demo 的容器，这里的别名和 application-docker.yml 文件中配置的 defaultZone 一致。其实就是通过别名找到了对应的容器IP，进到容器里查看 hosts 文件就明白了，其实就是加了条hosts映射。
add-service-demo 容器启动成功之后，刷新配置中心的页面，发现已经注册到配置中心了。

作者：月冷心寒
链接：https://www.jianshu.com/p/85a4dcdcd2b4