陈毓哲——学海无涯苦作舟 - J2EE

OC4J或Oracle Application Server 下MSSQLServer数据源的配置

yuzhechen@163.com(admin) — Sun,27 Jul 2008 21:44:58 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com
      昨天帮一个朋友解决一个应用系统的发布问题，他们的应用系统必须发布在Oracle Application Server下，原先开的用的Servlet容器是使用Tomcat，现在需要将应用系统移植到OAS上面。由于OAS比较大，所以我们使用了OAS的核心容器OC4J，直接使用OC4J对资源的损耗，也少很多。
    因为一直使用Oracle数据库，还真的没在OC4J上面使用连接池连接到达MSSQLServer，所以搞了一两个小时，居然搞定定，实在是丢脸，也觉得很不好意思。昨天晚上回到家之后，继续研究这一块的实现，终于搞定了如何在OC4J上面配置MSSQLServer的连接池，这种配置方式Mysql一样可行。
    OC4J的EM控制台做得比较****，而这个管理后台只支持Oracle的连接池跟数据源的配置，晕死！如果想采用其他的数据库，那只能通过手工修改配置文件的方式来实现了，再次晕死。。。。
    首先介绍一下网上网友的实现方案：
    第一步：将MSSQLServer的jdbc driver拷贝到%OC4J_HOME%/j2ee/home/applib，对于OC4J或OAS都是一样，应用程序的包文件，可以放在这个目录下，OAS或OC4J会自动加载。
    第二步：修改%OC4J_HOME%/j2ee/home/conf/data-sources.xml，在XML当中，增加以下配置：

 程序代码
<data-source
        class="com.evermind.sql.DriverManagerDataSource"
        name="JIRA database"
        location="jdbc/sunecaDataSource"
        xa-location="jdbc/xa/sunecaDataSource"
        pooled-location="jdbc/sunecaDataSource"
        connection-driver="net.sourceforge.jtds.jdbc.Driver"
        username="suneca"
        password="www.suneca.com"
        url="jdbc:jtds:sqlserver://localhost/suneca;tds=8.0;lastupdatecount=true"
        inactivity-timeout="30"
/>

使用上面的方式怎么配置都起不来。。。晕死。。。我测试使用了MSSQLServer官方的driver跟jtds都不行（上面的配置是使用jtds的，如果是官方driver，无非就是url跟driver不同而已）！居然网上类似的贴还真是多。。。真是天下文章一大抄，哈哈~~~

后来研究了一下，根据一些OAS的DEMO，使用以下例子终于可以实现，以下例子是使用Microsoft官方Driver。
修改一下data-sources.xml文件，在该文件当中增加以下的配置信息：

 程序代码
    <connection-pool 
        name="SQLSERVERDS" 
        max-connections="30">
        <connection-factory factory-class="com.microsoft.jdbc.sqlserver.SQLServerDriver" 
            user="suneca" 
            password="www.suneca.com" 
            url="jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=suneca;SelectMethod=Cursor" 
            commit-record-table-name=""/>
    </connection-pool>

    <managed-data-source 
        connection-pool-name="SQLSERVERDS" 
        jndi-name="jdbc/sunecaDataSource" 
        name="SunecaDataSource"/>

终于可以连接上去了。。。感动中。。。
希望这编文章对有这一方面需要的朋友有所帮助！

顺便将web.xml的配置也一起贴上来：

 程序代码
...
<resource-ref>
    <description>DB Connection</description>
    <res-ref-name>jdbc/sunecaDataSource</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
</resource-ref>
...

数据源的引用

 程序代码
...
Context context  = new InitialContext();
DataSource ds = (DataSource)context.lookup("jdbc/sunecaDataSource");
Connection conn = ds.getConnection();
...

如果上述有问题，可以加入QQ群讨论或发邮件给我:yuzhechen@163.com

Java线程Step By Step(Step 4)

yuzhechen@163.com(admin) — Sun,20 Apr 2008 22:39:47 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com

直接进入：Java线程Step By Step(Step1)
直接进入：Java线程Step By Step(Step2)
直接进入：Java线程Step By Step(Step3)

七，对象的wait()、notify()和notifyAll()用法
1）Object 类定义了 wait()、notify() 和 notifyAll() 方法。可以让线程相互通知事件的发生。要执行这些方法，必须拥有相关对象的锁。
2）wait() 会让调用线程休眠，直到用 Thread.interrupt() 中断它、过了指定的时间、或者另一个线程用 notify() 或 notifyAll() 唤醒它。
3）当对某个对象调用 notify() 时，如果有任何线程正在通过 wait() 等待该对象，那么就会唤醒其中一个线程。当对某个对象调用 notifyAll() 时，会唤醒所有正在等待该对象的线程。

假如我们有两条线程，我们希望线程的输出顺序是：
线程t1输出十次
线程t2输出十次
线程t1输出十次
线程t2输出十次

那程序该如何实现？
我们的设计思路是：
使用锁的机制，首先，线程1进入可运行状态后
1）线程t1获取对象的锁
2）线程t1完成输出十个数的任务
3）唤醒其他(t2)正在等待的线程
4）自身阻塞，释放锁。
5）线程t2获取锁
6）线程t2完成输出十个数的任务
7）唤醒其他(t1)正在等待的线程
8）自身阻塞，释放锁。
9）。。。。

程序的实现如下：

程序代码

package zizz;

/**
* 主程序. 使用wait(),notify(),notifyAll()方法
*
* @author ZIZZ
*
* @Create-Time:2008-4-21 上午12:51:59
*/
public class ThreadLock {

    public static void main(String[] args) {
        //共享线程实例的线程.
        ShareRunnable share = new ShareRunnable();
        Thread t1 = new Thread(share, "t1");
        Thread t2 = new Thread(share, "t2");
        t1.start();
        t2.start();
    }

}

/**
*
* @author ZIZZ
*
* @Create-Time:2008 上午12:14:26
*/
class ShareRunnable implements Runnable {

    public void run() {
        //第一个线程运行时，对共享的线程对象进行加锁
        synchronized (this) {
            for (int i = 1; i <= 100; i++) {
                //输出当前的值
                System.out.println(Thread.currentThread().getName() + " : " + i);
                // 如果i为10的倍数
                if (i % 10 == 0) {
                    try {
                        // 唤起其他线程
                        notifyAll();
                        // 当前正在运行的线程阻塞，释放拥有该对象的锁.
                        if(i == 100)break;
                        else wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

}

运行结果片断：

假如在开发的时候，并没有写上synchronized (this) {...}的同步语句，那将会出现一些问题，因为使用wait()、notify()，它需要有owner，假如没有写上这个同步语句块，那系统将会执出如下错误信息：

 程序代码
Exception in thread "t1" java.lang.IllegalMonitorStateException: current thread not owner
    at java.lang.Object.notifyAll(Native Method)
    at zizz.ShareRunnable.run(ThreadLock.java:41)
    at java.lang.Thread.run(Thread.java:595)

Java线程Step By Step(Step 3)

yuzhechen@163.com(admin) — Sat,19 Apr 2008 08:48:17 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com

直接进入：Java线程Step By Step(Step1)
直接进入：Java线程Step By Step(Step2)
直接进入：Java线程Step By Step(Step4)

六、线程同步
多线程操作给我们带来了很多好处，但也不少问题我们需要去解决，这些问题主要是当多个线程共享数据时，我们应该如何去考虑同步的问题。线程同步问题，可能有些人做开发根本就不会发生，因为在技术框架上，它根本就不可能发生；有些人可能在开发一些应用系统的时候，需要考虑到线程同步的总理，但根本就不去考虑，再说，这种问题也是很少发生；有些人，对线程同步的问题想得太复杂，提到某一些类对象的时候，就马上提出，这个不是线程安全的，应该怎么样怎么样！其实，根本不会发生线程同步的问题，也就是说多线程没有共享数据的时候，你考虑线程安全干嘛？线程安全这一块控制不好，反而会影响整个系统的性能。
多线程共享数据的时候，我们需要考虑到线程同步，以下演示了一个线程共享数据的问题。现在假设有两条线程，分别为线程t1跟线程t2，帐号的余额为1000元，这两条线程都是取钱。假如不考虑线程同步问题，线程1启动后，执行取钱操作，一共取六次，每次一百元；线程2启动后，执行取钱操作，一共也取六次，每次一百元。每次取钱之前都会先检查一下余额，如果余额度小于一百元，则线程退出。最后，在控制台上输出帐号的总额。程序的实现如下：

程序代码

package zizz;

import java.util.Date;

/**
* 该类演示了多线程的数据共享问题.
*
* @author ZIZZ
*
* @Create-Time:2008 下午08:41:38
*/
public class MultiThread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        BankThread bank = new BankThread();
        Thread t1 = new Thread(bank);
        Thread t2 = new Thread(bank);
        t1.start();
        t2.start();
        try {
            //子线程执行完毕之后，主线程才继续执行.
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("帐号余额为：" + BankThread.totalMoney);
    }

}

/**
* 共享的线程实例.
*
* @author ZIZZ
*
* @Create-Time:2008 下午08:43:01
*/
class BankThread implements Runnable{

    /**
     * 帐号金额.
     */
    static int totalMoney = 1000;

    /**
     * 取钱或转帐每次的金额.
     *
     */
    final static int FETCH_EACH_TIME = 100;

    /**
     * 线程执行内容.
     */
    public void run() {
        for(int i=0;i<6;i++){
            //每次取钱先检查一下帐户的余额.
            if(checkAccountBalance()){
                //执行日志操作.
                logOperator();
                doFetchMoney();
            } else {
                //余额不足，退出循环
                break;
            }
        }
    }

    /**
     * 检查帐号状态.
     *
     * @return
     */
    public boolean checkAccountBalance(){
        //如果余额不够，则返false.否则，返回true
        if(totalMoney < FETCH_EACH_TIME){
            return false;
        } else {
            return true;
        }
    }

    /**
     * 取钱.假设每次取一百块钱.
     */
    public void doFetchMoney(){
        System.out.println(Thread.currentThread().getName() + " 取出" + FETCH_EACH_TIME);
        totalMoney = totalMoney - FETCH_EACH_TIME;
    }

    /**
     * 做日志，该方法目的是为了让线程多干一些事情.
     *
     */
    public void logOperator(){
        for(int i=0;i<100000;i++){
            //不断让JVM分配内存，该操作目的是为了能让线程同步问题更快发生.
            Date date = new Date();
        }
    }
}

对程序一共执行了两次，第一次结果为：

该结果正确！
运行第二次，结果为：

该结果不正确！

为什么会出现这个问题呢？我们给出这样的解释：
1）线程t1跟线程t2他们的优先级别相同，他们在线程调度器的调度下，交叉着使用CPU资源。
2）当线程t1处于运行状态时，检查完帐号余额（checkAccountBalance）时，结果是满足条件的，帐号余额还有100元，此时，t1阻塞，CPU资源给线程t2，t2进入运行状态。
3）线程t2检查帐号余额，此时，还是满足条件，则进行日志后，进行扣款。扣款后的余额为0。继续执行循环，不够提款，线程t2退出。
4）线程t1继续执行，执行扣款操作，因为已经跳过了检查帐号途额的操作，所以直接扣款，扣款后的帐号余额为：-100元。

那我们应该如何去解决这个问题呢？此时，我们需要使用到锁的机制来进行相应的操作。
在Java语言中，引入了对象互斥锁（mutual exclusive lock，也简称为对象锁）的概念，来保证共享数据操作的完整性：
1）每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
2）关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。在Java中的两种使用synchronized的方式：
a）放在方法前面，这样，调用该方法的线程均将获得对象的锁。
b）放在代码块前面，它也有两种形式：
synchronized (this){… …}或synchronized {… …}：代码块中的代码将获得当前对象引用的锁
synchronized(otherObj){… …}：代码块中的代码将获得指定对象引用的锁
对对象加了锁，用完之后，我们需要释放锁
1）如果一个线程一直占用一个对象的锁，则其他的线程将永远无法访问该对象，因此，需要在适当的时候，将对象锁归还。
2）当线程执行到synchronized()块结束时，释放对象锁。
3）当在synchronized()块中遇到break, return或抛出exception，则自动释放对象锁。
4）当一个线程调用wait()方法时，它放弃拥有的对象锁并进入等待队列。

对于银行存款的例子，我们可以使用锁机制，对其进行改进！

程序代码

package zizz;

import java.util.Date;

/**
* 该类演示了多线程的数据共享问题.
*
* @author ZIZZ
*
* @Create-Time:2008 下午08:41:38
*/
public class MultiThread {

    /**
     * @param args
     */
    public static void main(String[] args) {
        BankThread bank = new BankThread();
        Thread t1 = new Thread(bank);
        Thread t2 = new Thread(bank);
        t1.start();
        t2.start();
        try {
            //子线程执行完毕之后，主线程才继续执行.
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("帐号余额为：" + BankThread.totalMoney);
    }

}

/**
* 共享的线程实例.
*
* @author ZIZZ
*
* @Create-Time:2008 下午08:43:01
*/
class BankThread implements Runnable{

    /**
     * 帐号金额.
     */
    static int totalMoney = 1000;

    /**
     * 取钱或转帐每次的金额.
     *
     */
    final static int FETCH_EACH_TIME = 100;

    /**
     * 线程执行内容.
     */
    public void run() {
        for(int i=0;i<6;i++){
            //每次取钱先检查一下帐户的余额.
            synchronized(this){
                if(checkAccountBalance()){
                    //执行日志操作.
                    logOperator();
                    doFetchMoney();
                } else {
                    //余额不足，退出循环
                    break;
                }
            }
        }
    }

    /**
     * 检查帐号状态.
     *
     * @return
     */
    public boolean checkAccountBalance(){
        //如果余额不够，则返false.否则，返回true
        if(totalMoney < FETCH_EACH_TIME){
            return false;
        } else {
            return true;
        }
    }

    /**
     * 取钱.假设每次取一百块钱.
     */
    public void doFetchMoney(){
        System.out.println(Thread.currentThread().getName() + " 取出" + FETCH_EACH_TIME);
        totalMoney = totalMoney - FETCH_EACH_TIME;
    }

    /**
     * 做日志，该方法目的是为了让线程多干一些事情.
     *
     */
    public void logOperator(){
        for(int i=0;i<100000;i++){
            //不断让JVM分配内存，该操作目的是为了能让线程同步问题更快发生.
            Date date = new Date();
        }
    }
}

在原来的：

 程序代码
                if(checkAccountBalance()){
                    //执行日志操作.
                    logOperator();
                    doFetchMoney();
                } else {
                    //余额不足，退出循环
                    break;
                }

增加锁，修改为：

 程序代码
            synchronized(this){
                if(checkAccountBalance()){
                    //执行日志操作.
                    logOperator();
                    doFetchMoney();
                } else {
                    //余额不足，退出循环
                    break;
                }
            }

问题解决，再次运行程序，结果正确！

使用锁机制也可能会导致死锁，在Step 4我们将会演示一个死锁的例子，这一节我们先了解一下概念！
1）是指两个线程，都相互等待对方释放lock
2）是不可测知或避开的
3）应采取措施避免死锁的出现

Java线程Step By Step(Step 2)

yuzhechen@163.com(admin) — Fri,18 Apr 2008 11:27:42 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com

直接进入：Java线程Step By Step(Step1)
直接进入：Java线程Step By Step(Step3)
直接进入：Java线程Step By Step(Step4)

四、Join方法的使用
Thread API 包含了等待另一个线程完成的方法：join() 方法。当调用 Thread.join() 时，调用线程将阻塞，直到被join方法加入的目标线程完成为止。可以于解起来抽象一睦，现在我们来举一个例子说明问题。

程序代码

package zizz;

/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {

    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + i);
        }
    }

    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread();
        //线程进入运行态
        t1.start();
        //主线程输出
        System.out.println("主线程输出：http://www.suneca.com");
    }
}

输出结果为：

从结果我们可以看到，对于我们运行MyThread这个程序，在主线程当中创建一个新的子线程，新的子线程启动后，主线程输出博客地址。因为当前主线程处于运行态，而子线程是处于可运行态，所以输出的结果为先输出网址，再输出了线程输出的数据。但也有可能会出现这种情况，子线程进入可运行态之后，马上进入运行态，那此时的是输出子线程的数据，再输出主线程的数据，它们的执行完全是由线程调度器进行调度。我们再将程序做如下的修改：

程序代码

package zizz;

/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {

    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=100;i++){
            System.out.println("子线程输出：" + i);
        }
    }

    /**
     * 应用程序入口.
     *
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread();
        //线程进入运行态
        t1.start();
        //主线程输出
        for(int i=0;i<100;i++){
            System.out.println("主线程输出：http://www.suneca.com");
        }
    }
}

此时的输出结果为：

主线程跟子线程在线程调度器的调度下，相互抢夺CPU资源，交叉运行着！

那么，如果我希望程序启用子线程，必须等待着子线程执行完毕之后，主线程才能继续执行下去，那该怎么办？那此时，我们就必须使用到join这个方法啦！当使用Thread.join()时，调用线程将阻塞。因为子线程是由主线程进行调用的，所以当子线程调用到join这个函数时，主线程将阻塞，必须等待子线程执行完毕之后，才能继续执行。使用join的程序：

程序代码

package zizz;

/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {

    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + i);
        }
    }

    /**
     * 应用程序入口.
     *
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread();
        //线程进入运行态
        t1.start();
        try {
            //线程的调用者，即主线程阻塞！
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程输出
        for(int i=0;i<10;i++){
            System.out.println("主线程输出：http://www.suneca.com");
        }
    }
}

输出结果为：

从结果当中，我们可以看出，当子线程调用到join的时候，主线程将阻塞，子线程执行完毕之后，主线程才能继续执行。对于join()方法，还有两个重载方法，比如joing(long millis)，那就是让主程序阻塞多长时间后才能恢复到可运行状态。

如果主程序调用了两个子线程，那这两个子线程是如何工作的呢？

程序代码

package zizz;

/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {

    public MyThread(String name){
        super(name);
    }

    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=100;i++){
            System.out.println("子线程输出：" + this.getName() + " - " + i);
        }
    }

    /**
     * 应用程序入口.
     *
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");
        //线程进入运行态
        t1.start();
        t2.start();
        try {
            //线程的调用者，即主线程阻塞！
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程输出
        for(int i=0;i<10;i++){
            System.out.println("主线程输出：http://www.suneca.com");
        }
    }
}

输出结果：

从图的输出结果我们可以看出：对于在线程t1跟线程t2当中都调用了线程的join()方法，那么，调用t1、t2的主线程将阻塞，等到t1、t2都执行完毕之后，再执行主线程。对于子线程t1跟t2，它们的一个先后顺序，如何进行调度，完全是由线程调度器进行管理！

五、多线程
从前面的例子我们已经可以看出，对于有两个以上的线程同时启动，那这些线程的执行的先后顺序我们是没有办法预知的，因为对于它们的调用完全是由线程调度器进行调用！当子线程t1跟t2同时处于运行状态，那谁先执行谁慢执行，由线程调度器决定。那我们程序能否进行控制呢？答案是可以的，我们可以通过设计优先级别来进行控制。每一个线程，默认的优先级别为5，值越高，表示优先级别越高（最高为10），值越低（最低为1），表示优先级别越低！当线先级别相等的时候，那就只有排队等待着线程调度器的调用。

程序代码

package zizz;

/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {

    public MyThread(String name){
        super(name);
    }

    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + this.getName() + " - " + i);
        }
    }

    /**
     * 应用程序入口.
     *
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");

        //线程进入运行态
        t1.start();
        t2.start();
        //主线程输出
        System.out.println("主线程输出：http://www.suneca.com");

    }
}

t1比t2先启动，进入可运行态，排队等候线程的调度。执行结果：

如果设置了线程的优先级，如：

程序代码

package zizz;

/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {

    public MyThread(String name){
        super(name);
    }

    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + this.getName() + " - " + i);
        }
    }

    /**
     * 应用程序入口.
     *
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");

        //设置t1的的优先级别为最低
        t1.setPriority(Thread.MIN_PRIORITY);
        //设置t2的优先级别为最高
        t2.setPriority(Thread.MAX_PRIORITY);

        //线程进入运行态
        t1.start();
        t2.start();
        //主线程输出
        System.out.println("主线程输出：http://www.suneca.com");

    }
}

执行结果：

从结果当中我们可以看到，最早的时候是由主线程执行，主线程占用着CPU资源，接着，线程t1启动，线程t1进入排队，等候着线程调度器的调度；再接着，线程t2启动，线程t2也进入排队。
我们从结果当中更可以发现一点，对于高于5的线程优先级别，它更容易从当中正在执行的线程(主线程)当中抢夺CPU资源。

多线程的另外一种情况就是，多个线程共享同一个线程实例。

程序代码

package zizz;

/**
* 使用实现Runnable接口的线程.
*
* @author ZIZZ
*
* @Create-Time:2008 下午10:48:31
*/
public class MyRunnable implements Runnable{

    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }

    public static void main(String[] args){
        //构造一个Runnable的实例
        MyRunnable runnable = new MyRunnable();
        //创建新的线程
        Thread t1 = new Thread(runnable,"T1");
        Thread t2 = new Thread(runnable,"T2");

        //线程启动.
        t1.start();
        t2.start();
    }

}

执行结果片断：

当多线程共享同一个线程实例的时候，我们需要考虑一下线程的同步问题。

Java线程Step By Step(Step 1)

yuzhechen@163.com(admin) — Thu,17 Apr 2008 22:56:48 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com

直接进入 Java线程Step By Step(Step2)
直接进入 Java线程Step By Step(Step3)
直接进入 Java线程Step By Step(Step4)

进程(Process)，简单地讲，就是在操作系统中运行着的任务。比如，我们打开一个word，那我们就是操作系统当中运着着一个进程，打开一个excel，那在操作系统当中就运行着一个进程。而线程（Thread）是在同一应用程序中有多个顺序流（同时）执行，它是进程的实体，一个进程可以拥有多个线程，线程必须有一个父进程。一般情况下，线程具有就绪、阴塞、运行三个基础状态。对于单核CPU的系统上，在某一个时间刻，后台只有一条线程在执行着。

一、线程的实现可以有两种方式，第一种是继承Thread，第二种是实现Runnable接口1、继承Thread

程序代码

package zizz;

/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread{

    public MyThread(){
    }

    public void run() {
        System.out.println("线程运行。。");
    }

    public static void main(String[] args){
        //创建一个线程实例
        MyThread thread = new MyThread();
        //线程进入运行态
        thread.start();
    }
}

线程的启动不是程序直接去调用run()方法，而是调用start()，因为线程在什么时候运行，完全是由线程调度器进行决定！

2、实现Runnable接口

程序代码

package zizz;

/**
* 使用实现Runnable接口的线程.
*
* @author ZIZZ
*
* @Create-Time:2008 下午10:48:31
*/
public class MyRunnable implements Runnable{

    public void run() {
        System.out.println("线程运行。。。");
    }

    public static void main(String[] args){
        //构造一个Runnable的实例
        MyRunnable runnable = new MyRunnable();
        //创建新的线程
        Thread thread = new Thread(runnable,"T1");
        //线程启动.
        thread.start();
    }

}

Runnable实例的启动不是直接调用run()方法，它需要由一个Thread作为它的载体！

二，多线程
线程的执行是由进程调度器进行调度的，线程在运行时，线程调度器会让线程由运行态转化为阻塞状态，对于线程它是如何运行，线程之间如何去抢夺CPU资源，我们无法控制，以下的例子创建了两条线程，并且这两条线程同时起动。

程序代码

控制台的输出结果为：

从结果当中我们可以看到，在多线程的应用程序当中，线程如何调用，是由虚拟机决定的。

注意：如果你的操作量太少，比如循环次数太少，那你可以看不到这个效果！

三、sleep
当我们线程执行完某一操作之后，要求先停下来，之后才继续进行，那此时我们将需要让线程休眠，由运行态转为可阻塞状态。比如，我们现在要编写一个每隔一秒钟输入一个数字，输出的数字是从100到999，那我们可以每输出一个数字之后，让线程休眠，由运行态转化为阻塞状态。

程序代码

package zizz;
/**
* 使用继承方式的线程实现.
*
* @author http://www.suneca.com">zizz
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {

    public MyThread(){
    }

    public MyThread(String name){
        super(name);
    }

    public void run() {
        //循环输出1 到 100
        for(int i=100;i<=999;i++){
            System.out.println(i);
            try {
                //线程休眠，由运行态转化为阻塞状态
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread("T1");
        //线程进入运行态
        t1.start();
    }
}

sleep(1000)表示线程休眠1秒钟！那线程休眠一秒钟之后是否马上就进入运行状态呢？不是的！从线程状态图我们可以看到，线程由阻塞状态并不是马上就进入运行状态，而是先进入可运行态，最后，由线程调度器进行调度。所以我们实现这个代码，严格来讲，是错的！谁也没有办法确保就刚好是一秒钟的时间输出一次！因为对于JAVA来讲，它也是运行于操作系统上的一个进程，操作系统此时有很多进程都是处于运行态！

内部类(inner class)的用法

yuzhechen@163.com(admin) — Fri,21 Mar 2008 12:22:18 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com

在Java当中，允许一个类的定义出现在另一个类中，将处于另一个类中的“寄生类”称为“内部类”（inner class），也称为“类属类”。这样的一组类在逻辑上是一个整体，内部类和外层封装它的类之间存在逻辑上的从属关系，内部类对其封装类的内部成员有访问权限。

一、普通的内部类：

程序代码

package zizz;

/**
* 内部类的使用.
*
* @author ZIZZ
*
* @Create-Time:2008-4-21 下午12:17:26
*/
public class Outer {
    //定义外部类的属性
    private int size = 10;

    private static String test = "http://www.suneca.com";

    //声明一个内部类
    public class Inner
    {
        //内部类不能有静态声明
        //static int a = 100;
        public void add(int i){
            System.out.println(test);
            System.out.println(size * i);
        }
    };

    /**
     * 由内部方法调用内部类
     */
    public void test(){
        Inner inner = new Inner();
        inner.add(10);
    }

    /**
     * 应用程序入口
     * @param args
     */
    public static void main(String[] args){
        //方式一，由内部方法初始化内部类
        Outer outer = new Outer();
        outer.test();

        //方式二，创建一个新的外部类实例来创建新的内部类
        Outer.Inner inner1=new Outer().new Inner();
        inner1.add(200);

        //方式三，由外部类实例创建外部类
        Outer.Inner inner2 = outer.new Inner();
        inner2.add(100);
    }
}

普通内部类需要注意的地方：
第一，普通内部类不允许定义静态的属性；
第二，内部类的声明必须由外部类的实例来创建；

二、静态内部类

程序代码

package zizz;

/**
* 内部类的使用.
*
* @author ZIZZ
*
* @Create-Time:2008-4-21 下午12:17:26
*/
public class Outer {
    //定义外部类的属性
    private int size = 10;

    private static String test = "http://www.suneca.com";

    //声明一个静态的内部类
    //static的内部类只能访问外部类static的类型
    public static class Inner2
    {
        //假如内部类声明为static，那可以声明static的成员变量
        static int a = 100;
        public void sub(int a,int b){
            //无法从静态上下文中引用非静态变量
            //System.out.println(size);
            System.out.println(a + b);
            //允许访问外部类的static的类型
            System.out.println(test);
        }
    };

    /**
     * 应用程序入口
     * @param args
     */
    public static void main(String[] args){
        //定义静态的内部类
        Outer.Inner2 in3 = new Outer.Inner2();
        in3.sub(10 , 20);
    }
}

静态内部类需要注意的地方：
1）静态内部类不能访问外部类非静态成员。
2）静态内部类可以声明静态成员。
3）静态内部类的使用是使用外部类加内部类进行声明（如Outer.Inner2 in3 = new Outer.Inner2()）。

三、抽象内部类

程序代码

package zizz;

/**
* 内部类的使用.
*
* @author ZIZZ
*
* @Create-Time:2008-4-21 下午12:17:26
*/
public class Outer {
    //定义外部类的属性
    private int size = 10;

    private static String test = "http://www.suneca.com";

    //声明一个抽象的内部类
    public abstract class AbstractInner
    {
        //声明了抽象的方法
        public abstract void test();
    };

    public class AbstractInnerImpl extends AbstractInner
    {
        //实现内部抽象类的方法
        public void test(){
            System.out.println("内部类的继承！");
        }

    };

    /**
     * 应用程序入口
     * @param args
     */
    public static void main(String[] args){
        //实例化内部抽象类的实现者
        Outer.AbstractInner impl = new Outer().new AbstractInnerImpl();
        impl.test();
    }
}

基于Java压缩技术压缩文件

yuzhechen@163.com(admin) — Mon,18 Feb 2008 22:47:34 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com

Java的压缩技术支持ZIP、GZIP、JAR等压缩
这是是一篇使用Zip技术实现目录压缩的文章，希望能给大家一些帮助！
希望大家能开发出一些开源或免费的压缩工具出来，然后拿出来给大家分享！
缺点：
中文问题比较麻烦，网站已经有解决方案了。
第一种是修改JDK（不可取）。
第二种是使用Apache Ant的Zip解决方案。自己做的项目就是基于这个。
第三种是通过复杂的编码来支持中文。

由于教学方面的要求，本次使用的是基于java的zip压缩技术来进行文件或目录的压缩

程序代码

package zizz;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
* 基于Java Zip技术压缩目录或文件.
* 该压缩技术支持多级目录的压缩，使用递归算法.
* 问题是不支持中文，如果想要支持中文，请使用Ant的Zip技术.
*
* @author http://www.suneca.com">ZIZZ
*
* @Create-Time:2008-2-18 下午10:28:56
*/
public class ZipMultiDirectoryCompress {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //初始化支持多级目录压缩的ZipMultiDirectoryCompress
        ZipMultiDirectoryCompress zipCompress = new ZipMultiDirectoryCompress();
        //压缩目录，可以指向一个文件
        String directory = "C:/computer";
        //生成的压缩文件
        String destFile = "c:/computer.zip";
        //默认的相对地址，为根路径
        String defaultParentPath = "";
        ZipOutputStream zos = null;
        try {
            //创建一个Zip输出流
            zos = new ZipOutputStream(new FileOutputStream(destFile));
            //启动压缩进程
            zipCompress.startCompress(zos,defaultParentPath,directory);
        } catch (FileNotFoundException e){
            e.printStackTrace();
        } finally{
            try {
                if(zos != null)zos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 开始压缩.
     *
     * @param zos ZipOutputStream
     * @param oppositePath 相对路径，开始时相对路径为空
     * @param directory 压缩目录，也可能是文件
     */
    public void startCompress(ZipOutputStream zos, String oppositePath, String directory){
        File file = new File(directory);
        if(file.isDirectory()){
            //如果是压缩目录
            File[] files = file.listFiles();
            for(int i=0;i<files.length;i++){
                File aFile = files[i];
                if(aFile.isDirectory()){
                    //如果是目录，修改相对地址
                    String newOppositePath = oppositePath + aFile.getName() + "/";
                    //创建目录
                    compressDirectory(zos, oppositePath, aFile);
                    //进行递归调用
                    startCompress(zos,newOppositePath,aFile.getPath());
                } else {
                    //如果不是目录，则进行压缩
                    compressFile(zos,oppositePath,aFile);
                }
            }
        } else {
            //如果是压缩文件，直接调用压缩方法进行压缩
            compressFile(zos,oppositePath,file);
        }
    }

    /**
     * 压缩文件.
     *
     * @param zos ZipOutputStream
     * @param oppositePath 相对于路路径
     * @param file 压缩的文件
     */
    public void compressFile(ZipOutputStream zos, String oppositePath, File file){
        //创建一个Zip条目，每个Zip条目都是必须相对于根路径
        ZipEntry entry = new ZipEntry(oppositePath + file.getName());
        InputStream is = null;
        try{
            //将条目保存到Zip压缩文件当中
            zos.putNextEntry(entry);
            //从文件输入流当中读取数据，并将数据写到输出流当中.
            is = new FileInputStream(file);
            int length = 0;
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            while((length=is.read(buffer,0,bufferSize))>=0){
                zos.write(buffer, 0, length);
            }
            zos.closeEntry();
        }catch(IOException ex){
            ex.printStackTrace();
        } finally {
            try{
                if(is != null)is.close();
            }catch(IOException ex){
                ex.printStackTrace();
            }
        }
    }

    /**
     * 在压缩文件当中创建一个新的压缩目录，支持空目录.
     *
     * @param zos
     * @param oppositePath
     * @param file
     */
    public void compressDirectory(ZipOutputStream zos, String oppositePath, File file){
        //压缩目录，这是关键，创建一个目录的条目时，需要在目录名后面加多一个"/"
        ZipEntry entry = new ZipEntry(oppositePath + file.getName() + "/");
        try {
            zos.putNextEntry(entry);
            zos.closeEntry();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

RMI开发 Step By Step

yuzhechen@163.com(admin) — Wed,26 Dec 2007 16:46:07 +0800

    版权所有，欢迎转载，转载请注明转自http://www.suneca.com

    RMI（Remote Method Invocation）RMI是分布式对象软件包，它简化了在多台计算机上的JAVA应用之间的通信。RMI从JDK1.1以后开始支持。
    RMI系统采用类似CORBA的对象请求代理机制，桩(Stub)是远程对象在客户端的代理，客户程序中的远程对象引用其实是对本地脏的引用。桩负责将远程调用请求通过远程引用层和传输层转发给服务端的框架(skeleton)，再由框架将请求分派给服务程序中的对象实现。
    远程引用层分为客户端与服务端两个相互协作的组件，负责完成远程调用的语义。
    传输层也分为客户端与服务器两部分，负责建立与管理连接，跟踪远程对象，以及将调用请求分派给合适的对象实现实例。在服务端，传输层将调用请求向上转发给远程引用层，远程引用层作相应处理后转发给框架，由框架向上调用服务程序中的对象实现，对象实现执行真正的方法调用任务。远程调用返回结果送回客户程序的路线与调用请求的传送路线刚好相反，首先经过服务端的框架、远程引用层和传输层，再向上经过客户端的传输层、远程引用层和桩。
    RMI体系结构图

    RMI在桩/框架层利用了两种关键技术。一种是java语言志用的对象串行化(object serialization)技术，该技术支持将对象的类型与值信息转为平坦的字节流形式，并可利用这种串行化表示重建与原对象状态相同的同类型对象，从而实现对象状态的持久性或网络传输，桩和框架利用这一技术对远程调用的参数与返回值进行打包与解包。另一种技术是动态类装载(dynamic class loading)，用于在程序动态远行时装载客户程序所需的框，并支持java语言内建的类型检查与类型转换机制。

    第一步，定义接口，继承java.rmi.Remote

 程序代码
package zizz.rmi;

/**
 * 定义一个问候者的接口.
 * @author ZIZZ
 * @Company manbuchina
 * Create-Time:2007-8-16 下午11:06:48
 */
public interface Greeter extends java.rmi.Remote{
    
    String greetByName(String name) throws java.rmi.RemoteException;
    
}

第二步，定义实现，继承UnicastRemoteObject

 程序代码
package zizz.rmi;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

/**
 * 问候者的实现.
 * @author ZIZZ
 * @Company manbuchina
 * Create-Time:2007-8-16 下午11:08:46
 */
public class GreeterImpl extends UnicastRemoteObject implements Greeter {

    /**
     * serialVersionUID
     */
    private static final long serialVersionUID = -5870885426008943753L;
    
    /**
     * 
     * @throws RemoteException
     */
    public GreeterImpl() throws RemoteException {
        //继承了UnicastRemoteObject，必须实现相应的构造器
        super();
    }

    public String greetByName(String name) throws RemoteException {
        return "您好，" + name;
    }

}

第三步，开发服务器端

 程序代码
package zizz.rmi;

import java.net.MalformedURLException;
import java.rmi.AlreadyBoundException;
import java.rmi.Naming;
import java.rmi.RemoteException;

/**
 * 服务程序
 * @author ZIZZ
 * @Company manbuchina
 * Create-Time:2007-8-16 下午11:10:54
 */
public class GreeterServer {
    
    public static void main(String[] args){
        try {
            GreeterImpl greeterImpl = new GreeterImpl();
            //绑定服务对象
            try {
                Naming.bind("SayHello", greeterImpl);
            } catch (AlreadyBoundException e) {
                e.printStackTrace();
            }
            System.out.println("系统已经成功绑定服务对象.");
        } catch (RemoteException e) {
            System.out.println("错误信息为：" + e.getMessage());
            e.printStackTrace();
        } catch (MalformedURLException e) {
            System.out.println("错误信息为：" + e.getMessage());
            e.printStackTrace();
        }
    }
}

    第四步，使用rmic产生客户端桩
    rmic zizz.rmi.GreeterImpl
    使用rmic将会产生一个GreeterImpl_Stub.class的新文件
    第五步，将产生的客户端桩及接口copy到客户端
    将GreeterImpl_Stub.class，Greeter.class这两个文件，使用jar命令打个包，取名叫rmiclient.jar
    命令如下：
    jar cvf rmiclient.jar zizz/rmi/GreeterImpl_Stub.class zizz/rmi/Greeter.class
    第六步，编写客户端

 程序代码
package zizz.rmi;

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

/**
 * RMI客户端
 * @author ZIZZ
 * @Company manbuchina
 * Create-Time:2007-8-16 下午11:25:29
 */
public class GreeterClient {
    
    public static void main(String[] args){
        try {
            //如果是其它服务器，则查找 rmi://server_name/SayHello
            Greeter greeter = (Greeter)Naming.lookup("rmi://127.0.0.1/SayHello");
            System.out.println(greeter.greetByName("ZIZZ"));
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (RemoteException e) {
            e.printStackTrace();
        } catch (NotBoundException e) {
            e.printStackTrace();
        }
    }

}

    第七步，使用rmiregistry起用服务，监听1099端口
    在命令行下打入rmiregistry，启用RMI注册表。
    注意，运行该注册表必须进入工程的Classpath下，也就是说，跟第八步运行服务器端必须在同一个路径
    第八步，启用服务器端，将服务对象绑定到rmigegistry当中
    java zizz.rmi.GreeterServer
    第九步，运行客户端，查看结果
    java zizz.rmi.GreeterClient

    其实RMI开发是非常简单的，关键就是要把原理搞清楚，把开发顺序搞清楚就可以了。如果返回的结果是一个对象，那该对象必须实现串行化接口，不然，程序在运行期间将会报错。
    有问题可以跟我联系：yuzhechen@163.com

应用系统发布在Oracle Application Server 10g的上下文的根目录

yuzhechen@163.com(admin) — Mon,24 Dec 2007 14:25:06 +0800

    版权所有，欢迎转载，转载请注明转自http://www.suneca.com

      在开发应用系统的时候，我们通常使用的上下文并不是根路径，而发布在测试服务器或生产服务器的时候，我们会将它发布在根目录下，以便通过ip地址可以直接访问得到，比如：http://www.suneca.com或http://192.168.1.163进行访问。

      oracle Application Server 10g将应用系统发布在根路径非常麻烦，在OC4J下面发布的时候，非常简单，只需要在context的选项当中输入 / 即可，但是在Oracle Application Server 10g下面发布是非常痛苦的一件事，一旦操作有误，应用服务器就起不来了，需要手工去修改server.xml及default-web-site.xml这两个配置文件，重起才能使用。

    之前研究Oracle Application Server 10g的时候，真的只能用四个字来形容，那就是“生不如死”，因为手头没有什么资料，google或baidu出来的信息很多都不能用。后来不断地尝试，再加上通过公司的资源，跟深圳Oracle 的售后工程师取得联系之后，在他们的支持下，最终解决了问题。现在总结一下，希望能给这一块有需要的朋友提供帮助。

    第一步，我们需要发布我们的应用系统，在发布应用系统的时候，指定上下文路径为/，如下图所示：

      接着，将应用程序成功发布，发布完之后可以关闭，也可以不关闭，先按以下的步骤修改配置文件先，但先万不要重起，一重起就麻烦了，需要做的事情会多很多。

    第二步，修改配置文件，进入%OAS_HOME%/Apache/Apache/conf/目录，找到mod_oc4j.conf文件，进行修改。在之间，加入

 程序代码
Oc4jMount /
Oc4jMount /*

注意，这种修改方式只适应于OAS instance为home的情况，假如你安装的OAS instance不是home，是其他名字，那要改为：

 程序代码
Oc4jMount / 
Oc4jMount /* 

第三步：修改%OAS_HOME%/j2ee/home/config/default-web-site.xml配置文件。
屏蔽以下设置:

 程序代码
<default-web-app application="default" name="defaultWebApp" root="/j2ee" />
<web-app application="training" name="training" load-on-startup="true"/>

将刚刚发布的应用作为default-web-app，如下所示：

 程序代码
<default-web-app application="training" name="training" load-on-startup="true" root="/" />

修改完的default-web-app.xml文件如下程序块所示：

程序代码

<?xml version="1.0"?>

<web-site xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://xmlns.oracle.com/oracleas/schema/web-site-10_0.xsd"  port="12501" protocol="ajp13" display-name="OC4J 10g (10.1.3) Default Web Site" schema-major-version="10" schema-minor-version="0" >

    <default-web-app application="training" name="training" load-on-startup="true" root="/" />
    <web-app application="system" name="dms" root="/dmsoc4j" access-log="false" />
    <web-app application="system" name="JMXSoapAdapter-web" root="/JMXSoapAdapter" />
    <web-app application="default" name="jmsrouter_web" load-on-startup="true" root="/jmsrouter" />
    <web-app application="ascontrol" name="ascontrol" load-on-startup="true" root="/em" />
    <web-app application="bc4j" name="webapp" load-on-startup="true" root="/webapp" />

    <access-log path="../log/default-web-access.log" split="day" />
</web-site>

      第四步：重起opmn
      opmnctl stopall  停步opmn及所有服务
      opmnctl startall 启动opmn及所有服务
    opmnctl status  检查opmn服务的状态，必须为Alive

     第五步：测试
    打开IE，浏览一下http://localhost<:youport>，假如显示正常，则说明发布已经成功。

     注意：假如你的opmn起不来或者发布之后没有修改配置文件就马上重起的，此时，你需要检查一下%OAS_HOME%/j2ee/home/config/server.xml文件，一般在倒数第四行，有没有一个

 程序代码
<web-site default="true" path="./default-web-site.xml" />

假如没有的话，重新加进去即可。

基于Hibernate的应用系统在Oracle Application Server 10g上的发布

yuzhechen@163.com(admin) — Fri,21 Dec 2007 14:06:29 +0800

版权所有，欢迎转载，转载请注明转自http://www.suneca.com

Hibernate 3版本开发的应用程序，发布在Oracle Application Server 10g上面将会有很严重的问题，那就是OC4J不断地关闭，启动。启动完之后，假如再对刚刚发布的应用程序再次访问，OC4J再次关闭，再次启动！郁闷！之前给佛山电信做生产辅助系统的时候，就遇到了这个非常麻烦的问题。查看OAS日志，可以在日志里面看到有这样一行信息：

 程序代码
 ClassNotFoundException: org.hibernate.hql.ast.HqlToken

基于Hibernate的应用系统发布在Oracle Application Server 10g将会有一些问题，主要是Hibernate跟 oracle TopLink包冲突导致了应用系统无法顺利发布在Oracle Application Server上。其实这类问题还是比较好解决的，解决的方法与途径也两种，当然可能其他人有更高明的解决方案。
第一种解决办法就是修改Hibernate的HQL解析，不过，问题比较大，有些HQL在默认的解析方式下可以使用，一旦修改解析方式就不能用了，所以这种方式也不推荐。
第二种是在发布的时候，将Oracle Application Server对TopLink的支持给干掉，这个也是目前我认为的最好的解决方案。
现在一步一步介绍一下Struts+Spring+Hibernate应用系统在OAS上面的发布。
进入OAS管理后台，默认的OAS端口号是80端口，当然这个端口可以自己修改。注意，修改OAS整合了一个Apache，修改http访问的端口必须修改%OAS_HOME%/Apache/config/httpd.conf文件，将监听端口吃改为你自己喜欢的端口。
进入home下面的“应用程序”标签，如下图所示：

点击部署按钮，将进入部署页面，如下图所示：

在部署页面选择“运行 Application Server Control 的服务器上已存在档案。”，在“服务器的位置”上输入应用程序存放于应用服务器的位置，当然，你也可以通过浏览后将本机的应用程序包上传到服务器上。不管你是否将文件保存在服务器或上传到服务器，最终，都将会在Windows的临时文档夹当中看到上传的war文件。
之后，点击下一页，进入应用程序的上下文配置页面。

在应用程序名称上输入你喜欢的应用程序名称，这个名字你可以随便取；在上下文根上面，输入/training，表示该应用是相对于根路径下面的training路径，以后访问training下面的所有资源都必须在根路径加多一个training，比如:http://localhost/training/index.do，之后，点击下一页，将进入部署设置管理界面，如下图所示：

点击“配置类加载”加边的笔，进入配置类加载的管理界面，如下图所示：

在导入共享库当中，将所有的共享库全部显示出来，并找到oracle.toplink的共享库，将导入的远项去掉，如下图所示：

接着，点击确定按钮，返回上一页。最后，点击部署按钮，完成应用程序的部署工作。如下图所示：

最后，访问刚刚部署的应用系统：http://localhost/training，效果如下图所示：

发布后的应用程序可以在%OAS_HOME%/j2ee/home/applications里面看到相应的目录。
注意：假如你是在Oracle Application Server 10，版本为：10.1.3.0.0下面发布应用程序，假如数据库是使用Oracle的，那你会发布，页面访问超级慢，简单生不如死，一个页面出来差不多要十秒钟，那此时你必须在发布应用程序之前，将数据源配置好，然后应用程序的数据源也配置好，不然，将会出现一些意想不到的问题。希望这篇文章能给遇到这一方面问题的朋友一些帮助。