我的编程,我的路
其实我根本就没深入学习编程,只能说是了解过,了解汇编,刷个板子,报过学习班,交了1万多大洋。没找到嵌入式的工作,后来就改做网络工程师了,考了MCP,过了CCNA。玩了几个月思科2900系列交换,路由之类的。3500系列,4000系列只见过没操作过。在国内企业干过2年,用的都是华为,华3C。玩了几个月LINUX,搞过几个月自己的网站论坛,基本都不长,就是单位需要 我就去学一下,不用了我就忘了,这么多年下来,没有一个精通的。全都算是了解吧。说到编程,C,C++,JAVA,都学了几个月。后来在论坛学了点CE破解之类的。最后剩下的东西,就是会用按键精灵写写WG脚本,有难度的都没突破,依旧和新手一样,用着简单是for,if ,do,loop, sub 没有太大的起色。日子还得过,学习和生活同步进行中。继续坚持一次,每天写一个小功能,今天开始写一个客户端和服务器的小程序,然后每天在上面加一个功能,逐步达到服务器让客户端干什么就能干什么。 本帖最后由 ╃烦了 于 2014-1-14 19:05 编辑
今天开始记录吧。希望我能坚持一下,性格最大的缺点就是急躁,我媳妇说这个是浮躁,人的沉淀不够就容易浮躁。我之所以开始捡起编程,是因为有一个强大的背景压力,万般无奈只能寄托希望于此。
标题:编程日志 初级(1)
日期:2014年1月14日19:03
目标:收集客户端和服务器的源代码
执行:现在出去买饭,回来后开始执行
结果:等待接受中
改善:等待结果后判断 执行开始:
搜索找到一个JAVA版本的。
代码如下:
功能说明:
TCP服务器提供文件下载服务,服务器支持多线程。
TCP Client从服务器上下载指定的文件,Client也支持多线程。
分服务器代码和客户端代码:ServerOneDownload.java 为服务器代码
DownLoadClient.java为客户端代码、DownFileThread.java为客户端代码
详细代码:
ServerOneDownload.java
//file:DownloadServer.java
import java.net.*;
import java.io.*;
class ServerOneDownload extends Thread {
private Socket socket = null;
private String downloadRoot = null;
private static final int Buffer = 8 * 1024;
public ServerOneDownload(Socket socket, String downloadRoot) {
super();
this.socket = socket;
this.downloadRoot = downloadRoot;
start();
}
// 检查文件是否真实存在,核对下载密码,若文件不存在或密码错误,则返回-1,否则返回文件长度
// 此处只要密码不为空就认为是正确的
private long getFileLength(String fileName, String password) {
// 若文件名或密码为null,则返回-1
if ((fileName == null) || (password == null))
return -1;
// 若文件名或密码长度为0,则返回-1
if ((fileName.length() == 0) || (password.length() == 0))
return -1;
String filePath = downloadRoot + fileName; // 生成完整文件路径
System.out.println("DownloadServer getFileLength----->" + filePath);
File file = new File(filePath);
// 若文件不存在,则返回-1
if (!file.exists())
return -1;
return file.length(); // 返回文件长度
}
// 用指定输出流发送指定文件
private void sendFile(DataOutputStream out, String fileName)
throws Exception {
String filePath = downloadRoot + fileName; // 生成完整文件路径
// 创建与该文件关联的文件输入流
FileInputStream in = new FileInputStream(filePath);
System.out.println("DownloadServer sendFile----->" + filePath);
byte[] buf = new byte;
int len;
// 反复读取该文件中的内容,直到读到的长度为-1
while ((len = in.read(buf)) >= 0) {
out.write(buf, 0, len); // 将读到的数据,按读到的长度写入输出流
out.flush();
}
out.close();
in.close();
}
// 提供下载服务
public void download() throws IOException {
System.out.println("启动下载... ");
System.out.println("DownloadServer currentThread--->"
+ currentThread().getName());
System.out.println("DownloadServer currentThread--->"
+ currentThread().getId());
// 获取socket的输入流并包装成BufferedReader
BufferedReader in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
// 获取socket的输出流并包装成DataOutputStream
DataOutputStream out = new DataOutputStream(socket.getOutputStream());
try {
String parameterString = in.readLine(); // 接收下载请求参数
// 下载请求参数字符串为自定义的格式,由下载文件相对于下载根目录的路径和
// 下载密码组成,两者间以字符 "@ "分隔,此处按 "@ "分割下载请求参数字符串
String[] parameter = parameterString.split("@ ");
String fileName = parameter; // 获取相对文件路径
String password = parameter; // 获取下载密码
// 打印请求下载相关信息
System.out.print(socket.getInetAddress().getHostAddress()
+ "提出下载请求, ");
System.out.println("请求下载文件: " + fileName);
// 检查文件是否真实存在,核对下载密码,获取文件长度
long len = getFileLength(fileName, password);
System.out.println("download fileName----->" + fileName);
System.out.println("download password----->" + password);
out.writeLong(len); // 向客户端返回文件大小
out.flush();
// 若获取的文件长度大于等于0,则允许下载,否则拒绝下载
if (len >= 0) {
System.out.println("允许下载 ");
System.out.println("正在下载文件 " + fileName + "... ");
sendFile(out, fileName); // 向客户端发送文件
System.out.println(fileName +": "+"下载完毕 ");
} else {
System.out.println("下载文件不存在或密码错误,拒绝下载! ");
}
} catch (Exception e) {
System.out.println(e.toString());
} finally {
socket.close(); // 关闭socket
}
}
@Override
public void run() {
try {
download();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// TODO Auto-generated method stub
super.run();
}
}
public class DownloadServer {
private final static int port = 65525;
private static String root = "C:\\ "; // 下载根目录
public static void main(String[] args) throws IOException {
String temp = null;
// 监听端口
try {
// 包装标准输入为BufferedReader
BufferedReader systemIn = new BufferedReader(new InputStreamReader(
System.in));
while (true) {
System.out.print("请输入下载服务器的下载根目录: ");
root = systemIn.readLine().trim(); // 从标准输入读取下载根目录
File file = new File(root);
// 若该目录确实存在且为目录,则跳出循环
if ((file.exists()) && (file.isDirectory())) {
temp = root.substring(root.length() - 1, root.length());
if (!temp.equals("\\"))
root += "\\";
}
break;
}
} catch (Exception e) {
System.out.println(e.toString());
}
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("Server start...");
try {
while (true) {
Socket socket = serverSocket.accept();
new ServerOneDownload(socket, root);
}
} finally {
serverSocket.close();
}
}
}
客户端:
DownLoadClient.java
//file:DownLoadClient.java
package org.piaozhiye.study;
import java.io.IOException;
import java.net.Socket;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
public class DownLoadClient extends Activity {
private Button download = null;
private EditText et_serverIP = null;
private EditText et_fileName= null;
private String downloadFile = null;
private final static int PORT = 65525;
private final static String defaultIP = "192.168.0.100";
private static String serverIP = null;
private Socket socket;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
download = (Button)findViewById(R.id.download);
et_serverIP= (EditText)findViewById(R.id.et_serverip);
et_fileName = (EditText)findViewById(R.id.et_filename);
et_serverIP.setText("192.168.0.100");
download.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
serverIP = et_serverIP.getText().toString();
if(serverIP == null){
serverIP = defaultIP;
}
System.out.println("DownLoadClient serverIP--->" + serverIP );
System.out.println("DownLoadClient MainThread--->" + Thread.currentThread().getId() );
try{
socket = new Socket(serverIP, PORT);
}catch(IOException e){
}
downloadFile = et_fileName.getText().toString();
Thread downFileThread = new Thread(new DownFileThread(socket, downloadFile));
downFileThread.start();
System.out.println("DownLoadClient downloadFile--->" + downloadFile );
}
});
}
}
执行任务:
DownFileThread.java
package org.piaozhiye.study;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
public class DownFileThread extends Thread {
private Socket socket;
private String downloadFile;
private final static int Buffer = 8 * 1024;
public DownFileThread(Socket socket, String downloadFile) {
super();
this.socket = socket;
this.downloadFile = downloadFile;
}
public Socket getSocket() {
return socket;
}
public void setSocket(Socket socket) {
this.socket = socket;
}
public String getDownloadFile() {
return downloadFile;
}
public void setDownloadFile(String downloadFile) {
this.downloadFile = downloadFile;
}
// 向服务器提出下载请求,返回下载文件的大小
private long request(String fileName, String password) throws IOException {
// 获取socket的输入流并包装成DataInputStream
DataInputStream in = new DataInputStream(socket.getInputStream());
// 获取socket的输出流并包装成PrintWriter
PrintWriter out = new PrintWriter(new OutputStreamWriter(
socket.getOutputStream()));
// 生成下载请求字符串
String requestString = fileName + "@ " + password;
out.println(requestString); // 发出下载请求
out.flush();
return in.readLong(); // 接收并返回下载文件长度
}
// 接收并保存文件
private void receiveFile(String localFile) throws Exception {
// 获取socket的输入流并包装成BufferedInputStream
BufferedInputStream in = new BufferedInputStream(
socket.getInputStream());
// 获取与指定本地文件关联的文件输出流
FileOutputStream out = new FileOutputStream(localFile);
byte[] buf = new byte;
int len;
// 反复读取该文件中的内容,直到读到的长度为-1
while ((len = in.read(buf)) >= 0) {
out.write(buf, 0, len); // 将读到的数据,按读到的长度写入输出流
out.flush();
}
out.close();
in.close();
}
// 从服务器下载文件
public void download(String downloadFile) throws Exception {
try {
String password = "password";
// String downloadFile ="imissyou.mp3";
String localpath = "/sdcard/";
String localFile = localpath + downloadFile;
long fileLength = request(downloadFile, password);
// 若获取的文件长度大于等于0,说明允许下载,否则说明拒绝下载
if (fileLength >= 0) {
System.out.println("fileLength: " + fileLength + " B");
System.out.println("downing...");
receiveFile(localFile); // 从服务器接收文件并保存至本地文件
System.out.println("file:" + downloadFile + " had save to "
+ localFile);
} else {
System.out.println("download " + downloadFile + " error! ");
}
} catch (IOException e) {
System.out.println(e.toString());
} finally {
socket.close(); // 关闭socket
}
}
@Override
public void run() {
System.out.println("DownFileThread currentThread--->"
+ DownFileThread.currentThread().getId());
// TODO Auto-generated method stub
try {
download(downloadFile);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
super.run();
}
}
分析判断:留作参考继续搜索 继续执行:
找到一个QQ的版本的,JAVA代码有些乱用处不大留着参考吧。
服务器版:
package com.way.chat.server;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.way.chat.common.util.Constants;
import com.way.chat.common.util.MyDate;
/**
* 服务器,接受用户登录、离线、转发消息
*
* @author way
*
*/
public class Server {
private ExecutorService executorService;// 线程池
private ServerSocket serverSocket = null;
private Socket socket = null;
private boolean isStarted = true;
public Server() {
try {
// 创建线程池,池中具有(cpu个数*50)条线程
executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
.availableProcessors() * 50);
serverSocket = new ServerSocket(Constants.SERVER_PORT);
} catch (IOException e) {
e.printStackTrace();
quit();
}
}
public void start() {
System.out.println(MyDate.getDateCN() + " 服务器已启动...");
try {
while (isStarted) {
socket = serverSocket.accept();
String ip = socket.getInetAddress().toString();
System.out.println(MyDate.getDateCN() + " 用户:" + ip + " 已建立连接");
// 为支持多用户并发访问,采用线程池管理每一个用户的连接请求
if (socket.isConnected())
executorService.execute(new SocketTask(socket));// 添加到线程池
}
if (socket != null)
socket.close();
if (serverSocket != null)
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
// isStarted = false;
}
}
private final class SocketTask implements Runnable {
private Socket socket = null;
private InputThread in;
private OutputThread out;
private OutputThreadMap map;
public SocketTask(Socket socket) {
this.socket = socket;
map = OutputThreadMap.getInstance();
}
@Override
public void run() {
out = new OutputThread(socket, map);//
// 先实例化写消息线程,(把对应用户的写线程存入map缓存器中)
in = new InputThread(socket, out, map);// 再实例化读消息线程
out.setStart(true);
in.setStart(true);
in.start();
out.start();
}
}
/**
* 退出
*/
public void quit() {
try {
this.isStarted = false;
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new Server().start();
}
}
客户 端
package com.way.client;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
/**
* 客户端
*
* @author way
*
*/
public class Client {
private Socket client;
private ClientThread clientThread;
private String ip;
private int port;
public Client(String ip, int port)
{
this.ip = ip;
this.port = port;
}
public boolean start()
{
try
{
client = new Socket();
// client.connect(new InetSocketAddress(Constants.SERVER_IP,
// Constants.SERVER_PORT), 3000);
client.connect(new InetSocketAddress(ip, port), 3000);
if (client.isConnected())
{
// System.out.println("Connected..");
clientThread = new ClientThread(client);
clientThread.start();
}
}
catch (IOException e)
{
e.printStackTrace();
return false;
}
return true;
}
// 直接通过client得到读线程
public ClientInputThread getClientInputThread()
{
return clientThread.getIn();
}
// 直接通过client得到写线程
public ClientOutputThread getClientOutputThread()
{
return clientThread.getOut();
}
// 直接通过client停止读写消息
public void setIsStart(boolean isStart)
{
clientThread.getIn().setStart(isStart);
clientThread.getOut().setStart(isStart);
}
public class ClientThread extends Thread
{
private ClientInputThread in;
private ClientOutputThread out;
public ClientThread(Socket socket)
{
in = new ClientInputThread(socket);
out = new ClientOutputThread(socket);
}
public void run()
{
in.setStart(true);
out.setStart(true);
in.start();
out.start();
}
// 得到读消息线程
public ClientInputThread getIn()
{
return in;
}
// 得到写消息线程
public ClientOutputThread getOut()
{
return out;
}
}
}
分析判断:还是没找到我想要的。简单的。
以上2个代码的分析,一个是对文件的操作,一个是对信息接收发送的操作。暂时记录这些。继续找 总结:以上2次操作发现没有适合的入手点,即使找到了代码,自己也改不明白,出了BUG也调不了。
搜索方向改变:找服务器与客户端通信原理
搜索目标:服务器与客户端通信原理
继续执行结果如下:
学习任何东西,我们只要搞清楚其原理,就会触类旁通。现在结和我所学,我想总结一下客户端到服务器端的通信过程。只有明白了原理,我们才会明白当我们程序开发过程中错误的问题会出现在那,才会更好的解决问题。
我们首先要了解一个概念性的词汇:Socket
socket的英文原义是“孔”或“插座”。作为进程通信机制,取后一种意思。通常也称作“套接字”,用于描述IP地址和端口,是一个通信链的句柄。(其实就是两个程序通信用的。)socket非常类似于电话的插座。以一个电话网为例。电话的通话双方相当于相互通信的2个程序,电话号码可以当作是IP地址。任何用户在通话之前,首先要占有一部电话机,相当于申请一个socket;同时要知道对方的号码(IP地址),相当于对方有一个固定的socket。然后向对方拨号呼叫,相当于发出连接请求。对方假如在场并空闲,拿起电话话筒,双方就可以正式通话,相当于连接成功。双方通话的过程,是一方向电话机发出信号和对方从电话机接收信号的过程,相当于向socket发送数据和从socket接收数据。通话结束后,一方挂起电话机相当于关闭socket,撤消连接,通信完成。
以上通信是以两个人通话做为事例来在概的说明了下通信,但是现在假如通信中的一个人是外国人(说英语),一个人是中国人(说普通话),他们俩相互通信的话,都不能听明白对方说的是什么,那么他们的沟通就不能够完成。但是如果我们给一个规定,给通话双方,只能讲普通话,那么双方沟通就没有障碍了。这就引出来了通信协议。
有两种类型:(Tcp协议与Udp协议):
Tcp协议与Udp协议是在两硬件设备上进行通信传输的一种数据语法。
– 流式Socket(STREAM):
是一种面向连接的Socket,针对于面向连接的TCP服务应用,安全,但是效率低;Tcp:是以流的形式来传的。
– 数据报式Socket(DATAGRAM):
是一种无连接的Socket,对应于无连接的UDP服务应用.不安全(丢失,顺序混乱,在接收端要分析重排及要求重发),但效率高.Udp:将数据包拆开为若干份编号后来传输。在传输的过程中容易出现数据的丢失。但是传输速度要比TCP的快。 OK。了解原理以后,选编程语言,之前学的是C和C++比较多,所以选C++。然后选编译软件。
对一款插件比较感兴趣,所以采用采用vc6.0编写。
执行:下载编译器。
Socket的通信流程 服务器端:
–申请一个socket (socketWatch)用来监听的
–绑定到一个IP地址和一个端口上
–开启侦听,等待接授客户端的连接
–当有连接时创建一个用于和连接进来的客户端进行通信的socket(socketConnection)
–即续监听,等侍下一个客户的连接 服务器代码如下:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;//IPAdress,IPEndPoint(ip和端口)类
using System.Net.Sockets;
using System.Threading;
using System.IO;
namespace MyChatRoomServer
{
public partial class FChatServer : Form
{
public FChatServer()
{
InitializeComponent();
TextBox.CheckForIllegalCrossThreadCalls = false;//关闭 对 文本框的跨线程操作检查
}
Thread threadWatch = null;//负责监听 客户端 连接请求的 线程
Socket socketWatch = null;//负责监听的 套接字
private void btnBeginListen_Click(object sender, EventArgs e)
{
//创建 服务端 负责监听的 套接字,参数(使用IP4寻址协议,使用流式连接,使用TCP协议传输数据)
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//获得文本框中的 IP地址对象
IPAddress address = IPAddress.Parse(txtIP.Text.Trim());
//创建 包含 ip 和 port 的网络节点对象
IPEndPoint endpoint = new IPEndPoint(address, int.Parse(txtPort.Text.Trim()));
//将 负责监听 的套接字 绑定到 唯一的IP和端口上
socketWatch.Bind(endpoint);
//设置监听队列的长度
socketWatch.Listen(10);
//创建 负责监听的线程,并传入监听方法
threadWatch = new Thread(WatchConnecting);
threadWatch.IsBackground = true;//设置为后台线程
threadWatch.Start();//开启线程
ShowMsg("服务器启动监听成功~");
//IPEndPoint
//socketWatch.Bind(
}
//保存了服务器端 所有负责和客户端通信的套接字
Dictionary<string, Socket> dict = new Dictionary<string, Socket>();
//保存了服务器端 所有负责调用 通信套接字.Receive方法 的线程
Dictionary<string, Thread> dictThread = new Dictionary<string, Thread>();
//Socket sokConnection = null;
/// <summary>
/// 监听客户端请求的方法
/// </summary>
void WatchConnecting()
{
while (true)//持续不断的监听新的客户端的连接请求
{
//开始监听 客户端 连接请求,注意:Accept方法,会阻断当前的线程!
Socket sokConnection = socketWatch.Accept();//一旦监听到客户端的请求,就返回一个负责和该客户端通信的套接字 sokConnection
//sokConnection.Receive
//向 列表控件中 添加一个 客户端的ip端口字符串,作为客户端的唯一标识
lbOnline.Items.Add(sokConnection.RemoteEndPoint.ToString());
//将 与客户端通信的 套接字对象 sokConnection 添加到 键值对集合中,并以客户端IP端口作为键
dict.Add(sokConnection.RemoteEndPoint.ToString(), sokConnection);
//创建 通信线程
ParameterizedThreadStart pts = new ParameterizedThreadStart(RecMsg);
Thread thr = new Thread(pts);
thr.IsBackground = true;//设置为
thr.Start(sokConnection);//启动线程 并为线程要调用的方法RecMsg 传入参数sokConnection
dictThread.Add(sokConnection.RemoteEndPoint.ToString(), thr);//将线程 保存在 字典里,方便大家以后做“踢人”功能的时候用
ShowMsg("客户端连接成功!" + sokConnection.RemoteEndPoint.ToString());
//sokConnection.RemoteEndPoint 中保存的是 当前连接客户端的 Ip和端口
}
}
/// <summary>
/// 服务端 负责监听 客户端 发送来的数据的 方法
/// </summary>
void RecMsg(object socketClientPara)
{
Socket socketClient = socketClientPara as Socket;
while (true)
{
//定义一个 接收用的 缓存区(2M字节数组)
byte[] arrMsgRec = new byte;
//将接收到的数据 存入 arrMsgRec 数组,并返回 真正接收到的数据 的长度
int length=-1;
try
{
length = socketClient.Receive(arrMsgRec);
}
catch (SocketException ex)
{
ShowMsg("异常:" + ex.Message);
//从 通信套接字 集合中 删除 被中断连接的 通信套接字对象
dict.Remove(socketClient.RemoteEndPoint.ToString());
//从 通信线程 结合中 删除 被终端连接的 通信线程对象
dictThread.Remove(socketClient.RemoteEndPoint.ToString());
//从 列表中 移除 被中断的连接 ip:Port
lbOnline.Items.Remove(socketClient.RemoteEndPoint.ToString());
break;
}
catch (Exception ex)
{
ShowMsg("异常:" + ex.Message);
break;
}
if (arrMsgRec == 0)//判断 发送过来的数据 的第一个元素是 0,则代表发送来的是 文字数据
{
//此时 是将 数组 所有的元素 都转成字符串,而真正接收到的 只有服务端发来的几个字符
string strMsgRec = System.Text.Encoding.UTF8.GetString(arrMsgRec,1, length-1);
ShowMsg(strMsgRec);
}
else if (arrMsgRec == 1)//如果是1 ,则代表发送过来的是 文件数据(图片/视频/文件....)
{
SaveFileDialog sfd = new SaveFileDialog();//保存文件选择框对象
if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)//用户选择文件路径后
{
string fileSavePath = sfd.FileName;//获得要保存的文件路径
//创建文件流,然后 让文件流来 根据路径 创建一个文件
using (FileStream fs = new FileStream(fileSavePath, FileMode.Create))
{
fs.Write(arrMsgRec, 1, length-1);
ShowMsg("文件保存成功:" + fileSavePath);
}
}
}
}
}
//发送消息到客户端
private void btnSend_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(lbOnline.Text))
{
MessageBox.Show("请选择要发送的好友");
}
else
{
string strMsg = txtMsgSend.Text.Trim();
//将要发送的字符串 转成 utf8对应的字节数组
byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(strMsg);
//获得列表中 选中的KEY
string strClientKey = lbOnline.Text;
//通过key,找到 字典集合中对应的 与某个客户端通信的 套接字的 send方法,发送数据给对方
try
{
dict.Send(arrMsg);
//sokConnection.Send(arrMsg);
ShowMsg("发送了数据出去:" + strMsg);
}
catch (SocketException ex)
{
ShowMsg("发送时异常:"+ex.Message);
}
catch (Exception ex)
{
ShowMsg("发送时异常:" + ex.Message);
}
}
}
//服务端群发消息
private void btnSendToAll_Click(object sender, EventArgs e)
{
string strMsg = txtMsgSend.Text.Trim();
//将要发送的字符串 转成 utf8对应的字节数组
byte[] arrMsg = System.Text.Encoding.UTF8.GetBytes(strMsg);
foreach (Socket s in dict.Values)
{
s.Send(arrMsg);
}
ShowMsg("群发完毕!:)");
}
#region 显示消息
/// <summary>
/// 显示消息
/// </summary>
/// <param name="msg"></param>
void ShowMsg(string msg)
{ 客户端:
–申请一个socket(socketClient)
–连接服务器(指明IP地址和端口号) 代码如下:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;
namespace MyChatRoomClient
{
public partial class FChatClient : Form
{
public FChatClient()
{
InitializeComponent();
TextBox.CheckForIllegalCrossThreadCalls = false;
}
Thread threadClient = null; //客户端 负责 接收 服务端发来的数据消息的线程
Socket socketClient = null;//客户端套接字
//客户端发送连接请求到服务器
private void btnConnect_Click(object sender, EventArgs e)
{
IPAddress address = IPAddress.Parse(txtIP.Text.Trim());//获得IP
IPEndPoint endpoint = new IPEndPoint(address, int.Parse(txtPort.Text.Trim()));//网络节点
//创建客户端套接字
socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//向 指定的IP和端口 发送连接请求
socketClient.Connect(endpoint);
//客户端 创建线程 监听服务端 发来的消息
threadClient = new Thread(RecMsg);
threadClient.IsBackground = true;
threadClient.Start();
}
/// <summary>
/// 监听服务端 发来的消息
/// </summary>
void RecMsg()
{
while (true)
{
//定义一个 接收用的 缓存区(2M字节数组)
byte[] arrMsgRec = new byte;
//将接收到的数据 存入 arrMsgRec 数组,并返回 真正接收到的数据 的长度
int length=socketClient.Receive(arrMsgRec);
//此时 是将 数组 所有的元素 都转成字符串,而真正接收到的 只有服务端发来的几个字符
string strMsgRec = System.Text.Encoding.UTF8.GetString(arrMsgRec, 0, length);
ShowMsg(strMsgRec);
}
}
void ShowMsg(string msg)
{
txtMsg.AppendText(msg + "\r\n");
}
}
} 上面的代码是ASP.Net的、 发现个问题,不同的编程语言写出来的这套东西,基本原理都一样。唯一是就开头的部分,不同的国籍的人都需要跟电脑硬件沟通,都需要表明自己是哪国的语言,然后根据自己国家的语法跟电脑说话,这样电脑就明白了 。 通信过程图 通过以上流程图我们可以看出,客户端与服务器端之间的一个基本通信流程,概括一下Socket 一般应用模式(客户端和服务器端)的作用:
服务器端:最少有两个socket,一个是服务端负责监听客户端发来连接请求,但不负责与请求的客户端通信,另一个是每当服务器端成功接收到客户端时,但在服务器端创建一个用与请求的客户端进行通信的socket.
客户端:指定要连接的服务器端地址和端口,通过创建一个socket对象来初始化一个到服务器端的TCP连接。
为我接下来要写的服务器的通信过程和插件调用做一个铺垫。 正在下载VC++英文版,300多M,我先去工作室调一下,我的游戏脚本。回来继续执行。 今天网络不稳定,游戏里的账号掉线了好多。真实辛苦的兼职。
继续执行编程:决定使用MFC实现我的软件。
我不得不顶了…… 加油吧 ...