hw5-impl
web hw5
Ai.开发一个微服务，输入为书名，输出为书的作者。将此微服务单独部署，并使用eureka或其他你擅长使用的工具进行路由，在你的E-Book系统中使用该服务来完成作者搜索功能。请你编写文档，用你编写的这个微服务为例，解释Gateway和Service Registry在微服务架构中都起到了什么作用？在文档中还需要说明你的服务的部署与使用方式
我的微服务相关代码如下
GateWay
package org.example.gateway.config;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
@Configuration
public class RouteConfig {
@Bean
public RouteLocator myRoutes(RouteLocatorBuilder builder) {
// order: 优先级，数字越小，优先级越高
return builder.routes()
.route("bookmap", p->p.order(0).path("/bookmap/**").
and().
query("name")
.filters(f -> f.rewritePath("/bookmap(?<segment>/?.*)", "/book${segment}"))
.uri("lb://book-name-author-map:8090"))
.route("main",p->p.order(1).path("/**").uri("lb://eBookStore-backend:8443"))
.build();
}
}
定义了两个路由，一个bookmap路由到创建的book-name-author-map微服务，其他全部路由到ebookstore主服务
EurukaServer
package org.example.eurukaserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer
public class EurukaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurukaServerApplication.class, args);
}
}
spring:
application:
name: euruka-server
server:
port: 8761
eureka:
client:
register-with-eureka: true
fetch-registry: true
logging:
level:
com.netflix.eureka: 'OFF'
com.netflix.discovery: 'OFF'
而在book-name-author-map微服务中，共用相同的数据库
package org.example.booknameauthormap.controller;
import org.example.booknameauthormap.entity.BookEntity;
import org.example.booknameauthormap.repo.IBookRepo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class NameAuthorMappingController {
@Autowired
private IBookRepo bookRepo;
@GetMapping("/book")
public String getAuthor(@RequestParam String name) {
BookEntity book = bookRepo.findByTitle(name);
if (book == null) {
return "";
}
return book.getAuthor();
}
}
通过@EnableDiscoveryClient注解自动完成服务发现（即采用默认的euruka-server配置）
在ebookstore的主服务同理
在整个过程之中，Gateway和Service Registry在微服务架构中都起到的作用是
API Gateway:
- 作用: API 网关充当所有客户端请求的单一入口点。它作为微服务架构的边缘，负责接收来自客户端的所有请求，并根据请求的路由规则将请求转发到相应的微服务。它的行为类似反向代理，隐藏了微服务架构的内部复杂性，为客户端提供了一个简化的接口。同时也方便进行监控、日志、安全控制（不暴露内部服务器的ip接口等）、协议转换（内部可能是rpc等，外部暴露http）等
Service Registry :
- 作用: 服务注册中心是一个存储所有微服务实例信息的数据库。每个微服务实例在启动时向注册中心注册自身信息（例如 IP 地址、端口号、健康状态等），并在停止时注销。其他微服务可以通过注册中心查找所需服务的可用实例。注册中心简化了相关配置，允许部分服务器下线，不需要硬编码IP, 是弹性扩缩容的必备组件，也方便后续提供服务熔断、服务降级等功能
使用方式/部署方式（本地）：
按照以下顺序
- 运行euruka-server
- 运行book-name-author-map服务
- 运行主服务
- 运行Gateway服务
A.ii 开发一个函数式服务，输入为订单中某种书的价格和数量，输出为订单中有关这种书的总价。将此函数式服务单独部署，并在你的E-Book系统中使用该服务来完成订单总价计算功能，其中一个订单中可能包含多种书，每种书包含一本或多本。请你编写文档，用你编写的这个函数式服务为例，解释函数式服务的无状态指的是什么？函数式服务为什么容易扩展？在文档中还需要说明你的服务的部署与使用方式。
函数式服务如下
package org.example.calprice;
import lombok.Data;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;
@SpringBootApplication
public class CalPriceApplication {
public static void main(String[] args) {
SpringApplication.run(CalPriceApplication.class, args);
}
@Data
public static class Book {
private long price;
private long count;
}
@Bean
public Function<List<Book>, Long> calTotalPrice() {
return param -> {
try {
long total = 0;
for (Book book : param) {
total += book.price * book.count;
}
return total;
} catch (Exception e) {
// 处理错误
System.err.println("Error calculating total price: " + e.getMessage());
return -1L; // 返回错误码
}
};
}
// @Bean
// public Supplier<String> hello() {
// return () -> "Hello, FaaS!";
// }
}
解释函数式服务的无状态指的是什么？函数式服务为什么容易扩展？在文档中还需要说明你的服务的部署与使用方式
无状态指的是不依赖于数据库，session等外部的状态, 所有的需要的数据都以参数 (rpc, http)等传入, 而在函数内部也没有持久化的状态, 也就是说函数本身具有幂等性, 可以多次调用得到相同的计算结果
为什么容易:
无持久数据方便动态分配计算资源，根据传入数据的频率和计算时间即可，同时不需要存储资源，也自动具有隔离性和容器的适配性。无服务器让函数式抛开了重量级的依赖，可以轻松在不同的机器上水平调度，而不需要一台具备特定 环境的物理机，也不需要考虑兼容问题，水平调度非常简单。
我的服务的部署方式：本地部署
使用方式：直接访问即可，例如
❯ curl -X POST -H "Content-Type: application/json" -d '[{"price": 10, "count": 2}, {"price": 20, "count": 1}]' http://localhost:8091
40
我是将其也作为一个微服务被euruka管理
配置进euruka之后即为
package com.example.ebookstorebackend.serviceimpl;
import com.example.ebookstorebackend.service.CalPriceService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.List;
@Service
@Slf4j
public class CalPriceServiceImpl implements CalPriceService {
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
@Override
public long calPrice(List<CalPriceParam> params) {
ServiceInstance serviceInstance = discoveryClient.getInstances("calPrice").get(0);
long result= restTemplate.postForObject(serviceInstance.getUri(), params, long.class);
log.info("Total Price: {}", result);
return result;
}
}
// ... service impl
var calParams = newOrder.getOrderItems().stream().map(item->{
CalPriceService.CalPriceParam calParam = new CalPriceService.CalPriceParam(0, 0);
calParam.price = item.getBook_price();
calParam.count = item.getQuantity();
return calParam;
}).toList();
long total = calPriceService.calPrice(calParams);
response.message += String.format(";订单总价为: %d", total);
return response;
就集成进了原有系统之中