Android与服务端进行交互，使用JSON传输数据还是传输序列化对象【java吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：717,222贴子：
Android与服务端进行交互，使用JSON传输数据还是传输序列化对象收藏
一个同事和我说使用JSON传输数据不安全，想说换成传输对象思路类似于传输Java对象，通过实现序列化接口，然后客户端那边进行反序列化可是平时用的很多的都是JSON字符串进行传输他说JSON性能不好，我咋觉得不就字符串而已，性能能有多不好……不解啊不解，难道传对象性能就好了？？
呵呵， 序列号
反序列号。
gson包 性能足够了。。 还有什么性能问题？
四核八核的机子如果连你这个反序列化都搞不定那游戏还怎么运行？
你同事是逗比
...你json走网络传的是数据流,你序列化传输传的还是数据流,而且可能传的比你自定义的json更多(看你数据结构如何定义了关于提高字符串传输性能可以看看
可能是他不会解析，才说不安全，让你用对象！
用序列化省事，不用解析神马的……就是后续维护麻烦
谁不用json我打谁
不用json干嘛，浪费
Socket用序列化，HTTP用JSON
问问他那json和xml是怎么崛起的
大王派我来巡山，巡完南山巡北山，没错，我就是大水b
你说的这两种应该都和安全没多大关系吧 主要是流量问题。如果是整个对象序列化的话 没多大意义 不一定会比json节省多少、如果是仅仅对有效数据部分转化为字节流 确实可以节省流量。
肯定是json啊，灵活方便快速。。
那我也跟风说json
用序列化对象的话 客户端与服务器端耦合太高，不利于后期维护，而且显得特逗比
TCP还是HTTP？
如果服务器改版，是用其他语言写的，怎么反序列化？
这还有疑问吗，当然json好了！
json可以跨平台，毕竟只是字符串，而我感觉json是xml升级版。序列化的话跨平台貌似不能用。。。也许只能java内使用吧
前辈，服务器传回来的html该怎么用andriod把数据提出来？
只能靠加密了
用拖拉机拖过去。。。。管你多大的东西，神牛拖拉机一切搞定，，，
ios可以用吗？
登录百度帐号Android五种数据传递方法汇总
& &开发中，在不同模块(如Activity)间经常会有各种各样的数据需要相互传递，我把常用的几种
方法都收集到了一起。它们各有利弊，有各自的应用场景。
我现在把它们集中到一个例子中展示,在例子中每一个按纽代表了一种实现方法。
1. 利用Intent对象携带简单数据
利用Intent的Extra部分来存储我们想要传递的数据，可以传送int, long, char等一些基础类型,对复杂的对象就无能为力了。
& & & & 1.1 设置参数
& & & &//传递些简单的参数 &
Intent intentSimple = new Intent(); &
intentSimple.setClass(MainActivity.this,SimpleActivity.class); &
Bundle bundleSimple = new Bundle(); &
bundleSimple.putString(&usr&, &xcl&); &
bundleSimple.putString(&pwd&, &zj&); &
intentSimple.putExtras(bundleSimple); &
& & & & & & & &
startActivity(intentSimple); &
1.2 接收参数
& & & &this.setTitle(&简单的参数传递例子&); &
//接收参数 &
Bundle bunde = this.getIntent().getExtras(); &
String eml = bunde.getString(&usr&); &
String pwd = bunde.getString(&pwd&); &&
2. 利用Intent对象携带如ArrayList之类复杂些的数据
这种原理是和上面一种是一样的，只是要注意下。 在传参数前，要用新增加一个List将对象包起来。
2.1 设置参数
//传递复杂些的参数 &
Map&String, Object& map1 = new HashMap&String, Object&(); &
map1.put(&key1&, &value1&); &
map1.put(&key2&, &value2&); &
List&Map&String, Object&& list = new ArrayList&Map&String, Object&&(); &
list.add(map1); &
& & & & & & & & & & & &
Intent intent = new Intent(); &
intent.setClass(MainActivity.this,ComplexActivity.class); &
Bundle bundle = new Bundle(); &
//须定义一个list用于在budnle中传递需要传递的ArrayList&Object&,这个是必须要的 &
ArrayList bundlelist = new ArrayList(); &&
bundlelist.add(list); &&
bundle.putParcelableArrayList(&list&,bundlelist); &
intent.putExtras(bundle); & & & & & & & &
startActivity(intent); &
2.1 接收参数
&span style=&white-space:pre&& &&/span& & this.setTitle(&复杂参数传递例子&); &
& & & & &&
& & & & //接收参数 &
& & & & &Bundle bundle = getIntent().getExtras(); &&
& & & & &ArrayList list = bundle.getParcelableArrayList(&list&); &
& & & & //从List中将参数转回 List&Map&String, Object&& &
& & & & &List&Map&String, Object&& lists= (List&Map&String, Object&&)list.get(0); &
& & & & &String sResult = &&; &
& & & & &for (Map&String, Object& m : lists) & &
& & & & &{ & &
& & & & & & &for (String k : m.keySet()) & &
& & & & & & &{ & &
& & & & & & & & & sResult += &\r\n&+k + & : & + m.get(k); & &
& & & & & & &} & & & & & &
& & & & &} & &
3. 通过实现Serializable接口
3.1 设置参数
利用语言本身的特性，通过将数据序列化后，再将其传递出去。
//通过Serializable接口传参数的例子 &
HashMap&String,String& map2 = new HashMap&String,String&(); &
map2.put(&key1&, &value1&); &
map2.put(&key2&, &value2&); &
Bundle bundleSerializable = new Bundle(); &
bundleSerializable.putSerializable(&serializable&, map2); &
Intent intentSerializable = new Intent(); & &&
intentSerializable.putExtras(bundleSerializable); &
intentSerializable.setClass(MainActivity.this, &&
& & & & & & & & & & & & & & SerializableActivity.class); & & & & & & & & & & &
startActivity(intentSerializable); & &
3.2 接收参数
& & & & & this.setTitle(&Serializable例子&); &
& //接收参数 &
& &Bundle bundle = this.getIntent().getExtras(); & & &
& &//如果传 LinkedHashMap，则bundle.getSerializable转换时会报ClassCastException，不知道什么原因 &
& &//传HashMap倒没有问题。 & & & &
& &HashMap&String,String& map = &(HashMap&String,String&)bundle.getSerializable(&serializable&); &
& & & & & & & & & & & & & & &&
String sResult = &map.size() =&+map.size(); &
Iterator iter = map.entrySet().iterator(); &
while(iter.hasNext()) &
& & Map.Entry entry = (Map.Entry)iter.next(); &
& & Object key = entry.getKey(); &
& & Object value = entry.getValue(); &
& & sResult +=&\r\n key----& &+(String) &
& & sResult +=&\r\n value----& &+(String) & & & & & &
4. 通过实现Parcelable接口
这个是通过实现Parcelable接口，把要传的数据打包在里面，然后在接收端自己分解出来。这个是Android独有的，在其本身的中也用得很多，
效率要比Serializable相对要好。
4.1 首先要定义一个类，用于 实现Parcelable接口
因为其本质也是序列化数据，所以这里要注意定义顺序要与解析顺序要一致噢。
public class XclParcelable implements Parcelable { &
& & //定义要被传输的数据 &
& & public int mI &
& & public String mS &
& & public HashMap&String,String& mMap = new HashMap&String,String&(); &
& & //Describe the kinds of special objects contained in this Parcelable's marshalled representation. &
& & public int describeContents() { &
& & & & return 0; &
& & //Flatten this object in to a Parcel. &
& & public void writeToParcel(Parcel out, int flags) { &
& & & & //等于将数据映射到Parcel中去 &
& & & & out.writeInt(mInt); & & & & &
& & & & out.writeString(mStr); &
& & & & out.writeMap(mMap); &
& & //Interface that must be implemented and provided as a public CREATOR field &&
& & //that generates instances of your Parcelable class from a Parcel. &&
& & public static final Parcelable.Creator&XclParcelable& CREATOR &
& & & & & & = new Parcelable.Creator&XclParcelable&() { &
& & & & public XclParcelable createFromParcel(Parcel in) { &
& & & & & & return new XclParcelable(in); &
& & & & } &
& & & & public XclParcelable[] newArray(int size) { &
& & & & & & return new XclParcelable[size]; &
& & & & } &
& & private XclParcelable(Parcel in) { &
& & & & //将映射在Parcel对象中的数据还原回来 &
& & & & //警告，这里顺序一定要和writeToParcel中定义的顺序一致才行!!! &
& & & & mInt = in.readInt(); & & & & &
& & & & mStr &= in.readString(); &
& & & & mMap &= in.readHashMap(HashMap.class.getClassLoader()); &
& & public XclParcelable() { &
& & & & // TODO Auto-generated constructor stub &
4.2 &设置参数
//通过实现Parcelable接口传参的例子 &
& & & & & & & & & & Intent intentParcelable = new Intent(); & & & & & & & & &&
& & & & & & & & & & XclParcelable xp = new XclParcelable(); & & & & & & &&
& & & & & & & & & & xp.mInt = 1; &
& & & & & & & & & & xp.mStr = &字符串&; &
& & & & & & & & & & xp.mMap = new HashMap&String,String&(); &
& & & & & & & & & & xp.mMap.put(&key&, &value&); & & & & & & & & & & &
& & & & & & & & & & intentParcelable.putExtra(&Parcelable&, xp); & & & & & & & & & & &
& & & & & & & & & & intentParcelable.setClass(MainActivity.this, &&
& & & & & & & & & & & & & & & & & & & & & & & ParcelableActivity.class); & &&
& & & & & & & & & & startActivity(intentParcelable); & &&
4.3 接收参数
&span style=&white-space:pre&& & & &&/span&this.setTitle(&Parcelable例子&); &
& & & & &&
& & & & //接收参数 &
& & & & Intent i = getIntent(); & &&
& & & & XclParcelable xp = i.getParcelableExtra(&Parcelable&); & &&
& & & & TextView &tv = (TextView)findViewById(R.id.tv); &
& & & & tv.setText( && mInt =&+xp.mInt &&
& & & & & & & & & & +&\r\n mStr&+xp.mStr &
& & & & & & & & & & +&\r\n size()=&+xp.mMap.size()); &
5. 通过单例模式实现参数传递
& & & & 单例模式的特点就是可以保证中一个类有且只有一个实例。这样很容易就能实现，
在A中设置参数，在B中直接访问了。这是几种方法中效率最高的。
5.1 &定义一个单实例的类
//单例模式 &
public class XclSingleton &
& & //单例模式实例 &
& & private static XclSingleton instance = &
& & //synchronized 用于线程安全，防止多线程同时创建实例 &
& & public synchronized static XclSingleton getInstance(){ &
& & & & if(instance == null){ &
& & & & & & instance = new XclSingleton(); &
& & & & } & &&
& & } & &&
& & final HashMap&String, Object& mM &
& & public XclSingleton() &
& & & & mMap = new HashMap&String,Object&(); &
& & public void put(String key,Object value){ &
& & & & mMap.put(key,value); &
& & public Object get(String key) &
& & & & return mMap.get(key); &
&5.2 设置参数
//通过单例模式传参数的例子 &
XclSingleton.getInstance().put(&key1&, &value1&); &
XclSingleton.getInstance().put(&key2&, &value2&); &
Intent intentSingleton = new Intent(); & & & & & & & &
intentSingleton.setClass(MainActivity.this, &&
& & & & & & & & & & & & SingletonActivity.class); & & & & & & & & & &&
startActivity(intentSingleton); &&
5.3 接收参数
&span style=&white-space:pre&& & & &&/span&this.setTitle(&单例模式例子&); &
& & & & &&
& & & & //接收参数 &
& & & & HashMap&String,Object& map = XclSingleton.getInstance().mM & & & & & & & & & & & & &&
& & & & String sResult = &map.size() =&+map.size(); & & &&
& & & & &&
& & & & //遍历参数 &
& & & & Iterator iter = map.entrySet().iterator(); &
& & & & while(iter.hasNext()) &
& & & & { &
& & & & & & Map.Entry entry = (Map.Entry)iter.next(); &
& & & & & & Object key = entry.getKey(); &
& & & & & & Object value = entry.getValue(); &
& & & & & & sResult +=&\r\n key----& &+(String) &
& & & & & & sResult +=&\r\n value----& &+(String) & & & & & & & &
& & & & } &Android如何传输参数给一个url接口 参数是json格式
[问题点数：100分，结帖人qq_]
本版专家分：0
结帖率 50%
CSDN今日推荐
本版专家分：814
本版专家分：452
本版专家分：814
本版专家分：0
结帖率 50%
本版专家分：814
本版专家分：0
结帖率 50%
本版专家分：814
匿名用户不能发表回复！|
CSDN今日推荐在Android中调用接口，如果请求的时候，request中存在数据且该数据是另一个接口返回的数据，该如何拿到该数据
[问题点数：60分，结帖人qq_]
本版专家分：0
结帖率 77.78%
CSDN今日推荐
本版专家分：806
本版专家分：0
结帖率 77.78%
本版专家分：60
本版专家分：0
结帖率 77.78%
匿名用户不能发表回复！|
CSDN今日推荐本节引言：
上一节中我们学习了Intent的一些基本使用，知道了Intent的七个属性，显式Intent以及
隐式Intent，以及如何自定义隐式Intent，最后还给大家提供了一些常用的系统Intent！
而本节跟大家讲解的是Intent传递数据的问题~好的，开始本节内容~
1.Intent传递简单数据
还记得我们在Activity那里学过如何在两个Activity中互相传递简单数据的方法吗？
就是可以直接通过调用Intent的putExtra()方法存入数据，然后在获得Intent后调用getXxxExtra获得
对应类型的数据；传递多个的话，可以使用Bundle对象作为容器，通过调用Bundle的putXxx先将数据
存储到Bundle中，然后调用Intent的putExtras()方法将Bundle存入Intent中，然后获得Intent以后，
调用getExtras()获得Bundle容器，然后调用其getXXX获取对应的数据！
另外数据存储有点类似于Map的&键，值>！
2.Intent传递数组
嘿嘿，普通类型倒没问题，但是如果是数组咧？解决方法如下：
写入数组：
bd.putStringArray("StringArray", new String[]{"呵呵","哈哈"});
//可把StringArray换成其他数据类型,比如int,float等等...
读取数组：
String[] str = bd.getStringArray("StringArray")
3.Intent传递集合
嗯，数组很简单吧，那我们再来传下集合~这个就稍微复杂点了，分情况处理：
1）List&基本数据类型或String>
写入集合：
intent.putStringArrayListExtra(name, value)
intent.putIntegerArrayListExtra(name, value)
读取集合：
intent.getStringArrayListExtra(name)
intent.getIntegerArrayListExtra(name)
2）List& Object>
将list强转成Serializable类型,然后传入(可用Bundle做媒介)
写入集合：
putExtras(key, (Serializable)list)
读取集合：
(List&Object&) getIntent().getSerializable(key)
PS:Object类需要实现Serializable接口
3）Map&String, Object>,或更复杂的
解决方法是：外层套个List
//传递复杂些的参数
Map&String, Object& map1 = new HashMap&String, Object&();
map1.put("key1", "value1");
map1.put("key2", "value2");
List&Map&String, Object&& list = new ArrayList&Map&String, Object&&();
list.add(map1);
Intent intent = new Intent();
intent.setClass(MainActivity.this,ComplexActivity.class);
Bundle bundle = new Bundle();
//须定义一个list用于在budnle中传递需要传递的ArrayList&Object&,这个是必须要的
ArrayList bundlelist = new ArrayList();
bundlelist.add(list);
bundle.putParcelableArrayList("list",bundlelist);
intent.putExtras(bundle);
startActivity(intent);
4.Intent传递对象
传递对象的方式有两种：将对象转换为Json字符串或者通过Serializable,Parcelable序列化
不建议使用Android内置的抠脚Json解析器，可使用fastjson或者Gson第三方库！
1）将对象转换为Json字符串
Gson解析的例子：
public class Book{
public class Author{
写入数据：
Book book=new Book();
book.setTitle("Java编程思想");
Author author=new Author();
author.setId(1);
author.setName("Bruce Eckel");
book.setAuthor(author);
Intent intent=new Intent(this,SecondActivity.class);
intent.putExtra("book",new Gson().toJson(book));
startActivity(intent);
读取数据：
String bookJson=getIntent().getStringExtra("book");
Book book=new Gson().fromJson(bookJson,Book.class);
Log.d(TAG,"book title-&"+book.getTitle());
Log.d(TAG,"book author name-&"+book.getAuthor().getName());
2）使用Serializable,Parcelable序列化对象
1.Serializable实现:
①业务Bean实现：Serializable接口,写上getter和setter方法
②Intent通过调用putExtra(String name, Serializable value)传入对象实例
当然对象有多个的话多个的话,我们也可以先Bundle.putSerializable(x,x);
③新Activity调用getSerializableExtra()方法获得对象实例:
eg:Product pd = (Product) getIntent().getSerializableExtra("Product");
④调用对象get方法获得相应参数
2.Parcelable实现:
①业务Bean继承Parcelable接口,重写writeToParcel方法,将你的对象序列化为一个Parcel对象;
②重写describeContents方法，内容接口描述，默认返回0就可以
③实例化静态内部对象CREATOR实现接口Parcelable.Creator
④同样式通过Intent的putExtra()方法传入对象实例,当然多个对象的话,我们可以先
放到Bundle里Bundle.putParcelable(x,x),再Intent.putExtras()即可
通过writeToParcel将你的对象映射成Parcel对象，再通过createFromParcel将Parcel对象映射
成你的对象。也可以将Parcel看成是一个流，通过writeToParcel把对象写到流里面，
在通过createFromParcel从流里读取对象，只不过这个过程需要你来实现，因此写的
顺序和读的顺序必须一致。
实现Parcelable接口的代码示例:
//Internal Description Interface,You do not need to manage
public int describeContents() {
public void writeToParcel(Parcel parcel, int flags){
parcel.writeString(bookName);
parcel.writeString(author);
parcel.writeInt(publishTime);
public static final Parcelable.Creator&Book& CREATOR = new Creator&Book&() {
public Book[] newArray(int size) {
return new Book[size];
public Book createFromParcel(Parcel source) {
Book mBook = new Book();
mBook.bookName = source.readString();
mBook.author = source.readString();
mBook.publishTime = source.readInt();
Android Studio生成Parcleable插件：
Intellij/Andriod Studio插件android-parcelable-intellij-plugin
只要ALT+Insert，即可直接生成Parcleable接口代码。
另外：Android中大量用到Parcelable对象，实现Parcable接口又是非常繁琐的,可以用到
第三方的开源框架:Parceler,因为Maven的问题,暂时还没试。
3.两种序列化方式的比较：
两者的比较:
1）在使用内存的时候，Parcelable比Serializable性能高，所以推荐使用Parcelable。
2）Serializable在序列化的时候会产生大量的临时变量，从而引起频繁的GC。
3）Parcelable不能使用在要将数据存储在磁盘上的情况，因为Parcelable不能很好的保证数据的
持续性在外界有变化的情况下。尽管Serializable效率低点，但此时还是建议使用Serializable。
5.Intent传递Bitmap
bitmap默认实现Parcelable接口,直接传递即可
实现代码：
Bitmap bitmap =
Intent intent = new Intent();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
intent.putExtra("bundle", bundle);
6.传来传去不方便，直接定义全局数据
如果是传递简单的数据，有这样的需求，Activity1 -> Activity2 -> Activity3 -> Activity4，
你想在Activity中传递某个数据到Activity4中，怎么破，一个个页面传么？
显然不科学是吧，如果你想某个数据可以在任何地方都能获取到，你就可以考虑使用
Application全局对象了！
Android系统在每个程序运行的时候创建一个Application对象，而且只会创建一个，所以Application
是单例(singleton)模式的一个类，而且Application对象的生命周期是整个程序中最长的，他的生命
周期等于这个程序的生命周期。如果想存储一些比静态的值(固定不改变的，也可以变)，如果你想使用
Application就需要自定义类实现Application类，并且告诉系统实例化的是我们自定义的Application
而非系统默认的，而这一步，就是在AndroidManifest.xml中卫我们的application标签添加:name属性！
关键部分代码：
1）自定义Application类：
class MyApp extends Application {
private String myS
public String getState(){
return myS
public void setState(String s){
2）AndroidManifest.xml中声明：
&application android:name=".MyApp" android:icon="@drawable/icon"
android:label="@string/app_name"&
3）在需要的地方调用：
class Blah extends Activity {
public void onCreate(Bundle b){
MyApp appState = ((MyApp)getApplicationContext());
String state = appState.getState();
高逼格写法：在任何位置都能获取到Application全局对象。
Applicaiton是系统的一个组件，他也有自己的一个生命周期，我们可以在onCraete里获得这个
Application对象。贴下修改后的代码吧！
class MyApp extends Application {
private String myS
private static MyA
public static MyApp getInstance(){
public String getState(){
return myS
public void setState(String s){
public void onCreate(){
onCreate();
instance =
然后在任意地方我们就可以直接调用：MyApp.getInstance（）来获得Application的全局对象！
注意事项：
Application对象是存在于内存中的，也就有它可能会被系统杀死，比如这样的场景：
我们在Activity1中往application中存储了用户账号，然后在Activity2中获取到用户账号，并且显示！
如果我们点击home键，然后过了N久候，系统为了回收内存kill掉了我们的app。这个时候，我们重新
打开这个app，这个时候很神奇的，回到了Activity2的页面，但是如果这个时候你再去获取Application
里的用户账号，程序就会报NullPointerException，然后crash掉~
之所以会发生上述crash，是因为这个Application对象是全新创建的，可能你以为App是重新启动的，
其实并不是，仅仅是创建一个新的Application，然后启动上次用户离开时的Activity，从而创造App
并没有被杀死的假象！所以如果是比较重要的数据的话，建议你还是进行本地化，另外在使用数据的时候
要对变量的值进行非空检查！还有一点就是：不止是Application变量会这样，单例对象以及公共静态变量
7.单例模式传参
上面的Application就是基于单例的，单例模式的特点就是可以保证系统中一个类有且只有一个实例。
这样很容易就能实现，在A中设置参数，在B中直接访问了。这是几种方法中效率最高的。
范例代码：(代码来自于网上~)
①定义一个单例类：
public class XclSingleton
//单例模式实例
private static XclSingleton instance =
//synchronized 用于线程安全，防止多线程同时创建实例
public synchronized static XclSingleton getInstance(){
if(instance == null){
instance = new XclSingleton();
final HashMap&String, Object& mM
private XclSingleton()
mMap = new HashMap&String,Object&();
public void put(String key,Object value){
mMap.put(key,value);
public Object get(String key)
return mMap.get(key);
②设置参数:
XclSingleton.getInstance().put("key1", "value1");
XclSingleton.getInstance().put("key2", "value2");
本节小结：
好的，关于Intent复杂数据传输就到这里，本节除了讲述使用Intent来传递复杂数据外，还教了大家
使用Application和单例模式来传递参数！相信会对大家在数据传递方面带来方便，谢谢~
4.5.2 Intent之复杂数据的传递
感谢您的支持，我会继续努力的!
扫码打赏，你说多少就多少
记住登录状态
重复输入密码