---------------------- ASP.Net+Unity开发、.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。
了解：Ping 127.0.0.1（LocalHost）可以查看网卡是否异常。（2）数据要发到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行了标识。为了方便称呼这个数字，叫做端口。（逻辑端口）
（网络编程-IP地址）
由于IP地址是一个复杂的事物，Java已经它封装成了对象，封装成了对象把复杂的事情简单化。
类 InetAddress
static InetAddressgetLocalHost()
返回本地主机。
StringgetHostAddress()
返回 IP 地址字符串（以文本表现形式）。StringgetHostName()
获取此 IP 地址的主机名。
static InetAddressgetByName(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)
out.println(line);break;
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 =
String line = null;new BufferedReader(new InputStreamReader(s.getInputStream()));
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分钟，哎真累，吃饭先*/
（网络编程——域名解析）
---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------
