BlogJava-LifeNote -随笔分类-Java

Java数据库操作基本流程

LifeNote — Thu, 24 Apr 2008 02:36:00 GMT

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 01:54:00 GMT

要实现对数据库的操作，离不开数据源（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 08:52:00 GMT

用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 01:39:00 GMT

一、功能实现核心：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 发表评论

两种特殊的java容器类list和set分析

LifeNote — Mon, 03 Mar 2008 04:23:00 GMT

容器类可以大大提高编程效率和编程能力，在java2中，所有的容器都由sun公司的joshua bloch进行了重新设计，丰富了容器类库的功能。
java2容器类类库的用途是“保存对象”，它分为两类：
collection----一组独立的元素，通常这些元素都服从某种规则。list必须保持元素特定的顺序，而set不能有重复元素。
map----一组成对的“键值对”对象，即其元素是成对的对象，最典型的应用就是数据字典，并且还有其它广泛的应用。另外，map可以返回其所有键组成的set和其所有值组成的collection，或其键值对组成的set，并且还可以像数组一样扩展多维map，只要让map中键值对的每个“值”是一个map即可。
1.迭代器
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
java中的iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个iterator。第一次调用iterator的next()方法时，它返回序列的第一个元素。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasnext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。
iterator是java迭代器最简单的实现，为list设计的listiterator具有更多的功能，它可以从两个方向遍历list，也可以从list中插入和删除元素。
2.list的功能方法
list(interface): 次序是list最重要的特点；它确保维护元素特定的顺序。list为collection添加了许多方法，使得能够向list中间插入与移除元素(只推荐linkedlist使用)。一个list可以生成listiterator，使用它可以从两个方向遍历list，也可以从list中间插入和删除元素。
arraylist: 由数组实现的list。它允许对元素进行快速随机访问，但是向list中间插入与移除元素的速度很慢。listiterator只应该用来由后向前遍历arraylist，而不是用来插入和删除元素，因为这比linkedlist开销要大很多。
linkedlist: 对顺序访问进行了优化，向list中间插入与删除得开销不大，随机访问则相对较慢(可用arraylist代替)。它具有方法addfirst()、addlast()、getfirst()、getlast()、removefirst()、removelast()，这些方法(没有在任何接口或基类中定义过)使得linkedlist可以当作堆栈、队列和双向队列使用。
3.set的功能方法
set(interface): 存入set的每个元素必须是唯一的，因为set不保存重复元素。加入set的object必须定义equals()方法以确保对象的唯一性。set与collection有完全一样的接口。set接口不保证维护元素的次序。
hashset: 为快速查找而设计的set。存入hashset的对象必须定义hashcode()。
treeset: 保持次序的set，底层为树结构。使用它可以从set中提取有序的序列。
linkedhashset: 具有hashset的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历set时，结果会按元素插入的次序显示。 hashset采用散列函数对元素进行排序，这是专门为快速查询而设计的；treeset采用红黑树的数据结构进行排序元素；linkedhashset内部使用散列以加快查询速度，同时使用链表维护元素的次序，使得看起来元素是以插入的顺序保存的。需要注意的是，生成自己的类时，set需要维护元素的存储顺序，因此要实现comparable接口并定义compareto()方法。

LifeNote 2008-03-03 12:23 发表评论

《J2EE核心模式》(DAO模式)

LifeNote — Fri, 15 Feb 2008 09:09:00 GMT

很多的J2EE应用程序需要使用持久性数据(数据库、文件等)。不同的程序，持久性存储是各不相同的，并且用来访问这些不同的持久性存储机制的API也有很大的不同。如果应用程序要在不同的持久性存储间迁移，这些访问特定持久存储层的代码将面临重写。
如何解决这个问题?且看"DAO模式"

数据访问对象(Data Acess Object) 模式
一.环境
根据数据源不同，数据访问也不同。根据存储的类型(关系数据库、面向对象数据库、文件等等)和供应商实现不同，持久性存储(比如数据库)的访问差别也很大

二.问题
许多真是的J2EE应用程序需要在一定程度上使用持久性数据。对于许多应用程序，持久性存储是使用不同的机制实现的,并且用来访问这些不同的持久性存储机制的API也有很大的不同。
比如，应用程序使用实体bean(这里应该是指BMP的bean，CMP的bean已大大降低了与RDBMS的耦合)的分布式组件来表示持久性数据，或者使用JDBC API来访问驻留在某关系数据库管理系统(RDBMS)中的数据，这些组件中包含连接性性和数据访问代码会引入这些组件与数据源实现之间的紧密耦合。组件中这类代码依赖性使应用程序从某种数据源迁移到其他种类的数据源将变得非常麻烦和困难。当数据源变化时，组件也需要改变，以便于能够处理新类型的数据源

(举个例子来说，我们UPTEL系统是使用JDBC API对 ORACLE数据库进行连接和数据访问的，这些JDBC API与SQL语句散布在系统中，当我们需要将UPTEL迁移到其他RDBMS时，比如曾经迁移到INFORMIX，就面临重写数据库连接和访问数据的模块。)

三.作用力
1.诸如bean管理的实体bean、会话bean、servlet等组件往往需要从持久性存储数据源中检索数据，以及进行数据存储等操作。
2.根据产品供应商的不同，持久性存储API差别也很大，这些API和其能力同样根据存储的类型不同也有差别，这样存在以下缺点，即访问这些独立系统的API很不统一。
3.组件需要透明于实际的持久性存储或者数据源实现，以便于提供到不同供应商产品、不同存储类型和不同数据源类型的更容易的移植性。

四.解决方案
使用数据访问对象(DAO)模式来抽象和封装所有对数据源的访问。DAO管理着与数据源的连接以便检索和存储数据。
DAO实现了用来操作数据源的访问机制。数据源可以时RDBMS,LDAP,File等。依赖于DAO的业务组件为其客户端使用DAO提供更简单的接口。DAO完全向客户端隐藏了数据源实现细节。由于当低层数据源实现变化时，DAO向客户端提供的接口不会变化，所有该模式允许DAO调整到不同的存储模式，而不会影响其客户端或者业务组件。重要的是,DAO充当组件和数据源之间的适配器。

(按照这个理论，如果我们UPTEL系统使用了DAO模式,就可以无缝的从ORACLE迁移到任何一个RDBMS了。梦想总是很完美的，且看看DAO模式如何实现)

LifeNote 2008-02-15 17:09 发表评论

JSF中文输入乱码问题解决方法

LifeNote — Thu, 31 Jan 2008 07:05:00 GMT

该方法已知适用的版本tomact5.0.18,tomcat5.0.9。
已知不适用的版本为tomcat5.0.28。
问题描述：
在inputtext中输入中文，然后在输出，显示为乱码。
解决方法：
1、自定义转器
package util;
import java.util.Map;
import javax.faces.component.UIComponent;
import javax.faces.convert.Converter;
import javax.faces.context.FacesContext;
import javax.faces.convert.ConverterException;

public class StringConverter implements Converter {
public Object getAsObject(FacesContext context, UIComponent component,
   String newValues) throws ConverterException {
  String newstr = "";
  if (newValues == null) {
   newValues = "";
  }
  byte[] byte1 = null;
  try {
   byte1 = newValues.getBytes("ISO-8859-1");
   newstr = new String(byte1, "GB2312");
   UIInput input=(UIInput)component;//
   input.setSubmittedValue(newstr);
  } catch (UnsupportedEncodingException e) {
   e.printStackTrace();
  }

return newstr;

}

public String getAsString(FacesContext context, UIComponent component,
Object Values) throws ConverterException {
return (String) Values;
}
}

2、注册转换器
faces-config.xml片段

util.stringconverter
util.StringConverter

3、在页面使用转换器

LifeNote 2008-01-31 15:05 发表评论

Tomcat,Weblogic 等服务器 SSL 安全登陆的例子---附证书文件生成器

LifeNote — Tue, 15 Jan 2008 04:32:00 GMT

公司今天一个登陆的地方要修改，需要加一个SSL安全登陆,于是查些资料并总结如下，希望对有用的着的朋友有帮助
文件打包地址：http://www.blogjava.net/Files/lifenote/tomcat配置ssl.rar
一下为帮助说明：

1.1. 安全登录 SSL
1.1.1 WebLogic下面SSL配置：
1．生成 keystoreFile：
* keystoreFile 文件的生成：
%Java_Home%\bin\keytool -genkey -alias localhost-weblogic -keyalg RSA -validity 365 -keystore ./testKey.jks

* csr 文件的生成：
%Java_Home%\bin\keytool -certreq -alias localhost-weblogic -sigalg MD5withRSA -file ./testServer.csr -keystore ./testKey.jks

* 注意： http 的默认端口是80，https 的默认端口是433，ftp 的默认端口是21。
2．部署keystore 文件
在中配置刚才生成的 testKey.jks 文件。

1.1.2 Tomcat 下面SSL配置

1．生成 keystoreFile：
* keystoreFile 文件的生成：
%Java_Home%\bin\keytool -genkey -alias localhost-weblogic -keyalg RSA -validity 365 -keystore ./testKey.jks

Example for inner test：
[root@localhost ~]#
/home/tomcat/jdk1.5.0_12/bin/keytool -genkey -alias localhost-tomcat -keyalg RSA -validity 365 -keystore /home/tomcat/apache-tomcat-5.5.23/conf/VCMarketKey.jks
Enter keystore password: someday2007
What is your first and last name?
[Unknown]: lifenote
What is the name of your organizational unit?
[Unknown]: Java
What is the name of your organization?
[Unknown]: Sunxc
What is the name of your City or Locality?
[Unknown]: Beijing
What is the name of your State or Province?
[Unknown]: Beijing
What is the two-letter country code for this unit?
[Unknown]: ZH
Is CN=lifenote, OU=Java, O=Sunxc, L=Beijing, ST=Beijing, C=ZH correct?
[no]: y

Enter key password for
(RETURN if same as keystore password): someday2007
[root@localhost ~]#

* csr 文件的生成：
%Java_Home%\bin\keytool -certreq -alias localhost-weblogic -sigalg MD5withRSA -file ./testServer.csr -keystore ./testKey.jks

* 注意： http 的默认端口是80，https 的默认端口是433，ftp 的默认端口是21。

2．部署keystore 文件
打开 server.xml 文件，修改内容如下：

* 只需去掉 server.xml 中对SSL定义的注释，在加上 keystoreFile、keystorePass 这两个属性即可。
      name="Catalina">
            port="8080"
  ...



                   maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS"
      keystoreFile="e:/temp_E/ssl/testKey.jks"
      keystorePass="aaaaaa"/>

            port="8009"
  ...

...
Example for inner test：
                   maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" disableUploadTimeout="true"
               acceptCount="100" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS"
      keystoreFile="/home/tomcat/apache-tomcat-5.5.23/conf/VCMarketKey.jks"
      keystorePass="password"/>

注意需默认要使用 443 而不是 8443，要使用8443要在apache中配置，保证从apache请求tomcat 采用 ... 的格式。

1.1.3 使用http访问WebService s的客户端配置
Servlet服务器配置好SSL之后，客户端可以使用https访问了。
对于用户使用浏览器访问https的方式，浏览器会弹出安装证书的对话框，确认之后可以正常使用https访问。
对于WebService 通过https方式访问，按照一下步骤：
1． WebService客户端要先取得keyStore文件；
2．虚拟机系统使用 System.setProperties(…) 设置keyStore信息；
3．使用 url= 访问WebService服务

LifeNote 2008-01-15 12:32 发表评论

一个Struts的上传下载文件的程序

LifeNote — Mon, 14 Jan 2008 13:24:00 GMT

参看了一些资料实现了一个Struts的上传下载文件的程序，提供下载学习，有什么不好的地方请留言多多指教
为了节省空间，文件中没有导入java包，导入eclipse后请自行加入java包

http://www.blogjava.net/Files/lifenote/使用struts实现文件上传下载.rar

要把上面的地址都复制哦

LifeNote 2008-01-14 21:24 发表评论

java.lang.OutOfMemoryError 的解决办法

LifeNote — Wed, 09 Jan 2008 05:27:00 GMT

最近在使用Tomcat +Tapestry的时候遇见一个问题，由于Tapestry修改些内容后要重新启动（即使配置了一下那参数有时候也要重启）当我修改了页面的内容需要调试不断刷新，发现页面显示的速度越来越慢最后就出现了 500错误java.lang.OutOfMemoryError 内存溢出，在网上查了一下资料
最后总结如下希望可以帮你解决同样的问题
解决java.lang.OutOfMemoryError的方法有如下几种：
1。增加jvm的内存大小。方法有：
             1）在执行某个class文件时候，可以使用java -Xmx256M aa.class来设置运行aa.class时jvm所允许占用的最大内存为256M。
             2）对tomcat容器，可以在启动时对jvm设置内存限度。对tomcat，可以在catalina.bat中添加：
  set CATALINA_OPTS=-Xms128M -Xmx256M
   set JAVA_OPTS=-Xms128M -Xmx256M
或者把%CATALINA_OPTS%和%JAVA_OPTS%代替为-Xms128M -Xmx256M

             3）对resin容器，同样可以在启动时对jvm设置内存限度。在bin文件夹下创建一个startup.bat文件，内容如下：
                  @echo off
                   call "httpd.exe"  "-Xms128M" "-Xmx256M"
                   :end
                   其中"-Xms128M"为最小内存，"-Xmx256M"为最大内存。

2. 优化程序，释放垃圾。

LifeNote 2008-01-09 13:27 发表评论

多模块Struts应用程序的几个问题（及部分解决方法）

LifeNote — Fri, 04 Jan 2008 05:35:00 GMT

Struts从1.1版本开始支持把应用程序分为多个模块，每个模块可以看作独立的应用程序，在带来方便的同时，我也发现了一些问题。比如有一个struts应用程序分了大约十个模块，现在有以下问题不知道大家一般是怎么解决的：

1、因为要进行验证，所以在每个模块对应的资源文件里都要有“errors.required={0} is required.”等资源，有没有只用在一个文件里定义的方法？

2、用tiles的时候，要在每个模块对应的tiles-defs.xml里定义几乎相同的definition，有没有只用在一个文件里定义的方法？（我试过在缺省模块里定义一个definition，然后在模块里extends它，但不行，extends似乎只找当前模块）

3、使用ExceptionHandler的时候，为什么在exception标签里指定了bundle属性还是只在当前模块里找资源？我希望把一些重复使用的异常处理声明在一个文件里，例如NotLoginException、NoSuchObjectException等等，并且它们对应的key也指向同一个资源文件里的资源（利用bundle属性），怎么实现？

经过一段时间的摸索，第一个和第三个问题基本上解决了，其实它们可以看作同一类问题，就是资源的问题。在struts-config-xxx.xml里定义资源文件时，可以指定一个factory属性，不指定时使用缺省的“org.apache.struts.util.PropertyMessageResourcesFactory”类。我的解决方法是自定义一个CustomMessageResourcesFactory类，将多个资源文件以逗号分隔的形式作为参数（即message-resources的parameter属性）传给它，在需要资源的地方会遍历它们进行查找。同时还要自定义一个CustomMessageResources类，它的getMessage()方法里是查找资源的关键代码，而factory只是解析逗号分隔的参数构造并返回CustomMessageResources实例。

CustomMessageResourcesFactory的代码比较简单，如下所示：

package eg;

import java.util.Arrays;

import org.apache.struts.util.MessageResources;
import org.apache.struts.util.MessageResourcesFactory;

public class CustomMessageResourcesFactory extends MessageResourcesFactory{

    public MessageResources createResources(String config) {

        return new CustomMessageResources(Arrays.asList(config.split(",")));
    }

}

CustomMessageResources就稍微复杂一些，不过很幸运，我在网上找到了一个完全符合自己要求的类，下载地址在

<message-resources factory="eg.CustomMessageResourcesFactory"
parameter="eg.ApplicationResources,eg.ErrorResources" />

上面参考了这篇文章

LifeNote 2008-01-04 13:35 发表评论

JSF和Spring集成

LifeNote — Thu, 03 Jan 2008 08:31:00 GMT

JSF和Spring集成原理是获得彼此的上下文引用,以此进一步获得各自管理的bean,这是可能的,因为两者是web应用框架都遵循servlet规范,为二者整合提供了可能和基础.

在Spring中ApplicationContext是相当重要的类,对于web应用,它还包装了javax.servlet.ServletContext,为web应用提供了所有可以利用的数据,包括可管理bean,Faces中通过FacesContext类可以获得所有可以利用的资源,同样包括JSF的可管理支持bean,它们都围绕着ServletContext提供了自己的门面,通过各自的门面在Servlet容器的世界里彼此相通.
本文介绍两种方式,实现二者集成:
1.         通过写自己的类来完成二者的连通,实际上只是获得彼此世界里存活的bean,对于JSF中事件处理可能需要更进一步的构思和编码,为了这点,第二个方法介绍了一种框架.
2.         使用框架完成二者集成.

一自己动手,下面的代码以示例为主,其它涉及的类和接口略去.
这个工具类提供在JSF世界里查找Spring管理的bean.也实现在Spring中查找JSF组件的方法.
package com.skysoft.rbac.dao;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import javax.faces.context.FacesContext;
import javax.servlet.ServletContext;
import javax.faces.el.ValueBinding;
import javax.faces.FactoryFinder;
import javax.faces.application.Application;
import javax.faces.application.ApplicationFactory;

public final class SpringFacesUtil {
public SpringFacesUtil() {
}
/**
   * 从Spring中查找bean.
   * @param beanname String
   * @return Object
   */
public static Object findBean(String beanname) {
    ServletContext context = (ServletContext) FacesContext.getCurrentInstance().
        getExternalContext().getContext();
    ApplicationContext appctx = WebApplicationContextUtils.
        getRequiredWebApplicationContext(context);
    return appctx.getBean(beanname);
}
/**
   * 从JSF中查找bean.
   * @param beanname String
   * @return Object
   */
public static Object lookupBean(String beanname) {
    Object obj = getValueBinding(getJsfEl(beanname)).getValue(FacesContext.
        getCurrentInstance());
    return obj;
}

private static ValueBinding getValueBinding(String el) {
    return getApplication().createValueBinding(el);
}

private static Application getApplication() {
    ApplicationFactory appFactory = (ApplicationFactory) FactoryFinder.
        getFactory(FactoryFinder.APPLICATION_FACTORY);
    //FactoryFinder.FACES_CONTEXT_FACTORY
    //FactoryFinder.RENDER_KIT_FACTORY
    return appFactory.getApplication();
}

private static String getJsfEl(String value) {
    return "#{" + value + "}";
}
}
下面定义一个由JSF管理的bean:
package com.skysoft.rbac.dao;

import javax.servlet.ServletContext;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.skysoft.struts.jsf.util.FacesUtils;

public class ServiceLocatorBean
    implements ServiceLocator {
private static final String DAO_SERVICE_BEAN_NAME = "userDAO";
//这个dao就是由Spring提供的管理bean,这个dao可以使用Hibernate实现.
private UserDAO dao;

public ServiceLocatorBean() {
    this.dao = (UserDAO)SpringFacesUtil.findBean(DAO_SERVICE_BEAN_NAME);
}

public UserDAO getDao() {
    return dao;
}
}
下面是一个使用ServiceLocatorBean的类.
public class UserDAOImp
    extends HibernateDaoSupport implements UserDAO {
private UserDAO dao;
private List list;

public UserDAOImp() {}

public List getList() {
    if (list == null) {
      list = dao.getList();
    }
    return list;
}

public UserDAO getDao() {
    return dao;
}

public void setDao(UserDAO dao) {
    this.dao = dao;
}
}

在faces-config.xml中的配置:

              serviceLocatorBean
              com.skysoft.rbac.dao.ServiceLocatorBean
              session


              User
              com.skysoft.rbac.User
              request

                     serviceLocator
                     com.skysoft.rbac.dao.ServiceLocatorBean
                     #{serviceLocatorBean}


在applicationContext.xml中的配置:





二使用框架
1 介绍
这个框架是Spring相关项目,提供一个包de.mindmatters.faces.spring,这个包包含JSF和Spring框架综合集成的粘合代码,这些代码以独立于一个实现的方式完成,这样它能和任何JSF实现一起使用.
本包的提供的代码主要目的是尽可能透明的集成两个框架,主要特征:
l         JSF/JSP开发者应该能访问Spring管理的Beans,就好象它们是由JSF管理的.
l         JSF可管理beans应能集成入Spring.
l         RequestHandledEvent事件也应该能被发布到Spring.
2 JSF配置集成
本包构造了一个基于faces配置文件(e.g. /WEB-INF/faces-config.xml)的WebApplicationContext类, 让它成为遵循"spring-beans" DTD配置文件(e.g. defined in /WEB-INF/applicationContext.xml)来配置的ApplicationContext的孩子,这样依从"faces-config" DTD的WebApplicationContext就是全特征的,即自动拥有如下功能:
l         JSF可管理beans实现了Spring的*Aware interfaces:
ApplicationContextAware
BeanFactoryAware
BeanNameAware
ResourceLoaderAware
ServletContextAware
l         JSF可管理beans实现Spring的lifecycle interfaces:
InitializingBean
DisposableBean
l         实现Spring的FactoryBean interface
l         实现Spring的ApplicationListener interface
l         发布ApplicationEvent事件.
l         从资源中读取消息.
等等,更多可看Spring.
3 访问方式
1) 从JSF中程序化的访问Spring管理的beans.
因为在FacesWebApplicationContext和ApplicationContext之间有层次关系,所以你的JSF可管理支持beans能容易的实现ApplicationContextAware接口,并能通过getBean方法访问它而不管它是否定义在FacesWebApplicationContext中还是定义在父ApplicationContext类对象中.
2) 通过JSF EL从JSF中访问Spring管理的beans.
能够使用JSF EL访问beans无论你引用的bean由JSF管理还是由Spring管理.两个bean上下文在存取时间合并.
a) 直接访问:
如果一个带有请求名字的bean只存在于Spring上下文内的话,这个bean被使用,bean的singleton属性设置被完全保持.
b) 区域化访问(scoped access):
如果你要从JSF定义bean的作用域的能力上得益还想让那个bean由Spring管理,那么就要在两个上下文中定义,只是对于JSF上下文中的定义的类类型要使用de.mindmatters.faces.spring.SpringBeanFactory类,你还应该设置那个bean的singleton属性到false,因这能覆盖你的作用域设置.在你使用JSF EL访问bean时,你总能获得一个遵从你在JSF上下文中定义的作用域设置的由Spring管理的bean的实例.

三用法
通常,就象设置任何其它JSF web应用一样设置你的web应用,下面的样例配置展示怎样使能上面提到的特征。
在web.xml配置中必须加入下列配置条目,同时注意把该库的jsf-spring.jar放在适当的位置.

    .........


        RequestHandled
        de.mindmatters.faces.spring.support.RequestHandledFilter



        RequestHandled
        *.faces




        org.springframework.web.context.ContextLoaderListener

    .........

下面的一些说明,都可以通过下载这个Spring相关项目得到,列在这里只为演示上面的说明的功能.
WEB-INF/faces-config.xml

    jsfBean
    example.NameBean
    session

        name



              scopedAccessSpringBean
       de.mindmatters.faces.spring.SpringBeanScope
              session


    referencingBean
    example.ReferencingBean
    session

        referencedBean
        #{managedPropertyAccessSpringBean}


WEB-INF/applicationContext.xml (partial)

参考:
http://jsf-spring.sourceforge.net/   JSF-Spring,Spring相关项目官方站点,提供本文介绍的框架下载以及实例下载.
javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html">http://www.javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html 一篇关于JSF和Spring的文章.
bean的singleton属性设置被完全保持.

b) 区域化访问(scoped access):
如果你要从JSF定义bean的作用域的能力上得益还想让那个bean由Spring管理,那么就要在两个上下文中定义,只是对于JSF上下文中的定义的类类型要使用de.mindmatters.faces.spring.SpringBeanFactory类,你还应该设置那个bean的singleton属性到false,因这能覆盖你的作用域设置.在你使用JSF EL访问bean时,你总能获得一个遵从你在JSF上下文中定义的作用域设置的由Spring管理的bean的实例.

三用法
通常,就象设置任何其它JSF web应用一样设置你的web应用,下面的样例配置展示怎样使能上面提到的特征。
在web.xml配置中必须加入下列配置条目,同时注意把该库的jsf-spring.jar放在适当的位置.

    .........


        RequestHandled
        de.mindmatters.faces.spring.support.RequestHandledFilter



        RequestHandled
        *.faces




        org.springframework.web.context.ContextLoaderListener

    .........

下面的一些说明,都可以通过下载这个Spring相关项目得到,列在这里只为演示上面的说明的功能.
WEB-INF/faces-config.xml

    jsfBean
    example.NameBean
    session

        name



              scopedAccessSpringBean
       de.mindmatters.faces.spring.SpringBeanScope
              session


    referencingBean
    example.ReferencingBean
    session

        referencedBean
        #{managedPropertyAccessSpringBean}


WEB-INF/applicationContext.xml (partial)

参考:
http://jsf-spring.sourceforge.net/   JSF-Spring,Spring相关项目官方站点,提供本文介绍的框架下载以及实例下载.
http://www.javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html 一篇关于JSF和Spring的文章.

LifeNote 2008-01-03 16:31 发表评论

博客搬家程序是如何实现的

LifeNote — Thu, 27 Dec 2007 08:28:00 GMT

如题，找有开发过这样功能的朋友介绍一下，是分析html代码么那比如sina 的和163的代码肯定不一样的那不是要写很多这样的程序疑惑中。。。

LifeNote 2007-12-27 16:28 发表评论

由MyEclipse内存不足谈谈JVM内存

LifeNote — Tue, 25 Dec 2007 05:56:00 GMT

原文出处: http://www.javatang.com/archives/2007/12/03/1653250.html
作者: Jet Mah from Java堂
声明: 可以非商业性任意转载, 转载时请务必以超链接形式标明文章原始出处、作者信息及此声明！

如果没有进行设置的话，在使用MyEclipse的经常出现如下图所示内存不足的提示。

提示中说的很明白：“MyEclipse has detected that less than 5% of the 64MB of Perm Gen (Non-heap memory) space remains.”意思是说当前只有小于5%的非堆内存是空闲的。所以我们只要将这个值设置大一些就可以了。

提示中给出了设置的参数：

-vmargs -Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M

这里有几个问题：
1. 各个参数的含义什么？
2. 为什么有的机器我将-Xmx和-XX:MaxPermSize都设置为512M之后Eclipse可以启动，而有些机器无法启动？
3. 为何将上面的参数写入到eclipse.ini文件Eclipse没有执行对应的设置？

下面我们一一进行回答

1. 各个参数的含义什么？

参数中-vmargs的意思是设置JVM参数，所以后面的其实都是JVM的参数了，我们首先了解一下JVM内存管理的机制，然后再解释每个参数代表的含义。

堆(Heap)和非堆(Non-heap)内存
按照官方的说法：“Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。堆是在 Java 虚拟机启动时创建的。”“在JVM中堆之外的内存称为非堆内存(Non-heap memory)”。可以看出JVM主要管理两种类型的内存：堆和非堆。简单来说堆就是Java代码可及的内存，是留给开发人员使用的；非堆就是JVM留给自己用的，所以方法区、JVM内部处理或优化所需的内存(如JIT编译后的代码缓存)、每个类结构(如运行时常数池、字段和方法数据)以及方法和构造方法的代码都在非堆内存中。
堆内存分配
JVM初始分配的内存由-Xms指定，默认是物理内存的1/64；JVM最大分配的内存由-Xmx指定，默认是物理内存的1/4。默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。因此服务器一般设置-Xms、-Xmx相等以避免在每次GC 后调整堆的大小。
非堆内存分配
JVM使用-XX:PermSize设置非堆内存初始值，默认是物理内存的1/64；由XX:MaxPermSize设置最大非堆内存的大小，默认是物理内存的1/4。
JVM内存限制(最大值)
首先JVM内存限制于实际的最大物理内存(废话！呵呵)，假设物理内存无限大的话，JVM内存的最大值跟操作系统有很大的关系。简单的说就32位处理器虽然可控内存空间有4GB,但是具体的操作系统会给一个限制，这个限制一般是2GB-3GB（一般来说Windows系统下为1.5G-2G，Linux系统下为2G-3G），而64bit以上的处理器就不会有限制了。

2. 为什么有的机器我将-Xmx和-XX:MaxPermSize都设置为512M之后Eclipse可以启动，而有些机器无法启动？

通过上面对JVM内存管理的介绍我们已经了解到JVM内存包含两种：堆内存和非堆内存，另外JVM最大内存首先取决于实际的物理内存和操作系统。所以说设置VM参数导致程序无法启动主要有以下几种原因：

1) 参数中-Xms的值大于-Xmx，或者-XX:PermSize的值大于-XX:MaxPermSize；

2) -Xmx的值和-XX:MaxPermSize的总和超过了JVM内存的最大限制，比如当前操作系统最大内存限制，或者实际的物理内存等等。说到实际物理内存这里需要说明一点的是，如果你的内存是1024MB，但实际系统中用到的并不可能是1024MB，因为有一部分被硬件占用了。

3. 为何将上面的参数写入到eclipse.ini文件Eclipse没有执行对应的设置？

那为什么同样的参数在快捷方式或者命令行中有效而在eclipse.ini文件中是无效的呢？这是因为我们没有遵守eclipse.ini文件的设置规则：

参数形如“项值”这种形式，中间有空格的需要换行书写，如果值中有空格的需要用双引号包括起来。比如我们使用-vm C:\Java\jre1.6.0\bin\javaw.exe参数设置虚拟机，在eclipse.ini文件中要写成这样：

-vm
C:\Java\jre1.6.0\bin\javaw.exe

按照上面所说的，最后参数在eclipse.ini中可以写成这个样子：

-vmargs
-Xms128M
-Xmx512M
-XX:PermSize=64M
-XX:MaxPermSize=128M

实际运行的结果可以通过Eclipse中“Help”-“About Eclipse SDK”窗口里面的“Configuration Details”按钮进行查看。

另外需要说明的是，Eclipse压缩包中自带的eclipse.ini文件内容是这样的：

-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
-vmargs
-Xms40m
-Xmx256m

其中–launcher.XXMaxPermSize（注意最前面是两个连接线）跟-XX:MaxPermSize参数的含义基本是一样的，我觉得唯一的区别就是前者是eclipse.exe启动的时候设置的参数，而后者是eclipse所使用的JVM中的参数。其实二者设置一个就可以了，所以这里可以把–launcher.XXMaxPermSize和下一行使用#注释掉。

LifeNote 2007-12-25 13:56 发表评论

解决Eclipse启动错误 jvm terminated. exit code 1

LifeNote — Tue, 25 Dec 2007 05:18:00 GMT

MyEclipse时弹出了下面得错误：

JVM terminated. Exit code=1
C:\WINNT\system32\javaw.exe
-Xms40m
-Xmx256m
-jar D:\eclipse-SDK-3.1.2-win32\startup.jar
-os win32
-ws win32
-arch x86
-launcher D:\eclipse-SDK-3.1.2-win32\eclipse.exe
-name Eclipse
-showsplash 600
-exitdata ad0_a0
-vm C:\WINNT\system32\javaw.exe
-vmargs
-Xms40m
-Xmx256m
-jar E:\eclipse-SDK-3.1.2-win32\startup.jar

原以为只是软件安装得问题，可是反复的安装了几遍之后还是不行，搜集了下也有出现类似问题的人，按照他们的办法终于可以用了。之所以我还要重复一遍写它，是因为原文并没有完全解决问题

1 修改eclipse.ini文件如下：(eclipse 和myeclipse下的eclipse都有这个文件)

-debug
options
-vm
d:\Java\jdk1.5\bin\javaw.exe
-Xms40m
-Xmx256m
-vmargs

2 将文件夹configuration下除config.ini外的所有文件删除；

3 最后还是不行就将workspace下的.metadata删除；

再次启动就没问题了

具体是不是myeclipse启动内存不足的问题呢？

LifeNote 2007-12-25 13:18 发表评论

(tomcat、weblogic)Jndi查找数据源配置

LifeNote — Mon, 24 Dec 2007 04:02:00 GMT

这是我在项目当中积累的资料关于配置tomcat和 weblogic的数据源，贴出来和大家分享，有什么问题还请多指教，共同学习，共同进步
一、tomcat数据源的配制
★★注意将数据库驱动程序最好放在common里，tomcat最先加载这里的驱动，放在server里有时候会出现找不到驱动程序的错误

在tomcat5.5中需要下载apache-tomcat-5.5admin.tar.rar 这个包才可以进行配制
   1.首先进入tomcat的配制数据源的页面Data Sources中配制jndi等连接信息如(jndi为hdb)
   2.在自己应用中的WEB-INF中的web.xml中添加如下：


     Resource reference to a factory for java.sql.Connection
     instances that may be used for talking to a particular
     database that is configured in the server.xml file.


     hdb


     javax.sql.DataSource


     Container


    3.在META-INF中添加context.xml文件内容如下：


   WEB-INF/web.xml
         type="javax.sql.DataSource" username="wangwin" password="wangwin"
      driverClassName="oracle.jdbc.driver.OracleDriver"
      url="jdbc:oracle:thin:@127.0.0.1:1521:ora9"
      maxActive="10" maxIdle="2"/>

   4.在程序中通过JNDI得到连接对象内容如下：
   try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");//这里这是必须的。。。
DataSource ds = (DataSource)(envCtx.lookup( "hdb" ));
if (ds != null){
     Connection conn = ds.getConnection();／／得到连接对象测试内容
     conn.setAutoCommit(false);
     Statement stm = conn.createStatement();
     ResultSet rs = stm.executeQuery("select * from tshp_flow");
     while(rs.next()){
  System.out.println(rs.getString(1));
  System.out.println(rs.getString(2));
  System.out.println(rs.getString(3));
     }
   }else{
     }
} catch (NamingException ex) {
  ex.printStackTrace();
}
二、weblogic数据源的配制
1.打开weblogic的控制台-服务-JDBC-连接缓冲池配制数据库的连接信息
2.服务-JDBC-数据源创建JNDI－继续－选择刚刚配制好的数据库JDBC
3.得到连接对象

LifeNote 2007-12-24 12:02 发表评论