简介:
1,IP
import java.net.InetAddress;
import java.net.UnknownHostException;
public class IPdemo {
/**
* @param args
*/
public static void main(String[] args) {
try {
// InetAddress i= InetAddress.getLocalHost();
// System.out.println(i.toString());
// System.out.println("address:"+i.getHostAddress());
// System.out.println("name:"+i.getHostName());
//InetAddress ia= InetAddress.getByName("192.168.1.101");
InetAddress[] ia= InetAddress.getAllByName("www.baidu.com");
for(InetAddress i :ia)
{
System.out.println(i);
}
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
获取了百度的IP地址
TCP练习:
需求:建立一个文本转换服务器。
客户端给服务端发送文本,服务端会将文本转成大写再发给客户端。
而且客户端可以不断进行文本转换,当客户端输入over时,转换结束。
分析:
客户端:既然是操作设备上的数据,那么就可以使用io技术,并按照Io的操作规律来思考。
源:键盘录入
目的:网络设备,网络输出流。
而且操作的都是文本数据,可以选择字符流。
步骤:
1,建立服务
服务端:
上传成功!
2,TCP和UDP
TCP 就相当于打电话
UDP 就相当于步话机
3,Socket
Socket 就相当于码头
4,UDP发送和接受数据
发送端:
接收端:
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
public class UdpSend {
/**
* 定义一个udp 发送端
*需求:通过udp传输方式将一段文字数据发送出去。
*1,建立udpsocket服务。
*2,提供数据,并将数据封装到数据包中。
*3,通过socket的发送功能,将数据包发出去
*4,关闭资源。
*/
public static void main(String[] args) throws IOException {
//1,创建UDP服务,通过 DatagramSocket 对象
//DatagramSocket ds=new DatagramSocket();
//或自定义发送端口
DatagramSocket ds=new DatagramSocket(8888);
//2,确定数据,并封装成数据包、
byte[] buf="udp come on".getBytes();
DatagramPacket dp=new DatagramPacket(buf, buf.length,InetAddress.getByName("192.168.1.101"),10000);
//3,通过socket服务,将已有的数据包发送出去,通过send方法
ds.send(dp);
//关闭资源
ds.close();
}
}
接收端:
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/*
* 定义udp的接收端
需求:定义一个应用程序,用于接收udp传输的数据并处理。
1,定义udpsocket服务。通常会监听一个端口,其实就是给这个接受网络应用程序定义数字标识,
方便与明确那些数据过来应用程序可以处理。
2,定义一个数据包,因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取
字节数据中的不同数据信息。
3,通过socket服务的receive方法将收到的数据存入已定义好的数据包中
4,通过数据包对象的特有功能,将这些不同的数据取出,打印在控制台上
5,关闭资源
*/
public class UdpRece {
public static void main(String[] args) throws IOException {
//1,创建udp socket,建立端点
DatagramSocket ds=new DatagramSocket(10000);
while(true)
{
//2,定义一个数据包,用于存储数组
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf, buf.length);
//3,通过服务的receive方法将受到数据存入到数据包中
ds.receive(dp); //阻塞式方法
//通过数据包的方法获取其中数据
String ip=dp.getAddress().getHostAddress();
String data=new String(dp.getData(),0,dp.getLength());
int port=dp.getPort();
System.out.println(ip+"::"+data+"::"+port);
}
//5,关闭资源
//ds.close();
}
}
因为是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 UdpSend2 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
DatagramSocket ds = new DatagramSocket();
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=bufr.readLine())!=null)
{
if("886".equals(line))
break;
byte[] buf=line.getBytes();
DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.1.101"), 9999);
ds.send(dp);
}
ds.close();
}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
public class UdpRece2 {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
DatagramSocket ds=new DatagramSocket(9999);
while(true)
{
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf, buf.length);
ds.receive(dp);
String ip=dp.getAddress().getHostAddress();
String data=new String(dp.getData(),0,dp.getLength());
int port=dp.getPort();
System.out.println(ip+"::"+data+"::"+port);
}
}
}
发送端:
接收端:
如果上面的地址 改为:192.168.1.255 这是广播地址,192.168.1.- 这个段里的都能收到。
练习:编写一个聊天程序。
有收数据的部分,和发数据的部分。
这两部分需要同时执行那就需要用到多线程技术,一个线程控制收,一个线程控制发。
这两部分需要同时执行那就需要用到多线程技术,一个线程控制收,一个线程控制发。
因为收和发动作是不一致的,所以要定义2个run方法,而且这2个方法要封装到不同类中
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.UnknownHostException;
public class Send implements Runnable{
private DatagramSocket ds;
public Send(DatagramSocket ds)
{
this.ds=ds;
}
@Override
public void run() {
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
String line=null;
try {
while((line=bufr.readLine())!=null)
{
if("886".equals(line))
break;
byte[] buf=line.getBytes();
//局域网中的每台计算机都能收到--255
DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.1.255"), 10008);
ds.send(dp);
}
}
catch (IOException e) {
e.printStackTrace();
}
//ds.close();
}
}
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Rece implements Runnable {
private DatagramSocket ds;
public Rece(DatagramSocket ds) {
this.ds = ds;
}
@Override
public void run() {
try {
while (true) {
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf, buf.length);
ds.receive(dp);
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(), 0, dp.getLength());
int port = dp.getPort();
System.out.println(ip + "::" + data + "::" + port);
}
}
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
import java.net.DatagramSocket;
import java.net.SocketException;
public class DosQQ {
public static void main(String[] args) throws SocketException {
DatagramSocket sendSocket =new DatagramSocket();
DatagramSocket receSocket =new DatagramSocket(10008);
new Thread(new Send(sendSocket)).start();
new Thread(new Rece(receSocket)).start();
}
}
5,TCP传输
1,TCP分客户端和服务端
2,客户端对应的对象是Socket
服务端对应的对象第ServerSocket
2,客户端对应的对象是Socket
服务端对应的对象第ServerSocket
package TCP;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class TcpClient {
/**
客户端:通过查阅Socket对象,发现在该对象建立时,就可以去连接指定主机
因为tcp是面向连接的,所以在建立socket服务时,就要有服务端存在,并连接成功,
形成通路后,在钙通道进行数据的传输
需求:给服务店发送一个文本数据
步骤:
1,创建Socket 服务,并指定要连接的服务和端口
*/
public static void main(String[] args) throws UnknownHostException, IOException {
//创建客户端的socket服务,指定目的主机和端口
Socket s=new Socket("192.168.1.101", 10000);
//为了发送数据,应该获取socket流中的输出流
OutputStream out=s.getOutputStream();
out.write("tcp come on".getBytes());
s.close();
}
}
package TCP;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class TpcServer {
/*
需求:定义端点接受数据并打印在控制台上
服务端:
1,建立服务端的socket服务,ServerSocket();
并监听一个端口、
2,获取连接过来的客户端对象,通过ServerSocket的accept方法,没有链接就会等,所以这个方法是阻塞式的。
3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流来读取发过来的数据
4,关闭服务端(可选)
*/
public static void main(String[] args) throws IOException {
//建立服务端的socket服务,并监听一个端口
ServerSocket ss=new ServerSocket(10000);
//通过accept方法获取链接过来的客户端对象
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println("ip"+ip);
//获取客户端发送过来的数据,那么要使用客户端对象的读取刘来读取数据
InputStream in= s.getInputStream();
byte[] buf=new byte[1024];
int len=in.read(buf);
System.out.print(new String(buf,0,len));
s.close(); //关闭客户端!!!
//ss.close();
}
}
要先启动服务端!
/下面演示客户端和服务端的互访:
需求:客户端给服务端发送数据,服务端收到后,给客户端反馈信息
服务端:
服务端:
package TCP;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
public class TcpServer2 {
public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {
ServerSocket ss=new ServerSocket(10008);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println("ip"+ip);
InputStream in= s.getInputStream();
byte[] buf=new byte[1024];
int len=in.read(buf);
System.out.print(new String(buf,0,len));
OutputStream out=s.getOutputStream();
Thread.sleep(3000);
out.write("客户端,你也好".getBytes());
s.close();
ss.close();
}
}
package TCP;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/**
客户端:
1,建立socket服务,指定连接的主机和端口。
2,获取socket流中的输出流、将数据写入到该流中,通过网络发送给服务端。
3,获取socketlzhong的输入流,将服务端反馈的数据获取到,并打印,
4,关闭客户端资源
*/
public class TcpClient2 {
public static void main(String[] args) throws UnknownHostException, IOException {
Socket s=new Socket("192.168.1.101", 10008);
OutputStream out=s.getOutputStream();
out.write("服务端,你好".getBytes());
InputStream in= s.getInputStream();
byte[] buf=new byte[1024];
int len=in.read(buf);
System.out.print(new String(buf,0,len));
s.close();
}
}
TCP练习:
需求:建立一个文本转换服务器。
客户端给服务端发送文本,服务端会将文本转成大写再发给客户端。
而且客户端可以不断进行文本转换,当客户端输入over时,转换结束。
分析:
客户端:既然是操作设备上的数据,那么就可以使用io技术,并按照Io的操作规律来思考。
源:键盘录入
目的:网络设备,网络输出流。
而且操作的都是文本数据,可以选择字符流。
步骤:
1,建立服务
2,获取键盘录入
3,将数据发给服务端
4,获取服务端返回的大些数据。
5,关闭资源
服务端:
3,将数据发给服务端
4,获取服务端返回的大些数据。
5,关闭资源
package TCP;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TranceServer {
/**
* 服务端:
* 源:socket读取流
* 目的:socket输出流
* 都是文本,装饰
*/
public static void main(String[] args) throws Exception{
ServerSocket ss=new ServerSocket(10028);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println("ip"+ip+"connect...");
//读取socket读取流中的数据
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
//目的:socket输出流。将大些数据写入到socket输出流,并发送给客户端
BufferedWriter bufwOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line=null;
while((line=bufIn.readLine())!=null)
{
System.out.println(line);
bufwOut.write(line.toUpperCase());
bufwOut.newLine();
bufwOut.flush();
}
s.close();
ss.close();
}
}
客户端:
这个列子出现的问题:
现象:客户端和服务端都在莫名的等待。
这是因为他们都有阻塞式的方法,这些方法没有读到结束标记就会一直等,而导致2端都在等待
package TCP;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class TranceClient {
public static void main(String[] args) throws Exception {
Socket s=new Socket("192.168.1.102", 10028);
//定义读取键盘数据的流对象
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
//定义目的,将数据写入到socket输出流,发给服务端
BufferedWriter bufwOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//定义一个socket读取流,读取服务端返回的大些信息
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufwOut.write(line);
bufwOut.newLine();
bufwOut.flush();
String str=bufIn.readLine();
System.out.println("server"+str);
}
bufr.close();
s.close();
}
}
这个列子出现的问题:
现象:客户端和服务端都在莫名的等待。
这是因为他们都有阻塞式的方法,这些方法没有读到结束标记就会一直等,而导致2端都在等待
所以换成PrintWriter更好,他有自带刷新。
package TCP;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TranceServer {
/**
* 服务端:
* 源:socket读取流
* 目的:socket输出流
* 都是文本,装饰
*/
public static void main(String[] args) throws Exception{
ServerSocket ss=new ServerSocket(10028);
Socket s=ss.accept();
String ip=s.getInetAddress().getHostAddress();
System.out.println("ip"+ip+"connect...");
//读取socket读取流中的数据
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
//目的:socket输出流。将大些数据写入到socket输出流,并发送给客户端
// BufferedWriter bufwOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
String line=null;
while((line=bufIn.readLine())!=null)
{
System.out.println(line);
out.println(line.toUpperCase());
// bufwOut.write(line.toUpperCase());
// bufwOut.newLine();
// bufwOut.flush();
//
}
s.close();
ss.close();
}
}
package TCP;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class TranceClient {
public static void main(String[] args) throws Exception {
Socket s=new Socket("192.168.1.102", 10028);
//定义读取键盘数据的流对象
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
//定义目的,将数据写入到socket输出流,发给服务端
// BufferedWriter bufwOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
//定义一个socket读取流,读取服务端返回的大些信息
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
// bufwOut.write(line);
// bufwOut.newLine();
// bufwOut.flush();
out.println(line);
String str=bufIn.readLine();
System.out.println("server"+str);
}
bufr.close();
s.close();
}
}
文件copy练习:
客户端:
客户端:
package TCP;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class TextClient {
public static void main(String[] args) throws Exception {
Socket s=new Socket("192.168.1.102", 10029);
BufferedReader bufr=new BufferedReader(new FileReader("D:\\Android\\workspace\\Net\\src\\IPdemo.java"));
PrintWriter out=new PrintWriter(s.getOutputStream(),true);
// //定义结束标记
// DataOutputStream dos=new DataOutputStream(s.getOutputStream());
// long mark=System.currentTimeMillis();
// dos.writeLong(mark);
String line=null;
while((line=bufr.readLine())!=null)
{
out.println(line);
}
s.shutdownOutput();//关闭客户端的输出流,相当于给流中加入一个结束标记-1
BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
String str=bufIn.readLine();
System.out.println("server"+str);
bufr.close();
s.close();
}
}
服务端:
package TCP;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class TextServer {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(10029);
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println("ip" + ip + "connect...");
// //读取时间戳
// DataInputStream dis=new DataInputStream(s.getInputStream());
// long l=dis.readLong();
BufferedReader bufIn = new BufferedReader(new InputStreamReader(
s.getInputStream()));
PrintWriter out = new PrintWriter(new FileWriter("server.txt"), true);
String line = null;
while ((line = bufIn.readLine())!= null) {
// if("over".equals(line))
// break;
out.println(line);
}
PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
pw.println("上传成功");
out.close();
s.close();
ss.close();
}
}
上传成功!