lagou 爪哇 2-1 tomcat / nginx 笔记

location /abc {
 proxy_pass http://myServer/;
}

upstream myServer{
 server 111.229.248.243:8080;
 server 111.229.248.243:8082;
}

upstream myServer{
 server 111.229.248.243:8080 weight=1;
 server 111.229.248.243:8082 weight=2;
}

upstream myServer{
 ip_hash;
 server 111.229.248.243:8080;
 server 111.229.248.243:8082;
}

<?xml version="1.0" encoding="utf-8" ?>
<Server>
    <services>
        <!--监听端口号-->
        <Connector port="80"/>
        <Engine>
            <!--appBase 为部署目录-->
            <Host name="localhost" appBase="C:/Users/hp/Desktop/第二阶段模块1/第二阶段模块1/code/myWebapps" />
        </Engine>
    </services>
</Server>

index.html
edu/lagou/server/LagouServlet01.class
edu/lagou/server/LagouServlet02.class
web.xml

index.html
edu/lagou/server/LagouServlet03.class
web.xml

public class Mapper {

    /**
     * 一级目录 以及 对应的动态资源
     */
    private Map<String, Map<String, HttpServlet>> content2Wrapper = new HashMap<>();

    /**
     * 一级目录 以及 对应的相对路径
     */
    private Map<String, String> resourcesMap = new HashMap<>();

    public void putStaticResources(String key, String value) {
        resourcesMap.put("/" + key, value);
    }

    public void putServletMap(String key, Map<String, HttpServlet> value) {
        content2Wrapper.put("/" + key, value);
    }

    public Map<String, HttpServlet> getServletMap(String key) {
        return content2Wrapper.get(key);
    }

    public String getStaticPath(String key) {
        return resourcesMap.get(key);
    }
}

public class MyClassLoader extends ClassLoader {


    public MyClassLoader(String basePath) {
        this.basePath = basePath;
    }

    /**
     * @description 解析类文件获得当前解析后的类
     * @param fullClassName 档期类的完全限定名， 例如 edu.lagou.server.my.Person
     * @return 使用类加载器后获取的类
     * @throws Exception 解析错误
     */
    public Class<?> transClassFile(String fullClassName) throws Exception {
        byte[] classBytes = this.loadBinaryClassFile(fullClassName);
        //主要通过父类来解析当前的class二进制文件
        return super.defineClass(fullClassName, classBytes, 0, classBytes.length);
    }

    /**
     * @description 读取并加载类文件获得byte数组返回
     * @return byte[] 数组
     * @throws Exception 读取失败
     */
    private byte[] loadBinaryClassFile(String packageName) throws Exception {
        String relativePath = packageName.replaceAll("\\.", "/");
        String classFilePath = this.basePath + "/" +relativePath + ".class";// 设置当前class文件的路径
        File classFile = new File(classFilePath);
        if (!classFile.exists()) {
            throw new FileNotFoundException(classFile.getAbsolutePath() + "文件不存在。。。。。。。。。。");
        }
        InputStream fis = null;
        ByteArrayOutputStream bos = null;// 内存流
        byte[] bytes = new byte[(int) classFile.length()]; // 设置缓冲区

        byte[] readBytes = null;
        try {
            bos = new ByteArrayOutputStream();
            // 开始实例化流，并加载流
            fis = new FileInputStream(classFile);// 这里必须为文件的实际路径
            while (( fis.read(bytes)) != -1) {
                bos.write(bytes);
            }
            readBytes = bos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                fis.close();
            }
            if (bos != null) {
                bos.close();
            }
        }
        return readBytes;
    }

    private final String basePath;
}

private void loadServerXML() {
        InputStream inputStream = Bootstrap.class.getClassLoader().getResourceAsStream("server.xml");
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(inputStream);
            Element rootElement = document.getRootElement();
            Node portNode = rootElement.selectSingleNode("/Server/services/Connector/@port");
            this.port = Integer.parseInt(portNode.getStringValue());
            System.out.println("配置 port = " + this.port);

            Node appBaseNode = rootElement.selectSingleNode("/Server/services/Engine/Host/@appBase");
            this.appBase = appBaseNode.getStringValue();
            System.out.println("配置 appBase = " + this.appBase);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void loadAppBaseServlet() {
        File file = new File(this.appBase);
        for (File f : Objects.requireNonNull(file.listFiles())) {
            if (f.isDirectory()) {
                // 解析 web.xml 并加载对应的 HttpServlet 类
                String webXmlFileName = f.getAbsolutePath() + "/" + "web.xml";
                File webXmlFile = new File(webXmlFileName);
                // 如果连 web.xml 不存在 则跳过该目录。
                if (webXmlFile.exists()) {
                    String fileName = f.getName();
                    System.out.println(fileName);
                    System.out.println("--------------");
                    System.out.println("...加载该目录" + f.getPath());
                    System.out.println(webXmlFileName);
                    // 加载对应的 各项目父路径 和 对应的 url-patten与servlet动态资源的对应关系, 例如 /demo1 -> （/lagou -> LagouServlet对象）
                    try {
                        InputStream inputStream = new FileInputStream(webXmlFile);
                        Map<String, HttpServlet> stringHttpServletMap = this.loadServletFromInputStream(inputStream,
                                new MyClassLoader(f.getAbsolutePath()));
                        this.mapper.putServletMap(fileName, stringHttpServletMap);

                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
                    // 加载对应的 各项目父路径 和 对应静态资源父目录的对应关系, 例如 /demo1 -> appBase/demo1
                    this.mapper.putStaticResources(fileName, f.getAbsolutePath());
                } else {
                    System.out.println("...跳过该目录" + f.getPath());
                }
            }
        }
    }

// url
            String url = request.getUrl();
            // 截取两端/index.html    / + index.html
            // /demo1/lagou
            String[] split = url.split("/");
            String part1;
            String part2;
            if (split.length == 2) {
                part1 = "/" + split[0];
                part2 = "/" + split[1];
            } else {
                part1 = "/" + split[1];
                part2 = "/" + split[2];
            }
            Map<String, HttpServlet> stringHttpServletMap = this.mapper.getServletMap(part1);
            if (stringHttpServletMap != null) {
                HttpServlet httpServlet = stringHttpServletMap.get(part2);
                // process static resources
                if (null == httpServlet) {
                    String filePath = this.mapper.getStaticPath(part1);
                    response.outputHtml(filePath, part2);
                } else {
                    httpServlet.service(request, response);
                }
            } else {
                // 404
                response.outputHtml("NOT FOUND");
            }

        String resourcePath = StaticResourceUtil.class.getResource("/").getPath();
        System.out.println(resourcePath);
        // 如果包含特殊字符，需要进行一次 URL 解码工作
        try {
            resourcePath = java.net.URLDecoder.decode(resourcePath, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }