java 网络编程

aweb:网页编程 B/S
网络编程:TCP/IP C/S

网络通信的要素通信双方地址：

ip
端口号

规则：网络通信协议

TCP/IP参考模型：

ip地址:InetAddress

唯一定位一台网络计算机
127.0.0.1 本机localhost
ip地址的分类
- ipv4/ipv6
- 公网(互联网)
- 私网(局域网)

TCP

client（客户端）
步骤：
1 创建客户端Socket,构造器（ip,port)
2使用getOuputStream 获取输出流
3使用getOutputStream方法write，往服务器发送数据
4使用Socket中的getInputStream获得输入流对象
5使用InputStream中的read方法，读取服务器返回的数据
6释放资源

注意：
1 客户端和服务端交互时，必须使用Socket中的流
2客户端请求服务端要经过3次握手
3如果服务端没有启动，就会报不能连接java.net.ConnectException: Connection refused: connect
4如果已经启动，就可以交互了

//客户端
public class ClientText {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            //本机地址
            InetAddress name = InetAddress.getByName("127.0.0.1");
            //端口号
            int port = 9999;
            //创建socket连接
            socket = new Socket(name,port);
            os= socket.getOutputStream();
            os.write("java".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                os.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}

service（服务端）
步骤：
1 创建服务器ServerSocket套接字
2调用accept获得客户端的socket对象
3使用socket的getInputStream获得输入流
4调用read的方法读取客户端发送的数据
5使用socket的getOutputStream获得输出流
6调用write的方法写出数据给客户端
7释放资源

//服务端
public class ServiceText {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream inputStream = null;
        ByteArrayOutputStream baos = null;
        try {
            //需要有一个地址
            serverSocket = new ServerSocket(9999);
            accept = serverSocket.accept();
            inputStream = accept.getInputStream();

            //管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int length;
            while ((length=inputStream.read(buffer))!=-1){
                baos.write(buffer,0,length);
            }
            System.out.println(baos.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                baos.close();
                inputStream.close();
                accept.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

UDP(发送端和接收端)

//没有客户端和服务端的概念，这样只是便于理解，两边可以相互发送
public class UDPClient {
    public static void main(String[] args) throws IOException {
        //建立spcket
        DatagramSocket soc = new DatagramSocket();
        //建包
        String str="会很尴尬附件";
        byte[] b = str.getBytes();
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;

        //包装信息
        DatagramPacket packet = new DatagramPacket(b, b.length, localhost, port);

        //发送
        soc.send(packet);

        //关闭流
        soc.close();
    }
}

public class UDPService {
    public static void main(String[] args) throws IOException {
        //端口
        DatagramSocket socket = new DatagramSocket(9090);
        //接收数据包
        byte[] b = new byte[1024];
        DatagramPacket packet = new DatagramPacket(b, 0, b.length);
        socket.receive(packet);

        System.out.println(new String(packet.getData(),0,packet.getLength()));

        socket.close();
    }
}

文件上传

服务端

//服务端
public class ServiceText {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(9999);
            Socket socket = serverSocket.accept();
            InputStream inputStream = socket.getInputStream();

            //文件输出
            FileOutputStream fileOutputStream = new FileOutputStream(new File("1.PNG"));
            byte[] b = new byte[1024];
            int len;
            while ((len=inputStream.read(b))!=-1){
                fileOutputStream.write(b,0,len);
            }

            //写出信息到客户端
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("接收完成".getBytes());

            //关闭资源
            outputStream.close();
            fileOutputStream.close();
            inputStream.close();
            socket.close();;

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端

//客户端
public class ClientText {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",9999);
        FileInputStream fileInputStream = new FileInputStream(new File("C:\Users\杰爸爸\Desktop\捕获.PNG"));

        OutputStream outputStream = socket.getOutputStream();
        //写出文件
        byte[] b = new byte[1024];
        int len;
        while ((len=fileInputStream.read(b))!=-1){
            outputStream.write(b,0,len);
        }

        
        socket.shutdownOutput();

        //接收服务端传来的信息
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] b2 = new byte[1024];
        int len2;
        while ((len2=inputStream.read(b2))!=-1){
            baos.write(b2,0,len2);
        }
        System.out.println(baos.toString());

        //关闭资源
        baos.close();
        inputStream.close();
        outputStream.close();
        fileInputStream.close();
        socket.close();
    }
}

文件上传加线程

public class TCPClient {
	public static void main(String[] args) throws IOException {
		//a创建FileInputStream,构造器里面要传入一个文件实例 
		FileInputStream fis = new FileInputStream("C:\Users\杰爸爸\Desktop\hello1.jpg");
		
		//b创建一个Socket对象，构造器里面有IP和端口号
		Socket sc = new Socket("127.0.0.1",8888);
	
		//使用Socket的getOutputStream,获得OutputStream对象
		OutputStream os = sc.getOutputStream();
		//使用FileInputStream，读取桌面上的一个图片文件
		int len = 0;
		byte[] b = new byte[1024];
		while((len = fis.read(b)) >0) {
			//使用OutputStream的write方法，上传文件到服务器
			os.write(b, 0, len);
		}
		
		
		sc.shutdownOutput();
		//使用getInputStream,获得InputStream对象
		InputStream is = sc.getInputStream();
		//调用read()获得服务端返回的数据
		while((len = is.read(b)) >0) {
			System.out.println(new String(b,0,len));
		}		
		//关闭资源
		fis.close();
		sc.close();
	}
}

public class TCPServer {
	public static void main(String[] args) throws IOException {
		//创建服务端的套接字 ServerSocket(port)
		ServerSocket ss = new ServerSocket(8888);
		
		//也可以用线程池
		//ExecutorService service = Executors.newFixedThreadPool(5);
		
		//b调用accept方法，获得客户端对象
		Socket sc = ss.accept();
		
		//需要创建一个对象
		Upload up = new Upload(sc);
		
		//提交任务
		//service.submit(up);
		
		//使用一个线程类来完成动作
		Thread t = new Thread(up);
		
		//启动线程
		t.start();		
	}
}

public class Upload implements Runnable{
	private Socket sc;

	public Upload(Socket sc) {
		this.sc=sc;
	}

	@Override
	public void run() {
		// d715文件夹存在吗？不存在就创建
		File file = new File("C:\715");
				
				
		// 使用Socket的getInputStream,获得InputStream对象
		try (InputStream is = sc.getInputStream(); 
			FileOutputStream fos = new FileOutputStream(file + "\"+UUID.randomUUID().toString().subSequence(0, 8)+".jpg");) {
			if (!file.exists()) {
				file.mkdirs();
			}

			// 使用FileInputStream的read方法，读取客户端文件
			int len = 0;
			byte[] b = new byte[1024];
			while ((len = is.read(b)) > 0) {
				// 使用FileOutputStream的Write方法，读取的资源写到硬盘上
				fos.write(b, 0, len);
			}

			// h使用Socket的getOutputStream,获得OutputStream对象
			OutputStream os = sc.getOutputStream();
			// i调用OutputStream的write方法，写出 上传成功
			os.write("上传成功".getBytes());
		}catch (IOException e) {
			e.printStackTrace();
		}

	}

		}

使用多线程实现聊天

public class TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            //准备数据  控制台读取
            reader = new BufferedReader(new InputStreamReader(System.in));

        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                String data = reader.readLine();
                byte[] dataBytes = data.getBytes();
                DatagramPacket packet = new DatagramPacket(dataBytes,0,dataBytes.length,new InetSocketAddress(this.toIP,this.toPort));
                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private int port;
    private String msgForm;

    public TalkReceive(int port, String msgForm) {
        this.port = port;
        this.msgForm = msgForm;

        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                //准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);
                //如果输入bye就断开连接
                byte[] data = packet.getData();
                String s = new String(data, 0, data.length);
                System.out.println(msgForm+"："+s);
                if(s.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

public class TalkStudent {
    public static void main(String[] args) {
        new Thread(new TalkSend(7777,"localhost",9999)).start();
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555,"localhost",8888)).start();
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

URL

public class URLAndConnection {
	public static void main(String[] args) throws IOException {
		//URL 统一资源定位符：它指向在互联网资源哪一个位置。这个资源可以是任意的文件，比如图片、视频、音频等
		//URL(String spec)  从 String表示形成一个 URL对象
		URL url=new URL("https://video-qn.51miz.com/preview/video/00/00/11/55/V-115507-CA837843.mp4");
		URLConnection con = url.openConnection();
		
		//边读边写
		try(InputStream in=con.getInputStream();
			OutputStream out=new FileOutputStream("C:\Users\杰爸爸\Desktop\1.mp4")	
			) {
			
			int len=0;
			byte[] b=new byte[1024];
			while((len=in.read(b))>0) {
				out.write(b, 0, len);
			}
			System.out.println("另存为完成");
			
		} catch (Exception e) {
			e.printStackTrace();
		}		
	}
}

编码

public class TestEncodeAndDecode {
	public static void main(String[] args) throws IOException {
		//当URL地址栏包含非西欧编码的字符时，会自动编码成16进制的符号
		//译码
		String str = "%E5%A4%A9%E5%AE%89%E9%97%A8";
		String decode = URLDecoder.decode(str, "UTF-8");
		System.out.println("解码后的字符串："+decode);
		
		//编码
		String encode = URLEncoder.encode("天安门", "UTF-8");
		System.out.println("编码后的字符串："+encode);
	}
}

java 网络编程

Java相关栏目本月热门文章