java-netty-文件服务器

原本是基于netty的java文件服务器，采用http协议，后在学习web时不断升级完善中

2018.7.21：
asm工具可以用代码手动构造class文件。jadx原理就是先用smali解码dex，之后解析smali代码，用asm生成class文件，反编译成java。
javaweb中也使用asm。实现自定义语法生成class文件，可以把页面和后台代码一起写，后用程序处理访问时读取，分离，用asm生成class，动态加载，反射调用，提供服务。

代码

package httpbynetty;



//该服务器为下载服务器！！！！！！
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder;
import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.*;
import io.netty.handler.codec.http.*;
import io.netty.handler.stream.ChunkedFile;
import io.netty.util.CharsetUtil;

import javax.activation.MimetypesFileTypeMap;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.URLDecoder;
import java.util.regex.Pattern;

import static io.netty.handler.codec.http.HttpMethod.GET;
import static io.netty.handler.codec.http.HttpResponseStatus.*;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;

public class HttpFileServer {
	 private static final String DEFAULT_URL = "/";

	    public void run(final int port, final String url) throws Exception {
	        EventLoopGroup bossGroup = new NioEventLoopGroup();
	        EventLoopGroup workerGroup = new NioEventLoopGroup();
	        try {
	            ServerBootstrap b = new ServerBootstrap();
	            b.group(bossGroup, workerGroup)
	                    .channel(NioServerSocketChannel.class)
	                    .childHandler(new ChannelInitializer<SocketChannel>() {
	                        @Override
	                        protected void initChannel(SocketChannel ch)
	                                throws Exception {
	                            ch.pipeline().addLast("http-decoder",
	                                    new HttpRequestDecoder()); // 请求消息解码器
	                            ch.pipeline().addLast("http-encoder",
	                                    new HttpResponseEncoder());//响应解码器
	                            ch.pipeline().addLast("http-aggregator",
	                                    new HttpObjectAggregator(65536));// 目的是将多个消息转换为单一的request或者response对象
	  
	                            ch.pipeline().addLast("http-chunked",
	                                    new ChunkedWriteHandler());//目的是支持异步大文件传输（）
	                            ch.pipeline().addLast("fileServerHandler",
	                                    new HttpFileServerHandler(url));// 业务逻辑
	                        }
	                    });
	            ChannelFuture future = b.bind(port).sync();
	            System.out.println("HTTP文件目录服务器启动，网址是 : " +  InetAddress.getLocalHost()+":"
	                    + port + url);
	            future.channel().closeFuture().sync();
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            bossGroup.shutdownGracefully();
	            workerGroup.shutdownGracefully();
	        }
	    }

	    public static void main(String[] args) throws Exception {
	        int port = 8080;
	        if (args.length > 0) {
	            try {
	                port = Integer.parseInt(args[0]);
	            } catch (NumberFormatException e) {
	                e.printStackTrace();
	            }
	        }
	        String url = DEFAULT_URL;
	        if (args.length > 1)
	            url = args[1];
	        new HttpFileServer().run(port, url);
	    }
}

class HttpFileServerHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

	private final String url;


	public HttpFileServerHandler(String url)
	{

		this.url = url;

	}



	@Override

	protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
		/*如果无法解码400*/
	//	System.out.println(request);
		if (!request.decoderResult().isSuccess()) 
		{
			//decoderResult解析该对象的结果
			sendError(ctx, BAD_REQUEST);
   
			return;

		}

		/*只支持GET方法*/

		if (request.method() != GET)
		{
    
			sendError(ctx, METHOD_NOT_ALLOWED);
    
			return;

		}


		final String uri = request.uri();//get的uri是什么————GET /hello.txt HTTP/1.1  需要前端知识
		//会在当前网页路径下加上页面上的要求
		
		/*格式化URL，并且获取路径*/
		System.out.println(uri);//http://127.0.0.1:8080   是指host
		//这里.uri得到的是http请求中的uri     /bin/   GET /bin/ HTTP/1.1中间的那个（不含host）
		final String path = sanitizeUri(uri);//解析uri

		if (path == null)
		{
    
			sendError(ctx, FORBIDDEN);
   
			return;

		}

		File file = new File(path);//file创建时最后一个有/时会被忽略掉/
	//	System.out.println(path);
		/*如果文件不可访问或者文件不存在*/

		if (file.isHidden() || !file.exists()) {
    
			sendError(ctx, NOT_FOUND);
  
			return;

		}

		/*如果是目录*/

		if (file.isDirectory()) {
    
			//1. 以/结尾就列出所有文件
  
			if (uri.endsWith("/")) {//uri是get获取到的
        
				sendListing(ctx, file);
				//列文件
			}
			else
			{
        
				//2. 否则自动+/
        
				sendRedirect(ctx, uri + '/');
				//重定向到带/的
			}
    
			return;

		}

		if (!file.isFile()) {
    
			sendError(ctx, FORBIDDEN);
    
			return;

		}

		RandomAccessFile randomAccessFile = null;

		try {
   
			randomAccessFile = new RandomAccessFile(file, "r");// 以只读的方式打开文件

		} catch (FileNotFoundException fnfe) {
    
			sendError(ctx, NOT_FOUND);
    
			return;

		}

		long fileLength = randomAccessFile.length();

		//创建一个默认的HTTP响应

		HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);

		//设置Content Length

		HttpUtil.setContentLength(response, fileLength);

		//设置Content Type  

		setContentTypeHeader(response, file);//传入file？——自定义的函数
		

		//如果request中有KEEP ALIVE信息

		if (HttpUtil.isKeepAlive(request)) {
    
			response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);

		}

		ctx.write(response);//发送回答头

		ChannelFuture sendFileFuture;
		//发送回答体
		
		//通过Netty的ChunkedFile对象直接将文件写入发送到缓冲区中
		//ChunkedFile是第二种，分块的方式，采用的是chunkedinput里的阻塞从文件中读取
		sendFileFuture = ctx.write(new ChunkedFile(randomAccessFile, 0,
        fileLength, 8192), ctx.newProgressivePromise());

		sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
    
			@Override
    
			public void operationProgressed(ChannelProgressiveFuture future,long progress, long total) {
        //一个EventListener侦听器，一旦与未来相关的发送任务被传送，将被调用。 表示已经发了多少(累计)   表示总量（未知为-1）
				
				if (total < 0) { // 总大小为止
           
					System.err.println("Transfer progress: " + progress);
        
				} 
				else {
            
					System.err.println("Transfer progress: " + progress + " / "+ total);
        }
    }

    
			@Override
    
			public void operationComplete(ChannelProgressiveFuture future)throws Exception {
        
				System.out.println("Transfer complete.");
    
			}

		});
		
		//发送最后一个回答体
		ChannelFuture lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);

		//如果不支持keep-Alive，服务器端主动关闭请求

		if (!HttpUtil.isKeepAlive(request)) {
    
			lastContentFuture.addListener(ChannelFutureListener.CLOSE);

		}

	}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	@Override

	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)throws Exception {

		cause.printStackTrace();

		if (ctx.channel().isActive()) {
  
			sendError(ctx, INTERNAL_SERVER_ERROR);

		}

	}


	private static final Pattern INSECURE_URI = Pattern.compile(".*[<>&\"].*");



	private String sanitizeUri(String uri) {//    /bin/    

		try {
    
			uri = URLDecoder.decode(uri, "UTF-8");

		} catch (UnsupportedEncodingException e) {
    
			try {
        
				uri = URLDecoder.decode(uri, "ISO-8859-1");
    
			} catch (UnsupportedEncodingException e1) {
        
				throw new Error();
    
			}

		}
	//	System.out.println(uri);//   /bin/

		if (!uri.startsWith(url)) {
    
			return null;

		}

		if (!uri.startsWith("/")) {
    
			return null;

		}

		uri = uri.replace('/', File.separatorChar);
		//    \bin\httpbynetty\1\

		if (uri.contains(File.separator + '.')//含"/."   "./"   开始为"."  结束为.    
				|| uri.contains('.' + File.separator) || uri.startsWith(".")
				|| uri.endsWith(".") || INSECURE_URI.matcher(uri).matches()) {
			//matches()对整个字符串进行匹配,只有整个字符串都匹配了才返回true 
			//此处为含<>&\之一就错
    
			return null;

		}

		return System.getProperty("user.dir")  + uri;//当前目录，+get的请求
		//      D:\javawsp\jav\netty实现http服务器\bin\httpbynetty\1\
	}


	private static final Pattern ALLOWED_FILE_NAME = Pattern.compile("[A-Za-z0-9][-_A-Za-z0-9\\.]*");


	private static void sendListing(ChannelHandlerContext ctx, File dir) {

		FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, OK);

		response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=UTF-8");

		StringBuilder buf = new StringBuilder();

		String dirPath = dir.getPath();

		buf.append("<!DOCTYPE html>\r\n");

		buf.append("<html><head><title>");

		buf.append(dirPath);

		buf.append(" 目录：");

		buf.append("</title></head><body>\r\n");

		buf.append("<h3>");

		buf.append(dirPath).append(" 目录：");

		buf.append("</h3>\r\n");
		
		buf.append("<img src=\"http://192.168.100.177:8080/1.jpg\" width=\"352\" height=\"220\" />");
		
		//这里获取jpg为发送一次get请求，有俩种方式：
		//1.:   <img src=\"1.jpg\" width=\"352\" height=\"220\" />   get的uri直接解析为当前get的uri+src   
		//请求uri为：/bin/1.jpg
		//2.:   <img src=\"http://192.168.100.177:8080/1.jpg\" width=\"352\" height=\"220\" />   get的uri为src内写的
		//请求uri为：/1.jpg
		buf.append("<ul>");

		buf.append("<li>链接：<a href=\"../\">..</a></li>\r\n");

		for (File f : dir.listFiles()) {
    
			if (f.isHidden() || !f.canRead()) {
        
				continue;
    
			}
    
			String name = f.getName();
    
			if (!ALLOWED_FILE_NAME.matcher(name).matches()) {
        
				continue;
    
			}
    
			buf.append("<li>链接：<a href=\"");
    
			buf.append(name);
   
			buf.append("/\">");
  
			buf.append(name);
    
			buf.append("</a></li>\r\n");

		}

		buf.append("</ul></body></html>\r\n");

		ByteBuf buffer = Unpooled.copiedBuffer(buf, CharsetUtil.UTF_8);

		response.content().writeBytes(buffer);

		buffer.release();

		ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);

	}
	


	private static void sendRedirect(ChannelHandlerContext ctx, String newUri) {

		FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, FOUND);//302重定向

		response.headers().set(HttpHeaderNames.LOCATION, newUri);//重定向到带/结尾的请求

		ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);

	}



//返回错误

	private static void sendError(ChannelHandlerContext ctx,HttpResponseStatus status) 

	{

		FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1,
        
				status, Unpooled.copiedBuffer("Failure: " + status.toString()
        
				+ "\r\n", CharsetUtil.UTF_8));

		response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");

		ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);

	}

	private static void setContentTypeHeader(HttpResponse response, File file) {

	
		MimetypesFileTypeMap mimeTypesMap = new MimetypesFileTypeMap();
		//把文件路径化为mime类型——MIME (Multipurpose Internet Mail Extensions) 是描述消息内容类型的因特网标准。
	
		response.headers().set(HttpHeaderNames.CONTENT_TYPE,mimeTypesMap.getContentType(file.getPath()));


	}

}