BlogJava-zheng's footprint-文章分类-java

正则表达式匹配多个字符串中一个或多个

alex_zheng — Wed, 30 Mar 2011 02:22:00 GMT

alex_zheng 2011-03-30 10:22 发表评论

巧用位运算表示属性分类

alex_zheng — Tue, 22 Feb 2011 03:07:00 GMT

有时候，我们希望用一个字段保存对象的所属状态或分类，当这个值存在多种组合的时候，我们就可以使用位运算来表示组合后的值。
先定义类型A=1,B=2,C=4,D=8,E=16等2的倍数,
那么objectA即属于A又属于C,其值为A|C,添加类型使用|（或）运算，移除类型使用^(异或)运算，判断是否属于某个类型使用&运算。
A=00000001
B=00000010
C=00000100
D=00001000
E=00010000

objectA = (A|B|C = 00000111)
去除B类型 00000111
^00000010
-------------------------
00000101=(A|C)

判断是否是A,00000101&00000001 = 00000001

alex_zheng 2011-02-22 11:07 发表评论

eclipse中xml的自动提示配置(转)

alex_zheng — Mon, 17 Jan 2011 01:31:00 GMT

转自http://hi.baidu.com/2wiki/blog/item/2cc40a3f2b7ef2c97c1e7127.html
DTD 类型约束文件
    1. Window->Preferences->XML->XML Catalog->User Specified Entries窗口中,选择Add 按纽

    2.在Add XML Catalog Entry 对话框中选择或输入以下内容:
        Location: F:\soft\programmingSoft\Framework\Ibatis\sql-map-config-2.dtd
        Key Type: URI
        KEY: http://ibatis.apache.org/dtd/sql-map-config-2.dtd

XSD 类型约束文件

    1. Window->Preferences->XML->XML Catalog->User Specified Entries窗口中,选择Add 按纽

    2.在Add XML Catalog Entry 对话框中选择或输入以下内容:
        Location: F:\soft\programmingSoft\Framework\Spring\spring-framework-2.5.6.SEC01-with-dependencies\spring-framework-2.5.6.SEC01\dist\resources\spring-beans-2.5.xsd
        Key Type: Schema Location
        KEY: http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

alex_zheng 2011-01-17 09:31 发表评论

hibernate源码org.hibernate.hql.antlr包为空的解决方法

alex_zheng — Tue, 14 Dec 2010 06:23:00 GMT

这里演示的是hibernate3.5.6，anltr版本是2.7.6
首先将antlr.jar包复制到hibernate-distribution-3.5.6-Final/project/core/src/main/antlr,这里hibernate-distribution-3.5.6-Final是你的解压路径
然后依次执行java -classpath antlr-2.7.6.jar antlr.Tool hql.g等，最后将生成的java文件复制到相应包

alex_zheng 2010-12-14 14:23 发表评论

netty源码分析小结

alex_zheng — Thu, 09 Dec 2010 08:46:00 GMT

先看下netty的channel对象关联关系。channel是由channelfactory来创建的，channelfactory又分为client和server两种。
channelfuture负责channel的所处状态，一个channle中关联来channelpipeline，channelpipeline则由pipelinefactory创建，
在channelpipeline中有内部类channelhandlercontext，保存channelhandler的链式结构，由channelhandler来传递channelevent，
channelevent分别有open，bind，connected，close，messagereceived等。

alex_zheng 2010-12-09 16:46 发表评论

netty3.2.3源码分析-ClientBootstrap启动分析

alex_zheng — Mon, 06 Dec 2010 08:59:00 GMT

在看完了server端的启动，再来看client端的启动过程是怎么进行的。例子是TelentServer对应的TelentClient

public class TelnetClient {

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

        ClientBootstrap bootstrap = new ClientBootstrap(
                new NioClientSocketChannelFactory(
                        Executors.newCachedThreadPool(),
                        Executors.newCachedThreadPool()));

        // Configure the pipeline factory.
        bootstrap.setPipelineFactory(new TelnetClientPipelineFactory());

        // Start the connection attempt.
        ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port));

        // Wait until the connection attempt succeeds or fails.
        Channel channel = future.awaitUninterruptibly().getChannel();
        if (!future.isSuccess()) {
            future.getCause().printStackTrace();
            bootstrap.releaseExternalResources();
            return;
        }


    }
}

直接看connect方法

public ChannelFuture connect(final SocketAddress remoteAddress, final SocketAddress localAddress) {

        if (remoteAddress == null) {
            throw new NullPointerException("remoteAddress");
        }

        ChannelPipeline pipeline;
        try {
            pipeline = getPipelineFactory().getPipeline();
        } catch (Exception e) {
            throw new ChannelPipelineException("Failed to initialize a pipeline.", e);
        }

        // Set the options.
        //NioClientSocketChannel构造函数中会触发channelopen
        //TelnetClientPipelineFactory中的upstreamhandler没有重写channelOpen，这里只是一直往下传递该事件
        Channel ch = getFactory().newChannel(pipeline);
        ch.getConfig().setOptions(getOptions());

        // Bind.
        if (localAddress != null) {
            ch.bind(localAddress);
        }

        // Connect.
        return ch.connect(remoteAddress);
    }

然后执行ch.connect(remoteAddress);
这里是NioClientSocketChannel-->NioSocketChannel-->AbstractChannel

public ChannelFuture connect(SocketAddress remoteAddress) {
       return Channels.connect(this, remoteAddress);
}

public static ChannelFuture connect(Channel channel, SocketAddress remoteAddress) {
        if (remoteAddress == null) {
            throw new NullPointerException("remoteAddress");
        }
        ChannelFuture future = future(channel, true);
        channel.getPipeline().sendDownstream(new DownstreamChannelStateEvent(
                channel, future, ChannelState.CONNECTED, remoteAddress));
        return future;
}

从TelnetClientPipelineFactory的pipeline中由下往上传递CONNECTED事件，这里只有一个StringEncoder-->OneToOneEncoder,其
handleDownstream方法对该事件不做处理,往上传递该事件,执行DefaultChannelHandlerContext.sendDownstream

public void sendDownstream(ChannelEvent e) {
            //在StringEncoder之前再没有downstreamhandler
            DefaultChannelHandlerContext prev = getActualDownstreamContext(this.prev);
            if (prev == null) {
                try {
                    getSink().eventSunk(DefaultChannelPipeline.this, e);
                } catch (Throwable t) {
                    notifyHandlerException(e, t);
                }
            } else {
                DefaultChannelPipeline.this.sendDownstream(prev, e);
            }
        }

执行NioClientSocketPipelineSink.eventSunk,其中会执行

private void connect(
            final NioClientSocketChannel channel, final ChannelFuture cf,
            SocketAddress remoteAddress) {
        try {
            //如果返回true，调用nioworker.register,开始启动nioworker线程处理该channel的读写
            //否则，交给boss.register方法，在boss线程中完成连接
            if (channel.socket.connect(remoteAddress)) {
                channel.worker.register(channel, cf);
            } else {
                //为当前clientsocketchannel添加closed的listener
                channel.getCloseFuture().addListener(new ChannelFutureListener() {
                    public void operationComplete(ChannelFuture f)
                            throws Exception {
                        if (!cf.isDone()) {
                            cf.setFailure(new ClosedChannelException());
                        }
                    }
                });
                cf.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
                channel.connectFuture = cf;

                boss.register(channel);
            }

        } catch (Throwable t) {
            cf.setFailure(t);
            fireExceptionCaught(channel, t);
            channel.worker.close(channel, succeededFuture(channel));
        }
    }

执行boss.register，在boss线程中确保该channel连接成功，这里会启动boss线程

void register(NioClientSocketChannel channel) {
            //在RegisterTask的run方法里注册SelectionKey.OP_CONNECT
            Runnable registerTask = new RegisterTask(this, channel);

                boolean offered = registerTaskQueue.offer(registerTask);
                assert offered;
            }

            if (wakenUp.compareAndSet(false, true)) {
                selector.wakeup();
            }
        }

最后启动boss.run，其中processSelectedKeys里执行connect

private void connect(SelectionKey k) {
            NioClientSocketChannel ch = (NioClientSocketChannel) k.attachment();
            try {
                if (ch.socket.finishConnect()) {
                    k.cancel();
                    //连接成功，才在nioworker中启动一个新线程来处理该socketchannel的读写
                    ch.worker.register(ch, ch.connectFuture);
                }
            } catch (Throwable t) {
                ch.connectFuture.setFailure(t);
                fireExceptionCaught(ch, t);
                ch.worker.close(ch, succeededFuture(ch));
            }
        }

之后就是交给nioworker线程来进行数据的发送和接收了。

alex_zheng 2010-12-06 16:59 发表评论

java-string类型参数传递分析

alex_zheng — Sun, 05 Dec 2010 08:27:00 GMT

摘要: 上周去一家公司面试，其中一个面试题是这样的，判断下面程序输出，本人很杯具的写了"changed" Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->public class StringArgTest ... 阅读全文

alex_zheng 2010-12-05 16:27 发表评论

netty3.2.3源码分析--服务器端发送数据分析

alex_zheng — Sat, 04 Dec 2010 06:54:00 GMT

上一篇分析了服务器端读取客户发送的数据，这篇来看服务器端如何发送数据给客户端，服务器往外发送数据是通过downstreamhandler从下到上执行
发送从ChannelFuture future = e.getChannel().write(response)开始执行Channels下的

public static ChannelFuture write(Channel channel, Object message, SocketAddress remoteAddress) {
        ChannelFuture future = future(channel);
        channel.getPipeline().sendDownstream(
                new DownstreamMessageEvent(channel, future, message, remoteAddress));
        return future;
}

telentpipeline中最下面一个downstreamhandler是stringencoder，最后执行OneToOneEncoder的handleDownstream

public void handleDownstream(
            ChannelHandlerContext ctx, ChannelEvent evt) throws Exception {
        if (!(evt instanceof MessageEvent)) {
            ctx.sendDownstream(evt);
            return;
        }

        MessageEvent e = (MessageEvent) evt;
        Object originalMessage = e.getMessage();
        Object encodedMessage = encode(ctx, e.getChannel(), originalMessage);
        if (originalMessage == encodedMessage) {
            ctx.sendDownstream(evt);
        } else if (encodedMessage != null) {
            //这里写encode数据，DefaultChannelPipeline的sendDownstream
            write(ctx, e.getFuture(), encodedMessage, e.getRemoteAddress());
        }
    }

DefaultChannelPipeline的sendDownstream方法

public void sendDownstream(ChannelEvent e) {
            DefaultChannelHandlerContext prev = getActualDownstreamContext(this.prev);
            if (prev == null) {
                try {
                    //因为stringencoder是唯一一个downstreamhandler，这里执行NioServerSocketPipelineSink.eventSunk
                    getSink().eventSunk(DefaultChannelPipeline.this, e);
                } catch (Throwable t) {
                    notifyHandlerException(e, t);
                }
            } else {
                DefaultChannelPipeline.this.sendDownstream(prev, e);
            }
        }

eventSunk方法会执行

private void handleAcceptedSocket(ChannelEvent e) {
        if (e instanceof ChannelStateEvent) {
            ChannelStateEvent event = (ChannelStateEvent) e;
            NioSocketChannel channel = (NioSocketChannel) event.getChannel();
            ChannelFuture future = event.getFuture();
            ChannelState state = event.getState();
            Object value = event.getValue();

            switch (state) {
            case OPEN:
                if (Boolean.FALSE.equals(value)) {
                    channel.worker.close(channel, future);
                }
                break;
            case BOUND:
            case CONNECTED:
                if (value == null) {
                    channel.worker.close(channel, future);
                }
                break;
            case INTEREST_OPS:
                channel.worker.setInterestOps(channel, future, ((Integer) value).intValue());
                break;
            }
        } else if (e instanceof MessageEvent) {
            MessageEvent event = (MessageEvent) e;
            NioSocketChannel channel = (NioSocketChannel) event.getChannel();
            //放入writerequestqueue队列
            boolean offered = channel.writeBuffer.offer(event);
            assert offered;
            //执行nioworker的writeFromUserCode,之后执行write0方法
            channel.worker.writeFromUserCode(channel);
        }
    }

private void write0(NioSocketChannel channel) {
        boolean open = true;
        boolean addOpWrite = false;
        boolean removeOpWrite = false;

        long writtenBytes = 0;

        final SocketSendBufferPool sendBufferPool = this.sendBufferPool;
        final SocketChannel ch = channel.socket;
        //之前将channel放到了该队列
        final Queue<MessageEvent> writeBuffer = channel.writeBuffer;
        //默认尝试16次写
        final int writeSpinCount = channel.getConfig().getWriteSpinCount();
        synchronized (channel.writeLock) {
            channel.inWriteNowLoop = true;
            for (;;) {
                MessageEvent evt = channel.currentWriteEvent;
                SendBuffer buf;
                if (evt == null) {
            //从writebuffer中获得一个writeevent
                    if ((channel.currentWriteEvent = evt = writeBuffer.poll()) == null) {
                        removeOpWrite = true;
                        channel.writeSuspended = false;
                        break;
                    }

                    channel.currentWriteBuffer = buf = sendBufferPool.acquire(evt.getMessage());
                } else {
                    buf = channel.currentWriteBuffer;
                }

                ChannelFuture future = evt.getFuture();
                try {
                    long localWrittenBytes = 0;
                    for (int i = writeSpinCount; i > 0; i --) {
                        //发送数据给客户端,执行PooledSendBuffer.transferTo
                        localWrittenBytes = buf.transferTo(ch);
                        if (localWrittenBytes != 0) {
                            writtenBytes += localWrittenBytes;
                            break;
                        }
                        if (buf.finished()) {
                            break;
                        }
                    }

                    if (buf.finished()) {
                        // Successful write - proceed to the next message.
                        buf.release();
                        channel.currentWriteEvent = null;
                        channel.currentWriteBuffer = null;
                        evt = null;
                        buf = null;
                        future.setSuccess();
                    } else {
                        // Not written fully - perhaps the kernel buffer is full.
                        addOpWrite = true;
                        channel.writeSuspended = true;

                        if (localWrittenBytes > 0) {
                            // Notify progress listeners if necessary.
                            future.setProgress(
                                    localWrittenBytes,
                                    buf.writtenBytes(), buf.totalBytes());
                        }
                        break;
                    }
                } catch (AsynchronousCloseException e) {
                    // Doesn't need a user attention - ignore.
                } catch (Throwable t) {
                    buf.release();
                    channel.currentWriteEvent = null;
                    channel.currentWriteBuffer = null;
                    buf = null;
                    evt = null;
                    future.setFailure(t);
                    fireExceptionCaught(channel, t);
                    if (t instanceof IOException) {
                        open = false;
                        close(channel, succeededFuture(channel));
                    }
                }
            }
            channel.inWriteNowLoop = false;
        }
        //触发写完成事件，执行的是DefaultChannelPipeline的sendUpstream，最后调用SimpleChannelUpstreamHandler.writeComplete
        //pipeline中的upstreamhandler的writeComplete都未重写，所以只是简单的传递该事件
        fireWriteComplete(channel, writtenBytes);

        if (open) {
            if (addOpWrite) {
                setOpWrite(channel);
            } else if (removeOpWrite) {
                clearOpWrite(channel);
            }
        }
    }

alex_zheng 2010-12-04 14:54 发表评论

netty3.2.3源码分析--服务器端读数据分析

alex_zheng — Fri, 03 Dec 2010 13:26:00 GMT

上一篇分析了serverboostrap的启动，接下来分析netty的数据读取。
在nioworker的，负责读取操作是由，在该方法中，如果当前channel的(readyOps & SelectionKey.OP_READ) != 0 || readyOps == 0，且此时
ch.read(buff)<0,则判断客户端已经断开连接

private boolean read(SelectionKey k) {
        final SocketChannel ch = (SocketChannel) k.channel();
        final NioSocketChannel channel = (NioSocketChannel) k.attachment();

        final ReceiveBufferSizePredictor predictor =
            channel.getConfig().getReceiveBufferSizePredictor();
        //默认1024个字节空间
        final int predictedRecvBufSize = predictor.nextReceiveBufferSize();

        int ret = 0;
        int readBytes = 0;
        boolean failure = true;
        //分配连续的1024个byte空间
        ByteBuffer bb = recvBufferPool.acquire(predictedRecvBufSize);
        try {
            while ((ret = ch.read(bb)) > 0) {
                readBytes += ret;
                if (!bb.hasRemaining()) {
                    break;
                }
            }
            failure = false;
        } catch (ClosedChannelException e) {
            // Can happen, and does not need a user attention.
        } catch (Throwable t) {
            fireExceptionCaught(channel, t);
        }

        if (readBytes > 0) {
            bb.flip();

            final ChannelBufferFactory bufferFactory =
                channel.getConfig().getBufferFactory();
            final ChannelBuffer buffer = bufferFactory.getBuffer(readBytes);
            buffer.setBytes(0, bb);
            buffer.writerIndex(readBytes);

            recvBufferPool.release(bb);

            // Update the predictor.
            predictor.previousReceiveBufferSize(readBytes);

            //触发消息接收事件，根据pipeline中upstreamhandler由上到下的顺序，调用messageReceived方法
            fireMessageReceived(channel, buffer);
        } else {
            recvBufferPool.release(bb);
        }

        if (ret < 0 || failure) {
            close(channel, succeededFuture(channel));
            return false;
        }

        return true;
    }

在pipelinefactory中的第一个upstreamhandler为DelimiterBasedFrameDecoder，继承自FrameDecoder

public ChannelPipeline getPipeline() throws Exception {
        // Create a default pipeline implementation.
        ChannelPipeline pipeline = pipeline();

        // Add the text line codec combination first,
        pipeline.addLast("framer", new DelimiterBasedFrameDecoder(
                8192, Delimiters.lineDelimiter()));
        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder());

        // and then business logic.
        pipeline.addLast("handler", new TelnetServerHandler());

        return pipeline;
    }

会调用FrameDecoder的messageReceived

public void messageReceived(
            ChannelHandlerContext ctx, MessageEvent e) throws Exception {

        Object m = e.getMessage();
        if (!(m instanceof ChannelBuffer)) {
            ctx.sendUpstream(e);
            return;
        }

        ChannelBuffer input = (ChannelBuffer) m;
        if (!input.readable()) {
            return;
        }

        ChannelBuffer cumulation = cumulation(ctx);
        if (cumulation.readable()) {
            cumulation.discardReadBytes();
            cumulation.writeBytes(input);
            callDecode(ctx, e.getChannel(), cumulation, e.getRemoteAddress());
        } else {
            //这里调用子类的decode方法
            callDecode(ctx, e.getChannel(), input, e.getRemoteAddress());
            if (input.readable()) {
                cumulation.writeBytes(input);
            }
        }
    }

//在这个upstreamhandler中，会一直读取数据，直到遇到协议约定的结束标志才将messagereceived事件传给下一个

private void callDecode(
            ChannelHandlerContext context, Channel channel,
            ChannelBuffer cumulation, SocketAddress remoteAddress) throws Exception {

        while (cumulation.readable()) {
            int oldReaderIndex = cumulation.readerIndex();
            Object frame = decode(context, channel, cumulation);
            if (frame == null) {
                if (oldReaderIndex == cumulation.readerIndex()) {
                    // Seems like more data is required.
                    // Let us wait for the next notification.
                    break;
                } else {
                    // Previous data has been discarded.
                    // Probably it is reading on.
                    continue;
                }
            } else if (oldReaderIndex == cumulation.readerIndex()) {
                throw new IllegalStateException(
                        "decode() method must read at least one byte " +
                        "if it returned a frame (caused by: " + getClass() + ")");
            }
            //将messagereceive事件传给下个upstreamhandler
            unfoldAndFireMessageReceived(context, remoteAddress, frame);
        }
    }

看子类的decode是如何判断数据读取完毕

protected Object decode(
            ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception {
        // Try all delimiters and choose the delimiter which yields the shortest frame.
        int minFrameLength = Integer.MAX_VALUE;
        ChannelBuffer minDelim = null;
        //获取\r\n的位置
        for (ChannelBuffer delim: delimiters) {
            int frameLength = indexOf(buffer, delim);
            if (frameLength >= 0 && frameLength < minFrameLength) {
                minFrameLength = frameLength;
                minDelim = delim;
            }
        }
        //如果找到\r\n，表明客户端数据发送完毕
        if (minDelim != null) {
            int minDelimLength = minDelim.capacity();
            ChannelBuffer frame;

            if (discardingTooLongFrame) {
                // We've just finished discarding a very large frame.
                // Go back to the initial state.
                discardingTooLongFrame = false;
                buffer.skipBytes(minFrameLength + minDelimLength);

                // TODO Let user choose when the exception should be raised - early or late?
                //      If early, fail() should be called when discardingTooLongFrame is set to true.
                int tooLongFrameLength = this.tooLongFrameLength;
                this.tooLongFrameLength = 0;
                fail(ctx, tooLongFrameLength);
                return null;
            }

            if (minFrameLength > maxFrameLength) {
                // Discard read frame.
                buffer.skipBytes(minFrameLength + minDelimLength);
                fail(ctx, minFrameLength);
                return null;
            }

            if (stripDelimiter) {
                //这里读取全部数据
                frame = buffer.readBytes(minFrameLength);
                buffer.skipBytes(minDelimLength);
            } else {
                frame = buffer.readBytes(minFrameLength + minDelimLength);
            }

            return frame;
        } else {
            if (!discardingTooLongFrame) {
                if (buffer.readableBytes() > maxFrameLength) {
                    // Discard the content of the buffer until a delimiter is found.
                    tooLongFrameLength = buffer.readableBytes();
                    buffer.skipBytes(buffer.readableBytes());
                    discardingTooLongFrame = true;
                }
            } else {
                // Still discarding the buffer since a delimiter is not found.
                tooLongFrameLength += buffer.readableBytes();
                buffer.skipBytes(buffer.readableBytes());
            }
            return null;
        }
    }

因为unfold默认是false，会执行，调用下一个upstreamhandler，这里是stringdecoder，通过stringdecoder，将channelbuffer中的数据转为string
然后再触发下一个upstreamhandler的messagereceive，这里是TelnetServerHandler

public void messageReceived(
            ChannelHandlerContext ctx, MessageEvent e) {

        // Cast to a String first.
        // We know it is a String because we put some codec in TelnetPipelineFactory.
        String request = (String) e.getMessage();

        // Generate and write a response.
        String response;
        boolean close = false;
        if (request.length() == 0) {
            response = "Please type something."r"n";
        } else if (request.toLowerCase().equals("bye")) {
            response = "Have a good day!"r"n";
            close = true;
        } else {
            response = "Did you say '" + request + "'?"r"n";
        }

        // We do not need to write a ChannelBuffer here.
        // We know the encoder inserted at TelnetPipelineFactory will do the conversion.
        ChannelFuture future = e.getChannel().write(response);

        // Close the connection after sending 'Have a good day!'
        // if the client has sent 'bye'.
        if (close) {
            future.addListener(ChannelFutureListener.CLOSE);
        }
    }

数据读取分析完毕，接着继续分析服务器端数据的发送

alex_zheng 2010-12-03 21:26 发表评论

netty3.2.3源码分析--ServerBootstrap启动分析

alex_zheng — Wed, 01 Dec 2010 13:37:00 GMT

摘要: 这里首先分析下ServerBootstrap的启动过程，在netty中，channel可以看成是socketchannel的抽象 channelpipeline里存放着channelhandler，channelpipeline根据不同的channelevent触发对应的操作如channel的open，bind，connect等下面以TelnetServer为例来一步步看server启动... 阅读全文

alex_zheng 2010-12-01 21:37 发表评论

jboss5.1+mysql5+spring3数据库jndi配置

alex_zheng — Sat, 27 Nov 2010 08:58:00 GMT

主要记录下jboss5下配置mysql。

1.将mysql的JDBC驱动放到的JBOSS_HOME\server\default\lib 下

2.把JBOSS_HOME\docs\examples\jca\mysql-ds.xml复制到JBOSS_HOME\server\default\deploy目录下。修改mysql- ds.xml文件

<local-tx-datasource>
    <jndi-name>mysqljndi-name>
    <connection-url>jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8connection-url>
    <driver-class>com.mysql.jdbc.Driverdriver-class>
    <user-name>alexuser-name>
    <password>alexpassword>
    <use-java-context>falseuse-java-context>
    <exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorterexception-sorter-class-name>


    <min-pool-size>5min-pool-size>
    <max-pool-size>100max-pool-size>
    <blocking-timeout-millis>5000blocking-timeout-millis>
    <idle-timeout-minutes>15idle-timeout-minutes>
    <set-tx-query-timeout/>
    <query-timeout>60query-timeout>


    <metadata>
       <type-mapping>mySQLtype-mapping>
    metadata>

3.spring配置文件中

    <jee:jndi-lookup id="dataSource" jndi-name="mysql" />
    <bean id="txManager"
        class="org.springframework.transaction.jta.JtaTransactionManager">

        <property name="transactionManagerName" value="java:/TransactionManager"/>
    bean>

至此，spring3使用jboss的jta事务管理已经配置完毕。

遗留问题：
如果使用默认设置use-java-context为true，然后使用jndi name为java:mysql,提示mysql not bound，很奇怪，在jboss启动的时候可以看到将mysql绑定
到命名空间java:mysql

alex_zheng 2010-11-27 16:58 发表评论