JAVA网络编程笔试

　　本文是关于JAVA网络编程笔试，希望对你有所帮助。

　　1、网络编程概述

　　(1)网络模型

　　OSI参考模型

　　TCP/IP参考模型

　　(2)网络通讯要素

　　IP地址

　　端口号

　　传输协议

　　(3)网络通讯前提：

　　**找到对方IP

　　**数据要发送到指定端口。为了标示不同的应用程序，所以给这些网络应用程序都用数字进行标示 。这个表示就叫端口。

　　**定义通信规则。这个规则称为通信协议，国际组织定义了通用协议TCP/IP

　　(4)计算机网络：

　　是指将地理位置不同的具有独立功能的多台计算机及其外部设备，

　　通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，

　　实现资源共享和信息传递的计算机系统。

　　(5)IP地址：

　　IP地址 = 网络号码+主机地址

　　A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码

　　B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码

　　C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码

　　特殊地址:

　　127.0.0.1 回环地址,可用于测试本机的网络是否有问题. ping 127.0.0.1

　　ipconfig:查看本机IP地址

　　xxx.xxx.xxx.0 网络地址

　　xxx.xxx.xxx.255 广播地址

　　A类1.0.0.1---127.255.255.25410.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址)(2)127.X.X.X是保留地址，用做循环测试用的。

　　B类128.0.0.1---191.255.255.254172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。

　　C类192.0.0.1---223.255.255.254192.168.X.X是私有地址

　　D类224.0.0.1---239.255.255.254

　　E类240.0.0.1---247.255.255.254

　　(6)各种网络分类方式

　　A:按网络覆盖范围划分

　　局域网(几米至10公里以内) 　　城域网(10~100公里) 　　广域网(几百公里到几千公里) 　　国际互联网

　　B:按网络拓扑结构划分

　　总线型网络　　星形网络　　环型网络　　树状网络　　混合型网络

　　C:按传输介质划分

　　有线网　　无线网

　　D:按网络使用性质划分

　　公用网　　专用网

　　(7)虚拟专用网络(Virtual Private Network ，简称VPN)指的是在公用网络上建立专用网络的技术。

　　其之所以称为虚拟网，主要是因为整个VPN网络的任意两个节点之间的连接并没有传统专网

　　所需的端到端的物理链路，而是架构在公用网络服务商所提供的网络平台，如Internet、

　　ATM(异步传输模式〉、Frame Relay (帧中继)等之上的逻辑网络，

　　用户数据在逻辑链路中传输。它涵盖了跨共享网络或公共网络的封装、

　　加密和身份验证链接的专用网络的扩展。VPN主要采用了隧道技术、加解密技术、

　　密钥管理技术和使用者与设备身份认证技术。

　　(8)网络模型：

　　****OSI模型

　　应用层

　　表示层

　　会话层

　　传输层

　　网络层

　　数据连接层

　　物理层

　　****TCP/IP模型

　　应用层

　　传输层

　　网际层

　　主机至网络层

　　2、TCP和UDP

　　(1)UDP和TCP的区别：

　　UDP

　　将数据及源和目的封装成数据包中，不需要建立连接

　　每个数据报的大小在限制在64k内

　　因无连接，是不可靠协议

　　不需要建立连接，速度快

　　TCP

　　建立连接，形成传输数据的通道。

　　在连接中进行大数据量传输

　　通过三次握手完成连接，是可靠协议

　　必须建立连接，效率会稍低

　　注：三次握手：

　　第一次：我问你在么?

　　第二次：你回答在。

　　第三次：我反馈哦我知道你在。

　　3、Socket(UDP传输)

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

　　**通信的两端都有Socket。

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

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

　　**玩Socket主要就是记住流程，代码查文档就行

　　(1)UDP传输：DatagramSocket与DatagramPacket

　　**发送端：

　　建立DatagramSocket服务;

　　提供数据，并将数据封装到字节数组中;

　　创建DatagramPacket数据包，并把数据封装到包中，同时指定IP和接收端口

　　通过Socket服务，利用send方法将数据包发送出去;

　　关闭DatagramSocket和DatagramPacket服务。

　　**接收端：

　　建立DatagramSocket服务，并监听一个端口;

　　定义一个字节数组和一个数据包，同时将数组封装进数据包;

　　通过DatagramPacket的receive方法，将接收的数据存入定义好的数据包;

　　通过DatagramPacke关闭t的方法，获取发送数据包中的信息;

　　关闭DatagramSocket和DatagramPacket服务。

　　DatagramSocket与DatagramPacket方法摘要：

　　*****DatagramSocket

　　构造方法：

　　DatagramSocket()

　　构造数据报套接字并将其绑定到本地主机上任何可用的端口。

　　DatagramSocket(intport)

　　创建数据报套接字并将其绑定到本地主机上的指定端口。

　　DatagramSocket(intport, InetAddress laddr)

　　创建数据报套接字，将其绑定到指定的本地地址。

　　方法摘要:

　　voidclose()

　　关闭此数据报套接字。

　　InetAddressgetInetAddress()

　　返回此套接字连接的地址。

　　InetAddressgetLocalAddress()

　　获取套接字绑定的本地地址。

　　intgetPort()

　　返回此套接字的端口。

　　voidreceive(DatagramPacket p)

　　从此套接字接收数据报包。

　　voidsend(DatagramPacket p)

　　从此套接字发送数据报包。

　　****DatagramPacket

　　构造方法：

　　DatagramPacket(byte[]buf, int length)

　　构造 DatagramPacket，用来接收长度为 length 的数据包。

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

　　构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

　　InetAddressgetAddress()

　　返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。

　　byte[] getData()

　　返回数据缓冲区。

　　intgetLength()

　　返回将要发送或接收到的数据的长度。

　　intgetPort()

　　返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。

　　代码示例：

　　****发送端：

　　class UDPSend

　　{

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

　　{

　　DatagramSocket ds = new DatagramSocket();

　　byte[] buf = "这是UDP发送端".getBytes();

　　DatagramPacket dp = new DatagramPacket(

　　buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);

　　ds.send(dp);

　　ds.close();

　　}

　　}

　　****接收端

　　class UDPRece

　　{

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

　　{

　　DatagramSocket ds = newDatagramSocket(10000);

　　byte[] buf = new byte[1024];

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

　　ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中

　　String ip =dp.getAddress().getHosyAddress();//获取发送端的ip

　　String data = new String(dp.getData(),0,dp.getLength());//获取数据

　　int port = dp.getPort();//获取发送端的端口号

　　sop(ip+":"+data+":"+port);

　　ds.close();

　　}

　　}

　　需求1：UDP键盘录入数据，并发送给接收端

　　发送端：

　　class UDPSend

　　{

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

　　{

　　DatagramSocket ds = new DatagramSocket();

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

　　String line = null;

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

　　{

　　if("886".equals(line))

　　break;

　　byte[] buf = line.getBytes();

　　DatagramPacket dp = new DatagramPacket(

　　buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);

　　ds.send(dp);

　　}

　　ds.close();

　　}

　　}

　　接收端：

　　class UDPRece

　　{

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

　　{

　　DatagramSocket ds = newDatagramSocket(10000);

　　while(true)

　　{

　　byte[] buf = new byte[1024];

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

　　ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中

　　String ip =dp.getAddress().getHosyAddress();//获取发送端的ip

　　String data = newString(dp.getData(),0,dp.getLength());//获取数据

　　int port = dp.getPort();//获取发送端的端口号

　　sop(ip+":"+data+":"+port);

　　ds.close();

　　}

　　}

　　}

　　需求2：编写简单的聊天工具

　　思路：

　　使用多线程技术

　　发送端：

　　class UDPSend implements Runnable

　　{

　　private DatagramSocket ds;

　　public UDPSend(){}

　　public UDPSend(DatagramSocket ds)

　　{

　　this.ds=ds;

　　}

　　public void run()

　　{

　　try

　　{

　　BufferedReader bufr = new BufferedReader(

　　new InputStreamReader(System.in));

　　String line = null;

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

　　{

　　if("886".equals(line))

　　break;

　　byte[] buff = line.getBytes();

　　DatagramPacket dp = new DatagramPacket(

　　buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);

　　ds.send(dp);

　　}

　　}

　　catch(Exception e)

　　{

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

　　}

　　}

　　}

　　接收端：

　　class UDPRece implements Runnable

　　{

　　private DatagramSocket ds;

　　public UDPSend(){}

　　public UDPSend(DatagramSocket ds)

　　{

　　this.ds=ds;

　　}

　　public void run()

　　{

　　try

　　{

　　while(true)

　　{

　　byte[] buf = new byte[1024];

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

　　ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中

　　String ip =dp.getAddress().getHosyAddress();//获取发送端的ip

　　String data = new String(dp.getData(),0,dp.getLength());//获取数据

　　int port = dp.getPort();//获取发送端的端口号

　　sop(ip+":"+data+":"+port);

　　}

　　}

　　catch(Exception e)

　　{

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

　　}

　　}

　　}

　　测试类：

　　class UDPTest

　　{

　　public static void main(String[] args)

　　{

　　DatagramSocket sendSocket = new DatagramSocket();

　　DatagramSocket receSocket = newDatagramSocket(10000);

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

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

　　}

　　}

　　(2)TCP传输

　　Socket和ServerSocket

　　建立客户端和服务器端

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

　　关闭socket

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

　　****Socket

　　**构造方法：

　　Socket()

　　通过系统默认类型的 SocketImpl 创建未连接套接字

　　Socket(InetAddressaddress, int port)

　　创建一个流套接字并将其连接到指定 IP 地址的指定端口号。

　　Socket(Stringhost, int port)

　　创建一个流套接字并将其连接到指定主机上的指定端口号。

　　**方法摘要：

　　voidclose()

　　关闭此套接字。

　　InetAddress getInetAddress()

　　返回套接字连接的地址。

　　InputStreamgetInputStream()

　　返回此套接字的输入流。

　　OutputStreamgetOutputStream()

　　返回此套接字的输出流。

　　intgetPort()

　　返回此套接字连接到的远程端口。

　　voidshutdownInput()

　　此套接字的输入流置于“流的末尾”。

　　voidshutdownOutput()

　　禁用此套接字的输出流。

　　StringtoString()

　　将此套接字转换为 String。

　　****ServerSocket

　　**构造方法：

　　ServerSocket()

　　创建非绑定服务器套接字。

　　ServerSocket(intport)

　　创建绑定到特定端口的服务器套接字。

　　方法摘要：

　　Socketaccept()

　　侦听并接受到此套接字的连接。

　　voidclose()

　　关闭此套接字。

　　InetAddressgetInetAddress()

　　返回此服务器套接字的本地地址。

　　****TCP传输流程：

　　**客户端：

　　建立Socket服务，并制定要连接的主机和端口;

　　获取Socket流中的输出流OutputStream，将数据写入流中，通过网络发送给服务端;

　　获取Socket流中的输出流InputStream，获取服务端的反馈信息;

　　关闭资源。

　　**服务端：

　　建立ServerSocket服务，并监听一个端口;

　　通过ServerSocket服务的accept方法，获取Socket服务对象;

　　使用客户端对象的读取流获取客户端发送过来的数据;

　　通过客户端对象的写入流反馈信息给客户端;

　　关闭资源;

　　****代码示例：

　　客户端：

　　class TCPClient

　　{

　　public static void main(String[] args)

　　{

　　Socket s = newSocket("192.168.1.253",10000);

　　OutputStream os = s.getOutputStream();

　　out.write("这是TCP发送的数据".getBytes());

　　s.close();

　　}

　　}

　　服务端：

　　class TCPServer

　　{

　　public static void main(String[] args)

　　{

　　ServerSocket ss = new ServerSocket(10000);

　　Socket s = ss.accept();

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

　　sop(ip);

　　InputStream is = s.getInputStream();

　　byte[] buf = new byte[1024];

　　int len = is.read(buf);

　　sop(new String(buf,0,len));

　　s.close();

　　ss.close();

　　}

　　}

　　TCP需求1：客户端给服务端发送数据，服务端接收到后反馈信息给客户端

　　客户端：

　　class TCPClient

　　{

　　public static void main(String[] args)

　　{

　　Socket s = newSocket("192.168.1.253",10000);

　　OutputStream os = s.getOutputStream();

　　out.write("这是TCP发送的数据".getBytes());

　　InputStream is = s.getInputStream();

　　byte[] buf = new byte[1024];

　　int len = is.read(buf);

　　sop(new String(buf,0,len));

　　s.close();

　　}

　　}

　　服务端：

　　class TCPServer

　　{

　　public static void main(String[] args)

　　{

　　ServerSocket ss = new ServerSocket(10000);

　　Socket s = ss.accept();

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

　　sop(ip);

　　InputStream is = s.getInputStream();

　　byte[] buf = new byte[1024];

　　int len = is.read(buf);

　　sop(new String(buf,0,len));

　　OutputStream os = s.getOutputStream();

　　out.write("这是TCP发送的数据".getBytes());

　　s.close();

　　ss.close();

　　}

　　}

　　TCP需求2：建立一个文本转换服务端，客户给服务端发送文本，服务端将数据转换成大写后返回给客户端

　　当客户端输入over时，转换结束

　　客户端：

　　class TCPClient

　　{

　　public static void main(String[] args)

　　{

　　Socket s = newSocket("192.168.1.253",10000);

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

　　BufferedWriter bufOut = newBufferedWriter(new OutputStreamWriter(

　　s.getOutputStream()));

　　BufferedReader bufIn = newBufferedReader(new InputStreamReader(

　　s.getInputStream()));

　　String line = null;

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

　　{

　　if("over".equals(line))

　　break;

　　bufOut.write(line);

　　bufOut.newLine();

　　bufOut.flush();

　　String retVal = bufIn.readLine();

　　sop("server:"+retVal);

　　}

　　bufr.close();

　　s.close();

　　}

　　}

　　服务端：

　　class TCPServer

　　{

　　public static void main(String[] args)

　　{

　　ServerSocket ss = new ServerSocket(10000);

　　Socket s = ss.accept();

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

　　sop(ip);

　　BufferedReader bufIn = newBufferedReader(new InputStreamReader(

　　s.getInputStream()));

　　BufferedWriter bufOut = newBufferedWriter(new OutputStreamWriter(

　　s.getOutputStream()));

　　while((line = bufIn.readLine())!=null)

　　{

　　bufOut.write(line.toUpperCase());

　　bufOut.newLine();

　　bufOut.flush();

　　}

　　s.close();

　　ss.close();

　　}

　　}

　　**需求3：拷贝文件

　　客户端：

　　class TCPClient

　　{

　　public static void main(String[] args)

　　{

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

　　BufferedReader bufr = newBufferedReader(new FileReader("g:\\demo.txt"));

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

　　String line = null;

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

　　{

　　pw.println();

　　}

　　s.shutDownOutput();

　　BufferedReader bufIn = newBufferedReader(new InputStreamReader(

　　s.getInputStream()));

　　String retVal = bufIn.readLine();

　　sop(retVal);

　　bufr.close();

　　s.close();

　　}

　　}

　　服务端：

　　class TCPServer

　　{

　　public static void main(String[] args)

　　{

　　ServerSocket ss = new ServerSocket(10000);

　　Socket s = ss.accept();

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

　　sop(ip);

　　BufferedReader bufIn = newBufferedReader(new InputStreamReader(

　　s.getInputStream()));

　　PrintWriter out = new PrintWriter(newFileWriter"copy.txt",true);

　　String line =null;

　　while((line = bufIn.readLine())!=null)

　　{

　　out.write(line);

　　}

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

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

　　out.close();

　　s.close();

　　ss.close();

　　}

　　}

　　需求4：上传图片

　　客户端：

　　class TCPClient

　　{

　　public static void main(String[] args)

　　{

　　Socket s = newSocket("192.168.1.253",10000);

　　FileInputStream fis = newFileInputStream("g:\\1.bmp");

　　OutputStream out = s.getOutputStream();

　　byte[] buf = new byte[1024];

　　int len = 0;

　　while((len = bufr.read())!=-1)

　　{

　　out.write(buf,0,len);

　　}

　　s.shutDownOutput();

　　InputStream in = s.getInputStream();

　　byte[] bufIn = new byte[1024];

　　int lenIn = in.read(bufIn);

　　sop(new String(bufIn,0,lenIn);

　　fis.close();

　　s.close();

　　}

　　}

　　服务端：

　　class TCPServer

　　{

　　public static void main(String[] args)

　　{

　　ServerSocket ss = new ServerSocket(10000);

　　Socket s = ss.accept();

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

　　sop(ip);

　　FileOutputStream fos = newFileOutputStream("g:\\copy.bmp");

　　InputStream in = s.getInputStream();

　　byte[] bufIn = new byte[1024];

　　int lenIn = 0;

　　while((lenIn=bufIn.read())!=-1)

　　{

　　fos.write(bufIn,0,lenIn)

　　}

　　OutputStream outIn = s.getOutputStream();

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

　　fos.close();

　　s.close();

　　ss.close();

　　}

　　}

　　需求5：客户端并发登陆

　　客户端通过键盘录入用户名，服务端对这个用户名进行校验

　　如果用户存在，在服务端现实xxx已登录，并在客户端现实欢迎xxx

　　如果用户不存在，在服务端现实xxx正在尝试登陆，并在客户端现实xxx用户不存在

　　最多登陆三次。

　　校验端：

　　class User implements Runnable

　　(

　　private Socket s;

　　public User(){}

　　public User(Socket s)

　　{

　　this.s=s;

　　}

　　public void run()

　　{

　　try

　　{

　　BufferedReader bufrIn = new BufferedReader(

　　new InputStream(s.getInputStream()))

　　String name = bufrIn.readLine();

　　if(name==null)

　　{

　　sop("用户名为空");

　　break;

　　}

　　BufferedReader bufr = new BufferedReader(

　　new FileReader("user.txt"));

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

　　String line = null;

　　boolean flag = false;

　　while((line = bufr.reanLine())!=null)

　　{

　　if(line.equals(name))

　　{

　　flag = true;

　　break;

　　}

　　if(flag)

　　{

　　sop(name+"已登陆");

　　pw.println("欢迎"+name);

　　break;

　　}

　　else

　　{

　　sop(name+"正尝试登陆");

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

　　}

　　}

　　s.close();

　　}

　　catch(Exception e)

　　{

　　throw new RuntimeException("用户校验失败");

　　}

　　}

　　)

　　客户端：

　　class LoginClient

　　{

　　public static void main(String[] args)

　　{

　　Socket s = newSocket("192.168.1.253",10000);

　　BufferedReader bufr = new BufferedReader(

　　new InputStreamReader(System.in)));

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

　　BufferedReader bufIn = new BufferedReader(

　　new InputStreamReader(s.getInputStream()));

　　for(int i=0;i<3;i++)

　　{

　　String line = bufr.readLine();

　　if(line == null)

　　{

　　sop("用户名不能为空!");

　　break;

　　}

　　out.write(line);

　　String retVal = bufIn.readLine();

　　sop(retVal);

　　}

　　bufr.close();

　　s.close();

　　}

　　}

　　服务端：

　　class LoginServer

　　{

　　public static void main(String[] args)

　　{

　　ServerSocket ss = new ServerSocket(10000);

　　while(true)

　　{

　　Socket s = ss.accept();

　　new Thread(new User()).start();

　　}

　　}

　　}