SpringCloud 学习笔记
SpringCloud 学习笔记
最开始新建一个新的maven项目，什么都不选，直接写名字就好,这里是 springloud
新建后，把 src 目录删除，在pom.xml文件导入依赖
<packaging>pompackaging>
<properties>
<junit.version>4.12junit.version>
properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-dependenciesartifactId>
<version>Hoxton.SR8version>
<type>pomtype>
<scope>importscope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-dependenciesartifactId>
<version>2.3.4.RELEASEversion>
<type>pomtype>
<scope>importscope>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.46version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
<version>1.1.20version>
dependency>
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>2.1.3version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>${junit.version}version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.12version>
dependency>
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.17version>
dependency>
<dependency>
<groupId>ch.qos.logbackgroupId>
<artifactId>logback-coreartifactId>
<version>1.2.3version>
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>
<dependency>
<groupId>com.wbqgroupId>
<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-testartifactId>
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>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-eurekaartifactId>
<version>1.4.6.RELEASEversion>
dependency>
dependencies>
3.配置application.yml
server:
port: 8001
#mybatis配置
mybatis:
type-aliases-package: com.wbq.springcloud.pojo
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml
#spring 的配置
spring:
application:
name: springcloud-provider-dept
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: org.gjt.mm.mysql.Driver
url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8
username: root
password: root
目录结构
4.在resources目录下新建mybatis-config.xml
<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 {
@Autowired
private 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 {
@Autowired
private 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
<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.导入依赖
<dependencies>
<dependency>
<groupId>com.wbqgroupId>
<artifactId>springcloud-apiartifactId>
<version>1.0-SNAPSHOTversion>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
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
@Bean
public 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 responseType)
@Autowired
private 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项目后导入依赖
<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>springcloudartifactId>
<groupId>com.wbqgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>springcloud-eurka-7001artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-eureka-serverartifactId>
<version>1.4.6.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
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-spring
company.name: blog.wbqstudy.com
5.DeptController
1.添加注解
//获取一些配置的信息，得到具体的微服务
@Autowired
private DiscoveryClient client;
2. 添加类 8001
//注册进来的微服务~，获取一些消息
@GetMapping("/dept/discovery")
public Object discovery(){
//获取微服务列表的清单
List<String> service = client.getServices();
System.out.println("discovery => service:" + service);
//得到一个具体的微服务信息,通过具体的微服务 Id ，applicationName
List<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-spring
company.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 -->
org.springframework.cloud
spring-cloud-starter-ribbon
1.4.6.RELEASE
<!-- erueka -->
org.springframework.cloud
spring-cloud-starter-eureka
1.4.6.RELEASE
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 //Ribbon
public 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
id
instance:
instance-id: springcloud-provider-dept8002 #修改eureka 上的默认描述信息
4.把8001的java文件都复制过去8001/8002，还有启动类，启动类记得改名字
5.启动访问80服务，
每次刷新的数据都不一样，轮流3个服务器的访问，负载均衡
三个服务，去实现负载均衡
八。自定义负载均衡规则
AvailabilityFilteringRule : 会先过滤掉挂掉的服务，或者说跳闸的服务，访问故障的服务 ~ ，对剩下的进行轮询
//IRule
//过滤已经崩溃的服务
// RoundRobinRule 轮询
// RandomRule 随机
// RetryRule ：会先按照轮询获取服务~ ，如果服务获取失败，则会在指定的时间内进行重试
// AvailabilityFilteringRule : 会先过滤掉挂掉的服务，或者说跳闸的服务，访问故障的服务 ~ ，对剩下的进行轮询
1.在80服务上添加一个随机规则的Bean，体验一下，获取服务会随机获取，没有规律
@Bean
public 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+1
private 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
@Bean
public 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依赖文件加入依赖
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-feignartifactId>
<version>1.4.6.RELEASEversion>
dependency>
8.在springcloud-api项目的pom依赖文件加入依赖
<dependency>
<groupId>org.springframework.cloudgroupId>
<artifactId>spring-cloud-starter-feignartifactId>
<version>1.4.6.RELEASEversion>
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 {
@Autowired
private 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
就完成了