------- android培训、java培训、期待与您交流！ ----------
一、网络编程的基本概念
1、网络模型
1）OSI（Open System Interconnection开放系统互联）参考模型
2）TCP/IP 参考模型
2、网络通讯要素
1）IP地址：对网络设备进行表示，由数字组成，不易记忆
2）端口号：用于标识进程的逻辑地址，不同进程的标识 ，有效端口：0~65535，其中0~1024系统使用或保留端口
3）传输协议：通信的规则，常见协议：TCP，UDP
3、UDP和TCP
UDP（User DatagramProtocol）用户数据包协议
1）将数据及源和目的封装成数据包中，不需要建立连接
2）每个数据报的大小在限制在64k内
3）因无连接，是不可靠协议
4）不需要建立连接，速度快
TCP(Transmission ControlProtocol)传输控制协议
1）建立连接，形成传输数据的通道。
2）在连接中进行大数据量传输
3）通过三次握手完成连接，是可靠协议
4）必须建立连接，效率会稍低
两种传输方式不同，但都是传输协议
IP地址被封装成类
Java中的网络编程在java.net包中
可以通过主机名或ip地址获取ip对象 ，通过ip对象获取其名字
域名的解析:域名--->IP地址
域名解析先要在本地进行解析,之后才会解析网络的域名（可以据此屏蔽网址）
二、Socket和InetAddress
1、 什么是Socket？
1）Socket就是为网络服务提供的一种机制。
2）通信两端都有Socket
3）网络通信其实就是Socket间的通信。
4）数据在连个Socket间通过IO传输。
Socket俗称插座,在数据的两端,数据在Socket间传输
2、InetAddress
是对IP地址的一种封装
构造方法私有，不能直接创建对象。
常见方法：
InetAddress getByName(String host):在给定主机名的情况下确定主机的ip地址。
InetAddress getLocalHost()：返回本地主机。
InetAddress[] getAllByName(String host)
ip.getHostAddress()
ip.getHostName()
例子：
import java.net.InetAddress;
public class Demo1 {
public static void main(String[] args) throws Exception {
InetAddress i = InetAddress.getLocalHost();
System.out.println(i);
i = InetAddress.getByName("www.baidu.com");
System.out.println(i);
System.out.println(i.getHostAddress());
System.out.println(i.getHostName());
}
}
三、UDP传输
必须有Socket来传输数据，java语言应该将UDP封装成对象，DatagramSocket 用来发送和接收数据报包
数据一定要封装到数据包中，数据包中包括目的地址、端口、数据等信息，DatagramPacket.通过这个对象中的方法，就可以获取到数据包中的各种信息。
DatagramSocket具备发送和接受功能，在进行udp传输时，需要明确一个是发送端，一个是接收端。
用UDP创建发送端的思路：
1、建立UDP的socket服务
2、将要发送的数据封装到数据包中
3、通过UDP的socket服务的send方法将数据包发送出去
4、关闭socket服务
用UDP创建接收端的思路：
1、创建UDP的Socket服务，必须要明确一个端口，作用在于，只有发送到这个端口的数据才是这个接收端可以处理的数据。
2、定义数据包，用于存储接收到数据。
3、通过socket服务的接收方法将收到的数据存储到数据包中。
4、通过数据包的方法获取数据包中的具体数据内容，比如ip、端口、数据等等。
5、关闭资源
客户端例子：
import java.net.*;
class UdpSend{
public static void main(String[] args)throws Exception {
// 1，建立udp的socket服务。
DatagramSocket ds = new DatagramSocket(8888);//指定发送端口，这个可以不指定，系统会随机分配。
// 2，明确要发送的具体数据。
String text = "udp传输演示 哥们来了";
byte[] buf = text.getBytes();
// 3，将数据封装成了数据包。
DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("10.1.31.127"),10000);
// 4，用socket服务的send方法将数据包发送出去。
ds.send(dp);
// 5，关闭资源。
ds.close();
}
}
服务端例子：
import java.net.*;
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，通过socket服务的接收方法将收到的数据存储到数据包中。
ds.receive(dp);//该方法是阻塞式方法。
// 4，通过数据包的方法获取数据包中的具体数据内容，比如ip，端口，数据等等。
String ip = dp.getAddress().getHostAddress();
int port = dp.getPort();
String text = new String(dp.getData(),0,dp.getLength());//将字节数组中的有效部分转成字符串。
System.out.println(ip+":"+port+"--"+text);
// 5，关闭资源。
ds.close();
}
}
练习：通过键盘录入获取要发送的信息，客户端和服务端相互通信
mport java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
//客户端，发送端
class Send implements Runnable {
private DatagramSocket ds;
public Send(DatagramSocket ds) {
super();
this.ds = ds;
}
@Override
public void run() {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));//数据源是键盘录入
String line;
while ((line = br.readLine()) != null) {
byte[] buf = line.getBytes();
DatagramPacket dp = new DatagramPacket(buf, buf.length,
InetAddress.getByName("localhost"), 10225);
ds.send(dp);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
// 服务器端，接收端
class Rece implements Runnable {
private DatagramSocket ds;
public Rece(DatagramSocket ds) {
super();
this.ds = ds;
}
@Override
public void run() {
try {
while (true) {
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf, 0, 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) {
e.printStackTrace();
}
}
}
public class Demo6 {
public static void main(String[] args) throws Exception {
DatagramSocket sendDs = new DatagramSocket();
DatagramSocket receDs = new DatagramSocket(10225);
new Thread(new Send(sendDs)).start();
new Thread(new Rece(receDs)).start();
}
}
四、TCP传输
两个端点的建立连接后会有一个传输数据的通道，这通道称为流，而且是建立在网络基础上的流，称之为socket流。该流中既有读取，也有写入。
TCP的两个端点：一个是客户端，一个是服务端。
客户端：对应的对象，Socket
服务端：对应的对象，ServerSocket
Socket实现了客户端的套接字
ServerSocket实现了服务端的套接字
TCP 传输，客户端建立的过程
1、创建TCP客户端Socket服务。使用的是Socket对象。建议改对象一创建就明确目的地，要连接的主机
2、如果连接成功，说明数据传输通道已建立该通道就是Socket流，是底层建立好的，既然是流，说明这里既有输入，又有输出。
想要输入或者输出流对象，可以找Socket来 获取。可以通过getOutputstream()和getInputStream来获取两个字节流
3、使用输出流
4、关闭资源
建立TCP服务端的思路：
1、创建服务端socket服务，通过ServerSocket对象
2、服务端必须对外提供一个端口，否则客户端无法连接
3、获取连接过来的客户端对象（accept()）
4、通过客户端对象获取socket流读取客户端发来的数据
5、关闭资源。关客户端，关服务端
例子
class TcpClient{
public static void main(String[] args) throws Exception{
Socket s = new Socket("10.1.31.69",10002);
OutputStream out = s.getOutputStream();//获取了socket流中的输出流对象。
out.write("tcp演示，哥们又来了!".getBytes());
s.close();
}
}
class TcpServer{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(10002);//建立服务端的socket服务
Socket s = ss.accept();//获取客户端对象
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+".....connected");//打印下作为连接上的标志
// 可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。
InputStream in = s.getInputStream();//读取客户端的数据，使用客户端对象的socket读取流
byte[] buf = new byte[1024];
int len = in.read(buf);
String text = new String(buf,0,len);
System.out.println(text);
// 如果通讯结束，关闭资源。注意：要先关客户端，在关服务端。
s.close();
ss.close();
}
}
双向对话的例子
public class Demo10 {
public static void main(String[] args) throws Exception {
Socket s = new Socket("localhost",10036);
OutputStream out = s.getOutputStream();
out.write("11111客户端".getBytes());
s.shutdownOutput();//注意！！！关闭标签
InputStream is = s.getInputStream();
byte []buf = new byte[1024];
int len = is.read(buf);
System.out.println(new String(buf,0,len));
s.close();
}
}
服务器端
package july76net;
//TCP双向输入输出
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Demo11 {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(10036);
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));*/
int len;
while((len = in.read(buf)) != -1){
System.out.println(new String(buf,0,len));
}
OutputStream os = s.getOutputStream();
os.write("222服务器".getBytes());
s.close();
ss.close();
}
}
利用TCP上传文件
public class Demo14 {
public static void main(String[] args) throws Exception {
Socket s = new Socket("localhost",12362);
BufferedReader br = new BufferedReader(new FileReader("E:/黑马.txt"));
PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
String line;
while((line = br.readLine()) != null){
pw.println(line);
}
s.shutdownOutput();//阻塞式方法的应对，否则会一直等待！
BufferedReader br2 = new BufferedReader(new InputStreamReader(s.getInputStream()));
String str = br2.readLine();//服务器端反馈的数据
System.out.println(str);
br.close();
s.close();
}
}
服务器端
package july76net;
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class Demo15 {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(12362);
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+".....connected!");
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter pw = new PrintWriter(new FileWriter("E:/黑马2.txt"),true);//建议打印时都用打印流
String line;
while((line = br.readLine()) != null){
pw.println(line);//不可以写成是write();
}
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
out.println("上传成功！");
s.close();
ss.close();
}
}<span style="font-size:14px;">
</span>
上传文件，多客户端上传，并且保证不会因为文件的名称而重复！
public class Demo22 {
public static void main(String[] args) throws Exception {
Socket s = new Socket("localhost", 10000);
BufferedReader br = new BufferedReader(new FileReader("E:/你好.txt"));
PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
BufferedReader br2 = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line;
while((line = br.readLine()) != null){
pw.println(line);
}
s.shutdownOutput();
String str = br2.readLine();
System.out.println(str);
s.close();
}
}
服务器端：
package july76net;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
class MyUpdate implements Runnable{
private Socket s;
public MyUpdate(Socket s) {
super();
this.s = s;
}
@Override
public void run() {
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+".........connected!");
int count = 0;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
File file = new File("E:/");
File f = new File(file,"你好"+count+".txt");
while(f.exists()){//如果写成if，就不可以！
f = new File(file,"你好"+(++count)+".txt");
}
PrintWriter pw = new PrintWriter(new FileWriter(f),true);
PrintWriter pw2 = new PrintWriter(s.getOutputStream(),true);
String line;
while((line = br.readLine()) != null){
pw.println(line);
}
pw2.println("恭喜您，上传成功！");
s.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class Demo23 {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(12036);
while(true){
Socket s = ss.accept();
new Thread(new MyUpdate(s)).start();
}
}
}
五、C/S和B/S
C/S:Client/Server
客户端，服务端。
特点：
1，需要在客户端和服务端都需要按照编写的软件。
2，维护较麻烦。
B/S:Browser/Server
浏览器，服务端。
1，客户端不用单独编写软件。
因为客户端用的就是浏览器。
2，对于软件升级，只要考虑服务端即可。
C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、
InFORMix或 SQL Server。客户端需要安装专用的客户端软件。
B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安
装Oracle、Sybase、InFORMix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在
前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。
C/S 与 B/S 区别：
１．硬件环境不同:
C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.
B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只
要有操作系统和浏览器就行
２．对安全要求不同
C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部
分可公开信息.
B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。
３．对程序架构不同
C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑.
B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势,
从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S
更加成熟.
４．软件重用不同
C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好.
B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子
５．系统维护不同
C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统
B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.
６．处理问题不同
C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统
B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.
７．用户接口不同
C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高
B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.
８．信息流不同
C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低
B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更像交易中心。
扫一扫
1667
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
