亚洲国产精品综合久久20,亚洲成AV人片在线观看,亚洲精品视频免费观看

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

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

有时候，我们希望用一个字�D�保存对象的所属状态或分类�Q�当�q�个值存在多�U�组合的时候，我们��可以��用位�q�算来表�C�组合后的倹{�?br /> 先定义类型A=1,B=2,C=4,D=8,E=16�{?的倍数,
那么objectA卛_��于A又属于C,其��gؓA|C,��d��c�d��使用|�Q�或�Q�运��，�U�除�c�d��使用^(异或)�q�算�Q�判断是否属于某个类型��?amp;�q�算�?br /> A=00000001
B=00000010
C=00000100
D=00001000
E=00010000

objectA = (A|B|C = 00000111)
去除B�c�d�� 00000111
^00000010
-------------------------
00000101=(A|C)

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

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

eclipse中xml的自动提�C�配�|?�?

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

转自http://hi.baidu.com/2wiki/blog/item/2cc40a3f2b7ef2c97c1e7127.html
DTD �c�d��U�束文�g
    1. Window->Preferences->XML->XML Catalog->User Specified Entries�H�口�?选择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 �c�d��U�束文�g

    1. Window->Preferences->XML->XML Catalog->User Specified Entries�H�口�?选择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包�ؓ�I�的解决�Ҏ��

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

�q�里演示的是hibernate3.5.6�Q�anltr版本�?.7.6
首先��antlr.jar包复制到hibernate-distribution-3.5.6-Final/project/core/src/main/antlr,�q�里hibernate-distribution-3.5.6-Final是你的解压�\�?br /> 然后依次执行java -classpath antlr-2.7.6.jar antlr.Tool hql.g�{�，最后将生成的java文�g复制到相应包

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

netty源码分析��结

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

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

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

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

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

在看完了server端的启动�Q�再来看client端的启动�q�程是怎么�q�行的。例子是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构造函��C��会触发channelopen
        //TelnetClientPipelineFactory中的upstreamhandler没有重写channelOpen�Q�这里只是一直往下传递该事�g
        Channel ch = getFactory().newChannel(pipeline);
        ch.getConfig().setOptions(getOptions());

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

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

然后执行ch.connect(remoteAddress);
�q�里是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事�g�Q�这里只有一个StringEncoder-->OneToOneEncoder,�?br /> handleDownstream�Ҏ��对该事�g不做处理,往上传递该事�g,执行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,其中会执�?br />

private void connect(
            final NioClientSocketChannel channel, final ChannelFuture cf,
            SocketAddress remoteAddress) {
        try {
            //如果�q�回true�Q�调用nioworker.register,开始启动nioworker�U�程处理该channel的读�?br />             //否则�Q�交�l�boss.register�Ҏ��Q�在boss�U�程中完成连�?/span>
            if (channel.socket.connect(remoteAddress)) {
                channel.worker.register(channel, cf);
            } else {
                //为当前clientsocketchannel��d��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�Q�在boss�U�程中确保该channel�q�接成功�Q�这里会启动boss�U�程

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�Q�其中processSelectedKeys里执行connect

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

之后��是交给nioworker�U�程来进行数据的发送和接收了�?br />

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

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

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

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

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

上一��分析了服务器端��d��客户发送的数据�Q�这��来看服务器端如何发送数据给客户端，服务器往外发送数据是通过downstreamhandler从下��C��执行
发送从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�Q�最后执行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) {
            //�q�里写encode数据�Q�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�Q�这里执行NioServerSocketPipelineSink.eventSunk
                    getSink().eventSunk(DefaultChannelPipeline.this, e);
                } catch (Throwable t) {
                    notifyHandlerException(e, t);
                }
            } else {
                DefaultChannelPipeline.this.sendDownstream(prev, e);
            }
        }

eventSunk�Ҏ��会执�?br />

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�Q�最后调用SimpleChannelUpstreamHandler.writeComplete
        //pipeline中的upstreamhandler的writeComplete都未重写�Q�所以只是简单的传递该事�g
        fireWriteComplete(channel, writtenBytes);

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

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

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

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

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

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

        int ret = 0;
        int readBytes = 0;
        boolean failure = true;
        //分配�q�箋�?024个byte�I�间
        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);

            //触发消息接收事�g�Q�根据pipeline中upstreamhandler�׃��C��的顺序，调用messageReceived�Ҏ��
            fireMessageReceived(channel, buffer);
        } else {
            recvBufferPool.release(bb);
        }

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

        return true;
    }

在pipelinefactory中的�W�一个upstreamhandler为DelimiterBasedFrameDecoder�Q��承自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 {
            //�q�里调用子类的decode�Ҏ��
            callDecode(ctx, e.getChannel(), input, e.getRemoteAddress());
            if (input.readable()) {
                cumulation.writeBytes(input);
            }
        }
    }

//在这个upstreamhandler中，会一直读取数据，直到遇到协议�U�定的结束标志才��messagereceived事�g传给下一�?br />

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事�g传给下个upstreamhandler
            unfoldAndFireMessageReceived(context, remoteAddress, frame);
        }
    }

看子�cȝ��decode是如何判断数据读取完�?br />

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的位�|?/span>
        for (ChannelBuffer delim: delimiters) {
            int frameLength = indexOf(buffer, delim);
            if (frameLength >= 0 && frameLength < minFrameLength) {
                minFrameLength = frameLength;
                minDelim = delim;
            }
        }
        //如果扑ֈ�\r\n�Q�表明客��L��数据发送完�?/span>
        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) {
                //�q�里��d��全部数据
                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�Q�会执行�Q�调用下一个upstreamhandler�Q�这里是stringdecoder�Q�通过stringdecoder�Q�将channelbuffer中的数据转�ؓstring
然后再触发下一个upstreamhandler的messagereceive�Q�这里是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);
        }
    }

数据��d��分析完毕�Q�接着�l�箋分析服务器端数据的发�?br />

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

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

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

摘要: �q�里首先分析下ServerBootstrap的启动过�E�，在netty中，channel可以看成是socketchannel的抽�?channelpipeline里存攄��channelhandler�Q�channelpipeline�Ҏ��不同的channelevent触发对应的操�?如channel的open�Q�bind�Q�connect�{?下面以TelnetServer��Z��来一步步看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�?nbsp;

1.��mysql的JDBC驱动攑ֈ�的JBOSS_HOME\server\default\lib �?wbr>

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

<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配置文�g�?br />

��x��Q�spring3使用jboss的jta事务��理已经配置完毕�?br />
遗留问题�Q?br /> 如果使用默认讄��use-java-context为true�Q�然后��用jndi name为java:mysql,提示mysql not bound�Q�很奇怪，在jboss启动的时候可以看到将mysql�l�定
到命名空间java:mysql

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