app = Flask(__name__)

@app.route(‘/users/‘, methods=[‘GET’])
def get_user(user_id):
# 模拟从数据库获取用户信息
user = {
‘id’: user_id,
‘name’: ‘John Doe’,
’email’: ‘john.doe@fgedu.net.cn’
}
return jsonify(user)

if __name__ == ‘__main__’:
app.run(host=’0.0.0.0′, port=5000)

# 订单服务调用用户服务
import requests

def get_user_info(user_id):
response = requests.get(f’http://user-service:5000/users/{user_id}’)
if response.status_code == 200:
return response.json()
else:
return None

connection = pika.BlockingConnection(pika.ConnectionParameters(‘rabbitmq’))
channel = connection.channel()

channel.queue_declare(queue=’order_created’)

channel.basic_publish(
exchange=”,
routing_key=’order_created’,
body='{“order_id”: 123, “user_id”: 456, “amount”: 100.0}’
)

print(” [x] Sent ‘Order created'”)
connection.close()

# 消费者示例（通知服务）
import pika
import json

connection = pika.BlockingConnection(pika.ConnectionParameters(‘rabbitmq’))
channel = connection.channel()

channel.queue_declare(queue=’order_created’)

def callback(ch, method, properties, body):
order = json.loads(body)
print(f” [x] Received order: {order}”)
# 发送通知逻辑
print(f” [x] Sending notification for order {order[‘order_id’]}”)

channel.basic_consume(
queue=’order_created’,
on_message_callback=callback,
auto_ack=True
)

print(‘ [*] Waiting for messages. To exit press CTRL+C’)
channel.start_consuming()

package user;

service UserService {
rpc GetUser(GetUserRequest) returns (GetUserResponse);
}

message GetUserRequest {
int32 user_id = 1;
}

message GetUserResponse {
int32 id = 1;
string name = 2;
string email = 3;
}

# 生成代码
$ protoc –go_out=. –go-grpc_out=. user.proto

# 服务端实现
package main

import (
“context”
“log”
“net”

“google.golang.org/grpc”
pb “fgedu.net.cn/user-service/proto”
)

type server struct {
pb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, in *pb.GetUserRequest) (*pb.GetUserResponse, error) {
// 模拟从数据库获取用户信息
return &pb.GetUserResponse{
Id: in.UserId,
Name: “John Doe”,
Email: “john.doe@fgedu.net.cn”,
}, nil
}

func main() {
lis, err := net.Listen(“tcp”, “:50051”)
if err != nil {
log.Fatalf(“failed to listen: %v”, err)
}
s := grpc.NewServer()
pb.RegisterUserServiceServer(s, &server{})
if err := s.Serve(lis); err != nil {
log.Fatalf(“failed to serve: %v”, err)
}
}

# 客户端实现
package main

import (
“context”
“log”

“google.golang.org/grpc”
pb “fgedu.net.cn/user-service/proto”
)

func main() {
conn, err := grpc.Dial(“user-service:50051”, grpc.WithInsecure())
if err != nil {
log.Fatalf(“did not connect: %v”, err)
}
defer conn.Close()

c := pb.NewUserServiceClient(conn)

ctx := context.Background()
res, err := c.GetUser(ctx, &pb.GetUserRequest{UserId: 123})
if err != nil {
log.Fatalf(“could not get user: %v”, err)
}
log.Printf(“User: %v”, res)
}

更多学习教程公众号风哥教程itpux_com

6. 服务发现

6.1 服务注册

server:
port: 8080

eureka:
client:
serviceUrl:
defaultZone: http://eureka-server:8761/eureka/

# 启动类
@SpringBootApplication
@EnableEurekaClient
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
}

@Autowired
private RestTemplate restTemplate;

@GetMapping(“/orders/{orderId}”)
public Order getOrder(@PathVariable Long orderId) {
// 从订单服务获取订单信息
Order order = getOrderFromDatabase(orderId);

// 调用用户服务获取用户信息
User user = restTemplate.getForObject(“http://user-service/users/{userId}”, User.class, order.getUserId());
order.setUser(user);

return order;
}

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
}

# 启动Consul代理
$ consul agent -dev

# 服务注册（使用Consul API）
$ curl -X PUT -d ‘{“ID”: “user-service”, “Name”: “user-service”, “Address”: “127.0.0.1”, “Port”: 8080}’ http://fgedudb:8500/v1/agent/service/register

# 服务发现（使用Consul API）
$ curl http://fgedudb:8500/v1/catalog/service/user-service