我有我的滋味

利用Ecipse生成Javadoc乱码(编码问题)终极解决方法

2008-10-25T23:42:00.001+08:00

这里面有两个指定编码问题的参数
1) -encoding charsetName
2) -charset charsetName

第一个参数表示javadoc 程序读取java源文件时候应该采用什么编码
第二个参数表示javadoc 程序写html文件时采用的编码形式,并会在HTML中加入如下标签

如果文件格式为UTF8格式的,可以采用如下形式进行Generate Javadoc:

javadoc -encoding UTF-8 -charset UTF-8

我的Blog访问信息

2008-07-30T22:33:00.001+08:00

真不错啊,blog流量一直在不段的上涨,为了对的起读者,还有我自己,努力

JDK1.5中的线程池使用简介2

2008-07-21T22:36:00.002+08:00

ExecutorService pool = Executors.newFixedThreadPool(4); //创建线程池 4个工作线程
pool.execute(new RunnableTask()); //向任务队列添加任务，任务是一个Runnbale的实现类
pool.shutdown();//停止工作线程

这样的实现方式和上一篇文章介绍的JDK1.5中的线程池使用简介(转),我对内存的使用情况做了测试,结果是:这篇文章的实现再内存上会不段的上涨,到了一个点后,JVM会做GC回收内存,根据我的测试数据来看,每次做了垃圾回收后都在50M左右.然后又继续上涨,不段的重复这个动作.
但是上片文章提到的实现方式,一直都在10M-30M直接波动.内存使用不会上涨.

JDK1.5中的线程池使用简介(转)

2008-07-21T22:33:00.001+08:00

一、简介
线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为：

ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue workQueue,
RejectedExecutionHandler handler)

* corePoolSize
线程池维护线程的最少数量
* maximumPoolSiz
线程池维护线程的最大数量
* keepAliveTime
线程池维护线程所允许的空闲时间
* unit
线程池维护线程所允许的空闲时间的单位
* workQueue
线程池所使用的缓冲队列
* handler
线程池对拒绝任务的处理策略

一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

当一个任务通过execute(Runnable)方法欲添加到线程池时：

* 如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
* 如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
* 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
* 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

也就是：处理任务的优先级为：
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue

handler有四个选择：

* ThreadPoolExecutor.AbortPolicy()
抛出java.util.concurrent.RejectedExecutionException异常
* ThreadPoolExecutor.CallerRunsPolicy()
由调用者执行这个任务
* ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
* ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务

二、一般用法举例 [下载源代码]

package cn.simplelife.exercise;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {
private static int produceTaskSleepTime = 2;
public static void main(String[] args) {
//构造一个线程池
ThreadPoolExecutor producerPool = new ThreadPoolExecutor(2, 4, 0,
TimeUnit.SECONDS, new ArrayBlockingQueue(3),
new ThreadPoolExecutor.DiscardOldestPolicy());

//每隔produceTaskSleepTime的时间向线程池派送一个任务。
int i=1;
while(true){
try {
Thread.sleep(produceTaskSleepTime);

String task = "task@ " + i;
System.out.println("put " + task);

producerPool.execute(new ThreadPoolTask(task));

i++;
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

package cn.simplelife.exercise;

import java.io.Serializable;

/**
* 线程池执行的任务
* @author hdpan
*/
public class ThreadPoolTask implements Runnable,Serializable{

//JDK1.5中，每个实现Serializable接口的类都推荐声明这样的一个ID
private static final long serialVersionUID = 0;

private static int consumeTaskSleepTime = 2000;
private Object threadPoolTaskData;

ThreadPoolTask(Object tasks){
this.threadPoolTaskData = tasks;
}

//每个任务的执行过程，现在是什么都没做，除了print和sleep，:)
public void run(){
System.out.println("start .."+threadPoolTaskData);
try {
//便于观察现象，等待一段时间
Thread.sleep(consumeTaskSleepTime);
} catch (Exception e) {
e.printStackTrace();
}
threadPoolTaskData = null;
}
}

对这两段程序的说明：

1. 在这段程序中，一个任务就是一个Runnable类型的对象，也就是一个ThreadPoolTask类型的对象。
2. 一般来说任务除了处理方式外，还需要处理的数据，处理的数据通过构造方法传给任务。
3. 在这段程序中，main()方法相当于一个残忍的领导，他派发出许多任务，丢给一个叫 threadPool的任劳任怨的小组来做。
* 这个小组里面队员至少有两个，如果他们两个忙不过来，任务就被放到任务列表里面。
* 如果积压的任务过多，多到任务列表都装不下(超过3个)的时候，就雇佣新的队员来帮忙。但是基于成本的考虑，不能雇佣太多的队员，至多只能雇佣 4个。
* 如果四个队员都在忙时，再有新的任务，这个小组就处理不了了，任务就会被通过一种策略来处理，我们的处理方式是不停的派发，直到接受这个任务为止(更残忍！呵呵)。
* 因为队员工作是需要成本的，如果工作很闲，闲到 3SECONDS都没有新的任务了，那么有的队员就会被解雇了，但是，为了小组的正常运转，即使工作再闲，小组的队员也不能少于两个。
4. 通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制，改变这两个值就可以观察不同速率下程序的工作情况。
5. 通过调整4中所指的数据，再加上调整任务丢弃策略，换上其他三种策略，就可以看出不同策略下的不同处理方式。
6. 对于其他的使用方法，参看jdk的帮助，很容易理解和使用。

关于split分割字符串,空结果不能得到的问题(转)

2008-07-19T21:08:00.003+08:00

先看源代码

/**
*
* @author 赵学庆 www.java2000.net
*
*/
class T {
public static void main(String args[]) {
String num[] = new String[11];
String sLine = "101494|360103660318444|2008/06/17|周润英|1292.0|3085.76|2778.28|912.91|106.0|||";
num = sLine.split("\\|");
int row = 1;
for (String s : num) {
System.out.println(row+++"="+s);
}
}
}

/**  *   * @author 赵学庆 www.java2000.net  *  */ class T {   public static void main(String args[]) {     String num[] = new String[11];     String sLine = "101494|360103660318444|2008/06/17|周润英|1292.0|3085.76|2778.28|912.91|106.0|||";     num = sLine.split("\\|");     int row = 1;     for (String s : num) {       System.out.println(row+++"="+s);     }   } }

运行结果为

1=101494

2=360103660318444

3=2008/06/17

4=周润英

5=1292.0

6=3085.76

7=2778.28

8=912.91

9=106.0

查看API,有一个

public String[] split(String regex, int limit);

public String[] split(String regex, int limit);

limit 参数控制应用模式的次数，从而影响结果数组的长度。

如果限制 n 大于零，那么模式至多应用 n> - 1 次，数组的长度不大于 n，并且数组的最后条目将包含除最后的匹配定界符之外的所有输入。

如果 n 非正，那么将应用模式的次数不受限制，并且数组可以为任意长度。

如果 n 为零，那么应用模式的次数不受限制，数组可以为任意长度，并且将丢弃尾部空字符串。修改代码为

/**
*
* @author 赵学庆 www.java2000.net
*
*/
class T {
public static void main(String args[]) {
String num[] = new String[11];
String sLine = "101494|360103660318444|2008/06/17|周润英|1292.0|3085.76|2778.28|912.91|106.0|||";
num = sLine.split("\\|",-1); // 这里使用-1作为参数
int row = 1;
for (String s : num) {
System.out.println(row+++"="+s);
}
}
}

/**  *   * @author 赵学庆 www.java2000.net  *  */ class T {   public static void main(String args[]) {     String num[] = new String[11];     String sLine = "101494|360103660318444|2008/06/17|周润英|1292.0|3085.76|2778.28|912.91|106.0|||";     num = sLine.split("\\|",-1); // 这里使用-1作为参数     int row = 1;     for (String s : num) {       System.out.println(row+++"="+s);     }   } }

运行结果

1=101494

2=360103660318444

3=2008/06/17

4=周润英

5=1292.0

6=3085.76

7=2778.28

8=912.91

9=106.0

10=

11=

12=

结果正常

转载自:http://blog.csdn.net/java2000_net/archive/2008/07/06/2618813.aspx

jconsole监控截图

2008-07-17T16:15:00.004+08:00

从下图可以清晰的看到JVM在一段时间内的内存使用率的一个走势.从图中可以看出每隔15分钟左右就会做一次GC,当然也可以手动执GC

下图为线程监控图.

还有很多的其他的,就自己慢慢的去耍了,我就不贴了.

JVM内存监控管理,Tomcat内存的设置

2008-07-17T15:23:00.007+08:00

JVM内存监控管理

首先你要启动Tomcat,只能使用startup.bat的方式启动.
启动jdk15\bin\jconsole.exe.
点击连接后,出现管理界面,这个时候我们就可以对内存,线程类等进行查看
可以手动执GC

让tomcat自己管理内存,在startup.bat的@echo off下面添加以下代码:
set JAVA_OPTS=%JAVA_OPTS% -Dcom.sun.management.jmxremote.port=1090 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djava.util.logging.config.file="%CATALINA_HOME%\conf\logging.properties"

解决严重: Exception initializing page context java.lang.OutOfMemoryError: Java heap space 的方法.

设置参数JVM参数-Xms256m -Xmx256m -XX:MaxNewSize=256m -XX:MaxPermSize=256m
可以在环境变量中增加CATALINA_OPTS,值为-Xms256m -Xmx256m -XX:MaxNewSize=256m -XX:MaxPermSize=256m,当然你也可以根据实际的需要加大内存值.

因为对于操作系统，请求内存的系统调用会占用大量的cpu时间，所以频繁的请求、释放内存将会导致性能的严重下降。所以对于jvm,最好的方式就是尽量多占用内存作为heap,少释放甚至不释放空闲的heap给操作系统以减少消耗在内存请求、释放操作上的cpu时间。
PermGen space的全称是Permanent Generation space,是指内存的永久保存区域OutOfMemoryError: PermGen space从表面上看就是内存益出，解决方法也一定是加大内存。说说为什么会内存益出：这一部分用于存放Class和Meta的信息,Class在被Load的时候被放入PermGen space区域，它和和存放Instance的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理，所以如果你的APP会LOAD很多CLASS的话,就很可能出现PermGen space错误。这种错误常见在web服务器对JSP进行pre compile的时候。

链接:

Tomcat内存释放不了

让Hibernate支持Informix真正意义上的分页方法

2008-07-15T13:50:00.004+08:00

这种分页方式只支持10或者10以上的版本.

建一个类InformixDialect继承org.hibernate.dialect.InformixDialect.

并重写下面几个方法useMaxForLimit();supportsLimitOffset();(String querySelect, int offset, int limit);

在Hibernate的配置中hibernate.dialect=您重写的这个类InformixDialect

具体代码见下:

import java.sql.Types;

import org.hibernate.Hibernate;

public class InformixDialect extends org.hibernate.dialect.InformixDialect {

public InformixDialect() {
super();
registerHibernateType(Types.DECIMAL, Hibernate.BIG_DECIMAL.getName());
}

public boolean useMaxForLimit() {
return false;
}

public boolean supportsLimitOffset() {
return true;
}

public String getLimitString(String querySelect, int offset, int limit) {
// if (offset>0) throw new UnsupportedOperationException("informix has
// no offset");
return new StringBuffer(querySelect.length() + 8).append(querySelect)
.insert(querySelect.toLowerCase().indexOf("select") + 6,
" skip " + offset + " first " + limit).toString();
}

}

informix数据库下导出表结构

2008-07-14T11:18:00.001+08:00

1）导出数据库中所有的表结构到文件db.sql
$>dbschema -d your_database -t all db.sql

2)导出数据库中所有的存储过程到文件db.sql
$>dbschema -d your_database -f all db.sql

3）导出数据库中的所有对象（包含表，存储过程，触发器。。。）到文件db.sql
$>dbschema -d your_database db.sql

4）导出数据库中一个表的结构到文件db.sql
$>dbschema -d your_database_name -t your_table_name db.sql

5）导出一个存储过程定义到文件db.sql
$>dbschema -d your_database_name -f your_procedure_name db.sql

6)如果导出更多的表的信息(EXTENT…)
$>dbschema -d your_database_name -ss db.sql

7)导出数据库中对用户或角色的授权信息
$>dbschema -d your_database_name -p all
$>dbschema -d your_database_name -r all

8)导出数据库中的同义词
$>dbschema -d your_database_name -s all

Informix 数据库表迁移工具在实际中的应用

2008-07-14T11:11:00.003+08:00

本文是 Informix 数据库表迁移工具在实际中的应用的第 2 部分,在第 1 部分中我们讨论了 Informix 提供的 onunload/onload、unload/load 等表级迁移工具进行详细探讨：分析两者存在的差异，不同情况适用哪个工具等。本部分文章将从如何提高 unload/load 性能效率及例举了实际测试样例等方面的问题,全面阐述 Informix 数据库表迁移工具.
提高 unload/load 性能的技巧

1．去掉数据库（表）日志，提高 load 速度

使用 load 工具进行批量装载时，如果数据库有日志，效率很低；尤其数据量较大时，还可能出现锁溢出、长事务等导致装载失败；对于失败的装载为保证数据一致性， IDS 自动回滚。回滚很耗时，尤其当长事务超出排它高水准线（ LTXEHWM ）时，其他用户的进程将被挂起，性能进一步恶化。这在联机事务处理环境中，势必影响其他业务的正常运行。为此，对有日志的数据库进行大量数据装载时，尽量去掉数据库日志，提高效率。

对于不能去掉日志的数据库环境，如果 Informix 版本为V9系列，可采用表级日志更改功能，即在装载时停止装载表的日志，装载结束后恢复表日志。

实施步骤：

1）删除装载表的参照性约束及索引，只能对没有参照性约束及索引的表改变表级日志，所以在装载前先删除表索引及参照性约束，在装载完毕后重新创建。

2）取掉目的表级日志
ALTER TABLE TABNAME TYPE(RAW)

3）采用 LOAD 工具装载，创建索引及参照性约束

4）增加目的表表级日志
ALTER TABLE TABNAME TYPE(STANDARD)

2．采用多进程，加速 unload/load 卸装速度

目前大多数用户数据库服务器配置较高，具有多个 CPU ，物理内存也较大，如果采用单进程卸装海量表，一方面运行速度缓慢，而另一方面大量系统资源闲置。为此，建议采用多进程，加速卸载速度。针对不同的实际情况，可采用不同方法启用多进程：

将需要装卸的多张表分配到不同的进程中并发装卸，可减少整体装卸载时间；
将海量表分配到多个进程中并发卸装，可减少海量表的卸载时间
多进程与单进程卸装速度的见测试6。

需要说明的是，多进程适合运行在资源充分、负载较轻、具有多个 CPU 的主机上，而对资源较少，或负载已重的主机，启动多进程反而会降低性能，甚至影响其他应用程序的执行。一般来说，在多 CPU 机器上可启动少于物理 CPU 个进程，同时将分割的多个输入输出文件分布在不同设备上。

采用多进程装载海量表，如果装载的数据库有日志，情况较为复杂，需要特别注意锁溢出与长事务的出现，为此采用以下方法：

采用小事务，即每个进程每次装载的数据量适当小。
多进程并发装载同一表，防止锁溢出，表锁设置为页级锁，而非行锁。
去掉表的索引，加速每个进程事务的提交。
3．去掉索引，加速 load 装载速度

索引的根本目的是提高查询效率，但在插入操作时，索引的存在却严重地影响效率。当插入数据量非常大时，索引页重建量也很大，索引结点的分裂也相当频繁， I/O 操作显著增大。同时索引页的分裂，导致需要更多的内存空间来存放分裂前相同的数据量，从而降低缓存效率。

下列情况索引的存在甚至导致装载失败：采用多进程向有日志数据库装载数据时，如果表有索引，锁模式为页锁，则会由于锁碰撞导致装载失败。这是因为每个进程对其插入的索引页加锁，当其他进程插入的记录需要在加锁的索引页上重建的索引时，势必引起索引页上锁碰撞，导致装载失败。这种情况可将表的锁模式改为行锁得到解决，但对于海量数据而言，采用行锁模式不仅锁管理开销庞大，性能低下，而且很可能由于锁溢出而装载失败。所以去掉索引，保证装载的成功。

4. 调整 IDS 性能参数，加速索引创建

调整 IDS 与性能相关的参数，可加速索引创建：

数据表分片，为数据并行扫描提供可能。
设置 MAX_PDQPRIORITY 及 PDQPRIORITY 参数，启用 PDQ 功能。需要说明，启动 PDQ 功能，将会给操作系统带来很大的负载， PDQ 将占用更多的内存、 CPU VP 、扫描线程、磁盘 I/O 资源。应充分考虑在 OLTP 环境对应用程序的影响。运用 PDQ 技术应该选择多 CPU 的机器。
配置多个临时数据库空间，提高排序速度。
回页首

其他说明

使用 unload 工具迁移，对静态表而言，卸载的文本与源表保持一致；对动态表而言，由于表的更新随时发生，从而造成卸载的文本与源表不一致性。为保证数据的一致性，可考虑将表加锁卸载。加锁会降低并发，需要权衡两方面的因素。装载时如果表有并发追加操作，同样存在上述问题。为此可对表更名装载，核对正确后，再删除原表，更名新表为目的表。onunload/onload 工具对卸装表加锁，故不存在上述问题。

测试

1．onunload/onload 与 unload/load 的装卸载速度测试
清单1 . 测试1

主机：HP-V260小型机，配置有8个ＣＰＵ，8G内存，操作系统为HP UNIX 版本：informix Dynamic Server Version 7.30 测试表：test1 ，列长：63, 记录数：8900000，有一复合唯一索引。测试结果：命令耗时： real user sys Unload 12:03.47 5:17.41 2:49.06 Onunload 6:08.35 0.02 0.00 Onload 16:22.89 0.01 0.01 Load 22:13.01 11:59.24 42.19 Load后创建索引： 7:11.74 0.00 0.01

清单2 . 测试2

主机：HP V2600小型机,配有4个CPU，8G内存，操作系统为HP UNIX 版本：informix Dynamic Server Version 9.30 测试表：test2，列长：24, 记录数：5009641，有一复合唯一索引。测试结果：命令耗时： real user sys Unload 6:51.30 5:26.23 16.57 Onunload 1.38.00 0 0 Onload 11:27.62 0.01 0.01 Load 33:17:85 4:02.81 13.59

结论：

Onload/onunload 比 load/unload 性能差异与数据量、主机有关。
理论上讲，如果数据库中索引占用比例较大，用unload卸出速度较快，但装入后创建索引较慢； Onload卸装较稳定，只与数据量大小有关。

2. onunload 与 unload 卸载数据占用空间大小比较

测试表 test 2

test 2 表列长：24，记录数：5009641，页大小：P=2K，有一复合索引。

数据页申请空间数据页占用空间索引页占用空间合计

1262696页 1252722页 418004页（1252722+418004）P=3421646848字节

test 2 测试结果

Unload 输出文件大小 Onunload 输出文件大小

970781283 字节 3422552064 字节

结论： unload 卸出的数据文本比 onunload 卸出的二进制数据文件小。

3. 测试 onunload/onload 对磁盘碎片的整理情况

1）测试前统计,测试表 test3 在 sysextents 中有 60 个 extents，说明 extents 不连续。

2）将测试表采用 onunload/onload 卸装。

3）卸装后统计,测试表 test3 在 sysextents 中仅有 5 个 extents，说明对 extents 进行了整理。

注意：Extents 个数大于 1，可能是测试表太大， IDS 需要多次分配磁盘空间；也可能有并发进程在同一数据库空间有写操作。

4. onunload 对删除的记录卸装的测试

1）新建一表 test4，装载数据，从而使表每个数据页的 rowid 连续；

2）对 test4 表使用 onunload 卸载，卸出文件占用磁盘空间为 1858076672K；

3）采用 mod(rowid, 3）=1 条件删除 test4 表中大量记录；

4）采用 onload 装载测试表，同时将新装载表更名为 test4_1

5）使用 onunload 卸载 test4_1 表，卸出文件占用磁盘空间仍为 1858076672K；

6）检测 test4、test4_1 表的 rowid ，结果一致

结论：onunload/onload 并不清理记录已删除的空间。

5. 测试 PDQPRIORITY 的并行效率
清单 3. 测试 PDQPRIORITY 的并行效率

版本：informix Dynamic Server Version 9.30 主机：HP V2600小型机,配有4个CPU，8G内存，操作系统为HP UNIX 表状态：列长：427 记录数：500万测试序号测试条件测试结果 1 set_pdqpriority 0 创建5个索引 24：16 2 set_pdqpriority 100 创建5个索引 07：32

结论：启用 PDQ 可加速索引的创建。

6. 复杂测试及对比：
单进程与多进程装载效率比较
索引表与无索引表装载效率比较
日志与无日志装载效率比较
测试环境

版本：Informix Dynamic Server Version 9.30

主机：HP V2600 小型机,配有 4 个CPU，8G 内存，操作系统为 HP UNIX

装载文件：行数 rows=8500000，列宽 rowsize=580。
表 1. 测试结果对比表

序号日志方式装载时索引状况多进程测试目的结果
1 数据库及表有日志无索引单进程长事务回滚在耗时 15 分钟、装载 800 多万时出现长事务，回滚耗时 5 小时
2 数据库及表有日志无索引 6 个进程小事务多进程 12 分钟
3 数据库无日志　无索引 1 个进程无索引非日志单进程装载 18 分钟
4 数据库无日志　无索引 6 个进程无索引非日志多进程装载 4 分钟
5 数据库无日志　有索引 6 个进程有索引非日志多进程装载 18 分钟

结论：去掉索引及数据库日志、采用多进程装载时，可显著提高装载效率。

附录

1．onunload 工具卸载空间大小的估计

1）估算表的数据量
清单4. 估算表的数据量

Select ti_npdata, ti_nrows from sysmaster:systabinfo a, sysmaster:systabnames b where ti_partnum=partnum and tabname=查询的表名 and ti_nkeys=0;

2）估算表的索引数据量
清单5. 估算表的索引数据量

Select ti_npdata from sysmaster:systabinfo a, database_name: systabnames b , database_name:sysindexes c where ti_partnum=c.partnum and b.tabname=表名 and b.tabid=c.tabid;

将1），2）结果相加，可近似看作 onunload 卸载文件大小。实际 onunload 卸载文件大小比估计结果略大些。这里注意，需要访问两个数据库的内容： sysmaster，与查询表所在的数据库： database_name。

2．unload 工具卸载文本空间大小的估计

1）统计表的记录数 recnum；

2）统计每条记录占用磁盘空间大小；

将1），2）结果相乘，可近似看作 unload 卸载文件大小。

3．查找 extents 个数较多的表
清单6. 查找 extents 个数较多的表

Select tabname, count(*) rec from sysmaster:sysextents group by 1 into temp tj with no log; Select * from tj order by rec desc ;

GlassFish安装

2008-07-13T18:22:00.005+08:00

1.首先需要安装JDK5或者是JDK6,并设置好环境变量
2.安装ant1.6.5以上版本，并设置好ANT_HOME,Path。
3.下载GlassFish:http://download.java.net/javaee5/v2ur2/promoted/WINNT/glassfish-installer-v2ur2-b04-windows-ml.jar
4.安装GlassFish

把下载后的文件放到D:\或者是其他目录
运行cmd，进入D:\
执行 java -Xmx256m -jar filename.jar
运行 cd glassfish
运行ant -f setup.xml
增加新的环境变量GLASSFISH_HOME,并再path后增加%GLASSFISH_HOME%\bin

5.应用服务器管理

启动asadmin start-domain domain1
停止asadmin stop-domain domain1
管理登录http://localhost:4848 admin/adminadmin

GlassFish v2资料汇总(不段更新)

2008-07-13T09:15:00.010+08:00

GlassFish v2资料汇总
1GlassFish.org官方网站消息，由于中文用户增加，为了提供一个一站式的中文产品和社区，GlassFish中文网站上线：http://cn.glassfish.org
2.GlassFish v2: 明智选择：http://developers.sun.com.cn/Java/GFv2OpenforBusiness.html#whatgf
主要讲述了下面几个方面：

什么是 GlassFish？
GlassFish v2 及其商业发行版
高可用性和可伸缩性
企业级性能
集中管理和监控
使用配置文件实现简单一步配置
与 .NET 的互操作性
JBI 就绪
高级消息处理
具有吸引力的支持报价

3.在GlassFish Version 2中实现集群:http://developers.sun.com.cn/Java/glassfishcluster.html

主要讲述了下面几个方面：

基本概念
域管理体系结构
集群体系结构
典型的故障转移场景
集群动态变形
组管理服务
内存复制配置
内存复制实现
应用服务器安装
集群配置
域检查
为现有域启用集群支持
HTTP负载平衡器插件

4.用 GlassFish v2 替换 Tomcat 5.x

5.GlassFish系列文章 http://www.javaeye.com/news/2880

tar命令参数列表

2008-07-12T21:30:00.001+08:00

1.压缩一组文件为tar.gz后缀。
# tar cvf backup.tar /etc
#gzip -q backup.tar
或
# tar cvfz backup.tar.gz /etc/
2.释放一个后缀为tar.gz的文件。
#gunzip backup.tar.gz
#tar xvf backup.tar
或
# tar xvfz backup.tar.gz

3.用一个命令完成压缩
#tar cvf - /etc/ | gzip -qc > backup.tar.gz

4.用一个命令完成释放
# gunzip -c backup.tar.gz | tar xvf -

5.如何解开tar.Z的文件？
# tar xvfz backup.tar.Z
或
# uncompress backup.tar.Z
#tar xvf backup.tar

6.如何解开.tgz文件？
#gunzip backup.tgz

SVN 增加用户

2008-07-12T21:16:00.002+08:00

htpasswd的几个参数
1. -m将密码以加密形式存放
htpasswd -m passwordfile.conf username

2. -n如果口令文件不存在那么创建一个新的

3. -b直接在控制台上输入口令，而不是以*号显示
htpasswd -mb passwordfile.conf username pass

Linux/Unix下怎么将一个数据文件分成多个文件

2008-07-12T21:09:00.012+08:00

2.执行 split -l 记录数(小文件记录数) 需要拆分的文件

3.ls x* > xxx.sql

4.vi xxx.sql

5. :1,$ s/^/ load from /g

6. :1,$ s/$/ insert into 表名; /g

Hibernate参数设置

2008-07-12T16:48:00.002+08:00

属性名用途
hibernate.dialect 一个Hibernate Dialect类名允许Hibernate针对特定的关系数据库生成优化的SQL. 取值full.classname.of.Dialect
hibernate.show_sql 输出所有SQL语句到控制台. 有一个另外的选择是把org.hibernate.SQL这个log category设为debug。 eg.true | false
hibernate.format_sql 在log和console中打印出更漂亮的SQL。取值true | false
hibernate.default_schema 在生成的SQL中, 将给定的schema/tablespace附加于非全限定名的表名上. 取值SCHEMA_NAME
hibernate.default_catalog 在生成的SQL中, 将给定的catalog附加于非全限定名的表名上. 取值CATALOG_NAME
hibernate.session_factory_name SessionFactory 创建后，将自动使用这个名字绑定到JNDI中. 取值jndi/composite/name
hibernate.max_fetch_depth 为单向关联(一对一, 多对一)的外连接抓取（outer join fetch）树设置最大深度. 值为0意味着将关闭默认的外连接抓取. 取值建议在0到3之间取值
hibernate.default_batch_fetch_size 为Hibernate关联的批量抓取设置默认数量. 取值建议的取值为4, 8, 和16
hibernate.default_entity_mode 为由这个SessionFactory打开的所有Session指定默认的实体表现模式. 取值dynamic-map, dom4j, pojo
hibernate.order_updates 强制Hibernate按照被更新数据的主键，为SQL更新排序。这么做将减少在高并发系统中事务的死锁。取值true | false
hibernate.generate_statistics 如果开启, Hibernate将收集有助于性能调节的统计数据. 取值true | false
hibernate.use_identifer_rollback 如果开启, 在对象被删除时生成的标识属性将被重设为默认值. 取值true | false
hibernate.use_sql_comments 如果开启, Hibernate将在SQL中生成有助于调试的注释信息, 默认值为false. 取值true | false

表 3.4. Hibernate JDBC和连接(connection)属性

属性名用途
hibernate.jdbc.fetch_size 非零值，指定JDBC抓取数量的大小 (调用Statement.setFetchSize()).
hibernate.jdbc.batch_size 非零值，允许Hibernate使用JDBC2的批量更新. 取值建议取5到30之间的值
hibernate.jdbc.batch_versioned_data 如果你想让你的JDBC驱动从executeBatch()返回正确的行计数 , 那么将此属性设为true(开启这个选项通常是安全的). 同时，Hibernate将为自动版本化的数据使用批量DML. 默认值为false. eg.true | false
hibernate.jdbc.factory_class 选择一个自定义的Batcher. 多数应用程序不需要这个配置属性. eg.classname.of.Batcher
hibernate.jdbc.use_scrollable_resultset 允许Hibernate使用JDBC2的可滚动结果集. 只有在使用用户提供的JDBC连接时，这个选项才是必要的, 否则Hibernate会使用连接的元数据. 取值true | false
hibernate.jdbc.use_streams_for_binary 在JDBC读写binary (二进制)或serializable (可序列化) 的类型时使用流(stream)(系统级属性). 取值true | false
hibernate.jdbc.use_get_generated_keys 在数据插入数据库之后，允许使用JDBC3 PreparedStatement.getGeneratedKeys() 来获取数据库生成的key(键)。需要JDBC3+驱动和JRE1.4+, 如果你的数据库驱动在使用Hibernate的标识生成器时遇到问题，请将此值设为false. 默认情况下将使用连接的元数据来判定驱动的能力. 取值true|false
hibernate.connection.provider_class 自定义ConnectionProvider的类名, 此类用来向Hibernate提供JDBC连接. 取值classname.of.ConnectionProvider
hibernate.connection.isolation 设置JDBC事务隔离级别. 查看java.sql.Connection来了解各个值的具体意义, 但请注意多数数据库都不支持所有的隔离级别. 取值1, 2, 4, 8
hibernate.connection.autocommit 允许被缓存的JDBC连接开启自动提交(autocommit) (不建议). 取值true | false
hibernate.connection.release_mode 指定Hibernate在何时释放JDBC连接. 默认情况下,直到Session被显式关闭或被断开连接时,才会释放JDBC连接. 对于应用程序服务器的JTA数据源, 你应当使用after_statement, 这样在每次JDBC调用后，都会主动的释放连接. 对于非JTA的连接, 使用after_transaction在每个事务结束时释放连接是合理的. auto将为JTA和CMT事务策略选择after_statement, 为JDBC事务策略选择after_transaction. 取值on_close | after_transaction | after_statement | auto
hibernate.connection.

将JDBC属性propertyName传递到DriverManager.getConnection()中去.
hibernate.jndi. 将属性propertyName传递到JNDI InitialContextFactory中去.

表 3.5. Hibernate缓存属性

属性名用途
hibernate.cache.provider_class 自定义的CacheProvider的类名. 取值classname.of.CacheProvider
hibernate.cache.use_minimal_puts 以频繁的读操作为代价, 优化二级缓存来最小化写操作. 在Hibernate3中，这个设置对的集群缓存非常有用, 对集群缓存的实现而言，默认是开启的. 取值true|false
hibernate.cache.use_query_cache 允许查询缓存, 个别查询仍然需要被设置为可缓存的. 取值true|false
hibernate.cache.use_second_level_cache 能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定的类，会默认开启二级缓存. 取值true|false
hibernate.cache.query_cache_factory 自定义实现QueryCache接口的类名, 默认为内建的StandardQueryCache. 取值classname.of.QueryCache
hibernate.cache.region_prefix 二级缓存区域名的前缀. 取值prefix
hibernate.cache.use_structured_entries 强制Hibernate以更人性化的格式将数据存入二级缓存. 取值true|false

表 3.6. Hibernate事务属性

属性名用途
hibernate.transaction.factory_class 一个TransactionFactory的类名, 用于Hibernate Transaction API (默认为JDBCTransactionFactory). 取值classname.of.TransactionFactory
jta.UserTransaction 一个JNDI名字，被JTATransactionFactory用来从应用服务器获取JTA UserTransaction. 取值jndi/composite/name
hibernate.transaction.manager_lookup_class 一个TransactionManagerLookup的类名 - 当使用JVM级缓存，或在JTA环境中使用hilo生成器的时候需要该类. 取值classname.of.TransactionManagerLookup
hibernate.transaction.flush_before_completion 如果开启, session在事务完成后将被自动清洗(flush)。现在更好的方法是使用自动session上下文管理。取值true | false
hibernate.transaction.auto_close_session 如果开启, session在事务完成后将被自动关闭。现在更好的方法是使用自动session上下文管理。取值true | false

表 3.7. 其他属性

属性名用途
hibernate.current_session_context_class 为”当前” Session指定一个(自定义的)策略。eg.jta | thread | custom.Class
hibernate.query.factory_class 选择HQL解析器的实现. 取值org.hibernate.hql.ast.ASTQueryTranslatorFactory or org.hibernate.hql.classic.ClassicQueryTranslatorFactory
hibernate.query.substitutions 将Hibernate查询中的符号映射到SQL查询中的符号 (符号可能是函数名或常量名字). 取值hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC
hibernate.hbm2ddl.auto 在SessionFactory创建时，自动检查数据库结构，或者将数据库schema的DDL导出到数据库. 使用 create-drop时,在显式关闭SessionFactory时，将drop掉数据库schema. 取值validate | update | create | create-drop
hibernate.cglib.use_reflection_optimizer 开启CGLIB来替代运行时反射机制(系统级属性). 反射机制有时在除错时比较有用. 注意即使关闭这个优化, Hibernate还是需要CGLIB. 你不能在hibernate.cfg.xml中设置此属性. 取值true | false

3.4.1. SQL方言你应当总是为你的数据库将hibernate.dialect属性设置成正确的 org.hibernate.dialect.Dialect子类. 如果你指定一种方言, Hibernate将为上面列出的一些属性使用合理的默认值, 为你省去了手工指定它们的功夫.

表 3.8. Hibernate SQL方言 (hibernate.dialect)

RDBMS 方言
DB2 org.hibernate.dialect.DB2Dialect
DB2 AS/400 org.hibernate.dialect.DB2400Dialect
DB2 OS390 org.hibernate.dialect.DB2390Dialect
PostgreSQL org.hibernate.dialect.PostgreSQLDialect
MySQL org.hibernate.dialect.MySQLDialect
MySQL with InnoDB org.hibernate.dialect.MySQLInnoDBDialect
MySQL with MyISAM org.hibernate.dialect.MySQLMyISAMDialect
Oracle (any version) org.hibernate.dialect.OracleDialect
Oracle 9i/10g org.hibernate.dialect.Oracle9Dialect
Sybase org.hibernate.dialect.SybaseDialect
Sybase Anywhere org.hibernate.dialect.SybaseAnywhereDialect
Microsoft SQL Server org.hibernate.dialect.SQLServerDialect
SAP DB org.hibernate.dialect.SAPDBDialect
Informix org.hibernate.dialect.InformixDialect
HypersonicSQL org.hibernate.dialect.HSQLDialect
Ingres org.hibernate.dialect.IngresDialect
Progress org.hibernate.dialect.ProgressDialect
Mckoi SQL org.hibernate.dialect.MckoiDialect
Interbase org.hibernate.dialect.InterbaseDialect
Pointbase org.hibernate.dialect.PointbaseDialect
FrontBase org.hibernate.dialect.FrontbaseDialect
Firebird org.hibernate.dialect.FirebirdDialect

表 3.9. Hibernate日志类别

类别功能
org.hibernate.SQL 在所有SQL DML语句被执行时为它们记录日志
org.hibernate.type 为所有JDBC参数记录日志
org.hibernate.tool.hbm2ddl 在所有SQL DDL语句执行时为它们记录日志
org.hibernate.pretty 在session清洗(flush)时，为所有与其关联的实体(最多20个)的状态记录日志
org.hibernate.cache 为所有二级缓存的活动记录日志
org.hibernate.transaction 为事务相关的活动记录日志
org.hibernate.jdbc 为所有JDBC资源的获取记录日志
org.hibernate.hql.AST 在解析查询的时候,记录HQL和SQL的AST分析日志
org.hibernate.secure 为JAAS认证请求做日志
org.hibernate 为任何Hibernate相关信息做日志 (信息量较大, 但对查错非常有帮助)

表 3.10. JTA TransactionManagers

Transaction工厂类应用程序服务器
org.hibernate.transaction.JBossTransactionManagerLookup JBoss
org.hibernate.transaction.WeblogicTransactionManagerLookup Weblogic
org.hibernate.transaction.WebSphereTransactionManagerLookup WebSphere
org.hibernate.transaction.WebSphereExtendedJTATransactionLookup WebSphere 6
org.hibernate.transaction.OrionTransactionManagerLookup Orion
org.hibernate.transaction.ResinTransactionManagerLookup Resin
org.hibernate.transaction.JOTMTransactionManagerLookup JOTM
org.hibernate.transaction.JOnASTransactionManagerLookup JOnAS
org.hibernate.transaction.JRun4TransactionManagerLookup JRun4
org.hibernate.transaction.BESTransactionManagerLookup Borland ES

//山风小子注：在agile_boy的《Hibernate调优小记》中看到《Hibernate 参数设置一览表》，觉得不错，拿来与大家分享
原文地址：http://www.ideagrace.com/html/doc/2007/01/30/08608.html

Blog搬家

2008-07-12T15:20:00.001+08:00

很早就在Blog，因为各种原因到现在都没有一个固定的家，现在终于可以安到这里了。