blogjava-凯发k8网页登录

云自无心水自闲 2016-01-28 18:06

云自无心水自闲 2015-12-11 21:40

james-cli.bat --host localhost adduser test＠example.com password

然后测试发送邮件，客户端显示发送成功，但是james服务器报错，找不到mimeconfig的无参数构造函数。
解决方法：
使用旧的mime4j的jar包替换james 3.0 beta5中自带的最新包。
beta5中自带的是0.8.0版，apache网站中可以下载到0.7.2
下载apache-mime4j-0.7.2-bin.zip, 将其中的apache-mime4j-core-0.7.2.jar, apache-mime4j-dom-0.7.2.jar复制到james\lib目录，
并将其更名覆盖原有的

云自无心水自闲 2015-10-08 08:45

singletonobject.java

public enum singletonobject { 
    instance; 
    private int num; 
    protected void setnum(int num) { 
        this.num = num; 
    } 
    public int getnum() { 
        return num; 
    } 
}

singletonconsumer.java

public class singletonconsumer {

    public string consumesingletonobject() { 

        return string.valueof(singletonobject.instance.getnum()); 

    } 
}

singletonconsumertest.java

@runwith(powermockrunner.class) 
@preparefortest({singletonobject.class}) 
public class singletonconsumertest { 
    @test public void testconsumesingletonobject() throws exception { 
        singletonobject mockinstance = mock(singletonobject.class); 
        whitebox.setinternalstate(singletonobject.class, "instance", mockinstance); 
        when(mockinstance.getnum()).thenreturn(42); 
        assertequals("42", new singletonconsumer().consumesingletonobject()); 
    } 
}

when(mymock.myfunction(anystring())).then(returnsfirstarg());

returnslastarg()

returnsargumentat(int position)

5. 在调用mock出来的方法中,改变方法参数的值

verifying with generic parameters
verify(someservice).process(matchers.<collection<person>>any());

verify(adunomasterbaseprocessor).processbinfiles( anylistof(file.class) );

云自无心水自闲 2015-06-16 21:27 发表评论

-javaagent:c:\temp\springloaded-1.2.3.release.jar -noverify

云自无心水自闲 2015-06-11 21:59

wrapper.java.additional.1=-dcom.sun.management.jmxremote.port=9898 ＃这里的端口号可以自行选择。
wrapper.java.additional.2=-dcom.sun.management.jmxremote.ssl=false
wrapper.java.additional.3=-dcom.sun.management.jmxremote.authenticate=false

云自无心水自闲 2015-06-11 14:09

         // optionally remove existing handlers attached to j.u.l root logger
         slf4jbridgehandler.removehandlersforrootlogger();  // (since slf4j 1.6.5)

         // add slf4jbridgehandler to j.u.l's root logger, should be done once during
         // the initialization phase of your application
         slf4jbridgehandler.install();

云自无心水自闲 2015-04-27 15:31

主要是使用bouncycastle提供的openpgp的库来完成这个功能，参照了其提供的示例程序，进行了部分改动 ( bouncy castle 是一种用于 java 平台的开放源码的轻量级密码术包。它支持大量的密码术算法，并提供 jce 1.2.1 的实现。因为 bouncy castle 被设计成轻量级的，所以从 j2se 1.4 到 j2me（包括 midp）平台，它都可以运行。它是在 midp 上运行的唯一完整的密码术包。)
1. 添加循环遍历来查找第一个可用的message
2. 需要注意的是在main函数中的，如果不添加这一句的话 security.addprovider(new bouncycastleprovider()); 程序运行中会报错：no such provider "bc"
3. 错误exception in thread "main" java.security.invalidkeyexception: illegal key size or default parameters , 这是因为java缺省的库支持的key长度比较短，需要到oracle的网站上去下载一个支持更长key的库覆盖原有的库文件
/lib/securty/ 目录下的两个jar文件

local_policy.jar and us_export_policy.jar

搜索这个文件: java cryptography extension (jce) unlimited strength jurisdiction policy files

下载页面(以jdk6为例)：

package org.bouncycastle.openpgp.examples;

import java.io.bufferedinputstream;
import java.io.bufferedoutputstream;
import java.io.file;
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.security.nosuchproviderexception;
import java.security.securerandom;
import java.security.security;
import java.util.iterator;

import org.bouncycastle.bcpg.armoredoutputstream;
import org.bouncycastle.bcpg.compressionalgorithmtags;
import org.bouncycastle.jce.provider.bouncycastleprovider;
import org.bouncycastle.openpgp.pgpcompresseddata;
import org.bouncycastle.openpgp.pgpencrypteddata;
import org.bouncycastle.openpgp.pgpencrypteddatagenerator;
import org.bouncycastle.openpgp.pgpencrypteddatalist;
import org.bouncycastle.openpgp.pgpexception;
import org.bouncycastle.openpgp.pgpliteraldata;
import org.bouncycastle.openpgp.pgponepasssignaturelist;
import org.bouncycastle.openpgp.pgpprivatekey;
import org.bouncycastle.openpgp.pgppublickey;
import org.bouncycastle.openpgp.pgppublickeyencrypteddata;
import org.bouncycastle.openpgp.pgpsecretkeyringcollection;
import org.bouncycastle.openpgp.pgpsignaturelist;
import org.bouncycastle.openpgp.pgputil;
import org.bouncycastle.openpgp.jcajce.jcapgpobjectfactory;
import org.bouncycastle.openpgp.operator.jcajce.jcakeyfingerprintcalculator;
import org.bouncycastle.openpgp.operator.jcajce.jcepgpdataencryptorbuilder;
import org.bouncycastle.openpgp.operator.jcajce.jcepublickeydatadecryptorfactorybuilder;
import org.bouncycastle.openpgp.operator.jcajce.jcepublickeykeyencryptionmethodgenerator;
import org.bouncycastle.util.io.streams;

/**
 * a simple utility class that encrypts/decrypts public key based
 * encryption files.
 * 

 * to encrypt a file: keybasedfileprocessor -e [-a|-ai] filename publickeyfile.

 * if -a is specified the output file will be "ascii-armored".
 * if -i is specified the output file will be have integrity checking added.
 * 

 * to decrypt: keybasedfileprocessor -d filename secretkeyfile passphrase.
 * 

 * note 1: this example will silently overwrite files, nor does it pay any attention to
 * the specification of "_console" in the filename. it also expects that a single pass phrase
 * will have been used.
 * 

 * note 2: if an empty file name has been specified in the literal data object contained in the
 * encrypted packet a file with the name filename.out will be generated in the current working directory.
 */
public class keybasedfileprocessor
{
    private static void decryptfile(
        string inputfilename,
        string keyfilename,
        char[] passwd,
        string defaultfilename)
        throws ioexception, nosuchproviderexception
    {
        inputstream in = new bufferedinputstream(new fileinputstream(inputfilename));
        inputstream keyin = new bufferedinputstream(new fileinputstream(keyfilename));
        decryptfile(in, keyin, passwd, defaultfilename);
        keyin.close();
        in.close();
    }

    /**
     * decrypt the passed in message stream
     */
    private static void decryptfile(
        inputstream in,
        inputstream keyin,
        char[]      passwd,
        string      defaultfilename)
        throws ioexception, nosuchproviderexception
    {
        in = pgputil.getdecoderstream(in);
        
        try
        {
            jcapgpobjectfactory pgpf = new jcapgpobjectfactory(in);
            pgpencrypteddatalist    enc;

            object                  o = pgpf.nextobject();
            //
            // the first object might be a pgp marker packet.
            //
            if (o instanceof pgpencrypteddatalist)
            {
                enc = (pgpencrypteddatalist)o;
            }
            else
            {
                enc = (pgpencrypteddatalist)pgpf.nextobject();
            }
            
            //
            // find the secret key
            //
            iterator                    it = enc.getencrypteddataobjects();
            pgpprivatekey               skey = null;
            pgppublickeyencrypteddata   pbe = null;
            pgpsecretkeyringcollection  pgpsec = new pgpsecretkeyringcollection(
                pgputil.getdecoderstream(keyin), new jcakeyfingerprintcalculator());

            while (skey == null && it.hasnext())
            {
                pbe = (pgppublickeyencrypteddata)it.next();
                
                skey = pgpexampleutil.findsecretkey(pgpsec, pbe.getkeyid(), passwd);
            }
            
            if (skey == null)
            {
                throw new illegalargumentexception("secret key for message not found.");
            }
    
            inputstream         clear = pbe.getdatastream(new jcepublickeydatadecryptorfactorybuilder().setprovider("bc").build(skey));
            
            jcapgpobjectfactory    plainfact = new jcapgpobjectfactory(clear);
            
            object              message = plainfact.nextobject();
    
            while ( true ) {
                if (message instanceof pgpcompresseddata)
                {
                    pgpcompresseddata   cdata = (pgpcompresseddata)message;
                    jcapgpobjectfactory    pgpfact = new jcapgpobjectfactory(cdata.getdatastream());
                    
                    message = pgpfact.nextobject();
                }
                
                if (message instanceof pgpliteraldata)
                {
                    pgpliteraldata ld = (pgpliteraldata)message;

                    string outfilename = ld.getfilename();
                    if (outfilename.length() == 0)
                    {
                        outfilename = defaultfilename;
                    }

                    inputstream unc = ld.getinputstream();
                    outputstream fout = new bufferedoutputstream(new fileoutputstream(outfilename));

                    streams.pipeall(unc, fout);

                    fout.close();
                    break;
                }
                else if (message instanceof pgponepasssignaturelist)
                {
                    system.out.println("encrypted message contains a signed message - not literal data.");
                }
                else if (message instanceof pgpsignaturelist)
                {
                    system.out.println("encrypted message contains a signed message - not literal data.");
                }
                else
                {
                    throw new pgpexception("message is not a simple encrypted file - type unknown.");
                }
                message = plainfact.nextobject();
            }
            
            if (pbe.isintegrityprotected())
            {
                if (!pbe.verify())
                {
                    system.err.println("message failed integrity check");
                }
                else
                {
                    system.err.println("message integrity check passed");
                }
            }
            else
            {
                system.err.println("no message integrity check");
            }
        }
        catch (pgpexception e)
        {
            system.err.println(e);
            if (e.getunderlyingexception() != null)
            {
                e.getunderlyingexception().printstacktrace();
            }
        }
    }

    private static void encryptfile(
        string          outputfilename,
        string          inputfilename,
        string          enckeyfilename,
        boolean         armor,
        boolean         withintegritycheck)
        throws ioexception, nosuchproviderexception, pgpexception
    {
        outputstream out = new bufferedoutputstream(new fileoutputstream(outputfilename));
        pgppublickey enckey = pgpexampleutil.readpublickey(enckeyfilename);
        encryptfile(out, inputfilename, enckey, armor, withintegritycheck);
        out.close();
    }

    private static void encryptfile(
        outputstream    out,
        string          filename,
        pgppublickey    enckey,
        boolean         armor,
        boolean         withintegritycheck)
        throws ioexception, nosuchproviderexception
    {
        if (armor)
        {
            out = new armoredoutputstream(out);
        }

        try
        {
            byte[] bytes = pgpexampleutil.compressfile(filename, compressionalgorithmtags.zip);

            pgpencrypteddatagenerator encgen = new pgpencrypteddatagenerator(
                new jcepgpdataencryptorbuilder(pgpencrypteddata.cast5).setwithintegritypacket(withintegritycheck).setsecurerandom(new securerandom()).setprovider("bc"));

            encgen.addmethod(new jcepublickeykeyencryptionmethodgenerator(enckey).setprovider("bc"));

            outputstream cout = encgen.open(out, bytes.length);

            cout.write(bytes);
            cout.close();

            if (armor)
            {
                out.close();
            }
        }
        catch (pgpexception e)
        {
            system.err.println(e);
            if (e.getunderlyingexception() != null)
            {
                e.getunderlyingexception().printstacktrace();
            }
        }
    }

    public static void main(
        string[] args)
        throws exception
    {
        security.addprovider(new bouncycastleprovider());

        if (args.length == 0)
        {
            system.err.println("usage: keybasedfileprocessor -e|-d [-a|ai] file [secretkeyfile passphrase|pubkeyfile]");
            return;
        }

        if (args[0].equals("-e"))
        {
            if (args[1].equals("-a") || args[1].equals("-ai") || args[1].equals("-ia"))
            {
                encryptfile(args[2]   ".asc", args[2], args[3], true, (args[1].indexof('i') > 0));
            }
            else if (args[1].equals("-i"))
            {
                encryptfile(args[2]   ".bpg", args[2], args[3], false, true);
            }
            else
            {
                encryptfile(args[1]   ".bpg", args[1], args[2], false, false);
            }
        }
        else if (args[0].equals("-d"))
        {
            decryptfile(args[1], args[2], args[3].tochararray(), new file(args[1]).getname()   ".out");
        }
        else
        {
            system.err.println("usage: keybasedfileprocessor -d|-e [-a|ai] file [secretkeyfile passphrase|pubkeyfile]");
        }
    }
}

云自无心水自闲 2014-12-10 06:50

while the i/o thread must not be blocked at all, thus prohibiting any direct blocking operations within your channelhandler, there is a way to implement this requirement. 

you can specify an eventexecutorgroup when adding channelhandlers to the channelpipeline. 

this eventexecutorgroup will then be used to obtain an eventexecutor, which will execute all the methods of the channelhandler. 

this eventexecutor will use a different thread from the i/o thread, thus freeing up the eventloop.

i／o线程是不允许被阻塞的，也就是不能在channelhandler中进行任何阻塞式的处理，但是对此我们也有相应的解决方法.

就是在把channelhanders添加到channelpipeline的时候，指定一个eventexecutorgroup，channelhandler中所有的方法都将会在这个指定的eventexecutorgroup中运行。

而这个eventexecutorgroup运行的线程与i/o线程不同，达到不阻塞i／o的目的。 

程序示例如下：

channel ch = ...;

channelpipeline p = ch.pipeline();

eventexecutor e1 = new defaulteventexecutorgroup(16);

eventexecutor e2 = new defaulteventexecutorgroup(8);

 

p.addlast(new myprotocolcodec());

p.addlast(e1, new mydatabaseaccessinghandler());

p.addlast(e2, new myharddiskaccessinghandler());
需要补充说明一下，上面的示例程序似乎有点问题。使用上述方法添加channelhandler到pipeline中以后，channelhandler的所有方法确实什么在一个单独的线程中被处理。
但是，每次defaulteventexcutorgroup线程池中的线程不能被重用，每次都会生成一个新的线程，然后在新的线程中调用channelhandler, 在visualvm可以看到线程数量直线增长。

解决的方法是：不能使用局部变量形式的defaulteventexecutorgroup。而使用类静态成员变量：
static final eventexecutor e1 = new defaulteventexecutorgroup(16);

云自无心水自闲 2014-11-27 07:36

p66
1. components:

    a. message

        a.1 header

a.1.1 destination

a.1.2 deliverymode: persistent, non-persistent

a.2 body

    b. queue

    c. client

        c.1 producer

        c.2 consumer - message selector

d. domain, 2 styles of messaging

d.1 point-to-point

d.1.1 destination known as queue

d.1.2 similar to person to person email sent through a mail server

d.1.3 multiple consumers can be registered on a single queue

but only one consumer will receive a a given messge 

and it's upt to that consumer to acknowledge the message

d.2 publish-subscribe

d.2.1 destination known as topics

d.2.2 publishers send messages to the topic 

and subscribers register to receive messages from the topic

d.2.3 durable subscriptions allow for subscriber disconnection without missing any messages

云自无心水自闲 2013-10-14 20:35

主要是使用：

biff8encryptionkey.setcurrentuserpassword(password);

在打开workbook之前

hssfworkbook workbook = new hssfworkbook(inp);

注意事项：这个应该是只适用于xls,而不是xlsx

云自无心水自闲 2011-05-30 10:42

tapestry5 in action现在还只是提供meap形式的订购，meap-manning early access program, 也就是提前试阅的意思，如果读者订购了此版本，那么manning会在作者每完成一章后，将该章节发给订购者，订购者可以提交自己的反馈，manning会根据情况发布相应的错误修改信息。

目前此书的第一章可以免费下载：

http://www.blogjava.net/files/usherlight/tapestry5 in action meap ch01.zip

云自无心水自闲 2011-03-29 05:53

我使用的是sun提供的javax.comm包，不确定其他的comm支持包（比如：rxtx)行为与之相同

1、事件驱动的数据读取

需要注意的是：一个serialport只能注册一个事件监听程序，因此，有时候有会发现，你的事件监听处理程序会变得非常庞大

另外，要注意的就是事件处理如果比较耗时的话，最好是在单独的线程中运行，否则会阻塞数据的接收。

串口接收到数据后，默认在线程: win32serialport notification thread中运行。如果不及时释放的话，会造成数据无法读取。

我的做法是，接收到数据后，先判断数据的合法和完整性，如果没有接收到完整的数据，则在缓存数据后，马上返回

如果数据完整而且合法，则另开一个线程，进行数据处理

2、数据的发送

建议单独使用一个线程来发送数据，目的还是为了防止阻塞，有一个技巧就是使用output_buffer_empty事件来发送。

云自无心水自闲 2011-02-07 13:22

1、用@requestparam获取httpservletrequest里的参数值相当方便，spring可以进行自动的类型转换

2、对于restful的支持，结合@requestmapping的uritemplate和method以及@pathvariable，非常方便地实现了restful的url

3、对于ajax的支持，@respsonsebody提供了方便的机制

4、灵活丰富的@controller的函数返回类型

5、可以方便地给@controller函数注入各种资源

其他的一些别的框架都有特性，诸如国际化，文件上传什么的就不说了

云自无心水自闲 2010-12-15 07:51

云自无心水自闲 2010-11-24 06:08

云自无心水自闲 2010-11-02 08:10

云自无心水自闲 2010-11-02 07:58

云自无心水自闲 2010-10-20 07:38

云自无心水自闲 2010-09-13 12:42

云自无心水自闲 2010-08-18 07:13

云自无心水自闲 2010-07-15 08:20

云自无心水自闲 2010-07-05 09:38

http, hypertext transfer protocol, is the method by which clients (i.e. you) and servers communicate. when someone clicks a link, types in a url or submits out a form, their browser sends a request to a server for information. it might be asking for a page, or sending data, but either way, that is called an http request. when a server receives that request, it sends back an http response, with information for the client. usually, this is invisible, though i'm sure you've seen one of the very common response codes - 404, indicating a page was not found. there are a fair few more status codes sent by servers, and the following is a list of the current ones in http 1.1, along with an explanation of their meanings.

a more technical breakdown of http 1.1 status codes and their meanings is available at . there are several versions of http, but currently http 1.1 is the most widely used.

informational

• 100 - continue
  a status code of 100 indicates that (usually the first) part of a request has been received without any problems, and that the rest of the request should now be sent.
• 101 - switching protocols
  http 1.1 is just one type of protocol for transferring data on the web, and a status code of 101 indicates that the server is changing to the protocol it defines in the "upgrade" header it returns to the client. for example, when requesting a page, a browser might receive a statis code of 101, followed by an "upgrade" header showing that the server is changing to a different version of http.

successful

• 200 - ok
  the 200 status code is by far the most common returned. it means, simply, that the request was received and understood and is being processed.
• 201 - created
  a 201 status code indicates that a request was successful and as a result, a resource has been created (for example a new page).
• 202 - accepted
  the status code 202 indicates that server has received and understood the request, and that it has been accepted for processing, although it may not be processed immediately.
• 203 - non-authoritative information
  a 203 status code means that the request was received and understood, and that information sent back about the response is from a third party, rather than the original server. this is virtually identical in meaning to a 200 status code.
• 204 - no content
  the 204 status code means that the request was received and understood, but that there is no need to send any data back.
• 205 - reset content
  the 205 status code is a request from the server to the client to reset the document from which the original request was sent. for example, if a user fills out a form, and submits it, a status code of 205 means the server is asking the browser to clear the form.
• 206 - partial content
  a status code of 206 is a response to a request for part of a document. this is used by advanced caching tools, when a user agent requests only a small part of a page, and just that section is returned.

redirection

• 300 - multiple choices
  the 300 status code indicates that a resource has moved. the response will also include a list of locations from which the user agent can select the most appropriate.
• 301 - moved permanently
  a status code of 301 tells a client that the resource they asked for has permanently moved to a new location. the response should also include this location. it tells the client to use the new url the next time it wants to fetch the same resource.
• 302 - found
  a status code of 302 tells a client that the resource they asked for has temporarily moved to a new location. the response should also include this location. it tells the client that it should carry on using the same url to access this resource.
• 303 - see other
  a 303 status code indicates that the response to the request can be found at the specified url, and should be retrieved from there. it does not mean that something has moved - it is simply specifying the address at which the response to the request can be found.
• 304 - not modified
  the 304 status code is sent in response to a request (for a document) that asked for the document only if it was newer than the one the client already had. normally, when a document is cached, the date it was cached is stored. the next time the document is viewed, the client asks the server if the document has changed. if not, the client just reloads the document from the cache.
• 305 - use proxy
  a 305 status code tells the client that the requested resource has to be reached through a proxy, which will be specified in the response.
• 307 - temporary redirect
  307 is the status code that is sent when a document is temporarily available at a different url, which is also returned. there is very little difference between a 302 status code and a 307 status code. 307 was created as another, less ambiguous, version of the 302 status code.

client error

• 400 - bad request
  a status code of 400 indicates that the server did not understand the request due to bad syntax.
• 401 - unauthorized
  a 401 status code indicates that before a resource can be accessed, the client must be authorised by the server.
• 402 - payment required
  the 402 status code is not currently in use, being listed as "reserved for future use".
• 403 - forbidden
  a 403 status code indicates that the client cannot access the requested resource. that might mean that the wrong username and password were sent in the request, or that the permissions on the server do not allow what was being asked.
• 404 - not found
  the best known of them all, the 404 status code indicates that the requested resource was not found at the url given, and the server has no idea how long for.
• 405 - method not allowed
  a 405 status code is returned when the client has tried to use a request method that the server does not allow. request methods that are allowed should be sent with the response (common request methods are post and get).
• 406 - not acceptable
  the 406 status code means that, although the server understood and processed the request, the response is of a form the client cannot understand. a client sends, as part of a request, headers indicating what types of data it can use, and a 406 error is returned when the response is of a type not i that list.
• 407 - proxy authentication required
  the 407 status code is very similar to the 401 status code, and means that the client must be authorised by the proxy before the request can proceed.
• 408 - request timeout
  a 408 status code means that the client did not produce a request quickly enough. a server is set to only wait a certain amount of time for responses from clients, and a 408 status code indicates that time has passed.
• 409 - conflict
  a 409 status code indicates that the server was unable to complete the request, often because a file would need to be editted, created or deleted, and that file cannot be editted, created or deleted.
• 410 - gone
  a 410 status code is the 404's lesser known cousin. it indicates that a resource has permanently gone (a 404 status code gives no indication if a resource has gine permanently or temporarily), and no new address is known for it.
• 411 - length required
  the 411 status code occurs when a server refuses to process a request because a content length was not specified.
• 412 - precondition failed
  a 412 status code indicates that one of the conditions the request was made under has failed.
• 413 - request entity too large
  the 413 status code indicates that the request was larger than the server is able to handle, either due to physical constraints or to settings. usually, this occurs when a file is sent using the post method from a form, and the file is larger than the maximum size allowed in the server settings.
• 414 - request-uri too long
  the 414 status code indicates the the url requested by the client was longer than it can process.
• 415 - unsupported media type
  a 415 status code is returned by a server to indicate that part of the request was in an unsupported format.
• 416 - requested range not satisfiable
  a 416 status code indicates that the server was unable to fulfill the request. this may be, for example, because the client asked for the 800th-900th bytes of a document, but the document was only 200 bytes long.
• 417 - expectation failed
  the 417 status code means that the server was unable to properly complete the request. one of the headers sent to the server, the "expect" header, indicated an expectation the server could not meet.

server error

• 500 - internal server error
  a 500 status code (all too often seen by perl programmers) indicates that the server encountered something it didn't expect and was unable to complete the request.
• 501 - not implemented
  the 501 status code indicates that the server does not support all that is needed for the request to be completed.
• 502 - bad gateway
  a 502 status code indicates that a server, while acting as a proxy, received a response from a server further upstream that it judged invalid.
• 503 - service unavailable
  a 503 status code is most often seen on extremely busy servers, and it indicates that the server was unable to complete the request due to a server overload.
• 504 - gateway timeout
  a 504 status code is returned when a server acting as a proxy has waited too long for a response from a server further upstream.
• 505 - http version not supported
  a 505 status code is returned when the http version indicated in the request is no supported. the response should indicate which http versions are supported.

云自无心水自闲 2010-06-23 07:16

云自无心水自闲 2010-06-18 17:06

云自无心水自闲 2010-06-17 06:18

云自无心水自闲 2010-06-03 10:31

云自无心水自闲 2010-05-24 19:58