LifeNote Java技术博客

迎奥运，抗雪灾，援震灾

LifeNote — Wed, 14 May 2008 11:25:00 +0800

今年中国实在多灾多难，2008注定是特别的一年，先是年前南方五十年不遇的特大雪灾，春天般的温暖刚刚融化了南方的暴雪，紧接着是西藏骚乱，整个西方都在谴责中国，为了阻止中国奥运还有人抢奥运火炬。接下来火车又出现大事故，胶济铁路两列火车相撞导致火车出轨，然后是全国数万人感染手足口病，现在则是几十年一遇的特大地震，地震达到了1976年唐山大地震的震级。五个月时间，各种天灾人祸纷纷上演。。。看来，2008的中国依真是多灾多难啊。我们真心的希望灾难就截止在2008年的5月这场大地震吧！

一场里氏7.8级的特大地震昨天14时28分在中国的四川省爆发，台湾媒体用”半个亚洲”形容这次地壳晃动的波及面，直接有震感的地区远及泰国的曼谷和越南的河内。截止现在为止，死亡人数接近10000人。震级与32年前唐山大地震相同，相当于400颗美国1945年投在广岛的原子弹，四川现在是什么样的了，在这里阿草哥通过支付宝的李连杰壹基金计划想震灾人民捐赠50元人民币钱不多但希望通过我自己的一份力量支援灾区

最后让我们一起祈祷吧，2008年从此一切顺利！

补充一下：终于接到了个feedsky的话题还是个公益话题的，顺便就拿这个当作话题广告吧！

LifeNote 2008-05-14 11:25 发表评论

奥运火炬传全球

LifeNote — Fri, 25 Apr 2008 10:08:00 +0800

很就没有收到feedsky的话题广告了，昨天发现GTalk弹出一个提示feedsky话题广告，非常高兴，于是豪不犹豫的接受了这个话题广告！
在今年 3 月底完成希腊雅典点火与北京交接仪式之后，2008 全球火炬接力已经开始了它经历世界 134 个城市、长达四个月的接力旅程，以完成在全球传递友谊与和平讯息的使命。为此，Google 携手本届运动会的官方互联网转播机构央视国际 CCTV.com , 推出简体中文版的” 2008全球火炬接力报道路线图“(测试版本)。中文繁体以及英、法、西、意、荷等其它五种语言的版本也将于近日在全球推出，以方便世界各国的人们通过 Google 地图产品与技术平台, 来追踪圣火传递路线，畅游接力途经全部城市，并在线观看来自 CCTV.com 的每一地的接力视频
关于这一路线图的亮点：
1.全程路线追踪：你将可以随着它，清晰看到接力全程路线和到达日期，其中的红色路线代表接力已经走过的部分。
2.城市详情：点击图中的每个城市点或者右侧的城市列表，一个小窗口会打开，你可以在这里了解接力路线上这一城市的基本状况、浏览城市风景图片，以及层层推进看到这个城市详细的地图。点击其中的相关链接如”更多城市图片”，你还可以直接看到用这个城市名在谷歌搜索图片的结果。如果您要了解更多的内容请点击这里

以下是本站的 2008全球火炬接力报道路线图

" width="760px" height="520px" frameborder="0" scrolling="no" marginheight="0" marginwidth="0" />

LifeNote 2008-04-25 10:08 发表评论

Eclipse下的Java反编译插件：Jode Decompiler

LifeNote — Thu, 24 Apr 2008 15:05:00 +0800

这个工具感觉非常方便介绍给大家
安装方法：
help => Software Updates => Find and Install... => Search for new features to install,单击"New Remote Site..." 在URL栏输入 http://www.technoetic.com/eclipse/update.然后下一步，就可以看到“jode decompiler plugin *.*”，选上安装就可以了。

安装好后可以看到Window => Preferences... => Java => Jode Decompiler选项卡。

配置：Window => Preferences... => General => Editors => File Associations找到"*.class"在"Associated editors"里面可以看到"Jode class file viewer"选中它再单击Default按钮.

在Eclipse中展开jar文件,双击class文件即可看到反编译之后的源代码.

LifeNote 2008-04-24 15:05 发表评论

Java数据库操作基本流程

LifeNote — Thu, 24 Apr 2008 10:36:00 +0800

1.Java数据库操作基本流程
a .数据库连接1.Drivermanager 链接数据库
String className,url,uid,pwd;
className="Oracle.jdbc.driver.OracleDriver";
uid="scott";
pwd="tiger";
url="jdbc:oracle:thin:@localhost:1521:ora92";
Class.forName(classname);
Connection conn=DriverManager.getConnection(url,uid,pwd);
2.JNDI链接数据库
String jndi ="jdbc/db"; // e20-040 9L0-609 数据源的名称
//context是一组名称到对象的绑定组成
Hashtable env=new Hashtable ();
Context ctx=(Context)new InitialContext.lookup("env");// 获得数据源所在的上下文点的对象
DataSource ds=(DataSource)ctx.lookup(jndi);//找到数据源

Connection conn=ds.getConnection();//
b.执行 sql语句
String sql;
StateMent stat=conn.createStatement();
ResultSet rs=stat.executeQuery(sql);//执行数据的查询语句(select);
stat.executeUpdate(sql);//执行数据的更新语句(inset into ,delete ,update ,drop)
stat.close();
c.用preparedStatement 来执行sql语句
String sql="inset into table(id,name) values(?,?)";
PreparedStatement ps=conn.prepareStatement(sql);
ps.setInt(1,001);
ps.setString(2,"zhangmanli");

ps.executeQuery();
int count=ps.executeUpdate();
d.处理执行结果
查询语句，返回记录集ResultSet对象
更新语句，返回数字，表示该更新影响的记录数
javax.sql.*
javax.naming.*;
数据处理：
1关闭connection 的自动提交
conn.setAutoCommit(false);
2执行一系列sql 语句，
Statement sm;
sm=conn.createStatement(sql);
sm.executeUpdate();
sm.close();

3.提交：
conn.commit();
4.回滚机制；
conn.rollback();
e:线程处理：
D：jndi和dataSource 来获得数据库的链接：
import java.sql.ResultSet ;
import java.sql.*;
import javax.sql.DataSource;
import javax.naming.Context;
import javax.naming.InitialContext;
import java.util.Hashtable;
import java.util.Properties;
import java.io.*;
public class BasicExample{
public static void main(String args[]){
Connection conn=null;
try{
   Properties prop =new Properties();
   prop.load(new FileInputStream("simple.properties"));
   Hashtable env =new Hashtable();
   env.put(Context.INITIAL_CONTEXT_FACTORY,prop.getProperty("INITIAL_CONTEXT_FACTORY"));
   env.put(Context.PROVIDER_URL,prop.getProperty("PROVIDER_URL"));
   InitialContext ctx=new InitialContext(env);
DataSource ds=(DataSource)ctx.lookup("Book");

   Conn=ds.getConnection();
   Statement stat=conn.createStatement();;
   ResultSet rs=stmt.executeQuery(sql);
   while(rs.next()){
    int id=Integer.parseInt(rs.getString("userId"));
    String userName=rs.getString ("username");

   }
}catch(SQLException e){
   e.printStackTrace();
}finally{
   try{
    if(conn!=null){
     conn.close();
    }
   }catch(SQLException e){
    e.printStackTrace();
   }
}
}
};

LifeNote 2008-04-24 10:36 发表评论

使用动态代理实现用AOP对数据库进行操作

LifeNote — Tue, 22 Apr 2008 09:54:00 +0800

要实现对数据库的操作，离不开数据源（DataSource）或者连接（Connection）,但是通常来说对数据库的操作都应该放在DAO中，而DAO又不应该与应用服务器相关联，所以一般都使用连接（Connection）。现在我们这里就有一个问题了，怎么在拦截器中获得连接。我想可以通过两种方式获得：
在分别讨论这两种方法之前，我们需要先讨论一下在处理数据库的时候的异常的处理。我这里做了一个TransactionException继承至RuntimeException然后在拦截器里面抛出，再又应用框架处理这个异常。下面试这个类的代码：
public class TransactionException extends RuntimeException {
    private Throwable superException;
    private String myMessage;

    public TransactionException(Throwable throwable){
        super(throwable);
        this.superException = throwable;
    }

    public TransactionException(Throwable throwable,String message){
        super(message,throwable);
        this.superException = throwable;
        this.myMessage = message;
    }

    /**
     * @return Returns the myMessage.
     */
    public String getMessage() {
        return myMessage;
    }

    /**
     * @return Returns the superException.
     */
    public Throwable getSuperException() {
        return superException;
    }

    /**
     * @param myMessage The myMessage to set.
     */
    public void setMyMessage(String message) {
        this.myMessage = message;
    }

    /**
     * @param superException The superException to set.
     */
    public void setSuperException(Throwable superException) {
        this.superException = superException;
    }


}
1）    通过方法的第一个参数传进去
l    DAO
import java.sql.Connection;

public class TestDao {
    public void insertA(Connection con,String a,String b,……){
        …………………………………………
一系列操作
…………………………………………
    }

    public String queryA(Connection con,…….){
    …………………………………………
一系列操作
…………………………………………
}

    public void updateA(Connection con,…….){
        …………………………………………
一系列操作
…………………………………………
}
}

l    拦截器
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class TransactionInterceptor implements Interceptor {

    public void before(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = (Connection) invInfo.getArgs()[0];
            try {
                conn.setAutoCommit(false);
            } catch (SQLException e) {
                throw new TransactionException(e);
            }
        }
    }

    public void after(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = (Connection) invInfo.getArgs()[0];
            try {
                conn.commit();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    public void exceptionThrow(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = (Connection) invInfo.getArgs()[0];
            try {
                conn.rollback();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    private List getNeedTransaction(){
        List needTransactions = new ArrayList();
        needTransactions.add("insert");
        needTransactions.add("update");
        return needTransactions;
    }

    private boolean isNeedTransactions(InvokeJniInfo invInfo){
        String needTransaction = "";
        List needTransactions = getNeedTransaction();
        for(int i = 0;i             needTransaction = (String)needTransactions.get(i);
            if(invInfo.getMethod().getName().startsWith(needTransaction)){
                return true;
            }
        }
        return false;
    }
}

需要注意的是：getNeedTransaction就是需要进行事务处理的方法的开头，这个方法可以写成一个从配置文件里面去读，这里我就写死在里面了。只是对insert和update开头的方法进行事务控制。
2）    将Connection对象放在ThreadLocal中
l    ConnectionUtil类：
import java.sql.Connection;

public final class ConnectionUtil {
    private static ThreadLocal connections = new ThreadLocal();
    public static Connection getConnection(){
        Connection conn = null;
        conn = (Connection) connections.get();
        if(conn == null){
            conn = getRealConnection();
            connections.set(conn);
        }
        return conn;
    }
    public static void realseConnection(Connection conn){
        connections.set(null);
    }
    private static Connection getRealConnection() {
        实现自己获取连接的代码
        return null;
    }
}
l    DAO类
public class TestDao {
    public void insertA(String a,String b){
        Connection conn = getConnection();
        …………………………………………
一系列操作
…………………………………………
    }
        public String queryA(Connection con,…….){
        Connection conn = getConnection();
    …………………………………………
一系列操作
…………………………………………
}

    public void updateA(Connection con,…….){
Connection conn = getConnection();
        …………………………………………
一系列操作
…………………………………………
}

    private Connection getConnection(){
        return ConnectionUtil.getConnection();
    }

}
l    拦截器
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class TransactionInterceptor implements Interceptor {

    public void before(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = getConnection();
            try {
                conn.setAutoCommit(false);
            } catch (SQLException e) {
                throw new TransactionException(e);
            }
        }
    }

    public void after(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = getConnection();
            try {
                conn.commit();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                        releaseConnection(conn);
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    public void exceptionThrow(InvokeJniInfo invInfo) {
        if(isNeedTransactions(invInfo)){
            Connection conn = getConnection();
            try {
                conn.rollback();
            } catch (SQLException e) {
                throw new TransactionException(e);
            }finally{
                if(conn != null){
                    try {
                        conn.close();
                        releaseConnection(conn);
                    } catch (SQLException e) {
                        throw new TransactionException(e,"Close Connection is failure!");
                    }
                }
            }
        }
    }

    private Connection getConnection(){
        return ConnectionUtil.getConnection();
    }

    private void releaseConnection(Connection conn){
        ConnectionUtil.releaseConnection(conn);
    }
    private List getNeedTransaction(){
        List needTransactions = new ArrayList();
        needTransactions.add("insert");
        needTransactions.add("update");
        return needTransactions;
    }

    private boolean isNeedTransactions(InvokeJniInfo invInfo){
        String needTransaction = "";
        List needTransactions = getNeedTransaction();
        for(int i = 0;i             needTransaction = (String)needTransactions.get(i);
            if(invInfo.getMethod().getName().startsWith(needTransaction)){
                return true;
            }
        }
        return false;
    }
}
    最后将这个拦截器添加到AOP拦截框架中去，InterceptorHandler类中的getIntercetors方法中添加一个：

    private synchronized List getIntercetors(){
        if(null == interceptors){
            interceptors = new ArrayList();
            ……………………………………
interceptors.add(new TransactionInterceptor ());
            ……………………………………
        }
        return interceptors;
}

LifeNote 2008-04-22 09:54 发表评论

如何获得鼠标的当前位置

LifeNote — Thu, 27 Mar 2008 16:52:00 +0800

用window.event对象的属性，总共有四对属性用来取得鼠标位置,分别是：
clientX和clientY screenX和screenY offsetX和offsetY x和y
一 clientX和clientY
设置或接收相对于浏览器窗口客户区的鼠标x、y坐标，客户区不包括窗口滚动条及边框
大小(MSDN原文:Sets or retrieves the x-coordinate/y-coordinate of the mouse
pointer's position relative to the client area of the window, excluding
window decorations and scroll bars.)

在IE4里，这一对属性只读不可写，IE5及以后版本里则可读可写(MSDN原文:The
property is read-only in Microsoft® Internet Explorer 4.0, and read/write
in Microsoft® Internet Explorer 5 and later.)

语法: event.clientX=[iPos] event.clientY=[iPos] iPos应该是一个整数

二 screenX和screenY
设置或接收相对于用户屏幕的鼠标坐标

在IE4里，这一对属性只读不可写，IE5及以后版本里则可读可写

语法: event.screenX=[iSize] event.screenY=[iSize] iSize应该是一个整数

三 offsetX和offsetY
设置或接收鼠标指针在鼠标所在的元素上的偏移量

在IE4里，这一对属性只读不可写，IE5及以后版本里则可读可写

语法: event.screenX=[iCoord] event.screenY=[iCoord] iCoord应该是一个整数

四 x和y
设置或接收相对于鼠标所在的元素的父元素的坐标(MSDN原文:Sets or retrieves
the x-coordinate, in pixels, of the mouse pointer's position relative to
the parent element.)

在IE4里，这一对属性只读不可写，IE5及以后版本里则可读可写,但IE5以前的版式本里
x和y坐标并不相对于鼠标所在的元素的父元素，只相对于浏览器窗口的客户区

如果在检测鼠标位置时，鼠标却在浏览器窗口的外面，则x和y都返回-1

LifeNote 2008-03-27 16:52 发表评论

Javascript----文件操作

LifeNote — Tue, 25 Mar 2008 09:39:00 +0800

一、功能实现核心：FileSystemObject 对象
要在javascript中实现文件操作功能，主要就是依靠FileSystemobject对象。
二、FileSystemObject编程
使用FileSystemObject 对象进行编程很简单，一般要经过如下的步骤：创建FileSystemObject对象、应用相关方法、访问对象相关属性。
（一）创建FileSystemObject对象
创建FileSystemObject对象的代码只要1行：
var fso = new ActiveXObject("Scripting.FileSystemObject");
上述代码执行后，fso就成为一个FileSystemObject对象实例。
（二）应用相关方法
创建对象实例后，就可以使用对象的相关方法了。比如，使用CreateTextFile方法创建一个文本文件：
var fso = new ActiveXObject("Scripting.FileSystemObject");
var f1 = fso.createtextfile("c:\\myjstest.txt",true");
（三）访问对象相关属性
要访问对象的相关属性，首先要建立指向对象的句柄，这就要通过get系列方法实现：GetDrive负责获取驱动器信息，GetFolder负责获取文件夹信息，GetFile负责获取文件信息。比如，指向下面的代码后，f1就成为指向文件c:\test.txt的句柄：
var fso = new ActiveXObject("Scripting.FileSystemObject");
var f1 = fso.GetFile("c:\\myjstest.txt");
然后，使用f1访问对象的相关属性。比如：
var fso = new ActiveXObject("Scripting.FileSystemObject");
var f1 = fso.GetFile("c:\\myjstest.txt");
alert("File last modified: " + f1.DateLastModified);
执行上面最后一句后，将显示c:\myjstest.txt的最后修改日期属性值。
但有一点请注意：对于使用create方法建立的对象，就不必再使用get方法获取对象句柄了，这时直接使用create方法建立的句柄名称就可以：
var fso = new ActiveXObject("Scripting.FileSystemObject");
var f1 = fso.createtextfile("c:\\myjstest.txt",true");
alert("File last modified: " + f1.DateLastModified);
三、操作驱动器（Drives）
使用FileSystemObject对象来编程操作驱动器（Drives）和文件夹（Folders）很容易，这就象在Windows文件浏览器中对文件进行交互操作一样，比如：拷贝、移动文件夹，获取文件夹的属性。
（一）Drives对象属性
Drive对象负责收集系统中的物理或逻辑驱动器资源内容，它具有如下属性：
l TotalSize：以字节（byte）为单位计算的驱动器大小。
l AvailableSpace或FreeSpace：以字节（byte）为单位计算的驱动器可用空间。
l DriveLetter：驱动器字母。
l DriveType：驱动器类型，取值为：removable（移动介质）、fixed（固定介质）、network（网络资源）、CD-ROM或者RAM盘。
l SerialNumber：驱动器的系列码。
l FileSystem：所在驱动器的文件系统类型，取值为FAT、FAT32和NTFS。
l IsReady：驱动器是否可用。
l ShareName：共享名称。
l VolumeName：卷标名称。
l Path和RootFolder：驱动器的路径或者根目录名称。
（二）Drive对象操作例程
下面的例程显示驱动器C的卷标、总容量和可用空间等信息：
var fso, drv, s ="";
fso = new ActiveXObject("Scripting.FileSystemObject");
drv = fso.GetDrive(fso.GetDriveName("c:\\"));
s += "Drive C:" + " - ";
s += drv.VolumeName + "\n";
s += "Total Space: " + drv.TotalSize / 1024;
s += " Kb" + "\n";
s += "Free Space: " + drv.FreeSpace / 1024;
s += " Kb" + "\n";
alert(s);
四、操作文件夹（Folders）
涉及到文件夹的操作包括创建、移动、删除以及获取相关属性。
Folder对象操作例程 :
下面的例程将练习获取父文件夹名称、创建文件夹、删除文件夹、判断是否为根目录等操作：
var fso, fldr, s = "";
// 创建FileSystemObject对象实例
fso = new ActiveXObject("Scripting.FileSystemObject");
// 获取Drive 对象
fldr = fso.GetFolder("c:\\");
// 显示父目录名称
alert("Parent folder name is: " + fldr + "\n");
// 显示所在drive名称
alert("Contained on drive " + fldr.Drive + "\n");
// 判断是否为根目录
if (fldr.IsRootFolder)
alert("This is the root folder.");
else
alert("This folder isn't a root folder.");
alert("\n\n");
// 创建新文件夹
fso.CreateFolder ("C:\\Bogus");
alert("Created folder C:\\Bogus" + "\n");
// 显示文件夹基础名称，不包含路径名
alert("Basename = " + fso.GetBaseName("c:\\bogus") + "\n");
// 删除创建的文件夹
fso.DeleteFolder ("C:\\Bogus");
alert("Deleted folder C:\\Bogus" + "\n");
五、操作文件（Files）
对文件进行的操作要比以上介绍的驱动器（Drive）和文件夹（Folder）操作复杂些，基本上分为以下两个类别：对文件的创建、拷贝、移动、删除操作和对文件内容的创建、添加、删除和读取操作。下面分别详细介绍。
（一）创建文件
一共有3种方法可用于创建一个空文本文件，这种文件有时候也叫做文本流（text stream）。
第一种是使用CreateTextFile方法。代码如下：
var fso, f1;
fso = new ActiveXObject("Scripting.FileSystemObject");
f1 = fso.CreateTextFile("c:\\testfile.txt", true);
第二种是使用OpenTextFile方法，并添加上ForWriting属性，ForWriting的值为2。代码如下：
var fso, ts;
var ForWriting= 2;
fso = new ActiveXObject("Scripting.FileSystemObject");
ts = fso.OpenTextFile("c:\\test.txt", ForWriting, true);
第三种是使用OpenAsTextStream方法，同样要设置好ForWriting属性。代码如下：
var fso, f1, ts;
var ForWriting = 2;
fso = new ActiveXObject("Scripting.FileSystemObject");
fso.CreateTextFile ("c:\\test1.txt");
f1 = fso.GetFile("c:\\test1.txt");
ts = f1.OpenAsTextStream(ForWriting, true);
（二）添加数据到文件
当文件被创建后，一般要按照“打开文件－>填写数据－>关闭文件”的步骤实现添加数据到文件的目的。
打开文件可使用FileSystemObject对象的OpenTextFile方法，或者使用File对象的OpenAsTextStream方法。
填写数据要使用到TextStream对象的Write、WriteLine或者WriteBlankLines方法。在同是实现写入数据的功能下，这3者的区别在于：Write方法不在写入数据末尾添加新换行符，WriteLine方法要在最后添加一个新换行符，而WriteBlankLines则增加一个或者多个空行。
关闭文件可使用TextStream对象的Close方法。
（三）创建文件及添加数据例程
下面的代码将创建文件、添加数据、关闭文件几个步骤结合起来进行应用：
var fso, tf;
fso = new ActiveXObject("Scripting.FileSystemObject");
// 创建新文件
tf = fso.CreateTextFile("c:\\testfile.txt", true);
// 填写数据，并增加换行符
tf.WriteLine("Testing 1, 2, 3.") ;
// 增加3个空行
tf.WriteBlankLines(3) ;
// 填写一行，不带换行符
tf.Write ("This is a test.");
// 关闭文件
tf.Close();
（四）读取文件内容
从文本文件中读取数据要使用TextStream对象的Read、ReadLine或ReadAll 方法。Read方法用于读取文件中指定数量的字符；ReadLine方法读取一整行，但不包括换行符；ReadAll方法则读取文本文件的整个内容。读取的内容存放于字符串变量中，用于显示、分析。在使用Read或ReadLine方法读取文件内容时，如果要跳过一些部分，就要用到Skip或SkipLine方法。
下面的代码演示打开文件、填写数据，然后读取数据：
var fso, f1, ts, s;
var ForReading = 1;
fso = new ActiveXObject("Scripting.FileSystemObject");
// 创建文件
f1 = fso.CreateTextFile("c:\\testfile.txt", true);
// 填写一行数据
f1.WriteLine("Hello World");
f1.WriteBlankLines(1);
// 关闭文件
f1.Close();
// 打开文件
ts = fso.OpenTextFile("c:\\testfile.txt", ForReading);
// 读取文件一行内容到字符串
s = ts.ReadLine();
// 显示字符串信息
alert("File contents = '" + s + "'");
// 关闭文件
ts.Close();
（五）移动、拷贝和删除文件
对于以上三种文件操作，javascript各有两种对应的方法：File.Move 或 FileSystemObject.MoveFile用于移动文件；File.Copy 或 FileSystemObject.CopyFile用于拷贝文件；File.Delete 或 FileSystemObject.DeleteFile用于删除文件。
下面的代码演示在驱动器C的根目录下创建一个文本文件，填写一些内容，然后将文件移动到\tmp目录下，再在目录\temp下面建立一个文件拷贝，最后删除这两个目录的文件：
var fso, f1, f2, s;
fso = new ActiveXObject("Scripting.FileSystemObject");
f1 = fso.CreateTextFile("c:\\testfile.txt", true);
// 写一行
f1.Write("This is a test.");
// 关闭文件
f1.Close();
// 获取C:\根目录下的文件句柄
f2 = fso.GetFile("c:\\testfile.txt");
// 移动文件到\tmp目录下
f2.Move ("c:\\tmp\\testfile.txt");
// 拷贝文件到\temp目录下
f2.Copy ("c:\\temp\\testfile.txt");
// 获取文件句柄
f2 = fso.GetFile("c:\\tmp\\testfile.txt");
f3 = fso.GetFile("c:\\temp\\testfile.txt");
// 删除文件
f2.Delete();
f3.Delete();
六、结语
通过以上对FileSystemObject的各种对象、属性和方法的介绍和示例，相信你已经对如何使用javascript语言在页面中操作驱动器、文件和文件夹有了清晰的认识。但是上述提及的例程都非常简单，要全面、灵活地掌握javascript文件操作技术，还需要大量的实践练习。而且还有一点提醒大家，由于涉及到在浏览器中进行文件读写这样的高级操作，对于默认的浏览器安全级别而言，在代码运行前都会有一个信息提示，这点请在实际环境中提示访问者注意。

LifeNote 2008-03-25 09:39 发表评论

Hibernate中Criteria的完整用法

LifeNote — Wed, 12 Mar 2008 15:24:00 +0800

最近在项目中使用 Spring 和 Hibernate 进行开发，有感于 Criteria 比较好用，在查询方法

设计上可以灵活的根据 Criteria 的特点来方便地进行查询条件的组装。现在对 Hibernate的Criteria 的用法进行总结：
   Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口，下面提供了 Criteria和DetachedCriteria 。
   Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所
以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需
Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name)
进行DetachedCriteria 实例的创建。 Spring 的框架提供了getHibernateTemplate
().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结
果。
   Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设
置 FetchMode( 联合查询抓取的模式 ) ，设置排序方式。对于 Criteria 还可以设置 FlushModel
（冲刷 Session 的方式）和 LockMode （数据库锁模式）。
下面对 Criterion 和 Projection 进行详细说明。
     Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来
添加查询条件。
     Criterion 接口的主要实现包括： Example 、 Junction 和 SimpleExpression 。而
Junction 的实际使用是它的两个子类 conjunction 和 disjunction ，分别是使用 AND 和 OR 操
作符进行来联结查询条件集合。
     Criterion 的实例可以通过 Restrictions 工具类来创建，Restrictions 提供了大量的静态
方法，如 eq （等于）、 ge （大于等于）、 between 等来方法的创建 Criterion 查询条件
（SimpleExpression 实例）。除此之外， Restrictions 还提供了方法来创建 conjunction 和
disjunction 实例，通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合
。
     至于 Example 的创建有所不同， Example 本身提供了一个静态方法 create(Object
entity) ，即根据一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设置一些
过滤条件：
Example exampleUser =Example.create(u)
.ignoreCase() // 忽略大小写
.enableLike(MatchMode.ANYWHERE);
// 对 String 类型的属性，无论在那里值在那里都匹配。相当于 %value%
Project 主要是让 Criteria 能够进行报表查询，并可以实现分组。 Project 主要有
SimpleProjection 、 ProjectionList 和 Property 三个实现。其中 SimpleProjection 和
ProjectionList 的实例化是由内建的 Projections 来完成，如提供的 avg 、 count 、 max 、
min 、 sum 可以让开发者很容易对某个字段进行统计查询。
       Property 是对某个字段进行查询条件的设置，如通过Porperty.forName(“color”).in
(new String[]{“black”,”red”,”write”}); 则可以创建一个 Project 实例。通过
criteria 的 add(Project) 方法加入到查询条件中去。
    使用 Criteria 进行查询，主要要清晰的是 Hibernate 提供了那些类和方法来满足开发中查
询条件的创建和组装，下面介绍几种用法：
1. 创建一个Criteria 实例
org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。
Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

2. 限制结果集内容
一个单独的查询条件是org.hibernate.criterion.Criterion 接口的一个实例。

org.hibernate.criterion.Restrictions类定义了获得某些内置Criterion类型的工厂方法。
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.between("weight", minWeight, maxWeight) )
    .list();

约束可以按逻辑分组。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.or(
        Restrictions.eq( "age", new Integer(0) ),
        Restrictions.isNull("age")
    ) )
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
    .add( Restrictions.disjunction()
        .add( Restrictions.isNull("age") )
        .add( Restrictions.eq("age", new Integer(0) ) )
        .add( Restrictions.eq("age", new Integer(1) ) )
        .add( Restrictions.eq("age", new Integer(2) ) )
    ) )
    .list();

Hibernate提供了相当多的内置criterion类型(Restrictions 子类), 但是尤其有用的是可以允许

你直接使用SQL。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",

Hibernate.STRING) )
    .list();

{alias}占位符应当被替换为被查询实体的列别名。
Property实例是获得一个条件的另外一种途径。你可以通过调用Property.forName() 创建一个

Property。

Property age = Property.forName("age");
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.disjunction()
        .add( age.isNull() )
        .add( age.eq( new Integer(0) ) )
        .add( age.eq( new Integer(1) ) )
        .add( age.eq( new Integer(2) ) )
    ) )
    .add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )
    .list();

3. 结果集排序
你可以使用org.hibernate.criterion.Order来为查询结果排序。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .addOrder( Order.asc("name") )
    .addOrder( Order.desc("age") )
    .setMaxResults(50)
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Property.forName("name").like("F%") )
    .addOrder( Property.forName("name").asc() )
    .addOrder( Property.forName("age").desc() )
    .setMaxResults(50)
    .list();

4. 关联
你可以使用createCriteria()非常容易的在互相关联的实体间建立约束。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .createCriteria("kittens")
        .add( Restrictions.like("name", "F%")
    .list();

注意第二个 createCriteria()返回一个新的 Criteria实例，该实例引用kittens 集合中的元素。
接下来，替换形态在某些情况下也是很有用的。

List cats = sess.createCriteria(Cat.class)
    .createAlias("kittens", "kt")
    .createAlias("mate", "mt")
    .add( Restrictions.eqProperty("kt.name", "mt.name") )
    .list();

(createAlias()并不创建一个新的 Criteria实例。)
Cat实例所保存的之前两次查询所返回的kittens集合是没有被条件预过滤的。如果你希望只获得

符合条件的kittens，你必须使用returnMaps()。

List cats = sess.createCriteria(Cat.class)
    .createCriteria("kittens", "kt")
    .add( Restrictions.eq("name", "F%") )
    .returnMaps()
    .list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
    Map map = (Map) iter.next();
    Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
    Cat kitten = (Cat) map.get("kt");
}

5. 动态关联抓取
你可以使用setFetchMode()在运行时定义动态关联抓取的语义。

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .setFetchMode("mate", FetchMode.EAGER)
    .setFetchMode("kittens", FetchMode.EAGER)
    .list();

这个查询可以通过外连接抓取mate和kittens。

6. 查询示例
org.hibernate.criterion.Example类允许你通过一个给定实例构建一个条件查询。

Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .list();

版本属性、标识符和关联被忽略。默认情况下值为null的属性将被排除。
可以自行调整Example使之更实用。

Example example = Example.create(cat)
    .excludeZeroes()           //exclude zero valued properties
    .excludeProperty("color") //exclude the property named "color"
    .ignoreCase()              //perform case insensitive string comparisons
    .enableLike();             //use like for string comparisons
List results = session.createCriteria(Cat.class)
    .add(example)
    .list();

甚至可以使用examples在关联对象上放置条件。

List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .createCriteria("mate")
        .add( Example.create( cat.getMate() ) )
    .list();

7. 投影(Projections)、聚合（aggregation）和分组（grouping）
org.hibernate.criterion.Projections是 Projection 的实例工厂。我们通过调用

setProjection()应用投影到一个查询。

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.rowCount() )
    .add( Restrictions.eq("color", Color.BLACK) )
    .list();

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount() )
        .add( Projections.avg("weight") )
        .add( Projections.max("weight") )
        .add( Projections.groupProperty("color") )
    )
    .list();


在一个条件查询中没有必要显式的使用 "group by" 。某些投影类型就是被定义为分组投影，他

们也出现在SQL的group by子句中。

可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的

实现方式：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
    .addOrder( Order.asc("colr") )
    .list();



List results = session.createCriteria(Cat.class)
    .setProjection( Projections.groupProperty("color").as("colr") )
    .addOrder( Order.asc("colr") )
    .list();

alias()和as()方法简便的将一个投影实例包装到另外一个别名的Projection实例中。简而言之，

当你添加一个投影到一个投影列表中时你可以为它指定一个别名：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount(), "catCountByColor" )
        .add( Projections.avg("weight"), "avgWeight" )
        .add( Projections.max("weight"), "maxWeight" )
        .add( Projections.groupProperty("color"), "color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

List results = session.createCriteria(Domestic.class, "cat")
    .createAlias("kittens", "kit")
    .setProjection( Projections.projectionList()
        .add( Projections.property("cat.name"), "catName" )
        .add( Projections.property("kit.name"), "kitName" )
    )
    .addOrder( Order.asc("catName") )
    .addOrder( Order.asc("kitName") )
    .list();

也可以使用Property.forName()来表示投影：

List results = session.createCriteria(Cat.class)
    .setProjection( Property.forName("name") )
    .add( Property.forName("color").eq(Color.BLACK) )
    .list();
List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount().as("catCountByColor") )
        .add( Property.forName("weight").avg().as("avgWeight") )
        .add( Property.forName("weight").max().as("maxWeight") )
        .add( Property.forName("color").group().as("color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

8. 离线(detached)查询和子查询
DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来

执行它。

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
    .add( Property.forName("sex").eq('F') );
//创建一个Session
Session session = .;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();

DetachedCriteria也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者
Property获得。

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
    .add( Property.forName("weight).gt(avgWeight) )
    .list();
DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
    .add( Subqueries.geAll("weight", weights) )
    .list();

相互关联的子查询也是有可能的：

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
    .setProjection( Property.forName("weight").avg() )
    .add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
    .add( Property.forName("weight).gt(avgWeightForSex) )
    .list();

LifeNote 2008-03-12 15:24 发表评论

超越梦想----动感十足的福特S-MAX

LifeNote — Sun, 09 Mar 2008 17:30:00 +0800

去年刚刚毕业并没有急于找工作而是在家里先去学驾驶，经过一段时间的学习终于拿到了驾驶证，并且来到北京这个繁华的国际大都市，寻找着自己的梦想，我希望有一天我能够向那些富足和积极向上的社会成功人士一样，开着属于自己的车穿梭在城市中！

今天在网上搜索汽车寻找自己中意的车型，无意中看见长安福特S-MAX一款动感设计的车型吸引了我，于是浏览更多的相关信息，发现在北京富特S-MAX有一个春日踏青自驾游活动。我的梦想终于可以实现了，虽然只是一次活动，但这也会让我更加珍惜这次机会而且会更加促使我不断努力为梦想而前进。

三月春天明媚照人，这样的季节，带着全家老小，自背行囊沿着海边一路游下去好不惬意。这时候你是不是为轿车的空间烦恼？不要让这些小事影响你的出游计划。这款定位为“都市多功能用车”的新佳乐具有MPV的空间，SUV的款式；MPV的实用，SUV的稳固。在解决你对空间的烦恼之余，也不输掉对家人的保护。福特S-MAX是福特第一款采用了福特欧洲动感设计(Kinetic Design)的车型，取代了较早的新边锋设计，其充满运动和时尚风格的造型设计体现了“运动中的能量”。

S-MAX前端以鲜明的楔角车头为特征，富于动感的前照灯为它的外表增添了一种果断。雾灯是嵌入式的，高高地布置在前保险杠上，赋予汽车一种动感美。牌照板下的大型梯形格栅与上格栅形成互补——这是福特的特征，同时也给前部外观平添一分霸气。下格栅两侧类似于“鲨鱼鳃”的设计，形成了自己独有的特色。

　　从福特S-MAX运动式的侧影，使人不难看出福特动感设计的意图所在。流线的车顶线条带着拱曲汇入发动机罩，突出的轮拱带有后沿出风口并以独特的上弯与窗玻璃后部相接。所有这一切都无不体现出福特S-MAX是一部魅力四射、活力迸发的汽车。

还忧郁什么呢这么好的车，这么好这么难得的机会难道不心动么，赶快去参加自驾游活动吧，这次试驾活动在3月底至4月中旬举行，现在正是报名时间哦我已经报名了！而且更惊喜的是还有机会获得海外旅游大奖啊！我最大的希望就是能够有一天带着我的爸爸妈妈出去交游一天，这么好的机会我是绝对不能错过了！

tag:福特，S-MAX，SAV，FORD，长安福特，公务，商务，安全，中级车，高级车，私家车

LifeNote 2008-03-09 17:30 发表评论