转载请注明出处：http://blog.csdn.net/luotuo44/article/details/39670221

本文从简单到复杂。展示怎样使用libevent。网上的很多样例都是仅仅有server端的，本文里面client和server端都有，以飨读者。

关于libevent编程时的一些疑问能够阅读《libevent编程疑难解答》。假如读者还想了解libevent的详细实现，能够阅读《libevent源代码分析》系统文章。

不说这么多了。直接上代码。

初等：

client代码：

  1. #include<sys/types.h>
  2. #include<sys/socket.h>
  3. #include<netinet/in.h>
  4. #include<arpa/inet.h>
  5. #include<errno.h>
  6. #include<unistd.h>
  7.  
  8. #include<stdio.h>
  9. #include<string.h>
  10. #include<stdlib.h>
  11.  
  12. #include<event.h>
  13. #include<event2/util.h>
  14.  
  15. int tcp_connect_server(const char* server_ip, int port);
  16.  
  17. void cmd_msg_cb(int fd, short events, void* arg);
  18. void socket_read_cb(int fd, short events, void *arg);
  19.  
  20. int main(int argc, char** argv)
  21. {
  22.     if( argc < 3 )
  23.     {
  24.         printf("please input 2 parameter\n");
  25.         return -1;
  26.     }
  27.  
  28.     //两个參数依次是服务器端的IP地址、端口号
  29.     int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));
  30.     if( sockfd == -1)
  31.     {
  32.         perror("tcp_connect error ");
  33.         return -1;
  34.     }
  35.  
  36.     printf("connect to server successful\n");
  37.  
  38.     struct event_base* base = event_base_new();
  39.  
  40.     struct event *ev_sockfd = event_new(base, sockfd,
  41.                                         EV_READ | EV_PERSIST,
  42.                                         socket_read_cb, NULL);
  43.     event_add(ev_sockfd, NULL);
  44.  
  45.     //监听终端输入事件
  46.     struct event* ev_cmd = event_new(base, STDIN_FILENO,
  47.                                       EV_READ | EV_PERSIST, cmd_msg_cb,
  48.                                       (void*)&sockfd);
  49.  
  50.     event_add(ev_cmd, NULL);
  51.  
  52.     event_base_dispatch(base);
  53.  
  54.     printf("finished \n");
  55.     return 0;
  56. }
  57.  
  58. void cmd_msg_cb(int fd, short events, void* arg)
  59. {
  60.     char msg[1024];
  61.  
  62.     int ret = read(fd, msg, sizeof(msg));
  63.     if( ret <= 0 )
  64.     {
  65.         perror("read fail ");
  66.         exit(1);
  67.     }
  68.  
  69.     int sockfd = *((int*)arg);
  70.  
  71.     //把终端的消息发送给服务器端
  72.     //为了简单起见。不考虑写一半数据的情况
  73.     write(sockfd, msg, ret);
  74. }
  75.  
  76. void socket_read_cb(int fd, short events, void *arg)
  77. {
  78.     char msg[1024];
  79.  
  80.     //为了简单起见，不考虑读一半数据的情况
  81.     int len = read(fd, msg, sizeof(msg)-1);
  82.     if( len <= 0 )
  83.     {
  84.         perror("read fail ");
  85.         exit(1);
  86.     }
  87.  
  88.     msg[len] = '\0';
  89.  
  90.     printf("recv %s from server\n", msg);
  91. }
  92.  
  93. typedef struct sockaddr SA;
  94. int tcp_connect_server(const char* server_ip, int port)
  95. {
  96.     int sockfd, status, save_errno;
  97.     struct sockaddr_in server_addr;
  98.  
  99.     memset(&server_addr, 0, sizeof(server_addr) );
  100.  
  101.     server_addr.sin_family = AF_INET;
  102.     server_addr.sin_port = htons(port);
  103.     status = inet_aton(server_ip, &server_addr.sin_addr);
  104.  
  105.     if( status == 0 ) //the server_ip is not valid value
  106.     {
  107.         errno = EINVAL;
  108.         return -1;
  109.     }
  110.  
  111.     sockfd = ::socket(PF_INET, SOCK_STREAM, 0);
  112.     if( sockfd == -1 )
  113.         return sockfd;
  114.  
  115.     status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );
  116.  
  117.     if( status == -1 )
  118.     {
  119.         save_errno = errno;
  120.         ::close(sockfd);
  121.         errno = save_errno; //the close may be error
  122.         return -1;
  123.     }
  124.  
  125.     evutil_make_socket_nonblocking(sockfd);
  126.  
  127.     return sockfd;
  128. }

server端代码：

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<errno.h>
  4.  
  5. #include<unistd.h>
  6. #include<event.h>
  7.  
  8. void accept_cb(int fd, short events, void* arg);
  9. void socket_read_cb(int fd, short events, void *arg);
  10.  
  11. int tcp_server_init(int port, int listen_num);
  12.  
  13. int main(int argc, char** argv)
  14. {
  15.  
  16.     int listener = tcp_server_init(9999, 10);
  17.     if( listener == -1 )
  18.     {
  19.         perror(" tcp_server_init error ");
  20.         return -1;
  21.     }
  22.  
  23.     struct event_base* base = event_base_new();
  24.  
  25.     //加入监听客户端请求连接事件
  26.     struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
  27.                                         accept_cb, base);
  28.     event_add(ev_listen, NULL);
  29.  
  30.     event_base_dispatch(base);
  31.  
  32.     return 0;
  33. }
  34.  
  35. void accept_cb(int fd, short events, void* arg)
  36. {
  37.     evutil_socket_t sockfd;
  38.  
  39.     struct sockaddr_in client;
  40.     socklen_t len = sizeof(client);
  41.  
  42.     sockfd = ::accept(fd, (struct sockaddr*)&client, &len );
  43.     evutil_make_socket_nonblocking(sockfd);
  44.  
  45.     printf("accept a client %d\n", sockfd);
  46.  
  47.     struct event_base* base = (event_base*)arg;
  48.  
  49.     //不过为了动态创建一个event结构体
  50.     struct event *ev = event_new(NULL, -1, 0, NULL, NULL);
  51.     //将动态创建的结构体作为event的回调參数
  52.     event_assign(ev, base, sockfd, EV_READ | EV_PERSIST,
  53.                  socket_read_cb, (void*)ev);
  54.  
  55.     event_add(ev, NULL);
  56. }
  57.  
  58. void socket_read_cb(int fd, short events, void *arg)
  59. {
  60.     char msg[4096];
  61.     struct event *ev = (struct event*)arg;
  62.     int len = read(fd, msg, sizeof(msg) - 1);
  63.  
  64.     if( len <= 0 )
  65.     {
  66.         printf("some error happen when read\n");
  67.         event_free(ev);
  68.         close(fd);
  69.         return ;
  70.     }
  71.  
  72.     msg[len] = '\0';
  73.     printf("recv the client msg: %s", msg);
  74.  
  75.     char reply_msg[4096] = "I have recvieced the msg: ";
  76.     strcat(reply_msg + strlen(reply_msg), msg);
  77.  
  78.     write(fd, reply_msg, strlen(reply_msg) );
  79. }
  80.  
  81. typedef struct sockaddr SA;
  82. int tcp_server_init(int port, int listen_num)
  83. {
  84.     int errno_save;
  85.     evutil_socket_t listener;
  86.  
  87.     listener = ::socket(AF_INET, SOCK_STREAM, 0);
  88.     if( listener == -1 )
  89.         return -1;
  90.  
  91.     //同意多次绑定同一个地址。
  92.  
  93. 要用在socket和bind之间
  94.     evutil_make_listen_socket_reuseable(listener);
  95.  
  96.     struct sockaddr_in sin;
  97.     sin.sin_family = AF_INET;
  98.     sin.sin_addr.s_addr = 0;
  99.     sin.sin_port = htons(port);
  100.  
  101.     if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )
  102.         goto error;
  103.  
  104.     if( ::listen(listener, listen_num) < 0)
  105.         goto error;
  106.  
  107.     //跨平台统一接口。将套接字设置为非堵塞状态
  108.     evutil_make_socket_nonblocking(listener);
  109.  
  110.     return listener;
  111.  
  112.     error:
  113.         errno_save = errno;
  114.         evutil_closesocket(listener);
  115.         errno = errno_save;
  116.  
  117.         return -1;
  118. }

中等：

client代码：

  1. #include<sys/types.h>
  2. #include<sys/socket.h>
  3. #include<netinet/in.h>
  4. #include<arpa/inet.h>
  5. #include<errno.h>
  6. #include<unistd.h>
  7.  
  8. #include<stdio.h>
  9. #include<string.h>
  10. #include<stdlib.h>
  11.  
  12. #include<event.h>
  13. #include<event2/bufferevent.h>
  14. #include<event2/buffer.h>
  15. #include<event2/util.h>
  16.  
  17. int tcp_connect_server(const char* server_ip, int port);
  18.  
  19. void cmd_msg_cb(int fd, short events, void* arg);
  20. void server_msg_cb(struct bufferevent* bev, void* arg);
  21. void event_cb(struct bufferevent *bev, short event, void *arg);
  22.  
  23. int main(int argc, char** argv)
  24. {
  25.     if( argc < 3 )
  26.     {
  27.         printf("please input 2 parameter\n");
  28.         return -1;
  29.     }
  30.  
  31.     //两个參数依次是服务器端的IP地址、端口号
  32.     int sockfd = tcp_connect_server(argv[1], atoi(argv[2]));
  33.     if( sockfd == -1)
  34.     {
  35.         perror("tcp_connect error ");
  36.         return -1;
  37.     }
  38.  
  39.     printf("connect to server successful\n");
  40.  
  41.     struct event_base* base = event_base_new();
  42.  
  43.     struct bufferevent* bev = bufferevent_socket_new(base, sockfd,
  44.                                                      BEV_OPT_CLOSE_ON_FREE);
  45.  
  46.     //监听终端输入事件
  47.     struct event* ev_cmd = event_new(base, STDIN_FILENO,
  48.                                       EV_READ | EV_PERSIST, cmd_msg_cb,
  49.                                       (void*)bev);
  50.     event_add(ev_cmd, NULL);
  51.  
  52.     //当socket关闭时会用到回调參数
  53.     bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
  54.     bufferevent_enable(bev, EV_READ | EV_PERSIST);
  55.  
  56.     event_base_dispatch(base);
  57.  
  58.     printf("finished \n");
  59.     return 0;
  60. }
  61.  
  62. void cmd_msg_cb(int fd, short events, void* arg)
  63. {
  64.     char msg[1024];
  65.  
  66.     int ret = read(fd, msg, sizeof(msg));
  67.     if( ret < 0 )
  68.     {
  69.         perror("read fail ");
  70.         exit(1);
  71.     }
  72.  
  73.     struct bufferevent* bev = (struct bufferevent*)arg;
  74.  
  75.     //把终端的消息发送给服务器端
  76.     bufferevent_write(bev, msg, ret);
  77. }
  78.  
  79. void server_msg_cb(struct bufferevent* bev, void* arg)
  80. {
  81.     char msg[1024];
  82.  
  83.     size_t len = bufferevent_read(bev, msg, sizeof(msg));
  84.     msg[len] = '\0';
  85.  
  86.     printf("recv %s from server\n", msg);
  87. }
  88.  
  89. void event_cb(struct bufferevent *bev, short event, void *arg)
  90. {
  91.  
  92.     if (event & BEV_EVENT_EOF)
  93.         printf("connection closed\n");
  94.     else if (event & BEV_EVENT_ERROR)
  95.         printf("some other error\n");
  96.  
  97.     //这将自己主动close套接字和free读写缓冲区
  98.     bufferevent_free(bev);
  99.  
  100.     struct event *ev = (struct event*)arg;
  101.     //由于socket已经没有，所以这个event也没有存在的必要了
  102.     event_free(ev);
  103. }
  104.  
  105. typedef struct sockaddr SA;
  106. int tcp_connect_server(const char* server_ip, int port)
  107. {
  108.     int sockfd, status, save_errno;
  109.     struct sockaddr_in server_addr;
  110.  
  111.     memset(&server_addr, 0, sizeof(server_addr) );
  112.  
  113.     server_addr.sin_family = AF_INET;
  114.     server_addr.sin_port = htons(port);
  115.     status = inet_aton(server_ip, &server_addr.sin_addr);
  116.  
  117.     if( status == 0 ) //the server_ip is not valid value
  118.     {
  119.         errno = EINVAL;
  120.         return -1;
  121.     }
  122.  
  123.     sockfd = ::socket(PF_INET, SOCK_STREAM, 0);
  124.     if( sockfd == -1 )
  125.         return sockfd;
  126.  
  127.     status = ::connect(sockfd, (SA*)&server_addr, sizeof(server_addr) );
  128.  
  129.     if( status == -1 )
  130.     {
  131.         save_errno = errno;
  132.         ::close(sockfd);
  133.         errno = save_errno; //the close may be error
  134.         return -1;
  135.     }
  136.  
  137.     evutil_make_socket_nonblocking(sockfd);
  138.  
  139.     return sockfd;
  140. }

server端代码：

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<errno.h>
  4.  
  5. #include<event.h>
  6. #include<event2/bufferevent.h>
  7.  
  8. void accept_cb(int fd, short events, void* arg);
  9. void socket_read_cb(bufferevent* bev, void* arg);
  10. void event_cb(struct bufferevent *bev, short event, void *arg);
  11. int tcp_server_init(int port, int listen_num);
  12.  
  13. int main(int argc, char** argv)
  14. {
  15.  
  16.     int listener = tcp_server_init(9999, 10);
  17.     if( listener == -1 )
  18.     {
  19.         perror(" tcp_server_init error ");
  20.         return -1;
  21.     }
  22.  
  23.     struct event_base* base = event_base_new();
  24.  
  25.     //加入监听客户端请求连接事件
  26.     struct event* ev_listen = event_new(base, listener, EV_READ | EV_PERSIST,
  27.                                         accept_cb, base);
  28.     event_add(ev_listen, NULL);
  29.  
  30.     event_base_dispatch(base);
  31.     event_base_free(base);
  32.  
  33.     return 0;
  34. }
  35.  
  36. void accept_cb(int fd, short events, void* arg)
  37. {
  38.     evutil_socket_t sockfd;
  39.  
  40.     struct sockaddr_in client;
  41.     socklen_t len = sizeof(client);
  42.  
  43.     sockfd = ::accept(fd, (struct sockaddr*)&client, &len );
  44.     evutil_make_socket_nonblocking(sockfd);
  45.  
  46.     printf("accept a client %d\n", sockfd);
  47.  
  48.     struct event_base* base = (event_base*)arg;
  49.  
  50.     bufferevent* bev = bufferevent_socket_new(base, sockfd, BEV_OPT_CLOSE_ON_FREE);
  51.     bufferevent_setcb(bev, socket_read_cb, NULL, event_cb, arg);
  52.  
  53.     bufferevent_enable(bev, EV_READ | EV_PERSIST);
  54. }
  55.  
  56. void socket_read_cb(bufferevent* bev, void* arg)
  57. {
  58.     char msg[4096];
  59.  
  60.     size_t len = bufferevent_read(bev, msg, sizeof(msg));
  61.  
  62.     msg[len] = '\0';
  63.     printf("recv the client msg: %s", msg);
  64.  
  65.     char reply_msg[4096] = "I have recvieced the msg: ";
  66.  
  67.     strcat(reply_msg + strlen(reply_msg), msg);
  68.     bufferevent_write(bev, reply_msg, strlen(reply_msg));
  69. }
  70.  
  71. void event_cb(struct bufferevent *bev, short event, void *arg)
  72. {
  73.  
  74.     if (event & BEV_EVENT_EOF)
  75.         printf("connection closed\n");
  76.     else if (event & BEV_EVENT_ERROR)
  77.         printf("some other error\n");
  78.  
  79.     //这将自己主动close套接字和free读写缓冲区
  80.     bufferevent_free(bev);
  81. }
  82.  
  83. typedef struct sockaddr SA;
  84. int tcp_server_init(int port, int listen_num)
  85. {
  86.     int errno_save;
  87.     evutil_socket_t listener;
  88.  
  89.     listener = ::socket(AF_INET, SOCK_STREAM, 0);
  90.     if( listener == -1 )
  91.         return -1;
  92.  
  93.     //同意多次绑定同一个地址。
  94.  
  95. 要用在socket和bind之间
  96.     evutil_make_listen_socket_reuseable(listener);
  97.  
  98.     struct sockaddr_in sin;
  99.     sin.sin_family = AF_INET;
  100.     sin.sin_addr.s_addr = 0;
  101.     sin.sin_port = htons(port);
  102.  
  103.     if( ::bind(listener, (SA*)&sin, sizeof(sin)) < 0 )
  104.         goto error;
  105.  
  106.     if( ::listen(listener, listen_num) < 0)
  107.         goto error;
  108.  
  109.     //跨平台统一接口，将套接字设置为非堵塞状态
  110.     evutil_make_socket_nonblocking(listener);
  111.  
  112.     return listener;
  113.  
  114.     error:
  115.         errno_save = errno;
  116.         evutil_closesocket(listener);
  117.         errno = errno_save;
  118.  
  119.         return -1;
  120. }

高等：

client代码：

  1. #include<sys/types.h>
  2. #include<sys/socket.h>
  3. #include<netinet/in.h>
  4. #include<arpa/inet.h>
  5. #include<errno.h>
  6. #include<unistd.h>
  7.  
  8. #include<stdio.h>
  9. #include<string.h>
  10. #include<stdlib.h>
  11.  
  12. #include<event.h>
  13. #include<event2/bufferevent.h>
  14. #include<event2/buffer.h>
  15. #include<event2/util.h>
  16.  
  17. int tcp_connect_server(const char* server_ip, int port);
  18.  
  19. void cmd_msg_cb(int fd, short events, void* arg);
  20. void server_msg_cb(struct bufferevent* bev, void* arg);
  21. void event_cb(struct bufferevent *bev, short event, void *arg);
  22.  
  23. int main(int argc, char** argv)
  24. {
  25.     if( argc < 3 )
  26.     {
  27.         //两个參数依次是服务器端的IP地址、端口号
  28.         printf("please input 2 parameter\n");
  29.         return -1;
  30.     }
  31.  
  32.     struct event_base *base = event_base_new();
  33.  
  34.     struct bufferevent* bev = bufferevent_socket_new(base, -1,
  35.                                                      BEV_OPT_CLOSE_ON_FREE);
  36.  
  37.     //监听终端输入事件
  38.     struct event* ev_cmd = event_new(base, STDIN_FILENO,
  39.                                      EV_READ | EV_PERSIST,
  40.                                      cmd_msg_cb, (void*)bev);
  41.  
  42.     event_add(ev_cmd, NULL);
  43.  
  44.     struct sockaddr_in server_addr;
  45.  
  46.     memset(&server_addr, 0, sizeof(server_addr) );
  47.  
  48.     server_addr.sin_family = AF_INET;
  49.     server_addr.sin_port = htons(atoi(argv[2]));
  50.     inet_aton(argv[1], &server_addr.sin_addr);
  51.  
  52.     bufferevent_socket_connect(bev, (struct sockaddr *)&server_addr,
  53.                                sizeof(server_addr));
  54.  
  55.     bufferevent_setcb(bev, server_msg_cb, NULL, event_cb, (void*)ev_cmd);
  56.     bufferevent_enable(bev, EV_READ | EV_PERSIST);
  57.  
  58.     event_base_dispatch(base);
  59.  
  60.     printf("finished \n");
  61.     return 0;
  62. }
  63.  
  64. void cmd_msg_cb(int fd, short events, void* arg)
  65. {
  66.     char msg[1024];
  67.  
  68.     int ret = read(fd, msg, sizeof(msg));
  69.     if( ret < 0 )
  70.     {
  71.         perror("read fail ");
  72.         exit(1);
  73.     }
  74.  
  75.     struct bufferevent* bev = (struct bufferevent*)arg;
  76.  
  77.     //把终端的消息发送给服务器端
  78.     bufferevent_write(bev, msg, ret);
  79. }
  80.  
  81. void server_msg_cb(struct bufferevent* bev, void* arg)
  82. {
  83.     char msg[1024];
  84.  
  85.     size_t len = bufferevent_read(bev, msg, sizeof(msg));
  86.     msg[len] = '\0';
  87.  
  88.     printf("recv %s from server\n", msg);
  89. }
  90.  
  91. void event_cb(struct bufferevent *bev, short event, void *arg)
  92. {
  93.  
  94.     if (event & BEV_EVENT_EOF)
  95.         printf("connection closed\n");
  96.     else if (event & BEV_EVENT_ERROR)
  97.         printf("some other error\n");
  98.     else if( event & BEV_EVENT_CONNECTED)
  99.     {
  100.         printf("the client has connected to server\n");
  101.         return ;
  102.     }
  103.  
  104.     //这将自己主动close套接字和free读写缓冲区
  105.     bufferevent_free(bev);
  106.  
  107.     struct event *ev = (struct event*)arg;
  108.     event_free(ev);
  109. }

server端代码：

  1. #include<netinet/in.h>
  2. #include<sys/socket.h>
  3. #include<unistd.h>  
  4.  
  5. #include<stdio.h>
  6. #include<string.h>  
  7.  
  8. #include<event.h>
  9. #include<listener.h>
  10. #include<bufferevent.h>
  11. #include<thread.h>  
  12.  
  13. void listener_cb(evconnlistener *listener, evutil_socket_t fd,
  14.                  struct sockaddr *sock, int socklen, void *arg);  
  15.  
  16. void socket_read_cb(bufferevent *bev, void *arg);
  17. void socket_event_cb(bufferevent *bev, short events, void *arg);  
  18.  
  19. int main()
  20. {
  21.     //evthread_use_pthreads();//enable threads  
  22.  
  23.     struct sockaddr_in sin;
  24.     memset(&sin, 0, sizeof(struct sockaddr_in));
  25.     sin.sin_family = AF_INET;
  26.     sin.sin_port = htons(9999);  
  27.  
  28.     event_base *base = event_base_new();
  29.     evconnlistener *listener
  30.             = evconnlistener_new_bind(base, listener_cb, base,
  31.                                       LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,
  32.                                       10, (struct sockaddr*)&sin,
  33.                                       sizeof(struct sockaddr_in));  
  34.  
  35.     event_base_dispatch(base);  
  36.  
  37.     evconnlistener_free(listener);
  38.     event_base_free(base);  
  39.  
  40.     return 0;
  41. }  
  42.  
  43. //一个新client连接上服务器了
  44. //当此函数被调用时，libevent已经帮我们accept了这个client。该client的
  45. //文件描写叙述符为fd
  46. void listener_cb(evconnlistener *listener, evutil_socket_t fd,
  47.                  struct sockaddr *sock, int socklen, void *arg)
  48. {
  49.     printf("accept a client %d\n", fd);  
  50.  
  51.     event_base *base = (event_base*)arg;  
  52.  
  53.     //为这个client分配一个bufferevent
  54.     bufferevent *bev =  bufferevent_socket_new(base, fd,
  55.                                                BEV_OPT_CLOSE_ON_FREE);  
  56.  
  57.     bufferevent_setcb(bev, socket_read_cb, NULL, socket_event_cb, NULL);
  58.     bufferevent_enable(bev, EV_READ | EV_PERSIST);
  59. }  
  60.  
  61. void socket_read_cb(bufferevent *bev, void *arg)
  62. {
  63.     char msg[4096];  
  64.  
  65.     size_t len = bufferevent_read(bev, msg, sizeof(msg)-1 );  
  66.  
  67.     msg[len] = '\0';
  68.     printf("server read the data %s\n", msg);  
  69.  
  70.     char reply[] = "I has read your data";
  71.     bufferevent_write(bev, reply, strlen(reply) );
  72. }  
  73.  
  74. void socket_event_cb(bufferevent *bev, short events, void *arg)
  75. {
  76.     if (events & BEV_EVENT_EOF)
  77.         printf("connection closed\n");
  78.     else if (events & BEV_EVENT_ERROR)
  79.         printf("some other error\n");  
  80.  
  81.     //这将自己主动close套接字和free读写缓冲区
  82.     bufferevent_free(bev);
  83. }

Libevent使用样例，从简单到复杂的更多相关文章

  1. Introspector(内省)简单演示样例 与 简单应用

    简单演示样例: package com.asdfLeftHand.test; import java.beans.BeanDescriptor; import java.beans.BeanInfo; ...

  2. Android中关于JNI 的学习（零）简单的样例，简单地入门

    Android中JNI的作用,就是让Java可以去调用由C/C++实现的代码,为了实现这个功能.须要用到Anrdoid提供的NDK工具包,在这里不讲怎样配置了,好麻烦,配置了好久. . . 本质上,J ...

  3. 通过Canvas及File API缩放并上传图片完整演示样例

    创建一个只管的用户界面,并同意你控制图片的大小.上传到server端的数据,并不须要处理enctype为 multi-part/form-data 的情况.只一个简单的POST表单处理程序就能够了. ...

  4. [转] Lodop、C-Lodop使用说明及样例

    本文转自:http://www.lodop.net/LodopDemo.html Lodop(标音:劳道谱,俗称:露肚皮)是专业WEB控件,用它既可裁剪输出页面内容,又可用程序代码直接实现 复杂打印. ...

  5. WEB打印控件Lodop(V6.x)使用说明及样例

    WEB打印控件Lodop(V6.x)使用说明及样例 Lodop是专业WEB控件,用它既可裁剪输出页面内容,又可用程序代码生成复杂打印页. 控件功能强大,却简单易用,所有调用如同JavaScript扩展 ...

  6. Linux下用OTL操作MySql（包含自己封装的类库及演示样例代码下载）

    版权声明:本文为博主原创文章,未经博主同意不得转载. https://blog.csdn.net/ClamReason/article/details/23971805 首先重点推荐介绍otl介绍及使 ...

  7. Thrift的安装和简单演示样例

    本文仅仅是简单的解说Thrift开源框架的安装和简单使用演示样例.对于具体的解说,后面在进行阐述. Thrift简述                                           ...

  8. socket编程——一个简单的样例

    从一个简单的使用TCP样例開始socket编程,其基本过程例如以下: server                                                  client ++ ...

  9. JBoss 系列九十六：JBoss MSC - 简介及一个简单演示样例

    什么是 JBoss MSC JBoss MSC 即 JBoss Modular Service Container,是第三代 JBoss 产品 JBoss 7和WildFfly的内核,JBoss MS ...

随机推荐

  1. Swift - 经纬度位置坐标与真实地理位置相互转化

    通过CoreLocation类,得到的定位信息都是以经度和纬度等表示的地理信息,通过CLGeocoder类可以将其反编码成一个地址.反之,也可根据一个地址获取经纬度. 1,通过经纬度获取地址 1 2 ...

  2. swift 有些语法还是不支持。

    <pre name="code" class="html">"func hasAnyMatches(list: Int[], condit ...

  3. Ubuntu环境下SSH的安装及使用

    Ubuntu环境下SSH的安装及使用 SSH是指Secure Shell,是一种安全的传输协议,Ubuntu客户端可以通过SSH访问远程服务器 .SSH的简介和工作机制可参看上篇文章SSH简介及工作机 ...

  4. 升级版:深入浅出Hadoop实战开发(云存储、MapReduce、HBase实战微博、Hive应用、Storm应用)

          Hadoop是一个分布式系统基础架构,由Apache基金会开发.用户可以在不了解分布式底层细节的情况下,开发分布式程序.充分利用集群的威力高速运算和存储.Hadoop实现了一个分布式文件系 ...

  5. 基于visual Studio2013解决C语言竞赛题之1064互质数差1验证

       题目 解决代码及点评 /* 64. 任意两个互质的自然数, 经过若干次加减后,总可获得结果为1的数值. 所谓互质数(即互素的数),是指这两个数除 1外再没有其它公因数. 如14,9为 ...

  6. C++学习之路—运算符重载（一）概念、方法及规则

    (根据<C++程序设计>(谭浩强)整理,整理者:华科小涛,@http://www.cnblogs.com/hust-ghtao转载请注明) 1    什么是运算符重载 先来说下什么是重载吧 ...

  7. Jsoup API解析HTML中input标签

    Jsoup官网地址:http://jsoup.org/ 1. 解析单个input元素     String html = "<p><input align=\"t ...

  8. linux下编译原理分析

    linux下编译hello.c 程序,使用gcc hello.c,然后./a.out就能够执行:在这个简单的命令后面隐藏了很多复杂的过程,这个过程包含了以下的步骤: ================= ...

  9. tomcat path设置

    zjtest7-app:/usr/local/apache-tomcat-7.0.55_8082/logs# netstat -nap | grep 8082 tcp 0 0 :::8082 :::* ...

  10. 用Swift开发二维码扫描器教程

    (原文:Building a QR Code Reader in Swift 作者:Simon Ng 译者:xiaoying )我相信大多数人都知道二维码(QR code)是什么,如果你对这个概念还不 ...