high-level——网络编程（12）

最新推荐文章于 2024-06-04 09:57:26 发布
最新推荐文章于 2024-06-04 09:57:26 发布
阅读量211 收藏
点赞数
分类专栏： java编程 java高级 文章标签： java socket 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44628734/article/details/113809940
版权

网络编程

一、通信

  • 两个节点实现相互间的数据传输。

  1. 线程间的通信，比较简单，是指同一进程中的不同线程，线程间共享内存空间，且由同一jvm来进行管理。

    • java线程间的通讯有三种方式，其中之一就是通过流来实现通讯。

      package com.zhong.test_7;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipeTest {
    public static void main(String[] args) {
        PipedInputStream input = new PipedInputStream();
        PipedOutputStream output = new PipedOutputStream();
        //流连接操作
        try {
            input.connect(output);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //启动线程
        new Thread(new Producer(output)).start();
        new Thread(new Consumer(input)).start();

    }

    static class Consumer implements Runnable {//消费者
        private PipedInputStream input;

        public Consumer(PipedInputStream input) {
            this.input = input;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    int count = input.available();//得到输入流中等待读取的数据的数量
                    if (count > 0) {
                        System.out.println("待取用的数据数量：" + count);
                        System.out.println("读出的数据：" + input.read());
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    static class Producer implements Runnable {//生产者
        private PipedOutputStream output;

        public Producer(PipedOutputStream output) {
            this.output = output;
        }

        @Override
        public void run() {
            while (true) {
                for (int i = 0; i < 5; i++) {
                    try {
                        output.write(i);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  2. 进程间的通信，比较复杂，两个进程可以处于不同的主机，操作系统可能不同，它们的内存是独立的。

二、网络编程

  • 在不同的进程间实现通信。
  • 依据通信的方式把现代的软件分成两大部分：
    • C/S 模式，客户/服务器，每个客户都是一个进程，服务器也是一个进程，C表示在客户机上安装的应用程序。（界面可以很复杂，但是客户机需要安装软件），给软件的使用带来了一定的不便。
    • B/S 模式，浏览器/服务器模型，客户机都是通过浏览器与服务器实现通讯，客户机不用安装应用程序。（界面不会太复杂，通讯的效率不高，不需要安装软件，使用很方便）
  • java 应用程序的通信模型：
    • 采用 C/S 的通讯模型。客户的请求与服务器的响应有先后次序，不能颠倒，这样一去一回是一个完整的过程。此过程可以无限的延续下去。

三、通信协议

  • 进程之间通信必须基于某种通信协议来完成。
  • 通信协议是通信双方都应该遵守的规则，它规定了通信双方在数据的格式、速度、先后顺序等方面的一些要求。
  • 通信双方所执行的功能及执行顺序可以用基于OSI标准的七层通讯模型来描述，它概括了几乎所有的通信结构。
  • 从七层模型中抽取出四层，称为通信的四层模型，基本上可以概括 java 程序的通讯结构。

  1. TCP/IP 协议

    • TCP 是传输控制协议，工作在传输层；IP 是网际协议，工作在网络层。
    • TCP是互联网通信的基础协议，它出现的原因就是为互联网的通信提供一种标准。
    • TCP协议的特点：
      1. 它是基于连接的，通信节点之间首选先要建立稳固的连接。
      2. 它是可靠的，可以不中断，完整的，连续的把数据传递给对方。

  2. UDP 协议

    • 数据报通信协议，也称为直连协议。
    • 特点：通信双方不用建立连接，把发送方和接收方的地址都放在数据包中，把数据包向网络上发送，可能会出现丢包。它是不可靠的传输协议。

    总结：以上两个协议都属于底层协议，通信中使用最多的是 TCP 协议。

  3. 通讯端口

    • 同一主机中的不同进程和不同主机间的进程都可以实现通讯，一台主机上有多个进程，为了区分不同的进程，需要给通讯的进程分配一个编号，此编号就是端口号。所以，需要进行通讯的进程都必须要有一个唯一的端口号。端口号由两个字节表示，范围是 0-65535，0-1023 这个范围被一些公共应用程序所占据，所以给程序分配的端口号要大于1023。如果发生冲突将不能正常通讯。

  4. 实现TCP协议通讯的三要素

    • 通讯协议，IP地址，端口号。缺一不可。

四、基于 tcp/ip 协议的通信编程

  1. 需要一个服务器的进程，同时也至少需要一个客户端的进程。
  2. java 的 net 包中提供了两个重要的 api，服务器端需要使用 ServerSocket（服务端套接字），客户端需要使用 Socket（套接字）。
  3. 通信的过程就是数据相互传输的过程，所以服务器和客户端都需要通过网络进行数据的读写，因此基本套接字可以获取用来进行读写操作的流对象。
  4. 如果服务器需要与多个客户端来实现即时通讯，在服务器端需要创建多个线程，每个线程各自负责一个客户端的通信任务。

五、实现单个客户端与服务器的通信

  • public class ServerSocket 类

    • 作用：接收客户端的请求，并创建服务器端与客户端的连接，然后返回一个套接字对象（Socket），服务器使用此套接字对象来与客户端进行数据的读写操作。

  • public class Socket 类

    • 作用：创建客户端的套接字，客户端需要创建一个 Socket 对象，此对象就是客户端套接字，客户端套接字会与服务器端的套接字形成了通信的两个端点。

  • 基本例子：

    package com.zhong.test_7;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerSocketDemo {
    public static void main(String[] args) throws IOException, InterruptedException {
        //创建服务器套接字
        ServerSocket ssk = new ServerSocket(8989);
        System.out.println("服务器在8989端口进行监听……");
        //利用服务器套接字来监听客户端的请求，程序阻塞，等待请求到达
        Socket socket = ssk.accept();
        System.out.println("本地的ip及端口：" + socket.getLocalAddress() + " " + socket.getLocalPort());
        System.out.println("服务器的ip及端口：" + socket.getInetAddress() + " " + socket.getPort());
        //接收到客户端的请求，创建socket套接字对象，获取输入流对象，等待接收客户的数据
        InputStream is = socket.getInputStream();
        System.out.println("已接收到客户端的连接请求，并建立了连接");
        System.out.println("已拿到输入流，等待接收客户端的信息");
        //准备读取客户端的数据
        int len;
        byte[] b = new byte[1024];
        //解除阻塞，处理客户的数据
        len = is.read(b);//程序在此阻塞，等待数据的到达
        System.out.println("客户端说：" + new String(b, 0, len));
        //服务器向客户端回话
        OutputStream os = socket.getOutputStream();
        os.write("你好!".getBytes());
        System.out.println("发送完毕");
        socket.close();
        ssk.close();
    }
}

    package com.zhong.test_7;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class SocketDemo {
    public static void main(String[] args) throws IOException, InterruptedException {
        //创建客户端套接字
        Socket sk = new Socket("127.0.0.1", 8989);
        System.out.println("本地的ip及端口：" + sk.getLocalAddress() + " " + sk.getLocalPort());
        System.out.println("服务器的ip及端口：" + sk.getInetAddress() + " " + sk.getPort());
        //sk创建成功，则两端的连接成功建立
        //得到输出流对象，向服务器发送信息
        OutputStream os = sk.getOutputStream();
        System.out.println("已建立与服务器的连接，向服务器发信息。");
        os.write("hello word!".getBytes());//不会阻塞
        InputStream is = sk.getInputStream();
        byte[] b = new byte[1024];
        int len = is.read(b);//此处会阻塞等待信息到达
        System.out.println("客户端正在等待服务器的信息：");
        System.out.println("服务器说：" + new String(b, 0, len));
        System.out.println(new String(b, 0, len));
        sk.close();
    }
}

  • 文件上传

    package com.zhong.test_7;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class FileServer {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("E:\\IDEA project\\src\\com\\zhong\\test_7\\new.txt");
        ServerSocket ssk = new ServerSocket(2520);
        Socket sk = ssk.accept();
        InputStream is = sk.getInputStream();
        byte[] b = new byte[1024];
        int len;
        System.out.println("等待接收文件…………");
        while ((len = is.read(b)) != -1) {
            fos.write(b, 0, len);
            fos.flush();
        }
        System.out.println("文件接收完毕");
        fos.close();
        sk.close();
    }
}

    package com.zhong.test_7;

import java.io.FileInputStream;
import java.io.IOException;
import java.net.Socket;

public class FileClient {
    public static void main(String[] args) throws IOException {
        Socket sk = new Socket("localhost", 2520);
        FileInputStream fis = new FileInputStream("F:\\我的文件\\常用系统命令及快捷键.txt");
        int len;
        byte[] b = new byte[1024];
        System.out.println("开始发送文件…………");
        while ((len = fis.read(b)) != -1) {
            sk.getOutputStream().write(b, 0, len);
        }
        System.out.println("文件上传完毕");
        fis.close();
        sk.close();
    }
}

  • 互相不间断的发送信息

    package com.zhong.test_7;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class SessionServer {
    public static void main(String[] args) throws IOException {
        ServerSocket ssk = new ServerSocket(8989);
        System.out.println("服务器启动……");
        Socket sk = ssk.accept();
        System.out.println("已有客户连接");
        BufferedReader br = null;
        PrintWriter pw = null;
        String word;
        Scanner sc = new Scanner(System.in);
        while (true) {
            br = new BufferedReader(new InputStreamReader(sk.getInputStream()));
            System.out.println("服务器在等待消息……");
            word = br.readLine();
            System.out.println("客户说：" + word);
            if (word.equals("再见")) break;
            pw = new PrintWriter(sk.getOutputStream(), true);
            System.out.print("服务器说：");
            word = sc.next();//阻塞等待用户输入
            pw.println(word);
            pw.flush();
            if (word.equals("再见")) break;
        }
        pw.close();
        br.close();
        sk.close();
        ssk.close();
    }
}

    package com.zhong.test_7;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class SessionClient {
    public static void main(String[] args) throws IOException {
        Socket sk = new Socket("127.0.0.1", 8989);
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = null;
        BufferedReader br = null;
        String word;
        while (true) {
            pw = new PrintWriter(sk.getOutputStream(), true);
            System.out.print("客户说：");
            word = sc.next();
            pw.println(word);
            pw.flush();
            if (word.equals("再见")) break;
            System.out.println("客户在等待消息……");
            br = new BufferedReader(new InputStreamReader(sk.getInputStream()));
            word = br.readLine();
            System.out.println("服务器说：" + word);
            if (word.equals("再见")) break;
        }
        pw.close();
        br.close();
        sk.close();
    }
}

  • QQ聊天（私聊和群聊）

    package com.zhong.test_8;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;

public class QQServer {
    static private ArrayList<User> userRegister = new ArrayList<>();

    public static void main(String[] args) {//主线程，管理线程
        ServerSocket ssk = null;
        try {
            ssk = new ServerSocket(3434);
            while (true) {
                System.out.println("等待客户端的连接请求……");
                Socket sk = ssk.accept();//sk负责与此次连接的客户端进行通信
                BufferedReader br = new BufferedReader(new InputStreamReader(sk.getInputStream()));
                String userName = br.readLine();
                User user = new User(userName, sk);
                userRegister.add(user);//把sk套接字放到集合中
                new Thread(new UserThread(user)).start();
            }
        } catch (Exception e) {
            System.out.println("有客户断开连接。");
        }
    }

    static private boolean isClose(Socket sk) {//判断是否断开连接
        try {
            sk.sendUrgentData(0xff);
            return false;
        } catch (Exception e) {
            return true;
        }
    }

    //服务端为各用户提供通信服务的用户线程
    //其任务一是接收对应客户端的信息（读），把其他客户端传来的信息发送给本客户端（写）
    static class UserThread implements Runnable {
        private User user;
        private ObjectInputStream readStream;

        public UserThread(User user) throws IOException {
            this.user = user;//本线程接收套接字对象
            readStream = new ObjectInputStream(user.getSk().getInputStream());//创建本线程的输入流对象
        }

        @Override
        public void run() {
            while (true) {
                if (isClose(user.getSk())) {
                    System.out.println("用户" + user.getUserName() + " 已断开！");
                    userRegister.remove(user);
                    return;
                } else {
                    System.out.println(Thread.currentThread().getName() + "等待接收信息");
                    try {
                        Message message = (Message) readStream.readObject();//会阻塞，等待信息的到达
                        System.out.println(message);
                        boolean isExist = false;
                        boolean all = false;
                        //把信息发送给接收方（对应客户端），先拿到对方的Socket，再写回客户端
                        for (User user : userRegister) {
                            if (message.getReceive().equals(this.user.getUserName()) && !message.getReceive().equals("all")) {
                                String date = new SimpleDateFormat("yyyy年/MM月/dd日 HH:mm:ss").format(Calendar.getInstance().getTime());
                                Message msg = new Message("系统", user.getUserName(), "不可以自言自语", date);
                                ObjectOutputStream oos = new ObjectOutputStream(user.getSk().getOutputStream());
                                oos.writeObject(msg);
                                isExist = true;
                                System.out.println("系统给 " + user + " 发了一条一级警告");
                                // oos.close();
                                break;//如果是本线程的套接字，则不发送信息
                            }
                            if (message.getReceive().equals("all")) {//群发
                                ObjectOutputStream writeStream = new ObjectOutputStream(user.getSk().getOutputStream());//得到对方的套接字对象
                                if (!all) {
                                    message.setDate(message.getDate() + " 全体消息");
                                    all = true;
                                }

                                writeStream.writeObject(message);
                                System.out.println(user + "发送信息到了客户端");
                                isExist = true;
                                //  writeStream.close();
                            }
                            if (message.getReceive().equals(user.getUserName())) {//单独发
                                ObjectOutputStream writeStream = new ObjectOutputStream(user.getSk().getOutputStream());//得到对方的套接字对象
                                writeStream.writeObject(message);
                                System.out.println(user + "发送信息到了客户端");
                                isExist = true;
                                //  writeStream.close();
                                break;
                            }
                        }
                        if (!isExist) {
                            String date = new SimpleDateFormat("yyyy年/MM月/dd日 HH:mm:ss").format(Calendar.getInstance().getTime());
                            Message msg = new Message("系统", user.getUserName(), "对不起，查无此人或此人已下线！", date);
                            ObjectOutputStream oos = new ObjectOutputStream(user.getSk().getOutputStream());
                            oos.writeObject(msg);
                            System.out.println("系统给 " + user + " 发了一条二级警告");
                            //  oos.close();
                        }
                    } catch (IOException | ClassNotFoundException e) {
                        e.printStackTrace();
                    }

                }
            }

        }
    }

}

    package com.zhong.test_8;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Scanner;

public class QQClient {
    public static void main(String[] args) throws IOException, ClassNotFoundException {//主线程负责接收信息
        Socket sk = new Socket("127.0.0.1", 3434);//创建客户端套接字，向服务器发首次连接请求
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(sk.getOutputStream(), true);
        System.out.print("请输入您的名字：");
        String userName = sc.next();
        pw.println(userName);
        pw.flush();

        User user = new User(userName, sk);
        ObjectInputStream ois;
        new Thread(new UserWrite(user)).start();//启动写信息的子线程
        while (true) {//主线程中负责接收服务器发来的信息，该信息来源于其他的客户端
            ois = new ObjectInputStream(sk.getInputStream());//得到输入流对象
            Message msg = (Message) ois.readObject();//阻塞，等待信息到达
            System.out.println(msg);
            System.out.print(user.getUserName() + "（你）：");//输出输入提示语
        }
    }

    static class UserWrite implements Runnable {
        private User user;
        private ObjectOutputStream oos;

        public UserWrite(User user) throws IOException {
            this.user = user;
            oos = new ObjectOutputStream(user.getSk().getOutputStream());//创建发信息的输出流对象
        }

        @Override
        public void run() {
            Scanner sc = new Scanner(System.in);//接收用户的输入
            System.out.print("接收人（all表示全体）：");
            String receive = sc.next();
            while (true) {//不断的书写信息并发送
                System.out.print(user.getUserName() + "（你）：");//输出输入提示语
                String word = sc.next();//接收控制台的输入，阻塞
                String date = new SimpleDateFormat("yyyy年/MM月/dd日 HH:mm:ss").format(Calendar.getInstance().getTime());
                //把输入内容封装到信息对象中
                Message msg = new Message(user.getUserName(), receive, word, date);
                try {
                    if (!receive.equals("all"))
                        System.out.println(msg.getSender() + "(" + msg.getDate() + ")：" + msg.getWord());
                    oos.writeObject(msg);//发送信息
                    oos.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}
Æ_华韵流风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
高级综合（high-level-synthesis，HLS）：软件算法在FPGA上实现硬件加速的综合工具
HongkeFPGA的博客
08-14 5574
目录高级综合HLS（high-level-synthesis）：软件算法在FPGA上实现硬件加速的综合工具HLS简述HLS应用背景HLS基本要素HLS优势小结 高级综合HLS（high-level-synthesis）：软件算法在FPGA上实现硬件加速的综合工具 HLS（high-level-synthesis），高级综合，将C/C++/SystemC编写的软体算法综合成RTL编码（VHDL/HDL），以实现软件算法设计的硬件加速和硬件电路设计的抽象级设计&验证。 HLS简述 HLS（High-le
FPGA——HLS编程入门
qq_48008050的博客
05-28 8951
目录一、HLS简介二、HLS与VHDL/Verilog三、HLS优点与局限四、入门级的HLS程序（一）官方教程文档（二）新建工程（三）添加源文件（四）添加 C 仿真文件（五）进行 C 仿真（六）进行C综合（七）联合仿真（八）添加 Directive（九）使用Modelsim 打开联合仿真所产生的波形（十）导出IP核参考资料 一、HLS简介 HLS(High Level Synthesis)：一款高层次综合工具。 能够将 C/C++ 或 者 system C 等高级语言转化为 RTL (底层硬件描述语言)
HDLC（High-Level Data Link Control）（对比以太网）
leixj的博客
12-31 6338
1、HDLC是什么 高级数据链路控制HDLC（High-Level Data Link Control），数据链路层是OSI参考模型的第二层，相当于以太网MAC层。 对物理层没有详细的规定，对数据速率、编码方式、传输介质等没有规定，可以采用光纤CMI、NRZI等编码。 2、HDLC的分类 主要分为两大类，一般使用时只使用某一特定的子集。以太网不同协议在datalink 层也不同，常见的以太网帧结构由ETHERNET II 和 IEEE802.3，详见帧结构一章的图片。 面向字符型 ...
高级语言（High-level programming language）
gongpeng1966的专栏
10-28 2277
高级语言（High-level programming language）是高度封装了的编程语言，与低级语言相对。它是以人类的日常语言为基础的一种编程语言，使用一般人易于接受的文字来表示，使程序编写员编写更容易，亦有较高的可读性，以方便对电脑认知较浅的人亦可以大概明白其内容。由于早期电脑业的发展主要在美国，因此一般的高级语言都是以英语为蓝本。在1980年代，当东亚地区开始使用电脑时，在日本、台湾及
Vivado HLS(High-level Synthesis)笔记八：优化方法综述
h__ang的博客
05-12 2559
一. Optimizing for Throughout 改变吞吐率是通过提高并行度实现的； Pipeline可以作用于函数，也可以作用于循环，当其作用于函数时是连续的，作用于循环时中间有停顿； 二. Optimizing for Latency 三. Optimizing for Area ...
Java并发编程基础
幻化成风
02-13 346
待定
high-level——单例模式和工厂模式（11）
huayunliufeng的博客
02-16 1192
一、单例模式 java设计模式分为三大类，创建型，结构型，行为型 装饰器属于结构型 单例模式属于创建型 单例模式要求某个类的实例在整个应用中只能有一个，实例只能由本类来创建，实例在多线程情况下必须是线程安全的。 在应用中，如果需要某个类的实例只能有一个，比如整个应用都要对同一 个文件进行读写，多个线程要操作同一个变量，多个线程要使用同一个连接对象来操作数据库。 spring 中的 Bean 默认都是单例的。 单例可以节约资源，一是对象的创建只有一 次，节省内存，节省创建和销毁的时
PythonStudy——高级语言 High-level programming language
04-12 486
高级语言 高级语言（High-level programming language）相对于机器语言（machine language，是一种指令集的体系。这种指令集，称机器码（machine code），是电脑的CPU可直接解读的数据）而言。是高度封装了的编程语言，与低级语言相对。它是以人类的日常语言为基础的一种编程语言，使用一般人易于接受的文字来表示（例如汉字、不规则英文或其他外语）...
ESP32-CAM ——Blinker平台
qq_73379310的博客
08-08 6099
ESP32-CAM，点灯云平台Blinker，MQTT协议，APP控制，Wifi视频监控，点灯，控制舵机。
探索终端艺术：terminal-canvas —— 终端画布的魅力
最新发布
gitblog_00042的博客
06-04 287
探索终端艺术：terminal-canvas —— 终端画布的魅力 terminal-canvasManipulate the cursor in your terminal via high-performant, low-level, canvas-like API项目地址:https://gitcode.com/gh_mirrors/te/terminal-canvas 在数字时代，我们常...
High-Level-Synthesis-Flow-on-Zynq-using-Vivado-HLS-master.zip
08-09
《基于Zynq的Vivado HLS高层次综合流——深入理解与实践》 在现代的数字系统设计中，FPGA（Field-Programmable Gate Array）因其灵活性和高性能而被广泛应用。Zynq系列作为Xilinx公司推出的SoC（System on Chip）...
ug902-vivado-high-level-synthesis(1)_high_HLS_vivado的图像处理_ug902_
09-30
Xilinx的Vivado HLS（High-Level Synthesis）工具为开发者提供了一种高效、便捷的设计方法，允许用高级语言（如C、C++或SystemC）编写硬件逻辑，然后自动转换为FPGA的逻辑门级描述。本篇文章将围绕ug902文档中关于...
High-Level Power Estimation and Low-Power
08-31
在电子设计自动化（EDA）领域，特别是在现场可编程门阵列（FPGA）的设计过程中，高功耗问题一直是业界关注的重点。随着集成电路技术的发展，如何在保持甚至提高电路性能的同时降低功耗，成为了一个亟需解决的问题。...
软件框架——dubbo
huayunliufeng的博客
10-30 748
一、dubbo 框架 是一个分布式的服务框架，服务的注册和发现，负载均衡，SPC（远程过程调用）。 二、zookeeper中间件 hadoop，它是基于谷歌关于大数据的三篇论文所设计的一个分布式的大数据处理平台。 论文一：分布式的文件系统，在大数据（P 级以上的数据）领域需要大量的服务器来存放大量的文件，所有的文件必须是安全的，当某台主机上的文件数据破坏后，不至于让此份不可用（一份数据多处存放）。另外，文件集群由一台主机进行管理，该主机中保存有所有文件所存放的地址。在这种集群结构的系统中，如果主机挂
十次方学习——elasticsearch（6）
huayunliufeng的博客
10-30 736
一、ElasticSearch elasticsearch 是一个分布式的搜索引擎，处理速度非常快，基于 Lucenc，使用时要用 restful 风格的接口。 它有三层结构：索引（index）；类型（type）和文档（document）。分别对应关系型数据库的 database，table 和 row。 它运行的端口有两个：9200是 http 协议使用，9300是 tcp 协议使用。 使用： 下载 elasticsearch，尽量使用成熟的版本例如 5.6.8。在bin目录执行命令 elastics
软件框架——简介（1）
huayunliufeng的博客
10-30 668
一、学习一点软件架构的知识 认识 什么是软件架构，就是软件项目的顶层结构，就相当于总体设计图。 为什么需要软件架构？现代的软件功能要求越来越强，规模越来越大，演进越来越快，响应速度越来越高，稳定性越来越强等等。为了满足以上要求，软件设计变得越来越复杂，软件架构就是为了解决软件的复杂性而生的。 什么是软件架构师?它具有丰富的编程实践经验，对普遍性的行业业务有基本的认识，有较扎实的计算机的功底，有良好地沟通能力，有较强的学习能力；在公司内部，它应该是技术权威，它不会去写代码，却要能够指导项目组的技术人员去
low-level——java语言的基本特征（2）
huayunliufeng的博客
02-14 341
java 程序是以类作为基本单位，所有的代码和程序都要写在类中。 一个完整的应用程序或系统至少要有一个 main 方法，它是整个程序的入口，程序的第一行代码就是 main 中的第一行代码。 任何java的代码行都要以 ; 结尾。 类必须在一个文件中，文件名必须与类名相同，可是在一个文件中可以包含多个类，只能有一个类是public（公共）类，那么文件名只能与公共的类名相同。如果多个类都不是公共的，可以取任何一个类的类名。一般情况下习惯一个文件放一个类。如果一个类中还有内部类，则内部类的名称与文件名没有关系。.
high-level——部分数据库知识总结（18）
huayunliufeng的博客
03-01 331
一、数据库的作用 就是数据的仓库，主要作用就是用来存放关系型数据，另外还必须有数据的管理，安全控制，事务机制等方面的一些功能。数据库中的数据存放在磁盘中，属于持久化的数据。 二、数据库的结构 数据库就是磁盘上的一份文件，数据库管理系统是能够对数据进行操作与管理的程序，客户端软件提供了基本界面能够访问，操作和管理数据库。 三、学习数据库的目的和目标 在应用开发中，能够写了正确的命令对数据库中的数据进行增删改查等方面的操作。 四、如何开始使用 mysql 数据库 在安装好数据库管理系统和客户端后，
java 实现简单的端口扫描程序
huayunliufeng的博客
03-19 319
实现思路：使用Socket类的connect(SocketAddress endpoint, int timeout) 方法，测试连接是否超时。使用多线程加快扫描速度。 package com.zhong.exam7; import java.net.InetSocketAddress; import java.net.Socket; import java.net.SocketAddress; import java.util.concurrent.ExecutorService; import jav
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Æ_华韵流风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值