汉字URL编码

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

这是本次项目的最后一个问题了，把这个问题解决了，项目就彻底竣工了。先说说要达到的效果：点击一个关键字，使用URL重写传值给Servlet，然后从数据库中查出所有包含这个关键字的文章。
然而在JSP中我们点击这样一个超级链接：http://localhost:8080/wwwroot/tagservlet?tag=数据库
可是这样传递的值我们在Servlet中是没法获取到的，我们需要对这里的汉字进行URL编码，这样我们才能够在Servlet中使用request.getParameter("tag")获得我们传递过来的值。为此，我们需要导入java.net.URLEncoder这个包，接下来使用URLEncoder.encode("数据库")来将“数据库”这三个字进行转码得到的结果是“%CA%FD%BE%DD%BF%E2”，如此一来我们的链接就变为了：http://localhost:8080/wwwroot/tagservlet?tag=%CA%FD%BE%DD%BF%E2
然而，当用request.getParameter("tag")获取这个值并将其输出，你会发现是一堆“？”，这里还得在转码才能得到汉字：
String tag = request.getParameter("tag");
tag = new String(tag.getBytes("ISO-8859-1"),"GBK");
这下终于好了，为什么汉字总是这么麻烦，老要转来转去的，老外的字母就没有问题…

pager-taglib分页标签使用方法

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

以前写的那个[jsp中实现分页显示数据] 方法不通用，得找个分页标签。关于pager-taglib的使用方法网上虽说一大堆，但是同样费我不少脑细胞去看。有的代码不齐全，有的根本就是错误的，有的写的很潦草，看的我是云里雾里的，经过本人耗费大量的脑细胞奋战N个小时终于搞出了点猫腻。
想明白了，写出来运行成功了，我才发现其实用法很简单，没那些人写的那么麻烦。
首先当然还是要导pager-taglib.jar包了，可以去http://jsptags.com/tags/navigation/pager/index.jsp下载，从下载下来的war文件中找到pager-taglib.jar包以及pager-taglib.tld文件。将pager-taglib.tld文件放在WEB-INF目录下，将pager-taglib.jar放在WEB-INF/lib目录下（JBuilder中的导入方法可以参考[Servlet中实现文件上传] ）。
新建一个bean文件定义如下两个方法（不一定非要这个样子）：

 
  1. /**
  2.      * 该方法用于获得数据总数
  3.      * @return int
  4.      */
  5. public int getArticlesCount() {
  6.         String sql = "SELECT COUNT(*) FROM blog_Article";
  7.         dbc = new DataSource();
  8.         stmt = dbc.getPreparedStatement(sql);
  9.         rs = dbc.getResultSet(stmt);
  10.         int count = 0;
  11.         try {
  12.             if(rs.next()){
  13.               count = rs.getInt(1);
  14.             }
  15.         } catch (SQLException ex) {
  16.             ex.printStackTrace();
  17.         } finally {
  18.             dbc.closeConnection();
  19.         }
  20.         return count;
  21.     }
  22.     
  23.     /**
  24.      * 该方法用于数据分页
  25.      * @param begin int
  26.      * @param end int
  27.      * @return ArrayList
  28.      */
  29. public ArrayList getArticlesAll(int begin,int end) {
  30.         String sql = "select top "+end+" * from blog_Article where (log_ID <= (select min(log_ID) from (select top "+begin+" log_ID from blog_Article order by log_PostTime desc) as t)) order by log_PostTime desc";
  31.         ArrayList list = new ArrayList();
  32.         dbc = new DataSource();
  33.         stmt = dbc.getPreparedStatement(sql);
  34.         rs = dbc.getResultSet(stmt);
  35.         try {
  36.             while (rs.next()) {
  37.                 ArticleBean article = new ArticleBean();
  38.                 article.setId(rs.getInt(1));
  39.                 //赋值操作…
  40.                 article.setTag(rs.getString(10));
  41.                 article.setIsTop(rs.getByte(11));
  42.                 list.add(article);
  43.             }
  44.         } catch (SQLException ex) {
  45.             ex.printStackTrace();
  46.         } finally {
  47.             dbc.closeCon
    nection();
  48.         }
  49.         return list;
  50.     }

 

接下来新建一个JSP页面（需要JSTL）：

 
  1. <%@ page contentType="text/html; charset=GBK" import="java.util.*,com.nkblog.bean.ArticleBean,com.nkblog.dbc.*" %>
  2. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  3. <%@ taglib uri="WEB-INF/pager-taglib.tld" prefix="pg" %>
  4. <%
  5. request.setCharacterEncoding("GBK");
  6. String offset = request.getParameter("pager.offset");//pager.offset为此分页标签内置变量用于传递页数
  7.         int page = 0;
  8.         if(offset == null){
  9.         //若offset为null则是第一次访问，所以显示第一页
  10.             page= 1;
  11.         }else{
  12.         //反之，则按照传递来的页数来分
  13.             page = Integer.parseInt(offset)+1;
  14.         }
  15. //获取数据总数        
  16. int dataTotal = ArticleManager.getArticlesCount();
  17. //查询分页数据，10为每页要显示的数据量，可自定义
  18. ArrayList articles = ArticleManager.getArticlesAll(page,10);
  19. %>
  20. <%
  21. for(int i=0;i<articles.size();i++)
  22. {
  23. //输出取出的10条数据…
  24. }
  25. %>
  26. <pg:pager scope="request" maxIndexPages="5" index="center" maxPageItems="10" url="index.jsp" items="<%=dataTotal%>" %>" export="currentPageNumber=pageNumber">
  27.         <pg:first><a href="${pageUrl}">首页</a></pg:first>
  28.         <pg:prev><a href="${pageUrl}">前页</a></pg:prev>
  29.   <pg:page>
  30.   </pg:page>
  31.         <pg:pages>
  32.             <c:choose>
  33.             <c:when test="${pageNumber eq currentPageNumber }">
  34.             <font color="red">${pageNumber }</font>
  35.             </c:when>
  36.             <c:otherwise>
  37.             <a href="${pageUrl }">${pageNumber}</a>
  38.             </c:
    otherwise>
  39.             </c:choose>
  40.    </pg:pages>
  41.         <pg:next><a href="${pageUrl}">下页</a></pg:next>
  42.         <pg:last><a href="${pageUrl}">尾页</a></pg:last>
  43. </pg:pager>

接下来具体说明上面的分页标签<pg:pager>
maxIndexPages为分页条个数，形如：< << 1 2 3 4 5 >> >
maxPageItems为每页要显示的数据量
url为处理分页请求的文件，可以是JSP或Servlet。当程序运行起来后，会以index.jsp?pager.offset=5的形式传递页数。
items为数据总数，pager-taglib会自动根据以上参数进行分页。
需要进行修改的也就上面这几个参数，起初看别人写的方法，我以为只要导入这个标签然后给定一个List数据集合，它就完全自动的跟也并显示数据了，汗~~也不知道我这么写会有几个看得懂的，估计懂的人有，但是能看明白我写的就少了…我发现原来代码写起来简单，但是要给别人将明白了真的好难啊。

 

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哈哈~

 

使用JSP技术开发Web程序

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

在使用JSP技术开发Web程序的时候，我们所要做的事情，就是在JSP页面中写入Java代码，当服务器运行JSP页面时，执行Java代码，动态获取数据，并生成HTML代码，最终显示在客户端浏览器上。 什么是Servlet Servlet是一个Java程序，是在服务器端运行以处理客户端请求并做出响应的程序。 初识Servlet 下面就让我们来认识一下Servlet吧，Servlet的常见代码如下：

 
  1. import javax.servlet.*;
  2. import javax.servlet.http.*;
  3. import java.io.*;
  4. import java.util.*;
  5.  
  6. public class Servlet1 extends HttpServlet {
  7.     private static final String CONTENT_TYPE = "text/html; charset=GBK";
  8.  
  9.     //Initialize global variables
  10.     public void init() throws ServletException {
  11.     }
  12.  
  13.     //Process the HTTP Get request
  14.     public void doGet(HttpServletRequest request, HttpServletResponse response) throws
  15.             ServletException, IOException {
  16.         response.setContentType(CONTENT_TYPE);
  17.         PrintWriter out = response.getWriter();
  18.         out.println("<html>");
  19.         out.println("<head><title>Servlet1</title></head>");
  20.         out.println("<body bgcolor=\"#ffffff\">");
  21.         out.println("<p>The servlet has received a GET. This is the reply.</p>");
  22.         out.println("</body>");
  23.         out.println("</html>");
  24.         out.close();
  25.         application s = new app
  26.     }
  27.  
  28.     //Clean up resources
  29.     public void destroy() {
  30.     }
  31. }

注意：创建的Servlet类必须即成HttpServlet类。实现doGet()或者doPost()方法。 Servlet编程模式 懂HTML基础的话就应该知道在HTML中的Form表单的提交方法有两种：GET、POST。这两种方法在提交数据时的差异。Servlet也同样如此。创建Servlet时，必须要继承HttpServlet，HttpServlet作为一个抽象类用来创建用户自己的Servlet，HttpServlet的子类至少重写以下方法中的一个：doGet()和doPost()。HttpServlet类提供doGet()方法处理Form表单中的GET请求，并提供doPost()方法来处理POST请求。

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