android获取服务器xml_android里面怎么解析xml

① 新手使用android的XML(DOM)解析问题，指定路径XML如何读取

一、在Android应用中的XML文件来源
1、本地xml文件
本地XML文件可以放在应用根目录assets文件夹、res/xml、res/raw、SDcard卡、应用的data目录等；
除res/xml可直接通过getXml(int id)获取XML文档，返回一个解析器对象（XmlResourceParer：XmlResourceParer是XmlPullParser的子类），其它位置情况都可以获取XML文档，返回一个Inputstream对象，进行读取数据，获取方法分别如下：
a.在res/xml目录下（推荐使用）：
[java] view plain
XmlResourceParser xmlParser = this.getResources().getXml(R.xml.XXX);

b.在res/xml、res/raw目录下：
[java] view plain
InputStream inputStream = this.getResources().openRawResource(R.xml.XXX);

c.在assets文件夹下(本人测试发现通过此方法获取的XML文档不能带有首行：<?xml version="1.0" encoding="utf-8"?>，否则解析报错，具体原因未查明，知道原因请回复交流)：
[java] view plain
InputStream inputStream = getResources().getAssets().open(fileName);

d.在应用指定目录下(SDcard，应用data目录等):
[java] view plain
// path路径根据实际项目修改，此次获取SDcard根目录
String path = Environment.getExternalStorageDirectory().toString();
File xmlFlie = new File(path+fileName);
InputStream inputStream = new FileInputStream(xmlFlie);

2、通过url得到的xml文件
很多时候需要解析xml文件都用于客户端与服务器之间的数据交互，比如解析google天气预报信息，或自己项目内定的一些XML数据结构，其中通过URL，使用DefaultHTTPClient get请求获取XML文件方法如下：
[java] view plain
/**
* 读取url的xml资源转成String
* @param url
* @return 返回读取url的xml字符串
*/
public String getStringByUrl(String url) {
String outputString = "";
// DefaultHttpClient
DefaultHttpClient httpclient = new DefaultHttpClient();
// HttpGet
HttpGet httpget = new HttpGet(url);
// ResponseHandler
ResponseHandler<String> responseHandler = new BasicResponseHandler();

try {
outputString = httpclient.execute(httpget, responseHandler);
outputString = new String(outputString.getBytes("ISO-8859-1"), "utf-8"); // 解决中文乱码

Log.i("HttpClientConnector", "连接成功");
} catch (Exception e) {
Log.i("HttpClientConnector", "连接失败");
e.printStackTrace();
}
httpclient.getConnectionManager().shutdown();
return outputString;
}

二、XML文件的解析方式
能够运用在Android系统上解析XML文件的常用有三种方式：DOM、SAX和PULL，其中DOM解析XML是先把XML文件读进内存中，再通过接口获取数据，该方法使用相对小的XML文件，移动设备往往受硬件性能影响，如果XML文件比较大使用DOM解析往往效率跟不上；SAX和PULL都是采用事件驱动方式来进行解析，在Android中的事件机制是基于回调函数。
本例旨在考虑简单方便性，综合考虑选择了PULL解析，PULL解析器是一个开源项目，Android平台已经内置了PULL解析器，同时Android系统本身也是使用PULL解析器来解析各种XML文档。
1、事件回调类型
PULL解析XML文件时，回调XmlResourceParser内定义表示文档开头结束和节点开头结束的数值（事件回调类型），表示如下：
a.读取到XML文档开头（声明）返回：XmlPullParser.START_DOCUMENT（0）
b.读取到XML文档结束返回：XmlPullParser.END_DOCUMENT （1）
c.读取到XML节点开始返回：XmlPullParser.START_TAG （2）
d.读取到XML节点结束返回：XmlPullParser.END_TAG （3）
e.读取到XML文本返回：XmlPullParser.TEXT （4）

2、XmlPullParser有几个主要方法(更多查阅Android APIs):
a.XmlPullParser.getEventType() : Returns the type of the current event (START_TAG, END_TAG, TEXT, etc.) 【获取当前事件回调类型】
b.XmlPullParser.getName():For START_TAG or END_TAG events, the (local) name of the current element is returned when namespaces are enabled.【获取当前节点名字】
c.XmlPullParser.getAttributeValue(int index):Returns the given attributes value.【根据id获取节点属性值】
d.XmlPullParser.getAttributeValue(String namespace, String name):Returns the attributes value identified by namespace URI and namespace localName.【根据name获取节点属性值】
e.XmlPullParser.netxText():If current event is START_TAG then if next element is TEXT then element content is returned or if next event is END_TAG then empty string is returned, otherwise exception is thrown.【回调节点START_TAG时，通过此方法获取节点内容】
3、实际编码中如何使用
在实际编码中，主要根据事件回调类型，结合被解析的XML结构进行解析提取数据，PULL解析XML文件的主要模式如下，更具体使用看本文提供的例子：
[java] view plain
try {
//开始解析事件
int eventType = parser.getEventType();

//处理事件，不碰到文档结束就一直处理
while (eventType != XmlPullParser.END_DOCUMENT) {
//因为定义了一堆静态常量，所以这里可以用switch
switch (eventType) {
case XmlPullParser.START_DOCUMENT:
// 不做任何操作或初开始化数据
break;

case XmlPullParser.START_TAG:
// 解析XML节点数据
// 获取当前标签名字
String tagName = parser.getName();

if(tagName.equals("XXXTAGXXX")){

// 通过getAttributeValue 和 netxText解析节点的属性值和节点值

}
break;

case XmlPullParser.END_TAG:
// 单节点完成，可往集合里边添加新的数据
break;
case XmlPullParser.END_DOCUMENT:

break;
}

// 别忘了用next方法处理下一个事件，不然就会死循环
eventType = parser.next();
}
} catch (XmlPullParserException e) {
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}

② android怎么从xml文件里面提取数据

一、环境：
主机:WIN8
开发环境:Eclipse
二、说明:
1.打开sd卡中的xml文件，如果不存在，这新建一个，并写入默认配置
2.读取xml文件
三、xml文件格式:

<?xml version="1.0" encoding="UTF-8" standalone="true"?>
-<config>
<title>远程视频会见系统</title>
<local_port>12600</local_port>
<schele_service_ip>10.58.1.59</schele_service_ip>
<schele_service_port>12601</schele_service_port>
</config>

四、源代码:

package com.example.helloanychat;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import android.os.Environment;
import android.util.Log;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xmlpull.v1.XmlPullParserFactory;
import org.xmlpull.v1.XmlSerializer;
/**
* 配置信息类
* 新建日期:2014/12/8 by jdh
*/
public class Config implements IF_Config {
//配置信息
private Config_Info config_info = new Config_Info();
/**
* 构造函数
*/
public Config() {
boolean ok;
File sd_path;
File file_cfg_dir;
File file_cfg;
FileOutputStream out;
String str;
FileInputStream in;
//得到本机ip地址
config_info.local_ip = getLocalIpAddress();
System.out.printf("本机ip:%s\n", config_info.local_ip);
//获取SD卡目录
sd_path = Environment.getExternalStorageDirectory();
//判断文件夹是否存在
file_cfg_dir = new File(sd_path.getPath() + "//Remote_Meeting");
if (!file_cfg_dir.exists() && !file_cfg_dir.isDirectory()) {
System.out.println("配置文件夹Remote_Meeting不存在!");
ok = file_cfg_dir.mkdirs();
if (ok) {
System.out.println("创建文件夹成功!");
} else {
System.out.println("创建文件夹失败!");
}
}
//判断配置文件是否存在
file_cfg = new File(file_cfg_dir.getPath(),"cfg.xml");
if (!file_cfg.exists())
{
System.out.println("配置文件cfg.xml不存在!");
try {
file_cfg.createNewFile();
System.out.println("创建文件cfg.xml成功!");
//生成初始化的配置数据
try {
out = new FileOutputStream(file_cfg);
//保存默认配置
config_info.title = "远程视频会见系统";
config_info.local_port = 12600;
config_info.schele_server_ip = "10.58.1.59";
config_info.schele_server_port = 12601;
str = proce_xml_string(config_info);
out.write(str.getBytes());
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
config_info.title = "远程";
config_info.local_port = 126;
config_info.schele_server_ip = "10.5";
config_info.schele_server_port = 12;
System.out.printf("----222222222%s,%d,%s,%d\n",config_info.title,config_info.local_port,
config_info.schele_server_ip,config_info.schele_server_port);
//解析xml文件
try {
in = new FileInputStream(file_cfg);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(in);
// 获取根节点
Element root = document.getDocumentElement();
NodeList node = root.getChildNodes();
//获得第1子节点:标题
config_info.title = node.item(0).getFirstChild().getNodeValue();
//获得第2子节点:本机端口
config_info.local_port = Integer.parseInt(node.item(1).getFirstChild().getNodeValue());
//获得第3子节点:调度服务器ip
config_info.schele_server_ip = node.item(2).getFirstChild().getNodeValue();
//获得第4子节点:调度服务器端口
config_info.schele_server_port = Integer.parseInt(node.item(3).getFirstChild().getNodeValue());
System.out.printf("----222222222%s,%d,%s,%d\n",config_info.title,config_info.local_port,
config_info.schele_server_ip,config_info.schele_server_port);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Config_Info get_config_info() {
return config_info;
}
/**
* 得到本机ip地址
* @return 本机ip地址
*/
private String getLocalIpAddress() {
try {
for (Enumeration<NetworkInterface> en = NetworkInterface
.getNetworkInterfaces(); en.hasMoreElements();) {
NetworkInterface intf = en.nextElement();
for (Enumeration<InetAddress> enumIpAddr = intf
.getInetAddresses(); enumIpAddr.hasMoreElements();) {
InetAddress inetAddress = enumIpAddr.nextElement();
//if (!inetAddress.isLoopbackAddress()) {
if (!inetAddress.isLoopbackAddress() && !(inetAddress instanceof Inet6Address)) {
return inetAddress.getHostAddress().toString();
}
}
}
} catch (SocketException ex) {
Log.e("WifiPreference IpAddress", ex.toString());
}
return null;
}
/**
* 生成xml配置文件的String数据流
* Config_Info的本机ip信息不会保存
* @param info:配置信息
* @return xml的String数据流
*/
private String proce_xml_string(Config_Info info) {
StringWriter stringWriter = new StringWriter();
try {
// 获取XmlSerializer对象
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlSerializer xmlSerializer = factory.newSerializer();
// 设置输出流对象
xmlSerializer.setOutput(stringWriter);
//开始标签
xmlSerializer.startDocument("utf-8", true);
xmlSerializer.startTag(null, "config");
//标题
xmlSerializer.startTag(null, "title");
xmlSerializer.text(info.title);
xmlSerializer.endTag(null, "title");
//本机端口
xmlSerializer.startTag(null, "local_port");
xmlSerializer.text(Integer.toString(info.local_port));
xmlSerializer.endTag(null, "local_port");
//调度服务器ip
xmlSerializer.startTag(null, "schele_service_ip");
xmlSerializer.text(info.schele_server_ip);
xmlSerializer.endTag(null, "schele_service_ip");
//调度服务器端口
xmlSerializer.startTag(null, "schele_service_port");
xmlSerializer.text(Integer.toString(info.schele_server_port));
xmlSerializer.endTag(null, "schele_service_port");
xmlSerializer.endTag(null, "config");
xmlSerializer.endDocument();
} catch (Exception e) {
e.printStackTrace();
}
return stringWriter.toString();
}
}

③ android中怎么获取到服务器的返回的数据解析并显示到界面

一般都是--- 首先，android客户端调用服务器端的接口，请求数据，服务器端响应、返回xml、或者json已经包装好的对象(服务器端需要做大量的工作，数据库的连接、数据操作、包装数据等等) 然后，客户端拿到这个对象，android有专门的类和方法来解析这些数据对象最后，按自己想要的格式显示在界面上就完成了

④ android如何获取服务器端文件列表及相关信息

要弄的话你先要搞清几个问题，
1、你与服务端的通信协议。如果一般服务端已经开发好了，那么会有一套通信协议，通常与手机的交互都采用JSON格式发送，减少流量。你可以网络下JSON的相关知识。很简单的一种格式。如果不是JSON的话一般会是XML，不过很少见。
2、数据量。Android market应用列表见过吧？很多情况下回做成懒加载，而不是刷新所有数据。这样的话你就要根据数据量考虑你的代码实现了，合理的使用SoftReference，优化ListView，用sqllite数据库缓存数据等等，具体机制你需要自己设计一下了，如果你是个PM的话。如果不是PM推荐你找个有经验的人设计下，否则很容易出现OOM异常

对于数据的处理方面，就像第一条说的，无论是JSON还是XML格式，android都有工具类，用法我就不贴了，自己搜一下，很多的

⑤ 如何获取android 下的StreamingAssets文件夹中的xml文件

assets文件夹里面的文件都是保持原始的文件格式，需要用AssetManager以字节流的形式读取文件。
assets的读取方式:
1. 先在Activity里面调用getAssets() 来获取AssetManager引用。
2. 再用AssetManager的open(String fileName, int accessMode) 方法则指定读取的文件以及访问模式就能得到输入流InputStream。
3. 然后就是用已经open file 的inputStream读取文件，读取完成后记得inputStream.close() 。
4.调用AssetManager.close() 关闭AssetManager。
需要注意的是，来自Resources和Assets 中的文件只可以读取而不能进行写的操作

⑥ android里面怎么解析xml

Android解析xml文件总共有三种方法，分别是：

SAX解析XML文件：SAX是一个解析速度快并且占用内存少的xml解析器，非常适合用于Android等移动设备。SAX解析XML文件采用的是事件驱动，也就是说，它并不需要解析完整个文档，在按内容顺序解析文档的过程中，SAX会判断当前读到的字符是否合法XML语法中的某部分，如果符合就会触发事件。所谓事件，其实就是一些回调（callback）方法，这些方法(事件)定义在ContentHandler接口。如下代码：

publicstaticList<Person>readXML(InputStreaminStream){
try{
//创建解析器
SAXParserFactoryspf=SAXParserFactory.newInstance();
SAXParsersaxParser=spf.newSAXParser();

//设置解析器的相关特性，true表示开启命名空间特性
saxParser.setProperty("http://xml.org/sax/features/namespaces",true);
XMLContentHandlerhandler=newXMLContentHandler();
saxParser.parse(inStream,handler);
inStream.close();

returnhandler.getPersons();
}catch(Exceptione){
e.printStackTrace();
}

returnnull;
}


//SAX类：DefaultHandler，它实现了ContentHandler接口。在实现的时候，只需要继承该类，重载相应的方法即可。
{

privateList<Person>persons=null;
privatePersoncurrentPerson;
privateStringtagName=null;//当前解析的元素标签

publicList<Person>getPersons(){
returnpersons;
}

//接收文档开始的通知。当遇到文档的开头的时候，调用这个方法，可以在其中做一些预处理的工作。
@Override
publicvoidstartDocument()throwsSAXException{
persons=newArrayList<Person>();
}

//接收元素开始的通知。当读到一个开始标签的时候，会触发这个方法。其中namespaceURI表示元素的命名空间；
//localName表示元素的本地名称（不带前缀）；qName表示元素的限定名（带前缀）；atts表示元素的属性集合
@Override
publicvoidstartElement(StringnamespaceURI,StringlocalName,StringqName,Attributesatts)throwsSAXException{

if(localName.equals("person")){
currentPerson=newPerson();
currentPerson.setId(Integer.parseInt(atts.getValue("id")));
}

this.tagName=localName;
}

//接收字符数据的通知。该方法用来处理在XML文件中读到的内容，第一个参数用于存放文件的内容，
//后面两个参数是读到的字符串在这个数组中的起始位置和长度，使用newString(ch,start,length)就可以获取内容。
@Override
publicvoidcharacters(char[]ch,intstart,intlength)throwsSAXException{

if(tagName!=null){
Stringdata=newString(ch,start,length);
if(tagName.equals("name")){
this.currentPerson.setName(data);
}elseif(tagName.equals("age")){
this.currentPerson.setAge(Short.parseShort(data));
}
}
}

//接收文档的结尾的通知。在遇到结束标签的时候，调用这个方法。其中，uri表示元素的命名空间；
//localName表示元素的本地名称（不带前缀）；name表示元素的限定名（带前缀）
@Override
publicvoidendElement(Stringuri,StringlocalName,Stringname)throwsSAXException{

if(localName.equals("person")){
persons.add(currentPerson);
currentPerson=null;
}

this.tagName=null;
}
}

DOM解析XML文件： DOM解析XML文件时，会将XML文件的所有内容读取到内存中，然后允许您使用DOM API遍历XML树、检索所需的数据。使用DOM操作XML的代码看起来比较直观，并且，在某些方面比基于SAX的实现更加简单。但是，因为DOM需要将XML文件的所有内容读取到内存中，所以内存的消耗比较大，特别对于运行Android的移动设备来说，因为设备的资源比较宝贵，所以建议还是采用SAX来解析XML文件，当然，如果XML文件的内容比较小采用DOM是可行的。
Pull解析器解析XML文件： Pull解析器的运行方式与 SAX 解析器相似。它提供了类似的事件，如：开始元素和结束元素事件，使用parser.next()可以进入下一个元素并触发相应事件。事件将作为数值代码被发送，因此可以使用一个switch对感兴趣的事件进行处理。当元素开始解析时，调用parser.nextText()方法可以获取下一个Text类型元素的值

⑦ android程序中客户端如何用pull 读取远程服务器上的xml文件请给出代码。谢谢。

可以用 httpclient get到这个xml
然后把这个流交给pull解析器解析就完了
//获取xml文件流
URL url = new URL("http://www.sohu.com");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setConnectTimeout(5* 1000);//设置连接超时
conn.setRequestMethod(“GET”);//以get方式发起请求
if (conn.getResponseCode() != 200) throw new RuntimeException("请求url失败");
InputStream is = conn.getInputStream();//得到网络返回的输入流
conn.disconnect();
//解析xml
List<Person> persons = readXML(is);

public static List<Person> readXML(InputStream inStream) {
XmlPullParser parser = Xml.newPullParser();
try {
parser.setInput(inStream, "UTF-8");
int eventType = parser.getEventType();
Person currentPerson = null;
List<Person> persons = null;
while (eventType != XmlPullParser.END_DOCUMENT) {
switch (eventType) {
case XmlPullParser.START_DOCUMENT://文档开始事件,可以进行数据初始化处理
persons = new ArrayList<Person>();
break;
case XmlPullParser.START_TAG://开始元素事件
String name = parser.getName();
if (name.equalsIgnoreCase("person")) {
currentPerson = new Person();
currentPerson.setId(new Integer(parser.getAttributeValue(null, "id")));
} else if (currentPerson != null) {
if (name.equalsIgnoreCase("name")) {
currentPerson.setName(parser.nextText());// 如果后面是Text节点,即返回它的值
} else if (name.equalsIgnoreCase("age")) {
currentPerson.setAge(new Short(parser.nextText()));
}
}
break;
case XmlPullParser.END_TAG://结束元素事件
if (parser.getName().equalsIgnoreCase("person") && currentPerson != null) {
persons.add(currentPerson);
currentPerson = null;
}
break;
}
eventType = parser.next();
}
inStream.close();
return persons;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}

⑧ android怎么获取服务器数据

一：基于Http协议获取数据方法。二：基于SAOP协议获取数据方法，
这篇文章主要是将关于使用Http协议获取服务器端数据，这里我们采取的服务器端技术为java，框架为Struts2,或者可以有Servlet,又或者可直接从JSP页面中获取数据。
那么，接下来我们便开始这一路程：
首先：编写服务器端方法,我这里采用的MVC框架是Struts2，目的很单纯，就是为了以后做个完整的商业项目，技术配备为：android+SSH。当然，篇幅有限，我这里就直接用Strtus2而已。
服务器端：新建WebProject ,选择Java ee 5.0.
为了给项目添加Struts2的支持，我们必须导入Struts2的一些类库，如下即可（有些jar包是不必的，但是我们后来扩展可能是要使用到的，就先弄进去）：
1: xwork-core-2.2.1.1.jar
2: struts2-core-2.2.1.1.jar
3: commons-logging-1.0.4.jar
4: freemarker-2.3.16.jar
5: ognl-3.0.jar
6: javassist-3.7.ga.jar
7：commons-ileupload.jar
8：commons-io.jar
9：json-lib-2.1-jdk15.jar 处理JSON格式数据要使用到
10：struts2-json-plugin-2.2.1.1.jar 基于struts2的json插件
以上的jar包，需要放在WebRoot/WEB-INF/lib目录下
然后在web.xml文件中敲下：
View Code
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


<filter>

<filter-name>struts2</filter-name>

<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>

<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

</web-app>
然后编写struts.xml文件，并放在WebRoot/WEB-INF/lib目录下:如下代码：
View Code
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>


<constant name="struts.i18n.encoding" value="UTF-8"></constant>
<constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>


<package name="dongzi" extends="json-default"> 

<action name="login" class="com.dongzi.action.loginAction" method="login">
<result type="json"></result> 
</action>
</package>
</struts>
配置好后，我们再根据<action>标签内容来编写action。方法为method对应的login，类名为loginAction,
注意：包继承为：json-default ，输出结果类型为json
如下：
View Code
public class loginAction extends ActionSupport implements
ServletRequestAware,ServletResponseAware {
/**
*
*/
private static final long serialVersionUID = 1L;

HttpServletRequest request;
HttpServletResponse response;

public void setServletRequest(HttpServletRequest request) {
this.request=request;
}

public void setServletResponse(HttpServletResponse response) {
this.response=response;
}

public void login(){
try {
//HttpServletRequest request =ServletActionContext.getRequest();
// HttpServletResponse response=ServletActionContext.getResponse();
this.response.setContentType("text/html;charset=utf-8");
this.response.setCharacterEncoding("UTF-8");
if(this.request.getParameter("username").equals("123456")){
this.response.getWriter().write("真的很奇怪,日本人！");
}else if(this.request.getParameter("username").equals("zhd")){
this.response.getWriter().write("没有错，我就是东子哥！");
}else{
this.response.getWriter().write("我就是东子哥！");
}

//将要返回的实体对象进行json处理
// JSONObject json=JSONObject.fromObject(this.getUsername());
//输出格式如：{"id":1, "username":"zhangsan", "pwd":"123"}
// System.out.println(json);

// this.response.getWriter().write(json.toString());
/**
JSONObject json=new JSONObject();
json.put("login", "login");
response.setContentType("text/html;charset=utf-8");
System.out.println(json);
byte[] jsonBytes = json.toString().getBytes("utf-8");
response.setContentLength(jsonBytes.length);
response.getOutputStream().write(jsonBytes);
**/
/**
JSONObject json=new JSONObject();
json.put("login", "login");
byte[] jsonBytes = json.toString().getBytes("utf-8");
response.setContentType("text/html;charset=utf-8");
response.setContentLength(jsonBytes.length);
response.getOutputStream().write(jsonBytes);
response.getOutputStream().flush();
response.getOutputStream().close();
**/

} catch (Exception e) {
e.printStackTrace();
}
// return null;
}
}

导航:首页 > 操作系统 > android获取服务器xml

android获取服务器xml

与android获取服务器xml相关的资料