SpringCloud基础知识点，案例实现。

最新推荐文章于 2022-07-07 17:03:17 发布

怎麼還沒睡a

最新推荐文章于 2022-07-07 17:03:17 发布

阅读量273

点赞数

分类专栏： Springcloud 微服务 Eureka

本文链接：https://blog.csdn.net/An_air/article/details/104817693

版权

微服务同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

Eureka

1 篇文章 0 订阅

订阅专栏

Springcloud

0 篇文章 0 订阅

订阅专栏

SpringCloud

远程方法调用

RPC：dubbo和微服务，都是分布式的，分布式最少是两台电脑以上，然后，电脑之间相互协作需要完成通讯。dubbo是基于RPC的。RPC意思就是A服务器可以调用B服务器的服务，两者保持数据传输格式相同。
http：网络传输协议，客户端和服务端采用Http协议。SpringCloud基于HTTP协议。浏览器访问网站。
两种方式比较

速度：RPC比HTTP更快，虽然底层都是TCP，但是http协议的而信息旺旺比较臃肿，不过可以采用gzip压缩。
难度：RPC实现比较复杂，http相对比较简单。
灵活：http更胜一筹，因为它不关心实现细节，跨平台、跨语言。
如果对效率要求比较高，并且开发过程中使用统一的技术栈，那么RPC还是不错的。例如：dubbo
如果需要更加灵活，跨语言、跨平台，http更适合。例如：SpringCloudHttpClientApache公司产品，是Http Components下的一个组件。用于模仿浏览器发出http请求。

HTTPClient案例实现：

第一步：引入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
</parent>
 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.6</version>
    </dependency>
</dependencies>

第二步，创建启动类

@SpringBootApplication
public class HttpDemoApplication {
    @Bean
    public RestTemplate getTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(HttpDemoApplication.class,args);
    }
}

第三步，测试类

public class HttpTests {
    CloseableHttpClient httpClient;
    @Before
    public void init(){
        httpClient = HttpClients.createDefault();
    }
    @Test
    public void testGet() throws IOException{
        HttpGet request = new HttpGet("www.baidu.com");
        String response = this.httpClient.execute(request,new BasicResponseHandler());
        System.out.println(response);
    }
    @Test
    public void testPost() throws IOException{
        HttpGet request = new HttpGet("www.oschina.net");
        request.set("user-Agent","Mozilla/5.0");
        String response = this.httpClient.execute(request,new BasicResponseHandler());
        System.out.println(response);
    }
}

SpringCloud

现阶段最流行的框架，SpringCloud封装NetFlix。微服务是一种架构方式，最终肯定需要技术架构去实施。微服务的实现方式有很多，但是最火莫过于SpringCloud，为什么？

1.后台硬：作为Spring家族的一员，有整个Spring全家桶靠山，背景十分强大。
2.技术强：Spring作为Java领域的前辈，可以说是功力深厚，有强力的技术团队支撑，一般人还真比不了
3.群众基础好：可以说大多数程序员的成长都伴随着Spring框架，试问：现在有几家公司开发不用Spring？SpringCloud与Spring的各个框架无缝整合，对大家来说一切都是熟悉的配方，熟悉的味道。
4.使用方便：相信大家都体会到了SpringBoot给我们开发带来的便利，而SoringCloud完全支持SpringBoot的开发，用很少的配置就能完成微服务框架的搭建。
SpringCloud最擅长的就是集成，把世界上最好的框架拿过来，集成到自己项目中。SpringCloud也是一样，他将现在非常流行的一些技术整合到一起，实现了注入：配置管理，服务发现，智能路由，负载均衡，熔断路，控制总线，集群状态等功能，其主要涉及的组件包括：
netflix:
·Eureka：注册中心
·Zuul：服务网关
·Ribbon：负载均衡
·Feign：服务调用
·Hystix：熔断器

Eureka：服务注册中心，可以是一个集群，对外暴露自己的地址
提供者：启动后想Eureka注册自己信息（地址，提供什么服务）
消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
心跳：提供者挺起通过http方式向Eureka刷新自己的状态

案例实现

1.创建父项目

添加依赖，父项目作为一个数据仓库，子项目需要时从此处拿取。父项目不具备这个jar包，只是作为一个仓库。

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.RC1</spring-cloud.version>
        <mybatis.starter.version>1.3.2</mybatis.starter.version>
        <mapper.starter.version>2.0.2</mapper.starter.version>
        <druid.starter.version>1.1.9</druid.starter.version>
        <mysql.version>8.0.18</mysql.version>
        <lombok.version>1.16.10</lombok.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--Spring Cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-build-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--Mybatis启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.starter.version}</version>
            </dependency>
            <!--通用Mapper启动器，简单SQL封装-->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
            <!--MySQL驱动类-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <!--SpringBoot与Maven的一个插件-->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <!--仓库，这个项目优先从下面地址下载，如果没有就找Settings设置-->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

2.User_Service子项目客户端

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>2.0.2</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.10</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

然后创建启动类、application.yml，Controller，Service，Mapper，pojo。

1.启动类核心：@SpringBootApplication  @MapperScan("com.aa.mapper")
2.Controller：@RestController    @RequestMapping @PathVariable
3.Service：@Service
4.Mapper：extends Mapper(User)
5.pojo:实体类，@Table(name = "user_table") @Data @Id @GeneratedValue(strategy=..IDENTITY)
Controller注入Service,Service注入Mapper，Mapper返回数据,pojo存放实体对象。

application.yml

server:
  port: 8089
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8
    username: root
    password: root
mybatis:
  type-aliases-package: com.aa.pojo

3.Consumer_Service子项目

添加依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>

启动类创建

@SpringBootApplication
public class ConsumerApplication {
    @Bean
    public RestTemplate getTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

//User类，接收对象
@Data
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private Date birthday;
}

//Controller类
@RestController
@RequestMapping("/consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/{id}")
    public User getUser(@PathVariable("id") Long id){
       User user = restTemplate.getForObject("http://localhost:8089/wa/user/"+id,User.class);
        return user;
    }
}

4.Eureka_Service子项目

Eureka负责管理、记录服务提供的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka。然后Eureka会把符合你需求的服务告诉你。同时，服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务出现问题，Eureka自然会把它从服务列表中剔除。流程：User向Eureka注册服务，然后Consumer定期从Eureka拉取服务，建立与User之间的连接，User与Consumer然后开始通讯，完成功能。
添加依赖

<dependency>
    <!--添加Eureka服务端-->
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    <version>2.0.2.RELEASE</version>
</dependency>

启动类

@SpringBootApplication
@EnableEurekaServer         //关键注解
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class,args);
    }
}

添加配置application.yml

eureka:
  client:
    serviceUrl: #EurekaServer地址
      defaultZone: http://127.0.0.1:10086/eureka/   #注册中心
    register-with-eureka: false #是否注册自己信息到Eureka，默认True
    fetch-registry: false   #是否拉取其他服务信息，默认为True
  server:
    enable-replicated-request-compression: false    #关闭自我保护模式，默认True
    eviction-interval-timer-in-ms: 1000 #扫描失效服务的时间，默认为60*1000ms

server:
  port: 10086   #IP访问端口
spring:
  application:
    name: eureka_server #设置
#service-url应该写成serviceUrl，可能存在格式问题。遵循驼峰式命名规则

此时三个服务器基本搭建完毕，需要完成服务器之间的通讯。首先是User注册到Eureka

5.User注册到Eurekauser

将自己的信息注册到Eureka，Eureka记录user的访问地址、端口号等其他信息。
添加依赖

<dependency>
    <!--添加Eureka客户端依赖-->
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    <version>2.1.2.RELEASE</version>
</dependency>

添加配置，配置Application名称，服务拉取将根据name查找。以及Eureka配置。

spring:
  application:
    name: user_service
eureka:
  client:
    serviceUrl:
      defaultZone: http://127.0.0.1:10086/eureka    #去这个地址进行注册
    registry-fetch-interval-seconds: 5      #5s间隔拉取服务列表
  instance:
    prefer-ip-address: true #当调用getHostname获取实例的hostname时，返回ip而不是host名称
    ip-address: 127.0.0.1   #指定自己的ip信息，不指定会自己寻找

启动类添加注解：@EnableDiscoveryClient

6.Consumer注册到Eureka

添加依赖，启动类添加注解，添加yml配置。因为都是Eureka的客户端，配置基本一致,如上重复一次。需要修改端口以及applicationName。
此时首先启动eureka，再启动consumer和user，进入eureka端口号可以查看客户端的注册信息。
修改Controller
ip地址通过服务访问进行获取，而不是直接指定(写死了)

@GetMapping("/{id}")
public User getUser(@PathVariable("id") Integer id){
    //获取UserService客户端
    List<ServiceInstance> instances = discoveryClient.getInstances("user_service");
    //取第一个，更多的任务将被分配到第一个user_service
    ServiceInstance serviceInstance = instances.get(0);
    //通过动态服务端口访问数据
    String url = "HTTP://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+"/wa/user/"+id;
    System.out.println(url);
    User user = restTemplate.getForObject(url,User.class);
    return user;
}

7.高可用Eureka配置高可用模式

只有一台服务器时，如果出现故障，损失将无法挽回；而配置多台服务器，他们相互注册，当一台宕机后，另一台顶上继续提供服务。这就是高可用模式。
修改application.yml配置，删除注册、拉取为false的配置。
端口为10086，注册地址为：http://127.0.0.1:10087/eureka。
启动然后复制一份启动类，操作如下：右上角锤子图标右边三角图标下拉→Edit Configurations→左上角第一个图标+→然后点击第三个图标复制→修改名称Application2→OK→修改端口为10087，注册为10086。
启动User与Consumer配置中添加新的注册地址http://127.0.0.1:10087/eureka。向两台注册。当其中一台服务直接关闭时，依旧能提供服务。模拟完毕。

8.服务提供者

服务注册
服务提供者在启动时，会检查配置属性中的：eureka.client.register-with-eureka=true是否正确，默认为true。如果为true，则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息，EurekaServer会把这戏信息保存在一个双层的Map结构中，第一层Map的key就是服务名称，第二层Map的key是服务的实例id。服务续约在注册服务完以后，服务提供者会维持一个心跳(定时向EurekaServer发起Rest请求)告诉它：我还活着。这个我们称为服务的续约。有两个重要参数可以修改服务续约的行为。

eureka:
  instance:
    lease-expiration-duration-in-seconds: 90	#服务失效时间，默认90秒
    lease-renewal-interval-in-seconds: 30		#服务续约间隔，默认30秒

也就是说每隔30秒向服务注册中心，发起一次Rest请求，如果超过90s没有发送心跳，Eureka会人为该服务宕机，从服务列表移除。开发阶段可以适当调小，生产环境默认就好。
服务注册信息
在status一列中，显示如下信息

up(1):代表现在是启动了一个实例，没有集群
DESKTOP-OLLRSUH:user_service:8089：是实例的名称(instance-id)
	默认格式:${hostname}+${spring.application.name}+${server.port}
	instance-id是区分同一服务的不同实例的唯一标准，因此不能重复

修改instance-id的结构

eureka:
	instance:
		instance-id: ${spring.application.name}:${server.port}

失效剔除保护
失效剔除：有时候，我们服务提供方不一定会正常下线，可能因为内存溢出、网络故障等原因到时服务无法正常工作。Eureka需要将这样的服务剔除出服务列表。因此它会开启一个定时任务，每隔60s对所有失效的服务(超过90s未响应)进行剔除。可以通过eureka.server.eviction-interval-timer-in-ms参数对其进行修改，单位是毫秒，生产环境不要修改。而在开发环境，你重启一个服务，60秒后eureka才反应过来，极不方便，可改为10s。
自我保护: 关停一个服务时，在eureka面板会看到一条红色警告(EMERGENCY!..)这就是出发了eureka的自我保护机制。当一个服务未按时进行心跳续约时，eureka会统计最近15分钟心跳失败的服务实例的比例是否超过了85%。在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下很有效，保证了多数服务依然可用。但开发环境很麻烦，因此开发环境下关闭自我保护。

9.负载均衡Robbin

在以上的代码实例中，我们使用ServiceInstance serviceInstance = instances.get(0);获取第一个user_service服务，然后分配任务，在空闲时，任务往往总被分配到第一个服务器，这就造成对此节点的使用频率太高，而其他节点就很闲。而负载均衡就是为了解决这一问题。在刚在的案例中，我们启动了一个user_Service，然后启动了DiscoveryClient来获取服务实例信息，然后获取ip和端口来访问。但是实际环境中，我们往往会开启很多个user-service的集群。此时我们获取的服务列表就会有多个，到底该访问哪一个？一般这种情况下我们就需要编写负载均衡算法，在多个实例列表中进行选择。不过Eureka中已经帮我们继承了负载均衡组件：Ribbon，简单修改代码即可使用。
什么是Ribbon：Ribbon是Netflix发布的负载均衡器，它有助于控制HTTP和TCP客户端的行为。为Ribbon配置服务提供地址列表后，Ribbon就可基于某种负载均衡算法，自动的帮助服务消费者去请求，Ribbon默认为我们提供了很多的负载均衡算法，例如轮询、随机等。当然，我们也可为Ribbon实现自定义的负载均衡算法。

案例实现

添加依赖：

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

Consumer启动类添加注解

@SpringBootApplication
@EnableDiscoveryClient
public class ConsumerApplication {
    @Bean
    @LoadBalanced	//负载均衡启动
    public RestTemplate getTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}
//Controller修改    
@GetMapping("/{id}")
    public User getUser(@PathVariable("id") Integer id){
        //不用再指定哪个进行服务，负载均衡自动帮忙选取
        String url = "HTTP://user-service/wa/user/"+id;
        System.out.println(url);
        User user = restTemplate.getForObject(url,User.class);
        return user;
    }

复制一个User_service启动，后台打印url观察url访问的地址。负载均衡就是将工作任务分摊到多个节点，避免一个节点很闲一个节点很忙的情况。
PS:启用负载均衡时，Application-name中不能包含下划线，否则无法被解析。如：user_service应该改成user-service。

Hystrix

熔断器，相当于生活中的保险丝。他是一个容错管理工具，作用时通过隔离、控制服务从而对延时和故障童工更强大的容错能力，避免整个系统被托跨。复杂分布式架构通常都具有很多依赖，当一个应用高度耦合其他服务时非常危险且容易导致失败，这种失败很同意伤害服务的调用者，最后导致一个接一个的连续错误，应用本身就处在被拖垮的风险中，最后失去控制，就像一个在高流量的网站中，某个单一的后端一旦发生延迟，将会在数秒内导致所有应用资源被耗尽。如何处理这些问题是有关系系统性能和效率的关键性问题在分布式系统中，服务调用方可以自己进行判断某些服务反应慢或者存在大量超时的情况时，能够主动熔断，防止整个系统被拖垮。hystrix可以实现弹性容错，当情况好转时，可以自动重连。
Consumer导入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.0.2.RELESAE</version>
</dependency>

启动类添加注解

@EnableCircuitBreaker	//开启熔断器
@EnableCircuitBreaker+@EnableDiscoveryClient+@SpringBootApplication=@SpringCloudApplication

//在方法上添加熔断功能注解
@GetMapping("/{id}")
@HystrixCommand(fallbackMethod = "queryBack")
public User getUser(@PathVariable("id") Integer id){
    String url = "http://user-Service/wa/user/"+id;
    System.out.println(url);
    User user = restTemplate.getForObject(url,User.class);
    return user;
}
//参数以及返回类型保持一。
public User queryBack(Integer id){
    User user = new User();
    return user;
}

//Hystrix第二种使用，对这个端口所有方法都加上熔断器。
//Controller添加注解 @DefaultProperties(defaultFallback="defaultFallback")
@RestController
@RequestMapping("/consumer")
@DefaultProperties(defaultFallback = "queryBack")	//默认熔断调用方法
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    
    @GetMapping("/{id}")
    @HystrixCommand
    public String getUser(@PathVariable("id") Integer id){
        String url = "http://user-Service/wa/user/"+id;
        System.out.println(url);
        String user = restTemplate.getForObject(url,String.class);
        return user;
    }
	//返回类型保持一致，参数去除。
    public String queryBack(){
        return "sass";
    }
}

Hystrix第三种使用，设置超时时间

#application.yml	添加配置
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000

Feign

在我们的consumer端，控制层的代码包含地址等，没有service、dao的概念，为了让代码更加美观并具有一定的结构，feign的作用就是让代码更加美观。
引入依赖

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

启动类添加注解@EnableFeignClients //开启Feign功能RestTemplate可以删除，Feign中已经集成了Ribbon负载均衡等，因此我们不需要自己定义RestTemplate。去掉Hystrix、RestTemplate。
创建一个包com.wa.client
定义一个接口UserClient Interface，只定义不实现

//UserClient.Interface
@FeignClient("user-service")
public interface UserClient{
    @GetMapping("user/{id}")
    public String getUser(@PathVariable("id") Integer id);
}
//首先是FeignClient注解，它是用来解析服务端口的。然后将解析到的端口和请求地址拼接，并自动发送请求。

//controller注入UserClient
@AutoWrite
private UserClient userClient;
public User getUser(@PathVariable("id") Integer id){
    userClient.getUser(id);
    return user;
}
//使用Feign之后就舍弃了RestTemplate。且Feign集成了Hystrix和Ribbon配置

Ribbon

#application.yml
ribbon:
	ConnectionTimeOut: 500	#连接时间
	ReadTimeOut: 2000		#超时时长，consumer响应user超过两秒，则超时。
配置hystrix#application.yml
feign: 
	hystrix: 
		enabled: true		#开启熔断器

创建一个类，实现UserClient接口，创建UserFallback.java

//UserFallback.java
@Component
public class UserFallback implements UserClient{
    @Override
    public User getUser(Integer id){
        User user = new User()
        return user;
    }
}
//然后在UserClient上的FeignClient注解上，添加属性fallback,设置为UserFallback.class
@FeignClient(value="user-service",fallback=UserFallback.class)

Zull

网关，可以简单的理解为过滤器，我们在后台编写的方法，不应该是都可以被调用，而应该是有权限的能调用，当我们需要保护一个地址时，先进行身份验证，然后对发送过来的请求进行过滤，然后跳转到别处执行。Zuul的核心是一系列的过滤器，这些过滤器可以完成以下功能：身份认证与安全：识别每个资源的验证要求，并拒绝那些要求不符的请求。

审查与监控：从边缘位置追踪有意义的数据和统计结果，从而带来精确的生产视图。
动态路由：动态地将请求路由到不同的后端集群。
压力测试：逐渐增加指向集群的流量，以了解性能。
负载分配：为每一种负载类型分配对应容量，并弃用超出限定值的请求。
静态响应处理：在边缘位置直接建立部分响应，从而避免其转发到内部集群。
多区域弹射：跨越AWSRegion进行请求路由，旨在实现ELB使用的多样化，以及让系统的边缘更贴近系统的使用者。

新建工程Zuul-Service

添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    <version>2.1.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>2.1.2.RELEASE</version>
</dependency>

创建启动类

//zuulApplication.java
@SpringBootApplication
@EnableZuulProxy
public class ZuulApplication{
    public static void main (String[] args){
        SpringApplication.run(ZuulApplication.class,args);
    }
}

配置文件

#application.yml
server:
	port: 6666
spring:
	application:
		name: zuul-server
#第一种
zuul:
	routes:
		haha:		#路由id，随便写
			path: /user-service/**	#映射路径
			url: http://localhost:8089	#映射路径对应的实际url地址
#输入user-service时，转发到http://localhost:8089
#http://localhost:6666/user-service/wa/user/1   映射到如下
#http://localhost:8089/wa/user/1

因为url写死了，所以需要引入eureka-client，做负载均衡。变成动态访问user-service
添加依赖

<!--application.yml-->
<dependency>
    <!--添加Eureka客户端依赖-->
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    <version>2.1.2.RELEASE</version>
</dependency>

添加注解

//ZuulApplication.java
@EnableDiscoveryClient

添加配置

#application.yml
eureka:
  client:
    serviceUrl:
      defaultZone: http://127.0.0.1:10086/eureka	#去这个地址进行注册
    registry-fetch-interval-seconds: 5		#5s间隔拉取服务列表
  instance:
    prefer-ip-address: true	#当调用getHostname获取实例的hostname时，返回ip而不是host名称
    ip-address: 127.0.0.1	#指定自己的ip信息，不指定会自己寻找
#第二种
zuul:
	routes:
		haha:		#路由id，随便写
			path: /user-service/**	#映射路径
			url: user-service	#映射路径对应的实际url地址
#第三种
zuul:
	routes:
	user-service: /user-service/**	#按服务名称定义，会被自动动解析。
#默认情况下，一切服务的映射路径就是服务本身。例如：user-service,则默认的映射路径就是/user-service/**
#也就是，不用配置Zuul，默认也是可以完成映射的。
#不配置，然后http://consumer-service/comsumer/1 有返回数据

隐藏服务
将服务隐藏起来，使得无法通过服务名访问。
http://consumer-service/comsumer/1 无法返回数据。

 zuul:
	ignored-services:
		- consumer-servic

路由前缀
我们认为去访问http://localhost:6666/user-service/wa/user/1比较麻烦，能不能直接访问http://localhost:6666/wa/user/1就能得到结果。
yml配置

#application.yml
zuul:
	prefix: /api		#加前缀
	routes:
	 user-service: 
	 	path: /wa/**
	 	serviceId: user-service
	 	strip-prefix: false		#不截取前缀/wa
#这里指定了serviceId。所以我们在访问/wa下的网址时，/wa不会被截取解析，识别配置中的serviceId分配地址。
#不加前缀http://localhost:6666/wa/user/1 得到数据
#加前缀 http://localhost:6666/api/wa/user/1 得到数据

ZullFilter

ZullFilter是过滤器的顶级父类。在这里我们看一下其中定义的4个最重要的方法：定义一个ZullUser，继承ZullFilter

//ZullUser.java
@Component
public class ZullUser extends ZullFilter{
    @Override
    public String filterType(){
        //请求到微服务之前进行过滤
        return FilterConstants.PRE_TYPE;
    }    
    @Override
    public int filterOrder(){
        //请求头之前，查看请求参数
        return FilterConstants.PRE_DECORATION_FILTER_ORDER-1;
    }    
    @Override
    public boolean shouldFilter(){
        //需要过滤
        return true;
    }    
    @Override
    public Object run() throws ZuulException{
        //获取请求上下文
        RequestContext ctx = RequestContext.getCurrentContext();
        //获取Requset
        HttpServletRequest request = ctx.getRequest();
        String token = request.getParameter("access-token");
        if(StringUtils.isBlank(token)){
            ctx.setSendZuulResponse(false);	//是否被允许通过
            ctx.setReSponseStatusCode(403);	//返回响应码
        }
        return null;
    }
}
//一个网址向服务器发送请求时，

负载均衡和熔断
zuul中默认集成了负载均衡和熔断，但是所有的超时策略都是走的默认值，比如熔断超时时间只有1s，很容易就触发，所以需要手动设置。

#application.yml
hystrix:
	command:
		default:
			execution:
				isolation:
					thread:
						timeoutInMillisecond: 6000	#熔断时长6000ms
ribbon:
	ConnectionTimeOut: 500	#连接时间
	ReadTimeOut: 4000		#超时时长，通信延迟超过4秒，则超时。
	MaxAutoRetriesNextServer: 2	#同一服务不同实例的重试次数

ES6语法指南

VSCodeUser一个国际性的前台页面绘制工具，国内主要使用Hbuilder。
操作VSCodeUser：第一步，安装一个中文插件，左边工具栏，打开商店，搜索Chinese和open in brow安装、重启。创建一个html文件，!+Tap 补全html骨架。

<body>
    <script>
        for(var i=0;i<5;i++){
            console.log(i)
        }
        console.log(i);	//在外部仍可以访问i的值。不符合规定。

        for(let i=0;i<5;i++){
            console.log(i)
        }
        console.log(i);	//加入let关键词，外部无法再访问i的值
        
        const a = 1;
        console.log(a);		//a被定义为常量，无法修改和再次赋值
        
        let a = 'hello js';
        console.log(a.includes("a"));	//判断a中是否包含字符串a，返回false
       
        var b = `a
        b
        c`;
        console.log(b);	//字符串模板使用，保持b的输出结构
        
        let arr = [1,2,3];
        const [x,y,z] = arr;
        console.log(x,y,z);	//打印1 2 3 x,y,z被依次赋值
        
        let person = {
            name:'tom',
            age:18,
            language:["c","js","java"]
        }
        const{name,age,language} = person;	//定义对象
        console.log(name);
        const{name:n} = person;
        console.log(n);
        
        function add(a,b){
            b = b||1;	//如果b为空，b=1
            return a+b;
        }
        console.log(add(3));
        
        function add(a,b=1){
            return a+b;
        }
        console.log(add(3));	//直接赋予默认值。
        
        var d = function(o){
            console.log(o);
        }
        d(3);		//定义匿名函数
        var d = o=>console.log(o);	//箭头函数，lamda表达式
        
        let p = {
            name:'tom',
            eet:function(o){
                console.log(this.name+o);
            },
            eet2:o=>console.log(p.name+o),	//无法用this获取，直接使用本类类名
        	eet3(o){
                console.log(this.name+o);
            }
        }
        
        var hi = ({name}) => console.log("hello,"+name);
        hi(person);		//需要传入对象，使用{}定义的属性，需要从对象中获取
        
        const a = ['1','3','5'];
        const b = a.map(x=>parseInt(x));
        console.log(b);	//元素一个一个被取出，然后元素转换类型，返回一个集合
        
        const y = [1,2,9];
        const z=y.reduce((a,b)=>a+b);
        console.log(z);	//元素两两依次取出，并进行计算，被计算的元素不再计算，最终计算结果返回。
    </script>
</body>

怎麼還沒睡a

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringCloud基础知识点，案例实现。

SpringCloud远程方法调用RPC：dubbo和微服务，都是分布式的，分布式最少是两台电脑以上，然后，电脑之间相互协作需要完成通讯。dubbo是基于RPC的。RPC意思就是A服务器可以调用B服务器的服务，两者保持数据传输格式相同。http：网络传输协议，客户端和服务端采用Http协议。SpringCloud基于HTTP协议。浏览器访问网站。两种方式比较速度：RPC比HTTP更快，虽...
复制链接

扫一扫