在线午夜精品自拍小视频_无码av无码专区线_亚洲无码精品人妻_人人澡欧美一区

netty實現(xiàn)tomcat（簡易版）

本篇主要是介紹如何用Netty來實現(xiàn)Tomcat簡易功能

一、Netty是什么？

Netty 是由 JBOSS 提供的一個 Java 開源框架。Netty 提供異步的、基于事件驅動的網絡應用程序框架，用以快速開發(fā)高性能、高可靠性的網絡 IO 程序,是目前最流行的 NIO 框架，Netty 在互聯(lián)網領域、大數(shù)據(jù)分布式計算領域、游戲行業(yè)、通信行業(yè)等獲得了廣泛的應用，知名的 Elasticsearch 、Dubbo 框架內部都采用了 Netty。

Netty不僅支持TCP、UDP協(xié)議，同時也有支持http協(xié)議類型的消息包，這里不專門介紹Netty就不多作描述。

二、Tomcat核心結構圖

三、pom配置

可以只用JDK及依賴netty包就可實現(xiàn)，本文用到fastjson只為將數(shù)據(jù)類型轉換為json格式更加可觀。

<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.56.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.75</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>
四、上代碼

話不多說，碼上安排，步驟有相應注釋，還沒有用過netty的同學們請移步netty文檔簡單了解一番。

1.啟動類：netty運行核心實現(xiàn)，置入解析http消息包

public class MainServer {
    private static final Logger log = LoggerFactory.getLogger(MainServer.class);
    /** 默認端口 */
    private int port = 9999;
 
    public static Map<String, Map<Method, Class<?>>> servlet = new HashMap<>();
 
    static {
        // 此處目的是裝載http接口的處理類，使用反射實現(xiàn)裝載Controller注解的類
        // TODO  pack包路徑必須拷貝自己項目controller那層的(必須是包路徑)
        servlet = new AnnotationScanner().getRequestMapping("com.star.system.netty.controller");
    }
 
    /**
     * 默認端口9999啟動
     */
    public void start() {
        doStart();
    }
 
    /**
     * 自定義端口啟動
     * @param port
     */
    public void start(int port) {
        this.port = port;
        doStart();
    }
 
    /**
     * netty核心簡單實現(xiàn)
     */
    private void doStart() {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();
        ServerBootstrap server = new ServerBootstrap();
        try {
            server.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    //客戶端連接時啟動
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel client) throws Exception {
                            // HTTP應答編碼器
                            client.pipeline().addLast(new HttpResponseEncoder());
                            // HTTP請求解碼器
                            client.pipeline().addLast(new HttpRequestDecoder());
                            // Tomcat之Servlet處理類
                            client.pipeline().addLast(new ServletHandler());
                        }
                    })
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);
            ChannelFuture f = server.bind(port).sync();
            //監(jiān)聽關閉狀態(tài)啟動
            log.info("Netty Server Started, Port:" + port);
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //關閉線程池
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
 
    /**
     * Netty啟動總入口
     * @param args
     */
    public static void main(String[] args) {
        new MainServer().start();
    }
}
2.Tomcat實現(xiàn)：Http消息包解析后并從servlet中找到已映射的接口方法

public class ServletHandler extends ChannelInboundHandlerAdapter {
 
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 判斷消息包是否屬于http類型
        if(msg instanceof HttpRequest){
            // 屬于既強轉為HttpRequest，該類是netty包中自帶的。
            HttpRequest req= (HttpRequest) msg;
            // 自定義request、response的處理類
            HttpRequestServlet request=new HttpRequestServlet(ctx,req);
            HttpResponseServlet response=new HttpResponseServlet(ctx,req);
            String url=request.getUri();
            // 查找已裝配的servlet集合中是否含有該請求
            if(MainServer.servlet.containsKey(url)){
                // 下方將有多處反射查找請求對應接口的方法及請求參數(shù)
                Map<Method, Class<?>> handler = MainServer.servlet.get(url);
                Map<String, List<String>> requestParam = request.getParameters();
                for(Map.Entry<Method, Class<?>> entry : handler.entrySet()) {
                    Method method = entry.getKey();
                    Class<?>[] paramType = method.getParameterTypes();
                    Object clazz = entry.getValue().newInstance();
                    Object paramObj = paramType[0].newInstance();
                    Field[] fields = paramObj.getClass().getDeclaredFields();
                    // 判斷請求參數(shù)是否在接口方法中入?yún)⒋嬖?，如存在且轉換數(shù)據(jù)類型。
                    for(String key : requestParam.keySet()) {
                        for(Field field : fields) {
                            if(key.equals(field.getName())) {
                                field.setAccessible(true);
                                Class<?> type = field.getType();
                                if(type == String.class) {
                                    field.set(paramObj, requestParam.get(key).get(0));
                                    continue;
                                }
                                if(type == int.class || type == Integer.class) {
                                    field.set(paramObj, Integer.valueOf(requestParam.get(key).get(0)));
                                    continue;
                                }
                                if(type == long.class || type == Long.class) {
                                    field.set(paramObj, Long.valueOf(requestParam.get(key).get(0)));
                                    continue;
                                }
                                if(type == byte.class || type == Byte.class) {
                                    field.set(paramObj, Byte.valueOf(requestParam.get(key).get(0)));
                                    continue;
                                }
                                if(type == boolean.class || type == Boolean.class) {
                                    field.set(paramObj, Boolean.valueOf(requestParam.get(key).get(0)));
                                    continue;
                                }
                            }
                        }
                    }
                    // 調用接口方法并傳遞請求參數(shù)。
                    Object retData = method.invoke(clazz, paramObj);
                    response.write(retData);
                }
            }else{
                response.write("404");
            }
        }
    }
 
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        super.exceptionCaught(ctx, cause);
    }
}
3.HttpRequestServlet、HttpResponseServlet、AnnotationScanner

下面代碼就不多寫注釋說明了

public class HttpRequestServlet {
    private ChannelHandlerContext ctx;
    private HttpRequest request;
    public HttpRequestServlet(ChannelHandlerContext ctx, HttpRequest request){
        this.ctx=ctx;
        this.request=request;
    }
    public String getUri(){
        String uri = request.uri();
        String[] s = uri.split("\\?");
        if(s.length < 2) {
            return uri;
        }
        return s[0];
    }
    public String getMethod(){
        return request.method().name();
    }
 
    public Map<String, List<String>> getParameters(){
        QueryStringDecoder decoder=new QueryStringDecoder(request.uri());
        return decoder.parameters();
    }
    public String getParameter(String name){
        Map<String,List<String>> params=getParameters();
        List<String> param=params.get(name);
        if(param==null)return null;
        else return param.get(0);
    }
}

public class HttpResponseServlet {
    private ChannelHandlerContext ctx;
    private HttpRequest request;
    private String code = "UTF-8";
 
    public HttpResponseServlet(ChannelHandlerContext ctx, HttpRequest request) {
        this.ctx = ctx;
        this.request = request;
    }
 
    public void write(Object out) throws Exception {
        try {
            //設置HTTP及請求頭信息
            FullHttpResponse response = null;
            response = new DefaultFullHttpResponse(
                    //設置版本
                    HttpVersion.HTTP_1_1,
                    //設置響應狀態(tài)碼
                    HttpResponseStatus.OK,
                    //設置輸出格式
                    Unpooled.wrappedBuffer(out == null ? "".getBytes(code) : JSON.toJSONBytes(out)));
            response.headers().set("Content-Type", "text/html;");
            ctx.write(response);
        } finally {
            ctx.flush();
            ctx.close();
        }
 
 
    }
}
public class AnnotationScanner {
    private static final Logger log = LoggerFactory.getLogger(AnnotationScanner.class);
    private Set<Class<?>> controllers;
 
    public Map<String, Map<Method, Class<?>>> getRequestMapping(String pack) {
        Map<String, Map<Method, Class<?>>> handler = new HashMap<>();
        for (Class<?> cls : getControllers(pack)) {
            Method[] methods = cls.getMethods();
            for (Method method : methods) {
                RequestMapping annotation = method.getAnnotation(RequestMapping.class);
                if (annotation != null) {
                    String urlValue = annotation.value();
                    if (!urlValue.startsWith("/")) {
                        urlValue = "/" + urlValue;
                    }
                    log.info("loaded servlet:{}", urlValue);
                    Map<Method, Class<?>> invoke = new HashMap<>();
                    invoke.put(method, cls);
                    handler.put(urlValue, invoke);
                }
            }
        }
        return handler;
    }
 
    public Set<Class<?>> getControllers(String pack) {
        if(controllers == null) {
            controllers = new HashSet<>();
            Set<Class<?>> clszzList = getClasses(pack);
            if (clszzList != null && clszzList.size() > 0) {
                for (Class<?> cls : clszzList) {
                    if (cls.getAnnotation(Controller.class) != null) {
                        controllers.add(cls);
                    }
                }
            }
        }
        return controllers;
    }
 
    private Set<Class<?>> getClasses(String pack) {
        Set<Class<?>> classes = new HashSet<>();
        boolean recursive = true;
        String packDirName = pack.replace(".", "/");
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packDirName);
            // 循環(huán)迭代下去
            while (dirs.hasMoreElements()) {
                // 獲取下一個元素
                URL url = dirs.nextElement();
                // 得到協(xié)議的名稱
                String protocol = url.getProtocol();
                // 如果是以文件的形式保存在服務器上
                if ("file".equals(protocol)) {
                    // 獲取包的物理路徑
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以文件的方式掃描整個包下的文件 并添加到集合中，以下倆種方法都可以
                    //網上的第一種方法，
                    findAndAddClassesInPackageByFile(pack, filePath, recursive, classes);
                    //網上的第二種方法
                    //addClass(classes,filePath,packageName);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包文件
                    // 定義一個JarFile
                    JarFile jar;
                    try {
                        // 獲取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 從此jar包 得到一個枚舉類
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同樣的進行循環(huán)迭代
                        while (entries.hasMoreElements()) {
                            // 獲取jar里的一個實體 可以是目錄 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/開頭的
                            if (name.charAt(0) == '/') {
                                // 獲取后面的字符串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定義的包名相同
                            if (name.startsWith(packDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"結尾 是一個包
                                if (idx != -1) {
                                    // 獲取包名 把"/"替換成"."
                                    pack = name.substring(0, idx).replace('/', '.');
                                }
                                // 如果可以迭代下去 并且是一個包
                                if ((idx != -1) || recursive) {
                                    // 如果是一個.class文件 而且不是目錄
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        // 去掉后面的".class" 獲取真正的類名
                                        String className = name.substring(pack.length() + 1, name.length() - 6);
                                        try {
                                            // 添加到classes
                                            classes.add(Class.forName(pack + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        return classes;
    }
 
    /**
     * 以文件的形式來獲取包下的所有Class
     *
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName,
                                                        String packagePath, final boolean recursive, Set<Class<?>> classes) {
        // 獲取此包的目錄 建立一個File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目錄就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            // log.warn("用戶定義包名 " + packageName + " 下沒有任何文件");
            return;
        }
        // 如果存在 就獲取包下的所有文件 包括目錄
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定義過濾規(guī)則 如果可以循環(huán)(包含子目錄) 或則是以.class結尾的文件(編譯好的java類文件)
            @Override
            public boolean accept(File file) {
                return (recursive && file.isDirectory())
                        || (file.getName().endsWith(".class"));
            }
        });
        // 循環(huán)所有文件
        for (File file : dirfiles) {
            // 如果是目錄 則繼續(xù)掃描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "."
                                + file.getName(), file.getAbsolutePath(), recursive,
                        classes);
            } else {
                // 如果是java類文件 去掉后面的.class 只留下類名
                String className = file.getName().substring(0,
                        file.getName().length() - 6);
                try {
                    // 添加到集合中去
                    //classes.add(Class.forName(packageName + '.' + className));
                    classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    // log.error("添加用戶自定義視圖類錯誤 找不到此類的.class文件");
                    e.printStackTrace();
                }
            }
        }
    }
 
}
4.HiController（簡易@Controller，@RequestMapping）、User（多個數(shù)

據(jù)類型，自行測試吧）
@Controller
public class HiController {
 
    @RequestMapping(value = "hi")
    public User hi(User user) {
        return user;
    }
 
    @RequestMapping(value = "say")
    public User say(User user) {
        return user;
    }
 
}
@Data
public class User implements Serializable {
    private Long id;
    private String name;
    private int age;
    private boolean status;
 
    public User() {
    }
 
    public User(Long id, String name, int age, boolean status) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.status = status;
    }
}
5.核心注解Controller、RequestMapping

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Component
public @interface Controller {
}
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestMapping {
 
    String value() default "";
 
}
五、未完待續(xù)

ps：首先說明此簡易版還有無限擴展空間，也沒有進行代碼的優(yōu)化，僅提供一個Tomcat的實現(xiàn)思路。

作者：java知路

歡迎關注微信公眾號 ：java知路