Tom·猫
Tom·猫

【计算机网络】UDP协议编写群聊天室----附代码

UDP构建服务器 x

预备知识

认识UDP协议

此处我们也是对UDP(User Datagram Protocol 用户数据报协议)有一个直观的认识; 后面再详细讨论.

  • 传输层协议
  • 无连接
  • 不可靠传输
  • 面向数据报
网络字节序

我们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分, 磁盘文件中的多字节数据相对于文件中的偏
移地址也有大端小端之分, 网络数据流同样有大端小端之分. 那么如何定义网络数据流的地址呢?

  • 发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出;
  • 接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存;
  • 因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址.
  • TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节.
  • 不管这台主机是大端机还是小端机, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据;
  • 如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可;
   #include 
   uint32_t htonl(uint32_t hostlong);

   uint16_t htons(uint16_t hostshort);

   uint32_t ntohl(uint32_t netlong);

   uint16_t ntohs(uint16_t netshort);
  • 这些函数名很好记,h表示host(本地),n表示network(网络),l表示32位长整数,s表示16位短整数。
  • 例如htonl表示将32位的长整数从主机字节序转换为网络字节序,例如将IP地址转换后准备发送。
  • 如果主机是小端字节序,这些函数将参数做相应的大小端转换然后返回;
  • 如果主机是大端字节序,这些 函数不做转换,将参数原封不动地返回 。
socket编程接口

``// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器) int socket(int domain, int type, int protocol);`

// 绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr *address,socklen_t address_len);*

// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);

// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,socklen_t* address_len);

// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

sockaddr结构

  • Pv4和IPv6的地址格式定义在netinet/in.h中,IPv4地址用sockaddr_in结构体表示,包括16位地址类型, 16位端口号和32位IP地址.1

  • IPv4、 IPv6地址类型分别定义为常数AF_INET、 AF_INET6. 这样,只要取得某种sockaddr结构体的首地址,不需要知道具体是哪种类型的sockaddr结构体,就可以根据地址类型字段确定结构体中的内容.

  • socket API可以都用struct sockaddr *类型表示, 在使用的时候需要强制转化成sockaddr_in; 这样的好处是程序的通用性, 可以接收IPv4, IPv6, 以及UNIX Domain Socket各种类型的sockaddr结构体指针做为参数;

    有sockaddr 结构，sockaddr_in 结构, sockaddr_un 结构

sockaddr_in 结构 用于网络中通讯。

sockaddr_un 结构 用于本地进程间的通信。

我们应该要知道的是，sockaddr 结构，sockaddr_in 结构, sockaddr_un 结构，构成了多态

sockaddr 结构是基类，sockaddr_in 结构, sockaddr_un 结构是衍生类。

我们现在只需要了解sockaddr_in 结构。

【计算机网络】UDP协议编写群聊天室----附代码_第1张图片

构建服务器

初始化服务器

1 .创建socket接口，打开网络文件

2 .给服务器指明IP 和 PORT

3 .bind 将 sockaddr 套接字字段和 网络文件描述符 进行绑定

​

代码：

void Init()
    {
        //1. 创建socket接口，打开网络文件
        _sock=socket(AF_INET,SOCK_DGRAM,0);
        if(_sock==-1)
        {
            std::cerr<<"socket error"<<strerror(errno)<<std::endl;
            exit(SOCKET_ERR);
        }
        std::cout<<"creat socket success:"<<_sock<<std::endl;

        //2.给服务器指明IP 和 PORT
        struct sockaddr_in local;
        memset(&local,0,sizeof(local));
        
        local.sin_family=AF_INET;
        //端口号和IP地址都需要通过网络发送给目标，所以需要转换成网络序列
        local.sin_port=htons(_port);
        //字符串风格的IP需要转换成4字节int   ，1.1.1.1 -》》int

        local.sin_addr.s_addr=INADDR_ANY;//char* 类型的 c_str();
        
        //此时的 local 还只是一个临时变量
        // bind 将 addr套接字字段和 网络文件描述符 进行绑定
       if(bind(_sock,(sockaddr*)&local,sizeof(local))==-1)
       {
        std::cerr<<"bind error"<<strerror(errno)<<std::endl;
        exit(BIND_ERR);
       }
       std::cout<<"bind success"<<std::endl;
    }

到这里，我们服务器的初始化就算成功了，接下来就是启动服务器了.

启动服务器

我们需要接收来自客户端的消息，并将消息进行处理后返回给客户端。

这就意味着，服务器需要有最基础的两项功能，

接收网络消息，并在网络上发送消息

  • 定义一个缓冲区，里面用来存储接收的消息
  • 我们同时也需要知道是谁给我发送的消息，定义一个sockaddr_in 结构，用于保存客户的IP和PORT
  • 最后，将消息返回给客户端

代码：

 void Start()
    {
        char buffer[1024];
        while(true)
        {
            struct sockaddr_in client;
            socklen_t len=sizeof(client);//client是一个接收型参数，存储了给服务器发送消息的客户端的IP+端口号
            
            int n=recvfrom(_sock,buffer,sizeof(buffer)-1,0,(sockaddr*)&client,&len);
            if(n>0) buffer[n]='\0';
            else continue;

            std::string clientIp=inet_ntoa(client.sin_addr);
            int clientport=ntohs(client.sin_port);
            std::cout<<clientIp<<'-'<<clientport<<" "<<"client echo#"<<buffer<<std::endl;

            sendto(_sock,buffer,strlen(buffer),0,(sockaddr*)&client,len);
        }
    }

整个服务端的简易编写就此完成：

代码：

udp_server.hpp

#pragma once 
#include
#include
#include
#include
#include
#include 
#include 
#include"err.hpp"



class UdpServer{
public:

public:
    static const u_int16_t DEFAULT_PORT=8080;
    UdpServer(uint16_t port=DEFAULT_PORT):_port(port)
    {
        std::cout<<"PORT:"<<_port<<std::endl;
    }

    void Init()
    {
        //1. 创建socket接口，打开网络文件
        _sock=socket(AF_INET,SOCK_DGRAM,0);
        if(_sock==-1)
        {
            std::cerr<<"socket error"<<strerror(errno)<<std::endl;
            exit(SOCKET_ERR);
        }
        std::cout<<"creat socket success:"<<_sock<<std::endl;

        //2.给服务器指明IP 和 PORT
        struct sockaddr_in local;
        memset(&local,0,sizeof(local));
        
        local.sin_family=AF_INET;
        //端口号和IP地址都需要通过网络发送给目标，所以需要转换成网络序列
        local.sin_port=htons(_port);
        //字符串风格的IP需要转换成4字节int   ，1.1.1.1 -》》int

        local.sin_addr.s_addr=INADDR_ANY;//char* 类型的 c_str();
        
        //此时的 local 还只是一个临时变量
        // bind 将 addr套接字字段和 网络文件描述符 进行绑定
       if(bind(_sock,(sockaddr*)&local,sizeof(local))==-1)
       {
        std::cerr<<"bind error"<<strerror(errno)<<std::endl;
        exit(BIND_ERR);
       }
       std::cout<<"bind success"<<std::endl;
    }

    void Start()
    {
        char buffer[1024];
        while(true)
        {
            struct sockaddr_in client;
            socklen_t len=sizeof(client);//client是一个接收型参数，存储了给服务器发送消息的客户端的IP+端口号
            
            int n=recvfrom(_sock,buffer,sizeof(buffer)-1,0,(sockaddr*)&client,&len);
            if(n>0) buffer[n]='\0';
            else continue;

            std::string clientIp=inet_ntoa(client.sin_addr);
            int clientport=ntohs(client.sin_port);
            std::cout<<clientIp<<'-'<<clientport<<" "<<"client echo#"<<buffer<<std::endl;

            sendto(_sock,buffer,strlen(buffer),0,(sockaddr*)&client,len);
        }
    }

private:
    int _sock;
    uint16_t _port;

    //std::string _ip;//  云服务器，或者一款服务器，一般不要指明某一个确定的IP, 让我们的udpserver在启动的时候，bind本主机上的任意IP
};

udp_server.cc

#include"udp_server.hpp"
#include
#include

using namespace std;

static void usage(string prc)
{
    cout<<"Usage\n\t"<<prc<<"port\n"<<endl;
}

int main(int argc,char* argv[])
{
    if(argc!=2)
    {
        usage(argv[0]);
        exit(USAGE_ERR);
    }

    uint16_t port=atoi(argv[1]);
    unique_ptr<UdpServer> us(new UdpServer(port));
    us->Init();
    us->Start();
    return 0;
}
客户端简易实现

接下来我们进行客户端的编写，客户端的编写基本按照服务端的端口来进行

现阶段也是只需要向服务端发送消息，接收服务端的消息这两种功能

流程：

  • 创建套接字
  • 我们要向客户端发送消息，需要知道其IP和PORT，所以需要一个sockaddr_in结构，填充的是服务端的信息
  • 然后就是发送消息和接收消息

但是客户端的编写有一些需要注意的地方

1.服务端的端口号和IP地址都sh是需要我们自己绑定的，那么客户端需要吗？
答：客户端也是需要绑定的，但是不需要我们自己手动绑定，而是OS帮我们进行操作。
原因：client的port要随机让OS分配防止client出现启动冲突（例如：我们的手机终端上有很多的软件（客户端），如果自己bind，会可能导致某些服务的端口号被占用，无法启动）

2.服务端为什么需要自己绑定？
原因：
1. server的端口不能随意改变，众所周知且不能随意改变的
2. 同一家公司的port号需要统一规范化

代码：
udp_client.cc

#include
#include
#include
#include
#include
#include 
#include 
#include"err.hpp"
using namespace std;


//127.0.0.1（本地回环） 表示的是当前主机,用于进行本地通讯或者测试
static void Usage(string prc)
{
    cout<<"Usage\t\n"<<prc<<" serverip serverport\n"<<endl;
}

int main(int argc,char* argv[])//./server 目标IP 目标PORT
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    string serverip=argv[1];
    uint16_t serverport=atoi(argv[2]);

   int sock=socket(AF_INET,SOCK_DGRAM,0);
   if(sock<0)
   {
    cerr<<"socket fail"<<strerror(errno)<<endl;
    exit(SOCKET_ERR);
   }


    struct sockaddr_in server;//目标服务器的IP+PORT
    memset(&server,0,sizeof(server));
    server.sin_family=AF_INET;
    server.sin_port=htons(serverport);
    server.sin_addr.s_addr=inet_addr(serverip.c_str());
   
   while(true)
   {
        char buffer[1024];
        cout<<"请输入#";
        cin>>buffer;

     //1. client 这里要不要bind呢？要的！socket通信的本质[clientip:clientport, serverip:serverport]
    // 2.client不需要自己bind，也不要自己bind，操作系统自动给我们进行bind -- 为什么？client的port要随机让OS分配防止client出现启动冲突（我们的手机终端上有很多的软件（客户端），如果自己bind，会可能导致某些服务的端口号被占用，无法启动）
    // 3.server 为什么要自己bind？1. server的端口不能随意改变，众所周知且不能随意改变的 2. 同一家公司的port号需要统一规范化
        sendto(sock,buffer,strlen(buffer),0,(sockaddr*)&server,sizeof(server));

        char Rebuffer[1024];
        sockaddr_in tmp;
        socklen_t len=sizeof(tmp);
       int n=recvfrom(sock,Rebuffer,sizeof(Rebuffer)-1,0,(sockaddr*)&tmp,&len);
        if(n>0) Rebuffer[n]='\0';
        std::cout<<serverip<<'-'<<serverport<<" "<<"server echo#"<<Rebuffer<<std::endl;
   }
    return 0;
}

好需要对错误码进行处理：
err.hpp

#pragma once

enum ERR{
    SOCKET_ERR=1,
    BIND_ERR,
    USAGE_ERR
};

在服务器中，我们实现了一个简单的echo型服务器，就不对消息进行处理，只是进行将消息简单的返回。

实现效果
【计算机网络】UDP协议编写群聊天室----附代码_第2张图片

构建一个群聊系统

在之前建设的服务器基础上，进行加工处理，便可以实现一个简易的群聊功能
我们可以这么理解群聊：

就是你把自己的消息发送给服务器，服务器在转发给每一个在群聊中的人

所以我们需要做如下改动：

  1. 需要一个储存客户消息的容器，把连接过来的客户都sockaddr_in结构保存
  2. 还需要一个缓冲区，保存发送过来的消息
  3. 同时需要注意的是，不同的客户来对同一个缓冲区发送消息，会有多线程并发的问题，需要加锁
  4. 服务器也需要进行多线程化，因为单一进程会阻塞在接收或者发送消息上

组件：
RingQueue.hpp

#pragma once

#include
#include
#include

const int DEFAULT_CAP=10; 
template<class T>
class RingQueue{
public:
    
    RingQueue(int num=DEFAULT_CAP):_cap(num),_rq(num),_consume_step(0),_produce_step(0)
    {
        sem_init(&_consume_sem,0,0);
        sem_init(&_produce_sem,0,_cap);
    }
    ~RingQueue()
    {
        sem_destroy(&_consume_sem);
        sem_destroy(&_produce_sem);
    }
    void lock(pthread_mutex_t& m)
    {
        pthread_mutex_lock(&m);
    }
    void unlock(pthread_mutex_t& m)
    {
        pthread_mutex_unlock(&m);
    }

    void P(sem_t& s)
    {
        sem_wait(&s);
    }
    void V(sem_t& s)
    {
        sem_post(&s);
    }
    void push(const T& in)
    {
        P(_produce_sem);

        lock(_produce_mutex);
        _rq[_produce_step++]=in;
        _produce_step%=_cap;
        unlock(_produce_mutex);

        V(_consume_sem);
        
    }
    void pop(T* out)
    {
        P(_consume_sem);

        lock(_consume_mutex);
        *out=_rq[_consume_step++];
        _consume_step%=_cap;
        unlock(_consume_mutex);

        V(_produce_sem);
    }

private:
    std::vector<T> _rq;
    int _cap;
    //消费者和生产者之间的同步关系通过信号量进行调节
    sem_t _consume_sem;
    sem_t _produce_sem;
    //当多线程运行时，生产者和生产者，消费锁者和消费者之间的互斥关系需要通过锁来维持
    pthread_mutex_t _consume_mutex;
    pthread_mutex_t _produce_mutex;
    int _consume_step;
    int _produce_step;
};

Thread.hpp

#pragma once

#include 
#include 
#include 
#include 
#include 

using namespace std;

string to_hex(uint64_t n)
{
    char arr[32];
    snprintf(arr, sizeof(arr), "0x%x", n);
    return arr;
}
class Thread
{
public:
    // typedef void(*func_t)();
    using func_t = std::function<void()>;
    typedef enum
    {
        NEW = 0,
        RUNNING,
        EXISTED
    } ThreadStatus;

    Thread(int num, func_t func) : _tid(0), _func(func)
    {
        char name[108];
        snprintf(name, sizeof(name), "thread-%d", num);
        _name = name;
        _status = NEW;
    }
    static void *runHelper(void *args)
    {
        Thread *ts = (Thread *)args;
        ts->_func();
        return nullptr;
    }

    void run()
    {
        int n = pthread_create(&_tid, nullptr, runHelper, this);
        if (n != 0)
        {
            exit(1);
        }
        _status = RUNNING;
    }

    int get_status()
    {
        return _status;
    }
    void join()
    {
        int n = pthread_join(_tid, nullptr);
        if (n != 0)
            exit(2);
        cout << _name << " "
             << "has joined" << endl;
        _status = EXISTED;
    }
    const string &get_name()
    {
        return _name;
    }
    string get_id()
    {
        return to_hex(_tid);
    }
    // pthread_t get_id()
    // {
    //     return _tid;
    // }

    ~Thread()
    {
    }

private:
    pthread_t _tid;
    string _name;
    ThreadStatus _status;
    func_t _func;
    // void* _args;//函数调用时需要传的参数
};

err.hpp

#pragma once

enum ERR{
    SOCKET_ERR=1,
    BIND_ERR,
    USAGE_ERR
};

代码：
udp_server.hpp

#pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "RingQueue.hpp"
#include "LockGuard.hpp"
#include "Thread.hpp"
#include "err.hpp"

using func_t = std::function<std::string(std::string)>;

class UdpServer
{
public:
public:
    static const u_int16_t DEFAULT_PORT = 8080;
    UdpServer(uint16_t port = DEFAULT_PORT) : _port(port)
    {
        std::cout << "PORT:" << _port << std::endl;
        pthread_mutex_init(&_lock, nullptr);

        // p=new Thread(1,);
        p = new Thread(1, std::bind(&UdpServer::Receive, this));
        c = new Thread(1, std::bind(&UdpServer::send, this));
    }

    void Start()
    {
        // 1. 创建socket接口，打开网络文件
        _sock = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sock == -1)
        {
            std::cerr << "socket error" << strerror(errno) << std::endl;
            exit(SOCKET_ERR);
        }
        std::cout << "creat socket success:" << _sock << std::endl;

        // 2.给服务器指明IP 和 PORT
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));

        local.sin_family = AF_INET;
        // 端口号和IP地址都需要通过网络发送给目标，所以需要转换成网络序列
        local.sin_port = htons(_port);
        // 字符串风格的IP需要转换成4字节int   ，1.1.1.1 -》》int

        local.sin_addr.s_addr = INADDR_ANY; // char* 类型的 c_str();

        // 此时的 local 还只是一个临时变量
        //  bind 将 addr套接字字段和 网络文件描述符 进行绑定
        if (bind(_sock, (sockaddr *)&local, sizeof(local)) == -1)
        {
            std::cerr << "bind error" << strerror(errno) << std::endl;
            exit(BIND_ERR);
        }
        std::cout << "bind success" << std::endl;

        p->run();
        c->run();
    }

    void Add_user(std::string ip, int port, struct sockaddr_in user)
    {
        std::string name = ip + " + " + to_string(port);
        LockGuard lockguard(&_lock);
        _online[name] = user;
    }

    void Receive()
    {
        char buffer[1024];
        while (true)
        {
            struct sockaddr_in client;
            socklen_t len = sizeof(client); // client是一个接收型参数，存储了给服务器发送消息的客户端的IP+端口号

            int n = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (sockaddr *)&client, &len);
            if (n > 0)
                buffer[n] = '\0';
            else
                continue;

            std::string clientIp = inet_ntoa(client.sin_addr);
            int clientport = ntohs(client.sin_port);
            Add_user(clientIp, clientport, client);
            _rq.push(buffer);
            std::cout << clientIp << '-' << clientport << " "<< "client echo#" << buffer << std::endl;
        }
    }

    void send()
    {
        while (true)
        {
            std::string message;
            _rq.pop(&message);

            LockGuard lockguard(&_lock);
            //访问临界资源，需要锁
            for (auto &user : _online)
            {
                sendto(_sock, message.c_str(), strlen(message.c_str()), 0, (sockaddr *)&user.second, sizeof(user.second));
            }
        }
    }

    ~UdpServer()
    {
        pthread_mutex_destroy(&_lock);

        p->join();
        c->join();
    }

private:
    int _sock;
    uint16_t _port;
    func_t _server;
    std::unordered_map<std::string, sockaddr_in> _online;
    RingQueue<std::string> _rq;
    pthread_mutex_t _lock;
    Thread *p;
    Thread *c;

    // std::string _ip;//  云服务器，或者一款服务器，一般不要指明某一个确定的IP, 让我们的udpserver在启动的时候，bind本主机上的任意IP
};

udp_server.cc

#include "udp_server.hpp"
#include 
#include 

using namespace std;

static void usage(string prc)
{
    cout << "Usage\n\t" << prc << "port\n"
         << endl;
}


bool isPass(const string &command)
{
    bool pass = true;
    auto pos = command.find("rm");
    if (pos != std::string::npos)
        pass = false;
    pos = command.find("mv");
    if (pos != std::string::npos)
        pass = false;
    pos = command.find("while");
    if (pos != std::string::npos)
        pass = false;
    pos = command.find("kill");
    if (pos != std::string::npos)
        pass = false;
    return pass;
}
string excuteCommand(const string &s)
{
    // 可能有些人会传递一些比较恶劣的代码，如rm ，所以我们需要进行安全检查
    if (!isPass(s))
        return "you are a bad man!";

    FILE *fp = popen((s.c_str()), "r");
    if (fp == NULL)
        return "None";
    // 获取结果
    string result;
    char line[2048];
    while (fgets(line, sizeof(line), fp) != NULL)
    {
        result += line;
    }
    pclose(fp);

    return result;
}

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        usage(argv[0]);
        exit(USAGE_ERR);
    }

    uint16_t port = atoi(argv[1]);
    // unique_ptr us(new UdpServer(excuteCommand,port));
    unique_ptr<UdpServer> us(new UdpServer(port));

    us->Start();
    return 0;
}

udp_client.cc

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "Thread.hpp"
#include "err.hpp"
#include 

using namespace std;

// 127.0.0.1（本地回环） 表示的是当前主机,用于进行本地通讯或者测试
static void Usage(string prc)
{
    cout << "Usage\t\n"
         << prc << " serverip serverport\n"
         << endl;
}

void *recver(void *args)
{
    int sock = *(static_cast<int *>(args));

    while (true)
    {
        // 接受
        char buffer[2048];
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        int n = recvfrom(sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&temp, &len);
        if (n > 0)
        {
            buffer[n] = 0;
            std::cout << buffer << std::endl; // 1
        }
    }
}

int main(int argc, char *argv[]) //./server 目标IP 目标PORT
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        cerr << "socket fail" << strerror(errno) << endl;
        exit(SOCKET_ERR);
    }

    struct sockaddr_in server; // 目标服务器的IP+PORT
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    pthread_t tid;
    pthread_create(&tid, nullptr, recver, &sock);

    while (true)
    {
        char buffer[1024];
        cout << "请输入#";
        // cin>>buffer;
        cin.getline(buffer, 1024);

        // 1. client 这里要不要bind呢？要的！socket通信的本质[clientip:clientport, serverip:serverport]
        // 2.client不需要自己bind，也不要自己bind，操作系统自动给我们进行bind -- 为什么？client的port要随机让OS分配防止client出现启动冲突（我们的手机终端上有很多的软件（客户端），如果自己bind，会可能导致某些服务的端口号被占用，无法启动）
        // 3.server 为什么要自己bind？1. server的端口不能随意改变，众所周知且不能随意改变的 2. 同一家公司的port号需要统一规范化
        sendto(sock, buffer, strlen(buffer), 0, (sockaddr *)&server, sizeof(server));
    }
    return 0;
}

展示效果：

【计算机网络】UDP协议编写群聊天室----附代码_第3张图片

你可能感兴趣的:(计算机网络,计算机网络,udp,单片机)

  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • 计算机网络八股总结 Petrichorzncu 八股总结计算机网络笔记
    这里写目录标题网络模型划分（五层和七层）及每一层的功能五层网络模型七层网络模型（OSI模型）==三次握手和四次挥手具体过程及原因==三次握手四次挥手TCP/IP协议组成==UDP协议与TCP/IP协议的区别==Http协议相关知识网络地址，子网掩码等相关计算网络模型划分（五层和七层）及每一层的功能五层网络模型应用层：负责处理网络应用程序，如电子邮件、文件传输和网页浏览。主要协议包括HTTP、FTP
  • metaRTC/webRTC QOS 方案与实践 metaRTC metaRTC解决方案webrtcqos
    概述质量服务(QOS/QualityofService)是指利用各种技术方案提高网络通信质量的技术，网络通信质量需要解决下面两个问题：网络问题：UDP/不稳定网络/弱网下的丢包/延时/乱序/抖动数据量问题：发送数据量超带宽负载和平滑发送拥塞控制是各种技术方案的数据基础，丢包恢复解决丢包问题，抗乱序抖动解决网络乱序抖动问题，流量控制解决平滑发送数据/数据超带宽负载/延时问题。拥塞控制(Congest
  • 51单片机——I2C总线存储器24C02的应用 老侯（Old monkey） 51单片机嵌入式硬件单片机
    目标实现功能单片机先向24C02写入256个字节的数据，再从24C02中一次读取2个字节的数据、并在数码管上动态显示，直至读完24C02中256个字节的数据。1.I2C总线简介I2C总线有两根双向的信号线，一根是数据线SDA,另一根是时钟线SCL。I2C总线通过上拉电阻接正电源，因此，当总线空闲时为高电平。2.I2C通信协议起始信号、停止信号由主机发出。在数据传送时，当时钟线为高电平时，数据线上的
  • 嵌入式单片机中数码管基本实现方法 嵌入式开发星球 单片机项目实战操作之优秀单片机
    1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
  • 4×4矩阵键盘详解（STM32） 辰哥单片机设计 STM32传感器教学矩阵计算机外设stm32嵌入式硬件单片机传感器
    目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
  • nfs服务搭建 GHope
    nfs是什么？基哥度娘网络文件系统(NFS)是sun微系统最初开发的分布式文件系统协议,[1]允许客户端计算机上的用户通过计算机网络访问文件很像本地存储被访问。NFS与许多其他协议一样,在开放网络计算远程过程调用(很久以前RPC)系统上建立。NFS是在请求注释(RFC)中定义的开放标准,允许任何人实现协议。NFSNFS优势：节省本地存储空间，将常用的数据存放在一台NFS服务器上且可以通过网络访问，
  • 学单片机怎么在3-5个月内找到工作？ 无际单片机编程 单片机嵌入式开发物联网stm32c语言
    每个初学者，都如履薄冰，10几年前，我自学单片机时，也一样。想通过学习，找一份体面点的工作，又害怕辛辛苦苦学出来，找不到工作。好在，当初执行力，还算可以，自学java没成功，后面自学单片机，成功入行了。转眼间，毕业到现在有13年了，马上也到了奔4的年纪。这13年一直在跟单片机打交道，打过工，创过业，对行业，对企业，都有一定的认知，坚持看完这篇内容，相信能帮你少走几个月弯路。有些老铁，加了我很久，时
  • 计算机网络基础 柒公子c
    1通信协议1.1定义通信协议（communicationsprotocol）是指双方实体完成通信或服务所必须遵循的规则和约定。协议定义了数据单元使用的格式，信息单元应该包含的信息与含义，连接方式，信息发送和接收的时序，从而确保网络中数据顺利地传送到确定的地方。在计算机通信中，通信协议用于实现计算机与网络连接之间的标准，网络如果没有统一的通信协议，电脑之间的信息传递就无法识别。通信协议是指通信各方事
  • Java-网络 胡净 java网络开发语言
    Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。1.网络协议Java支持多种网络协议，最常用的包括：TCP（传输控制协议）：面向连接的协议，确保数据的可靠传输。UDP（用户数据报协议）：无连接的协议，适用于对速度要求高但对可靠性要求低的应用。网络通信模型通常指的是OSI（开放系统互联）模型，它将网络通信分为七个层次。每一层
  • 网络工程师学习笔记（一） 专业白嫖怪 网络工程师学习笔记学习笔记网络
    为了备战下半年的软考——网络工程师，利用每天的下班的闲暇时间看书听课，然后自己手敲整理的系列资料。希望能够对你们有所帮助第一章__计算机网络概述计算机网络的定义：将分散的具有独立运算功能的计算机系统，通过通信线路和通信设备进行连接起来的实现资源的共享。ARPAnet网络的特征：资源共享、分散控制、分组交换1946年第一台通用计算机—埃尼亚克能够相互连通进行数据交换。1960年提出巨型网络，出现了对
  • 51单片机：P3.3口输入/P 1口输出实验 li星野 单片机
    51单片机：P3.3口输入/P1口输出实验一、实验内容1P3.3口做输入口，外接一脉冲,每输入一个脉冲,P1口按十六进制除2（乘2）。2.P1口做输出口，P1口接的8个发光二极管L1—L8按十六进制除2（乘2）方式点亮。二、仿真图三、代码实现C语言实现：#include#includesbitKEY=P3^3;voiddelay10ms(void);voidmain(){charnum=0xfe;
  • udp的广播，多播，单播 demo mengzhi啊 udp网络
    enumclassEMsgType:uint8_t{EMSGT_SINGLE,//单播EMSGT_MULTICAST,//多播EMSGT_BROADCAST,//广播};sendSocket=newQUdpSocket(this);sendSocket->setSocketOption(QAbstractSocket::MulticastTtlOption,1);sendSocket->bind(
  • 每日刷题Day_15-17 Minamoshizuku 每日刷题
    1.在TCP/IP协议簇中，UDP协议工作在（）。正确答案:B你的答案:B(正确)应用层传输层网络互联层网络接口层2.查看本机的IP配置、子网掩码、网关等信息，可使用下列哪个命令？（）正确答案:D你的答案:D(正确)pingtelnettraceipconfig3.计算机网络有很多功能，最主要的是（）。正确答案:D你的答案:D(正确)电子邮件电子商务WWW资源共享4.在OSI七层模型中，网络层的主
  • 2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
    这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
  • 单片机中断 woainizhongguo. STM32单片机原理解析篇单片机嵌入式硬件
    **在51单片机中，中断向量表的地址是如何被设置的？**在51单片机中，中断向量表的设置是中断系统的核心部分，它定义了中断服务程序的入口地址。以下是中断向量表的设置方法：中断向量表的位置：51单片机的中断向量表通常位于程序存储器的起始位置，即地址0x0000到0x000F（对于双字节的中断向量，实际占用0x0000到0x001F）。这些地址是固定的，由单片机的硬件设计决定。中断向量的分配：每个中断
  • 2021国家开放大学计算机网络安全技术形成性考核五 chaoliang.top 国开试题网络安全网络安全
    本人还会继续更新其他国家开放大学的试题，请大家多多关注，如果有什么建议，还希望大家提出来，本人也好完善本人在测试答案的时候发现，本章考试回顾结果中明明选对了答案，但是提示错误的情况，并且该题没有提示正确答案，这种情况应该是国开试题出现bug导致，请大家不要担心，如果有追求完美的同学，多答几次，可能就会避开这种题，因为出题是随机的。1.SQL注入一般可通过网页表单直接输入选择多项：对错正确答案：对2
  • 基于STC12C5A60S2单片机的LED汉字显示系统的设计 lantiandianzi 单片机嵌入式硬件
    本设计基于单片机的LED汉字显示装置，该设计以STC12C5A60S2单片机为核心，利用最小系统和多个模块完成设计，包括点阵驱动模块、时钟模块、串口通信模块、红外线接收模块以及LED点阵屏。其中，点阵驱动模块采用74HC245芯片设计完成，结合DS1302时钟芯片完成LED点阵显示屏的汉字与时间显示，使用按键、串口、红外线遥控可以完成时间的实时更新、自定义汉字显示、改变汉字显示颜色、改变汉字滚动方
  • 网络编程9.3 江亭棠 网络算法
    使用UDP实现多个客户端与服务器的通信，并在使用connect函数后只有一个客户端能与服务器通信服务器：#include#defineSERPORT9999#defineSERIP"192.168.0.126"intmain(intargc,constchar*argv[]){//1、创建旧的套接字intoldfd=socket(AF_INET,SOCK_DGRAM,0);if(oldfd==-1
  • 51单片机-AT24C02-实验2-秒表实验（可参考上一节） Whappy001 51单片机嵌入式硬件单片机
    利用定时器去对按键和数码管进行扫描(Whappy)main.c#include#include"LCD1602.h"#include"AT24C02.h"#include"Delay.h"#include"Timer0.h"#include"Nixie.h"#include"Key.h"unsignedcharKeyNum;unsignedcharMin,Sec,MiniSec;unsignedc
  • 传输层之UDP协议 厚积薄发ض JavaEEudp网络网络协议
    目录UDP协议报文UDP数据报长度受限问题UDP协议特点UDP协议报文UDP协议特点是,面向数据报,不可靠性传输,无连接,全双工-->传输层协议源端口号源端口号可以理解为从哪个进程发来的.-----源端口号目的端口号目的端口号可以理解为要到哪个进程.----目地端口号两个端口号可以理解为从哪里来(源端口号)到哪里去(目的端口号)包长度整个UDP数据报的长度(包括UDP数据首部长度+UDP载荷(数据
  • TCP和UDP的区别 life_binary Linux网络编程
    TCP和UDP都是传输层的协议TCP面向连接的、可靠地、数据流服务UDP无连接的、不可靠的、数据报服务那么为什么TCP可靠，为什么UDP不可靠呢？也就是是什么保证了TCP是可靠的呢？共有四点原因：1、TCP保证数据都能到达对端。是通过应答确认机制和超时重传机制来保证的。2、TCP保证数据有序。TCP的每一个报文段都有序号3、TCP保证数据不失真。TCP报头有16位的冗余检验码4、滑动窗口和拥塞控制
  • linux 端口数据转发,Linux iptables 端口转发 文静的妹子 linux端口数据转发
    准备：1，UDP端口范围映射2，tcp端口范围映射3，本机端口转发4，单个端口转发准备：打开转发[root@CentOS~]#cat/etc/sysctl.conf|grepnet.ipv4.ip_forwardnet.ipv4.ip_forward=1清空规则，修改默认策略，重要数据请备份[root@CentOS~]#iptables-F-tnat[root@CentOS~]#iptables-
  • 即时通讯开发之TCP/IP中的TCP 协议概述 wecloud1314 tcp/ip网络udp
    终于看到了TCP协议,这是TCP/IP详解里面最重要也是最精彩的部分,要花大力气来读。前面的TFTP和BOOTP都是一些简单的协议,就不写笔记了,写起来也没啥东西。TCP和UDP处在同一层---运输层,但是TCP和UDP最不同的地方是,TCP提供了一种可靠的数据传输服务,TCP是面向连接的,也就是说,利用TCP通信的两台主机首先要经历一个“拨打电话”的过程,等到通信准备结束才开始传输数据,最后结束
  • 微信小程序中的实时通讯：TCP/UDP 协议实现详解 人工智能的苟富贵 前端小程序微信小程序tcp/ipudp
    文章目录前言一、实时通讯的基础知识二、微信小程序中TCP/UDP的支持2.1TCP实现2.2UDP实现三、实现即时通讯的基本架构四、实际开发中的注意事项4.1网络环境问题4.2数据格式与协议设计4.3消息重发机制五、实时通讯中的性能优化5.1减少不必要的通信5.2数据压缩5.3异步通信与心跳机制六、使用场景七、总结前言在现代应用程序中，实时通讯已成为用户体验的关键组成部分。无论是在线聊天、游戏、还
  • 单片机在医疗设备中的应用实例教程 kkchenjj 单片机单片机嵌入式硬件
    单片机在医疗设备中的应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、医疗设备等多个领域。特点集成度高：单片机将计算机的主要部件集成在一块芯片上
  • 单片机与传感器接口技术应用实例教程 kkchenjj 单片机单片机nosql嵌入式硬件
    单片机与传感器接口技术应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、通信设备、医疗器械等领域。特点集成度高：单片机将计算机的主要部件集成在一
  • 网络编程 UDP发送数据 稻田里展望者 Java网络编程udp网络网络协议
    UDP通信原理不可靠的网络协议,在通信的两端各建立一个Socket对象(发送和接收数据)发送数据的步骤1.创建发送端的Socket对象(DatagramSocket)2.创建数据,并把数据打包3.调用DatagramSocket对象的方法发送数据4.关闭发送端//创建发送端的Socket对象(DatagramSocket)DatagramSocketds=newDatagramSocket();/
  • 计算机网络基础2-网络设备 一条无趣的咸鱼
    网络设备中继器中继器：在一种网络中，每一网段的传输媒介均有其最大的传输距离，如细缆最大网段长度为185m,粗缆为500m,双绞线为100m,超过这个长度，传输介质中的数据信号就会衰减。中继器可以“延长”网络的距离，在网络数据传输中起到放大信号的作用。中继器工作于OSI模型的物理层。集线器集线器:对信号进行放大整形，延长网络距离，每个端口都可以与传输介质相连。数据传输是以广播的方式将数据包发送到所有
  • java Illegal overloaded getter method with ambiguous type for propert的解决 zwllxs javajdk
    好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
  • IT人应当知道的10个行业小内幕 beijingjava 工作互联网
    10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。 　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。 　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
  • java 实现自定义链表 CrazyMizzz java数据结构
    1.链表结构   链表是链式的结构 2.链表的组成    链表是由头节点，中间节点和尾节点组成    节点是由两个部分组成：       1.数据域       2.引用域 3.链表的实现 &nbs
  • web项目发布到服务器后图片过一会儿消失 麦田的设计者 struts2上传图片永久保存
      作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
  • CodeIgniter框架Cart类 name 不能设置中文的解决方法 IT独行者 CodeIgniterCart框架　
    今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。 在CI手册里也有说明，如下： $data = array( 'id' => 'sku_123ABC', 'qty' => 1, '
  • linux回收站 _wy_ linux回收站
    今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。     后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
  • jquery回到页面顶端 知了ing htmljquerycss
    html代码： <h1 id="anchor">页面标题</h1> <div id="container">页面内容</div> <p><a href="#anchor" class="topLink">回到顶端</a><
  • B树、B-树、B+树、B*树 矮蛋蛋 B树
    原文地址： http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html B树        即二叉搜索树：        1.所有非叶子结点至多拥有两个儿子（Left和Right）； &nb
  • 数据库连接池 alafqq 数据库连接池
    http://www.cnblogs.com/xdp-gacl/p/4002804.html @Anthor:孤傲苍狼 数据库连接池 用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
  • java泛型 百合不是茶 java泛型
    泛型 在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患   泛型的特点：消除强制转换 确保类型安全 向后兼容   简单泛型的定义：      泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 class fan
  • javascript闭包[两个小测试例子] bijian1013 JavaScriptJavaScript
    一.程序一 <script> var name = "The Window"; var Object_a = { 　　name : "My Object", 　　getNameFunc : function(){ var that = this; 　　　　return function(){ 　　　　
  • 探索JUnit4扩展：假设机制（Assumption） bijian1013 javaAssumptionJUnit单元测试
    一.假设机制（Assumption）概述        理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
  • 【Gson四】范型POJO的反序列化 bit1129 POJO
    在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 String str = new Gson().toJson(data); 得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO   import com.google.gson.Gson; import java.
  • 【Spark八十五】Spark Streaming分析结果落地到MySQL bit1129 Stream
    几点总结： 1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
  • NGINX + LUA实现复杂的控制 ronin47 nginx lua
    安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。 这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
  • java-递归判断数组是否升序 bylijinnan java
    public class IsAccendListRecursive { /*递归判断数组是否升序 * if a Integer array is ascending,return true * use recursion */ public static void main(String[] args){ IsAccendListRecursiv
  • Netty源码学习-DefaultChannelPipeline2 bylijinnan javanetty
    Netty3的API http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 里面提到ChannelPipeline的一个“pitfall”： 如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB） 来
  • Java工具之JPS chinrui java
    JPS使用     熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
  • window.print分页打印 ctrain window
    function init() { var tt = document.getElementById("tt"); var childNodes = tt.childNodes[0].childNodes; var level = 0; for (var i = 0; i < childNodes.length; i++) {
  • 安装hadoop时 执行jps命令Error occurred during initialization of VM daizj jdkhadoopjps
    在安装hadoop时，执行JPS出现下面错误   [slave16][email protected]:/tmp/hsperfdata_hdfs# jps Error occurred during initialization of VM java.lang.Error: Properties init: Could not determine current working
  • PHP开发大型项目的一点经验 dcj3sjt126com PHP重构
    一、变量 最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。 二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
  • android笔记之--向网络发送GET/POST请求参数 dcj3sjt126com android
    使用GET方法发送请求 private static boolean sendGETRequest (String path, Map<String, String> params) throws Exception{ //发送地http://192.168.100.91:8080/videoServi
  • linux复习笔记 之bash shell (3) 通配符 eksliang linux 通配符linux通配符
    转载请出自出处： http://eksliang.iteye.com/blog/2104387 在bash的操作环境中有一个非常有用的功能，那就是通配符。 下面列出一些常用的通配符，如下表所示 符号 意义 * 万用字符，代表0个到无穷个任意字符 ? 万用字符，代表一定有一个任意字符 [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
  • Android关于短信加密 gqdy365 android
    关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）：     1、因为Android有短信收发接口，可以调用接口完成短信收发；         发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
  • asp.net在网站根目录下创建文件夹 hvt .netC#hovertreeasp.netWeb Forms
    假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： string m_keleyiFolderName = Server.MapPath("/hovertree"); if (Directory.Exists(m_keleyiFolderName)) { //文件夹已经存在 return; } else { try { D
  • 一个合格的程序员应该读过哪些书 justjavac 程序员书籍
    编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本， 你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 很多程序员响应，他们在推荐时也写下自己的评语。 以前就有国内网友介绍这个程序员书单，不过都是推荐数
  • 单实例实践 跑龙套_az 单例
       1、内部类 public class Singleton { private static class SingletonHolder { public static Singleton singleton = new Singleton(); } public Singleton getRes
  • PO VO BEAN 理解 q137681467 VODTOpo
    PO：      全称是 persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。     BO：     全称是 business object:业务对象 主要作用是把业务逻辑封装为一个对象。这个对
  • 战胜惰性，暗自努力 金笛子 努力
    偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？ 我有个朋友是搞技术的，平时嘻嘻哈哈，以
  • NDK/JNI二维数组多维数组传递 wenzongliang 二维数组jniNDK
    多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组 用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata) { jint i,j; int s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他