黑马程序员--Java面向对象——（网络编程）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！
面向对象

（网络编程：概述）

1、网络模型

（1）OSI参考模型

（2）TCP/IP参考模型



2、网络通讯要素

（1）IP地址（InetAddress已经封装成了对象）

1、网络中设备的标识

2、不易记忆，可用主机名

3、本地IP地址：127.0.0.1 主机名：Localhost。

（2）端口号（数字标识，没有必要封装成对象）

1、用于标识进程的逻辑地址，不同进程的标识。

2、有效端口：0~65535，其中0~1024系统使用或保留端口。

（3）传输协议

1、通讯的规则。

2、常见协议：TCP，UDP。

3、网络通讯过程

（1）找到对方 IP。

（2）数据要发到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行了标识。为了方便称呼这个数字，叫做端口。（逻辑端口）

了解：Ping 127.0.0.1（LocalHost）可以查看网卡是否异常。

（网络编程-IP地址）

由于IP地址是一个复杂的事物，Java已经它封装成了对象，封装成了对象把复杂的事情简单化。

类 InetAddress

static InetAddress

getLocalHost() 返回本地主机。

String	getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
String	getHostName() 获取此 IP 地址的主机名。

static InetAddress

getByName(String host) 在给定主机名的情况下确定主机的 IP 地址。

import java.net.InetAddress;

public class Test{

public static void main(String... args) throws Exception{

InetAddress i = InetAddress.getLocalHost();

String ip = i.getHostAddress();

String hostName = i.getHostName();

//System.out.println("IP地址"+ip);

//System.out.println("主机名"+hostName);

InetAddress inetAddress = InetAddress.getByName("www.baidu.com");

System.out.println(inetAddress.getHostAddress());

System.out.println(inetAddress.getHostName());

/*

InetAddress[] hosts = InetAddress.getAllByName("www.baidu.com");

for(InetAddress host :hosts ){

System.out.println(host.getHostAddress());

System.out.println(host.getHostName());

}

*/

}

}

（网络编程-UDP-TCP）

UDP 特点：（面向无连接）（聊天）

1、将数据及源和目的封装成数据包中，不需要建立连接。（封包，无连接）

2、每个数据包的大小限制在64k内。（小数据）

3、因无连接，是不可靠协议。（不可靠，丢数据）

4、不需要建立连接，速度快。（速度快）

TCP 特点：（面向连接）（下载）

1、建立连接，形成传输数据的通道。（传输，连接）

2、在连接中进行大数据量传输。（大数据）

3、通过三次捂手完成连接，是可靠协议。（可靠。在？ 我在！我知道你在了）

4、必须建立连接，效率会稍低。（速度慢）

（网络编程-Socket）（Socket也称套接字）

1、Socket就是为网络服务提供的一种机制。

2、通信的两端都有Socket。

3、网络通信其实就是Socket间的通信。

4、数据在两个Socket间通过IO传输。

注意：Socket可以理解为码头，有码头才有船可以对货（数据）进行装卸（读写）。

但是由于船运输的方式不同，所以有了不同的服务方式。

一个是UDP，另外一个是TCP。

（网络编程-UDP传输）应用小程序

import java.net.InetAddress;

import java.net.DatagramSocket;

import java.net.DatagramPacket;

/*

需求：

通过udp传输方式，将一段文字数据发送出去。

思路：

1.建立udpSocket服务。

2.提供数据，并将数据封装到数据包中。

3.通过Socket服务的发送功能，将数据包发送出去。

4.关闭资源。

*/

class UdpSend{

public static void main(String...args)throws Exception{

//1.创建udp服务，通过DatagramSocket对象。

DatagramSocket ds =new DatagramSocket (888);

//2.确定数据，并封装成数据包。

//DatagramPacket(byte[] buf, int length, InetAddress address, int port)

byte[] buf ="黑马程序员——哥们来了".getBytes();

DatagramPacketdp =

new DatagramPacket(

buf,

buf.length,

InetAddress.getByName("192.168.9.101"),

10000);

//3.通过socket服务，将已有的数据包发送出去，通过Send方法。

ds.send(dp);

//4.关闭资源。

ds.close();

}

}

/*

需求：

定义一个应用程序，用于接收udp协议传输的数据并处理。

思路：

1.建立udpSocket服务。

2.建立一个数据包，用于存储监听到的端口的数据。

把接收到的数据封装的数据包，就可以操作数据包对象，

使用其更多的功能对接收到的数据进行更多的操作。

3.通过Socket服务的监听功能，

将接收到的数据存入到已经定义好的数据包中。

4.通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上。

5.关闭资源。

*/

class UdpRece{

public static void main(String...args) throws Exception{

//1.创建udp的Socket服务，建立端点。

DatagramSocket ds =new DatagramSocket(10000);

//2.预定义数据包，用于存储接收数据。

byte[] buf =new byte[1024];

DatagramPacket dp = new DatagramPacket(buf,buf.length);

//3.通过服务的receive方法，将收到的数据存入到定义好的数据包中。

ds.receive(dp);

//4.通过数据包中的方法获取其中的数据。

String ip = dp.getAddress().getHostAddress();

int port = dp.getPort();

String data = new String(dp.getData(),0,dp.getLength());

System.out.println("IP地址："+ip+"..."+data+"...端口："+port);

//5.关闭资源。

ds.close();

}

}

注意：receive方法有一个阻塞式方法，如果发送端没有进行数据传输，那么该线程就是等，

如果有数据进行传输，那么就会接收发送端的数据并封装进数据包。

send方法如果接收端没有开启，数据将会丢失，但是数据是已经发送出去了的，只是丢失了。

（网络编程——UDP群聊小程序）

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.net.InetAddress;

import java.net.DatagramSocket;

import java.net.DatagramPacket;

public
class Test {

public
static void main(String[] args) throws Exception{

DatagramSocket sendSocket
= new DatagramSocket();

DatagramSocket receSocket
= new DatagramSocket(10000);

new Thread(new Send(sendSocket)).start();

new Thread(new Rece(receSocket)).start();

}

}
class Send implements Runnable{

private DatagramSocket ds
;

public Send(DatagramSocket ds){

this.ds=ds;

}

public
void run(){

BufferedReader bufr
= null;

try{

String line
=null;

bufr =new BufferedReader(new InputStreamReader(System.in));

while((line=bufr.readLine())!=null){

if("over".equals(line))

break;

byte[]
buf = line.getBytes();

DatagramPacket dp
= new DatagramPacket(buf,

buf.length,

InetAddress.getByName("192.168.9.255"),

10000);

ds.send(dp);

}

}

catch(Exception e){

throw
new RuntimeException("发送端失败");

}

finally{

if(bufr!=null){

try{

bufr.close();

}

catch (Exception e){

throw new RuntimeException("读取关闭失败");

}

}

}

ds.close();

}

}
class Rece implements Runnable{

private DatagramSocket ds
;

public Rece(DatagramSocket ds){

this.ds=ds;

}

public
void run(){

try{

while(true){

byte[]
buf =new byte[1024];

DatagramPacket dp
=new DatagramPacket(buf,buf.length);

ds.receive(dp);

String ip
= dp.getAddress().getHostAddress();

String data
=new String(dp.getData(),0,dp.getLength());

System.out.println(ip+"::"+data);

}

}

catch (Exception e){

throw new RuntimeException("接收端失败");

}

}

}

（网络编程-TCP传输）

1、Socket和ServerSocket。

2、建立客户端和服务器端。

3、建立连接后，通过Socket中的IO流进行数据的传输。

4、关闭Socket。

同样，客户端和服务器端是两个独立的应用程序



/*

演示Tcp传输

1、Tcp分客户端和服务端

2、客户端对应的是Socket，服务端对应的是ServerSocket

客户端

通过查阅 Socket 对象，发现在该对象建立时，就可以去连接指定主机

因为Tcp是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，在该通道进行数据的传输

步骤：

1、创建Socket服务，并制定要连接的主机和端口。

需求：给服务端发送一个文本数据

通过图例发现：服务端需要一直开着，或者关闭。那么服务器的资源可以关闭，也可以24小时开启。

*/

import java.net.Socket;

import java.net.ServerSocket;

import java.io.InputStream;

import java.io.OutputStream;

class TcpClient{

public static void main(String...args) throws Exception{

//创建客户端的socket服务。指定目的主机和端口

Socket s = new Socket("192.168.1.109",10003);

//为了发送数据，应该获取socket流中的输出流。

OutputStream out = s.getOutputStream();

out.write("Tcp 黑马程序员 哥们来了".getBytes());

s.close();

}

}

/*

需求：定义端点接收数据并打印在控制台上。

服务端:

1，建立服务端的socket服务。ServerSocket();

并监听一个端口。

2，获取连接过来的客户端对象。

通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。

3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。并打印在控制台。

4，关闭服务端。（可选）

*/

class TcpServer{

public static void main(String... args) throws Exception{

//建立服务端socket服务。并监听一个端口。

ServerSocket ss = new ServerSocket(10003);

//通过accept方法获取连接过来的客户端对象。

while(true){

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+".....连接成功");

//获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。

InputStream in = s.getInputStream();

byte[] buf = new
byte[1024];

int len = in.read(buf);

System.out.println(new String(buf,0,len));

s.close();//关闭客户端.服务

}

//ss.close();//关闭服务端资源，可选可不选

}

}

（网络通讯——Tcp服务端客户端互动）

import java.io.InputStream;

import java.io.OutputStream;

import java.net.InetAddress;

import java.net.Socket;

import java.net.ServerSocket;

/*

思路：

1.创建客户端服务。并指定需要连接的主机与端口。

2.获取客户端中的输出流，将数据写入流中。

3.获取客户端中的输入流，将服务端反馈的数据进行读取。

4.关闭资源。

*/

class Cilent{

public static void main(String...args) throws Exception{

Socket s = new Socket("127.0.0.1",10000);

OutputStream out = s.getOutputStream();

out.write("服务端你好".getBytes());

InputStream in = s.getInputStream();

byte[]buf =new
byte[1024];

int len = in.read(buf);

System.out.println(new String(buf,0,len));

s.close();

}

}

/*

思路：

1.建立服务端服务。并监听一个端口。

2.获取连接进来的客户端对象。

3.获取客户端的读取流，读取客户端流中的数据。

4.给客户端回馈一个信息，获取客户端中的输入流，将数据写入流中。

5.关闭连接进来的客户端对象。

6.关闭客户资源（必选）关闭服务端资源（可选）

*/

class Server{

public static void main(String...args) throws Exception{

ServerSocket ss = new ServerSocket(10000);

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+"...连接成功");

InputStream in = s.getInputStream();

byte[] buf = new
byte[1024];

int len = in.read(buf);

System.out.println(new String(buf,0,len));

OutputStream out = s.getOutputStream();

Thread.sleep(10000);

out.write("客户端你也好".getBytes());

s.close();//必需的

ss.close();//可选

}

}

（网络编程——模拟一个翻译软件）

其实这个还不是翻译软件，只是我觉得跟翻译软件类似，日后我们把数据发送到数据库，而数据库返回的应该就是翻译后的结果。

/*

需求：建立一个文字转换服务器。

客户端给服务端发送文字，服务单会将文字转成大写在返回给客户端。

而且客户度可以不断的进行文字转换。当客户端输入over时，转换结束。

客户端：

1.建立客户端服务。并指定主机和端口。

2.获取键盘录入。纯文本，用到字符流。

3.获取客户端的输出流，将键盘录入的数据写入客户端的输出流中。

4.定义循环结束标记，因为键盘录入无法停下。

3.读取服务端反馈的数据。

4.关闭客户端资源。

*/

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.ServerSocket;

class TransClient {

public
static void main(String...args)throws Exception{

Socket s
= new Socket("127.0.0.1",10000);

BufferedReader bufr
=

new BufferedReader(new InputStreamReader(System.in));

/*

BufferedWriter bufout =

new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

*/

PrintWriter pw
= new PrintWriter(s.getOutputStream(),true);

BufferedReader bufin
=

new BufferedReader(new InputStreamReader(s.getInputStream()));

String line
= null;

while((line=bufr.readLine())!=null){

if("over".equals(line))

break;

pw.println(line);

//bufout.write(line);

//bufout.newLine();

//bufout.flush();

String str
= bufin.readLine();

System.out.println(str);

}

bufr.close();

s.close();

}

}

/*

服务端：

1.创建服务端服务。并监听一个端口

2.获取客户端对象。

3.读取客户端中的输入流，将数据读取出来。

4.给客户端回馈信息，将客户端的数据进行大写转换。

5.获取客户端的输出流，将数据发送给客户端。

6.关闭客户端资源。关闭服务端资源。

*/

class TransServer{

public
static void main(String...args) throws Exception{

ServerSocket ss
= new ServerSocket(10000);

Socket s
= ss.accept();

BufferedReader bufin
=

new BufferedReader(new InputStreamReader(s.getInputStream()));

/*

BufferedWriter bufout =

new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

*/

PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

String line
=null;

while((line=bufin.readLine())!=null){

System.out.println(line);

pw.println("Server:"+line.toUpperCase());

//bufout.write("server:"+line.toUpperCase());

//bufout.newLine();

//bufout.flush();

}

s.close();

ss.close();

}

}

/*

键盘录入读取的标识是换行符。

服务端停止的原来是客户端键盘录入结束，服务端读到了标记-1，所以结束。

read方法是阻塞式的。

accept方法也是阻塞式的。

阻塞式的方法只要没有读到所属的数据就是等。

*/

（网络编程——上传文本）

/*

需求：

将客户端的一个文本文件上传到服务端去.

客户端:

1.建立客户端服务，并指定一个主机和端口。

2.获取客户端的输出流对象，把数据写入流中。

3.获取客户端的输入流，读取服务端的反馈信息。

4.关闭资源。

*/

import java.io.BufferedReader;

import java.io.PrintWriter;

import java.io.InputStreamReader;

import java.io.FileReader;

import java.io.FileWriter;

import java.net.Socket;

import java.net.ServerSocket;

class TextClient{

public static void main(String...args) throws Exception{

Socket s = new Socket("127.0.0.1",10000);

BufferedReader bufr =

new BufferedReader(new FileReader("C:\\1.txt"));

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

String line =null;

while((line=bufr.readLine())!=null){

out.println(line);

}

s.shutdownOutput();//原理其实就是-1

BufferedReader in =

new BufferedReader(new InputStreamReader(s.getInputStream()));

String len =null;

while((len=in.readLine())!=null){

System.out.println(len);

}

bufr.close();

s.close();

}

}

/*

服务端：

1.建立服务端服务，并监听一个端口。

2.获取客户端对象。

3.获取客户端输入流，将数据读取出来，并写入一个文件中，存入在D盘。

4.获取客户端的输出流，给客户端回馈点信息。

5.关闭资源。

*/

class TextServer{

public static void main(String...args)throws Exception{

ServerSocket ss = new ServerSocket(10000);

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+"....连接成功");

PrintWriter pw =new PrintWriter(new FileWriter("D:\\1.txt"),true);

BufferedReader in =

new BufferedReader(new InputStreamReader(s.getInputStream()));

String line = null;

while((line=in.readLine())!=null){

pw.println(line);

}

PrintWriter out =new PrintWriter(s.getOutputStream(),true);

out.println("上传成功");

pw.close();

s.close();

ss.close();

}

}

（网络编程——上传图片文件）

/*

需求：

将客户端的图片文件上传到服务端去。（并考虑多个用户同时操作的情况）

客户端

1.创建客户端服务。并指定主机和端口。

2.读硬盘上的图片文件。

3.获取客户端的输出流，将图片文件写出去。

4.定义上传结束标记。

5.服务端给客户端反馈一个结果。

6.关闭流资源。关闭客户端资源。关闭服务端资源。

*/

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.File;

import java.net.Socket;

import java.net.ServerSocket;

class PicClient{

public static void main(String...args) throws Exception{

if(args.length!=1){

System.out.println("请选择一个jpg文件");

return;

}

File file = new File(args[0]);

if(!file.getName().endsWith(".jpg")){

System.out.println("文件格式错误，不是jpg");

return ;

}

if(!(file.exists() && file.isFile())){

System.out.println("该文件有问题，要么不存在，要么不是文件");

return ;

}

if(file.length()>1024*1024*5){

System.out.println("文件过大，无法处理");

return ;

}

Socket s = new Socket("127.0.0.1",10000);

FileInputStream fis = new FileInputStream(file);

OutputStream out = s.getOutputStream();

byte[]bufout = new byte[1024];

int by = 0;

while((by=fis.read(bufout))!=-1){

out.write(bufout,0,by);

}

s.shutdownOutput();

InputStream in = s.getInputStream();

byte[] bufin =new byte[1024];

int len = in.read(bufin);

System.out.println(new String(bufin,0,len));

fis.close();

s.close();

}

}

/*

服务端：

1.创建服务端服务，并监听一个端口。

2.获取客户端对象。

3.获取客户端的输入流，将传输的数据存储到硬盘中。

4.存储成功则给客户端回馈上传成功，否则上传失败。

5.关闭流资源。关闭客户端资源。关闭服务端资源。

*/

class PicThread implements Runnable{

private Socket s;

PicThread(Socket s){

this.s=s;

}

public void run(){

String ip = s.getInetAddress().getHostAddress();

int count = 1;

try{

System.out.println(ip+"...连接进来了");

File file = new File("D:\\Pic\\"+ip+"("+(count)+").jpg");

while(file.exists())

file = new File("D:\\Pic\\"+ip+"("+(count++)+").jpg");

FileOutputStream fos = new FileOutputStream(file);

InputStream in = s.getInputStream();

byte [] buf =new byte[1024];

int by = 0;

while((by=in.read(buf))!=-1){

fos.write(buf,0,by);

}

OutputStream out = s.getOutputStream();

out.write("上传成功".getBytes());

fos.close();

s.close();

}

catch(Exception e){

throw new RuntimeException("图片上传失败");

}

}

}

class PicServer{

public static void main(String...args) throws Exception{

ServerSocket ss = new ServerSocket(10000);

while(true){

Socket s = ss.accept();

new Thread(new PicThread(s)).start();

}

}

}

/*

客户端通过键盘录入用户名。

服务端对这个用户名进行校验。

如果该用户存在，在服务端显示xxx，已登陆。

并在客户端显示 xxx，欢迎光临。

如果该用户存在，在服务端显示xxx，尝试登陆。

并在客户端显示 xxx，该用户不存在。

最多就登录三次。

客户端：

1.建立客户端服务，并指定主机和端口。

2.通过键盘录入一个用户名。最多三次输入。

3.获取客户端输出流将键盘录入的用户名发送到服务端去。

4.通过客户端输入流，读取服务反馈的信息，如果服务端反馈信息是

用户成功登录，那么就退出循环。否则则继续输入。

5.关闭资源。

服务端：

1.建立服务端服务，并监听一个端口。

2.获取客户端对象。

3.通过客户端输入流接收客户端发送过来的用户名。最多三次验证。

4.对用户名进行验证，如果该用户名在数据库存在，

那么给客户端回馈一个欢迎光临的信息。

如果不存在，那么将回馈一个用户不存在的信息。

5.关闭资源。

*/

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

class Client {

public static void main(String...
args) throws Exception{

Socket s = new Socket("192.168.9.101",10047);

BufferedReader bufr =

new BufferedReader(new InputStreamReader(System.in));

PrintWriter out = new PrintWriter(s.getOutputStream(),true);

BufferedReader bufIn =

new BufferedReader(new InputStreamReader(s.getInputStream()));

for (int x
= 0; x < 3; x++) {

String line = bufr.readLine();

if(line ==null)

break;

out.println(line);

String info = bufIn.readLine();

System.out.println("info:"+
info);

if(info.contains("欢迎"))

break;

}

bufr.close();

s.close();

}

}

class UserThread implements Runnable {

private Socket s;

UserThread(Socket s) {

this.s = s;

}

public void run() {

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip +"....连接成功");

try{

for (int x
= 0; x < 3; x++) {

BufferedReader bufIn =

new BufferedReader(new InputStreamReader(s.getInputStream()));

String name = bufIn.readLine();

if(name ==null)

break;

BufferedReader bufr =

new BufferedReader(new FileReader("C:\\user.txt"));

PrintWriter out =new PrintWriter(s.getOutputStream(),true);

String line =null;

boolean flag = false;

while ((line = bufr.readLine()) !=null)
{

if (line.equals(name)) {

flag =true;

break;

}

}

if(flag) {

System.out.println(name +"...已登录");

out.println(name + "...欢迎光临");

break;

}

else {

System.out.println(name +"...尝试登录");

out.println(name + "...用户名不存在");

}

}

s.close();

}

catch (Exception e) {

throw new RuntimeException(ip + "校验失败");

}

}

}

class Server {

public static void main(String... args) throws Exception {

ServerSocket ss = new ServerSocket(10047);

while(true)
{

Socket s = ss.accept();

new Thread(new UserThread(s)).start();

}

}

}

（网络通讯-浏览器交互）

/*

演示客户端和服务端

客户端：浏览器

服务端：自定义

*/

import java.io.PrintWriter;

import java.net.ServerSocket;

public class Test{

public static void main(String...args) throws Exception{

ServerSocket ss = new ServerSocket(10005);

while(true){

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+"...连接成功");

PrintWriter out =new PrintWriter(s.getOutputStream(),true);

out.println("<font size=8 color=red>客户端你好</font>");

s.close();

}

}

}

telnet 命令 相当于一个客户端 在dos命令行输出 telnet 主机IP 端口

（网络通讯-Tomcat）

/*

客户端：浏览器

服务端：Tomcat服务器

*/

import java.io.PrintWriter;

import java.net.ServerSocket;

public class Test{

public static void main(String...args) throws Exception{

ServerSocket ss = new ServerSocket(11000);

while(true){

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+"...连接成功");

PrintWriter out =new PrintWriter(s.getOutputStream(),true);

out.println("<font size=8 color=red>客户端你好</font>");

s.close();

}

}

}











（网络通讯——Tomcat）

/*

客户端：自定义

服务端：Tomcat服务器

获取浏览器给Tomcat服务器发送了什么请求呢？

*/

import java.io.PrintWriter;

import java.io.InputStream;

import java.net.ServerSocket;

public class Test{

public static void main(String...args) throws Exception{

ServerSocket ss = new ServerSocket(10005);

while(true){

Socket s = ss.accept();

String ip = s.getInetAddress().getHostAddress();

System.out.println(ip+"...连接成功");

InputStream in = e.getInputStream();

byte[] buf =new byte[1024];

int len = in.read(buf):

System.out.println(new String(buf,0,len));

PrintWriter out =new PrintWriter(s.getOutputStream(),true);

out.println("<font size=8 color=red>客户端你好</font>");

s.close();

}

}

}

/*

（获取连接客户端的IP地址）

192.168.9.101...连接成功

GET / HTTP/1.1

Accept: application/x-ms-application, image/jpeg, application/xaml+xml, image/gi

f, image/pjpeg, application/x-ms-xbap, */*

Accept-Language: zu,zh-CN;q=0.5

User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.

0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Cent

er PC 6.0; .NET4.0C; .NET4.0E)

Accept-Encoding: gzip, deflate

Host: 192.168.9.101:11000

Connection: Keep-Alive

请按任意键继续. . .

*/



/*

自定义客户端

客户端：自定义

服务器：Tomcat

*/

import java.io.PrintWriter;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.net.Socket;

public class Test{

public static void main(String...args)throws Exception{

Socket s = new Socket("127.0.0.1",8080);

PrintWriter out =new PrintWriter(s.getOutputStream(),true);

out.println("GET /Web/index.html HTTP/1.1");

out.println("Accept: */*");

out.println("Accept-Language: zh-cn");

out.println("Host: 192.168.9.101:11000");

out.println("Connection: closed");

out.println();

out.println();

BufferedReader bufr =

new BufferedReader(new InputStreamReader(s.getInputStream()));

String line =null;

while((line=bufr.readLine())!=null){

System.out.println(line);

}

s.close();

}

}

/*

（获取连接客户端的IP地址）

192.168.9.101...连接成功

GET / HTTP/1.1

Accept: application/x-ms-application, image/jpeg, application/xaml+xml, image/gi

f, image/pjpeg, application/x-ms-xbap, */*

Accept-Language: zu,zh-CN;q=0.5

User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.

0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Cent

er PC 6.0; .NET4.0C; .NET4.0E)

Accept-Encoding: gzip, deflate

Host: 192.168.9.101:11000

Connection: Keep-Alive

请按任意键继续. . .

*/



（网络编程——自定义图形界面浏览器-Tomcat服务端）

这里先放放。因为消息头无法去掉。等下学完URLConnection先来一个图形化界面浏览器。

（网络编程——URL）

地址链接是一个复杂的事物，所以Java已经把地址链接封装成URL对象，方便了我们的操作。

我们只要操作URL对象的方法，就可以拿到URL的数据了。

import java.net.URL;

public class Test{

public static void main(String...args)throws Exception{

URL url =new URL("http://127.0.0.1:8080/Web/index.html?姓名=黑马程序员——新长城&年龄=20");

String protocol = url.getProtocol();

String path = url.getPath();

String host = url.getHost();

int port = url.getPort();//如果不指定端口，返回的是-1

String file = url.getFile();

String query = url.getQuery();//用？号隔开。获取地址栏的参数，如果多参数用&符号隔开

//if(port==-1)

//port=80;

//System.out.println(protocol+"://"+host+":"+port+path);

System.out.println(protocol);

System.out.println(host);

System.out.println(port);

System.out.println(path);

System.out.println(file);

System.out.println(query);

}

}

（网络编程——URLConnection）

/*

远程连接对象。

底层封装了Socket对象，调用的是Socket对象的读取流方法。

*/

import java.io.InputStream;

import java.net.URL;

import java.net.URLConnection;

public class Test{

public static void main(String...args)throws Exception{

URL url =new URL("http://www.so.com/");

URLConnection urlconnection = url.openConnection();

InputStream in = urlconnection.getInputStream();

byte[]buf =new byte[1024];

int len = in.read(buf);

System.out.println(new String(buf,0,len,"utf-8"));

}

}

（网络编程——openStream）

底层其实调用的是远程连接对象，直接调用远程连接对象的Socket流中的读取流方法。

更加方便我们的应用。

（网络编程——自定义图形界面浏览器-Tomcat服务端）

现在自己去一步一步自己实现，可能晚上才发布。因为难嘛。

import java.awt.Button;

import java.awt.FlowLayout;

import java.awt.Frame;

import java.awt.TextArea;

import java.awt.TextField;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.io.InputStream;

import java.net.URL;

public class Test{

private Frame f;

private TextField tf;

private Button b;

private TextArea ta;

Test(){

init();

}

public void init(){

f = new Frame("MyIE");

tf = new TextField(70);

b = new Button("搜索一下");

ta =new TextArea(25,80);

b.setSize(20,30);

f.setBounds(0,200,1024,500);

f.setLayout(new FlowLayout());

f.add(tf);

f.add(b);

f.add(ta);

myEvent();

f.setVisible(true);

}

public void myEvent(){

b.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){

ta.setText("");

try{

URL url = new URL(tf.getText());

InputStream in = url.openStream();

byte[]buf =new byte[1024];

int len = in.read(buf);

ta.setText(new String(buf,0,len,"gbk"));

}

catch (Exception ex){

ta.setText("输入错误，请重新输入");

}

}

});

f.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent e){

System.exit(0);

}

});

}

public static void main(String...args){

new Test();

}

}

/*花了15分钟，哎真累，吃饭先*/

（网络编程——域名解析）