方法名 | 说明 |
static InetAddress getByName(String host) | 确定主机名称的IP地址。主机名称可以是机器名称,也可以是IP地址 |
String getHostName() | 获取此IP地址的主机名(计算机名) |
String getHostAddress() | 返回文本显示中的IP地址字符串 |
package inetaddress;
import java.net.InetAddress;
import java.net.UnknownHostException;
/*
static InetAddress getByName(String host) 确定主机名称的IP地址。主机名称可以是机器名称,也可以是IP地址
String getHostName() 获取此IP地址的主机名(计算机名)
String getHostAddress() 返回文本显示中的IP地址字符串
*/
public class InetAddressTest {
public static void main(String[] args) throws UnknownHostException {
//static InetAddress getByName(String host)
// 确定主机名称的IP地址。主机名称可以是机器名称(计算机名),也可以是IP地址
// InetAddress ia = InetAddress.getByName("192.168.14.23");//这里的IP地址必须是在当前网络段分配的实际IP地址
InetAddress ia = InetAddress.getByName("USER-20181101RG");
//String getHostName() 获取此IP地址的主机名(计算机名)
System.out.println(ia.getHostName());
//String getHostAddress() 返回文本显示中的IP地址字符串
System.out.println(ia.getHostAddress());
}
}
方法名 | 说明 |
DataGramSocket() | 创建数据报套接字并将其绑定到本机地址上的任何可用端口 |
DatagramPacket(byte[] buf,int len,InetAddress add,int port) | 创建数据包,发送长度为len的数据包到指定主机的指定端口 |
方法名 | 说明 |
void send(DatagramPacket p) | 发送数据报包 |
void close() | 关闭数据报套接字 |
void receive(DatagramPacket p) | 从此套接字接受数据报包 |
package UDP;
import java.io.IOException;
import java.net.*;
/*
- 构造方法
方法名 说明
DatagramSocket() 创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramPacket(byte[] buf,int len,InetAddressTest add,int port) 创建数据包,发送长度为len的数据包到指定主机的指定端口
- 相关方法
方法名 说明
void send(DatagramPacket p) 发送数据报包
void close() 关闭数据报套接字
void receive(DatagramPacket p) 从此套接字接受数据报包
- 发送数据的步骤
- 创建发送端的Socket对象(DatagramSocket)
- 创建数据,并把数据打包
- 调用DatagramSocket对象的方法发送数据
- 关闭发送端
*/
public class UDPSendTest {
public static void main(String[] args) throws IOException {
//创建发送端的Socket对象(DatagramSocket)
//DatagramSocket() 创建数据报套接字并将其绑定到本机地址上的任何可用端口
DatagramSocket ds = new DatagramSocket();
//创建数据,并把数据打包
//DatagramPacket(byte[] buf,int len,InetAddressTest add,int port)
// 创建数据包,发送长度为len的数据包到指定主机的指定端口
byte[] bys = "hello".getBytes();
DatagramPacket dp = new DatagramPacket(bys, bys.length,InetAddress.getByName("127.0.0.1"),8081);
//调用DatagramSocket对象的方法发送数据
//void send(DatagramPacket p) 发送数据报包
ds.send(dp);
//关闭发送端
//void close() 关闭数据报套接字
ds.close();
}
}
方法名 | 说明 |
DatagramPacket(byte[] buf, int len) | 创建一个DatagramPacket用于接收长度为len的数据包 |
方法名 | 说明 |
byte[] getData() | 返回数据缓冲区,将接收到的数据转换为字节数组 |
int getLength() | (获取)返回接收的数据的长度 |
package UDP;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/*
- 接收数据的步骤
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包,用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包,并把数据在控制台显示
- 关闭接收端
- 构造方法
方法名 说明
DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接收长度为len的数据包
- 相关方法
方法名 说明
byte[] getData() 返回数据缓冲区
int getLength() 返回要发送的数据的长度或接收的数据的长度
*/
public class UDPReceiveTest {
public static void main(String[] args) throws IOException {
//创建接收端的Socket对象(DatagramSocket)
//DatagramSocket(Port p),要传入一个端口号,来接收发送者的数据
DatagramSocket ds = new DatagramSocket(8081);
//创建一个数据包,用于接收数据
// DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接收长度为len的数据包
byte[] bys = new byte[1024];
DatagramPacket dp = new DatagramPacket(bys,bys.length);
//调用DatagramSocket对象的方法接收数据,
// 如果需要打印接收的数据,需要使用DataGramPacket()的方法,
System.out.println("准备接收");
ds.receive(dp);
System.out.println("接收完毕");
//解析数据包,并把数据在控制台显示
//byte[] getData() 返回数据缓冲区,获取发送者的数据的数据,返回值是byte[]数组
//int getLength() 返回要发送的数据的长度或接收的数据的长度
System.out.println("数据是:"+new String(dp.getData(),0,dp.getLength()));
//关闭接收端
ds.close();
}
}
package UDP;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
public class UDPSendTest1 {
public static void main(String[] args) throws IOException {
DatagramSocket ds = new DatagramSocket();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
//这个循环,是每写一行字符串九把这个字符串打包,发给接收者
while ((line = br.readLine()) != null) {
if ("886".equals(line)) {
break;
}
//line = br.readLine();
byte[] bys = line.getBytes();
DatagramPacket dp = new DatagramPacket(bys, bys.length, InetAddress.getByName("127.0.0.1"), 8082);
ds.send(dp);
}
ds.close();
}
}
package UDP;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UDPReceiveTest1 {
public static void main(String[] args) throws IOException {
DatagramSocket ds = new DatagramSocket(8082);
byte[] bys = new byte[1024];
while (true) {
DatagramPacket dp = new DatagramPacket(bys, bys.length);
System.out.println("准备接收");
ds.receive(dp);
System.out.println("接收完毕");
System.out.println("数据是:" + new String(dp.getData(), 0, dp.getLength()));
}
// ds.close();
}
}
方法名 | 说明 |
Socket(InetAddress address,int port) | 创建流套接字并将其连接到指定IP指定端口号,InetAddress address = InetAddress.getByName(String host),可以传ip地址,也可以传主机名 |
Socket(String host, int port) | 创建流套接字并将其连接到指定主机上的指定端口号,String host,可以传ip地址,也可以传主机名 |
方法名 | 说明 |
InputStream getInputStream() | 返回此套接字的输入流,客户端(服务器)可以通过它来向服务器端(客户端)传入数据 |
OutputStream getOutputStream() | 返回此套接字的输出流,服务器端(客户端)服务器端传入数据可以通过它来反馈信息给客户端(服务器) |
package TCP;
/*
- 构造方法
方法名 说明
Socket(InetAddressTest address,int port) 创建流套接字并将其连接到指定IP指定端口号
Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
- 相关方法
方法名 说明
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流
*/
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class TCPClientTest1 {
public static void main(String[] args) throws IOException {
//创建客户端链接
//创建客户端的Socket对象(Socket)
//Socket(InetAddressTest address,int port) 创建流套接字并将其连接到指定IP指定端口号
//Socket s = new Socket(InetAddressTest.getByName("127.0.0.1"),8081);
//Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
Socket s = new Socket("127.0.0.1",8081);
//OutputStream getOutputStream() 返回此套接字的输出流
//写数据
//获取输出流,写数据
OutputStream os = s.getOutputStream();
os.write("hello".getBytes());
//释放资源
s.close();
}
}
方法名 | 说明 |
ServletSocket(int port) | 创建绑定到指定端口的服务器套接字,通过它来创建服务器端Socket对象 |
方法名 | 说明 |
Socket accept() | 监听要连接到此的套接字并接受它,通过它来监听客户端连接,连接上后,把客户端的Socket对象和这个方法返回的Socket对象进行相匹配 |
package TCP;
/*
- 方法名 说明
ServletSocket(int port) 创建绑定到指定端口的服务器套接字
- 相关方法
方法名 说明
Socket accept() 监听要连接到此的套接字并接受它
*/
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServerTest1 {
public static void main(String[] args) throws IOException {
//ServletSocket(int port) 创建绑定到指定端口的服务器套接字
//创建服务器端
//创建服务器端的Socket对象(ServerSocket)
ServerSocket ss = new ServerSocket(8081);
//Socket accept() 监听要连接到此的套接字并接受它
//监听客户端的链接,监听到了,就建立链接,连接通道是Socket对象
Socket s = ss.accept();
//获取客户端发送的数据
//获取输入流,读数据,并把数据显示在控制台
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
//数据接收到的数据
System.out.println(new String(bys,0,len));
//释放资源
ss.close();
}
}
package TCP;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class TCPClientTest2 {
public static void main(String[] args) throws IOException {
//创建服务器端的Socket对象(ServerSocket)
Socket s = new Socket("127.0.0.1",8082);
OutputStream os = s.getOutputStream();
os.write("hello".getBytes());
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
System.out.println("反馈:"+new String(bys,0,len));
s.close();
}
}
package TCP;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServerTest2 {
public static void main(String[] args) throws IOException {
//监听客户端连接,返回一个Socket对象
ServerSocket ss = new ServerSocket(8082);
//监听客户端连接,返回一个Socket对象
Socket s = ss.accept();
//获取输入流,读数据,并把数据显示在控制台
InputStream is = s.getInputStream();
byte[] bys = new byte[1024];
int len = is.read(bys);
System.out.println(new String(bys,0,len));
OutputStream os = s.getOutputStream();
os.write("数据收到了".getBytes());
ss.close();
}
}
package TCP;
import java.io.*;
import java.net.Socket;
public class TCPClientTest3 {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1",8083);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while((line=br.readLine()) != null){
if (line.equals("886")){
break;
}
bw.write(line);
bw.newLine();
bw.flush();
}
s.close();
}
}
package TCP;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServerTest3 {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(8083);
Socket s = ss.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line;
while ((line=br.readLine())!=null){
System.out.println(line);
}
ss.close();
}
}
package TCP;
import java.io.*;
import java.net.Socket;
public class TCPClientTest4 {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1",8084);
//InputStreamReader是从字节流到字符流的桥梁---转换流
//BufferedReader(Reader in)
//InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader
//static InputStream in “标准”输入流。 返回一个字节输入流InputStream类对象
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
//OutputStreamWriter是从字符流到字节流的桥梁---转换流
//OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//PrintWriter(OutputStream out, boolean autoFlush) 从现有的OutputStream创建一个新的PrintWriter。
PrintWriter bw = new PrintWriter(s.getOutputStream(),true);
String line;
while((line=br.readLine()) != null){
if (line.equals("886")){
break;
}
/*bw.write(line);
bw.newLine();
bw.flush();*/
bw.println(line);
}
s.close();
}
}
package TCP;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServerTest4 {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(8084);
Socket s = ss.accept();
//InputStreamReader是从字节流到字符流的桥梁---转换流
//BufferedReader(Reader in)
//InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader
//InputStream getInputStream() 返回此套接字的输入流。
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
//OutputStreamWriter是从字符流到字节流的桥梁
//OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
// BufferedWriter bw = new BufferedWriter(new FileWriter("day12\\s.txt"));
//PrintWriter(Writer out, boolean autoFlush) 创建一个新的PrintWriter。
PrintWriter bw = new PrintWriter(new FileWriter("day12\\s.txt"),true);
String line;
while ((line=br.readLine())!=null){
/*bw.write(line);
bw.newLine();
bw.flush();*/
bw.println(line);
}
bw.close();
ss.close();
}
}
package TCP;
import java.io.*;
import java.net.Socket;
public class TCPClientTest5 {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1",8085);
BufferedReader br = new BufferedReader(new FileReader("day12\\src\\TCP\\TCPClientTest1.java"));
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter bw = new PrintWriter(s.getOutputStream(),true);
String line;
while ((line=br.readLine())!=null){
/*bw.write(line);
bw.newLine();
bw.flush();*/
bw.println(line);
}
br.close();
s.close();
}
}
package TCP;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServerTest5 {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(8085);
Socket s = ss.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// BufferedWriter bw = new BufferedWriter(new FileWriter("day12\\copy.txt"));
PrintWriter bw = new PrintWriter(new FileWriter("day12\\\\copy.txt"),true);
String line;
while ((line=br.readLine())!=null){
/*bw.write(line);
bw.newLine();
bw.flush();*/
bw.println(line);
}
bw.close();
ss.close();
}
}
方法名 | 说明 |
void shutdownInput() | 将此套接字的输入流放置在“流的末尾” |
void shutdownOutput() | 禁止用此套接字的输出流 |
package TCP;
import java.io.*;
import java.net.Socket;
public class TCPClientTest6 {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1",8086);
BufferedReader br = new BufferedReader(new FileReader("day12\\s.txt"));
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter bw = new PrintWriter(s.getOutputStream(),true);
String line;
while ((line=br.readLine())!=null){
/*bw.write(line);
bw.newLine();
bw.flush();*/
bw.println(line);
}
s.shutdownOutput();
BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String data = brClient.readLine();
System.out.println("反馈:"+data);
br.close();
s.close();
}
}
package TCP;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServerTest6 {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(8086);
Socket s = ss.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// BufferedWriter bw = new BufferedWriter(new FileWriter("day12\\copy.txt"));
PrintWriter bw = new PrintWriter(new FileWriter("day12\\\\copy.txt"),true);
String line;
while ((line=br.readLine())!=null){
/*bw.write(line);
bw.newLine();
bw.flush();*/
bw.println(line);
}
/*BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwServer.write("文件上传成功");
bwServer.newLine();
bwServer.flush();*/
PrintWriter bwServer = new PrintWriter(s.getOutputStream(),true);
bwServer.println("文件上传成功");
bw.close();
ss.close();
}
}
package TCP;
import java.io.*;
import java.net.Socket;
public class TCPClientTest7 {
public static void main(String[] args) throws IOException {
Socket s = new Socket("127.0.0.1",8087);
BufferedReader br = new BufferedReader(new FileReader("day12\\s.txt"));
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter bw = new PrintWriter(s.getOutputStream(),true);
String line;
while ((line=br.readLine())!=null){
/*bw.write(line);
bw.newLine();
bw.flush();*/
bw.println(line);
}
s.shutdownOutput();
BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
String data = brClient.readLine();
System.out.println("反馈:"+data);
br.close();
s.close();
}
}
package TCP;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPServerTest7 {
public static void main(String[] args) throws IOException {
ServerSocket ss =new ServerSocket(8087);
while (true) {
Socket s = ss.accept();
/*Thread t = new Thread(new ServerThread(s));
t.start();*/
new Thread(new ServerThread(s)).start();
}
}
}
package TCP;
import java.io.*;
import java.net.Socket;
public class ServerThread implements Runnable {
private Socket s;
public ServerThread(Socket s) {
this.s = s;
}
@Override
public void run() {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
// BufferedWriter bw = new BufferedWriter(new FileWriter("day12\\copy.txt"));
int count = 1;
File f = new File("day12\\copy("+count+").txt");
/*System.out.println("############");
System.out.println("day12\\copy("+count+").txt");*/
while (f.exists()){
count++;
f = new File("day12\\copy("+count+").txt");
}
BufferedWriter bw = new BufferedWriter(new FileWriter(f));
String line;
while ((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bwServer.write("文件上传成功");
bwServer.newLine();
bwServer.flush();
bw.close();
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) | 黑马程序员IT技术论坛 X3.2 |