标签：java socket IP System TCP close new 服务端 客户端

网络的相关概念

网络通信

网络

ip地址

1. 概念:用于唯一标识网络中的每台计算和41主机
2. 查看ip地址:ipconfig
3. ip地址的表示形式:点分十进制 xx.xx.xx.xx
4. 每一个十进制数的范围:0~255
5. ip地址的组成=网络地址+主机地址，比如:192.168.16.69
6. IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每 一粒沙子编上一个地址。
7. 由于IPv4最大的问题在于网络地址资源有限，严重制约了互联网的应用和发展。IPv6的使用，不仅能解决网络地址资源数量的问题，而且也解决了多种接入设备连入互联网的障碍

ipv4地址分类

域名

1. www.baidu.cam
2. 好处:为了方便记忆，解决记ip的困难
3. 概念:将!p地址映射成域名，这里怎么映射上，HTTP协议

• 端口号

1. 概念:用于标识计算机上某个特定的网络程序
2. 表示形式:以整数形式，端口范围0-65535 [2个字节表示端口0~2^16-1]
3. 0~1024已经被占用，比如ssh 22,ftp 21,smtp 25,http 80
   4.常见的网络程序端口号:

• tomcat:8080
• mysql:3306
• oracle:1521
• sqlserver:1433

网络通信协议

TCP/IP(Transmission Control Protocol/Internet Protocol)的简写,中文译名为:传输控制协议/因特网互联协议,又叫网络通讯协议,这个协议是Internet最基本的协议,Internet国际互联网络的基础,简单地说,就是由网络层的IP协议和传输层的TCP协议组成的.

TCP和UDP

TCP协议:传输控制协议

1. 使用TCP协议前，须先建立TCP连接，形成传输数据通道
2. 传输前,采用"三次握手"方式，是可靠的
3. TCP协议进行通信的两个应用进程:客户端、服务端
4. 在连接中可进行大数据量的传输
5. 传输完毕，需释放已建立的连接，效率低
   UDP协议:用户数据协议
6. 将数据、源、目的封装成数据包，不需要建立连接
7. 每个数据报的大小限制在64k内，不适合传输大量数据
8. 因无需连接，故是不可靠的
9. 发送数据结束时无需释放资源(因为不是面向连接的),速度快

InetAddress类

相关方法

1. 获取本机InetAddress对象 getLocalHost
2. 根据指定主机名/域名获取ip地址对象 getByName
3. 获取InetAddress对象的主机名 getHostName
4. 获取InetAddress对象的地址 getHostAddress

案例:

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-16:43
 * @Version 演示InetAddress类的使用
 */
//主机名等价域名对应一个ip(地址)
public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        //1. 获取本机的InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println("localHost = " + localHost);//主机名/ip

        //2. 根据指定  主机名 获取 InetAddress对象
        InetAddress host1 = InetAddress.getByName("WIN-I0Q1644D4PA");
        System.out.println("host1 = " + host1);//主机名/ip

        //3. 根据 域名 获取InetAddress对象
        //亦可根据ip获取InetAddress对象
        InetAddress host2 = InetAddress.getByName("www.baidu.com");
        System.out.println("host2 = " + host2);


        //4. 通过 InetAddress 对象，获取对应的地址
        String address = host2.getHostAddress();
        System.out.println("address = " + address);

        //5. 通过 InetAddress 对象，获取对应的主机名/或者的域名
        String name = host2.getHostName();
        System.out.println("name = " + name);


    }
}

Socket

1. 套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。
2. 通信的两端都要有Socket，是两台机器间通信的端点
3. 网络通信其实就是Socket间的通信。
4. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
5. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

TCP 网络通信编程

1. 基于客户端一服务端的网络通信
2. 底层使用的是TCP/IP协议
3. 应用场景举例:客户端发送数据，服务端接受并显示控制台
4. 基于Socket的TCP编程

补充

1. 当客户端连接到服务器后,实际上客户端也是通过一个端口和服务端进行通讯的,这个端口是TCP/IP来分配的,是不确定的,是随机的
2. 程序验证+netstat

案例一

1. 编写一个服务器端，和一个客户端
2. 服务器端在9999端口监听
3. 客户端连接到服务器端，发送"hello,server"，然后退出
4. 服务器端接收到客户端发送的信息，输出，并退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 服务端
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass());

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接,端口插座(插孔有限)以节约资源
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:25
 * @Version
 * 客户端，发送 "hello, server" 给服务端
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass());

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //关闭流,连接
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例二

1.编写一个服务端，和一个客户端
2.服务器端在9999端口监听
3.客户端连接到服务端，发送”hello, serer"，并接收服务器端回发的 “heilo,client”，再退出
4.服务器端接收到客户端发送的信息，输出，并发送”hello, client"，再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();

        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());

        //设置(输出)结束标记
        socket.shutdownOutput();//若写入后没有再传输可以不设置标记

        //关闭流,连接,端口插座(插孔有限)以节约资源
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,sever".getBytes());

        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
//        socket.shutdownOutput();

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int length;
        while ((length = inputStream.read(buf)) != -1) {
            System.out.println(new String(buf, 0, length));
        }

        //关闭流,连接
        inputStream.close();
        outputStream.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例三

1. 编写一个服务端,和一个客户端
2. 服务端在9999端口监听
3. 客户端连接到服务端,发送"hello,server",并接收服务端回发的"hello,client",在退出
4. 服务端接收到客户端发送的信息,输出,并发送"hello,client",再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:57
 * @Version 字符流方式
 * 服务端:接收客户端发送的消息-->并发送"hello,client"
 */
public class Server {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //在(默认)本机的指定端口建立服务端插座
        //注意:serverSocket监听9999的前提是没有其他服务在监听9999
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,在9999端口监听,并等待连接..");

        //等待连接插入-->若没有连接,程序阻塞-->若连接成功,返回Socket对象,程序继续
        //注意:该方法可返回多个Socket对象->多个客户端连接服务器的并发
        Socket socket = serverSocket.accept();

        //net包下Socket类型
        System.out.println("服务端 socket="+socket.getClass()+"已连接");

        //通过网络连接构造输入流:读取
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //读取后的 写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,client 字符流");


        //设置(输出)结束标记
//      bw.newLine();//若写入后没有再传输可以不设置标记


        //关闭流,连接,端口插座(插孔有限)以节约资源
        bw.close();//写入
        br.close();
        socket.close();
        serverSocket.close();

    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-17:56
 * @Version 字符流方式
 * 客户端:连接服务端-->发送"hello,server"-->接收服务端回发的"hello,client"-->退出
 */
public class Client {
    @SuppressWarnings({"all"})
    public static void main(String[] args) throws IOException {
        //客户端连接到服务端(本机的9999端口)的插座-->若连接成功,返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        //与服务端的连接类型一致
        System.out.println("客户端socket="+socket.getClass()+"已连接");

        //通过网络连接构造输出流:写入
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
        bw.write("hello,server 字符流");


        //设置(输出)结束标记(先写后读不可省略,否则两端都阻塞在数据的传输上)
        bw.newLine();//对应的另一端必须使用readLine!!!
        bw.flush();//刷新以写入

        //写入后的 读取数据
        InputStream inputStream = socket.getInputStream();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));

        System.out.println(br.readLine());

        //关闭流,连接
        br.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出...");
    }
}

案例四(上传文件)

1. 编写一个服务端，和一个客户端
2. 服务器端在8 888端口监听
3. 客户端连接到服务端，发送一张图片e://q i e. p n g
4. 服务器端接收到客户端发送的图片，保存到src下，发送”收到图片”
5. 客户端接收到服务端发送的”收到图片”，再退出
6. 该程序要求使用StreamUtils.java,我们直接使用

public class StreamUtils {
	/**
	 * 功能：将输入流转换成byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];
		int len;
		while((len=is.read(b))!=-1){
			bos.write(b, 0, len);	
		}
		byte[] array = bos.toByteArray();
		bos.close();
		return array;
	}
	/**
	 * 功能：将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){ //当读取到 null时，就表示结束
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 服务端
 * 接收客户端发送的文件-->保存到系统文件目录下-->发送"收到图片"后退出
 */
public class Server {
    public static void main(String[] args) throws Exception {
        //创建字节输出流-->上传到本地
        String filePath = "chapter21\\src\\Copy.wmv";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));

        //服务端监听本机端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端,监听8888端口,等待连接...");

        //等待连接
        Socket socket = serverSocket.accept();

        //连接后创建数据通道的输入流/输出流
        InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = socket.getOutputStream();

        /*byte[] buf = new byte[1024];
        int length;
        //从数据通道的输入流读取到图片数据
        while ((length = inputStream.read(buf)) != -1) {
            //通过字节输出流将数据写入到指定目录下的文件
            bos.write(buf,0,length);
        }*/

        //不使用缓冲数组的先读后写(简化了循环读写)
        byte[] bytes = StreamUtils.streamToByteArray(inputStream);
        bos.write(bytes);

        //从数据通道的输出流写入文本数据
        outputStream.write("收到图片".getBytes());

        //关闭资源
        outputStream.close();
        inputStream.close();
        bos.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-05-19:58
 * @Version 客户端
 * 连接到服务端-->发送磁盘里的文件-->接收到"收到图片"后退出
 */
public class Client {
    public static void main(String[] args) throws Exception {
        //创建字节输入流-->从磁盘读取到内存
        String filePath = "f:\\io\\bufferedCopy.wmv";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //连接到服务端
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);

        //创建数据通道的输出流/输入流
        OutputStream outputStream = socket.getOutputStream();
        InputStream inputStream = socket.getInputStream();


        /*byte[] buf = new byte[1024];
        int length;
        //通过字节输入流从磁盘读取到图片数据
        while ((length = bis.read(buf)) != -1) {
            //通过数据通道的输出流写入图片数据
            outputStream.write(buf,0,length);
        }*/

        //简化版先读后写
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        outputStream.write(bytes);

        //设置传输结束标记
        socket.shutdownOutput();

        /*byte[] bytes = new byte[1024];
        int len;
        //通过数据通道的输入流读取文本数据
        while ((len = inputStream.read(bytes))!=-1) {
            System.out.println(new String(bytes,0,len));
        }*/

        //简化版循环读取打印
        String string = StreamUtils.streamToString(inputStream);
        System.out.println(string);

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

案例五(下载文件)

1. 编写客户端程序和服务器端程序
2. 客户端可以输入一个音乐文件名，比如高山流水，服务端收到音乐名后，可以给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的音乐即可.
3. 客户端收到文件后，保存到本地e:\
4. 提示:该程序可以使用StreamUtils.java
   本质:其实就是指定下载文件的应用

public class StreamUtils {
	/**
	 * 功能：将输入流转换成byte[]
	 * @param is
	 * @return
	 * @throws Exception
	 */
	public static byte[] streamToByteArray(InputStream is) throws Exception{
		ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
		byte[] b = new byte[1024];
		int len;
		while((len=is.read(b))!=-1){
			bos.write(b, 0, len);	
		}
		byte[] array = bos.toByteArray();
		bos.close();
		return array;
	}
	/**
	 * 功能：将InputStream转换成String
	 * @param is
	 * @return
	 * @throws Exception
	 */
	
	public static String streamToString(InputStream is) throws Exception{
		BufferedReader reader = new BufferedReader(new InputStreamReader(is));
		StringBuilder builder= new StringBuilder();
		String line;
		while((line=reader.readLine())!=null){ //当读取到 null时，就表示结束
			builder.append(line+"\r\n");
		}
		return builder.toString();
		
	}

}

public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端,监听9999端口,等待连接...");
        Socket socket = serverSocket.accept();

        //接收文件名
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String musicName = br.readLine();
        System.out.println("客户端点歌:"+musicName);

        String srcPath = "";
        if (musicName.equals("高山流水")) {
            srcPath = "chapter21\\src\\高山流水.mp3";
        } else {
            srcPath="chapter21\\src\\无名.mp3";
        }

        //提取文件数据到数组
        FileInputStream fileInputStream = new FileInputStream(srcPath);
        byte[] data = StreamUtils.streamToByteArray(fileInputStream);

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(data);

        bos.close();
        fileInputStream.close();
        br.close();
        socket.close();
        serverSocket.close();

    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入下载的音乐名");
        String music = sc.next();
        bw.write(music);
        bw.newLine();
        bw.flush();

        InputStream inputStream = socket.getInputStream();
        byte[] data = StreamUtils.streamToByteArray(inputStream);

        String destPath = "";
        if (music.equals("高山流水")) {
            destPath = "f:\\io\\高山流水.mp3";
        } else {
            destPath = "f:\\io\\zxk.mp3";
        }
        FileOutputStream fos = new FileOutputStream(destPath);
        fos.write(data);

        fos.close();
        inputStream.close();
        bw.close();
        socket.close();
        System.out.println("客户端退出");
    }
}

netstat指令

补充:

netstat -anb指令:

查看监听端口的应用:

必须在管理员身份下运行控制台输入指令

UDP 网络通信编程

介绍

1. 类DatagramSocket和DatagramPacket[数据报/数据包]实现了基于UDP协议网络程序。
2. UDP数据报通过数据报套接字DatagramSacket发送和接收,系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
3. DatagramPacket对象封装了UDP数据报，在数据报中包含了发送端的IP地址端口号以及接收端的IP地址和端口号。
4. UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接

基本流程

1. 核心的两个类/对象DatagrarnSocket与DatagramPacket
2. 建立发送端，接收端(没有服务端和客户端概念)
3. 发送数据前，建立数据报 DatagramPacket对象
4. 调用DatagramSocket的发送、接收方法
5. 关闭DatagramSocket

案例

1. 编写一个接收端A，和一个发送端B
2. 接收端A在9999端口等待接收数据(receive)
3. 发送端B向接收端A发送数据”hello，明天吃火锅~”
4. 接收端A接收到发送端B发送的数据，回复"好的，明天见"，再退出
5. 发送端接收回复的数据，再退出

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 接收端A
 */
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9999);

        //创建DatagramPacket对象-->准备接收数据报
        byte[] bytes = new byte[1024];//接收数组
        DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口A,监听9999端口,等待接收...");
        //调用 接收方法, 将通过网络传输的 DatagramPacket 对象,填充到 packet对象
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();
        byte[] data = packet.getData();
        String s = new String(data, 0, length);
        System.out.println(s);

        //创建待发送数据报,并指明接收端的地址和端口
        byte[] buf = "好的明天见".getBytes();
        packet = new DatagramPacket(buf, buf.length,
                InetAddress.getByName("192.168.200.1"), 9998);
        socket.send(packet);

        socket.close();
        System.out.println("A端退出");
    }
}

/**
 * @ClassName
 * @Description
 * @Author zxk
 * @DateTime 2022-02-06-0:53
 * @Version 发送端B
 */
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //创建DatagramSocket对象-->在指定端口接收
        DatagramSocket socket = new DatagramSocket(9998);

        //待发送数据封装到数据报
        byte[] data = "hello,明天吃火锅~".getBytes();
        //待发报中指明接收地址和端口
        DatagramPacket packet = new DatagramPacket(data, data.length,
                InetAddress.getByName("192.168.200.1"), 9999);
        socket.send(packet);

        //创建数据报准备接收
        byte[] bytes = new byte[1024];
        packet = new DatagramPacket(bytes, bytes.length);
        System.out.println("端口B,监听9998端口,等待接收...");
        //调用接收方法填充数据报
        socket.receive(packet);
        //拆包显示
        int length = packet.getLength();//实际接收的数据字节长度
        byte[] buf = packet.getData();//接收到的数据
        String s = new String(buf, 0, length);
        System.out.println(s);


        socket.close();
        System.out.println("B端退出");
    }
}

标签：java,socket,IP,System,TCP,close,new,服务端,客户端
来源： https://blog.csdn.net/jason_bone_/article/details/122870771

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。