What's a Web Server?It's a server u

What's a Web Server?

It's a server used to communicate with Web Browsers as its clients and the communication protocol used in this case is HTTP (HyperText Transfer Protocol). This is why a Web Server is also called an HTTP Server.

Before moving on to discussing how a typical Web Server works, it's better to understand what exactly the HTTP is all about? If you don't know it already then you may like to go through this article.

How does a Web Server work?

As is the case with any client-server comunication, in this case also the client (i.e., the Web Browser) and the server (i.e., HTTP/Web Server) should be able to communicate with each other in a defined way. This pre-defined set of rules which form the basis of the communication are normally termed as a protocol and in this case the underlying protocol will be HTTP.

Irrespective of how the client or the server has been implemented, there will always be a way to form a valid HTTP Request for the client to work and similarly the server needs to be capable of understanding the HTTP Requests sent to it and form valid HTTP Responses to all the arrived HTTP Requests. Both the client and the server machines should also be equipped with the capability of establishing the connection to each other (in this case it'll be a TCP reliable connection) to be able to transfer the HTTP Requests (client -> server) and HTTP Responses (server -> client).

How these things can be done, depends on a variety of factors including the very important factor - what's the choice of programming language. Let's take Java as the programming language here. Now the question arises - How can we implement a typical Web Server using Java? Okay... let's try it. For a Web Server to work perfectly, we need the client to form and send valid HTTP Requests to it. So, the Web Browser (client in this case) should be also be discussed for how it can have those required capabilities. Let's consider that the browser is also being implemented in Java only. The other preferred language for developing Web Browsers is C++ and we use Sockets to implement the above mentioned capabilities in a Web Browser. Implementation of Sockets in C++ is quite similar to that in Java (at least conceptually). Java makes the overall implementation relatively simpler and that's the only difference we would notice.

HTTP Request building and transfer by the client (i.e., by a Web Browser)

In this case, the Browser will use the java.net.Socket class to establish itself as one endpoint of the communication on a TCP reliable connection (the other endpoint will be another Socket instance returned by the accept() method of the ServerSocket class at the server). For creating a socket and being able to communicate to a machine, we need to know two things - the IP Address and the Port Number. In our case, a part of the URL will help us getting the IP Address of the server and for HTTP protocol the default port is assumed to be 80. The DNS server gives the IP Address for a valid URL entered into the address bar of a typical Web Browser. You can enter the IP Address directly as well, but it'll of course be extremely difficult to remember the IP Addresses and of course they won't be so self-explanatory (as compared to typical URLs).

So, if we type www.google.com in the address bar of the web browser, then a Socket will probably be created using the construtor 'public Socket(String host, int port)' and the statement will be something similar to 'Socket socket = new Socket("www.google.com", 80);'. After the successful creation of the Socket instance, the client will be able to send/receive stream of bytes simply by using the OutputStream/InputStream associated with the Socket instance. The HTTP Request is created by examining the client machine (for HTTP Request Headers) and the URL (for HTTP Method and the URI of the resource being requested). Once the client has successfully created a valid HTTP Request, it'll use the TCP connection established using the Socket (at the client machine) and ServerSocket (at the server machine... we'll discuss it next) objects to transfer the HTTP Request to the Web Server.

HTTP Response building and transfer by the server (i.e., by a Web Server)

The Web Server needs to listen to the connection requests made by various clients and it should also be equipped with the capability of accepting HTTP Requests, understanding the requests, forming the corresponding HTTP Responses, and finally to transfer it to the appropriate client machines. The Web Server may use a java.net.ServerSocket object to do all these tasks. It may use one of the constructors of this class 'public ServerSocket(int port, int backlog, InetAddress bindAddr)'. Here port specifies the port number where the ServerSocket object will listen; backlog specifies the maximum number of queued requests before the ServerSocket object will start refusing any more incoming HTTP Requests; and the bindAddr specifies the IP Address of the machine where this ServerSocket object will listen to the incoming requests. So, it's normally the loopback address i.e., '127.0.0.1'.

After we are ready with a working ServerSocket instance, we can call the instance method having the signature as 'public Socket accept() throws IOException' for listening to the connection requests made by the client machines to this server. This method blocks until a connection is made and after that it returns a new Socket object, which forms the second endpoint of the communication between the client and the server. If there is a Security Manager at the server machine then the checkAccept() method is called with socket.getInetAddress().getHostAddress and socket.getPort() as parameters, where 'socket' is the newly returned Socket instance returned by the accept() method. If the checkAccept() method returns as the operation to be allowed then only we can proceed further otherwise a SecurityException will be raised and the communication will be terminated instantly.

If the Security Manager allows the operation then the newly created Socket instance will be used to retrieve the InputStream and the OutputStream associated with it, which the Web Server will ultimately use to read the HTTP Request from and to write the HTTP Response to. It's important to understand here that the InputStream os this Socket instance is just a replica of the OutputStream of the Socket instance at the client end. Whatever is written there is simply transferred by using the reliable TCP communication. Similarly, the OutputStream associated with the Socket instance at the server will be a replica of the InputStream associated with the Socket instance at the client end. We don't need to do anything extra than creating the Socket instance at the client end with appropriate parameters, creating the ServerSocket instance at the server end, call the accept() method ion this ServerSocket instance, and use the returned Socket instance by the accept() method to read and write the HTTP Request and Response. Everything else is taken care by the library classes of the java.net package. So simple, isn't it? That's the beauty of Java!

This Web Server is normally a multithreaded one, where the accept() on the ServerSocket object will return a Socket instance in a newly spawned Thread and the responsibilities of reading the request, processing it, forming the response, and sending the response back to corresponding client is delegated to this Thread only whereas the main thread keeps on running the accept() method indefinitely (till the server machine shuts down :-)) for accepting the incoming requests coming to this server.

ผลลัพธ์ (ไทย) 1:

เว็บเซิร์ฟเวอร์คืออะไร?

เป็นเซิร์ฟเวอร์ที่ใช้ในการสื่อสารกับเว็บเบราว์เซอร์เป็นลูกค้า และโพรโทคอลการสื่อสารที่ใช้ในกรณีนี้คือ HTTP (HyperText ถ่ายโอนโพรโทคอล) นี่คือเหตุผลที่เรียกว่าเว็บเซิร์ฟเวอร์ยังเซิร์ฟเวอร์ HTTP มีการ

ก่อนที่จะย้ายในการสนทนาวิธีการทำงานของเว็บเซิร์ฟเวอร์ทั่วไป ดีกว่าเข้าใจว่า HTTP คืออะไรทั้งหมดเกี่ยวกับ ถ้าคุณไม่รู้แล้วคุณอาจต้องไปผ่านบทความนี้

ไม่เว็บเซิร์ฟเวอร์ทำงานอย่างไร?

เป็นในกรณีของ comunication ใด ๆ ไคลเอ็นต์-เซิร์ฟเวอร์ ในกรณีนี้ (เช่น เว็บเบราเซอร์) ไคลเอ็นต์และเซิร์ฟเวอร์ (เช่น HTTP/เว็บ เซิร์ฟเวอร์) ควรสามารถสื่อสารกันในแบบที่กำหนด ชุดของกฎที่เป็นพื้นฐานของการสื่อสารกำหนดไว้ล่วงหน้านี้จะเรียกว่าเป็นโพรโทคอปกติ และในกรณีนี้ โพรโทคอลแบบจะเป็น HTTP

ไม่ว่าไคลเอนต์หรือเซิร์ฟเวอร์ที่มีการใช้ เสมอจะมีวิธีการร้องขอ HTTP ถูกต้องสำหรับไคลเอ็นต์การทำงาน และในทำนองเดียวกัน เซิร์ฟเวอร์ต้องสามารถเข้าใจการร้องขอ HTTP ที่ส่งไปยัง และการตอบสนอง HTTP ถูกต้องไปทั้งหมดที่มาร้องขอ HTTP ไคลเอ็นต์และเครื่องเซิร์ฟเวอร์ควรยังมีพร้อมทั้งความสามารถในการสร้างการเชื่อมต่อกัน (ในกรณีนี้ก็จะเชื่อมต่อที่เชื่อถือได้ของ TCP) เพื่อให้สามารถโอนย้ายการร้องขอ HTTP (ไคลเอนต์->เซิร์ฟเวอร์) และการตอบสนอง HTTP (เซิร์ฟเวอร์->ไคลเอนต์) ได้

ว่าสิ่งเหล่านี้สามารถทำได้ ขึ้นอยู่กับหลายปัจจัยรวมถึงปัจจัยที่สำคัญมาก - เลือกภาษาการเขียนโปรแกรมคืออะไร ลองใช้ Java เป็นภาษาโปรแกรมที่นี่ ตอนนี้คำถามที่เกิดขึ้น - วิธีสามารถเรานำเซิร์ฟเวอร์เว็บทั่วไปที่ใช้ Java โอเควัน...ลองทำ สำหรับเว็บเซิร์ฟเวอร์ให้ทำงานอย่างสมบูรณ์แบบ เราต้องไคลเอ็นต์เพื่อสร้าง และส่งการร้องขอ HTTP ที่ถูกต้อง ดังนั้น เว็บเบราว์เซอร์ (ไคลเอนต์ในกรณีนี้) ควรจะยังทำการสนทนาได้ว่าสามารถมีความสามารถที่ต้องการ ลองพิจารณาว่า เบราว์เซอร์ยังถูกใช้ในจาวาเท่านั้น อื่น ๆ ภาษาที่ต้องการสำหรับพัฒนาเว็บเบราว์เซอร์เป็น C และเราใช้ซ็อกเก็ตการใช้ความสามารถกล่าวในเว็บเบราว์เซอร์ ใช้งานของซ็อกเก็ตใน C จะค่อนข้างคล้ายกับใน Java (น้อยทางแนวคิด) Java ทำให้ใช้งานโดยรวมค่อนข้างง่ายกว่า และที่แตกต่างเราจะสังเกต

สร้างการร้องขอ HTTP และโอนจากลูกค้า (เช่น โดยเว็บเบราว์เซอร์)

ในกรณีนี้ เบราว์เซอร์จะใช้ java.netซ็อกเก็ตชั้นการสร้างตัวเองเป็นหนึ่งปลายทางของการสื่อสารบน TCP เชื่อถือได้เชื่อมต่อ (ปลายทางอื่น ๆ จะเป็นซ็อกเก็ตตัวกลับ โดยวิธี accept() คลา ServerSocket ในเซิร์ฟเวอร์) สร้างซ็อกเก็ต และความสามารถในการสื่อสารกับเครื่องจักร เราต้องรู้สองสิ่ง - อยู่ IP และหมายเลขพอร์ต ในกรณีของเรา เป็นส่วนหนึ่งของ URL จะช่วยให้เราได้รับอยู่ IP ของเซิร์ฟเวอร์ และสำหรับโพรโทคอล HTTP พอร์ตเริ่มต้นจะสรุปให้เป็น 80 เซิร์ฟเวอร์ DNS ให้อยู่ IP สำหรับ URL ถูกป้อนลงในแถบอยู่ของเว็บเบราเซอร์ทั่วไป คุณสามารถป้อนอยู่ IP โดยตรงด้วย แต่ก็แน่นอนจะยากมากที่จะจำ IP แอดเดรส และแน่นอนจะไม่ self-explanatory มาก (เมื่อเทียบกับ Url ปกติ)

ดังนั้น ถ้าเราพิมพ์ www.google.com ในแถบอยู่ของเว็บเบราว์เซอร์ แล้วซ็อกเก็ตจะอาจสร้างโดยใช้การ construtor ' ซ็อกเก็ตสาธารณะ (สตริโฮสต์ int พอร์ต)' และคำสั่งจะคล้ายกับ ' ซ็อกเก็ต Socket =ซ็อกเก็ตใหม่ ("www.google.com", 80);'. หลังจากประสบความสำเร็จสร้างอินสแตนซ์ซ็อกเก็ต ไคลเอนต์จะสามารถส่ง/รับกระแสไบต์เพียงโดย OutputStream/InputStream ที่เกี่ยวข้องกับอินสแตนซ์ซ็อกเก็ต มีสร้างการร้องขอ HTTP โดยตรวจสอบเครื่องไคลเอนต์ (สำหรับหัวข้อการร้องขอ HTTP) และ URL (สำหรับวิธี HTTP และ URI ของทรัพยากรร้องขอ) เมื่อไคลเอ็นต์เสร็จเรียบร้อยแล้วสร้างการร้องขอ HTTP ที่ถูกต้อง มันจะใช้การเชื่อมต่อ TCP ที่สร้างโดยใช้ซ็อกเก็ต (ที่เครื่องไคลเอนต์) และ ServerSocket (ที่เครื่องเซิร์ฟเวอร์... เราจะอธิบายเรื่องถัดไป) วัตถุที่จะถ่ายโอนคำขอ HTTP ไปยังเซิร์ฟเวอร์เว็บ

ตอบสนอง HTTP ที่สร้างและโอนย้ายเซิร์ฟเวอร์ (เช่น โดยเว็บเซิร์ฟเวอร์)

ที่เว็บเซิร์ฟเวอร์ต้องฟังการร้องขอการเชื่อมต่อโดยไคลเอ็นต์ต่าง ๆ และนอกจากนี้ควรจะพร้อมกับความสามารถในการยอมรับการร้องขอ HTTP เข้าใจการร้องขอ การขึ้นรูปการตอบสนอง HTTP ที่สอดคล้องกัน, และสุดท้ายจะโอนย้ายไปเครื่องไคลเอ็นต์ เว็บเซิร์ฟเวอร์อาจใช้วัตถุ java.net.ServerSocket เพื่อทำงานเหล่านี้ มันอาจใช้หนึ่งตัวสร้างของคลาสนี้ 'สาธารณะ ServerSocket (พอร์ต int, int ยอดคงค้าง InetAddress bindAddr)' นี่ท่าระบุหมายเลขพอร์ตที่วัตถุ ServerSocket จะฟัง ยอดคงค้างระบุจำนวนสูงสุดของการร้องขอถูกจัดคิวก่อนวัตถุ ServerSocket จะเริ่มปฏิเสธใด ๆ เข้ามาเพิ่มเติมคำขอ HTTP และ bindAddr ระบุอยู่ IP ของเครื่องที่วัตถุ ServerSocket นี้จะฟังคำขอขาเข้า ดังนั้น จึงเป็นปกติอยู่ย้อนกลับเช่น, ' 127.0.0.1'.

After เรามีความพร้อมใช้งานอินสแตนซ์ ServerSocket เราสามารถเรียกวิธีการอินสแตนซ์ที่มีลายเซ็นเป็น 'สาธารณะซ็อกเก็ต accept() พ่น IOException' สำหรับฟังการร้องขอการเชื่อมต่อที่ทำ โดยเครื่องไคลเอ็นต์ไปยังเซิร์ฟเวอร์นี้ วิธีบล็อกนี้จนกว่า จะทำการเชื่อมต่อ และหลัง จากนั้นจะส่งกลับวัตถุซ็อกเก็ตใหม่ ซึ่งรูปแบบที่สองปลายทางของการสื่อสารระหว่างไคลเอนต์และเซิร์ฟเวอร์ ถ้ามีผู้จัดการความปลอดภัยในเครื่องเซิร์ฟเวอร์ แล้ววิธี checkAccept() เรียกว่า socket.getInetAddress ().getHostAddress และ socket.getPort() เป็นพารามิเตอร์ อินสแตนซ์ซ็อกเก็ตใหม่ส่งกลับคืน โดยวิธี accept() 'หนวด' หากวิธีการ checkAccept() ส่งกลับจะยกการได้รับอนุญาต แล้วเท่านั้น เราสามารถดำเนินต่อไปหรือการ SecurityException และการสื่อสารจะถูกยกเลิกทันที

ถ้าผู้จัดการความปลอดภัยช่วยให้การดำเนินงาน แล้วจะใช้อินสแตนซ์ซ็อกเก็ตที่สร้างขึ้นใหม่เพื่อดึงข้อมูล InputStream และ OutputStream ที่เกี่ยวข้องกับ ซึ่งเว็บเซิร์ฟเวอร์จะใช้การร้องขอ HTTP จากอ่าน และเขียนตอบสนอง HTTP สุด สิ่งสำคัญคือต้องเข้าใจที่นี่ว่า ระบบปฏิบัติการ InputStream อินสแตนซ์ซ็อกเก็ตนี้เป็นเพียงแบบจำลองของ OutputStream ของอินสแตนซ์ซ็อกเก็ตที่สุดลูกค้า เพียงถ่ายโอนเพียงเขียนมีโดยการสื่อสาร TCP ที่เชื่อถือได้ ในทำนองเดียวกัน OutputStream ที่เกี่ยวข้องกับอินสแตนซ์ซ็อกเก็ตที่เซิร์ฟเวอร์จะเป็นแบบจำลองของ InputStream ที่เกี่ยวข้องกับอินสแตนซ์ซ็อกเก็ตที่สิ้นสุดของไคลเอ็นต์ เราไม่ต้องทำอะไรที่พิเศษกว่าการสร้างอินสแตนซ์ซ็อกเก็ตที่สิ้นสุดลูกค้ามีพารามิเตอร์ที่เหมาะสม สร้างอินสแตนซ์ ServerSocket ท้ายเซิร์ฟเวอร์ เรียกไอออนวิธี accept() อินสแตนซ์นี้ของ ServerSocket และใช้อินสแตนซ์ซ็อกเก็ตที่ส่งคืน โดยวิธี accept() เพื่ออ่าน และเขียนคำขอ HTTP และคำตอบ ทุกอย่างจะดูแล โดยคลาไลบรารีของ java.net เพื่อให้ง่าย ไม่ได้หรือไม่ ที่มีความสวยงามของ Java !

นี้เว็บเซิร์ฟเวอร์เป็นปกติการให้ ที่ accept() บนวัตถุ ServerSocket จะกลับสแตนซ์ซ็อกเก็ตในเธรดใหม่ spawned และความรับผิดชอบในการอ่านคำ ประมวลผล ตอบสนอง การขึ้นรูป และส่งการตอบสนองกลับไปยังไคลเอนต์ที่เกี่ยวข้องได้รับมอบหมายกับหัวข้อนี้เท่านั้นในขณะที่เก็บเธรดหลักในการเรียกวิธี accept() อย่างไม่มีกำหนด (จนถึงเครื่องเซิร์ฟเวอร์ปิด:) -) ที่ตอบรับการร้องขอขาเข้ามาไปยังเซิร์ฟเวอร์นี้

ผลลัพธ์ (ไทย) 2:

สิ่งที่ Web Server? มันเป็นเซิร์ฟเวอร์ที่ใช้ในการสื่อสารกับเว็บเบราเซอร์เป็นลูกค้าและโปรโตคอลการสื่อสารที่ใช้ในกรณีนี้คือ HTTP (HyperText Transfer Protocol) นี่คือเหตุผลที่เว็บเซิร์ฟเวอร์จะเรียกว่าเซิร์ฟเวอร์ HTTP ก่อนที่จะย้ายไปคุยวิธีทั่วไปงานเว็บเซิร์ฟเวอร์จะดีกว่าที่จะเข้าใจว่าสิ่งที่ HTTP เป็นข้อมูลเกี่ยวกับ? หากคุณไม่ได้รู้ว่ามันอยู่แล้วแล้วคุณอาจต้องการที่จะไปผ่านบทความนี้วิธีการที่ไม่ทำงานเว็บเซิร์ฟเวอร์? ในฐานะที่เป็นกรณีที่มีใด ๆ Comunication ลูกค้าเซิร์ฟเวอร์ในกรณีนี้ยังลูกค้า (เช่นเว็บเบราเซอร์) และ เซิร์ฟเวอร์ (เช่น HTTP / เว็บเซิร์ฟเวอร์) ควรจะสามารถที่จะสื่อสารกับคนอื่น ๆ ในทางที่กำหนด ชุดนี้ที่กำหนดไว้ล่วงหน้าของกฎที่เป็นพื้นฐานของการสื่อสารที่เรียกว่าปกติเป็นโปรโตคอลและในกรณีนี้โปรโตคอลพื้นฐานจะ HTTP โดยไม่คำนึงถึงวิธีการที่ไคลเอ็นต์หรือเซิร์ฟเวอร์ที่ได้รับการดำเนินการมีจะเป็นวิธีการที่จะ แบบฟอร์มขอ HTTP ที่ถูกต้องสำหรับลูกค้าในการทำงานและในทำนองเดียวกันเซิร์ฟเวอร์จะต้องมีความสามารถในการทำความเข้าใจเกี่ยวกับการร้องขอ HTTP ที่ส่งไปมันและการตอบสนองในรูปแบบที่ถูกต้อง HTTP ทุกมาขอ HTTP เครื่องไคลเอนต์และเซิร์ฟเวอร์ก็ควรจะมาพร้อมกับความสามารถในการสร้างการเชื่อมต่อกัน (ในกรณีนี้มันจะเชื่อมต่อ TCP เชื่อถือได้) เพื่อให้สามารถที่จะถ่ายโอนการร้องขอ HTTP (ลูกค้า -> เซิร์ฟเวอร์) และ HTTP การตอบสนอง (เซิร์ฟเวอร์ -> ลูกค้า) ว่าสิ่งเหล่านี้สามารถทำได้ขึ้นอยู่กับความหลากหลายของปัจจัยรวมทั้งปัจจัยที่สำคัญมาก - สิ่งที่เป็นทางเลือกของการเขียนโปรแกรมภาษา ลอง Java เป็นภาษาโปรแกรมที่นี่ ตอนนี้คำถามที่เกิดขึ้น - วิธีที่เราสามารถใช้เว็บเซิร์ฟเวอร์โดยทั่วไปใช้ Java? เอาล่ะ ... ลองมัน สำหรับเว็บเซิร์ฟเวอร์ที่จะทำงานอย่างสมบูรณ์แบบที่เราต้องการของลูกค้าในรูปแบบและส่งคำขอ HTTP ที่ถูกต้องให้กับมัน ดังนั้นเว็บเบราเซอร์ (ลูกค้าในกรณีนี้) ควรจะสามารถพูดคุยสำหรับวิธีที่จะสามารถมีความสามารถที่จำเป็นเหล่านั้น ลองพิจารณาว่าเบราว์เซอร์นอกจากนี้ยังถูกนำมาใช้ใน Java เท่านั้น ภาษาที่ต้องการอื่น ๆ ในการพัฒนาเว็บเบราเซอร์คือ C ++ และเราจะใช้ซ็อกเก็ตที่จะใช้ความสามารถดังกล่าวข้างต้นในเว็บเบราเซอร์ การดำเนินการของซ็อกเก็ตใน C ++ ค่อนข้างคล้ายกับว่าใน Java (อย่างน้อยแนวคิด) Java ทำให้การดำเนินงานโดยรวมที่ค่อนข้างง่ายและนั่นคือความแตกต่างเดียวที่เราจะสังเกตเห็นอาคารขอ HTTP และการถ่ายโอนจากลูกค้า (เช่นโดยเว็บเบราเซอร์) ในกรณีนี้เบราว์เซอร์จะใช้คลาส java.net.Socket เพื่อสร้างตัวเอง เป็นหนึ่งในปลายทางของการสื่อสารในการเชื่อมต่อ TCP ที่เชื่อถือได้ (ปลายทางอื่น ๆ จะซ็อกเก็ตอีกเช่นส่งกลับโดยยอมรับ () วิธีการของการเรียน ServerSocket ที่เซิร์ฟเวอร์) สำหรับการสร้างซ็อกเก็ตและความสามารถในการสื่อสารกับเครื่องที่เราจำเป็นต้องรู้ว่าสองสิ่ง - ที่อยู่ IP และหมายเลขพอร์ต ในกรณีของเราเป็นส่วนหนึ่งของ URL ที่จะช่วยให้เราได้รับที่อยู่ IP ของเซิร์ฟเวอร์และโปรโตคอล HTTP พอร์ตเริ่มต้นจะถือว่าเป็น 80 เซิร์ฟเวอร์ DNS ให้ที่อยู่ IP สำหรับ URL ที่ถูกต้องเข้ามาในแถบที่อยู่ของ เว็บเบราว์เซอร์ทั่วไป คุณสามารถป้อนที่อยู่ไอพีโดยตรงเช่นกัน แต่มันแน่นอนจะเป็นเรื่องยากมากที่จะจำที่อยู่ IP และแน่นอนพวกเขาจะไม่เป็นเช่นนั้นด้วยตนเองอธิบาย (เมื่อเทียบกับ URL ที่ปกติ) ดังนั้นถ้าเราพิมพ์ www .google.com ในแถบที่อยู่ของเว็บเบราว์เซอร์แล้วซ็อกเก็ตอาจจะถูกสร้างขึ้นโดยใช้ construtor 'ซ็อกเก็ตสาธารณะ (เจ้าภาพสตริงพอร์ต int)' และงบจะเป็นสิ่งที่คล้ายกับ 'ซ็อกเก็ตซ็อกเก็ต = ใหม่ซ็อกเก็ต (" www.google.com ", 80); ' หลังจากที่ประสบความสำเร็จของการสร้างซ็อกเก็ตเช่นลูกค้าจะสามารถส่ง / รับกระแสของไบต์เพียงโดยใช้ OutputStream / InputStream ที่เกี่ยวข้องกับซ็อกเก็ตเช่น ขอ HTTP จะถูกสร้างขึ้นโดยการตรวจสอบเครื่องของลูกค้า (สำหรับขอ HTTP ส่วนหัว) และ URL (สำหรับวิธี HTTP และ URI ของทรัพยากรที่ถูกร้องขอ) เมื่อลูกค้าได้สร้างสำเร็จขอ HTTP ที่ถูกต้องก็จะใช้การเชื่อมต่อ TCP จัดตั้งขึ้นโดยใช้ซ็อกเก็ต (ที่เครื่องไคลเอนต์) และ ServerSocket (ที่เครื่องเซิร์ฟเวอร์ ... เราจะหารือเกี่ยวกับมันต่อไป) วัตถุที่จะถ่ายโอน HTTP การร้องขอไปยังเว็บเซิร์ฟเวอร์อาคารตอบสนอง HTTP และการโอนโดยเซิร์ฟเวอร์ (เช่นโดยเว็บเซิร์ฟเวอร์) เว็บเซิร์ฟเวอร์จะต้องฟังการร้องขอการเชื่อมต่อที่ทำโดยลูกค้าที่แตกต่างกันและมันก็ควรจะมาพร้อมกับความสามารถในการยอมรับการร้องขอ HTTP, การทำความเข้าใจขอรูปการตอบสนอง HTTP ที่สอดคล้องกันและในที่สุดก็จะโอนไปยังเครื่องไคลเอนต์ที่เหมาะสม เว็บเซิร์ฟเวอร์อาจใช้วัตถุ java.net.ServerSocket ดำเนินงานเหล่านี้ทั้งหมด มันอาจจะใช้หนึ่งในการก่อสร้างของชั้นนี้ 'ServerSocket สาธารณะ (พอร์ต int, int ค้าง, InetAddress bindAddr)' นี่คือพอร์ตระบุหมายเลขพอร์ตที่วัตถุ ServerSocket จะฟัง Backlog ในมือระบุจำนวนสูงสุดของการร้องขอการจัดคิวก่อนวัตถุ ServerSocket จะเริ่มปฏิเสธการร้องขอ HTTP ใด ๆ ที่เข้ามามากขึ้น และ bindAddr ระบุที่อยู่ไอพีของเครื่องที่วัตถุ ServerSocket นี้จะฟังการร้องขอเข้ามา ดังนั้นจึงเป็นเรื่องปกติที่อยู่ย้อนกลับเช่น '127.0.0.1' หลังจากที่เรามีความพร้อมด้วยเช่น ServerSocket ทำงานเราสามารถเรียกวิธีการเช่นที่มีลายเซ็นเป็น 'ซ็อกเก็ตประชาชนยอมรับ () พ่น IOException' สำหรับการฟังการร้องขอการเชื่อมต่อ ทำโดยเครื่องไคลเอนต์กับเซิร์ฟเวอร์นี้ นี้บล็อกวิธีจนกว่าการเชื่อมต่อจะทำและหลังจากนั้นก็จะส่งกลับวัตถุซ็อกเก็ตใหม่ซึ่งเป็นปลายทางที่สองของการสื่อสารระหว่างไคลเอ็นต์และเซิร์ฟเวอร์ หากมีการจัดการความปลอดภัยที่เครื่องเซิร์ฟเวอร์แล้ว checkAccept () วิธีการเรียกว่ามี socket.getInetAddress (.) getHostAddress และ socket.getPort () เป็นพารามิเตอร์ที่ 'ซ็อกเก็ต' เป็นตัวอย่างซ็อกเก็ตกลับมาใหม่กลับโดยยอมรับ ( ) วิธีการ ถ้า checkAccept () ผลตอบแทนที่วิธีการดำเนินการจะได้รับอนุญาตแล้วเท่านั้นที่เราจะสามารถดำเนินการต่อไปเป็นอย่างอื่น SecurityException จะได้รับการเลี้ยงดูและการสื่อสารจะถูกยกเลิกทันทีหากผู้จัดการการรักษาความปลอดภัยช่วยให้การดำเนินการแล้วเช่นซ็อกเก็ตที่สร้างขึ้นใหม่จะใช้ในการ เรียก InputStream และ OutputStream ที่เกี่ยวข้องกับมันซึ่งเว็บเซิร์ฟเวอร์ในท้ายที่สุดจะใช้ในการอ่านขอ HTTP และจากการเขียนการตอบสนอง HTTP ไป มันเป็นสิ่งสำคัญที่จะเข้าใจที่นี่ว่า os InputStream เช่นซ็อกเก็ตนี้เป็นเพียงแบบจำลองของ OutputStream ของอินสแตนซ็อกเก็ตในตอนท้ายของลูกค้า สิ่งที่เขียนมีการโอนเพียงโดยใช้การสื่อสาร TCP มีความน่าเชื่อถือ ในทำนองเดียวกัน OutputStream ที่เกี่ยวข้องกับซ็อกเก็ตเช่นที่เซิร์ฟเวอร์จะเป็นแบบจำลองของ InputStream ที่เกี่ยวข้องกับซ็อกเก็ตเช่นในตอนท้ายของลูกค้า เราไม่จำเป็นต้องทำอะไรพิเศษกว่าการสร้างเช่นซ็อกเก็ตที่สิ้นสุดลูกค้าที่มีพารามิเตอร์ที่เหมาะสมในการสร้างเช่น ServerSocket ในตอนท้ายเซิร์ฟเวอร์โทรยอมรับ () วิธีไอออนเช่น ServerSocket นี้และใช้ซ็อกเก็ตเช่นส่งกลับโดย ยอมรับ () วิธีการอ่านและเขียนขอ HTTP และการตอบสนอง ทุกอย่างอื่นจะได้รับการดูแลโดยการเรียนห้องสมุดของแพคเกจ java.net เพื่อให้ง่ายไม่ได้หรือไม่ นั่นคือความงามของ Java! เว็บเซิร์ฟเวอร์นี้เป็นปกติแบบมัลติเธรดหนึ่งที่ยอมรับ () บนวัตถุ ServerSocket จะกลับมาเช่นซ็อกเก็ตในกระทู้กลับกลายใหม่และความรับผิดชอบของการอ่านการร้องขอการประมวลผลมันสร้างการตอบสนองและ ส่งการตอบสนองกลับไปยังลูกค้าที่เกี่ยวข้องจะได้รับการแต่งตั้งอ่านกระทู้เท่านั้นในขณะที่หัวข้อหลักช่วยในการทำงานยอมรับ () วิธีการนี้ไปเรื่อย ๆ (จนถึงเครื่องเซิร์ฟเวอร์ปิด:-)) สำหรับการยอมรับการร้องขอเข้ามาที่เซิร์ฟเวอร์นี้

ผลลัพธ์ (ไทย) 3:

สิ่งที่เป็นเว็บเซิร์ฟเวอร์ ?

มันเป็นเซิร์ฟเวอร์ที่ใช้สื่อสารกับเว็บเบราว์เซอร์เป็นลูกค้าและโปรโตคอลการสื่อสารที่ใช้ในคดีนี้คือ HTTP ( Hypertext Transfer Protocol ) นี่คือเหตุผลที่เว็บเซิร์ฟเวอร์จะเรียกว่า HTTP Server .

ก่อนจะย้ายไปคุยว่าเป็นเว็บเซิร์ฟเวอร์ที่ทำงานจะดีกว่าที่จะเข้าใจอะไร HTTP คือทั้งหมดเกี่ยวกับ ?ถ้าคุณไม่รู้จักมันแล้วคุณอาจต้องการที่จะไปผ่านบทความนี้ .

ทำไม Web Server ทำงานอย่างไร

เป็นกรณีกับไคลเอ็นต์เซิร์ฟเวอร์การสื่อสาร ในกรณีนี้ลูกค้า ( เช่นเว็บเบราเซอร์และเซิร์ฟเวอร์ ( เช่น HTTP / Web Server ) ควรจะสามารถสื่อสารกับแต่ละอื่น ๆในการกำหนดวิธีนี้ที่กำหนดไว้ล่วงหน้าชุดของกฎซึ่งรูปแบบพื้นฐานของการสื่อสารโดยปกติจะ termed เป็น โปรโตคอล และในกรณีนี้จะอ้างอิงโปรโตคอล HTTP

ไม่ใช้วิธีไคลเอนต์หรือเซิร์ฟเวอร์ได้ถูกพัฒนาจะมีวิธีที่จะสร้างการร้องขอ HTTP ใช้ได้สำหรับลูกค้าที่จะทำงานและในทำนองเดียวกันเซิร์ฟเวอร์ต้องสามารถเข้าใจ HTTP ส่งไปมันและรูปแบบการตอบสนอง HTTP ใช้ได้ทั้งหมดมาถึง HTTP .ทั้งลูกค้าและเซิร์ฟเวอร์ เครื่องควรเป็นอุปกรณ์ที่มีความสามารถในการสร้างการเชื่อมต่อกับแต่ละอื่น ๆ ( ในกรณีนี้จะเป็นการเชื่อมต่อ TCP ที่เชื่อถือได้ที่จะสามารถถ่ายโอนการร้องขอ HTTP ( ลูกค้า - > Server ) และการตอบสนอง HTTP ( เซิร์ฟเวอร์ > ลูกค้า )

เรื่องเหล่านี้ได้ เสร็จแล้วขึ้นอยู่กับหลายปัจจัย ได้แก่ ปัจจัยสําคัญมาก - อะไรคือทางเลือกของการเขียนโปรแกรมภาษา มาใช้ Java เป็นภาษาโปรแกรมที่ที่นี่ ตอนนี้คำถามที่เกิดขึ้นว่าเราสามารถใช้เซิร์ฟเวอร์เว็บทั่วไปโดยใช้ Java ? โอเค . . . . . . . ลองดูสิ สำหรับ Web Server เพื่อให้สามารถใช้งานได้อย่างสมบูรณ์ เราต้องการให้ลูกค้าที่จะสร้างและส่งการร้องขอ HTTP ที่ถูกต้องแล้ว ดังนั้นเว็บเบราเซอร์ ( ลูกค้า ) ในกรณีนี้ควรจะยังถูกกล่าวถึงว่ามันสามารถมีผู้ที่ต้องการความสามารถในการ ให้พิจารณาว่าเบราว์เซอร์ยังถูกใช้ใน Java เท่านั้น อื่น ๆภาษาเพื่อพัฒนาเว็บเบราว์เซอร์เป็น C และเราใช้ซ็อกเก็ตที่ใช้ข้างต้นที่กล่าวถึงความสามารถในเว็บเบราเซอร์การใช้ซ็อกเก็ตใน C ค่อนข้างคล้ายกับที่ใน Java ( อย่างน้อยแนวคิด ) Java ทำให้การดำเนินการโดยรวมค่อนข้างง่ายกว่า และนั่นคือความแตกต่างเท่านั้นที่เราจะสังเกตเห็น

http ขออาคารและการถ่ายโอนโดยลูกค้า ( เช่นโดยเว็บเบราเซอร์ )

ในกรณีนี้ เบราว์เซอร์จะใช้สองรายการซ็อกเก็ตชั้นเพื่อสร้างตัวเองเป็นหนึ่งปลายทางของการสื่อสารบน TCP การเชื่อมต่อที่เชื่อถือได้ ( Media อื่นๆ จะเป็นอีกตัวอย่างที่ส่งกลับโดยซ็อกเก็ตยอมรับ ( ) วิธีการของ serversocket คลาสที่เซิร์ฟเวอร์ ) สำหรับการสร้างซ็อกเก็ต และสามารถสื่อสารกับเครื่อง เราต้องรู้สองสิ่ง -- ที่อยู่ IP และหมายเลขพอร์ต ในกรณีของเราเป็นส่วนหนึ่งของ URL จะช่วยให้เราได้รับที่อยู่ IP ของเซิร์ฟเวอร์ HTTP โปรโตคอลและพอร์ตเริ่มต้นคือสมมติเป็น 80 เซิร์ฟเวอร์ DNS ให้ที่อยู่ IP สำหรับ URL ที่ป้อนลงในแถบที่อยู่ของเบราว์เซอร์เว็บทั่วไป คุณสามารถระบุที่อยู่ IP โดยตรงเช่นกันแต่มันจะแน่นอนจะยากมากที่จะจำที่อยู่ IP และแน่นอนพวกเขาจะไม่อธิบายตนเอง ( เมื่อเทียบกับ URL ทั่วไป ) .

ถ้าเราพิมพ์ www.google.com ในแถบที่อยู่ของเบราว์เซอร์เว็บ , ซ็อกเก็ตจะถูกสร้างขึ้นโดยใช้ construtor สาธารณะ ( String โฮสต์เต้ารับ ,1 พอร์ต ) และงบจะคล้ายกับ ' ซ็อกเก็ตซ็อกเก็ตซ็อกเก็ตใหม่ = ( " www.google . com " 80 ) ; ' หลังจากการสร้างที่ประสบความสำเร็จของซ็อกเก็ตที่อินสแตนซ์ ลูกค้าจะสามารถรับ / ส่งกระแสของไบต์โดยเพียงแค่ใช้ outputstream / นพุต รีมที่เกี่ยวข้องกับซ็อกเก็ตอินสแตนซ์http request จะถูกสร้างขึ้นโดยการตรวจสอบเครื่องลูกค้า ( สำหรับส่วนหัวคำขอ HTTP ) และ URL ( วิธี HTTP และชนิดของทรัพยากรถูกร้องขอ ) เมื่อลูกค้าได้สร้างการร้องขอ HTTP ใช้ได้ มันก็ใช้การเชื่อมต่อซ็อกเก็ต ( TCP ใช้ในเครื่องไคลเอ็นต์ ) และ serversocket ( ที่เครื่องเซิร์ฟเวอร์ . . . . . . .เราจะหารือเกี่ยวกับมันต่อไป ) วัตถุที่ถ่ายโอนการร้องขอ HTTP ไปยังเว็บเซิร์ฟเวอร์ .

http การอาคารและการถ่ายโอนโดยเซิร์ฟเวอร์ ( เช่นโดยเว็บเซิร์ฟเวอร์ )

Web Server ต้องฟังต่อการร้องขอจากลูกค้าต่าง ๆ และควรที่จะมาพร้อมกับความสามารถในการยอมรับการร้องขอ HTTP ความเข้าใจความต้องการสร้างการตอบสนอง HTTP ที่สอดคล้องกันและสุดท้ายที่จะโอนไปยังเครื่องไคลเอ็นต์ที่เหมาะสม เว็บเซิร์ฟเวอร์อาจใช้ java.net.serversocket วัตถุเพื่อทำงานทั้งหมดเหล่านี้ มันอาจจะใช้หนึ่งในผู้รับเหมาของคลาสนี้ serversocket ( int สาธารณะพอร์ต int ( inetaddress bindaddr ) ' นี้พอร์ต ระบุหมายเลขพอร์ตที่ serversocket วัตถุจะฟัง ;บาท ระบุจำนวนสูงสุดของคิวการร้องขอก่อน serversocket วัตถุจะเริ่มปฏิเสธใด ๆการร้องขอ HTTP ขาเข้ามากขึ้น และ bindaddr ระบุที่อยู่ IP ของเครื่องที่ serversocket วัตถุจะฟังการร้องขอเข้ามา ดังนั้น มันคือปกติโปรทรอมบิน ที่อยู่ เช่น 127.0.0.1 ' '

หลังจากที่เราพร้อมกับอินสแตนซ์ serversocket การทํางานเราสามารถเรียกใช้อินสแตนซ์มีลายเซ็นเป็น ' สาธารณะ ' ยอมรับ ( ) พ่น ioexception ซ็อกเก็ตฟังการร้องขอการเชื่อมต่อจากเครื่องลูกข่ายไปยังเซิร์ฟเวอร์นี้ วิธีนี้บล็อกจนกว่าการเชื่อมต่อจะทำ และหลังจากนั้นก็ส่งกลับวัตถุซ็อกเก็ตใหม่ซึ่งรูปแบบปลายทางที่สองของการสื่อสารระหว่างไคลเอนต์และเซิร์ฟเวอร์ถ้ามีการรักษาความปลอดภัยผู้จัดการเซิร์ฟเวอร์เครื่องนั้น checkaccept() วิธีการที่เรียกว่ากับเต้ารับ getinetaddress() . gethostaddress และซ็อกเก็ต . getport() เป็นพารามิเตอร์ที่ ' ' เป็นซ็อกเก็ตซ็อกเก็ตอินสแตนซ์ที่พึ่งกลับมาส่งกลับโดยยอมรับ ( ) วิธีการถ้าวิธี checkaccept() จะเป็นปฏิบัติการที่ได้รับอนุญาตแล้วเท่านั้น เราสามารถดำเนินการต่อไปมิฉะนั้น securityexception จะยกขึ้นและการสื่อสารจะถูกยกเลิกทันที

ถ้าผู้จัดการการรักษาความปลอดภัยช่วยให้ผ่าตัดแล้วสร้างขึ้นใหม่ เช่น ซ็อกเก็ตจะถูกใช้เพื่อเรียก outputstream นพุต รีมและที่เกี่ยวข้องที่เว็บเซิร์ฟเวอร์สุดจะใช้อ่านจากการร้องขอ HTTP และ HTTP การเขียนเพื่อสนอง มันเป็นสิ่งสำคัญที่จะเข้าใจตรงนี้ว่า นพุต รีม OS นี้ซ็อกเก็ตอินสแตนซ์เป็นแค่ภาพจำลองของ outputstream ของซ็อกเก็ตตัวอย่างที่สิ้นสุดของลูกค้า ก็ตามที่เขียนไว้มีเพียงโอนโดยใช้การสื่อสาร TCP ที่เชื่อถือได้ ในทํานองเดียวกันการ outputstream เกี่ยวข้องกับซ็อกเก็ตตัวอย่างที่เซิร์ฟเวอร์จะเป็นแบบจำลองของ นพุต รีมที่เกี่ยวข้องกับซ็อกเก็ตตัวอย่างสิ้นค้า เราไม่ต้องทำอะไรที่พิเศษกว่าการสร้างซ็อกเก็ตตัวอย่างที่สิ้นสุดของลูกค้ากับพารามิเตอร์ที่เหมาะสม การสร้าง serversocket อินสแตนซ์ท้ายเซิร์ฟเวอร์เรียกยอมรับ ( ) วิธีการนี้ serversocket ไอออนเช่นและใช้ส่งกลับซ็อกเก็ตอินสแตนซ์ โดยยอมรับ ( ) วิธีการอ่านและเขียนขอ HTTP และการตอบสนอง ทุกอย่างอื่นจะถูกจัดการโดยไลบรารีคลาสของสองรายการแพคเกจ ดังนั้น ง่ายใช่มั้ย ? นั่นคือความงามของ Java !

เว็บเซิร์ฟเวอร์นี้โดยปกติจะเป็นแบบมัลติเธรดหนึ่งซึ่งยอมรับ ( ) ใน serversocket วัตถุจะส่งกลับซ็อกเก็ตใหม่ spawned เช่นด้ายและความรับผิดชอบของการอ่านคำขอ การประมวลผล มันสร้างการตอบสนองและส่งการตอบสนองกลับไปที่ลูกค้ามอบหมายให้กระทู้นี้เท่านั้น ส่วนกระทู้หลักยังใช้ยอมรับ ( ) วิธีการไปเรื่อย ๆ ( จนเครื่องปิดเซิร์ฟเวอร์ :- ) ) สำหรับการเข้ามารับประทานอาหารมา server นี้