javajson验签顺序,java验签方法

本文目录一览：

• 1、Java解析json数据
• 2、JAVA中遍历JSONObject不能按原顺序遍历
• 3、java校验json格式及内容
• 4、JAVA中按原顺序遍历JSONObject
• 5、json.parseobject()的set方法设置顺序

Java解析json数据

一、 JSON （JavaScript Object Notation）一种简单的数据格式，比xml更轻巧。

Json建构于两种结构：

1、“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。 如：

{

“name”:”jackson”,

“age”:100

}

2、值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）如：

{

“students”:

[

{“name”:”jackson”,“age”:100},

{“name”:”michael”,”age”:51}

]

}

二、java解析JSON步骤

A、服务器端将数据转换成json字符串

首先、服务器端项目要导入json的jar包和json所依赖的jar包至builtPath路径下（这些可以到JSON-lib官网下载：）

然后将数据转为json字符串，核心函数是：

public static String createJsonString(String key, Object value)

{

JSONObject jsonObject = new JSONObject();

jsonObject.put(key, value);

return jsonObject.toString();

}

B、客户端将json字符串转换为相应的javaBean

1、客户端获取json字符串（因为android项目中已经集成了json的jar包所以这里无需导入）

public class HttpUtil

{

public static String getJsonContent(String urlStr)

{

try

{// 获取HttpURLConnection连接对象

URL url = new URL(urlStr);

HttpURLConnection httpConn = (HttpURLConnection) url

.openConnection();

// 设置连接属性

httpConn.setConnectTimeout(3000);

httpConn.setDoInput(true);

httpConn.setRequestMethod(“GET”);

// 获取相应码

int respCode = httpConn.getResponseCode();

if (respCode == 200)

{

return ConvertStream2Json(httpConn.getInputStream());

}

}

catch (MalformedURLException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

catch (IOException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return “”;

}

private static String ConvertStream2Json(InputStream inputStream)

{

String jsonStr = “”;

// ByteArrayOutputStream相当于内存输出流

ByteArrayOutputStream out = new ByteArrayOutputStream();

byte[] buffer = new byte[1024];

int len = 0;

// 将输入流转移到内存输出流中

try

{

while ((len = inputStream.read(buffer, 0, buffer.length)) != -1)

{

out.write(buffer, 0, len);

}

// 将内存流转换为字符串

jsonStr = new String(out.toByteArray());

}

catch (IOException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return jsonStr;

}

}

2、获取javaBean

public static Person getPerson(String jsonStr)

{

Person person = new Person();

try

{// 将json字符串转换为json对象

JSONObject jsonObj = new JSONObject(jsonStr);

// 得到指定json key对象的value对象

JSONObject personObj = jsonObj.getJSONObject(“person”);

// 获取之对象的所有属性

person.setId(personObj.getInt(“id”));

person.setName(personObj.getString(“name”));

person.setAddress(personObj.getString(“address”));

}

catch (JSONException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return person;

}

public static ListPerson getPersons(String jsonStr)

{

ListPerson list = new ArrayListPerson();

JSONObject jsonObj;

try

{// 将json字符串转换为json对象

jsonObj = new JSONObject(jsonStr);

// 得到指定json key对象的value对象

JSONArray personList = jsonObj.getJSONArray(“persons”);

// 遍历jsonArray

for (int i = 0; i personList.length(); i++)

{

// 获取每一个json对象

JSONObject jsonItem = personList.getJSONObject(i);

// 获取每一个json对象的值

Person person = new Person();

person.setId(jsonItem.getInt(“id”));

person.setName(jsonItem.getString(“name”));

person.setAddress(jsonItem.getString(“address”));

list.add(person);

}

}

catch (JSONException e)

{

// TODO Auto-generated catch block

e.printStackTrace();

}

return list;

}

JAVA中遍历JSONObject不能按原顺序遍历

这个估计没办法，json本来就是无序的。我来试一下，没遇到这种情况。

可以重写原码，不过不推荐，如下：

要使输出是有序的，可以用LinkedHashMap来替换HashMap。

修改org.json.JSONObject的构造函数，

public JSONObject() {

this.map = new LinkedHashMap(); //new HashMap();

}

可能会对JSON 函数的执行效率有所影响。

java校验json格式及内容

代码如下

import java.text.CharacterIterator;

import java.text.StringCharacterIterator;

public class JsonValidator {

private CharacterIterator it;

private char c;

private int col;

public JsonValidator(){

}

/**

* 验证一个字符串是否是合法的JSON串

*

* @param input 要验证的字符串

* @return true-合法 ，false-非法

*/

public boolean validate(String input) {

input = input.trim();

boolean ret = valid(input);

return ret;

}

private boolean valid(String input) {

if (“”.equals(input)) return true;

boolean ret = true;

it = new StringCharacterIterator(input);

c = it.first();

col = 1;

if (!value()) {

ret = error(“value”, 1);

} else {

skipWhiteSpace();

if (c != CharacterIterator.DONE) {

ret = error(“end”, col);

}

}

return ret;

}

private boolean value() {

return literal(“true”) || literal(“false”) || literal(“null”) || string() || number() || object() || array();

}

private boolean literal(String text) {

CharacterIterator ci = new StringCharacterIterator(text);

char t = ci.first();

if (c != t) return false;

int start = col;

boolean ret = true;

for (t = ci.next(); t != CharacterIterator.DONE; t = ci.next()) {

if (t != nextCharacter()) {

ret = false;

break;

}

}

nextCharacter();

if (!ret) error(“literal ” + text, start);

return ret;

}

private boolean array() {

return aggregate(‘[‘, ‘]’, false);

}

private boolean object() {

return aggregate(‘{‘, ‘}’, true);

}

private boolean aggregate(char entryCharacter, char exitCharacter, boolean prefix) {

if (c != entryCharacter) return false;

nextCharacter();

skipWhiteSpace();

if (c == exitCharacter) {

nextCharacter();

return true;

}

for (;;) {

if (prefix) {

int start = col;

if (!string()) return error(“string”, start);

skipWhiteSpace();

if (c != ‘:’) return error(“colon”, col);

nextCharacter();

skipWhiteSpace();

}

if (value()) {

skipWhiteSpace();

if (c == ‘,’) {

nextCharacter();

} else if (c == exitCharacter) {

break;

} else {

return error(“comma or ” + exitCharacter, col);

}

} else {

return error(“value”, col);

}

skipWhiteSpace();

}

nextCharacter();

return true;

}

private boolean number() {

if (!Character.isDigit(c) c != ‘-‘) return false;

int start = col;

if (c == ‘-‘) nextCharacter();

if (c == ‘0’) {

nextCharacter();

} else if (Character.isDigit(c)) {

while (Character.isDigit(c))

nextCharacter();

} else {

return error(“number”, start);

}

if (c == ‘.’) {

nextCharacter();

if (Character.isDigit(c)) {

while (Character.isDigit(c))

nextCharacter();

} else {

return error(“number”, start);

}

}

if (c == ‘e’ || c == ‘E’) {

nextCharacter();

if (c == ‘+’ || c == ‘-‘) {

nextCharacter();

}

if (Character.isDigit(c)) {

while (Character.isDigit(c))

nextCharacter();

} else {

return error(“number”, start);

}

}

return true;

}

private boolean string() {

if (c != ‘”‘) return false;

int start = col;

boolean escaped = false;

for (nextCharacter(); c != CharacterIterator.DONE; nextCharacter()) {

if (!escaped c == ‘\\’) {

escaped = true;

} else if (escaped) {

if (!escape()) {

return false;

}

escaped = false;

} else if (c == ‘”‘) {

nextCharacter();

return true;

}

}

return error(“quoted string”, start);

}

private boolean escape() {

int start = col – 1;

if (” \\\”/bfnrtu”.indexOf(c) 0) {

return error(“escape sequence \\\”,\\\\,\\/,\\b,\\f,\\n,\\r,\\t or \\uxxxx “, start);

}

if (c == ‘u’) {

if (!ishex(nextCharacter()) || !ishex(nextCharacter()) || !ishex(nextCharacter())

|| !ishex(nextCharacter())) {

return error(“unicode escape sequence \\uxxxx “, start);

}

}

return true;

}

private boolean ishex(char d) {

return “0123456789abcdefABCDEF”.indexOf(c) = 0;

}

private char nextCharacter() {

c = it.next();

++col;

return c;

}

private void skipWhiteSpace() {

while (Character.isWhitespace(c)) {

nextCharacter();

}

}

private boolean error(String type, int col) {

System.out.printf(“type: %s, col: %s%s”, type, col, System.getProperty(“line.separator”));

return false;

}

public static void main(String[] args){

String jsonStr = “{\”website\”:\”open-open.com\”}”;

System.out.println(jsonStr+”:”+new JsonValidator().validate(jsonStr));

}

}

JAVA中按原顺序遍历JSONObject

正常的玩法应该是这样， 因为 ObjectMapper 有各种配置， 可以更好的实现转换， 比如 解析数据顺序， 忽略错误字段 等等 高端大气上档次的东西， 你的方法已经被时代淘汰了。

ObjectMapper objectMapper = new ObjectMapper();

Map map = objectMapper.readValue(resultStr,LinkedHashMap.class);

json.parseobject()的set方法设置顺序

取出数据库中的字符串通过前端的JSON.parse（str）遍历显示key,value值。到此一个新的要求是要显示的顺序和数据库中保持一致，通过JSON.parse()通常会按照key排序。所以使用JSON.parse失败。

只能手动获取字符串中的key,value值，最好的方式是采用正则，不然也可以采用 replace,replaceALl，split等方法逐步分割在回到如果不需要保持顺序的情况下，使用JSON.parse()遇到了抛出异常的问题，一看数据库中的内容，发现并不是标准的JSON格式，比如这段{name:“张三”,age:12}，此时使用JSON.parse便会抛出异常，所以需要改为{“name”:“张三”,age:12} 解决的思路是前端给该字符串补全双引号，不过也可以用JAVA。

思路是通过fastjson库将字符串转换为JSON对象，在转回JSON字符串。这里利用了fastjson对JSON格式要求不严格

在使用fastjson直接将字符串转为JSON对象后在转换回JSON字符串，顺序将保证不了。修改代码这里仅仅对key,value形式，key不带双引号的，value仅仅是字符串(也仅带特殊符号”:”)的处理，对于嵌套的JSON格式或者value值为时间，数字，其它转义特殊符号还考虑。还有些地方需要完善。