语源科技BlogJava-我的JAVA学习笔记

WebSphere下LinkageError解决办法

EvanLiu — Sat, 14 Mar 2009 12:26:00 GMT

环境：WebSphere 6.l
JRE: WebSphere 6.1 JRE
项目需求：用SUN JDK6自带的JAX-WS创建Web Service。其中Server端的Web Service接口已发布，我这边的项目直接根据对方提供的WSDL创建Client。
碰到的问题：
当调用javax.xml.ws.Service的构造方法 Service(URL url, QName qName)的时候，报错如下：

[3/14/09 14:51:53:750 CST] 0000002c SystemErr R Caused by: java.lang.Throwable: java.lang.LinkageError: You are loading old SAAJ from jar:file:/C:/Program%20Files/IBM/SDP70/runtimes/base_v61/lib/j2ee.jar!/javax/xml/soap/MessageFactory.class
at com.sun.xml.ws.api.SOAPVersion.(SOAPVersion.java:184)
at com.sun.xml.ws.api.SOAPVersion.(SOAPVersion.java:83)
at java.lang.J9VMInternals.initializeImpl(Native Method)
at java.lang.J9VMInternals.initialize(J9VMInternals.java:177)
at com.sun.xml.ws.api.BindingID.(BindingID.java:318)
...(以下省略300字)
Caused by: java.lang.Throwable: java.lang.NoSuchMethodError: javax/xml/soap/MessageFactory.newInstance(Ljava/lang/String;)Ljavax/xml/soap/MessageFactory;
at com.sun.xml.ws.api.SOAPVersion.(SOAPVersion.java:178)
... 21 more

也就是说，程序先去读取了WebSphere 6.1的j2ee.jar包里的相关类，而没去读取我们真正要用的两个SAAJ jar包：saaj-api.jar和saaj-impl.jar. 结果就出错了。

IBM上找到的原因及解决办法：

如何在WebSphere中解决jar包冲突

主要就是把Classloader mode从默认的Parent_First改成Parent_Last，让程序先读自己的class文件以及jar包。
我就照样画葫芦设置了。顺便说一下，关联共享库到应用程序，我无论如何都做不成功。关闭Application,进入Application，关联共享库，关联好了，保存成功，退到外面，再进去，共享库又没关联上。设置Classloader mode的时候也遇到了这样的问题，但最终还是迫使其让我保存了。共享库就不管理，反正无所谓，只要加载顺序变了就成。
但事实上，我的担心成为了事实：程序启动失败，虽然起来了，但只跑了一小部分代码，后面的服务都没起来。想想也是，程序那么大，用到的jar包那么多，改了Classloader mode，一切全都乱套了...

之后，查看Console-->TroubleShooting-->Class Loader View，发现系统最开始加载的是WebSphere下的ext目录下的jar包

、

所以就投机取巧，把我要用的两个saaj包放到了ext目录下，重启，程序运行成功
当然，这不是一个好的解决办法，阿三那里能不能通得过还是个问题

EvanLiu 2009-03-14 20:26 发表评论

ThreadLocal学习

EvanLiu — Wed, 18 Feb 2009 08:28:00 GMT

摘要: ThreadLocal 多线程阅读全文

EvanLiu 2009-02-18 16:28 发表评论

java.util.ConcurrentModificationException

EvanLiu — Sun, 31 Aug 2008 11:44:00 GMT

工作中碰到个ConcurrentModificationException。代码如下：
List list = ...;
for(Iterator iter = list.iterator(); iter.hasNext();) {
    Object obj = iter.next();
    ...
    if(***) {
        list.remove(obj);
    }
}
在执行了remove方法之后，再去执行循环，iter.next()的时候，报java.util.ConcurrentModificationException(当然，如果remove的是最后一条，就不会再去执行next()操作了)

下面来看一下源码
public interface Iterator {
    boolean hasNext();
    E next();
    void remove();
}

public interface Collection extends Iterable {
    ...
    Iterator iterator();
    boolean add(E o);
    boolean remove(Object o);
    ...
}
这里有两个remove方法

接下来来看看AbstractList
public abstract class AbstractList extends AbstractCollection implements List {
//AbstractCollection和List都继承了Collection
    protected transient int modCount = 0;
    private class Itr implements Iterator { //内部类Itr
        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size();
        }

        public E next() {
            checkForComodification(); //特别注意这个方法
            try {
                E next = get(cursor);
                lastRet = cursor++;
                return next;
            } catch(IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet == -1)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet); //执行remove对象的操作
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount; //重新设置了expectedModCount的值，避免了ConcurrentModificationException的产生
            } catch(IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount) //当expectedModCount和modCount不相等时，就抛出ConcurrentModificationException
                throw new ConcurrentModificationException();
        }
    }
}

remove(Object o)在ArrayList中实现如下：
public boolean remove(Object o) {
    if (o == null) {
            for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
            fastRemove(index);
            return true;
        }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
private void fastRemove(int index) {
    modCount++; //只增加了modCount
    ....
}

所以，产生ConcurrentModificationException的原因就是：
执行remove(Object o)方法之后，modCount和expectedModCount不相等了。然后当代码执行到next()方法时，判断了checkForComodification()，发现两个数值不等，就抛出了该Exception。
要避免这个Exception，就应该使用remove()方法。
这里我们就不看add(Object o)方法了，也是同样的原因，但没有对应的add()方法。一般嘛，就另建一个List了

下面是网上的其他解释，更能从本质上解释原因：
Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

http://gceclub.sun.com.cn/yuanchuang/week-14/iterator.html

EvanLiu 2008-08-31 19:44 发表评论

物化视图(Materialized View)基础

EvanLiu — Sat, 09 Aug 2008 07:53:00 GMT

物化视图（实体化视图）是包括一个查询结果的数据库对象，它是远程数据的的本地副本，或者用来生成基于数据表求和的汇总表。物化视图存储基于远程表的数据，也可以称为快照。
所以物化视图和视图的最大区别是，物化视图在本地保存数据，而视图只是一些SQL语句而已。视图的好处是简化使用过程，物化视图的好处提高性能，当然也可以简化使用过程。提高查询速度的代价就是放弃一定的数据实时性。
物化视图可以查询表，视图和其它的物化视图。

创建物化视图，应先在对于的基础表上创建存储的日志空间：
create materialized view log on tablex
tablespace mytestspace           -- 日志空间
with rowid;

然后再创建物化视图：
create materialized vew myfirstmv
on prebuild tabley                   -- 将物化视图建立在一个已经存在的表上，也可不加这句
tablespace mytestspace
build deffered                         -- buld clause子句，deffered表示创建时不生成数据，默认为build immediate
refresh fast                             -- refresh 子句。fast表示只刷新上次刷新之后所作的修改。相对为complete。默认为force
           on commit                   -- 对基表的DML操作提交的同时进行刷新。默认为on demand
           start with to_date('2008-08-08 20:00:00', 'yyyy-mm-dd hh24:mi:ss')             --第一次刷新时间
           next TRUNC(SYSDATE+1)+18/24          --刷新时间间隔。每两天刷新一次，时间为下午6点
as
        select x1, x2, x3 from tablex

删除时，删除物化视图和物化视图日志无顺序要求，不过先删除日志，会使删除物化视图的速度加快很多。
如果物化视图日志存在的话，物化视图在删除的时候，需要将物化视图日志中所有当前物化视图需要刷新的记录删除掉。这意味着一个DDL的语句中包含着DML的部分。

以上都没经过实际操作，以后有时间再说

http://xznsoft.javaeye.com/blog/124000

EvanLiu 2008-08-09 15:53 发表评论

JMS简单不完全实现

EvanLiu — Sun, 03 Aug 2008 10:04:00 GMT

如前所述，JMS分两大类：PTP和Pub/Sub

主要的几个对象：ConnectionFactory、Connection、Destination、Session、MessageProducer、MessageConsumer
其相互关系如下图：

1.PTP:
简单回顾7个对象：QueueConnectionFactory、QuequeConnection、Queue、QueueSession、QueueSender、QueueReceiver、QueueBrowser
    1) Sender
    try {
        //具体怎么得到就不写了，各个系统肯定都不一样，但终究都是通过jdni来获得
        Context jndiContext = new InitialContext();
        QueueConnectionFactory factory = jndiContext.lookup("**Factory");
        Queue queue = jndiContext.lookup("**Queue");
        QueueConnection connection = factory.createQueueConnection();
        boolean transaction = true;
        QueueSession session = connection.createQueueSession(transaction , Session.AUTO_ACKNOWLEDGE);
        Message objMessage = session.createObjectMessage();  //或session.createTextMessage("...");
        objMessage.setObject((Serializable)obj); //obj为要传输的对象
        QueueSender sender = session.createSender(queue);
        publisher.setTimeToLive(timeout); //long timeout = ...
        connection.start();
        sender.send(objMessage);
        //or
        /**
        sender = session.createSender(null);
        sender.send(queue, message);
        */
        //如果不用了，就收拾干净
        publisher.close();
        session.close();
        connection.close();
    } catch (JMSException e) {
        //TODO
    } finally {
        publisher = null;
        session = null;
        connection = null;
    }

    2) Receiver/Browser
        a.主动接收，synchronously
        try {
            QueueReceiver receiver = session.createReceiver(queue);
            receiver.receiveNoWait();
            /**
            QueueBrowser browser = session.createBrowser(queue); //QueueBrowser只会取消息，但不会取走消息
            Enumeration elements = browser.getEnumeration();
            while(elements.hasMoreElements) {
                Message message = elements.nextElement();
                ...
            }
            */
        } catch (JMSException e) {
            ...
        }

        b.消息侦听，也是最主要的应用，asynchronously
        try {
            MessageListener myListener = new MyListener();
            QueueReceiver receiver = session.createReceiver(queue);
            receiver.setMessageListener(myListener);
            connection.start();
        } catch (JMSException e) {
            ...
        }

        public class MyListener impelments MessageListner {
            public void onMessage(Message message) {
                if(message instanceof TextMessage) {
                    ...
                } else if (message instanceof ObjectMessage) {
                    ...
                } else {
                    ...
                }
            }
        }

2.Pub/Sub:
简单回顾6个对象：TopicConnectionFactory、TopicConnection、Topic、TopicSession、TopicPublisher、TopicSubscriber
    1) Publisher
    try {
        //具体怎么得到就不写了，各个系统肯定都不一样，但终究都是通过jdni来获得
        Context jndiContext = new InitialContext();
        TopicConnectionFactory factory = jndiContext.lookup("**Factory");
        Topic topic = jndiContext.lookup("**Topic");
        TopicConnection connection = factory.createTopicConnection();
        TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);  //false表示不使用事务
        Message objMessage = session.createObjectMessage();
        objMessage.setObject((Serializable)obj); //obj为要传输的对象
        TopicPublisher publisher = session.createPublisher(topic);
        publisher.setTimeToLive(100000);
        connection.start();
        publisher.publish(message);
        //or
        /**
        publisher = session.createPublisher(null);
        publiser.publish(topic, message);
        */
        publisher.close();
        session.close();
        connection.close();
    } catch (JMSException e) {
        //TODO
    }

    2) Subscriber
        a.主动接收，比如上面发送完后，接收回应消息，相当于同步接收了
        try {
            TopicSubscriber subscriber = session.createSubScriber(topic);
            message = subscriber.receiver(timeout); //long timeout = ...
            subscriber.close();
        } catch (JMSException e) {
            ...
        }

        b.消息侦听，asynchronously
        try {
            ...
            TopicSubscriber subscriber = session.createSubScriber(topic);
            MessageListener listener = new MyListener();
            subscriber.setMessageListener(listener); //关键在于这个listener
            connection.start();
        } catch (JMSException e) {
            ...
        }
        MyListener实现同上

EvanLiu 2008-08-03 18:04 发表评论

JMS基本概念（转）

EvanLiu — Sun, 03 Aug 2008 09:51:00 GMT

1.JMS概述

JAVA 消息服务(JMS)定义了Java 中访问消息中间件的接口。JMS只是接口，并没有给予实现，实现JMS接口的消息中间件称为JMS Provider

消息中间件提供企业数据的异步传输，通过消息中间件，一些原本互相孤立的业务组件可以组合成一个可靠的、灵活的系统。也可以模拟实现同步传输，但其实质仍然是异步的。

JMS 支持两种消息类型PTP （Point-to-Point）和Pub/Sub（Publish-Subscribe），分别称作：PTP Domain 和Pub/Sub Domain。
PTP的主要特点是：
1）一条消息只有一个使用者
2）不存在时间限制
Pub/Sub主要特点有：
1）一条消息可以有多个使用者
2）存在时间限制。订阅者可以使用持久方式来订阅消息，但是也会过期或者取消订阅

这两种接口都继承统一的JMS Parent 接口，JMS 主要接口如下所示：

JMS Parent	PTPDomain	Pub/Sub Domain
ConnectionFactory	QueueConnectionFactory	TopicConnectionFactory
Connection	QueueConnection	TopicConnection
Destination	Queue	Topic
Session	QueueSession	TopicSession
MessageProducer	QueueSender	TopicPublisher
MessageConsumer	QueueReceiver,QueueBrowser	TopicSubscriber

以下是对这些接口的简单描述：

ConnectionFactory ：连接工厂，JMS 用它创建连接

Connection ：JMS 客户端到JMS Provider 的连接

Destination ：消息的目的地

Session：一个发送或接收消息的线程

MessageProducer：由Session 对象创建的用来发送消息的对象

MessageConsumer：由Session 对象创建的用来接收消息的对象

2.JMS消息模型

JMS 消息由以下几部分组成：消息头，属性，消息体。

消息头(Header) -消息头包含消息的识别信息和路由信息，消息头包含一些标准的属性如：JMSDestination,JMSMessageID等。

消息头	由谁设置
JMSDestination	send 或 publish 方法
JMSDeliveryMode	send 或 publish 方法
JMSExpiration	send 或 publish 方法
JMSPriority	send 或 publish 方法
JMSMessageID	send 或 publish 方法
JMSTimestamp	send 或 publish 方法
JMSCorrelationID	客户
JMSReplyTo	客户
JMSType	客户
JMSRedelivered	JMS Provider

属性(Properties) -除了消息头中定义好的标准属性外，JMS提供一种机制增加新属性到消息头中，这种新属性包含以下几种：

应用需要用到的属性;
消息头中原有的一些可选属性;
JMS Provider 需要用到的属性。

标准的JMS 消息头包含以下属性：

JMSDestination --消息发送的目的地。

JMSDeliveryMode --传递模式，有两种模式：PERSISTENT和NON_PERSISTENT，PERSISTENT表示该消息一定要被送到目的地，否则会导致应用错误。 NON_PERSISTENT表示偶然丢失该消息是被允许的，这两种模式使开发者可以在消息传递的可靠性和吞吐量之间找到平衡点。

JMSMessageID 唯一识别每个消息的标识，由JMS Provider 产生。

JMSTimestamp 一个消息被提交给JMS Provider 到消息被发出的时间。

JMSCorrelationID 用来连接到另外一个消息，典型的应用是在回复消息中连接到原消息。

JMSReplyTo 提供本消息回复消息的目的地址。

JMSRedelivered如果一个客户端收到一个设置了JMSRedelivered属性的消息，则表示可能该客户端曾经在早些时候收到过该消息，但并没有签收(acknowledged)。

JMSType 消息类型的识别符。

JMSExpiration 消息过期时间，等于QueueSender 的send方法中的timeToLive值或TopicPublisher 的publish 方法中的timeToLive值加上发送时刻的GMT时间值。如果timeToLive值等于零，则JMSExpiration被设为零，表示该消息永不过期。如果发送后，在消息过期时间之后消息还没有被发送到目的地，则该消息被清除。

JMSPriority 消息优先级，从0-9 十个级别，0-4 是普通消息，5-9 是加急消息。JMS 不要求JMS Provider严格按照这十个优先级发送消息，但必须保证加急消息要先于普通消息到达。

消息体(Body) - JMS API定义了5种消息体格式，也叫消息类型，你可以使用不同形式发送接收数据并可以兼容现有的消息格式，下面描述这5种类型：

消息类型	消息体
TextMessage	java.lang.String对象，如xml文件内容
MapMessage	名/值对的集合，名是String对象，值类型可以是Java任何基本类型
BytesMessage	字节流
StreamMessage	Java中的输入输出流
ObjectMessage	Java中的可序列化对象
Message	没有消息体，只有消息头和属性

Message是以上5类的基础。最常用的是ObjectMessage和TextMessage

3.消息的同步异步接收

消息的同步接收

同步接收是指客户端主动去接收消息，JMS 客户端可以采用MessageConsumer的receive方法去接收下一个消息。

消息的异步接收

异步接收是指当消息到达时，主动通知客户端。JMS客户端可以通过注册一个实现MessageListener接口的对象到MessageConsumer，这样，每当消息到达时，JMS Provider 会调用MessageListener中的onMessage 方法。

4.PTP模型

PTP(Point-to-Point)模型是基于队列的，发送方发消息到队列，接收方从队列接收消息，队列的存在使得消息的异步传输成为可能。和邮件系统中的邮箱一样，队列可以包含各种消息，JMS Provider 提供工具管理队列的创建、删除。JMS PTP模型定义了客户端如何向队列发送消息，从队列接收消息，浏览队列中的消息。

下面描述JMS PTP 模型中的主要概念和对象：

名称	描述
Queue	由JMS Provider 管理，队列由队列名识别，客户端可以通过JNDI接口用队列名得到一个队列对象。
TemporaryQueue	由QueueConnection 创建，而且只能由创建它的QueueConnection 使用。
QueueConnectionFactory	客户端用QueueConnectionFactory 创建QueueConnection 对象。
QueueConnection	一个到JMS PTP provider 的连接，客户端可以用QueueConnection创建QueueSession来发送和接收消息。
QueueSession	提供一些方法创建QueueReceiver、QueueSender、QueueBrowser和TemporaryQueue。如果在 QueueSession关闭时，有一些消息已经被收到，但还没有被签收(acknowledged)，那么，当接收者下次连接到相同的队列时，这些消息还会被再次接收。
QueueReceiver	客户端用QueueReceiver接收队列中的消息，如果用户在QueueReceiver中设定了消息选择条件，那么不符合条件的消息会留在队列中，不会被接收到。
QueueSender	客户端用QueueSender 发送消息到队列。
QueueBrowser	客户端可以QueueBrowser 浏览队列中的消息，但不会收走消息。
QueueRequestor	JMS 提供QueueRequestor类简化消息的收发过程。QueueRequestor的构造函数有两个参数：QueueSession和queue，QueueRequestor 通过创建一个临时队列来完成最终的收发消息请求。
可靠性(Reliability)	队列可以长久地保存消息直到接收者收到消息。接收者不需要因为担心消息会丢失而时刻和队列保持激活的连接状态，充分体现了异步传输模式的优势。

4.Pub/Sub模型

JMS Pub/Sub 模型定义了如何向一个内容节点发布和订阅消息，这些节点被称作主题(topic)。

主题可以被认为是消息的传输中介，发布者(publisher)发布消息到主题，订阅者(subscribe)从主题订阅消息。主题使得消息订阅者和消息发布者保持互相独立，不需要接触即可保证消息的传送。

下面描述JMS Pub/Sub 模型中的主要概念和对象：

名称	描述
订阅(subscription)	消息订阅分为非持久订阅(non-durable subscription)和持久订阅(durablesubscrip-tion)，非持久订阅只有当客户端处于激活状态，也就是和JMS Provider保持连接状态才能收到发送到某个主题的消息，而当客户端处于离线状态，这个时间段发到主题的消息将会丢失，永远不会收到。持久订阅时，客户端向JMS注册一个识别自己身份的ID，当这个客户端处于离线时，JMS Provider 会为这个ID 保存所有发送到主题的消息，当客户再次连接到JMS Provider时，会根据自己的ID得到所有当自己处于离线时发送到主题的消息。
Topic	主题由JMS Provider 管理，主题由主题名识别，客户端可以通过JNDI接口用主题名得到一个主题对象。JMS没有给出主题的组织和层次结构的定义，由JMS Provider 自己定义。
TemporaryTopic	临时主题由TopicConnection创建，而且只能由创建它的TopicConnection使用。临时主题不能提供持久订阅功能。
TopicConnectionFactory	客户端用TopicConnectionFactory 创建TopicConnection 对象。
TopicConnection	TopicConnection 是一个到JMS Pub/Sub provider的连接，客户端可以用TopicConnection创建TopicSession来发布和订阅消息。
TopicSession	TopicSession提供一些方法创建TopicPublisher、TopicSubscriber、TemporaryTopic。它还提供unsubscribe方法取消消息的持久订阅。
TopicPublisher	客户端用TopicPublisher 发布消息到主题。
TopicSubscriber	客户端用TopicSubscriber接收发布到主题上的消息。可以在TopicSubscriber中设置消息过滤功能，这样，不符合要求的消息不会被接收。
Durable TopicSubscriber	如果一个客户端需要持久订阅消息，可以使用Durable TopicSubscriber，TopSession提供一个方法createDurableSubscriber创建Durable TopicSubscriber 对象。
恢复和重新派送(Recovery and Redelivery)	非持久订阅状态下，不能恢复或重新派送一个未签收的消息。只有持久订阅才能恢复或重新派送一个未签收的消息。
TopicRequestor	JMS 提供TopicRequestor类简化消息的收发过程。TopicRequestor的构造函数有两个参数：TopicSession和topic。TopicRequestor 通过创建一个临时主题来完成最终的发布和接收消息请求。
可靠性(Reliability)	当所有的消息必须被接收，则用持久订阅模式。当丢失消息能够被容忍，则用非持久订阅模

EvanLiu 2008-08-03 17:51 发表评论

JAAS学习

EvanLiu — Sat, 02 Aug 2008 05:52:00 GMT

JAAS：Java Authentication and Authorization Service Java认证和授权服务，从jdk1.4开始就集成JAAS。
目前流行的Acegi中也提供了JAAS
JAAS的几个核心类和接口：
1.Subject: 实际被认证的人或者服务
2.Principal (interface): Subject的唯一标识。一个Subject含有一个或多个Pricipal，比如一个人有身份证、护照等Pricipal
3.LoginContext
4.LoginModule (interface)
5.CallbackHandler (interface)
还有两个配置文件：×××.conf（或config）和 ×××..policy
JAAS首先使用一个LoginContext类来查找配置文件中的内容，这些内容可以用来对LoginModules进行初始化。所有 LoginContext没有指定的初始化参数都会包含在配置文件中。LoginContext向LoginModule传递一个CallbackHandler对象和一个Subject，如果LoginModule还需要其他认证信息，它就会用CallbackHandler回调适当的应用程序，从而获得这些信息。

在应用程序中，一般这样使用LoginContext:
    try {
        LoginContext loginContext = new LoginContext("Sample", callbackHandler ); //"Sample"定义在相关的conf文件中; callbackHandler见下面
        loginContext.login(); //如果认证失败，则抛出异常
    } catch (LoginException e) {
        //do sth.
    }

我们要使用JAAS，就需要实现上述接口，以及配置好文件
上面的代码，只是在应用时，这样写就够了。当然，在这之前，还需要设置callbackHandler：
    SampleCallbackHandler callbackHandler = new SampleCallbackHandler();
    // 设置用户名、密码等需要验证的信息到callbackHandler里。具体怎么设，看自己的SampleCallbackHandler怎么设计了
     ......

举例：
    public class SampleCallbackHandler implements CallbackHandler {
        protected String username;
        protected String password;

        public void handle(Callback[] callbacks)
            throws UnsupportedCallbackException {    //这个方法是必须实现的,用来设置username和password到对应的Callback变量中
               for (int index = 0; index < callbacks.length; index++) {
                    if (callbacks[index] instanceof NameCallback) {
                    NameCallback ncb = (NameCallback) callbacks[index];
                    ncb.setName(username);
              } else if (callbacks[index] instanceof PasswordCallback) {
                    PasswordCallback pcb = (PasswordCallback) callbacks[index];
                    pcb.setPassword(password.toCharArray());
              } else if() { //如果还有其他需要验证的信息
                       ...
              }
        }

        //其他方法，诸如设置username和password
}

    然后来说前面的"Sample"。这里的"Sample"对应一个Sample.conf文件，这个文件的具体位置可以自己设置。conf文件中配置了对应的LoginModule类，可以是一个或多个，用来做不同的验证。
    public class SampleLoginModule implements LoginModule {
        ....
    }
LoginModule有5个方法需要实现，简单点写个方法名得了：
public void initialize(Subject subject, CallbackHandler callbackHandler, Map arg2, Map arg3);
public boolean login() throws LoginException;
public boolean commit() throws LoginException;
public boolean abort() throws LoginException;
public boolean logout() throws LoginException;
业务逻辑主要在login()中实现，步骤包括了从callbackHandler中读取用户名密码，然后该从数据库验证就从数据库验证，该从配置文件验证就从配置文件验证，该从其他系统中验证就从其他系统中验证...

Pricipal的实现就不写了，下面链接中的例子写得很详细。我的只是给自己理一个大概步骤，以后回顾起来也方便
不过Subject和Pricipal应该有更重要的用处，比如在Authorization中，把pricipal和要可以执行的相关操作对应起来。这个还没看下去，接触的代码中也没用到。放到以后补充

更多内容，可直接查看sun的JDK文档http://java.sun.com/javase/6/docs/technotes/guides/security/jaas/JAASRefGuide.html
实例：http://www.blogjava.net/fastunit/archive/2008/01/28/178204.html

EvanLiu 2008-08-02 13:52 发表评论

struts validate之ApplicationResources.properties内容读取乱码

EvanLiu — Mon, 16 Jun 2008 04:42:00 GMT

JSP页面用UTF-8编码
编码过滤器设置成UTF-8编码
配置都正确，在jdk\bin目录下，用native2ascii ApplicationResources.properties ApplicationResources2.properties
结果JSP页面显示提示信息时，提示信息成了乱码。

解决办法：native2ascii -encoding UTF-8 ApplicationResources.properties ApplicationResources2.properties

感谢http://kenshinlk.javaeye.com/blog/59080

EvanLiu 2008-06-16 12:42 发表评论

struts validate之ValidatorActionForm

EvanLiu — Sat, 14 Jun 2008 16:58:00 GMT

用Struts Validate机制，因为一个form需要在多个页面进行操作，不同页面会有不同的验证需求，所以我采用了ValidatorActionForm

代码如下：
public class UserForm extends ValidatorActionForm {
    private Integer id;
    private String name;
    private String password;
    private String confirmpwd;
    private String email;
    private Integer sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    ...
}
Action类略过
validation.xml:


    ...

ApplicationContext.properties:
user.name = {0}\u6d93\u5d88\u5158\u6d93\u8679\u2516
    ...

编译后，ApplicationContext.properties能在WEB-INF\classes下找到，且struts-config.xml里也已添加

JSP页面：
    ...

...

结果：验证起作用，但是提示信息打印不出来。
HELP！！！

已解决
需要修改validation.xml和ApplicationContext.properties
validation.xml:
    ...



    ...

ApplicationContext.properties （未转码前）
    ...
user.name=姓名
user.required={0}不能为空
    ...

EvanLiu 2008-06-15 00:58 发表评论

foxmail下邮件CSS乱了的问题

EvanLiu — Tue, 13 May 2008 05:32:00 GMT

今天做一个邮件程序，测试时，发现用foxmail收邮件时，CSS乱了。后来看源码，发现这段声明在显示的时候被过滤掉了。在写了两行，CSS就正常了。应该是foxmail的规则是只过滤第一行声明。

另外，用outlook2007收邮件的时候，当图片是写在css里的时候，不能下载图片。在“工具-信任中心-自动下载”那里取消了禁止自动下载功能，仍然不能显示。目前仍未解决

EvanLiu 2008-05-13 13:32 发表评论