1 //java基础视频教程第23天-01-网络编程(概述1)
2 //java基础视频教程第23天-02-网络编程(概述2)
3 /*
4 本节课主要概述的网络之间通信的三大条件
5 1.IP
6 IPV4和IPV6，IP地址就是上地东路27号春申太和大厦
7 2.端口
8 0-65535个端口，端口就是房间号
9 3.协议
10 TCP/IP，这个协议既可以用于局域网，也可以用于广域网，协议就是双方之间交流的规则，比如让人与人交流可以通过英文交流也可以通过中文交，其它的局域网协议IPX
11 */
1 //java基础视频教程第23天-03-网络编程(网络模型)
2 /*
3 本节课主要讲解了
4 1.OSI(开放式网络)模型
5 OST主要通过七层（应用层-表示层-会话层-传输层-网络层-数据链路层-物理层）数据封包传递给对方后再七层数据拆包最终实现数据传输的
6 TCP/IP模型
7 TCP/IP通过四层（应用层，传输层，网际层，主机至网络层）来传输的
8 我们玩的网络编程在传输层和网际层混
9 传输层最常见的协议是TCP/UDP
10 网际层最常见的协议就是IP
11 应用层的协议就是http，ftp等
12
13
14 */
1 //java基础视频教程第23天-04-网络编程（IP地址）
2 /*
3 本节课主要讲解了2点
4 1.获取本机地址以及IP，注意InetAddress没有构造函数，不能new对象，但是可以通过静态方法获取自身
5 public static InetAddress getLocalHost() thorws UnknownHostException; //获取本地主机名和ip,注意是静态方法 InetAddress表示互联网协议Ip地址
6 public String getHostAddress(); //获取本机地址
7 public string getHostName(); //获取本机名
8 2.获取给定主机名的Ip地址
9 public static InetAddress getByName(String host) throws UnknownHostException //更具指定的主机名获取地址
10 public static InetAddress[] getAllByName(String host) throws UnknownHostException //获取指定主机名的所有地址,注意，返回的是数组
11 */
12 import java.net.*;
13 class IpDemo
14 {
15 public static void main(String[] args) throws UnknownHostException
16 {
17 InetAddress ia = InetAddress.getLocalHost(); //这个静态方法要抛异常，因为有可能你解析不到地址,并且返回的是一个对象
18 System.out.println(ia.toString()); //toString()也是InetAddress的方法，将Ip地址转换成string
19 String address = ia.getHostAddress();
20 String host = ia.getHostName();
21 System.out.println(host+"-"+address);
22
23 InetAddress i = InetAddress.getByName("www.yc60.com"); //获取单个Id
24 System.out.println(i.toString()); //InetAddress也有自己的toString()方法
25
26 InetAddress[] arr = InetAddress.getAllByName("www.baidu.com"); //百度有两台服务器
27 for(InetAddress is : arr)
28 {
29 System.out.println(is.toString());
30 }
31
32 }
33 }
1 //java基础视频教程第23天-05-网络编程(TCP/UDP)
2 //java基础视频教程第23天-06-网络编程(Socket)
3 /*
4 这两节课主要概述三点内容
5 1.UDP(相当于对讲机)
6 (1).面向无连接
7 (2).数据会被封包，包体积有限制64K以内，然后要明确地址和端口（天堂路地狱街18号）
8 (3).不可靠，数据会丢失，因为面向无连接
9 (4).速度快
10 举例：聊天，视频会议
11 2.TCP(相当于打电话)
12 (1).建立连接（三次握手）对方必须在，通过三次握手确定对方是否在不在
13 (2).不用封包，可以大数据传输
14 (3).比较可靠，数据不丢失，因为有连接
15 (4).速度较慢
16 举例：下载
17 3.Socket（插座）
18 所谓Socket就是通信之间的接口机制，相当于码头，数据就相当于货物，打包拆包相当于把货物装入船和把货物从船上卸下
19 网络编程学的就是Socket之间的通行
20 */
1 //java基础视频教程第23天-07-网络编程(Udp发送端)
2 /*
3 本节课主要讲解了Udp发送的四个步骤
4 1.建立发送接收服务对象（相当于建立发送码头）建立用来发送和接收数据报包的套接字对象
5 DatagramSocket ds = new DategramSocket();
6 2.将数据和地址以及端口打包（相当于把货物装到船上并确定发送的地址）数据报包，既可以接收又可以发送 7 DategramPacket dp = new DategramPacket(byte[] buf,int length,InetAddress address,int host)
8 3.发送
9 发送用DatagramSocket的send方法 将数据报包发送出去
10 public void send(DatagramPacket p)throws IOException
11 4.最后一步是关闭系统资源
12 ds.close();
13 */
14 import java.net.*;
15 class UdpDemo //发送端
16 {
17 public static void main(String[] args) throws Exception //Ip有可能不存在所以要报异常，建立套接字也要报异常
18 {
19 DatagramSocket ds = new DatagramSocket(); //建立Udp服务。如果不传入数字标识(端口)。系统会自动分配一个端口
20 byte[] buf = "hallo java,I am coming@@@@@".getBytes(); //需要发送的数据
21 DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000); //封装数据 //发送是发送了，但是没有接收
22 ds.send(dp); //发送数据
23 ds.close(); //关闭系统资源
24 }
25 }
1 //java基础视频教程第23天-08-网络编程（Udp-接收端）
2 /*
3 这节课主要讲解了接收端的几个步骤
4 1.建立Udp接收服务对象，并指明接收数据端口
5 DatagramSocket ds = new DatagramSocket(10000);
6 2.建立一个数据包来接收数据
7 DatagramPacket dp = new DatagramPacket(buf,buf.length);
8 3.通过DatagramSocket的reseive方法把数据接收到建立的数据包中
9 ds.reseive(dp);
10 通过套接字对象的reseive()方法将数据接收到建立好的数据报包中
11 4.通过数据包Datagrampacket中的特有方法获取其中数据
12 InetAddress ia = dp.getAddress();
13 String address = ia..getHostAddress(); 获取主机的IP地址
14 String name = ia.getHostName() 获取主句的名称
34 public byte[] getDate()获取数据报包中的数据缓冲区
35 public int getLength()获取要发送或接收到的数据的长度
36 public int getPort()获取远程主机的端口
15 5.关闭系统资源
16 */
17 import java.net.*;
18 class UdpReceiveDemo
19 {
20 public static void main(String[] args)throws Exception
21 {
22 DatagramSocket ds = new DatagramSocket(10000); //注意添加端口
23 byte[] buf =new byte[1024];
24 DatagramPacket dp = new DatagramPacket(buf,buf.length);
25 ds.receive(dp); //reveive是一个阻塞式方法，没有数据就一直等
26 InetAddress ia = dp.getAddress();
27 String address = ia.getHostAddress();
28 String name = ia.getHostName();
37 int port = dp.getPort();
29 System.out.println(address+name+port);
30 System.out.println(new String(dp.getData(),0,dp.getLength()));
31 ds.close();
32 }
33 }
1 //java基础视频教程第23天-09-网络编程(UDP-键盘录入方式数据)
2 /*
3 本节课主要在上一节课的基础上在传送端添加了一个键盘输入
4 主要讲解有以下几点
5 1.通常用到net包中的方法就会用到io包的方法，因为网络通讯就是数据传输
6 2.两个阻塞式方法
7 3.绑定异常
8 4.特殊的两个IP地址，在IP地址中有两个特殊的IP地址（192.168.1.0）是网段地址，（192.168.1.255）是广播地址
9 */
10 import java.net.*;
11 import java.io.*; //通常用到net包中的方法就会用到io包的方法，因为网络通讯就是数据传输
12 class UdpSend
13 {
14 public static void main(String[] args)throws Exception
15 {
16 DatagramSocket ds = new DatagramSocket();
17 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
18 String line =null;
19 while((line=br.readLine())!=null) //read是一个阻塞式方法
20 {
21 if("886".equals(line))
22 break;
23 byte[] buf = line.getBytes();
24 DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),8888); //255是一个广播地址，只要在这个网络段的机器都收的到 //当数据包中传入的地址和端口就表示是传输
25 ds.send(dp);
26 }
27 ds.close();
28 }
29 }
30
31 class UdpReceive
32 {
33 public static void main(String[] args)throws Exception
34 {
35 DatagramSocket ds = new DatagramSocket(8888); //这个接收服务对象不能再while(true)内部，不然会报端口绑定异常BindException，因为一建立这个对象就需要用到8888这个端口，如果第二次又建立对象，但是这个端口还没有来得及在内存中释放
36 byte[] buf= new byte[1024]; //不用担心数组大小，UDB传输最大传输为64K，这里可以乘以64
37 while(true) //接收端用了while(true)而不死循环是因为receive()是阻塞式方法
38 {
39
40 DatagramPacket dp = new DatagramPacket(buf,buf.length); //当数据包中的参数没有地址和端口表示是接收
41 ds.receive(dp); //receive也是一个阻塞式方法
42 InetAddress ia = dp.getAddress();
43 String address = ia.getHostAddress();
44 String name = ia.getHostName();
45 String data = new String(dp.getData(),0,dp.getLength());
46 System.out.println(name+":"+address+data);
47 }
48 }
49 }
1 //java基础视频教程第23天-10-网络编程(UDP-聊天)重点研究
2 /*
3 本节课主要讲解了通过多线程实现udp数据传输和接收
4 一个线程控制发送数据，另一个线程控制接收数据
5 然后自己添加一个界面实现接收
7 我想写一个有界面的简易版QQ，但是思路不好，一直没写好
6 */
1 import java.io.*;
2 import java.net.*;
3 import java.awt.*;
4 import java.awt.event.*;
5 class UdpSend implements Runnable
6 {
7 private DatagramSocket ds;
8 UdpSend(DatagramSocket ds)
9 {
10 this.ds = ds;
11 }
12 public void run()
13 {
14 try
15 {
16 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
17 String line = null;
18 while((line=br.readLine())!=null)
19 {
20 byte[] buf = line.getBytes();
21 DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10086);
22 ds.send(dp);
23 }
24
25 }
26 catch (Exception e)
27 {
28 System.out.println("传送数据失败！");
29 }
30 }
31 }
32 class UdpReceive implements Runnable
33 {
34 private DatagramSocket ds;
35 UdpReceive(DatagramSocket ds)
36 {
37 this.ds = ds;
38 }
39 public void run()
40 {
41 try
42 {
43 while(true)
44 {
45 byte[] buf = new byte[1024];
46 DatagramPacket dp = new DatagramPacket(buf,buf.length);
47 ds.receive(dp);
48
49 InetAddress ia = dp.getAddress();
50 String name = ia.getHostName();
51 String ip = ia.getHostAddress();
52 String data = new String(dp.getData(),0,dp.getLength());
53 System.out.println(name+":"+ip+"--"+data);
54 }
55 }
56 catch (Exception e)
57 {
58 System.out.println("接收数据异常！");
59 }
60 }
61 }
62 class YY
63 {
64 public static void main(String[] args) throws Exception //建立传输/接收对象要抛异常
65 {
66 new Thread(new UdpSend(new DatagramSocket())).start();
67 new Thread(new UdpReceive(new DatagramSocket(10086))).start();
68 }
69 }
1 //java基础视频教程第23天-11-网络编程(TCP传输)
2 /*
3 本节课主要讲解了TCP中相对应的客户端对象传递到服务端，然后服务端获取对应客户端对象，然后获取传输过来的数据
UDP主要分发送端和接收端，而TCP分为客户端和接收端
4 主要分两大点
5 1.客户端(TcpClient)
6 (1).建立客户端套接字Socket对象,并指定地址和端口
7 Socket s = new Socket("192.168.1.2",10086); //还要注意一点TCP是面向连接了，不能用像UDP那样用广播地址传输数据
8 (2).获取套接字Socket输出流
9 OutputStream os = s.getOutputStream();
10 (3).向输出流写入数据
11 os.write("Come from TcpClient".getBytes()); //注意传输的是字节数组
12 (4).关闭客户端
13 s.close(); //关闭套接字就相当于关闭流
14 最后要注意一点，客户端指定了地址和端口，有可能地址会不存在，端口被占用，所以必须抛异常
15 2.服务端(TcpServer)
16 (1).建立服务端套接字对象，并指定端口
17 ServerSocket ss = new ServerSocket(10086);
18 (2).通过ServerSocket的accept方法获取对应客户端对象，
19 Socket s = ss.accept(); //这个方法是一个阻塞式方法，有数据就接收，没数据就等待
20 (3).如果客户端发了数据，那么就用对应的客户端对象去获取它的输入流，并读取数据以及客户端的地址
21 InetAddress ia = s.getInetAddress();
22 String ip =ia.getHostAddress();
23 InputStream is = s.getInputStream();
24 byte[] buf = new byte[1024];
25 int len = is.read(buf);
26 System.out.println(new String(buf,0,len));
27 (4).关闭服务端。（可选，有的服务器不必关闭）
28 ss.close();
2x s.close();
29 最后也注意一点，启动时先启动服务端，TCP传输必须要求服务端开启才能传输，如果服务端你没开启，客户端发数据是没有意义的。
30 */
31 import java.io.*;
32 import java.net.*;
33 class TcpClient
34 {
35 public static void main(String[] args) throws Exception
36 {
37 Socket s = new Socket("192.168.1.5",2000);
38 OutputStream os = s.getOutputStream();
39 os.write("Come from TcpClient".getBytes());
40 s.close();
41 }
42 }
43 class TcpServer
44 {
45 public static void main(String[] args) throws Exception
46 {
47 ServerSocket ss = new ServerSocket(2000);
48 Socket s = ss.accept();
49 InetAddress ia = s.getInetAddress();
50 String ip =ia.getHostAddress();
51 InputStream is = s.getInputStream();
52 byte[] buf = new byte[1024];
53 int len = is.read(buf);
54 System.out.println(ip+"---"+new String(buf,0,len));
55 ss.close();
5x s.clsoe();
56 }
57 }
1 //java基础视频教程第23天-12-网络编程(TCP传输)
2 /*
3 本节课在上一节课的基础上添加了客户端的接收数据和服务端的发送返回数据
4 其实接收和发送数据都是通过客户端的流来实现的。
5 1.客户端
6 (1).创建客户端Socket套接字对象，并指定地址和端口
7 Socket s = new Socket("192.168.1.2",10086);
8 (2).获取客户端Socket套接字对象的输出流，并写入数据
9 OutputStream os = s.getOutputStream();
10 os.write("服务器，你好".getBytes());
11 (3).获取客户端Socket套接字对象的输入流，并且阻塞式读取服务端发送的响应数据，然后打印数据
12 InputStream is = s.getInputStream();
13 byte[] buf = new byte[1024];
14 int len = is.read(buf);
15 System.out.println(new String(buf,0,len));
16 (4).关闭客户端资源
17 s.close();
18 2.服务端
19 (1).建立服务端ServerSocket套接字对象，并指定端口
20 ServerSocket ss = new ServerSocket(10086);
21 (2).通过服务端ServerSocket套接字对象的accept方法获取对应客户端对象
22 Socket s = ss.accept();
23 (3).通过获取到的客户端对象获取输入流,然后读取客户端发送的数据以及客户端的地址
24 InetAddress ia = s.getInetAddress();
25 String ip = ia.getHostAddress();
26 InputStream is = s.getInputStream();
27 byte[] buf = new byte[1024];
28 int len = is.read(buf);
29 System.out.println(ip+"---"+new String(buf,0,len));
30 (4).获取客户端对象的输出流，人后给客户端发送数据
31 OutputStream os = S.getOutputStream();
32 os.write("哥们，辛苦了".getBytes());
33 (5).关闭服务器
34 s.close();
35 ss.close();
36 */
37 import java.io.*;
38 import java.net.*;
39 class TcpClient1
40 {
41 public static void main(String[] args) throws Exception
42 {
43 Socket s = new Socket("192.168.1.2",10086);
44 OutputStream os = s.getOutputStream();
45 os.write("老大你好了！".getBytes());
46 InputStream is = s.getInputStream();
47 byte[] buf = new byte[1024];
48 int len = is.read(buf); //read是阻塞式方法，没有数据就等，有就读取
49 System.out.println(new String(buf,0,len));
50 s.close();
51 }
52 }
53 class TcpServer1
54 {
55 public static void main(String[] args) throws Exception
56 {
57 ServerSocket ss = new ServerSocket(10086);
58 Socket s = ss.accept(); //accept也是阻塞式方法，没有数据就等，有就读取
59 InetAddress ia = s.getInetAddress();
60 String ip = ia.getHostAddress();
61 InputStream is = s.getInputStream();
62 byte[] buf = new byte[1024];
63 int len = is.read(buf);
64 System.out.println(ip+"---"+new String(buf,0,len));
65 OutputStream os = s.getOutputStream();
66 Thread.sleep(10000); //让服务器接收到数据在等10S在返回相应，这样体现了read方法是阻塞式方法
67 os.write("哥们，辛苦了".getBytes());
68 ss.close();
6x s.close();
69 }
70 }
1 //java基础视频教程第23天-13-网络编程(TCP练习)(重点)
2 /*
3 需求：建立一个文本转换服务器
4 客户端给服务端发送一个文本，服务端会将文本转换成大写在返回给客户端
5 并且客户端可以不断的输入文本，当客户端输入over时就结束转换
6 本节课分下面三点
7 1.客户端
8 分析:
9 源：键盘录入
10 目的：网络输出流
11 (1).创建客户端套接字Socket对象,指定地址和端口
12 Socket s = new Socket("192.168.1.100",10086);
13 (2).创建键盘录入
14 BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
15 (3).获取客户端输出流对象，并包装
16 BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
17 (4).获取客户端输入流对象，并包装
18 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
19 (5).向输出流中写入键盘录入数据,并接受服务端返回来的数据
20 String line = null;
21 while((line=buf.readLine())!=null)
22 {
23 if("over".equals(line))
24 break;
25 bufOut.write(line);
26 bufOut.newLine();
27 bufOut.flush();
28 System.out.println(bufIn.readLine());
29 }
30 (6).关闭资源
31 s.close();
32 buf.close();
33 2.服务端
34 分析：
35 源：网络输入流
36 目标：网络输出流
37 (1).创建服务端套接字对象,并指定端口
38 ServerSocket ss = new ServerSocket(10086);
39 (2).获取客户端对象和地址并打印
40 Socket s = ss.accept();
41 String ip = s.getInetAddress().getHostAddress();
42 System.out.println(ip+"成功连接服务器");
43 (3).获取客户端对象输入流，并包装
44 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
45 (4).获取客户端对象的输出流，并包装
46 BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
47 (5).获取客户端发送过来的数据，并将此数据转换大写然后返回给客户端
48 String line = null;
49 while((line=bufIn.readLine())!=null)
50 {
51 if("over".equals(line))
52 break;
53 System.out.println(line);
54 bufOut.write(line.toUpperCase());
55 bufOut.newLine();
56 bufOut.flush();
57 }
58 (6).关闭资源
59 ss.close();
60 s.close();
61
62 2.TCP网络的注意事项
63 注意代码
64 while((line=buf.readLine())!=null)
65 {
66 if("over".equals(line))
67 break;
68 bufOut.write(line);
69 bufOut.newLine();
70 bufOut.flush();
71 System.out.println(bufIn.readLine());
72 }
73 (1)由于readLine()是阻塞式方法，只有读取到结束标记\r\n换行时才会将数据赋给line，没有换行标记就会等
74 在读取键盘录入的时候，结束标记特备重要，容易被忽视
75 另外一点，写入字符流需要刷新流才能将数据写出去，这点也是最容易忽视的
76 (2)另外一点，当客户端结束，服务端也跳出了while循环，这是为什么呢？
77 当我在客户端输入over之后，跳出while循环，执行了s.close();这个s.close()就是向Socket输出流中加了一个-1结束标记
78 当服务端的readLine()接收到-1就会停止跳出while循环（readLine内部就是read方法，读到-1就会结束）
79
80 3.优化
81 将BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
82 替代为目的流PrintWriter pw = PrintWriter(s.getOutputStream(),true);
83 PrintWriter有自动刷新功能还有换行打印的方法
84 pw.println(line);
85
86 */
87 import java.io.*;
88 import java.net.*;
89 class TransClient
90 {
91 public static void main(String[] args) throws Exception
92 {
93 Socket s = new Socket("192.168.1.100",10086);
94 BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
95 //BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
96 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
97 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
98
99 String line = null;
100 while((line=buf.readLine())!=null)
101 {
102 if("over".equals(line))
103 break;
104 //bufOut.write(line);
105 //bufOut.newLine();
106 //bufOut.flush();
107 pw.println(line);
108 System.out.println(bufIn.readLine());
109 }
110 s.close();
111 buf.close();
112 }
113 }
114 class TransServer
115 {
116 public static void main(String[] args) throws Exception
117 {
118 ServerSocket ss = new ServerSocket(10086);
119 Socket s = ss.accept();
120 String ip = s.getInetAddress().getHostAddress();
121 System.out.println(ip+"成功连接服务器");
122 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
123 //BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
124 PrintWriter pw =new PrintWriter(s.getOutputStream(),true);
125 String line =null;
126 while((line=bufIn.readLine())!=null)
127 {
128 System.out.println(line);
129 //bufOut.write(line.toUpperCase());
130 //bufOut.newLine();
131 //bufOut.flush();
132 pw.println(line.toUpperCase());
133 }
134 ss.close();
135 s.close();
136 }
137 }
1 //java基础视频教程第23天-14-网络编程(TCP复制文件)
2 /*
3 本节课问题多多？？？？
4 要求:在客户端传输一个文件到服务端，然后服务端将文件存储起来
5 传递文本最好的用法就是用字节流，而且要包装
6 客户端：
7 (1),创建客户端套接字对象，并指定地址和端口
8 Socket s = new Socket("192.168.1.100",10086);
9 (2),创建需要读取客户端的字符流
10 BufferedReader br = new BufferedReader(new FileReader("IpDemo.java"));
11 (3),获取客户端的输出流并将字符流中的数据写入到客户端的输出流中
12 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
13 String line = null;
14 while((line=br.readLine())!=null)
15 {
16 pw.println(line);
17 }
18 (4)虽然while循环可以结束，但是又读取了Socket的输入流，等着读取返回上传成功的字样，服务端也没有读到结束标记也等着，为
19 s.shutdownOutput();
20 (5)，获取客户端的输入流，并读取服务端发送过来的数据，判断是否上传成功
21 BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
22 System.out.println(brIn.readLine());
23 (6)，关闭资源
24 br.close();
25 s.close();
26
27 服务端：
28 (1),创建服务端的套接字对象，并指定端口
29 ServerSocket ss = new ServerSocket(10086);
30 (2),获取客户端的对象，并获取地址并打印
31 Socket s = ss.accept();
32 String ip = s.getInetAddress().getHostAddress();
33 System.out.println(ip);
34 (3),获取客户端的对象输入流
35 BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
36 (4),创建一个打印流，存储发送过来的数据
37 PrintWriter pw = new PrintWriter("Server.txt");
38 while((line=br.readLine())!=null) //读取文件可以自动结束，而读取键盘录入则需要添加结束标记
39 {
40 pw.println(line);
41 pw.flush();
42 }
43 (5),获取客户端对象的输出流，并返回"上传成功"
44 PrintWriter pwOut = new PrintWriter(s.getOutputStream(),true);
45 pwOut.println("上传成功！");
46 (6),关闭资源
47 pw.close();
48 s.close();
49 ss.close()
50
51 注意
52 (1)结束标记可以自己定义，可以现在服务端传递一个自定义的结束标签给服务端，当服务端在读取数据中遇到指定的结束标签就跳出循环，执行返回语句，通常定义时间戳为结束4 标记，也可以定义其它的标记，但是这样不安全，因为说不定在读取的数据中有可能包含结束标签关键字，这样读取数据就不完全。
53 */
54 import java.io.*;
55 import java.net.*;
56 class TextClient
57 {
58 public static void main(String[] args)throws Exception
59 {
60 Socket s = new Socket("192.168.1.100",10086);
61 BufferedReader br = new BufferedReader(new FileReader("IpDemo.java"));
62 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
63 String line = null;
64 while((line=br.readLine())!=null)
65 {
66 pw.println(line);
67 } //客户端的while循环虽然可以自动结束，但是服务端的while循环却不能自动结束，因为客户端while循环结束之后又去读取了Socket的输入流
68 s.shutdownOutput(); //阻塞式的等待读取服务端的返回信息，为了服务端结束while，则添加一个结束标记，当然也可以自己定义一个结束标记
69 BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
70 System.out.println(brIn.readLine());
71 br.close();
72 s.close();
73 }
74 }
75 class TextServer
76 {
77 public static void main(String[] args)throws Exception
78 {
79 ServerSocket ss = new ServerSocket(10086);
80 Socket s = ss.accept();
81 String ip = s.getInetAddress().getHostAddress();
82 System.out.println(ip);
83 BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
84 PrintWriter pw = new PrintWriter("Server.txt");
85 String line = null;
86 while((line=br.readLine())!=null)
87 {
88 pw.println(line);
89 pw.flush();
90 }
91 PrintWriter pwOut = new PrintWriter(s.getOutputStream(),true);
92 pwOut.println("上传成功！");
93 pw.close();
94 s.close();
95 ss.close();
96 }
97 }
1 //java基础视频教程第24天-01-网络编程(TCP-上传图片)
2 /*
3 本节课讲解上传图片到服务器
4 传递图片最好的方式就是字节流
5 客户端：
6 (1).创建客户端套接字对象，并指定地址和端口
7 Socket s = new Socket("192.168.1.100",10086);
8 (2).创建一个字节流，并指定要读取的图片文件
9 FileInputStream fis = new FileInputStream("client.jpg");
10 (3).获取客户端对象的输出流，并将图片数据写入到输出流中
11 OutputStream os = s.getOutputStream();
12 byte[] buf = new byte[1024];
13 int len=0;
14 while((len=fis.read(buf))!=-1)
15 {
16 os.write(buf,0,len);
17 }
18 (4),为输出流中添加结束标记
19 s.shutdownOutput();
20 (5),获取客户端对象的输入流，并读取服务端返回的“图片上传成功”的数据
21 InputStream is = s.getInputStream();
22 byte[] bufIn = new byte[1024];
23 int num = is.read(bufIn);
24 System.out.println(new String(bufIn,0,num));
25 (6)，关闭资源
26 fis.close();
27 s.close();
28 服务端：
29 (1)创建服务端套接字对象，并指定端口
30 ServerSocket ss = new ServerSocket(10086);
31 (2)获取客户端对象，并获取ip地址并打印
32 Socket s = ss.accept();
33 String ip = s.getInetAddress().getHostAddress();
34 System.out.println(ip+"成功连接服务器");
35 (3)创建一个输出流，并指定数据输出的地址
36 FileOutputStream fos = new FileOutputStream("server.jpg");
37
38 (4)获取客户端的输入流，并将输入流中的数据写入到创建的输出流中
39 InputStream is = s.getInputStream();
40 byte[] buf = new byte[1024];
41 int len=0;
42 while((len=is.read(buf))!=-1)
43 {
44 fos.write(buf,0,len);
45 }
46 (5)获取客户端的输出流，并写入“图片上传成功”
47 OutputStream os = s.getOutputStream();
48 os.write("上传图片成功".getBytes());
49 (6)关闭资源
50 fos.close();
51 s.close();
52 ss.close();
53
54 */
55 import java.io.*;
56 import java.net.*;
57 class PicClient
58 {
59 public static void main(String[] args) throws Exception
60 {
61 Socket s = new Socket("192.168.1.100",10086);
62 FileInputStream fis = new FileInputStream("client.jpg");
63 OutputStream os = s.getOutputStream();
64 byte[] buf = new byte[1024];
65 int len=0;
66 while((len=fis.read(buf))!=-1)
67 {
68 os.write(buf,0,len);
69 }
70 s.shutdownOutput(); //给Socket输出流中添加一个结束标记，让服务端结束while循环
71 InputStream is = s.getInputStream();
72 byte[] bufIn = new byte[1024];
73 int num = is.read(bufIn);
74 System.out.println(new String(bufIn,0,num));
75 fis.close();
76 s.close();
77
78 }
79 }
80 class PicServer
81 {
82 public static void main(String[] args) throws Exception
83 {
84 ServerSocket ss = new ServerSocket(10086);
85 Socket s = ss.accept();
86 String ip = s.getInetAddress().getHostAddress();
87 System.out.println(ip+"成功连接服务器");
88 FileOutputStream fos = new FileOutputStream("server.jpg");
89 InputStream is = s.getInputStream();
90 byte[] buf = new byte[1024];
91 int len=0;
92 while((len=is.read(buf))!=-1) //服务端while循环不能自动循环，需要在服务端想Socket输出流写一个结束标记
93 {
94 fos.write(buf,0,len);
95 }
96 OutputStream os = s.getOutputStream();
97 os.write("上传图片成功".getBytes());
98 fos.close();
99 s.close();
100 ss.close();
101 }
102 }
1 //java基础教程第24天-02-网络编程(TCP-客户端并发上传图片)
/*
（1）并非访问的时候服务器得玩多线程，不然只能是一一处理请求，那样效率非常低下，这个时候把服务器共用的部分单独写入到一个线程的run方法中
（2）防止多次上传图片被覆盖，这用ip地址+count++来表示上传的图片
（3）在上传时又做了很多限制选择
并发要用多线程这种思想要记住
*/
2 import java.io.*;
3 import java.net.*;
4 class PicClient
5 {
6 public static void main(String[] args) throws Exception
7 {
8 if(!(args.length==1))
9 {
10 System.out.println("只能上传一张JPG的图片");
11 return;
12 }
13 File file = new File(args[0]);
14 if(!(file.exists()&&file.isFile()))
15 {
16 System.out.println("你上传的数据不是图片或者不存在");
17 return;
18 }
19 if(!(file.getName().endsWith("jpg")))
20 {
21 System.out.println("你上传的图片必须是JPG格式");
22 return;
23 }
24 if(file.length()>1024*1024*5)
25 {
26 System.out.println("上传的图片必须小于5M");
27 return;
28 }
29 Socket s = new Socket("192.168.1.100",10086);
30 FileInputStream fis = new FileInputStream(file);
31 OutputStream os = s.getOutputStream();
32 byte[] buf = new byte[1024];
33 int len=0;
34 while((len=fis.read(buf))!=-1)
35 {
36 os.write(buf,0,len);
37 }
38 s.shutdownOutput(); //给输出流中添加一个结束标记
39 InputStream is = s.getInputStream();
40 byte[] bufIn = new byte[1024];
41 int num = is.read(bufIn);
42 System.out.println(new String(bufIn,0,num));
43 fis.close();
44 s.close();
45
46 }
47 }
48 class PicThread implements Runnable
49 {
50 private Socket s;
51 PicThread(Socket s)
52 {
53 this.s = s;
54 }
55
56 public void run()
57 {
58 int count = 1;
59 String ip = s.getInetAddress().getHostAddress();
60 try
61 {
62 System.out.println(ip+"成功连接服务器");
63 File file = new File(ip+"("+count+")"+".jpg");
64 while(file.exists())
65 file = new File(ip+"("+count+++")"+".jpg"); //防止传入的图片重名被覆盖，所以用ip地址然后自加来表示名称
66 FileOutputStream fos = new FileOutputStream(file);
67 InputStream is = s.getInputStream();
68 byte[] buf = new byte[1024];
69 int len=0;
70 while((len=is.read(buf))!=-1)
71 {
72 fos.write(buf,0,len);
73 }
74 OutputStream os = s.getOutputStream();
75 os.write("上传图片成功".getBytes());
76 fos.close();
77 s.close();
78
79 }
80 catch (Exception e)
81 {
82 throw new RuntimeException(ip+"上床失败");
83 }
84 }
85
86 }
87
88 class PicServer
89 {
90 public static void main(String[] args) throws Exception
91 {
92 ServerSocket ss = new ServerSocket(10086);
93 while(true)
94 {
95 new Thread(new PicThread(ss.accept())).start();
96 }
97 //ss.close(); //服务端一直开着
98 }
99 }
1 //java基础视频教程第24天-03-网络编程(TCP-客户端并发登录)
2 /*
3 需求：客户端通过键盘录入用户名，服务端对这个用户名进行校验
4 如果该用户存在，在服务端显示xxx，已经登录，并在客户端显示xxx，欢迎光临
5 如果该用户不存在，在服务端显示xxx，尝试登录，并在客户端显示xxx，该用户不存在
6 最多登录三次
7
8 这节课有问题，待解决。先不做解释
9 */
10 import java.io.*;
11 import java.net.*;
12 class LoginClient
13 {
14 public static void main(String[] args) throws Exception
15 {
16 Socket s = new Socket("192.168.1.100",10086);
17 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
18 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
19 BufferedReader brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
20 for (int x=0;x<3;x++)
21 {
22 String line = br.readLine();
23 if(line==null) //当你ctrl+c（空格）则退出
24 break;
25 pw.println(line);
26 String info = brIn.readLine();
27 System.out.println(info);
28 if(info.contains("欢迎")) //当你写入的名称已近存在则也退出
29 break;
30 }
31 br.close();
32 s.close();
33 }
34 }
35 class UserThread implements Runnable
36 {
37 private Socket s ;
38 UserThread(Socket s)
39 {
40 this.s = s;
41 }
42
43 public void run()
44 {
45 String ip = s.getInetAddress().getHostAddress();
46 System.out.println(ip+"...conected");
47 try
48 {
49 for (int x=0;x<3;x++)
50 {
51 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
52 String name = bufIn.readLine();
53 if(name==null) //防止穿过来的值是null，防止null尝试登录
54 break;
55 BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));
56 PrintWriter out = new PrintWriter(s.getOutputStream(),true);
57 String line = null;
58 boolean flag = false; //要的是循环判读后的结果，更具结果来判断，这里用一个标记来定义判断结果
59 while((line=bufr.readLine())!=null)
60 {
61 if(line.equals(name))
62 {
63 flag = true;
64 break;
65 }
66 }
67 if(flag)
68 {
69 System.out.println(name+",已登录");
70 out.println(name+"欢迎光临");
71 break;
72 }
73 else
74 {
75 System.out.println(name+",尝试登录");
76 out.println(name+",用户名不存在");
77 }
78 }
79 s.close();
80 }
81 catch (Exception e)
82 {
83 throw new RuntimeException(ip+"校验失败");
84 }
85 }
86 }
87
88 class LoginServer
89 {
90 public static void main(String[] args) throws Exception
91 {
92 ServerSocket ss = new ServerSocket(10086);
93 while(true)
94 {
95 new Thread(new UserThread(ss.accept())).start();
96 }
97 }
98 }
1 //java基础视频教程第24天-04-网络编程(浏览器客户端-自定义服务端)
2 /*
3 本节课主要讲解自定义服务端，浏览器作为客户端，以及telnet作为客户端
4 经过我测试telnet不好用
5 */
6 import java.io.*;
7 import java.net.*;
8 class ServerDemo
9 {
10 public static void main(String[] args) throws Exception
11 {
12 while(true)
13 {
14 ServerSocket ss = new ServerSocket(15000);
15 Socket s = ss.accept();
16 String ip = s.getInetAddress().getHostAddress();
17 System.out.println(ip);
18 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
19 pw.println("<font color='red' size='7'><a href=http://www.baidu.com>小伙子你好哇</a></font>");
20 s.close();
21 ss.close();
22 }
23 }
24 }
1 //java基础视频教程第24天-05-网络编程(浏览器客户端-Tomcat服务端)
2 //java基础视频教程第24天-06-网络编程(自定义浏览器-Tomcat服务器)
3 /*
4 05
5 tamcat服务器是java写的，其实它内部封装了ServerSocket
6 打开tamcat服务器的方法：点击tomtac文件中bin文件夹中的startup.bat，就开启的tamcat服务器
7 */
8 /*
9 06
10 本节课讲解了自定义一个浏览器
11 (1),首先通过我们自己定义的服务器讲解了浏览器发送过来的请求消息头
12 HTTP请求消息头（消息头根据浏览器不同而不同）
13
14 192.168.1.100...conected
15 GET /myweb/demo.html HTTP/1.1 //GET请求,表示要访问的内容,以及传输协议是
16 Host: 192.168.1.100:20000 //表示要访问服务器的那个主机，那个端口
17 Connection: keep-alive //保持连接存活
18 Cache-Control: max-age=0
19 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,星/星;q=0.8
20 User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.17 (KHTML, like
21 Gecko) Chrome/24.0.1312.57 Safari/537.17 //表示浏览器支持内容
22 Accept-Encoding: gzip,deflate,sdch //支持的压缩格式，以便于数据传输
23 Accept-Language: zh-CN,zh;q=0.8 //支持的语言
24 Accept-Charset: GBK,utf-8;q=0.7,*;q=0.3
25 空一行（请求数据头和请求数据体必须用空行隔开，这个是格式）
26 请求数据体
27
28 (2).自定义自己的IE，然后用自定义IE请求访问tomcat服务器的的内容，然后服务器返回应答消息头
29 HTTP应答消息头
30
31 HTTP/1.1 200 OK //表示用HTTP1.1协议传输，200表示响应状态码，表示成功
32 Server: Apache-Coyote/1.1 /服务器是Apache
33 Accept-Ranges: bytes
34 ETag: W/"319-1373622503082" //标记
35 Last-Modified: Fri, 12 Jul 2013 09:48:23 GMT //最后修改的时间
36 Content-Type: text/html //文件类型
37 Content-Length: 319 //文件长度（字节）
38 Date: Fri, 12 Jul 2013 09:53:52 GMT
39 Connection: close //数据传输完毕就关闭
40 要空一行
41 返回数据
42 <html>
43 <head>
44 <title>编程人生，java，html，php，javaScript,c,c#,c++,code</title>
45 </head>
46 <body>
47 <marquee behavior="scroll" direction="down" scrollamount=100 bgcolor="red" height="500" width="500" hspace="50" vspace="50">及时当勉励，岁月不待人</marquee>
48 </body>
49 </html>
50
51 */
52
53 import java.io.*;
54 import java.net.*;
55 class TamcatServer
56 {
57 public static void main(String[] args)throws Exception
58 {
59 ServerSocket ss = new ServerSocket(1000);
60 Socket s = ss.accept();
61 String ip = s.getInetAddress().getHostAddress();
62 System.out.println(ip+"...conected");
63 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
64 pw.println("<font color='red' size='7'><a href=http://www.gov.cn/>小伙子国家需要你!</a></font>");
65 InputStream in = s.getInputStream();
66 byte[] buf = new byte[1024];
67 int len = in.read(buf);
68 System.out.println(new String(buf,0,len));
69 s.close();
70 ss.close();
71 }
72 }
73
74 class MyIE
75 {
76 public static void main(String[] args)throws Exception
77 {
78 Socket s = new Socket("192.168.1.100",8080); //访问的是tomcat服务器
79 PrintWriter pw =new PrintWriter(s.getOutputStream(),true);
80 pw.println("GET /myweb\Guest\index.php HTTP/1.1"); //表示请求访问tomcat服务器中的这个内容
81 pw.println("Accept:*/*");
82 pw.println("Accept-Language: zh-CN");
83 pw.println("Host:192.168.1.100:11000");
84 pw.println("Connection:closed");
85
86 pw.println(); //请求数据头必须和请求体隔一空行，就用println
87 pw.println();
88 BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
89 String line = null;
90 while((line=br.readLine())!=null)
91 {
92 System.out.println(line);
93 }
94 s.close();
95
96 }
97 }
1 //java基础视频教程第24天-07-网络编程(自定义图形界面浏览器-Tomcat服务器)
2 /*
3 本节课讲解了自定义图形化的浏览器，在文本栏输入url按按钮或者回车键则在文本区域显示返回的数据
4 */
5 import java.awt.*;
6 import java.awt.event.*;
7 import java.io.*;
8 import java.net.*;
9 class MyIE
10 {
11 public static void main(String[] args)
12 {
13 new Init();
14 }
15 }
16 class Init
17 {
18 //窗体组件变量
19 private Frame f;
20 private Button b;
21 private TextField tf;
22 private TextArea ta;
23 //对话框的组件变量
24 private Dialog d;
25 private Label l;
26 private Button bn;
27 Init()
28 {
29 myFrame();
30 }
31 public void myFrame()
32 {
33 f=new Frame("my frame");
34 f.setBounds(500,500,500,500);
35 f.setLayout(new FlowLayout());
36 tf=new TextField(50);
37 f.add(tf);
38 b=new Button("转到");
39 f.add(b);
40 ta=new TextArea(25,60);
41 f.add(ta);
42 myDialog();
43 myEvent();
44 f.setVisible(true);
45 }
46 public void myDialog()
47 {
48 d=new Dialog(f,"my dialog",false); //true表示当对话框出现时不能操作所属窗体
49 d.setBounds(500,500,200,200);
50 d.setLayout(new FlowLayout());
51 l=new Label(); //在窗体上的文字其实就是标签(Label)，这里标签没有设置初始化内容
52 d.add(l);
53 bn = new Button("确定");
54 d.add(bn);
55 }
56 public void myEvent()
57 {
58 d.addWindowListener(new WindowAdapter(){
59 public void windowClosing(WindowEvent e)
60 {
61 d.setVisible(false); //当按了对话框上的x就不显示对话框
62 }
63 });
64 bn.addMouseListener(new MouseAdapter(){
65 public void mouseClicked(MouseEvent e)
66 {
67 d.setVisible(false); //但点击对话框中的按钮则不显示对话框
68 }
69 });
70 f.addWindowListener(new WindowAdapter(){
71 public void windowClosing(WindowEvent e) //注意参数
72 {
73 System.exit(0);
74 }
75 });
76 b.addMouseListener(new MouseAdapter(){
77 public void mouseClicked(MouseEvent e)
78 {
79 try
80 {
81 myDir();
82 }
83 catch (Exception ex)
84 {
85 }
86
87 }
88 });
89 tf.addKeyListener(new KeyAdapter(){ //当按回车键时就相当于点击按钮
90 public void keyPressed(KeyEvent e)
91 {
92 try
93 {
94 if(e.getKeyCode()==KeyEvent.VK_ENTER)
95 myDir();
96 }
97 catch (Exception ex)
98 {
99 }
100
101
102 }
103 });
104
105 }
106 public void myDir() throws Exception //把地址单独分离出来
107 {
108
109 ta.setText("");
110 String url = tf.getText(); //http://192.168.1.100:8080/myweb/demo.html
111 int index1 = url.indexOf("//")+2;
112 int index2 = url.indexOf("/",index1);
113 String str = url.substring(index1,index2);
114 String[] arr = str.split(":");
115 String host = arr[0];
116 int port = Integer.parseInt(arr[1]);
117 String path = url.substring(index2);
118
119
120 //ta.setText(str+"..."+path);
121
122 Socket s = new Socket(host,port); //访问的是tomcat服务器
123 PrintWriter pw =new PrintWriter(s.getOutputStream(),true);
124 pw.println("GET "+path+" HTTP/1.1"); //表示请求访问tomcat服务器中的这个内容
125 pw.println("Accept: */*");
126 pw.println("Accept-Language: zh-cn");
127 pw.println("Host:192.168.1.100:11000");
128 pw.println("Connection:closed");
129
130 pw.println(); //请求数据头必须和请求体隔一空行，就用println
131 pw.println();
132 BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
133 String line = null;
134 while((line=br.readLine())!=null)
135 {
136 ta.append(line+"\r\n");
137 //System.out.println(line);
138 }
139 s.close();
140
141 /*
142 //这段代码可以代替上面那段代码，通过URLConection包Socket封装
143 ta.setText("");
144 String urlPath = tf.getText(); //http://192.168.1.100:8080/myweb/demo.html
145 URL url = new URL(urlPath);
146 URLConnection conn = url.openConnection();
147 InputStream is = conn.getInputStream();
148 byte[] buf = new byte[1024];
149 int len=0;
150 while((len=is.read(buf))!=-1)
151 {
152 ta.append(new String(buf,0,len));
153 }
154 is.close();
155 */
156 }
157 }
1 //java基础视频教程第24-08-网络教程(URL-URLConection)
2 /*
3 本节课继续讲解URL中的方法，URL表示统一资源定位符
4 public URLConnection openConnection()throws IOException 这个方法返回一个URL所引用的远程对象的连接
5 它返回的是一个URLConnection,它是一个抽象类public abstract class URLConnetion extends Object
6 它代表应用程序和URL之间的通信连接，此类的实例可以读取和写入URL引用的资源
7 它的子类是HttpURLConnection JarURLConnetion，这里返回的是HttpURLConnection
8
9 URLConnection中可以获取输入输出流，其实它的内部就是封装了Socket，拿到的流就是Socket的流，就是将传输层的数据传到应用层
10 这个流是将应答消息头拆包，打印出来的是拆包后的有效数据
URLConnection可以直接开流url.openStream(),也可以先获取连接然后在获取流url.openConnection().getInputStream();,一般选用先连接对象在获取流，这样可以在连接 对象的基础上有更多的操作
11 */
12 import java.io.*;
13 import java.net.*;
14 class URLConnectionDemo
15 {
16 public static void main(String[] args)throws Exception
17 {
18 URL url = new URL("http://192.168.1.100:8080/myweb/demo.html");
19 URLConnection conn = url.openConnection();
20 InputStream is = conn.getInputStream();
21 byte[] buf = new byte[1024];
22 int len=0;
23 while((len=is.read(buf))!=-1)
24 {
25 System.out.println(new String(buf,0,len));
26 }
27 is.close();
28 }
29 }
1 //java基础视频教程第24天-08-网络编程(URL-URLConnection)
2 /*
3 本节课主要讲解URL这个类，URL它可以将一个url地址封装成对象，这样可以将通过方法来取它的主机，端口等，不用麻烦的自己去截取
4 它的构造方法可以直接传递url字符串，还可以传递协议，主机，端口，访问文件等等
5 public String getProtocol() //获取URL的协议
6 public String getHost() //获取URL的主机名
7 public int getPort() //获取URL的端口，如果没有设置端口号则返回-1
8 public String getFile() //获取URL的文件名，如果没有getQuery()值，则返回的部分与getPath()相同
9 public String getPath() //获取URL的路径
10 public String getQuery //获取URL的查询部分,如果没有则返回null
11
12 当url中端口没有设置，getPort()返回-1，返回-1时我们就可以将端口定义成80端口
13 */
14 import java.net.*;
15 class URLDemo
16 {
17 public static void main(String[] args)throws Exception
18 {
19 URL url = new URL("http://192.168.1.100:8080/myweb/demo.html?name=张三&age=22"); //这个要抛异常，因为你完全可以传一个不存在的url
20 sop(url.getProtocol());
21 sop(url.getHost());
22 sop(url.getPort());
23 sop(url.getFile());
24 sop(url.getPath());
25 sop(url.getQuery());
26 }
27 public static void sop(Object obj)
28 {
29 System.out.println(obj);
30 }
31 }
32
1 //java基础视频教程第24天-09-网络编程(小知识点)
2 /*
3 本节课主要讲解了Socket和ServerSocket中
4 （1）
5 Socket的构造方法中有一个没有传主机和端口的构造方法
6 public Socket();它一建立就要用Socket的connect()方法来指定端口和主机
7 public void connect(SocketAddress endpoint)throws IOException
8 而connect()方法的参数则是一个SocketAddress抽象类
9 public abstract class SocketAddress entends Object implents Serializable
10 它的子类是IntSocketAddress，这个类就是就包装了ip和端口号，传它的对象，并在对象中传入ip和端口即可
11 （2）
12 ServerSocket中的构造方法有一个
13 public ServerSocket(int port,int blacking)throws IOException
14 第二个参数表示连接到服务器的客户端的个数
15
16
17
18 */
1 //java基础视频教程第24天-10-网络编程(域名解析)
2 /*
3 解析域名的时候先走的是本地的host文件，如果里面有对应的键值对，则直接解析并访问，如果没有找到对应的域名解析地址则到公网域名解析服务器DNS上去找，
4 所以对于host中的文件，可以有几点作用，
5 （1）可以将常访问的网址的键值对存入其中，可以提供访问速度
6 （2）可以破解软件更新的网址设置成本地回环地址，避免它自动更新
7 （3）可以流氓网站的网址设置成本地回环地址，屏蔽访问
8
9
10 */
浙公网安备 33010602011771号