码农碎碎念

19. SpringCloud学习笔记

笔记整理来源 B站UP主狂神说：https://www.bilibili.com/video/BV1jJ411S7xr
文档来源：https://www.kuangstudy.com/bbs/1374942542566551554

1. 学习前言

1.1 学习前提

* 熟练使用SpringBoot 微服务快速开发框架
* 了解过Dubbo + Zookeeper 分布式基础
* 电脑配置内存不低于8G(我自己的是16G)

给大家看下多个服务跑起来后的内存开销图：

1.2 文章大纲

Spring Cloud 五大组件

* 服务注册与发现——Netflix Eureka
*  负载均衡：

      * 客户端负载均衡——Netflix Ribbon
    * 服务端负载均衡：——Feign(其也是依赖于Ribbon，只是将调用方式RestTemplete 更改成Service 接口)
*  断路器——Netflix Hystrix
*  服务网关——Netflix Zuul
*  分布式配置——Spring Cloud Config

1.3 常见面试题

1.1 什么是微服务？

1.2 微服务之间是如何独立通讯的？

1.3 SpringCloud 和 Dubbo有那些区别？

1.4 SpringBoot 和 SpringCloud，请谈谈你对他们的理解

1.5 什么是服务熔断？什么是服务降级？

1.6 微服务的优缺点分别是什么？说下你在项目开发中遇到的坑

1.7 你所知道的微服务技术栈有哪些？列举一二

1.8 Eureka和Zookeeper都可以提供服务注册与发现的功能，请说说两者的区别

2. 微服务概述

2.1 什么是微服务？

什么是微服务？

微服务(Microservice Architecture) 是近几年流行的一种架构思想，关于它的概念很难一言以蔽之。

究竟什么是微服务呢？我们在此引用ThoughtWorks 公司的首席科学家 Martin Fowler 于2014年提出的一段话：

原文：https://martinfowler.com/articles/microservices.html

汉化：https://www.cnblogs.com/liuning8023/p/4493156.html

就目前而言，对于微服务，业界并没有一个统一的，标准的定义。
但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它体长将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HTTP)互相沟通，每个服务都围绕着具体的业务进行构建，并且能狗被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应该根据业务上下文，选择合适的语言，工具(Maven)对其进行构建，可以有一个非常轻量级的集中式管理来协调这些服务，可以使用不同的语言来编写服务，也可以使用不同的数据存储。

再来从技术维度角度理解下：

微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。

2.2 微服务与微服务架构

微服务

强调的是服务的大小，它关注的是某一个点，是具体解决某一个问题/提供落地对应服务的一个服务应用，狭义的看，可以看作是IDEA中的一个个微服务工程，或者Moudel。IDEA 工具里面使用Maven开发的一个个独立的小Moudel，它具体是使用SpringBoot开发的一个小模块，专业的事情交给专业的模块来做，一个模块就做着一件事情。强调的是一个个的个体，每个个体完成一个具体的任务或者功能。

微服务架构

一种新的架构形式，Martin Fowler 于2014年提出。

微服务架构是一种架构模式，它体长将单一应用程序划分成一组小的服务，服务之间相互协调，互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务之间采用轻量级的通信机制 (如HTTP)互相协作，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具(如Maven)**对其进行构建。

2.3 微服务优缺点

优点

单一职责原则；
每个服务足够内聚，足够小，代码容易理解，这样能聚焦一个指定的业务功能或业务需求；
开发简单，开发效率高，一个服务可能就是专一的只干一件事；
微服务能够被小团队单独开发，这个团队只需2-5个开发人员组成；
微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的；
微服务能使用不同的语言开发；
易于和第三方集成，微服务允许容易且灵活的方式集成自动部署，通过持续集成工具，如jenkins，Hudson，bamboo；
微服务易于被一个开发人员理解，修改和维护，这样小团队能够更关注自己的工作成果，无需通过合作才能体现价值；
微服务允许利用和融合最新技术；
微服务只是业务逻辑的代码，不会和HTML，CSS，或其他的界面混合;
每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一的数据库；

缺点

开发人员要处理分布式系统的复杂性；
多服务运维难度，随着服务的增加，运维的压力也在增大；
系统部署依赖问题；
服务间通信成本问题；
数据一致性问题；
系统集成测试问题；
性能和监控问题；

2.4 微服务技术栈有那些？

| **微服务技术条目**          | 落地技术                                             |
| -------------------- | ------------------------------------------------ |
| 服务开发                 | SpringBoot、Spring、SpringMVC等                     |
| 服务配置与管理              | Netfix公司的Archaius、阿里的Diamond等                    |
| 服务注册与发现              | Eureka、Consul、Zookeeper等                         |
| 服务调用                 | Rest、PRC、gRPC                                    |
| 服务熔断器                | Hystrix、Envoy等                                   |
| 负载均衡                 | Ribbon、Nginx等                                    |
| 服务接口调用(客户端调用服务的简化工具) | Fegin等                                           |
| 消息队列                 | Kafka、RabbitMQ、ActiveMQ等                         |
| 服务配置中心管理             | SpringCloudConfig、Chef等                          |
| 服务路由(API网关)          | Zuul等                                            |
| 服务监控                 | Zabbix、Nagios、Metrics、Specatator等                |
| 全链路追踪                | Zipkin、Brave、Dapper等                             |
| 数据流操作开发包             | SpringCloud Stream(封装与Redis，Rabbit，Kafka等发送接收消息) |
| 时间消息总栈               | SpringCloud Bus                                  |
| 服务部署                 | Docker、OpenStack、Kubernetes等                     |

2.5 为什么选择SpringCloud作为微服务架构

选型依据

整体解决方案和框架成熟度
社区热度
可维护性
学习曲线

当前各大IT公司用的微服务架构有那些？

阿里：dubbo+HFS
京东：JFS
新浪：Motan
当当网：DubboX

各微服务框架对比

| 功能点/服务框架 | Netflix/SpringCloud | Motan | gRPC | Thri t | Dubbo/DubboX |
| —————— | ———————————————————————————— | —————————————————- | ————————— | ———— | —————————— |
| 功能定位 | 完整的微服务框架 | RPC框架，但整合了ZK或Consul，实现集群环境的基本服务注册发现 | RPC框架 | RPC框架 | 服务框架 |
| 支持Rest | 是，Ribbon支持多种可拔插的序列号选择 | 否 | 否 | 否 | 否 |
| 支持RPC | 否 | 是(Hession2) | 是 | 是 | 是 |
| 支持多语言 | 是(Rest形式) | 否 | 是 | 是 | 否 |
| 负载均衡 | 是(服务端zuul+客户端Ribbon)，zuul-服务，动态路由，云端负载均衡Eureka（针对中间层服务器） | 是(客户端) | 否 | 否 | 是(客户端) |
| 配置服务 | Netfix Archaius，Spring Cloud Config Server 集中配置 | 是(Zookeeper提供) | 否 | 否 | 否 |
| 服务调用链监控 | 是(zuul)，zuul提供边缘服务，API网关 | 否 | 否 | 否 | 否 |
| 高可用/容错 | 是(服务端Hystrix+客户端Ribbon) | 是(客户端) | 否 | 否 | 是(客户端) |
| 典型应用案例 | Netflix | Sina | Google | Facebook | |
| 社区活跃程度 | 高 | 一般 | 高 | 一般 | 2017年后重新开始维护，之前中断了5年 |
| 学习难度 | 中等 | 低 | 高 | 高 | 低 |
| 文档丰富程度 | 高 | 一般 | 一般 | 一般 | 高 |
| 其他 | Spring Cloud Bus为我们的应用程序带来了更多管理端点 | 支持降级 | Netflix内部在开发集成gRPC | IDL定义 | 实践的公司比较多 |

3. SpringCloud入门概述

3.1 SpringCloud是什么？

Spring官网：https://spring.io/

3.2 SpringCloud和SpringBoot的关系

SpringBoot专注于开苏方便的开发单个个体微服务；
SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务，整合并管理起来，为各个微服务之间提供：配置管理、服务发现、断路器、路由、为代理、事件总栈、全局锁、决策竞选、分布式会话等等集成服务；
SpringBoot可以离开SpringCloud独立使用，开发项目，但SpringCloud离不开SpringBoot，属于依赖关系；
SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架；

3.3 Dubbo 和 SpringCloud技术选型

分布式+服务治理Dubbo：目前成熟的互联网架构，应用服务化拆分 + 消息中间件
Dubbo 和 SpringCloud对比可以看一下社区活跃度：
https://github.com/dubbo
https://github.com/spring-cloud
对比结果：

|        | Dubbo         | SpringCloud                  |
| ------ | ------------- | ---------------------------- |
| 服务注册中心 | Zookeeper     | Spring Cloud Netfilx Eureka  |
| 服务调用方式 | RPC           | REST API                     |
| 服务监控   | Dubbo-monitor | Spring Boot Admin            |
| 断路器    | 不完善           | Spring Cloud Netfilx Hystrix |
| 服务网关   | 无             | Spring Cloud Netfilx Zuul    |
| 分布式配置  | 无             | Spring Cloud Config          |
| 服务跟踪   | 无             | Spring Cloud Sleuth          |
| 消息总栈   | 无             | Spring Cloud Bus             |
| 数据流    | 无             | Spring Cloud Stream          |
| 批量任务   | 无             | Spring Cloud Task            |

最大区别：Spring Cloud 抛弃了Dubbo的RPC通信，采用的是基于HTTP的REST方式
严格来说，这两种方式各有优劣。虽然从一定程度上来说，后者牺牲了服务调用的性能，但也避免了上面提到的原生RPC带来的问题。而且REST相比RPC更为灵活，服务提供方和调用方的依赖只依靠一纸契约，不存在代码级别的强依赖，这个优点在当下强调快速演化的微服务环境下，显得更加合适。
社区支持与更新力度的区别
总结：二者解决的问题域不一样：Dubbo的定位是一款RPC框架，而SpringCloud的目标是微服务架构下的一站式解决方案。

3.4 SpringCloud能干嘛？

Distributed/versioned configuration 分布式/版本控制配置
Service registration and discovery 服务注册与发现
Routing 路由
Service-to-service calls 服务到服务的调用
Load balancing 负载均衡配置
Circuit Breakers 断路器
Distributed messaging 分布式消息管理
…

3.5 SpringCloud下载

官网：http://projects.spring.io/spring-cloud/

版本号有点特别：

SpringCloud没有采用数字编号的方式命名版本号，而是采用了伦敦地铁站的名称，同时根据字母表的顺序来对应版本时间顺序，比如最早的Realse版本：Angel，第二个Realse版本：Brixton，然后是Camden、Dalston、Edgware，目前最新的是Hoxton SR4 CURRENT GA通用稳定版。

自学参考书：
SpringCloud Netflix 中文文档：https://springcloud.cc/spring-cloud-netflix.html
SpringCloud 中文API文档(官方文档翻译版)：https://springcloud.cc/spring-cloud-dalston.html
SpringCloud中国社区：http://springcloud.cn/
SpringCloud中文网：https://springcloud.cc
SpringCloud项目：https://spring.io/projects/spring-cloud

4. SpringCloud Rest学习环境搭建：服务提供者

4.1 介绍

我们会使用一个Dept部门模块做一个微服务通用案例Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务。
回顾Spring，SpringMVC，Mybatis等以往学习的知识。
Maven的分包分模块架构复习。

一个简单的Maven模块结构是这样的：
-- app-parent: 一个父项目(app-parent)聚合了很多子项目(app-util\app-dao\app-web...)
  |-- pom.xml
  |
  |-- app-core
  ||---- pom.xml
  |
  |-- app-web
  ||---- pom.xml
  ......

一个父工程带着多个Moudule子模块

MicroServiceCloud父工程(Project)下初次带着3个子模块(Module)

microservicecloud-api 【封装的整体entity/接口/公共配置等】
microservicecloud-consumer-dept-80 【服务提供者】
microservicecloud-provider-dept-8001 【服务消费者】

4.2 SpringCloud版本选择

| SpringBoot | SpringCloud       | 关系                                 |
| ---------- | ----------------- | ---------------------------------- |
| 1.2.x      | Angel版本(天使)       | 兼容SpringBoot1.2x                   |
| 1.3.x      | Brixton版本(布里克斯顿)  | 兼容SpringBoot1.3x，也兼容SpringBoot1.4x |
| 1.4.x      | Camden版本(卡姆登)     | 兼容SpringBoot1.4x，也兼容SpringBoot1.5x |
| 1.5.x      | Dalston版本(多尔斯顿)   | 兼容SpringBoot1.5x，不兼容SpringBoot2.0x |
| 1.5.x      | Edgware版本(埃奇韦尔)   | 兼容SpringBoot1.5x，不兼容SpringBoot2.0x |
| 2.0.x      | Finchley版本(芬奇利)   | 兼容SpringBoot2.0x，不兼容SpringBoot1.5x |
| 2.1.x      | Greenwich版本(格林威治) |                                    |

实际开发版本关系：使用后两个

| spring-boot-starter-parent |          | spring-cloud-dependencles |          |
|:--------------------------:| --------:|:-------------------------:|:--------:|
|          **版本号**           | **发布日期** |          **版本号**          | **发布日期** |
|       1.5.2.RELEASE        |  2017-03 |        Dalston.RC1        |  2017-x  |
|       1.5.9.RELEASE        |  2017-11 |      Edgware.RELEASE      | 2017-11  |
|       1.5.16.RELEASE       |  2018-04 |        Edgware.SR5        | 2018-10  |
|       1.5.20.RELEASE       |  2018-09 |        Edgware.SR5        | 2018-10  |
|       2.0.2.RELEASE        |  2018-05 |  Fomchiey.BULD-SNAPSHOT   |  2018-x  |
|       2.0.6.RELEASE        |  2018-10 |       Fomchiey-SR2        | 2018-10  |
|       2.1.4.RELEASE        |  2019-04 |       Greenwich.SR1       | 2019-03  |

4.3 创建项目

1. 创建空项目

创建一个空的项目，选择路径和输入名称

2. 创建父项目

右键项目->new module

新建model

项目路径

pom配置
https://spring.io/projects/spring-cloud


<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.xxxgroupId>
    <artifactId>springcloud_parentartifactId>
    <version>1.0-SNAPSHOTversion>
    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.2.5.RELEASEversion>
    parent>

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

4.4 链接数据库创建创建实例

新建父工程项目springcloud，切记Packageing是pom模式
主要是定义POM文件，将后续各个子模块公用的jar包等统一提取出来，类似一个抽象父类

选择maven项目点击下一步
选择创建的路径，及名称，点击完成
删除src
pom 依赖


<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.xxxgroupId>
    <artifactId>1_springCloudartifactId>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        
        <junit.version>4.12 junit.version>
        <log4j.version>1.2.17log4j.version>
        <lombok.version>1.16.18lombok.version>
    properties>
    
    <packaging>pompackaging>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-alibaba-dependenciesartifactId>
                <version>0.2.0.RELEASEversion>
                <type>pomtype>
                <scope>importscope>
            dependency>
            
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>Greenwich.SR1version>
                <type>pomtype>
                <scope>importscope>
            dependency>
            
            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-dependenciesartifactId>
                <version>2.6.3version>
                <type>pomtype>
                <scope>importscope>
            dependency>
            
            <dependency>
                <groupId>mysqlgroupId>
                <artifactId>mysql-connector-javaartifactId>
                <version>8.0.28version>
            dependency>
            <dependency>
                <groupId>com.alibabagroupId>
                <artifactId>druidartifactId>
                <version>1.2.8version>
            dependency>
            
            <dependency>
                <groupId>org.mybatis.spring.bootgroupId>
                <artifactId>mybatis-spring-boot-starterartifactId>
                <version>2.2.2version>
            dependency>
            
            <dependency>
                <groupId>ch.qos.logbackgroupId>
                <artifactId>logback-coreartifactId>
                <version>1.2.11version>
            dependency>
            <dependency>
                <groupId>junitgroupId>
                <artifactId>junitartifactId>
                <version>${junit.version}version>
            dependency>
            <dependency>
                <groupId>log4jgroupId>
                <artifactId>log4jartifactId>
                <version>${log4j.version}version>
            dependency>
            <dependency>
                <groupId>org.projectlombokgroupId>
                <artifactId>lombokartifactId>
                <version>${lombok.version}version>
            dependency>
        dependencies>
    dependencyManagement>

project>

4.4.1 springcloud-api 项目公共实体

new module
选择maven，下一步
springcloud-api ，点击完成
引入当前springcloud-api 的pom依赖

    
    <dependencies>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
    dependencies>

新建数据库和表

-- 创建数据库
drop database if exists db01;
create database db01 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

-- 创建表
CREATE TABLE `dept` (
  `deptno` bigint(20) NOT NULL AUTO_INCREMENT,
  `dname` varchar(60) DEFAULT NULL,
  `db_source` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`deptno`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='部门表'

-- 添加数据
INSERT INTO dept(dname,db_source) VALUES ('开发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES ('项目部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES ('研发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES ('运维部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES ('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES ('人事部',DATABASE());

springcloud-api 实体类结构图

路径：src/main/java/com/xxx/springcloud/pojo/Dept.java
代码：

package com.xxx.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@NoArgsConstructor
@Accessors(chain = true)//开启链式写法 普通写法：new Dept().setid(1);   链式写法：new Dept().setid(1).setname("test")....

/*实体类实现序列化*/
public class Dept implements Serializable { //数据库的表和当前实体类映射，类表关系映射
    private Long deptno;//主键
    private String dname;
    //存在于哪个数据库的字段 ~ 微服务，一个服务对应一个数据库，同一个信息可能存在于不同的数据库
    private String db_source;

    public Dept(String dname) {
        this.dname = dname;
    }
}

4.4.2 springcloud-provider-dept-8001 创建服务的提供者maven项目

右键父类项目，new->module…
选择maven，下一步
输入名称 springcloud-provider-dept-8001，点击完成
pom.xml引入依赖

 
    <artifactId>springcloud-provider-dept-8001artifactId>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>

    <dependencies>
        
        <dependency>
            <groupId>com.xxxgroupId>
            <artifactId>springcloud-apiartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
        dependency>
        
        <dependency>
            <groupId>ch.qos.logbackgroupId>
            <artifactId>logback-coreartifactId>
        dependency>
        
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jettyartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
        dependency>
    dependencies>

配置8001提供者的application.yml
路径：src/main/resources/application.yml

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.lemon.springcloud.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml
  config-location: classpath:mybatis/mybatis-config.xml

#spring的配置
spring:
  application:
    name: springcloud-provider-dept
    #数据源的配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #数据源为druid
    driver-class-name: com.mysql.jdbc.Driver #数据库驱动
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8&servetTimeZone=Asia/Shanghai
    username: root
    password: root

创建mybaits配置对应的文件夹，及文件如下图
配置mybaits config-location对应的配置文件
路径：src/main/resources/mybatis/mybatis-config.xml


DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <settings>
        
        <setting name="cacheEnabled" value="true"/>
    settings>

configuration>

创建Dao接口类
路径：src/main/java/com/xxx/springcloud/dao/DeptDao.java

package com.xxx.springcloud.dao;

import com.xxx.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
public interface DeptDao {
    //添加一个部门
    public boolean addDept(Dept dept);

    //根据id查出一个部门
    public Dept queryById(Long id);

    //查询所有部门信息
    public List<Dept> queryAll();

}

创建Mapper.xml
路径：src/main/resources/mybatis/mapper/DeptMapper.xml


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.xxx.springcloud.dao.DeptDao">
    
    <insert id="addDept" parameterType="com.xxx.springcloud.pojo.Dept">
        insert into dept (dname, db_source)
        values (#{dname}, DATABASE())
    insert>
    
    <select id="queryById" resultType="com.xxx.springcloud.pojo.Dept">
        select deptno, dname, db_source
        from dept
        where deptno = #{deptno};
    select>
    
    <select id="queryAll" resultType="com.xxx.springcloud.pojo.Dept">
        select deptno, dname, db_source
        from dept;
    select>
mapper>

创建service 接口类
路径：src/main/java/com/xxx/springcloud/service/DeptService.java

package com.xxx.springcloud.service;

import com.xxx.springcloud.pojo.Dept;

import java.util.List;

public interface DeptService {
    //添加一个部门
    public boolean addDept(Dept dept);

    //根据id查出一个部门
    public Dept queryById(Long id);

    //查询所有部门信息
    public List<Dept> queryAll();
}

创建service实现类
路径：com/xxx/springcloud/service/DeptServiceImpl.java

package com.xxx.springcloud.service;

import com.xxx.springcloud.dao.DeptDao;
import com.xxx.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    public DeptDao deptDao;

    @Override
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryById(Long id) {

        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

创建controll类
路径：src/main/java/com/xxx/springcloud/controller/DeptController.java

package com.xxx.springcloud.controller;

import com.xxx.springcloud.pojo.Dept;
import com.xxx.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class DeptController{
    @Autowired
    private DeptService deptService;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept) {
        return deptService.addDept(dept);
    }

    @RequestMapping("/dept/get/{id}")
    public Dept queryById(@PathVariable("id") Long id) {
        return deptService.queryById(id);
    }

    @RequestMapping("/dept/list")
    public List<Dept> queryAll() {
        return deptService.queryAll();
    }
}

创建启动类
路径：src/main/java/com/xxx/springcloud/DeptProvider_8001.java

package com.xxx.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

访问
路径：http://localhost:8001/dept/list 集合
访问：http://localhost:8001/dept/get/1 详情

4.4.3 springcloud-consumer-dept-80 Rest环境搭建，服务消费者

创建
输入名称 springcloud-consumer-dept-80，完成
导入pom依赖

    
    <artifactId>springcloud-consumer-dept-80artifactId>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>
    
    <dependencies>
        <dependency>
            <groupId>com.xxxgroupId>
            <artifactId>springcloud-apiartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>

配置类
路径：src/main/java/com/xxx/springcloud/config/ConfigBean.java

package com.xxx.springcloud.config;

import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean { //配置类
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

controller
路径：src/main/java/com/xxx/springcloud/controller/DeptConsumerController.java

package com.xxx.springcloud.controller;

import com.xxx.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {
    /**
     * 理解：消费者，不应该有service层~
     * RestTemplate .... 供我们直接调用就可以了！ 注册到Spring中
     * (地址：url, 实体：Map ,Class responseType)
     * 
     * 提供多种便捷访问远程http服务的方法，简单的Restful服务模板~
     */
    @Autowired
    private RestTemplate restTemplate;
    /**
     * 服务提供方地址前缀
     * 
     * Ribbon:我们这里的地址，应该是一个变量，通过服务名来访问
     */
    private static final String REST_URL_PREFIX = "http://localhost:8001";
    //private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
    /**
     * 消费方添加部门信息
     * @param dept
     * @return
     */
    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        // postForObject(服务提供方地址(接口),参数实体,返回类型.class)
        return Boolean.TRUE.equals(restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class));
    }
    /**
     * 消费方根据id查询部门信息
     * @param id
     * @return
     */
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        // getForObject(服务提供方地址(接口),返回类型.class)
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    }
    /**
     * 消费方查询部门信息列表
     * @return
     */
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    }
}

启动类
路径：src/main/java/com/xxx/springcloud/DeptConsumer_80.java

package com.xxx.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

5. Eureka服务注册中心

5.1 什么是Eureka

Netflix在涉及Eureka时，遵循的就是API原则.
Eureka是Netflix的有个子模块，也是核心模块之一。Eureka是基于REST的服务，用于定位服务，以实现云端中间件层服务发现和故障转移，服务注册与发现对于微服务来说是非常重要的，有了服务注册与发现，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了，功能类似于Dubbo的注册中心，比如Zookeeper.

5.2 原理理解

服务注册中心

三大角色

* Eureka Server：提供服务的注册与发现
* Service Provider：服务生产方，将自身服务注册到Eureka中，从而使服务消费方能狗找到
* Service Consumer：服务消费方，从Eureka中获取注册服务列表，从而找到消费服务

5.3 构建步骤<以4.3为项目基础>

1. Eureka Server 的创建

右击springcloud_parent 创建moudel->springcloud_01eureka_server
路由查看
springcloud_01eureka_server的pom的配置


    
     <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
        dependency>
    dependencies>

springcloud_01eureka_server的配置文件的编写
路径：src/main/resources/application.yml

# 默认端口号：8761
server:
  port: 8761
# Eureka配置
eureka:
  instance:
    # Eureka服务端的实例名字
    hostname: 127.0.0.1
  client:
    # 表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    # 让当前应用仅仅是服务注册中心
    register-with-eureka: false
    # fetch-registry如果为false,则表示自己为注册中心,客户端的化为 ture
    # 关闭eureka client的立即注册
    fetch-registry: false
    # Eureka监控页面~
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
# spring 配置
spring:
  application:
    # 服务名不能出现下划线,默认服务名不区分大小写，推荐大写
    name: EUREKASERVER

springcloud_01eureka_server的启动类的创建
路径：src/main/java/com/xxx/EurekaServerApplication.java

package com.xxx;

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

@SpringBootApplication
//开启服务注册中心
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

启动
访问：http://127.0.0.1:8761/

2. Eureka Client的创建

基于业务开发出来的一个个微服务

springcloud_02eureka_client的创建

2. 路由查看

3. pom配置


        <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
        dependency>
    dependencies>

配置文件
路径：src/main/resources/application.yml

# 端口
server:
  port: 8989

# 服务名称
spring:
  application:
    name: EUREKACLIENT
# 指定服务注册中心地址 Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

启动类
路径：src/main/java/com/xxx/EurekaClintApplication.java

package com.xxx;

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

@SpringBootApplication
//开启Eureka客户端
@EnableEurekaClient
public class EurekaClintApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaClintApplication.class, args);
    }
}

启动客户端
查看服务端的路径监控
路径：http://127.0.0.1:8761/
已经成功注册到eureka

3. Eureka 自我保护机制：好死不如赖活着

出现一下这句话，说明进入自我保护机制

详细内容可以参考下这篇博客内容：https://blog.csdn.net/wudiyong22/article/details/80827594

服务端配置测试

客户端配置测试

加快统计时间，用最短的时间清除自我保护

4. Eureka Server 集群搭建

点击修改配置
复制server项目，配置vm-Dserver.port=8762、-Dserver.port=8763、-Dserver.port=8764等如下图多个项目端口号
启动这四个服务，都正常启动

4. 停止服务，配置本地hosts
路径：C:\Windows\System32\drivers\etc

5. 配置hosts

注意：最好通过软件修改，如果手动打开文件修改可能不生效或者保存失败

127.0.0.1   eureka8761.com
127.0.0.1   eureka8762.com
127.0.0.1   eureka8763.com

配置服务端8761集群
路径：springcloud_01eureka_server\src\main\resources\application.yml

server:
  port: 8761
#Eureka配置
eureka:
  instance:
    hostname: eureka8761.com #Eureka服务端的实例名字
  client:
    register-with-eureka: false #表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    fetch-registry: false #fetch-registry如果为false,则表示自己为注册中心
    service-url: #监控页面~
      #重写Eureka的默认端口以及访问路径 --->http://localhost:8761/eureka/
      # 单机： defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群（关联）：8761关联8762、8763
      defaultZone: http://eureka8762.com:8762/eureka/,http://eureka8763.com:8763/eureka/

两个节点，当前运行时8761

7. 配置服务端8762集群
路径：springcloud_01eureka_server\src\main\resources\application.yml

server:
  port: 8762
#Eureka配置
eureka:
  instance:
    hostname: eureka8762.com #Eureka服务端的实例名字
  client:
    register-with-eureka: false #表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    fetch-registry: false #fetch-registry如果为false,则表示自己为注册中心
    service-url: #监控页面~
      #重写Eureka的默认端口以及访问路径 --->http://localhost:8761/eureka/
      # 单机： defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群（关联）：8762关联8761、8763
      defaultZone: http://eureka8761.com:8761/eureka/,http://eureka8763.com:8763/eureka/

配置服务端8763集群
路径：springcloud_01eureka_server\src\main\resources\application.yml

server:
  port: 8763
#Eureka配置
eureka:
  instance:
    hostname: eureka8763.com #Eureka服务端的实例名字
  client:
    register-with-eureka: false #表示是否向 Eureka 注册中心注册自己(这个模块本身是服务器,所以不需要)
    fetch-registry: false #fetch-registry如果为false,则表示自己为注册中心
    service-url: #监控页面~
      #重写Eureka的默认端口以及访问路径 --->http://localhost:8761/eureka/
      # 单机： defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群（关联）：8763关联8762、8761
      defaultZone: http://eureka8761.com:8761/eureka/,http://eureka8762.com:8762/eureka/

客户端配置文件
路径：springcloud_02eureka_client\src\main\resources\application.yml

# 端口
server:
  port: 8989

# Eureka配置：配置服务注册中心地址
# Eureka配置：配置服务注册中心地址
eureka:
  client:
    service-url:
      # 注册中心地址8761-8763
      defaultZone: http://eureka8761.com:8761/eureka/,http://eureka8762.com:8762/eureka/,http://eureka8763.com:8763/eureka/

运行客户端访问路由
访问：http://eureka8761.com:8761/

访问：http://eureka8762.com:8762/

访问：http://eureka8763.com:8763/

6. consul 服务注册中心

文档：https://www.consul.io/docs/architecture

1. consul Server 服务注册中心介绍和安装

选择下载：https://www.consul.io/downloads
下载完成后生成如下文件
压缩文件到指定位置，路径名称不要有中文
在当前目录输入cmd，进入shell
输入命令consul agent -dev
访问counsul 界面，默认端口号8500, 路由：http://localhost:8500/
管理中心介绍
dc1：数据中心名称 datacenter 默认为 dc1
指定数据中心名称启动：consul agent -dev -datacenter=aaa
访问：http://localhost:8500/ 自动跳转到 http://localhost:8500/ui/aaa/services
界面说明
配置环境变量
查看当前exe的路径：E:\Java\springCloud\other\consul_1.13.2_windows_amd64

右键win->应用和功能(F)->搜索环境变量,最后编辑path，全部点击确定

添加完成后，任意位置都可以打开consul 了

2. consul client 服务客户端(微服务)

3. 新增model<以5.3为项目基础>

新增springcloud_03consulclient ，路由
pom.xml 引入依赖

 
  
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-consul-discoveryartifactId>
        dependency>
    dependencies>

文件配置
路径：springcloud_03consulclient\src\main\resources\application.yml

# 端口
server:
  port: 8082
# 指定名称
spring:
  application:
    name: CONSULCLIENT
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name} # 注册服务名称
# consul server 服务注册地址

启动类创建
路径：src/main/java/com/xxx/ConsulClientApplication.java

package com.xxx;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;


@SpringBootApplication
// 开启consul ,jk
@EnableDiscoveryClient
public class ConsulClientApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsulClientApplication.class, args);

    }
}

启动

6. pom.xml 引入健康检查的依赖

  
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>

启动
断开后consul就直接消失了，说明没有自我保护机制

7. 服务间通信和RestTemplate的使用

users Model 和 orders model 同步进行创建配置，最后进行通信，因为是user调用order，所以要先有order，user在调用。

1. 创建users Model<以6.3为项目基础>

名称：springcloud_04users

路由查看

pom.xml 依赖引入

  
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-consul-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
    dependencies>

application.yml配置

# 端口
server:
  port: 8888
# 指定名称
spring:
  application:
    name: USER
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name} # 注册服务名

UsersApplication启动类创建

package com.xxx;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
// 开启consul ,jk
@EnableDiscoveryClient
public class UsersApplication {
    public static void main(String[] args) {
        SpringApplication.run(UsersApplication.class, args);
    }
}

启动运行，先开启的两个服务，再查看的服务管理，所有两个都有

创建controller：src/main/java/com/xxx/controller/UserController.java

package com.xxx.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;


@RestController
public class UserController {

    private static final Logger log = LoggerFactory.getLogger(UserController.class);

    /**
     * 调用demo
     */
    @GetMapping("user")
    public String invokeDemo() {
        System.out.println("user demo");
        //调用order 订单服务，http://localhost:9999/order 接收返回值
        RestTemplate restTemplate = new RestTemplate();
        String orderResult = restTemplate.getForObject("http://localhost:9999/order", String.class);
        log.info("调用顶层服务成功：{}", orderResult);
        return "调用order服务成功，结果为：" + orderResult;
    }
}

启动程序并访问：http://localhost:8888/user

2. 创建orders Model

名称：springcloud_05orders

路由查看

pom.xml 依赖引入

  
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-consul-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
    dependencies>

application.yml配置

# 端口
server:
  port: 9999
# 指定名称
spring:
  application:
    name: ORDER
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        service-name: ${spring.application.name} # 注册服务名称

OrdersApplication启动类创建

package com.xxx;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
// 开启consul ,jk
@EnableDiscoveryClient
public class OrdersApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrdersApplication.class, args);
    }
}

启动运行，先开启的两个服务，再查看的服务管理，所有两个都有
创建controller：src/main/java/com/xxx/controller/OrderController.java

package com.xxx.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    private static final Logger log = LoggerFactory.getLogger(OrderController.class);

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

    /**
     * 调用demo
     */
    @GetMapping("order")
    public String demo() {
        log.info("order demo.....");
        return "order demo ok ，当前提供服务端口为：" + port;
    }
}

启动程序并访问：http://localhost:9999/order

8. Ribbon：负载均衡(基于客户端)

Ribbon：只能负载均衡不能发送请求
RestTemplate：发送请求

1.负载均衡以及Ribbon

2. Ribbon的服务调用说明

3. Ribbon的服务调用实例

配置里面复制order,新建order9990

1. DiscoveryClient 的实现

服务注册与发现客户端对象，需要自己写策略

路径： springcloud_04users\src\main\java\com\xxx\controller\UserController.java

package com.xxx.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;


@RestController
public class UserController {

    private static final Logger log = LoggerFactory.getLogger(UserController.class);

    @Autowired //服务注册与发现客户端对象
    private DiscoveryClient discoveryClient;

    /**
     * 调用demo
     */
    @GetMapping("user")
    public String invokeDemo() {
        //1. 调用order 订单服务，http://localhost:9999/order 接收返回值
        //RestTemplate restTemplate = new RestTemplate();
        //String orderResult = restTemplate.getForObject("http://localhost:9999/order", String.class);

        //2. 调用ribbon组件+restTemplate 实现负载均衡的调用 1. DiscoveryClient 2. LoadBalanceClient 3.LoadBalance
        List<ServiceInstance> serviceInstances = discoveryClient.getInstances("ORDER");
        serviceInstances.forEach(serviceInstance -> {
            log.info("服务机：{} 服务端口：{} 服务地址：{}", serviceInstance.getHost(), serviceInstance.getPort(), serviceInstance.getUri());
        });
      /*  log.info("调用顶层服务成功：{}", orderResult);
        return "调用order服务成功，结果为：" + orderResult;*/
        return "user ok";
    }
}

运行：http://localhost:8888/user ，发现返回两个接口的数据

2. LoadBalancerClient 的实现

负载均衡客户端对象，轮询策略

路径： springcloud_04users\src\main\java\com\xxx\controller\UserController.java

package com.xxx.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;


@RestController
public class UserController {

    private static final Logger log = LoggerFactory.getLogger(UserController.class);

    @Autowired //服务注册与发现客户端对象，需要自己写策略
    private DiscoveryClient discoveryClient;
    @Autowired //负载均衡客户端对象，轮询策略
    private LoadBalancerClient loadBalancerClient;

    /**
     * 调用demo
     */
    @GetMapping("user")
    public String invokeDemo() {
        //1. 调用order 订单服务，http://localhost:9999/order 接收返回值
        //RestTemplate restTemplate = new RestTemplate();
        //String orderResult = restTemplate.getForObject("http://localhost:9999/order", String.class);

        //2. 调用ribbon组件+restTemplate 实现负载均衡的调用 1. DiscoveryClient 2. LoadBalancerClient 3.LoadBalance
       /* List serviceInstances = discoveryClient.getInstances("ORDER");
        serviceInstances.forEach(serviceInstance -> {
            log.info("服务机：{} 服务端口：{} 服务地址：{}", serviceInstance.getHost(), serviceInstance.getPort(), serviceInstance.getUri());
        });
        String forObject = new RestTemplate().getForObject(serviceInstances.get(0).getUri() + "/order", String.class);
       */
        // 3. 使用LoadBalancerClient 进行服务调用 轮询策略
        ServiceInstance serviceInstance = loadBalancerClient.choose("ORDER");
        log.info("服务机：{} 服务端口：{} 服务地址：{}", serviceInstance.getHost(), serviceInstance.getPort(), serviceInstance.getUri());
        String forObject = new RestTemplate().getForObject(serviceInstance.getUri() + "/order", String.class);
      /*  log.info("调用顶层服务成功：{}", orderResult);
        return "调用order服务成功，结果为：" + orderResult;*/
        return "user ok" + forObject;
    }
}

访问：http://localhost:8888/user ，查看服务端信息

服务机：localhost 服务端口：9990 服务地址：http://localhost:9990

再次访问：http://localhost:8888/user ，查看服务端信息

服务机：localhost 服务端口：9999 服务地址：http://localhost:9999

3. @LoadBalanced 的实现

创建配置类BeansConfig
路径：springcloud_04users\src\main\java\com\xxx\config\BeansConfig.java

package com.xxx.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration //代表这是一个springboot 配置类  spring.xml
public class BeansConfig {

    //在工厂中创建restTemplate
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

修改控制器： springcloud_04users\src\main\java\com\xxx\controller\UserController.java

package com.xxx.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;


@RestController
public class UserController {

    private static final Logger log = LoggerFactory.getLogger(UserController.class);

    @Autowired //服务注册与发现客户端对象，需要自己写策略
    private DiscoveryClient discoveryClient;
    @Autowired //负载均衡客户端对象，轮询策略
    private LoadBalancerClient loadBalancerClient;
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 调用demo
     */
    @GetMapping("user")
    public String invokeDemo() {
        //1. 调用order 订单服务，http://localhost:9999/order 接收返回值
        //RestTemplate restTemplate = new RestTemplate();
        //String orderResult = restTemplate.getForObject("http://localhost:9999/order", String.class);

        //2. 调用ribbon组件+restTemplate 实现负载均衡的调用 1. DiscoveryClient 2. LoadBalancerClient 3.@LoadBalance
       /* List serviceInstances = discoveryClient.getInstances("ORDER");
        serviceInstances.forEach(serviceInstance -> {
            log.info("服务机：{} 服务端口：{} 服务地址：{}", serviceInstance.getHost(), serviceInstance.getPort(), serviceInstance.getUri());
        });
        String forObject = new RestTemplate().getForObject(serviceInstances.get(0).getUri() + "/order", String.class);
       */
        // 3. 使用LoadBalancerClient 进行服务调用 轮询策略
    /*    ServiceInstance serviceInstance = loadBalancerClient.choose("ORDER");
        log.info("服务机：{} 服务端口：{} 服务地址：{}", serviceInstance.getHost(), serviceInstance.getPort(), serviceInstance.getUri());
        String forObject = restTemplate.getForObject(serviceInstance.getUri() + "/order", String.class);*/
        // 4. 使用 @LoadBalanced注解调用
        String forObject = restTemplate.getForObject("http://ORDER/order", String.class);
      /*  log.info("调用顶层服务成功：{}", orderResult);
        return "调用order服务成功，结果为：" + orderResult;*/
        return "user ok" + forObject;
    }
}

访问：http://localhost:8888/user

9. OpenFeign：负载均衡(基于服务端)

网页：https://spring.io/projects/spring-cloud-openfeign

9.1 简介

9.2 开发

1. 关闭所有服务

2. 开启consul ：`consul agent -dev`

3. 查看consul是否运行正常

路径：http://localhost:8500/ui/dc1/services

4. 创建类别model->springcloud_06category

pom.xml

  
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-consul-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
    dependencies>

application配置：src/main/resources/application.yml

# 端口
# 端口
server:
  port: 8787
spring:
  application:
    name: CATEGORY
  cloud:
    consul:
      host: localhost
      port: 8500

创建启动文件：src/main/java/com/xxx/CategoryApplication.java

package com.xxx;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

启动服务查看consul：http://localhost:8500/ui/dc1/services

创建控制类：src/main/java/com/xxx/controller/CategoryController.java

package com.xxx.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Value("${server.port}")
    private int port;
    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
        return "category ok,类别服务提供的端口为：" + port;
    }
}

访问：http://localhost:8787/category

pom.xml 添加openfeign

  <dependency>
       <groupId>org.springframework.cloudgroupId>
       <artifactId>spring-cloud-starter-openfeignartifactId>
  dependency>

启动类开启openFeign

package com.xxx;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient//开启服务注册
@EnableFeignClients//开启openFeign的调用
public class CategoryApplication {
    public static void main(String[] args) {
        SpringApplication.run(CategoryApplication.class, args);
    }
}

创建配置：src/main/java/com/xxx/feignclient/ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {
    //调用商品服务
    @GetMapping("/product")
    public String product();
}

修改控制器：src/main/java/com/xxx/controller/CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
        String product = productClient.product();
        return "category ok !!!" + product;
    }
}

启动，访问路径：http://localhost:8787/category

测试：product添加了一个list方法，这边修改ProductClient

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {
    //调用商品服务
    @GetMapping("/product")
    public String product();
    @GetMapping("/list")
    public String list();
}

测试：修改controller

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
        String product = productClient.product();
        String list = productClient.list();
        log.info("结果1：{}",product);
        log.info("结果2：{}",list);
        return "category ok !!! ===>product：" + product+" ===>list："+list;
    }
}

访问路径：http://localhost:8787/category

5. 创建产品model->springcloud_07product

pom.xml

 
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-consul-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
    dependencies>

application配置：src/main/resources/application.yml

# 端口
# 端口
server:
  port: 8788
spring:
  application:
    name: PRODUCT
  cloud:
    consul:
      host: localhost
      port: 8500

创建启动文件：src/main/java/com/xxx/ProductApplication.java

package com.xxx;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

启动服务查看consul：http://localhost:8500/ui/dc1/services

创建控制类：src/main/java/com/xxx/controller/ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

    @GetMapping("/product")
    public String product() {
        log.info("进入商品服务....");
        return "product ok,商品服务提供的端口为：" + port;
    }


}

访问：http://localhost:8788/product

pom.xml 添加openfeign

  <dependency>
       <groupId>org.springframework.cloudgroupId>
       <artifactId>spring-cloud-starter-openfeignartifactId>
  dependency>

启动类开启openFeign

package com.xxx;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient//开启服务注册
@EnableFeignClients//开启openFeign的调用
public class ProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductApplication.class, args);
    }
}

controller 添加方法：src/main/java/com/xxx/controller/ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

    @GetMapping("/product")
    public String product() {
        log.info("进入商品服务....");
        return "product ok,商品服务提供的端口为：" + port;
    }

    @GetMapping("/list")
    public String list() {
        log.info("进入商品列表服务....");
        return "list ok,商品列表服务提供的端口为：" + port;
    }
}

6. 参数传递对象和零散数据

1. 零散类型querySting

querySting：test?name=zs&age=11

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

    // 零散类型 querySting test?name=zs&age=11
    @GetMapping("/test")
    public String test(@RequestParam("name") String name, @RequestParam("age") Integer age) {
        log.info("name：{}   age:{}", name, age);
        return "test ok, 当前服务端口为：" + port;

      }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


    //调用商品服务
    @GetMapping("/test")
    public String test(@RequestParam("name") String name, @RequestParam("age") Integer age);
}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
        String zs = productClient.test("zs", 11);
        return "category ok !!!   " + zs;
    }
}

访问：http://localhost:8787/category

查看ProductController运行界面，已经接收到

2. 零散类型路由传参

路由传参：test1/1/zs

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

    // 零散类型 路径传参 test1/zs/11
    @GetMapping("/test1/{id}/{name}")
    public String test1(@PathVariable("id") Integer id, @PathVariable("name") String name) {
        log.info("id：{}   name：{}", id, name);
        return "test1 ok, 当前服务端口为：" + port;

     }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


    //调用商品服务
 
    // 零散类型 路径传参 test1/zs/11
    @GetMapping("/test1/{id}/{name}")
    public String test1(@PathVariable("id") Integer id, @PathVariable("name") String name);

    @GetMapping("/product")

}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
        String zs = productClient.test1(1, "zs");
        return "category ok !!!   " + zs;
    }
}

访问：http://localhost:8787/category

查看ProductController运行界面，已经接收到

3. 对象传递

form 表单 ---------------> 参数加 @RequestPart ,文件上传的时候可以用
application/json--------> 参数加 @RequestBody

Product实体类：springcloud_07product\src\main\java\com\xxx\pojo\Product.java

package com.xxx.pojo;

import java.util.Date;

public class Product {
    private Integer id;
    private String name;
    private Double price;
    private Date bir;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Date getBir() {
        return bir;
    }

    public void setBir(Date bir) {
        this.bir = bir;
    }
    public Product() {
    }

    public Product(Integer id, String name, Double price, Date bir) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.bir = bir;
    }
    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", bir=" + bir +
                '}';
    }
}

Category实体类：springcloud_06category\src\main\java\com\xxx\pojo\Product.java

package com.xxx.pojo;

import java.util.Date;

public class Product {
    private Integer id;
    private String name;
    private Double price;
    private Date bir;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Date getBir() {
        return bir;
    }

    public void setBir(Date bir) {
        this.bir = bir;
    }

    public Product() {
    }

    public Product(Integer id, String name, Double price, Date bir) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.bir = bir;
    }

    @Override
    public String toString() {
        return "Product{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                ", bir=" + bir +
                '}';
    }
}

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import com.xxx.pojo.Product;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;
    // 对象类型
    @PostMapping("/test3")
    public String test3(@RequestBody Product product) {
        log.info("product：{} ", product);
        return "test3 ok, 当前服务端口为：" + port;

    }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import com.xxx.pojo.Product;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


    //调用商品服务
    // 对象类型
    @PostMapping("/test3")
    public String test3(@RequestBody Product product);

}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import com.xxx.pojo.Product;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
        String zs = productClient.test3(new Product(1, "zs", 23.3, new Date()));
        return "category ok !!!   " + zs;
    }
}

访问：http://localhost:8787/category

查看ProductController运行界面，已经接收到

7. 参数传递数组和集合数据

1. 数组传递

querySting方式：test?name=zs&age=11

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

    // 数组类型 queryString test4?name=zs&age=11
    @GetMapping("/test4")
    public String test4(@RequestParam("ids") String[] ids) {
        for (String id : ids) {
            log.info("id：{} ", id);
        }
          //转为list集合
        List<String> strings = Arrays.asList(ids);
        return "test4 ok, 当前服务端口为：" + port;

    }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


    // 数组类型 queryString test4?name=zs&age=11
    @GetMapping("/test4")
    public String test4(@RequestParam("ids") String[] ids);
}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
      	String result = productClient.test4(new String[]{"11", "22", "33", "44"});
        return "category ok !!!   " + result;
    }
}

访问：http://localhost:8787/category

查看ProductController运行界面，已经接收到

2. 集合传递

oo(oriented 面向 object 对象)：面向对象
vo(value 值 object 对象)：用来传递数据对象称之为值对象
dto(data 数据 transfer 传输 object 对象)：数据传输对象
传递：以数组传递。
接收：以值对象vo 接收。

Product创建vo对象：springcloud_07product\src\main\java\com\xxx\vos\CollectionVO.java

package com.xxx.vos;

import java.util.List;

//定义用来接收集合类型参数对象
public class CollectionVO {
    private List<String> ids;

    public List<String> getIds() {
        return ids;
    }

    public void setIds(List<String> ids) {
        this.ids = ids;
    }
}

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

  // 集合列表
    // oo(oriented 面向  object 对象):面向对象    vo(value 值 object 对象)：用来传递数据对象称之为值对象
    // dto(data 数据 transfer 传输 object 对象)：数据传输对象
    @PostMapping("/test5")
    public String test5(CollectionVO collectionVO) {
        collectionVO.getIds().forEach(id -> log.info("id：{}", id));
        return "test5 ok, 当前服务端口为：" + port;
     }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


    // 集合列表
    @PostMapping("/test5")
    public String test5(@RequestParam("ids") String[] ids);
}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public String category() {
        log.info("进入类别服务....");
      	    String result = productClient.test5(new String[]{"11", "22", "33", "44"});
        return "category ok !!!   " + result;
    }
}

访问：http://localhost:8787/category

查看ProductController运行界面，已经接收到

8. 调用服务响应处理

1. 根据id查询对象信息

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

 // 定义一个接口接收id类型参数，返回一个基于id查询的对象
    @GetMapping("/product/{id}")
    public Product product(@PathVariable("id") Integer id) {
        log.info("id：{} ", id);
        return new Product(1, "十四", 23.5, new Date());
     }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


    //根据id查询商品
    @GetMapping("/product/{id}")
    public Product product(@PathVariable("id") Integer id);
}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public Product category() {
        log.info("进入类别服务....");
      	 Product result = productClient.product(1);
        return result;
    }
}

访问：http://localhost:8787/category

2. 根据id查询对象列表信息

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

  // 定义一个接口接收类型id类型参数，返回一个基于id查询的list对象
    @GetMapping("/products")
    public List<Product> finProductsByCategoryId(@RequestParam("categoryId") Integer categoryId) {
        log.info("categoryId：{} ", categoryId);
        List<Product> productList = new ArrayList<>();
        productList.add(new Product(1, "十四", 24.5, new Date()));
        productList.add(new Product(2, "十五", 25.5, new Date()));
        productList.add(new Product(3, "十六", 26.5, new Date()));
        return productList;
        //return new Product(1, "十四", 23.5, new Date());
     }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


  // 定义一个接口接收类型id类型参数，返回一个基于id查询的list对象
    @GetMapping("/products")
    public List<Product> finProductsByCategoryId(@RequestParam("categoryId") Integer categoryId) ;
}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public List<Product> category() {
        log.info("进入类别服务....");
   
        List<Product> products = productClient.finProductsByCategoryId(1);
        return products;
    }
}

访问：http://localhost:8787/category

3. 根据id查询对象列表信息分页

ProductController ：springcloud_07product\src\main\java\com\xxx\controller\ProductController.java

package com.xxx.controller;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    private static final Logger log = LoggerFactory.getLogger(ProductController.class);
    @Value("${server.port}")
    private int port;

    // 定义一个接口接收类型id类型参数，返回一个基于id查询的list对象
    @GetMapping("/productsPage")
    public Map<String, Object> finProductsByCategoryIdAndPage(@RequestParam("page") Integer page, @RequestParam("pageNum") Integer pageNum, @RequestParam("categoryId") Integer categoryId) {
        log.info("当前页:{}   每页数量:{}   categoryId：{} ", page, pageNum, categoryId);
        Map<String, Object> map = new HashMap<>();
        List<Product> productList = new ArrayList<>();
        productList.add(new Product(1, "十四", 24.5, new Date()));
        productList.add(new Product(2, "十五", 25.5, new Date()));
        productList.add(new Product(3, "十六", 26.5, new Date()));
        map.put("row", productList);
        map.put("total", 50);
        return map;
    }
  }

ProductClient：springcloud_06category\src\main\java\com\xxx\feignclient\ProductClient.java

package com.xxx.feignclient;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

//调用商品服务接口
@FeignClient(value = "PRODUCT")//value:用来书写调用服务的id
public interface ProductClient {


   // 定义一个接口接收类型id类型参数，返回一个基于id查询的list对象,并返回分页信息
    @GetMapping("/productsPage")
    public Map<String, Object> finProductsByCategoryIdAndPage(@RequestParam("page") Integer page, @RequestParam("pageNum") Integer pageNum, @RequestParam("categoryId") Integer categoryId);
}

CategoryController：springcloud_06category\src\main\java\com\xxx\controller\CategoryController.java

package com.xxx.controller;

import com.xxx.feignclient.ProductClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CategoryController {
    private static final Logger log = LoggerFactory.getLogger(CategoryController.class);
    @Autowired
    private ProductClient productClient;

    @GetMapping("/category")
    public  Map<String, Object>  category() {
        log.info("进入类别服务....");
    	Map<String, Object> map = productClient.finProductsByCategoryIdAndPage(1, 10, 1);
        int total = (int) map.get("total");
        List<Product> row = (List<Product>) map.get("row");
        System.out.println(total);
        System.out.println(row);
        return map;
       
    }
}

访问：http://localhost:8787/category

CategoryController 查看打印的数据

9.3 细节

openfeign默认调用时间为1秒，超时报错，如下图。可以通过修改超时时间，处理.

路径：springcloud_06category\src\main\resources\application.yml

# 端口
server:
  port: 8787
spring:
  application:
    name: CATEGORY
  cloud:
    consul:
      host: localhost
      port: 8500
# 配置类别调用商品服务openfeign 默认 超时时间 默认1s 现在改为5秒。PRODUCT：指定的服务名称
feign:
  client:
    config:
      PRODUCT:
        connect-timeout: 5000
        read-timeout: 5000

你可能感兴趣的:(java,微服务,spring,cloud,学习,java)

情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
铭刻于星（四十二）随风至
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
腾讯云技术深度探索：构建高效云原生微服务架构我的运维人生云原生架构腾讯云运维开发技术共享
腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
2019-12-22-22:30 涓涓1016
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
阶段总结反思轻争
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
展现思维导图魅力，不断挖掘人生宝藏思维导图讲师Mandy
第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
xml解析小猪猪08 xml
1、DOM解析的步奏准备工作： 1.创建DocumentBuilderFactory的对象 2.创建DocumentBuilder对象 3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件 4.通过Document的getElem
每个开发人员都需要了解的一个SQL技巧 brotherlamp linux linux视频 linux教程 linux自学 linux资料
对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： CREATE TABLE books ( id &
Quartz——CronTrigger触发器 eksliang quartz CronTrigger
转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。二.Cron表达式介绍 1）Cron表达式规则表 Quartz
Informatica基础 18289753290 Informatica Monitor manager workflow Designer
1. 1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 2）Workflow Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 3）Workflow Monitor：监控Workflow和Session运行情况，生成日志和报告 4）Repository Manager：
linux下为程序创建启动和关闭的的sh文件，scrapyd为例酷的飞上天空 scrapy
对于一些未提供service管理的程序每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件下面以scrapy启动server为例，文件名为run.sh： #端口号，根据此端口号确定PID PORT=6800 #启动命令所在目录 HOME='/home/jmscra/scrapy/' #查询出监听了PORT端口
人--自私与无私永夜-极光
今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么? 从客观的角度来看,人有自私的行为,也有无私的
Ubuntu安装NS-3 环境脚本随便小屋 ubuntu
将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令： sudo ./ns3environment.sh >>result 这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示 com
创业的简单感受 aijuans 创业的简单感受
2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
如何经营自己的独立人脉 aoyouzi 如何经营自己的独立人脉
独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。以一个普通的银行柜员
JSP基础百合不是茶 jsp 注释隐式对象
1,JSP语句的声明 <%! 声明 %> 　　声明：这个就是提供java代码声明变量、方法等的场所。表达式 <%= 表达式 %> 　　这个相当于赋值，可以在页面上显示表达式的结果，程序代码段/小型指令　<% 程序代码片段 %> 2,JSP的注释
web.xml之session-config、mime-mapping bijian1013 java web.xml servlet session-config mime-mapping
session-config 1.定义： <session-config> <session-timeout>20</session-timeout> </session-config> 2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。 mime-mapping 1.定义： <mime-m
互联网开放平台（1） Bill_chen 互联网 qq 新浪微博百度腾讯
现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 1.淘宝开放平台(TOP) 网址：http://open.taobao.com/ 依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。目前TOP的三条主线： TOP访问网站：open.taobao.com ISV后台：my.open.ta
【MongoDB学习笔记九】MongoDB索引 bit1129 mongodb
索引可以在任意列上建立索引索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 使用索引可以加快查询,但同时会降低修改,插入等的性能内嵌文档照样可以建立使用索引测试数据 var p1 = { "name":"Jack", "age&q
JDBC常用API之外的总结白糖_ jdbc
做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。 ResultSetMetaData获取ResultSet对象的元数据信息
apache VelocityEngine使用记录 bozch VelocityEngine
VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。使用方法如下： VelocityEngine engine = new VelocityEngine();// 定义模板引擎 Properties properties = new Properties();// 模板引擎属
编程之美-快速找出故障机器 bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; public class TheLostID { /*编程之美假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。 1.假设在某个时间得到一个数据文件ID的列表，是
关于Java中redirect与forward的区别 chenbowen00 java servlet
在Servlet中两种实现： forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); redirect方式：response.sendRedirect(“/somePage.jsp”); forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
[信号与系统]人体最关键的两个信号节点 comsci 系统
如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做百汇穴, 另外一个节点在腰部,中医的名称叫做命门如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
oracle 存储过程执行权限 daizj oracle 存储过程权限执行者调用者
在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 CREATE OR REPLACE PROCEDURE TestProc IS fla
为mysql数据库建立索引 dengkane mysql 性能索引
前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
学习C语言常见误区如何看懂一个程序如何掌握一个程序以及几个小题目示例 dcj3sjt126com c 算法
如果看懂一个程序，分三步 1、流程 2、每个语句的功能 3、试数如何学习一些小算法的程序尝试自己去编程解决它，大部分人都自己无法解决如果解决不了就看答案关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义照着答案去敲调试错误
centos6.3安装php5.4报错 dcj3sjt126com centos6
报错内容如下: Resolving Dependencies --> Running transaction check ---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed --> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for
JSONP请求 flyer0126 jsonp
使用jsonp不能发起POST请求。 It is not possible to make a JSONP POST request. JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
Spring Security（03）——核心类简介 234390216 Authentication
核心类简介目录 1.1 Authentication 1.2 SecurityContextHolder 1.3 AuthenticationManager和AuthenticationProvider 1.3.1 &nb
在CentOS上部署JAVA服务 java--hhf java jdk centos Java服务
本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行第一步：卸载旧Linux自带的JDK ①查看本机JDK版本 java -version 结果如下 java version "1.6.0"
oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date] ldzyz007 oracle mysql SQL Server
oracle &n
记Protocol Oriented Programming in Swift of WWDC 2015 ningandjin protocol WWDC 2015 Swift2.0
其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭，把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS rensanning keepalived
（一）Keepalived （1）安装 # cd /usr/local/src # wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz # tar zxvf keepalived-1.2.15.tar.gz # cd keepalived-1.2.15 # ./configure # make &a
ORACLE数据库SCN和时间的互相转换 tomcat_oracle oracle sql
SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换；　　用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了；　　操作方法：　　1、通过dbms_f
Spring MVC 方法注解拦截器 xp9802 spring mvc
应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理先看一个实例,使用@access_required拦截： ?

19. SpringCloud学习笔记

1. 学习前言

1.1 学习前提

1.2 文章大纲

1.3 常见面试题

2. 微服务概述

2.1 什么是微服务？

2.2 微服务与微服务架构

2.3 微服务优缺点

2.4 微服务技术栈有那些？

2.5 为什么选择SpringCloud作为微服务架构

3. SpringCloud入门概述

3.1 SpringCloud是什么？

3.2 SpringCloud和SpringBoot的关系

3.3 Dubbo 和 SpringCloud技术选型

3.4 SpringCloud能干嘛？

3.5 SpringCloud下载

4. SpringCloud Rest学习环境搭建：服务提供者

4.1 介绍

4.2 SpringCloud版本选择

4.3 创建项目

1. 创建空项目

2. 创建父项目

4.4 链接数据库创建创建实例

4.4.1 springcloud-api 项目公共实体

4.4.2 springcloud-provider-dept-8001 创建服务的提供者maven项目

4.4.3 springcloud-consumer-dept-80 Rest环境搭建，服务消费者

5. Eureka服务注册中心

5.1 什么是Eureka

5.2 原理理解

5.3 构建步骤<以4.3为项目基础>

1. Eureka Server 的创建

2. Eureka Client的创建

3. Eureka 自我保护机制：好死不如赖活着

4. Eureka Server 集群搭建

6. consul 服务注册中心

1. consul Server 服务注册中心介绍和安装

2. consul client 服务客户端(微服务)

3. 新增model<以5.3为项目基础>

7. 服务间通信和RestTemplate的使用

1. 创建users Model<以6.3为项目基础>

2. 创建orders Model

8. Ribbon：负载均衡(基于客户端)

1.负载均衡以及Ribbon

2. Ribbon的服务调用说明

3. Ribbon的服务调用实例

1. DiscoveryClient 的实现

2. LoadBalancerClient 的实现

3. @LoadBalanced 的实现

9. OpenFeign：负载均衡(基于服务端)

9.1 简介

9.2 开发

1. 关闭所有服务

2. 开启consul ：consul agent -dev

3. 查看consul是否运行正常

4. 创建类别model->springcloud_06category

5. 创建产品model->springcloud_07product

6. 参数传递 对象和零散数据

1. 零散类型querySting

2. 零散类型 路由传参

3. 对象传递

7. 参数传递 数组和集合数据

1. 数组传递

2. 集合传递

8. 调用服务响应处理

1. 根据id查询对象信息

2. 根据id查询对象列表信息

3. 根据id查询对象列表信息分页

9.3 细节

你可能感兴趣的:(java,微服务,spring,cloud,学习,java)

2. 开启consul ：`consul agent -dev`

6. 参数传递对象和零散数据

2. 零散类型路由传参

7. 参数传递数组和集合数据