serialize接口（前端调用接口404报错）

本文目录

• 前端调用接口404报错
• spring mvc怎么实现dto自动序列化反序列化
• *****怎么做json数据接口
• 怎样对带有不可序列化属性的Java对象进行序列化
• .net 做的json接口
• *****序列化ArrayList

前端调用接口404报错

今天遇到了一个很离奇的场景，使用ajax请求后台结果 后台处理成功了页面还报了404错误。
程序员不说话，默默上代码：
JS：
view plain copy
var save = function(){
$.ajax({
url: *****,
type: ’post’,
async: false,
dataType: ’json’,
data: $("#groupInfo").serialize()
}).done(function(res) {
c********(res);
if(*****) {
}else{
*****(*****);
}
});
}
后端：
view plain copy
@RequestMapping(value = "/saveOrUpdate", method = *****)
public Resp***eVo saveOrUpdate(String id, String name, String parentId, String parentName, String operate){
Resp***eVo result = new Resp***eVo();
GroupInfo info = new GroupInfo();
Date now =new Date();
*****(now);
try{
if(*****("add")){
*****(*****(parentId));
*****(name);
*****(now);
*****(info);
}else if (*****("edit")) {
*****(*****(id));
*****(name);
*****(*****(parentId));
*****(info);
}else if (*****("delete")) {
*****(*****(id));
}
*****(true);
}catch (Exception e){
*****("operate group error."+ *****(info), e);
*****(false);
*****(*****());
}
return result;
}
}
挺奇怪吧？
经分析是请求没有返回状态码，这是因为我用的是SpringMVC框架，前后端使用JSON传递数据，因为返回的是对象，而忘记了添加
@Resp***eBody
注解，所以 Spring对我的返回值进行了映射，但是映射结果又对应不到视图，所以返回了404
正常后台代码：
view plain copy
@RequestMapping(value = "/saveOrUpdate", method = *****)
@Resp***eBody
public Resp***eVo saveOrUpdate(String id, String name, String parentId, String parentName, String operate){
Resp***eVo result = new Resp***eVo();
GroupInfo info = new GroupInfo();
Date now =new Date();
*****(now);
try{
if(*****("add")){
*****(*****(parentId));
*****(name);
*****(now);
*****(info);
}else if (*****("edit")) {
*****(*****(id));
*****(name);
*****(*****(parentId));
*****(info);
}else if (*****("delete")) {
*****(*****(id));
}
*****(true);
}catch (Exception e){
*****("operate group error."+ *****(info), e);
*****(false);
*****(*****());
}
return result;
}

spring mvc怎么实现dto自动序列化反序列化

一、序列化和反序列化的概念
　　把对象转换为字节序列的过程称为对象的序列化。
　　把字节序列恢复为对象的过程称为对象的反序列化。
　　对象的序列化主要有两种用途：
　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
　　2） 在网络上传送对象的字节序列。
　　在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。
　　当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。
二、JDK类库中的序列化API
　　*****代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
　　*****代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
　　只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。
　　对象序列化包括如下步骤：
　　1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
　　2） 通过对象输出流的writeObject()方法写对象。
　　对象反序列化的步骤如下：
　　1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
　　2） 通过对象输入流的readObject()方法读取对象。
对象序列化和反序列范例：
　　定义一个Person类，实现Serializable接口
1 import *****;
2
3 /**
4 * 《p》ClassName: Person《p》
5 * 《p》Description:测试对象序列化和反序列化《p》
6 * @author xudp
7 * @version *** V
8 * @createTime 2014-6-9 下午02:33:25
9 */
10 public class Person implements Serializable {
11
12 /**
13 * 序列化ID
14 */
15 private static final long serialVersionUID = -5809782578272943999L;
16 private int age;
17 private String name;
18 private String ***;
19
20 public int getAge() {
21 return age;
22 }
23
24 public String getName() {
25 return name;
26 }
27
28 public String getSex() {
29 return ***;
30 }
31
32 public void setAge(int age) {
33 ***** = age;
34 }
35
36 public void setName(String name) {
37 ***** = name;
38 }
39
40 public void setSex(String ***) {
41 this.*** = ***;
42 }
43 }
　　序列化和反序列化Person类对象
1 import *****;
2 import *****;
3 import *****;
4 import *****;
5 import *****;
6 import *****;
7 import *****;
8 import *****;
9
10 /**
11 * 《p》ClassName: TestObjSerializeAndDeserialize《p》
12 * 《p》Description: 测试对象的序列化和反序列《p》
13 * @author xudp
14 * @version *** V
15 * @createTime 2014-6-9 下午03:17:25
16 */
17 public class TestObjSerializeAndDeserialize {
18
19 public static void main(String args) throws Exception {
20 SerializePerson();//序列化Person对象
21 Person p = DeserializePerson();//反序列Per***对象
22 *****(*****("name={0},age={1},***={2}",
23 *****(), *****(), *****()));
24 }
25
26 /**
27 * MethodName: SerializePerson
28 * Description: 序列化Person对象
29 * @author xudp
30 * @throws FileNotFoundException
31 * @throws IOException
32 */
33 private static void SerializePerson() throws FileNotFoundException,
34 IOException {
35 Person person = new Person();
36 *****("gacl");
37 *****(25);
38 *****("男");
39 // ObjectOutputStream 对象输出流，将Person对象存储到E盘的*****文件中，完成对Person对象的序列化操作
40 ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
41 new File("E:/*****")));
42 *****(person);
43 *****("Person对象序列化成功！");
44 *****();
45 }
46
47 /**
48 * MethodName: DeserializePerson
49 * Description: 反序列Per***对象
50 * @author xudp
51 * @return
52 * @throws Exception
53 * @throws IOException
54 */
55 private static Person DeserializePerson() throws Exception, IOException {
56 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
57 new File("E:/*****")));
58 Person person = (Person) *****();
59 *****("Person对象反序列化成功！");
60 return person;
61 }
62
63 }

*****怎么做json数据接口

//序列化为Json返回
User user = new User {Name = "jquery", Age = 20};
JavaScriptSerializer serializer = new JavaScriptSerializer();
string result = *****(user);
Rep********(result);
///反序列化
String input = "";
JavaScriptSerializer serializer = new JavaScriptSerializer();
*****《User》(input);
在.net 的这个命名控件下 *****；
***隐藏网址***
Good Luck！希望能够帮助到你！
如果帮助到你，请采纳！谢谢！

怎样对带有不可序列化属性的Java对象进行序列化

1、序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。
2、可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
3、序列化的实现：
1）、将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的
2）、然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象
3）、接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

.net 做的json接口

手写么...
简单的话 创建一个ashx文件 后台重写ProcessRequest方法 从*****中获取客户端请求的数据 如QueryString Form等
然后查询数据库 创建返回的封装对象(可以用匿名类) 然后用*****或者内置的JSSerialize对象编码成js文本 用*************输出
***隐藏网址***

*****序列化ArrayList

Axis是Apache组织推出的SOAP引擎，Axis项目是Apache组织著名的SOAP项目的后继项目。Axis为开发者提供了大量的序列化/反序列化器，能够基本满足大部分应用。但在某些情况下，对特定的对象，现有的序列化/反序列化器不能胜任，于是只有开发人员自己实现专用于此对象的序列化/反序列化器插入到Axis中来完成序列化工作。考虑到Web Service是一门新兴技术，中文资料大多是泛泛的讲解，关于序列化/反序列化器的开发鲜有较为深入的介绍，本文提供一份较为完整的开发指南，并提供了一个十分有用的实现，即序列化JDOM模型的Element,使其可以通过Web 服务在网络上传输，我想这一扩展是许多采用JDOM作为XML解析工具的开发人员都梦寐以求的功能。通过本文的介绍和实例，希望能起到抛砖引玉的作用，读者在阅读完本文之后可以轻松的实现针对于任何非符合BEAN规范的对象的序列化/反序列化器。
本文所面对的读者需要有一定的使用Axis做Web服务开发的开发经验，因此关于如何Axis的基础知识并不在本文的介绍范围，如果读者对此感兴趣，可以参考本文最后的参考资料部分，去相应的网站进行学习。
序列化/反序列化器简介
序列化/反序列化器在英文中的对应翻译是Serializer/Deserializer，一个序列化器的功能是遵循一定的映射规则和编码风格，将一种类型的J**A对象通过某种特定的机制，转换成为XML描述的形式；反序列化器的功能是序列化器所做工作的逆操作，两者相辅相成，成对出现。Axis中的序列化/反序列化器采用设计范式中的工厂模式，每一个Serializer唯一对应一个SerializerFactory；每一个Deserializer唯一对应一个DeserializerFactory。一种类型的J**A对象具体要采用哪个序列化/反序列化器需要在提供Web服务的服务器和调用Web服务的客户端分别配置，关于这一部分如何配置，我将在本文后面的内容中进行详细介绍。Axis已经为开发者提供了丰富的序列化/反序列化器,对于java的基本数据类型，绝大部分常用的容器类(比如数组类型，Vector类型等)都提供了实现，特别是提供了对W3C的DOM对象(比如Document, Element等)和符合Bean规范的J**A对象提供了功能完善的序列化/反序列化器，因此我们在需要的时候只要在配置文件中配置一下就可以直接使用。如果对象中包含其它类型的对象，比如Vector中包含一组Bean对象，Axis会自动叠代的调用序列化器，最终拼装成唯一的XML表述。在还原成J**A对象时，也遵循这样的叠代操作逆向进行。关于Axis到底内置了哪些序列化/反序列化器，您可以参照Axis的API文档中包*****下的类的名称"望文生义"的了解一下，在以后的开发中做到心中有数。但对于一些特殊类型的对象(其实我们自己开发的很大一部分类都是这种特殊类型的对象，很少有绝对符合Bean规范的)，需要通过Web服务进行传递，我们不得不开发自己的序列化/反序列化器。
开发篇
开发自己的序列化/反序列化器是一个激动人心的工作，但是却并不复杂,需要做的事情包括实现名成为*****的包中的SerializerFactory，Serializer，DeserializerFactory和Deserializer这四个接口。下面我将结合一个实例来讲解序列化/反序列化器的开发方法，希望读者能够一边参看本文提供的源代码一边学习。
JDOM作为一款比较"另类"的XML解析工具(因为它不符合W3C的DOM模型，自己另立一套)默默地占领着java世界里的xml解析器的半壁江山，由于其简洁的设计和方便灵活的API调用，已经渐渐成为了许多开发人员在进行XML开发的首选。但是Axis是建立在W3C的DOM模型的基础之上，师出名们正派，自然不屑与JDOM为伍。因此当开发人员想将自己已经写好的基于JDOM的应用模块采用Web服务的方式发布的时候，不可避免的会遇到如何将JDOM模型下的对象如Document, Element等序列化的问题。在软件工程师不会自己扩展Axis的序列化/反序列化器的时候，我们只能有两个办法达到这个目的，第一个就是更改以前应用模块内的API设计,使暴露的入口参数和返回值参数都是W3C的对象类型，但这种做法并不现实，因为这一应用模块往往不是独立存在，牵一发将动全身，导致旧有系统架构的崩塌；另一种做法就是为这个模块做一个代理类，它做的工作就对外接收或返回DOM模型的对象，对内转换成JDOM模型的对象，然后转发给应用模块，繁琐且效率低下。当我们向Axis注入了针对于JDOM模型的序列化/反序列化器后，这一工作便可以由Axis代劳了。下面我们将逐个开发这四个类：
JDomElementSerializerFactory
JDomElementSerializerFactory是一个工厂类，需要通过某种机制注册到Axis引擎(具体方法见下面"服务器端应用篇")；Axis通过调用它，来实例化***** 提供了BaseSerializerFactory,这个类是一个抽象类，并实现其中包含了一些可重用的代码。我们自己开发的工厂类只需简单继承这个类就可以。构造函数中需要调用父类的构造函数将序列器类下面是它的源代码：
package *****;
public class JDomElementSerializerFactory
extends BaseSerializerFactory {
public JDomElementSerializerFactory() {
super(*****);
}
}
JDomElementSerializer
JDomElementSerializer实现*****接口，其核心API是serialize()，我们需要在这个方法的内部完成对JDOM模型的Element的序列化工作,序列化的结果要保存在入口参数传入的序列化上下文对象（SerializationContext）中：
public void serialize(QName name, Attributes attributes, Object value,
SerializationContext context) throws ***** {
if (!(value instanceof Element))
throw new IOException(
*****("cant Serialize Object"));
//获取符合JDOM的Element对象
Element root=(Element)value;
//输出到StringWriter
XMLOutputter outputter=new XMLOutputter();//创建一个JDOM的XML输出器
StringWriter sw=new StringWriter();
*****(root,sw);
//用支持W3C的DOM模型的Xerces解析器解析文本流
DOMParser parser=new DOMParser();//创建一个DOM的XML解析器
try {
*****(new *****(
new *****(*****())));
}catch (Exception ex) {
throw new *****("序列化时产生错误");
}
//获取符合DOM模型的Element对象
***** w3c_root =
*****().getDocumentElement();
//放入序列化上下文对象中
*****(name, attributes);
*****(w3c_root);
*****();
}
JDomElementDeserializerFactory
反序列化器的工厂类同序列化器的工厂类一样的设计，在此不在赘述。代码：
package *****;
public class JDomElementDeserializerFactory
extends BaseDeserializerFactory {
public JDomElementDeserializerFactory() {
super(*****);
}
}
JDomElementDeserializer
用过SAX解析XML的读者，对反序列化的实现比较容易理解，反序列化也采用了消息触发的机制，我们只需继承*****类，并覆盖其中的onEndElement方法：
/**
* 在元素结束触发反序列化的方法
* @param namespace String 命名空间
* @param localName String 本地名称
* @param context DeserializationContext 反序列化上下文
* @throws SAXException
*/
public void onEndElement(String namespace, String localName,
DeserializationContext context) throws SAXException {
try {
//从反序列化上下文对象中获取原始的消息元素
MessageElement msgElem = *****();
if (msgElem != null) {
MessageContext messageContext = *****();
Boolean currentElement = (Boolean) *****(
DESERIALIZE_CURRENT_ELEMENT);
//如果当前的消息元素本身需要反序列化
if (currentElement != null && *****()) {
***** element = *****();
***** db=new *****();
value=*****(element);
*****(DESERIALIZE_CURRENT_ELEMENT,
*****);
return;
}
//反序列化消息元素中的消息体
***** children = *****();
if (children != null) {
//取得消息体
msgElem = (MessageElement) *****(0);
if (msgElem != null) {
***** ret = *****();
***** db=new *****();
//用DOMBuilder将DOM模型的Element,转换成JDOM模型的Element
value=*****(ret);
}
}
}
}
catch (Exception ex) {
//错误，则记日志,并抛SAXException
*****(*****("exception00"), ex);
throw new SAXException(ex);
}
}
完成这四个类的编码，序列化/反序列化器的开发工作基本完成，下面将详细讲解使用及部署方法。
服务器端应用篇
为了简单起见，我们将一个很简单的类通过Web服务发布,类中只有一个名称为hello函数，函数的返回值为JDOM模型的Element。代码如下：
package test;
import *****.*;
import *****;
public class Sample1 implements *****{
public Sample1() {
}
public Element hello(String name){
Element root=new Element("root");
Element hello=new Element("hello");
*****("hello,"+name+"!");
*****(hello);
return root;
}
}
关于如何将一个类发布成Web服务，在此并不进行介绍，相信读者可以自己完成，我们只关注如何将序列化/反序列化器加入到我们的Web服务中。打开web服务的配置文件*****,关于Sample1的服务的配置部分：
《service name="Sample1" type="" regenerateElement="true"
provider="java:RPC" style="rpc" use="encoded"》
《parameter name="scope" value="Request" regenerateElement="false"/》
《parameter name="className" value="*****" regenerateElement="false"/》
《parameter name="allowedMethods" value="*" regenerateElement="false"/》
《typeMapping
***隐藏网址***
qname="ns1:Element"
languageSpecificType="java:*****"
serializer=
"*****"
deserializer=
"*****"
name="Element" regenerateElement="true"
***隐藏网址***
《/service》
注意上面代码中的粗体字部分，是我们现在要添加的，它表述了如何将序列化反序列化器部署到Web服务中。
部署到Web Server
解压缩本文后面附带的源代码，根目录下有*****文件，读者需要正确安装配置好Apache Ant，然后运行
Ant make
***隐藏网址***
客户端应用篇
下面我们将编写客户端程序访问刚才部署的Web服务，讲解如何把我们编写的序列化/反序列化器加载到客户端应用程序中，下面是客户端调用的代码,注意斜体字部分，是关于序列化/反序列化器的注册过程(如果你的Web服务器不是工作在8080端口，或采用了其他Web服务名，请自行更改下面程序中的url变量中的值)，我们在test包下创建了一个名称为 Client的类，代码如下：
package test;
import *****;
import *****;
import ********;
import *****;
public class Client {
public Client() {
}
public static void main(String args) throws Exception{
if(*****《1){
*****("错误：缺少参数");
*****(0);
}
//Web服务的URL
***隐藏网址***
Service service=new Service();
Call call = (Call)*****();
*****(url);
//注册序列化/反序列化器
*****(*****,
***隐藏网址***
new *****(),
new *****());
//设置调用方法
*****(
***隐藏网址***
//Web服务调用
***** _resp = *****(new *****});
//输出到屏幕
***** out=new *****();
*****( (*****) _resp, *****);
}
}
编译后运行该程序，在控制台窗口工程的根目录下输入
run world ( 其中"world"为调用例程中API的入口参数)
经过一次web通讯，一两秒后屏幕将显示运行结果：
《root》
《hello》hello,world!《/hello》
《/root》
至此我们完成了一次Web服务的访问过程。如果在程序执行过程中，我们用TCP Moniter之类的工具监视这一次访问中的在网络中流入流出的数据，可以看到客户端发起调用的xml数据流如下：
POST /sample/services/Sample1 HTTP/***
Content-Type: text/xml; charset=utf-8
Accept: application/soap+xml,
application/dime, multipart/related, text/*
User-Agent: Axis/***
Host: *****
Cache-Control: no-cache
Pragma: no-cache
SOAPAction: ""
Content-Length: 430
《?xml version="***" encoding="UTF-8"?》
《soapenv:Envelope xmlns:soapenv=
***隐藏网址***
***隐藏网址***
***隐藏网址***
《soapenv:Body》
《ns1:hello soapenv:encodingStyle=
***隐藏网址***
***隐藏网址***
《name xsi:type="xsd:string"》world《/name》
《/ns1:hello》
《/soapenv:Body》
《/soapenv:Envelope》
服务器端返回的结果的XML输出流如下：
HTTP/*** 200 OK
Content-Type: text/xml; charset=utf-8
Date: Wed, 31 Mar 2004 06:42:18 GMT
Server: Apache Coyote/***
Connection: close
《?xml version="***" encoding="UTF-8"?》
《soapenv:Envelope xmlns:soapenv
***隐藏网址***
***隐藏网址***
***隐藏网址***
《soapenv:Body》
《ns1:helloResp***e soapenv:encodingStyle=
***隐藏网址***
***隐藏网址***
《ns1:helloReturn href="#id0"/》
《/ns1:helloResp***e》
《multiRef id="id0" soapenc:root="0" soapenv:encodingStyle=
***隐藏网址***
xsi:type="ns2:Element"
***隐藏网址***
***隐藏网址***
《root》
《hello》hello,world!《/hello》
《/root》
《/multiRef》
《/soapenv:Body》
《/soapenv:Envelope》
结语
以上详细讲解了Axis的序列化/反序列化器的开发过程，相信读者已经从中学到了不少知识，并能够应用于自己的项目开发中去。通过掌握这一技术，我们将更为深刻的理解Axis的内部结构和Web服务的工作机理，这些经验是市面上那些泛泛的讲解J**A Web服务的参考书上所学不到的。后续的文章还将向您展示一些在Java Web服务深度开发中的高级技术，让您真正驾驭Axis。
参考资料
附件中提供了本文中的全部源码，它是一个完整的工程,可以参考学习。
***隐藏网址***
《IBM DEVELOPWORK》中一个关于web服务的教程《从J**A类创建web服务》，是您快速掌握Web服务开发的很好教材，初学者可以进行学习。
***隐藏网址***