网络编程知识(5)--用Netty实现的一个简单的HTTP服务器

最新推荐文章于 2024-09-19 16:40:22 发布
最新推荐文章于 2024-09-19 16:40:22 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： java进阶-网络编程知识 文章标签： 网络编程 http服务器

本文转载自：http://akingde.iteye.com/blog/1923625 尊重原创

用Netty实现的一个简单的HTTP服务器，可以处理静态文件，例子中的注释也比较全。

public class HttpServer {  
    public static void main(String[] args) {  
        ServerBootstrap bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(  
                Executors.newCachedThreadPool(), Executors.newCachedThreadPool()));  

        bootstrap.setPipelineFactory(new HttpServerPipelineFactory());  

        bootstrap.bind(new InetSocketAddress(8080));  
        System.out.println("服务器已经启动，请访问http://127.0.0.1:8080/index.html进行测试！\n\n");  
    }  
}

2.Pipeline

public class HttpServerPipelineFactory implements ChannelPipelineFactory {  
    public ChannelPipeline getPipeline() throws Exception {  
        // Create a default pipeline implementation.  
        ChannelPipeline pipeline = pipeline();  

        // Uncomment the following line if you want HTTPS  
        // SSLEngine engine =  
        // SecureChatSslContextFactory.getServerContext().createSSLEngine();  
        // engine.setUseClientMode(false);  
        // pipeline.addLast("ssl", new SslHandler(engine));  

        pipeline.addLast("decoder", new HttpRequestDecoder());  
        // Uncomment the following line if you don't want to handle HttpChunks.  
        // pipeline.addLast("aggregator", new HttpChunkAggregator(1048576));  
        pipeline.addLast("encoder", new HttpResponseEncoder());  
        // Remove the following line if you don't want automatic content  
        // compression.  
        //pipeline.addLast("aggregator", new HttpChunkAggregator(1048576));  
        pipeline.addLast("chunkedWriter", new ChunkedWriteHandler());  
        pipeline.addLast("deflater", new HttpContentCompressor());  
        pipeline.addLast("handler", new HttpRequestHandler());  
        return pipeline;  
    }  
}

3.handler类

import static org.jboss.netty.handler.codec.http.HttpHeaders.is100ContinueExpected;  

import static org.jboss.netty.handler.codec.http.HttpHeaders.isKeepAlive;  
import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.CONTENT_LENGTH;  
import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.COOKIE;  
import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.SET_COOKIE;  
import static org.jboss.netty.handler.codec.http.HttpResponseStatus.CONTINUE;  
import static org.jboss.netty.handler.codec.http.HttpResponseStatus.OK;  
import static org.jboss.netty.handler.codec.http.HttpVersion.HTTP_1_1;  

import java.io.File;  
import java.io.RandomAccessFile;  
import java.util.List;  
import java.util.Map;  
import java.util.Map.Entry;  
import java.util.Set;  

import org.jboss.netty.buffer.ChannelBuffer;  
import org.jboss.netty.channel.Channel;  
import org.jboss.netty.channel.ChannelFutureListener;  
import org.jboss.netty.channel.ChannelHandlerContext;  
import org.jboss.netty.channel.ExceptionEvent;  
import org.jboss.netty.channel.MessageEvent;  
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;  
import org.jboss.netty.handler.codec.http.Cookie;  
import org.jboss.netty.handler.codec.http.CookieDecoder;  
import org.jboss.netty.handler.codec.http.CookieEncoder;  
import org.jboss.netty.handler.codec.http.DefaultHttpResponse;  
import org.jboss.netty.handler.codec.http.HttpChunk;  
import org.jboss.netty.handler.codec.http.HttpChunkTrailer;  
import org.jboss.netty.handler.codec.http.HttpHeaders;  
import org.jboss.netty.handler.codec.http.HttpMethod;  
import org.jboss.netty.handler.codec.http.HttpRequest;  
import org.jboss.netty.handler.codec.http.HttpResponse;  
import org.jboss.netty.handler.codec.http.HttpResponseStatus;  
import org.jboss.netty.handler.codec.http.QueryStringDecoder;  
import org.jboss.netty.handler.stream.ChunkedFile;  
import org.jboss.netty.util.CharsetUtil;  

public class HttpRequestHandler extends SimpleChannelUpstreamHandler {  

    private HttpRequest request;  
    private boolean readingChunks;  

    @Override  
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {  
        if (!readingChunks) {  
            HttpRequest request = this.request = (HttpRequest) e.getMessage();  
            String uri = request.getUri();  
            System.out.println("-----------------------------------------------------------------");  
            System.out.println("uri:"+uri);  
            System.out.println("-----------------------------------------------------------------");  
            /** 
             * 100 Continue 
             * 是这样的一种情况：HTTP客户端程序有一个实体的主体部分要发送给服务器，但希望在发送之前查看下服务器是否会 
             * 接受这个实体，所以在发送实体之前先发送了一个携带100 
             * Continue的Expect请求首部的请求。服务器在收到这样的请求后，应该用 100 Continue或一条错误码来进行响应。 
             */  
            if (is100ContinueExpected(request)) {  
                send100Continue(e);  
            }  
            // 解析http头部  
            for (Map.Entry<String, String> h : request.getHeaders()) {  
                System.out.println("HEADER: " + h.getKey() + " = " + h.getValue() + "\r\n");  
            }  
            // 解析请求参数  
            QueryStringDecoder queryStringDecoder = new QueryStringDecoder(request.getUri());  
            Map<String, List<String>> params = queryStringDecoder.getParameters();  
            if (!params.isEmpty()) {  
                for (Entry<String, List<String>> p : params.entrySet()) {  
                    String key = p.getKey();  
                    List<String> vals = p.getValue();  
                    for (String val : vals) {  
                        System.out.println("PARAM: " + key + " = " + val + "\r\n");  
                    }  
                }  
            }  
            if (request.isChunked()) {  
                readingChunks = true;  
            } else {  
                ChannelBuffer content = request.getContent();  
                if (content.readable()) {  
                    System.out.println(content.toString(CharsetUtil.UTF_8));  
                }  
                writeResponse(e, uri);  
            }  
        } else {// 为分块编码时  
            HttpChunk chunk = (HttpChunk) e.getMessage();  
            if (chunk.isLast()) {  
                readingChunks = false;  
                // END OF CONTENT\r\n"  
                HttpChunkTrailer trailer = (HttpChunkTrailer) chunk;  
                if (!trailer.getHeaderNames().isEmpty()) {  
                    for (String name : trailer.getHeaderNames()) {  
                        for (String value : trailer.getHeaders(name)) {  
                            System.out.println("TRAILING HEADER: " + name + " = " + value + "\r\n");  
                        }  
                    }  
                }  
                writeResponse(e, "/");  
            } else {  
                System.out.println("CHUNK: " + chunk.getContent().toString(CharsetUtil.UTF_8)  
                        + "\r\n");  
            }  
        }  
    }  

    private void writeResponse(MessageEvent e, String uri) {  
        // 解析Connection首部，判断是否为持久连接  
        boolean keepAlive = isKeepAlive(request);  

        // Build the response object.  
        HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);  
        response.setStatus(HttpResponseStatus.OK);  
        // 服务端可以通过location首部将客户端导向某个资源的地址。  
        // response.addHeader("Location", uri);  
        if (keepAlive) {  
            // Add 'Content-Length' header only for a keep-alive connection.  
            response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes());  
        }  
        // 得到客户端的cookie信息，并再次写到客户端  
        String cookieString = request.getHeader(COOKIE);  
        if (cookieString != null) {  
            CookieDecoder cookieDecoder = new CookieDecoder();  
            Set<Cookie> cookies = cookieDecoder.decode(cookieString);  
            if (!cookies.isEmpty()) {  
                CookieEncoder cookieEncoder = new CookieEncoder(true);  
                for (Cookie cookie : cookies) {  
                    cookieEncoder.addCookie(cookie);  
                }  
                response.addHeader(SET_COOKIE, cookieEncoder.encode());  
            }  
        }  
        final String path = Config.getRealPath(uri);  
        File localFile = new File(path);  
        // 如果文件隐藏或者不存在  
        if (localFile.isHidden() || !localFile.exists()) {  
            // 逻辑处理  
            return;  
        }  
        // 如果请求路径为目录  
        if (localFile.isDirectory()) {  
            // 逻辑处理  
            return;  
        }  
        RandomAccessFile raf = null;  
        try {  
            raf = new RandomAccessFile(localFile, "r");  
            long fileLength = raf.length();  
            response.setHeader(HttpHeaders.Names.CONTENT_LENGTH, String.valueOf(fileLength));  
            Channel ch = e.getChannel();  
            ch.write(response);  
            // 这里又要重新温习下http的方法，head方法与get方法类似，但是服务器在响应中只返回首部，不会返回实体的主体部分  
            if (!request.getMethod().equals(HttpMethod.HEAD)) {  
                ch.write(new ChunkedFile(raf, 0, fileLength, 8192));//8kb  
            }  
        } catch (Exception e2) {  
            e2.printStackTrace();  
        } finally {  
            if (keepAlive) {  
                response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes());  
            }  
            if (!keepAlive) {  
                e.getFuture().addListener(ChannelFutureListener.CLOSE);  
            }  
        }  
    }  

    private void send100Continue(MessageEvent e) {  
        HttpResponse response = new DefaultHttpResponse(HTTP_1_1, CONTINUE);  
        e.getChannel().write(response);  
    }  

    @Override  
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {  
        e.getCause().printStackTrace();  
        e.getChannel().close();  
    }  
}

4.配置类 

public class Config {  

    public static String getRealPath(String uri) {  
        StringBuilder sb=new StringBuilder("/home/guolei/workspace/Test/web");  
        sb.append(uri);  
        if (!uri.endsWith("/")) {  
            sb.append('/');  
        }  
        return sb.toString();  
    }  
}

5.页面
在项目中新建一个文件夹，名称为web（可以在配置中配置），在文件夹中放入静态页面index.html。
6.启动服务器，测试

网络编程之Netty
Strange_boy的博客
05-23 1056
原文链接 概述 Netty 是一个高性能、异步事件驱动的 NIO 框架 优点 1、高性能、高吞吐量、低延迟 2、使用方便，详细的Javadoc,用户指南和示例 3、社区活跃，版本迭代周期短 4、设计优雅，适用于各种传输类型的统一API阻塞和非阻塞Socket；基于灵活且可扩展的事件模型 线程模型介绍 目前的线程模型有：传统阻塞I/O服务模型、Reactor模型； 根据Reactor数量和处理资源线程的的数量不同，有3种形式： 1、单Reactor 2、单Reactor多线程 3、主从Reactor多线程
netty网络编程学习文档
04-09
在"Netty02-入门.md"文件中，通常会涵盖Netty的基础知识，包括如何创建一个简单的Netty服务器和客户端。首先，会介绍Bootstrap类，它是Netty服务端的启动器，通过它可以配置服务器的参数，如绑定的端口、事件循环组...
Netty
Sai_BAN的博客
12-25 783
一、概述 1、什么是Netty Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.Copy Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端 注意：netty的异步还是基于多路复用的，并没有实现真正意
Netty网络编程
最新发布
waooi的博客
09-19 1104
在本章中，我们快速浏览了Netty，并演示了如何使用Netty编写一个完全可用的网络应用程序。在接下来的章节中会有更多关于Netty的详细信息。我们还鼓励您查看包中的Netty示例。本文章是为学习Netty网络编程所写，根据项目需求会时不时更新。参考Netty官方手册。
netty编程
zslngu的博客
06-14 217
根据netty创建简单的tcp服务器，需要自实现三个类，encoder（用于把对象解析为字节码），decoder（用于把字节码解析为对象）， handler（业务逻辑处理）。 这里通过netty简单搭建一个自定义协议的tcp服务器。 encoder public class MessageEncoder extends MessageToByteEncoder<Package&gt...
Netty 编程
每一个不曾起舞的日子，都是对人生的辜负。
12-06 508
NettyServer: import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.chan...
Netty编程
weixin_43794897的博客
02-18 267
Netty 概述 Netty是由JBOSS 提供的一个Java 开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序。 模型和异步 比较类似于上面的线程池模型，Netty抽象出两组线程池，BossGroup专门负责接收客户端连接，WorkerGroup 专门负责网络读写操作。NioEventLoop 表示一个不断循环执行处理任务的线程，每...
基于netty与Springboot实现的编程游戏服务器-源码
10-02
总的来说，这个项目提供了一个实际应用Netty和Spring Boot构建游戏服务器的例子，涵盖了网络编程、并发处理、微服务架构等多个IT领域的核心知识点。对于想要学习游戏服务器开发或者提升Java后端技能的开发者来说，这...
Netty进阶之路-跟着案例学Netty
05-16
接着，通过一系列逐步进阶的案例，如构建简单的Echo服务器、处理HTTP请求、实现WebSocket通信，读者将深入理解如何使用Netty进行网络编程。 在处理TCP连接方面，书中会详细讲解如何建立、管理和关闭连接，以及如何...
learn-netty-in-aciton:《 Netty实战（Netty IN ACTION）》源码仓库
03-24
Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。通过学习这本书的源码仓库，我们可以深入了解Netty的设计理念和最佳实践。 Netty的核心特性包括： 1. **异步...
netty-all-4.1.5.Final:netty-all-4.1.5.Final源码学习
03-24
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。这个"netty-all-4.1.5.Final"版本是Netty框架的一个特定版本，包含了所有模块的功能，使得开发者可以深入理解...
netty5 HTTP协议栈浅析与实践
05-01
NULL 博文链接：https://baobeituping.iteye.com/blog/2398076
netty5.0 HTTPServer服务实例
lvbaolin123的博客
09-25 2414
这个HTTPServer实例是基于netty-all-5.0.0.Alpha2.jar我的这个实例中还会用到log4j-api-2.3.jar 和log4j-core-2.3.jar用来输出日志HTTPServer 这是一个启动类package com.lv.httpServer;import io.netty.bootstrap.ServerBootstrap;import io.netty.c
Netty的编程模型
Dream2World,SayHi
09-08 355
网络编程模型传统的BIO网络编程模型（线程池）Netty的网络编程模型三级目录 传统的BIO网络编程模型（线程池） 传统的网络编程模型，以Tomcat为代表，服务端的ServerSocketChannel个数取决于线程池中线程的数量，如图所示。 这种编程模型，客户端的连接数受限于线程池中线程的数量。 Netty的网络编程模型 三级目录 ...
网络编程-netty
qq_42514129的博客
01-12 445
netty 1.netty介绍: netty是由jboss提供的基于nio的网络编程开源框架,它采用异步,事件驱动的方式用来快速开发一个高性能高可靠的网络IO程序;elasticsearch,dubbox内部采用的就是netty 2.netty线程模型: * 单线程模型: 单线程多路复用的方式来完成服务器端包括建立客户端连接,读写的所有操作,编码简单,但是无法满足大量客户端连接的需求,传统的n...
Netty学习之编写Netty程序
My Blog
11-19 644
Netty学习之编写Netty程序
Netty编程（一）—— 初识Netty+超全注释
lizefeng1998的博客
11-21 1045
Netty编程（一）—— 初识Netty 文章目录Netty编程（一）—— 初识Netty什么是NettyHello World服务端 之前的博客介绍了NIO网络编程的相关知识，从这篇博客开始，我将开始介绍Netty的相关知识。 什么是Netty Netty 是一个异步的、基于事件驱动的网络应用框架，可用于快速开发可维护、高性能的网络服务器和客户端 基于事件驱动意思是底层实现采用多路复用技术（selector），事件发生时才需要进行处理 异步是指使用了多线程完成方法调用和处理结果相分离，并不是异步IO
5.Netty 网络编程 netty入门
m0_37488173的博客
07-31 186
netty ByteBuf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值