SpringCloud入门案例(Eureak,Ribbon,Feign)-使用教程

最新推荐文章于 2022-05-15 11:45:02 发布

程序逸

最新推荐文章于 2022-05-15 11:45:02 发布

阅读量168

点赞数 1

分类专栏： SpringBoot 文章标签： springcloud

本文链接：https://blog.csdn.net/qq_43265564/article/details/115672556

版权

SpringBoot 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Dubbo的简单项目服务发布(入门超详细)
对于微服务框架来说，我们一般使用阿里的Dubbo框架或者使用SpringCloud实现远程服务调用。接下来我们来学习一下SpringCloud框架实现远程调用。

1.SpringCloud介绍

SpringCloud是一系列框架集合，不是单纯的一个框架，里面包含了很多Spring官方觉得很好而且经得起考验的开源框架。并且，SpringCloud是基于SpringBoot的，原生的SSM项目是不能直接使用SpringCloud的。
可以使用SpringCloud干些什么：服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等。

名称
服务发现（Eureka）
断路器（Hystrix）
智能路由（Zuul）
户端负载均衡（Ribbon）

Spring Cloud&SpringBoot什么关系？

Spring Cloud是分布式系统的整体解决方案，底层用的SpringBoot来构建项目；SpringCloud新增很多的分布式的starter，以及这些starter的自动配置；

SpringCloud的官网：官网

2.实现远程服务注册和调用

2.1父工程和注册中心模块的实现

第一步：创建父工程SpringCloud_helloworld
第二步：增加依赖：

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

    <groupId>com.offcn</groupId>
    <artifactId>SpringCloud-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>eureka-server</module>
        <module>provider-movie</module>
        <module>consumer-user</module>
        <module>consumer-user-feign</module>
    </modules>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <packaging>pom</packaging>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

第三步：创建子工程，做为注册中心，项目名称eureka-server
第四步：注册中心中添加依赖：

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

    <!--注册中心eurekad-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

第五步：在eureka-server的resources目录下创建application.yml配置文件：

spring:
  application:
    name: eureka-server #注册中心的名称
server:
  port: 8761  #端口号
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false #此EurekaServer不在注册到其他的注册中心（自己本身就是一个注册中心）
    fetch-registry: false #不在从其他中心中心拉取服务器信息（服务注册中心现在只有一个）
    service-url:
          defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka

第六步：在java文件下创建启动类：

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerStart {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerStart.class);
    }
}

到这一步，就可以启动主函数，然后启动服务，去浏览器输入地址：http://localhost:8761，会出现注册中心的页面：

2.2服务模块发布到注册中心的实现

注册中心已经实现，现在我们实现一个电影服务，原来返回当前最新的电影票
第一步：创建子工程，名为：provider-movie
第二步：导入依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

第三步：项目结构
这里实体类代码如下（代码精简了，get,set方法等自行添加哈）：

//pojo中的Movie类
public class Movie implements Serializable {
    private Integer id;
    private String movieName;
}
//dao中的
@Repository
public class MovieDao {

    public Movie getNewMovie(){
        return new Movie(1,"送你一朵小红花");
    }
}

//控制器层代码
@RestController
@RequestMapping("/service")
public class MovieController {
    @Autowired
    MovieService movieService;


    @GetMapping("/movie")
    public Movie getNewMovie(){
        return movieService.getNewMovie();
    }
}
//service层
@Service
public class MovieService {

    @Value("${server.port}")
    private String port;

    @Autowired
    MovieDao movieDao;

    public Movie getNewMovie(){

        System.out.println("当前电影服务的端口："+port);
       return movieDao.getNewMovie();
    }

}

#application.yml中的配置
spring:
  application:
    name: Provider-Movie
server:
  port: 8001
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true #注册服务使用IP的方式

在启动类上加入注解：

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

2.3运行两个项目，查看是否发布到注册中心上去了
在这里插入图片描述
可以发现，服务已经启动

2.4创建用户服务，实现用户远程调用电影服务，实现查询最新电影票，当你实现到这步时，可以有两个选择，一个是使用Ribbon实现远程调用，或者使用Feign,接下来我们分别学习。

【Ribbon】实现远程调用的方法

首先创建子工程consumer-user工程，依赖和项目结构如下：

<?xml version="1.0" encoding="UTF-8"?>
<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>SpringCloud-helloworld</artifactId>
        <groupId>com.offcn</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>consumer-user</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!-- 引入ribbon实现远程调用和负载均衡功能 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <!-- 引入hystrix进行服务熔断 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
    </dependencies>

</project>

在这里插入图片描述

这里我们实现最普通的控制器，dao,pojo层和service层：

public class Movie implements Serializable {
    private Integer id;
    private String movieName;
}

public class User implements Serializable {
    private Integer id;
    private String userName;
}

@Repository
public class UserDao {

    public User getUser(Integer id){
        User user = new User();
        user.setId(id);
        user.setUserName("程序逸");
        return user;
    }
}


@RestController
public class UserController {

    @Autowired
    UserService userService;


    @GetMapping("/user")
    public User getUser(@RequestParam("id") Integer id){
        User user = userService.getUser(id);
        return user;
    }

    @GetMapping("/buyMovie")
    public Map buyMovie(@RequestParam("id") Integer id){
        Map newMovie = userService.getNewMovie(id);
        return newMovie;
    }
}

@Service
public class UserService {

    @Autowired
    UserDao userDao;

    @Autowired
    RestTemplate restTemplate;

    /**
     * 根据id得到用户
     * @param id
     * @return
     */
    public User getUser(Integer id){
        User user = userDao.getUser(id);
        return user;
    }

    /**
     * 购买最新电影票
     * @param id
     * @return
     */
    
    public Map getNewMovie(Integer id){
            Map map=new HashMap();
        User user = userDao.getUser(id);
        map.put("user",user);

        Movie movie = restTemplate.getForObject("http://PROVIDER-MOVIE/service/movie", Movie.class);
        //TODO 暂时为null
        map.put("movie", movie);
        return map;
    }

   
                
  

}

application.yml配置文件中代码如下：

spring:
  application:
    name: Consumer-User
server:
  port: 9000
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

主运行函数如下：

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

此时，最重要的就是config包下的MyConfig类：

@Configuration
public class MyConfig {

    @Bean
    @LoadBalanced //使用该注解实现负载均衡，默认采用轮询
    public RestTemplate restTemplate(){
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate;
    }
}

此时我们就可以直接自动注入RestTemplate类调用getForObject方法，该方法有两个参数，一个是远程调用的服务url,一个是该服务返回的参数类型的class对象。
总结一波：

步骤	内容
1	对于需要远程调用服务的项目，首先导入ribbon的依赖
2	配置application.yml文件
3	创建配置类，类上使用@Configuration注解，定义一个 restTemplate方法，返回为RestTemplate值类型,该方法上使用@Bean和@LoadBalanced注解
4	在service层中自动装配RestTemplate类，使用其方法getForObject来调用远程服务
5	在启动主方法中增加注解@EnableDiscoveryClient

【Feign】实现远程调用的方法

使用Feign更加规范，因为我们使用Ribbon是使用一个类的方法调用，传入url来实现的，Feign是使用接口来实现的。

我们新建一个子工程，叫consumer-user-feign,注意，这里这个子工程和上面的consumer-uer的dao,pojo,controller层代码一样，可以直接复制，不一样的就是service层代码。
第一步，导入依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

第二步，配置application.yml配置文件：

spring:
  application:
    name: ConsumerUserFeign
server:
  port: 7000
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

第三步：在service包下新建一个feign包，定义一个接口MovieServiceFeign:

@FeignClient(value = "PROVIDER-MOVIE") //调用的服务名称
public interface MovieServiceFeign {

    @GetMapping("/service/movie")
    public Movie getNewMovie();  //与被调用服务端映射方法一致

}

第四步：直接去service层代码中自动装配MovieServiceFeign接口，然后直接调用getNewMovie方法就可以实现远程服务调用。
总结：

我们可以不难发现，Feign实现远程调用的方法就是通过注解将调用的服务的接口映射到一个和返回值相同的方法上去，然后我们来调用。

程序逸

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringCloud入门案例(Eureak,Ribbon,Feign)-使用教程

Dubbo的简单项目服务发布(入门超详细)对于微服务框架来说，我们一般使用阿里的Dubbo框架或者使用SpringCloud实现远程服务调用。接下来我们来学习一下SpringCloud框架实现远程调用。1.SpringCloud介绍SpringCloud是一系列框架集合，不是单纯的一个框架，里面包含了很多Spring官方觉得很好而且经得起考验的开源框架。并且，SpringCloud是基于SpringBoot的，原生的SSM项目是不能直接使用SpringCloud的。可以使用SpringClou.
复制链接

扫一扫

专栏目录