Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

🤡🤡🤡个人主页🤡🤡🤡
🤡🤡🤡JavaEE专栏🤡🤡🤡

1. nervum Datagram (UDP)

1.1 Features

1. Connectionless: Non opus est ut canalem dedicantem instituere antequam notitia transmittatur. Singulae notae fasciculus independenter mittitur et suum iter eligit ut destinatum attingat eget suscipit.
2. Transmissio ambigui: Cum notitia transmittendi, operam dare non debes utrum altera pars acceperit, solum mitte.
3. Profluentia ad data orientatur: Praecipua unitas transmissionis notitiarum UDP datagram singulae est.
4. Plenus duplex: communicatio dupliciter potest in una pagina.

1.2 Encoding

APIs nervum omnia a systemate provisa sunt. APIs a diversis systematibus diversae sunt, sed haec ratio APIs in Java ulteriore encapsulata sunt.
Nervus api in UDP in duas classes collocat: DatagramSocket et DatagramPacket

1.2.1DatagramSocket

Munus huius ordinis remotum imperium haberi potest ad "cardum retis operandum", id est, operationes legendi et scribendi in scheda retis, quae sicut tabulae legendi et scribendi possunt intellegi.
Pluribus modis praebentur:

1.2.2DatagramPacket

Hoc genus datagrams UDP describit. A DatagramPacket obiectum aequipollet UDP datagram.

1.2.3 Implement a UDP (24*7) resonare server

Echo: Cliens varias petitiones servo mittit, et servo diversa responsa reddit. Sed resonare hic est quod clienti petenti servo, et sine calculo aut negotio logicae ministranti respondet.

public class udpEchoServer {
    public DatagramSocket socket = null;
    public udpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    public void  start() throws IOException {
        System.out.println("服务器启动!!!");
        while (true) {
            //接受客户端请求
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacket);
            //为了更好处理数据并方便打印，将接受的数据转化为字符串操作
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            //处理客户端的请求（算术计算或者业务逻辑）
            String response = this.process(request);
            //将处理完的请求返还给客户端
            DatagramPacket resposePacket = new DatagramPacket(response.getBytes(),0,response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(resposePacket);
            //打印客户端的ip地址端口号和接收客户端的数据以及处理完客户端后的数据
            System.out.printf("[%s:%d] req = %s,resp = %sn",requestPacket.getAddress(),requestPacket.getPort(),
                    request,response);
        }
    }
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        udpEchoServer udpEchoServer = new udpEchoServer(9999);
        udpEchoServer.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Objectum DatagramPacket datagram repraesentat. A UDP datagram ex capite et stipendio componitur. IP oratio et numerus portus in capite attributa sunt classis DatagramPacket, sed genus payload non est provisum, ut programmator id facere debet. Dummodo, sicut monachus eleemosynam petens, phialam eleemosynam praebere debes, et tunc unaquaeque familia cibum in phiala ponit .

Notitia accepta a cliente reddi debet clienti postquam processit a servo, ideo objectum DatagramPacket creari debet ut processus notitias a servo reponat, et tunc clienti servo mittat. Hoc tempore, objectum DatagramPacket spatium blank praebere non indiget. Iustus pone notitias processus in hoc obiecto. Cum huius IP oratio et numerus portus referuntur in notitia accepta, solum IP oratio et portus numerus clientium scripta sunt cum eam ad clientem mittens.

Cum servo fixum sit, protinus portum te numerum constitue potes.
Quid opus est numero portui IP inscriptionis?
Ut feliciter inter duas partes communicatio, hi quattuor nuclei indices praesentes esse debent;
Fons portus, fons IP, destinatio portus, destinatio IP
Per quattuor nucleos his indicibus, communicatio reticularis inter duas partes potest effici. IP uti possumus ad significandum 172.0.0.1, etiam nota IP loopback.

1.2.4 deducendi UDP clientem

public class udpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverProt;
    public  udpEchoClient(String serverIp, int serverProt) throws SocketException {
        socket = new DatagramSocket();
        this.serverIp = serverIp;
        this.serverProt = serverProt;
    }
    public void start() throws IOException {
        System.out.println("客户端启动!");
        //1.从控制台获取字符串
        Scanner scanner = new Scanner(System.in);
        while(true) {
            System.out.println("请输入要发送的请求: ");
            String request = scanner.nextLine();
            //2.将输入的字符串发送给服务器,还要将发送的目标确定，IP和端口号
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), 0, request.getBytes().length,
                    InetAddress.getByName(serverIp), serverProt);
            socket.send(requestPacket);
            //3.从服务器读取到经过处理的响应
            DatagramPacket responsePackt = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePackt);
            //将响应打印在控制台
            String response = new String(responsePackt.getData(), 0, responsePackt.getLength());
            System.out.println(response);
        }
    }
    public static void main(String[] args) throws IOException {
        udpEchoClient udpEchoClient = new udpEchoClient("127.0.0.1",9999);
        udpEchoClient.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Nam chorda a console recepta, obiectum petendi fasciculum obtinet respectum et longitudinem objecti chordi, tum suum IP et Prot, tum emittit servo per modum nervus mittendi.

Ut responsionem accipias a servo, responsumPackt rem creare debes et blank byte ordinata in antecessum ad responsionem a servo receptam recipiendam.
Distingue aliquos modos;
Priusquam methodos distinguas, conceptus bytes, ingenia et formas descriptas comprehendere oportet
Bytes et characteres essentialiter sunt binarii, quae data sicut 0101, quod computatorium solum 0101A cognoscit.
Byte: Byte est unitas fundamentalis pro repono notitiarum computatrorum. 1 byte est 8 minuta.
Moribus: Character est fundamentalis unitas ad informationem textuum repraesentandam. Secundum varias formas descriptas, numerus bytes cum charactere varius respondet notitia et copia data.
Formam descriptam:

1. ASCII code: repraesentabat ingenia Latina.Utitur 7 frenis ad repraesentandum 128 characteres (including casus superiores et inferiores litteras, numeros, notas et notas aliquas temperantiae), sed characteribus Sinensibus non sustinet
2. Unicode (UTF8): UTF-8 est forma variabilis et longitudo descripta, quae characteres ab omnibus systematibus scribendis circum orbem includit characteribus 1-4 respondet.
3. GBK: longitudo variabilis utitur modum translitterandi, maxime propter characterem Seres modum translitterandi, unus character respondet 1-2 bytes

Modi sunt diversi;

1. getBytes (): Respicientiam ad byte ordinata. Obiectum est character. Hic, characteres in bytes convertuntur ut notitias congregem.
2. getBytes (). longitudo accipe longitudinem byte ordinata obiectum character
3. GetData(): Quod obtinetur, filum ex characteribus compositum est. Obiectum est bytes.
4. getLength(): longitudo chordae consecuti, obiectum bytes
5. getAddress(): IP oratio obtine, obiectum DatagramPacket
6. getPort (): numerum portum posside Prot, obiectum DatagramPacket
7. getSocketAddress(): IP oratio et Prot portum numerum obtine, obiectum DatagramPacket
8. InetAddress.getByName(): Haec methodus nomen hospitii parse potest et nomen IP inscriptionis hospitii reddere, vel directe reddere obiectum InetAddress data IP oratio IP nacti hanc rem.

1.2.5 Exsequere UDP dictionary translation server

Hic notiones hereditatis et polymorphismi applicare possumus ad hunc servitorem efficiendum, quia essentialis differentia inter hoc glossarium translationis servientis et servo resonantis est processus responsionum, itaque codicem repetitum possidemus et reuse possumus et codicem inquisitum ampliare.

public class udpDictServer extends udpEchoServer{
    HashMap<String,String> map = null;
    public udpDictServer(int port) throws SocketException {
        super(port);
        map = new HashMap<>();
        map.put("server","服务");
        map.put("client","客户端");
        map.put("cat","🐱");
        map.put("dog","🐕");
        map.put("pig","🐖");
    }
    @Override
    public String process(String request) {
        return map.getOrDefault(request, "该词汇没有查询到");
    }

    public static void main(String[] args) throws IOException {
        udpDictServer udpDictServer = new udpDictServer(9999);
        udpDictServer.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Ad translationem hoc glossarium efficiendum, tabula etiam in structura data opus est, et clavis pretii paria in tabula ad notitias reponendas utere.

Tunc operationes specificae negotiorum tantum processus methodi rescribere necesse est.

Cum hic exsequens, licet hoc ad udpEchoServer obiectum parentis ordinis referat, quia genus udpDictServer genus parentis udpEchoServer possidet et modum processus vincit, processus methodus exsecutus propter polymorphicum genus est actu processus generis.

2. Client et servo processus

1. Get notitia ex console
2. Clientem mittit data servo
3. Servo accipit notitia a client
4. Adice responsum
5. Calculus in calculo responsum misit servo ad clientem
6. Cliens responsum a servo accipit
7. Imprimendi responsionem missam a servo a cliente ad consolem acceptam