BlogJava-金色闪电--陈彦虎（Ryan）-文章分类-J2SE

提交与回滚事务

金色闪电 — Mon, 28 Dec 2009 13:22:00 GMT

    事务在提交前，所有的操作都是在虚拟的环境中进行的，事务提交时才将事务进行的所有修改更新到数据库的存储介质上，如硬盘。在事务提交前，如果有操作失败的情况，那么需要进行回滚操作，便可以取消事务所进行的修改，当事务被提交后，再执行回滚是无效的。
    事务需要数据库的支持，不是所有的数据库都执行事务，如MySQL中默认的数据库都采用了MyISAM存储引擎，它不支持事务，如果MySQL数据库采用InnoDB存储的引擎，便支持事务。通过DatabaseMetaData的supportsTransactions方法可以判断数据库是否支持事务。
    数据库连接Connection对象默认是自动提交的，即在该连接下，每用Statement执行一条SQL语句，便提交到数据库。为了控制事务提交的时机，需要在事务开始前，调用Connection的setAutoCommit方法将数据库连接的自动提交属性关闭，此后，所有的操作都不会提交到数据库，直到调用Connection的commit方法，提交事务位置。
    在提交事务之前，一旦有SQL语句执行不通过，应调用Connection的rollback方法，执行回滚操作，那么此前所有数据库操作将无效。

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.sql.Statement;

/**
* 判断数据库是否支持事务，如果支持，如何实现事务的提交与回滚。
* MySQL中如果要使用事物，必须使用InnoDB存储引擎，在创建表时，后面加上ENGINE=InnoDB。
* MySQL默认的存储引擎是MyISAM，不支持事物
*/
public class Transaction {

    /**
     * 判断数据库是否支持事务
     * @param con    数据库的连接
     * @return
     */
    public static boolean supportTransaction(Connection con){
        try {
            // 得到数据库的元数据
            DatabaseMetaData md = con.getMetaData();
            return md.supportsTransactions();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 将一组SQL语句放在一个事务里执行，要某全部执行通过，要某全部不执行
     * @param con    数据库的连接
     * @param sqls    待执行的SQL数组
     */
    public static void goTransaction(Connection con, String[] sqls){
        if (sqls == null){
            return ;
        }
        Statement sm = null;
        try {
            // 事务开始
            System.out.println("事务开始！");
            // 设置连接不自动提交，即用该连接进行的操作都不更新到数据库
            con.setAutoCommit(false);
            sm = con.createStatement();
            for (int i=0; i<sqls.length; i++){
                // 执行SQL语句，但是没更新到数据库
                sm.execute(sqls[i]);
            }
            // 提交，立即更新到数据库
            System.out.println("事务提交！");
            con.commit();
            System.out.println("事务结束！");
            // 事务结束
        } catch (SQLException e) {
            try {
                // 出现异常时，进行回滚，取消前面执行的操作
                System.out.println("事务执行失败，进行回滚！");
                con.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            OperateDB.closeStatement(sm);
        }
    }

    public static void main(String[] args) throws ClassNotFoundException,
            SQLException {
        String dbName = "studentdb";
        String userName = "test";
        String password = "test";
        String[] sqls = new String[3];
        sqls[0] = "UPDATE student_basic_innodb SET score=93 where name='john'";
        sqls[1] = "INSERT INTO student_basic_innodb (name, age, score)"
            + " VALUES ('zhangsan', 17, 86)";
        // 执行这条语句会引起错误，因为表student_basic_innodb没有xxxxxxx列
        sqls[2] = "DELETE FROM student_basic_innodb where xxxxxxx='wade'";

        Connection con = null;
        try {
            // 获得数据库连接
            con = DBConnector.getMySQLConnection(null, null, null, dbName,
                    userName, password);
            // 判断是否支持批处理
            boolean supportTransaction = Transaction.supportTransaction(con);
            System.out.println("支持事务？ " + supportTransaction);
            if (supportTransaction){
                // 执行事务
                Transaction.goTransaction(con, sqls);
            }
        } catch (ClassNotFoundException e1) {
            throw e1;
        } catch (SQLException e2) {
            throw e2;
        } finally {
            // 关闭数据库连接
            OperateDB.closeConnection(con);
        }
    }
}

金色闪电 2009-12-28 21:22 发表评论

值得怀念的JDBC

金色闪电 — Mon, 28 Dec 2009 13:07:00 GMT

摘要: 只有在数据库服务开启时，才能连接数据库。需要提供连接数据库的Java驱动类和数据库的URL，不同数据库的URL的格式略有不同，但都符合一个基本的格式，即“协议名+IP地址（域名）+端口+数据库名”。如果数据库设有... 阅读全文

金色闪电 2009-12-28 21:07 发表评论

线程--BlockingQueue

金色闪电 — Thu, 24 Dec 2009 13:59:00 GMT

摘要: 本例介绍一个特殊的队列：BlockingQueue，如果BlockingQueue是空的，从BlockingQueue取东西的操作将会被阻断进入等待状态，直到BlockingQueue进了东西才会被唤醒，同样，如果BlockingQueue是满的，任何试图往里存东西的操作也会被阻断进入等待状态，直到BlockingQueue... 阅读全文

金色闪电 2009-12-24 21:59 发表评论

线程--Exchanger

金色闪电 — Thu, 24 Dec 2009 13:31:00 GMT

摘要: 本例介绍第四个同步装置：Exchanger，它让两个线程呼唤信息。本实例模拟服务生和顾客，服务生往空杯子中倒水，顾客从装满水的杯子中喝水，然后互换杯子，服务生接着倒水，顾客接着喝水。初始化Exchanger对象时，可以通过泛型指定杯子能交换的信息类型。如“new Exchanger阅读全文

金色闪电 2009-12-24 21:31 发表评论

线程--CyclicBarrier

金色闪电 — Wed, 23 Dec 2009 15:38:00 GMT

本例介绍第三个同步装置：CyclicBarrier，它维护一个计数器，与CountDownLatch不同的是，等待这个CyclicBarrier的线程必须等到计数器到达某个值时，才可以继续。CyclicBarrier就像它名字的意思一样，可看成是个障碍，所有的线程必须到齐后才能一起通过这个障碍。本例实现一个数组相邻元素的加法，一个线程给数组的第一个元素赋值，然后等待其他线程给数组第二个元素赋值，然后将第一个元素和第二个元素相加。

构造CyclicBarrier对象时，需要指定计数器的目标值，计数器的初始值为0.还可以在构造方法中带一个Runnable参数，表示当计数器到达目标值时，在等待CyclicBarrier的线程被唤醒之前，指定该Runnable任务。
CyclicBarrier的await方法使当前线程进入等待状态，计数器加1，当计数器到达目标值时，当前线程被唤醒。

import java.util.Random;
import java.util.concurrent.CyclicBarrier;

/**
* CyclicBarrier类似于CountDownLatch也是个计数器，
* 不同的是CyclicBarrier数的是调用了CyclicBarrier.await()进入等待的线程数，
* 当线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。
* CyclicBarrier就象它名字的意思一样，可看成是个障碍，
* 所有的线程必须到齐后才能一起通过这个障碍。
* CyclicBarrier初始时还可带一个Runnable的参数，
* 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。
*/
public class CyclicBarrierTest {

    public static class ComponentThread implements Runnable {
        CyclicBarrier barrier;// 计数器
        int ID;    // 组件标识
        int[] array;    // 数据数组

        // 构造方法
        public ComponentThread(CyclicBarrier barrier, int[] array, int ID) {
            this.barrier = barrier;
            this.ID = ID;
            this.array = array;
        }

        public void run() {
            try {
                array[ID] = new Random().nextInt(100);
                System.out.println("Component " + ID + " generates: " + array[ID]);
                // 在这里等待Barrier处
                System.out.println("Component " + ID + " sleep");
                barrier.await();
                System.out.println("Component " + ID + " awaked");
                // 计算数据数组中的当前值和后续值
                int result = array[ID] + array[ID + 1];
                System.out.println("Component " + ID + " result: " + result);
            } catch (Exception ex) {
            }
        }
    }
    /**
     * 测试CyclicBarrier的用法
     */
    public static void testCyclicBarrier() {
        final int[] array = new int[3];
        CyclicBarrier barrier = new CyclicBarrier(2, new Runnable() {
            // 在所有线程都到达Barrier时执行
            public void run() {
                System.out.println("testCyclicBarrier run");
                array[2] = array[0] + array[1];
            }
        });

        // 启动线程
        new Thread(new ComponentThread(barrier, array, 0)).start();
        new Thread(new ComponentThread(barrier, array, 1)).start();
    }

    public static void main(String[] args) {
        CyclicBarrierTest.testCyclicBarrier();
    }
}

金色闪电 2009-12-23 23:38 发表评论

线程--CountDownLatch

金色闪电 — Wed, 23 Dec 2009 15:20:00 GMT

     本例介绍第二种同步装置：CountDownLatch，它维护一个计数器，等待这个CountDownLatch的线程必须等到计数器为0时才可以继续。本例模拟服务器的启动，假设启动一个服务器需要初始化3个组件，当3个组件初始化完毕时，服务器才算成功启动。

     构造CountDownLatch对象时，需要制定计数器的初始值，该值必须大于等于0，一旦对象被创建，其初始值将不能被改变。
     CountDownLatch的await方法使当前线程进入等待状态，直到计数器为0.
     CountDownLatch的countDown方法使计数器减1.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* CountDownLatch是个计数器，它有一个初始数，
* 等待这个计数器的线程必须等到计数器倒数到零时才可继续。
*/
public class CountDownLatchTest {

    /**
     * 初始化组件的线程
     */
    public static class ComponentThread implements Runnable {
        // 计数器
        CountDownLatch latch;
        // 组件ID
        int ID;

        // 构造方法
        public ComponentThread(CountDownLatch latch, int ID) {
            this.latch = latch;
            this.ID = ID;
        }

        public void run() {
            // 初始化组件
            System.out.println("Initializing component " + ID);
            try {
                Thread.sleep(500 * ID);
            } catch (InterruptedException e) {
            }
            System.out.println("Component " + ID + " initialized!");
            //将计数器减一
            latch.countDown();
        }
    }

    /**
     * 启动服务器
     */
    public static void startServer() throws Exception {
        System.out.println("Server is starting.");
        //初始化一个初始值为3的CountDownLatch
        CountDownLatch latch = new CountDownLatch(3);
        //起3个线程分别去启动3个组件
        ExecutorService service = Executors.newCachedThreadPool();
        service.submit(new ComponentThread(latch, 1));
        service.submit(new ComponentThread(latch, 2));
        service.submit(new ComponentThread(latch, 3));
        service.shutdown();

        //等待3个组件的初始化工作都完成
        latch.await();

        //当所需的三个组件都完成时，Server就可继续了
        System.out.println("Server is up!");
    }

    public static void main(String[] args) throws Exception {
        CountDownLatchTest.startServer();
    }
}

金色闪电 2009-12-23 23:20 发表评论

线程--Semaphore

金色闪电 — Wed, 23 Dec 2009 15:14:00 GMT

   本例介绍第一个同步装置：Semaphore，它是一个用来管理资源池的工具，可以看成是个通行证，线程想要从资源池拿到资源必须先拿到通行证，如果线程暂时拿不到通行证，线程就会被阻断，进入等待状态。

     在构造Semaphore对象时，必须提供通行证的数目，如"new Semaphore(3)"将创建一个具有3个通行证的Semaphore对象，一旦该对象被创建，其通行证数量是不能改变的。
     Semaphore的acquire方法取得一个通行证，如果通行证已经发完了，当前线程将进入等待状态，直到有其他线程释放了通行证。
     Semaphore的release方法释放资源池。

import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
* Java 5.0里新加了4个协调线程间进程的同步装置，它们分别是：
* Semaphore, CountDownLatch, CyclicBarrier和Exchanger.
* 本例主要介绍Semaphore。
* Semaphore是用来管理一个资源池的工具，可以看成是个通行证，
* 线程要想从资源池拿到资源必须先拿到通行证，
* 如果线程暂时拿不到通行证，线程就会被阻断进入等待状态。
*/
public class SemaphoreTest {
    /**
     * 模拟资源池的类
     * 只为池发放2个通行证，即同时只允许2个线程获得池中的资源。
     */
    public static class Pool {
        // 保存资源池中的资源
        ArrayList<String> pool = null;
        // 通行证
        Semaphore pass = null;
        Lock lock = new ReentrantLock();
        public Pool(int size) {
            // 初始化资源池
            pool = new ArrayList<String>();
            for (int i = 0; i < size; i++) {
                pool.add("Resource " + i);
            }
            // 发放2个通行证
            pass = new Semaphore(2);
        }

        public String get() throws InterruptedException {
            // 获取通行证,只有得到通行证后才能得到资源
            System.out.println("Try to get a pass");
            pass.acquire();
            System.out.println("Got a pass");
            return getResource();
        }

        public void put(String resource) {
            // 归还通行证，并归还资源
            System.out.println("Released a pass");
            pass.release();
            releaseResource(resource);
        }

        private String getResource() {
            lock.lock();
            String result = pool.remove(0);
            System.out.println("资源 " + result + " 被取走");
            lock.unlock();
            return result;
        }

        private void releaseResource(String resource) {
            lock.lock();
            System.out.println("资源 " + resource + " 被归还");
            pool.add(resource);
            lock.unlock();
        }
    }

    public static void testPool() {
        // 准备10个资源的资源池
        final Pool aPool = new Pool(10);
        Runnable worker = new Runnable() {
            public void run() {
                String resource = null;
                try {
                    //取得resource
                    resource = aPool.get();
                    //用resource做工作
                    System.out.println("I am working on " + resource);
                    Thread.sleep(500);
                    System.out.println("I finished on " + resource);
                } catch (InterruptedException ex) {
                }
                //归还resource
                aPool.put(resource);
            }
        };
        // 启动5个任务
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            service.submit(worker);
        }
        service.shutdown();
    }

    public static void main(String[] args) {
        SemaphoreTest.testPool();
    }
}

金色闪电 2009-12-23 23:14 发表评论

线程--条件Condition

金色闪电 — Wed, 23 Dec 2009 14:50:00 GMT

摘要: 本例介绍一个篮子程序，为了简化问题，篮子中最多只能有一个苹果。消费者必须在篮子里有苹果的时候才能吃苹果，否则它必须暂时放弃对篮子的锁定，等到生产者往篮子里放了苹果后再去拿来吃。而生产者也必须等到篮子空了才能往里放苹果，否则它也需要暂时解锁等消费者把苹果吃了才能往篮子里放苹果。通过Lock的n... 阅读全文

金色闪电 2009-12-23 22:50 发表评论

线程--锁

金色闪电 — Tue, 22 Dec 2009 13:10:00 GMT

摘要: ReentrantLock类实现了Lock接口，通过它可以完全取代synchronized关键字 ReentrantLock的lock方法取得锁，如果该锁定没有被其他线程占据，则获取该锁定并返回，将保持计数器置为1；如果当前线程已经占据锁，则立即返回... 阅读全文

金色闪电 2009-12-22 21:10 发表评论

线程--任务执行架构

金色闪电 — Tue, 22 Dec 2009 12:53:00 GMT

   Executor服务对象是用来执行Runnable任务的，常用的方法如下：
          execute方法用于执行Ruannable类型的任务。
   ExecutorService服务对象能执行和终止Callable任务，它继承了Executor，所以也能执行Runnable任务。常用的方法如下：

         submit方法用来提交Callable 或Runnable任务，并返回代表此任务的Future对象。
         invokeAll方法批处理任务集合，并返回一个代表这些任务的Future对象集合。
         shutdown方法在完成已提交的任务后关闭服务，不再接受新任务。
         shutdownNow方法停止所有正在执行的任务并关闭服务。
         isTerminated测试是否所有任务都执行完毕了。
         isShuttdown测试是否该ExecutorService已被关闭。

    ScheduledExecutorService服务对象继承ExecutorService，提供了按时间安排执行任务的功能。常用的方法如下:
           a>schedule(task,initDelay)方法安排所提交的Runnable任务按指定的间隔重复执行。
           b>scheduleAtFixedRate方法安排所提交的Runnable任务按指定的间隔重复执行。
           c>sheduleWithFixedDelay方法安排所提交的Runnable任务在每次执行完后，等待delay所指定的时间后重复执行。
    Executors类用来创建各种服务对象，常用的方法如下：
           a> callable（Runnable task）方法将Runnable的任务转化成Callable的任务。
           b> newSingleThreadExecutor方法产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，则按先后顺序执行任务。
           c>newCachedThreadPool方法产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
           d>newFixedThreadPool(int poolSize)方法产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个队列里顺序执行
           e>   newSingleThreadScheduledExecutor方法产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，若任务多余一个，任务将按先后顺序执行。
           f>newScheduledThreadPool(int poolSize) 方法产生一个ScheduleExecutorService对象，这个对象的线程池大小为poolSize，若任务数量大于poolSize，任务会在一个队列里等待执行。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
* 新的任务执行架构。
* 在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的，
* 任务的提于交和执行是同时进行的，如果你想对任务的执行进行调度，
* 或是控制同时执行的线程数量就需要额外编写代码来完成。
* 5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行，
* 并且可以建立一个类似数据库连接池的线程池来执行任务。
* 这个架构主要有三个接口和其相应的具体类组成。
* 这三个接口是Executor, ExecutorService和ScheduledExecutorService。
* （1）Executor接口：是用来执行Runnable任务的，它只定义一个方法：
* execute(Runnable command)：执行Ruannable类型的任务
* （2）ExecutorService：继承了Executor的方法，并提供了执行Callable任务和中止任务执行的服务，
* 其定义的方法主要有：
* submit(task)：可用来提交Callable或Runnable任务，并返回代表此任务的Future对象
* invokeAll(collection of tasks)：批处理任务集合，并返回一个代表这些任务的Future对象集合
* shutdown()：在完成已提交的任务后关闭服务，不再接受新任务
* shutdownNow()：停止所有正在执行的任务并关闭服务。
* isTerminated()：测试是否所有任务都执行完毕了。
* isShutdown()：测试是否该ExecutorService已被关闭
* （3）ScheduledExecutorService：继承ExecutorService，提供了按时间安排执行任务的功能、
* schedule(task, initDelay): 安排所提交的Callable或Runnable任务在initDelay指定的时间后执行。
* scheduleAtFixedRate()：安排所提交的Runnable任务按指定的间隔重复执行
* scheduleWithFixedDelay()：安排所提交的Runnable任务在每次执行完后，等待delay所指定的时间后重复执行。
*
* 通过Executors类来获得各种服务对象。
* callable(Runnable task): 将Runnable的任务转化成Callable的任务
* newSingleThreadExecutor: 产生一个ExecutorService对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。
* newCachedThreadPool(): 产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。
* newFixedThreadPool(int poolSize)：产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，若任务数量大于poolSize，任务会被放在一个queue里顺序执行。
* newSingleThreadScheduledExecutor：产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，若任务多于一个，任务将按先后顺序执行。
* newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService对象，这个对象的线程池大小为poolSize，若任务数量大于poolSize，任务会在一个queue里等待执行
*/
public class ExecuteArch {

    /**
     * 该线程输出一行字符串
     */
    public static class MyThread implements Runnable {
        public void run() {
            System.out.println("Task repeating. " + System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Task interrupted. "
                        + System.currentTimeMillis());
            }
        }
    }

    /**
     * 该Callable结束另一个任务
     */
    public static class MyCallable implements Callable {
        private Future future;

        public MyCallable(Future future) {
            this.future = future;
        }

        public String call() {
            System.out.println("To cancell Task"
                    + +System.currentTimeMillis());
            this.future.cancel(true);
            return "Task cancelled!";
        }
    }

    /**
     * @param args
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException,
            ExecutionException {
        // 产生一个ExecutorService对象，这个对象带有一个线程池，线程池的大小会根据需要调整，
        // 线程执行完任务后返回线程池，供执行下一次任务使用。
        ExecutorService cachedService = Executors.newCachedThreadPool();
        Future myThreadFuture = cachedService.submit(new MyThread());
        Future myCallableFuture = cachedService.submit(new MyCallable(
                myThreadFuture));
        System.out.println(myCallableFuture.get());
        System.out.println("-----------------");

        // 将Runnable任务转换成Callable任务
        Callable myThreadCallable = Executors.callable(new MyThread());
        Future myThreadCallableFuture = cachedService.submit(myThreadCallable);
        // 对于Runnable任务，转换成Callable任务后，也没有返回值
        System.out.println(myThreadCallableFuture.get());
        cachedService.shutdownNow();
        System.out.println("-----------------");

        // 产生一个ExecutorService对象，这个对象带有一个大小为poolSize的线程池，
        // 若任务数量大于poolSize，任务会被放在一个queue里顺序执行
        ExecutorService fixedService = Executors.newFixedThreadPool(2);
        fixedService.submit(new MyThread());
        fixedService.submit(new MyThread());
        // 由于线程池大小为2，所以后面的任务必须等待前面的任务执行完后才能被执行。
        myThreadFuture = fixedService.submit(new MyThread());
        myCallableFuture = fixedService.submit(new MyCallable(myThreadFuture));
        System.out.println(myCallableFuture.get());
        fixedService.shutdownNow();
        System.out.println("-----------------");

        // 产生一个ScheduledExecutorService对象，这个对象的线程池大小为poolSize，
        // 若任务数量大于poolSize，任务会在一个queue里等待执行
        ScheduledExecutorService fixedScheduledService = Executors
                .newScheduledThreadPool(2);
        // 新建任务1
        MyThread task1 = new MyThread();
        // 使用任务执行服务立即执行任务1，而且此后每隔2秒执行一次任务1。
        myThreadFuture = fixedScheduledService.scheduleAtFixedRate(task1, 0, 2,
                TimeUnit.SECONDS);
        // 新建任务2
        MyCallable task2 = new MyCallable(myThreadFuture);
        // 使用任务执行服务等待5秒后执行任务2，执行它后会将任务1关闭。
        myCallableFuture = fixedScheduledService.schedule(task2, 5,
                TimeUnit.SECONDS);
        System.out.println(myCallableFuture.get());
        fixedScheduledService.shutdownNow();
    }
}

金色闪电 2009-12-22 20:53 发表评论

线程--Callable和Future

金色闪电 — Mon, 21 Dec 2009 13:16:00 GMT

     Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。
     Callable和Runnable的区别如下：

              Callable定义的方法是call，而Runnable定义的方法是run。
              Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。
              Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常。
       Future表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。Future的cancel方法取消任务的执行，有一个布尔参数，参数为true表示立即中断任务的执行，参数为false表示允许正在运行的任务运行完成。Future的get方法等待计算完成，获取计算结果。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
* Callable 和 Future接口
* Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
* Callable和Runnable有几点不同：
* （1）Callable规定的方法是call()，而Runnable规定的方法是run().
* （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
* （3）call()方法可抛出异常，而run()方法是不能抛出异常的。
* （4）运行Callable任务可拿到一个Future对象，
* Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
* 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
*/
public class CallableAndFuture {

    /**
     * 自定义一个任务类，实现Callable接口
     */
    public static class MyCallableClass implements Callable{
        // 标志位
        private int flag = 0;
        public MyCallableClass(int flag){
            this.flag = flag;
        }
        public String call() throws Exception{
            if (this.flag == 0){
                // 如果flag的值为0，则立即返回
                return "flag = 0";
            }
            if (this.flag == 1){
                // 如果flag的值为1，做一个无限循环
                try {
                    while (true) {
                        System.out.println("looping.");
                        Thread.sleep(2000);
                    }
                } catch (InterruptedException e) {
                    System.out.println("Interrupted");
                }
                return "false";
            } else {
                // falg不为0或者1，则抛出异常
                throw new Exception("Bad flag value!");
            }
        }
    }

    public static void main(String[] args) {
        // 定义3个Callable类型的任务
        MyCallableClass task1 = new MyCallableClass(0);
        MyCallableClass task2 = new MyCallableClass(1);
        MyCallableClass task3 = new MyCallableClass(2);

        // 创建一个执行任务的服务
        ExecutorService es = Executors.newFixedThreadPool(3);
        try {
            // 提交并执行任务，任务启动时返回了一个Future对象，
            // 如果想得到任务执行的结果或者是异常可对这个Future对象进行操作
            Future future1 = es.submit(task1);
            // 获得第一个任务的结果，如果调用get方法，当前线程会等待任务执行完毕后才往下执行
            System.out.println("task1: " + future1.get());

            Future future2 = es.submit(task2);
            // 等待5秒后，再停止第二个任务。因为第二个任务进行的是无限循环
            Thread.sleep(5000);
            System.out.println("task2 cancel: " + future2.cancel(true));

            // 获取第三个任务的输出，因为执行第三个任务会引起异常
            // 所以下面的语句将引起异常的抛出
            Future future3 = es.submit(task3);
            System.out.println("task3: " + future3.get());
        } catch (Exception e){
            System.out.println(e.toString());
        }
        // 停止任务执行服务
        es.shutdownNow();
    }
}

金色闪电 2009-12-21 21:16 发表评论

监控与管理虚拟机

金色闪电 — Mon, 21 Dec 2009 12:51:00 GMT

摘要: 本例介绍如何监控和管理Java虚拟机，包括获取Java虚拟机的内存使用情况、线程数、运行时间等。J2SE 5.0中使用Bean监控和管理Java虚拟机。 java.lang.management.ManagementFactory是管理Bean的工厂类，通过它的get系列方法能够获得不同的管理... 阅读全文

金色闪电 2009-12-21 20:51 发表评论

对象与XML的转换

金色闪电 — Sun, 20 Dec 2009 12:40:00 GMT

     本例介绍如何将一个对象输出到XML文档，再从XML文档中读取到内存，把一个描述学生的对象输出到XML文档，然后从XML文档中读取学生信息到内存。

     java.beans.XMLEncoder是XML编码器，它的writeObject方法能把对象以XML的格式输出到文件中。
     java.beans.XMLDecoder是XML解码器，它的readObject方法能把XML文档的内容读到对象中。注意，它只能解码用XMLEncoder生成的XML文档。
     XMLEncoder和XMLDecoder相当于对象的序列化和反序列化，只不过它以XML的格式序列化对象。

import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
* 根据对象生成XML文档.
* 使用Java提供的java.beans.XMLEncoder和java.beans.XMLDecoder类。
* 这是JDK 1.4以后才出现的类
*/
public class Object2XML {

    /**
     * 对象输出到XML文件
     * @param obj    待输出的对象
     * @param outFileName    目标XML文件的文件名
     * @return    返回输出XML文件的路径
     * @throws FileNotFoundException
     */
    public static String object2XML(Object obj, String outFileName)
            throws FileNotFoundException {
        // 构造输出XML文件的字节输出流
        File outFile = new File(outFileName);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(outFile));
        // 构造一个XML编码器
        XMLEncoder xmlEncoder = new XMLEncoder(bos);
        // 使用XML编码器写对象
        xmlEncoder.writeObject(obj);
        // 关闭编码器
        xmlEncoder.close();

        return outFile.getAbsolutePath();
    }

    /**
     * 把XML文件解码成对象
     * @param inFileName    输入的XML文件
     * @return    返回生成的对象
     * @throws FileNotFoundException
     */
    public static Object xml2Object(String inFileName)
            throws FileNotFoundException {
        // 构造输入的XML文件的字节输入流
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(inFileName));
        // 构造一个XML解码器
        XMLDecoder xmlDecoder = new XMLDecoder(bis);
        // 使用XML解码器读对象
        Object obj = xmlDecoder.readObject();
        // 关闭解码器
        xmlDecoder.close();

        return obj;
    }

    public static void main(String[] args) throws IOException {

        // 构造一个StudentBean对象
        StudentBean student = new StudentBean();
        student.setName("wamgwu");
        student.setGender("male");
        student.setAge(15);
        student.setPhone("55556666");

        // 将StudentBean对象写到XML文件
        String fileName = "AStudent.xml";
        Object2XML.object2XML(student, fileName);
        // 从XML文件读StudentBean对象
        StudentBean aStudent = (StudentBean)Object2XML.xml2Object(fileName);
        // 输出读到的对象
        System.out.println(aStudent.toString());
    }
}

金色闪电 2009-12-20 20:40 发表评论

用XSLT转换XML

金色闪电 — Sun, 20 Dec 2009 12:34:00 GMT

    XSL（eXtensible Stylesheet Language）是一种XML格式的文档，常用于定义文件的样式，比如可以用XSL定义一个HTML的样式。
    XSLT（XSL Transformations）是一种将XML文档按照XSL定义的样式进行转换的技术。比如XSLT可以按照XSL将XML文档转换成HTML文档。

     在Java中，通过JAXP（Java API for XML Processing）技术实现XSLT。
     TransformerFactory是XSLT引擎的工厂，它的newTransformer方法创建XSLT引擎Transformer,如果再创建时指定Source，则创建的XSLT引擎将按照Source进行转换。可以用XSL文件构造Source，那么使用了改Source的引擎将按照XSL文档定义的样式对XML文档进行转换。
     通过Transformer的getOutputProperties方法获得XSLT引擎的输出属性，OutputKeys.ENCODING属性表示输出的字符编码，OutputKeys.METHOD表示输出的文件格式，如html、text、xml等。
     Transformer的transform方法将Source转换成Result，其中Source为待转换的XML文件的Source，Result为目标文档的Result。

import java.io.File;
import java.util.Properties;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

/**
* 使用JAXP根据XSL转换XML文档
* JAXP是Java API for XML Processing的英文字头缩写,
* 中文含义是:用于XML文档处理的使用Java语言编写的编程接口。
* JAXP支持DOM、SAX、XSLT等标准。
*/
public class JAXPTransform {

    /**
     * 使用XSLT将XML文档转换成HTML
     * @param xmlFileName    源XML文件名
     * @param xslFileName    XSL文件名
     * @param htmlFileName    输出的HTML文件名
     * @return    返回HTML文件名
     */
    public static String xml_xslt_html(String xmlFileName, String xslFileName,
            String htmlFileName)throws Exception{
        // 创建XSLT引擎的工厂
        TransformerFactory tFactory = TransformerFactory.newInstance();
        // 创建XSLT引擎要使用的XSL文件源
        StreamSource source = new StreamSource(new File(xslFileName));
        // 创建XSLT引擎
        Transformer tx = tFactory.newTransformer(source);

        // 设置XSLT引擎的输出属性，使之输出为HTML格式，并且支持中文。
        Properties properties = tx.getOutputProperties();
        properties.setProperty(OutputKeys.ENCODING,"GB2312");
        properties.setProperty(OutputKeys.METHOD, "html");
        tx.setOutputProperties(properties);

        // 创建XML文件源和HTML文件的结果流
        StreamSource xmlSource = new StreamSource(new File(xmlFileName));
        File targetFile = new  File(htmlFileName);
        StreamResult result = new StreamResult(targetFile);

        // 实现XSLT转换，根据XSL文件源将XML文件源转换成HTML结果流
        tx.transform(xmlSource,    result);

        return targetFile.getAbsolutePath();
    }

    public static void main(String[] args) throws Exception {

        String xmlFileName = "students.xml";
        String xslFileName = "students.xsl";
        String targetFileName = "students.html";

        JAXPTransform.xml_xslt_html(xmlFileName, xslFileName, targetFileName);
    }
}

students.xsl定义了目标HTML的样式，将XML文档的相关属性用HTML显示出来，具体内容如下：

学生信息

姓名	年龄	电话

金色闪电 2009-12-20 20:34 发表评论

用SAX处理XML文档

金色闪电 — Sun, 20 Dec 2009 06:49:00 GMT

摘要: 用DOM处理XML文档时，需要读取整个XML文档，然后在内存中创建DOM树，生成DOM树上的每个Node对象。当XML文档很大时，需要的内存也就很大，开销较大。本例介绍另一种轻量级的处理XML文档的方法：SAX（Simple API for XML）,将描述学生信息的XML文档的内容解析成多个学生对象。 ... 阅读全文

金色闪电 2009-12-20 14:49 发表评论

用DOM处理XML文档

金色闪电 — Sun, 20 Dec 2009 06:07:00 GMT

摘要: DOM(Document Object Model)是一种处理XML文档的技术，通过DOM能够读取、修改XML文档。本例将介绍用DOM处理XML文档，把一个描述学生信息的XML文档读到内存中，构成多个学生对象，然后把这些学生对象的信息保存到另一个XML文档中。 DOM将整个XML文档读到内存中，用基本对象描... 阅读全文

金色闪电 2009-12-20 14:07 发表评论

调用存储过程

金色闪电 — Sat, 19 Dec 2009 17:08:00 GMT

摘要: 假设给一个名为studentdb的数据库创建若干个存储过程，SQL脚本如下： user studentdb; delimiter // create procedure my_count_proc (IN scorevalue INT, OUT no INT) BEGIN SELECT count(*) INTO no from ... 阅读全文

金色闪电 2009-12-20 01:08 发表评论

Properties属性文件

金色闪电 — Sat, 19 Dec 2009 16:41:00 GMT

除了使用Map保存键值对外，还可以用java.util.Properties保存键值对。与Map相比，Properties具有如下特点：

能从输入流（如文件）中获取键值对信息。
能将键值对信息存放到输出流（如文件）中。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

/**
* 属性集合类 Properties
*/
public class TestProperties {

    public static void main(String[] args) throws IOException {
        //新建一个Properties对象
        Properties props = new Properties();

        //往Properties中存放数据，格式位
        //key 和 value都是字符串
        props.setProperty("name", "ZhangSan");
        props.setProperty("gender", "male");
        props.setProperty("age", "30");
        props.setProperty("telNO", "01088888888");
        props.setProperty("address", "xxxxxxxx");

        //从Properties中获取数据。必须提供key
        System.out.println("name: " + props.getProperty("name"));
        System.out.println("gender: " + props.getProperty("gender"));
        System.out.println("age: " + props.getProperty("age"));
        System.out.println("telNO: " + props.getProperty("telNO"));
        System.out.println("address: " + props.getProperty("address"));
        //可以位返回值提供一个缺省值，当Properties中没有该key时，用默认值返回
        System.out.println("other: " + props.getProperty("other", "none"));

        //将Properties中的数据保存到输出流，比如文件输出流
        String fileName = "c:/test.properties";
        FileOutputStream out = new FileOutputStream(fileName);
        props.store(out, "test");
        out.close();
        //打开c:/test.properties文件，可以看见里面的内容，注意到，顺序是改变了的。

        Properties newProps = new Properties();
        newProps.setProperty("type", "newProps");
        //可以从输入流中获取加载数据，比如文件输入流
        //从properties文件中加载数据
        FileInputStream in = new FileInputStream(fileName);
        newProps.load(in);
        in.close();
        System.out.println();
        System.out.println("type: " + newProps.getProperty("type"));
        System.out.println("name: " + newProps.getProperty("name"));
        System.out.println("gender: " + newProps.getProperty("gender"));

        //将Properties中的数据输出到一个输出流
        System.out.println();
        props.list(System.out);
    }
}

金色闪电 2009-12-20 00:41 发表评论

注释功能Annotation

金色闪电 — Sat, 19 Dec 2009 16:32:00 GMT

Java有两个常用的内置的注释：
           @Override放在方法的访问修饰符前，表示该方法覆盖了父类的同名同参方法，如果该方法没有覆盖父类的方法而使用该注释，则编译器会报错。
           @Deprecated放在变量和方法的访问修饰符前，表示该变量或者方法已经不推荐使用，通常是因为它很危险或者是存在更好的选择。
可以自定义注释类型，与enum定义枚举类型一样，使用@interface定义注释类型。
能在自定义的注释类型中定义其他类、属性和方法。定义属性时，以属性名为方法名，以属性类型为方法的返回值类型，方法后接default关键字表示属性的默认值。如"String name();"表示该注释类型具有name属性，类型为String；而"int age()default 20；"表示该注释类型具有age属性，类型为int，默认值为20
可以在自定义注释类型的声明中添加注释，即注释的元注释。Java有2个常用的内置的元注释。
            @Target指定Annotation类型可以应用的程序元素，程序元素的类型由java.lang.annotation.ElementType枚举类定义。如ElementType.METHOD表示该注释类型只能用于方法声明中。
            @Retention和Java编译器处理Annotation类型的方式有关，这些方式有java.lang.annotation.RetentionPolicy枚举类定义。如RetentionPolicy.RUNTIME表示该注释类型将被编译成class文件。
            @Documented指明需要在Javadoc中包含注释类型（默认是不包含的）

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* 使用注释Annotation.
* Java 编程的一个最新趋势就是使用元数据，元数据可以用于创建文档，
* 跟踪代码中的依赖性，甚至执行基本编译时检查。
* 许多元数据工具（如Xdoclet）将这些功能添加到核心Java语言中，暂时成为Java编程功能的一部分。
* Annotation是可以添加到代码中的修饰符，
* 可以用于包声明、类型声明、构造函数、方法、域变量、参数和变量
*/
public class AnnotationData {
    @Deprecated private String name;
    public AnnotationData(String name){
        this.name = name;
    }

    // 方法声明中使用了内置的@Override元数据，表示该方法覆盖了父类的同名同参数方法
    // 如果父类不存在该方法，则编译不会通过。
    @Override public String toString() {
        return super.toString() + this.name;
    }
    @Override public int hashCode() {
        return toString().hashCode();
    }
    /**
     * 方法中使用了内置的@Deprecated元数据，表示该方法已经不被推荐使用了。
     * @return
     */
    @Deprecated public String getName(){
        return name;
    }
    public String getAnnotationDataName(){
        return this.name;
    }

    // 下面自定义元数据类型
    // 使用@interface声明Annotation类型
    public @interface MyAnnotation {
        // 在元数据类中可以定义其他类
        public enum Severity {
            CRITICAL, IMPORTANT, TRIVIAL, DOCUMENTATION
        };
        // 定义数据成员不需要定义getter和setter方法，
        // 只需要定义一个以成员名称命名的方法，并指定返回类型为需要的数据类型
        // default关键字为Annotation类型的成员设置缺省值
        Severity severity() default Severity.IMPORTANT;
        String item();
        String assignedTo();
        String dateAssigned();
    }
    // 使用自定义Annotation类型，在使用时，
    // 如果Annotation类型在其他的包下，需要跟使用类一样，import它
    @MyAnnotation(
            severity = MyAnnotation.Severity.CRITICAL,
            item = "Must finish this method carefully",
            assignedTo = "Programmer A",
            dateAssigned = "2006/09/10")
    public void doFunction() {
        // do something
    }
    // 下面再定义一个Annotation类型，使用了元数据的元数据
    //  @Target指定Annotation类型可以应用的程序元素，
    //  程序元素的类型由java.lang.annotation.ElementType枚举类定义

    //  @Retention和 Java 编译器处理Annotation类型的方式有关，
    //  这些方式由java.lang.annotation.RetentionPolicy 枚举类定义
    //  @Documented指明需要在Javadoc中包含Annotation（缺省是不包含的）

    //@Retention(RetentionPolicy.RUNTIME)这个meta-annotation
    // 表示了此类型的annotation将编译成class文件，而且还能被虚拟机读取。
    //而@Target(ElementType.METHOD)表示此类型的annotation只能用于修饰方法声明
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface MyNewAnnotation{
    }
}

金色闪电 2009-12-20 00:32 发表评论

可变长参数Varargs

金色闪电 — Sat, 19 Dec 2009 16:00:00 GMT

在J2SE5.0之前，当传入到方法的参数个数不固定时，经常采用数组的方式传递参数。5.0之后，可以使用可变长参数的特性给方法传递参数。

在参数类型和参数名之间使用"..."，表示该参数为可变长的。
通过新的for循环读取可变长参数中的值

/**
* 可变长的参数。
* 有时候，我们传入到方法的参数的个数是不固定的，为了解决这个问题，我们一般采用下面的方法：
* 1．  重载，多重载几个方法，尽可能的满足参数的个数。显然这不是什么好办法。
* 2．  将参数作为一个数组传入。虽然这样我们只需一个方法即可，但是，
* 为了传递这个数组，我们需要先声明一个数组，然后将参数一个一个加到数组中。
* 现在，我们可以使用可变长参数解决这个问题，
* 也就是使用将参数声明成可变长参数。显然，可变长参数必须是最后一个参数。
*/
public class VarArgs {

    /**
     * 打印消息，消息数量可以任意多
     * @param debug    是否debug模式
     * @param msgs    待打印的消息
     */
    public static void printMsg(boolean debug, String  msgs){
        if (debug){
            // 打印消息的长度
            System.out.println("DEBUG: 待打印消息的个数为" + msgs.length);
        }
        for (String s : msgs){
            System.out.println(s);
        }
        if (debug){
            // 打印消息的长度
            System.out.println("DEBUG: 打印消息结束");
        }
    }
    /**
     * 重载printMsg方法，将第一个参数类型该为int
     * @param debugMode 是否debug模式
     * @param msgs    待打印的消息
     */
    public static void printMsg(int debugMode, String  msgs){
        if (debugMode != 0){
            // 打印消息的长度
            System.out.println("DEBUG: 待打印消息的个数为" + msgs.length);
        }
        for (String s : msgs){
            System.out.println(s);
        }
        if (debugMode != 0){
            // 打印消息的长度
            System.out.println("DEBUG: 打印消息结束");
        }
    }

    public static void main(String[] args) {
        // 调用printMsg(boolean debug, String  msgs)方法
        VarArgs.printMsg(true);
        VarArgs.printMsg(false, "第一条消息", "这是第二条");
        VarArgs.printMsg(true, "第一条", "第二条", "这是第三条");

        // 调用printMsg(int debugMode, String  msgs)方法
        VarArgs.printMsg(1, "The first message", "The second message");
    }
}

金色闪电 2009-12-20 00:00 发表评论

网络编程>>FTP客户端

金色闪电 — Fri, 18 Dec 2009 14:19:00 GMT

摘要: 一种登录FTP服务器的方法是使用Socket，用Socket连接FTP服务器，通过FTP命令与FTP服务器交互，用这种方法实现FTP客户端比较麻烦。 Java提供了sun.net.ftp.FtpClient类，这是一个标准的FTP客户端类，通过它能方便地在FTP上浏览、上传和下载。 FtpClient的openSer... 阅读全文

金色闪电 2009-12-18 22:19 发表评论

网络编程>>聊天室客户端

金色闪电 — Fri, 18 Dec 2009 13:56:00 GMT

摘要: 客户端通过Socket连接聊天室服务器的端口，然后获得Socket的输入和输出，往输入流中写自己的连接信息，包括IP地址和账户。客户端连接服务器后，启动一个线程专门去接受服务器端发送的信息使用StringTokenizer分析收到的信息，信息类型主要有：聊天信息、聊天室成员信息和服务器退出信息。 impo... 阅读全文

金色闪电 2009-12-18 21:56 发表评论

网络编程>>聊天室服务器端

金色闪电 — Fri, 18 Dec 2009 13:51:00 GMT

摘要: 聊天室的服务器端主要用于接收客户端的连接与断开请求、广播聊天室的成员信息、将成员的聊天信息公布给所有成员。服务器端在某个端口上开启ServerSocket，接收客户端的连接请求。根据客户端的IP地址和账号，判断客户端是否重复登录，如果不是，便允许它加入聊天室，并将最新的成员列表发送给所有客户端。每当收到客户端的聊天信息时，将聊天信息发送给所有客户端... 阅读全文

金色闪电 2009-12-18 21:51 发表评论

网络编程>>UDP编程

金色闪电 — Thu, 17 Dec 2009 14:59:00 GMT

摘要: 上面的例子都用Socket建立连接，属于TCP(Transmission Control Protocol)连接，本节实例实现UDP（User Data Protocol）编程，包括发送和接收UDP报文。首先来看看UDP与TCP的区别： TCP是基于连接的协议，也就是说，在正式收发数据前，必须和对方建立可靠的连接，这与打电话的机制相似。在前面几节的编程中，客户端... 阅读全文

金色闪电 2009-12-17 22:59 发表评论

网络编程>>Telnet客户端

金色闪电 — Thu, 17 Dec 2009 14:27:00 GMT

摘要: 实现Telnet客户端的关键技术如下：访问系统的Telnet服务实质上是与Telnet服务建立Socket连接，默认的Telnet服务的端口是23 Telnet客户端将标准输入流中的命令发送给Telnet服务，将响应消息显示在标准输出流中。因此，Telnet客户端相当于一个代理服务，起中转作用，将标准输入流、Telnet服务和标准输出流连接起来。... 阅读全文

金色闪电 2009-12-17 22:27 发表评论

网络编程>>代理服务器

金色闪电 — Sun, 13 Dec 2009 07:45:00 GMT

摘要: 本实例实现了一个代理服务器，实质上是实现了一个代理服务，部署在前文实现的通用服务器框架上。用户需要指定目标服务器的IP地址和端口，然后在浏览器中输入本地网址，便可以访问目标服务器上的网页。代理服务作为一个服务部署在服务器框架上，必须实现book.net.GeneraServer$Servi... 阅读全文

金色闪电 2009-12-13 15:45 发表评论

网络编程>>一个支持多线程的服务器框架

金色闪电 — Sun, 13 Dec 2009 07:33:00 GMT

摘要: 本实例实现了一个服务器框架，在该框架下，能够在不同的端口上部署各类服务，客户端通过Socket访问服务。 ... 阅读全文

金色闪电 2009-12-13 15:33 发表评论

网络编程>>HTTP服务器

金色闪电 — Sat, 12 Dec 2009 08:22:00 GMT

摘要: 与一般的Socket编程一样，服务器端需要在某个端口上开启一个ServerSocket，以等待、接受客户端的请求。采用多线程技术，支持多用户同时访问，对于每一个请求，都用一个线程专门去处理。客户端发送给服务器端的HTTP请求遵循一定的格式，服... 阅读全文

金色闪电 2009-12-12 16:22 发表评论

网络编程>>基本的Socket编程

金色闪电 — Sat, 12 Dec 2009 08:04:00 GMT

摘要: Socket 服务器端需要在某个端口上开启服务端类型的Socket，即java.net.ServerSocket.通过它的accept方法等待并接收客户端的请求，返回的是一个java.net.Socket对象，如果一直没有客户端请求，那么accept方法将会一直等待。 Socket 客户端根据... 阅读全文

金色闪电 2009-12-12 16:04 发表评论

网络编程>>HTTP客户端

金色闪电 — Sat, 12 Dec 2009 07:48:00 GMT

java.net.URL类的openConnection方法连接HTTP服务器，得到一个HttpURLConnection对象，该对象的getHeaderFieldKey 和 getHeaderField 方法获取服务器响应请求的头信息。
HttpURLConnection的getInputStream方法从该连接读取的输入流，即服务器上被请求的HTML文件的源代码。

/**
* 访问HTTP的客户端。将网页的内容显示在控制台中。这里得到的是一堆HTML代码
*/
public class HttpClient {
    //网址URL
    String urlString;

    public static void main(String[] args) throws Exception {
        // 第一个参数为网址
        if (args.length != 1) {
            System.out.println("Usage: java book.net.http.HttpClient url");
            System.exit(1);
        }
        HttpClient client = new HttpClient(args[0]);
        client.run();
    }

    public HttpClient(String urlString) {
        this.urlString = urlString;
    }

    public void run() throws Exception {
        //生成一个URL对象
        URL url = new URL(urlString);
        //打开URL
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        //打印头信息
        System.out.println("THE HEADERS");
        System.out.println("-----------");
        for (int i = 1;; ++i) {
            String key;
            String value;
            if ((key = urlConnection.getHeaderFieldKey(i)) == null)
                break;
            if ((value = urlConnection.getHeaderField(i)) == null)
                break;
            System.out.print(key);
            System.out.println(" is: " + value);
        }
        //得到输入流，即获得了网页的内容
        BufferedReader reader = new BufferedReader(new InputStreamReader(urlConnection
                .getInputStream()));
        String line;
        System.out.println("-----CONTENT------");
        // 读取输入流的数据，并显示
        while ((line = reader.readLine()) != null){
            System.out.println(line);
        }
    }
}

金色闪电 2009-12-12 15:48 发表评论