@RestController public class demo { @GetMapping("/hello") //不是@RequestMapping public String hello(){ System.out.println("11111111111"); return "hello 欢迎使用疫苗预约管理系统"; } }

这是一个基于Spring Boot框架的RESTful API，其中@RestController注解表示该类是一个控制器，@GetMapping("/hello")注解表示该方法处理GET请求，并且映射到"/hello"路径上。在该方法中，会先打印一行文本，然后返回一个字符串"hello 欢迎使用疫苗预约管理系统"。这个API可以用于向客户端提供一个简单的欢迎信息。

相关问题

Spring Boot 应用程序中使用 Netty 的 ServerBootstrap 和 Bootstrap 来创建服务器和客户端 demo

下面是一个简单的 Spring Boot 应用程序中使用 Netty 的 ServerBootstrap 和 Bootstrap 来创建服务器和客户端的示例：

1. 首先，需要在 Maven 中添加以下依赖项：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.65.Final</version>
</dependency>

2. 创建 Netty 服务器的代码：

@Component
public class NettyServer {

    private final EventLoopGroup bossGroup = new NioEventLoopGroup();
    private final EventLoopGroup workerGroup = new NioEventLoopGroup();

    @Autowired
    private NettyServerInitializer nettyServerInitializer;

    public void start() throws InterruptedException {

        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(nettyServerInitializer);

        ChannelFuture future = bootstrap.bind(8080).sync();
        future.channel().closeFuture().sync();
    }

    @PreDestroy
    public void stop() {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

3. 创建 Netty 服务器的初始化器：

@Component
public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {

    @Autowired
    private NettyServerHandler nettyServerHandler;

    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(nettyServerHandler);
    }
}

4. 创建 Netty 服务器的处理器：

@Component
public class NettyServerHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        // 处理接收到的数据
        System.out.println("Received message: " + msg);
        ctx.writeAndFlush("Server response: " + msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 处理异常
        cause.printStackTrace();
        ctx.close();
    }
}

5. 创建 Netty 客户端的代码：

@Component
public class NettyClient {

    private final EventLoopGroup group = new NioEventLoopGroup();

    @Autowired
    private NettyClientInitializer nettyClientInitializer;

    public String sendMessage(String host, int port, String message) throws InterruptedException, ExecutionException {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(nettyClientInitializer);

        ChannelFuture future = bootstrap.connect(host, port).sync();
        future.channel().writeAndFlush(message).sync();
        future.channel().closeFuture().sync();

        return nettyClientInitializer.getResponse();
    }

    @PreDestroy
    public void stop() {
        group.shutdownGracefully();
    }
}

6. 创建 Netty 客户端的初始化器：

@Component
public class NettyClientInitializer extends ChannelInitializer<SocketChannel> {

    private String response;

    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(new StringEncoder(), new StringDecoder(), new NettyClientHandler(this));
    }

    public String getResponse() {
        return response;
    }

    public void setResponse(String response) {
        this.response = response;
    }
}

7. 创建 Netty 客户端的处理器：

public class NettyClientHandler extends SimpleChannelInboundHandler<String> {

    private final NettyClientInitializer nettyClientInitializer;

    public NettyClientHandler(NettyClientInitializer nettyClientInitializer) {
        this.nettyClientInitializer = nettyClientInitializer;
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        // 处理接收到的数据
        nettyClientInitializer.setResponse(msg);
        ctx.close();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 处理异常
        cause.printStackTrace();
        ctx.close();
    }
}

在 Spring Boot 应用程序中使用 Netty 的 ServerBootstrap 和 Bootstrap 来创建服务器和客户端，需要将 Netty 服务器和客户端的 Bean 注入到 Spring 容器中，并在需要使用时使用它们。例如，在控制器中使用 Netty 客户端：

@RestController
@RequestMapping("/netty")
public class NettyController {

    @Autowired
    private NettyClient nettyClient;

    @GetMapping("/send")
    public String sendMessage() throws InterruptedException, ExecutionException {
        return nettyClient.sendMessage("localhost", 8080, "Hello from client");
    }
}

这样，当访问 /netty/send 路径时，将会向 Netty 服务器发送消息并接收响应。