blogjava-凯发k8网页登录

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

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

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

angular. module('notesapp' , [])
 . controller('mainctrl' , ['$log' , function($log) {
 var self = this;
 self. logstuff = function() {
 $log. log('the button was pressed' );
 };
 }])

mymodule.controller("mainctrl",  ["$log", "$window", function($l, $w) {}]);
在这个例子中，$log, $windows是angularjs自带的两个服务，在数组中通过名称声明后，会被注入到函数的两个参数中。
比较常用的angularjs自带的服务有：$window, $location, $http等

从上面的例子中可以看出，angularjs的设计思想就是不要在函数中自己去实例化或者通过其它途径来获取服务的实例，而是声明需要的对象，由angularjs来注入具体的实例。

创建自己的服务
什么时候应该创建服务，而不是controller呢？
1。 需要重用的时候
2。需要保留应用级的状态。这是非常重要的一点，controller是会不断地被创建和销毁的，如果需要保存应用级的状态，就需要使用service
3。和页面显示无关
4。需要和第三方服务整合
5。缓存

服务是会被延迟加载的，也就是说只有在第一次被引用的时候，才会被创建。
服务将会被定义一次，也只会被实例化一次。

云自无心水自闲 2015-02-09 19:28

a. 在循环map的时候，会自动根据键值进行排序。

b. 一些自带的变量，$first(是否是第一个), $last(是否是最后一个), $middle(是否是中间的), $index(下标，根据键值排序后的下标), $even, $odd

08. 自己定义新变量时不要使用$$开头。

09. 可以使用track-by表达式来优化对dom的操作，对dom对象使用从数据库取得的id来进行标记，这样的话，当我们重复多次从数据库中取出相同的数据的时候，dom对象就能够被重用。

10. 数据双向绑定的好处

a. 如果我们想改变页面form中的数值，我们不需要在javascript中，根据id或者名称来查找相应的form控件，只需要改变controller变量的值，不需要jquery的selector,也不需要findelementbyid

b. 如果我们想在javascript中获取form控件的值，在控件的变量中就能直接获得。

11. 使用ng-submit比在button上使用ng-click要好一些。html的表单的提交有多种方式，比如在输入域中按回车键就会触发ng-submit，而不会触发button的ng-click事件。

12. 在ng-model中，可以直接引用一个对象,比如：，而不需要事先在model中以self.user={}定义。在angularjs中，使用了ng-model的话，angularjs在初始化数据绑定的时候，自动创建其中的对象和键值。在刚才的例子中，一旦用户开始在输入域中键入第一个字母，用户user就会被自动创建。

13. 推荐使用将相关数据集中到一个对象的方式来进行数据绑定，比如，用户名和密码，推荐使用：

而不是：

云自无心水自闲 2015-02-03 19:36

a. 定义一个module, 需要传入2个参数，module('modulename', []), 第一个参数是新的module名称，第二个参数是新module所依赖的module数组。

b. 载入一个module, 只需要1个参数，module('modulename'), 唯一的一个参数指定要载入的module名称。

2. 使用controller函数来定义一个控制器(controller), 用ng-controller将控制器绑定到具体的html组件上。定义控制器的controller函数也需要2个参数，第一个是控制器名称，第二个参数同样也是一个数组，数组的最后一个元素就是controller本身的函数，前面的元素用字符串的形式指定其需要的依赖项。如果没有依赖项，那就只需要定义函数。比如：

angular.module('app1', [])

.controller('maincontrol', [function() {

console.log('controller created.');

}]);

3. 在controller函数中用var定义的局部变量，在html中是不可见的。

4. 推荐在controller函数中尽量避免直接引用this, 比较好的做法是使用代理。原因是一个函数中的this关键词在被外部调用的时候，是会被覆盖掉的。这样的话，在函数内部和外部的this会是完全不同两个对象。

代理用法示例：

angular.module('app1', [])

.controller('maincontrol', [function() {

var self = this;

self.message = 'hello world';

self.changemessage = function() {

self.message = 'goodbye.';

};

}]);

5. ng-bind与双大括号的区别, ng-bind和{{}}可以说基本上是可以互相替换的，但是也有区别。区别在于：angularjs在启动的时候就会执行ng-bind, 而{{}}的替换时间会稍晚一些。有可能发现页面在加载的时候，双括号被一闪而过地替换掉（只在页面初次加载的时候发生）。但是ng-bind就没有这个问题。
6. ng-cloak可以用于解决双括号闪现的问题。

云自无心水自闲 2015-02-01 19:19

主要是使用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

云自无心水自闲 2011-08-08 10:36

主要是使用：

biff8encryptionkey.setcurrentuserpassword(password);

在打开workbook之前

hssfworkbook workbook = new hssfworkbook(inp);

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

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

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

1、事件驱动的数据读取

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

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

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

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

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

2、数据的发送

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

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

云自无心水自闲 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-20 08:51

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

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

云自无心水自闲 2010-07-14 09:33

云自无心水自闲 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-16 20:08