• Qt操作Sqlite类封装，及命令行导入csv文件到Sqlite数据库

    日常工作中，有时候需要对数据进行分析。如果能把待分析的数据导入sqllite数据库，是种不错的分析手段。或者需要导入其他数据库中的数据，做数据迁移用，比如可以把其他数据库中的表数据导出为csv文件，再把csv文件导入到sqllite。

    用Qt来操作sqlite，可以做些带界面和图表的分析，使用很方便。

    这里记录下导入csv文件到sqlite数据库的操作方法及sqlite的封装，留作备忘。

    浏览sqllite数据库的客户端工具，我常用的是SQLiteSpy，仅4M大小，小巧简单。

     导入csv到sqlite

    使用sqlite3.exe命令行工具。这个sqllite数据库带的有这个工具，可以直接下载使用。

    操作的步骤：

    1.打开数据库文件（前提存在db文件，且里面有相应的表结构）

     .\sqlite3.exe .\test.db

    2.命令行操作

    1. //查看数据库
    2. .databases
    1. // 查看数据
    2. select * from tb_user;
    3. 1|yang|10
    1. //查看表
    2. .tables

    3.导入csv文件到sqlite

    这其中有个特别需要注意的问题是：csv文件的编码问题，必须为utf-8格式，utf-8-bom不行。

    1. // 必须修改为,分隔符 
    2. .separator ","
    3.  
    4. // 查看表结构
    5. .schema tb_data
    6.  
    7. // 导入csv数据到表中 (前提 结构必须一致)                                                           
    8. .import dbo_data.csv tb_data

    以上操作即完成了csv文件数据入库的操作。

    qt操作sqlite封装

    Qt中操作数据库，.pro文件中，需要添加上：

    QT += sql

    1. #ifndef SQLITEDB_H
    2. #define SQLITEDB_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15. class sqliteDb
    16. {
    17. public:
    18.     sqliteDb();
    19.     ~sqliteDb();
    20. public:
    21.     bool setDbDir(QString dirPath);//设置数据库存放路径
    22.     bool creatDbFile(QString dbName);//生成一个db文件
    23.     bool reOpenSql(QString dbName);//打开连接
    24.     bool closeSql();//关闭连接
    25.     bool queryExec(QString dbName,QString sqlStr);//执行sql语句，不获取结果
    26.     bool queryExec(QString dbName,QString sqlStr,QList> &data);//执行sql语句，并获取结果
    27.     bool getData(QString dbName,QString tableName,QHash &data,QString sqlWhere=""); //获取数据
    28.     bool getData(QString dbName,QString table,QList> &data,QString sqlWhere=""); //获取数据
    29.     bool getData(QString dbName,QString tableName,QHash columndata,QList> &data,QString sqlWhere=""); //获取数据
    30.     bool addData(QString dbName,QString tableName,QHash data);//增加
    31.     bool delData(QString dbName,QString tableName,QString sqlWhere);//删除
    32.     bool updateData(QString dbName,QString tableName,QHash data,QString sqlWhere="");//修改
    33.  
    34.     bool queryExec(QString sqlStr);//执行sql语句，不获取结果
    35.     bool queryExec(QString sqlStr,QList> &data);//执行sql语句，并获取结果
    36.     bool getData(QString tableName,QHash &data,QString sqlWhere=""); //获取数据
    37.     bool getData(QString table,QList> &data,QString sqlWhere=""); //获取数据
    38.     bool getData(QString tableName,QHash columndata,QList> &data,QString sqlWhere=""); //获取数据
    39.     bool addData(QString tableName,QHash data);//增加
    40.     bool delData(QString tableName,QString sqlWhere);//删除
    41.     bool updateData(QString tableName,QHash data,QString sqlWhere="");//修改
    42.     bool transaction();
    43.     bool commit();
    44.     QString getErrorSql();//获取错误的数据库语句
    45. private:
    46.     QSqlDatabase db;
    47.     QString dbFilePath;//数据库路径
    48.     QString dbDir; //数据库文件夹
    49.     QString databaseName;//数据库名字
    50.     QString errorSqlText;//错误语句
    51. private:
    52.     void errorSql(QString sql);//错误打印
    53. };
    54.  
    55. #endif // SQLITEDB_H
    56.  
    1. #include "sqlitedb.h"
    2.  
    3. sqliteDb::sqliteDb()
    4. {
    5.     dbDir = QDir::currentPath() ;
    6. }
    7. sqliteDb::~sqliteDb()
    8. {
    9.  
    10. }
    11. //设置数据库存放路径
    12. bool sqliteDb::setDbDir(QString dirPath)
    13. {
    14.     QDir dir(dirPath);
    15.     if(dir.exists())
    16.     {
    17.         dbDir = dirPath;
    18.         return true;
    19.     }
    20.     else
    21.     {
    22.         return false;
    23.     }
    24. }
    25. //打开连接
    26. bool sqliteDb::reOpenSql(QString dbName)
    27. {
    28.     QString fileName = (dbDir + "/"+dbName + ".db");
    29.     if(!QFile::exists(fileName))
    30.     {
    31.         qWarning("error,db not exist");
    32.         return false;//数据库不存在
    33.     }
    34.     QFileInfo file(fileName);
    35.     if(file.suffix() != "db")
    36.         return false;
    37.     db = QSqlDatabase::database(dbName);
    38.     if(!db.isValid())
    39.     {
    40.         db = QSqlDatabase::addDatabase("QSQLITE",dbName);
    41.         db.setDatabaseName(fileName);
    42.         if (!db.open())
    43.         {
    44.             return false;//打开失败
    45.         }
    46.     }
    47.     dbFilePath = fileName;
    48.     databaseName = dbName;//数据库名字
    49.     return true;
    50. }
    51. //关闭连接
    52. bool sqliteDb::closeSql()
    53. {
    54.     if(databaseName.isEmpty())
    55.         return true;
    56.     if(!QFile::exists(dbFilePath))
    57.     {
    58.         return false;//数据库不存在
    59.     }
    60.     db = QSqlDatabase::database(databaseName);
    61.     if(!db.isValid())
    62.     {
    63.         return true;
    64.     }
    65.     db.close();
    66.     db = QSqlDatabase::database();
    67.     QSqlDatabase::removeDatabase(databaseName);
    68.     databaseName = "";
    69.     dbFilePath = "";
    70.     return true;
    71. }
    72. //生成一个db文件
    73. bool sqliteDb::creatDbFile(QString dbName)
    74. {
    75.     QString fileName = (dbDir + "/"+dbName + ".db");
    76.     QFileInfo fileInfo(fileName);
    77.     if(fileInfo.isFile()){
    78.         qWarning("db已存在，创建失败");
    79.         return false;
    80.     }
    81.     QFile file(fileName);
    82.     if(file.open(QIODevice::WriteOnly))
    83.     {
    84.         file.close();
    85.     }
    86.     else
    87.     {
    88.         return false;
    89.     }
    90.     return true;
    91. }
    92. //错误打印
    93. void sqliteDb::errorSql(QString sql)
    94. {
    95.     errorSqlText = sql;
    96.     qCritical("%s",qPrintable(errorSqlText));
    97.     //QString("数据库执行错误：%1 ")+sql.toUtf8().constData();
    98. }
    99. //获取错误的数据库语句
    100. QString sqliteDb::getErrorSql()
    101. {
    102.     if(databaseName.isEmpty())
    103.     {
    104.         return "db  not setting";//数据库未设置
    105.     }
    106.     return errorSqlText;
    107. }
    108. //执行sql语句，不获取结果
    109. bool sqliteDb::queryExec(QString dbName,QString queryStr)
    110. {
    111.     if(databaseName.isEmpty())
    112.     {
    113.         if(!reOpenSql(dbName))
    114.         {
    115.             return false;
    116.         }
    117.     }
    118.     QSqlQuery query(QSqlDatabase::database(dbName, true));
    119.     if(!query.exec(queryStr))
    120.     {
    121.         errorSql(queryStr);
    122.         return false;
    123.     }
    124.     return  true;
    125. }
    126. //执行sql语句，并获取结果
    127. bool sqliteDb::queryExec(QString dbName,QString queryStr,QList> &data)
    128. {
    129.     data.clear();
    130.     if(databaseName.isEmpty())
    131.     {
    132.         if(!reOpenSql(dbName))
    133.         {
    134.             return false;
    135.         }
    136.     }
    137.     QSqlQuery query(QSqlDatabase::database(dbName, true));
    138.     if(!query.exec(queryStr))
    139.     {
    140.         errorSql(queryStr);
    141.         return false;
    142.     }
    143.     QSqlRecord rec = query.record();
    144.     while(query.next())
    145.     {
    146.         QHash rowData;
    147.         for(int i =0;icount();i++)
    148.         {
    149.             QVariant::Type ty =  query.value(i).type();
    150.             if( QVariant::Type::Date == ty)
    151.             {
    152.                 QDate temp = query.value(i).toDate();
    153.                 rowData[rec.fieldName(i)]=temp.toString("yyyy-MM-dd");
    154.             }
    155.             else if( QVariant::Type::Time == ty)
    156.             {
    157.                 QTime temp = query.value(i).toTime();
    158.                 rowData[rec.fieldName(i)]=temp.toString("hh:mm:ss");
    159.             }
    160.             else if( QVariant::Type::DateTime == ty)
    161.             {
    162.                 QDateTime temp = query.value(i).toDateTime();
    163.                 rowData[rec.fieldName(i)]=temp.toString("yyyy-MM-dd hh:mm:ss");
    164.             }
    165.             else
    166.                 rowData[rec.fieldName(i)]=query.value(i).toString();
    167.         }
    168.         data.append(rowData);
    169.     }
    170.     return  true;
    171. }
    172. //获取数据
    173. bool sqliteDb::getData(QString dbName,QString tableName,QHash &data,QString sqlWhere)
    174. {
    175.     data.clear();
    176.     QList> dataList;
    177.     if(!getData(dbName,tableName,dataList,sqlWhere))
    178.     {
    179.         return false;
    180.     }
    181.     if(dataList.count() > 0)
    182.     {
    183.         data = dataList[0];
    184.     }
    185.     return true;
    186. }
    187. //获取数据
    188. bool sqliteDb::getData(QString dbName,QString tableName,QList> &data,QString sqlWhere)
    189. {
    190.     QString queryStr="select * from "+tableName;
    191.     if(!sqlWhere.isEmpty())
    192.         queryStr+=" "+sqlWhere;
    193.     if(!queryExec(dbName,queryStr,data))
    194.     {
    195.         return  false;
    196.     }
    197.     return  true;
    198. }
    199. //获取数据
    200. bool sqliteDb::getData(QString dbName,QString tableName,QHash columndata,QList> &data,QString sqlWhere)
    201. {
    202.     QString colunmStr;
    203.     if(columndata.count() == 0)
    204.         colunmStr = "*";
    205.     else
    206.     {
    207.         QStringList keys = columndata.keys();
    208.         for(auto key : keys)
    209.         {
    210.             QString column = QString("%1 AS `%2`").arg(key).arg(columndata[key]);
    211.             if(!colunmStr.isEmpty())
    212.                 colunmStr += ",";
    213.             colunmStr += column;
    214.         }
    215.     }
    216.     QString queryStr = QString("SELECT %1 FROM %2 %3").arg(colunmStr).arg(tableName).arg( sqlWhere);
    217.     if(!queryExec(dbName,queryStr,data))
    218.     {
    219.         return  false;
    220.     }
    221.     return  true;
    222. }
    223. //增加
    224. bool sqliteDb::addData(QString dbName,QString tableName,QHash data)
    225. {
    226.     if(data.isEmpty())
    227.         return false;
    228.     QString queryStr="insert into "+tableName+" ";
    229.     QString fieldStr="(",valueStr="values(";
    230.     QHash::iterator it;
    231.     for ( it = data.begin(); it != data.end(); ++it )
    232.     {
    233.         fieldStr+=it.key()+",";
    234.         valueStr+="'"+it.value()+"',";
    235.     }
    236.     fieldStr=fieldStr.left(fieldStr.length()-1);
    237.     valueStr=valueStr.left(valueStr.length()-1);
    238.     fieldStr+=")";
    239.     valueStr+=")";
    240.     queryStr+=fieldStr+" "+valueStr;
    241.     if(!queryExec(dbName,queryStr))
    242.     {
    243.         return false;
    244.     }
    245.     return true;
    246. }
    247. //删除
    248. bool sqliteDb::delData(QString dbName, QString tableName, QString sqlWhere)
    249. {
    250.     QString queryStr="delete from "+tableName;
    251.     if(!sqlWhere.isEmpty())
    252.         queryStr+=" "+sqlWhere;
    253.     if(!queryExec(dbName,queryStr))
    254.     {
    255.         return false;
    256.     }
    257.     return true;
    258. }
    259. //修改
    260. bool sqliteDb::updateData(QString dbName,QString tableName,QHash data,QString sqlWhere)
    261. {
    262.     QString queryStr="update "+tableName+" ";
    263.     QHash::iterator it;
    264.     QString setStr="set ";
    265.     for ( it = data.begin(); it != data.end(); ++it )
    266.     {
    267.         setStr+=it.key()+"='"+it.value()+"'";
    268.         setStr+=",";
    269.     }
    270.     setStr=setStr.left(setStr.length()-1);
    271.     queryStr+=setStr;
    272.     if(!sqlWhere.isEmpty())
    273.         queryStr+=" "+sqlWhere;
    274.     if(!queryExec(dbName,queryStr))
    275.     {
    276.         return false;
    277.     }
    278.     return true;
    279. }
    280. bool sqliteDb::transaction()
    281. {
    282.     if(databaseName.isEmpty())
    283.         return false;
    284.     return  db.transaction();
    285. }
    286. bool sqliteDb::commit()
    287. {
    288.     if(databaseName.isEmpty())
    289.         return false;
    290.     return  db.commit();
    291. }
    292. //执行sql语句，不获取结果
    293. bool sqliteDb::queryExec(QString sqlStr)
    294. {
    295.     if(databaseName.isEmpty())
    296.         return false;
    297.     return  queryExec(databaseName,sqlStr);
    298. }
    299. //执行sql语句，并获取结果
    300. bool sqliteDb::queryExec(QString sqlStr,QList> &data)
    301. {
    302.     if(databaseName.isEmpty())
    303.         return false;
    304.     return  queryExec(databaseName,sqlStr,data);
    305. }
    306. //获取数据
    307. bool sqliteDb::getData(QString tableName,QHash &data,QString sqlWhere)
    308. {
    309.     if(databaseName.isEmpty())
    310.         return false;
    311.     return  getData(databaseName,tableName,data,sqlWhere);
    312. }
    313. //获取数据
    314. bool sqliteDb::getData(QString table,QList> &data,QString sqlWhere)
    315. {
    316.     if(databaseName.isEmpty())
    317.         return false;
    318.     return  getData(databaseName,table,data,sqlWhere);
    319. }
    320. //获取数据
    321. bool sqliteDb::getData(QString tableName,QHash columndata,QList> &data,QString sqlWhere)
    322. {
    323.     if(databaseName.isEmpty())
    324.         return false;
    325.     return  getData(databaseName,tableName,columndata,data,sqlWhere);
    326. }
    327. //增加
    328. bool sqliteDb::addData(QString tableName,QHash data)
    329. {
    330.     if(databaseName.isEmpty())
    331.         return false;
    332.     return  addData(databaseName,tableName,data);
    333. }
    334. //删除
    335. bool sqliteDb::delData(QString tableName,QString sqlWhere)
    336. {
    337.     if(databaseName.isEmpty())
    338.         return false;
    339.     return  delData(databaseName,tableName,sqlWhere);
    340. }
    341. //修改
    342. bool sqliteDb::updateData(QString tableName,QHash data,QString sqlWhere)
    343. {
    344.     if(databaseName.isEmpty())
    345.         return false;
    346.     return  updateData(databaseName,tableName,data,sqlWhere);
    347. }
    348. //

     使用举例

    新建一个dbhelper类，作为具体的操作使用。

    1. #include "dbhelper.h"
    2. #include "cglobal.h"
    3. Dbhelper::Dbhelper()
    4. {
    5.     db = new sqliteDb();
    6.     init_table_0 = R"(
    7.                  CREATE TABLE IF NOT EXISTS  tb_user (
    8.                  id   INTEGER   PRIMARY KEY AUTOINCREMENT NOT NULL,
    9.                  name CHAR (50) NOT NULL,
    10.                  age  INTEGER
    11.                  );)";
    12. }
    13.  
    14. Dbhelper::~Dbhelper()
    15. {
    16.     if(db!= nullptr){
    17.         db->closeSql();
    18.         delete db;
    19.     }
    20. }
    21.  
    22. int Dbhelper::createTable()
    23. {
    24.     db->setDbDir(DATA_PATH);
    25.     bool ret = db->creatDbFile(DB_NAME);
    26.     if(!ret){
    27.         return -1;
    28.     }
    29.     ret = db->reOpenSql(DB_NAME);
    30.     if(ret){
    31.         db->queryExec(QString::fromStdString(init_table_0));
    32.         db->queryExec(QString::fromStdString(init_table_1));
    33.         db->queryExec(QString::fromStdString(init_table_2));
    34.     }
    35.  
    36.     return 0;
    37. }

    简单使用：

    1.     Dbhelper mydb;
    2.     //若库不存在则自动创建库和表
    3.     mydb.createTable();
    4.     //打开数据库
    5.     auto ret = mydb.db->reOpenSql(DB_NAME);
    6.     if(!ret){
    7.        qCritical("打开数据库失败");
    8.     }
    9.     //插入一条测试数据
    10.     QHash data;
    11.     data["name"] = "yang";
    12.     data["age"] = "10";
    13.     mydb.db->addData("tb_user",data);
    14.     //......

    注意事项

    由于QSqlDatabase机制问题，不能跨线程访问，上述封装的连接和使用只能在同一个线程中使用。若需要放在多线程中使用，则需要改下query的实现方法，如：

    1. //执行sql语句，并获取结果
    2. bool sqliteDb::queryExec(QString dbName,QString queryStr,QList> &data)
    3. {
    4.  
    5.     if(QSqlDatabase::contains("default")){
    6.          qDebug() << "query error,now in use";
    7.          return false;
    8.     }
    9.  
    10.     data.clear();
    11.  
    12.     {
    13.         QSqlDatabase mdb;
    14.         {
    15.             mdb= QSqlDatabase::addDatabase("QSQLITE","default");
    16.             mdb.setDatabaseName("./liuliang.db");
    17.             auto ret =  mdb.open();
    18.             if(!ret){
    19.                  qCritical("error,open",qPrintable(errorSqlText));
    20.             }
    21.         }
    22.  
    23.         QSqlQuery query(mdb);
    24.         if(!query.exec(queryStr))
    25.         {
    26.             qDebug() << mdb.lastError();
    27.             errorSql(queryStr);
    28.             return false;
    29.         }
    30.         QSqlRecord rec = query.record();
    31.         while(query.next())
    32.         {
    33.             QHash rowData;
    34.             for(int i =0;icount();i++)
    35.             {
    36.                 QVariant::Type ty =  query.value(i).type();
    37.                 if( QVariant::Type::Date == ty)
    38.                 {
    39.                     QDate temp = query.value(i).toDate();
    40.                     rowData[rec.fieldName(i)]=temp.toString("yyyy-MM-dd");
    41.                 }
    42.                 else if( QVariant::Type::Time == ty)
    43.                 {
    44.                     QTime temp = query.value(i).toTime();
    45.                     rowData[rec.fieldName(i)]=temp.toString("hh:mm:ss");
    46.                 }
    47.                 else if( QVariant::Type::DateTime == ty)
    48.                 {
    49.                     QDateTime temp = query.value(i).toDateTime();
    50.                     rowData[rec.fieldName(i)]=temp.toString("yyyy-MM-dd hh:mm:ss");
    51.                 }
    52.                 else
    53.                     rowData[rec.fieldName(i)]=query.value(i).toString();
    54.             }
    55.             data.append(rowData);
    56.         }
    57.     }
    58.  
    59.     qDebug() << "query ok";
    60.     QSqlDatabase::removeDatabase("default");
    61.     return  true;
    62. }

    SQLiteDatabse实质上是将数据写入一个文件，我们可以得知SQLiteDatabse是文件级别的锁。多个线程可以同时读；但是多个线程同时读／写时：如读先发生，写会被阻塞直至读完毕，写才会继续执行；如写先发生，读会被阻塞直至写完毕，读才会继续执行。 

    Qt字节转换

    1. #include "stringutils.h"
    2. #include 
    3. #include  //解决QBytearray中文乱码问题
    4. #include 
    5. //将1-9 a-f字符转化为对应的整数
    6.  char ConvertHexChar(char ch)
    7.     {
    8.         if((ch >= '0') && (ch <= '9'))
    9.             return ch-0x30;
    10.         else if((ch >= 'A') && (ch <= 'F'))
    11.             return ch-'A'+10;
    12.         else if((ch >= 'a') && (ch <= 'f'))
    13.             return ch-'a'+10;
    14.         else return (-1);
    15.     }
    16. //将字符型进制转化为16进制
    17.  QByteArray QString2Hex(QString str)
    18.     {
    19.         QByteArray senddata;
    20.         int hexdata,lowhexdata;
    21.         int hexdatalen = 0;
    22.         int len = str.length();
    23.         senddata.resize(len/2);
    24.         char lstr,hstr;
    25.         for(int i=0; i
    26.         {
    27.             hstr=str[i].toLatin1();   //字符型
    28.             if(hstr == ' ')
    29.             {
    30.                 i++;
    31.                 continue;
    32.             }
    33.             i++;
    34.             if(i >= len)
    35.                 break;
    36.             lstr = str[i].toLatin1();
    37.             hexdata = ConvertHexChar(hstr);
    38.             lowhexdata = ConvertHexChar(lstr);
    39.             if((hexdata == 16) || (lowhexdata == 16))
    40.                 break;
    41.             else
    42.                 hexdata = hexdata*16+lowhexdata;
    43.             i++;
    44.             senddata[hexdatalen] = (char)hexdata;
    45.             hexdatalen++;
    46.         }
    47.         senddata.resize(hexdatalen);
    48.         return senddata;
    49.     }
    50.  
    51. //将接收的一串QByteArray类型的16进制,转化为对应的字符串16进制
    52.  QString Hex2QString(QByteArray str)
    53.  {
    54.  
    55.      QDataStream out(&str,QIODevice::ReadWrite);   //将str的数据 读到out里面去
    56.      QString buf;
    57.      while(!out.atEnd())
    58.      {
    59.            qint8 outChar = 0;
    60.            out >> outChar;   //每次一个字节的填充到 outchar
    61.            QString str = QString("%1").arg(outChar&0xFF,2,16,QLatin1Char('0')).toUpper() + QString("");   //2 字符宽度
    62.  
    63.            buf += str;
    64.      }
    65.      return buf;
    66.  }
    67.  QString ShowStr(QByteArray arr)
    68.  {
    69.  
    70.      //QDataStream out(&str,QIODevice::ReadWrite);   //将str的数据 读到out里面去
    71.      //QString buf;
    72.      //buf.prepend(str);
    73.  
    74. //     while(!out.atEnd())
    75. //     {
    76. //           qint8 outChar = 0;
    77. //           out >> outChar;   //每次一个字节的填充到 outchar
    78. //           QString str = QString("%1").arg(outChar&0xFF,2,16,QLatin1Char('0')).toUpper() + QString(" ");   //2 字符宽度
    79.  
    80. //           buf += str;
    81. //     }
    82.      QTextCodec *tc = QTextCodec::codecForName("GBK");
    83.      QString tmpQStr = tc->toUnicode(arr);
    84.      return tmpQStr;
    85.  }
    86. //将接收的一串QByteArray类型的16进制,每2个16进制转化为1个字的16进制的字符串
    87.  QString Convert4Hex(QByteArray str)
    88.  {
    89.  
    90.      QDataStream out(&str,QIODevice::ReadWrite);   //将str的数据 读到out里面去
    91.      QString buf;
    92.      while(!out.atEnd())
    93.      {
    94.            qint16 outChar = 0;
    95.            out>>outChar;   //每次一个字节的填充到 outchar
    96.            QString str = QString("%1").arg(outChar&0xFFFF,4,16,QLatin1Char('0')).toUpper() + QString(" ");   //2 字符宽度
    97.  
    98.            buf += str;
    99.      }
    100.      return buf;
    101.  }

    引用

    Qt中操作SQLite数据库_龚建波的博客-CSDN博客_qt sqlite

    QSqlDatabase二三事_龚建波的博客-CSDN博客

    Qt使用sqlite数据库，查询数据卡顿导致其他数据偶尔插入失败_ouyang1988503的博客-CSDN博客

    SQLiteDatabase 多线程访问需要注意的问题_苍痕的博客-CSDN博客 

  • 相关阅读:
    基于C++的人脸过渡项目
    【TypeScript】中接口的详细介绍
    第 45 届国际大学生程序设计竞赛（ICPC）亚洲区域赛（沈阳），签到题4题
    springboot thymeleaf使用
    self-attention、transformer、bert理解
    【C++】list常用接口
    面试必备杀技：SQL查询专项训练！
    22.07.03.05(Wireshark 抓包并分析)
    SpringBoot学习笔记-配置MySQL与实现注册登录模块（中）
    专利申请需要多少钱
  • 原文地址：https://blog.csdn.net/qq8864/article/details/126215755