# demo-cloud

**Repository Path**: zhang_jun_fa/demo-cloud

## Basic Information

- **Project Name**: demo-cloud
- **Description**: 学习SpringCloud-Eureka服务注册，使用Feign消费服务;
后续添加了从git获取配置文件，SpringCloud-Config的配置中心学习
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-06-16
- **Last Updated**: 2023-01-11

## Categories & Tags

**Categories**: Uncategorized

**Tags**: SpringCloud, Eureka, feign, 多模块, SpringCloud-Config

## README

# Spring-cloud 学习- Eureka 
Spring Cloud将Netflix Eureka 拿进来整合了一下，方便Spring Cloud采用Netflix Eureka来做服务注册中心，方便使用；
也就是说 Spring Cloud对 Netflix Eureka做了二次封装。

Eureka 
Eureka 采用了 C-S（客户端/服务端）的设计架构，也就是 Eureka 由两个组件组成：Eureka服务端和Eureka客户端。
Eureka Server（一个独立的项目）用于注册服务 以及 实现服务的 负载均衡 和 故障转移，它是 服务的 注册中心，
如果我们要将自己的服务注册到Eureka服务上去的话，就要让我们的服务作为Eureka的客户端，而且我们的服务本质上也是一个Springboot的单体项目。

Eureka Client（我们的微服务）它是用于与 Eureka Server交互(我们的服务即Eureka Client客户端与Eureka Server服务端进行交互)，获取其上注册的服务(不需要去记住接口地址)，使得交互变得非常简单，只需要通过 服务标识 即可拿到服务(其实就是从Eureka Server上获取拿到接口地址，也不需要自己去记住接口地址，即代码层当中的GOODS_SERVICE_URL就不再需要了)。


Spring Cloud中的Eureka 服务注册中心, 实际上也是一个 Spring Boot 工程，

# 工程架构
```
 demo-cloud  ———————————————————————————————— 父项目
 ├── eureka-server ----------------------------Eureka的服务端  6091
 ├── eureka-admin -----------------------------Eureka的客户端 8763
 ├── eureka-job -------------------------------Eureka的客户端 8764
 ├── eureka-config ----------------------------Eureka的客户端,也是Config配置中心  8762
 ├── eureka-gateway ----------------------------Eureka网关配置   8765
```



# 项目说明
## eureka-server-Eureka的服务端
要作为服务端，其实也很简单，因为Springcloud已经给我们封装好了。
* 我们先在Eureka引入maven
```xml
<!--Spring Cloud 的 eureka-server 起步依赖-->
 <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
 </dependency>
```
* 在Eureka-server项目的启动入口类上添加注解
```java
/**
 * @author zhangjunfa
 */
@SpringBootApplication
@EnableEurekaServer   //注册为Eureka的服务端
public class EurekaServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }

}
```
* 配置yml文件
```yaml
# 服务端口
server:
  port: 6091
  enable-self-preservation: false                                 
# 应用名称
spring:
  application:
    name: eureka-server
# Eureka配置
eureka:
  instance:
    #设置该服务注册中心的 hostname
    hostname: 127.0.0.1
  client:
    registerWithEureka: false   #注册使用Eureka，设为FALSE，防止自己注册自己
    fetchRegistry: false  #设置为false，表示禁止这种 自己向自己注册的默认行为
    serviceUrl:
      #      defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:${server.port}/eureka/
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
```
上面的配置完成后。就可以简单的测试了。
![这个是我的测试结果](https://img-blog.csdnimg.cn/a8f222cc4da94a99be993be03397711f.png#pic_center)

## eureka-admin-Eureka的客户端
eureka的客户端和服务端差不多一样的配置,
* 我们先引入maven
```xml
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
```
* 然后在Eureka-admin的启动入口做注解
```java
@SpringBootApplication
@EnableEurekaClient   //注解为Eureka的客户端
public class EurekaJobApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaJobApplication.class, args);
    }

}
```
* 配置yml文件
```yaml
server:
  port: 8762
#服务的名称
spring:
  application:
    name: eureka-job

#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://127.0.0.1:6091/eureka/
  instance:
    prefer-ip-address: true
```
客户端配置和上面一样，
接下了就可以测试一下啦
![注册服务后的测试结果](https://img-blog.csdnimg.cn/369b7afa32c549d19b2b2dc814c5e45f.png#pic_center)

## Eureka服务消费 - Feign
SpringCloud有两种服务调用方式，一种是ribbon+restTemplate，另外一种是feign
Feign是一个声明式的伪客户端，它使得写Http客户端变得更简单，使用Feign，只需要创建一个接口并注解。
* 首先我们在eureka-admin中创建一个测试接口
```java
@RestController
@RequestMapping
public class TestController {
    @GetMapping("/testAdmin")
    public String test() {
        return "我是Eureka服务的消费者，我的名字是eureka-admin";
    }
}
```
* 其次我们在eureka-job中消费eureka-admin中的testAdmin接口，我们要在eureka-job中先定义接口
```java
@FeignClient(value = "eureka-admin")
public interface FeignService {
    /**
     * 测试消费Eureka-admin服务中的接口
     *
     * @return java.lang.String
     * @author rosszhang
     * @date 2022/6/16 11:27
     */
    @GetMapping("/testAdmin")
    public String testAdmin();
}
```
* 然后我们就可以在eureka-job中使用FeignService
```java
@RequestMapping
@RestController
public class TestController {
    
    //注意此处可能会有一个报错。无法发现feignService这个服务，
    /*Consider defining a bean of type 'com.example.eurekajob.feign.FeignService' in your configuration.*/
    @Autowired
    private FeignService feignService;

    @GetMapping("/findOne")
    public HashMap fineOne() {
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("name", "陈");
        map.put("age", "18");
        map.put("address", "天字一号");
        return map;
    }

    @GetMapping("/testConsumerService")
    public String testConsumerService(){
        return feignService.testAdmin();
    }
}
```
这个错误是因为：
我们要在启动入口添加两个注解：我原先的代码中只添加了一个@EnableEurekaClient，所以会报错。我们只需要添加@EnableFeignClients这个注解就可以解决
```java
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class EurekaJobApplication {

    public static void main(String[] args) {
        SpringApplication.run(EurekaJobApplication.class, args);
    }

}
```
然后我们就可以测试一下了。在eureka-job中请求一下
![在这里插入图片描述](https://img-blog.csdnimg.cn/c5aa3199ddea4fd5a520070ef6917122.png)

## SpringCloud-config 统一管理配置文件
我们先测试eureka-job服务
 1. 引入Maven
 ```xml
    <!--引入统一配置中心-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-config-server</artifactId>
    </dependency>
```
 2. 在启动入口添加注解 @EnableConfigServer
 ```java
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
@EnableConfigServer
public class EurekaJobApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaJobApplication.class, args);
    }
}
```
 3. 我们需要在gitte中建立一个仓库，私有的，公共的都可以
 如果是私有的就需要加入用户名和密码
 此处需要在eureka-job的yml文件中配置一下
 ```yaml
#springcloud-config配置----开始
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/zhang_jun_fa/spring-cloud-config.git
          username: 你的用户名
          password: 你的密码
#springcloud-config配置----结束
```
 具体建立仓库的方法，大家自行百度，
 ![我的gitte配置](https://img-blog.csdnimg.cn/f5d4e5cdaaca4aec9dbc68d8c53816f9.png)
 这个仓库中只有一个.md和eureka-job.properties文件.
 eureka-job.properties中我们只加入两个值
 ```properties
name=rosszhang
age=30
```
然后我们可以测试一下
![测试结果](https://img-blog.csdnimg.cn/98c42d620ebe446dbf569961f47db94d.png)

## SpringCloud-gateway 网关说明
1. 网关常见的作用
其常见的作用有：
* 鉴权校验：验证是否认证和授权
* 统一入口：提供所有微服务的入口点，起到隔离作用，保障服务的安全性
* 限流熔断
* 路由转发
* 负载均衡
* 链路追踪
2. 目前常用的网关
* SpringCloud Gateway
* Zuul
3. 添加pom依赖
```xml
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- json -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>
```
4. 跨域请求处理
```java
@Configuration
public class CorsConfig {
    //处理跨域
    @Bean
    public CorsWebFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedMethod("*");
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}
```
5. 过滤器
```java
package com.example.eurekagateway.filter;

import com.alibaba.fastjson.JSONObject;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
/**
 * @author zhang
 * @date 2022/9/20
 */
@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println("执行了自定义的全局过滤器");
        //1.获取请求参数access-token
        String token = exchange.getRequest().getQueryParams().getFirst("access-token");
        //2.判断是否存在
        if(token == null) {
            //3.如果不存在 : 认证失败
            System.out.println("没有登录");
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete(); //请求结束
        }
        //4.如果存在,继续执行
                return chain.filter(exchange); //继续向下执行
    }

    @Override
    public int getOrder() {
        return 0;
    }

}


```

# 延伸阅读
大家可以看看这位大佬的文章：[Fengshana](https://blog.csdn.net/qq_43409111/article/details/117061595)