Développement backend Java : Implémentation d'un serveur API hautes performances à l'aide de Netty

Ces dernières années, avec le développement rapide de la technologie Internet, les exigences en matière de hautes performances, de haute concurrence et de haute disponibilité côté serveur sont de plus en plus élevées en tant que communication réseau hautes performances, asynchrone et non bloquante. framework, Netty devient de plus en plus populaire Attention et utilisation par la majorité des développeurs.

Cet article présentera comment utiliser le framework Netty pour implémenter un serveur API hautes performances.

1. Qu'est-ce que Netty

Netty est un framework d'application réseau asynchrone piloté par événements basé sur Java NIO, utilisé pour développer rapidement des programmes de communication réseau hautes performances et haute fiabilité , comme le client et le serveur.

Ses composants principaux incluent Buffer, Channel, EventLoop, Codec, etc. Buffer est le composant tampon de Netty, Channel fournit une interface de communication réseau abstraite, EventLoop est le modèle événementiel de Netty et Codec est un codec. Grâce à ces composants, le framework Netty peut fournir des capacités de communication réseau hautes performances, à haute concurrence et à faible latence.

2. Utilisation basique de Netty

Tout d'abord, nous devons introduire les dépendances de Netty :

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

Ensuite, nous devons créer un objet Bootstrap, through Cet objet est utilisé pour démarrer notre serveur Netty :

EventLoopGroup bossGroup = new NioEventLoopGroup(); 
EventLoopGroup workerGroup = new NioEventLoopGroup(); 
try{
    ServerBootstrap bootstrap = new ServerBootstrap();
    bootstrap.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline pipeline = ch.pipeline();
                     pipeline.addLast(new HttpServerCodec());
                     pipeline.addLast(new HttpObjectAggregator(65536));
                     pipeline.addLast(new ChunkedWriteHandler());
                     pipeline.addLast(new HttpServerHandler());
                  }
              });
    ChannelFuture future = bootstrap.bind(port).sync();
    future.channel().closeFuture().sync();
}finally{
      bossGroup.shutdownGracefully();
      workerGroup.shutdownGracefully();
}

Dans le code ci-dessus, nous avons créé deux objets EventLoopGroup, l'un est le bossGroup utilisé pour recevoir les demandes des clients et l'autre est utilisé pour gérer les demandes des clients. . groupe de travailleurs. Configurez les paramètres du serveur Netty via l'objet ServerBootstrap, y compris le protocole de communication (NioServerSocketChannel), le processeur (Handler), l'initialisation du canal et d'autres opérations.

Nous pouvons également voir que dans le code ci-dessus, nous avons ajouté les composants HttpServerCodec et HttpObjectAggregator pour implémenter l'encodage, le décodage et l'agrégation des requêtes et réponses HTTP. Dans le même temps, nous avons également ajouté ChunkedWriteHandler pour traiter les flux de Big Data.

Enfin, nous lions le port et démarrons le serveur Netty via la méthode bootstrap.bind, bloquons le thread principal et attendons que le serveur Netty s'arrête via future.channel().closeFuture( .sync() méthode.

3. Utilisez Netty pour implémenter un serveur API hautes performances

Pour un serveur API, nous devons généralement gérer un grand nombre de requêtes et de réponses tout en garantissant une disponibilité et une haute disponibilité du système. -temps de réponse des performances.

Ici, nous prenons comme exemple la mise en œuvre d'un serveur API simple pour présenter comment utiliser le framework Netty pour implémenter un serveur API hautes performances.

1. Définition de l'interface

Définissons d'abord une interface API simple, qui permet d'implémenter la fonction d'obtention d'informations utilisateur :

GET /user/{id} HTTP/1.1
Host: localhost:8888

Où {id} est le numéro d'identification de l'utilisateur. Nous devons interroger les informations de l'utilisateur en fonction de ce numéro d'identification et les renvoyer au client.

2. Traitement métier

Ensuite, nous devons implémenter le traitement de la logique métier, c'est-à-dire interroger les informations de l'utilisateur en fonction du numéro d'identification dans la demande du client et renvoyer la requête résultats au client.

Tout d'abord, créons un processeur HttpServerHandler. Ce processeur hérite de SimpleChannelInboundHandler. Nous pouvons implémenter notre logique métier dans ce processeur.

public class HttpServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) throws Exception {
        HttpServerRoute route = HttpServerRoute.builder()
                .addRoute("/user/{id}", new GetUserHandler())
                .build();
        HttpServerRequest request = new HttpServerRequest(msg);
        HttpServerResponse response = new HttpServerResponse(ctx, msg);
        route.route(request, response);
    }
}

Comme vous pouvez le voir, dans le code ci-dessus, nous implémentons la correspondance de route via l'objet HttpServerRoute. Lors de la réception d'une demande client, nous convertirons la demande en un objet HttpServerRequest, y envelopperons l'objet de réponse HttpServerResponse, puis utiliserons l'objet HttpServerRoute pour faire correspondre les règles de routage et distribuer la demande au processeur correspondant pour traitement.

Nous devons implémenter le processeur GetUserHandler, qui est utilisé pour interroger les informations utilisateur en fonction de l'ID utilisateur :

public class GetUserHandler implements HttpServerHandlerInterface {
    @Override
    public void handle(HttpServerRequest request, HttpServerResponse response) throws Exception {
        String id = request.getPathParam("id");
        //查询用户信息
        User user = UserService.getUserById(id);
        if (user != null) {
            JSONObject json = new JSONObject();
            json.put("id", user.getId());
            json.put("name", user.getName());
            response.sendJSON(HttpResponseStatus.OK, json.toJSONString());
        } else {
            response.sendError(HttpResponseStatus.NOT_FOUND);
        }
    }
}

Dans le code ci-dessus, nous interrogerons en fonction de l'ID numéro dans les informations utilisateur de la demande, et utilisez JSONObject pour construire les données de chaîne JSON de la réponse à la demande, et enfin renvoyer les résultats de la requête au client.

Nous devons également implémenter la classe UserService pour fournir la fonction d'interrogation des informations utilisateur :

public class UserService {
    public static User getUserById(String id) {
        //查询数据库中的用户信息
    }
}

3 Test de performances

Enfin, testons. il Le temps de réponse et le QPS (nombre de requêtes simultanées par seconde) du serveur API hautes performances Netty que nous avons implémenté.

Grâce à l'outil Apache ab, nous pouvons simuler plusieurs requêtes simultanées de clients et collecter des statistiques sur les temps de réponse et les informations QPS. Utilisez la commande suivante :

ab -n 10000 -c 100 -k http://localhost:8888/user/1

Description du paramètre :

-n : Indique le nombre total de requêtes

-c : Indique le nombre de requêtes simultanées requêtes

-k : Indique l'activation des connexions Keep-alive

Grâce aux tests, nous pouvons obtenir le temps de réponse et les informations QPS :

Server Software:
Server Hostname:        localhost
Server Port:            8888

Document Path:          /user/1
Document Length:        36 bytes

Concurrency Level:      100
Time taken for tests:   3.777 seconds
Complete requests:      10000
Failed requests:        0
Keep-Alive requests:    10000
Total transferred:      1460000 bytes
HTML transferred:       360000 bytes
Requests per second:    2647.65 [#/sec] (mean)
Time per request:       37.771 [ms] (mean)
Time per request:       0.378 [ms] (mean, across all concurrent requests)
Transfer rate:          377.12 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    2   1.2      2      10
Processing:     3   32  11.3     32      84
Waiting:        3   32  11.3     32      84
Total:          6   34  11.2     34      86

Percentage of the requests served within a certain time (ms)
  50%     34
  66%     38
  75%     40
  80%     42
  90%     49
  95%     55
  98%     64
  99%     71
 100%     86 (longest request)

Vous pouvez voyez que notre serveur API Lors du test, il a été capable de gérer efficacement les simulations de 100 requêtes simultanées et il a pu gérer 2 647,65 requêtes par seconde, avec un temps de réponse moyen de seulement 37,771 millisecondes.

4. Résumé

Grâce à l'introduction et aux étapes ci-dessus, nous avons appris à utiliser Netty comme cadre de communication réseau et à l'utiliser pour développer des serveurs API hautes performances. L'utilisation du framework Netty peut considérablement améliorer les performances du serveur, ce qui confère à notre serveur une concurrence élevée, une fiabilité élevée, une faible latence et d'autres caractéristiques. Dans le même temps, le framework Netty présente également une évolutivité et une flexibilité élevées et peut être facilement intégré à n'importe quelle application.

Dans le cadre de la stack technologique de développement back-end Java, l'utilisation du framework Netty fait également partie des compétences qu'il faut maîtriser.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!