黑马程序员-----Java基础-----网络编程

-----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

                                                                                                        网络编程

 
 三要素：IP，端口，协议
 1，找到对方IP
 2，数据要发送对方指定的应用程序上，为了标示这些应用程序，所以给这些网络应用程序都用数字
 进行标识，为了方便称呼这个数字，叫做 端口。逻辑端口
 3，定义了通信规则，这个规则称为协议。
 国际组织定义了通用协议。TCP/IP.
 
 127.0.0.1本地回环地址
 
 OSI参考模型                               TCP/IP参考模型 向上拆包
1       应用层   1
1 表示层   1
1 会话层             --------------             应用层  1
1 传输层 传输层  1
1 网络层 网际层  1
1 数据链路层    1
1 物理层 --------------     主机至网络层         1
1从上向下数据封包--------------------------------


端口号：
用于标示进程的逻辑地址，不同进程的标示
有效端口  0~ 65535  其中0~1024系统使用或保留端口。


传输协议  XX重要。
UDP
面向无连接
数据及源和目的封装成数据包中，不需要建立连接
每个数据报的大小限制在64K内
因无连接，是不可靠协议
不需要建立连接，速度快
举例：网络聊天，视频会议，对讲机等。


TCP
建立连接，形成传输数据通道
在连接中进行大数据传输
通过三次握手完成连接，是可靠协议
必须建立连接，效率会稍低
三次握手：你在吗》》我在》》我知道你在了。
举例：打电话，下载等。


Socket--插座
指网络编程
sochet就是为网络服务提供的一种机制
通信的两端都有Socket
网络通信其实就是socket之间的通信。
数据在两个socket间通过IO传输。


public class test1 {


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

InetAddress i = InetAddress.getLocalHost();
  System.out.println(i.toString());
//获取主机名称和地址
// System.out.println(i.getHostAddress());
// System.out.println(i.getHostName());
 
//以IP地址为主，主机名需要解析。
InetAddress ia = InetAddress.getByName("www.jd.com");
System.out.println("add="+ia.getHostAddress());
System.out.println("name="+ia.getHostName());

}

}
---
package TCP;

 UDP
 需求：通过udp传输方式，将一段文字数据发出去
 思路：
 1，建立udpsocket服务
 2，提供数据，并将数据封装到数据包中
 3，通过socket服务的发送功能，将数据包发出去
 4，关闭资源。
 
 发送端test2   --   接收端test3


import java.net.*;
public class test2 {


public static void main(String[] args)throws Exception
{
// TODO Auto-generated method stub


//建立udpsocket服务，通过Datagramsocket对像8888是自定义的，默认是随机的。
DatagramSocket ds = new DatagramSocket(8888);

//确定数据，并封装成数据包，DatagramPacket（byte[],int length , InetAddress address ,int port）;
byte[] buf ="udp ge men lai le".getBytes();
DatagramPacket dp = new DatagramPacket(buf, buf.length , InetAddress.getByName("192.168.0.105"),10000);

//通过socket服务，将已有数据包发送出去，通过send方法
ds.send(dp);

//关闭资源
ds.close();

}

}
--
package TCP;

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


思路；
1，定义UDPsocket服务, 通常会监听一个端口，其实就是给这个接受网络应用程序
定义数字标示，方便于明确那些数据过来该应用程序可以处理。
2，定义一个数据包，存储接收到的字节数据，数据包对象中有功能可以提取数据。
3，通过socket服务receive方法接受到的数据存入定义好的数据包中
4，通过数据包对象特有功能，将这些不同数据取出，打印在控制台上
5，关闭资源

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class test3 {


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();

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

int port = dp.getPort();

System.out.println(ip+"--"+data+"--"+port);

//5.关闭资源
ds.close();
}

}
---
package TCP;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class test4 {


public static void main(String[] args)throws IOException 
{
// TODO Auto-generated method stub
DatagramSocket ds =new DatagramSocket();
BufferedReader bfr =
new BufferedReader(new InputStreamReader(System.in));
String line = null;
while((line = bfr.readLine())!=null)
{
if("886".equals(line))
break;
byte[] buf = line.getBytes();
DatagramPacket dp = 
new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.0.105"), 1001);
ds.send(dp);
}
ds.close();
}

}
---
package TCP;


import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class test5 {
public static void main(String[] args)throws Exception
{
DatagramSocket ds =new DatagramSocket(1001);
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);

}
}

}
---
package TCP;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

 编写一个聊天程序
 有收数据的部分，和发数据的部分
 这两部分需要同时执行
 那就西药用到多线程技术
 一个线程控制收，一个线程控制发
 
 因为收和发动作是不一致的，所以
 要定义两个run方法，而且这两个方法
 要封装到不同的类中。

class Send implements Runnable
{
private DatagramSocket ds;
public Send(DatagramSocket ds)
{
this.ds =ds;
}
public void run()
{
try {
BufferedReader bfr =
new BufferedReader(new InputStreamReader(System.in));
String line =null;
while((line = bfr.readLine())!= null)
{
if("886".equals(line))
break;
byte[] buf =line.getBytes();
DatagramPacket dp = 
new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.0.105"), 1002);
ds.send(dp);
}
ds.close();
} catch (Exception e) {
throw new RuntimeException("发送端失败");
}
}
}
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("接收端失败");

}
}
}
public class test6 {


public static void main(String[] args) throws Exception
{
DatagramSocket sendSocket = new DatagramSocket();
DatagramSocket receiveSocket = new DatagramSocket();

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

}
}
---
package TCP;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

 演示TCP传输
 1，tcp分客户端和服务端
 2，客户端对应的对象是 Socket
  服务端对应对象是ServerSocket
 先启动服务端
 
 客户端
通过查阅socket对象，发现该对象在建立时，就可以取连接指定主机
因为tcp是面向连接的，所以在建立socket服务时就要
有服务端存在，并连接成功，形成通路后，在该通道进行数据的传输


步骤
1，创建Socket 服务，并指定连接的主机和端口。
 
 服务端
 1，建立服务端的socket服务，ServerSocket（）；
 并监听一个端口
 2.获取连接过来的客户端对象。
 通过ServerSocket的accept方法  没有连接会等，是阻塞式的。
 3.客户端如果发过来数据，那么服务端要使用对于的客户端对象
 并获取该客户端对象的读取发过来的数据并打印控制台上。
 4.关闭服务端（可选）

public class TcpClient {
//客户端class Client
public static void main(String[] args)throws Exception
{
//创建客户端socket服务，指定目的主机和端口
Socket s = new Socket("192.168.0.105",10006);

//为了发送数据，应该获取socket中输出流
OutputStream out = s.getOutputStream();

out.write("tcp ge men lai le".getBytes());
s.close();
}
}

package TCP;

import java.io.*;
import java.net.*;
class TcpServer 
{
//服务端class Server

public static void main(String[] args)throws IOException
{
//建立服务端socket服务，并监听一个端口
ServerSocket ss = new ServerSocket(10006);

//通过accept 方法获取连接过来的客户端对象
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();//关闭客户端。
}
}
-----
package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;


 演示tcp的传输的客户端和服务端的互访
 需求：客户端给服务端发送数据，服务端收到后，给客户端大亏信息。
 
 客户端
 1，建立socket服务，指定要连接的主机和端口
 2，获取socket流中的输出流，将数据写到该流中。通过网络发送给服务端。
 3，获取socket流中的输入流，将服务端的反馈数据获取到，并打印。
 4，关闭客户端资源。
 
public class TcpClient2 {


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


Socket s = new Socket("192.168.0.105",10010);

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();
}
}
package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer2 {


public static void main(String[] args)throws Exception
{
// TODO Auto-generated method stub


ServerSocket ss = new ServerSocket(10010);
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));
Thread.sleep(5000);
OutputStream out = s.getOutputStream();
out.write("哥们收到了，开心".getBytes());

s.close();
ss.close();

}
}
-------
package TCP;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

 需求：建立一个文本转换服务器
 客户端给服务端发送本文，服务端会将文本转换成大写返回给客户端
 而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束
 
 分析
 客户端
 既然操作设备上的数据，那么就可以使用io技术，并按照io的操作来思考，
 源 ；键盘录入
 目的 ； 网络设备，网络输出流
 而且操作的是文本数据，可以用字符流
 
 步骤；
 1，建立服务
 2，获取录入
 3，发给服务端
 4，获取返回数据  3,4循环
 5，结束，关资源
 都是文本数据，字符流，加入缓冲
 

public class TcpClient3 {


public static void main(String[] args)throws Exception
{
Socket s = new Socket("192.168.0.105",10011);
//定义读取键盘数据流对象
BufferedReader bfr = 
new BufferedReader(new InputStreamReader(System.in));
//定义目的，将数据写入到socket输出流中，发给服务端
//BufferedWriter bfwout =
//     new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//上面简化写法
PrintWriter out =new PrintWriter(s.getOutputStream());
//定义一个socket读取流，读取返回的大写信息。
BufferedReader bfin =
new BufferedReader(new InputStreamReader(s.getInputStream()));
String line =null;
while((line =bfr.readLine())!= null)
{
if("over".equals(line))
break;

out.println(line);
//下面简化成上面语句
// bfwout.write(line);
// bfwout.newLine();
// bfwout.flush();

String str =bfin.readLine();
System.out.println("server---"+str);
}
bfr.close();
s.close();

}
}

package TCP;

 该例子出现的问题
 客户端和服务端都在莫名的等待，这是因为
 客户端和服务端，都有阻塞式的方法，这些方法
 没有读到结束标记，就会一直等，而导致，两端都在等待，
 newline();
 flush();
 
import java.io.*;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer3 {


public static void main(String[] args) throws Exception
{
// TODO Auto-generated method stub
ServerSocket ss = new ServerSocket(10011);
Socket s =ss.accept();
//源，读取流中的数据
BufferedReader bfrin =
new BufferedReader(new InputStreamReader(s.getInputStream()));

//目的,socket输出流，将大写数据，写入到socket输出流，并发送给客户端
//BufferedWriter bfwout =
// new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

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

String line =null;
while((line =bfrin.readLine())!=null)
{
System.out.println(line);

out.println(line.toUpperCase());
// bfwout.write(line.toUpperCase());
// bfwout.newLine();
// bfwout.flush();
}
s.close();
ss.close();
}
}
--------
package TCP2;
//上传文件练习
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class TextClient {

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

Socket s =new Socket("192.168.0.105",10013);

BufferedReader bfr =
new BufferedReader(new FileReader("stu.txt"));
PrintWriter out =new PrintWriter(s.getOutputStream(),true);

String line =null;
while((line=bfr.readLine())!=null)
{
out.println(line);
}


//关闭客户端输出流，相当于给流中加入结束标记-1.
s.shutdownOutput();

BufferedReader bfrin =
new BufferedReader(new InputStreamReader(s.getInputStream()));
String str =bfrin.readLine();
System.out.println(str);

bfr.close();
s.close();
}

}
package TCP2;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TextServer {


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


ServerSocket ss =new ServerSocket(10013);
Socket s =ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"............connected");

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

PrintWriter out = new PrintWriter(new FileWriter("123.txt"),true);

String line =null;
while((line = bfrin.readLine())!=null)
{
out.println(line);
}


PrintWriter pw =new PrintWriter(s.getOutputStream(),true);
pw.println("上传成功");

out.close();
s.close();
ss.close();
}

}
----------
package TCP2;
//上传图片
import java.io.*;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class PicClient {


/**
* @param args
*/
public static void main(String[] args) throws Exception
{

Socket s = new Socket("192.168.0.105",10015);

FileInputStream fis = new FileInputStream("1.jpg");

OutputStream os = s.getOutputStream();

byte[] buf =new byte[1024];
int len =0;
while((len= fis.read(buf))!=-1)
{
os.write(buf,0,len);
}

s.shutdownOutput();

InputStream is =s.getInputStream();
byte [] by = new byte[1024];
int a =is.read(by);
System.out.println(new String(by,0,a));

fis.close();
s.close();
}


}
 
package TCP2;


import java.io.*;
import java.net.*;


/*public class PicServer {


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

ServerSocket ss =new ServerSocket(10015);
Socket s = ss.accept();

InputStream is =s.getInputStream();

FileOutputStream fos = new FileOutputStream("2.jpg");

byte[] buf = new byte[1024];
int len =0;
while((len = is.read(buf))!= -1)
{
fos.write(buf,0,len);
}

OutputStream os = s.getOutputStream();
os.write("上传完毕".getBytes());

fos.close();
s.close();
ss.close();
}

}*/

 这个服务端有个局限性，当A客户端连接上后，被服务端获取到
 服务端执行具体流程，这时B客户端连接，之恩那个等待
 
 唯一服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法，
 所以暂时获取不到B客户端对象。
 
 那么为了可以让多个客户端同时并发访问服务端
 那么服务端最好就是每一个客户端封装到一个单独的线程中
 这样就可以同时处理多个客户端请求
 
 那么如何定义线程
 只要明确了每一个客户端要在服务端执行的代码即可，将代码存入run方法中。

class PicThread implements Runnable
{
private Socket s;
public PicThread(Socket s)throws Exception
{
this.s =s;
}
public void run()
{
int count =0;
try {
String ip =s.getInetAddress().getHostAddress();
System.out.println(ip+".........c");
InputStream is =s.getInputStream();
//避免覆盖，
File file = new File(ip+"("+(count++)+")"+".jpg");
while(file.exists())
file=new File(ip+"("+(count++)+")"+".jpg");

FileOutputStream fos = new FileOutputStream(file);

byte[] buf = new byte[1024];
int len =0;
while((len = is.read(buf))!= -1)
{
fos.write(buf,0,len);
}

OutputStream os = s.getOutputStream();
os.write("上传完毕".getBytes());

fos.close();
s.close();
} catch (Exception e) {
throw new RuntimeException("ip上传失败");
}
}
}
public class PicServer {


public static void main(String[] args) throws Exception
{
ServerSocket ss =new ServerSocket(10015);
while(true)
{
Socket s = ss.accept();
new Thread(new PicThread(s)).start();
}
}
}
----------
package TCP2;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

 客户端通过键盘录入用户名
 服务端对这个用户名进行校验
 
 如果该用户存在，在服务端显示xxx 已登录
 并在客户端显示 xxx 欢迎光临
 
 如果该用户不存在，在服务端显示xxx 尝试登陆
 并在客户端显示xxx 该用户不存在
 
 最多三次。
 
public class LoginClient 
{
public static void main(String[] args)throws Exception
{


Socket s= new Socket("192.168.0.105",10027);
BufferedReader bfr =
new BufferedReader(new InputStreamReader(System.in));
PrintWriter out =new PrintWriter(s.getOutputStream(),true);

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

for (int i = 0; i < 3; i++) 
{
String line =bfr.readLine();

if(line==null)
break;

out.println(line);
String info = bfrin.readLine();
System.out.println(info);

if(info.contains("欢迎"))
break;
}

bfr.close();
s.close();

}
}


package TCP2;

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 UserThread implements Runnable
{
private Socket s;
UserThread(Socket s)
{
this.s = s;
}
public void run()
{
String ip =s.getInetAddress().getHostAddress();
System.out.println(ip+".........connected");
try 
{
for (int i = 0; i < 3; i++) 
{
BufferedReader bfrin =
new BufferedReader(new InputStreamReader(s.getInputStream()));

String name = bfrin.readLine();
if(name==null)
break;

BufferedReader bfr = new BufferedReader(new FileReader("f:\\1.txt"));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);


String line = null;

boolean flag = false;//加个标记
while((line = bfr.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+"---校验失败");
}
}
}


public class LoginServer {
public static void main(String[] args)throws Exception
{
ServerSocket ss = new ServerSocket(10027);
while(true)
{
Socket s =ss.accept();
new Thread(new UserThread(s)).start();
}
}

}
------------
package TCP2;
//自定义浏览器 服务端
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
//浏览器里输入主机地址和：11002，就可以访问本服务端，显示文字
public class server {


public static void main(String[] args) throws Exception
{
// TODO Auto-generated method stub
ServerSocket ss =new ServerSocket(11002);
Socket s =ss.accept();
System.out.println(s.getInetAddress().getHostAddress());

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

out.println("客户端你好");

s.close();
ss.close();
}

}
-------
package TCP2;
import java.net.*;
public class URLDemo {


public static void main(String[] args)throws Exception
{
URL url = new URL("http://zhidao.baidu.com/daily/view?id=5334");
System.out.println("getPortocol():"+url.getProtocol());
System.out.println("getHost():"+url.getHost());
System.out.println("getPort():"+url.getPort());
System.out.println("getPath():"+url.getPath());
System.out.println("getFile():"+url.getFile());
System.out.println("getQuery():"+url.getQuery());
}


}

String  getFile();  获取此URL的文件名

String   getHost();  获取此URL的主机名

String   getPort();获取此URL的 端口号

String   getPath();获取此URL的路径部分

String   getProtocol();获取此URL的 协议名称

String   getQuery();获取此URL的查询部
 
------
package TCP2;

import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

public class URLConnectionDemo {

public static void main(String[] args) throws Exception
{
// TODO Auto-generated method stub
URL url = new URL("http://zhidao.baidu.com/daily/view?id=5334");

URLConnection coon =url.openConnection();//收到数据拆包
System.out.println(coon);
InputStream in = coon.getInputStream();

byte[] buf =new byte[1024];
int len = in.read(buf);

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

}

 域名解析：
 
 主机------》DNS 收录公网地址返回给自己主机
  《-------
 |   \
 | \
 |   \
 本地        要访问主机地址

 

-----<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------