一、spring cloud简介
spring cloud 为开发人员提供了快速构建分布式系统的一些工具,包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。它运行环境简单,可以在开发人员的电脑上跑。另外说明spring cloud是基于springboot的,所以需要开发中对springboot有一定的了解,另外对于“微服务架构” 不了解的话,可以通过搜索引擎搜索“微服务架构”了解下。
二、创建服务注册中心
在这里,我们需要用的的组件上Spring Cloud Netflix的Eureka ,eureka是一个服务注册和发现模块。
2.1 首先创建一个maven主工程。
New Maven Project:过程就不截图了 直接上pom.xml
<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.0</modelVersion>
<groupId>spring-cloud</groupId>
<artifactId>spring-cloud</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<jdk.version>1.8</jdk.version>
<maven-compiler-plugin.version>3.1</maven-compiler-plugin.version>
<maven-resources-plugin.version>2.6</maven-resources-plugin.version>
<org.mybatis.generator.version>1.3.2</org.mybatis.generator.version>
<mybatis.version>3.1.1</mybatis.version>
<mybatis-spring.version>1.2.0</mybatis-spring.version>
<dubbo.version>2.4.9</dubbo.version>
<zookeeper.version>3.4.5</zookeeper.version>
<zkclient.version>0.1</zkclient.version>
<com.alibaba.druid.version>0.2.6</com.alibaba.druid.version>
<commons.version>3.2.1</commons.version>
</properties>
<!-- springboot使用1.4.1.RELEASE版本 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.3.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>${commons.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<configuration>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
<modules>
<module>spring-ykf-eureka-server</module>
<module>spring-ykf-eureka-provide</module>
<module>spring-ykf-eureka-consume</module>
<module>spring-ykf-eureka-provide1</module>
</modules>
</project>
然后在这个Project下面新建4个Module
分别是:<1> spring-ykf-eureka-server 服务注册中心 目录结构如下
EureKaServcerMasterApplication.java
package spring.cloud.eureka.server.main;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
//标明当前是 注册中
@EnableEurekaServer
// 标明是springboot项目
@SpringBootApplication
public class EureKaServcerMasterApplication {
public static void main(String[] args) {
System.err.println("EureKaServcerMasterApplication Service Strat Success!");
SpringApplication.run(EureKaServcerMasterApplication.class, args);
}
}
application.properties
spring.application.name=spring-ykf-eureka-server
server.port=10001
eureka.client.register-with-eureka=false#由于我们目前创建的应用是一个服务注册中心,而不是普通的应用,默认情况下,这个应用会向注册中心(也是它自己)注册它自己,设置为false表示禁止这种默认行为
eureka.client.fetch-registry=false#,表示不去检索其他的服务,因为服务注册中心本身的职责就是维护服务实例,它也不需要去检索其他服务
eureka.client.service-url.defaultZone=http://localhost:10001/eureka
pom.xml
<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.0</modelVersion>
<parent>
<groupId>spring-cloud</groupId>
<artifactId>spring-cloud</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>spring-ykf-eureka-server</groupId>
<artifactId>spring-ykf-eureka-server</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- 注册中 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>
<!-- 安全依赖 需要登录才能查看控制界面 -->
<!-- <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency> -->
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Dalston.SR3</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
然后就可以先测试一下了 启动EureKaServcerMasterApplication main localhost:10001访问界面如下:
标红的那一行是没有 发现服务的,继续撸代码 编写
spring-ykf-eureka-provide 服务提供者 目录结构如下:
EurekaProvideApp.java
package spring.cloud.ykf.eureka.provide.main;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
//标明是服务提供者
@EnableEurekaClient
// springboot项目
@SpringBootApplication
public class EurekaProvideApp {
public static void main(String[] args) {
System.err.println("EurekaProvideApp Service Strat Success!");
SpringApplication.run(EurekaProvideApp.class, args);
}
}
TestController.java
package spring.cloud.ykf.eureka.provide.main.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@GetMapping(value = "/aa")
public String aa() {
return "aa";
}
}
application.properties
spring.application.name=spring-ykf-eureka-provide
server.port=20001
eureka.client.service-url.defaultZone=http://localhost:10001/eureka/
pom.xml
<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.0</modelVersion>
<parent>
<groupId>spring-cloud</groupId>
<artifactId>spring-cloud</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>spring-ykf-eureka-provide</groupId>
<artifactId>spring-ykf-eureka-provide</artifactId>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- 服务提供 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Dalston.SR3</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
其实到了这里就可以 启动main 运行测试了:
服务已经被注册到 注册中心了,测试一下吧当前这个服务自己访问自己的时候通不通
接下继续撸代码,服务消费者:
spring-ykf-eureka-consume目录结构如下:
EurekaConsumeApp.java
package spring.cloud.ykf.eureka.consume.main;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
//标明是服务提供者
@EnableEurekaClient
// springboot项目
@SpringBootApplication
public class EurekaConsumeApp {
@Bean
@LoadBalanced//实现负载均衡
RestTemplate restTemplate() {
return new RestTemplate();
}
public static void main(String[] args) {
System.err.println("EurekaConsumeApp Service Strat Success!");
SpringApplication.run(EurekaConsumeApp.class, args);
}
}
TestController.java
package spring.cloud.ykf.eureka.consume.main.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.client.RestTemplate;
@Controller
@Configuration
public class TestController {
@Autowired
private RestTemplate restTemplate;
@GetMapping(value = "/aa")
@ResponseBody
public String add() {
return restTemplate.getForEntity("http://spring-ykf-eureka-provide/aa/", String.class).getBody();
}
}
application.properties
spring.application.name=spring-ykf-eureka-consume
server.port=30001
eureka.client.service-url.defaultZone=http://localhost:10001/eureka/
pom.xml
<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.0</modelVersion>
<parent>
<groupId>spring-cloud</groupId>
<artifactId>spring-cloud</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>spring-ykf-eureka-consume</groupId>
<artifactId>spring-ykf-eureka-consume</artifactId>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- 服务提供 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<!-- 负载均衡 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-ribbon</artifactId>
</dependency>
<!-- 提供web服务 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Dalston.SR3</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
然后 启动注册中心的main 服务提供者的main 然后在是服务消费者的main 在去查看服务注册中:
多出来一个服务,然后继续访问 服务消费的者的url调用看是否能 连通
到这里一个简单的 服务注册中心 服务提供 服务消费就完事了, 下面开始继续撸代码 实现 数据库 增删查改
这里首先开始改造 服务提供spring-ykf-eureka-provide
1:首先在原来的pom.xml基础之上在添加新的依赖:
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.8</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.1</version>
</dependency>
2:application.properties 也得改造 原来的基础上加上
#db
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=1234
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
mybatis.mapper-locations=classpath*:/mybatis-mapping/*Mapper.xml
# Specify the DBMS
spring.jpa.database = MYSQL
# Show or not log for each sql query
spring.jpa.show-sql = true
3:在原来的启动类:EurekaProvideApp.java上面加入注解
package spring.cloud.ykf.eureka.provide.main;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
//标明是服务提供者
@EnableEurekaClient
// springboot项目
@SpringBootApplication
@MapperScan("spring.cloud.ykf.eureka.provide.main.mapper")
public class EurekaProvideApp {
public static void main(String[] args) {
System.err.println("EurekaProvideApp Service Strat Success!");
SpringApplication.run(EurekaProvideApp.class, args);
}
}
4:新建一个Userservice
package spring.cloud.ykf.eureka.provide.main.service;
import spring.cloud.ykf.eureka.provide.main.entry.User;
public interface UserService {
User findUser(Integer id);
int saveUser(User user);
int deleteUser(Integer id);
}
5:实现类
package spring.cloud.ykf.eureka.provide.main.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import spring.cloud.ykf.eureka.provide.main.entry.User;
import spring.cloud.ykf.eureka.provide.main.mapper.UserMapper;
import spring.cloud.ykf.eureka.provide.main.service.UserService;
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserMapper userMapper;
@Override
public User findUser(Integer id) {
return this.userMapper.findUser(id);
}
@Override
public int saveUser(User user) {
this.userMapper.saveUser(user);
return 1;
}
@Override
public int deleteUser(Integer id) {
this.userMapper.deleteUser(id);
return 1;
}
}
6:UserMapper
package spring.cloud.ykf.eureka.provide.main.mapper;
import spring.cloud.ykf.eureka.provide.main.entry.User;
public interface UserMapper {
User findUser(Integer id);
int saveUser(User user);
int deleteUser(Integer id);
}
7:然后是mybatis的 mapper文件
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="spring.cloud.ykf.eureka.provide.main.mapper.UserMapper">
<select id="findUser" parameterType="integer"
resultType="spring.cloud.ykf.eureka.provide.main.entry.User">
select *
from user where id = #{id}
</select>
<insert id="saveUser" parameterType="spring.cloud.ykf.eureka.provide.main.entry.User">
insert into user(uname,pwd)
values(#{uname},#{pwd})
</insert>
<delete id="deleteUser" parameterType="integer">
delete from user where id
= #{id}
</delete>
</mapper>
8:然后在是 controller控制层
package spring.cloud.ykf.eureka.provide.main.controller;
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 spring.cloud.ykf.eureka.provide.main.entry.User;
import spring.cloud.ykf.eureka.provide.main.service.UserService;
/**
*/
@RestController
public class UserController {
@Autowired
UserService userService;
@RequestMapping(value = "/query/{id}")
public User findByIdUser(@PathVariable("id") Integer id) {
User us = userService.findUser(id);
return us;
}
@RequestMapping(value = "/del/{id}")
public String delUser(@PathVariable("id") Integer id) {
int num = userService.deleteUser(id);
return num == 1 ? "succ" : "err";
}
@RequestMapping(value = "/save/{uname}/{pwd}")
public String delUser(@PathVariable("uname") String uname, @PathVariable("pwd") String pwd) {
User user = new User();
user.setPwd(pwd);
user.setUname(uname);
int num = userService.saveUser(user);
return num == 1 ? "succ" : "err";
}
}
好了 到这里 就可以 进行一下测试了,先启动注册中心 在启动服务提供效果如下:
这说明当前这个服务通过mybatis进行数据库交互是正常的.可以正常提供服务 继续撸代码 改造服务消费者:
spring-ykf-eureka-consume
增加controller
UserController.java
package spring.cloud.ykf.eureka.consume.main.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.client.RestTemplate;
import spring.cloud.ykf.eureka.consume.main.entry.User;
/**
* Created by majunwei on 2017/10/10.
*/
@Controller
@Configuration//说明当前这是个配置类 如果不写下面restTemplate调用的时候会告诉你找不到指定的服务的
public class UserController {
@Autowired
private RestTemplate restTemplate;
@GetMapping(value = "/query/{id}")
@ResponseBody
public User add(@PathVariable("id") Integer id) {
return restTemplate.getForEntity("http://spring-ykf-eureka-provide/query/{id}", User.class, id).getBody();
}
@GetMapping(value = "/del/{id}")
@ResponseBody
public String del(@PathVariable("id") Integer id) {
return restTemplate.getForEntity("http://spring-ykf-eureka-provide/del/{id}", String.class, id).getBody();
}
@GetMapping(value = "/save/{id}")
@ResponseBody
public String save(@PathVariable("uname") String uname, @PathVariable("pwd") String pwd) {
return restTemplate
.getForEntity("http://spring-ykf-eureka-provide/save/{uname}/{pwd}", String.class, uname, pwd)
.getBody();
}
}
然后依次启动main 访问30001的url 结果如下
好了到这里 一个简单的 springcloud springboot mybatis mysql进行微服务开发就完成了
这里要说明上面 服务消费者main 里面的一个注解
@LoadBalanced 实现负载均衡
其实如果你是从上面依次看下来的 你会发现我少了一个 spring-ykf-eureka-provide1
对你们这边就自己 底下实现了吧 直接复制spring-ykf-eureka-provide 他把端口号改一下就行了 然后启动
然后再去 注册中心看的时候你会发现 如图:
一模一样 的服务多了一个 只是端口不一样 ,然后服务消费方 调用的时候 会根据负载均衡 随机调用这2个当中的一个, 你们可以试着关掉一个 消费方还是可以正常调用的,其实注册中心也是可以实现集群的 道理跟服务提供 差不多.
上面有什么不明白的 可以邮件:[email protected]一起讨论,我也是刚开始学习springcloud.
下面是整个案例的源码:https://download.csdn.net/download/wangbo54979/10375723
上面负载均衡采用的是ribbon 下面在补充一点用feign做负载均衡
直接更改上面spring-ykf-eureka-consume 消费者 其他的都不用动
在消费的pom.xml 增加feign的 依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-feign</artifactId>
</dependency>
在main启动类 上添加feign 注解
@EnableEurekaClient
// springboot项目
@SpringBootApplication
@EnableFeignClients
public class EurekaConsumeApp {
public static void main(String[] args) {
System.err.println("EurekaConsumeApp Service Strat Success!");
SpringApplication.run(EurekaConsumeApp.class, args);
}
}
然后继续 定义一个接口
package spring.cloud.ykf.eureka.consume.main.service;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import spring.cloud.ykf.eureka.consume.main.entry.User;
//直接在这里 指明我要调用哪个服务
@FeignClient(name = "spring-ykf-eureka-provide")
public interface UserService {
//声明 调用上面服务 下面的 哪些接口
@RequestMapping(value = "/query/{id}")
User findByIdUser(@PathVariable("id") Integer id);
@RequestMapping(value = "/del/{id}")
String delUser(@PathVariable("id") Integer id);
@RequestMapping(value = "/save/{uname}/{pwd}")
String saveUser(@PathVariable("uname") String uname, @PathVariable("pwd") String pwd);
@RequestMapping(value = "/delsave/{id}")
String delsave(@PathVariable("id") Integer id);
}
然后 继续改造 UserController.java
package spring.cloud.ykf.eureka.consume.main.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.ResponseBody;
import spring.cloud.ykf.eureka.consume.main.entry.User;
import spring.cloud.ykf.eureka.consume.main.service.UserService;
@Controller
public class UserController {
@Autowired
UserService userService;
@GetMapping(value = "/query/{id}")
@ResponseBody
public User findUser(@PathVariable("id") Integer id) {
return userService.findByIdUser(id);
}
@GetMapping(value = "/del/{id}")
@ResponseBody
public String del(@PathVariable("id") Integer id) {
String smg = userService.delUser(id);
return smg + "";
}
@GetMapping(value = "/save/{uname}/{pwd}")
@ResponseBody
public String save(@PathVariable("uname") String uname, @PathVariable("pwd") String pwd) {
return userService.saveUser(uname, pwd);
}
@GetMapping(value = "/delsave/{id}")
@ResponseBody
public String delsave(@PathVariable("id") Integer id) {
return userService.delsave(id);
}
}
然后启动依次 启动 注册中心 服务提供 服务消费 页面请求效果
是不是用feign 做调用 比ribbon 要方便多了 代码维护下要高一点啊, 不用每次调用 都得写 http :// 服务 ...等等了 只需要在指定的接口定义一次就好了
继续改造 消费者端, 当服务挂掉的时候 消费者发送请求 还能正常 返回:
pom.xml 添加依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>
main 启动类 添加注解 开启断路由
//标明是服务提供者
@EnableEurekaClient
// springboot项目
@SpringBootApplication
// 开启 feign 做负载均衡
@EnableFeignClients
// 开启Hystrix断路器
@EnableCircuitBreaker
public class EurekaConsumeApp {
public static void main(String[] args) {
System.err.println("EurekaConsumeApp Service Strat Success!");
SpringApplication.run(EurekaConsumeApp.class, args);
}
}
application.properties增加配置
feign.hystrix.enabled=true //开启断路由
然后是UserService接口改造 在原来的基础上增加后面的 配置断路由返回到这里处理
//直接在这里 指明我要调用哪个服务 fallback当这个服务挂掉的时候 返回提示 不让请求阻塞 导致整个集群挂掉
@FeignClient(name = "spring-ykf-eureka-provide",fallback = UserServiceHystrix.class)
UserServiceHystrix实现类
package spring.cloud.ykf.eureka.consume.main.hystrix;
import org.springframework.stereotype.Component;
import spring.cloud.ykf.eureka.consume.main.entry.User;
import spring.cloud.ykf.eureka.consume.main.service.UserService;
//断路由 当请求对应服务 挂掉的时候 这里处理返回
@Component
public class UserServiceHystrix implements UserService {
@Override
public User findByIdUser(Integer id) {
return new User();
}
@Override
public String delUser(Integer id) {
return "server invoker err";
}
@Override
public String saveUser(String uname, String pwd) {
return "server invoker err";
}
@Override
public String delsave(Integer id) {
return "server invoker err";
}
}
然后依次启动注册中心 服务提供 消费者 正常访问一波是 返回正常数据的, 这个时候 当你关掉服务端的时候
返回的是 server invoker err 是能正常返回的 并没有报错 我这里就不截图演示了