【移动应用开发技术】黑马程序员-网络编程篇

【移动应用开发技术】黑马程序员——网络编程篇

android培训、java培训、期待与您交流！概述

2，数据要发送到对方指定的应用程序上。为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识。

为了方便称呼这个数据，叫做端口（逻辑端口）；

3，定义通信规则。这个通讯规则称为协议。

国际组织定义了通用协议TCP/IP

端口范围：0~65535

0~1024一般都被系统预定的

常见端口：

web服务默认端口80

Tomcat默认端口8080

mysql默认端口3306数据模型

OSI数据模型

TCP/IP参考模型

应用层

|

表示层

|

应用层

会话层

|

传输层

|

传输层

TCP/UDP

网络层

|

网际层

IP地址协议

数据链路层

|

主机至网络层

物理层

|

staticInetAddressgetByName(Stringhost)在给定主机名的情况下确定主机的IP地址。UDP和TCP

UDP

1、面向无连接。

2、将数据及源和目的封装成数据包中，不需要建立连接。每个数据包的大小限制在64K内。

3，因为无连接，是不可靠协议。

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

例子：聊天软件。视频会议。只追求速度，即便丢失部分数据无伤大雅。

TCP

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

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

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

必须建立连接，效率会稍低。Socket服务

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

2、通信的两端都有Socket

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

4、数据在两个Socket间通过IO传输UDP发送端和接收端import.*;

/*

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

定义一个udp发送端。

思路：

1，建立udpsocket服务。

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

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

4，关闭资源。

*/

classUdpSend

{

publicstaticvoidmain(String[]args)throwsException

{

//1,创建udp服务，通过DatagramScket对象。

DatagramSocketds=newDatagramSocket();

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

byte[]data="udpgemenlaile".getBytes();

DatagramPacketdp=

//数据包数组//长度//目的地址。//目的端口号

newDatagramPacket(data,data.length,InetAddress.getByName("26"),1000);

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

ds.send(dp);

//关闭资源。

ds.close();

}

}

/*

需求：

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

定义udp的接收端。

思路：

1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接受网络应用程序定义数字标识。

方便于明确哪些数据过来改应用程序可以处理。

2，定义一个数据包（没有数据），因为要存储接受到的字节数据，因为数据包对象中有更多功能可以提前字节数据中的不同数据信息。

3，通过socket服务的receive方法将接受到的数据存入定义好的数据包中。

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

5，关闭资源。

*/

classUdpRece

{

publicstaticvoidmain(String[]args)throwsException

{

//1，创建udpsocket，建立端点。

DatagramSocketds=newDatagramSocket(10000);

while(true)

{

//2，定义数据包，用于存储数据。

byte[]buf=newbyte[1024];

DatagramPacketdp=newDatagramPacket(buf,buf.length);

//3,通过服务的receive方法将接受到的数据存入数据包中。

ds.receive(dp);

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

Stringip=dp,getAddress().getHostAddress();

Stringdata=newString(dp.getData(),0,dp.getLength());

intport=dp.getPort();

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

}

//关闭资源。

//ds.close();

}

}UDP-使用键盘录入方式传输数据。import.*;

importjava.io.*;

classUdpSend2

{

publicstaticvoidmain(String[]args)throwsException

{

//创建UDP服务。

DatagramSocketds=newDatagramSocket();

//键盘录入。

BufferedReaderbufr=

newBufferedReader(newInputStreamReader(System.in));

Stringline=null;

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

{

if("over".equals(line))//判断结束标记

break;

byte[]buf=line.getBytes();

//定义用于发送的数据报包，将数据发送端指定的主机的端口上。

DatagramPacketdp=newDatagramPacket(buf,buf.length,InetAddress.getByName(""),10001);

ds.send(dp);

}

ds.close();

}

}

classUdpRece2

{

publicstaticvoidmain(String[]args)throwsException

{

//创建udp服务，并指定端口。

DatagramSocketds=newDatagramSocket(10001);

while(true)

{

byte[]buf=newbyte[1024];//定义容器，存储数据。

//定义用于接收的数据报包。

DatagramPacketdp=newDatagramPacket(buf,buf.length);

//接受数据报包。

ds.receive(dp);

Stringip=dp.getAddress().getHostAddress();

Stringdata=newString(dp.getData(),0,dp.getLength());

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

}

}

}UDP-聊天程序/*

编写一个聊天程序。

有收数据的部分，和发数据的部分。

这两部分需要同时执行。

那就需要用到多线程技术。

一个线程控制收，一个线程控制发。

因为收和发动作是不一致的，所以要定义两个run方法。

而且这两个方法要封装到不同的类中。

*/

import.*;

importjava.io.*;

classSendimplementsRunnable

{

privateDatagramSocketds;

publicSend(DatagramSocketds)

{

this.ds=ds;

}

publicvoidrun()

{

try

{

BufferedReaderbufr=newBufferedReader(newInputStreamReader(System.in));

Stringline=null;

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

{

if("over".equals(line))

break;

byte[]buf=line.getBytes();

DatagramPacketdp=

newDatagramPacket(buf,buf.length,InetAddress.getByName(""),10002);

ds.send(dp);

}

}

catch(Exceptione)

{

thrownewRuntimeException("发送失败");

}

}

}

classReceimplementsRunnable

{

privateDatagramSocketds;

publicRece(DatagramSocketds)

{

this.ds=ds;

}

publicvoidrun()

{

try

{

while(true)

{

byte[]buf=newbyte[1024];

DatagramPacketdp=newDatagramPacket(buf,buf.length);

ds.receive(dp);

Stringip=dp.getAddress().getHostAddress();

Stringdata=newString(dp.getData(),0,dp.getLength());

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

}

}

catch(Exceptione)

{

thrownewRuntimeException("接受失败");

}

}

}

classChatDemo

{

publicstaticvoidmain(String[]args)throwsException

{

DatagramSocketsendSocket=newDatagramSocket();

DatagramSocketreceSocket=newDatagramSocket(10002);

newThread(newSend(sendSocket)).start();

newThread(newRece(receSocket)).start();

}

}TCP-服务端和客户端/*

演示tcp传输。

1，tcp分客户端和服务端。

2,客户端对应的对象时Socket。

服务端对应的对象时ServerSocket。

*/

/*

客户端

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

因为tcp是面向连接的。所以在建立socket服务时，

就要有服务端操作，并连接成功。形成通路后，在该通道进行数据的传输。

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

步骤：

1，创建socket访问，并指定要连接的主机和端口。

*/

importjava.io.*;

import.*;

classTcpClient

{

publicstaticvoidmain(String[]args)throwsException

{

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

Sockets=newSocket("",10003);

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

OutputStreamos=s.getOutputStream();

os.write("tcpgemenlaile".getBytes());

s.close();

}

}

/*

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

服务端：

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

并监听一个端口。

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

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

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

并打印在控制台。

4，关闭服务器.(可选)

*/

classTcpServer

{

publicstaticvoidmain(String[]args)throwsException

{

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

ServerSocketss=newServerSocket(10003);

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

Sockets=ss.accept();

Stringip=s.getInetAddress().getHostAddress();

System.out.println(ip+"connected");

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

InputStreamin=s.getInputStream();

byte[]buf=newbyte[1024];

intlen=in.read(buf);

System.out.println(newString(buf,0,len));

s.close();

ss.close();

}

}TCP--客户端与服务端的互访importjava.io.*;

import.*;

/*

演示tcp的传输的客户端和服务端的互访。

需求：客户端给服务端发生数据，服务端收到后，给刚看的反馈信息。

*/

/*

客户端：

1，建立socket服务。指定要连接主机和端口。

2，获取socket流中的输出流，将数据写到该流中。通过网络发送给服务端。

3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。

4，关闭客户端资源。

*/

classTcpClient2

{

publicstaticvoidmain(String[]args)throwsException

{

Sockets=newSocket("",10004);

OutputStreamout=s.getOutputStream();

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

InputStreamin=s.getInputStream();

byte[]buf=newbyte[1024];

intlen=in.read(buf);

System.out.println(newString(buf,0,len));

s.close();

}

}

classTcpServer2

{

publicstaticvoidmain(String[]args)throwsException

{

ServerSocketss=newServerSocket(10004);

Sockets=ss.accept();

Stringip=s.getInetAddress().getHostAddress();

System.out.println(ip+"connect");

InputStreamin=s.getInputStream();

byte[]buf=newbyte[1024];

intlen=in.read(buf);

System.out.println(newString(buf,0,len));

OutputStreamout=s.getOutputStream();

out.write("收到，哥们你也好".getBytes());

s.close();

ss.close();

}

}TCP练习——实现服务端的文本转换/*

需求:建立一个文本转换服务器。

客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。

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

分析：

客户端：

既然是操作设备上的数据，就可以使用io技术，并按照io的操作规律来思考。

源：键盘录入。

目的：网络设备，网络输出流。而且操作的文本数据。可以选择字符流。

步骤：

1，建立服务。

2，获取键盘录入。

3，将数据发送给服务端。

4，获取服务端返回的大写数据。

5，结束。关闭资源。

*/

importjava.io.*;

import.*;

classTransClient

{

publicstaticvoidmain(String[]args)throwsException

{

Sockets=newSocket("",10005);

//定义读取键盘数据的流对象。

BufferedReaderbufr=

newBufferedReader(newInputStreamReader(System.in));

//定义目的，将数据写入到socket输入流，发给服务端。

//BufferedWriterbufOut=

//newBufferedWriter(newOutputStreamWriter(s.getOutputStream()));

PrintWriterout=newPrintWriter(s.getOutputStream(),true);

//定义一个socket读取流，读取服务端返回的大写信息。

BufferedReaderbufIn=

newBufferedReader(newInputStreamReader(s.getInputStream()));

Stringline=null;

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

{

if("over".equals(line))

break;

out.println(line);

//bufOut.write(line);

//bufOut.newLine();

//bufOut.flush();

Stringstr=bufIn.readLine();

System.out.println("server:"+str);

}

bufr.close();

s.close();

}

}

/*

服务端：

获取socket对象。

源：socket读取流。

目的：serversocket输出流。

*/

classTransServer

{

publicstaticvoidmain(String[]args)throwsException

{

ServerSocketss=newServerSocket(10005);

Sockets=ss.accept();

Stringip=s.getInetAddress().getHostAddress();

System.out.println(ip+"connected");

//读取socket读取流中的数据。

BufferedReaderbufIn=

newBufferedReader(newInputStreamReader(s.getInputStream()));

//目的。socket输出流。将大写数据写入到socket输出流，并发生个客户端。

//BufferedWriterbufOut=

//newBufferedWriter(newOutputStreamWriter(s.getOutputStream()));

PrintWriterout=newPrintWriter(s.getOutputStream(),true);

Stringline=null;

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

{

System.out.println(line);

out.println(line.toUpperCase());

//bufOut.write(line.toUpperCase());

//bufOut.newLine();

//bufOut.flush();

}

s.close();

ss.close();

}

}

/*

该例子出现的问题。

出现：客户端和服务端都在莫名等等等。

为什么呢？

因为客户端和fws都有阻塞式的方法。这些方法没有读到结束标记。那么就一直等。

而导致两端，都在等待。

*/TCP——上传文本importjava.io.*;

import.*;

classTextClient

{

publicstaticvoidmain(String[]args)throwsException

{

Sockets=newSocket("",10006);

BufferedReaderbufr=newBufferedReader(newFileReader("IpDemo.java"));

PrintWriterout=newPrintWriter(s.getOutputStream(),true);

Stringline=null;

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

{

out.println(line);

}

s.shotdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记。

BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));

Stringstr=bufIn.readLine();

System.out.println(str);

bufr.close();

s.close();

}

}

classTextServer

{

publicstaticvoidmain(String[]args)throwsException

{

ServerSocketss=newServerSocket(10006);

Sockets=ss.accept();

Stringip=s.getInetAddress().getHostAddress();

BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));

PrintWriterout=newPrintWriter(newFileWriter("server.txt"),true);

Stringline=null;

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

{

out.println(line);

}

PrintWriterpw=newPrintWriter(s.getOutputStream(),true);

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

}

}TCP--多客户端并发上传图片/*

需求：上传图片。

*/

/*

客户端

1，服务端点。

2，读取客户端已有的数据。

3，通过socket输出流发给服务端。

4，读取服务端反馈信息。

5，关闭。

*/

import.*;

importjava.io.*;

classPicClient

{

publicstaticvoidmain(String[]args)throwsException

{

Sockets=newSocket("",10007);

FileInputStreamfis=newFileInputStream(file);

OutputStreamout=s.getOutputStream();

byte[]buf=newbyte[1024];

intlen=0;

while((len=fis.read(buf))!=-1)

{

out.write(buf,0,len);

}

s.shutdownOutput();

InputStreamin=s.getInputStream();

byte[]bufIn=newbyte[1024];

intnum=in.read(bufIn);

System.out.println(newString(bufIn,0,num));

fis.close();

s.close();

}

}

/*

服务端

这个服务端有个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程。

这时B客户端连接，只有等待。

因为服务端还没有处理完A客户端的请求，还没有循环回来执行下次accpet方法。

所以，暂时获取不到B客户端对象。

为了可以让多个客户端同时并发访问服务端。

那么服务端最好就是将没有客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

如何定义线程呢？

只有明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。

*/

classPicThreadimplementsRunnable

{

privateSockets;

PicThread(Sockets)

{

this.s=s;

}

publicvoidrun()

{

intcount=1;

Stringip=s.getInetAddress().getHostAddress();

try

{

System.out.println(ip+"connect");

InputStreamin=s.getInputStream();

Filefile=newFile(ip+"("+(count)+").jpg");

while(file.exists())

{

file=newFile(ip+"("+(count++)+").jpg");

}

FileOutputStreamfos=newFileOutputStream(file);

byte[]buf=newbyte[1024];

intlen=0;

while((len=in.read(buf))!=-1)

{

fos.write(buf,0,len);

}

OutputStreamout=s.getOutputStream();

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

fos.close();

s.close();

}

catch(Exceptione)

{

thrownewRuntimeException(ip+"上传失败");

}

}

}

classPicServer

{

publicstaticvoidmain(String[]args)throwsException

{

ServerSocketss=newServerSocket(10007);

while(true)

{

Sockets=ss.accept();

newThread(newPicThread(s)).start();

}

//ss.close();

}

}TCP——模拟用户登陆/*

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

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

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

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

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

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

最多就登陆三次。

*/

import.*;

importjava.io.*;

classLoginClient

{

publicstaticvoidmain(String[]args)throwsException

{

Sockets=newSocket("",10008);

BufferedReaderbufr=

newBufferedReader(newInputStreamReader(System.in));

PrintWriterout=newPrintWriter(s.getOutputStream(),true);

BufferedReaderbufIn=newBufferedReader(newInputStreamReader(s.getInputStream()));

for(intx=0;x<3;x++)

{

Stringline=bufr.readLine();

if(line==null)

break;

out.println(line);

Stringinfo=bufIn.readLine();

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

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

break;

}

bufr.close();

s.close();

}

}

classUserThreadimplementsRunnable

{

privateSockets;

UserThread(Sockets)

{

this.s=s;

}

publicvoidrun()

{

Stringip=s.getInetAddress().getHostAddress();

System.out.println(ip+"connected");

try

{

for(intx=0;x<3;x++)

{

BufferedReaderbufIn=

newBufferedReader(newInputStreamReader(s.getInputStream()));

Stringname=bufIn.readLine();

if(name==null)

break;

BufferedReaderbufr=newBufferedReader(newFileReader("user.txt"));

PrintWriterout=newPrintWriter(s.getOutputStream(),true);

Stringline=null;

booleanflag=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(Exceptione)

{

thrownewRuntimeException(ip+"校验失败");

}

}

}

classLoginServer

{

publicstaticvoidmain(String[]args)throwsException

{

ServerSocketss=newServerSocket(10008);

while(true)

{

Sockets=ss.accept();

newThread(newUserThread(s)).start();

}

}

}自定义客户端（服务端—Tomcat；客户端-浏览器）/*

演示客户端和服务端。

1,客户端：浏览器

服务端：自定义

2,客户端：浏览器

服务端：Tomcat服务器。

*/

import.*;

importjava.io.*;

classServerDemo

{

publicstaticvoidmain(String[]args)throwsException

{

ServerSocketss=newServerSocket(11000);

Sockets=ss.accept();

Stringip=s.getInetAddress().getHostAddress();

System.out.println(ip+"connected");

InputStreamin=s.getInputStream();

byte[]buf=newbyte[1024];

intlen=in.read(buf);

System.out.println(newString(buf,0,len));

PrintWriterout=newPrintWriter(s.getOutputStream(),true);

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

s.close();

ss.close();

}

}自定义图形化界面浏览器importjava.awt.*;

importjava.awt.event.*;

importjava.io.*;

classMyIEByGUI

{

privateFramef;

privateButtonbut;

privateTextFieldtf;

privateTextAreata;

privateDialogd;//什么时候出错什么时候创建对象。放在这里只是便于阅读。

privateLabellab;

privateButtonokBut;

MyIEByGUI()

{

init();

}

publicvoidinit()

{

f=newFrame("MyWindow");

f.setBounds(300,100,500,400);

f.setLayout(newFlowLayout());

d=newDialog(f,"提示信息-self",true);//模式为true时，后面的窗体不能操作。

d.setBounds(400,200,240,150);

d.setLayout(newFlowLayout());

lab=newLabel();

okBut=newButton("确定");

d.add(lab);

d.add(okBut);

tf=newTextField(40);

but=newButton("转到");

ta=newTextArea(20,60);//20行，60列

f.add(tf);//注意，因为流式布局，所以按顺序添加。

f.add(but);

f.add(ta);

myEvent();

f.setVisible(true);

}

privatevoidmyEvent()

{

d.addWindowListener(newWindowAdapter()

{

publicvoidwindowCloing(WindowEvente)

{

d.setVisible(false);//不需要关闭。

}

});

okBut.addActionListener(newActionListener()

{

publicvoidactionPerformed(ActionEvente)

{

d.setVisible(false);

}

});

tf.addKeyListener(newKeyAdapter()

{

publicvoidkeyPressed(KeyEvente)

{

if(e.getKeyCode()==Ke