SpringCloud——feign的工程化架构分析

架构

工程创建

1.创建父亲Maven项目

在pom中将spring boot做为父项目，配置整体项目的一些依赖

<parent>
    <artifactId>spring-boot-starter-parentartifactId>
    <groupId>org.springframework.bootgroupId>
    <version>2.3.12.RELEASEversion>
parent>
1
2
3
4
5

添加cloud版本依赖，lombok依赖

<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>org.dcitsgroupId>
    <artifactId>04-feign-projectartifactId>
    <version>1.0-SNAPSHOTversion>

    <parent>
        <artifactId>spring-boot-starter-parentartifactId>
        <groupId>org.springframework.bootgroupId>
        <version>2.3.12.RELEASEversion>
    parent>

    
    <properties>
        <java.version>1.8java.version>
        <spring-cloud.version>Hoxton.SR12spring-cloud.version>
    properties>
    
    <dependencies>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
    dependencies>

    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>${spring-cloud.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>

        dependencies>
    dependencyManagement>

    
    <build>

    build>
project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

2.创建doMain

创建一个maven模块，将父类指向04-feign-project
此时会发现父类的pom中多了内容

3.创建API

父项目指向04-feign-project

4.创建两个业务模块

同样指定父类

5.分析依赖关系

api需要依赖domain，在pom中添加依赖

<dependencies>
    <dependency>
        <groupId>org.dcitsgroupId>
        <artifactId>project-domainartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
dependencies>
1
2
3
4
5
6
7

order和user模块需要依赖api

<dependencies>
    <dependency>
        <groupId>org.dcitsgroupId>
        <artifactId>common-apiartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
dependencies>
1
2
3
4
5
6
7

6.创建包，创建实体类，添加模块所需依赖

注意包名要一致
创建Order类

package com.dcits.domain;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Order {
    private Integer orderId;
    private String name;
    private Double price;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

分析order需要依赖有web支持，需要eureka注册所以需要eureka依赖，项目要部署的话需要对order模块进行打包，所以需要打包插件

<dependencies>
    <dependency>
        <groupId>org.dcitsgroupId>
        <artifactId>common-apiartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

写一个启动类

package com.dcits;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
@SpringBootApplication
@EnableEurekaClient
public class OrderServiceApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApp.class,args);
    }
}
1
2
3
4
5
6
7
8
9
10
11

写一个接口

@RestController
public class OrderController {
    
}
1
2
3
4

这里需要调用feign，方法签名是提供者和使用者都需要的，所以可以将这个共同需要的放入到api模块中
在api中添加openFeign的依赖

<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-openfeignartifactId>
dependency>
1
2
3
4

创建Feign的接口

@FeignClient(value = "order-service")
public interface UserOrderFeign {
    //查询订单
    @GetMapping("/order/gerOrderByUserId")
    Order gerOrderByUserId(@RequestParam Integer userId);
}
1
2
3
4
5
6

这样只需要在order-service的controller中实现这个接口即可

package com.dcits.contorller;

import com.dcits.domain.Order;
import com.dcits.feign.UserOrderFeign;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController implements UserOrderFeign {

    @Override
    public Order gerOrderByUserId(Integer userId) {
        System.out.println(userId);
        Order order = Order.builder().name("红烧肉").price(20D).orderId(1).build();
        return order;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

接着修改yml文件

server:
  port: 8081
spring:
  application:
    name: order-service
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
ribbon:
  ReadTimeOut: 3000 # 给3s超时时间
  ConnectTimeout: 3000 # 连接服务超时时间
logging:
  level:
    com.dcits.userserver.feign.UserOrderFeign: debug # 需要打印这个接口下面的日志
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

同样给user-center模块加yml文件，修改下名和端口号

server:
  port: 8082
spring:
  application:
    name: user-service
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
ribbon:
  ReadTimeOut: 3000 # 给3s超时时间
  ConnectTimeout: 3000 # 连接服务超时时间
logging:
  level:
    com.dcits.userserver.feign.UserOrderFeign: debug # 需要打印这个接口下面的日志
feign:
  hystrix:
    enabled: true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

分析user-center模块需要web，eureka，hystrix

<dependencies>
    <dependency>
        <groupId>org.dcitsgroupId>
        <artifactId>common-apiartifactId>
        <version>1.0-SNAPSHOTversion>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
    dependency>
dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

写main方法

package com.dcits;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class UserServiceApp {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApp.class,args);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

写controller

package com.dcits.controller;

import com.dcits.domain.Order;
import com.dcits.feign.UserOrderFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Autowired
    public UserOrderFeign userOrderFeign;

    @GetMapping("find")
    public Order find(){
        return userOrderFeign.gerOrderByUserId(1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

熔断可以在user下写，也可以在api中，这里选择在api中

package com.dcits.feign.hystrix;

import com.dcits.domain.Order;
import com.dcits.feign.UserOrderFeign;
import org.springframework.stereotype.Component;

@Component
public class UserHyxtrix implements UserOrderFeign {
    @Override
    public Order gerOrderByUserId(Integer userId) {
        return null;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

将feign参数补全

@FeignClient(value = "order-service",fallback = UserHyxtrix.class)
1

测试：

测试熔断：