Java读取XML文件

2008.10.07 / 标签: ,,, / 分类: J2EE技术
Sofa

前天做了那个[JSP网站RSS的实现] ，此乃用Java写XML文件，学东西我们要学全（尽可能的全），不能只知其一不知其二，今天来实现在Java中对XML类型文件的读取。
在Java中要实现对XML文件的读取，首先，我们要导入一下几个包。
javax.xml.parsers.DocumentBuilder;
相关解释：
定义 API， 使其从 XML 文档获取 DOM 文档实例。使用此类，应用程序员可以从 XML 获取一个 Document。
javax.xml.parsers.DocumentBuilderFactory;
相关解释：
定义工厂 API，使应用程序能够从 XML 文档获取生成 DOM 对象树的解析器。
org.w3c.dom.Document;
相关解释：
Document 接口表示整个 HTML 或 XML 文档。从概念上讲，它是文档树的根，并提供对文档数据的基本访问。
org.w3c.dom.NodeList;
相关解释：
NodeList 接口提供对节点的有序集合的抽象，没有定义或约束如何实现此集合。DOM 中的 NodeList 对象是活动的。
NodeList 中的项可以通过从 0 开始的整数索引进行访问。
了解了这些知识，我们就可以在Java中像写JavaScript一样获得XML文件中的数据了。
下面是一个具体的方法用于读取前天创建的RSS文件：

 
  1. public static void getArticleList(String fpath){
  2.         try{
  3.             DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
  4.             DocumentBuilder db=dbf.newDocumentBuilder();
  5.             Document doc=db.parse(fpath);
  6.             NodeList nodeList=doc.getElementsByTagName("item");
  7.             for(int i=0;i<nodeList.getLength();i++){
  8.                 String title=doc.getElementsByTagName("title").item(i).getFirstChild().getNodeValue();
  9.                 String author=doc.getElementsByTagName("author").item(i).getFirstChild().getNodeValue();
  10.                 String pubDate=doc.getElementsByTagName("pubDate").item(i).getFirstChild().getNodeValue();
  11.                 String description=doc.getElementsByTagName("description").item(i).getFirstChild().getNodeValue();
  12.                 String category=doc.getElementsByTagName("category").item(i).getFirstChild().getNodeValue();
  13.                 
  14.                 System.out.println(title);
  15.                 System.out.println(author);
  16.                 System.out.println(pubDate);
  17.                 System.out.println(description);
  18.                 System.out.println(category);
  19.             }
  20.         }catch(Exception e){
  21.             System.out.println(e.getMessage());
  22.         }
  23.     }

JSP网站RSS的实现

2008.10.05 / 标签: ,, / 分类: J2EE技术
7°

RSS（也叫聚合内容，Really Simple Syndication）现在用的已经很广啦，最初的RSS要追溯到1995年,当Ramanathan V. Guha和其他在苹果电脑公司的高级技术组开发了一个测试的内容框架。更多有关RSS的资料可查看这里，下面我们来为我们的JSP网站生成RSS。

首先我们来看看最基本的RSS结构：

 
  1. <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  2. <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/"  
  3. xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/"  
  4. xmlns:wfw="http://wellformedweb.org/CommentAPI/"  
  5. xmlns:slash="http://purl.org/rss/1.0/modules/slash/">
  6. </rss>

其实就是一个XML文件！在<rss></rss>之间我们可以自由配置自己要发布的RSS的格式。例如此次我们要发布的RSS是这样的：

 
  1. <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  2. <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" x
  3. mlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" 
  4. xmlns:wfw="http://wellformedweb.org/CommentAPI/" x
  5. mlns:slash="http://purl.org/rss/1.0/modules/slash/">
  6. <channel>
  7. <item>
  8. <title>JSP网站RSS的实现</title>
  9. <author>neeke</author>
  10. <pubDate>2008-10-04</pubDate>
  11. <description>这是来自尼克技术博客博客的RSS</description>
  12. <category>J2EE技术</category>
  13. </item>
  14. </channel>
  15. </rss>

 

了解了它的结构实现起来就容易了。我们创建IO流，并从数据库中获取到我们要发布的RSS资源的集合，然后按照它的格式与结构一行一行的写入到一个RSS.XML文件中即可。

 
  1. public static void publishRss(String rssPath)
  2.     {
  3.       &
    nbsp;     //获得要发布的RSS数据集合
  4.         ArrayList rssArticle = ArticleManager.getArticlesAll();
  5.         try {
  6.             //创建输入输出流
  7.             FileWriter fw = new FileWriter(rssPath);
  8.             BufferedWriter bw = new BufferedWriter(fw);
  9.             //开始按照格式写入数据
  10.             bw.write(
  11.                     "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n");
  12.             bw.write("<?xml-stylesheet type=\"text/xsl\" href=\"CSS/rss.xslt\"?>");
  13.             bw.write("<rss version=\"2.0\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:trackback=\"http://madskills.com/public/xml/rss/module/trackback/\" xmlns:wfw=\"http://wellformedweb.org/CommentAPI/\" xmlns:slash=\"http://purl.org/rss/1.0/modules/slash/\">\r\n");
  14.             bw.write("<channel>\r\n");
  15.             for (int i = 0; i < rssArticle.size(); i++) {
  16.                 ArticleBean article = (ArticleBean) rssArticle.get(i);
  17.                 bw.write("<item>\r\n");
  18.                 bw.write("<title>" + article.getTitle() + "</title>\r\n");
  19.                 bw.write("<author>" + article.getAuthorId() + "</author>\r\n");
  20.                 bw.write("<pubDate>" + article.getPostTime() + "</pubDate>\r\n");
  21.                 bw.write("<description>" + article.getIntro() +
  22.                          "</description>\r\n");
  23.                 bw.write("<category>" + article.getCateId() + "</category>\r\n");
  24.                 bw.write("</item>\r\n");
  25.             }
  26.             bw.write("</channel>\r\n");
  27.             bw.write("</rss>");
  28.             //关闭流，RSS发布完毕。
  29.             bw.close();
  30.             fw.close();
  31.         } catch (IOException ex) {
  32.             ex.printStackTrace();
  33.         }
  34.     }

发布完毕，经过我的测试打开后会提示出错，用记事本打开生成的源文件，然而我们的RSS文件是一点问题都没有的哇，怎么可能呢？接着又用JBuilder打开这个XML文件，晕倒~汉字全是乱码，立刻意识到问题出在了哪里了。在哪呢？其实就是文件的编码问题！将原先
bw.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n");该行代码中的UTF-8改为GBK，重新跑一次程序，一切OK！

J2EE MVC模式中首页初始化

2008.10.04 / 标签: ,,,,,,, / 分类: J2EE技术
4°

虽然也学了这么久的J2EE了（基础型），但是我一直都搞不明白：MVC模式是要分三层的，显示层、控制层（业务逻辑层）及数据层，业务逻辑层才能访问数据层，而显示层不能够直接访问数据层。既然如此，那么网站的首页所需要的数据都是来自数据库的，是要动态读取的，这就要在jsp中直接访问数据层，岂不是相互矛盾了吗？
去了几个技术论坛看了看，有人说那只是一个高效的框架模型，不一定非要遵守，可以直接在首页jsp中调用数据层的方法，活人岂能被尿憋死？话虽说有那么点道理，不过我还是不想这么试。
我是这么想的：
方法1.能不能打开网站地址时候访问的第一个文件是一个Servlet，在Servlet中获得首页用于显示所需要的所有数据，然后将它放在request中，接着在使用
request.getRequestDispatcher("index.jsp").forward(request, response);
跳转到真实的首页，如此即可在index.jsp中从request中获得所要的数据了。那么，如何才能打开网址就直接访问Servlet呢？在网站的根目录下WEB-INF中的web.xml中有这么一对标签：
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
类似于配置IIS中的默认首页 ，我们把这里的index.jsp改为对应的Servlet即可。

方法2.创建一个过滤器，专门用来过滤首页文件，当请求首页文件时就在过滤器中取数据。过滤器本身其实也是Servlet。
我就晕了，无论用这里面哪一个方法，那这里面的Servlet到底属于哪一层啊？是不是我太钻牛角尖了？

JSP读取自定义配置文件

2008.10.02 / 标签: ,,,, / 分类: J2EE技术
2°

在J2EE的Web开发中（其他的也有），有时我们需要存储一些常量类型的配置信息，而这些信息是在不查询数据库的时候就要能够使用的，我就只想到了两个方法。
一个是存储在XML文件中，使用的时候用AJAX来获取，可是这样需要在客户端写大量的JavaScript代码，如果我们在写Jsp脚本的时候也需要这些信息呢？AJAX也没办法了吧？而且，XML文件是可以直接从URL来访问查看的，虽说不一定是重要的信息，但是能够被人随意看那也不好吧。
第二个方法就是，写在Jsp脚本里面，读取的时候我们可以通过
<%@ include file="" %>这样的[JSP指令] 或者<jsp:include flush="" page="" />[标准动作] 把它包含进当前脚本页即可直接访问它的值。需要修改的时候那就只能用IO流来写进去了。
经过再三斟酌，我决定使用第二个方法。那么，既然是配置信息，那就必须有它的规则（格式），若随便写，那读取起来就不好办了。这里举个实例，比如尼克技术博客使用这个ZBLOG程序，在它的根目录下就有一个类似这样的配置文件c_custom.asp，其代码如下：

 
  1. <%
  2. ‘网站基本设置
  3. Const ZC_DATABASE_PATH="data/#%206438769b7b43fa552613.mdb"
  4. Const ZC_BLOG_HOST="http://localhost/"
  5.  
  6. ‘——————————————————————–
  7. Const ZC_BLOG_TITLE="Your Blog"
  8. Const ZC_BLOG_SUBTITLE="Good Luck To You!"
  9. Const ZC_BLOG_NAME="你的Blog名称"
  10. Const ZC_BLOG_SUB_NAME="欢迎使用Z-Blog，有问题或意见请到Zblogger.BBS社区反馈，谢谢您的参与使用。"
  11. Const ZC_BLOG_CSS="default"
  12. Const ZC_BLOG_COPYRIGHT="Copyright xxxx-xxxx Your WebSite. Some Rights Reserved."
  13. Const ZC_BLOG_MASTER="neeke"
  14. ‘——————————————————————–
  15.  
  16. Const ZC_BLOG_THEME="default"
  17.  
  18. %>

 

我们看到它的定义是这样的：

数据类型 关键字名称 = "配置信息"

那么我我们也可以相应的写一个自己的配置文件。

 
  1. <%@ page contentType="text/html; charset=GBK" %>
  2. <%
  3. String NK_BLOG_TITLE="Your Blog";
  4. String NK_BLOG_SUBTITLE="Good Luck To You!";
  5. String NK_BLOG_NAME="你的Blog名称";
  6. String NK_BLOG_SUB_NAME="欢迎使用NK-Blog!";
  7. String NK_BLOG_COPYRIGHT="Copyright xxxx-xxxx Your WebSite. Some Rights Reserved.";
  8. %>

如果在Jsp脚本中需要用他们的时候，我们可以在页头使用<%@ include file="" %>包含这个文件，之后我们就可以直接使用<%=NK_BLOG_TITLE %>来输出“Your Blog”这条信息。修改的时候我们可以使用IO流每次读取其中一行若该行包含有NK_BLOG_TITLE这样的关键字则截取它对应的值，如何截取呢？找每行都有的特征出来，最容易看出来的应该就是双引号啦("")，不过我们不这样截，我们从等号（=）开始截取到分号（；）完，然后替换成新的数据再写入到文件中就OK了！下面就来写具体的实现代码。

读取配置信息：

 
  1. public static BlogSetting getBaseSetting(String custom) {
  2.         BlogSetting bset = new BlogSetting();
  3.         //用于存放每行的信息
  4.      &nbs
    p;  String line =     "";
  5.         //用于存储配置信息
  6.         String[] lines = new String[5];
  7.         try {
  8.             //开始读取配置信息
  9.             FileReader fr = new FileReader(custom);
  10.             BufferedReader br = new BufferedReader(fr);
  11.             while ((line = br.readLine()) != null) {
  12.                 //keyWords为预定义的特征字符数组
  13.                 for (int i = 0; i < keyWords.length; i++) {
  14.                     if (line.contains(keyWords[i])) {
  15.                         int begin = line.indexOf("=");
  16.                         int end = line.indexOf(";");
  17.                         //截取配置信息
  18.                         String key = line.substring(begin + 2, end - 1);
  19.                         //存储
  20.                         lines[i] = key;
  21.                     }
  22.                 }
  23.             }
  24.             //关闭文件流
  25.             br.close();
  26.             fr.close();
  27.         } catch (FileNotFoundException ex) {
  28.             ex.printStackTrace();
  29.         } catch (IOException ex) {
  30.             ex.printStackTrace();
  31.         }
  32.         bset.title = lines[0];
  33.         bset.subTitle = lines[1];
  34.         bset.name = lines[2];
  35.         bset.subName = lines[3];
  36.         bset.copyRight = lines[4];
  37.         return bset;
  38.     }

存储配置信息：

 
  1. public span> boolean BaseSettingSave(String custom) {
  2.         boolean ok = true;
  3.         //待保存的配置信息
  4.         String[] Words = new String[] {this.title, this.subTitle, this.name,
  5.                             this.subName,
  6.                             this.copyRight};
  7.         try {
  8.             //开始读取原配置信息
  9.             FileReader fr = new FileReader(custom);
  10.             BufferedReader br = new BufferedReader(fr);
  11.             String line = "";
  12.             String lines = "";
  13.             while ((line = br.readLine()) != null) {
  14.                 for (int i = 0; i < keyWords.length; i++) {
  15.                     //keyWords为预定义好的特特征字符数组
  16.                     if (line.contains(keyWords[i])) {
  17.                         int begin = line.indexOf("=");
  18.                         int end = line.indexOf(";");
  19.                         //截取出要替换掉的配置信息
  20.                         String key = line.substring(begin + 2, end - 1);
  21.                         //开始替换
  22.                         line = line.replaceAll(key, Words[i]);
  23.                     }
  24.                 }
  25.                 //新的配置信息字符串
  26.                 lines += line+"\r\n";//*****需要换行符
  27.             }
  28.             //关闭文件流
  29.             br.close();
  30.             fr.close();
  31.             //开始写入新的配置信息
  32.             FileWriter fw = new FileWriter(custom);
  33.             BufferedWriter bw = new BufferedWriter(fw);
  34.             bw.write(lines);
  35.             bw.flush();
  36.             //关闭文件流
  37.             bw.close();
  38.             fw.close();
  39.         } catch (FileNotFoundException ex) {
  40.             ok = false;
  41.             ex.printStackTrace();
  42.         } catch (IOExc
    eption ex) {
  43.             ok = false;
  44.             ex.printStackTrace();
  45.         }
  46.         return ok;
  47.     }

为什么要写这个呢？因为这个也是我这次J2EE项目中的一部分，JAVA真的忘得差不多了，想到了方法但是如何使用IO流就给忘了，结果翻书找到…温故而知新，写完后读取成功，修改成功，再读取就失败了~ – -！怎么回事呢？因为我修改写入的时候规则丢了，直接用bw.write(lines)写到一行了，第二次读取的时候它找不到规则当然错啦，然后给加上换行符搞定（"\r\n"）。贴出来以备将来书丢了的时候用，O(∩_∩)O哈哈~

 

Java模式和框架

2008.07.27 / 标签: , / 分类: J2EE技术
Sofa

什么是模式?

模式，即pattern。其实就是解决某一类问题的方法论。你把解决某类问题的方法总结归纳到理论高度，那就是模式。

Alexander给出的经典定义是：每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。

模式有不同的领域，建筑领域有建筑模式，软件设计领域也有设计模式。当一个领域逐渐成熟的时候，自然会出现很多模式。

什么是框架?

框架，即framework。其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

为什么要用模式?

因为模式是一种指导，在一个良好的指导下，有助于你完成任务，有助于你作出一个优良的设计方案，达到事半功倍的效果。而且会得到解决问题的最佳办法。

为什么要用框架?

因为软件系统发展到今天已经很复杂了，特别是服务器端软件，设计到的知识，内容，问题太多。在某些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事物处理，安全性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它是不断升级的，你可以直接享受别人升级代码带来的好处。

框架一般处在低层应用平台(如J2EE)和高层业务逻辑之间的中间层。

软件为什么要分层?

为了实现“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源…总之好处很多啦：)。

以下所述主要是JAVA，J2EE方面的模式和框架：　　

常见的设计模式有什么?

首先，你要了解的是GOF的《设计模式–可复用面向对象软件的基础》一书(这个可以说是程序员必备的了)，注意：GOF不是一个人，而是指四个人。它的原意是Gangs Of Four,就是“四人帮”，就是指此书的四个作者：Erich Gamma,Richard Helm，Ralph Johnson,John Vlissides。这本书讲了23种主要的模式，包括：抽象工厂、适配器、外观模式等。

还有其他的很多模式，估计有100多种。

软件设计模式太多，就我的理解简单说一下最常见的MVC模式。

MVC模式是1996年由Buschmann提出的：

模型(Model)：就是封装数据和所有基于对这些数据的操作。

视图(View)：就是封装的是对数据显示，即用户界面。控制器(Control)：就是封装外界作用于模型的操作和对数据流向的控制等。

另外：RUP(Rational Unified Process)软件统一过程，XP(Extreme Programming)极端编程，这些通常被叫做“过程方法”，是一种软件项目实施过程的方法论，它是针对软件项目的实施过程提出的方法策略。也是另一个角度的模式。

常见的JAVA框架有什么?

WAF：全称：WEB APPLICATION FRAMEWORK

主要应用方面：EJB层，(WEB层也有，但是比较弱)。

主要应用技术：EJB等。

简述：这是SUN在展示J2EE平台时所用的例子PetStore(宠物商店系统)里面的框架。是SUN蓝皮书例子程序中提出的应用框架。它实现了 MVC和其他良好的设计模式。SUN的网站上有技术资料，最好下载PetStore来研究，WEBLOGIC里自带此系统，源码在bea/weblogic700/samples/server/src/petstore。这是学习了解J2EE的首选框架。

Struts:主要应用方面：WEB层。

主要应用技术：JSP,TagLib,JavaBean,XML等

简述：这是APACHE的开源项目，目前应用很广泛。基于MVC模式，结构很好，基于JSP。Jbuilder8里已经集成了STRUTS1.02的制作。

简述WAF+STRUTS结合的例子：

WEB层用STRUTS，EJB层用WAF：

JSP(TagLib)——>ActionForm——>Action　——>Event——>EJBAction——>EJB——>DAO——>Database

JSP(TagLib) (forward) <——Action<——EventResponse<——Turbine：

主要应用方面：WEB层。

主要应用技术：servlet等

简述：这是APACHE的开源项目。基于SERVLET。据说速度比较快，基于service(pluggable implementation可插拔的执行组件)的方式提供各种服务。

COCOON：

主要应用方面：WEB层。

主要应用技术：XML，XSP，servlet等

简述：这是APACHE的一个开源项目。基于XML，基于XSP(通俗地说，XSP是在XML静态文档中加入Java程序段后形成的动态XML文档。)。特点是可以与多种数据源交互，包括文件系统，数据库，LDAP，XML资源库，网络数据源等。

ECHO：

主要应用方面：WEB层。

主要应用技术：servlet

简述：nextapp公司的一个开源项目。基于SERVLET。页面可以做的很漂亮，结合echopoint，可以作出很多图形效果(里面用了jfreechart包)。使用SWING的思想来作网页，把HTML当作JAVA的类来做。但是大量使用Session，页面分帧(Frame)很多,系统资源消耗很大。

JATO：全称：SUN ONE Application Framework

主要应用方面：WEB层。主要应用技术：JSP,TagLib,JavaBean等

简述：这是SUN推出的一个商业性框架，一看名字就知道是结合SUN ONE的平台推出的。我下载了JATO2.0看了一下，感觉有些简单，使用了JSP+TagLib+JavaBean。如他的DOC所说JATO是适合用在小的WEB应用里。

TCF：全称：Thin-Client Framework

主要应用方面：JAVA GUI。

主要应用技术：JAVA application等

无觅相关文章插件，快速提升流量