颠覆软件 » java开发技术

谈谈方法中的返回值类型和参数类型

Alex — Sun, 13 May 2007 13:47:13 +0000

和大家谈谈方法中的返回值类型和参数类型。

大多数时候我们用具体的返回类型，比如要么是一个具体的对象，要么是一个Collection作为返回类型，对于参数同样如此，
现在我看到另一种做法，即参数和返回类型都是HashMap,大家以为此种做法是否可取？

代码如下:

public BeanValue saveMyPo(RequestMap rMap) {

        BeanValue value = new BeanValue();

        try {

            MyPo mypo= (MyPo) BeanUtil.convertObject(MyPo.class,
                    rMap.getMap());

            mypo.setTtime(new Date());

            dao.saveObject(mypo);

            value.addRequestMap(“hi“, mypo);

        } catch (Exception e) {
            value.addErrorMap(Constants.MyException, e);
            value.setForword(“fail“);
        }

        return value;

    }

目前这个做法看得到的好处有几点：
1。返回的类型可以存放更多的内容，包括错误信息以及更多的其他内容
2。参数传递的内容更丰富，可以减少不必要的重载，减少代码量。

不过，如果说有什么缺点的话可能就是语义不够明确，那么除了这一点还有什么别的问题么？请大家拍砖。

[zt]插入图片到数据库(BLOB大字段保存对象)

Alex — Wed, 28 Mar 2007 14:02:32 +0000

key words : blob , oracle ,插入图片

come from here

显示blob

try {
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver“).newInstance();
Connection con=DriverManager.getConnection(“jdbc:odbc:Multimedia“,“samp“,“samp“);
Statement stmt=con.createStatement();
ResultSet rs=stmt.executeQuery(“select frame from MULTIMEDIA_TAB where clip_id=1“);
if(rs.next()){
try {
InputStream dis=rs.getBinaryStream(1);
byte[] x = new byte [10*1024]; //creare byte array to hold the blob data
int lengthRead = 0; // Number of bytes read
String fileToWriteBlob = “./default-app/MyProgs/ImageRetrieval/ganpati.jpg“;
FileOutputStream outputStream = new FileOutputStream(fileToWriteBlob);
while( (lengthRead =dis.read(x)) != -1){
outputStream.write(x);
}
dis.close();
outputStream.close();
}
catch(Exception e) {
System.out.println (“Error is : “ + e);
}
}
}
catch(Exception ex) {
System.out.println(“Error “ + ex);
}

If you are inserting a row:

1.Insert the row with all values, but insert an empty blob into the blob column:
“INSERT INTO yourtable (id,blob_value) VALUES (?,empty_blob())”

2. Select the empty blob you created:
“SELECT blob_value FROM yourtable WHERE id=?”
oracle.sql.BLOB blob = rs.getBLOB(“blob_value”);
(some code is of course missing, but this should give you the idea)
3. Write the bytes into the blob:

try {
OutputStream outstream = blob.getBinaryOutputStream();
outstream.write(blobValue);
outstream.flush();
outstream.close();
} catch (IOException e) {
// handle exception
}
Where blobValue is the byte array containing the image data.

4. Update the row:
“UPDATE yourtable SET blob_value=? WHERE id=?”
pstmt.setBLOB(1, blob);
pstmt.setInt(2, id);
(NOTE: the setBLOB is an Oracle specific method, you can probably also use the setBlob method).
Again, some essential code concerning the prepared statements is missing, but this should give you an idea…

That’s that. If you just need to update the row, you just go through steps 2-4 above.

Here is an example:

import java.sql.*;
import java.io.*;

public class imgtest {

private PreparedStatement ps = null;
private Connection conn = null;

public void initialise() {
String URL = “jdbc:oracle:thin:@localhost:1521:SID“;
String userid = “user“;
String passwd = “pass“;
// register the JDBC driver
try {
DriverManager.registerDriver(new
oracle.jdbc.driver.OracleDriver());
// get a connection
Connection conn = DriverManager.getConnection(URL, userid, passwd);
this.conn = conn;
// create a prepared statement
ps = conn.prepareStatement(“INSERT INTO images (NAME,IMAGE) VALUES (?,?)“);
}
catch (Exception e) {
System.out.println(“Error: “ + e);
System.exit(1);
}
}

public imgtest() {
initialise();
File fImage = null;
FileInputStream isImage = null;

try {
fImage = new File( “fileo.gif“ );
isImage = new FileInputStream( fImage );
}
catch (FileNotFoundException fnf) {
System.out.println(“File not found: “ + fnf);
System.exit(1);
}
try {
ps.setString(1,“Open File“);
ps.setBinaryStream(2,isImage,(int)(fImage.length()));
ps.executeUpdate();
ps.close();
conn.close();
}
catch (Exception e) {
System.out.println(“Error: “ + e);
System.exit(1);
}
}

public static void main(String[] args) {
new imgtest();
}
}

My table looks like this:
// —->%—-
CREATE TABLE images
(NAME VARCHAR2(16) primary key not null,
IMAGE BLOB(64k));
commit;
quit;
// —->%—-

update(2007-5-13)

/** *//**
* Oracle中的Blob类型字段操作
* User: Alex
* Date: 2007-5-9
* Time: 16:42:43
*/
public class BlobUtil {

    /** *//**
     * 获得blob内容
     *
     * @param documentId : 文档编号
     * @param response   : HttpServletResponse
     */
    public static void downloadDocument(String documentId, HttpServletResponse response) {
        if (null == documentId) throw new JyhdException(“文档编号为空，请检查“);

        DbDao db = null;
        ResultSet rs = null;
        BLOB blob = null;
        OutputStream out = null;
        try {
            String sql = “select id,file_blob from tbl_blob_document where id = “ + documentId;
            db = new DbDaoImpl();
            rs = db.query(sql);

            if (rs.next()) {
                blob = (BLOB) rs.getBlob(“file_blob“);
                InputStream in = blob.getBinaryStream();
                out = response.getOutputStream();
                int size = blob.getBufferSize();
                byte[] buffer = new byte[size]; // 建立缓冲区
                int len;
                while ((len = in.read(buffer)) != -1)
                    out.write(buffer, 0, len);
            }
        }
        catch (Exception e) {
            e.printStackTrace();
            throw new JyhdException(“===>>>table非法“);
        }
        finally {
            try {
                if (null != out) {
                    out.close();
                }
                if (null != db) {
                    db.close();
                }
            } catch (Exception ee) {
                ee.printStackTrace();
            }
        }

    }

    /** *//**
     * 插入blob内容
     * updated: 支持update,动态判断documentId是否已经存在，若已经存在则修改
     *
     * @param inputStream : 读取输入流
     * @param documentId  :  请从WellsoonUtil.getSequence(“TBL_BLOB_DOCUMENT_SEQ”) 获取
     */
    public static void uploadDocument(InputStream inputStream, String documentId) {
        DbDao db = null;
        ResultSet rs = null;
        Connection conn = null;
        String sql = null;
        try {
            db = new DbDaoImpl();
            conn = db.getConnection();
            conn.setAutoCommit(false);
            Statement stmt = conn.createStatement();

            //如果已经存在则更新
            String hasOldRecord = “select id from tbl_blob_document where id =“ + documentId;
            if (!DbUtil.hasRecord(hasOldRecord)) {
                sql = “insert into tbl_blob_document( id,file_blob) values(“ + documentId + “,EMPTY_BLOB())“;
                int count = stmt.executeUpdate(sql);
            }
            //select for update
            sql = “select id,file_blob from tbl_blob_document where id = “ + documentId + “ for update“;
            rs = stmt.executeQuery(sql);

            if (rs.next()) {
                BLOB blob = ((OracleResultSet) rs).getBLOB(“file_blob“);  // 得到BLOB对象
                OutputStream out = blob.getBinaryOutputStream();  // 建立输出流
                int size = blob.getBufferSize();
                byte[] buffer = new byte[size];  // 建立缓冲区
                int len;
                while ((len = inputStream.read(buffer)) != -1)
                    out.write(buffer, 0, len);
                inputStream.close();
                out.close();

            }
            conn.commit();

        }
        catch (Exception e) {
            e.printStackTrace();
            throw new JyhdException(“===>>>table非法“);
        }
        finally {
            try {
                db.close();
            } catch (Exception ee) {
                ee.printStackTrace();
            }
        }
    }

    /** *//**
     * 填充Blob
     */
    private static void fillBlob(oracle.sql.BLOB blob, byte[] btaData) throws Exception {
        int len = btaData.length;
        long num = 0;
        byte[] btBlockData;
        for (int i = 0; i < len; i += num) {
            if (i == 0)
                btBlockData = btaData;
            else {
                btBlockData = new byte[len - i];
                System.arraycopy(btaData, i, btBlockData, 0, len - i);
            }
            num = blob.putBytes(i + 1, btBlockData);
        }
    }

    /** *//**
     * dump Blob
     *
     * @param blob
     * @return
     * @throws Exception
     */
    private static byte[] dumpBlob(oracle.sql.BLOB blob) throws Exception {
        long len = blob.length();
        byte[] byte0 = new byte[(int) len];
        byte[] byte1 = new byte[32512];
        int num = 0;
        for (int i = 0; i < len; i += num) {
            num = blob.getBytes(i + 1, (int) len - i, byte1);
            System.arraycopy(byte1, 0, byte0, i, num);
        }
        byte1 = null;
        return byte0;
    }

    public static void main(String[] args) throws Exception {
        //文件上传
        File file = new File(“Y:\\我的照片\\Palm\\Photo_121306_013.jpg“);
        InputStream in = new FileInputStream(file);
        String sequence = SequenceUtil.getSequence(“TBL_BLOB_DOCUMENT_SEQ“);
        uploadDocument(in, sequence);

    }

}

[zt]用JSP实现上传文件的两种方法

Alex — Mon, 26 Mar 2007 14:03:55 +0000

key words: 文件上传，upload, cos.jar + uploadbean.jar + filemover.jar

以前用cos作文件上传，但是对于文件上传后的改名还需要借助其他的工具。

摘录如下:

在用Java开发企业器系统的使用,特别是涉及到与办公相关的软件开发的时候,文件的上传是客户经常要提到的要求.因此有一套很好文件上传的解决办法也能方便大家在这一块的开发.

首先申明,该文章是为了自己记录一备以后开发需要的时候,不用手忙脚乱哈哈……..

现在在国内用的非常多的一般是两种方法解决来解决文件上传.

cos.jar + uploadbean.jar + filemover.jar
这个是用的非常普遍的,原因是因为他操作方便,是我们不必再去关注,那些文件的输入和输出流,使我们从底层的流中解脱出来.
UploadFile,UploadBean,MultipartFormDataRequest

<％@ page contentType=”text/html;charset=gb2312″ ％>
<head>
<title>fbysss UploadBean 示例title>
meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1″–>
meta http-equiv=”Content-Type” content=”text/html; charset=gb2312″–>
head>
<FORM name=”form1″ METHOD=”POST” ACTION=”sssupload.jsp” ENCTYPE=”multipart/form-data”>
<input name=”title” type= ”text” value=”中文字”>
<td class=”bodystyle”>附件td>
<td class=”bodystyle”> <input name=”attach” type=”FILE” id=”attach” size=”50″ > td>
<input name=”ok” type= ”submit” value=”提交”>
form>

2.读取表单页面sssgetdata.jsp

//==========================================================================
//文件：UploadBean上传实例
//功能：解决中文乱码，完成文件上传，并提供上传改名解决方案
//作者：fbysss
//msn:jameslastchina@hotmail.com
//==========================================================================
–>
<％@ page contentType=”text/html;charset=GBK” ％>
<％@ page language=”java” import=”com.jspsmart.upload.*”％>
<％@ page import=”java.text.SimpleDateFormat”％>
<％@ page import=”java.io.File”％>
<％@ page import=”java.util.*”％>
<％@ page import=”javazoom.upload.*”％>
<％@ page import=”uploadutilities.FileMover”％>
<head>
<meta http-equiv=”Content-Type” content=”text/html; charset=gb2312″>
head>
<％
request.setCharacterEncoding(“GBK”);//设置编码格式，就不用一个个转码了。
FileMover fileMover = new FileMover();//你也可以使用自带的实例中jsp:useBean的形式。
UploadBean upBean = new UploadBean();
MultipartFormDataRequest mrequest = null;
Hashtable files = null;

if (MultipartFormDataRequest.isMultipartFormData(request))
{
mrequest = new MultipartFormDataRequest(request,null,100*1024*1024,MultipartFormDataRequest.COSPARSER,”GBK”);//注意这里也要设置编码参数
String sTt0 = mrequest.getParameter(“title”);
out.println(“>Title0是：”+sTt0+”<br>“);
String sTt1 = new String(sTt0.getBytes(“ISO-8859-1″),”GBK”);
out.println(“<br>Title1是：”+sTt1+”<br>“);
//这里用来测试title参数是否正确。调试的时候，加一句if (true)return;即可。
files = mrequest.getFiles();
}

//获取修改前的文件名
String sOldFileName =mrequest.getParameter(“oldfilename”);
out.println(“sOldFileName:”+sOldFileName);
String sWebRootPath = request.getRealPath(“/”);//得到你的web应用的根。
String sPath=sWebRootPath+”attach”;
int iFileCount = 0;
String sServerFileName=”";
String sLocalFileName = ”";
//文件获取
if ( (files != null) || (!files.isEmpty()) ) {

iFileCount = files.size();
UploadFile file = (UploadFile) files.get(“attach”);
sLocalFileName=file.getFileName();
out.println(“sLocalFileName:”+sLocalFileName);
int ii= sLocalFileName.indexOf(“.”); //取文件名的后缀
String sExt = sLocalFileName.substring(ii,sLocalFileName.length());
//得到不重复的文件名
java.util.Date dt = new java.util.Date(System.currentTimeMillis());
SimpleDateFormat fmt = new SimpleDateFormat(“yyyyMMddHHmmssSSS”);
sServerFileName= fmt.format(dt);
sServerFileName =sServerFileName + sExt;
//如果不存在该目录，则新建一个
File dir =new File(sPath);
if (!dir.exists()){
dir.mkdirs();
}
upBean.setFolderstore(sPath);//设置要上传的目录
upBean.addUploadListener(fileMover);//增加filMover监听
fileMover.setNewfilename(sServerFileName);//设置服务器上的文件名
upBean.store(mrequest, ”attach”);//上传
out.println(“file path is ”+sPath+”/”+sServerFileName);
}

％>

Demo注意事项：cos.jar，uploadbean.jar，filemover.jar这几个包必须有。
必备下载地址：
UploadBean1.5：http://wcarchive.cdrom.com/pub/simtelnet/winnt/java/uploadbean1_5.zip
FileMover1.3：http://www.javazoom.net/jzservlets/uploadbean/addons/filemover1.3.zip
参考下载地址：
ChinesUpload例子：http://www.javazoom.net/jzservlets/uploadbean/addons/ChineseUpload.zip
参考了fbysss的一篇文章
2. org.apache.struts.upload.FormFile
Struts1.1的org.apache.struts.upload.FormFile类。很方便，不用自己写。也不用写一个jsp调用jspsmartupload就可以搞定。

选择上传文件页面：selfile.jsp

——————————————————————————–
<％@ taglib uri=”/WEB-INF/struts-html.tld” prefix=”html”％>

——————————————————————————–
UpLoadAction.java
——————————————————————————–

import java.io.*;
import javax.servlet.http.*;
import org.apache.struts.action.*;
import org.apache.struts.upload.FormFile;

/** *//**
*

Title:UpLoadAction

Description: QRRSMMS

Company: jiahansoft

* @author wanghw
* @version 1.0
*/

public class UpLoadAction extends Action {
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws Exception {
if (form instanceof uploadsForm) {//如果form是uploadsForm
String encoding = request.getCharacterEncoding();
if ((encoding != null) && (encoding.equalsIgnoreCase(“utf-8“)))
{
response.setContentType(“text/html; charset=gb2312“);//如果没有指定编码，编码格式为gb2312
}
UpLoadForm theForm = (UpLoadForm ) form;
FormFile file = theForm.getTheFile();//取得上传的文件
try {
InputStream stream = file.getInputStream();//把文件读入
String filePath = request.getRealPath(“/“);//取当前系统路径
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStream bos = new FileOutputStream(filePath + “/“ +
file.getFileName());//建立一个上传文件的输出流
//System.out.println(filePath+”/”+file.getFileName());
int bytesRead = 0;
byte[] buffer = new byte[8192];
while ( (bytesRead = stream.read(buffer, 0, 8192)) != -1) {
bos.write(buffer, 0, bytesRead);//将文件写入服务器
}
bos.close();
stream.close();
}catch(Exception e){
System.err.print(e);
}
//request.setAttribute(“dat”,file.getFileName());
return mapping.findForward(“display“);
}
return null;
}
}

——————————————————————————–

UpLoadForm.java

——————————————————————————–

import javax.servlet.http.HttpServletRequest;
import org.apache.struts.action.*;
import org.apache.struts.upload.*;

/** *//**
*

Title:UpLoadForm

Description: QRRSMMS

Company: jiahansoft

* @author wanghw
* @version 1.0
*/

public class UpLoadForm extends ActionForm {
public static final String ERROR_PROPERTY_MAX_LENGTH_EXCEEDED = “org.apache.struts.webapp.upload.MaxLengthExceeded“;
protected FormFile theFile;
public FormFile getTheFile() {
return theFile;
}
public void setTheFile(FormFile theFile) {
this.theFile = theFile;
}
public ActionErrors validate(ActionMapping mapping, HttpServletRequest request)
{
ActionErrors errors = null;
//has the maximum length been exceeded?
Boolean maxLengthExceeded = (Boolean)
request.getAttribute(MultipartRequestHandler.ATTRIBUTE_MAX_LENGTH_EXCEEDED);
if ((maxLengthExceeded != null) && (maxLengthExceeded.booleanValue()))
{
errors = new ActionErrors();
errors.add(ERROR_PROPERTY_MAX_LENGTH_EXCEEDED, new ActionError(“maxLengthExceeded“));
}
return errors;

}
}
//这是相对应的form，还有其他属性可以设置，具体可以参考struts的上传例子。

——————————————————————————–

struts-config.xml

——————————————————————————–

http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd”;>

jsp防盗链

Alex — Tue, 13 Mar 2007 14:05:32 +0000

key words : jsp防盗链 header

最近碰到盗链的问题，即复制一个url地址，在另一个地方也能访问。

index.jsp页面

<html>
  <head><title>Simple jsp pagetitle>head>
  <body>Place your content here

  here is index jsp
    get header info
  <a href=”a.jsp”>a.jspa>
  body>
html>
a.jsp页面

<html>
  <head><title>Simple jsp pagetitle>head>
  <body>Place your content here

  here is a. jsp
    get header info
  <%=request.getHeader(“Referer“)%>
  <%if(null == request.getHeader(“Referer“) || request.getHeader(“Referer“).indexOf(“yourdomain.com“) < 0){%>
     做人要厚道
  <%}else{%>
  合法访问
  <%}%>
  body>
html>

即从内部访问可以，直接粘贴地址在另一个浏览器里访问禁止

真正理解面向接口编程

Alex — Mon, 12 Mar 2007 14:06:27 +0000

key words ：面向接口编程

面向对象设计里有一点大家已基本形成共识，就是面向接口编程，我想大多数人对这个是没有什么觉得需要怀疑的。

问题是在实际的项目开发中我们是怎么体现的呢？难道就是每一个实现都提供一个接口就了事了？反过来说，你有时候有没有觉得接口是多余的事？又或者，你仅仅是觉得现在类似spring这样的框架已习惯用接口这种方式而心存当然。

设计模式解析里提到了面向对象设计考虑的几个视角，一个是概念层，一个是规约层，一个是实现层。我如果没有猜错的话，实际上我们大多数人的眼睛一直是盯着实现层的，而这正是面向对象设计所极力避免的，即你不要在一开始就关注这些细节，你要关注的是规约（接口）.

对于实际项目开发来说，如果我们把实现的过程分为多个阶段的话我们不妨这么划分，第一阶段，根据client端的需要去设计我们的规约(interface),在这个阶段任何实现都没有，所有的任务就是定义接口所需要的职责，以及所需要的一些po,vo;第二阶段，实现前面定义的规约。而以前我是怎么做的呢？我是交叉作的，即假模假样的定义一个接口（其实我心里在想这个东西有屁用）,然后定义了一个方法，然后就立即去实现这个方法，再然后我又定义一个方法，继续去实现，我现在终于想通了，这样好累，效率很低，最重要的是，这不属于真正的设计。
现在我是怎么做的呢？比如一个list.jsp里需要查询，列表，然后看明细信息，然后增加信息，我会第一步在接口里定义完(这个过程会有整体设计的意识),毫不关心底层实现(数据库、事务)，我的目标就是”我想要这个功能，我想要那个功能”，至于那个功能怎么实现在第一阶段我认为那不是我的事情(尽管这个事情最终还是由我来做) .大家看这个过程和前面的过程有什么本质的不同呢？就是分层的概念更加明显，你的工作更有层次，每次都有先设计再实现的步骤，而前面那个过程很容易就让你不知不觉地陷入纯实现的陷阱中。

一点感想，欢迎大家拍砖。

No related posts.

上传文件放在哪里比较合适?

Alex — Wed, 31 Jan 2007 14:10:27 +0000

目里面有上传文件的需求,我想了一下不外乎下面两种处理方法: 1. 在数据库表中建立一个blob字段存放用户上传文件. 2. 在服务器上建立一个文件夹保存用户上传文件,数据库表中只存放该文件的url地址. 我本人现在比较倾向于第2种方案, 主要原因是担心方案1的效率（我用的是mysql数据库）。但是处理过程中除了维护数据库中表的字段还要维护上传的文件,稍微麻烦一点。大家在项目里面又是怎么做呢？给我点建议！谢谢讨论内容见: javaeye robin更建议第二种方案，放在数据库中主要的问题是 AppServer吃不消，开销比较大. 上面是摘录，不过我们这里用的是Oracle9i AS,在Oracle的协作套间里一般文档或者上传的文件都是保存在数据库里，还把这个特性作为Oracle 与别的协作套件之间不同的卖点。大家以为如何? 我直觉是Oracle的DB和oc4j的AppServer对付这个似乎没有开销上的担心，但是没有实际检测过。换句话说，文件的管理是放在文件夹里方便还是数据库里方便? 有点为难 update (2007-5-13): 还有一种方案结合了数据库和IO，我认为比较可行，就是文件存在数据库，但是下载的时候第一次从数据库下载，然后第一次这个文件保存在一个临时文件夹下面，以后每次下载的时候总是先检查此临时文件夹，如果已经存在则直接下载，如果没有则从数据库重复这个动作。当然，保存在临时文件夹下的文件的命名需要唯一，这个应该没有问题。

No related posts.

web快速开发相关技术和产品

Alex — Sat, 20 Jan 2007 14:14:07 +0000

key words : web快速开发

web快速开发是一个值得期待的东西，最早我接触过codecharge,是一个商业软件，功能据说很强大，我试用过，支持php,asp,jsp等多语言，但是感觉对java的支持不是很顺手，接着就是asp,这个好也不好，原因就不说了，因为我对java关注。

2. 接着就是dorado ,刚看到的，感觉也不错,有asp的风格，不过更适合j2ee的环境 ,这里是他们的在线演示demo,有兴趣的可以看一下

3. 最后，刚google了一下，Oracle也有一个基于Oracle数据库的快速开发产品 : APEX,基于浏览器做DB 开发,原来的名字叫做HTML DB,名字很直观，据说Oracle的metalink就是用这个实现的，应该功能不赖。

4.对了，再补充一个现在很热的，Ror,听说javaeye的网站要重新用ruby1.2开发，试用过一点，感觉确实令人震惊，值得关注。

java的技术其实是看着很热闹，比较大的东西也不少，但是真正关注web这一块的其实不多，无论是struts还是webwork,离我们所说的真正的“快速开发”的距离很远，而以上一些工具的出现也许会逐步改善j2ee在这一领域的现状。

我之所以对这个目前有点兴趣，确实有一种强烈的反差在折磨着我，因为我相信在j2ee的web开发里确实存在本来要开发1周多的工作量很可能用一个好的工具几个小时就搞定了，这是一件多么荒唐搞笑的事情？如果dorado在它的产品中真的能做到这样那我们的java开发那么坑吃坑吃的折腾个什么劲啊? 也许真的有奇迹，我宁愿相信有这样的奇迹。

大家有什么好的想法可以讨论一下。

No related posts.

[zt]关于commons logging

Alex — Mon, 18 Dec 2006 14:27:22 +0000

key words: commons log,log4j,apache log

前言: 对于log4j虽然在用，但是也存在一个疑问，怎么有的用apache的commons logging有的直接用log4j,下面的这篇文章解释了我的疑问.

转自 here

Apache组织开发了一套用于支持Logging的Log4J，Java 1.4版本也引入了一套内置的 Logging框架，如果开发者想在这两套Logging系统之间自由的切换，该怎么办呢？答案就是，使用Commons Logging。 Commons Logging定义了一套抽象的Logging接口，用户可以通过配置，使这些接口指向任何一个已存在的Logging系统。

•使用抽象Logging接口
问题：
你在编写一个可以重复使用的库，需要写入Log信息，但你不想使你的Logging功能绑定在Apache Log4J或者JDK 1.4 Logging框架上。
解决方案：

public static void main(String［］ args) {//自己替换［］

System.setProperty(“org.apache.commons.logging.Log”,
“org.apache.commons.logging.impl.Jdk14Logger”);
Log log = LogFactory.getLog(“com.discursive.jccook.SomeApp”);

if (log.isTraceEnabled()) {
log.trace(“This is a trace message”);
}

if (log.isDebugEnabled()) {
log.debug(“This is a debug message”);
}

log.info(“This is an informational message”);
log.warn(“This is a warning”);
log.error(“This is an error”);
log.fatal(“This is fatal”);

}

LogFactory.getLog方法会根据底层环境返回一个适当的Log实现。如果用户想指定一个具体的Logging系统实现，可以设置org.apache.commons.logging.Log系统属性。例如：
System.setProperty(“org.apache.commons.logging.Log”,
“org.apache.commons.logging.impl.Log4JLogger”);
这样就会使用Log4J作为Logging系统。
org.apache.commons.logging.Log可以设定为：
•org.apache.commons.logging.impl.Log4JLogger  使用Log4J
•org.apache.commons.logging.impl.Jdk14Logger  使用JDK 1.4 Logging框架
•org.apache.commons.logging.impl.SimpleLog  使用Commons Logging内置的简单Log实现
其他：
总结一下，Commons Logging会按照下列顺序来指定具体的Log实现。
•如果定义了org.apache.commons.logging.Log系统参数，实用指定的Logging实现。
•如果在CLASSPATH里发现了Log4J，使用Log4J。
•如果使用的是JDK1.4，使用JDK1.4内置的Logging框架。
•如果都没有找到，则使用Commons Logging内置的简单Log实现。

jstl标签注意问题

Alex — Mon, 11 Dec 2006 14:29:16 +0000

key words: jsp,jstl,1.0,1.1,fn函数

原来一直用struts,最近项目里有人用jstl,我也就顺便拿来用，感觉还是不错。

过程中碰到一些小的问题总结如下:

一。版本问题
jstl存在1.0和1.1的差异问题，用EL建议需要在1.1的版本下，1.1的URI的标志为:

<%@ taglib uri=“http://java.sun.com/jsp/jstl/core“ prefix=“c“%>
<%@ taglib uri=“http://java.sun.com/jsp/jstl/functions“ prefix=“fn“%>
注意，1.0版本没有/jsp/.

如果用的1.0会出现如下异常

org.apache.jasper.JasperException: /public/left_tree.jsp(100,24) According to TLD or attribute directive in tag file, attribute items does not accept any expressions
org.apache.jasper.servlet.JspServletWrapper.handleJspException(JspServletWrapper.java:510)
org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:375)
org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:314)
org.apache.jasper.servlet.JspServlet.service(JspServlet.java:264)
javax.servlet.http.HttpServlet.service(HttpServlet.java:802)
org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:75)
org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:77)
com.wellsoon.zfzw.webapp.common.VabAccessFilter.doFilter(VabAccessFilter.java:43)

root cause

二。打开ＥＬ

<%@ page contentType=“text/html;charset=gb2312“ language=“java“ isELIgnored=“false“ %>
前提是容器支持２．０，即使支持默认也未必打开，最安全的方式就是显示打开 isELIgnored=“false“

三.fn的用法
对于Vo里的一个List作length的计算或判断很方便

<table width=”160″ border=”0″ cellspacing=”0″ cellpadding=”4″>
<c:forEach items=”${menuInfos}” var=”m”>
<c:if test=”${fn:length(m.subMenus)>0}”>
<tr>
<td>
<script language=”JavaScript”>
var tObj = new treeClass(“A1“)
tObj.start();
tObj.m_start(““${m.menuModule}“/>“,0);
<c:forEach items=“${m.subMenus}“ var=“sub“>
tObj.add_Sub(““${sub.menuName}“/>“,“<%=path%>
“${sub.url}“/>“,“mymain“);
c:forEach>
tObj.m_end();
tObj.end();
tObj.print();
script>
td>
tr>
c:if>
c:forEach>

table>
四.tld的声明可以在web.xml作显式声明也可以用http作直接URL声明
推荐用本地的方式.

Unsupported major.minor version 49.0错误

Alex — Wed, 08 Nov 2006 14:38:29 +0000

key words:jdk错误，Unsupported major.minor version

今天用一个工作流的产品，非要用jdk1.4的版本，没办法，只好切换回来，但是换回来后打开页面jsp出错，提示Unsupported major.minor version 49.0错误,到网上查了一下，49.0错误属于jdk1.5的错误，但是我的jdk1.5已经删除了啊？怎么回事呢?

最后想起来，可能是jboss中的1.5 版本产生临时文件class文件删除，删除后ＯＫ

资料:Unsupported major.minor version 49.0

No related posts.

解决response.sendRedirect(“mypage.jsp”)的问题

Alex — Tue, 31 Oct 2006 14:40:54 +0000

key word: response.sendRedirect() 页面转向

在jsp里经常要碰到页面的跳转，但是有一个问题，就是跳转的时候有些信息无法携带，比如
response.sendRedirect(“myPage.jsp?method=save”)通过URL携带信息没问题，但是request.setAttribute(“message”,myObject);就无法携带. 以前碰到这个问题我都回避了，改用session存放信息，但是显然不足取。

察看了一下，在servlet里的途径好办，jsp里必须调用标签

<jsp:forward page=“myPage.jsp“/>

No related posts.

[zt]关于用户角色权限的一点想法

Alex — Thu, 26 Oct 2006 14:44:09 +0000

前言：

权限往往是一个极其复杂的问题，但也可简单表述为这样的逻辑表达式：判断“ Who 对 What(Which) 进行 How 的操作”的逻辑表达式是否为真。针对不同的应用，需要根据项目的实际情况和具体架构，在维护性、灵活性、完整性等 N 多个方案之间比较权衡，选择符合的方案。

目标：

直观，因为系统最终会由最终用户来维护，权限分配的直观和容易理解，显得比较重要，系统不辞劳苦的实现了组的继承，除了功能的必须，更主要的就是因为它足够直观。

简单，包括概念数量上的简单和意义上的简单还有功能上的简单。想用一个权限系统解决所有的权限问题是不现实的。设计中将常常变化的“定制”特点比较强的部分判断为业务逻辑，而将常常相同的“通用”特点比较强的部分判断为权限逻辑就是基于这样的思路。

扩展，采用可继承在扩展上的困难。的 Group 概念在支持权限以组方式定义的同时有效避免了重定义时

现状：

对于在企业环境中的访问控制方法，一般有三种：

1. 自主型访问控制方法。目前在我国的大多数的信息系统中的访问控制模块中基本是借助于自主型访问控制方法中的访问控制列表 (ACLs) 。

2. 强制型访问控制方法。用于多层次安全级别的军事应用。

3. 基于角色的访问控制方法（ RBAC ）。是目前公认的解决大型企业的统一资源访问控制的有效方法。其显著的两大特征是： 1. 减小授权管理的复杂性，降低管理开销。 2. 灵活地支持企业的安全策略，并对企业的变化有很大的伸缩性。

名词：

粗粒度：表示类别级，即仅考虑对象的类别 (the type of object) ，不考虑对象的某个特

定实例。比如，用户管理中，创建、删除，对所有的用户都一视同仁，并不区分操作的具体对象实例。

细粒度：表示实例级，即需要考虑具体对象的实例 (the instance of object) ，当然，细

粒度是在考虑粗粒度的对象类别之后才再考虑特定实例。比如，合同管理中，列表、删除，需要区分该合同实例是否为当前用户所创建。

原则：

权限逻辑配合业务逻辑。即权限系统以为业务逻辑提供服务为目标。相当多细粒度的权限问题因其极其独特而不具通用意义，它们也能被理解为是“业务逻辑”的一部分。比如，要求：“合同资源只能被它的创建者删除，与创建者同组的用户可以修改，所有的用户能够浏览”。这既可以认为是一个细粒度的权限问题，也可以认为是一个业务逻辑问题。在这里它是业务逻辑问题，在整个权限系统的架构设计之中不予过多考虑。当然，权限系统的架构也必须要能支持这样的控制判断。或者说，系统提供足够多但不是完全的控制能力。即，设计原则归结为：“系统只提供粗粒度的权限，细粒度的权限被认为是业务逻辑的职责”。

需要再次强调的是，这里表述的权限系统仅是一个“不完全”的权限系统，即，它不提供所有关于权限的问题的解决方法。它提供一个基础，并解决那些具有“共性”的 ( 或者说粗粒度的 ) 部分。在这个基础之上，根据“业务逻辑”的独特权限需求，编码实现剩余部分 ( 或者说细粒度的 ) 部分，才算完整。回到权限的问题公式，通用的设计仅解决了 Who+What+How 的问题，其他的权限问题留给业务逻辑解决。

概念：

Who ：权限的拥用者或主体（ Principal 、 User 、 Group 、 Role 、 Actor 等等）

What ：权限针对的对象或资源（ Resource 、 Class ）。

How ：具体的权限（ Privilege, 正向授权与负向授权）。

Role ：是角色，拥有一定数量的权限。

Operator ：操作。表明对 What 的 How 操作。

说明：

User ：与 Role 相关，用户仅仅是纯粹的用户，权限是被分离出去了的。 User 是不能与 Privilege 直接相关的， User 要拥有对某种资源的权限，必须通过 Role 去关联。解决 Who 的问题。

Resource ：就是系统的资源，比如部门新闻，文档等各种可以被提供给用户访问的对象。资源可以反向包含自身，即树状结构，每一个资源节点可以与若干指定权限类别相关可定义是否将其权限应用于子节点。

Privilege ：是 Resource Related 的权限。就是指，这个权限是绑定在特定的资源实例上的。比如说部门新闻的发布权限，叫做 “ 部门新闻发布权限 “ 。这就表明，该 Privilege 是一个发布权限，而且是针对部门新闻这种资源的一种发布权限。 Privilege 是由 Creator 在做开发时就确定的。权限，包括系统定义权限和用户自定义权限用户自定义权限之间可以指定排斥和包含关系 ( 如：读取，修改，管理三个权限，管理权限包含前两种权限 ) 。 Privilege 如 “ 删除 ” 是一个抽象的名词，当它不与任何具体的 Object 或 Resource 绑定在一起时是没有任何意义的。拿新闻发布来说，发布是一种权限，但是只说发布它是毫无意义的。因为不知道发布可以操作的对象是什么。只有当发布与新闻结合在一起时，才会产生真正的 Privilege 。这就是 Privilege Instance 。权限系统根据需求的不同可以延伸生很多不同的版本。

Role ：是粗粒度和细粒度 ( 业务逻辑 ) 的接口，一个基于粗粒度控制的权限框架软件，对外的接口应该是 Role ，具体业务实现可以直接继承或拓展丰富 Role 的内容， Role 不是如同 User 或 Group 的具体实体，它是接口概念，抽象的通称。

Group ：用户组，权限分配的单位与载体。权限不考虑分配给特定的用户。组可以包括组 ( 以实现权限的继承 ) 。组可以包含用户，组内用户继承组的权限。 Group 要实现继承。即在创建时必须要指定该 Group 的 Parent 是什么 Group 。在粗粒度控制上，可以认为，只要某用户直接或者间接的属于某个 Group 那么它就具备这个 Group 的所有操作许可。细粒度控制上，在业务逻辑的判断中， User 仅应关注其直接属于的 Group ，用来判断是否“同组” 。 Group 是可继承的，对于一个分级的权限实现，某个 Group 通过“继承”就已经直接获得了其父 Group 所拥有的所有“权限集合”，对这个 Group 而言，需要与权限建立直接关联的，仅是它比起其父 Group 需要“扩展”的那部分权限。子组继承父组的所有权限，规则来得更简单，同时意味着管理更容易。为了更进一步实现权限的继承，最直接的就是在 Group 上引入“父子关系”。

User 与 Group 是多对多的关系。即一个 User 可以属于多个 Group 之中，一个 Group 可以包括多个 User 。子 Group 与父 Group 是多对一的关系。 Operator 某种意义上类似于 Resource + Privilege 概念，但这里的 Resource 仅包括 Resource Type 不表示 Resource Instance 。 Group 可以直接映射组织结构， Role 可以直接映射组织结构中的业务角色，比

较直观，而且也足够灵活。 Role 对系统的贡献实质上就是提供了一个比较粗颗粒的分配单位。

Group 与 Operator 是多对多的关系。各概念的关系图示如下：

解释：

Operator 的定义包括了 Resource Type 和 Method 概念。即， What 和 How 的概念。之所以将 What 和 How 绑定在一起作为一个 Operator 概念而不是分开建模再建立关联，这是因为很多的 How 对于某 What 才有意义。比如，发布操作对新闻对象才有意义，对用户对象则没有意义。

How 本身的意义也有所不同，具体来说，对于每一个 What 可以定义 N 种操作。比如，对于合同这类对象，可以定义创建操作、提交操作、检查冲突操作等。可以认为， How 概念对应于每一个商业方法。其中，与具体用户身份相关的操作既可以定义在操作的业务逻辑之中，也可以定义在操作级别。比如，创建者的浏览视图与普通用户的浏览视图要求内容不同。既可以在外部定义两个操作方法，也可以在一个操作方法的内部根据具体逻辑进行处理。具体应用哪一种方式应依据实际情况进行处理。

这样的架构，应能在易于理解和管理的情况下，满足绝大部分粗粒度权限控制的功能需要。但是除了粗粒度权限，系统中必然还会包括无数对具体 Instance 的细粒度权限。这些问题，被留给业务逻辑来解决，这样的考虑基于以下两点：

一方面，细粒度的权限判断必须要在资源上建模权限分配的支持信息才可能得以实现。比如，如果要求创建者和普通用户看到不同的信息内容，那么，资源本身应该有其创建者的信息。另一方面，细粒度的权限常常具有相当大的业务逻辑相关性。对不同的业务逻辑，常常意味着完全不同的权限判定原则和策略。相比之下，粗粒度的权限更具通用性，将其实现为一个架构，更有重用价值；而将细粒度的权限判断实现为一个架构级别的东西就显得繁琐，而且不是那么的有必要，用定制的代码来实现就更简洁，更灵活。

所以细粒度控制应该在底层解决， Resource 在实例化的时候，必需指定 Owner 和 GroupPrivilege 在对 Resource 进行操作时也必然会确定约束类型：究竟是 OwnerOK 还是 GroupOK 还是 AllOK 。 Group 应和 Role 严格分离 User 和 Group 是多对多的关系， Group 只用于对用户分类，不包含任何 Role 的意义； Role 只授予 User ，而不是 Group 。如果用户需要还没有的多种 Privilege 的组合，必须新增 Role 。 Privilege 必须能够访问 Resource ，同时带 User 参数，这样权限控制就完备了。

思想：

权限系统的核心由以下三部分构成： 1. 创造权限， 2. 分配权限， 3. 使用权限，然后，系统各部分的主要参与者对照如下： 1. 创造权限 - Creator 创造， 2. 分配权限 - Administrator 分配， 3. 使用权限 - User ：

1. Creator 创造 Privilege ， Creator 在设计和实现系统时会划分，一个子系统或称为模块，应该有哪些权限。这里完成的是 Privilege 与 Resource 的对象声明，并没有真正将 Privilege 与具体 Resource 实例联系在一起，形成 Operator 。

2. Administrator 指定 Privilege 与 Resource Instance 的关联。在这一步，权限真正与资源实例联系到了一起，产生了 Operator （ Privilege Instance ）。 Administrator 利用 Operator 这个基本元素，来创造他理想中的权限模型。如，创建角色，创建用户组，给用户组分配用户，将用户组与角色关联等等 … 这些操作都是由 Administrator 来完成的。

3. User 使用 Administrator 分配给的权限去使用各个子系统。 Administrator 是用户，在他的心目中有一个比较适合他管理和维护的权限模型。于是，程序员只要回答一个问题，就是什么权限可以访问什么资源，也就是前面说的 Operator 。程序员提供 Operator 就意味着给系统穿上了盔甲。 Administrator 就可以按照他的意愿来建立他所希望的权限框架可以自行增加，删除，管理 Resource 和 Privilege 之间关系。可以自行设定用户 User 和角色 Role 的对应关系。 ( 如果将 Creator 看作是 Basic 的发明者， Administrator 就是 Basic 的使用者，他可以做一些脚本式的编程 ) Operator 是这个系统中最关键的部分，它是一个纽带，一个系在 Programmer ， Administrator ， User 之间的纽带。

用一个功能模块来举例子。

一．建立角色功能并做分配：

1 ．如果现在要做一个员工管理的模块 ( 即 Resources) ，这个模块有三个功能，分别是：增加，修改，删除。给这三个功能各自分配一个 ID ，这个 ID 叫做功能代号：

Emp_addEmp ， Emp_deleteEmp ， Emp_updateEmp 。

2 ．建立一个角色 (Role) ，把上面的功能代码加到这个角色拥有的权限中，并保存到数据库中。角色包括系统管理员，测试人员等。

3 ．建立一个员工的账号，并把一种或几种角色赋给这个员工。比如说这个员工既可以是公司管理人员，也可以是测试人员等。这样他登录到系统中将会只看到他拥有权限的那些模块。

二．把身份信息加到 Session 中。

登录时，先到数据库中查找是否存在这个员工，如果存在，再根据员工的 sn 查找员工的权限信息，把员工所有的权限信息都入到一个 Hashmap 中，比如就把上面的 Emp_addEmp 等放到这个 Hashmap 中。然后把 Hashmap 保存在一个 UserInfoBean 中。最后把这个 UserInfoBean 放到 Session 中，这样在整个程序的运行过程中，系统随时都可以取得这个用户的身份信息。

三．根据用户的权限做出不同的显示。

可以对比当前员工的权限和给这个菜单分配的“功能 ID ”判断当前用户是否有打开这个菜单的权限。例如：如果保存员工权限的 Hashmap 中没有这三个 ID 的任何一个，那这个菜单就不会显示，如果员工的 Hashmap 中有任何一个 ID ，那这个菜单都会显示。

对于一个新闻系统 (Resouce) ，假设它有这样的功能 (Privilege) ：查看，发布，删除，修改；假设对于删除，有 “ 新闻系统管理者只能删除一月前发布的，而超级管理员可删除所有的这样的限制，这属于业务逻辑 (Business logic) ，而不属于用户权限范围。也就是说权限负责有没有删除的 Permission ，至于能删除哪些内容应该根据 UserRole or UserGroup 来决定 ( 当然给 UserRole or UserGroup 分配权限时就应该包含上面两条业务逻辑 ) 。

一个用户可以拥有多种角色，但同一时刻用户只能用一种角色进入系统。角色的划分方法可以根据实际情况划分，按部门或机构进行划分的，至于角色拥有多少权限，这就看系统管理员赋给他多少的权限了。用户—角色—权限的关键是角色。用户登录时是以用户和角色两种属性进行登录的（因为一个用户可以拥有多种角色，但同一时刻只能扮演一种角色），根据角色得到用户的权限，登录后进行初始化。这其中的技巧是同一时刻某一用户只能用一种角色进行登录。

针对不同的“角色”动态的建立不同的组，每个项目建立一个单独的 Group ，对于新的项目，建立新的 Group 即可。在权限判断部分，应在商业方法上予以控制。比如：不同用户的“操作能力”是不同的 ( 粗粒度的控制应能满足要求 ) ，不同用户的“可视区域”是不同的 ( 体现在对被操作的对象的权限数据，是否允许当前用户访问，这需要对业务数据建模的时候考虑权限控制需要 ) 。

扩展性：

有了用户 / 权限管理的基本框架， Who(User/Group) 的概念是不会经常需要扩展的。变化的可能是系统中引入新的 What ( 新的 Resource 类型 ) 或者新的 How( 新的操作方式 ) 。那在三个基本概念中，仅在 Permission 上进行扩展是不够的。这样的设计中 Permission 实质上解决了 How 的问题，即表示了“怎样”的操作。那么这个“怎样”是在哪一个层次上的定义呢？将 Permission 定义在“商业方法”级别比较合适。比如，发布、购买、取消。每一个商业方法可以意味着用户进行的一个“动作”。定义在商业逻辑的层次上，一方面保证了数据访问代码的“纯洁性”，另一方面在功能上也是“足够”的。也就是说，对更低层次，能自由的访问数据，对更高层次，也能比较精细的控制权限。

确定了 Permission 定义的合适层次，更进一步，能够发现 Permission 实际上还隐含了 What 的概念。也就是说，对于 What 的 How 操作才会是一个完整的 Operator 。比如，“发布”操作，隐含了“信息”的“发布”概念，而对于“商品”而言发布操作是没有意义的。同样的，“购买”操作，隐含了“商品”的“购买”概念。这里的绑定还体现在大量通用的同名的操作上，比如，需要区分“商品的删除”与“信息的删除”这两个同名为“删除”的不同操作。

提供权限系统的扩展能力是在 Operator (Resource + Permission) 的概念上进行扩展。 Proxy 模式是一个非常合适的实现方式。实现大致如下：在业务逻辑层 (EJB Session Facade [Stateful SessionBean] 中 ) ，取得该商业方法的 Methodname ，再根据 Classname 和 Methodname 检索 Operator 数据，然后依据这个 Operator 信息和 Stateful 中保存的 User 信息判断当前用户是否具备该方法的操作权限。

应用在 EJB 模式下，可以定义一个很明确的 Business 层次，而一个 Business 可能意味着不同的视图，当多个视图都对应于一个业务逻辑的时候，比如， Swing Client 以及 Jsp Client 访问的是同一个 EJB 实现的 Business 。在 Business 层上应用权限较能提供集中的控制能力。实际上，如果权限系统提供了查询能力，那么会发现，在视图层次已经可以不去理解权限，它只需要根据查询结果控制界面就可以了。

灵活性 ：

Group 和 Role ，只是一种辅助实现的手段，不是必需的。如果系统的 Role 很多，逐个授权违背了“简单，方便”的目的，那就引入 Group ，将权限相同的 Role 组成一个 Group 进行集中授权。 Role 也一样，是某一类 Operator 的集合，是为了简化针对多个 Operator 的操作。

Role 把具体的用户和组从权限中解放出来。一个用户可以承担不同的角色，从而实现授权的灵活性。当然， Group 也可以实现类似的功能。但实际业务中， Group 划分多以行政组织结构或业务功能划分；如果为了权限管理强行将一个用户加入不同的组，会导致管理的复杂性。

Domain 的应用。为了授权更灵活，可以将 Where 或者 Scope 抽象出来，称之为 Domain ，真正的授权是在 Domain 的范围内进行，具体的 Resource 将分属于不同的 Domain 。比如：一个新闻机构有国内与国外两大分支，两大分支内又都有不同的资源（体育类、生活类、时事政治类）。假如所有国内新闻的权限规则都是一样的，所有国外新闻的权限规则也相同。则可以建立两个域，分别授权，然后只要将各类新闻与不同的域关联，受域上的权限控制，从而使之简化。

权限系统还应该考虑将功能性的授权与资源性的授权分开。很多系统都只有对系统中的数据（资源）的维护有权限控制，但没有对系统功能的权限控制。

权限系统最好是可以分层管理而不是集中管理。大多客户希望不同的部门能且仅能管理其部门内部的事务，而不是什么都需要一个集中的 Administrator 或 Administrators 组来管理。虽然你可以将不同部门的人都加入 Administrators 组，但他们的权限过大，可以管理整个系统资源而不是该部门资源。

正向授权与负向授权：正向授权在开始时假定主体没有任何权限，然后根据需要授予权限，适合于权限要求严格的系统。负向授权在开始时假定主体有所有权限，然后将某些特殊权限收回。

权限计算策略：系统中 User ， Group ， Role 都可以授权，权限可以有正负向之分，在计算用户的净权限时定义一套策略。

系统中应该有一个集中管理权限的 AccessService ，负责权限的维护（业务管理员、安全管理模块）与使用（最终用户、各功能模块），该 AccessService 在实现时要同时考虑一般权限与特殊权限。虽然在具体实现上可以有很多，比如用 Proxy 模式，但应该使这些 Proxy 依赖于 AccessService 。各模块功能中调用 AccessService 来检查是否有相应的权限。所以说，权限管理不是安全管理模块自己一个人的事情，而是与系统各功能模块都有关系。每个功能模块的开发人员都应该熟悉安全管理模块，当然，也要从业务上熟悉本模块的安全规则。

技术实现 ：

1 ．表单式认证，这是常用的，但用户到达一个不被授权访问的资源时， Web 容器就发

出一个 html 页面，要求输入用户名和密码。

2 ．一个基于 Servlet Sign in/Sign out 来集中处理所有的 Request ，缺点是必须由应用程序自己来处理。

3 ．用 Filter 防止用户访问一些未被授权的资源， Filter 会截取所有 Request/Response ，

然后放置一个验证通过的标识在用户的 Session 中，然后 Filter 每次依靠这个标识来决定是否放行 Response 。

这个模式分为：

Gatekeeper ：采取 Filter 或统一 Servlet 的方式。

Authenticator ：在 Web 中使用 JAAS 自己来实现。

用户资格存储 LDAP 或数据库：

1. Gatekeeper 拦截检查每个到达受保护的资源。首先检查这个用户是否有已经创建

好的 Login Session ，如果没有， Gatekeeper 检查是否有一个全局的和 Authenticator 相关的 session ？

2. 如果没有全局的 session ，这个用户被导向到 Authenticator 的 Sign-on 页面，

要求提供用户名和密码。

3. Authenticator 接受用户名和密码，通过用户的资格系统验证用户。

4. 如果验证成功， Authenticator 将创建一个全局 Login session ，并且导向 Gatekeeper

来为这个用户在他的 web 应用中创建一个 Login Session 。

5. Authenticator 和 Gatekeepers 联合分享 Cookie ，或者使用 Tokens 在 Query 字符里。

[zt]RBAC 模型初探

Alex — Thu, 26 Oct 2006 14:43:08 +0000

访问控制背景

访问控制技术是由美国国防部（Department of Defense, DoD）资助的研究和开发成果演变而来的。这一研究导致两种基本类型访问控制的产生：自主访问控制（Discretionary Access Control, DAC）和强制访问控制（Mandatory Access Control, MAC）。最初的研究和应用主要是为了防止机密信息被未经授权者访问，近期的应用主要是把这些策略应用到为商业领域。

自主访问控制，允许把访问控制权的授予和取消留给个体用户来判断。为没有访问控制权的个体用户授予和废除许可。自主访问控制机制允许用户被授权和
取消访问其控制之下的任何客体（object），换句话说，用户就是他们控制下的客体的拥有者。然而，对于多数组织来说，最终用户对所访问的信息没有拥有权。对于这些组织，公司或代理机构是事实上的系统客体和处理他们的程序的拥有者。访问优先权受组织控制，而且也常常基于雇员功能而不是数据所有权。

强制访问控制，在美国国防部 Trusted Computer Security Evaluation Criteria (TCSEC) 中定义如下：“一种限制访问客体的手段，它以包含在这些客体中的信息敏感性和访问这些敏感性信息的主体的正式授权信息（如清除）为基础”。

以上访问控制策略对于处理一些无需保密但又敏感的信息的政府和行业组织的需求并不是特别的适合。在这样的环境下，安全目标支持产生于现有法律、道德规范、规章、或一般惯例的高端组织策略。这些环境通常需要控制个体行为的能力，而不仅仅是如何根据信息的敏感性为其设置标签从而访问这一信息的个人能力。

什么是基于角色访问控制（Role-Based Access Control, RBAC）？NIST 有如下定义。

访问是一种利用计算机资源去做某件事情的的能力，访问控制是一种手段，通过它这种能力在某些情况下被允许或者受限制（通常是通过物理上和基于系统的控制）。基于计算机的访问控制不仅可规定是“谁”或某个操作有权使用特定系统资源，而且也能规定被允许的访问类型。这些控制方式可在计算机系统或者外部设备中实现。

就基于角色访问控制而言，访问决策是基于角色的，个体用户是某个组织的一部分。用户具有指派的角色（比如医生、护士、出纳、经理）。定义角色的过程应该基于对组织运转的彻底分析，应该包括来自一个组织中更广范围用户的输入。

访问权按角色名分组，资源的使用受限于授权给假定关联角色的个体。例如，在一个医院系统中，医生角色可能包括进行诊断、开据处方、指示实验室化验等；而研究员的角色则被限制在收集用于研究的匿名临床信息工作上。

控制访问角色的运用可能是一种开发和加强企业特殊安全策略，进行安全管理过程流程化的有效手段。

用户（User）和角色（Role）

用户指访问系统中的资源的主体，一般为人，也可为 Agent 等智能程序。角色指应用领域内一种权力和责任的语义综合体，可以是一个抽象概念，也可以是对应于实际系统中的特定语义体，比如组织内部的职务等。针对角色属性的不同，某些模型中将角色进一步细分为普通角色和管理员角色（可理解为全局角色）。

许可（Permissions）和权限（Permission）

许可描述了角色对计算机资源的访问和操作所具有的权限，其反映的是授权的结果。比如授予某个角色对计算机资源有读的权限，则代表了一个许可的存在，这个许可表示：角色获取了对计算机资源的读许可。针对操作来说，其描述的是许可和操作之间的一种关联关系，而这层关系则表示了某一角色对某一操作所具有的权限及权限状态。

角色和指派（Assignment）

指派包含两个方面，用户指派和许可指派。用户指派表示的是，将用户指派给特定的角色。许可指派表示的是为角色指派计算机资源的访问和操作许可。

会话（session）

会话表示的是用户和角色之间的关系。用户每次必须通过建立会话来激活角色，得到相应的访问权限。

角色和角色等级（Role Hierarchies）

角色本身仅仅只是一个名词，其本身并不能代表权限的大小。比如，我们可以定一个“Director”的角色，也可以定一个“Project Leader”的角色。对于现实中我们来说，看到这样两个角色，就清楚 DIR 的权限要比一个 PL 的权限级别高。但是对计算机来说，这两个角色仅仅是两个“词语”，是等同的。可以采用分等级角色，在角色上实现层次化来解决这些问题。也可以采用复合角色（其表示的就是一个角色组的概念），对角色实现一定的分组和复合，以便于权限指派。在一些 OA 产品中经常出现分等级角色。

限制（Constraints）

模型中的职责分离关系（Separation of Duty），用于控制冲突（Conflict）。静态职责分离（Static SD）指定角色的互斥关系，用于用户指派阶段。避免同一用户拥有互斥的角色。实现简单，角色互斥语义关系清楚，便于管理不够灵活，不能处理某些实际情况。动态职责分离（Dynamic SD）指定角色的互斥关系，用于角色激活阶段。允许同一用户拥有某些互斥的角色，但是不允许该用户同时激活互斥的角色。更灵活，直接与会话挂钩，适应实际管理需要，实现复杂，不易管理。

参考文献

《AN INTRODUCTION TO ROLE-BASED ACCESS CONTROL》 NIST《工作流授权控制模型》胡长城

《基于角色的权限管理综述》俞诗鹏

最后，感谢宏云博士对本文翻译提供的指导。

请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://www.blogjava.net/rosen

No related posts.

谈谈 Facade与Proxy的联系与区别

Alex — Tue, 10 Oct 2006 03:40:17 +0000

key words: 门面与代理,设计模式

这两组内容没有联系，只是今天在路上的时候突然一下子想到了，就放在一起说说吧

Facade与proxy大多数人应该很熟悉，也接触了不少，但是放在一起比较问他们有什么具体区别的时候好像一下子也说得很含糊。
Facade 意为门面，proxy意为代理,中文的解释也很通俗，但是有时候感觉Facade也有代理的味道，有人认为二者都属于proxy这个大概念，但是问题是他们总得有不同的用途吧，否则发明这两个词岂不是浪费?

google了一些说法，下面这个说法比较到位:

Facade: 用于隐藏调用的复杂性
proxy: 放在服务期端保护被访问的对象

我个人的理解是:
对于客户端掉用来说，Facade是一定可见的，proxy是不可见的 .

比如，一个报刊亭卖报纸，可能有人民日报，新华日报等多家送报纸给他们的人，但是我们直接到他的店面就可以取到我们想要的报纸，而不是买人民日报的时候到人民日报社去取，以此类推.
而proxy对我们是隐藏的，比如Jive论坛里的权限验证，我们发帖子的时候客户端是透明访问的，压根实际在服务端后台作了isAdmin和isGuest的判断

Facade仅仅是提供了你一个方便的 “门面”,你可以把它理解为超市，你只要到他那里就可以取到你想要的东西，但是他所调用的后台仍然可以根据策略开放给客户端，比如我们完全可以不去报刊亭买报纸，我们自己去人民日报社去取，但是这种做法显然在如今的现代化潮流下是没什么提倡的，现在更提倡分工.

对于proxy我们仍有一个误解，比如问你”中介公司是proxy吗？” 请思考一下

很多人认为中介公司是代理，因为我们生活中有时候就直接称中介公司为代理商或代理公司等，但是此代理非彼代理也! 为什么？参照我们上面所说的proxy的特征，proxy是隐藏的，难道我们联系代理公司的地址时他会说 : “打一枪换一个地方” 么? 显然不是，恰恰相反，中介公司事实上反而是我们java里的Facade模式,因为它是可见的.

好，关于facade 与proxy就说到这里，应该很清楚了.

No related posts.

关于Facade的应用

Alex — Mon, 09 Oct 2006 03:41:13 +0000

Facade用的非常的广了，以前刚接触的时候有个误解，总觉得Facade是简单的，而它后面的支撑服务是复杂的，对于客户来说却是简单的，现在来看，不完全对，或者说只是说对了一半，因为有时候恰恰是Facade是复杂的.

我们举一个例子，比如发送短信，我们一般就定义一个MessageService的服务类，里面只提供一个方法就行了，sendToUser(String phone,String content)
但是到了客户端的时候有了自己的 “方言”,比如它不是关心一个抽象的用户，它只知道向教师发送短信，或者向学生发送短信，或者向家长发送短信。

示例如下:

由图中可以看到，Facade的内容非常丰富，而支撑它的服务类却很简单，在开发过程中我们一般先实现通用的ServiceA,然后根据进一步的需求做一个面向具体复杂的Facade.

在Spring提供的sample里发现一个小技巧，就是Facade和ServiceA都是接口，然后提供一个实现二者的支撑类:

public class PetStoreAnnotationImpl implements PetStoreFacade, OrderService {

private AccountDao accountDao;

private CategoryDao categoryDao;

private ProductDao productDao;

private ItemDao itemDao;

private OrderDao orderDao;

//————————————————————————-
// Setter methods for dependency injection
//————————————————————————-

public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}

public void setCategoryDao(CategoryDao categoryDao) {
this.categoryDao = categoryDao;
}

public void setProductDao(ProductDao productDao) {
this.productDao = productDao;
}

public void setItemDao(ItemDao itemDao) {
this.itemDao = itemDao;
}

public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}

//————————————————————————-
// Operation methods, implementing the PetStoreFacade interface
//————————————————————————-

public Account getAccount(String username) {
return this.accountDao.getAccount(username);
}

public Account getAccount(String username, String password) {
return this.accountDao.getAccount(username, password);
}

public void insertAccount(Account account) {
this.accountDao.insertAccount(account);
}

public void updateAccount(Account account) {
this.accountDao.updateAccount(account);
}

public List getUsernameList() {
return this.accountDao.getUsernameList();
}

public List getCategoryList() {
return this.categoryDao.getCategoryList();
}

public Category getCategory(String categoryId) {
return this.categoryDao.getCategory(categoryId);
}

public List getProductListByCategory(String categoryId) {
return this.productDao.getProductListByCategory(categoryId);
}

public List searchProductList(String keywords) {
return this.productDao.searchProductList(keywords);
}

public Product getProduct(String productId) {
return this.productDao.getProduct(productId);
}

public List getItemListByProduct(String productId) {
return this.itemDao.getItemListByProduct(productId);
}

public Item getItem(String itemId) {
return this.itemDao.getItem(itemId);
}

public boolean isItemInStock(String itemId) {
return this.itemDao.isItemInStock(itemId);
}

public void insertOrder(Order order) {
this.orderDao.insertOrder(order);
this.itemDao.updateQuantity(order);
}

public Order getOrder(int orderId) {
return this.orderDao.getOrder(orderId);
}

public List getOrdersByUsername(String username) {
return this.orderDao.getOrdersByUsername(username);
}

}

看起来似乎不错，不过仔细想想个人认为还是不是太好,总的感觉就是层次不清晰，因为很多时候Facade和Service之间是被服务与服务的关系，所以理当分开。同时，这个类有点倾向于”万能类”了，能分还是分开好.这和我们以前提到的dao又背离过来了（以前我们提倡一个业务一个dao,现在觉得只用一个通用的dao更合适）,这个并不矛盾，具体问题具体看待.

欢迎各位拍砖.

[zt]设计模式之Visitor 访问者模式

Alex — Thu, 28 Sep 2006 03:44:31 +0000

设计模式之Visitor

板桥里人 http://www.jdon.com 2002/05/05（转载请保留）

模式实战书籍《Java实用系统开发指南》

Visitor访问者模式定义
作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作.

在Java中,Visitor模式实际上是分离了collection结构中的元素和对这些元素进行操作的行为.

为何使用Visitor?
Java的Collection(包括Vector和Hashtable)是我们最经常使用的技术,可是Collection好象是个黑色大染缸,本来有各种鲜明类型特征的对象一旦放入后,再取出时,这些类型就消失了.那么我们势必要用If来判断,如:
Iterator iterator = collection.iterator()
while (iterator.hasNext()) {
Object o = iterator.next();
if (o instanceof Collection)
messyPrintCollection((Collection)o);
else if (o instanceof String)
System.out.println(“‘”+o.toString()+”‘”);
else if (o instanceof Float)
System.out.println(o.toString()+”f”);
else
System.out.println(o.toString());
}
在上例中,我们使用了 instanceof来判断 o的类型.

很显然,这样做的缺点代码If else if 很繁琐.我们就可以使用Visitor模式解决它.

如何使用Visitor?
针对上例,定义接口叫Visitable,用来定义一个Accept操作,也就是说让Collection每个元素具备可访问性.

被访问者是我们Collection的每个元素Element,我们要为这些Element定义一个可以接受访问的接口(访问和被访问是互动的,只有访问者,被访问者如果表示不欢迎,访问者就不能访问),取名为Visitable，也可取名为Element。

public interface Visitable
{
public void accept(Visitor visitor);
}

被访问的具体元素继承这个新的接口Visitable：

public class StringElement implements Visitable
{
private String value;
public StringElement(String string) {
value = string;
}

public String getValue(){
return value;
}
//定义accept的具体内容这里是很简单的一句调用
public void accept(Visitor visitor) {
visitor.visitString(this);
}
}

上面是被访问者是字符串类型，下面再建立一个Float类型的：

public class FloatElement implements Visitable
{
private Float value;
public FloatElement(Float value) {
this.value = value;
}

public Float getValue(){
return value;
}
//定义accept的具体内容这里是很简单的一句调用
public void accept(Visitor visitor) {
visitor.visitFloat(this);
}
}

我们设计一个接口visitor访问者，在这个接口中,有一些访问操作，这些访问操作是专门访问对象集合Collection中有可能的所有类，目前我们假定有三个行为：访问对象集合中的字符串类型；访问对象集合中的Float类型；访问对象集合中的对象集合类型。注意最后一个类型是集合嵌套，通过这个嵌套实现可以看出使用访问模式的一个优点。

接口visitor访问者如下：

public interface Visitor
{

public void visitString(StringElement stringE);
public void visitFloat(FloatElement floatE);
public void visitCollection(Collection collection);

}

访问者的实现:

public class ConcreteVisitor implements Visitor
{
//在本方法中,我们实现了对Collection的元素的成功访问
public void visitCollection(Collection collection) {
Iterator iterator = collection.iterator()
while (iterator.hasNext()) {
Object o = iterator.next();
if (o instanceof Visitable)
((Visitable)o).accept(this);
}
｝

public void visitString(StringElement stringE) {
System.out.println(“‘”+stringE.getValue()+”‘”);
}
public void visitFloat(FloatElement floatE){
System.out.println(floatE.getValue().toString()+”f”);
}

}

在上面的visitCollection我们实现了对Collection每个元素访问,只使用了一个判断语句,只要判断其是否可以访问.

StringElement只是一个实现，可以拓展为更多的实现，整个核心奥妙在accept方法中，在遍历Collection时，通过相应的accept方法调用具体类型的被访问者。这一步确定了被访问者类型，

如果是StringElement，而StringElement则回调访问者的visiteString方法，这一步实现了行为操作方法。

客户端代码：

Visitor visitor = new ConcreteVisitor();

StringElement stringE = new StringElement(“I am a String”);
visitor.visitString(stringE);

Collection list = new ArrayList();
list.add(new StringElement(“I am a String1″));
list.add(new StringElement(“I am a String2″));
list.add(new FloatElement(new Float(12)));
list.add(new StringElement(“I am a String3″));
visitor.visitCollection(list);

客户端代码中的list对象集合中放置了多种数据类型，对对象集合中的访问不必象一开始那样，使用instance of逐个判断，而是通过访问者模式巧妙实现了。

至此,我们完成了Visitor模式基本结构.

使用Visitor模式的前提
使用访问者模式是对象群结构中(Collection) 中的对象类型很少改变。

在两个接口Visitor和Visitable中,确保Visitable很少变化,也就是说，确保不能老有新的Element元素类型加进来，可以变化的是访问者行为或操作，也就是Visitor的不同子类可以有多种,这样使用访问者模式最方便.

如果对象集合中的对象集合经常有变化, 那么不但Visitor实现要变化，Visistable也要增加相应行为，GOF建议是,不如在这些对象类中直接逐个定义操作，无需使用访问者设计模式。

但是在Java中，Java的Reflect技术解决了这个问题，因此结合reflect反射机制，可以使得访问者模式适用范围更广了。

Reflect技术是在运行期间动态获取对象类型和方法的一种技术,具体实现参考Javaworld的英文原文.

DAO模式演变

Alex — Thu, 21 Sep 2006 03:49:37 +0000

key words: DAO模式

今天在看一篇文章时提到了DAO，这个东西以前也经常接触，突然想回顾一下，于是打开Appfuse里看看dao模式（记忆中appfuse里就是很多的dao）

截图如下:

很清楚，左边的部分是基础模块，原意是想让右边的DAO和实现能够重用左边的，可是我找了半天也没看到需要重用左边的东西，因为在client调用的所有方法中都是明确的getUser或removeUser,就是没有getObject或者removeObject,那么不禁要问，左边的基础dao和它的实现还有什么意义呢？所以我的第一想法就是把左边的去掉得了，还好，果然有支持我想法的做法，打开springside,我们看到如下的结构:
截图2

这里的做法更厉害，连interface也不要了，不过效果确实是很简洁，在bookmanager里完全重用了左边的基本方法：

public Book get(Integer id) {
return (Book) super.get(id);
}

public void save(Book book) {
super.save(book);
logger.info(“保存图书.图书详情:“ + book.toString());
}

public void remove(Integer id) {
super.remove(id);
logger.info(“删除图书.图书ID:“ + id);
}
这是一个更务实的做法，如果你的项目并不是那么那么的复杂完全可以这么做，当然要说其有什么缺点显然和没有了interface的天生属性决定了的，不可强求，若你对测试隔离面向接口以及你能想到的所有关于interface的好处，那就用你自己的方式吧。

现在我在想一个问题，难道appfuse里的继承的基本关于object的做法就没有地方可用了么？

其时正好碰到java视线这一篇文章有点相关，你可以参考一下:
用DAO模式有什么好处？

ps:
以前是一个基本的dao,然后n个业务dao继承于这个基本dao,现在提供一个通用dao,每个要用到的地方直接继承用就是了，更务实了!
不过，有一个小小的瑕疵，就是对于service中类似getUserByName或者getPeopleByEmail方法中需要提供给dao一个sql语句，从mvc的角度看，在service中看到了db层，有点不雅，不过综合来看这个还是可以或略，不要专牛角尖嘛

[zt]Java 学习方法浅谈

Alex — Wed, 20 Sep 2006 03:59:07 +0000

转自 robin

Java本身是一种设计的非常简单，非常精巧的语言，所以Java背后的原理也很简单，归结起来就是两点：

1、JVM的内存管理

理解了这一点，所有和对象相关的问题统统都能解决

2、JVM Class Loader

理解了这一点，所有和Java相关的配置问题，包括各种App Server的配置，应用的发布问题统统都能解决

就像张无忌学太极剑，本质就是一圈一圈的画圆，你要是懂得了太极剑的本质，那么太极剑就那么一招而已，本身是很容易学的，只是难度在于你要能够举一反三，化一式剑意为无穷无尽的剑招，这就需要一点悟性和不断的实践了；反过来说，如果学剑不学本质，光学剑招，你就是学会了1万招，碰到了第1万零1招，还是不会招架，败下阵来。

技术世界本来就是丰富多彩，企图统一标准，实际上也做不到，但是世界本质其实并不复杂。学习技术，特别是某种具体的软件工具的时候，应该学会迅速把握事物的本质，不要过多搅缠细节。软件工具应该为我所用，而不是我被工具所驾驭。当你具备了对整个J2EE架构的设计和实施的能力，你还会被具体的工具束缚吗？哪种工具适合你的架构，你就用什么，哪种不适合你，你就抛弃它，软件皆臣服于你的脚下，而不是你被什么软件牵着鼻子走，到了这种程度，你难道还害怕学习什么新的软件？

我自己也在一直朝着这个方向努力，在我心中，设计软件，架构是第一位的，采用什么技术要为架构服务。如果我发现什么技术对我的架构来说很重要，那么我会花时间去学习，去钻研，就像我花时间去钻研ORM一样，如果我觉得什么技术对我的架构来说没有用，即使技术再火爆，我也不去碰它。

总之要学会抓住本质，驾驭技术，而不是被技术所驾驭。当你掌握了本质原理，其实学什么都很快，毕竟都是相通的，我先看JDO，后看 Hibernate，其实两者就很类似，所以学得很快，以后如果有工作需要，要我学习别的ORM，那我也不会觉得有什么困难的，一样手到拿来。

更有说服力的是Unix类的操作系统，那就更相似了，只要抓住了Unix最本质的几点，例如shell命令和编程，文件系统结构和配置，系统启动原理和过程，所有的Unix都是无师自通的。我自己会用Linux，FreeBSD，SCO Unix， Solaris，HP-UX 和 AIX等6种Unix，更体会到一通百通的道理。

拿刚出了光明顶密道的张无忌来说吧，(我很喜欢张无忌这个角色)，他也没有练过什么武功，但是他已经把天下武学之本质：九阳神功 + 乾坤大挪移学会了，所以不管什么功夫，他都是看一遍就会，马上为我所用，看了空性用了一遍龙爪手，就会用龙爪手来破对方；和昆仑派打了一架，就会用昆仑剑法和灭绝师太过招；七伤拳更是无师自通；太极拳也是看一遍就会。

总之，学习方法还是很重要，别被五花八门的技术给搞不清学习方向了。

No related posts.

Oracle分页的一个问题

Alex — Wed, 20 Sep 2006 03:57:25 +0000

key words :Oracle分页视图

google了一下关于Oracle的分页方法，方法还不少，大多数效果差不多-有点恶心. 恶心也要作，不过后来就是大家都用得这种方式在我这里出现了新问题，奇怪的是怎么没有别人碰到?

String condition = “ teacher_id = “ + userId + “ and school_id=“+siteId;
sql =
“ select * “ +
“ from your_table where “ + condition +
“ and rowid not in ( select rowid from your_table where“ + condition +
“ and rownum <= “ + (pageIndex - 1) * Constants.PAGE_NUMS + “order by id desc) “ +
“ and rownum <= “ + Constants.PAGE_NUMS + ” order by id desc“;
这个sql有问题么?
答案是可能有问题，也可能没有问题，因为据说在8i的Oracle版本之前都不行，实际上也不尽然，在我的9i和10g我得到的是同样的错误 “missing right parenthesis“,还有一位兄弟估计是DBA建议我去metalink打一个patch,埃，动作太大了，不敢动。

问题还是要解决，试了下类似于select a.*,rownum r from (select * from table where …) a where rownum < 10 等的方法，效果一样，就是不能加嵌套的order by
最后，用视图的方法间接解决问题，因为我要解决的问题实际就是按某个字段排序，那么在视图里先对table进行排序，再在视图的基础上作操作就OK了.

另，还有一种不错的实现方法，即用OracleCachedRowSet,分页也比较简单，有点类似于hibernate,由于时间关系没有时间去看，感兴趣的朋友可以看一下.

BTW: 对于视图可能rowid有问题，可以改成视图的某个主键替换

String condition = “ teacher_id = “ + userId + “ and school_id=“+siteId;
sql =
    “ select * “ +
    “ from your_table where “ + condition +
    “ and id not in ( select id from your_table where“ + condition +
    “ and rownum <= “ + (pageIndex - 1) * Constants.PAGE_NUMS + “order by id desc) “ +
    “ and rownum <= “ + Constants.PAGE_NUMS + “ order by id desc“;

[zt]领域相关的模型里面需要3种对象

Alex — Tue, 19 Sep 2006 04:00:13 +0000

key words : 模型，vo,po

转自portian

基本上一个应用程序里面的领域相关的模型里面需要3种对象：
1。值对象(Value Object)，没有身份，内容表示一切，譬如我和weihello都去银行里面存取100大洋，那这个100RMB是一个值对象

2。实体对象（Entity)，需要持久，不是按照内容，而是按照它的身份来区分，也就是说即使内容完全一样，也不是同一个对象。这个身份在内存里面是它的实例地址，在数据库里面是关键字，最常见的就是OID.这个实体对象并不是纯数据，它处理本身的实体模型，例如Accout，它的 withDraw,它的子Account等等，它也处理自己和其他实体对象之间的关系，例如订单里面的订单行，都是应该在这个Account里面实现的，而不应该有一个什么控制类。在一个Web应用程序里面，涉及到对象关系的一般只需要一个（或几个）DTOFactory负责所有对象的DTO和 Entity之间的组装和拆份，不需要专门的管理，这一部分也是和数据建模最相近的地方。

3。服务对象(Service)，这是为我们提供服务的类，譬如银行里面服务员，她帮助我们把钱从一个账户转到另外一个账户，并记录相应的交易。

对象的作用是对它自己的内部状态负责，如果它需要存取很多其它对象的状态进行运算，那叫做特性忌妒，是要重构的。应该把这些代码移到那个持有这些状态的类里面

辨别一些名词：
1。VO：实际上很模糊，通常指ValueObject和ViewObject
2. ViewObject，界面展现需要的对象，如Struts的FormBean
3。Value Object，早期被作为ValueObject和Transfer Object的总称。实际上Value Object的真正意义在于它的内容，而不是身份
4。Transfer Object：数据传输对象，在应用程序不同层次之间传书对象，在一个分布式应用程序中，通常可以提高整体的性能
5。PO：也许就是Persistent Object，基本上就是Entity了
在不同的体系结构和实现方式里面，这些对象有可能重复，也有可能不重叠。如果你要做一个对所有的体系都能够方便移植的框架，那么每一种对象都需要严格区分。例如JDO的PO不能作为TO，应为它不能脱离PM，譬如你可以选择用ViewObject（如Struts的FOrmBean)直接作为 TO，但在tapestry和Webwork里面就不合适了。但在很多时候，能够方便实用是最重要的，不要过度设计就是了。

No related posts.

[zt]关于Cookie跨域操作遇到的问题及解决方法

Alex — Mon, 18 Sep 2006 04:03:50 +0000

注:关于跨域登陆cookie的问题在网上搜索了一下，没看到有java下的示例，这个asp的也可以参照一下，有空再在java下测一下.

key words:单点登陆 SSO 跨域cookie

摘要：当你有一个Cookie组（或叫Cookie字典）使用Domain属性指定域名之后，当你在对该组的成员进行修改或新增的时候，一定要在操作之后加上Resonse.Cookies(CookieName).Domain属性。如果没有必要，请不要修改已设置Domain的Cookie组.
关键字：
正文：
Cookie跨域操作看来是个简单的问题,因为只要指定Domain属性为指定网站的根域名就可以了.但是笔者在实际使用过程中却遇到了一些问题，的确值得注意.

cookie在www主域名下创建，并写入Domain属性，

如：(为方便调试以下代码皆为asp代码) 　　Write.asp <%
Response.Cookies(CookieName)(“UserName”) = ”SunBird”
Response.Cookies(CookieName)(“Password”) = ”xyz1234″
Response.Cookies(CookieName).Domain = ”xxxx.com”
%> 　　上面文件放在www主域名下，同时在同目录下放置一个读取cookie的Read.asp 　　Read.asp <%
Response.Write Request.Cookies(CookieName)(“UserName”)
Response.Write Request.Cookies(CookieName)(“Password”)
%> 　　再放一个Read.asp文件到另外一个子域名站点里，代码同上。最后我们再做一个清除cookie的Clear.asp放在主域名下　　Clear.asp <%
Response.Cookies(CookieName)(“UserName”) = ”"
Response.Cookies(CookieName)(“Password”) = ”"
Response.Cookies(CookieName).Domain = ”xxxx.com”
%> 　　

现在可以通过下面的执行顺序来测试，Write.asp–>主域名的Read.asp–>子域名的Read.asp 所有 Read.asp页面都可以读取到Write.asp创建的cookie的值，然后再运行Clear.asp进行清除，一切都Ok，看上去没有什么问题。　　但是把这种方法运用到实际的站点时却出现问题了。　　问题描述：　　第一次登录一切ok，所有子域名都可以访问到主域名存储的cookie，但是，一旦退出之后，子域名的cookie被清除了，但是主域名的 cookie仍然保留着，强行清除主域名的cookie之后，无论怎样登录主域名下都无法保存cookie了，除非关掉浏览器重新打开。　　经过多次尝试之后，无意中发现问题所在，以下是测试经过。　　创建一个Write2.asp的页面放在主域名下 <%
Response.Cookies(CookieName)(“TEST_COOKIE”) = ”TEST_COOKIE”
%> 　　

第一步：关闭浏览器后，按以下顺序执行，Write.asp–>主域名的Read.asp–>子域名的Read.asp 到这里所有Read.asp读取正常。　　

第二步：Clear.asp–>主域名的Read.asp–>子域名的Read.asp 到这里清除操作是成功的。第三步：Write.asp–> Write2.asp –> 主域名Read.asp –> 子域名Read.asp 到这里两个Read.asp都可以读取到cookie的值。　　

第四步：重新执行第二步，发现主域名Read.asp仍然输出了值，而子域名下的Read.asp的值已经被清空了。　　根据以上测试总结以下几点再跨域使用cookie时需要注意的地方　　1、当你有一个Cookie组（或叫Cookie字典）使用Domain属性指定域名之后，当你在对该组的成员进行修改或新增的时候，一定要在操作之后加上Resonse.Cookies(CookieName).Domain属性。

2、如果没有必要，请不要修改已设置Domain的Cookie组，直接使用Response.Cookies(“CookieText”) = CookieValue 来创建一个新的Cookie。

[zt]做设计的步骤

Alex — Sat, 16 Sep 2006 04:02:07 +0000

key words: 如何做设计设计步骤
转自robin

一。需求分析(抽象Use case + 分析Use case之间的关系)

分析软件需求，以用户的角度来使用软件，找出发生的scenerio，抽象成为一个一个Use Case，分析出Use Case之间的关系，这一步是非常重要的，这一步做好了，设计就成功了一半。Use Case的抽象有一些可以遵循的原则，这里不详细谈。

然后用语言描述每一个Use Case，描述用户使用一个Use Case发生的主事件流以及异常流。

这样就完成了需求分析阶段。

二。概要设计(找出实体 + 分析实体类之间的关系 + 提取控制类 + 画序列图)

接下来做概要设计，针对每个Use Case，读Use Case的描述，看事件流，找出所有的实体类，这也有一些可以遵循的原则，例如找出所有的名词，画表格排除等等方法。

然后分析实体类之间的关系，是包含，聚合还是依赖，是1：1，还是1：n，还是其他….，根据这些关系，就可以得出实体类和别的实体类想关联的属性，然后再找出每个实体类本身重要的属性。

然后再次分析Use Case的事件流，一方面check实体类的设计是否合理，另一方面你可以找出动词，分析对实体类的控制逻辑，这样就可以可以设计出业务控制类，一般你可以一个实体类一个控制类，也可以业务逻辑相关的实体类由一个Facade Session Bean(非EJB含义)来统一控制，这里面的控制类的颗粒度就由你自己来掌握了。一般来说先可以设计一些细颗粒度的控制类，然后再按照模块，用粗粒度封装细颗粒度的控制类，提供给Web层一个Facade。

然后你可以画序列图，就是用序列图来表达事件流，在这个过程中，你需要不断回到类图，给控制类添加方法，而序列图就是控制类的方法调用。

至此，你已经在Rose里面完成了概要设计，当然你不可能一次设计完善，会有很多次迭代，因此你不能一开始把类设计的太详细，只抓住主要的属性和方法，特别需要注意的是，是抽象的设计，不要用具体的编程语言来表达类。

三。实施(结合xdoclet和Schema工具自动生成代码)

然后你就可以抛开Rose了，转到Eclipse+Togehter里面，根据那些类，规划一下package层次，然后在Together里面进行类的详细设计，所有需要的属性一一写上，当然你还是不可能一下把所有的属性方法写全，不过没有关系，把重要的写好就行了。

然后类框架已经生成好了，给所有的实体类加上xdoclet，然后生成hbm，然后用Hibernate的ExportScheme生成DDL，运行一遍自动创建好所有的表。这样所有的实体相关类全部做好了。

你现在就集中精力把控制类那些方法里面的代码填写上就OK了，在这个过程，你会发现有些实体类缺属性，没有关系，加上属性，然后写好xdoclet，运行一遍，自动生成hbm，自动创建好表，然后继续写你的方法，也有可能你发现控制类缺方法，那么就加上。

基本上实体类就是getter/setter，和少量的实体相关方法，所有的控制逻辑都写在控制类里面。

最后你的软件就基本写好了，用Eclipse生成好一堆你的testCase运行测试，反复修改，除bug。

看看使用OOAD的设计思路，是多么的爽的事情阿！你只需要把精力放到Use Case的抽象，实体类的关系总结，控制类的归纳。而当你使用Eclipse＋Together之后，你所需要写的代码只不过是控制类的方法实现代码，其他的都已经生成好了。另外可能需要写少量工具类。

No related posts.

[zt]从工作流状态机实践中总结状态模式使用心得

Alex — Sat, 09 Sep 2006 04:08:21 +0000

从工作流状态机实践中总结状态模式使用心得

banq http://www.jdon.com Dec 7, 2003 12:10 AM 回复

状态模式好像是很简单的模式，正因为状态好像是个简单的对象，想复杂化实现设计模式就不是容易，误用情况很多。

我个人曾经设计过一个大型游戏系统的游戏状态机，游戏状态可以说是游戏设计的主要架构，但是由于系统过分复杂
和时间仓促，并没有真正实现状态模式。

目前在实现一个电子政务项目中，需要进行流程状态变化，在电子政务设计中，我发现，如果一开始完全按照工作流
规范开发，难度很大，它和具体项目实践结合无法把握，而且工作流规范现在有wfmc，还有bpml，选择也比较难。因
此，我决定走自创的中间道路。

因为，我需要做一个状态机API，或者说状态机框架，供具体系统调用：类如公文流转应用或信息发报送应用等。

好的状态模式必须做到两点：
1. 状态变化必须从外界其它逻辑划分出来。
2. 状态必须可方便拓展，对其它代码影响非常小。

要做到这两点，必须先明确状态变化机制，状态变化实际是由Event事件驱动的，可以认为是Event-condition-State，
在MVC模式一般是Event-condition-Action实现。状态模式需要封装的是Event-condition-State中的condition-State
部分。

清晰理解状态和流程的关系也非常重要，因为状态不是孤立的，可以说和流程是点和线的关系，状态从一个方面说明
了流程，流程是随时间而改变，状态是截取流程某个时间片。因此，必须明白使用状态模式实现状态机实际是为了更
好地表达和说明流程。

状态和流程以及事件的关系如下：

|Event
___currentState__|______newState___

图中表示了是事件改变了流程的状态，在业务逻辑中，经常发生的是事件，如果不使用状态模式，需要在很多业务逻
辑处实现事件到状态判定和转换，这有很多危险性。

最大的危险是系统没有一个一抓就灵的主体结构，以那个游戏系统为例，在没有状态模式对状态提炼的情况下，状态
改变由每个程序员想当然实现，导致每个程序员开发的功能在整合时就无法调试，因为这个程序员可能不知道那个程
序员的代码在什么运行条件下改变了游戏状态，结果导致自己的代码无法运行。

这种现象实际上拒绝了项目管理的协作性，大大地拖延项目进度（程序员之间要反复商量讨论对方代码设计）。从这
一点也说明，一个好的架构设计是一个项目快速成功完成的基础技术保证，没有这个技术基础，再先进的项目管理手
段也是没有效率的，或者是笨拙的。

状态模式对于很多系统来说，确实是架构组成一个重要部分。

下面继续讨论如何实现一个好的状态模式，为了实现好的状态模式，必须在状态模式中封装下面两个部分：
1. 状态转换规则（行为）
2. 状态属性（属性）

状态转换行为有两种划分标准：
1. run和next两个行为，run是当前状态运行行为，next是指在Event参与下，几种可能转向的下一个状态。
2. stateEnter和stateExit，状态进入和状态退出。

如果用进入一个个房间来表示状态流程的话，第一种分析是只重视着“在房间里”和“如何转入下一个房间”，这两种行
为一旦确定，可以被反复使用，进而一个流程的状态切换可以全部表达出来。

第二中分析方法有所区别，只重视进入房间和离开房间这个两个行为，同样，这种模型也可以被反复利用在其它房间，
一个流程的状态切换也可以全部表达出来。

具体选择取决于你的需求，比如，如果你在进入一个状态开始，要做很多初始化工作，那么第二种模型就很适合。

状态变化都离不开一个主体对象，主体对象可以说包含状态变化（行为）和状态属性（属性），假设为StateOwner，
StateOwner有两个部分组成：Task/事情和状态。任何一个Task/事情都会对应一个状态。

这样，我们已经抽象出两个主要对象：状态State和StateOwner。

为了封装状态变化细节，我们可以抽象出一个状态机StateMachine来专门实现状态根据事情实现转换。

这样，客户端外界通过状态机可访问状态模式这个匣子。在实践中，外界客户端需要和状态机实现数据交换，我们把
它也分为两种：属性和行为。

其中属性可能需要外界告诉状态状态变化的主体对象Task，解决状态的主人问题，是谁的问题；行为可能是需要持久
化当前这个主体对象的状态到数据库。

这两种数据交换可以分别通过StateOwner和StateMachine与整个状态机实现数据交换，这样，具体状态和状态切换也
和外界实现了解耦隔离。

因此好的状态模式实现必须有下列步骤：
（1）将每个状态变成State的子类，实现每个状态对象化。
（2）在每个状态中，封装着进入下一个状态可能规则，这些规则是状态变化的核心，换句话说，统一了状态转换的规则。
具体可采取run和next这样的转换行为。

下面是一个子状态代码：

publicclass Running extends StateT{

//
publicvoid run(StateOwner stateOwner){
stateOwner.setCurrentState(this);
}

//转换到下一个状态的规则
//当前是Running状态，下一个状态可能是暂停、结束或者强制退出等
//状态，但是绝对不会是Not_Started这样的状态
//转换规则在这里得到了体现。
public State next(Event e) {
if(transitions == null){
addEventState(new EventImp(“PAUSE”), new Suspended());
addEventState(new EventImp(“END”), new Completed());
addEventState(new EventImp(“STOP”), new Aborted());
}
returnsuper.next(e);
}

}

外界直接调用 StateMachine的关键方法transition；实行状态的自动转变。

publicclass StateMachine {

/**
* 状态切换
* 根据Event参数，运行相应的状态。
* 1. 获得当前状态
* 2. 使用当前状态的next()转换
* |Event
* ___currentState__|______newState___
*
* @param inputs
*/
publicfinalvoid transition(String taskid, Event e) throws Exception {
State currentState = readCurrentState(taskid); //从数据库获得当前状态
StateOwner stateOwner = new StateOwner(taskid, currentState);
//转换状态
currentState = currentState.next(e);
if (currentState != null) {
currentState.run(stateOwner);
saveCurrentState(stateOwner); //保存当前状态
}
}

}

No related posts.

web开发的瑞士军刀 javawebparts

Alex — Fri, 08 Sep 2006 04:09:20 +0000

引言:最近在看一个开源的聊天室AjaxChat 时看到一个被引用的包:javawebparts,处于好奇去看了一下，突然发现这么好的一个常用web组件不去用实在是太可惜了，下面逐一介绍，详细文档大家可以去官方文档看看，最好看它的Demo,很直观。

javawebparts的口号是:不用重新发明轮子 !

对这点我是严重支持啊，在我的身边看到N多所谓的牛人来到项目组作的第一件事就是把以前的项目推倒，重新实现自己的所谓一套先进的东西，靠，你有多先进啊，你的自己”方言”一边自我欣赏，一边还让别人接受，再来一个人又把这个推倒，循环。。。。无语.

所以,用开源吧 ,是不是绕的太远了? 让我们言归正传吧.

一。管理你的web配置文件信息

web的配置文件是我们经常要用到的，配置信息我们可以分为两大类，一类是最简单的”平板”型的,比如:

For an XML config file like this:

< config >
< firstName > Frank firstName >
config >

The following bean could be used:

public class MyConfigBean {
private static String firstName;
public void setFirstName(String inFirstName) {
firstName = inFirstName;
}
public String getFirstName() {
return firstName;
}
}

在应用中你不用去自己解析xml了，javawebparts已经帮你做好了，你只要getFirstName()就可以了，是不是很方便?你所要做的工作就是在web.xml中引用一个listener,配置如下:

<context-param>
<param-name>configFileparam-name>
<param-value>/WEB-INF/app_config.xml< /param-value>context-param>
<context-param>
<param-name>rootElementparam-name>
<param-value>configparam-value> context-param>
<context-param>
<param-name>configClassparam-name>
<param-value>javawebparts.sampleapp. SampleAppConfigBeanparam-value>
context-param>
<context-param>
<param-name>AjaxPartsTaglibConfigparam-name>
<param-value>/WEB-INF/ajax_config.xmlparam-value>
context-param>

<listener>
<listener-class>javawebparts.listener. AppConfigContextListenerlistener-class>
listener>
这种平板型结构的数据这样就已经OK了，还有一种是复杂一点的，有层次结构，比如在Bean中可能还有collection,需要自己实现一下，也不复杂直接调用apache的Digester就可以了（实际上在javawebparts到处都有Digester的影子）,需要了解的请参看用Digester解析xml到bean

二。缓存页面

比如，我想缓存所有的gif图片，但是jpg的不缓存，web.xml中配置如下:

<filter>
<filter-name>CacheControlFilterfilter-name>
<filter-class>javawebparts.filter. CacheControlFilterfilter-class>
<init-param>
<param-name>pathSpecparam-name>
<param-value>includeparam-value>
init-param>
<init-param>
<param-name>pathListparam-name>
<param-value>*/header1.gif, *.jpgparam-value>
init-param>
filter>

<filter-mapping>
<filter-name>CacheControlFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
它的后台实现机制很简单，内部部分代码如下:

((HttpServletResponse)response).setHeader(“Pragma“, “No-cache“);
((HttpServletResponse)response).setHeader(“Cache-Control“,
“no-cache,no-store,max-age=0“);
((HttpServletResponse)response).setDateHeader(“Expires“, 1);
三。图片压缩
是不是对gzip压缩很亲切？对的，就是传说中可以压缩图片减少网络传输体积的玩意，现在你只要在web.xml中增加以下内容就可以轻松实现了:

<filter>
<filter-name>CompressionFilterfilter-name>
<filter-class>javawebparts.filter. CompressionFilterfilter-class>
<init-param>
<param-name>pathSpecparam-name>
<param-value>includeparam-value>
init-param>
<init-param>
<param-name>pathListparam-name>
<param-value>*/bigimage2.gif param-value>
init-param>
<init-param>
<param-name>compressTypeparam-name>
<param-value>gzip_firstparam-value>
init-param>
filter>

<filter-mapping>
<filter-name>CompressionFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
上面的配置表示只对bigimage2.gif的文件进行压缩，其他不用,pathSpec的属性有两种include,exclude,意思已经很明确了，相反地意思,而pathList得内部实现也是用正则表达式实现的，支持*等用法.这些内部实现你觉得复杂的话就不用管它了，反正人家已经给你实现好了，你只要说”给我压缩’美女与野兽.JPG’”就可以了

四.控制只在设定的时间范围内访问应用

比如说只允许在工作时间内可以访问应用，其他时间禁止访问，虽然不是很普遍不过这种需求还是有的,如果自己实现还是比较麻烦的，我们用现成的，配置如下：(怎么都是配置阿？对，全部是配置就可以了，难道不好吗?太爽了啊，乖乖龙地动)

<filter>
<filter-name>AppAvailabilityFilterfilter-name>
<filter-class>javawebparts.filter. AppAvailabilityFilterfilter-class>
<init-param>
<param-name>pathSpecparam-name>
<param-value>includeparam-value>
init-param>
<init-param>
<param-name>pathListparam-name>
<param-value>*/AAFTestTarget.jsp param-value>
init-param>
<init-param>
<param-name>mondayparam-name>
<param-value>0600-2359param-value>
init-param>
<init-param>
<param-name>tuesdayparam-name>
<param-value>0600-2359param-value>
init-param>
<init-param>
<param-name>wednesdayparam-name>
<param-value>0600-2359param-value>
init-param>
<init-param>
<param-name>thursdayparam-name>
<param-value>0600-2359param-value>
init-param>
<init-param>
<param-name>fridayparam-name>
<param-value>0600-2359param-value>
init-param>
<init-param>
<param-name>saturdayparam-name>
<param-value>0600-2359param-value>
init-param>
<init-param>
<param-name>sundayparam-name>
<param-value>0600-2359param-value>
init-param>
<init-param>
<param-name>redirectToparam-name>
<param-value>AAFReject.jsp< /param-value>
init-param>
<init-param>
<param-name>bypassCheckClass< /param-name>
<param-value>javawebparts.sampleapp. AAFBypassCheckparam-value>
init-param>
filter>

<filter-mapping>
<filter-name>AppAvailabilityFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
上面的配置很明确了吧，表示在访问AAFTestTarget.jsp 文件的时候必须在设定的时间内，其他则无限制，很清楚了哦.

五。统一重定向

redirect或者forward大家都再熟悉不过了，不过这个是基于配置的，不用你写代码，比如，你希望在访问某个目录的时候自动重订向到其他文件，或者直接转到其他网站比如google.com,配置如下:

<filter>
<filter-name>URLRedirectFilterfilter-name>
<filter-class>javawebparts.filter.URLRedirectFilter filter-class>
<init-param>
<param-name>configFileparam-name>
<param-value>/WEB-INF/redirect_config.xml param-value>
filter>

<filter-mapping>
<filter-name>URLRedirectFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
其中redirect_config.xml配置如下:

<config>
<redirect from=”*/app/redirect_test/*” to=”http://www.google.com” />
<forward from=”*/app/forward/test.htm” to=”/index.jsp” />
config>
很直观吧?凡是访问/app/redirect_test下的所有应用都重订向到google,太简单了,我就不多说了.
六.估算每个请求所花费的时间

这个对性能调整是很有好处的,性能的调整的前提是你了解你的系统的瓶颈在什么地方,更具体的说是你的应用哪些地方花费的资源较多,一个是监控sql的执行情况,这里推荐jdbmonitor,大家可以去看看,另一种就是本文所说的查看每个请求的执行时间,他会告诉你本请求花费了多少秒,很直观了.

配置如下:

<filter>
<filter-name>ElapsedTimeFilterfilter-name>
<filter-class>javawebparts.filter.ElapsedTimeFilter filter-class>
<init-param>
<param-name>pathSpecparam-name>
<param-value>includeparam-value>
init-param>
<init-param>
<param-name>pathListparam-name>
<param-value>*param-value>
init-param>
filter>

<filter-mapping>
<filter-name>ElapsedTimeFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
上面的一个include ,一个pathList的*就代表了所有的应用都过滤,反之,你想暂时取消这个功能就直接把include换成exclude就行了

应用在启动后你直接观察后台日志就可以了,就这么就OK了,还要你做什么呢? 没有.

七.监控session的会话

经常碰到这样的一个情况,用户在登陆系统一段时间后session实效,但是他接着点击里面的连接,结果报异常,因为session里已经取不到数据了,常常是空指针错误,在每一个页面里都进行这种低级问题的判断是很烦人的,现在我们有新的方式可以一次性解决所有的问题,还是一段简单的配置:

<filter>
<filter-name>SessionInactivityFilter< /filter-name>
<filter-class>javawebparts.filter. SessionInactivityFilterfilter-class>
<init-param>
<param-name>forwardToparam-name>
<param-value>/login.jsp< /param-value>
init-param>
filter>

<filter-mapping>
<filter-name>SessionInactivityFilter< /filter-name>
<url-pattern>/*url-pattern>
filter-mapping>
表示会话失效后直接重定向到登陆界面,让用户重新登陆.

八.控制访问应用的IP

出于安全考虑,过滤某些IP能或不能访问,配置如下:

<filter>
<filter-name>IPAccessControlFilterfilter-name>
<filter-class>javawebparts.filter. IPAccessControlFilterfilter-class>
<init-param>
<param-name>pathSpecparam-name>
<param-value>includeparam-value>
init-param>
<init-param>
<param-name>pathListparam-name>
<param-value>*/IACTestTarget.jsp param-value>
init-param>
<init-param>
<param-name>addressSpecparam-name>
<param-value>includeparam-value>
init-param>
<init-param>
<param-name>addressListparam-name>
<param-value>localhostparam-value>
init-param>
<init-param>
<param-name>forwardToparam-name>
<param-value>/IACReject.jspparam-value> init-param>
filter>

<filter-mapping>
<filter-name>IPAccessControlFilterfilter-name>
<url-pattern>/*url-pattern>
filter-mapping>
以上的配置效果就是只允许是从服务器上访问应用的来源(太苛刻了吧? )

九.随机显示文字

比如每日一语,随机广告,很实用的,配置如下:

<servlet>
<servlet-name>TextReturnerServletservlet-name>
<servlet-class>javawebparts.servlet. TextReturnerServletservlet-class>
<init-param>
<param-name>orderparam-name>
<param-value>randomparam-value>
init-param>
<init-param>
<param-name>itemsFileparam-name>
<param-value>/WEB-INF/text_returner_items.xml param-value>
init-param>
servlet>

<servlet-mapping>
<servlet-name>TextReturnerServletservlet-name>
<url-pattern>/textReturnerurl-pattern>
servlet-mapping>
上面的配置表示随机显示text_returner_items.xml 中的文字,text_returner_items.xml 内容如下:

<TextReturnerServletItems>
<item>0 - It’s always darkest before the dawnitem>
<item>1 - A journey of a thousand miles begins with a single stepitem>
<item>2 - The universe is like stupidity: both are infinite and actually, I’m not sure about the universeitem>
<item>3 - I believe there is intelligent life in the universe, except for some parts of New Jerseyitem>
<item>4 - If your falling of a cliff, you might as well try and flyitem>
<item>5 - The cost of life is to chance the consequenceitem>
TextReturnerServletItems>
十.随机显示图片

和上面有点类似,只是显示的内容可以是图片

<servlet>
<servlet-name>RedirectReturnerServletservlet-name>
<servlet-class>javawebparts.servlet. RedirectReturnerServletservlet-class>
<init-param>
<param-name>orderparam-name>
<param-value>randomparam-value>
init-param>
<init-param>
<param-name>itemsFileparam-name>
<param-value> /WEB-INF/redirect_returner_items.xmlparam-value>
init-param>
servlet>

<servlet-mapping>
<servlet-name>RedirectReturnerServletservlet-name>
<url-pattern>/redirectReturnerurl-pattern>
servlet-mapping>

redirect_returner_items.xml的内容如下:

<RedirectReturnerServletItems>
<item>http://www.google.com/intl/en/images/logo.gifitem>
<item>/img/header1.gifitem>
<item>/img/mouse.gifitem>
<item>http://javawebparts.sourceforge.net/logo.jpgitem>
RedirectReturnerServletItems>
我就不用解释了吧

十一.生成文字图片

你提供文字,系统帮你生成对应的图片,是不是很有用? 比如验证码里经常需要用到,生成的效果如下:

配置如下:

<servlet>
<servlet-name>TextRendererServletservlet-name>
<servlet-class>javawebparts.servlet. TextRendererServletservlet-class>
<init-param>
<param-name>fontNameparam-name>
<param-value>arialparam-value>
init-param>
<init-param>
<param-name>fontPointparam-name>
<param-value>24param-value>
init-param>
<init-param>
<param-name>colorparam-name>
<param-value>255,0,0 param-value>
init-param>
<init-param>
<param-name>backColorparam-name>
<param-value>255,255,0 param-value>
init-param>
<init-param>
<param-name>stylePlainparam-name>
<param-value>falseparam-value>
init-param>
<init-param>
<param-name>styleBoldparam-name>
<param-value>trueparam-value>
init-param>
<init-param>
<param-name>styleItalicparam-name>
<param-value>trueparam-value>
init-param>
servlet>

<servlet-mapping>
<servlet-name>TextRendererServletservlet-name>
<url-pattern>/textRendererurl-pattern>
servlet-mapping>
好了，基本介绍到这里，基本感觉web常碰到的东西都有所涉及，另外还有Ajax的封装，但我个人感觉没什么大用，如果需要可以考虑别的开源产品，比如prototype或者DWR等，感觉更方便.

好东西不敢独享,如果你觉得有点用我就很开心了

用开源组件jcaptcha做jsp彩色验证码

用Digester解析xml到bean

Alex — Wed, 06 Sep 2006 04:11:45 +0000

key words: Digester 解析xml

假设有下列xml文件:

xml version=’1.0′ encoding=’utf-8′?>
<address-book>
<contact myType=”individual”>
<name>Zane Pasolininame>
<address>999 W. Prince St.address>
<city>New Yorkcity>
<province>NYprovince>
<postalcode>10013postalcode>
<country>USAcountry>
<telephone>1-212-345-6789telephone>
contact>
<contact myType=”business”>
<name>SAMOFIX d.o.o.name>
<address>Ilica 47-2address>
<city>Zagrebcity>
<province>province>
<postalcode>10000postalcode>
<country from=”cn”>Croatiacountry>
<telephone>385-1-123-4567telephone>
contact>
address-book>
这是一份常用到的文件，现在我们需要将之映射到java bean,用Digester解析显得非常简单

public class AddressBookParser
{
/**
* Prints the contact information to standard output.
*
* @param contact the Contact to print out
*/
public void addContact(Contact contact)
{
System.out.println(“TYPE: “ + contact.getType());
System.out.println(“NAME: “ + contact.getName());
System.out.println(“    ADDRESS:    “ + contact.getAddress());
System.out.println(“    CITY:       “ + contact.getCity());
System.out.println(“    PROVINCE:   “ + contact.getProvince());
System.out.println(“    POSTALCODE: “ + contact.getPostalcode());
System.out.println(“    COUNTRY:    “ + contact.getCountry());
System.out.println(“    COUNTRY-From:    “ + contact.getCountryFrom());
System.out.println(“    TELEPHONE:  “ + contact.getTelephone());
}

/**
* Configures Digester rules and actions, parses the XML file specified
* as the first argument.
*
* @param args command line arguments
*/
public static void main(String[] args) throws IOException, SAXException
{
// instantiate Digester and disable XML validation
Digester digester = new Digester();
digester.setValidating(false);

// instantiate AddressBookParser class
digester.addObjectCreate(“address-book“, AddressBookParser.class );
// instantiate Contact class
digester.addObjectCreate(“address-book/contact“, Contact.class );

// set type property of Contact instance when ’type’ attribute is found
//对有属性的值通过setProperties方法

digester.addSetProperties(“address-book/contact“, “myType“, “type“ );

// set different properties of Contact instance using specified methods
//addCallMethod与addBeanPropertySetter等价
// 参数 0代表一个参数，默认就是当前读的数据

digester.addCallMethod(“address-book/contact/name“,       “setName“, 0);
digester.addCallMethod(“address-book/contact/address“,    “setAddress“, 0);
digester.addCallMethod(“address-book/contact/address“,    “setAddress“,0);
digester.addCallMethod(“address-book/contact/city“,       “setCity“, 0);
digester.addCallMethod(“address-book/contact/province“,   “setProvince“, 0);
digester.addCallMethod(“address-book/contact/postalcode“, “setPostalcode“, 0);
digester.addCallMethod(“address-book/contact/country“,    “setCountry“, 0);

//增加country的属性 : from
digester.addSetProperties(“address-book/contact/country“,“from“,“countryFrom“);
digester.addCallMethod(“address-book/contact/telephone“, “setTelephone“, 0);

// call ’addContact’ method when the next ’address-book/contact’ pattern is seen
digester.addSetNext(“address-book/contact“, “addContact“ );

// now that rules and actions are configured, start the parsing process
AddressBookParser abp = (AddressBookParser) digester.parse(new File(“c:\\addressbook.xml“));
}

/**
* JavaBean class that holds properties of each Contact entry.
* It is important that this class be public and static, in order for
* Digester to be able to instantiate it.
*/
public static class Contact
{
private String type;
private String name;
private String address;
private String city;
private String province;
private String postalcode;
private String country;
        //增加一个country的属性: from
        private String countryFrom;
        private String telephone;

public void setType(String newType)
{
type = newType;
}
public String getType()
{
return type;
}

public void setName(String newName)
{
name = newName;
}
public String getName()
{
return name;
}

public void setAddress(String newAddress)
{
address = newAddress;
}
public String getAddress()
{
return address;
}

public void setCity(String newCity)
{
city = newCity;
}
public String getCity()
{
return city;
}

public void setProvince(String newProvince)
{
province = newProvince;
}
public String getProvince()
{
return province;
}

public void setPostalcode(String newPostalcode)
{
postalcode = newPostalcode;
}
public String getPostalcode()
{
return postalcode;
}

public void setCountry(String newCountry)
{
country = newCountry;
}
public String getCountry()
{
return country;
}

public void setTelephone(String newTelephone)
{
telephone = newTelephone;
}
public String getTelephone()
{
return telephone;
}

public String getCountryFrom() {
return countryFrom;
}

public void setCountryFrom(String countryFrom) {
this.countryFrom = countryFrom;
}
}
}

在 AjaxChat 中的读取房间信息的方式显得更简洁
房间的xml配置文件如下:

<rooms>
<room id=”1″ name=”General Topics” />
<room id=”2″ name=”Programming” />
<room id=”3″ name=”Movies” />
<room id=”4″ name=”Music” />
<room id=”5″ name=”Television” />
rooms>
解析代码如下 :

public synchronized void init(InputStream isConfigFile) {

log.debug(“init()“);
if (isConfigFile != null) {
// Read in rooms config and create beans, hand off to DAO.
Digester digester = new Digester();
digester.setValidating(false);
digester.push(this);
digester.addObjectCreate(“rooms/room“,
“org.apache.struts.apps.ajaxchat.dto.RoomDTO“);
//注意这里，如果xl的属性名称和bean的属性名称完全对应，则直接提供xml的位置即可
digester.addSetProperties(“rooms/room“);
digester.addSetNext(“rooms/room“, “addRoom“);
try {
digester.parse(isConfigFile);
log.info(“***** Rooms = “ + rooms);
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (SAXException se) {
se.printStackTrace();
}
}

} // End init().
如果在xml文件中增加非attribute则更改后的配置文件如下:

对应的解析如下:

public synchronized void init(InputStream isConfigFile) {

log.debug(“init()“);
if (isConfigFile != null) {
// Read in rooms config and create beans, hand off to DAO.
Digester digester = new Digester();
digester.setValidating(false);
digester.push(this);
digester.addObjectCreate(“rooms/room“,
“org.apache.struts.apps.ajaxchat.dto.RoomDTO“);
digester.addSetProperties(“rooms/room“);
//增加addCallMethod方法
digester.addCallMethod(“rooms/room/id“,“setId“,0);
digester.addCallMethod(“rooms/room/name“,“setName“,0);
digester.addSetNext(“rooms/room“, “addRoom“);
try {
digester.parse(isConfigFile);
log.info(“***** Rooms = “ + rooms);
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (SAXException se) {
se.printStackTrace();
}
}

} // End init().

[zt]JDBMonitor全攻略

Alex — Thu, 31 Aug 2006 04:13:29 +0000

key words: dbmonitor,sql跟踪，sql监控

JDBMonitor是一个开源项目。使用它开发者可以很轻松为系统增加数据库执行日志功能。它使用十分方便，您所需要做的唯一事情就是在您系统的JDBC连接字符串前增加类似于 “listenerconfig=/config.xml:url=” 的字符即可，不用写任何代码。

使用 JDBMonitor，您可以把数据库执行情况记录通过各种方式记录下来，比如打印到控制台、输出到文件或者通过socket传送给远程客户端。JDBMonitor是可扩展的，您可以扩展它来将执行情况通过其他方式记录下来，您所需要做的就是写一个实现IDBListener接口的类即可。

JDBMonitor遵守 GNU Lesser General Public Licence (LGPL)协议。此协议包含在发行包中。

入门

几乎所有大型数据库应用都包含有自己的SQL执行日志功能，此功能不仅能帮助开发人员调试，而且可以为DBA（数据库管理员）提供系统的运行信息。

（1）很难将业务逻辑同日志代码分离

（2）降低了代码的可读性。

（3）降低了系统的运行速度。在记录日志的时候，程序会暂停运行等待直到记录完成，而I/O操作是相当耗时的。

（4）很难记录运行耗时、语句参数等其他信息

（5）很难为我们无法修改代码的系统（例如没有源代码的系统）或者很难增加记录日志功能代码的系统（比如系统使用了ORMapping）增加日志功能。

JDBMonitor 则不同：

（1）您最多只需要修改一行代码。您需要修改的代码就是这一行:Class.forName(“com.cownew.JDBMonitor.jdbc.DBDriver”) ,然后再修改一下 JDBC连接字符串，只要从 “jdbc:db2://10.74.198.247:50000/app”修改成” listenerconfig=config.xml:url= jdbc:db2://10.74.198.247:50000/app”就可以了。在您使用WebLogic ,Tomcat或其他服务器的数据源功能的时候，连修改代码这一步都是无需的。

（2）JDBMonitor另起一个线程来记录SQL，所以它不会对程序运行速度有任何影响。

（3）它是高度可扩展的，所以您可以扩展它来把执行情况通过其他方式记录。比如，您可以写一个扩展类，来通过电子邮件将日志发送出去。

取得 JDBMonitor

JDBMonitor的最新稳定版本可以在JDBMonitor的网站上取得：

http://www.cownew.com/JDBMonitor

使用 JDBMonitor

1 将 jdbmonitor.jar放到您系统的类路径下。

2 让系统加载 JDBMonitor的JDBC驱动。

这一步将会依您系统加载JDBC驱动的方式的不同而不同。

（1）如果您通过代码的形式加载JDBC驱动，例如：

Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”);
Connection cn = DriverManager.getConnection(……);

在这种情况下，您必须修改 “Class.forName”这一句来加载JDBMonitor的JDBC驱动（“com.cownew.JDBMonitor.jdbc.DBDriver”），而非以前的数据库JDBC驱动。

例如：

Class.forName(“com.cownew.JDBMonitor.jdbc.DBDriver”);
Connection cn = DriverManager.getConnection(……);

（2）如果您在配置文件中指定JDBC驱动，比如，数据源配置文件或者其他类似的文件。

请修改原来的 JDBC驱动类为 “com.cownew.JDBMonitor.jdbc.DBDriver” 。

3 让 JDBMonitor加载能够加载原来的JDBC驱动

JDBMonitor的工作原理就是截获JDBC驱动的SQL语句调用、记录SQL语句，然后将SQL语句重新转发给原来的JDBC驱动，所以JDBMonitor必须首先向DriverManager注册JDBC驱动。

原来的JDBC驱动定义在配置文件的“JdbcDrivers” 段中。

4 在原来的JDBC连接字符串前增加 JDBMonitor所需的信息。

您所需要做的就是将” listenerconfig=:url=” 增加到原来的JDBC连接字符串前。“”代表配置文件的路径，下面集中路径都是合法的：

/com/jdbmonitor/config.xml
com/jdbmonitor/config.xml
c:/ jdbmonitor /config.xml

JDBMoinitor使用getClass().getResourceAsStream加载类似于“/com/jdbmonitor/config.xml” and “com/jdbmonitor/config.xml” 的类路径文件，使用 FileInputStream加载类似于 “c:/ jdbmonitor /config.xml”的配置文件。

5 指定您要使用监听器：

您可以把数据库执行情况记录通过各种方式记录下来，比如打印到控制台、输出到文件或者通过socket传送给远程客户端。

我们已经开发了如下常用的监听器：FileDBListener、ConsoleDBListener、 SocketDBListene、DataBaseDBListener。当然您也可以开发满足您要求的监听器。
监听器定义在配置文件的 “Listeners”段中：

搞定！启动您的系统。耶！SQL语句被记录下来了，我们可以在控制台、文件甚至远程监视器中看到日志了。

举例

mvnforum的例子：

您可以从http://www.mvnForum.com得到mvnforum。我演示用的版本是1.0。

(1)打开webapp\WEB-INF\classes\ mvncore.xml，重新配置：

修改之前：

com.mysql.jdbc.Driver
listenerconfig=c:/log/jdbmonitor/config.xml:url= jdbc:mysql://localhost/mvnforum?useUnicode=true&characterEncoding=utf-8

修改之后：
com.cownew.JDBMonitor.jdbc.DBDriver
jdbc:mysql://localhost/mvnforum?useUnicode=true&characterEncoding=utf-8

(2)创建文件 c:/log/jdbmonitor/config.xml。我只想将SQL语句记录到文本文件中，所以我做如下配置：

(3) 将 jdbmonitor.jar放到webapp\WEB-INF\lib下。
(4) 搞定！

Jive的例子：

您可以从http://www.jivesoftware.com得到Jive。我演示用的版本是 Jive 2.0 beta版。

(1)打开http://localhost:8080/jive/admin/

“jdbc” 填为：com.cownew.JDBMonitor.jdbc.DBDriver

“server” 填为：c:/log/jdbmonitor/config.xml:url=jdbc:mysql://locahost/jive
(2)将 jdbmonitor.jar放到WEB-INF\lib下
(3) 象mvnforum中一样创建同样的 c:/log/jdbmonitor/config.xml 文件.
(4) 搞定!

代码方式的例子：

尽管直接在代码中指定系统所用的JDBC驱动类名和JDBC连接字符串是不推荐的，但是仍然有系统是这么做的。

比如：

              Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
              Connection conn = null;
              PreparedStatement ps = null;
              try
              {
                     conn = DriverManager
                                   .getConnection(“jdbc:odbc:MQIS”);
                     for (int i = 0; i < 1000; i++)
                     {
                            ps = conn.prepareStatement(“update T_Material set fid=fid”);
                            ps.execute();
                            ps.close();
                     }
              } finally
              {
                     ….
              }

（1）修改一下代码为：
              Class.forName(“com.cownew.JDBMonitor.jdbc.DBDriver”);
              Connection conn = null;
              PreparedStatement ps = null;
              try
              {
                     conn = DriverManager.getConnection(“listenerconfig= c:/log/jdbmonitor/config.xml:url=jdbc:odbc:MQIS”);
                     for (int i = 0; i < 1000; i++)
                     {
                            ps = conn.prepareStatement(“update T_Material set fid=fid”);
                            ps.execute();
                            ps.close();
                     }
              } finally
              {
                     ….
              }

（2）创建c:/log/jdbmonitor/config.xml文件。我想记录SQL语句到文本文件中同时输出到控制台，这样可以辅助我进行调试，所以我配置如下：

(3) 将 jdbmonitor.jar放到类路径下。
(4) 搞定!

监听器

我们已经开发了如下常用的监听器：FileDBListener、ConsoleDBListener、 SocketDBListener、DataBaseDBListener。

1、ConsoleDBListener 控制台监听器

ConsoleDBListener会将SQL语句打印到控制台中。

这个监听器很容易配置：

2、FileDBListener 文件监听器

FileDBListener 会将SQL语句保存到文本文件中。

如下配置：

arg=”c:/aaa.txt”表示日志将保存到文件c:/aaa.txt中。

3、SocketDBListener Socket监听器

SocketDBListener是一个socket服务器，客户端连接到它上边以后就可以接收到它发出的SQL语句。

如下配置：

arg=”9527″表示服务器将在9527端口监听。

我们已经开发了如下两种客户端：SocketConsoleClient（Socket控制台客户端）和 SocketSwingClient（Socket Swing客户端）。

SocketConsoleClient工作在控制台中：

SocketSwingClient是一个Swing GUI客户端：

您可以运行“java -classpath jdbmonitor.jar com.cownew.JDBMonitor.listenerImpl.sckListenerClient.SocketConsoleClient” 来启动SocketConsoleClient，运行“java -classpath jdbmonitor.jar com.cownew.JDBMonitor.listenerImpl.sckListenerClient.SocketSwingClient”启动SocketSwingClient。

您可以编写符合您自己要求的客户端，具体细节请参考com.cownew.JDBMonitor.listenerImpl.sckListenerClient.ListenerClient和com.cownew.JDBMonitor.listenerImpl.sckListenerClient.IDBSocketClientListener.

4、DataBaseDBListener

DataBaseDBListener将会把SQL语句记录到数据库中：

如下配置：

arg=”dburl=jdbc:odbc:MQIS;user=;password=;logtable=T_Log_SQLLog”/>

“dburl=jdbc:odbc:MQIS;user=;password=;”表示目标数据库的JDBC连接字符串。“logtable=T_Log_SQLLog” 表示SQL记录将被保存到哪个表中，默认的是T_Log_SQLLog。

如果目标数据库用的JDBC驱动与被监控的数据库不同，请将它加入配置文件的 “JdbcDrivers” 部分，例如：

true

arg=”dburl=jdbc:odbc:MQIS;user=;password=;logtable=T_Log_SQLLog”/>

“T_Log_SQLLog“的结构是：

“T_Log_SQLLog“的建库脚本在com/cownew/JDBMonitor/listenerImpl/dataBaseListener,(db2.sql,mssqlserver.sql,oracle.sql)。

DataBaseDBListener是跨数据库的，你可以把记录SQL到任何关系数据库中。

FAQ:

1 如果我暂时不想记录SQL语句执行怎么办？难道我要重新修改成原来的样子？

答：无须如此。您只要修改config.xml，增加false到文件中即可。

如下：

false

……

如何扩展JDBMonitor？

我们已经开发了如下常用的监听器：FileDBListener、ConsoleDBListener、 SocketDBListener、DataBaseDBListener。当然您也可以开发满足您要求的监听器。所有的监听器必须实现接口：com.cownew.JDBMonitor.commo. IDBListener。IDBListener有两个方法需要实现：

public void init(String arg);
public void logSql(SQLInfo info);

JDBMonitor会将配置文件中监听器定义中“arg”的值传递给 “init”方法、将代表SQL语句执行信息的SQLInfo传递给“logSql”方法。

更多信息请参考API文档。

tomcat4,5的数据源配置差异

关于java与javaScript的互相访问

Alex — Sat, 19 Aug 2006 04:21:01 +0000

key words: 脚本编码中文乱码 js
在jsp中，通过js访问java代码比较容易(不过，也有缺陷，比如java代码的声明必须先于js),反过来则不方便,网上看到有通过其他组件的方式来做，感觉也不是很好，其实平时用的更多的是在js中有中文编码，而需要到下一个jsp页面中得到这个对应的值。

js中有函数escape和unescape,可惜的是java.net.*中的编码和解码与js的不一致，所以他们不能协同工作，有一个方法就是在java中重新实现一遍js里对应的方法,代码如下:

/**
* java版本的escape和 unescape[对应javaScript里的函数]
*/
public class EscapeUnescape {
/**
* escape ==> escape
* @param src
* @return String
*/
public static String escape(String src) {
int i;
char j;
StringBuffer tmp = new StringBuffer();
tmp.ensureCapacity(src.length() * 6);
for (i = 0; i < src.length(); i++) {
j = src.charAt(i);
if (Character.isDigit(j) || Character.isLowerCase(j)
|| Character.isUpperCase(j))
tmp.append(j);
else if (j < 256) {
tmp.append(“%“);
if (j < 16)
tmp.append(“0“);
tmp.append(Integer.toString(j, 16));
} else {
tmp.append(“%u“);
tmp.append(Integer.toString(j, 16));
}
}
return tmp.toString();
}

/**
* unescape ===>js
* @param src
* @return String
*/
public static String unescape(String src) {
StringBuffer tmp = new StringBuffer();
tmp.ensureCapacity(src.length());
int lastPos = 0, pos = 0;
char ch;
while (lastPos < src.length()) {
pos = src.indexOf(“%“, lastPos);
if (pos == lastPos) {
if (src.charAt(pos + 1) == ‘u‘) {
ch = (char) Integer.parseInt(src.substring(pos + 2, pos + 6), 16);
tmp.append(ch);
lastPos = pos + 6;
} else {
ch = (char) Integer.parseInt(src.substring(pos + 1, pos + 3), 16);
tmp.append(ch);
lastPos = pos + 3;
}
} else {
if (pos == -1) {
tmp.append(src.substring(lastPos));
lastPos = src.length();
} else {
tmp.append(src.substring(lastPos, pos));
lastPos = pos;
}
}
}
return tmp.toString();
}
}

POI的一个bug问题

Alex — Thu, 10 Aug 2006 05:24:15 +0000

key words : POI java读取Excel java.io.IOException Unable to read entire block

版本:2.5.1final
错误提示:
java.io.IOException Unable to read entire block

出这个问题具有随机性，有时候没问题，有时候将Excel里的CellType改一下好像就没问题，但也不总是这样，真是莫名其妙.

Google了一下是一个bug,重新下载src文件，将RawDataBlock.java文件的RawDataBlock(final InputStream stream)constructor覆盖:

public RawDataBlock(final InputStream stream) throws IOException
{
_data = new byte[ POIFSConstants.BIG_BLOCK_SIZE ];
int count = 0;
int totalBytesRead = 0;
while ((totalBytesRead < POIFSConstants.BIG_BLOCK_SIZE) &&
(count != -1)) {
count = stream.read(_data, totalBytesRead,
POIFSConstants.BIG_BLOCK_SIZE - totalBytesRead);
if (count != -1) {
totalBytesRead += count;
}
}
if (count == -1) {
_eof = true;
} else {
_eof = false;
}
if ((totalBytesRead != POIFSConstants.BIG_BLOCK_SIZE) && (totalBytesRead != 0)) {
String type = “ byte“ + ((totalBytesRead == 1) ? (“”): (“s“));
throw new IOException(“Unable to read entire block; “ +
totalBytesRead + type + “ read; expected “ + POIFSConstants.BIG_BLOCK_SIZE + “bytes“);
}
}

打包:

ant jar
重启app，OK!

说明:
主要问题出在 InputStream的read上，原来的实现用ReadFully方法：

public static int readFully(InputStream in, byte[] b, int off, int len)
throws IOException
{
int total = 0;
for (;;) {
int got = in.read(b, off + total, len - total);
if (got < 0) {
return (total == 0) ? -1 : total;
} else {
total += got;
if (total == len)
return total;
}
}
}
InputStream的read不能确保返回的是最大字节数,但是另一个实现却可以:ByteInputStream
所以，下面的方法也可以修改这个问题:

// read entire stream into byte array:
ByteArrayOutputStream byteOS = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int count;
while (count = inputStream.read(buffer)) != -1)
byteOS.append(buffer, 0, count);
byteOS.close();
byte[] allBytes = byteOS.betByteArray();

// create workbook from array:
InputStream byteIS = new ByteArrayInputStream(allBytes);
HSSFWorkbook wb = new HSSFWorkbook(byteIS);

[zt]可编程的热部署问题

Alex — Tue, 08 Aug 2006 05:27:08 +0000

key words : 热部署动态读取配置文件动态读取properties文件

come from here

package com.javaeye.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
import java.util.Properties;

/**
* @author Robbin Fan
*
*/
public class ConfigUtil {

private static Properties props = null;
private static File configFile = null;
private static long fileLastModified = 0L;

private static void init() {
URL url = ConfigUtil.class.getClassLoader().getResource(“global.properties“);
configFile = new File(url.getFile());
fileLastModified = configFile.lastModified();
props = new Properties();
load();
}

private static void load() {
try {
props.load(new FileInputStream(configFile));
fileLastModified = configFile.lastModified();
} catch (IOException e) {
throw new RuntimeException(e);
}
}

public static String getConfig(String key) {
if ((configFile == null) || (props == null)) init();
if (configFile.lastModified() > fileLastModified) load();
return props.getProperty(key);
}

}

两则:切割字符串；用DecimalFormat格式化字符

Alex — Mon, 03 Jul 2006 05:59:32 +0000

key words: 切割字符串切割中文字符 DecimalFormat 格式化字符科学计数法

一.切割字符串的前几个字符
在首页，有时候会因为table列表里的某个内容比较长而使得页面撑得很难看，一般做法就是截取前几个字符

/**
* 截取前几个字符串
* @param src 被截取的字符
* @param num 截取的长度
* @param append 附加的字符
* @return String
*/
public static String splitStr(String src, int num, String append) {
if (null == src || num < 0) return “”;
if (src.length() < num) return src;
char[] rtnChar = src.toCharArray();
StringBuffer sb = new StringBuffer();
for (int i = 0; i < num; i++) {
sb.append(rtnChar[i]);
}
sb.append(append);
return sb.toString();
}
toCharArray会把一个汉字当作一个char(java中一个char两个字节)

二.用DecimalFormat格式化字符
这次用POI读取Excel碰到的一个问题，即，如果Excel里的格式不同，比如同样的20060623，有可能是字符型的格式，也可能是普通数字型的，而且在数字型的时候如果比较长会给你返回科学计数法的格式,如:2.002623E7,而这个不是我希望出现的，所以后来只好碰到这种格式的就自己给转换一下:

if (null != row.getCell((short) i)) {
switch (row.getCell((short) i).getCellType()) {
case HSSFCell.CELL_TYPE_FORMULA :
strExcelLine[i] = “FORMULA “;
break;
case HSSFCell.CELL_TYPE_NUMERIC :
strExcelLine[i] = String.valueOf(row.getCell((short) i).getNumericCellValue());
break;
case HSSFCell.CELL_TYPE_STRING :
strExcelLine[i] = row.getCell((short) i).getStringCellValue();
break;
case HSSFCell.CELL_TYPE_BLANK :
strExcelLine[i] = “”;
break;
default :
strExcelLine[i] = “”;
break;
}
//如果读取的是科学计数法的格式，则转换为普通格式
//added by Alex at 20060626
if(null != strExcelLine[i] &&
strExcelLine[i].indexOf(“.“) != -1 &&
strExcelLine[i].indexOf(“E“) != -1){
DecimalFormat df = new DecimalFormat();
strExcelLine[i] = df.parse(strExcelLine[i]).toString();
}
}

jsp实现文件下载与中文文件名乱码问题解决

Alex — Wed, 14 Jun 2006 06:04:36 +0000

key words: jsp文件下载中文乱码文件名乱码

文件上传参看: 这里

碰到文件乱码，google了一下，发现这篇文章还不赖

摘录如下:

之前,写过一个Download.jsp文件,可以解决下载文件乱码问题(诸如:DOC,XSL文件等等).
后来发现,遇到中文名的文件的时候,文件下载将会报错~~~~
今天,通过改写原Download.jsp文件已经彻底解决了这个问题~
现在,把一整套的文件上传下载的方法给贴出来~~~以便大家借鉴!~!~!~!~!
作者:古埃及法老

download.jsp文件
———————————————————

<%
java.io.BufferedInputStream bis=null;
java.io.BufferedOutputStream bos=null;
try{
String filename=request.getParameter(“filename“);
filename=new String(filename.getBytes(“iso8859-1“),“gb2312“);
response.setContentType(“application/x-msdownload“);
response.setHeader(“Content-disposition“,“attachment; filename=“+new String(filename.getBytes(“gb2312“),“iso8859-1“));
bis =new java.io.BufferedInputStream(new java.io.FileInputStream(config.getServletContext().getRealPath(“files/“ + filename)));
bos=new java.io.BufferedOutputStream(response.getOutputStream());
byte[] buff = new byte[2048];
int bytesRead;
while(-1 != (bytesRead = bis.read(buff, 0, buff.length))) {
bos.write(buff,0,bytesRead);
}
}
catch(Exception e){
e.printStackTrace();
}
finally {
if (bis != null)bis.close();
if (bos != null)bos.close();
}
%>

注意，关键就是setHeader里的filename需要重新编码,格式是ISO-8859-1就ＯＫ了

以下是我自己项目中用到的代码片断，供参考:

list.jsp: 显示附件名称的页面

<tr>
<td height=”25″ class=”tdcor”>附件 td>
<td colspan=”3″ height=50>
<%
if (null != publish.getAttatchFilename() &&
publish.getAttatchFilename().length() > 0) {
%>
<a href=”publish_do.jsp?method=download&fileName=
<%=URLEncoder.encode(publish.getAttatchFilename(),”GBK”)%>“>
<%=URLDecoder.decode(publish.getAttatchFilename(),“GBK“)%>a>
<%
}
%>
td>
tr>
download.jsp:下载页面

else if (null != method && method.equals(“download“)) {//下载附件

String fileName = request.getParameter(“fileName“);
File file = new File(Constants.PUBLISH_FILE_PATH + “/“ + URLDecoder.decode(fileName,“GBK“));
response.reset();
response.setContentType(“application/octet-stream; charset=GBK“);
response.addHeader(“Content-Disposition“, “attachment; filename=“ + CourseDetailBusiness.transfer(URLDecoder.decode(fileName,“GBK“),“GBK“,“ISO-8859-1“));
response.setContentLength((int) file.length());

byte[] buffer = new byte[4096];
BufferedOutputStream output = null;
BufferedInputStream input = null;

// 写缓冲区：
try {
output = new BufferedOutputStream(response.getOutputStream());
input = new BufferedInputStream(new FileInputStream(file));

int n = (-1);
while ((n = input.read(buffer, 0, 4096)) > -1) {
output.write(buffer, 0, n);
}
response.flushBuffer();
}
catch (Exception e) {
} // maybe user cancelled download
finally {
if (input != null) input.close();
if (output != null) output.close();
}

说明:
１。文件名在数据库中保存的编码为URLEncode
2.在list.jsp显示的时候多了一次encode,不知为什么，不encode一次还不行，实际上是第二次编码了

HttpClient通过ldap验证

Alex — Sun, 11 Jun 2006 06:08:20 +0000

key words: HttpClient LDAP LDAP验证

LDAP目前应用得非常广泛，在企业环境里可以供各种应用统一用户验证数据。

以下是一个客户端在正常访问的时候插入验证代码，将用户提交的用户名和密码提交给ldap验证

HttpClient hc = new HttpClient();
GetMethod method = new GetMethod(“http://www.yoursite.com/auth/your_auth.html“);
String inputUserName = JOptionPane.showInputDialog(“Input your User Name:“);
String inputPassWord = JOptionPane.showInputDialog(“Input your password:“);
UsernamePasswordCredentials upc = new UsernamePasswordCredentials(inputUserName, inputPassWord);
hc.getState().setCredentials(null, null, upc);
int status = hc.executeMethod(method);
method.releaseConnection();
if(status == 200)
{
System.out.println(“login successful!“);
//do your business things
} else
{
System.out.println(“Login failed! Please check your userName and Password!“);
}

http://www.yoursite.com/auth/your_auth.html如果直接访问会弹出对话框让你输入用户名密码

用开源组件jcaptcha做jsp彩色验证码

Alex — Sun, 11 Jun 2006 06:07:34 +0000

key words: jsp验证码 jcaptcha

原文参考这里

安装

Add jcaptcha-all.jar (provided in bin-distribution) and ehcache.jar (not provided see ehcache site) to your application class path, ie in you WEB-INF/lib folder.

实例一个jcaptcha服务，注意，必须是单例模式的

import com.octo.captcha.service.image.ImageCaptchaService;
import com.octo.captcha.service.image.DefaultManageableImageCaptchaService;

public class CaptchaServiceSingleton {

private static ImageCaptchaService instance = new DefaultManageableImageCaptchaService();

public static ImageCaptchaService getInstance(){
return instance;
}
}
注:以上是默认的一个实现，下面是其他更多的实现

SimpleListSoundCaptchaEngine //还可以用声音，真爽哦
SpellerSoundCaptchaEngine
SpellerSoundCaptchaEngine
DefaultGimpyEngineCaptcha
BaffleListGimpyEngineCaptcha
BasicListGimpyEngineCaptcha
DeformedBaffleListGimpyEngineCaptcha
DoubleRandomListGimpyEngineCaptcha
SimpleListImageCaptchaEngineCaptcha
SimpleFishEyeEngineCaptcha

具体请参考官方说明

编写一个产生图片的servlet

import com.octo.captcha.service.CaptchaServiceException;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ImageCaptchaServlet extends HttpServlet {

public void init(ServletConfig servletConfig) throws ServletException {

super.init(servletConfig);

}

protected void doGet(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {

byte[] captchaChallengeAsJpeg = null;
// the output stream to render the captcha image as jpeg into
        ByteArrayOutputStream jpegOutputStream = new ByteArrayOutputStream();
try {
// get the session id that will identify the generated captcha.
//the same id must be used to validate the response, the session id is a good candidate!
        String captchaId = httpServletRequest.getSession().getId();
// call the ImageCaptchaService getChallenge method
            BufferedImage challenge =
CaptchaServiceSingleton.getInstance().getImageChallengeForID(captchaId,
httpServletRequest.getLocale());

// a jpeg encoder
JPEGImageEncoder jpegEncoder =
JPEGCodec.createJPEGEncoder(jpegOutputStream);
jpegEncoder.encode(challenge);
} catch (IllegalArgumentException e) {
httpServletResponse.sendError(HttpServletResponse.SC_NOT_FOUND);
return;
} catch (CaptchaServiceException e) {
httpServletResponse.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
}

captchaChallengeAsJpeg = jpegOutputStream.toByteArray();

// flush it in the response
httpServletResponse.setHeader(“Cache-Control“, “no-store“);
httpServletResponse.setHeader(“Pragma“, “no-cache“);
httpServletResponse.setDateHeader(“Expires“, 0);
httpServletResponse.setContentType(“image/jpeg“);
ServletOutputStream responseOutputStream =
httpServletResponse.getOutputStream();
responseOutputStream.write(captchaChallengeAsJpeg);
responseOutputStream.flush();
responseOutputStream.close();
}
}

为servlet修改web.xml配置文件

<servlet>
<servlet-name>jcaptchaservlet-name>
<servlet-class>ImageCaptchaServletservlet-class>
<load-on-startup>0load-on-startup>
servlet>

<servlet-mapping>
<servlet-name>jcaptchaservlet-name>
<url-pattern>/jcaptchaurl-pattern>
servlet-mapping>

编写你的客户端的展示

<img src=”jcaptcha”>
<input type=’text’ name=’j_captcha_response’ value=”>
上面的src=”jcaptcha” 就是调用了上面的servlet,text里是用户填写的确认验证码

后台逻辑验证

Boolean isResponseCorrect =Boolean.FALSE;
//remenber that we need an id to validate!
           String captchaId = httpServletRequest.getSession().getId();
//retrieve the response
           String response = httpServletRequest.getParameter(“j_captcha_response“);
// Call the Service method
            try {
isResponseCorrect = CaptchaServiceSingleton.getInstance().validateResponseForID(captchaId,
response);
} catch (CaptchaServiceException e) {
//should not happen, may be thrown if the id is not valid
            }

OK,大功告成了.

javamail整理

Alex — Tue, 23 May 2006 06:13:27 +0000

kew words: javamail

这几天项目里涉及到javamail,顺便看了下.

现在都习惯在blogjava上搜索一番了 XXX in site:blogjava.net是我常用的搜索方式了,呵呵,大多数时候发现blogjava没让我失望,也说明这里的高手很多啊

感觉 Bromon的两篇文章很实用:
JavaMail使用指南(一) 和 Javamail使用指南(二)

还有 morcble的 javamail发送邮件和 javamail接受邮件

在测试的时候有几个问题值得一提:

第一就是一定要加上activation.jar 库文件,否则会报下面的异常:

NoClassDefFoundError: javax/activation/DataSource

另外,发现用yahoo的smtp会报535的验证错误,把验证的方式换为morcble的下面的内部类的方式验证也不行:

Session session = Session.getDefaultInstance(props,
new Authenticator() {
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(mymail.username,
mymail.password);
}
});
~~最后换了个smtp服务器没问题,不知道各位兄弟有没有碰到这样的问题,可以确认的是我的yahoo配置信息应该是正确的,因为我用foxmail收发信件都是可以的.~~

后来到yahoo中国里面看了一下帮助,里面说

我们目前正在对雅虎邮箱该项服务进行相关的调整，因此我们暂时停止了在页面上POP服务设置的相关介绍。目前雅虎邮箱暂时不提供POP服务，敬请关注雅虎邮箱的近期活动。

应该就是这个原因了

另外,还有一些基于javamail封装的工具类:

可以参考这篇 : 简化JavaMail：小巧 Jakarta Commons-Email 简单教程

文件上传:用O’Reilly公司的cos实现文件上传

Alex — Mon, 22 May 2006 06:14:33 +0000

出处:codeChina

key words: cos 文件上传 jsp上传

index.html文件:

<html>
<head>
<meta http-equiv=”Content-Type” content=”text/html;charset=gb2312″>
<title>无标题文档title>
head>

<body>
enctype的值很重要,upload.jsp为处理上传的jsp–>
<form name=”form1″ method=”post” enctype=”multipart/form-data”
action=”upload.jsp”>
<p>
<input name=”file1″ type=”file”>
p>
<p>
<input name=”file2″ type=”file”>
p>
<p> <input name=”file3″ type=”file”>
p>
<p>
<input type=”submit” name=”Submit” value=”上传”>
p>
form >

body>
html>
upload.jsp文件 :

<%@page import=“java.io.*“%>
<%@page import=“com.oreilly.servlet.MultipartRequest“%>
<%@page import=“com.oreilly.servlet.multipart.CoverFileRenamePolicy“%>
<%@page contentType=“text/html; charset=gb2312“ %>
<%
//文件上传后，保存在c:\\upload
String saveDirectory =“c:\\upload“;
//每个文件最大5m,最多3个文件,所以
int maxPostSize =3 * 5 * 1024 * 1024 ;
//response的编码为“gb2312“,同时采用缺省的文件名冲突解决策略,实现上传
//就这一句就完成上传了,真是很爽
MultipartRequest multi = new MultipartRequest(request, saveDirectory, maxPostSize,“gb2312“);

//输出反馈信息
Enumeration files = multi.getFileNames();
while (files.hasMoreElements()) {
System.err.println(“ccc“);
String name = (String)files.nextElement();
File f = multi.getFile(name);
if(f!=null){
String fileName = multi.getFilesystemName(name);
String lastFileName= saveDirectory+“\\“ + fileName;
out.println(“上传的文件:“+lastFileName);
out.println(“

“);

}
}

相关链接:几种上传方法介绍和比较

[zt]Struts中防止任意形式的重复提交

Alex — Mon, 08 May 2006 06:18:58 +0000

注:这个说的挺全面,考虑到了两种情况,一个是超连接,一个是表单

原文是这里

Struts 的 Token 机制可以解决这个问题。

1．防止通过超链接重复访问 Struts Action 。

如果我们要防止 A 的默认页面 J 中指向 K 的超链接重复提交数据，按照下列步骤即可：

a．如果 J 是从 Struts Action 转发而来，我们要在该 Struts Action 的 execute 方法中添加下面的一行：

saveToken(request);

b．如果 J 不是从 Struts Action 转发而来，那么新建一个 Struts Action ，在该 Struts Action 的 excute 方法中增加上面的一行，然后再从该 action 转到 J 页面。

c．在 J 页面中使用 Struts 标签生成指向 K 的超链接，如：

transaction=”true” >delete

注意红色字体部分。

d．在标签指向的 action 的 excute 方法中加入下面的代码：

if (!isTokenValid(request)) {

return mapping.findForward(“ 这种情况下就是重复提交，转到相应的页面 “);

}

e ． All Done.

2．防止通过表单重复提交数据。

a．如果 J 是从 Struts Action 转发而来，我们要在该 Struts Action 的 execute 方法中添加下面的一行：

saveToken(request);

b．如果 J 不是从 Struts Action 转发而来，那么新建一个 Struts Action ，在该 Struts Action 的 excute 方法中增加上面的一行，然后再从该 action 转到 J 页面。

c．在 J 页面中表单 Action 属性指向的 Struts action 的 excute 方法中加入下面的代码：

if (!isTokenValid(request)) {

saveToken(request);

return mapping.findForward(“ 这种情况下就是重复提交，转到相应的页面 “);

saveToken(request);

}

e ． All Done.

分页继续[数据库分页和PageBean的改进]

Alex — Mon, 08 May 2006 06:17:01 +0000

注:本文继续分页的上一篇关于分页,标签,缓存
hibernate分页有现成的支持:

query.setFirstResult(start);
query.setMaxResults(rowNum);

MySql如下:

select * from table where limit start,rowNum;

Oracle如下

select * from table where and rowid not in(select rowid from t_table where …. and rownum<= (pageIndex-1) * size)
and rownum <= size;
PageBean以前是设置currentPage,然后在页面里自己判断上一页下一页是什么,后来发现纯粹多余,完全可以把目标页写进去,而且参数也统一了,以前页面传到Action有好几个参数:

if(method.equals(“lastPage“)){

}else if(method.equals(“nextPage“)){

}else if(method.equals(“targetPage“)){
//.
}

现在统一一个参数就是pageIndex,爽多了
PageBean代码如下:

int currentPage = 1;//当前页:Action控制
    int totalPages = 0;//总页数 :自己运算
    public static int pageRecorders = 10; //每页记录数,默认为10,可以在初始化的时候修改//总数据数
    int pageStartRow = 0; //每页的起始数 [这个字段可以去掉]
    int pageEndRow = 0; //每页显示数据的终止数 [这个字段也可以去掉]
    boolean hasNextPage = false; //是否有下一页:自己运算
    boolean hasPreviousPage = false; //是否有前一页 :自己运算
    List objList = new ArrayList();//存放欲展示的对象列表
    int totalRows;//总记录数,由底层service提供

//增加上一页索引 [directly to target page]
private int lastPageIndex = 1;
//增加下一页索引 [directly to target page]
private int nextPageIndex = 1;

public int getLastPageIndex() {
return currentPage - 1;
}

public int getNextPageIndex() {
return currentPage + 1;
}

//是否有上一页
public boolean isHasPreviousPage() {
return (currentPage > 1 ? true : false);
}

//共有多少页,service只提供有多少条记录,多少页数由PageBean自己运算
public int getTotalPages() {
if (totalRows <= pageRecorders) return 1;
return (totalRows % pageRecorders == 0 ? totalRows / pageRecorders : totalRows / pageRecorders + 1);
}

public int getCurrentPage() {
return currentPage;
}

public int getPageEndRow() {
return pageEndRow;
}

//是否有下一页
public boolean isHasNextPage() {
return (currentPage < this.getTotalPages() ? true : false);
}

public int getTotalRows() {
return totalRows;
}

public int getPageStartRow() {
return pageStartRow;
}

public int getPageRecorders() {
return pageRecorders;
}

public void setObjList(List objList) {
this.objList = objList;
}

public void setHasPreviousPage(boolean hasPreviousPage) {
this.hasPreviousPage = hasPreviousPage;
}

public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}

public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}

public void setPageEndRow(int pageEndRow) {
this.pageEndRow = pageEndRow;
}

public void setHasNextPage(boolean hasNextPage) {
this.hasNextPage = hasNextPage;
}

public void setTotalRows(int totalRows) {
this.totalRows = totalRows;
}

public void setPageStartRow(int pageStartRow) {
this.pageStartRow = pageStartRow;
}

public void setPageRecorders(int pageRecorders) {
this.pageRecorders = pageRecorders;
}

public List getObjList() {
return objList;
}
}
在action中负责把pageIndex传给PageBean,以及通过service得到的记录总数传给pageBean就OK了

补充:另,在IDEA中文站上看到一篇文章分页，心中的痛？提到用一个统一的接口来规范:
代码如下:

public interface Page {
boolean isFirstPage();
boolean isLastPage();
boolean hasNextPage();
boolean hasPreviousPage();
int getLastPageNumber();
Object getThisPageElements();
int getTotalNumberOfElements();
int getThisPageFirstElementNumber();
int getThisPageLastElementNumber();
int getNextPageNumber();
int getPreviousPageNumber();
int getPageSize();
int getThisPageNumber ();
}
个人感觉思想挺好,不过我还是喜欢用一个PageBean类就足够了,没必要搞复杂了,在PageBean中其实是currentPage为核心.

一个工具能够在任何地方都能容易的嵌入进去,这就很小巧了,也就够用了.

简单的错误

Alex — Thu, 30 Mar 2006 06:20:23 +0000

想用缓存又不想用oscache觉得
麻烦,自己写了个简单的缓存,不小心发现getAllCity结果总是在第一次进去的时候数量加倍,第二次就好了,真实怪事.

代码如下:

public static List getAllCity(boolean bInit) throws XXException {
List cityList = new ArrayList();
if (null == CityInfos || CityInfos.size() == 0) bInit = true;
synchronized (CityInfos) {
if (bInit) { //retrieve city info from database
CityService service = new CityService();
cityList = service.getAllCitys();
CityInfos.clear();
if (null != cityList && cityList.size() > 0) {
log.info(“========“ + “cityList size : “ + cityList.size() + “========“);
for (Iterator it = cityList.iterator(); it.hasNext();) {
CityVo cityVo = (CityVo) it.next();
CityInfos.put(cityVo.getId(), cityVo);
}
}
}

cityList.addAll(CityInfos.values());
}
return cityList;
}
CityInfos是一个static Hashtable,查了下原来是共用了cityList,将synchronized 里面的cityList 改成
List tmpCityList 就可以了为什么会犯低级错误呢?

Struts中Action的一个笔误造成莫名的错误.

Alex — Sun, 05 Mar 2006 06:24:14 +0000

keyword: struts错误,持续构建,checkbox

前天在运行应用时有一个页面一点button就转到系统错误页面,折腾了好半天,在Action里打桩调试连调试信息都见不到,还以为时log4j配置出了问题,改来改去也不知道原因在哪,最后检查居然时在Action里用错了Form,哎,真是要命.回忆了一下,以前这个地方一直正常,怎么这次修改了别的地方就影响到这了呢,记忆中好像是因为做了一次重构不小心在批量修改的时候把这里给改了.

现在总结一下Struts里可能常出现的错误的原因:

1.配置文件里的input或者forward写错
2.jsp里的Action对应的.do写错,实际就是对应的Form也错了
3.Action里Form写错,或者forward为空
4.还有Form里的属性和jsp页面的属性不一致

经过这次的教训也让我有了一个以前不怎么重视的想法要实现,就是持续构建,如果有了持续构建我的每一次的提交都有报告和分析结果出来,防患于未然,也不至于让我折腾半天为了一行代码.
方案就选maven + cc .

目前国内用的多么?没有调查过,不过就我目前了解到的情况,好多公司的做法真是让人觉得有点shit,但愿越来越好,越来越规范.

写到这里又想起一个关于jsp的checkbox问题,例如,在一个产品删除的页面里,每条记录前面有一个checkbox,我们一般的做法是给checkbox的value赋值为产品ID的值,然后Action根据ID就可以直接删除产品了,但是问题是有时候我除了需要删除这个产品,同时还需要在下一个页面里再将当前页面的东西显示一次,让用户确认,就还需要除产品ID以外的信息了,该怎么办呢? 我以前有一个比较笨的办法就是在value里拼数据,
比如id | name | quantity | other,最后在Action里再解析,现在想来其实没有必要,可以用里的indexId属性来做。
具体请参看这里:
这里贴下关键部分的代码:
jsp代码:

<logic:iterate id=”testqclist” name=”testQCActionForm” property=”result” indexId=”index” >
<tr bgcolor=”#FFFFFF”>
<td height=”26″ bgcolor=”#EEEEEE”>
<div align= ”center” >
<input type=”checkbox” name=”checkboxVal” value=”<%=index%>” >div>
td>
tr>
logic:iterate>

Action代码: [原文作者写在Form里实现，不过我个人喜欢在Action里做，看你情况了]

if (checkboxVal != null && checkboxVal.length > 0){

      for (int i = 0; i < checkboxVal.length; i++){

        int chkVal = Integer.parseInt(checkboxVal[i]); //取得checkbox的index值

        //……………………..
        checkform.setSaamsampleid (datesampledVal[chkVal].toString());//取得和checkbox为true的其他属性的值

        checkform.setSaamsampleid(saamsampleidVal[chkVal].toString());

        //………………………………………………

      }

    }

log4j配置

Alex — Thu, 16 Feb 2006 06:38:20 +0000

log4j配置,原来以为需要程序种写config,实际上不用,只要提供配置文件放到classpath下即可,示例配置如下:

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file hibernate.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=hibernate.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change ’info’ to ’debug’ ###

log4j.rootLogger=info,stdout,file

log4j.logger.net.sf.hibernate=info

### log just the SQL
#log4j.logger.net.sf.hibernate.SQL=debug

### log JDBC bind parameters ###
log4j.logger.net.sf.hibernate.type=info

### log schema export/update ###
log4j.logger.net.sf.hibernate.tool.hbm2ddl=debug

### log cache activity ###
#log4j.logger.net.sf.hibernate.cache=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.net.sf.hibernate.connection.DriverManagerConnectionProvider=trace

颠覆软件 » java开发技术

谈谈方法中的返回值类型和参数类型

[zt]插入图片到数据库(BLOB大字段保存对象)

[zt]用JSP实现上传文件的两种方法

jsp防盗链

真正理解面向接口编程

上传文件放在哪里比较合适?

web快速开发相关技术和产品

[zt]关于commons logging

jstl标签注意问题

Unsupported major.minor version 49.0错误

解决response.sendRedirect(“mypage.jsp”)的问题

[zt]关于用户角色权限的一点想法

[zt]RBAC 模型初探

谈谈 Facade与Proxy的联系与区别

关于Facade的应用

[zt]设计模式之Visitor 访问者模式

设计模式之Visitor

DAO模式演变

[zt]Java 学习方法浅谈

Oracle分页的一个问题

[zt]领域相关的模型里面需要3种对象

[zt]关于Cookie跨域操作遇到的问题及解决方法

[zt]做设计的步骤

[zt]从工作流状态机实践中总结状态模式使用心得

从工作流状态机实践中总结状态模式使用心得

web开发的瑞士军刀 javawebparts

用Digester解析xml到bean

[zt]JDBMonitor全攻略

入门

取得 JDBMonitor

使用 JDBMonitor

举例

mvnforum的例子：

(1)打开http://localhost:8080/jive/admin/

“jdbc” 填为：com.cownew.JDBMonitor.jdbc.DBDriver

“server” 填为：c:/log/jdbmonitor/config.xml:url=jdbc:mysql://locahost/jive (2)将 jdbmonitor.jar放到WEB-INF\lib下 (3) 象mvnforum中一样创建同样的 c:/log/jdbmonitor/config.xml 文件. (4) 搞定!

监听器

FAQ:

如何扩展JDBMonitor？

关于java与javaScript的互相访问

POI的一个bug问题

[zt]可编程的热部署问题

两则:切割字符串；用DecimalFormat格式化字符

jsp实现文件下载与中文文件名乱码问题解决

HttpClient通过ldap验证

用开源组件jcaptcha做jsp彩色验证码

javamail整理

文件上传:用O’Reilly公司的cos实现文件上传

[zt]Struts中防止任意形式的重复提交

分页继续[数据库分页和PageBean的改进]

简单的错误

Struts中Action的一个笔误造成莫名的错误.

log4j配置

“server” 填为：c:/log/jdbmonitor/config.xml:url=jdbc:mysql://locahost/jive
(2)将 jdbmonitor.jar放到WEB-INF\lib下
(3) 象mvnforum中一样创建同样的 c:/log/jdbmonitor/config.xml 文件.
(4) 搞定!