在STRUTS2中如何使用JSON
json使用场景及使用方法

json使用场景及使用方法JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,常用于Web应用中的数据传输和存储。
以下是JSON 的使用场景和使用方法:1. 数据传输:JSON常用于前后端之间的数据传输。
前端可以将数据序列化为JSON格式,通过AJAX请求发送给后端,后端则可以解析JSON数据,并根据需要进行处理和返回相应的数据。
2. 存储配置信息:JSON可以用来存储和配置应用程序的设置和参数。
通过将配置信息保存为JSON文件,可以实现动态修改和更新配置,而无需修改源代码。
3. API接口:许多Web服务和API都使用JSON作为数据交换的格式。
前端通过调用API接口获取JSON数据,然后解析和展示数据。
4. 数据存储:JSON也可以用来存储数据,特别适用于非关系型数据库或文档数据库。
在这种情况下,可以将JSON作为文档的格式,存储和检索数据。
使用JSON的方法如下:1. 序列化:将对象转换为JSON字符串的过程称为序列化。
可以使用编程语言中提供的JSON库或API来将对象转换为JSON格式。
2. 解析:将JSON字符串转换为对象的过程称为解析。
同样,可以使用JSON库或API来解析JSON字符串,并将其转换为对象或其他数据结构。
3. 访问和修改:一旦将JSON数据转换为对象,就可以通过点号或方括号来访问和修改其中的属性和值。
例如,对于以下JSON数据:```{"name": "John","age": 25,"email":"****************"}```可以使用``或`object["name"]`来访问和修改`name`属性的值。
总之,JSON在Web开发中被广泛应用于数据交换和存储,通过序列化和解析的方式可以方便地处理JSON数据。
struts2的execute() 方法

struts2的execute() 方法(实用版4篇)《struts2的execute() 方法》篇1在Struts 2 中,execute() 方法是Action 的核心方法,它负责处理HTTP 请求并返回一个Action 的执行结果。
当Struts 2 接收到一个HTTP 请求时,它会查找并实例化指定的Action 类,然后调用其execute() 方法。
execute() 方法的参数包括:- HttpServletRequest 请求对象- HttpServletResponse 响应对象- ActionContext 动作上下文对象execute() 方法的返回值通常是Action 的一个结果类型,例如String、Map、List 等。
在Struts 2 中,结果类型可以通过在Action 类上添加注解来指定,例如:```java@Result(type = "json")public String handle() {//...}```如果execute() 方法返回一个结果类型为String 类型的字符串,那么Struts 2 将将其作为HTML 页面的内容返回给客户端。
如果返回一个Map 类型的结果,那么Struts 2 将将其作为JSON 数据返回给客户端。
如果返回一个List 类型的结果,那么Struts 2 将将其作为一个表格返回给客户端。
《struts2的execute() 方法》篇2在Struts 2 中,execute() 方法是Action 类的核心方法,它是Action 处理请求的关键步骤。
当请求进入Action 类后,首先会调用execute() 方法。
execute() 方法负责处理用户的请求,执行相应的业务逻辑,并将处理结果返回给客户端。
Struts 2 的execute() 方法的参数包括:1. HttpServletRequest request:当前请求的ServletRequest 对象。
Struts2返回JSON对象

1、引入包(本文中的包全部引自struts-2.1.8.1\lib):struts2-json-plugin-2.1.8.1.jarjson-lib-2.1.jarcommons-collections-3.2.jarcommons-beanutils-1.7.0.jarcommons-lang-2.3.jarcommons-logging-1.0.4.jarezmorph-1.0.3.jar这7个包是返回json形式的数据必须的。
因为json大量引用了Apache commons的包,所以要加入4个,commons包,除了commons的包外,还需要引入一个ezmorph的包。
最后加入struts2必须的6个包:struts2-core-2.1.8.1.jarxwork-core-2.1.6.jarognl-2.7.3.jarfreemarker-2.3.15.jarcommons-fileupload-1.2.1.jarcommons-io-1.3.2.jar2、后台:1) Userinfo实体类代码public class UserInfo implements Serializable {private int userId;private String userName;private String password;get set方法略}2) Action类public class TestAction extends ActionSupport {private String message; //使用json返回单个值 private UserInfo userInfo; //使用json返回对象 private List userInfosList; //使用josn返回List对象get set方法略/*返回单个值*/public String returnMsg(){this.message = "成功返回单个值";return SUCCESS;}/*返回UserInfo对象*/public String returnUser(){userInfo = new UserInfo();userInfo.setUserId(10000);userInfo.setUserName("刘栋");userInfo.setPassword("123456");return SUCCESS;}/*返回List对象*/public String returnList(){userInfosList = new ArrayList<UserInfo>();UserInfo u1 = new UserInfo();u1.setUserId(10000);u1.setUserName("张三");u1.setPassword("111111");UserInfo u2 = new UserInfo();u2.setUserId(10001);u2.setUserName("李四");u2.setPassword("222222");userInfosList.add(u1);userInfosList.add(u2);return SUCCESS;}}3) struts.xml(必须继承json-default、json-default继承自struts-default)<package name="default" namespace="/json" extends="json-default"><action name="returnMsg" class="com.testAction " method="returnMsg"> <result name="success" type="json"><param name="root">validate</param></result></action><action name="returnUser "class="com.testAction " method="returnUser "><result name="success" type="json"><param name="includeProperties">userInfo\.userId,userInfo\.userName,userInfo\.password</param></result></action><action name="returnList" class="com.testAction "method="returnList"><result name="success" type="json"><param name="includeProperties">userInfosList\[\d+\]\.userName,userInfosList\[\d+\]\.password </param></result></action></package>4、只要继承extends="json-default",result type设置成json之后,容器会把action的属性自动封装到一个json对象中(json拦截器来做)5、includeProperties 参数:输出结果中需要包含的属性值,这里正则表达式和属性名匹配,可以用“,”分割填充多个正则表达式。
strusts2课堂总结

一、1、struts2struts2是mvc设计思想的一个实现,可以将项目低耦合,提高扩展性2、struts2和struts1的区别struts2不是struts1的升级,而是继承的下xwork的血统,它吸收了struts1和webwork 的优势。
struts2的action是原型,安全的,struts2的action是单例,非安全3、步骤:1、导入包2、在web.xml文件中,加入struts2的核心拦截器3、在src下放入struts2的xml struts.xml4、urlhttp://localhost:8080/Struts2_01_HelloWorld/demo/hello.action二、1、默认值2、转发和重定向的区别转发:url显示的依然是上一个的url,共享上一次的请求重定向:url显示的是下一个的url,不共享3、urlhttp://localhost:8080/Struts2_02_Default/demo/hello.action4、路径http://localhost:8080/Struts2_02_Default/demo/a/b/c/hello.action1、原路径找不到,http://localhost:8080/Struts2_02_Default/demo/a/b/hello.action2、如果1找不到,http://localhost:8080/Struts2_02_Default/demo/a/hello.action3、如果2找不到,http://localhost:8080/Struts2_02_Default/demo/hello.action3、如果3找不到,http://localhost:8080/Struts2_02_Default/hello.action三、11、自定义action继承ActionSupport2、功能方法必须满足格式public String 名字()throws Exception{....};3、urlhttp://localhost:8080/Struts2_03_Action/demo/a.action四、1、如何给action传入参数注意:赋值的必须有封装的set方法,通过el表达式获取的时候,必须有封装的get 方法1、直接给单个参数赋值,在action里建立一个变量,名字与参数的名字一样2、为对象的某个属性赋值,在action里建立一个对象,将参数改为对象名.属性的格式五、1、转发和重定向的区别转发到下一次的时候,url依然是上一次的url,共享上一次的request重定向到下一次的时候,url是下一次的url,不共享上一次的request2、struts2的result的type转发:共享上一次action重定向:不共享上一次action1、转发到下一个jsp,html:dispatcher2、重定向到下一个jsp,html:redirect3、转发到下一个action:chain转到同一个包下的action转发到不同包下的action4、重定向到下一个action:redirectAction转到同一个包下的action转发到不同包下的action六、1、为了分模块开发,可以设置多个xmL文件。
struts2+json+jquery实现ajax登录和注册功能

在上一篇博文中已经学习了如何整合mybatis和spring,实现持久层的CRUD操作、业务层的事务管理和spring的IoC。
现在我们这个demo的基础上,继续整合struts2,并利用json插件和jquery实现ajax,完成后系统将实现登录与注册的简单功能。
浏览器端如何简单、高效地与服务器端进行数据交互是web开发者最为关心的内容。
在客户端构造intput表单数据或者拼凑URL参数名称/参数值,然后在服务器端笨拙地用request.getParameter(“参数名称”)获取参数显然已经过时了,在struts2中,只要在action 里定义了input表单名称/URL参数名称对应的String类型属性,并设置getter和setter 方法,struts2在调用action的时候就可以根据参数值自动帮你设置好action中对应的属性值供你使用,这极大地方便了开发者。
但是json更为强大——它可以根据浏览器端上传的符合格式的数据设置action中对象的值,也就是说,struts2自动封装的数据只有一层,而json是无限层。
json给页面参数的传递带来极大的方便,结合jquery来使用,可以轻易地做到页面局部刷新、页面无跳转进行友好的系统异常提示等,其中后者是我觉得最有必要做到的一点,在action中定义一个message变量,把action方法执行的结果或者系统异常信息放到里面以json的方式返回给客户端,客户端根据这个变量的结果来进行下一步的操作或者提示系统异常信息,非常地好用。
json由javascript中的对象和数组构成,基本形式是{key:value},key为属性名称,value 为属性值,value可以为数字、字符串、数组、对象,value可以为数组和对象是json可以封装无限层数据的关键所在。
至于如何建构和解析json不是本篇博文的详细表述范围,请参考其他资料。
现在就让我们利用struts2作为MVC框架,整合json插件,在浏览器端使用jquery解析和系列化json数据,由此制作一个具有登陆/注册功能的小demo。
fastjson2 jsonpath 语法

fastjson2 jsonpath 语法
fastjson2的jsonpath语法与其他的JSONPath语法类似,它支持使用点(.)和方括号([])来访问JSON对象中的属性和数组元素。
以下是fastjson2的jsonpath语法的一些示例:
1. 使用点号获取属性:
- $.name:获取根对象的name属性的值
- $.address.street:获取根对象的address属性下的street属性的值
2. 使用方括号和索引获取数组元素:
- $[0]:获取数组的第一个元素
- $[1].name:获取数组的第二个元素的name属性的值
3. 使用通配符*匹配多个元素:
- $.employees[*].name:获取根对象的employees属性中所有元素的name属性的值
4. 使用过滤器进行条件筛选:
- $.employees[?(@.age > 30)].name:获取根对象的employees 属性中age大于30的元素的name属性的值
5. 使用逻辑运算符进行条件组合:
- $.employees[?(@.age > 30 && @.gender == "male")].name:获取根对象的employees属性中age大于30且gender为male
的元素的name属性的值
更多关于fastjson2的jsonpath语法的详细信息可以参考fastjson2的官方文档或者其他jsonpath的文档。
Struts2配置json数据返回

Struts2配置json数据返回(作者:张宗杰时间:2012-05-07)从事软件编程工作近3个月来,在项目中经常的使用到json数据格式。
由于公司的框架已经高度封装好了,我们只需用java调用相关的类,即可向浏览器返回json数据格式,但本人对这个十分好奇,今天抽空研究了下在struts2下如何自己配置json数据返回方法。
首先,在myeclipse中新建一个java web工程,接着引入Struts2必须的jar包,这时要使用json,还需多引入一个名字为“struts2-json-plugin-2.3.1.2.jar”的jar包(版本号和你下载的struts2有关,本人使用的是struts-2.3.1.2),结构如图1所示:图1jar包引入同时把jquery.js也放到工程中,后面采用javascript读取出服务器返回的json数据。
然后配置web.xml文件,具体步骤不说了,如果不会struts2的,自己先去学习一下,然后再看本文章。
然后在struts.xml中新增如图2所示代码,用于strust2识别json:图2json配置我们可以自己手工的用java代码输出json数据格式,同时也可以使用很多开源的类来来实现(可以访问去下载java的json相关类)。
在这里,我使用org.json。
下载下来后,解压出源码,对照着在myeclipse中建立出包结构,把这些源代码放到里面,如图3所示:图3引入org.json接着在com.ajie包下建立JsonTest.java类,继承ActionSupport类。
然后建立一个方法,实现向客户端返回http的数据,如图4所示:图4接着实现strust2的execute方法,代码如图5所示:图5上述代码,封装了2个json值,分别是test和msg。
然后在index.jsp中编写html代码和js代码,html代码如图6所示:图6Js代码如图7所示:图7然后将web工程部署到tomcat中,运行,打开浏览器,运行后看到如图8所示界面:图8接着,打开firebug,点击按钮后观察http的传输流程,结果如图9所示:图9浏览器也将弹出一个对话框,显示json中test对应的值,如图10所示:图10本文只是讲述了如何在struts2中使用json,只要稍微修改就可以在项目中运用。
关于Struts-JSON配置(详解带实例struts2的json数据支持)

关于Struts-JSON配置(详解带实例struts2的json数据支持)关于Struts-JSON的提高开发效率一、JSON是什么?:JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。
易于人阅读和编写,同时也易于机器解析和生成。
它基于JavaScript(Standard ECMA-262 3rd Edition - December 1999)的一个子集。
JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C , C#, Java, JavaScript, Perl, Python等)。
这些特性使JSON成为理想的数据交换语言。
二、struts2对于JSON有什么支持?:struts2提供了一个struts2-json-plugin.jar 用于支持JSON的使用。
当我们在struts2中使用JSON的时候必须导入struts2-json-plugin.jar并且需要一下几点:1.<package name="struts2" extends="json-default">//必须是继承struts2-json-plugin.jar中struts-plugin.xml文件中的定义的json-default/* struts2-json-plugin.jar中struts-plugin.xml配置信息:<struts><package name="json-default" extends="struts-default"> <result-types><result-type name="json" class="org.apache.struts2.json.JSONResult"/></result-types><interceptors><interceptor name="json" class="org.apache.struts2.json.JSONInterceptor"/> </interceptors></package></struts>通过配置信息我们可以知道:1.json-default其实是继承了struts-default的2.定义了一个name为json的返回类型和一个name为json的拦截器 */2.<action name="*" class="*"><result name="success" type="json"/></action>//我们需要将result的返回类型定义为json三、关于JSON在struts.xml中的一些属性的功能。
Struts2+JQuery插件的使用

Struts2—使用JQuery插件(2) 本节介绍更多更高级的JQuery控件.1.首先做好基本配置,这次将JSON 插件一起加入struts2xml文件struts-jquery.xml2.选项卡效果2.1选项卡的内容在本地新建localtab.jsp关于JqueryUI 插件:在Jquery官方,提供了很多的jquery插件,其中jqueryUI 是一套关于用户界面的插件,使用它可以很方便的做出各种界面效果,而且还提供了themes 各种主题包的下载,可以很方便的更换主题在为Struts2做插件的时候,struts2-jquery插件将jquery官方的jquery核心js文件,还有jquery的UI插件,以及主题(themes)都打进了jar包中,如下图在localtab.jsp文件中添加如下代码:运行该jsp文件,效果如下:字体有些大,我们可以通过css将字体进行调整上面我们使用<sj:head >标签引入jquery库的时候,只是使用<sj:head jqueryui="true" />引入了jqueyUI,此时会有一个默认的themes被应用。
我们可以查看生成的HTML 源代码:可以看到themes的名称为smoothness,那么插件包中都提供了那些themes呢,我们可以查看struts2-jquery-plugin-1.8.X.ja文件:可以看到提供了cupertino ,darkness,lightness, redmod,smoothness 这样的几个风格,其中smoothness是默认的风格.2.2改变风格如何改变风格呢?很简单在<sj:head />中只需要给jquerytheme属性设置风格名称即可:做完这个设置之后,浏览页面:可以看到这个页面的风格发生了变化插件包中提供的主题毕竟有限,如果我们需要更多的主题,我们可以到jquery官方网站下载更多的主题,甚至可以使用官网提供的在线工具定制出我们需要的主题.Jquey首页: 定制主题(theme)下载定制好的主题:下载之后的文件, 这里我下载的是名称为start的themes:进入development-bundle 文件夹:进入themes文件夹里面有两个themes,一个是base,一个是start,这两个文件夹的目录结构都是一样的,不光是这两个一样,所有的jquery UI的themes目录结构都是一样的,里面都是一些css样式,还有图片文件。
Struts2-Json-Plugin 的使用

Struts2-Json-Plugin 的使用在Struts2 中要使用Ajax 获得Json 数据我认为目前还是struts2-json-plugin 了。
当然你你可以用手工用像XStream、Google Gson、Jackson 这样的工具手工把Java 对象转换成Json 字符串再写往Response 去,要写的代码自然多不了,还得留心字符集与content type。
而struts2-json-plugin 毫无疑问是与Struts2 最亲近了,只需你配置一些属性就能得到你想的结果。
本想分几篇逐步介绍如何使用struts2-json-plugin 的,然而就在现在发现官方的struts2-json-plugin 指南已经很详细了,所以干脆翻译一下/2.2.1.1/docs/json-plugin.html,同时自己加深对它的理解。
JSON 插件提供了一个"json" 结果类型来把action 序列化成JSON. 这一序列化的过程是递归的, 意即整个对象图,从action 类开始(未包括基类) 将会被序列化(可以用"root" 属性来指定自己的根对象). 如果使用了json 拦截器, action 将可通过请求中的JSON 内容组装出来, 该拦截器遵循以下几条规则:"content-type" 必须为"application/json"JSON 内容必须是格式良好的, 参考 中的语法.Action 里必须有欲获取值的属性的相应public 的"setter" 方法.所支持的类型有: 原始类型(int,long...String), Date, List, Map, 原始类型数组, 其他的类(将会支持更多), 和其他类型的数组.JSON 中的任何将要被填入到list 或map 中的对象会是Map 类型(属性映射到值), 任何整数都是Long 类型, 任何小数会是Double 类型, 任何数组会是List 类型.给定下面的JSON 字符串:{"doubleValue": 10.10,"nestedBean": {"name": "Mr Bean"},"list": ["A", 10, 20.20, {"firstName": "El Zorro"}],"array": [10, 20]}action 中必须有一个"setDoubleValue" 方法, 参数为"float" 或者"double"(拦截器将会把值转换为相应的类型). 还必须有一个"setNestedBean" 方法,它的参数类型可以为任何类类型, 其中含有参数为"String" 的"setName" 方法. 还必须有一个参数为"List" 的"setList" 方法, 这个List 中将会包含: "A" (String), 10 (Long), 20.20 (Double), Map ("firstName" -> "El Zorro"). "setArray" 方法可以是"List", 或任何数字类型数组作参数的.序列化你的对象成javascript 的JSON, 参考json2安装本插件可通过把插件jar 包到你的应用的/WEB-INF/lib 目录来完成安装. 没有别的文件需要拷贝或被创建.使用maven 的话, 加入下列到你的pom 中:<dependencies>...<dependency><groupId>org.apache.struts</groupId><artifactId>struts2-json-plugin</artifactId><version>STRUTS_VERSION</version></dependency>...</dependencies>定制化序列化和反序列化使用JSON 注解来达到定制序列化和反序列化过程. 可用的JSON 注解如下:名称描述默认值序列化反序列化name 定制字段名empty yes noserialize 标识为可被序列化true yes nodeserialize 标识为可被反序列化true no yesformat 用于格式化或解析Date 字段的格式"yyyy-MM-dd'T'HH:mm:ss" yes yes排除属性逗号分隔的正则表达式列表可传递给JSON Result 和Interceptor(拦截器), 被任何一个正则表达式匹配的属性将会在序列化过程时忽略掉:<!-- Result fragment --><result type="json"><param name="excludeProperties">login.password,studentList.*\.sin</param></result><!-- Interceptor fragment --><interceptor-ref name="json"><param name="enableSMD">true</param><param name="excludeProperties">login.password,studentList.*\.sin</param></interceptor-ref>包含属性逗号分隔的正则表达式列表可被传递给JSON Result, 用于限制哪些属性可用于序列化. 只有当能够匹配任何一个正则表达式的属性才会包含在序列化输出中.排除属性表达式优先于包含属性的表达式. 那就是说, 如果包含和排除表达式应用于同一个结果, 包含表达式对于被排除表达式匹配到的属性是不起作用的.<!-- Result fragment --><result type="json"><param name="includeProperties">^entries\[\d+\]\.clientNumber,^entries\[\d+\]\.scheduleNumber,^entries\[\d+\]\.createUserId</param></result>根对象使用"root" 属性(OGNL 表达式) 指定被用于序列化的根对象.<result type="json"><param name="root">person.job</param></result>"root" 属性(OGNL 表达式) 也可以用于拦截器来指定被组装的对象, 确保这个对象不会是null.<interceptor-ref name="json"><param name="root">bean1.bean2</param></interceptor-ref>包装可能会有某些原因,你想要用些文本对JSON 输出包装一下, 像用注释包裹, 加上前缀, 或使用文件上载让结果显示在textarea 之中. 用wrapPrefix 在开始处加上内容,wrapPostfix 添加内容在尾端. 这两个参数优先使用,而"wrapWithComments" 和"prefix" 自从0.34 后就不推荐使用. 例子:进行注释:<result type="json"><param name="wrapPrefix">/*</param><param name="wrapSuffix">*/</param></result>添加前缀:<result type="json"><param name="wrapPrefix">{}&&</param></result>包裹上传的文件内容:<result type="json"><param name="wrapPrefix"><![CDATA[<html><body><textarea>]]></param><param name="wrapSuffix"><![CDATA[</textarea></body></html>]]></param></result>wrapWithComments 自0.34 不推荐使用, 建议用wrapPrefix 和wrapSuffix.wrapWithComments 可使得安全的JSON 文本变得不安全. 例如,["*/ alert('XSS'); /*"]谢谢Douglas Crockford 的提示! 应考虑用prefix.假如被序列化的JSON 是{name: 'El Zorro'}. 那么此时输出就会是: {}&& ({name: 'El Zorro'}假如"wrapWithComments" (默认为false) 属性被设为true, 生成的被包裹上注释的JSON 就如下:/* {"doubleVal": 10.10,"nestedBean": {"name": "Mr Bean"},"list": ["A", 10, 20.20, {"firstName": "El Zorro"}],"array": [10, 20]} */欲取消上面的注释,可用:var responseObject = eval("("+data.substring(data.indexOf("\/\*")+2, stIndexOf("\*\/"))+")");前缀prefix 从0.34 后不建议用, 请用wrapPrefix 和wrapSuffix.假如参数prefix 被设置为true, 生成的JSON 将被附上前缀"{}&& ". 这有助于防止被劫持. 详细内容请看this Dojo Ticket:<result type="json"><param name="prefix">true</param></result>基类默认时,定义在"root" 对象的基类中的属性不会被序列化, 要序列化来自于所有基类(直到Object) 中的属性,需在JSON result 里设置"ignoreHierarchy" 为false:<result type="json"><param name="ignoreHierarchy">false</param></result>枚举类型默认的, Enum 被序列化为name=value 对,这里的value = name().public enum AnEnum {ValueA,ValueB}JSON: "myEnum":"ValueA"使用result 的参数"enumAsBean" 可使得Enum 像一个bean 一样的被序列化,特定的属性为_name,值为name(). 所有的枚举属性都会被序列化.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" }在struts.xml 中启用该参数:<result type="json"><param name="enumAsBean">true</param></result>压缩输出.设置enableGZIP 属性为true 可用gzip 压缩响应输出. 在请求后"Accept-Encoding" 头中必须包含"gzip" 才能正常工作.<result type="json"><param name="enableGZIP">true</param></result>防止浏览器缓存响应数据noCache 设置为true(默认为false) 会设置如下响应头:Cache-Control: no-cacheExpires: 0Pragma: No-cache<result type="json"><param name="noCache">true</param></result>排除值为null 的属性默认的,为null 的字段也被序列化,生成像{property_name: null}. 这能够通过设置excludeNullProperties 为true 来防止.<result type="json"><param name="excludeNullProperties">true</param></result>状态和错误代码使用statusCode 来设置响应状态代码:<result type="json"><param name="statusCode">304</param></result>同时可用errorCode 来发送一个错误(the server might end up sending something to the client which is not the serialized JSON):<result type="json"><param name="errorCode">404</param></result>JSONPTo enable JSONP, set the parameter callbackParameter in either the JSON Result or the Interceptor. A parameter with that name will be read from the request, and it value will be used as the JSONP function. Assuming that a request is made with the parameter "callback"="exec":<result type="json"><param name="callbackParameter">callback</param></result>And that the serialized JSON is {name: 'El Zorro'}. Then the output will be: exec({name: 'El Zorro'})Content TypeContent type will be set to application/json-rpc by default if SMD is being used, or application/json otherwise. Sometimes it is necessary to set the content type to something else, like when uploading files with Dojo and YUI. Use the contentType parameter in those cases.<result type="json"><param name="contentType">text/html</param></result>ExampleSetup ActionThis 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 serializedprivate transient String field2;//fields without getter method are not serializedprivate 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;}}Write the mapping for the actionAdd the map inside a package that extends "json-default"Add a result of type "json"Example:<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN""/dtds/struts-2.0.dtd"><struts><package name="example" extends="json-default"><action name="JSONExample"><result type="json"/></action></package></struts>JSON example output{"field1" : "str","ints": [10, 20],"map": {"John":"Galt"},"newName": "custom"}JSON RPCThe 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;}@SMDMethodpublic Bean doSomething(Bean bean, int quantity) {bean.setPrice(quantity * 10);return bean;}}Methods that will be called remotely must 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 thodParameter. 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:<package name="RPC" namespace="/nodecorate" extends="json-default"><action name="SMDAction" method="smd"><interceptor-ref name="json"><param name="enableSMD">true</param></interceptor-ref><result type="json"><param name="enableSMD">true</param></result></action></package>Nothing special here, except that both the interceptor and the result must be applied to the action, and "enableSMD" must be enabled for both.Now the javascript code:<s:url id="smdUrl" namespace="/nodecorate" action="SMDAction" /><script type="text/javascript">//load dojo RPCdojo.require("dojo.rpc.*");//create service object(proxy) using SMD (generated by the json result)var service = new dojo.rpc.JsonService("${smdUrl}");//function called when remote method returnsvar callback = function(bean) {alert("Price for " + bean.type + " is " + bean.price);};//parametervar bean = {type: "Mocca"};//execute remote methodvar defered = service.doSomething(bean, 5);//attach callback to defered objectdefered.addCallback(callback);</script>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 hronous 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.Proxied objectsAs 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.<action name="contact" method="smd"><interceptor-ref name="json"><param name="enableSMD">true</param><param name="ignoreSMDMethodInterfaces">false</param></interceptor-ref><result type="json"><param name="enableSMD">true</param><param name="ignoreInterfaces">false</param> </result><interceptor-ref name="default"/></action>。
通过代码示例学习JSon在Java和Struts2中的应用技术

前言JSON采用完全独立于语言的文本格式,从而使得在JavaScript相关程序中处理JSON 格式的数据不需要应用任何特殊的API或软件工具包,这使得JSON成为理想的数据交换语言。
随着Web应用的普及及AJAX相关应用的深入,客户端和Web服务器端需要频繁地交互数据;同时随着移动设备的普及,客户端的访问设备也逐渐多样化。
如何使得同一Web 服务器能够响应不同的终端设备,并且都能够进行数据交互。
目前比较好的技术实现手段是应用JSon相关的技术。
作者根据自身多年的软件开发实践和经验总结,结合多年的IT职业培训的教学和高校软件学院一线的教学工作体验,在本系列文档中将从多个不同的方面和通过具体的程序代码示例为读者介绍JSon及相关的应用技术。
本文档主要涉及如何将Java对象转换为JSON 对象字符串、将JSON格式的对象字符串转换为Java对象、JSON在J2EE Web应用中实现数据交换的示例和应用AJAX+JSON+Struts2技术实现数据查询的应用示例等内容。
欢迎读者下载相关的技术资料阅读和收藏,并提出良好的建议。
感兴趣的读者可以在百度文库页面中搜索“杨少波”,将能够搜索到杨教授工作室精心创作的优秀程序员职业提升必读系列技术资料。
这些资料将系统地从软件设计和开发实现的“设计思想”、“管理策略”、“技术实现”和“经验方法”等方面与读者进行充分的交流,也欢迎读者发表和交流自己对软件开发、课程设计、项目实训、技术学习的心得体会。
本文目录1.1将Java对象转换为JSON对象字符串 (3)1.1.1JSON-lib系统库及开发环境搭建 (3)1.1.2将布尔类型数组转换为JSON格式的对象字符串 (6)1.1.3将字符串数组转换为JSON格式的对象字符串 (9)1.1.4将List集合对象转换为JSON格式的对象字符串 (10)1.1.5将Map集合对象转换为JSON格式的对象字符串 (11)1.1.6将Set集合对象转换为JSON格式的对象字符串 (11)1.1.7将PO对象转换为JSON格式的对象字符串 (12)1.1.8将List集合(包装PO对象)转换为JSON格式的对象字符串 (13)1.2将JSON格式的对象字符串转换为Java对象 (14)1.2.1将JSON格式的字符串转换为Java对象 (14)1.2.2将JSON对象数组字符串转换为Java对象数组 (15)1.2.3将JSON对象数组字符串转换为List集合对象 (16)1.3JSON在J2EE Web应用中实现数据交换的示例一 (18)1.3.1构建相关的JSP页面和后台处理的Servlet程序 (18)1.3.2进一步完善示例中的相关程序 (23)1.4JSON在J2EE Web应用中实现数据交换的示例二 (28)1.4.1构建JSP页面和相关的JS程序 (28)1.4.2构建系统中后台相关的系统库和程序 (33)1.5构建基于Struts2框架的示例项目 (52)1.5.1构建基于Struts2框架的Web项目 (52)1.5.2应用EL表达式和JSTL标签库显示出数据 (65)1.5.3实现系统的数据访问层相关程序 (68)1.6应用AJAX+JSON+Struts2技术实现数据查询 (71)1.6.1构建示例页面及相关的JS程序 (71)1.6.2构建示例中Struts2相关的后台处理程序 (80)1.6.3测试目前的示例实现效果 (85)1.6.4解决AJAX表单请求中的中文乱码问题 (86)1.1将Java对象转换为JSON对象字符串1.1.1JSON-lib系统库及开发环境搭建1、JSON-lib系统库(1)主要的功能JSON-lib系统库不仅可以实现将JavaBean(实体)、集合对象(如List、Set和Map等类型)等形式的Java对象或者XML数据转换成JSON格式的字符串,也还能够把JSON格式的字符串转换回JavaBean 等二进制对象。
easyui结合struts2总结

easyui 结合Struts2 总结1 在把struts2框架搭好以后,由于easyui和后台交互主要是靠ajax来进行的并且返回的数据格式是json形式的。
所以我们必须在项目中引入struts2-json-plugin 来方便的把数据转换为json格式。
需要的jar包如下图:下面是我写的一个小例子,来更好的说明之间数据是如何传递的。
(为了节省篇幅,数据库表就省略了)jsp页面主要代码如下:当我们把页面写好以后就要写action类了。
主要代码如下:get、set方法这里就省略了。
接下来就是在struts.xml 中进行配置了。
代码如下这里要特别注意了,继承的是json-default, result 中德type是json。
这里的配置是关键,起初由于配置问题,花了我很多时间。
然后就是写EmpService类和getAll方法了。
代码如下这里我是把对象先放到map集合中,让和放到list集合中,这样就自动转为json 格式(感觉有些麻烦,谁有好的方法,请发送到zl673170035@,谢谢哈)然后在浏览器上运行。
在js 中加入了工具条。
剩下的修改、删除、增加,我是仿照easyui官网的demo中的一个例子做的。
我遇到的主要问题就是,ajax 如何把参数传给action和ajax如何接收action传回的参数。
首先说说第一个问题,ajax 如何把参数传给action.。
只要action 中有相对应的get和set 方法。
我们发起ajax请求时struts就自动的把参数加到action中了。
这里把参数名都变为emp.XX 然后在action 中加入成员变量emp和get、set 方法。
这样action就能接收值了。
接下来需要从action中给ajax中传递参数了。
我们在struts.xml中如下配置在action中设置result 的get、set 方法。
这样ajax就能接收到action传回的参数了。
.json的 用法

.json的用法JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,常用于前后端数据传输、存储和配置文件。
它易于阅读和编写,并且易于解析和生成,因此它在互联网应用中得到广泛应用。
JSON的使用方法非常灵活,可以用于各种应用场景。
下面我将详细介绍JSON 的用法。
1. JSON的数据结构JSON的数据结构由键值对组成,键(也称为属性名)是字符串,值可以是字符串、数值、布尔值、数组、对象或null。
键和值之间使用冒号(:)分隔,多个键值对之间使用逗号(,)分隔。
键值对的集合通过花括号({})表示,称为对象;多个对象之间使用逗号分隔,通过方括号([])表示,称为数组。
例如,以下是一个包含数组和对象的JSON示例:JSON{"name": "张三","age": 20,"isStudent": true,"hobbies": ["篮球", "音乐", "旅游"],"address": {"province": "广东","city": "深圳"},"languages": [{"name": "JavaScript", "level": "高级"},{"name": "Python", "level": "中级"}]}2. JSON的编码与解码在应用程序中,我们经常需要将数据转换为JSON格式(编码),或将JSON格式转换为数据(解码)。
.json的 用法

.json 文件是一种纯文本文件,用于存储结构化数据。
它经常用于与Web服务和API进行交互,以及在Web开发中存储和传输数据。
以下是关于.json 文件的一些基本用法:
数据格式化:JSON(JavaScript Object Notation)使用类似JavaScript的对象字面量语法来表示结构化数据。
数据由键值对组成,可以使用逗号分隔的列表表示。
数据解析:可以使用各种编程语言中的JSON解析器将JSON数据转换为本地数据结构(如对象、数组等)。
解析器将JSON字符串转换为可操作的数据。
数据序列化:与解析相反,序列化是将本地数据结构转换为JSON格式的过程。
这通常用于将数据发送到服务器或保存到文件中。
文件操作:可以使用文本编辑器或专门的JSON编辑器打开和编辑.json文件。
这些文件通常用于存储配置信息、应用程序设置或应用程序的数据。
API交互:许多Web服务和API使用JSON作为请求和响应的格式。
当调用这些服务时,您通常会发送一个包含JSON数据的POST请求,并接收一个包含JSON数据的响应。
数据验证:由于JSON具有严格的语法规则,因此可以使用工具来验证JSON 数据的格式是否正确。
这有助于确保数据的完整性和准确性。
数据传输:JSON经常用于在不同系统之间传输数据,特别是在Web开发中。
它是一种轻量级的数据交换格式,易于阅读和编写,并且可以被机器解析和生成。
总之,.json 文件在许多方面都非常有用,特别是在处理结构化数据时。
通过使用JSON,您可以轻松地共享、存储和传输数据,而无需担心格式和兼容性问题。
java相关的Struts2-Json插件的使用例子

The JSO N p lug in p ro vid es a "js on" re sult type that se ria lizes a ctio ns into JSO N. The se ria liza tion p ro cess is re curs ive, me aning that the w ho le ob je ct g r a ph, s ta rting on the a ctio n class (b ase class not include d) w ill b e s e ria lize d (r o ot ob je ct ca n be cus to mize d us ing the "ro ot" a ttribute). If the inte rcep to r is used, the a ction w ill b e pop ulate d fro m the JSO N co ntent in the re ques t, thes e a re the rules o f the inte rce pto r:1The "conte nt-type" must be "a pp lica tio n/jso n"2The JSO N co nte nt mus t b e we ll fo rme d, s ee js on.o rg fo r g ra mma r.3Actio n mus t ha ve a p ub lic "s ette r" me tho d fo r fie ld s tha t mus t b e p o pula ted.4Sup po rte d type s fo r p op ula tio n a re: P rimitive s (int,long...String), Da te, Lis t, Map, P rimitive Arra ys, O the r cla ss (mo re o n this la te r), a nd Array o f O the r clas s.5Any o b je ct in JSO N, tha t is to b e p op ula ted ins ide a lis t, o r a ma p, w ill b e o f type Map (ma p p ing fro m p rope rtie s to va lues), a ny who le numbe r w ill b e o f type Long, a ny de cima l numbe r w ill be o f type Doub le, and a nya rra y o f type Lis t.JSON插件提供一种叫做“json”返回类型,来将action序列化成JSON 格式。
json使用方法

json使用方法JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,通常用于将结构化数据存储、传输以及表示。
JSON的使用方法非常简单和灵活,适用于多种编程语言和平台。
以下是JSON的一些常见使用方法和技巧。
1.JSON格式:JSON使用Key-Value的形式来表示数据,数据由大括号包围。
Key和Value之间使用冒号分隔,每个Key-Value对之间使用逗号分隔。
Key必须是字符串,而Value可以是字符串、数字、布尔值、数组、对象或null。
例如:```"name": "John","age": 30,"isStudent": true,"hobbies": ["reading", "coding"],"address":"street": "123 Main St","city": "New York"},"isEmployed": null```2.生成JSON:多种编程语言提供了将数据转换为JSON格式的方法或函数。
例如,在JavaScript中,可以使用`JSON.stringify(`方法将一个对象转换为JSON格式的字符串。
```var person =name: "John",age: 30,isStudent: true,hobbies: ["reading", "coding"],address:street: "123 Main St",city: "New York"},isEmployed: null};var json = JSON.stringify(person);3.解析JSON:同样,多种编程语言提供了将JSON字符串解析为对象或其他数据类型的方法或函数。
struts2返回数据

Struts2返回数据@Controller@ParentPackage("json-default")@Namespace("/user")@Scope("prototype")@Results({@Result(name="SUCCESS",type="json",params={"root","userMap"}), @Result(name="list",location="/list.jsp")})publicclass UserAction extends ActionSupport {/*** 页面异步获取数据,且需要json格式的数据* 往root根对象里面存入数据,并使用json类型返回给页面,需要提供get 方法给struts调用*/private Map<String,Object>userMap;public Map<String, Object> getUserMap() {return userMap;}/*** 页面以ognl表达式的形式获取数据:${userList}*/private List<User>userList;public List<User> getUserList() {return userList;}//方式一:返回json数据@Resourceprivate UserService userService;@Action(value="/UserAction_findAllUsers")public String findAllUsers(){List<User>users = userService.findAllUsers();int total = users.size();userMap = new HashMap<>();userMap.put("total", total);userMap.put("rows", users);return"SUCCESS";}//方式二:返回集合类型数据@Action(value="/list")public String toPage(){userList = userService.findAllUsers();return"list";}。
Struts2返回JSON数据的具体应用范例

Struts2返回JSON数据的具体应用范例早在我刚学Struts2之初的时候,就想写一篇文章来阐述Struts2如何返回JSON数据的原理和具体应用了,但苦于一直忙于工作难以抽身,渐渐的也淡忘了此事。
直到前两天有同事在工作中遇到这个问题,来找我询问,我又细细地给他讲了一遍之后,才觉得无论如何要抽一个小时的时间来写这篇文章,从头到尾将Struts2与JSON的关系说清楚。
其实网络中,关于这个问题的答案已是海量,我当初也是从这海量的答案中吸收精华,才将“Struts2返回JSON数据”这个问题搞清楚的。
但是这些海量的答案,有一个共同的缺陷,就是作者们只关注问题核心,即“如何在具体的Struts2应用中返回JSON数据到客户端”如何实现,而对于"为何要这样实现"以及实现的本质却解释的不甚了了,在笔者看来这只是“授人以鱼”而非笔者所推崇的“授人以鱼的同时,授人以渔”。
在这篇文章中,笔者将总结前辈们的经验,并结合自己的理解,来从理论到实践由浅入深的说明“Struts2返回JSON数据”这一问题。
JSON(JavaScript Object Notation)首先来看一下JSON官方对于“JSON”的解释:JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。
易于人阅读和编写。
同时也易于机器解析和生成。
它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。
JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)。
这些特性使JSON成为理想的数据交换语言。
JSON建构于两种结构:“名称/值”对的集合(A collection of name/value pairs)。
fastjson2 jsonpath 语法

在本文中,我将重点探讨fastjson2和jsonpath语法,这两个主题对于理解和操作JSON数据具有重要意义,因此希望通过本文的深入讨论,能够帮助你更好地理解和运用这些概念。
1. 了解fastjson2在介绍fastjson2之前,我们先来了解一下JSON。
JSON (JavaScript Object Notation)是一种轻量级的数据交换格式,具有简洁、易于理解的特点,被广泛用于互联网应用中的数据交换和传输。
fastjson2是阿里巴巴开发的一个高性能JSON库,它能够将Java对象转换为JSON字符串,也可以将JSON字符串转换为Java对象。
在实际应用中,fastjson2被广泛用于前后端数据交互、接口传参和返回结果的处理等方面。
它的高性能和丰富的功能使得它成为了Java开发中不可或缺的组件之一。
2. 了解jsonpath语法jsonpath是一种用于从JSON文档中选取或过滤数据的查询语言,类似于XPath对XML文档的查询。
使用jsonpath语法,可以快速、精准地定位JSON文档中的数据元素,实现对JSON数据的灵活操作和处理。
jsonpath语法具有丰富的表达能力,支持各种复杂的查询需求和条件过滤,对于处理大规模的JSON数据尤为实用。
3. fastjson2与jsonpath的结合运用将fastjson2与jsonpath结合运用,可以实现对JSON数据的快速解析和处理。
在实际开发中,我们通常会先使用fastjson2将JSON字符串转换为Java对象,然后结合jsonpath语法对Java对象进行精准的数据查询和处理。
这种结合运用可以大大提高开发效率和数据处理的灵活性,让我们更好地应对各种复杂的业务需求和数据交互场景。
4. 个人观点和理解从个人的角度来看,我认为掌握fastjson2和jsonpath语法对于Java 开发人员来说至关重要。
这不仅仅是因为它们是当前业界使用最广泛的JSON处理工具和语法,更重要的是它们能够为我们带来高效、灵活的数据操作和处理能力。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
STRUTS2对JSON的做了很好的封装。
基本上不需要对原始程序做太多修改即可变成JSON方式。
以下是一个例子。
首先是WEB程序。
function gotClick()
{
//请求的地址
var url = 'res.action';
//将form1表单域的值转换为请求参数
var params = Form.serialize('propForm');
//创建Ajax.Request对象,对应于发送请求
var myAjax = new Ajax.Request(
url,
{
//请求方式:POST
method:'post',
//请求参数
parameters:params,
//指定回调函数
onComplete: processResponse,
//是否异步发送请求
asynchronous:true
});
}
function processResponse(request)
{
console.log(request.responseText); ○1
var obj = JSON.parse(request.responseText); ○2
$("show").innerHTML = ; ○3
}
这段JS中,我们使用的是轻量级的prototype来实现AJAX,我们将FORM的数据提交给res.action。
对返回值的处理,
○1我们首先在控制台输出整个JSON字符串(FF有控制台,但IE没有),
○2然后用JSON2这个js包把JSON字符串转换为一个javascript对象,
○3并且输出其中一个属性的值。
接下来是配置文件,只用做很小改动就可以让返回值自动转换为JSON对象。
<package name="json"extends="json-default">○1
<action name="info"
class="mon.action.SysPropertyInfoAction"
method="infoJson">
<result name="success">/WEB-INF/jsp/json/info.jsp</result> </action>
<action name="res"
class="mon.action.SysPropertyInfoAction"
method="resJson">
<result type="json">○2
<param name="excludeProperties">○3
additionalInfo,additionalInfo2
</param>
</result>
</action>
</package>
○1注意这里要继承自json-default
○2返回值类型设置为JSON
○3需要注意的是,如果用JSON插件把返回结果定为JSON。
而JSON的原理是在ACTION中的
get方法都会序列化,所以前面是get的方法只要没指定不序列化,都会执行。
然而也许程序员希望有选择性的向浏览器端提供的数据。
STRUTS2提供了一些可用的办法,如例子中所示,我们把additionalInfo,additionalInfo2这两个对象设置为不返回给客户端,而其他对象不受影响。
我们也可以用includeProperties设置返回的对象,如下面这个例子
<param name="includeProperties">
person\[\d+\]\.person1
</param>
这个例子展示了更为强大的功能,STRUTS2允许用户对返回数据的限制粒度精确到对象中的某个属性,比如””,你甚至可以挥舞着正则表达式这种杀牛刀来搞定这个小问题。
最后是ACTION类,
private SysProperty prop = new SysProperty();
private String additionalInfo = " additional information";
private String additionalInfo2 = " additional information2";
public String infoJson(){
return SUCCESS;
}
public String resJson(){
System.out.println("prop : id="+prop.getId()+" ,
name="+prop.getName()+" , value="+prop.getValue()+" ,
desc="+prop.getDesc());
return SUCCESS;
}
public SysProperty getProp() {
return prop;
}
public void setProp(SysProperty prop) {
this.prop = prop;
}
//此处略去additionalInfo和additionalInfo2的get/set方法。
infoJson方法用来返回一个页面,因为在struts.xml配置文件中,我们配置了
<result name="success">/WEB-INF/jsp/json/info.jsp</result>
所以它返回了一个页面。
resJson没有配置SUCCESS,所以它只返回一个被序列化的JSON对象,并且不会导致页面跳转。
在struts.xml的配置中,提到了如何过滤返回给浏览器的数据。
同样的功能也可以在ACTION 中配置(但在配置文件中处理这个问题显得更灵活和漂亮,不是么)以下展示了JAVA注释的作用
JSON注释还支持如下几个域:
serialize:设置是否序列化该属性
deserialize:设置是否反序列化该属性。
format:设置用于格式化输出、解析日期表单域的格式。
例如"yyyy-MM-dd'T'HH:mm:ss"。
//使用注释语法来改变该属性序列化后的属性名
@JSON(name="newName")
public String getName()
{
return ;
}
需要引入 import com.googlecode.jsonplugin.annotations.JSON;
@JSON(serialize=false)
public User getUser() {
return er;
}
@JSON(format="yyyy-MM-dd")
public Date getStartDate() {
return this.startDate;
}。