Spring Cloud+ spring boot +mybatis+ mysql+ Eureka+ Ribbon实现 服务注册中心 服务提供 服务消费

其他 2018-08-01 22:14:02 阅读次数: 0

一、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  是能正常返回的 并没有报错 我这里就不截图演示了



猜你喜欢

转载自blog.csdn.net/wangbo54979/article/details/80092084
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022