ipconfig

ping 空格 IP地址

ping 220.181.57.216

package com.atguigu.ip;

import java.net.InetAddress;

import java.net.UnknownHostException;

import org.junit.Test;

public class TestInetAddress {

    @Test

    public void test01() throws UnknownHostException{

        InetAddress localHost = InetAddress.getLocalHost();

        System.out.println(localHost);

    }

    @Test

    public void test02()throws UnknownHostException{

        InetAddress atguigu = InetAddress.getByName("www.atguigu.com");

        System.out.println(atguigu);

    }

    @Test

    public void test03()throws UnknownHostException{

//		byte[] addr = {112,54,108,98};

        byte[] addr = {(byte)192,(byte)168,24,56};

        InetAddress atguigu = InetAddress.getByAddress(addr);

        System.out.println(atguigu);

    }

}

public class TCPTest1 {

    // 客户端

    @Test

    public void client() {

        Socket socket = null;

        OutputStream os = null;

        try {

            // 1. 创建 Socket 对象，指明服务器端的 ip 和端口号

            InetAddress inet = InetAddress.getByName("10.28.234.139"); // 服务器端的 ip 地址

            int port = 8989; // 服务器端的端口号

            socket = new Socket(inet, port); // 创建 Socket 对象，指明服务器端的 ip 和端口号

            // 2. 获取一个输出流，用于输出数据

            os = socket.getOutputStream(); // 字节输出流

            os.write("你好，我是客户端".getBytes()); // 将数据写出到字节输出流

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            // 3. 关闭资源（Socket、字节流）

            try {

                if (os != null) {

                    os.close(); // 关闭输出流

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

            try {

                if (socket != null) {

                    socket.close(); // 关闭 Socket

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

    // 服务端

    @Test

    public void server() {

        ServerSocket serverSocket = null;

        Socket socket = null; // 阻塞式监听，等待客户端连接，一旦连接，就返回一个 Socket 对象

        InputStream is = null; // 字节输入流

        try {

            // 1. 创建 ServerSocket，指明自己的端口号

            int port = 8989;

            serverSocket = new ServerSocket(port);

            // 2. 调用 accept () 表示接收来自于客户端的 socket

            socket = serverSocket.accept();

            System.out.println("服务器端接收到了客户端" + socket.getInetAddress().getHostAddress() + "的连接");

            // 3. 获取输入流，并读取客户端信息

            is = socket.getInputStream();

            byte[] buffer = new byte[5]; // 字节数组

            int len; // 每次读取的字节长度

            ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 内部维护了一个 byte [] 数组

            System.out.println("服务器端接收到的数据为：");

            while ((len = is.read(buffer)) != -1) {

                // 以下是错误写法，可能会因为客户端、服务器端的字符集不同而出现中文字符的乱码（因为字节数组 buffer 的长度可能不是恰好能够存储一个中文字符的）

//                String str = new String (buffer, 0, len); // 将字节数组转换为字符串

//                System.out.print(str);

                // 正确写法，借助 ByteArrayOutputStream，因为它的 toString () 方法是通过指定的字符集来转换的

                baos.write(buffer, 0, len); // 将字节数组写入到字节数组输出流中

            }

            System.out.println(baos.toString()); // 将字节数组输出流转换为字符串

            System.out.println("\n数据接收完毕");

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            // 4. 关闭资源（ServerSocket，Socket，字节流）

            try {

                if (is != null) {

                    is.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

            try {

                if (socket != null) {

                    socket.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

            try {

                if (serverSocket != null) {

                    serverSocket.close();

                }

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }

}

服务器端接收到了客户端10.28.234.139的连接

服务器端接收到的数据为：

你好，我是客户端

数据接收完毕

public class TCPTest2 {

    /**

     * 客户端

     * 注意：这里只是为了演示清晰才直接 throws 异常，实际建议使用 try-catch-finally，以确保关闭资源

     *

     * @throws IOException

     */

    @Test

    public void client() throws IOException {

        // 1. 创建 Socket 对象，指明服务器端的 ip 和端口号

        InetAddress inet = InetAddress.getByName("127.0.0.1");

        int port = 9090;

        Socket socket = new Socket(inet, port);

        // 2. 创建 File、FileInputStream 的实例

        File file = new File("paper.jpg");

        FileInputStream fis = new FileInputStream(file);

        // 3. 通过 Socket 获取一个输出流，用于输出数据

        OutputStream os = socket.getOutputStream();

        // 4. 将数据写出到输出流中

        byte[] buffer = new byte[1024];

        int len;

        while ((len = fis.read(buffer)) != -1) {

            os.write(buffer, 0, len);

        }

        System.out.println("文件发送成功");

        // 5. 关闭资源（Socket、相关流）

        os.close();

        fis.close();

        socket.close();

    }

    /**

     * 服务端

     * 注意：这里只是为了演示清晰才直接 throws 异常，实际建议使用 try-catch-finally，以确保关闭资源

     *

     * @throws IOException

     */

    @Test

    public void server() throws IOException {

        // 1. 创建 ServerSocket 对象，指明自己的端口号

        int port = 9090;

        ServerSocket serverSocket = new ServerSocket(port);

        // 2. 调用 accept () 方法，表示接收来自于客户端的 socket

        Socket socket = serverSocket.accept();

        // 3. 通过 socket 获取一个输入流，用于读取数据

        InputStream is = socket.getInputStream();

        // 4. 创建 File、FileOutputStream 的实例

        File file = new File("paper_copy.jpg");

        FileOutputStream fos = new FileOutputStream(file);

        // 5. 将数据写入到文件中

        byte[] buffer = new byte[1024];

        int len;

        while ((len = is.read(buffer)) != -1) {

            fos.write(buffer, 0, len);

        }

        System.out.println("文件接收成功");

        // 6. 关闭资源（ServerSocket、Socket 和相关流）

        fos.close();

        is.close();

        socket.close();

        serverSocket.close();

    }

}

public class TCPTest3 {

    /**

     * 客户端

     * 注意：这里只是为了演示清晰才直接 throws 异常，实际建议使用 try-catch-finally，以确保关闭资源

     *

     * @throws IOException

     */

    @Test

    public void client() throws IOException {

        // 1. 创建 Socket 对象，指明服务器端的 ip 和端口号

        InetAddress inet = InetAddress.getByName("127.0.0.1");

        int port = 9090;

        Socket socket = new Socket(inet, port);

        // 2. 创建 File、FileInputStream 的实例

        File file = new File("paper.jpg");

        FileInputStream fis = new FileInputStream(file);

        // 3. 通过 Socket 获取一个输出流，用于输出数据

        OutputStream os = socket.getOutputStream();

        // 4. 将数据写出到输出流中

        byte[] buffer = new byte[1024];

        int len;

        while ((len = fis.read(buffer)) != -1) {

            os.write(buffer, 0, len);

        }

        System.out.println("文件发送成功");

        // 客户端表明不再发送数据

        socket.shutdownOutput(); // 重要！！！

        // 5. 等待接收服务器端的消息，需要通过 socket 获取一个输入流

        InputStream is = socket.getInputStream();

        ByteArrayOutputStream baos = new ByteArrayOutputStream(); // 为了防止中文乱码

        byte[] buffer1 = new byte[1024];

        int len1;

        while ((len1 = is.read(buffer1)) != -1) {

            baos.write(buffer1, 0, len1);

        }

        System.out.println(baos.toString());

        // 6. 关闭资源（Socket、相关流）

        baos.close();

        is.close();

        os.close();

        fis.close();

        socket.close();

    }

    /**

     * 服务端

     * 注意：这里只是为了演示清晰才直接 throws 异常，实际建议使用 try-catch-finally，以确保关闭资源

     *

     * @throws IOException

     */

    @Test

    public void server() throws IOException {

        // 1. 创建 ServerSocket 对象，指明自己的端口号

        int port = 9090;

        ServerSocket serverSocket = new ServerSocket(port);

        // 2. 调用 accept () 方法，表示接收来自于客户端的 socket

        Socket socket = serverSocket.accept();

        // 3. 通过 socket 获取一个输入流，用于读取数据

        InputStream is = socket.getInputStream();

        // 4. 创建 File、FileOutputStream 的实例

        File file = new File("paper_copy1.jpg");

        FileOutputStream fos = new FileOutputStream(file);

        // 5. 将数据写入到文件中

        byte[] buffer = new byte[1024];

        int len;

        while ((len = is.read(buffer)) != -1) {

            fos.write(buffer, 0, len);

        }

        System.out.println("文件接收成功");

        // 6. 服务端发送 “接收成功” 给客户端，需要通过 socket 获取一个输出流

        OutputStream os = socket.getOutputStream();

        os.write("你的图片我喜欢".getBytes());

        // 7. 关闭资源（ServerSocket、Socket 和相关流）

        os.close();

        fos.close();

        is.close();

        socket.close();

        serverSocket.close();

    }

}

package com.atguigu.tcp.one;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

public class Server {

    public static void main(String[] args)throws Exception {

        //1、准备一个 ServerSocket 对象，并绑定 8888 端口

        ServerSocket server =  new ServerSocket(8888);

        System.out.println("等待连接....");

        //2、在 8888 端口监听客户端的连接，该方法是个阻塞的方法，如果没有客户端连接，将一直等待

        Socket socket = server.accept();

        InetAddress inetAddress = socket.getInetAddress();

        System.out.println(inetAddress.getHostAddress() + "客户端连接成功！！");

        //3、获取输入流，用来接收该客户端发送给服务器的数据

        InputStream input = socket.getInputStream();

        // 接收数据

        byte[] data = new byte[1024];

        StringBuilder s = new StringBuilder();

        int len;

        while ((len = input.read(data)) != -1) {

            s.append(new String(data, 0, len));

        }

        System.out.println(inetAddress.getHostAddress() + "客户端发送的消息是：" + s);

        //4、获取输出流，用来发送数据给该客户端

        OutputStream out = socket.getOutputStream();

        // 发送数据

        out.write("欢迎登录".getBytes());

        out.flush();

        //5、关闭 socket，不再与该客户端通信

        //socket 关闭，意味着 InputStream 和 OutputStream 也关闭了

        socket.close();

        //6、如果不再接收任何客户端通信，可以关闭 ServerSocket

        server.close();

    }

}

package com.atguigu.tcp.one;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.Socket;

public class Client {

    public static void main(String[] args) throws Exception {

        // 1、准备 Socket，连接服务器，需要指定服务器的 IP 地址和端口号

        Socket socket = new Socket("127.0.0.1", 8888);

        // 2、获取输出流，用来发送数据给服务器

        OutputStream out = socket.getOutputStream();

        // 发送数据

        out.write("lalala".getBytes());

        // 会在流末尾写入一个 “流的末尾” 标记，对方才能读到 - 1，否则对方的读取方法会一致阻塞

        socket.shutdownOutput();

        //3、获取输入流，用来接收服务器发送给该客户端的数据

        InputStream input = socket.getInputStream();

        // 接收数据

        byte[] data = new byte[1024];

        StringBuilder s = new StringBuilder();

        int len;

        while ((len = input.read(data)) != -1) {

            s.append(new String(data, 0, len));

        }

        System.out.println("服务器返回的消息是：" + s);

        //4、关闭 socket，不再与服务器通信，即断开与服务器的连接

        //socket 关闭，意味着 InputStream 和 OutputStream 也关闭了

        socket.close();

    }

}

package com.atguigu.tcp.many;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintStream;

import java.net.ServerSocket;

import java.net.Socket;

public class Server {

    public static void main(String[] args) throws IOException {

        // 1、准备一个 ServerSocket

        ServerSocket server = new ServerSocket(8888);

        System.out.println("等待连接...");

        int count = 0;

        while(true){

            // 2、监听一个客户端的连接

            Socket socket = server.accept();

            System.out.println("第" + ++count + "个客户端"+socket.getInetAddress().getHostAddress()+"连接成功！！");

            ClientHandlerThread ct = new ClientHandlerThread(socket); // 为每个客户端连接分配一个线程去处理

            ct.start();

        }

        // 这里没有关闭 server，永远监听

    }

    static class ClientHandlerThread extends Thread{

        private Socket socket;

        private String ip;

        public ClientHandlerThread(Socket socket) {

            super();

            this.socket = socket;

            ip = socket.getInetAddress().getHostAddress();

        }

        public void run(){

            try{

                //（1）获取输入流，用来接收该客户端发送给服务器的数据

                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));

                //（2）获取输出流，用来发送数据给该客户端

                PrintStream ps = new PrintStream(socket.getOutputStream());

                String str;

                // （3）接收数据

                while ((str = br.readLine()) != null) {

                    //（4）反转

                    StringBuilder word = new StringBuilder(str);

                    word.reverse();

                    //（5）返回给客户端

                    ps.println(word);

                }

                System.out.println("客户端" + ip+"正常退出");

            }catch(Exception  e){

                System.out.println("客户端" + ip+"意外退出");

            }finally{

                try {

                    //（6）断开连接

                    socket.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

package com.atguigu.tcp.many;

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintStream;

import java.net.Socket;

import java.util.Scanner;

public class Client {

    public static void main(String[] args) throws Exception {

        // 1、准备 Socket，连接服务器，需要指定服务器的 IP 地址和端口号

        Socket socket = new Socket("127.0.0.1", 8888);

        // 2、获取输出流，用来发送数据给服务器

        OutputStream out = socket.getOutputStream();

        PrintStream ps = new PrintStream(out);

        // 3、获取输入流，用来接收服务器发送给该客户端的数据

        InputStream input = socket.getInputStream();

        BufferedReader br;

        if(args!= null && args.length>0) {

            String encoding = args[0];

            br = new BufferedReader(new InputStreamReader(input,encoding));

        }else{

            br = new BufferedReader(new InputStreamReader(input));

        }

        Scanner scanner = new Scanner(System.in);

        while(true){

            System.out.println("输入发送给服务器的单词或成语：");

            String message = scanner.nextLine();

            if(message.equals("stop")){

                socket.shutdownOutput();

                break;

            }

            // 4、 发送数据

            ps.println(message);

            // 接收数据

            String feedback  = br.readLine();

            System.out.println("从服务器收到的反馈是：" + feedback);

        }

        //5、关闭 socket，断开与服务器的连接

        scanner.close();

        socket.close();

    }

}

package com.atguigu.tcp;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.PrintStream;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.ArrayList;

public class TestChatServer {

	// 这个集合用来存储所有在线的客户端

	static ArrayList<Socket> online = new  ArrayList<Socket>();

	public static void main(String[] args)throws Exception {

		//1、启动服务器，绑定端口号

		ServerSocket server = new ServerSocket(8989);

		//2、接收 n 多的客户端同时连接

		while(true){

			Socket accept = server.accept();

			online.add(accept);// 把新连接的客户端添加到 online 列表中

			MessageHandler mh = new MessageHandler(accept);

			mh.start();//

		}

	}

	static class MessageHandler extends Thread{

		private Socket socket;

		private String ip;

		public MessageHandler(Socket socket) {

			super();

			this.socket = socket;

		}

		public void run(){

			try {

				ip = socket.getInetAddress().getHostAddress();

				// 插入：给其他客户端转发 “我上线了”

				sendToOther(ip+"上线了");

				//(1) 接收该客户端的发送的消息

				InputStream input = socket.getInputStream();

				InputStreamReader reader = new InputStreamReader(input);

				BufferedReader br = new BufferedReader(reader);

				String str;

				while((str = br.readLine())!=null){

					//(2) 给其他在线客户端转发

					sendToOther(ip+":"+str);

				}

				sendToOther(ip+"下线了");

			} catch (IOException e) {

				try {

					sendToOther(ip+"掉线了");

				} catch (IOException e1) {

					e1.printStackTrace();

				}

			}finally{

				// 从在线人员中移除我

				online.remove(socket);

			}

		}

		// 封装一个方法：给其他客户端转发 xxx 消息

		public void sendToOther(String message) throws IOException{

			// 遍历所有的在线客户端，一一转发

			for (Socket on : online) {

				OutputStream every = on.getOutputStream();

				// 为什么用 PrintStream？目的用它的 println 方法，按行打印

				PrintStream ps = new PrintStream(every);

				ps.println(message);

			}

		}

	}

}

package com.atguigu.tcp;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintStream;

import java.net.Socket;

import java.util.Scanner;

public class TestChatClient {

	public static void main(String[] args)throws Exception {

		//1、连接服务器

		Socket socket = new Socket("127.0.0.1",8989);

		//2、开启两个线程

		//(1) 一个线程负责看别人聊，即接收服务器转发的消息

		Receive receive = new Receive(socket);

		receive.start();

		//(2) 一个线程负责发送自己的话

		Send send = new Send(socket);

		send.start();

		send.join();// 等我发送线程结束了，才结束整个程序

		socket.close();

	}

}

class Send extends Thread{

	private Socket socket;

	public Send(Socket socket) {

		super();

		this.socket = socket;

	}

	public void run(){

		try {

			OutputStream outputStream = socket.getOutputStream();

			// 按行打印

			PrintStream ps = new PrintStream(outputStream);

			Scanner input = new Scanner(System.in);

			// 从键盘不断的输入自己的话，给服务器发送，由服务器给其他人转发

			while(true){

				System.out.print("自己的话：");

				String str = input.nextLine();

				if("bye".equals(str)){

					break;

				}

				ps.println(str);

			}

			input.close();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

}

class Receive extends Thread{

	private Socket socket;

	public Receive(Socket socket) {

		super();

		this.socket = socket;

	}

	public void run(){

		try {

			InputStream inputStream = socket.getInputStream();

			Scanner input = new Scanner(inputStream);

			while(input.hasNextLine()){

				String line = input.nextLine();

				System.out.println(line);

			}

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

}

public class UDPTest {

    // 发送端

    @Test

    public void sender() throws Exception {

        // 1. 创建 DatagramSocket 对象

        DatagramSocket ds = new DatagramSocket();

        // 2. 创建 DatagramPacket 对象，封装数据，指定目的地的 IP 和端口号

        InetAddress inetAddress = InetAddress.getByName("127.0.0.1");

        int port = 9090;

        byte[] bytes = "你好，我是UDP方式发送的数据".getBytes("utf-8");

        DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, inetAddress, port);

        // 3. 调用 DatagramSocket 对象的 send 方法，发送数据

        ds.send(packet);

        // 4. 关闭资源

        ds.close();

    }

    // 接收端

    @Test

    public void receiver() throws Exception {

        // 1. 创建 DatagramSocket 对象，指定端口号

        int port = 9090;

        DatagramSocket ds = new DatagramSocket(port);

        // 2. 创建 DatagramPacket 对象，用于接收数据

        byte[] buffer = new byte[1024 * 64]; // 64KB

        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        // 3. 调用 DatagramSocket 对象的 receive 方法，接收数据

        ds.receive(packet);

        // 4. 读取数据并打印

        String str = new String(packet.getData(), 0, packet.getLength(), "utf-8");

        System.out.println(str);

        // 5. 关闭资源

        ds.close();

    }

}

DatagramSocket ds = null;

try {

    ds = new DatagramSocket();

    byte[] by = "hello,atguigu.com".getBytes();

    DatagramPacket dp = new DatagramPacket(by, 0, by.length,     InetAddress.getByName("127.0.0.1"), 10000);

    ds.send(dp);

} catch (Exception e) {

    e.printStackTrace();

} finally {

    if (ds != null)

        ds.close();

}

DatagramSocket ds = null;

try {

    ds = new DatagramSocket(10000);

    byte[] by = new byte[1024*64];

    DatagramPacket dp = new DatagramPacket(by, by.length);

    ds.receive(dp);

    String str = new String(dp.getData(), 0, dp.getLength());

    System.out.println(str + "--" + dp.getAddress());

} catch (Exception e) {

    e.printStackTrace();

} finally {

    if (ds != null)

        ds.close();

}

package com.atguigu.udp;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.util.ArrayList;

public class Send {

    public static void main(String[] args)throws Exception {

//		1、建立发送端的 DatagramSocket

        DatagramSocket ds = new DatagramSocket();

        // 要发送的数据

        ArrayList<String> all = new ArrayList<String>();

        all.add("尚硅谷让天下没有难学的技术！");

        all.add("学高端前沿的IT技术来尚硅谷！");

        all.add("尚硅谷让你的梦想变得更具体！");

        all.add("尚硅谷让你的努力更有价值！");

        // 接收方的 IP 地址

        InetAddress ip = InetAddress.getByName("127.0.0.1");

        // 接收方的监听端口号

        int port = 9999;

        // 发送多个数据报

        for (int i = 0; i < all.size(); i++) {

//			2、建立数据包 DatagramPacket

            byte[] data = all.get(i).getBytes();

            DatagramPacket dp = new DatagramPacket(data, 0, data.length, ip, port);

//			3、调用 Socket 的发送方法

            ds.send(dp);

        }

//		4、关闭 Socket

        ds.close();

    }

}

package com.atguigu.udp;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

public class Receive {

    public static void main(String[] args) throws Exception {

//		1、建立接收端的 DatagramSocket，需要指定本端的监听端口号

        DatagramSocket ds = new DatagramSocket(9999);

        // 一直监听数据

        while(true){

            //2、建立数据包 DatagramPacket

            byte[] buffer = new byte[1024*64];

            DatagramPacket dp = new DatagramPacket(buffer,buffer.length);

            //3、调用 Socket 的接收方法

            ds.receive(dp);

            //4、拆封数据

            String str = new String(dp.getData(),0,dp.getLength());

            System.out.println(str);

        }

//        ds.close();

    }

}

URL url = new URL("http://localhost:8080/examples/myTest.txt");

System.out.println("getProtocol() :"+url.getProtocol());

System.out.println("getHost() :"+url.getHost());

System.out.println("getPort() :"+url.getPort());

System.out.println("getPath() :"+url.getPath());

System.out.println("getFile() :"+url.getFile());

System.out.println("getQuery() :"+url.getQuery());

getProtocol() :http

getHost() :localhost

getPort() :8080

getPath() :/examples/myTest.txt

getFile() :/examples/myTest.txt

getQuery() :null

/**

 * 将 URL 代表的资源下载到本地

 *

 * @throws MalformedURLException

 */

@Test

public void test2() throws MalformedURLException {

    HttpURLConnection conn = null;

    InputStream is = null;

    FileOutputStream fos = null;

    try {

        //1. 创建 URL 实例

        URL url = new URL("http://localhost:8080/examples/myTest.txt");

        //2. 调用 URL 的 openConnection () 方法，获取 HttpURLConnection 的实例，此时才真正建立连接

        conn = (HttpURLConnection) url.openConnection();

        //3. 获取输入流，创建本地文件输出流

        is = conn.getInputStream();

        fos = new FileOutputStream(new File("dest.txt"));

        //4. 读取输入流中的数据，写入到本地文件中

        byte[] buffer = new byte[1024];

        int len;

        while ((len = is.read(buffer)) != -1) {

            fos.write(buffer, 0, len);

        }

        System.out.println("文件下载成功");

    } catch (IOException e) {

        e.printStackTrace();

    } finally {

        //5. 关闭资源

        try {

            if (fos != null) {

                fos.close();

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        try {

            if (is != null) {

                is.close();

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

        conn.disconnect(); // 断开连接

    }

}