JSONJSONJSONJSON 是什么？
JSON的全称是 JavaScript Object Notation，是一种轻量级的数据交换格式。JSO
N与 XML具有相同的特性，例如易于人编写和阅读，易于机器生成和解析。但是 JSON比
XML 数据传输的有效性要高出很多。JSON完全独立与编程语言，使用文本格式保存。
JSON数据有两种结构：
• Name-Value 对构成的集合，类似于 Java中的Map。
• Value的有序列
表
关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf
，类似于 Java中的 Array。
一个 JSON格式的数据示例：
{
"Name": "Apple",
"Expiry": "2007/10/11 13:54",
"Price": 3.99,
"Sizes": [
"Small",
"Medium",
"Large"
]
}
更多关于 JSON数据格式的说明参看 JSON官方网站：http://www.json.org（中文
内容
财务内部控制制度的内容财务内部控制制度的内容人员招聘与配置的内容项目成本控制的内容消防安全演练内容
参看：http://www.json.org/json-zh.html）
GWTGWTGWTGWT与 JSONJSONJSONJSON
GWT中支持的客户端服务器端方法调用和数据传递的
标准
excel标准偏差excel标准偏差函数exl标准差函数国标检验抽样标准表免费下载红头文件格式标准下载
格式是 RPC。 JSON并不
是 GWT支持的标准的数据传递格式。那么如何使用 JSON来作为GWT的数据传递格式
呢？需要以下几步。
第一，引用 HTTP和 JSON支持。
第二，在客户端创建 JSON数据，提交到服务器
第三，在服务器上重写数据格式解析的代码，使之支持 JSON格式的数据
第四，在服务器上组织 JSON格式的数据，返回给客户端。
第五，客户端解析服务器传回的 JSON数据，正确的显示
引用HTTPHTTPHTTPHTTP和 JSONJSONJSONJSON支持
找到.gwt.xml文件，在其中的
在之后添加如下的内容：
其中 com.google.gwt.json.JSON指的是要使用 JSON，com.google.gwt.http.H
TTP值得是通过 HTTP调用服务器上的服务方法。
客户端构造 JSONJSONJSONJSON数据
客户端需要使用 com.google.gwt.json.client包内的类来组装 JSON格式的数据，
数据格式如下：
组合一个简单的 JSON数据：
数据类型 说明
JSONArray JSONValue构成的数组类型
JSONBoolean JSON boolean值
JSONException
访问 JSON结构的数据出错的情况下可以抛出此异
常
JSONNull JSON Null根式的数据
JSONNumber JSON Number类型的数据
JSONObject JSON Object类型的数据
JSONParser
将 String格式的 JSON数据解析为 JSONValue类
型的数据
JSONString JSON String 类型的数据
JSONValue 所有 JSON类型值的超级类型
Administrator
矩形
JSONObject input = new JSONObject();
JSONString value = new JSONString("mazhao");
input.put("name", value);
JSON数据格式为：{name: "mazhao"}
组合一个包含数组类型的复杂 JSON数据：
JSONObject input = new JSONObject();
JSONString value = new JSONString("mazhao");
input.put("name", value);
JSONArray arrayValue = new JSONArray();
arrayValue.set(0, new JSONString("array item 0"));
arrayValue.set(1, new JSONString("array item 1"));
arrayValue.set(2, new JSONString("array item 2"));
input.put("array", arrayValue);
JSON数据格式为：
{name: "mazhao",
array: {"array item 0", "array item 1", "array item 2"}}
注意上述的 JSON类型的数据，使用的都是 com.google.gwt.json.client 包内的类
型。这些类型最终会被编译为 JavaScript执行。
服务端重写数据解析代码，支持JSONJSONJSONJSON格式的数据
在服务器上，需要使用 JSON Java 支持类才能将 JSON格式的数据转换为各种类型
的数据，当然也可以自己写一些解析用的代码。这里我们使用了 www.json.org 上的代码
来完成。这组代码与 com.google.gwt.json.client 的代码很相似，只是在 org.json包内
部。
怎么解析 JSON术诀呢？针对上述中的复杂的 JSON数据：
{name: "mazhao",
array: {"array item 0", "array item 1", "array item 2"}}
可以使用如下的方式解析：
JSONObject jsonObject = new JSONObject(payload);
String name = jsonObject.getString("name");
Administrator
线条
Administrator
线条
Administrator
线条
System.out.println("name is:" + name);
JSONArray jsonArray = jsonObject.getJSONArray("array");
for(int i = 0; i < jsonArray.length(); i++) {
System.out.println("item " + i + " :" + jsonArray.getString(i));
}
其中 payload 指的是上述的 JSON格式的数据。
那么如何写 GWT 的 Service 来得到 Payload 的数据呢？需要两点，第一，需要建立
一个 Service 类，第二，覆盖父类的 processCall 方法。
示例代码：
package com.jpleasure.gwt.json.server;
import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.jpleasure.gwt.json.client.HelloWorldService;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* Created by IntelliJ IDEA.
* User: vaio
* Date: 2007-9-4
* Time: 22:08:31
* To change this template use File | Settings | File Templates.
*/
public class HelloWorldServiceImpl extends RemoteServiceServlet implements
HelloWorldService {
public String processCall(String payload) throws SerializationException {
try {
JSONObject jsonObject = new JSONObject(payload);
String name = jsonObject.getString("name");
System.out.println("name is:" + name);
JSONArray jsonArray = jsonObject.getJSONArray("array");
for(int i = 0; i < jsonArray.length(); i++) {
System.out.println("item " + i + " :" + jsonArray.getString(i));
}
} catch (JSONException e) {
e.printStackTrace(); //To change body of catch statement use File |
Administrator
线条
Administrator
线条
Administrator
线条
Settings | File Templates.
}
return "success";
}
}
在服务器上组织 JSONJSONJSONJSON格式的数据，返回给客户端
同上
客户端解析服务器传回的JSONJSONJSONJSON数据，正确的显示
同上
Struts2Struts2Struts2Struts2返回 jsonjsonjsonjson需要 jsonplugin-0[1].25jsonplugin-0[1].25jsonplugin-0[1].25jsonplugin-0[1].25的
包
然后我们的配置文件中需要继承 json-default
Java 代码
1.
2.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
然后我们的 Action中需要返回的 json信息需要加上注解
Java 代码
1. //pizza
2. package com.action.testJson;
3.
4. import java.util.ArrayList;
5. import java.util.List;
6.
7. import com.googlecode.jsonplugin.annotations.JSON;
8. import com.opensymphony.xwork2.ActionSupport;
9.
10.public class JsonAction extends ActionSupport {
11.
12. private static final long serialVersionUID = -
4082165361641669835L;
13.
14. Users user=new Users();
15. List userList=new ArrayList();
16.
17.
18. public String testUser(){
19. System.out.println("in the json Acton");
20. userInit();
21. userList.add(user);
22. return SUCCESS;
23. }
24.
25. public void userInit(){
26. user.setAge(1);
27. user.setName("张泽峰");
28. user.setPassword("nofengPassword");
29. }
30.
31. @JSON(name="userString")
32. public Users getUser() {
33. return user;
34. }
35.
36. @JSON(name="userList")
37. public List getUserList() {
38. return userList;
39. }
40.
41. public void setUser(Users user) {
42. this.user = user;
43. }
44.
45. public void setUserList(List userList) {
46. this.userList = userList;
47. }
48.
49.
50.}
JSONJSONJSONJSON PluginPluginPluginPlugin
的说明
Edit Page Browse Space Add Page Add News
Added by Musachy Barroso, last edited by ghostroller on Jul 04, 2008 (view change) SHOW COMMENT
NameNameNameName JSON Plugin
PublisherPublisherPublisherPublisher Musachy Barroso
LicenseLicenseLicenseLicense Open Source (ASL2)
VersionVersionVersionVersion 0.30
CompatibilityCompatibilityCompatibilityCompatibility Struts 2.0.6 or later
HomepageHomepageHomepageHomepage http://code.google.com/p/jsonplugin/
DownloadDownloadDownloadDownload http://code.google.com/p/jsonplugin/downloads/list
OverviewOverviewOverviewOverview
The JSON plugin provides a "json" result type that serializes actions into JSON. The serialization
process is recursive, meaning that the whole object graph, starting on the action class (base
class not included) will be serialized (root object can be customized using the "root" attribute).
If the interceptor is used, the action will be populated from the JSON content in the request,
these are the rules of the interceptor:
1. The "content-type" must be "application/json"
2. The JSON content must be well formed, see json.org for grammar.
3. Action must have a public "setter" method for fields that must be populated.
4. Supported types for population are: Primitives (int,long...String), Date, List, Map,
Primitive Arrays, Other class (more on this later), and Array of Other class.
5. Any object in JSON, that is to be populated inside a list, or a map, will be of type Map
(mapping from properties to values), any whole number will be of type Long, any
decimal number will be of type Double, and any array of type List.
Given this JSON string:
{
"doubleValue": 10.10,
"nestedBean": {
"name": "Mr Bean"
},
"list": ["A", 10, 20.20, {
"firstName": "El Zorro"
}],
"array": [10, 20]
}
The action must have a "setDoubleValue" method, taking either a "float" or a "double" argument
(the interceptor will convert the value to the right one). There must be a "setNestedBean"
whose argument type can be any class, that has a "setName" method taking as argument an
"String". There must be a "setList" method that takes a "List" as argument, that list will contain:
"A" (String), 10 (Long), 20.20 (Double), Map ("firstName" -> "El Zorro"). The "setArray"
method can take as parameter either a "List", or any numeric array.
Rating?
•••• 1111
•••• 2222
•••• 3333
•••• 4444
•••• 5555
InstallationInstallationInstallationInstallation
This plugin can be installed by copying the plugin jar into your application's /WEB-INF/lib
directory. No other files need to be copied or created.
To use maven, add this to your pom:
...
com.googlecode
jsonplugin
0.26
...
Maven Plugin Repository
http://struts2plugin-maven-
repo.googlecode.com/svn/trunk/
false
true
CustomizingCustomizingCustomizingCustomizing SerializationSerializationSerializationSerialization andandandand DeserializationDeserializationDeserializationDeserialization
Use the JSON annotation to customize the serialization/deserialization process. Available JSON
annotation fields:
NameNameNameName DescriptionDescriptionDescriptionDescription DefaultDefaultDefaultDefault ValueValueValueValue SerializationSerializationSerializationSerialization DeserializationDeserializationDeserializationDeserialization
name Customize field name empty yes no
serialize
Include in
serialization
true yes no
deserialize
Include in
deserialization
true no yes
ExcludingExcludingExcludingExcluding propertiespropertiespropertiesproperties
A comma-delimited list of regular expressions can be passed to the JSON Result and Interceptor,
properties matching any of these regular expressions will be ignored on the serialization process:
login.password,
studentList.*\.sin
true
login.password,
studentList.*\.sin
IncludingIncludingIncludingIncluding propertiespropertiespropertiesproperties
A comma-delimited list of regular expressions can be passed to the JSON Result to restrict
which properties will be serialized. ONLY properties matching any of these regular expressions
will be included in the serialized output.
^entries\[\d+\]\.clientNumber,
format
Format used to
format/parse a Date
field
"yyyy-MM-dd'T'HH:mm:ss" yes yes
NoteNoteNoteNote
Exclude property expressions take precedence over include property
expressions. That is, if you use include and exclude property expressions
on the same result, include property expressions will not be applied if an
exclude exclude property expression matches a property first.
^entries\[\d+\]\.scheduleNumber,
^entries\[\d+\]\.createUserId
RootRootRootRoot ObjectObjectObjectObject
Use the "root" attribute(OGNL expression) to specify the root object to be serialized.
person.job
The "root" attribute(OGNL expression) can also be used on the interceptor to specify the object
that must be populated, makemakemakemake suresuresuresure thisthisthisthis objectobjectobjectobject isisisis notnotnotnot nullnullnullnull.
bean1.bean2
WrapWrapWrapWrap withwithwithwith CommentsCommentsCommentsComments
If the "wrapWithComments" (false by default) attribute is set to true, the generated JSON is
wrapped with comments like:
/* {
"doubleVal": 10.10,
"nestedBean": {
"name": "Mr Bean"
},
"list": ["A", 10, 20.20, {
"firstName": "El Zorro"
}],
"array": [10, 20]
} */
wrapWithComments can turn safe JSON text into dangerous text. For
example,
["*/ alert('XSS'); /*"]
Thanks to Douglas Crockford for the tip!
This can be used to avoid potential Javascript Hijacks . To strip those comments use:
var responseObject = eval("("+data.substring(data.indexOf("\/\*")+2,
data.lastIndexOf("\*\/"))+")");
BaseBaseBaseBase ClassesClassesClassesClasses
By default properties defined on base classes of the "root" object won't be serialized, to serialize
properties in all base classes (up to Object) set "ignoreHierarchy" to false in the JSON result:
false
EnumerationsEnumerationsEnumerationsEnumerations
By default, an Enum is serialized as a name=value pair where value = name().
public enum AnEnum {
ValueA,
ValueB
}
JSON: "myEnum":"ValueA"
Use the "enumAsBean" result parameter to serialize Enum's as a bean with a special property
_name with value name(). All properties of the enum are also serialized.
public enum AnEnum {
ValueA("A"),
ValueB("B");
private String val;
public AnEnum(val) {
this.val = val;
}
public getVal() {
return val;
}
}
JSON: myEnum: { "_name": "ValueA", "val": "A" }
Enable this parameter through struts.xml:
true
CompressingCompressingCompressingCompressing thethethethe output.output.output.output.
Set the enableGZIP attribute to true to gzip the generated json response. The request mustmustmustmust
include "gzip" in the "Accept-Encoding" header for this to work.
true
ExampleExampleExampleExample
SetupSetupSetupSetup ActionActionActionAction
This simple action has some fields:
Example:
import java.util.HashMap;
import java.util.Map;
import com.opensymphony.xwork2.Action;
public class JSONExample {
private String field1 = "str";
private int[] ints = {10, 20};
private Map map = new HashMap();
private String customName = "custom";
//'transient' fields are not serialized
private transient String field2;
//fields without getter method are not serialized
private String field3;
public String execute() {
map.put("John", "Galt");
return Action.SUCCESS;
}
public String getField1() {
return field1;
}
public void setField1(String field1) {
this.field1 = field1;
}
public int[] getInts() {
return ints;
}
public void setInts(int[] ints) {
this.ints = ints;
}
public Map getMap() {
return map;
}
public void setMap(Map map) {
this.map = map;
}
@JSON(name="newName")
public String getCustomName() {
return this.customName;
}
}
WriteWriteWriteWrite thethethethe mappingmappingmappingmapping forforforfor thethethethe actionactionactionaction
1. Add the map inside a package that extends "json-default"
2. Add a result of type "json"
Example:
JSONJSONJSONJSON exampleexampleexampleexample outputoutputoutputoutput
{
"field1" : "str",
"ints": [10, 20],
"map": {
"John":"Galt"
},
"newName": "custom"
}
JSONJSONJSONJSON RPCRPCRPCRPC
The json plugin can be used to execute action methods from javascript and return the output.
This feature was developed with Dojo in mind, so it uses Simple Method Definition to advertise
the remote service. Let's work it out with an example(useless as most examples).
First write the action:
package smd;
import com.googlecode.jsonplugin.annotations.SMDMethod;
import com.opensymphony.xwork2.Action;
public class SMDAction {
public String smd() {
return Action.SUCCESS;
}
@SMDMethod
public Bean doSomething(Bean bean, int quantity) {
bean.setPrice(quantity * 10);
return bean;
}
}
Methods that will be called remotely mustmustmustmust be annotated with the SMDMethod annotation, for
security reasons. The method will take a bean object, modify its price and return it. The action
can be annotated with the SMD annotation to customize the generated SMD (more on that
soon), and parameters can be annotated with SMDMethodParameter. As you can see, we have a
"dummy", smd method. This method will be used to generate the Simple Method Definition (a
definition of all the services provided by this class), using the "json" result.
The bean class:
package smd;
public class Bean {
private String type;
private int price;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
}
The mapping:
true
true
Nothing special here, except that bothbothbothboth the interceptor and the result must be applied to the
action, and "enableSMD" must be enabled for both.
Now the javascript code:
Dojo's JsonService will make a request to the action to load the SMD, which will return a JSON
object with the definition of the available remote methods, using that information Dojo creates a
"proxy" for those methods. Because of the asynchronous nature of the request, when the
method is executed, a deferred object is returned, to which a callback function can be attached.
The callback function will receive as a parameter the object returned from your action. That's it.
ProxiedProxiedProxiedProxied objectsobjectsobjectsobjects
(V0.20) As annotations are not inherited in Java, some user might experience problems while
trying to serialize objects that are proxied. eg. when you have attached AOP interceptors to your
action.
In this situation, the plugin will not detect the annotations on methods in your action.
To overcome this, set the "ignoreInterfaces" result parameter to false (true by default) to
request that the plugin inspects all interfaces and superclasses of the action for annotations on
the action's methods.
NOTE: This parameter should only be set to false if your action could be a proxy as there is a
performance cost caused by recursion through the interfaces.
true
false
true
false
在 StrutsStrutsStrutsStruts 222
浙公网安备 33021202002483