网络参考模型：
--|| OSI参考模型
--|| TCP/IP参考模型
应用层：http协议，ftp协议
传输层：tcp，udp
网际层：ip
TCP和UDP:
UDP:
1，面向无连接的，需要将数据封装在数据包中
2，每个数据包大小限制在64k内
3，无连接，是不可靠协议
4，因无连接，速度快
TCP:
1，需要建立连接，形成数据传输通道
2，在连接中进行大数据量传输
3，通过三次握手完成连接，是可靠协议
甲：已你在吗
已：我在
甲：我知道你在了
4，必须建立连接，效率稍低
重要对象介绍
InetAddress
方法介绍：
1，static InetAddress getLocalHost() //获取本地主机IP
2，static InetAddress getByName(String ip/name)
Socket
Socket就是为网络服务提供的一种机制
通信两端都有Socket
网络通信其实就是Socket间的通信
数据在两个Socket间通过IO传输
UDP的Socket传输服务对象：
DatagramSocket(port/可选接受端口时)
1，void send(DatagramPacket p)
2，void receive(DatagramPacket p)
DatagramPacket:
构造方法：
DatagramPacket(byte[] buf,int length)
DatagramPacket(byte[] buf,int length,InetAddress ad,int port)
TCP的Soceket服务对象
tcp分客户端和服务端。
案例一
tcp结束方式
1，客户端发送结束标记，单如果发送的数据中包含该标记就不好了 //不推荐
2，时间戳方法，先发送一遍时间戳，在发送一遍时间戳，当服务端读取到第二次时间戳时就停止tcp通信 //不推荐
3，shutdownInput() ,shutdowmOutput() //关闭输入输出流，相当于加入结束标记
/*
客户端，
通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。
因为tcp是面向连接的。所以在建立socket服务时，
就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。
需求：给服务端发送给一个文本数据。
步骤：
1，创建Socket服务。并指定要连接的主机和端口。
*/
import java.io.*;
import java.net.*;
class TcpClient
{
public static void main(String[] args) throws Exception
{
//创建客户端的socket服务。指定目的主机和端口
Socket s = new Socket("192.168.1.254",10003);
//为了发送数据，应该获取socket流中的输出流。
OutputStream out = s.getOutputStream();
out.write("tcp ge men lai le ".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+".....connected");
//获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。
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();
}
}
练习二
/*
需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。
而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。
分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。
步骤
1，建立服务。
2，获取键盘录入。
3，将数据发给服务端。
4，后去服务端返回的大写数据。
5，结束，关资源。
都是文本数据，可以使用
字符流进行操作，同时提高效率，加入缓冲。
服务端：
源：socket读取流。
目的：socket输出流。
都是文本，装饰。
该例子出现的问题。
现象：客户端和服务端都在莫名的等待。
为什么呢？
因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等
而导致两端，都在等待。
下例中的客户端和服务端输出流都可以用
PrintWriter out = new PrintWriter(s.getInputStream())代替
客户端
import java.io.*;
import java.net.*;
public class Test {
public static void main(String[] args) throws Exception
{
Socket s = new Socket("localhost",9999);
BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
BufferedReader bufin = new BufferedReader(new InputStreamReader(s.getInputStream()));
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
while(true)
{
String line =br.readLine();
bufout.write(line);
bufout.newLine();
bufout.flush();
if("over".equals(line))
break;
String data =bufin.readLine();
sop("server:"+data);
}
s.close();
}
public static void sop(Object o)
{
System.out.println(o);
}
}
服务端
import java.io.*;
import java.net.*;
public class zhangxu {
public static void main(String[] args) throws Exception
{
ServerSocket s = new ServerSocket(9999);
Socket ss = s.accept();
sop(ss.getInetAddress().getHostAddress());
BufferedWriter bufout = new BufferedWriter(new OutputStreamWriter(ss.getOutputStream()));
BufferedReader bufin = new BufferedReader(new InputStreamReader(ss.getInputStream()));
while(true)
{
String line =bufin.readLine(); //由于客户端没有发送回车键，所以一直没有读完，客户端打印的时候应该带换行
sop(line);
bufout.write(line.toUpperCase());
bufout.newLine();
bufout.flush();
}
}
public static void sop(Object o)
{
System.out.println(o);
}
}
udp通信举例
/*
需求： 通过udp传输方式将一段文字发送出去
1，建立udp socket服务
2，提高数据，将数据风罩到数据包中
3，通过socket服务发送功能发送数据包
4，关闭资源
需求：接收发送过来的数据
1，建立 udp socket服务,通常会定义一个接收端口。
2，建立容纳数据的数据包，存储接收到的字节数据，因为数据包对象有方法可以提取信息。
3，通过receive方法监听并接受数据存储到已定义好的数据包中。
4，通过数据包对象的特有功能，将不同数据取出。
5，关闭资源
*/
发送端
import java.io.IOException;
import java.net.*;
public class Test {
public static void main(String[] args) throws IOException
{
sop(111);
DatagramSocket ds = new DatagramSocket();
byte [] data ="udp 哈哈".getBytes();
DatagramPacket dp = new DatagramPacket(data,data.length,InetAddress.getLocalHost(),8888);
ds.send(dp);
ds.close();
}
public static void sop(Object o)
{
System.out.println(o);
}
}
接收端
import java.net.*;
public class zhangxu {
public static void main(String[] args) throws Exception
{
sop("listen...");
DatagramSocket ds= new DatagramSocket(8888);//设置了监听端口
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());
int port = dp.getPort();
sop(ip+"--"+data+"--"+port);
ds.close();
}
public static void sop(Object o)
{
System.out.println(o);
}
}
/*
需求：tcp上传图片。
*/
/*
客户端。
1，服务端点。
2，读取客户端已有的图片数据。
3，通过socket 输出流将数据发给服务端。
4，读取服务端反馈信息。
5，关闭。
*/
import java.io.*;
import java.net.*;
public class Test {
public static void main(String[] args) throws Exception
{
Socket s = new Socket("localhost",9999);
FileInputStream fi= new FileInputStream("C:\\Users\\zx\\Desktop\\1.png");
byte [] buf = new byte[1024];
OutputStream out = s.getOutputStream();
InputStream in = s.getInputStream();
int len;
while((len=fi.read(buf))!=-1)
{
out.write(buf, 0, len);
}
s.shutdownOutput(); //注意这里，如果不加入这句，服务端无法得到-1，因为当本地文件达到末尾时，发送完数据就不会再发送了。
len =in.read(buf);
sop(new String(buf,0,len));
s.close();
fi.close();
}
public static void sop(Object o)
{
System.out.println(o);
}
}
import java.io.*;
import java.net.*;
public class zhangxu {
public static void main(String[] args) throws Exception
{
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept();
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
FileOutputStream fi = new FileOutputStream("e:\\888.png");
byte [] buf =new byte [1024];
int len;
while((len=in.read(buf))!=-1)
{
fi.write(buf,0,len);
}
out.write("上传成功".getBytes());
sop("over");
out.close();
ss.close();
s.close();
fi.close();
}
public static void sop(Object o)
{
System.out.println(o);
}
}
需求：多线程tcp上传图片。
import java.io.*;
import java.net.*;
public class Test {
public static void main(String[] args) throws Exception
{
while(true)
{
Socket s = new Socket("localhost",8888);
FileInputStream fi= new FileInputStream("C:\\Users\\zx\\Desktop\\1.png");
byte [] buf = new byte[1024];
OutputStream out = s.getOutputStream();
InputStream in = s.getInputStream();
int len;
while((len=fi.read(buf))!=-1)
{
out.write(buf, 0, len);
}
s.shutdownOutput(); //注意这里，如果不加入这句，服务端无法得到-1，因为当本地文件达到末尾时，发送完数据就不会再发送了。
len =in.read(buf);
sop(new String(buf,0,len));
s.close();
fi.close();
Thread.sleep(500);
}
}
public static void sop(Object o)
{
System.out.println(o);
}
}
import java.io.*;
import java.net.*;
public class zhangxu {
public static void main(String[] args) throws Exception
{
while(true)
{
ServerSocket ss = new ServerSocket(8888);
Socket s = ss.accept();
new Thread(new Update(s)).start();
ss.close();
}
}
public static void sop(Object o)
{
System.out.println(o);
}
}
class Update implements Runnable
{
Socket s;
Update(Socket s)
{
this.s=s;
}
private static int count =0;
public void run()
{
try
{
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
FileOutputStream fi = new FileOutputStream("e:"+count++ +".png");
byte [] buf =new byte [1024];
int len;
while((len=in.read(buf))!=-1)
{
fi.write(buf,0,len);
}
out.write(("上传成功"+count).getBytes());
System.out.println("over"+count);
out.close();
s.close();
fi.close();
}
catch(Exception e)
{
}
}
}