资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/MySql+Socket 完成数据库的增查Demo

MySql+Socket 完成数据库的增查Demo

番茄西红柿 / 1325人阅读

摘要：之前没有试过利用技术完成请求这次也算是一次尝试偶尔看到这个程序以防以后需要做个笔记

         需求: 利用MySql数据库结合前端技术完成用户的注册(要求不使用Web服务技术),所以 Demo采用Socket技术实现Web通信.

第一部分:数据库创建

数据库采用mysql 5.7.18, 数据库名称为MyUser, 内部有一张表 user.字段有 Id,UserName,Psd,Tel

 

第二部分:数据库连接与Socket通信

创建控制台程序(服务端程序),添加以下类

1 MySqlHelper

 建立MySqlHelper 类,用于实现数据库操作

</>复制代码 
  1. public class MysqlHelper
  2.     {
  3.         //数据库连接字符串 
  4.         public static string Conn = "Database=Myuser;Data Source=localhost;User Id=root;Password=;charset=utf8"; //XXX的为修改项
  5.         
  6.         public static   void SetConn(string UserName = "root", string Password="", string IP= "localhost",   string Database="Myuser")
  7.         {
  8.             Conn = "datasource=" + IP + ";username=" + UserName + ";password=" + Password + ";database=" + Database + ";charset=utf8";
  9.            
  10.         }
  11.         ///  
  12.         /// 给定连接的数据库用假设参数执行一个sql命令（不返回数据集） 
  13.         ///  
  14.         /// 一个有效的连接字符串 
  15.         /// 命令类型(存储过程, 文本, 等等) 
  16.         /// 存储过程名称或者sql命令语句 
  17.         /// 执行命令所用参数的集合 
  18.         /// 执行命令所影响的行数 
  19.         public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  20.         {
  21.             MySqlCommand cmd = new MySqlCommand();
  22.             using (MySqlConnection conn = new MySqlConnection(connectionString))
  23.             {
  24.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
  25.                 int val = cmd.ExecuteNonQuery();
  26.                 cmd.Parameters.Clear();
  27.                 return val;
  28.             }
  29.         }
  30.         ///  
  31.         /// 用现有的数据库连接执行一个sql命令（不返回数据集） 
  32.         ///  
  33.         /// 一个现有的数据库连接 
  34.         /// 命令类型(存储过程, 文本, 等等) 
  35.         /// 存储过程名称或者sql命令语句 
  36.         /// 执行命令所用参数的集合 
  37.         /// 执行命令所影响的行数 
  38.         public static int ExecuteNonQuery(MySqlConnection connection, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  39.         {
  40.             MySqlCommand cmd = new MySqlCommand();
  41.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
  42.             int val = cmd.ExecuteNonQuery();
  43.             //cmd.Parameters.Clear();
  44.             return val;
  45.         }
  46.         ///  
  47.         ///使用现有的SQL事务执行一个sql命令（不返回数据集） 
  48.         ///  
  49.         ///  
  50.         ///举例: 
  51.         /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24)); 
  52.         ///  
  53.         /// 一个现有的事务 
  54.         /// 命令类型(存储过程, 文本, 等等) 
  55.         /// 存储过程名称或者sql命令语句 
  56.         /// 执行命令所用参数的集合 
  57.         /// 执行命令所影响的行数 
  58.         public static int ExecuteNonQuery(MySqlTransaction trans, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  59.         {
  60.             MySqlCommand cmd = new MySqlCommand();
  61.             PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
  62.             int val = cmd.ExecuteNonQuery();
  63.             cmd.Parameters.Clear();
  64.             return val;
  65.         }
  66.         ///  
  67.         /// 用执行的数据库连接执行一个返回数据集的sql命令 
  68.         ///  
  69.         ///  
  70.         /// 举例: 
  71.         /// MySqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24)); 
  72.         ///  
  73.         /// 一个有效的连接字符串 
  74.         /// 命令类型(存储过程, 文本, 等等) 
  75.         /// 存储过程名称或者sql命令语句 
  76.         /// 执行命令所用参数的集合 
  77.         /// 包含结果的读取器 
  78.         public static MySqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  79.         {
  80.             //创建一个MySqlCommand对象 
  81.             MySqlCommand cmd = new MySqlCommand();
  82.             //创建一个MySqlConnection对象 
  83.             MySqlConnection conn = new MySqlConnection(connectionString);
  84.             //在这里我们用一个try/catch结构执行sql文本命令/存储过程，因为如果这个方法产生一个异常我们要关闭连接，因为没有读取器存在， 
  85.             //因此commandBehaviour.CloseConnection 就不会执行 
  86.             try
  87.             {
  88.                 //调用 PrepareCommand 方法，对 MySqlCommand 对象设置参数 
  89.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
  90.                 //调用 MySqlCommand 的 ExecuteReader 方法 
  91.                 MySqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
  92.                 //清除参数 
  93.                 cmd.Parameters.Clear();
  94.                 return reader;
  95.             }
  96.             catch
  97.             {
  98.                 //关闭连接，抛出异常 
  99.                 conn.Close();
  100.                 throw;
  101.             }
  102.         }
  103.         ///  
  104.         /// 返回DataSet 
  105.         ///  
  106.         /// 一个有效的连接字符串 
  107.         /// 命令类型(存储过程, 文本, 等等) 
  108.         /// 存储过程名称或者sql命令语句 
  109.         /// 执行命令所用参数的集合 
  110.         ///  
  111.         public static DataSet GetDataSet(string connectionString, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  112.         {
  113.             //创建一个MySqlCommand对象 
  114.             MySqlCommand cmd = new MySqlCommand();
  115.             //创建一个MySqlConnection对象 
  116.             MySqlConnection conn = new MySqlConnection(connectionString);
  117.             //在这里我们用一个try/catch结构执行sql文本命令/存储过程，因为如果这个方法产生一个异常我们要关闭连接，因为没有读取器存在，
  118.             try
  119.             {
  120.                 //调用 PrepareCommand 方法，对 MySqlCommand 对象设置参数 
  121.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
  122.                 //调用 MySqlCommand 的 ExecuteReader 方法 
  123.                 MySqlDataAdapter adapter = new MySqlDataAdapter();
  124.                 adapter.SelectCommand = cmd;
  125.                 DataSet ds = new DataSet();
  126.                 adapter.Fill(ds);
  127.                 //清除参数 
  128.                 cmd.Parameters.Clear();
  129.                 conn.Close();
  130.                 return ds;
  131.             }
  132.             catch (Exception e)
  133.             {
  134.                 throw e;
  135.             }
  136.         }
  137.         public static DataTable GetDataTable(string connectionString, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  138.         {
  139.             //创建一个MySqlCommand对象 
  140.             MySqlCommand cmd = new MySqlCommand();
  141.             //创建一个MySqlConnection对象 
  142.             MySqlConnection conn = new MySqlConnection(connectionString);
  143.             //在这里我们用一个try/catch结构执行sql文本命令/存储过程，因为如果这个方法产生一个异常我们要关闭连接，因为没有读取器存在，
  144.             try
  145.             {
  146.                 //调用 PrepareCommand 方法，对 MySqlCommand 对象设置参数 
  147.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
  148.                 //调用 MySqlCommand 的 ExecuteReader 方法 
  149.                 MySqlDataAdapter adapter = new MySqlDataAdapter();
  150.                 adapter.SelectCommand = cmd;
  151.                 DataTable ds = new DataTable();
  152.                 adapter.Fill(ds);
  153.                 //清除参数 
  154.                 cmd.Parameters.Clear();
  155.                 conn.Close();
  156.                 return ds;
  157.             }
  158.             catch (Exception e)
  159.             {
  160.                 throw e;
  161.             }
  162.         }
  163.         ///  
  164.         /// 用指定的数据库连接字符串执行一个命令并返回一个数据集的第一列 
  165.         ///  
  166.         ///  
  167.         ///例如: 
  168.         /// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24)); 
  169.         ///  
  170.         ///一个有效的连接字符串 
  171.         /// 命令类型(存储过程, 文本, 等等) 
  172.         /// 存储过程名称或者sql命令语句 
  173.         /// 执行命令所用参数的集合 
  174.         /// 用 Convert.To{Type}把类型转换为想要的  
  175.         public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  176.         {
  177.             MySqlCommand cmd = new MySqlCommand();
  178.             using (MySqlConnection connection = new MySqlConnection(connectionString))
  179.             {
  180.                 PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
  181.                 object val = cmd.ExecuteScalar();
  182.                 cmd.Parameters.Clear();
  183.                 return val;
  184.             }
  185.         }
  186.         ///  
  187.         /// 用指定的数据库连接执行一个命令并返回一个数据集的第一列 
  188.         ///  
  189.         ///  
  190.         /// 例如: 
  191.         /// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24)); 
  192.         ///  
  193.         /// 一个存在的数据库连接 
  194.         /// 命令类型(存储过程, 文本, 等等) 
  195.         /// 存储过程名称或者sql命令语句 
  196.         /// 执行命令所用参数的集合 
  197.         /// 用 Convert.To{Type}把类型转换为想要的  
  198.         public static object ExecuteScalar(MySqlConnection connection, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
  199.         {
  200.             MySqlCommand cmd = new MySqlCommand();
  201.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
  202.             object val = cmd.ExecuteScalar();
  203.             cmd.Parameters.Clear();
  204.             return val;
  205.         }
  206.         ///  
  207.         /// 准备执行一个命令 
  208.         ///  
  209.         /// sql命令 
  210.         /// OleDb连接 
  211.         /// OleDb事务 
  212.         /// 命令类型例如 存储过程或者文本 
  213.         /// 命令文本,例如:Select * from Products 
  214.         /// 执行命令的参数 
  215.         private static void PrepareCommand(MySqlCommand cmd, MySqlConnection conn, MySqlTransaction trans, CommandType cmdType, string cmdText, MySqlParameter[] cmdParms)
  216.         {
  217.             if (conn.State != ConnectionState.Open)
  218.                 conn.Open();
  219.             cmd.Connection = conn;
  220.             cmd.CommandText = cmdText;
  221.             if (trans != null)
  222.                 cmd.Transaction = trans;
  223.             cmd.CommandType = cmdType;
  224.             if (cmdParms != null)
  225.             {
  226.                 foreach (MySqlParameter parm in cmdParms)
  227.                     cmd.Parameters.Add(parm);
  228.             }
  229.         }
  230.     }

　　

2,User类与UserHelper类

建立用户类User与用户操作类UserHelper

User

</>复制代码 
  1. public class User
  2.     {
  3.         public int Id { get; set; }
  4.         public string UserName { get; set; }
  5.         public string Psd { get; set; }
  6.         public string PhoneNum { get; set; }
  7.      
  8.     }

　　

UserHelper

</>复制代码 
  1. public   class UserHelper
  2.     {
  3.         /// 
  4.         /// 获取用户列表
  5.         /// 
  6.         /// 
  7.         /// 
  8.         public static  List GetUsers()
  9.         {
  10.             var cmdText = "select * from Users";
  11.             var data = MysqlHelper.GetDataSet(MysqlHelper.Conn, System.Data.CommandType.Text, cmdText, new MySql.Data.MySqlClient.MySqlParameter());
  12.             List userList = new List();
  13.             foreach (DataRow row in data.Tables[0].Rows)
  14.             {
  15.                 User user = new User();
  16.                 user.Id = int.Parse(row[0].ToString());
  17.                 user.UserName=(row[1].ToString());
  18.                 user.Psd=(row[2].ToString());
  19.                 user.PhoneNum=(row[3].ToString());
  20.                 userList.Add(user);
  21.             }
  22.             return userList;
  23.         }
  24.         /// 
  25.         /// 根据姓名查找用户
  26.         /// 
  27.         /// 
  28.         /// 
  29.         public static  User GetUserByName(string name)
  30.         {
  31.             var cmdText = "select * from Users Where UserName=?name";
  32.             var pars = new MySql.Data.MySqlClient.MySqlParameter("?name", name);
  33.             var data = MysqlHelper.GetDataSet(MysqlHelper.Conn, System.Data.CommandType.Text, cmdText, pars);
  34.             User user = new User();
  35.             if (data.Tables.Count == 0)
  36.             {
  37.                 return null;
  38.             }
  39.             if (data.Tables[0].Rows.Count != 1)
  40.             {
  41.                 return null;
  42.             }
  43.             foreach (DataRow row in data.Tables[0].Rows)
  44.             {               
  45.                 user.Id = int.Parse(row[0].ToString());
  46.                 user.UserName = (row[1].ToString());
  47.                 user.Psd = (row[2].ToString());
  48.                 user.PhoneNum = (row[3].ToString());
  49.                 ;
  50.             }
  51.             return user;
  52.         }
  53.         /// 
  54.         /// 添加用户
  55.         /// 
  56.         /// 
  57.         /// 
  58.         public static bool AddUser(User user)
  59.         {
  60.             var sqlInsert = "insert into Users(UserName,Psd,Tel) values" +
  61.                "(" + user.UserName + "," + user.Psd + "," + user.PhoneNum + ")";           
  62.             var parms = new MySqlParameter();
  63.             var data = MysqlHelper.ExecuteNonQuery(MysqlHelper.Conn, System.Data.CommandType.Text, sqlInsert, parms);
  64.            
  65.             return data>0;
  66.         }
  67.     }

　　

3 Socket

网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket.socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；

利用Socket技术,可以捕捉Http请求,获取数据.构建SocketHelper类,获取前端页面请求.默认Socket 端口为8086

</>复制代码 
  1. public class SocketHelper
  2.     {
  3.         static Socket m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  4.         /// 
  5.         /// Socket初始化 
  6.         /// 
  7.         public static bool  Init()
  8.         {
  9.             try
  10.             {
  11.                 m_socket.Bind(new IPEndPoint(IPAddress.Any, 8086));
  12.                 m_socket.Listen(100);
  13.                 m_socket.BeginAccept(new AsyncCallback(OnAccept), m_socket);
  14.                 Console.WriteLine("开启Socket服务成功!!");
  15.                 Console.Read();
  16.                 return true;
  17.             }
  18.             catch (Exception )
  19.             {
  20.                 Console.WriteLine("开启Socket服务失败!!,请检查网络,端口8086是否被占用!!!");
  21.                 Console.Read();
  22.                 return false;
  23.             }
  24.           
  25.         }
  26.         public static void Route(string path, Dictionary param, Socket response)
  27.         {
  28.             if (param.Count == 1)
  29.             {
  30.                 try
  31.                 {
  32.                     var userName = param["userName"];
  33.                     var searUser = UserHelper.GetUserByName(userName);
  34.                     if (searUser != null)
  35.                     {
  36.                         HomePage(response, "该用户名已经被占用!!");
  37.                         Console.WriteLine("** - **");
  38.                         Console.WriteLine("用户名" + userName + "被占用");
  39.                         Console.WriteLine("");
  40.                         HomePage(response, "no");
  41.                     }
  42.                     else
  43.                     {
  44.                         HomePage(response, "ok");
  45.                     }
  46.                 }
  47.                 catch (Exception e)
  48.                 {
  49.                     HomePage(response, e.Message);
  50.                     Console.WriteLine("** - **");
  51.                     Console.WriteLine("发生错误,错误原因为" + e.Message);
  52.                     Console.WriteLine("");
  53.                 }
  54.                
  55.                 return;
  56.             }
  57.             else if (param.Count == 3) {
  58.                 try
  59.                 {
  60.                     User user = new User();
  61.                     user.UserName = param["userName"];
  62.                     user.Psd = param["psd"];
  63.                     user.PhoneNum = param["phoneNum"];
  64.                     var isSuccess = UserHelper.AddUser(user);
  65.                     if (isSuccess)
  66.                     {
  67.                         HomePage(response, "ok");
  68.                         Console.WriteLine("** - **");
  69.                         Console.WriteLine("用户名为" + user.UserName + "已添加到数据库!!");
  70.                         Console.WriteLine("");
  71.                     }
  72.                     else
  73.                     {
  74.                         HomePage(response, "no");
  75.                         Console.WriteLine("** - **");
  76.                         Console.WriteLine("用户名为" + user.UserName + "添加到数据库失败!!");
  77.                         Console.WriteLine("");
  78.                     }
  79.                 }
  80.                 catch (Exception e)
  81.                 {
  82.                     HomePage(response, e.Message);
  83.                     Console.WriteLine("** - **");
  84.                     Console.WriteLine("发生错误,错误原因为" + e.Message);
  85.                     Console.WriteLine("");
  86.                 }
  87.             }
  88.             else
  89.             {
  90.                 HomePage(response, "参数错误!!");
  91.                 Console.WriteLine("** - **");
  92.                 Console.WriteLine("参数错误" );
  93.                 Console.WriteLine("");
  94.             }
  95.            
  96.             return;
  97.             
  98.         }
  99.         public static void OnAccept(IAsyncResult ar)
  100.         {
  101.             try
  102.             {
  103.                 Socket socket = ar.AsyncState as Socket;
  104.                 Socket new_client = socket.EndAccept(ar);
  105.                 socket.BeginAccept(new AsyncCallback(OnAccept), socket);
  106.                 byte[] recv_buffer = new byte[1024 * 640];
  107.                 int real_recv = new_client.Receive(recv_buffer);
  108.                 string recv_request = Encoding.UTF8.GetString(recv_buffer, 0, real_recv);
  109.                 Console.WriteLine(recv_request);
  110.                 Resolve(recv_request, new_client);
  111.             }
  112.             catch
  113.             {
  114.             }
  115.         }
  116.         public static void Resolve(string request, Socket response)
  117.         {
  118.             string[] strs = request.Split(new string[] { "rn" }, StringSplitOptions.None);
  119.             if (strs.Length > 0)
  120.             {
  121.                 string[] items = strs[0].Split( );
  122.                 Dictionary param = new Dictionary();
  123.                 if (strs.Contains(""))
  124.                 {
  125.                     string post_data = strs[strs.Length - 1];
  126.                     if (post_data != "")
  127.                     {
  128.                         string[] post_datas = post_data.Split(&);
  129.                         foreach (string s in post_datas)
  130.                         {
  131.                             param.Add(s.Split(=)[0], s.Split(=)[1]);
  132.                         }
  133.                     }
  134.                 }
  135.                 Route(items[1], param, response);
  136.             }
  137.         }
  138.         public static void HomePage(Socket response,string result)
  139.         {
  140.             string statusline = "HTTP/1.1 200 OKrn";
  141.             byte[] statusline_to_bytes = Encoding.UTF8.GetBytes(statusline);
  142.             string content = result;
  143.             byte[] content_to_bytes = Encoding.UTF8.GetBytes(content);
  144.             string header = string.Format("Access-Control-Allow-Origin:*rnContent-Type:text/html;charset=UTF-8rnContent-Length:{0}rn", content_to_bytes.Length);
  145.             byte[] header_to_bytes = Encoding.UTF8.GetBytes(header);
  146.             response.Send(statusline_to_bytes);
  147.             response.Send(header_to_bytes);
  148.             response.Send(new byte[] { (byte)r, (byte)n });
  149.             response.Send(content_to_bytes);
  150.             response.Close();
  151.         }
  152.     }

　　

第三部分 前端页面与Ajax请求

 前端页面设计为:

ajax请求代码:

</>复制代码 
  1. $(.red_button).click(function () {
  2.   if (user_Boolean && password_Boolean && varconfirm_Boolean && Mobile_Boolean == true) {
  3.     $.ajax({
  4.       type: POST,
  5.       url: http://127.0.0.1:8086/,
  6.       data: {
  7.         userName:$(#userName).val(),
  8.         psd: $(#psd).val(),
  9.         phoneNum: $(#phoneNum).val()
  10.       },
  11.       success: function (data) {
  12.         if (data == "ok") {
  13.           alert("注册成功!!")
  14.         } else {
  15.           alert("data");
  16.         }
  17.         
  18.       }
  19.     });
  20.   } 
  21.   else {
  22.     alert("请完善信息");
  23.   }
  24. });

 

至此,程序完成.运行程序进行验证.

1:启动服务端程序

 

 

2:启动前端页面，进行数据填写

3 添加结果

 

    至此 ，Demo功能完成。之前没有试过利用Socket技术完成Ajax请求,这次也算是一次尝试,偶尔看到这个程序,以防以后需要 做个笔记..

 

 

 

 

 

 

 

云服务器 GPU云服务器 增查改删 c语言一组数据的增 linux的增删改查 php的增删改查实例

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/1856.html

相关文章

  • 迈出全栈第一步，vue+node+mysql独立完成前后端分离的增删改查流程

    摘要：本使用创建本地服务器，在就能完成全部流程，并不需要线上服务器。路径要与后端接口一致。后端返回成功后，前端数据中对应的元素也要删掉，更新视图。控制器里拿一个方法出来说一下吧，完整的代码都在。读取操作完成后调用释放连接。 写在前面 本文只是本人学习过程的一个记录，并不是什么非常严谨的教程，希望和大家一起共同进步。也希望大家能指出我的问题。适合有一定基础，志在全栈的前端初学者学习，从点击按钮...

    fsmStudy 评论0 收藏0

  • 数据库相关异常分析

    摘要：起因最近一段时间，生产系统持续碰到一些数据库异常，导致执行失败。综上，若发生异常，为数据库连接失效，但是失效的原因可能会有多种，大致都与各种参数相关。当时数据量大概多条，然后在批量插入时抛出该异常。 起因 最近一段时间，生产系统持续碰到一些数据库异常，导致 sql 执行失败。 应用环境 Java 1.7 + Mysql 5.6 + spring + ibatis 问题排查 将各种失败的...

    IamDLY 评论0 收藏0

发表评论

登陆后可评论

0条评论

番茄西红柿

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<