XML在各种开发中都广泛应用,Android也不例外。作为承载数据的一个重要角色,如何读写XML成为Android开发中一项重要的技能。今天就由我向大家介绍一下在Android平台下几种常见的XML解析和创建的方法。

在Android中,常见的XML解析器分别为SAX解析器、DOM解析器和PULL解析器,下面,我将一一向大家详细介绍。

SAX解析器:

SAX(Simple API for XML)解析器是一种基于事件的解析器,它的核心是事件处理模式,主要是围绕着事件源以及事件处理器来工作的。当事件源产生事件后,调用事件处理器相应的处理方法,一个事件就可以得到处理。在事件源调用事件处理器中特定方法的时候,还要传递给事件处理器相应事件的状态信息,这样事件处理器才能够根据提供的事件信息来决定自己的行为。

SAX解析器的优点是解析速度快,占用内存少。非常适合在Android移动设备中使用。

DOM解析器:

DOM是基于树形结构的的节点或信息片段的集合,允许开发人员使用DOM API遍历XML树、检索所需数据。分析该结构通常需要加载整个文档和构造树形结构,然后才可以检索和更新节点信息。

由于DOM在内存中以树形结构存放,因此检索和更新效率会更高。但是对于特别大的文档,解析和加载整个文档将会很耗资源。

PULL解析器:

PULL解析器的运行方式和SAX类似,都是基于事件的模式。不同的是,在PULL解析过程中,我们需要自己获取产生的事件然后做相应的操作,而不像SAX那样由处理器触发一种事件的方法,执行我们的代码。PULL解析器小巧轻便,解析速度快,简单易用,非常适合在Android移动设备中使用,Android系统内部在解析各种XML时也是用PULL解析器。

以上三种解析器,都是非常实用的解析器,我将会一一介绍。我们将会使用这三种解析技术完成一项共同的任务。

我们新建一个项目,项目结构如下:

我会在项目的assets目录中放置一个XML文档books.xml,内容如下:

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <books>
  3. <book>
  4. <id>1001</id>
  5. <name>Thinking In Java</name>
  6. <price>80.00</price>
  7. </book>
  8. <book>
  9. <id>1002</id>
  10. <name>Core Java</name>
  11. <price>90.00</price>
  12. </book>
  13. <book>
  14. <id>1003</id>
  15. <name>Hello, Andriod</name>
  16. <price>100.00</price>
  17. </book>
  18. </books>

然后我们分别使用以上三种解析技术解析文档,得到一个List<Book>的对象,先来看一下Book.java的代码:

  1. package com.scott.xml.model;
  2. public class Book {
  3. private int id;
  4. private String name;
  5. private float price;
  6. public int getId() {
  7. return id;
  8. }
  9. public void setId(int id) {
  10. this.id = id;
  11. }
  12. public String getName() {
  13. return name;
  14. }
  15. public void setName(String name) {
  16. this.name = name;
  17. }
  18. public float getPrice() {
  19. return price;
  20. }
  21. public void setPrice(float price) {
  22. this.price = price;
  23. }
  24. @Override
  25. public String toString() {
  26. return "id:" + id + ", name:" + name + ", price:" + price;
  27. }
  28. }

最后,我们还要把这个集合对象中的数据生成一个新的XML文档,如图:

生成的XML结构跟原始文档略有不同,是下面这种格式:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <books>
  3. <book id="1001">
  4. <name>Thinking In Java</name>
  5. <price>80.0</price>
  6. </book>
  7. <book id="1002">
  8. <name>Core Java</name>
  9. <price>90.0</price>
  10. </book>
  11. <book id="1003">
  12. <name>Hello, Andriod</name>
  13. <price>100.0</price>
  14. </book>
  15. </books>

接下来,就该介绍操作过程了,我们先为解析器定义一个BookParser接口,每种类型的解析器需要实现此接口。BookParser.java代码如下:

  1. package com.scott.xml.parser;
  2. import java.io.InputStream;
  3. import java.util.List;
  4. import com.scott.xml.model.Book;
  5. public interface BookParser {
  6. /**
  7. * 解析输入流 得到Book对象集合
  8. * @param is
  9. * @return
  10. * @throws Exception
  11. */
  12. public List<Book> parse(InputStream is) throws Exception;
  13. /**
  14. * 序列化Book对象集合 得到XML形式的字符串
  15. * @param books
  16. * @return
  17. * @throws Exception
  18. */
  19. public String serialize(List<Book> books) throws Exception;
  20. }

好了,我们就该一个一个的实现该接口,完成我们的解析过程。

使用SAX解析器:

SaxBookParser.java代码如下:

  1. package com.scott.xml.parser;
  2. import java.io.InputStream;
  3. import java.io.StringWriter;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import javax.xml.parsers.SAXParser;
  7. import javax.xml.parsers.SAXParserFactory;
  8. import javax.xml.transform.OutputKeys;
  9. import javax.xml.transform.Result;
  10. import javax.xml.transform.Transformer;
  11. import javax.xml.transform.TransformerFactory;
  12. import javax.xml.transform.sax.SAXTransformerFactory;
  13. import javax.xml.transform.sax.TransformerHandler;
  14. import javax.xml.transform.stream.StreamResult;
  15. import org.xml.sax.Attributes;
  16. import org.xml.sax.SAXException;
  17. import org.xml.sax.helpers.AttributesImpl;
  18. import org.xml.sax.helpers.DefaultHandler;
  19. import com.scott.xml.model.Book;
  20. public class SaxBookParser implements BookParser {
  21. @Override
  22. public List<Book> parse(InputStream is) throws Exception {
  23. SAXParserFactory factory = SAXParserFactory.newInstance();  //取得SAXParserFactory实例
  24. SAXParser parser = factory.newSAXParser();                  //从factory获取SAXParser实例
  25. MyHandler handler = new MyHandler();                        //实例化自定义Handler
  26. parser.parse(is, handler);                                  //根据自定义Handler规则解析输入流
  27. return handler.getBooks();
  28. }
  29. @Override
  30. public String serialize(List<Book> books) throws Exception {
  31. SAXTransformerFactory factory = (SAXTransformerFactory) TransformerFactory.newInstance();//取得SAXTransformerFactory实例
  32. TransformerHandler handler = factory.newTransformerHandler();           //从factory获取TransformerHandler实例
  33. Transformer transformer = handler.getTransformer();                     //从handler获取Transformer实例
  34. transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");            // 设置输出采用的编码方式
  35. transformer.setOutputProperty(OutputKeys.INDENT, "yes");                // 是否自动添加额外的空白
  36. transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");   // 是否忽略XML声明
  37. StringWriter writer = new StringWriter();
  38. Result result = new StreamResult(writer);
  39. handler.setResult(result);
  40. String uri = "";    //代表命名空间的URI 当URI无值时 须置为空字符串
  41. String localName = "";  //命名空间的本地名称(不包含前缀) 当没有进行命名空间处理时 须置为空字符串
  42. handler.startDocument();
  43. handler.startElement(uri, localName, "books", null);
  44. AttributesImpl attrs = new AttributesImpl();    //负责存放元素的属性信息
  45. char[] ch = null;
  46. for (Book book : books) {
  47. attrs.clear();  //清空属性列表
  48. attrs.addAttribute(uri, localName, "id", "string", String.valueOf(book.getId()));//添加一个名为id的属性(type影响不大,这里设为string)
  49. handler.startElement(uri, localName, "book", attrs);    //开始一个book元素 关联上面设定的id属性
  50. handler.startElement(uri, localName, "name", null); //开始一个name元素 没有属性
  51. ch = String.valueOf(book.getName()).toCharArray();
  52. handler.characters(ch, 0, ch.length);   //设置name元素的文本节点
  53. handler.endElement(uri, localName, "name");
  54. handler.startElement(uri, localName, "price", null);//开始一个price元素 没有属性
  55. ch = String.valueOf(book.getPrice()).toCharArray();
  56. handler.characters(ch, 0, ch.length);   //设置price元素的文本节点
  57. handler.endElement(uri, localName, "price");
  58. handler.endElement(uri, localName, "book");
  59. }
  60. handler.endElement(uri, localName, "books");
  61. handler.endDocument();
  62. return writer.toString();
  63. }
  64. //需要重写DefaultHandler的方法
  65. private class MyHandler extends DefaultHandler {
  66. private List<Book> books;
  67. private Book book;
  68. private StringBuilder builder;
  69. //返回解析后得到的Book对象集合
  70. public List<Book> getBooks() {
  71. return books;
  72. }
  73. @Override
  74. public void startDocument() throws SAXException {
  75. super.startDocument();
  76. books = new ArrayList<Book>();
  77. builder = new StringBuilder();
  78. }
  79. @Override
  80. public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
  81. super.startElement(uri, localName, qName, attributes);
  82. if (localName.equals("book")) {
  83. book = new Book();
  84. }
  85. builder.setLength(0);   //将字符长度设置为0 以便重新开始读取元素内的字符节点
  86. }
  87. @Override
  88. public void characters(char[] ch, int start, int length) throws SAXException {
  89. super.characters(ch, start, length);
  90. builder.append(ch, start, length);  //将读取的字符数组追加到builder中
  91. }
  92. @Override
  93. public void endElement(String uri, String localName, String qName) throws SAXException {
  94. super.endElement(uri, localName, qName);
  95. if (localName.equals("id")) {
  96. book.setId(Integer.parseInt(builder.toString()));
  97. } else if (localName.equals("name")) {
  98. book.setName(builder.toString());
  99. } else if (localName.equals("price")) {
  100. book.setPrice(Float.parseFloat(builder.toString()));
  101. } else if (localName.equals("book")) {
  102. books.add(book);
  103. }
  104. }
  105. }
  106. }

代码中,我们定义了自己的事件处理逻辑,重写了DefaultHandler的几个重要的事件方法。下面我为大家着重介绍一下DefaultHandler的相关知识。DefaultHandler是一个事件处理器,可以接收解析器报告的所有事件,处理所发现的数据。它实现了EntityResolver接口、DTDHandler接口、ErrorHandler接口和ContentHandler接口。这几个接口代表不同类型的事件处理器。我们着重介绍一下ContentHandler接口。结构如图:

这几个比较重要的方法已被我用红线标注,DefaultHandler实现了这些方法,但在方法体内没有做任何事情,因此我们在使用时必须覆写相关的方法。最重要的是startElement方法、characters方法和endElement方法。当执行文档时遇到起始节点,startElement方法将会被调用,我们可以获取起始节点相关信息;然后characters方法被调用,我们可以获取节点内的文本信息;最后endElement方法被调用,我们可以做收尾的相关操作。

最后,我们需要调用SAX解析程序,这个步骤在MainActivity中完成:

  1. package com.scott.xml;
  2. import java.io.FileOutputStream;
  3. import java.io.InputStream;
  4. import java.util.List;
  5. import android.app.Activity;
  6. import android.content.Context;
  7. import android.os.Bundle;
  8. import android.util.Log;
  9. import android.view.View;
  10. import android.widget.Button;
  11. import com.scott.xml.model.Book;
  12. import com.scott.xml.parser.BookParser;
  13. import com.scott.xml.parser.SaxBookParser;
  14. public class MainActivity extends Activity {
  15. private static final String TAG = "XML";
  16. private BookParser parser;
  17. private List<Book> books;
  18. @Override
  19. public void onCreate(Bundle savedInstanceState) {
  20. super.onCreate(savedInstanceState);
  21. setContentView(R.layout.main);
  22. Button readBtn = (Button) findViewById(R.id.readBtn);
  23. Button writeBtn = (Button) findViewById(R.id.writeBtn);
  24. readBtn.setOnClickListener(new View.OnClickListener() {
  25. @Override
  26. public void onClick(View v) {
  27. try {
  28. InputStream is = getAssets().open("books.xml");
  29. parser = new SaxBookParser();  //创建SaxBookParser实例
  30. books = parser.parse(is);  //解析输入流
  31. for (Book book : books) {
  32. Log.i(TAG, book.toString());
  33. }
  34. } catch (Exception e) {
  35. Log.e(TAG, e.getMessage());
  36. }
  37. }
  38. });
  39. writeBtn.setOnClickListener(new View.OnClickListener() {
  40. @Override
  41. public void onClick(View v) {
  42. try {
  43. String xml = parser.serialize(books);  //序列化
  44. FileOutputStream fos = openFileOutput("books.xml", Context.MODE_PRIVATE);
  45. fos.write(xml.getBytes("UTF-8"));
  46. } catch (Exception e) {
  47. Log.e(TAG, e.getMessage());
  48. }
  49. }
  50. });
  51. }
  52. }

界面就两个按钮,顺便给大家贴上:

点击“readXML”按钮,将会调用SAX解析器解析文档,并在日志台打印相关信息:

然后再点击“writeXML”按钮,将会在该应用包下的files目录生成一个books.xml文件:

使用DOM解析器:

DomBookParser.java代码如下:

  1. package com.scott.xml.parser;
  2. import java.io.InputStream;
  3. import java.io.StringWriter;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import javax.xml.parsers.DocumentBuilder;
  7. import javax.xml.parsers.DocumentBuilderFactory;
  8. import javax.xml.transform.OutputKeys;
  9. import javax.xml.transform.Result;
  10. import javax.xml.transform.Source;
  11. import javax.xml.transform.Transformer;
  12. import javax.xml.transform.TransformerFactory;
  13. import javax.xml.transform.dom.DOMSource;
  14. import javax.xml.transform.stream.StreamResult;
  15. import org.w3c.dom.Document;
  16. import org.w3c.dom.Element;
  17. import org.w3c.dom.Node;
  18. import org.w3c.dom.NodeList;
  19. import com.scott.xml.model.Book;
  20. public class DomBookParser implements BookParser {
  21. @Override
  22. public List<Book> parse(InputStream is) throws Exception {
  23. List<Book> books = new ArrayList<Book>();
  24. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  //取得DocumentBuilderFactory实例
  25. DocumentBuilder builder = factory.newDocumentBuilder(); //从factory获取DocumentBuilder实例
  26. Document doc = builder.parse(is);   //解析输入流 得到Document实例
  27. Element rootElement = doc.getDocumentElement();
  28. NodeList items = rootElement.getElementsByTagName("book");
  29. for (int i = 0; i < items.getLength(); i++) {
  30. Book book = new Book();
  31. Node item = items.item(i);
  32. NodeList properties = item.getChildNodes();
  33. for (int j = 0; j < properties.getLength(); j++) {
  34. Node property = properties.item(j);
  35. String nodeName = property.getNodeName();
  36. if (nodeName.equals("id")) {
  37. book.setId(Integer.parseInt(property.getFirstChild().getNodeValue()));
  38. } else if (nodeName.equals("name")) {
  39. book.setName(property.getFirstChild().getNodeValue());
  40. } else if (nodeName.equals("price")) {
  41. book.setPrice(Float.parseFloat(property.getFirstChild().getNodeValue()));
  42. }
  43. }
  44. books.add(book);
  45. }
  46. return books;
  47. }
  48. @Override
  49. public String serialize(List<Book> books) throws Exception {
  50. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  51. DocumentBuilder builder = factory.newDocumentBuilder();
  52. Document doc = builder.newDocument();   //由builder创建新文档
  53. Element rootElement = doc.createElement("books");
  54. for (Book book : books) {
  55. Element bookElement = doc.createElement("book");
  56. bookElement.setAttribute("id", book.getId() + "");
  57. Element nameElement = doc.createElement("name");
  58. nameElement.setTextContent(book.getName());
  59. bookElement.appendChild(nameElement);
  60. Element priceElement = doc.createElement("price");
  61. priceElement.setTextContent(book.getPrice() + "");
  62. bookElement.appendChild(priceElement);
  63. rootElement.appendChild(bookElement);
  64. }
  65. doc.appendChild(rootElement);
  66. TransformerFactory transFactory = TransformerFactory.newInstance();//取得TransformerFactory实例
  67. Transformer transformer = transFactory.newTransformer();    //从transFactory获取Transformer实例
  68. transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");            // 设置输出采用的编码方式
  69. transformer.setOutputProperty(OutputKeys.INDENT, "yes");                // 是否自动添加额外的空白
  70. transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");   // 是否忽略XML声明
  71. StringWriter writer = new StringWriter();
  72. Source source = new DOMSource(doc); //表明文档来源是doc
  73. Result result = new StreamResult(writer);//表明目标结果为writer
  74. transformer.transform(source, result);  //开始转换
  75. return writer.toString();
  76. }
  77. }

然后再MainActivity中只需改一个地方:

  1. readBtn.setOnClickListener(new View.OnClickListener() {
  2. @Override
  3. public void onClick(View v) {
  4. try {
  5. InputStream is = getAssets().open("books.xml");
  6. //             parser = new SaxBookParser();
  7. parser = new DomBookParser();
  8. books = parser.parse(is);
  9. for (Book book : books) {
  10. Log.i(TAG, book.toString());
  11. }
  12. } catch (Exception e) {
  13. Log.e(TAG, e.getMessage());
  14. }
  15. }
  16. );

执行结果是一样的。

使用PULL解析器:

PullBookParser.java代码如下:

  1. package com.scott.xml.parser;
  2. import java.io.InputStream;
  3. import java.io.StringWriter;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. import org.xmlpull.v1.XmlPullParser;
  7. import org.xmlpull.v1.XmlSerializer;
  8. import android.util.Xml;
  9. import com.scott.xml.model.Book;
  10. public class PullBookParser implements BookParser {
  11. @Override
  12. public List<Book> parse(InputStream is) throws Exception {
  13. List<Book> books = null;
  14. Book book = null;
  15. //      XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
  16. //      XmlPullParser parser = factory.newPullParser();
  17. XmlPullParser parser = Xml.newPullParser(); //由android.util.Xml创建一个XmlPullParser实例
  18. parser.setInput(is, "UTF-8");               //设置输入流 并指明编码方式
  19. int eventType = parser.getEventType();
  20. while (eventType != XmlPullParser.END_DOCUMENT) {
  21. switch (eventType) {
  22. case XmlPullParser.START_DOCUMENT:
  23. books = new ArrayList<Book>();
  24. break;
  25. case XmlPullParser.START_TAG:
  26. if (parser.getName().equals("book")) {
  27. book = new Book();
  28. } else if (parser.getName().equals("id")) {
  29. eventType = parser.next();
  30. book.setId(Integer.parseInt(parser.getText()));
  31. } else if (parser.getName().equals("name")) {
  32. eventType = parser.next();
  33. book.setName(parser.getText());
  34. } else if (parser.getName().equals("price")) {
  35. eventType = parser.next();
  36. book.setPrice(Float.parseFloat(parser.getText()));
  37. }
  38. break;
  39. case XmlPullParser.END_TAG:
  40. if (parser.getName().equals("book")) {
  41. books.add(book);
  42. book = null;
  43. }
  44. break;
  45. }
  46. eventType = parser.next();
  47. }
  48. return books;
  49. }
  50. @Override
  51. public String serialize(List<Book> books) throws Exception {
  52. //      XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
  53. //      XmlSerializer serializer = factory.newSerializer();
  54. XmlSerializer serializer = Xml.newSerializer(); //由android.util.Xml创建一个XmlSerializer实例
  55. StringWriter writer = new StringWriter();
  56. serializer.setOutput(writer);   //设置输出方向为writer
  57. serializer.startDocument("UTF-8", true);
  58. serializer.startTag("", "books");
  59. for (Book book : books) {
  60. serializer.startTag("", "book");
  61. serializer.attribute("", "id", book.getId() + "");
  62. serializer.startTag("", "name");
  63. serializer.text(book.getName());
  64. serializer.endTag("", "name");
  65. serializer.startTag("", "price");
  66. serializer.text(book.getPrice() + "");
  67. serializer.endTag("", "price");
  68. serializer.endTag("", "book");
  69. }
  70. serializer.endTag("", "books");
  71. serializer.endDocument();
  72. return writer.toString();
  73. }
  74. }

然后再对MainActivity做以下更改:

  1. readBtn.setOnClickListener(new View.OnClickListener() {
  2. @Override
  3. public void onClick(View v) {
  4. try {
  5. InputStream is = getAssets().open("books.xml");
  6. //                  parser = new SaxBookParser();
  7. //                  parser = new DomBookParser();
  8. parser = new PullBookParser();
  9. books = parser.parse(is);
  10. for (Book book : books) {
  11. Log.i(TAG, book.toString());
  12. }
  13. } catch (Exception e) {
  14. Log.e(TAG, e.getMessage());
  15. }
  16. }
  17. });

和其他两个执行结果都一样。

对于这三种解析器各有优点,我个人比较倾向于PULL解析器,因为SAX解析器操作起来太笨重,DOM不适合文档较大,内存较小的场景,唯有PULL轻巧灵活,速度快,占用内存小,使用非常顺手。读者也可以根据自己的喜好选择相应的解析技术。

Android中解析XML的更多相关文章

  1. [置顶] Android学习系列-Android中解析xml(7)

    Android学习系列-Android中解析xml(7) 一,概述 1,一个是DOM,它是生成一个树,有了树以后你搜索.查找都可以做. 2,另一种是基于流的,就是解析器从头到尾解析一遍xml文件.   ...

  2. Android中解析XML格式数据的方法

    XML介绍:Extensible Markup Language,即可扩展标记语言 一.概述 Android中解析XML格式数据大致有三种方法: SAX DOM PULL 二.详解 2.1 SAX S ...

  3. android 中解析XML的方法(转)

    在XML解析和使用原始XML资源中都涉及过对XML的解析,之前使用的是 DOM4J和 XmlResourceParser 来解析的.本文中将使用XmlPullParser来解析,分别解析不同复杂度的t ...

  4. Android中解析XML的方法

    假设我要解析如下的XML文件: <?xml version="1.0" encoding="UTF-8"?> <books> <b ...

  5. android中解析文件的三种方式

    android中解析文件的三种方式     好久没有动手写点东西了,最近在研究android的相关技术,现在就android中解析文件的三种方式做以下总结.其主要有:SAX(Simple API fo ...

  6. 用 ElementTree 在 Python 中解析 XML

    用 ElementTree 在 Python 中解析 XML 原文: http://eli.thegreenplace.net/2012/03/15/processing-xml-in-python- ...

  7. iOS中解析 XML / JSON

    JSON数据格式 1. 概述: JSON (JavaScript Object Notation) 是⼀一种轻量级的数据交换格式 基于⽂文本格式,易于⼈人阅读和编写,同时也易于机器解析和⽣生成. 2. ...

  8. 修改Android中strings.xml文件, 动态改变数据

    有些朋友可能会动态的修改Android中strings.xml文件中的值,在这里给大家推荐一种简单的方法.strings.xml中节点是支持占位符的,如下所示: <string name=&qu ...

  9. Delphi中解析Xml的控件-SimDesign NativeXml

    Delphi中解析Xml的控件-SimDesign NativeXml 正在学习,感觉应用很方便.无源代码的版本还是免费的. SimDesign.NativeXml是一个delphi和bcb的XML控 ...

随机推荐

  1. [转]extjs grid的Ext.grid.CheckboxSelectionModel默认选中解决方法

    原文地址:http://379548695.iteye.com/blog/1167234 grid的复选框定义如下:   var sm = new Ext.grid.CheckboxSelection ...

  2. spring websocket源码分析续Handler的使用

    1. handler的定义 spring websocket支持的消息有以下几种: 对消息的处理就使用了Handler模式,抽象handler类AbstractWebSocketHandler.jav ...

  3. Java-继承,多态练习0922-03

    编写一个Java应用程序,该程序包括3个类:Monkey类.People类和主类 E.要求: (1) Monkey类中有个构造方法:Monkey (String s),并且有个public void ...

  4. Mysql 学习

    一.ubuntu下mysql的安装: 通过sudo apt-get install mysql-server 完成: 然后可以通过/etc/init.d/mysql 进行start/stop/rest ...

  5. ASP.NET MVC 页面调整并传递参数

    转自:http://blog.csdn.net/zhensoft163/article/details/7174661 使用过ASP.NET MVC的人都知道在MVC中页面后台中常用的页面跳转方法有几 ...

  6. 如何实现phpcms v9_4X版本tag的伪静态?

    这两个月来写的文章越来越少了,不是懒,因为太忙了--为客户赶做网站.因为客户指定要使用phpcms v9,还要求使用phpcms v9_42版本实现tag伪静态,在接手的时候phpcms v9_42是 ...

  7. 【产品体验】echo回声

    本人产品新人,学习中,希望大家用过该产品的给点意见,不吝赐教哦~~ 先来两张echo的界面图镇楼——        echo简介: “echo”是一款做声音社交的APP,在这里,你可以感受到声音无限的 ...

  8. ZOJ Problem - 2588 Burning Bridges tarjan算法求割边

    题意:求无向图的割边. 思路:tarjan算法求割边,访问到一个点,如果这个点的low值比它的dfn值大,它就是割边,直接ans++(之所以可以直接ans++,是因为他与割点不同,每条边只访问了一遍) ...

  9. DBCC命令

    DBCC SQLMGRSTATS 用于产生3个不同的值,这些值用在你想查看高速缓存在ad-hoc和预编译的TSQL语句中是如何工作的 Memory Used(8K Pages):若内存页的数量非常大, ...

  10. 我的第一个Angular2应用

    1需要具备的基本前端基础:HTML.CSS.JavaScript.为了实现对项目包的管理,推荐使用npm NPM是随同NodeJS一起安装的包管理工具,能解决NodeJS代码部署上的很多问题:官网先下 ...