SpringCloud 学习笔记

最开始新建一个新的maven项目，什么都不选，直接写名字就好,这里是 springloud

新建后，把 src 目录删除，在pom.xml文件导入依赖

<!-- 打包方式 pom --><packaging>pom</packaging><properties><junit.version>4.12</junit.version></properties><dependencyManagement><dependencies><!-- spring-cloud依赖 --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-dependencies</artifactId><version>Hoxton.SR8</version><type>pom</type><scope>import</scope></dependency><!-- SpringBoot依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>2.3.4.RELEASE</version><type>pom</type><scope>import</scope></dependency><!-- 数据库依赖 --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.46</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.20</version></dependency><!-- SpringBoot启动器 --><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.3</version></dependency><!-- junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version></dependency><!-- lombok --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.12</version></dependency><!-- log4j --><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId><version>1.2.3</version></dependency></dependencies></dependencyManagement>

一、springcloud-api ~Module

1.新建Module~~ springcloud-api

2.导入依赖

<artifactId>springcloud-api</artifactId><!-- 当前的Module自己需要的依赖，如果父依赖中已经配置了版本，然后这里就不用写了 --><dependencies><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency></dependencies>

3.写目录 + 实体类

目录结构

Dept.java

package com.wbq.springcloud.pojo;import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;import java.io.Serializable;@Data
@NoArgsConstructor
@Accessors( chain = true)  //链式写法public class Dept implements Serializable {private Long deptno;private  String dname;//这个数据存在哪个数据库的字段 ~ 微服务，一个服务对应一个数据库，同一信息可能存在不同的数据库private String db_source;public Dept(String dname) {this.dname = dname;}/*链式写法Dept dept = new Dept();dept.setDeptNo(11).setDname('sss').setDb_source('001');*/
}

二、springcloud-provider-dept-8001 ~Module

1.在主项目下，右键新建moodule ~~ springcloud-provider-dept-8001

2.导入依赖 ~pom.xml

<dependencies><!-- 要拿到实体类，所以需要配置api module --><dependency><groupId>com.wbq</groupId><artifactId>springcloud-api</artifactId><version>1.0-SNAPSHOT</version></dependency><!-- junit --><dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId></dependency><!-- test --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-test</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- jetty --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jetty</artifactId></dependency><!-- 热部署工具 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency><!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.4.6.RELEASE</version></dependency></dependencies>

3.配置application.yml

server:port: 8001#mybatis配置
mybatis:type-aliases-package: com.wbq.springcloud.pojoconfig-location: classpath:mybatis/mybatis-config.xmlmapper-locations: classpath:mybatis/mapper/*.xml#spring 的配置spring:application:name: springcloud-provider-deptdatasource:type: com.alibaba.druid.pool.DruidDataSourcedriver-class-name: org.gjt.mm.mysql.Driverurl: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8username: rootpassword: root

目录结构

4.在resources目录下新建mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration ><settings><!-- 开启二级缓存 --><setting name="cacheEnabled" value="true"/></settings>
</configuration>

5.在springcloud目录下新建3个目录

**controller,dao,service,启动类DeptProvider_8001**

5.1 dao ~~DeptDao接口

package com.wbq.springcloud.dao;import com.wbq.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;import java.util.List;@Mapper
@Repository
public interface DeptDao {public boolean addDept(Dept dept);public Dept queryById(Long id);public List<Dept> queryAll();
}

5.2 service 目录

**DeptService**

package com.wbq.springcloud.service;import com.wbq.springcloud.pojo.Dept;import java.util.List;public interface DeptService {public boolean addDept(Dept dept);public Dept queryById(Long id);public List<Dept> queryAll();
}

DeptServiceImpl

package com.wbq.springcloud.service;import com.wbq.springcloud.dao.DeptDao;
import com.wbq.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 {@Autowiredprivate DeptDao deptDao;public boolean addDept(Dept dept) {return deptDao.addDept(dept);}public Dept queryById(Long id) {return deptDao.queryById(id);}public List<Dept> queryAll() {return deptDao.queryAll();}
}

5.3controller目录

**DeptController**

package com.wbq.springcloud.controller;import com.wbq.springcloud.pojo.Dept;
import com.wbq.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestController
public class DeptController {@Autowiredprivate DeptService deptService;@PostMapping("/dept/add")public boolean addDept(Dept dept){return deptService.addDept(dept);}@GetMapping ("/dept/get/{id}")public Dept get(@PathVariable("id")Long id){return deptService.queryById(id);}@GetMapping("/dept/list")public List<Dept> queryAll(){return deptService.queryAll();}}

5.4启动类 ~~DeptProvider_8001

package com.wbq.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,args);}
}

6.在resources/mybatis目录下新建mapper目录

DeptMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.wbq.springcloud.dao.DeptDao"><insert id="addDept" parameterType="Dept">insert into dept (dname,db_source)values (#{dname},DATABASE())</insert><select id="queryById" resultType="Dept" parameterType="Long">select * from dept where deptno = #{deptno};</select><select id="queryAll" resultType="Dept" >select * from dept;</select></mapper>

三、新建mudule —springcloud-consumer-dept-80 ~~module

1.导入依赖

<!-- 实体类+web --><dependencies><dependency><groupId>com.wbq</groupId><artifactId>springcloud-api</artifactId><version>1.0-SNAPSHOT</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- 热部署工具 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency></dependencies>

2.配置端口号

server:port: 80

3.config 目录下新建ConfigBean.java

package com.wbq.springcloud.config;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;@Configuration
public class ConfigBean { //@Configuration相当于Spring applicationContext.xml@Beanpublic RestTemplate getRestemplate(){return new RestTemplate();}}

4.controler下面新建DeptConsumerController.java

package com.wbq.springcloud.controller;import com.wbq.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
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层 ~//RestFull//RestTemplate ... 供我们直接调用就可以了！ 注册到Spring 中//（url,实体：map ,Class<T> responseType)@Autowiredprivate RestTemplate restTemplate; //提供多种便捷访问远程 http 服务的方法，简单的Restful服务模板 ~private static final String REST_URL_PREFIX = "http://localhost:8001";@RequestMapping("/consumer/dept/add")public  boolean add(Dept dept){return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);}@RequestMapping("/consumer/dept/get/{id}")public Dept get(@PathVariable("id") Long id){return restTemplate.getForObject(REST_URL_PREFIX +"/dept/get/"+id,Dept.class);}@RequestMapping("/consumer/dept/list")public List<Dept> list(){return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);}}

5.配置启动类 DeptConsumer_80.java

package com.wbq.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);}
}

四、新建module ~~ springcloud-eurka-7001

1.新建空的maven项目后导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><parent><artifactId>springcloud</artifactId><groupId>com.wbq</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><artifactId>springcloud-eurka-7001</artifactId><!-- 导包 --><dependencies><!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka-server</artifactId><version>1.4.6.RELEASE</version></dependency><!-- 热部署工具 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency></dependencies></project>

2.application.yml 配置

server:port: 7001#Eureka 配置
eureka:instance:hostname: localhost  #Eureka 服务端的实例名称client:register-with-eureka: false  #表示是否向eureka注册中心注册自己fetch-registry: false  #表示如果为false，则表示自己为注册中心service-url:  #监控页面 ~defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

3.springcloud-provider-dept-8001 ~~module的配置yml中加上

#Eureka 的配置，服务注册到哪里
eureka:client:service-url:defaultZone: http://localhost:7001/eureka/

DeptProvider_8001启动类加注解 ~~ @EnableEurekaClient

package com.wbq.springcloud;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;@SpringBootApplication
@EnableEurekaClient   //在服务启动后自动注册到eureka 中
public class DeptProvider_8001 {public static void main(String[] args) {SpringApplication.run(DeptProvider_8001.class,args);}
}

4. 继续在springcloud-provider-dept-8001 yml文件加

#Eureka 的配置，服务注册到哪里
eureka:client:service-url:defaultZone: http://localhost:7001/eureka/instance:instance-id: springcloud-provider-dept8001   #修改eureka 上的默认描述信息#info配置 ,点击描述可以看到的信息
info:app.name: wbq-springcompany.name: blog.wbqstudy.com

5.DeptController

1.添加注解

//获取一些配置的信息，得到具体的微服务@Autowiredprivate DiscoveryClient client;

2. 添加类 8001

//注册进来的微服务~，获取一些消息@GetMapping("/dept/discovery")public Object discovery(){//获取微服务列表的清单List<String> service = client.getServices();System.out.println("discovery => service:" + service);//得到一个具体的微服务信息,通过具体的微服务 Id ，applicationNameList<ServiceInstance> instances = client.getInstances("S");for (ServiceInstance instance : instances) {System.out.println(instance.getHost()+"\t"+instance.getPort()+"\t"+instance.getUri()+"\t"+instance.getServiceId());}return  this.client;}

启动类加注解： @EnableDiscoveryClient //服务发现

五、新注册了springcloud-eurka-7002和7003两个module

1.跟7001一样的，除了端口不一样

1.在7001 的 yml 配置文件注册 7002

2.更改 7001 的 yml 配置

#Eureka 配置
eureka:instance:hostname: localhost  #Eureka 服务端的实例名称client:register-with-eureka: false  #表示是否向eureka注册中心注册自己fetch-registry: false  #表示如果为false，则表示自己为注册中心service-url:  #监控页面 ~#单机  defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/#集群（关联）：defaultZone: http://locahost:7002/eureka/

3.更改 7002 的 yml 配置

#Eureka 配置
eureka:instance:hostname: localhost  #Eureka 服务端的实例名称client:register-with-eureka: false  #表示是否向eureka注册中心注册自己fetch-registry: false  #表示如果为false，则表示自己为注册中心service-url:  #监控页面 ~defaultZone: http://eureka7001/eureka/

2.这样就把 7001 和 7002 关联起了

3.再在 7001 yml 的配置加上 7003

1.这样7001 和 7003 也关联起来了

#集群（关联）：defaultZone: http://locahost:7002/eureka/,http://locahost:7003/eureka/

4.在 7002 的 yml 配置中关联上7001和7003

#集群（关联）：defaultZone: http://locahost:7001/eureka/,http://locahost:7003/eureka/

5.在 7003 的yml 配置中关联7001和7002

#集群（关联）：defaultZone: http://locahost:7001/eureka/,http://locahost:7003/eureka/

这样就实现了下面的效果，三个关联起来了

6.更改 8001 的 yml 配置文件 : defaultZone:

#Eureka 的配置，服务注册到哪里
eureka:client:service-url:defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/instance:instance-id: springcloud-provider-dept8001   #修改eureka 上的默认描述信息#info配置 ,点击描述可以看到的信息
info:app.name: wbq-springcompany.name: blog.wbqstudy.com

三个都注册

7.注意

在本机的 C:\Windows\System32\drivers\etc 目录下 hosts 文件下添加：

127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com
127.0.0.1 eureka7003.com

这样才有效果，这样做是做3个假的域名

没有这个域名，好像是不生效，我的加了这个假域名才生效

效果图如下：

访问7001 、7002、 7003 都有圈出来的，不用假域名，是不会显示的
.

六、Ribbon

1.在80 服务上的 pom.xml文件添加依赖

<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-ribbon</artifactId><version>1.4.6.RELEASE</version></dependency><!-- erueka --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.4.6.RELEASE</version></dependency>

2.80服务器 yml加上配置

#负载均衡配置
#Euraka
eureka:client:register-with-eureka: false   #不像euraka中注册自己#实现随机选择一个服务，实现负载均衡service-url:defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

3.在 ConfigBean 上更改，加上一个注解 @LoadBalanced

@Configuration
public class ConfigBean { //@Configuration相当于Spring applicationContext.xml//配置负载均衡实现RestTemplate@Bean@LoadBalanced  //Ribbonpublic RestTemplate getRestemplate(){return new RestTemplate();}}

4.变更 DeptConsumerController 的 private static final String REST_URL_PREFIX

 //Ribbon，我们这里的地址，应该是一个变量，通过服务名来访问//private static final String REST_URL_PREFIX = "http://localhost:8001";private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

5.80启动类加 @EnableEurekaClient //客户端

@EnableEurekaClient  //客户端

七.添加 springcloud-provider-dept-8002和8003服务

1.8002和8003

1.复制8001服务的全部依赖过8002和8003

2.复制8001的yml过8002和8003

3.更改地方

服务端口

server:port: 8002

数据库名称
url: jdbc:mysql://localhost:3306/db02

instance:instance-id: springcloud-provider-dept8002   #修改eureka 上的默认描述信息

4.把8001的java文件都复制过去8001/8002，还有启动类，启动类记得改名字

5.启动访问80服务，

每次刷新的数据都不一样，轮流3个服务器的访问，负载均衡

三个服务，去实现负载均衡

八。自定义负载均衡规则

AvailabilityFilteringRule : 会先过滤掉挂掉的服务，或者说跳闸的服务，访问故障的服务 ~ ，对剩下的进行轮询

//IRule
//过滤已经崩溃的服务
// RoundRobinRule 轮询
// RandomRule 随机
// RetryRule ：会先按照轮询获取服务~ ，如果服务获取失败，则会在指定的时间内进行重试
// AvailabilityFilteringRule : 会先过滤掉挂掉的服务，或者说跳闸的服务，访问故障的服务 ~ ，对剩下的进行轮询

1.在80服务上添加一个随机规则的Bean，体验一下，获取服务会随机获取，没有规律

@Beanpublic IRule myRule(){return new RandomRule();}

2.进入主题，在80服务上新建一个myrule文件，不能跟启动类同级，会扫描到，在启动类的上一级目录新建

1.然后在myrule文件下，新建WbqRule.java，注册组件

引入注解： @Configuration
在80服务启动类加入注解 : @RibbonClient(name = “SPRINGCLOUD-PROVIDER-DEPT”,configuration = WbqRule.class)
在微服务启动的时候就能去加载我们自定义的Ribbon类

//在微服务启动的时候就能去加载我们自定义的Ribbon类
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = WbqRule.class)

上面的注解的 name 是：
在80服务的config 新增的那个随机数Bean的位置Ctrl+鼠标左键，进去后，全部复制，在myrule文件夹复制，生成新的一个类，再更改名字，WbqRandomRule,删除刚刚复制的那个，有这个就好了

2.WbqRandomRule.java源代码，有修改


package com.wbq.myrule;import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;import java.util.List;
import java.util.concurrent.ThreadLocalRandom;public class WbqRandomRule extends AbstractLoadBalancerRule {//每个服务，访问5次~ ， 换下一个服务（3个）//total=0, 默认=0，如果=5， 我们指向下一个服务节点//index=0, 默认=0，如果total=5, index+1private int total = 0; //被调用的次数private int currentIndex = 0;   //当前是谁在提供服务~@SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})public Server choose(ILoadBalancer lb, Object key) {if (lb == null) {return null;} else {Server server = null;while(server == null) {if (Thread.interrupted()) {return null;}List<Server> upList = lb.getReachableServers(); //获得或者的服务List<Server> allList = lb.getAllServers();  //获得全部的服务int serverCount = allList.size();if (serverCount == 0) {return null;}//                int index = this.chooseRandomInt(serverCount);  //生成区间随机数
//                server = (Server)upList.get(index);  //从或者的服务中随机获取一个~//-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++if(total<5){server = upList.get(currentIndex);total++;}else {total = 0;currentIndex++;if (currentIndex>upList.size()){currentIndex = 0;}server = upList.get(currentIndex);  //从活着的服务中，获取指定的服务来进行操作}//-================================================================if (server == null) {Thread.yield();} else {if (server.isAlive()) {return server;}server = null;Thread.yield();}}return server;}}protected int chooseRandomInt(int serverCount) {return ThreadLocalRandom.current().nextInt(serverCount);}public Server choose(Object key) {return this.choose(this.getLoadBalancer(), key);}public void initWithNiwsConfig(IClientConfig clientConfig) {}
}

3.更换 ConfigBean 下面的 myRule 下面的 return new WbqRandomRule();换回来我们刚刚写的那个java

    @Beanpublic IRule myRule(){return new WbqRandomRule();  //默认是轮询，现在我们自定义为~ WbqRandomRule}

现在访问的话，就会进行每5个轮询，进入负载均衡

3.Ribbon就到此结束了

持续更新中。。。

4.Feign负载均衡(和Ribbon一样负载均衡，哪个都可以)

1.在springcloud-api项目上建文件夹service

2.建立一个新的项目，springcloud-consumer-dept-feign

1.建立目录com.wbq.springcloud

2.把80端口的3个目录内容复制过来config、controller、DeptConsumer_80

3.把80项目的pom依赖导入进来

4.导入80项目yml配置文件application.yml

5.改一下Feign项目的启动类

package com.wbq.springcloud;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;//Ribbon 和 Eureka 整合以后，客户端可以直接调用，不用关心 IP 地址和端口号
@SpringBootApplication
@EnableEurekaClient  //客户端
public class FeignDeptConsumer_80 {public static void main(String[] args) {SpringApplication.run(FeignDeptConsumer_80.class,args);}
}

6。在springcloud-api项目的service建立DeptClientService接口

package com.wbq.springcloud.service;import com.wbq.springcloud.pojo.Dept;public interface DeptClientService {public Dept queryById();public Dept queryAll();public Dept addDept(Dept dept);
}

7.在Feign项目的pom.xml依赖文件加入依赖

<!-- Feign --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-feign</artifactId><version>1.4.6.RELEASE</version></dependency>

8.在springcloud-api项目的pom依赖文件加入依赖

<!-- Feign --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-feign</artifactId><version>1.4.6.RELEASE</version></dependency>

9.在springcloud-api项目的service的DeptClientService接口加入注解 @FeignClient(value = “SPRINGCLOUD-PROVIDER-DEPT”)

这里的SPRINGCLOUD-PROVIDER-DEPT是在这里拿的

找到这个东西进行负载均衡 “SPRINGCLOUD-PROVIDER-DEPT“

这样接口就直接写到这里，不用些其他地方了，方便

package com.wbq.springcloud.service;import com.wbq.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {@GetMapping("/dept/get/{id}")public Dept queryById(@PathVariable("id") Long id);@GetMapping("/dept/list")public Dept queryAll();@GetMapping("/dept/add")public Dept addDept(Dept dept);
}

3.现在就可以去Feign项目中调用了

1.Feign项目Controller目录的DeptConsumerController

删除
//Ribbon，我们这里的地址，应该是一个变量，通过服务名来访问
//private static final String REST_URL_PREFIX = “http://localhost:8001”;
private static final String REST_URL_PREFIX = “http://SPRINGCLOUD-PROVIDER-DEPT”;

2.先去springcloud-api项目中的Service下面的DeptClientService接口加入注解 @Component

把DeptClientService注册到spring里面去

3. 在Feign项目Controller目录的DeptConsumerController加入

该删除的删除，就剩现在的代码

package com.wbq.springcloud.controller;import com.wbq.springcloud.pojo.Dept;
import com.wbq.springcloud.service.DeptClientService;
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 {@Autowiredprivate DeptClientService service = null;@RequestMapping("/consumer/dept/add")public  boolean add(Dept dept){}@RequestMapping("/consumer/dept/get/{id}")public Dept get(@PathVariable("id") Long id){}@RequestMapping("/consumer/dept/list")public List<Dept> list(){}}

这里的private DeptClientService service = null; 是因为没有实现类，所以等于null

在第一个方法中调用接口，

@RequestMapping("/consumer/dept/add")public  boolean add(Dept dept){return this.service.addDept(dept);}

这里会报错，以为返回的是一个布尔值，所以要去springcloud-api项目中的那个接口中改，

 @GetMapping("/dept/add")public boolean addDept(Dept dept);

后面的一样

 @RequestMapping("/consumer/dept/get/{id}")public Dept get(@PathVariable("id") Long id){return this.service.queryById(id);}@RequestMapping("/consumer/dept/list")public List<Dept> list(){return this.service.queryAll();}

这里会报错，以为前面的那个接口，不是List < Dept >,需要去改

4. 这样的代码就很简洁，看起来很清爽

不想RIbbon一样那么多，比如看下面，就会很多，看起来不简洁清爽

就像这句话说得一样

5.Feign启动类加入注解，

@EnableFeignClients(basePackages = {“com.wbq.springcloud”}
作用是去扫描包

@ComponentScan(“com.wbq.springcloud”)
作用是扫描注解

红色下划线不用管，项目跑起来没问题

这样就完成了feign的负载均衡了
启动7001,8001,8002，feign服务测试一下
http://localhost/consumer/dept/list
就完成了