java学习-网络编程

一、前期配置：安装tomcat服务器

现代的应用程序都离不开网络，网络编程是非常重要的技术。Java SE提供java.net包，其中包含了网络编程所需要的最基础一些类和接口。这些类和接口面向两个不同的层次：基于Socket的低层次网络编程和基于URL的高层次网络编程。

所谓高低层次就是通信协议的高低层次，Socket采用TCP、UDP等协议，这些协议属于低层次的通信协议；URL采用HTTP和HTTPS这些属于高层次的通信协议。

低层次网络编程，因为它面向底层，比较复杂，但是“低层次网络编程”并不等于它功能不强大。恰恰相反，正因为层次低，Socket编程与基于URL的高层次网络编程比较，能够提供更强大的功能和更灵活的控制，但是要更复杂一些。

1、环境配置：

下载Tomcat安装包，解压之后，进入bin目录，复制其路径

进入高级系统设置，配置环境变量

进入path编辑，新建一个环境变量，复制bin地址，之后蒂点击确定

2、运行

进入bin目录，双击startup.bat运行，如果闪退，原因可能是因为在配置java环境中，配置有误，或者没有配置成HOME的模式。

运行之后，发现中文部分乱码，这因为，tomcat在配置时候，输入到控制台的编码格式是UTF-8，如果需要改，就进入conf目录，选择logging.properties日志文件，更改java.util.logging.ConsoleHandler.encoding的值为GBK

注意：运行startup.bat的窗口不要关闭，一旦关闭就认为服务器关闭，

测试服务器是否开启成功，在网浏览器输入http://localhost:8080/，服务器配置成功会进入Tomcat的欢迎页面，如下

如果启动失败，大部分原因是端口已被占用，特别是网站开发者而言，很容易遇到这种问题，因为大部分的网站开发语言的默认端口就是8080端口，所以导致8080容易被占用。

进入conf目录，选择server.xml，右击选择打开方式，选择记事本打开，找到更改port的值，就是更该端口号，之后保存

3、简单测试：在浏览器中访问文件

进入webapps目录，新建test文件，里面存放你要访问的文件。webapps目录用来存放应用程序。当tomcat启动时会去加载webapps目录下的应用程序。可以以文件夹、war包、jar包的形式发布应用

要重新运行startup.bat，这是因为，我们刚刚在里面写文件，还没刷新，此时访问的话，浏览器会查找不到该文件，所以要重新运行startup.bat。

之后再网页上输入http://localhost:8089/test/hello.txt

二、网络编程基础

1、网络模型：OSI与TCP/IP

2、ip地址

为实现网络中不同计算机之间的通信，每台计算机都必须有一个与众不同的标识，这就是IP地址， TCP/IP使用IP地址来标识源地址和目的地址。最初所有的IP地址都是32位数字构成，由4个8位的二进制数组成，每8位之间用圆点隔开，如：192.168.1.1，这种类型的地址通过IPv4指定。而现在有一种新的地址模式称为IPv6，IPv6使用128位数字表示一个地址，分为8个16位块。尽管IPv6比IPv4有很多优势，但是由于习惯的问题，很多设备还是采用IPv4。不过Java语言同时指出IPv4和IPv6。

在IPv4地址模式中IP地址分为A、B、C、D和E等5类：

A类地址用于大型网络，地址范围：1.0.0.1~126.155.255.254。
B类地址用于中型网络，地址范围：128.0.0.1~191.255.255.254。
C类地址用于小规模网络，192.0.0.1~223.255.255.254。
D类地址用于多目的地信息的传输和作为备用。
E类地址保留仅作实验和开发用。

另外，有时还会用到一个特殊的IP地址127.0.0.1，127.0.0.1称为回送地址，指本机。主要用于网络软件测试以及本地机进程间通信，使用回送地址发送数据，不进行任何网络传输，只在本机进程间通信

3、端口

一个IP地址标识这一台计算机，每一台计算机又有很多网络通信程序在运行，提供网络服务或进行通信，这就需要不同的端口进行通信。如果把IP地址比作电话号码，那么端口就是分机号码，进行网络通信时不仅要指定IP地址，还要指定端口号。

TCP/IP系统中的端口号是一个16位的数字，它的范围是0~65535。小于1024的端口号保留给预定义的服务，如HTTP是80，FTP是21，Telnet是23，Email是25等，除非要和那些服务进行通信，否则不应该使用小于1024的端口

三、网络编程-基本操作

1、读取网络上的资源

访问网络上的资源，输出到控制台上：

import java.io.*;
import java.net.*;public class One {public static void main(String[] args) throws Exception {URL url=new URL("http","localhost",8089,"/test/hello.txt");//实例化URl对象URLConnection uc=url.openConnection(); //得到网络连接对象InputStream is=uc.getInputStream();//得到网络资源的输入流InputStreamReader isr=new InputStreamReader(is);//转化为字符流BufferedReader br=new BufferedReader(isr);//转化为字符缓冲流读取String word=null;while((word=br.readLine())!=null) {System.out.println(word);}br.close();isr.close();is.close();}
}

2、网络资源的编码和解码

import java.io.*;
import java.net.*;
public class One {public static void main(String[] args) throws Exception {String word="hello,大家好";String newstr=URLEncoder.encode(word);System.out.println("编码后："+newstr);String decode=URLDecoder.decode(newstr);System.out.println("解码后："+decode);}
}

四，网络编程-基于TCP协议的操作

1、Socket类与ServerSocket类

java.net包为TCP Socket编程提供了两个核心类：Socket和ServerSocket，分别用来表示双向连接的客户端和服务器端

Socket常用的构造方法有：

Socket(InetAddress address, int port) ：创建Socket对象，并指定远程主机IP地址和端口号。
Socket(InetAddress address, int port, InetAddress localAddr, int localPort)：创建Socket对象，并指定远程主机IP地址和端口号，以及本机的IP地址（localAddr）和端口号（localPort）
Socket(String host, int port)：创建Socket对象，并指定远程主机名和端口号，IP地址为null，null 表示回送地址，即127.0.0.1。
Socket(String host, int port, InetAddress localAddr, int localPort)：创建Socket对象，并指定远程主机和端口号，以及本机的IP地址（localAddr）和端口号（localPort）。host主机名，IP地址为 null，null表示回送地址，即127.0.0.1。

Socket其他的常用方法有：

InputStream getInputStream()：通过此Socket返回输入流对象。
OutputStream getOutputStream()：通过此Socket返回输出流对象。 int getPort()：返回Socket连接到的远程端口。
int getLocalPort()：返回Socket绑定到的本地端口。 InetAddress getInetAddress()：返回Socket连接的地址。
InetAddress getLocalAddress()：返回Socket绑定的本地地址。 boolean isClosed()：返回Socket是否处于关闭状态。
boolean isConnected()：返回Socket是否处于连接状态。 void close()：关闭Socket。

注意 Socket与流类似所占用的资源，不能通过JVM的垃圾收集器回收，需要程序员释放。一种方法是可以在finally代码块调用close()方法关闭Socket，释放流所占用的资源。另一种方法通过自动资源管理技术释放资源，Socket和ServerSocket都实现了AutoCloseable接口。

ServerSocket类常用的构造方法有：

ServerSocket(int port, int maxQueue)：创建绑定到特定端口的服务器Socket。maxQueue设置连接的请求最大队列长度，如果队列满时，则拒绝该连接。默认值是50。
ServerSocket(int port)：创建绑定到特定端口的服务器Socket。最大队列长度是50。

ServerSocket其他的常用方法有：

InputStream getInputStream()：通过此Socket返回输入流对象。
OutputStream getOutputStream()：通过此Socket返回输出流对象。
boolean isClosed()：返回Socket是否处于关闭状态。
Socket accept()：侦听并接收到Socket的连接。此方法在建立连接之前一直阻塞。
void close()：关闭Socket。

ServerSocket类本身不能直接获得I/O流对象，而是通过accept()方法返回Socket对象，通过Socket对象取得I/O流对象，进行网络通信。此外，ServerSocket也实现了AutoCloseable接口，通过自动资源管理技术关闭ServerSocket。

2、客户端向服务端发送信息：

客户端类Client

import java.io.*;
import java.net.*;public class Client {public static void main(String[] args) throws Exception {Socket socket=new Socket("localhost",9999);//实例化一个基于客户端的Socket对象,参数是目标主机和目标主机的端口号OutputStream os=socket.getOutputStream(); //输出流对象,用于发送信息BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));bw.write("服务器，你好！！，我是客户端");bw.close();socket.close();}}

服务器端Server类：

import java.io.*;
import java.net.*;
public class Server {
public static void main(String[] args) throws Exception {ServerSocket ssocket=new ServerSocket(9999);  //实例化一个基于服务器端的socket对象Socket socket =ssocket.accept();//监听9999号端口，有信息发送就立马获取客户端的socket对象InputStream is=socket.getInputStream();//获取内容，转化为输入流BufferedReader br=new BufferedReader(new InputStreamReader(is));System.out.println(br.readLine());br.close();is.close();socket.close();ssocket.close();}
}

3、服务器端响应客户端

客户端类Client

public static void main(String[] args) throws Exception {//向服务器发送信息Socket socket=new Socket("localhost",9999);//实例化一个基于客户端的Socket对象,参数是目标主机和目标主机的端口号OutputStream os=socket.getOutputStream(); //输出流对象,用于发送信息BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(os));bw.write("服务器，你好！！，我是客户端");bw.flush();//刷新//接收服务器信息socket.shutdownOutput(); //把socket关于写的操作先关闭掉InputStream is=socket.getInputStream();//获取信息，转化为输入流BufferedReader br=new BufferedReader(new InputStreamReader(is));System.out.println(br.readLine());//关闭os.close();bw.close();br.close();is.close();}

服务器端类Server:

import java.io.*;
import java.net.*;
public class Server {public static void main(String[] args) throws Exception {//接收客户端发送的信息ServerSocket ssocket = new ServerSocket(9999); //实例化一个基于服务器端的socket对象Socket socket = ssocket.accept(); //调用侦听的功能，侦听9999端口，侦听到了就直接获得该客户端的socket对象InputStream is = socket.getInputStream();//获取客户端内容，转化为输入流BufferedReader br = new BufferedReader(new InputStreamReader(is));//转换为缓冲字符输出流，进行输出System.out.println(br.readLine());//回应客户端OutputStream os = socket.getOutputStream(); //获取输出流BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));//转化为字符缓冲输出流，进行输出bw.write("客户端你好，信息我已收到！！");//关闭bw.flush();bw.close();os.close();br.close();is.close();}
}

4、客户端向服务器端传输对象信息

客户端向服务器端传输的都是数据流，所以要使得客户端能够传输对象信息到服务器端，要把对象序列化

user类：

import java.io.Serializable;public class User implements Serializable{private static final long serialVersionUID = 1L;private String account;  //账户private String password; //密码public String toString() {return "User [account=" + account + ", password=" + password + "]";}public User(String account, String password) {super();this.account = account;this.password = password;}public User() {super();}public String getAccount() {return account;}public void setAccount(String account) {this.account = account;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}}

客户端Client:

import java.io.*;
import java.net.*;public class Client {public static void main(String[] args) throws Exception {//向服务器发送对象信息Socket socket=new Socket("localhost",9999);//实例化一个基于客户端的Socket对象,参数是目标主机和目标主机的端口号OutputStream os=socket.getOutputStream(); //输出流对象,用于发送信息User user=new User("admin","123456");//实例化User对象ObjectOutputStream oos=new ObjectOutputStream(os);//序列化对象oos.writeObject(user);//将指定的对象写入ObjectOutputStream//关闭oos.close();os.close();socket.close();}}

Server类：

import java.io.*;
import java.net.*;
public class Server {public static void main(String[] args) throws Exception {//接收客户端发送的对象信息ServerSocket ssocket = new ServerSocket(9999); //实例化一个基于服务器端的socket对象Socket socket = ssocket.accept(); //调用侦听的功能，侦听9999端口，侦听到了就直接获得该客户端的socket对象InputStream is = socket.getInputStream();//获取客户端内容，转化为输入流ObjectInputStream  ois=new ObjectInputStream(is);//反序列化对象Object obj=ois.readObject();//从ObjectInputStream读取一个对象User user = (User)obj; //转化为User类型if("admin".equals(user.getAccount())&&"123456".equals(user.getPassword())) { //进行账号密码匹配System.out.println("登录成功");}else {System.out.println("用户名或者密码不正确");}//关闭ois.close();is.close();socket.close();ssocket.close();}
}

5、客户端与服务器端自由交流

有两个方法实现，可以直接实现，也可以利用子线程实现

方法一：直接实现

客户端Client：

import java.io.*;
import java.net.*;
import java.util.Scanner;public class Client {public static void main(String[] args) throws Exception {Scanner input = new Scanner(System.in);Socket socket = new Socket("192.168.23.18",9999); // 实例化一个基于客户端的Socket对象，目标主机和目标主机的端口号，目标主机这里采用本电脑的ipwhile(true) {//发送信息OutputStream os = socket.getOutputStream();//得到输出流对象,用于发送信息DataOutputStream dos = new DataOutputStream(os);//实例化数据输出流，将原始Java数据类型写入输出流，应用程序可以使用数据输入流来读取数据dos.writeUTF("客户端说："+input.next());//发送信息给服务器端dos.flush();//接收响应数据InputStream is = socket.getInputStream();得到输入流对象,用于读取信息DataInputStream dis = new DataInputStream(is);//转化为数据输入流，便于直接读取System.out.println(dis.readUTF());}}
}

服务器端：

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Server {public static void main(String[] args) throws Exception {//接收客户端发送的对象信息Scanner input = new Scanner(System.in);    ServerSocket ssocket = new ServerSocket(9999); //实例化一个基于服务器端的socket对象Socket socket = ssocket.accept(); //调用监听功能，侦听9999端口，有信息就直接获得该客户端的socket对象while(true) {//接收信息InputStream is = socket.getInputStream();DataInputStream dis = new DataInputStream(is);System.out.println(dis.readUTF());//发送信息OutputStream os = socket.getOutputStream();//得到输出流对象DataOutputStream dos = new DataOutputStream(os);//实例化数据输出流对象，发送信息dos.writeUTF("服务器端说："+input.next());  //将信息发送给客户端dos.flush();}}
}

结果：

方法二：利用子线程实现

客户端Client：

import java.io.*;
import java.net.*;
import java.util.Scanner;public class Client {public static void main(String[] args) throws Exception {Scanner input = new Scanner(System.in);Socket socket = new Socket("192.168.23.18",9999); // 实例化一个基于客户端的Socket对象，目标主机和目标主机的端口号，目标主机这里采用本电脑的ipClientReadThread thread = new ClientReadThread(socket);//实例化子线程：用来读取取服务器端信息new Thread(thread).start(); //子线程启动//由主线程发送数据给服务器端while(true) {OutputStream os = socket.getOutputStream();//得到输出流对象,用于发送信息DataOutputStream dos = new DataOutputStream(os);//实例化数据输出流，将原始Java数据类型写入输出流，应用程序可以使用数据输入流来读取数据dos.writeUTF("客户端说："+input.next());//发送信息给服务器端}}}

客户端的子线程ClientReadThread：

import java.io.*;
import java.net.*;public class ClientReadThread implements Runnable {private Socket socket;public ClientReadThread(Socket socekt) {this.socket = socekt;}public void run() {while(true) {try {//客户端读取服务器端的响应数据InputStream is = socket.getInputStream();DataInputStream dis = new DataInputStream(is);System.out.println(dis.readUTF());} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}

服务器端：

import java.io.*;
import java.net.*;
import java.util.Scanner;
public class Server {public static void main(String[] args) throws Exception {//接收客户端发送的对象信息Scanner input = new Scanner(System.in);    ServerSocket ssocket = new ServerSocket(9999); //实例化一个基于服务器端的socket对象Socket socket = ssocket.accept(); //调用监听功能，侦听9999端口，有信息就直接获得该客户端的socket对象ServerReadThread thread = new ServerReadThread(socket);//实例化子线程，用来取客户端发送的信息new Thread(thread).start(); //实例化子线程对象，并启动子//由主线程来负责发送数据给客户端while(true) {OutputStream os = socket.getOutputStream();//得到输出流对象DataOutputStream dos = new DataOutputStream(os);//实例化数据输出流对象，发送信息dos.writeUTF("服务器端说："+input.next());   //将信息发送给客户端}}
}

服务器端的子线程：

import java.io.*;
import java.net.*;public class ServerReadThread implements Runnable {private Socket socket;public ServerReadThread(Socket socket) {this.socket = socket;}public void run() {try {while(true) {// 读取客户端发送过来的数据// 通过该socket得到输入流对象InputStream is = socket.getInputStream();DataInputStream dis = new DataInputStream(is);System.out.println(dis.readUTF());}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}

结果如下：

6、多个客户端群聊

这也用得子线程实现

客户端Client:

import java.io.*;
import java.net.*;
import java.util.Scanner;public class Client {public static void main(String[] args) throws Exception {Scanner input = new Scanner(System.in);Socket socket = new Socket("192.168.23.18",9999); // 实例化一个基于客户端的Socket对象，目标主机和目标主机的端口号，目标主机这里采用本电脑的ipwhile(true) {//发送信息OutputStream os = socket.getOutputStream();//得到输出流对象,用于发送信息DataOutputStream dos = new DataOutputStream(os);//实例化数据输出流，将原始Java数据类型写入输出流，应用程序可以使用数据输入流来读取数据dos.writeUTF("客户端说："+input.next());//发送信息给服务器端dos.flush();//接收响应数据InputStream is = socket.getInputStream();DataInputStream dis = new DataInputStream(is);System.out.println(dis.readUTF());}}}

客户端的子线程：ClientReadThread

import java.io.*;
import java.net.*;public class ClientReadThread implements Runnable {private Socket socket;public ClientReadThread(Socket socekt) {this.socket = socekt;}public void run() {while(true) {try {//客户端读取服务器端的响应数据InputStream is = socket.getInputStream();DataInputStream dis = new DataInputStream(is);System.out.println(dis.readUTF());} catch (IOException e) {e.printStackTrace();}}}}

服务器端：Server

import java.io.*;
import java.net.*;
import java.util.*;
public class Server {public static ArrayList<Socket> list = new ArrayList<>(); //收集所有群成员对应的socket对象private static Scanner input = new Scanner(System.in);public static void main(String[] args) throws Exception {ServerSocket ssocket = new ServerSocket(9999); //实例化一个基于服务器端的socket对象while(true) {//服务器负责给每个用户端发送信息Socket socket = ssocket.accept(); //调用监听功能，侦听9999端口，有信息就直接获得该客户端的socket对象list.add(socket);System.out.println("当前在线人数是："+list.size());ServerReadThread thread = new ServerReadThread(socket);//子线程作用就是负责读取发送客户端的信息，并且广播给其它成员客户端new Thread(thread).start(); //启动一个子线程}}
}

服务器的子线程：ServerReadThread

import java.io.*;
import java.net.*;
public class ServerReadThread implements Runnable {private Socket socket;public ServerReadThread(Socket socket) {this.socket = socket;}public void run() {try {while(true) {InputStream is = socket.getInputStream();//获取客户端发来的输入流，socket指的是发送信息的客户端socket对象DataInputStream dis = new DataInputStream(is);//转化为数据输入流//得到发送信息客户端的实现发送的内容String message = dis.readUTF();for (Socket currentSocket : Server.list) { //遍历集合中收集的所有成员的socket对象if(socket!=currentSocket) { //排除掉自己，因为这条信息本身就是自己发的，没必要再广播给自己了OutputStream os = currentSocket.getOutputStream();//得到当前遍历的socket的输出流对象，因为广播就是通过该输出流写出去的DataOutputStream oos = new DataOutputStream(os);oos.writeUTF(message);//把信息广播发送出去}}}} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

结果:每运行一次Client类，就产生一个用户，

五，网络编程-基于UDP协议的操作

1、DatagramSocket和DatagramPacket

java.net包中提供了两个类：DatagramSocket和DatagramPacket用来支持UDP通信。这一节先介绍一下 DatagramSocket类，DatagramSocket用于在程序之间建立传送数据报的通信连接。

下DatagramSocket常用的构造方法：

DatagramSocket()：创建数据报DatagramSocket对象，并将其绑定到本地主机上任何可用的端口。
DatagramSocket(int port)：创建数据报DatagramSocket对象，并将其绑定到本地主机上的指定端口。
DatagramSocket(int port, InetAddress laddr)：创建数据报DatagramSocket对象，并将其绑定到指定的本地地址。

DatagramSocket其他的常用方法有：

void send(DatagramPacket p)：从发送数据报包。
void receive(DatagramPacket p)：接收数据报包。
int getPort()：返回DatagramSocket连接到的远程端口。
int getLocalPort()：返回DatagramSocket绑定到的本地端口。
InetAddress getInetAddress()：返回DatagramSocket连接的地址。
InetAddress getLocalAddress()：返回DatagramSocket绑定的本地地址。
boolean isClosed()：返回DatagramSocket是否处于关闭状态。
boolean isConnected()：返回DatagramSocket是否处于连接状态。
void close()：关闭DatagramSocket。

DatagramSocket也实现了AutoCloseable接口，通过自动资源管理技术关闭DatagramSocket。

2、发送端给接收端发送信息：

发送端Sender:

import java.net.*;public class Sender {public static void main(String[] args) throws Exception {DatagramSocket socket = new DatagramSocket();String content = "hello,好好学习，天天向上！！！";//准备要发送的内容System.out.println(content.length()); //18System.out.println(content.getBytes().length); //30//把要发送的内容和目标主机及端口封装在数据报包对象中DatagramPacket packet = new DatagramPacket(content.getBytes(), content.getBytes().length, InetAddress.getByName("127.0.0.1"), 10086);
//      content.getBytes():要发送的字节数据
//      content.getBytes().length:发送内容字节的长度
//      InetAddress.getByName("127.0.0.1"):目的地的ip
//      10086:目的地主机的端口号socket.send(packet);//执行发送操作System.out.println("发送成功！！！！");}}

接收端：

import java.net.*;public class Sender {public static void main(String[] args) throws Exception {DatagramSocket socket = new DatagramSocket();String content = "hello,好好学习，天天向上！！！";//准备要发送的内容System.out.println(content.length()); //18System.out.println(content.getBytes().length); //30//把要发送的内容和目标主机及端口封装在数据报包对象中DatagramPacket packet = new DatagramPacket(content.getBytes(), content.getBytes().length, InetAddress.getByName("127.0.0.1"), 10086);
//      content.getBytes():要发送的字节数据
//      content.getBytes().length:发送内容字节的长度
//      InetAddress.getByName("127.0.0.1"):目的地的ip
//      10086:目的地主机的端口号socket.send(packet);//执行发送操作System.out.println("发送成功！！！！");}}

结果：