通过PHP将NSData发送到MySQL的最佳方式是什么？

Question

好吧，我相信这一定是一个很常见的情况。我需要通过一个PHP页面通过HTTP请求发送一个NSData变量，随后将它存储在MySQL中。稍后将由其他一些HTTP调用检索到，然后再将其下载到NSData中。做这个的最好方式是什么？

我应该将NSData转换成某种类型的字符串表示形式（base64等）吗？我应该将数据作为VARCHAR还是Blob存储在MySQL中？数据长度不会超过MySQL/HTTP限制。

Answer 1

第一条建议：您可以将它存储在PHP 的会话中，例如， $ _SESSION ['mytext'] = < NSDATA>;不要忘记session_start（）;检索你的字符串。

第二条建议：您可以将其存储在XML文件中。这就是如果它支持XML

第三条建议：只是从MYSQL回拨是安全的。

Answer 2

通过对数据进行Base64编码，您可能会让自己变得更容易，以便来回传输到服务器。 （或yEnc或其他字节的ASCII编码）。您当然可以可以来回传输原始字节（毕竟，这就是我们对图像所做的，对吧？），但是不用担心编码和其他带有字符串数据的HTTP标头。

在服务器端，您可以将字符串存储在数据库的字符字段中，您可以解码它们并存储在BLOB中，也可以将它们保存到文件系统中。你的应用程序的要求，很难说什么是“最好”的选择。

Answer 3

最简单的方法是Base64对数据进行编码并创建一个Web服务，让您可以来回发送信息。

这里是做Base64编码/解码，我在网上找到一个类别：

ECBase64.h

#import <Foundation/Foundation.h> 



    @interface NSData (NSDataBase64Additions) 

    + (NSData*)dataWithBase64EncodedString: (NSString*)string; 
    - (id)initWithBase64EncodedString: (NSString*)string; 

    - (NSString*)base64Encoding; 
    - (NSString*)base64EncodingWithLineLength: (NSUInteger)lineLength; 

    @end 

ECBase64.m：

#import "ECBase64.h" 

    static char encodingTable[64] = { 
    'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P', 
    'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f', 
    'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v', 
    'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/' }; 

    @implementation NSData (NSDataBase64Additions) 

    + (NSData*)dataWithBase64EncodedString: (NSString*)string 
    { 
     NSData* result = [[NSData alloc] initWithBase64EncodedString: string]; 
     return [result autorelease]; 
    } 

    - (id)initWithBase64EncodedString: (NSString*)string 
    { 
     NSMutableData* mutableData = nil; 

     if (string) 
     { 
      unsigned long ixtext = 0; 
      unsigned long lentext = 0; 
      unsigned char ch = 0; 
      unsigned char inbuf[4], outbuf[3]; 
      short i = 0, ixinbuf = 0; 
      BOOL flignore = NO; 
      BOOL flendtext = NO; 
      NSData* base64Data = nil; 
      const unsigned char* base64Bytes = nil; 

      // Convert the string to UTF8 data. 
      base64Data = [string dataUsingEncoding: NSUTF8StringEncoding]; 
      base64Bytes = [base64Data bytes]; 
      mutableData = [NSMutableData dataWithCapacity: [base64Data length]]; 
      lentext = [base64Data length]; 

      while (YES) 
      { 
       if (ixtext >= lentext) 
        break; 

       ch = base64Bytes[ixtext++]; 
       flignore = NO; 

       if ((ch >= 'A') && (ch <= 'Z')) 
        ch = ch - 'A'; 
       else if ((ch >= 'a') && (ch <= 'z')) 
        ch = ch - 'a' + 26; 
       else if ((ch >= '0') && (ch <= '9')) 
        ch = ch - '0' + 52; 
       else if (ch == '+') 
        ch = 62; 
       else if (ch == '=') 
        flendtext = YES; 
       else if (ch == '/') 
        ch = 63; 
       else 
        flignore = YES; 

       if (!flignore) 
       { 
        short ctcharsinbuf = 3; 
        BOOL flbreak = NO; 

        if (flendtext) 
        { 
         if (!ixinbuf) 
          break; 

         if ((ixinbuf == 1) || (ixinbuf == 2)) 
          ctcharsinbuf = 1; 
         else 
          ctcharsinbuf = 2; 

         ixinbuf = 3; 
         flbreak = YES; 
        } 

        inbuf [ixinbuf++] = ch; 

        if (ixinbuf == 4) 
        { 
         ixinbuf = 0; 
         outbuf [0] = (inbuf[0] << 2) | ((inbuf[1] & 0x30) >> 4); 
         outbuf [1] = ((inbuf[1] & 0x0F) << 4) | ((inbuf[2] & 0x3C) >> 2); 
         outbuf [2] = ((inbuf[2] & 0x03) << 6) | (inbuf[3] & 0x3F); 

         for(i = 0; i < ctcharsinbuf; ++i) 
          [mutableData appendBytes: &outbuf[i] length: 1]; 
        } 

        if (flbreak) 
         break; 
       } 
      } 
     } 

     self = [self initWithData: mutableData]; 
     return self; 
    } 

    #pragma mark - 
    - (NSString*) base64Encoding 
    { 
     return [self base64EncodingWithLineLength: 0]; 
    } 

    - (NSString*)base64EncodingWithLineLength: (unsigned int)lineLength 
    { 
     const unsigned char* bytes = [self bytes]; 
     NSMutableString* result = [NSMutableString stringWithCapacity: [self length]]; 
     unsigned long ixtext = 0; 
     unsigned long lentext = [self length]; 
     long ctremaining = 0; 
     unsigned char inbuf[3], outbuf[4]; 
     short i = 0; 
     short charsonline = 0, ctcopy = 0; 
     unsigned long ix = 0; 

     while (YES) 
     { 
      ctremaining = lentext - ixtext; 
      if (ctremaining <= 0) 
       break; 

      for(i = 0; i < 3; ++i) 
      { 
       ix = ixtext + i; 
       if (ix < lentext) 
        inbuf[i] = bytes[ix]; 
       else 
        inbuf [i] = 0; 
      } 

      outbuf [0] = (inbuf [0] & 0xFC) >> 2; 
      outbuf [1] = ((inbuf [0] & 0x03) << 4) | ((inbuf [1] & 0xF0) >> 4); 
      outbuf [2] = ((inbuf [1] & 0x0F) << 2) | ((inbuf [2] & 0xC0) >> 6); 
      outbuf [3] = inbuf [2] & 0x3F; 
      ctcopy = 4; 

      switch (ctremaining) 
      { 
       case 1: 
        ctcopy = 2; 
        break; 
       case 2: 
        ctcopy = 3; 
        break; 
      } 

      for(i = 0; i < ctcopy; ++i) 
       [result appendFormat: @"%c", encodingTable[outbuf[i]]]; 

      for(i = ctcopy; i < 4; ++i) 
       [result appendFormat: @"%c",'=']; 

      ixtext += 3; 
      charsonline += 4; 

      if (lineLength > 0) 
      { 
       if (charsonline >= lineLength) 
       { 
        charsonline = 0; 
        [result appendString: @"\n"]; 
       } 
      } 
     } 

     return result; 
    } 

    @end