Wie unten gezeigt, schreiben wir eine einfache Netty Demo, kommunizieren der Client und Server zu erreichen.
1, Netty Server Startklasse
/ ** * (1), einen Haupt Acceptor "thread pool" und für den "Thread - Pool" I / O Arbeit Initialisierung; * (2), die Initialisierung ServerBootstrap Beispiel, das die Entwicklung netty Server - Anwendung ist ein Einlass; * (3), durch eine Gruppe Methode ServerBootstrap (1) vorgesehen ist , im Master-Slave "thread pool" initialisiert; * (4), der angegebene Kanal - Kanal - Typ, weil es der Server, und deshalb ist NioServerSocketChannel; . * (5 ), stellen ServerSocketChannel Prozessor „Hauptschlachtfeld“ * (6), Unterkanal eingerichtet Socket Prozessor ist, der die tatsächliche interne Geschäftsentwicklung ist, * (8), Unterkanal - Konfiguration ist Socket Optionen * (9) binden und hört für einen Port * / public class SimpleNettyServer { public Leere der bind ( int port) wirft Exception { // server-seitige Anwendung erstellt zwei Gruppen Ereignisschleife zwei NioEventLoopGroup, Ereignisschleife Dies ist äquivalent zu einem Verarbeitungsthread, Netty Anforderung empfangen wird, und die IO Anforderungs - Verarbeitungs Threads. //Die Haupt - Thread - Gruppe, für eine Client - Verbindung zu akzeptieren, aber keine Behandlung, wie der Chef, keine Dinge tun EventLoopGroup bossGroup = new new NioEventLoopGroup (); // der Thread - Gruppe, wenn der Chef akzeptiert die Verbindung und Anmeldung akzeptiert wird , wenn der Arbeitnehmer verbunden wird der Verarbeitungsfluß Verbindung angenommen. WorkerGroup = EventLoopGroup neue neue NioEventLoopGroup (); der Versuch { // Netty Serverstart Klasse erstellt wird, Hilfsmittel für den Durchgang von einer Reihe von Server - Konfiguration ServerBootstrap ServerBootstrap = new new ServerBootstrap (); / ** * Verwenden Sie die Anzahl der Threads und wie sie abgebildet werden , den Kanal zu schaffen abhängen EventLoopGroup erreicht, auch von dem Konstruktor konfiguriert werden. Fadengruppe * Set - Schleife, der erstere für den Client - Verbindung Ereignisprozess, der für die Verarbeitung von Netzwerk - IO (Server unter Verwendung der zwei Parameter) verwendet wird * public von ServerBootstrap Gruppe (Gruppe EventLoopGroup) Gruppe von ServerBootstrap public * (EventLoopGroup parentGroup, EventLoopGroup childGroup) / / eine entsprechende Leitung , durch Socket zu erhalten* / ServerBootstrap.group (bossGroup, workerGroup) // bind die beiden Fadengruppen // verwendet Socket Fabrik zu konstruieren .Channel (. NioServerSocketChannel Klasse ) // angegebenen NIO Modell / ** * @BESCHREIBUNG: Initialisierer, Kanalregistrierungs nach der Initialisierung Methode führt innerhalb der entsprechenden, benutzerdefinierten Client Handle Passing (hier der Server - Betrieb) * @Override protected void initChannel (die Socket Channel) Ausnahme auslöst { die ChannelPipeline Pipeline channel.pipeline = (); // durch Pipeline, Add - Handler pipeline.addLast ( "nettyServerOutBoundHandler", neue neue NettyServerOutBoundHandler ()); pipeline.addLast ( "nettyServerHandler", neue neue NettyServerHandler ()); } * Subprozessor auch durch das folgende interne Verfahren implementiert werden kann. * / .ChildHandler ( neu neu ChannelInitializer <die Socket> () { // Unterprozessoren für die Verarbeitung von workerGroup geschützt Leere initChannel (die Socketsocket) wirft Exception { // socketChannel.pipeline () addlast (neu neue NettyServerOutBoundHandler ()) ;. Socket .pipeline (). addlast ( new new SimpleNettyServerHandler ()); } }); // beginnen Server, Port - Bindungen, beginnt empfangen eingehende Verbindungen, die Nummer 8088 eingestellte Port zur gleichen Zeit für den synchronen Start starten ChannelFuture channelFuture = serverBootstrap .bind (8088 ) .Sync (); System.out.println ( "Start - Server" ); // Streams geschlossener Kanal, warten auf den Server - Socket geschlossen ist. Set bitsynchronen Modus .. ChannelFuture.channel () closeFuture () , sync (); } die schließlich { // Austrittsfadengruppe bossGroup.shutdownGracefully (); workerGroup.shutdownGracefully (); } } Public static Hohlraum main (String [] args) wirftAusnahme { int port = 8080 ; neuer netty.server.SimpleNettyServer () bind (port). } }
2, Netty Server-Handler-Klasse Handler
public class SimpleNettyServerHandler die sich ChannelInboundHandlerAdapter { / ** * Diese Methode für Informationen , die von den Client übertragen Lesen * * @param CTX * @param MSG * @throws Exception * / @Override öffentliche Leere channelRead (ChannelHandlerContext CTX, Objekt MSG) wirft Ausnahme { System.out.println ( "SimpleNettyServerHandler.channelRead" ); ByteBuf Ergebnis = (ByteBuf) MSG; Byte [] = bytesMsg neue neue Byte[Result.readableBytes ()]; // MSG ByteBuf Art in Daten gespeichert sind, werden die Daten in den Byte - Lese [] in result.readBytes (bytesMsg); String ResultStr = new new String (bytesMsg); // Empfangen und Drucken Client - Informationen System.out.println ( "Client von Said:" + ResultStr); // Release Ressourcen ist diese Linie kritisches result.release (); // eine Nachricht an den Client senden String = Response "das Hallo - Client!" ; / / im aktuellen Szenario müssen die übertragenen Daten in Arrays ByteBuf umgewandelt werden ByteBuf codierte = ctx.alloc () -Puffer (* 4. response.length ()); encoded.writeBytes (response.getBytes ()); ctx.write (codiert ); ctx.flush (); } / ** * Diese Methode als Ausnahmeverarbeitung verwendet wird * * @param CTX * @param die Ursache ist * @ throws Exception * / @Override öffentliche Leere exceptionCaught (CTX ChannelHandlerContext, ist die Ursache der Throwable) throws Exception { // wenn anormale Verbindung geschlossen cause.printStackTrace (); ctx.close (); } / ** * nach der Beendigung der Informationserfassungsoperation * * @param CTX * @ throws Exception * / @Override öffentliche Leere channelReadComplete (ChannelHandlerContext CTX) wirft Exception { ctx.flush (); } }
3, Netty Client Startklasse
public class SimpleNettyClient { public Leere Connect (Host String, int - Port) wirft Exception { EventLoopGroup Arbeiter = new new NioEventLoopGroup (); der Versuch { // das Client - Programm auf Basis beginnen auf Bootstrap auf Bootstrap = Kommentare neu auf Bootstrap (); / ** * Ereignisschleife Gruppe * / bootstrap.group (Arbeiter); / ** * Socket Werk konfiguriert für * / bootstrap.channel (NioSocketChannel. Klasse ); / **Einstellmöglichkeiten * Parameter: Socket Standardparameter von (Schlüssel, Wert), frei zu Baidu , um zu atmen, atmen nicht! * * / Bootstrap.option (ChannelOption.SO_KEEPALIVE, true ); / ** * Angepasste Client - Handle (Client Dinge hier raus) * / bootstrap.handler ( neu neu ChannelInitializer <die Socket> () { @Override öffentliche Leere initChannel (die Socket CH) wirft Exception { ch.pipeline () addlast (. neue neue SimpleNettyClientHandler ()); } }); / **Open Client Monitor mit dem entfernten Knoten verbunden ist , Block warten , bis die Verbindung beendet ist * / ChannelFuture ChannelFuture = bootstrap.connect (Host, Port) .Sync (); / ** blockiert auf Daten warten, bis der Kanal geschlossen ist (geschlossene Client) * / . channelFuture.channel () closeFuture () Sync () ;. } finally { worker.shutdownGracefully (); } } public static Leere main (String [] args) wirft Exception { SimpleNettyClient - Client = new new SimpleNettyClient (); die client.connect ( "127.0.0.1", 8088 ); } }
4 ist der Client-basierten Handler
public class SimpleNettyClientHandler der Ausdehnungs ChannelInboundHandlerAdapter { / ** * Dieses Verfahren zum Erhalten einer Nachricht von dem Server gesendet wird * * @param CTX * @param MSG * @ throws Exception * / @Override public Hohlraum channelRead (ChannelHandlerContext CTX, Object MSG) wirft Exception { System.out.println ( "SimpleClientHandler.channelRead" ); ByteBuf Ergebnis = (ByteBuf) MSG; Byte [] = RESULT1 neue neue Byte[Result.readableBytes ()]; result.readBytes (RESULT1); System.out.println ( "Said Server:" + new new String (RESULT1)); result.release (); } / ** * Diese Methode zur Verarbeitung abnormal * * @param CTX * @param die Ursache ist * @throws Ausnahme * / @Override öffentliche Leere exceptionCaught (CTX ChannelHandlerContext, ist die Ursache der Throwable) throws Exception { // wenn abnorme Verbindung geschlossen cause.printStackTrace (); ctx.close () ; } / ** *本方法用于向服务端发送信息 * * @param ctx * @throws Exception * / @Override öffentliche Leere channelActive (ChannelHandlerContext CTX) wirft Exception { String msg = "Hallo Server!" ; ByteBuf codiert = ctx.alloc () -Puffer (4 *. Msg.length ()); encoded.writeBytes (msg.getBytes ()); ctx.write (codiert); ctx.flush (); } }
Zuerst den Server starten, und dann den Client startet jeweils in der Konsole erhält die folgende Ausgabe:
Server:
Serverstart
SimpleNettyServerHandler.channelRead
Kunde sagte: hallo Server !
Auftraggeber:
SimpleClientHandler.channelRead
Server sagte: hallo Client !
Somit beendet eine einfache Demo Netty d.h. Strukturen.