【SpringCloud】1.一文带你入门SpringCloud微服务
文章目录
-
- 1. 搭建父工程
- 2. 搭建注册中心
- 3. 搭建一个服务提供者
- 4. 搭建一个服务消费者
- 5. 整合OpenFeign实现服务之间的调用
1. 搭建父工程
最近打算使用 springcloud 搭建微服务玩一下，用到的东西大致有以下这些：
- jdk 1.8
- idea 2019
- maven 3.6.3
- springcloud 2021.0.3
- springboot 2.6.14
- mysql 8.0
- mybatis-plus 3.5.1
这里需要注意的是，springcloud 的版本和 springboot 的版本要能匹配，不然会出现问题，没法使用。由于我这里已经搭建好了开发环境，所以我们直接开始父工程的搭建。
第一步，非常简单，打开 idea ，新建一个 maven 项目，配置什么的一切默认，项目名字改为自己定义的就好，我这里直接把项目名字写为 springcloud ，这就是我们的父工程了。
第二步，将项目中的 src 这个包删除掉，仅保留 .idea 、pom.xml、springcloud.iml 这三个文件。
第三步，在 pom.xml 文件中，加入依赖，将我们需要的包导入进来，下面是整个 pom.xml 文件的内容。
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<groupId>com.yuhuofeigroupId>
<artifactId>springcloudartifactId>
<version>1.0-SNAPSHOTversion>
<modules>
<module>springcloud-eurekamodule>
<module>springcloud-service-providermodule>
<module>springcloud-service-consumermodule>
modules>
<packaging>pompackaging>
<properties>
<spring-boot.version>2.6.14spring-boot.version>
<spring-cloud.version>2021.0.3spring-cloud.version>
<java.version>1.8java.version>
<mybatis-plus-spring-boot.version>3.5.1mybatis-plus-spring-boot.version>
<mysql.version>8.0.11mysql.version>
<druid.version>1.2.11druid.version>
<lombok.version>1.18.22lombok.version>
<project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-dependenciesartifactId>
<version>${spring-cloud.version}version>
<type>pomtype>
<scope>importscope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-dependenciesartifactId>
<version>${spring-boot.version}version>
<type>pomtype>
<scope>importscope>
dependency>
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>${mybatis-plus-spring-boot.version}version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>${mysql.version}version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
<version>${druid.version}version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>${lombok.version}version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<version>${spring-boot.version}version>
<scope>testscope>
<exclusions>
<exclusion>
<groupId>org.junit.vintagegroupId>
<artifactId>junit-vintage-engineartifactId>
exclusion>
exclusions>
dependency>
dependencies>
dependencyManagement>
<build>
<finalName>${project.artifactId}finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.pluginsgroupId>
<artifactId>maven-compiler-pluginartifactId>
<configuration>
<source>${java.version}source>
<target>${java.version}target>
configuration>
plugin>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
<version>${spring-boot.version}version>
<configuration>
<fork>truefork>
<addResources>trueaddResources>
configuration>
plugin>
plugins>
build>
project>
至此，整个父工程的搭建工作大致就完成了，下图是我已经搭建完服务消费者的项目结构，供参考。
2. 搭建注册中心
注册中心，我这里采用 eureka ，其它可以作为注册中心的组件还有 zookeeper、consul、nacos 等。
在前面的父工程里面，新建一个 module ，类型选择 Maven，名字写为 springcloud-eureka ，其它配置一切默认直至完成，这就是我们注册中心所在的服务了。
第一步，在自己的 pom.xml 文件中，引入依赖，整个 pom.xml 文件的内容如下所示，由于这个 module 只是作为注册中心，所以引入 eureka 服务端的依赖就可以了，版本选择的是 3.1.3 ，需要和前面选择的 springcloud 版本相匹配。
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springcloudartifactId>
<groupId>com.yuhuofeigroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>springcloud-eurekaartifactId>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
<version>3.1.3version>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<build>
<finalName>springcloud-eurekafinalName>
build>
project>
第二步，新增一个启动类，我这里新建了一个 com.yuhuofei 的包，并将启动类 SpringCloudEurekaApplication.java 写在了这个包下，内容如下所示，注意需要加上注解 @EnableEurekaServer 以开启 eureka 服务端的使用。
package com.yuhuofei;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
* @Description
* @ClassName SpringCloudEurekaApplication
* @Author yuhuofei
* @Date 2023/5/22 18:56
* @Version 1.0
*/
@EnableEurekaServer
@SpringBootApplication
public class SpringCloudEurekaApplication {
public static void main(String[] args) {
SpringApplication.run(SpringCloudEurekaApplication.class, args);
}
}
第三步，增加配置文件，在 resource 目录下，新建一个 application.properties 文件，内容如下所示。
#服务启动端口
server.port=8000
#服务名称
spring.application.name=springcloud-eureka
#========下面是eureka配置========#
#eureka服务端实例名称
eureka.instance.hostname=eureka-server
#不向注册中心注册当前服务
eureka.client.register-with-eureka=false
#当前服务是注册中心所在服务，负责维护所有服务实例，不需要检查服务
eureka.client.fetch-registry=false
#注册中心地址，当其它微服务连接注册中心时，需要这个地址
eureka.client.service-url.defaultZone=http://localhost:8000/eureka/
到这里，注册中心的搭建，我们就完成了，整个 module 的结构如下图所示，非常简单，不复杂。
下面，我们启动一下启动类，并在浏览器访问 http://localhost:8000/ 看看结果，可以看到，一切如我们所料。
3. 搭建一个服务提供者
在父工程的基础上，新建一个 module ，类型选择 Maven，名字写为 springcloud-service-provider ，其它配置一切默认直至完成。
由于需要用到数据库，因此需要自己建立一个数据库以及数据库表，我这里随便建了一个 user 表，内容如下：
CREATE TABLE `user` (
`id` int(20) NOT NULL,
`name` varchar(30) COLLATE utf8_bin DEFAULT NULL,
`password` varchar(30) COLLATE utf8_bin DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin
在自身的 pom.xml 文件中，加入依赖，我这里的依赖信息如下：
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springcloudartifactId>
<groupId>com.yuhuofeigroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>springcloud-service-providerartifactId>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
<version>3.1.3version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<build>
<finalName>springcloud-service-providerfinalName>
build>
project>
新建一个包 com.yuhuofei，然后在这个包下新建一个启动类 SpringCloudServiceProviderApplication.java，内容如下所示，这里要注意开启 Eureka 客户端的支持。
package com.yuhuofei;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
* @Description
* @ClassName SpringCloudServiceProviderApplication
* @Author yuhuofei
* @Date 2023/5/22 18:56
* @Version 1.0
*/
@SpringBootApplication
@EnableEurekaClient
public class SpringCloudServiceProviderApplication {
public static void main(String[] args) {
SpringApplication.run(SpringCloudServiceProviderApplication.class, args);
}
}
后面就是依次新建 controller 、entity、mapper、service 相关的东西了，这里我直接贴出来各个类或者接口的内容。
- UserController.java
package com.yuhuofei.controller;
import com.yuhuofei.entity.User;
import com.yuhuofei.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* @Description
* @ClassName UserController
* @Author yuhuofei
* @Date 2023/5/22 19:56
* @Version 1.0
*/
@RestController
@RequestMapping("/provider/user")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/list")
public List<User> queryAllUser() {
return userService.queryUserList();
}
}
- User.java
package com.yuhuofei.entity;
import lombok.Data;
import java.io.Serializable;
/**
* @Description
* @ClassName User
* @Author yuhuofei
* @Date 2023/5/22 19:49
* @Version 1.0
*/
@Data
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private String passWord;
}
- UserMapper.java
package com.yuhuofei.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yuhuofei.entity.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @Description
* @InterfaceName UserMapper
* @Author yuhuofei
* @Date 2023/5/22 19:55
* @Version 1.0
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
List<User> queryUserList();
}
- userMapper.xml
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yuhuofei.mapper.UserMapper">
<resultMap id="userResultMap" type="com.yuhuofei.entity.User">
<result column="id" property="id"/>
<result column="name" property="name"/>
<result column="password" property="passWord"/>
resultMap>
<sql id="Base_Column_List">
id,name,password
sql>
<select id="queryUserList" resultType="com.yuhuofei.entity.User">
select id,name,password
from user
where id is not null;
select>
mapper>
- UserService.java
package com.yuhuofei.service;
import com.yuhuofei.entity.User;
import java.util.List;
/**
* @Description
* @InterfaceName UserService
* @Author yuhuofei
* @Date 2023/5/22 19:57
* @Version 1.0
*/
public interface UserService {
List<User> queryUserList();
}
- UserServiceImpl.java
package com.yuhuofei.service.impl;
import com.yuhuofei.entity.User;
import com.yuhuofei.mapper.UserMapper;
import com.yuhuofei.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @Description
* @ClassName UserServiceImpl
* @Author yuhuofei
* @Date 2023/5/22 19:58
* @Version 1.0
*/
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public List<User> queryUserList() {
return userMapper.queryUserList();
}
}
最后在 resource 目录下，新建一个 application.properties 文件，写入配置信息，内容如下：
#服务启动端口
server.port=8001
#服务名称
spring.application.name=springcloud-service-provider
#数据库连接配置
spring.datasource.username=root
spring.datasource.password=pan
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#MybatisPlus配置
mybatis-plus.type-aliases-package=com.yuhuofei.entity
mybatis-plus.mapper-locations=classpath:mapper/*.xml
mybatis-plus.configuration.map-underscore-to-camel-case=true
#========下面是eureka配置========#
#向注册中心注册当前服务
eureka.client.register-with-eureka=true
#当前服务需要获取注册中心已经存在的注册信息，所以需要检查服务
eureka.client.fetch-registry=true
#注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8000/eureka/
整个服务提供者的目录结构如下图所示，到这里服务提供者的搭建就完成了。
4. 搭建一个服务消费者
服务消费者的搭建，和前面服务提供者的搭建类似，我这里搭建一个名为 springcloud-service-consumer 的服务消费者，整个 module 的结构如下图所示。
由于这个服务里面没有用到数据库的东西，所以不用整合 MybatisPlus 以及 MySQL 相关的东西，下面是各个相关的文件信息。
- pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springcloudartifactId>
<groupId>com.yuhuofeigroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>springcloud-service-consumerartifactId>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
<version>3.1.3version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
dependencies>
<build>
<finalName>springcloud-service-consumerfinalName>
build>
project>
- SpringCloudServiceConsumerApplication.java
package com.yuhuofei;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
* @Description
* @ClassName SpringCloudServiceConsumerApplication
* @Author yuhuofei
* @Date 2023/5/22 18:59
* @Version 1.0
*/
@SpringBootApplication
@EnableEurekaClient
public class SpringCloudServiceConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(SpringCloudServiceConsumerApplication.class, args);
}
}
- application.properties
#服务启动端口
server.port=8002
#服务名称
spring.application.name=springcloud-service-consumer
#========下面是eureka配置========#
#向注册中心注册当前服务
eureka.client.register-with-eureka=true
#当前服务需要获取注册中心已经存在的注册信息，所以需要检查服务
eureka.client.fetch-registry=true
#注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8000/eureka/
- PersonInfo.java
package com.yuhuofei.entity;
import lombok.Data;
import java.io.Serializable;
/**
* @Description
* @ClassName PersonInfo
* @Author yuhuofei
* @Date 2023/5/23 18:54
* @Version 1.0
*/
@Data
public class PersonInfo implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private String passWord;
}
- RestTemplateConfig.java
这个类主要是提供一个 RestTemplate 的 bean 并交给 Spring 去托管
package com.yuhuofei.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
/**
* @Description
* @ClassName RestTemplateConfig
* @Author yuhuofei
* @Date 2023/5/23 18:45
* @Version 1.0
*/
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
- ConsumerController.java
这个类里面用到 RestTemplate 来实现 http 接口的调用，在当前这个服务消费者里面调用服务提供者的接口。
package com.yuhuofei.controller;
import com.yuhuofei.entity.PersonInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;
/**
* @Description
* @ClassName ConsumerController
* @Author yuhuofei
* @Date 2023/5/23 18:55
* @Version 1.0
*/
@RestController
@RequestMapping("/consumer/person")
public class ConsumerController {
public static final String PROVIDER_URL = "http://localhost:8001/";
@Autowired
private RestTemplate restTemplate;
@GetMapping("/list")
public List<PersonInfo> getPersonList() {
return restTemplate.getForObject(PROVIDER_URL + "provider/user/list", List.class);
}
}
到这里，我们就可以启动前面的服务提供者，然后再启动当前的服务消费者，接着在浏览器中访问 http://localhost:8002/consumer/person/list ，看看有没有数据出现，如果有，说明目前一切都是 OK 的。
至于目录中的 api 这个包，是后面整合 feign 客户端用的，这里暂时不用理会。
5. 整合OpenFeign实现服务之间的调用
前面我们已经实现了服务消费者调用服务提供者的接口，但是是通过 RestTemplate 这种方式来调用的，这是类似于单体服务的调用，并没有和我们说的微服务、注册中心等东西关联上，现在我们来改造一下，用 OpenFeign 实现微服务间的调用，与注册中心关联上。
在上面的服务消费者中，我们已经建了一个 api 的包，包里面后面要写一个接口 FeignServiceApi.java ，它的作用就是用来关联服务提供者的各个接口的。
下面我们在服务消费者 springcloud-service-consumer 的基础上，整合一下 OpenFeign 。
第一步，在 pom.xml 中引入下面的依赖
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-openfeignartifactId>
<version>3.0.2version>
dependency>
完整的 pom.xml 文件内容如下所示：
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springcloudartifactId>
<groupId>com.yuhuofeigroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>springcloud-service-consumerartifactId>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
<version>3.1.3version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-actuatorartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
<scope>runtimescope>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-openfeignartifactId>
<version>3.0.2version>
dependency>
dependencies>
<build>
<finalName>springcloud-service-consumerfinalName>
build>
project>
第二步，在启动类 SpringCloudServiceConsumerApplication.java 上，加上注解 @EnableFeignClients ，开启 feign 客户端支持。
package com.yuhuofei;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* @Description
* @ClassName SpringCloudServiceConsumerApplication
* @Author yuhuofei
* @Date 2023/5/22 18:59
* @Version 1.0
*/
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class SpringCloudServiceConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(SpringCloudServiceConsumerApplication.class, args);
}
}
第三步，在接口 FeignServiceApi.java 中，加上注解 @FeignClient ，并指定要调用的服务提供者名称为 springcloud-service-provider ，接着就是在里面写上要调用的接口信息，内容如下：
package com.yuhuofei.api;
import com.yuhuofei.entity.PersonInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import java.util.List;
/**
* @Description feign调用服务提供者的接口
* @InterfaceName FeignServiceApi
* @Author yuhuofei
* @Date 2023/5/23 19:26
* @Version 1.0
*/
@Service
@FeignClient("springcloud-service-provider")
public interface FeignServiceApi {
//调用服务提供者的接口
@GetMapping("/provider/user/list")
List<PersonInfo> queryAllUser();
}
第四步，为了和前面做出区分，我们在 ConsumerController.java 中，新增一个方法 getPersonListUseOpenFeign ，这个方法就通过 openfeign 来实现服务间的接口调用，为了更好地跟踪，我们加上日志打印。
package com.yuhuofei.controller;
import com.yuhuofei.api.FeignServiceApi;
import com.yuhuofei.entity.PersonInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;
/**
* @Description
* @ClassName ConsumerController
* @Author yuhuofei
* @Date 2023/5/23 18:55
* @Version 1.0
*/
@RestController
@RequestMapping("/consumer/person")
@Slf4j
public class ConsumerController {
public static final String PROVIDER_URL = "http://localhost:8001/";
@Autowired
private FeignServiceApi feignServiceApi;
@Autowired
private RestTemplate restTemplate;
@GetMapping("/list")
public List<PersonInfo> getPersonList() {
return restTemplate.getForObject(PROVIDER_URL + "provider/user/list", List.class);
}
@GetMapping("/list-by-openfeign")
public List<PersonInfo> getPersonListUseOpenFeign() {
log.info("通过openfeign调用");
List<PersonInfo> list = feignServiceApi.queryAllUser();
log.info("得到的列表：{}",list);
return list;
}
}
到这里，就改造完了，下面需要测试一下，验证我们的改造结果。首先把注册中心 springcloud-eureka 启动起来，接着再启动服务提供者 springcloud-service-provider ，最后再启动 springcloud-service-consumer。
都启动之后，在浏览器中访问 http://localhost:8000/ ，可以看到两个服务都注册到注册中心了。
接着，我们在浏览器新的标签页访问 http://localhost:8002/consumer/person/list-by-openfeign ，可以看到，有结果返回，同时日志也正常打印出来，这说明整合 OpenFeign 是没问题的。
通过这种方式调用服务提供者的接口，我们不再需要配置服务提供者的域名或者 IP ，只需要指定它在注册中心的服务名称便可，这样就实现了前面提到的微服务间的调用与注册中心关联上的目的。
入门篇暂时到这里结束，后面还有服务的熔断及降级、增加网关、增加配置中心等等，留待后面的博客再介绍。