深入浅出boot2.0 第17章 cloud 和完结篇

最新推荐文章于 2024-01-29 13:28:06 发布

天海华兮

最新推荐文章于 2024-01-29 13:28:06 发布

阅读量483

点赞数

分类专栏： springBoot深入浅出2.0 文章标签： spring cloud

本文链接：https://blog.csdn.net/qq120631157/article/details/107145680

版权

springBoot深入浅出2.0 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

分布式开发
服务发现
配置中心
消息总线
负载均衡
- 声明式服务调用
断路器
数据监控
分布式事务

服务治理和服务发现 ——Eureka

注册中心

xml

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
		
	<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR6</spring-cloud.version>
    </properties>

配置

@SpringBootApplication
@EnableEurekaServer
public class Chapter17ServerApplication {}

# Spring项目名称
spring.application.name=server

# 服务器端口
server.port=7001

# Eureka注册服务器名称
eureka.instance.hostname=localhost

# 是否注册给服务中心：默认会自动查找 服务治理中心
eureka.client.register-with-eureka=false

# 是否检索服务：注册中心是 维护服务实例的，不需要这个功能
eureka.client.fetch-registry=false

# 治理客户端服务域：服务中心的域，提供给别的微服务注册
eureka.client.serviceUrl.defaultZone=http://localhost:7001/eureka/

服务发现

xml

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>

配置

//@EnableDiscoveryClient 新版本已经不需要这个注解了

#服务器端口
server.port=9001

#Spring服务名称
spring.application.name=product

#治理客户端服务域
eureka.client.serviceUrl.defaultZone=http://localhost:7001/eureka/

management.endpoints.web.exposure.include=health,info,hystrix.stream

紧急!eureka可能是错误地声称实例已经启动，而实际上它们还没有启动。续费低于阈值，因此为了安全起见，实例不会过期。
15min中 低于85%

配置多个服务治理中心节点

## 微服务名称依旧保持不变
spring.application.name=server
#server.port=7002
eureka.instance.hostname=localhost
## 将7002端口服务治理中心，注册给7001端口服务治理中心
eureka.client.serviceUrl.defaultZone=http://localhost:7001/eureka/

## 微服务名称依旧保持不变
spring.application.name=server
#server.port=7001
eureka.instance.hostname=localhost
## 将7002端口服务治理中心，注册给7001端口服务治理中心
eureka.client.serviceUrl.defaultZone=http://localhost:7002/eureka/

#治理客户端服务域
eureka.client.serviceUrl.defaultZone=http://localhost:7001/eureka/,http://localhost:7002/eureka/

微服务之间的调用

Ribbon

一个 RestTemplate
@LoadBalance 提供负载均衡算法

xml

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
		</dependency>

服务提供者

@RestController
public class UserController {
	// 日志
	private Logger log = Logger.getLogger(this.getClass());

	// 服务发现客户端
	@Autowired
	private DiscoveryClient discoveryClient = null;

	// 获取用户信息
	@GetMapping("/user/{id}")
	public UserPo getUserPo(@PathVariable("id") Long id) {
        
		ServiceInstance service = discoveryClient.getInstances("USER").get(0);
		log.info("【" + service.getServiceId() + "】:" + service.getHost() + ":" + service.getPort());
        
        
		UserPo user = new UserPo();
		user.setId(id);
		int level = (int) (id % 3 + 1);
		user.setLevel(level);
		user.setUserName("user_name_" + id);
		user.setNote("note_" + id);
		return user;
	}
	
	// 新增用户，POST请求，且以请求体(body)形式传递
	@PostMapping("/insert")
	public Map<String, Object> insertUser(@RequestBody UserPo user) {
	    Map<String, Object> map = new HashMap<String, Object>();
	    map.put("success", true);
	    map.put("message", "插入用户信息【" +user.getUserName() + "】成功");
	    return map;
	}

	// 修改用户名，POST请求，其中用户编号使用请求头的形式传递
	@PostMapping("/update/{userName}") 
	public Map<String, Object> updateUsername(
	        @PathVariable("userName") String userName,
	        @RequestHeader("id") Long id) {
	    Map<String, Object> map = new HashMap<String, Object>();
	    map.put("success", true);
	    map.put("message", "更新用户【" +id +"】名称【" +userName + "】成功");
	    return map;
	}
	
	@GetMapping("/timeout")
	public String timeout() {
	    // 生成一个3000之内的随机数
	    long ms = (long)(3000L*Math.random());
	    try {
	        // 程序延迟，有一定的概率超过2000毫秒
	        Thread.sleep(ms);
	    } catch (InterruptedException e) {
	        e.printStackTrace();
	    }
	    return "熔断测试";
	}
}

服务调用者

//自定义扫描包
@ComponentScan(basePackages = "com.springboot.chapter17.product")
@SpringCloudApplication
public class Chapter17ProductApplication {

    // 初始化RestTemplate
    @LoadBalanced // 多节点负载均衡
    @Bean(name = "restTemplate")
    public RestTemplate initRestTemplate() {
        return new RestTemplate();
    }

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


@RestController
@RequestMapping("/product")
public class ProductController {

	// 注入RestTemplate
	@Autowired
	private RestTemplate restTemplate = null;

	@GetMapping("/ribbon")
	public UserPo testRibbon() {
		UserPo user = null;
		// 循环10次，然后可以看到各个用户微服务后台的日志打印
		for (int i = 0; i < 10; i++) {
            
			// 注意这里直接使用了USER这个服务ID，代表用户微服务系统
			// 该ID通过属性spring.application.name来指定
			user = restTemplate.getForObject("http://USER/user/" + (i + 1), UserPo.class);
            
		}
		return user;
	}
    
}

Feign 声明式调用

xml

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-openfeign</artifactId>
		</dependency>

配置feign

@EnableFeignClients(basePackages = "com.springboot.chapter17.product")

使用feign

	// 测试
	@GetMapping("/feign")
	public UserPo testFeign() {
		UserPo user = null;
		// 循环10次
		for (int i = 0; i < 10; i++) {
			Long id = (long) (i + 1);
			user = userService.getUser(id);
		}
		return user;
	}

	@GetMapping("/feign2")
	public Map<String, Object> testFeign2() {
		Map<String, Object> result = null;
		UserPo user = null;
		for (int i = 1; i <= 10; i++) {
			Long id = (long) i;
			user = new UserPo();
			user.setId(id);
			int level = i % 3 + 1;
			user.setUserName("user_name_" + id);
			//user.setLevel(level);
			user.setNote("note_" + i);
			result = userService.addUser(user);
		}
		return result;
	}

	@GetMapping("/feign3")
	public Map<String, Object> testFeign3() {
		Map<String, Object> result = null;
		for (int i = 0; i < 10; i++) {
			Long id = (long) (i + 1);
			String userName = "user_name_" + id;
			result = userService.updateName(userName, id);
		}
		return result;
	}

@FeignClient("user") //user为 service Id
public interface UserService {
    // 指定通过HTTP的GET方法请求路径
    @GetMapping("/user/{id}")
    // 这里会采用Spring MVC的注解配置
    public UserPo getUser(@PathVariable("id") Long id);

    // POST方法请求用户微服务
    @PostMapping("/insert")
    public Map<String, Object> addUser(
            // 请求体参数
            @RequestBody UserPo user);

    // POST方法请求用户微服务
    @PostMapping("/update/{userName}")
    public Map<String, Object> updateName(
            // URL参数
            @PathVariable("userName") String userName,
            // 请求头参数
            @RequestHeader("id") Long id);

    // 调用用户微服务的timeout请求
    @GetMapping("/timeout")
    public String testTimeout();
}

	
	// 获取用户信息
	@GetMapping("/user/{id}")
	public UserPo getUserPo(@PathVariable("id") Long id) {
		ServiceInstance service = discoveryClient.getInstances("USER").get(0);
		log.info("【" + service.getServiceId() + "】:" + service.getHost() + ":" + service.getPort());
		UserPo user = new UserPo();
		user.setId(id);
		int level = (int) (id % 3 + 1);
		user.setLevel(level);
		user.setUserName("user_name_" + id);
		user.setNote("note_" + id);
		return user;
	}
	
	// 新增用户，POST请求，且以请求体(body)形式传递
	@PostMapping("/insert")
	public Map<String, Object> insertUser(@RequestBody UserPo user) {
	    Map<String, Object> map = new HashMap<String, Object>();
	    map.put("success", true);
	    map.put("message", "插入用户信息【" +user.getUserName() + "】成功");
	    return map;
	}

	// 修改用户名，POST请求，其中用户编号使用请求头的形式传递
	@PostMapping("/update/{userName}") 
	public Map<String, Object> updateUsername(
	        @PathVariable("userName") String userName,
	        @RequestHeader("id") Long id) {
	    Map<String, Object> map = new HashMap<String, Object>();
	    map.put("success", true);
	    map.put("message", "更新用户【" +id +"】名称【" +userName + "】成功");
	    return map;
	}

Hystrix 断路器

其自身不可用之后可能继续蔓延到其他与之相关的服务上，会使更多的微服务不可用
如果电器耗电大，导致电流过大，那么保险丝就会熔断。

服务降级

请求其他微服务出现超时，或者发生故障时，就会使用自身服务其他的方法进行相应。
Hystrix 默认服务之间的调用超过 2000ms (2s)，会根据你配置的其他方法进行相应。
写了一个3秒以上的方法

	@GetMapping("/timeout")
	public String timeout() {
	    // 生成一个3000之内的随机数
	    long ms = (long)(3000L*Math.random());
	    try {
	        // 程序延迟，有一定的概率超过2000毫秒
	        Thread.sleep(ms);
	    } catch (InterruptedException e) {
	        e.printStackTrace();
	    }
	    return "熔断测试";
	}

引入 pom

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
		</dependency>

配置

// 启动断路器
@EnableCircuitBreaker

使用断路器

	// Ribbon断路
	@GetMapping("/circuitBreaker1")
	@HystrixCommand(fallbackMethod = "error", commandProperties = {
			@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000") })
	public String circuitBreaker1() {
		return restTemplate.getForObject("http://USER/timeout", String.class);
	}

	// Feign断路测试
	@GetMapping("/circuitBreaker2")
	@HystrixCommand(fallbackMethod = "error")
	public String circuitBreaker2() {
		return userService.testTimeout();
	}

	// 降级服务方法
	public String error() {
		return "超时出错。";
	}

dashboard 启用hystrix仪表盘

引入xml

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
		</dependency>

启动仪表盘


// 启用Hystrix仪表盘
@EnableHystrixDashboard

server.port=6001
spring.application.name=hystrix_dashboard

http://localhost:6001/hystrix

Delay: 2000 ms 轮询时间
title: 标题，如产品监控
https://hystrix-app:port/actuator/hystrix.stream

产品微服务引入监控的依赖

spring-boot-starter-actuator

还要打开端点的暴露：

management.endpoints.web.exposure.include=health,info,hystrix.stream

之后再访问一下产品微服务地址的断路器

路由网关

请求路由到真实的服务器上，保护真实服务器的IP地址
作为负载均衡的手段
提供过滤器，判定请求是否有效

引入 pom

		<!--引入服务发现 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
		</dependency>

配置

//启动Zuul代理功能。里面包含了 启用断路器的机制
@EnableZuulProxy

# 服务端口
server.port=80
# Spring应用名称
spring.application.name=zuul

# 用户微服务映射规则
# 指定ANT风格的URL匹配
zuul.routes.user-service.path=/u/**

#指定映射的服务用户地址，这样Zuul就会将请求转发到用户微服务上了
zuul.routes.user-service.url=http://localhost:8001/

#产品微服务映射规则
zuul.routes.product-service.path=/p/**
#映射产品服务中心服务ID，Zuul会自动使用服务端负载均衡，分摊请求
zuul.routes.product-service.serviceId=product

#注册给服务治理中心
eureka.client.serviceUrl.defaultZone=http://localhost:7001/eureka/,http://localhost:7002/eureka/

默认访问： http://localhost/user/timeout 即可映射到 user 项目，timeout方法
配置了上面：localhost/p/product/ribbon 即可访问

使用redis 做过滤器

网关：

检测用户登录
黑名单用户
购物验证码
恶意刷请求
模拟场景：
- 提交表单，每个表单存在一个序列号：serialNumber
- 对应一个验证码 verificationCode
- 这两个参数一起提交给表单。reids以序列号为key，验证码为值
- 判断用户提交的验证码与 redis上是否一致。

引入redis和配置

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<exclusions>
				<!--不依赖Redis的异步客户端lettuce -->
				<exclusion>
					<groupId>io.lettuce</groupId>
					<artifactId>lettuce-core</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<!--引入Redis的客户端驱动jedis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</dependency>

spring.redis.jedis.pool.min-idle=5
spring.redis.jedis.pool.max-active=10
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.max-wait=2000
spring.redis.port=6379
spring.redis.host=192.168.10.128
spring.redis.password=123456
spring.redis.timeout=1000

ZuulFilter

实现 4个抽象方法
- shouldFilter 如果为true，则执行这个过滤器的方法
- run 核心方法
- filterType 过滤器类型
  - pre 执行前
  - route 处理请求，进行路由
  - post 处理完成后
  - error 出现错误的时候
- filterOrder 过滤器的顺序。值越小越优先。
Qualifier的意思是合格者，通过这个标示，表明了哪个实现类才是我们所需要的，
@Qualifier(“myZuulFilter”)

@Component
@Qualifier
public class MyZuulFilter extends ZuulFilter {

	// 注入StringRedisTemplate
	@Autowired
	private StringRedisTemplate residTemplate = null;

	// 是否过滤
	@Override
	public boolean shouldFilter() {
		// 请求上下文
		RequestContext ctx = RequestContext.getCurrentContext();
        
		// 获取HttpServletRequest对象
		HttpServletRequest req = ctx.getRequest();
        
		// 取出表单序列号
		String serialNumber = req.getParameter("serialNumber");
		// 如果存在验证码返回为true，启用过滤器
		return !StringUtils.isEmpty(serialNumber);
        //这里有问题，如果没有这个表单序列号，那这个过滤器不启用，应该在下面，拦截。
	}

	// 过滤器逻辑方法
	@Override
	public Object run() {
		RequestContext ctx = RequestContext.getCurrentContext();
		HttpServletRequest req = ctx.getRequest();
        
		// 取出表单序列号和请求验证码
		String serialNumber = req.getParameter("serialNumber");
		String reqCode = req.getParameter("verificationCode");
        
		// 从Redis中取出验证码
		String verifCode = residTemplate.opsForValue().get(serialNumber);
        
		// Redis验证码为空或者与请求不一致，拦截请求报出错误
		if (verifCode == null || !verifCode.equals(reqCode)) {
            
			// 不再转发请求
			ctx.setSendZuulResponse(false);
			// 设置HTTP响应码为401（未授权）
			ctx.setResponseStatusCode(401);
			// 设置响应类型为JSON数据集
			ctx.getResponse().setContentType(MediaType.APPLICATION_JSON_UTF8.getType());
			// 设置响应体
			ctx.setResponseBody("{'success': false, " + "'message':'Verification Code Error'}");
		}
		// 一致放过
		return null;
	}

	// 过滤器类型为请求前
	@Override
	public String filterType() {
		return "pre";
	}

	// 过滤器排序，数字越小优先级越高
	@Override
	public int filterOrder() {
		return 0;
	}
}

开发自己的注解

研究 @SpringCloudApplication

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited

@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker
public @interface SpringCloudApplication {
}

目前没有配置扫描包，所以一般都加上

//自定义扫描包
@ComponentScan(basePackages = "com.springboot.chapter17.product")
@EnableFeignClients(basePackages = "com.springboot.chapter17.product")

boot 的知识补充点

可以选择 tomcat 服务器

还可以选择 Jetty 或 Undertow

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<exclusions>
				<exclusion>
					<groupId>org.springframework.boot</groupId>
					<artifactId>spring-boot-starter-tomcat</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<!--<artifactId>spring-boot-starter-jetty</artifactId>-->
			<artifactId>spring-boot-starter-undertow</artifactId>
		</dependency>

修改商标

http://patorjk.com/software/taag/
录入文字，保存为 banner.txt
或者把图标保存为 banner.jpg

boot自动装配

spring-boot-start-web 会引入 spriing-boot-starters ——引入了 spring-boot-autocofigure包

RedisAutoConfiguration

//配置类
@Configuration(
    proxyBeanMethods = false
)
//存在哪些类，ioc容器才会装配这个类
@ConditionalOnClass({RedisOperations.class})
//使用哪个类 可以通过配置文件装配
@EnableConfigurationProperties({RedisProperties.class})//可以通过文件配置

@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )//在缺失redisTemplate，才将方法 返回的bean装配到 Ioc容器中
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}


@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(EnableRedisRepositories.class)
@ConditionalOnBean(RedisConnectionFactory.class)

//当存在这个 .repositories.* 属性后，才会启动这个类作为 配置文件
@ConditionalOnProperty(prefix = "spring.data.redis.repositories", name = "enabled", havingValue = "true",
		matchIfMissing = true)
@ConditionalOnMissingBean(RedisRepositoryFactoryBean.class)

//加在其他其他类 到当前环境中来
@Import(RedisRepositoriesRegistrar.class)
//完成RedisAutoConfiguration的装配后，才执行。还存在before 定制在哪些类之前初始化
@AutoConfigureAfter(RedisAutoConfiguration.class)

public class RedisRepositoriesAutoConfiguration {

}