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

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

---

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

第一个建议：您可以将其存储在PHP会话中 e、 g.$_会话['mytext']=；别忘了启动会话（）；检索字符串

第二个建议：可以将其存储在XML文件中。如果它支持XML的话

---

第三个建议：为了安全起见，只需从MYSQL中调用它。

第一个建议：您可以将其存储在PHP中的会话中 e、 g.$_会话['mytext']=；别忘了启动会话（）；检索字符串

第二个建议：可以将其存储在XML文件中。如果它支持XML的话

---

第三个建议：为了安全起见，只需从MYSQL中调用它。

通过对数据进行Base64编码以便来回传输到服务器，您可能会让事情变得更简单。（或者yEnc，或者其他一些ASCII编码的字节。）您当然可以来回传输原始字节（毕竟，这就是我们处理图像的方法，对吧？），但对于编码和其他HTTP头以及字符串数据，就不必担心了

---

在服务器端，您可以将字符串存储在数据库的字符字段中，您可以解码它们并存储在blob中，您可以将它们保存到文件系统中。。。。如果不了解应用程序的更多要求，就很难说什么是“最佳”选项。

通过对数据进行Base64编码以便来回传输到服务器，您可能会让事情变得更简单。（或者yEnc，或者其他一些ASCII编码的字节。）您当然可以来回传输原始字节（毕竟，这就是我们处理图像的方法，对吧？），但对于编码和其他HTTP头以及字符串数据，就不必担心了

---

在服务器端，您可以将字符串存储在数据库的字符字段中，您可以解码它们并存储在blob中，您可以将它们保存到文件系统中。。。。如果不了解应用程序的更多要求，就很难说什么是“最佳”选项。

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

以下是我在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

#导入
@接口NSData（NSDATABASE64增补）
+（NSData*）dataWithBase64EncodedString:（NSString*）字符串；
-（id）initWithBase64EncodedString:（NSString*）字符串；
-（NSString*）base64编码；
-（NSString*）base64编码带lineLength:（NSInteger）lineLength；
@结束

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

#导入“ECBase64.h”
静态字符编码表[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’、‘加’、‘/’等}；
@实施NSData（NSDATABASE64增补）
+（NSData*）dataWithBase64EncodedString:（NSString*）字符串
{
NSData*结果=[[NSData alloc]initWithBase64EncodedString:string]；
返回[结果自动释放]；
}
-（id）initWithBase64EncodedString:（NSString*）字符串
{
NSMutableData*mutableData=nil；
如果（字符串）
{
无符号长文本=0；
无符号长文本=0；
无符号字符ch=0；
无符号字符inbuf[4]，extruf[3]；
短i=0，ixinbuf=0；
BOOL-flignore=否；
BOOL-flendtext=否；
NSData*base64Data=nil；
const unsigned char*base64Bytes=nil；
//将字符串转换为UTF8数据。
base64Data=[string dataUsingEncoding:NSUTF8StringEncoding]；
base64Bytes=[base64Data字节]；
mutableData=[NSMutableData dataWithCapacity:[Base64数据长度]]；
lentext=[base64数据长度]；
虽然（是）
{
如果（ixtext>=lentext）
打破
ch=base64字节[ixtext++]；
flignore=否；
如果（（ch>='A'）&&（ch='A'）&&（ch='0'）&&（ch 4）；
exputf[1]=（（inbuf[1]&0x0F）>2）；
exputf[2]=（（inbuf[2]&0x03）2；
exputf[1]=（（inbuf[0]&0x03）>4）；
exputf[2]=（（inbuf[1]&0x0F）>6）；
exputf[3]=inbuf[2]&0x3F；
ctcopy=4；
开关（ctremaining）
{
案例1：
ctcopy=2；
打破
案例2：
ctcopy=3；
打破
}
对于（i=0；i