使用Gson框架制作Json时遇到的字符转义问题

第一次做后台遇到一个Json格式的问题,刚开始得到的JsonArray格式如下:
[{"id":8,"account":"123456","password":"123456","name":"啦啦啦"},{"id":9,"account":"10086","password":"123456","name":"哈哈哈"}]
在返回给前端时需要弄成一个JsonObject,于是我写了一个实体类ReturnData,里面只有一个String data,然后使用Gson中的方法(json就是上面的jsonArray):

ReturnData returnData = new ReturnData(json);
String gsonResult = gson.toJson(returnData);

但是在转换时,Gson自动帮我添加了转义字符,最后结果如下:
{"data":"[{\"id\":8,\"account\":\"123456\",\"password\":\"123456\",\"name\":\"啦啦啦\"}
有没有大神知道为什么会自动出现这样的转义字符,以及好一点的解决办法。

12个回答

将{"id":8,"account":"123456","password":"123456","name":"啦啦啦"}定义成一个对象Data,然后将这个对象数组作为ReturnData的属性===>List data;
或者List> data;

你定义的ReturnData只包含一个String字符串,toJson函数做的就是把这个String字符串转为json格式的,所有加上了转义字符;
你应该把ReturnData字段定义为一个包含json结果的Java类,参考http://www.importnew.com/16638.html

说明你给 toJson发的是个字符串,gson需要把字符串转换为正常的JSON所以需要加上转义字符。

你可以将结果处理一下,把转义符个替换掉啊(如:.replaceAll() ),这样会比较简单一些。

{"data":"[{\"id\":8,\"account\":\"123456\",\"password\":\"123456\",\"name\":\"啦啦啦\"}

JSONObject message = new JSONObject(json);
这样返回就可以了

1.为什么会自动出现这样的转义字符? 因为字符串里有引号等等特殊字符,
比如你要打印一个引号出来,你怎么打印呢,
是不是这样写 String gsonResult=““”,三个引号那编译准报错,所以要加入转义符。
2.Json解析有现成的对象。我在这边这个是c++的,应该有java版本的,你可以百度一下,或者翻译成java.
/*
Copyright (c) 2009 Dave Gamble

Permission is hereby granted, dispose of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
example:
string resStr;
resStr.assign(response->getResponseData()->begin(), response->getResponseData()->end());
Json * root = Json_create(resStr.c_str());
if( !root)
return;
Json * status =Json_getItem(root,"status");
OutputT("充值回调 status=%d", status->valueInt);
if( status->valueInt != 0)
return;

*/

/* Esoteric Software: Removed everything except parsing, shorter method names, more get methods, double to float, formatted. */

#ifndef SPINE_JSON_H_
#define SPINE_JSON_H_

#ifdef __cplusplus
extern "C" {
#endif

/* Json Types: */
#define Json_False 0
#define Json_True 1
#define Json_NULL 2
#define Json_Number 3
#define Json_String 4
#define Json_Array 5
#define Json_Object 6

#ifndef SPINE_JSON_HAVE_PREV
/* Spine doesn't use the "prev" link in the Json sibling lists. */
#define SPINE_JSON_HAVE_PREV 0
#endif

/* The Json structure: /
typedef struct Json {
struct Json
next;
#if SPINE_JSON_HAVE_PREV
struct Json* prev; /* next/prev allow you to walk array/object chains. Alternatively, use getSize/getItem /
#endif
struct Json
child; /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */

int type; /* The type of the item, as above. */
int size; /* The number of children. */

const char* valueString; /* The item's string, if type==Json_String */
int valueInt; /* The item's number, if type==Json_Number */
float valueFloat; /* The item's number, if type==Json_Number */

const char* name; /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */

} Json;

/* Supply a block of JSON, and this returns a Json object you can interrogate. Call Json_dispose when finished. /
Json
Json_create (const char* value);

/* Delete a Json entity and all subentities. /
void Json_dispose (Json
json);

/* Get item "string" from object. Case insensitive. /
Json
Json_getItem (Json* json, const char* string);
const char* Json_getString (Json* json, const char* name, const char* defaultValue);
float Json_getFloat (Json* json, const char* name, float defaultValue);
int Json_getInt (Json* json, const char* name, int defaultValue);

/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when Json_create() returns 0. 0 when Json_create() succeeds. /
const char
Json_getError (void);

#ifdef __cplusplus
}
#endif

#endif /* SPINE_JSON_H_ */

//----------------------------------------------------------cpp
/*
Copyright (c) 2009, Dave Gamble
Copyright (c) 2013, Esoteric Software

Permission is hereby granted, dispose of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/

/* Json /
/
JSON parser in C. */

#ifndef _DEFAULT_SOURCE
/* Bring strings.h definitions into string.h, where appropriate */
#define _DEFAULT_SOURCE
#endif

#ifndef _BSD_SOURCE
/* Bring strings.h definitions into string.h, where appropriate */
#define _BSD_SOURCE
#endif

#include "Json.h"
#include
#include
#include /* strtod (C89), strtof (C99) /
#include /
strcasecmp (4.4BSD - compatibility), _stricmp (_WIN32) */
//#include

#ifndef SPINE_JSON_DEBUG
/* Define this to do extra NULL and expected-character checking */
#define SPINE_JSON_DEBUG 0
#endif

static const char* ep;

const char* Json_getError (void) {
return ep;
}

static int Json_strcasecmp (const char* s1, const char* s2) {
/* TODO we may be able to elide these NULL checks if we can prove
* the graph and input (only callsite is Json_getItem) should not have NULLs
/
if (s1 && s2) {
#if defined(_WIN32)
return _stricmp(s1, s2);
#else
return strcasecmp( s1, s2 );
#endif
} else {
if (s1 < s2)
return -1; /
s1 is null, s2 is not /
else if (s1 == s2)
return 0; /
both are null /
else
return 1; /
s2 is nul s1 is not */
}
}

/* Internal constructor. /
static Json *Json_new (void) {
return (Json *)calloc(1,sizeof(Json));//return (Json
)CALLOC(Json, 1);
}

/* Delete a Json structure. /
void Json_dispose (Json *c) {
Json *next;
while (c) {
next = c->next;
if (c->child) Json_dispose(c->child);
if (c->valueString) free((void
)c->valueString);//FREE(c->valueString);
if (c->name) free((void*)c->name);//FREE(c->name);
free(c);//FREE(c);
c = next;
}
}

/* Parse the input text to generate a number, and populate the result into item. /
static const char
parse_number (Json item, const char num) {
char * endptr;
float n;

/* Using strtod and strtof is slightly more permissive than RFC4627,
 * accepting for example hex-encoded floating point, but either
 * is often leagues faster than any manual implementation.
 *
 * We also already know that this starts with [-0-9] from parse_value.
 */

#if STDC_VERSION >= 199901L
n = strtof(num, &endptr);
#else
n = (float)strtod( num, &endptr );
#endif
/* ignore errno's ERANGE, which returns +/-HUGE_VAL /
/
n is 0 on any other error */

if (endptr != num) {
    /* Parse success, number found. */
    item->valueFloat = n;
    item->valueInt = (int)n;
    item->type = Json_Number;
    return endptr;
} else {
    /* Parse failure, ep is set. */
    ep = num;
    return 0;
}

}

/* Parse the input text into an unescaped cstring, and populate item. /
static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
static const char
parse_string (Json item, const char str) {
const char* ptr = str + 1;
char* ptr2;
char* out;
int len = 0;
unsigned uc, uc2;
if (*str != '\"') { /* TODO: don't need this check when called from parse_value, but do need from parse_object /
ep = str;
return 0;
} /
not a string! */

while (*ptr != '\"' && *ptr && ++len)
    if (*ptr++ == '\\') ptr++; /* Skip escaped quotes. */

out=(char*)malloc(len + 1);//out = MALLOC(char, len + 1); /* The length needed for the string, roughly. */
if (!out) return 0;

ptr = str + 1;
ptr2 = out;
while (*ptr != '\"' && *ptr) {
    if (*ptr != '\\')
        *ptr2++ = *ptr++;
    else {
        ptr++;
        switch (*ptr) {
        case 'b':
            *ptr2++ = '\b';
            break;
        case 'f':
            *ptr2++ = '\f';
            break;
        case 'n':
            *ptr2++ = '\n';
            break;
        case 'r':
            *ptr2++ = '\r';
            break;
        case 't':
            *ptr2++ = '\t';
            break;
        case 'u': /* transcode utf16 to utf8. */
            sscanf(ptr + 1, "%4x", &uc);
            ptr += 4; /* get the unicode char. */

            if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0) break; /* check for invalid. */

            /* TODO provide an option to ignore surrogates, use unicode replacement character? */
            if (uc >= 0xD800 && uc <= 0xDBFF) /* UTF16 surrogate pairs. */
            {
                if (ptr[1] != '\\' || ptr[2] != 'u') break; /* missing second-half of surrogate.    */
                sscanf(ptr + 3, "%4x", &uc2);
                ptr += 6;
                if (uc2 < 0xDC00 || uc2 > 0xDFFF) break; /* invalid second-half of surrogate.   */
                uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF));
            }

            len = 4;
            if (uc < 0x80)
                len = 1;
            else if (uc < 0x800)
                len = 2;
            else if (uc < 0x10000) len = 3;
            ptr2 += len;

            switch (len) {
            case 4:
                *--ptr2 = ((uc | 0x80) & 0xBF);
                uc >>= 6;
                /* fallthrough */
            case 3:
                *--ptr2 = ((uc | 0x80) & 0xBF);
                uc >>= 6;
                /* fallthrough */
            case 2:
                *--ptr2 = ((uc | 0x80) & 0xBF);
                uc >>= 6;
                /* fallthrough */
            case 1:
                *--ptr2 = (uc | firstByteMark[len]);
            }
            ptr2 += len;
            break;
        default:
            *ptr2++ = *ptr;
            break;
        }
        ptr++;
    }
}
*ptr2 = 0;
if (*ptr == '\"') ptr++; /* TODO error handling if not \" or \0 ? */
item->valueString = out;
item->type = Json_String;
return ptr;

}

/* Predeclare these prototypes. /
static const char
parse_value (Json item, const char value);
static const char* parse_array (Json item, const char value);
static const char* parse_object (Json item, const char value);

/* Utility to jump whitespace and cr/lf /
static const char
skip (const char* in) {
if (!in) return 0; /* must propagate NULL since it's often called in skip(f(...)) form */
while (*in && (unsigned char)*in <= 32)
in++;
return in;
}

/* Parse an object - create a new root, and populate. /
Json *Json_create (const char
value) {
Json c;
ep = 0;
if (!value) return 0; /
only place we check for NULL other than skip() /
c = Json_new();
if (!c) return 0; /
memory fail */

value = parse_value(c, skip(value));
if (!value) {
    Json_dispose(c);
    return 0;
} /* parse failure. ep is set. */

return c;

}

/* Parser core - when encountering text, process appropriately. /
static const char
parse_value (Json item, const char value) {
/* Referenced by Json_create(), parse_array(), and parse_object(). /
/
Always called with the result of skip(). /
#if SPINE_JSON_DEBUG /
Checked at entry to graph, Json_create, and after every parse_ call. /
if (!value) return 0; /
Fail on null. */
#endif

switch (*value) {
case 'n': {
    if (!strncmp(value + 1, "ull", 3)) {
        item->type = Json_NULL;
        return value + 4;
    }
    break;
}
case 'f': {
    if (!strncmp(value + 1, "alse", 4)) {
        item->type = Json_False;
        /* calloc prevents us needing item->type = Json_False or valueInt = 0 here */
        return value + 5;
    }
    break;
}
case 't': {
    if (!strncmp(value + 1, "rue", 3)) {
        item->type = Json_True;
        item->valueInt = 1;
        return value + 4;
    }
    break;
}
case '\"':
    return parse_string(item, value);
case '[':
    return parse_array(item, value);
case '{':
    return parse_object(item, value);
case '-': /* fallthrough */
case '0': /* fallthrough */
case '1': /* fallthrough */
case '2': /* fallthrough */
case '3': /* fallthrough */
case '4': /* fallthrough */
case '5': /* fallthrough */
case '6': /* fallthrough */
case '7': /* fallthrough */
case '8': /* fallthrough */
case '9':
    return parse_number(item, value);
default:
    break;
}

ep = value;
return 0; /* failure. */

}

/* Build an array from input text. /
static const char
parse_array (Json item, const char value) {
Json *child;

#if SPINE_JSON_DEBUG /* unnecessary, only callsite (parse_value) verifies this /
if (*value != '[') {
ep = value;
return 0;
} /
not an array! */
#endif

item->type = Json_Array;
value = skip(value + 1);
if (*value == ']') return value + 1; /* empty array. */

item->child = child = Json_new();
if (!item->child) return 0; /* memory fail */
value = skip(parse_value(child, skip(value))); /* skip any spacing, get the value. */
if (!value) return 0;
item->size = 1;

while (*value == ',') {
    Json *new_item = Json_new();
    if (!new_item) return 0; /* memory fail */
    child->next = new_item;

#if SPINE_JSON_HAVE_PREV
new_item->prev = child;
#endif
child = new_item;
value = skip(parse_value(child, skip(value + 1)));
if (!value) return 0; /* parse fail */
item->size++;
}

if (*value == ']') return value + 1; /* end of array */
ep = value;
return 0; /* malformed. */

}

/* Build an object from the text. /
static const char
parse_object (Json item, const char value) {
Json *child;

#if SPINE_JSON_DEBUG /* unnecessary, only callsite (parse_value) verifies this /
if (*value != '{') {
ep = value;
return 0;
} /
not an object! */
#endif

item->type = Json_Object;
value = skip(value + 1);
if (*value == '}') return value + 1; /* empty array. */

item->child = child = Json_new();
if (!item->child) return 0;
value = skip(parse_string(child, skip(value)));
if (!value) return 0;
child->name = child->valueString;
child->valueString = 0;
if (*value != ':') {
    ep = value;
    return 0;
} /* fail! */
value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
if (!value) return 0;
item->size = 1;

while (*value == ',') {
    Json *new_item = Json_new();
    if (!new_item) return 0; /* memory fail */
    child->next = new_item;

#if SPINE_JSON_HAVE_PREV
new_item->prev = child;
#endif
child = new_item;
value = skip(parse_string(child, skip(value + 1)));
if (!value) return 0;
child->name = child->valueString;
child->valueString = 0;
if (*value != ':') {
ep = value;
return 0;
} /* fail! /
value = skip(parse_value(child, skip(value + 1))); /
skip any spacing, get the value. */
if (!value) return 0;
item->size++;
}

if (*value == '}') return value + 1; /* end of array */
ep = value;
return 0; /* malformed. */

}

Json Json_getItem (Json *object, const char string) {
Json *c = object->child;
while (c && Json_strcasecmp(c->name, string))
c = c->next;
return c;
}

const char* Json_getString (Json* object, const char* name, const char* defaultValue) {
object = Json_getItem(object, name);
if (object) return object->valueString;
return defaultValue;
}

float Json_getFloat (Json* value, const char* name, float defaultValue) {
value = Json_getItem(value, name);
return value ? value->valueFloat : defaultValue;
}

int Json_getInt (Json* value, const char* name, int defaultValue) {
value = Json_getItem(value, name);
return value ? value->valueInt : defaultValue;
}

在使用一下String result = StringEscapeUtils.unescapeJson(gsonResult );处理下

具体啥原因我是不清楚,我也遇到过,跟JSONObject定义有关,使用apache 的json和googe的json有关,有的json传入前台是不带"\"的,后台json定义换一下

直接将实体类ReturnData里面加属性,和json里面的一样就可以了

共12条数据 1 尾页
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
安卓使用GSON解析JSON产生的问题
-
根据java实体拼接可被gson解析的json字符串
-
如何使用gson来解析json???
-
Android gson解析复杂JSON数据
-
java json字符串里的引号转义
-
用Gson解析json的问题
-
求大神!! SpringbootAdmin2.1.4 解析gson类型的json出错
-
gson将json格式的字符串转成java对象,json字符串中long怎么转变不会报错?
-
Gson将字符串转换为对象时“\\\\”问题,请大神帮看看
-
在Android中使用Gson解析json
-
GSON使用toJson方法将类转为json格式字符串时的问
-
Gson解析Json数据出现了异常
-
关于GSON解析json字符串的问题
-
如何使用gson转换map数据为json数组
-
java中,谷歌的Gson类在解析yyyy/MM/dd格式的日期时遇到的问题
-
Gson解析json数据返回空值
-
GSON解析 json转java对象问题
-
Java Gson解析多层嵌套json字符串
-
Gson解析json报错。。。
-
程序员那些必须掌握的排序算法(下)
接着上一篇的排序算法,我们废话不多,直接进入主题。 1.快速排序 快速排序(Quicksort)是对冒泡排序的一种改进。 快速排序由C. A. R. Hoare在1960年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。 演示...
学会了这些技术,你离BAT大厂不远了
每一个程序员都有一个梦想,梦想着能够进入阿里、腾讯、字节跳动、百度等一线互联网公司,由于身边的环境等原因,不知道 BAT 等一线互联网公司使用哪些技术?或者该如何去学习这些技术?或者我该去哪些获取这些技术资料?没关系,平头哥一站式服务,上面统统不是问题。平头哥整理了 BAT 等一线大厂的必备技能,并且帮你准备了对应的资料。对于整理出来的技术,如果你掌握的不牢固,那就赶快巩固,如果你还没有涉及,现在...
程序员真是太太太太太有趣了!!!
网络上虽然已经有了很多关于程序员的话题,但大部分人对这个群体还是很陌生。我们在谈论程序员的时候,究竟该聊些什么呢?各位程序员大佬们,请让我听到你们的声音!不管你是前端开发...
史上最详细的IDEA优雅整合Maven+SSM框架(详细思路+附带源码)
网上很多整合SSM博客文章并不能让初探ssm的同学思路完全的清晰,可以试着关掉整合教程,摇两下头骨,哈一大口气,就在万事具备的时候,开整,这个时候你可能思路全无 ~中招了咩~ ,还有一些同学依旧在使用eclipse或者Myeclipse开发,我想对这些朋友说IDEA 的编译速度很快,人生苦短,来不及解释了,直接上手idea吧。这篇文章每一步搭建过程都测试过了,应该不会有什么差错。本文章还有个比较优秀的特点,就是idea的使用,基本上关于idea的操作都算是比较详细的,所以不用太担心不会撸idea!最后,本文
知乎上 40 个有趣回复,很精辟很提神
点击蓝色“五分钟学算法”关注我哟加个“星标”,天天中午 12:15,一起学算法作者 |佚名来源 |网络整理,版权归原作者所有,侵删。1交朋友的标准是什么?- Ques...
从入门到精通,Java学习路线导航
引言 最近也有很多人来向我"请教",他们大都是一些刚入门的新手,还不了解这个行业,也不知道从何学起,开始的时候非常迷茫,实在是每天回复很多人也很麻烦,所以在这里统一作个回复吧。 Java学习路线 当然,这里我只是说Java学习路线,因为自己就是学Java的,对Java理当很熟悉,对于其它方面,我也不是很了解。 基础阶段 首先是基础阶段,在基础阶段,我们必须掌握Java基础,Mysql数据库,Ora...
我花了一夜用数据结构给女朋友写个H5走迷宫游戏
起因 又到深夜了,我按照以往在csdn和公众号写着数据结构!这占用了我大量的时间!我的超越妹妹严重缺乏陪伴而 怨气满满! 而女朋友时常埋怨,认为数据结构这么抽象难懂的东西没啥作用,常会问道:天天写这玩意,有啥作用。而我答道:能干事情多了,比如写个迷宫小游戏啥的! 当我码完字准备睡觉时:写不好别睡觉! 分析 如果用数据结构与算法造出东西来呢? ...
实现 Java 本地缓存,该从这几点开始
缓存,我相信大家对它一定不陌生,在项目中,缓存肯定是必不可少的。市面上有非常多的缓存工具,比如 Redis、Guava Cache 或者 EHcache。对于这些工具,我想大家肯定都非常熟悉,所以今天我们不聊它们,我们来聊一聊如何实现本地缓存。参考上面几种工具,要实现一个较好的本地缓存,平头哥认为要从以下三个方面开始。 1、存储集合的选择 实现本地缓存,存储容器肯定是 key/value 形式的数...
揭开 Python 内存分配时的小秘密!
作者 | 豌豆花下猫 责编 | 胡巍巍 Python 中的sys模块极为基础而重要,它主要提供了一些给解释器使用(或由它维护)的变量,以及一些与解释器强交互的函数。 本文将会频繁地使用该模块的getsizeof()方法,因此,我先简要介绍一下: 该方法用于获取一个对象的字节大小(bytes) 它只计算直接占用的内存,而不计算对象内所引用对象的内存 这里有个直观的例...
让程序员崩溃的瞬间(非程序员勿入)
今天给大家带来点快乐,程序员才能看懂。 来源:https://zhuanlan.zhihu.com/p/47066521 1. 公司实习生找 Bug 2.在调试时,将断点设置在错误的位置 3.当我有一个很棒的调试想法时 4.偶然间看到自己多年前写的代码 5.当我第一次启动我的单元测试时 ...
用Python分析2000款避孕套,得出这些有趣的结论
到现在为止,我们的淘宝教程已经写到了第四篇,前三篇分别是: 第一篇:Python模拟登录淘宝,详细讲解如何使用requests库登录淘宝pc端。 第二篇:淘宝自动登录2.0,新增Cookies序列化,教大家如何将cookies保存起来。 第三篇:Python爬取淘宝商品避孕套,教大家如何爬取淘宝pc端商品信息。 今天,我们来看看淘宝系列的第四篇 我们在上一篇的时候已经将淘宝数据爬取下来了,...
做好以下四点,拒做 “ 空心 ” 程序员
01、注重原理性知识 现在的互联网环境下,注重原理性知识学习的程序员越来越少,特别是在这种培训机构大爆炸的环境下,在网上你会经常看到类似三个月从入门到精通高并发、分布式的广告,我相信培训机构有这套技术的能力,但是我不相信一个初学者有这么好的接收能力。甚至某个培训机构的讲师里,有一个1997年出生的架构师,20岁出头就当上了架构师,真的是后生可畏呀。在我的思维里,架构师不是学出来的,架构师是...
分享靠写代码赚钱的一些门路
作者 mezod,译者 josephchang10如今,通过自己的代码去赚钱变得越来越简单,不过对很多人来说依然还是很难,因为他们不知道有哪些门路。今天给大家分享一个精彩...
技术人员要拿百万年薪,必须要经历这9个段位
很多人都问,技术人员如何成长,每个阶段又是怎样的,如何才能走出当前的迷茫,实现自我的突破。所以我结合我自己10多年的从业经验,总结了技术人员成长的9个段位,希望对大家的职...
面试官:兄弟,说说基本类型和包装类型的区别吧
Java 的每个基本类型都对应了一个包装类型,比如说 int 的包装类型为 Integer,double 的包装类型为 Double。基本类型和包装类型的区别主要有以下 4 点。
进程和线程的区别(超详细)
进程和线程 进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间,一个进程可以有多个线程,比如在Windows系统中,一个运行的xx.exe就是一个进程。 线程 进程中的一个执行任务(控制单元),负责当前进程中程序的执行。一个进程至少有一个线程,一个进程可以运行多个线程,多个线程可共享数据。 与进程不同的是同类的多个线程共享进程的堆和方法区资源,但每个线程有自己的程序计数器、虚拟...
第二弹!python爬虫批量下载高清大图
文章目录前言下载免费高清大图下载带水印的精选图代码与总结 前言 在上一篇写文章没高质量配图?python爬虫绕过限制一键搜索下载图虫创意图片!中,我们在未登录的情况下实现了图虫创意无水印高清小图的批量下载。虽然小图能够在一些移动端可能展示的还行,但是放到pc端展示图片太小效果真的是很一般!建议阅读本文查看上一篇文章,在具体实现不做太多介绍,只讲个分析思路。 当然,本文可能技术要求不是特别高,但可以...
面试官,不要再问我三次握手和四次挥手
三次握手和四次挥手是各个公司常见的考点,也具有一定的水平区分度,也被一些面试官作为热身题。很多小伙伴说这个问题刚开始回答的挺好,但是后面越回答越冒冷汗,最后就歇菜了。 见过比较典型的面试场景是这样的: 面试官:请介绍下三次握手 求职者:第一次握手就是客户端给服务器端发送一个报文,第二次就是服务器收到报文之后,会应答一个报文给客户端,第三次握手就是客户端收到报文后再给服务器发送一个报文,三次握手就...
为什么说 Web 开发永远不会退出历史舞台?
早在 PC 崛起之际,Web 从蹒跚学步一路走到了主导市场的地位,但是随着移动互联网时代的来临,业界曾有不少人猜测,“Web 应该被杀死,App 才是未来”。不过时间是检...
Java 爬虫遇到需要登录的网站,该怎么办?
这是 Java 网络爬虫系列博文的第二篇,在上一篇 Java 网络爬虫,就是这么的简单 中,我们简单的学习了一下如何利用 Java 进行网络爬虫。在这一篇中我们将简单的聊一聊在网络爬虫时,遇到需要登录的网站,我们该怎么办? 在做爬虫时,遇到需要登陆的问题也比较常见,比如写脚本抢票之类的,但凡需要个人信息的都需要登陆,对于这类问题主要有两种解决方式:一种方式是手动设置 cookie ,就是先在网站上...
nginx学习,看这一篇就够了:下载、安装。使用:正向代理、反向代理、负载均衡。常用命令和配置文件
文章目录前言一、nginx简介1. 什么是 nginx 和可以做什么事情2.Nginx 作为 web 服务器3. 正向代理4. 反向代理5. 动静分离6.动静分离二、Nginx 的安装三、 Nginx 的常用命令和配置文件四、 Nginx 配置实例 1 反向代理五、 Nginx 配置实例 2 负载均衡六、 Nginx 配置实例 3 动静分离七、 Nginx 的高可用集群 前言 一、nginx简介...
相关热词 c#二进制字符转字节 c# rc4 c#中md5加密 c# 新建mvc项目 c# 引用mysql c#动态加载非托管dll c# 两个表数据同步 c# 返回浮点json c# imap 链接状态 c# 漂亮字