Java含个人认为很重要的个人理解和提醒：服务器，网络编程，UDP【诗书画唱】
网络编程概述：
网络编程三要素，
UDP编程，
TCP编程。
打印出自己的IP地址
package getIP;
import java.net.*;
public class getIP{
public
static void main(String[] args) throws Exception{
//
// 下面“DESKTOP-HSPHJ7O”是
// 我自己电脑的IP，这个只能打印出自己的IP地址
InetAddress ia= InetAddress.getByName("DESKTOP-HSPHJ7O");
System . out. println(ia.getHostAddress());
}
}
ipconfig: 查看本机IP地址
netstat -an:查看本机占用的端口号
1.使用UDP传入“我爱我的祖国”到服务器
package getIP;
import java.net.*;
public class UDPFuWuDuan {
//个人的总结：
//想要写服务端的话就要先：1.创建接收Socket对象容器（DatagramSocket）
//2.用DatagramPacket创建一个数据包(接收数据)
// 3.调用Socket对象接收方法（DatagramSocket.receive），接收数据
// 4.用byte[]和String(byteArray,0,length)解析数据包
// 5.用DatagramSocket.close()释放资源。
public static void main(String[] args) throws Exception{
System.out.println("服务器端启动");
// 1.创建接收Socket对象容器：
// datagram： 数据包;
// socket 英[ˈsɒkɪt]
// 美[ˈsɑːkɪt]
// n. (电源) 插座; (电器上的) 插口，
// 插孔，管座; 托座; 孔穴; 窝; 槽; 臼;
// vt. 把…装入插座; 给…配插座;
// DatagramSocket(int port)
// 构建一个数据报套接字，绑定到本地主机的指定端口：
DatagramSocket DatagramSocket=
new DatagramSocket(22222);
//：22222为服务端的端口号
// 2.创建一个数据包(接收数据)：
byte[] byteShuZu=new byte[1024*60];
DatagramPacket DatagramPacket=new DatagramPacket
(byteShuZu,0,byteShuZu.length);
// 3.调用Socket对象接收方法接收数据：
System.out.println("服务器正在耐心的等待接收数据");
DatagramSocket.receive(DatagramPacket);//：接收快递
System.out.println("——————");
System.out.println("服务器已经接收到客户端发来的数据了，"
+ "接收到的数据的内容为：");
// 4.解析数据包：
byte[] byteArray=DatagramPacket.getData();
//：得到发送的字节数组。
// 下面是打印客户端发来的数据：
int length=DatagramPacket.getLength();//：接收长度
String String=new String(byteArray,0,length);
System.out.println(String);
// 5.释放资源：
DatagramSocket.close();
}
}
package getIP;
import java.net.*;
public class UDPKeHuDuan {
public static void main(String[] args) throws Exception{
System.out.println("客户端启动了");
// ——————
// 个人的总结：
// 客户端一般是发送数据的，
// 而服务端一般是接收数据的。
// 客户端和服务端分别是两个Java文件，可以分别写到
// 两台不同的电脑，进行互相地聊天，交流，
// 传输数据。
// 要先开启（执行）服务端，再开启客户端，这样才有用。
// 写客户端时先要：
// 1.创建发送数据Socket对象(里面的参数是你发送端的端口号
// ，就是自己设置声明的端口号，
// 一般是要大于10000。)
// 2.创建数据（一般通过声明String或用Scanner接收等的方式
// 来创建数据，类型不定），用声明byte[]和getBytes()
// 来将String等转换为字节，并用DatagramPacket将数据打包，
// DatagramPacket
// (byteArray,byteArray.length,
// new InetSocketAddress("127.0.0.1",22222))
// 中的参数依次为字节数组，字节数组的长度，
// 实例化一个InetSocketAddress("127.0.0.1",22222)
// 。InetSocketAddress("127.0.0.1",22222)
// 中的参数分别为127.0.0.1（代表本机）
// ，服务端(别的要进行联机的电脑）的
// 端口号名（比如这里的22222）。
// ——————
// 多去用一些比喻等来描述一些过程，概念等，
// 会让听者（包括提出比喻者自己）感到更有趣等。
// ————
// 这个发送数据的过程就像是送（退）快递（货）的过程，
// 1.创建发送数据Socket对象（指定是哪个快递员去送快递）
// 。2.创建数据，并将数据打包（客户买了的东西，
// 快递员将要送的东西打包，了解要送的目的地）。
// 3.调用Socket发送的方法发送数据（用骑电动车或其他的方法把快递
// 送到卖家（服务端）那里。4.释放资源（卖家把钱退给买家，
// 也就是说卖家把钱退给客户)
// ——————
// DatagramSocket(int port)：
// 构建一个数据报套接字，绑定到本地主机的指定端口
// ——————
// 发送数据:
// 1.创建发送数据Socket对象(里面的参数是
// 你发送端（客户端）的端口号)：
DatagramSocket DatagramSocket
=new DatagramSocket(11111);//：快递员
// 2.创建数据，并将数据打包：
String String="我爱我的祖国";//：你要发送的数据，发快递
byte[] byteArray=String.getBytes();//：将数据转为字节
//快递打包：
DatagramPacket DatagramPacket=new DatagramPacket
(byteArray,byteArray.length,
new InetSocketAddress("127.0.0.1",22222));
// 3.调用Socket发送的方法发送数据：
DatagramSocket.send(DatagramPacket);//：发快递
// 4.释放资源：
DatagramSocket.close();//：休息
}
}
2.客户端提示用户输入“hello,world”到服务器端，如果输入的内容不对
提示，输入错误，如果输入正确提示输入正确
package getIP;
import java.net.*;
public class HelloWorldFuWuDuan {
//个人的总结：
//想要写服务端的话就要先：1.创建接收Socket对象容器（DatagramSocket）
//2.用DatagramPacket创建一个数据包(接收数据)
// 3.调用Socket对象接收方法（DatagramSocket.receive），接收数据
// 4.用byte[]和String(byteArray,0,length)解析数据包
// 5.用DatagramSocket.close()释放资源。
public static void main(String[] args) throws Exception{
System.out.println("服务器端启动");
// 1.创建接收Socket对象容器：
// datagram： 数据包;
// socket 英[ˈsɒkɪt]
// 美[ˈsɑːkɪt]
// n. (电源) 插座; (电器上的) 插口，
// 插孔，管座; 托座; 孔穴; 窝; 槽; 臼;
// vt. 把…装入插座; 给…配插座;
// DatagramSocket(int port)
// 构建一个数据报套接字，绑定到本地主机的指定端口：
DatagramSocket DatagramSocket=
new DatagramSocket(22226);
// ——————
// 个人提醒：
// //：22226为服务端的端口号，每一对服务端和客户端的端口号
// 都不能相同也都不 能太小或太大（比如222226就是
// 太大的“端口号”），不然就会报错。
// ————
// 2.创建一个数据包(接收数据)：
byte[] byteShuZu=new byte[1024*60];
DatagramPacket DatagramPacket=new DatagramPacket
(byteShuZu,0,byteShuZu.length);
// 3.调用Socket对象接收方法接收数据：
System.out.println("服务器正在耐心的等待接收数据");
DatagramSocket.receive(DatagramPacket);//：接收快递
System.out.println("——————");
System.out.println("服务器已经接收到客户端发来的数据了，"
+ "接收到的数据的内容为：");
// 4.解析数据包：
byte[] byteArray=DatagramPacket.getData();
//：得到发送的字节数组。
// 下面是打印客户端发来的数据：
int length=DatagramPacket.getLength();//：接收长度
String String=new String(byteArray,0,length);
System.out.println(String);
if(String.equals("hello,world")){
System.out.println("输入正确");
}
else {
System.out.println("输入错误");
}
// 5.释放资源：
DatagramSocket.close();
}
}
package getIP;
import java.net.*;
import java.util.Scanner;
public class HelloWorldKeHuDuan {
public static void main(String[] args) throws Exception{
System.out.println("客户端启动了，"
+ "请接下来输入“hello,world”\n"
+ "，这样的话这个数据就会发送到"
+ "服务端");
// ——————
// 个人的总结：
// 客户端一般是发送数据的，
// 而服务端一般是接收数据的。
// 客户端和服务端分别是两个Java文件，可以分别写到
// 两台不同的电脑，进行互相地聊天，交流，
// 传输数据。
// 要先开启（执行）服务端，再开启客户端，这样才有用。
// 写客户端时先要：
// 1.创建发送数据Socket对象(里面的参数是你发送端的端口号
// ，就是自己设置声明的端口号，
// 一般是要大于10000。)
// 2.创建数据（一般通过声明String或用Scanner接收等的方式
// 来创建数据，类型不定），用声明byte[]和getBytes()
// 来将String等转换为字节，并用DatagramPacket将数据打包，
// DatagramPacket
// (byteArray,byteArray.length,
// new InetSocketAddress("127.0.0.1",22222))
// 中的参数依次为字节数组，字节数组的长度，
// 实例化一个InetSocketAddress("127.0.0.1",22222)
// 。InetSocketAddress("127.0.0.1",22222)
// 中的参数分别为127.0.0.1（代表本机）
// ，服务端(别的要进行联机的电脑）的
// 端口号名（比如这里的22222）。
// ——————
// 多去用一些比喻等来描述一些过程，概念等，
// 会让听者（包括提出比喻者自己）感到更有趣等。
// ————
// 这个发送数据的过程就像是送（退）快递（货）的过程，
// 1.创建发送数据Socket对象（指定是哪个快递员去送快递）
// 。2.创建数据，并将数据打包（客户买了的东西，
// 快递员将要送的东西打包，了解要送的目的地）。
// 3.调用Socket发送的方法发送数据（用骑电动车或其他的方法把快递
// 送到卖家（服务端）那里。4.释放资源（卖家把钱退给买家，
// 也就是说卖家把钱退给客户)
// ——————
// DatagramSocket(int port)：
// 构建一个数据报套接字，绑定到本地主机的指定端口
// ——————
// 发送数据:
// 1.创建发送数据Socket对象(里面的参数是你
// 发送端（客户端）的端口号)：
DatagramSocket DatagramSocket
=new DatagramSocket(11116);//：快递员
// 2.创建数据，并将数据打包：
Scanner s=new Scanner(System.in);
String String=s.next();
// String String="我爱我的祖国";
//：你要发送的数据，发快递
byte[] byteArray=String.getBytes();//：将数据转为字节
//快递打包：
DatagramPacket DatagramPacket=new DatagramPacket
(byteArray,byteArray.length,
new InetSocketAddress("127.0.0.1",22226));
// 3.调用Socket发送的方法发送数据：
DatagramSocket.send(DatagramPacket);//：发快递
// 4.释放资源：
DatagramSocket.close();//：休息
}
}
若
会有中文乱码等（要鼠标右键点最后一个来统一改成一种编码格式等，比如UTF-8等）
若
则
3.定义用户类，该类实现序列化接口，定义属性uname，pwd，
提示用户输入用户名和密码保存到对应的属性中，将内容使用对象
传入到服务器端，解析传入的用户名和密码，如果用户名是王大锤密码
是张三丰就登录成功，否则登录失败
package getIP;
import java.net.*;
public class dengLuFuWuDuan {
public static void main(String[] args) throws Exception{
System.out.println("服务器端启动");
DatagramSocket DatagramSocket
=new DatagramSocket(23456);
byte[] byteArray=new byte[1026];
DatagramPacket DatagramPacket
=new DatagramPacket(byteArray,byteArray.length);
DatagramSocket.receive(DatagramPacket);
byte[] byteShuZu=DatagramPacket.getData();
int length=DatagramPacket.getLength();
String String= new String(byteShuZu,0,length);
// 之前在客户端用“:”（String String=uname+":"+pwd;）
// ，在这里和split（用于以split("XXX")中的"XXX"
// 为分割线来分割字符串）配合用，就有很大的作用了，可以把
// 用户在客户端输入的用户名和密码分割，
// 成String数组中的第一个内容
// （StringArra[0])和第二个内容(StringArra[1])。
String[] StringArray=String.split(":");
if(StringArray[0].trim().equals("王大锤")
&&StringArray[1].trim().equals("张三丰")){
System.out.println("登录成功");
}else {
System.out.println("登录失败");
}
DatagramSocket.close();
}
}
package getIP;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.net.*;
import java.util.Scanner;
public class dengLuKeHuDuan {
public static void main(String[] args) throws Exception{
//将字符串换为float或者Object
//ByteArrayOutputStream:将内容可以转为字节的流
// ObjectOutputStream:对象必须序列化，另外对象也要转为字节流
System.out.println("客户端启动了");
System.out.println("提示：如果用户名是王大锤，"
+ "\n密码是张三丰就登录成功，否则登录失败");
Scanner s=new Scanner(System.in);
System.out.println("请输入你的用户名");
String uname=s.next();
System.out.println("请输入你的密码");
String pwd=s.next();
DatagramSocket DatagramSocket
=new DatagramSocket(12345);
String String=uname+":"+pwd;
DatagramPacket DatagramPacket=new
DatagramPacket(String.getBytes(),
String.getBytes().length,
new InetSocketAddress(
// localhost表示本机
"localhost",23456));
DatagramSocket.send(DatagramPacket);
DatagramSocket.close();
}
}
//Serializable：
//Serializable接口是java提供的通用数据保存和读取的接口。
//功能 ：
//实现java.io.Serializable 。
//
//作用 ：
//标识可序列化的语义。
//
//SERIALIZABLE： 序列化可串行化可序列化串行化。
//serializable
//adj. 可串行化的。
class yongHu implements Serializable{
}
若
则
4.使用upd传入一张图片到服务器，服务器解析图片到项目的根目录中
package getIP;
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class UdpImgfuWuDuan {
public static void main(String[] args) throws Exception{
System.out.println("服务器启动了 ");
DatagramSocket DatagramSocket=new DatagramSocket(54321);
//创建接收数据的容器：
byte[] byteArray1=new byte[1024*60];
DatagramPacket DatagramPacket=
new DatagramPacket(byteArray1, byteArray1.length);
//堵塞性的接收数据：
System.out.println("服务器正在等待用户发送图片");
DatagramSocket.receive(DatagramPacket);
System.out.println("服务器接收了用户发送的图片");
//解析数据包：
byte[] byteArray2=DatagramPacket.getData();
int len1=DatagramPacket.getLength();
//将解析后的字节数组再转回图片：
ByteArrayInputStream ByteArrayInputStream=
new ByteArrayInputStream(byteArray2,0,len1);
FileOutputStream FileOutputStream=
new FileOutputStream("客户端发送的3.jpg");
//遍历byte数组：
byte [] byteArray3=new byte[1024];
int len2;
while((len2=ByteArrayInputStream.read(byteArray3))!=-1){
FileOutputStream.write(byteArray3,0,len2);
}
FileOutputStream.flush();
FileOutputStream.close();ByteArrayInputStream.close();
DatagramSocket.close();
}
}
package getIP;
import java.util.*;
import java.io.*;
import java.net.*;
public class UdpImgkeHuDuan {
public static void main(String[] args)throws Exception {
// 4.使用upd传入一张图片到服务器，服务器解析图片到项目的根目录中
// disiti();
//创建发送数据的对象
System.out.println("客户端启动");
DatagramSocket DatagramSocket=new DatagramSocket(12345);
//得到发送的数据并打包
FileInputStream FileInputStream=new FileInputStream("3.jpg");
ByteArrayOutputStream ByteArrayOutputStream
=new ByteArrayOutputStream();
//在读图片的同时将读取的内容写入到byte字节流里
byte[] byteArray1=new byte[1024];
int len;
while((len=FileInputStream.read(byteArray1))!=-1){
ByteArrayOutputStream.write(byteArray1,0,len);
}
ByteArrayOutputStream.flush();
byte[] byteArray2=ByteArrayOutputStream.toByteArray();
//将读取的数据转为字节数组
DatagramPacket DatagramPacket=new
DatagramPacket(byteArray2,byteArray2.length,
new InetSocketAddress("localhost",54321));
//发送数据
DatagramSocket.send(DatagramPacket);
DatagramSocket.close();
}
}
鼠标右键刷新后：
5.在第三题的基础上判断用户名和密码是否正确，正确则服务器向客户端
发送内容，登录成功，客户端接收服务器发送的内容，错误则发送登录失败
也是由客户端进行接收服务器发送的内容
package dengLu;
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class fuWuDuan {
public static void main(String[] args) throws Exception{
fuWuDuanFangFa();
}
private static void fuWuDuanFangFa() throws
SocketException, IOException,
ClassNotFoundException {
System.out.println("UDP的服务器端开启了"
+ "用户名和密码都为"
+ "“给诗书画唱三连关注”");
DatagramSocket DatagramSocket
=new DatagramSocket(27222);
byte[] byteArray1=new byte[1024];
DatagramPacket DatagramPacket1=new
DatagramPacket(byteArray1,byteArray1.length);
DatagramSocket.receive(DatagramPacket1);
//：堵塞性的接收内容
byte[] byteArray2=DatagramPacket1.getData();
int len2=DatagramPacket1.getLength();
ByteArrayInputStream ByteArrayInputStream2=new
ByteArrayInputStream(byteArray2,0,len2);
ObjectInputStream ObjectInputStream=new
ObjectInputStream(ByteArrayInputStream2);
yongHuClass yongHuClass=(yongHuClass)
ObjectInputStream.readObject();
if(yongHuClass.uname.trim().
equals("给诗书画唱三连关注")
&&yongHuClass.pwd.trim()
.equals("给诗书画唱三连关注")){
String String="登录成功";
DatagramPacket DatagramPacket=
new DatagramPacket(String.getBytes(),
String.getBytes().length,new
InetSocketAddress("localhost",17111));
DatagramSocket.send(DatagramPacket);
}else{
String StringFalse="登录失败";
DatagramPacket DatagramPacketFalse=new DatagramPacket
(StringFalse.getBytes(),
StringFalse.getBytes().length,
new InetSocketAddress("localhost",17111));
DatagramSocket.send(DatagramPacketFalse);
}
DatagramSocket.close();
}}
package dengLu;
import java.util.*;
import java.io.*;
import java.net.*;
public class keHuDuan {
public static void main(String[] args)throws Exception {
keHuDuanFangFa();
}
private static void keHuDuanFangFa() throws
SocketException, IOException {
System.out.println("UDP的客户端开启了");
Scanner s=new Scanner(System.in);
System.out.println("请输入用户名");
String uname=s.next();
System.out.println("请输入用户密码");
String pwd=s.next();
yongHuClass yongHuClass=new yongHuClass(uname,pwd);
DatagramSocket DatagramSocket
=new DatagramSocket(17111);
ByteArrayOutputStream ByteArrayOutputStream=
new ByteArrayOutputStream();
ObjectOutputStream ObjectOutputStream=
new ObjectOutputStream(ByteArrayOutputStream);
ObjectOutputStream.writeObject(yongHuClass);
byte[] byteArray1=ByteArrayOutputStream.toByteArray();
DatagramPacket DatagramPacket1
=new DatagramPacket(byteArray1,byteArray1.length
,new InetSocketAddress("localhost",27222));
DatagramSocket.send(DatagramPacket1);
byte[] byteArray2=new byte[1024*60];
DatagramPacket DatagramPacket2=new DatagramPacket
(byteArray2,byteArray2.length);
DatagramSocket.receive(DatagramPacket2);
byte[] byteArray3=DatagramPacket2.getData();
int len3=DatagramPacket2.getLength();
String StringPrintOut=new String(byteArray3,0,len3);
System.out.println(StringPrintOut);
DatagramSocket.close();
}
}
//用户类：
class yongHuClass implements Serializable{
String uname,pwd;
public yongHuClass(String uname,String pwd){
this.uname=uname;
this.pwd=pwd;
}
@Override
public String toString() {
return "yonghu [uname=" + uname
+ ", pwd=" + pwd + "]";
}
}
6.使用多线程实现1对1聊天
package dengLu;
import java.io.*;
import java.net.*;
import java.util.Scanner;
public class oneVoneFu {
public static void main(String[] args) throws Exception{
System.out.println("诗书画唱SSHC，服务器端启动,"
+ "\n请先输入内容，将会发给客户端");
jieShouClass jieShouClass=new jieShouClass(33397);
// jieShouClass(int wofangduankou) ，
// 33397是接收客户端发送给服务端时，服务端要用来接受
// 客户端发来内容的端口号，33397为服务端专门用来接受
// 客户端发来内容的端口号
faSongClass faSongClass=
new faSongClass(44497,11197,"localhost");
//44497为当前服务器发送给客户端内容时要用的本机端口号，
//11197为客户本机端口号
new Thread(jieShouClass,"诗书画唱").start();
new Thread(faSongClass).start();
}
}
package dengLu;
import java.util.*;
import java.io.*;
import java.net.*;
public class oneVoneKe {
public static void main(String[] args)throws Exception {
System.out.println("诗书画唱，客户端启动");
jieShouClass jieShouClass=new jieShouClass(11197);
faSongClass faSongClass
=new faSongClass(22297,33397,"localhost");
// 这里的22297为端口号
new Thread(jieShouClass,"诗书画唱SSHC").start();
new Thread(faSongClass).start();
}
}
//————
//将发送数据封为一个类，
//将接收数据封为一个类，
//在用户不管是客户端还是服务器端都开启一个接收和发送的线程。
//————
class jieShouClass implements Runnable{
DatagramSocket DatagramSocket=null;
public jieShouClass(int benJiDuanKouHao){
try {
DatagramSocket=new DatagramSocket(benJiDuanKouHao);
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() {
//接收数据也是死循环
while(true){
// byteArrayRead:用来读对方输入的内容的字节数组
byte[] byteArrayRead=new byte[1024*60];
DatagramPacket DatagramPacket=
new DatagramPacket
(byteArrayRead, byteArrayRead.length);
try {
DatagramSocket.receive(DatagramPacket);
//解析数据：
// byteArrayPrint：用来打印出读出的对方发送过来的
// 内容的字节数组
byte[] byteArrayPrint=DatagramPacket.getData();
int lenPrint=DatagramPacket.getLength();
// jieShouDaoDeNeiRong：接收到对方发来的内容
String jieShouDaoDeNeiRong
=new String(byteArrayPrint,0,lenPrint);
if(jieShouDaoDeNeiRong.trim().equals("不聊了")){
break;
}
System.out.println(Thread.currentThread().getName()
+":"+jieShouDaoDeNeiRong);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//：接收数据
}DatagramSocket.close();
}
}
class faSongClass implements Runnable{
private int wofangduankou,duiFangDuanKouHao;
String duiFangIP=null;
Scanner s=new Scanner(System.in);
//发送的对象:
// benJiDuanKouHao:本机端口号
// duiFangDuanKouHao：对方端口号
// duiFangIP：对方IP
DatagramSocket DatagramSocket=null;
public faSongClass(int benJiDuanKouHao,
int duiFangDuanKouHao,String duiFangIP){
this.duiFangDuanKouHao=duiFangDuanKouHao;
this.duiFangIP=duiFangIP;
try {
DatagramSocket=new
DatagramSocket(benJiDuanKouHao);
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() {
while(true){
//打包数据：
// shuRuNeiRong;输入内容
System.out.println(
// Thread.currentThread().getName()+
"——————\n"
+ "下面是评论区（请输入你的内容）\n"
+ "——————");
//System.out.println(
// Thread.currentThread().getName()+":");
String shuRuNeiRong=s.next();
DatagramPacket DatagramPacket
=new DatagramPacket(shuRuNeiRong.getBytes(),
shuRuNeiRong.getBytes().length,
new InetSocketAddress(duiFangIP,duiFangDuanKouHao));
if(shuRuNeiRong.trim().equals("不聊了")){
break;
}
try {
DatagramSocket.send(DatagramPacket);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
DatagramSocket.close();
}
}
