精华内容
下载资源
问答
  • web项目中静态页放在nginx服务器,java程序在tomcat中,tomcat的请求日志和request中都获取不到ip 需要在nginx的配置文件中配置 server{ location ^~ /serviceManager/ {  proxy_connect_timeout 30;  proxy...

    web项目中静态页放在nginx服务器,java程序在tomcat中,tomcat的请求日志和request中都获取不到ip

    需要在nginx的配置文件中配置

    server{

    location ^~ /serviceManager/ {
                       proxy_connect_timeout   30;
                       proxy_send_timeout      30;
                       proxy_read_timeout      30;
                       proxy_pass http://pingtai;
                       proxy_http_version 1.1;
                       proxy_set_header Upgrade $http_upgrade;
                       proxy_set_header Connection "upgrade";
                       proxy_set_header            Host $host:80;
                       proxy_set_header            X-Real-IP $remote_addr;
                       proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;

    }

    }

    当nginx作为反向代理服务器时,获取ip只需要在nginx的配置文件中配置

    http{

       proxy_set_header            Host $host:80;
                    proxy_set_header            X-Real-IP $remote_addr;
                    proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;

    }


    nginx作为静态服务器的nginx的配置:

    user  nginx nginx;
    worker_processes  20;
    worker_rlimit_nofile 65535; 
    events {
        use epoll;
        worker_connections 2048000 ;
    }




    http {


    #    limit_conn_zone $limit zone=one:10m;
    #    limit_req_zone  $limit  zone=req_one:10m rate=50r/s;


        include       mime.types;
        default_type  application/octet-stream;
        sendfile        on;
        keepalive_timeout  60;






         log_format main '$remote_addr - $remote_user [$time_local] "$request" '
                                '"$status" $body_bytes_sent "$http_referer" '
                                '"$http_user_agent" $http_x_forwarded_for "request-time:$request_time" "upstream-time:$upstream_response_time"';
          access_log /home/usr/local/nginx/logs/access.log main;


        client_body_buffer_size 16k;
        client_header_buffer_size 5k;
        client_max_body_size 1m;
        large_client_header_buffers 8 16k;
        fastcgi_buffers 8 128k;
        fastcgi_intercept_errors on;
        proxy_intercept_errors on;


        gzip_min_length 1k;
        gzip_buffers 4 16k;
        gzip_http_version 1.0;
        gzip_comp_level 2;
        gzip_types text/plain application/x-javascript text/css application/xml;
        gzip_vary on;
        gzip  on;


               proxy_redirect              off;
               proxy_set_header            Host $host:80;
               proxy_set_header            X-Real-IP $remote_addr;
               add_header X-Server         $upstream_addr;
               proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;
               #client_max_body_size        10m;
               #client_body_buffer_size     128k;
               proxy_connect_timeout       90;
               proxy_send_timeout          90;
               proxy_read_timeout          90;
               proxy_buffer_size           4k;
               proxy_buffers               4 32k;
               proxy_busy_buffers_size     64k;
               proxy_temp_file_write_size  64k;


               error_page  403       /403.html;
               error_page  404       /404.html;
               error_page  500       /500.html;
               error_page  502       /502.html;
               error_page  503       /503.html;
               error_page  504       /504.html;






    #        default 1;
    #        127.0.0.1 0;
    #        210.5.155.130 0;
    #       49.5.2.6 0;
    #        118.186.138.162 0;
    #                       }
    #    map $whiteiplist  $limit {
    #         1 $binary_remote_addr;
    #         0 "";
    #                       }
       upstream tomcat1{
    #        server 192.168.1.54:81;
    #        server 192.168.1.54:82;
    #        server 192.168.1.54:83;
    #        server 192.168.1.54:84;
    #        server 192.168.1.54:85;
    #        server 192.168.1.54:86;
    #        server 192.168.1.54:87;
    #        server 192.168.1.54:88;
    #        server 192.168.1.54:89;
    #        server 192.168.1.54:90;
            server 192.168.1.54:91;
    #        server 192.168.1.54:92;
                            }


               


        upstream pingtai {
            server 192.168.1.55:93;
        }




        upstream api {
            server 192.168.1.54:92;
        }
    #    server {
    #        listen       80;
    #        location /nginx_status {
    #            stub_status on;
    #            access_log off;
    #            allow 127.0.0.1;
    #            deny all;
    #        }
    #        }


        server {
            listen       80;
            server_name  pingtai.fahaicc.com;
    root /home/usr/local/UI/;
    index login.html;
      
            location ^~ /bower_components/ {
                root    /home/usr/local/UI/;
            }


            location ^~  /app/ {
                root   /home/usr/local/UI/;
                }
            location ^~ /serviceManager/ {
                       proxy_connect_timeout   30;
                       proxy_send_timeout      30;
                       proxy_read_timeout      30;
                       proxy_pass http://pingtai;
                       proxy_http_version 1.1;
                    proxy_set_header Upgrade $http_upgrade;
                    proxy_set_header Connection "upgrade";
                    proxy_set_header            Host $host:80;
                    proxy_set_header            X-Real-IP $remote_addr;
                    proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;
                }
            location ^~  /dashboard {
                    rewrite ^(.*)$ /index.html last;
                }
            #charset koi8-r;


            #access_log  logs/host.access.log  main;


            location = /404.html {
                 root    /home/usr/local/nginx/html;
                              }
            location = /403.html {
                 root    /home/usr/local/nginx/html;
                              }
            location = /500.html {
                 root    /home/usr/local/nginx/html;
                              }
            location = /502.html {
                 root    /home/usr/local/nginx/html;
                              }
            location = /503.html {
                 root    /home/usr/local/nginx/html;
                              }
            location = /504.html {
                 root    /home/usr/local/nginx/html;
                              }
            }

    nginx作为反向代理服务器的nginx的配置:



    user  nginx nginx;
    worker_processes  20;
    worker_rlimit_nofile 65535;
    events {
        use epoll;
        worker_connections 2048000 ;
    }






    http {
        limit_req_zone  $binary_remote_addr  zone=req_one2:10m rate=100r/s;
         limit_conn_zone  $binary_remote_addr zone=one2:10m;
         limit_req   zone=req_one2  burst=100;


        include       mime.types;
        default_type  application/octet-stream;
        sendfile        on;
        keepalive_timeout  60;






         log_format main '$remote_addr - $remote_user [$time_local] "$request" $request_body'
                                '"$status" $body_bytes_sent "$http_referer" '
                                '"$http_user_agent" $http_x_forwarded_for "request-time:$request_time" "upstream-time:$upstream_response_time"';
          access_log /home/usr/local/nginx/logs/access.log main;


        client_body_buffer_size 16k;
        client_header_buffer_size 5k;
        client_max_body_size 1m;
        large_client_header_buffers 8 16k;
        fastcgi_buffers 8 128k;
        fastcgi_intercept_errors on;
        proxy_intercept_errors on;
        gzip_min_length 1k;
        gzip_buffers 4 16k;
        gzip_http_version 1.0;
        gzip_comp_level 2;
        gzip_types text/plain application/x-javascript text/css application/xml;
        gzip_vary on;
        gzip  on;


               proxy_redirect              off;
               proxy_set_header            Host $host:80;
               proxy_set_header            X-Real-IP $remote_addr;
               add_header X-Server         $upstream_addr;
               proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;
               #client_max_body_size        10m;
               #client_body_buffer_size     128k;
               proxy_connect_timeout       90;
               proxy_send_timeout          90;
               proxy_read_timeout          90;
               proxy_buffer_size           4k;
               proxy_buffers               4 32k;
               proxy_busy_buffers_size     64k;
               proxy_temp_file_write_size  64k;


               error_page  403       /403.html;
               error_page  404       /404.html;
               error_page  500       /500.html;
               error_page  502       /502.html;
               error_page  503       /503.html;
               error_page  504       /504.html;




        upstream bank-report {
            server 192.168.1.44:97;
            server 192.168.1.47:97;
         }


        upstream bank-apps {
            server 192.168.1.44:99;
            server 192.168.1.47:99;
         }


        upstream bank-monitor {
            server 192.168.1.44:96;
            server 192.168.1.47:96;
         }


    include /home/usr/local/nginx/conf.bank/*.conf;


       server {
            listen       80 default;
            server_name  localhost;




            location /nginx_status {
                stub_status on;
                access_log off;
                allow 127.0.0.1;
                deny all;
            }
          }
    }

    java构建的web项目中获取ip地址的工具类:

    package com.fahai.cc.service.util;


    import javax.servlet.http.HttpServletRequest;
    import java.net.InetAddress;
    import java.net.UnknownHostException;


    public class TCPIPUtil {




    public static String getIpAddr(HttpServletRequest request) {
    String ipAddress = null;
    // ipAddress = this.getRequest().getRemoteAddr();
    ipAddress = request.getHeader("x-forwarded-for");
    if (ipAddress == null || ipAddress.length() == 0
    || "unknown".equalsIgnoreCase(ipAddress)) {
    ipAddress = request.getHeader("Proxy-Client-IP");
    }
    if (ipAddress == null || ipAddress.length() == 0
    || "unknown".equalsIgnoreCase(ipAddress)) {
    ipAddress = request.getHeader("WL-Proxy-Client-IP");
    }
    if (ipAddress == null || ipAddress.length() == 0
    || "unknown".equalsIgnoreCase(ipAddress)) {
    ipAddress = request.getRemoteAddr();
    if (ipAddress.equals("127.0.0.1")
    || ipAddress.equals("0:0:0:0:0:0:0:1")) {
    // 根据网卡取本机配置的IP
    InetAddress inet = null;
    try {
    inet = InetAddress.getLocalHost();
    ipAddress = inet.getHostAddress();
    } catch (UnknownHostException e) {
    e.printStackTrace();
    }
    }


    }


    // 对于通过多个代理的情况,第一个IP为客户端真实IP,多个IP按照','分割
    if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
    // = 15
    if (ipAddress.indexOf(",") > 0) {
    ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
    }
    }
    return ipAddress;
    }


    }


    展开全文
  • Java实现能获取静态资源的服务器 我们平时使用Tomcat做为服务器进行Web开发,通常会输入http://localhost:8888/index.html这种URL,这种请求的Request Headers 如下: GET /index.html HTTP/1.1 Host: localhost:...

    推荐:Java网络编程汇总

    Java实现能获取静态资源的简易版服务器(类Tomcat)

    我们平时使用Tomcat做为服务器进行Web开发,通常会输入http://localhost:8888/index.html这种URL,这种请求的Request Headers 如下:

    GET /index.html HTTP/1.1
    Host: localhost:8888
    Connection: keep-alive
    Cache-Control: max-age=0
    Upgrade-Insecure-Requests: 1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36
    Sec-Fetch-User: ?1
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
    Sec-Fetch-Site: none
    Sec-Fetch-Mode: navigate
    Accept-Encoding: gzip, deflate, br
    Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
    

    Request Headers 可以得到请求想要访问的静态资源是index.html(我们自己实现服务器,浏览器发起请求,服务器后台得到就是Request Headers这种数据 )。

    现在我们知道如何获取请求想要的资源了(从Request Headers 获取),这就好办了。

    当用户在浏览器中输入URL发起请求,其实就是与服务器先建立网络连接,再获取服务器上的资源。
    这就和Java网络编程有关系了,现在说一说服务器主要的任务:

    • 服务器首先要打开ServerSocket,当有客户端(浏览器)进行连接,并且发起请求后,获得该请求的Request Headers (你可以把浏览器当作我们之前实现的多人聊天室里面的客户端,因为浏览器向服务器发起请求,数据也是通过流Stream或者类似的组件实现的)。
    • 服务器获得用户请求的Request Headers 后,然后从Request Headers 中分析出资源名称。
    • 知道用户想要的资源后,服务器将资源与一些必要信息打包发送给客户端(协议、状态码、资源等),当资源不存在时,服务器返回404.html资源。

    Bootstrap类,启动服务器的模块。

    import connector.Connector;
    
    public final class Bootstrap {
        public static void main(String[] args) {
            Connector connector = new Connector();
            connector.start();
        }
    }
    

    Connector类,创建ServerSocket(用于客户端建立连接)、创建Request(从Request Headers 中获取客户端请求的资源)、创建Response(将协议、状态码、资源等数据打包写入流中)、创建StaticProcessor(借助Response将资源与一些必要信息发送给服务器),代码注释应该非常清楚。

    package connector;
    
    import processor.StaticProcessor;
    
    import java.io.Closeable;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class Connector implements Runnable {
    
        private static final int DEFAULT_PORT = 8888;
    
        private ServerSocket server;
        private int port;
    
        public Connector(){
            this(DEFAULT_PORT);
        }
    
        public Connector(int port) {
            this.port = port;
        }
    
        public void start(){
            new Thread(this).start();
        }
    
        @Override
        public void run() {
            try {
                // 创建ServerSocket,绑定、监听端口
                server = new ServerSocket(port);
                System.out.println("启动服务器,监听端口:" + port);
                while(true){
                    // 等待客户端连接
                    Socket socket = server.accept();
                    // 获取输入流
                    InputStream input = socket.getInputStream();
                    // 获取输出流
                    OutputStream output = socket.getOutputStream();
    
                    // 创建请求request,并且传入输入流(有客户端请求的信息)
                    Request request = new Request(input);
                    // request通过输入流的信息,分析出客户端想要的资源
                    request.parse();
    
                    // 创建响应response,并且传入输出流(方便将获取的资源发送给客户端)
                    Response response = new Response(output);
                    // response需要request的uri(客户端请求的资源)
                    response.setRequest(request);
                    
                    // 创建处理者processor
                    StaticProcessor processor = new StaticProcessor();
                    // processor通过response把数据发送给客户端
                    processor.process(response);
    
                    //关闭socket
                    close(socket);
                }
            } catch (IOException e) {
                // 浏览器可以识别状态码,当状态码表示请求不成功时(如404),似乎会断开socket,所以这里不进行处理
            } finally{
                close(server);
            }
        }
    
        private void close(Closeable closeable){
            if(closeable != null){
                try {
                    closeable.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    Request类,从客户端与服务器建立连接的socket的输入流InputStream中读取信息,并且分析出客户端想要的资源。

    package connector;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    public class Request {
    
        private static final int BUFFER_SIZE = 1024;
    
        private InputStream input;
    
        private String uri;
    
        public Request(InputStream input) {
            this.input = input;
        }
    
        public String getUri() {
            return uri;
        }
    
        public void parse(){
            int length = 0;
            byte[] buffer = new byte[BUFFER_SIZE];
            try {
                // 读取流里面的数据,并且记录长度
                length = input.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            // 将数据转化成StringBuilder
            StringBuilder request = new StringBuilder();
            for (int i = 0; i < length; i++) {
                request.append((char) buffer[i]);
            }
    
            // 分析出客户端想要的资源
            uri = parseUri(request.toString());
        }
    
        /**
         *从 “GET /index.html HTTP/1.1 
         *      ......
         *       ”中获取index.html
         * 通过空格来分离出来
         * */
        public String parseUri(String request){
            int index1 , index2;
            // 第一个空格的位置
            index1 = request.indexOf(' ');
            if(index1 != -1){
                // 第二个空格的位置
                index2 = request.indexOf(' ', index1+1);
                if(index2 != -1){
                    // 分离出资源名称
                    return request.substring(index1 + 2 , index2);
                }
            }
            // 没有办法解析出uri
            return "";
        }
    }
    

    Response类,将协议、状态码、资源等数据打包写入流中。

    package connector;
    
    import java.io.*;
    
    public class Response {
    
        private static final int BUFFER_SIZE = 1024;
        Request request;
        OutputStream output;
    
        public Response(OutputStream output) {
            this.output = output;
        }
    
        public void setRequest(Request request) {
            this.request = request;
        }
    
        public void sendStaticResource() throws IOException {
            try{
                // 通过request的uri,获取资源的路径
                String filePath = getClass()
                        .getClassLoader()
                        .getResource(request.getUri()).getFile();
                // 创建资源文件
                File file = new File(filePath.substring(1 , filePath.length()));
                // 将资源写入流里面,HttpStatus.SC_OK是状态码
                write(file , HttpStatus.SC_OK);
            } catch (Exception e) {
                // 当出现错误时,简单处理 ,发送404.html给客户端
                String errorFilePath = getClass().getClassLoader().getResource("404.html").getFile();
                // 将资源写入流里面,HttpStatus.SC_NOT_FOUND是状态码
                write(new File(errorFilePath.substring(1 , errorFilePath.length())) ,
                        HttpStatus.SC_NOT_FOUND);
    
            }
        }
    
        private void write(File resource , HttpStatus status) throws IOException {
            
            try(FileInputStream fis = new FileInputStream(resource)){
                // 先将协议、状态码等必要信息写入流中,ConnectorUtils是工具类
                output.write(ConnectorUtils.renderStatus(status).getBytes());
                byte[] buffer = new byte[BUFFER_SIZE];
                int length = 0;
                // 把资源文件写入流中
                while((length = fis.read(buffer , 0 , BUFFER_SIZE)) != -1){
                    output.write(buffer , 0 ,length);
                }
            }
        }
    }
    

    HttpStatus类,状态码枚举类。

    package connector;
    
    public enum HttpStatus {
        SC_OK(200 , "OK"),
        SC_NOT_FOUND(404 , "File Not Found");
    
        private int statusCode;
        private String reason;
    
        HttpStatus(int statusCode, String reason) {
            this.statusCode = statusCode;
            this.reason = reason;
        }
    
        public int getStatusCode() {
            return statusCode;
        }
    
        public String getReason() {
            return reason;
        }
    }
    

    ConnectorUtils类(工具类),将协议、状态码等信息组装成浏览器可以识别的信息。

    package connector;
    
    public class ConnectorUtils {
    
        public static final String PROTOCOL = "HTTP/1.1";
    
        public static final String CARRIAGE = "\r";
    
        public static final String NEWLINE = "\n";
    
        public static final String SPACE = " ";
    
        public static String renderStatus(HttpStatus status){
            StringBuilder sb = new StringBuilder(PROTOCOL)
                    .append(SPACE)
                    .append(status.getStatusCode())
                    .append(SPACE)
                    .append(status.getReason())
                    .append(CARRIAGE).append(NEWLINE)
                    .append(CARRIAGE).append(NEWLINE);
            return sb.toString();
        }
    }
    

    StaticProcessor类,做为静态资源处理者的身份,借助Response进行处理。

    package processor;
    
    import connector.Response;
    
    import java.io.IOException;
    
    public class StaticProcessor {
    
        public void process(Response response){
            try {
                response.sendStaticResource();
            } catch (IOException e) {
                // 不处理浏览器断开连接等错误
            }
        }
    }
    

    这里我们便完成了一个Java实现的能获取静态资源的简易版服务器。

    项目结构
    在这里插入图片描述
    项目源码

    Java实现获取静态资源的服务器

    测试

    请求成功,服务器有资源。
    在这里插入图片描述
    在这里插入图片描述

    请求失败,服务器没有资源。

    在这里插入图片描述

    在这里插入图片描述

    大家可以动手试一试,不用ServerSocket来实现,用NIO模型或者AIO模型的组件来实现。

    如果有说错的地方,请大家不吝赐教(记得留言哦~~~~)。

    展开全文
  • tomcat获取客户端请求图: 1、Request类 package request; import response.Response; import java.io.IOException; import java.io.InputStream; /** * version1.0 访问项目下得静态资源 * 这个类主要是把从...

    tomcat获取客户端请求图:在这里插入图片描述

    1、Request类

    package request;
    
    import response.Response;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * version1.0 访问项目下得静态资源
     * 这个类主要是把从socket拿到得输入流解析一下,解析url出来
     *
     */
    public class Request {
    
        private InputStream is;
    
        //请求路径
        private String url;
    
        public Request(){
    
        }
    
        public Request(InputStream is){
            this.is = is;
        }
    
        /**
         * 解析url
         */
        public void parse(){
            StringBuffer request = new StringBuffer(Response.BUFFER_SIZE);
    
            byte[] buffer = new byte[Response.BUFFER_SIZE];
    
            int i = 0;
            try{
                i = is.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            for (int j = 0; j < i; j++) {
                request.append((char)buffer[j]);
            }
            System.out.println(request.toString());
            this.url = parseUrl(request.toString());
        }
    
    
        /**
         *
         * @param request
         * @return
         */
        private String parseUrl(String request) {
            int index1,index2;
            //查看socket获取的请求头是否有值
            index1 = request.indexOf(' ');
            if (index1 != -1){
                index2 = request.indexOf(' ', index1 + 1);
                if (index2 > index1){
                    return request.substring(index1 + 1,index2);
                }
            }
            return null;
        }
    
        public String getUrl(){
            return url;
        }
    }
    
    

    2、Response类

    package response;
    
    import request.Request;
    
    import java.io.*;
    
    
    public class Response {
    
        public static final Integer BUFFER_SIZE = 2048;
    
        private static final String WEB_ROOT = "D:";
    
        private Request request;
    
        private OutputStream outputStream;
    
        public Response(OutputStream outputStream){
            this.outputStream = outputStream;
        }
    
        public void setRequest(Request request) {
            this.request = request;
        }
    
        public void sendStaticResource() throws IOException{
            byte[] buffer = new byte[BUFFER_SIZE];
            FileInputStream fis = null;
            File file = new File(WEB_ROOT,request.getUrl());
            String returnMsg = null;
            try {
                if(file.exists() && !file.isDirectory()){
                    fis = new FileInputStream(file);
                    StringBuilder sb = new StringBuilder();
                    int length;
                    while ((length = fis.read(buffer,0,buffer.length)) != -1){
                        sb.append(new String(buffer,0,length,"gbk"));
                    }
                    returnMsg = "HTTP/1.1 200 OK\r\n" +
                                "Content-Type: text/html \r\n" +
                                "Content-Length: "+sb.length()+"\r\n"+
                                "\r\n"+
                                sb.toString();
                }else{
                    String errorMsg = "<h1>" + file.getName() + " file or directory not exists</h1>";
                    returnMsg = "HTTP/1.1 404 File Not Fount\r\n" +
                            "Content-Type: text/html \r\n" +
                            "Content-Length: "+errorMsg.length()+"\r\n"+
                            "\r\n"+
                            errorMsg;
                }
                outputStream.write(returnMsg.getBytes());
            }catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (fis != null){
                    fis.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
            }
        }
    
    }
    
    

    3、HTTPServer类

    package server;
    
    import request.Request;
    import response.Response;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class HTTPServer {
    
        public void acceptWait() throws IOException {
            ServerSocket serverSocket = null;
            try {
                serverSocket = new ServerSocket(8080, 3, InetAddress.getByName("127.0.0.1"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            while (true){
                try {
                    Socket socket = serverSocket.accept();
                    InputStream is = socket.getInputStream();
                    OutputStream os = socket.getOutputStream();
    
                    Request request = new Request(is);
                    request.parse();
    
                    Response response = new Response(os);
                    response.setRequest(request);
                    response.sendStaticResource();
    
                    socket.close();
                }catch (IOException e){
                    e.printStackTrace();
                    continue;
                }
            }
        }
    }
    
    

    4、Main启动类

    import server.HTTPServer;
    
    import java.io.IOException;
    
    public class Main {
    
        public static void main(String[] args) throws IOException {
            HTTPServer httpServer = new HTTPServer();
            httpServer.acceptWait();
        }
    }
    
    
    • http请求
      在这里插入图片描述

    • http响应
      在这里插入图片描述
      把以前同事的文章抄过来水一水,模拟tomcat访问静态资源

    展开全文
  • 正常情况下通过request.getSession().getServletContext().getRealPath("/") 获取项目的目录,在该目录下面 创建文件夹保存上传的文件, 然后通过http://localhost:8080/项目名/文件名,访问文件,但是如果整体...

    正常情况下通过request.getSession().getServletContext().getRealPath("/")  获取项目的目录,在该目录下面 创建文件夹保存上传的文件,


    然后通过http://localhost:8080/项目名/文件名,访问文件,但是如果整体打包发布项目  会把之前创建的目录给覆盖掉,除非每次针对单个文件替换或者先把上传的文件拷贝出来,然后发不完项目在将之前上传的文件拷贝的对应的目录中,感觉很繁琐。

    如果想要让文件保存在项目外的其他固定的路径,就要使用到tomcat的虚拟路径了,如下图所示,指定虚拟路径地址为D://data目录




    如果文件存放的目录如下图所示:



    那么访问test.png  可以这样访问

    http://localhost:8080/image/icon/test.png

    展开全文
  • Apache Tomcat Web应用服务器(二) ...封装Request和Response对象依赖的工具类:静态资源工具类StaticResourceUtil第四步:定义动态的Servlet接口及其相关的实现方法定义配置文件,注册自定义的Servlet,完成加载操
  • http_request

    2020-11-09 09:23:10
    目录今日内容一、ServletServlet大体了解虚拟路径前台发送请求==必须==有虚拟路径后台转发==禁止==写虚拟路径后台重定向==根据需要==带上虚拟路径tomcat项目目录结构目录结构静态资源的访问==注意==二、HTTP协议**1....
  • how-tomcat-works

    2011-06-30 13:09:09
    3.3.3.7 静态资源处理器和servlet处理器 17 第4章 tomcat的默认连接器 18 4.1 简介 18 4.2 HTTP1.1的新特性 18 4.2.1 持久化连接 18 4.2.2 编码 18 4.2.3 状态码100的使用 19 4.3 Connector接口 19 4.4 ...
  • 3.3.3.7 静态资源处理器和servlet处理器 17 第4章 tomcat的默认连接器 18 4.1 简介 18 4.2 HTTP1.1的新特性 18 4.2.1 持久化连接 18 4.2.2 编码 18 4.2.3 状态码100的使用 19 4.3 Connector接口 19 4.4 ...
  • 总的来说就是通过代理服务器访问服务器,页面通过request.getserverPort方法获取端口,当服务器为websphere的时候,不能获取到正确的代理服务器端口,但是用tomcat作为服务器时,可以正确获取端口。 不知道...
  • JSP中URL路径获取问题

    2018-12-03 13:07:00
    项目需求是内网也就是ip+端口号可以访问资源,但是后来要上外网可以访问,资源...1 获取域名或者/前第一个请求的url名称方法是 request.getServerName(); 2 在通过basePath请求静态资源的时候,如果src开头有 "/",...
  • )方法是可以获取静态资源路径的。但是spring boot获取的是内部容器的地址,如C:\Users\cjj\AppData\Local\Temp\tomcat-docbase.2424851108757135007.8088\ 这样我们无法使用request.getRealPath...
  • cookie和session技术入门

    2019-04-05 16:03:24
    向我们的服务器访问服务端指定项目下的某个静态的资源例如:XXX.html,XXX.js,XXX.css等,也可以访问服务端的动态运行着的程序让其执行,并且可以在程序中通过request获取HTTP协议的请求部分,利用request实现转发,也能...
  • SpringBoot常用注解总结

    2020-06-28 22:38:22
    目录Spring Boot@Controller和@RequestMapping@RequestMapping标注类@RequestMapping的简写形式返回HTML本地资源文件组织服务器中的静态资源文件@PathVariable定义URL变量规则获取URL变量匹配正则表达式@...
  • 2.2.2 获取Tomcat安装程序包 44 2.2.3 使用zip和tar.gz包安装Tomcat 44 2.2.4 使用exe程序安装Tomcat 46 2.3 Tomcat的启动与停止 50 2.3.1 使用Tomcat服务程序 50 多学两招:查找网络服务程序监听异常的问题 2.3.2 ...
  • JSP程序设计从入门到精通.pdf

    千次下载 热门讨论 2011-04-13 13:13:58
    2.8.3实例3(JSP里request变量列表) 42 2. 9本章小结 44 第3章JavaBean组件 44 3.1 什么是JavaBeans 45 3.1.1 JavaBeans 简介 45 3.1.2 JavaBeans 属性 45 3.1.3 JavaBeans 的事件 50 3.2 在Jsp中使用JavaBeans 55 ...
  • 2.2.2 Tomcat的下载与安装 20 2.2.3 显示字体实例 23 2.3 安装与配置Eclipse 25 2.3.1 Eclipse简介 25 2.3.2 安装MyEclipse 26 2.3.3 Eclipse加载Tomcat 30 2.3.4 在Eclipse中创建JSP 31 2.4 JSP页面执行流程 36 2.5...
  • 1.4.3 获取Tomcat 1.4.4 熟悉Tomcat的五脏六腑 1.5 JavaWeb开发利器之Eclipse 1.5.1 获取Eciipse 1.5.2 运行Eclipse 1.5.3 打造中文版Eclipse 1.6 做好项日开发的准备工作 1.6.1 集成Eelipse与Tomcat 1.6.2 完善web...
  • 1.4.3 获取Tomcat 1.4.4 熟悉Tomcat的五脏六腑 1.5 JavaWeb开发利器之Eclipse 1.5.1 获取Eciipse 1.5.2 运行Eclipse 1.5.3 打造中文版Eclipse 1.6 做好项日开发的准备工作 1.6.1 集成Eelipse与Tomcat 1.6.2 完善web...
  • JSP 程序设计从入门到精通 PDF 教程

    热门讨论 2012-04-13 18:08:01
     2.8.3实例3(JSP里request变量列表) 42  2. 9本章小结 44  第3章JavaBean组件 44  3.1 什么是JavaBeans 45  3.1.1 JavaBeans 简介 45  3.1.2 JavaBeans 属性 45  3.1.3 JavaBeans 的事件 50  3.2 ...
  • fckeditor for jsp 的jar包

    2008-10-03 19:52:44
    我在这两个文件中都是加了一个静态变量encoding,private static String encoding;保存项目中的编码, 若在web.xml文件中没有给这个变量传值的话,默认是gb2312,如下代码if(encoding.isEmpty()){encoding="gb2312";}...
  • 框架底层是借助ThreadLocal从当前线程上获取事先绑定的Request对象) HttpServletRequest request = requestContext.getRequest(); // 3.获取servletPath值 String servletPath = ...
  • 实例105 通过request对象进行数据传递 实例106 通过cookie保存并读取用户登录信息 实例107 实现重定向页面 实例108 防止表单在网站外部提交 实例109 通过Application对象实现网站计数器 实例110 记录用户IP...
  • 实例105 通过request对象进行数据传递 实例106 通过cookie保存并读取用户登录信息 实例107 实现重定向页面 实例108 防止表单在网站外部提交 实例109 通过Application对象实现网站计数器 实例110 记录用户IP...
  • java初学者必看

    热门讨论 2012-02-24 16:07:34
    16.3.5 获取Connection连接对象 16.4 Java与各种数据库连接 16.5 本章习题 第17章 Java Web应用——JSP 17.1 JSP技术概述 17.2 JSP运行环境搭建 17.2.1 Tomcat下载与安装 17.2.2 Tomcat的环境变量配置 17.3 ...
  • 告诉FileUpload组件处理时的编码为项目编码,在FileItem中,用getString(encoding),这项设置可以解决获取的表单字段为乱码的问题,所以在每个FileItem实例后面都执行一次getString(encoding),就告诉FileItem在取值...
  • Kotlin 是一种静态类型的JVM语言,它让代码具有表现力,简洁性和可读性。 Spring5.0 对 Kotlin 有很好的支持。 7. 移除的特性 随着 Java、JavaEE 和其他一些框架基准版本的增加,SpringFramework5 取消了对几个...
  • redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址,一般来说浏览器会用刚才请求的所有参数重新请求,所以session,request参数都可以获取。 23、EJB与JAVA BEAN的区别?  Java Bean 是可...
  • java 面试题 总结

    2009-09-16 08:45:34
    redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址,一般来说浏览器会用刚才请求的所有参数重新请求,所以session,request参数都可以获取。 20、EJB与JAVA BEAN的区别? Java Bean 是可复用...

空空如也

空空如也

1 2 3
收藏数 45
精华内容 18
关键字:

tomcat静态获取request