socket编程客户端代码,Socket 编程
一个关于socket编程的问题，我用vs写了一个很简单的客户端和一个服务器的程序
服务器的地址指定服务器工作的IP地址
客户端的地址指定所连接的服务器的IP地址，因此：
两个都填写服务器那台计算机的IP地址即可，端口号保持一致！
socket编程问题（附代码）
1.首先你的程序时是单线程的程序。
2.基于SOCKET的程序，也就是C/S程序，要区分那个是C,那个是S。
3.建议你看下孙鑫的VC++视频里面的基于SOCKET通信。
基于JAVA socket的服务器客户端编程
要完成这个工作，需要完成三个部分的工作，以下依次说明：
一、建立服务器类
Java中有一个专门用来建立Socket服务器的类，名叫ServerSocket,可以用服务器需要使用的端口号作为参数来创建服务器对象。
ServerSocket server = new ServerSocket(9998)
这条语句创建了一个服务器对象，这个服务器使用9998号端口即在端口9998上注册服务，这里稍微要注意的是端口的分配必须是唯一的。因为端口是为了唯一标识每台计算机唯一服务的，另外端口号是从0~65535之间的，前1024个端口已经被Tcp/Ip 作为保留端口，因此你所分配的端口只能是1024个之后的。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响应这个连接，并且server.accept()方法会创建一个Socket对象。服务器端便可以利用这个Socket对象与客户进行通讯。
Socket incoming = server.accept() ; // 监听窗口,等待连接
进而得到输入流和输出流,并进行封装
BufferedReader in = new BufferedReader(new
InputStreamReader(incoming.getInputStream()));
/*
当读取文件时，先把内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
*/
PrintWriter ut = new PrintWriter(incoming.getOutputStream(),true);
随后，就可以使用in.readLine()方法得到客户端的输入，也可以使用out.println()方法向客户端发送数据。从而可以根据程序的需要对客户端的不同请求进行回应。
在所有通讯结束以后应该关闭这两个数据流，关闭的顺序是先关闭输出流，再关闭输入流，即使用
out.close();
in.close();
二、建立客户端代码
相比服务器端，客户端要简单一些，客户端只需用服务器所在机器的ip以及服务器的端口作为参数创建一个Socket对象。得到这个对象后，就可以用"建立服务器"部分介绍的方法实现数据的输入和输出。
Socket socket = new Socket("168.160.12.42",9998);
或：
Socket socket = new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接
客户机必须知道有关服务器的IP地址，对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供，它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法。
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(),true);
以上的程序代码建立了一个Socket对象，这个对象连接到ip地址为168.160.12.42的主机上、端口为9998的服务器对象。并且建立了输入流和输出流，分别对应服务器的输出和客户端的写入。
三、实例分析
服务方:
import java.io.*;
import java.net.*;
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket(5678); //在端口5678上注册服务
Socket client=server.accept(); // 监听窗口,等待连接
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
BufferedReader serverInput=new BufferedReader(new InputStreamReader(System.in));
PrintWriter ut=new PrintWriter(client.getOutputStream());
while(true){
String str=in.readLine(); //// 读取从client传来的数据信息
str = serverInput.readLine(); // 读取用户键盘输入的字符串
System.out.println(str); //服务器控制台输出数据信息
out.println("has receive...."); //服务器向客户端发送信息:has receive....
out.flush();
if(str.equals("end"))
break;
}
client.close();
}
}
这个程序的主要目的在于服务器不断接收客户机所写入的信息只到，客户机发送"End"字符串就退出程序，并且服务器也会做出"Receive"为回应，告知客户机已接收到消息。
客户机代码:
import java.net.*;
import java.io.*;
public class Client{
static Socket server;
public static void main(String[] args)throws Exception{
server=new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接
BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); //客户端建立输入流并进行封装
PrintWriter ut=new PrintWriter(server.getOutputStream());
BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)); //客户端从键盘输入信息
while(true){
String str=wt.readLine(); //客户端读取（获得）键盘的字符串
String str1=in.readLine(); // 从服务器获得字符串
out.println(str); //客户端向服务器发送信息
out.flush();
if(str.equals("end")){
break;
}
System.out.println(in.readLine());
}
server.close();
}
}
客户机代码则是接受客户键盘输入,并把该信息输出，然后输出"End"用来做退出标识。
这个程序只是简单的两台计算机之间的通讯，如果是多个客户同时访问一个服务器呢？你可以试着再运行一个客户端，结果是会抛出异常的。那么多个客户端如何实现呢?
其实,简单的分析一下，就可以看出客户和服务通讯的主要通道就是Socket本身，而服务器通过accept方法就是同意和客户建立通讯.这样当客户建立Socket的同时。服务器也会使用这一根连线来先后通讯，那么既然如此只要我们存在多条连线就可以了。那么我们的程序可以变为如下:
服务器:
import java.io.*;
import java.net.*;
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket(5678);
while(true){
Socket client=server.accept();
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter ut=new PrintWriter(client.getOutputStream());
while(true){
String str=in.readLine();
System.out.println(str);
out.println("has receive....");
out.flush();
if(str.equals("end"))
break;
}
client.close();
}
}
}
这里仅仅只是加了一个外层的While循环，这个循环的目的就是当一个客户进来就为它分配一个Socket直到这个客户完成一次和服务器的交互，这里也就是接受到客户的"End"消息.那么现在就实现了多客户之间的交互了。但是.问题又来了，这样做虽然解决了多客户,可是是排队执行的。也就是说当一个客户和服务器完成一次通讯之后下一个客户才可以进来和服务器交互，无法做到同时服务，那么要如何才能同时达到既能相互之间交流又能同时交流呢？很显然这是一个并行执行的问题了。所以线程是最好的解决方案。
那么下面的问题是如何使用线程.首先要做的事情是创建线程并使得其可以和网络连线取得联系。然后由线程来执行刚才的操作，要创建线程要么直接继承Thread要么实现Runnable接口，要建立和Socket的联系只要传递引用就可以了.而要执行线程就必须重写run方法，而run方法所做的事情就是刚才单线程版本main所做的事情，因此我们的程序变成了这样:
import java.net.*;
import java.io.*;
public class MultiUser extends Thread{
private Socket client;
public MultiUser(Socket c){
this.client=c;
}
public void run(){
try{
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter ut=new PrintWriter(client.getOutputStream());
//Mutil User but can't parallel
while(true){
String str=in.readLine();
System.out.println(str);
out.println("has receive....");
out.flush();
if(str.equals("end"))
break;
}
client.close();
}catch(IOException ex){
}finally{
}
}
public static void main(String[] args)throws IOException{
ServerSocket server=new ServerSocket(5678);
while(true){
//transfer location change Single User or Multi User
MultiUser mu=new MultiUser(server.accept());
mu.start();
}
}
}
我的类直接从Thread类继承了下来.并且通过构造函数传递引用和客户Socket建立了联系，这样每个线程就有了。一个通讯管道.同样我们可以填写run方法，把之前的操作交给线程来完成，这样多客户并行的Socket就建立起来了。
socket 客户端可以向服务器端接收和发送文件，代码怎么写
之前写过这样的一个小程序，我发布在自己的博客上：
Server.c
#include?WinSock2.h
#include?WS2tcpip.h
#include?cstdio
#include?iostream
//?for?file?read
#include?fstream
#include?string
int?main()?{
/*?load?the?initializer?library?*/
WSADATA?wsaData;
WSAStartup(MAKEWORD(2,?2),?wsaData);
/*?list?the?each?fields?of?wsaData?*/
//?printf("wVersion:?%d\n",?wsaData.wVersion); //?514
//?printf("wHighVersion:?%d\n",?wsaData.wHighVersion); //?514
//?printf("iMaxSockets:?%d\n",?wsaData.iMaxSockets); //?0
//?printf("iMaxUdpDg:?%d\n",?wsaData.iMaxUdpDg); //?0
/*?you?may?not?print?the?lpVendorInfo?*/
//?printf("szDescription:?%s\n",?wsaData.szDescription); //?WinSock?2.0
//?printf("szSystemStatus:?%s\n",?wsaData.szSystemStatus); //?Running
/*?create?socket(address?family,?type,?protocol)?*/
int?socket_fd?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);
/*?initialize?the?addrinfo?hints?*/
struct?addrinfo?hints;
memset(hints,?0,?sizeof(hints));
hints.ai_family?=?AF_INET;
hints.ai_socktype?=?SOCK_STREAM;
hints.ai_protocol?=?IPPROTO_TCP;
hints.ai_flags?=?AI_PASSIVE;
struct?addrinfo?*result?=?nullptr;
/*?by?hints,?and?then?get?the?result(a?linked?list,?see?fields?below)?*/
getaddrinfo(NULL,?"8080",?hints,?result);
/*?the?member?fiekds?of?result?*/
//?printf("ai_family:?%d\n",?result-ai_family); //?2
//?printf("ai_socktype:?%d\n",?result-ai_socktype); //?1
//?printf("ai_protocol:?%d\n",?result-ai_protocol); //?6
//?printf("ai_flags:?%d\n",?result-ai_flags); //?0
//?printf("ai_canonname:?%s\n",?result-ai_canonname); //?(null)
//?printf("ai_a?ddrlen:?%d\n",?result-ai_addrlen); //?16
//?printf("ai_addr-sa_family:?%d\n",?result-ai_addr-sa_family); //?2
//?printf("ai_addr-sa_data:?%s\n",?result-ai_addr-sa_data); //?
//?printf("ai_next:?%x\n",?result-ai_next); //?0
/*?bind?the?socket?to?a?address?*/
/*?bind(socket,?sockaddr?name,?name?len)?*/
bind(socket_fd,?result-ai_addr,?result-ai_addrlen);
freeaddrinfo(result);
/*?listen?the?socket?*/
/*?listen(socket,?backlog)?*/
listen(socket_fd,?SOMAXCONN); /*?0x7fffffff?*/
while(true)?{
/*?accept?a?connection?*/
/*?accept(socket,?addr,?addrlen)?*/
int?client_fd?=?accept(socket_fd,?nullptr,?0);
printf("New?Connection?Eastablished...\n");
/*?Now?we?send?the?source?code?of?this?file?to?client?*/
std::ifstream?fin("c:\\source.cpp");
/*?store?it?into?a?buffer.?*/
while?(fin.good())?{
//?I?rememeber?there?is?a?method?called?getline
std::string?s;
getline(fin,?s);
//?we?need?a?new?line
s?=?s?+?'\n';
send(client_fd,?s.c_str(),?s.size(),?0);
}
fin.close();
/*?close?client?socket?*/
closesocket(client_fd);
}
/*?may?be?never?invoked?*/
closesocket(socket_fd);
WSACleanup();
return?0;
}
Client.c
#include?WinSock2.h
#include?cstdio
#include?iostream
#include?fstream
int?main()?{
/*?load?the?initializer?library?*/
WSADATA?wsaData;
WSAStartup(MAKEWORD(2,?2),?wsaData);
/*?create?socket?*/
int?socket_fd?=?socket(AF_INET,?SOCK_STREAM,?IPPROTO_TCP);
/*?connect?*/
sockaddr_in?addr;
addr.sin_family?=?AF_INET;
addr.sin_addr.s_addr?=?inet_addr("127.0.0.1");
addr.sin_port?=?htons(8080);
/*?connect(socket,?sockaddr,?namelen)?*/
connect(socket_fd,?(sockaddr*)addr,?sizeof(addr));
/*?buffer?memory?*/
char?buf[1024];
/*?open?a?file?for?write?*/
std::ofstream?fout("source.cpp",?std::ios_base::trunc);
while?(true)?{
int?read?=?recv(socket_fd,?buf,?1024,?0);?
if?(read?==?0)?{
fout.close();
printf("Connection?Closed...\n");
break;
}
if?(read??1024)?{
printf("Buffer?Overflow...\n");
}?else?{
buf[read?-?1]?=?0;
/*?now?we?can?print?the?bytes?from?server?*/
fout??buf??std::endl;
}
}
/*?close?socket?*/
closesocket(socket_fd);
WSACleanup();
return?0;
}
6.Twisted UDP Socket 编程示例
示例：客户端每隔10秒向服务端报送设备使用情况，具体数据如下：
数据以文本进行传输，传输格式：Key:Value，中间用冒号分隔。服务端只做数据的原样显示并回复"OK!"
由于 UDP 没有连接的概念，所以大多数情况下，采用 UDP Socket 实现的应用都是由设备采集数据上报到服务上来运行的。
虽然对于 UDP 来说没有服务端和客户端的概念，但在实际项目开发中，我们一般还是要区分服务端和客户端的。对于 UDP 服务端来说，其实代码很简单，因为其主要任务就是接收数据，然后对数据进行处理。
先来编写代码框架：
代码中，主要实现的是 datagramReceived 事件，一般在该事件的代码中就是我们的业务逻辑，示例代码如下：
客户端代码相对比服务端要复杂一点，主要是客户端需要执行定时任务，这样的话，我们需要设计一个线程来执行该定时任务，由于线程中需要发送数据到服务端，所以，在线程中需要设计一个属性指向客户端的 Protocol。线程的框架代码如下：
客户端框架代码：
线程主要通过 Protocol 发送数据，实现代码如下：
客户端 Protocol 代码实现如下：
在 Protocol 启动时连接到服务器，这样就可以形成 Connected UDP，相对于 UDP 来说，数据的传输可靠性有所提高，同时，在代码中发送数据也不需要写服务端的地址。
服务端：
客户端：