……天天向上

TOMCAT獲取信息：JMXServiceURL 、JMXConnector 和MBeanServerConnection

import java.lang.management.MemoryUsage; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.Formatter; 
import java.util.HashMap; 
import java.util.Iterator; 
import java.util.Map; 
import java.util.Set; 
 
import javax.management.MBeanAttributeInfo; 
import javax.management.MBeanInfo; 
import javax.management.MBeanServerConnection; 
import javax.management.ObjectInstance; 
import javax.management.ObjectName; 
import javax.management.openmbean.CompositeDataSupport; 
import javax.management.remote.JMXConnector; 
import javax.management.remote.JMXConnectorFactory; 
import javax.management.remote.JMXServiceURL; 
 
public class test { 
    /** 
     * @param args 
     */ 
    public static void main(String[] args) { 
        try { 
 
            String jmxURL = "service:jmx:rmi:///jndi/rmi://192.168.1.126:10090/jmxrmi";//tomcat jmx url   
            JMXServiceURL serviceURL = new JMXServiceURL(jmxURL); 
 
            Map map = new HashMap(); 
            String[] credentials = new String[] { "monitorRole", "QED" }; 
            map.put("jmx.remote.credentials", credentials); 
            JMXConnector connector = JMXConnectorFactory.connect(serviceURL, map); 
            MBeanServerConnection mbsc = connector.getMBeanServerConnection(); 
 
            //端口最好是動態(tài)取得   
            ObjectName threadObjName = new ObjectName("Catalina:type=ThreadPool,name=http-8089"); 
            MBeanInfo mbInfo = mbsc.getMBeanInfo(threadObjName); 
 
            String attrName = "currentThreadCount";//tomcat的線程數(shù)對應(yīng)的屬性值   
            MBeanAttributeInfo[] mbAttributes = mbInfo.getAttributes(); 
            System.out.println("currentThreadCount:" + mbsc.getAttribute(threadObjName, attrName)); 
 
            //heap   
            for (int j = 0; j < mbsc.getDomains().length; j++) { 
                System.out.println("###########" + mbsc.getDomains()[j]); 
            } 
            Set MBeanset = mbsc.queryMBeans(null, null); 
            System.out.println("MBeanset.size() : " + MBeanset.size()); 
            Iterator MBeansetIterator = MBeanset.iterator(); 
            while (MBeansetIterator.hasNext()) { 
                ObjectInstance objectInstance = (ObjectInstance) MBeansetIterator.next(); 
                ObjectName objectName = objectInstance.getObjectName(); 
                String canonicalName = objectName.getCanonicalName(); 
                System.out.println("canonicalName : " + canonicalName); 
                if (canonicalName.equals("Catalina:host=localhost,type=Cluster")) { 
                    // Get details of cluster MBeans   
                    System.out.println("Cluster MBeans Details:"); 
                    System.out.println("========================================="); 
                    //getMBeansDetails(canonicalName);   
                    String canonicalKeyPropList = objectName.getCanonicalKeyPropertyListString(); 
                } 
            } 
            //------------------------- system ----------------------   
            ObjectName runtimeObjName = new ObjectName("java.lang:type=Runtime"); 
            System.out.println("廠商:" + (String) mbsc.getAttribute(runtimeObjName, "VmVendor")); 
            System.out.println("程序:" + (String) mbsc.getAttribute(runtimeObjName, "VmName")); 
            System.out.println("版本:" + (String) mbsc.getAttribute(runtimeObjName, "VmVersion")); 
            Date starttime = new Date((Long) mbsc.getAttribute(runtimeObjName, "StartTime")); 
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
            System.out.println("啟動時間:" + df.format(starttime)); 
 
            Long timespan = (Long) mbsc.getAttribute(runtimeObjName, "Uptime"); 
            System.out.println("連續(xù)工作時間:" + test.formatTimeSpan(timespan)); 
            //------------------------ JVM -------------------------   
            //堆使用率   
            ObjectName heapObjName = new ObjectName("java.lang:type=Memory"); 
            MemoryUsage heapMemoryUsage = MemoryUsage.from((CompositeDataSupport) mbsc.getAttribute(heapObjName, 
                    "HeapMemoryUsage")); 
            long maxMemory = heapMemoryUsage.getMax();//堆最大   
            long commitMemory = heapMemoryUsage.getCommitted();//堆當(dāng)前分配   
            long usedMemory = heapMemoryUsage.getUsed(); 
            System.out.println("heap:" + (double) usedMemory * 100 / commitMemory + "%");//堆使用率   
 
            MemoryUsage nonheapMemoryUsage = MemoryUsage.from((CompositeDataSupport) mbsc.getAttribute(heapObjName, 
                    "NonHeapMemoryUsage")); 
            long noncommitMemory = nonheapMemoryUsage.getCommitted(); 
            long nonusedMemory = heapMemoryUsage.getUsed(); 
            System.out.println("nonheap:" + (double) nonusedMemory * 100 / noncommitMemory + "%"); 
 
            ObjectName permObjName = new ObjectName("java.lang:type=MemoryPool,name=Perm Gen"); 
            MemoryUsage permGenUsage = MemoryUsage.from((CompositeDataSupport) mbsc.getAttribute(permObjName, "Usage")); 
            long committed = permGenUsage.getCommitted();//持久堆大小   
            long used = heapMemoryUsage.getUsed();//   
            System.out.println("perm gen:" + (double) used * 100 / committed + "%");//持久堆使用率   
 
            //-------------------- Session ---------------    
            ObjectName managerObjName = new ObjectName("Catalina:type=Manager,*"); 
            Set<ObjectName> s = mbsc.queryNames(managerObjName, null); 
            for (ObjectName obj : s) { 
                System.out.println("應(yīng)用名:" + obj.getKeyProperty("path")); 
                ObjectName objname = new ObjectName(obj.getCanonicalName()); 
                System.out.println("最大會話數(shù):" + mbsc.getAttribute(objname, "maxActiveSessions")); 
                System.out.println("會話數(shù):" + mbsc.getAttribute(objname, "activeSessions")); 
                System.out.println("活動會話數(shù):" + mbsc.getAttribute(objname, "sessionCounter")); 
            } 
 
            //----------------- Thread Pool ----------------   
            ObjectName threadpoolObjName = new ObjectName("Catalina:type=ThreadPool,*"); 
            Set<ObjectName> s2 = mbsc.queryNames(threadpoolObjName, null); 
            for (ObjectName obj : s2) { 
                System.out.println("端口名:" + obj.getKeyProperty("name")); 
                ObjectName objname = new ObjectName(obj.getCanonicalName()); 
                System.out.println("最大線程數(shù):" + mbsc.getAttribute(objname, "maxThreads")); 
                System.out.println("當(dāng)前線程數(shù):" + mbsc.getAttribute(objname, "currentThreadCount")); 
                System.out.println("繁忙線程數(shù):" + mbsc.getAttribute(objname, "currentThreadsBusy")); 
            } 
 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
 
    public static String formatTimeSpan(long span) { 
        long minseconds = span % 1000; 
 
        span = span / 1000; 
        long seconds = span % 60; 
 
        span = span / 60; 
        long mins = span % 60; 
 
        span = span / 60; 
        long hours = span % 24; 
 
        span = span / 24; 
        long days = span; 
        return (new Formatter()).format("%1$d天 %2$02d:%3$02d:%4$02d.%5$03d", days, hours, mins, seconds, minseconds) 
                .toString(); 
    } 
 
}  

import java.util.Iterator;    
import java.util.Set;    
import javax.management.Attribute;    
import javax.management.MBeanInfo;    
import javax.management.MBeanServerConnection;    
import javax.management.MBeanServerInvocationHandler;    
import javax.management.ObjectInstance;    
import javax.management.ObjectName;    
import javax.management.remote.JMXConnector;    
import javax.management.remote.JMXConnectorFactory;    
import javax.management.remote.JMXServiceURL;    
public class Client {    
    public static void main(String[] args) throws Exception {       
        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:9999/server");       
        JMXConnector jmxc = JMXConnectorFactory.connect(url, null);        
        MBeanServerConnection mbsc = jmxc.getMBeanServerConnection();      
        ObjectName mbeanName = new ObjectName("chengang:name=HelloWorld");    
        // 把所有Domain都打印出來    
        System.out.println("Domains:---------------");       
        String domains[] = mbsc.getDomains();        
        for (int i = 0; i < domains.length; i++) {        
            System.out.println("\tDomain[" + i + "] = " + domains[i]);     
        }    
        // MBean的總數(shù)    
        System.out.println("MBean count = " + mbsc.getMBeanCount());    
        // 對name屬性的操作（屬性名的第一個字母要大寫）    
        mbsc.setAttribute(mbeanName, new Attribute("Name", "PANDA"));// 設(shè)值    
        System.out.println("Name = " + mbsc.getAttribute(mbeanName, "Name"));// 取值    
        // 得到proxy代理后直接調(diào)用的方式    
        HelloMBean proxy = (HelloMBean) MBeanServerInvocationHandler.newProxyInstance(mbsc, mbeanName, HelloMBean.class, false);         
        proxy.printHello();         
        proxy.printHello("Raymend");    
        // 遠(yuǎn)程調(diào)用的方式    
        mbsc.invoke(mbeanName, "printHello", null, null);          
        mbsc.invoke(mbeanName, "printHello", new Object[] { "熊貓燒香" }, new String[] { String.class.getName() });    
        // 得mbean的信息    
        MBeanInfo info = mbsc.getMBeanInfo(mbeanName);          
        System.out.println("Hello Class: " + info.getClassName());       
        System.out.println("Hello Attriber：" + info.getAttributes()[0].getName());      
        System.out.println("Hello Operation：" + info.getOperations()[0].getName());    
        // 得到所有的MBean的ObjectName    
        System.out.println("all ObjectName：---------------");         
        Set set = mbsc.queryMBeans(null, null);        
        for (Iterator it = set.iterator(); it.hasNext();) {         
            ObjectInstance oi = (ObjectInstance) it.next();         
            System.out.println("\t" + oi.getObjectName());         
            }
        // 關(guān)閉MBeanServer連接    
        jmxc.close();      
}    
}    

posted @ 2012-09-05 14:14 japper 閱讀(4990) | 評論 (0) | 編輯 收藏

LinkedHashMap和HashMap的比較使用

posted @ 2012-09-05 14:12 japper 閱讀(16467) | 評論 (5) | 編輯 收藏

java synchronized詳解 (轉(zhuǎn))

記下來，很重要。

Java語言的關(guān)鍵字，當(dāng)它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多只有一個線程執(zhí)行該段代碼。

     一、當(dāng)兩個并發(fā)線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內(nèi)只能有一個線程得到執(zhí)行。另一個線程必須等待當(dāng)前線程執(zhí)行完這個代碼塊以后才能執(zhí)行該代碼塊。

     二、然而，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。

     三、尤其關(guān)鍵的是，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。

     四、第三個例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結(jié)果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。

     五、以上規(guī)則對其它對象鎖同樣適用.

舉例說明： 
     一、當(dāng)兩個并發(fā)線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內(nèi)只能有一個線程得到執(zhí)行。另一個線程必須等待當(dāng)前線程執(zhí)行完這個代碼塊以后才能執(zhí)行該代碼塊。

package ths;

public class Thread1 implements Runnable { 
     public void run() { 
          synchronized(this) { 
               for (int i = 0; i < 5; i++) { 
                    System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); 
               } 
          } 
     } 
     public static void main(String[] args) { 
          Thread1 t1 = new Thread1(); 
          Thread ta = new Thread(t1, "A"); 
          Thread tb = new Thread(t1, "B"); 
          ta.start(); 
          tb.start(); 
     }    
}

結(jié)果： 
     A synchronized loop 0 
     A synchronized loop 1 
     A synchronized loop 2 
     A synchronized loop 3 
     A synchronized loop 4 
     B synchronized loop 0 
     B synchronized loop 1 
     B synchronized loop 2 
     B synchronized loop 3 
     B synchronized loop 4

     二、然而，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。

package ths;

public class Thread2 { 
     public void m4t1() { 
          synchronized(this) { 
               int i = 5; 
               while( i-- > 0) { 
                    System.out.println(Thread.currentThread().getName() + " : " + i); 
                    try { 
                         Thread.sleep(500); 
                    } catch (InterruptedException ie) { 
                    } 
               } 
          } 
     } 
     public void m4t2() { 
          int i = 5; 
          while( i-- > 0) { 
               System.out.println(Thread.currentThread().getName() + " : " + i); 
               try { 
                    Thread.sleep(500); 
               } catch (InterruptedException ie) { 
               } 
          } 
     } 
     public static void main(String[] args) { 
          final Thread2 myt2 = new Thread2(); 
          Thread t1 = new Thread(  new Runnable() {  public void run() {  myt2.m4t1();  }  }, "t1"  ); 
          Thread t2 = new Thread(  new Runnable() {  public void run() { myt2.m4t2();   }  }, "t2"  ); 
          t1.start(); 
          t2.start(); 
     }    
}

結(jié)果： 
     t1 : 4 
     t2 : 4 
     t1 : 3 
     t2 : 3 
     t1 : 2 
     t2 : 2 
     t1 : 1 
     t2 : 1 
     t1 : 0 
     t2 : 0

     三、尤其關(guān)鍵的是，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。

     //修改Thread2.m4t2()方法： 
     public void m4t2() { 
          synchronized(this) { 
               int i = 5; 
               while( i-- > 0) { 
                    System.out.println(Thread.currentThread().getName() + " : " + i); 
                    try { 
                         Thread.sleep(500); 
                    } catch (InterruptedException ie) { 
                    } 
               } 
          }

     }

結(jié)果：

     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

     四、第三個例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結(jié)果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。

     //修改Thread2.m4t2()方法如下：

     public synchronized void m4t2() { 
          int i = 5; 
          while( i-- > 0) { 
               System.out.println(Thread.currentThread().getName() + " : " + i); 
               try { 
                    Thread.sleep(500); 
               } catch (InterruptedException ie) { 
               } 
          } 
     }

結(jié)果： 
     t1 : 4 
     t1 : 3 
     t1 : 2 
     t1 : 1 
     t1 : 0 
     t2 : 4 
     t2 : 3 
     t2 : 2 
     t2 : 1 
     t2 : 0

     五、以上規(guī)則對其它對象鎖同樣適用:

package ths;

public class Thread3 {   
     class Inner {    
          private void m4t1() {    
               int i = 5;    
               while(i-- > 0) {    
                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);    
                    try {    
                         Thread.sleep(500);    
                    } catch(InterruptedException ie) {    
                    }    
               }    
          }    
          private void m4t2() {    
               int i = 5;    
               while(i-- > 0) {    
                    System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);    
                    try {    
                         Thread.sleep(500);    
                    } catch(InterruptedException ie) {    
                    }    
               }    
          }    
     }    
     private void m4t1(Inner inner) {    
          synchronized(inner) { //使用對象鎖    
          inner.m4t1();    
     }    
     private void m4t2(Inner inner) {    
          inner.m4t2();    
     }    
     public static void main(String[] args) {    
          final Thread3 myt3 = new Thread3();    
          final Inner inner = myt3.new Inner();    
          Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");    
     Thread t2 = new Thread( new Runnable() {public void run() { myt3.m4t2(inner);} }, "t2");    
     t1.start();    
     t2.start();    
  }    
}

結(jié)果：

盡管線程t1獲得了對Inner的對象鎖，但由于線程t2訪問的是同一個Inner中的非同步部分。所以兩個線程互不干擾。

     t1 : Inner.m4t1()=4 
     t2 : Inner.m4t2()=4 
     t1 : Inner.m4t1()=3 
     t2 : Inner.m4t2()=3 
     t1 : Inner.m4t1()=2 
     t2 : Inner.m4t2()=2 
     t1 : Inner.m4t1()=1 
     t2 : Inner.m4t2()=1 
     t1 : Inner.m4t1()=0 
     t2 : Inner.m4t2()=0

現(xiàn)在在Inner.m4t2()前面加上synchronized：

     private synchronized void m4t2() { 
          int i = 5; 
          while(i-- > 0) { 
               System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i); 
               try { 
                    Thread.sleep(500); 
               } catch(InterruptedException ie) { 
               } 
          } 
     }

結(jié)果：

盡管線程t1與t2訪問了同一個Inner對象中兩個毫不相關(guān)的部分,但因?yàn)閠1先獲得了對Inner的對象鎖，所以t2對Inner.m4t2()的訪問也被阻塞，因?yàn)閙4t2()是Inner中的一個同步方法。

     t1 : Inner.m4t1()=4 
     t1 : Inner.m4t1()=3 
     t1 : Inner.m4t1()=2 
     t1 : Inner.m4t1()=1 
     t1 : Inner.m4t1()=0 
     t2 : Inner.m4t2()=4 
     t2 : Inner.m4t2()=3 
     t2 : Inner.m4t2()=2 
     t2 : Inner.m4t2()=1 
     t2 : Inner.m4t2()=0

第二篇：

synchronized 關(guān)鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。 
1. synchronized 方法：通過在方法聲明中加入 synchronized關(guān)鍵字來聲明 synchronized 方法。如： 
public synchronized void accessVal(int newVal); 
synchronized 方法控制對類成員變量的訪問：每個類實(shí)例對應(yīng)一把鎖，每個 synchronized 方法都必須獲得調(diào)用該方法的類實(shí)例的鎖方能

執(zhí)行，否則所屬線程阻塞，方法一旦執(zhí)行，就獨(dú)占該鎖，直到從該方法返回時才將鎖釋放，此后被阻塞的線程方能獲得該鎖，重新進(jìn)入可執(zhí)行

狀態(tài)。這種機(jī)制確保了同一時刻對于每一個類實(shí)例，其所有聲明為 synchronized 的成員函數(shù)中至多只有一個處于可執(zhí)行狀態(tài)（因?yàn)橹炼嘀挥?/p>

一個能夠獲得該類實(shí)例對應(yīng)的鎖），從而有效避免了類成員變量的訪問沖突（只要所有可能訪問類成員變量的方法均被聲明為 synchronized）

。 
在 Java 中，不光是類實(shí)例，每一個類也對應(yīng)一把鎖，這樣我們也可將類的靜態(tài)成員函數(shù)聲明為 synchronized ，以控制其對類的靜態(tài)成

員變量的訪問。 
synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為

synchronized ，由于在線程的整個生命期內(nèi)它一直在運(yùn)行，因此將導(dǎo)致它對本類任何 synchronized 方法的調(diào)用都永遠(yuǎn)不會成功。當(dāng)然我們可

以通過將訪問類成員變量的代碼放到專門的方法中，將其聲明為 synchronized ，并在主方法中調(diào)用來解決這一問題，但是 Java 為我們提供

了更好的解決辦法，那就是 synchronized 塊。 
2. synchronized 塊：通過 synchronized關(guān)鍵字來聲明synchronized 塊。語法如下： 
synchronized(syncObject) { 
//允許訪問控制的代碼 
} 
synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實(shí)例或類）的鎖方能執(zhí)行，具體機(jī)

制同前所述。由于可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。 
對synchronized(this)的一些理解    
一、當(dāng)兩個并發(fā)線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內(nèi)只能有一個線程得到執(zhí)行。另一個線

程必須等待當(dāng)前線程執(zhí)行完這個代碼塊以后才能執(zhí)行該代碼塊。 
二、然而，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized

(this)同步代碼塊。 
三、尤其關(guān)鍵的是，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)

同步代碼塊的訪問將被阻塞。 
四、第三個例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個

object的對象鎖。結(jié)果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。 
五、以上規(guī)則對其它對象鎖同樣適用

http://hi.baidu.com/sunshibing/blog/item/5235b9b731d48ff430add14a.html
java中synchronized用法

打個比方：一個object就像一個大房子，大門永遠(yuǎn)打開。房子里有 很多房間（也就是方法）。

這些房間有上鎖的（synchronized方法）， 和不上鎖之分（普通方法）。房門口放著一把鑰匙（key），這把鑰匙可以打開所有上鎖的房間。

另外我把所有想調(diào)用該對象方法的線程比喻成想進(jìn)入這房子某個 房間的人。所有的東西就這么多了，下面我們看看這些東西之間如何作用的。

在此我們先來明確一下我們的前提條件。該對象至少有一個synchronized方法，否則這個key還有啥意義。當(dāng)然也就不會有我們的這個主題了。

一個人想進(jìn)入某間上了鎖的房間，他來到房子門口，看見鑰匙在那兒（說明暫時還沒有其他人要使用上鎖的 房間）。于是他走上去拿到了鑰匙

，并且按照自己 的計(jì)劃使用那些房間。注意一點(diǎn)，他每次使用完一次上鎖的房間后會馬上把鑰匙還回去。即使他要連續(xù)使用兩間上鎖的房間，

中間他也要把鑰匙還回去，再取回來。

因此，普通情況下鑰匙的使用原則是：“隨用隨借，用完即還。”

這時其他人可以不受限制的使用那些不上鎖的房間，一個人用一間可以，兩個人用一間也可以，沒限制。但是如果當(dāng)某個人想要進(jìn)入上鎖的房

間，他就要跑到大門口去看看了。有鑰匙當(dāng)然拿了就走，沒有的話，就只能等了。

要是很多人在等這把鑰匙，等鑰匙還回來以后，誰會優(yōu)先得到鑰匙？Not guaranteed。象前面例子里那個想連續(xù)使用兩個上鎖房間的家伙，他

中間還鑰匙的時候如果還有其他人在等鑰匙，那么沒有任何保證這家伙能再次拿到。 （JAVA規(guī)范在很多地方都明確說明不保證，象

Thread.sleep()休息后多久會返回運(yùn)行，相同優(yōu)先權(quán)的線程那個首先被執(zhí)行，當(dāng)要訪問對象的鎖被 釋放后處于等待池的多個線程哪個會優(yōu)先得

到，等等。我想最終的決定權(quán)是在JVM，之所以不保證，就是因?yàn)镴VM在做出上述決定的時候，絕不是簡簡單單根據(jù) 一個條件來做出判斷，而是

根據(jù)很多條。而由于判斷條件太多，如果說出來可能會影響JAVA的推廣，也可能是因?yàn)橹R產(chǎn)權(quán)保護(hù)的原因吧。SUN給了個不保證 就混過去了

。無可厚非。但我相信這些不確定，并非完全不確定。因?yàn)橛?jì)算機(jī)這東西本身就是按指令運(yùn)行的。即使看起來很隨機(jī)的現(xiàn)象，其實(shí)都是有規(guī)律

可尋。學(xué)過 計(jì)算機(jī)的都知道，計(jì)算機(jī)里隨機(jī)數(shù)的學(xué)名是偽隨機(jī)數(shù)，是人運(yùn)用一定的方法寫出來的，看上去隨機(jī)罷了。另外，或許是因?yàn)橐肱?/p>

的確定太費(fèi)事，也沒多大意義，所 以不確定就不確定了吧。）

再來看看同步代碼塊。和同步方法有小小的不同。

1.從尺寸上講，同步代碼塊比同步方法小。你可以把同步代碼塊看成是沒上鎖房間里的一塊用帶鎖的屏風(fēng)隔開的空間。

2.同步代碼塊還可以人為的指定獲得某個其它對象的key。就像是指定用哪一把鑰匙才能開這個屏風(fēng)的鎖，你可以用本房的鑰匙；你也可以指定

用另一個房子的鑰匙才能開，這樣的話，你要跑到另一棟房子那兒把那個鑰匙拿來，并用那個房子的鑰匙來打開這個房子的帶鎖的屏風(fēng)。

         記住你獲得的那另一棟房子的鑰匙，并不影響其他人進(jìn)入那棟房子沒有鎖的房間。

         為什么要使用同步代碼塊呢？我想應(yīng)該是這樣的：首先對程序來講同步的部分很影響運(yùn)行效率，而一個方法通常是先創(chuàng)建一些局部變

量，再對這些變量做一些 操作，如運(yùn)算，顯示等等；而同步所覆蓋的代碼越多，對效率的影響就越嚴(yán)重。因此我們通常盡量縮小其影響范圍。

如何做？同步代碼塊。我們只把一個方法中該同 步的地方同步，比如運(yùn)算。

         另外，同步代碼塊可以指定鑰匙這一特點(diǎn)有個額外的好處，是可以在一定時期內(nèi)霸占某個對象的key。還記得前面說過普通情況下鑰

匙的使用原則嗎。現(xiàn)在不是普通情況了。你所取得的那把鑰匙不是永遠(yuǎn)不還，而是在退出同步代碼塊時才還。

          還用前面那個想連續(xù)用兩個上鎖房間的家伙打比方。怎樣才能在用完一間以后，繼續(xù)使用另一間呢。用同步代碼塊吧。先創(chuàng)建另外

一個線程，做一個同步代碼 塊，把那個代碼塊的鎖指向這個房子的鑰匙。然后啟動那個線程。只要你能在進(jìn)入那個代碼塊時抓到這房子的鑰匙

，你就可以一直保留到退出那個代碼塊。也就是說 你甚至可以對本房內(nèi)所有上鎖的房間遍歷，甚至再sleep(10*60*1000)，而房門口卻還有

1000個線程在等這把鑰匙呢。很過癮吧。

          在此對sleep()方法和鑰匙的關(guān)聯(lián)性講一下。一個線程在拿到key后，且沒有完成同步的內(nèi)容時，如果被強(qiáng)制sleep()了，那key還一

直在 它那兒。直到它再次運(yùn)行，做完所有同步內(nèi)容，才會歸還key。記住，那家伙只是干活干累了，去休息一下，他并沒干完他要干的事。為

了避免別人進(jìn)入那個房間 把里面搞的一團(tuán)糟，即使在睡覺的時候他也要把那唯一的鑰匙戴在身上。

          最后，也許有人會問，為什么要一把鑰匙通開，而不是一個鑰匙一個門呢？我想這純粹是因?yàn)閺?fù)雜性問題。一個鑰匙一個門當(dāng)然更

安全，但是會牽扯好多問題。鑰匙 的產(chǎn)生，保管，獲得，歸還等等。其復(fù)雜性有可能隨同步方法的增加呈幾何級數(shù)增加，嚴(yán)重影響效率。這也

算是一個權(quán)衡的問題吧。為了增加一點(diǎn)點(diǎn)安全性，導(dǎo)致效 率大大降低，是多么不可取啊。

synchronized的一個簡單例子

public class TextThread {

public static void main(String[] args) {   
   TxtThread tt = new TxtThread();    
   new Thread(tt).start();    
   new Thread(tt).start();    
   new Thread(tt).start();    
   new Thread(tt).start();    
}    
}

class TxtThread implements Runnable {   
int num = 100;    
String str = new String();

public void run() {   
   synchronized (str) {    
    while (num > 0) {

     try {   
      Thread.sleep(1);    
     } catch (Exception e) {    
      e.getMessage();    
     }    
     System.out.println(Thread.currentThread().getName()    
       + "this is " + num--);    
    }    
   }    
}    
}

上面的例子中為了制造一個時間差,也就是出錯的機(jī)會,使用了Thread.sleep(10)

Java對多線程的支持與同步機(jī)制深受大家的喜愛，似乎看起來使用了synchronized關(guān)鍵字就可以輕松地解決多線程共享數(shù)據(jù)同步問題。到底如

何？――還得對synchronized關(guān)鍵字的作用進(jìn)行深入了解才可定論。

總的說來，synchronized關(guān)鍵字可以作為函數(shù)的修飾符，也可作為函數(shù)內(nèi)的語句，也就是平時說的同步方法和同步語句塊。如果再細(xì)的分類，

synchronized可作用于instance變量、object reference（對象引用）、static函數(shù)和class literals(類名稱字面常量)身上。

在進(jìn)一步闡述之前，我們需要明確幾點(diǎn)：

A．無論synchronized關(guān)鍵字加在方法上還是對象上，它取得的鎖都是對象，而不是把一段代碼或函數(shù)當(dāng)作鎖――而且同步方法很可能還會被其

他線程的對象訪問。

B．每個對象只有一個鎖（lock）與之相關(guān)聯(lián)。

C．實(shí)現(xiàn)同步是要很大的系統(tǒng)開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制。

接著來討論synchronized用到不同地方對代碼產(chǎn)生的影響：

假設(shè)P1、P2是同一個類的不同對象，這個類中定義了以下幾種情況的同步塊或同步方法，P1、P2就都可以調(diào)用它們。

1． 把synchronized當(dāng)作函數(shù)修飾符時，示例代碼如下：

Public synchronized void methodAAA()

{

//….

}

這也就是同步方法，那這時synchronized鎖定的是哪個對象呢？它鎖定的是調(diào)用這個同步方法對象。也就是說，當(dāng)一個對象P1在不同的線程中

執(zhí)行這個同步方法時，它們之間會形成互斥，達(dá)到同步的效果。但是這個對象所屬的Class所產(chǎn)生的另一對象P2卻可以任意調(diào)用這個被加了

synchronized關(guān)鍵字的方法。

上邊的示例代碼等同于如下代碼：

public void methodAAA()

{

synchronized (this)      // (1)

{

       //…..

}

}

(1)處的this指的是什么呢？它指的就是調(diào)用這個方法的對象，如P1。可見同步方法實(shí)質(zhì)是將synchronized作用于object reference。――那個

拿到了P1對象鎖的線程，才可以調(diào)用P1的同步方法，而對P2而言，P1這個鎖與它毫不相干，程序也可能在這種情形下擺脫同步機(jī)制的控制，造

成數(shù)據(jù)混亂：（

2．同步塊，示例代碼如下：

public void method3(SomeObject so)

{

    synchronized(so)

    {   
       //…..    
    }

}

這時，鎖就是so這個對象，誰拿到這個鎖誰就可以運(yùn)行它所控制的那段代碼。當(dāng)有一個明確的對象作為鎖時，就可以這樣寫程序，但當(dāng)沒有明

確的對象作為鎖，只是想讓一段代碼同步時，可以創(chuàng)建一個特殊的instance變量（它得是一個對象）來充當(dāng)鎖：

class Foo implements Runnable

{

        private byte[] lock = new byte[0]; // 特殊的instance變量

        Public void methodA()   
        {

           synchronized(lock) { //… }

        }

        //…..

}

注：零長度的byte數(shù)組對象創(chuàng)建起來將比任何對象都經(jīng)濟(jì)――查看編譯后的字節(jié)碼：生成零長度的byte[]對象只需3條操作碼，而Object lock

= new Object()則需要7行操作碼。

3．將synchronized作用于static 函數(shù)，示例代碼如下：

Class Foo   
{

    public synchronized static void methodAAA()   // 同步的static 函數(shù)   
    {    
        //….    
    }

    public void methodBBB()   
    {

       synchronized(Foo.class)   // class literal(類名稱字面常量)

    }   
}

   代碼中的methodBBB()方法是把class literal作為鎖的情況，它和同步的static函數(shù)產(chǎn)生的效果是一樣的，取得的鎖很特別，是當(dāng)前調(diào)用這

個方法的對象所屬的類（Class，而不再是由這個Class產(chǎn)生的某個具體對象了）。

記得在《Effective Java》一書中看到過將 Foo.class和 P1.getClass()用于作同步鎖還不一樣，不能用P1.getClass()來達(dá)到鎖這個Class的

目的。P1指的是由Foo類產(chǎn)生的對象。

可以推斷：如果一個類中定義了一個synchronized的static函數(shù)A，也定義了一個synchronized 的instance函數(shù)B，那么這個類的同一對象Obj

在多線程中分別訪問A和B兩個方法時，不會構(gòu)成同步，因?yàn)樗鼈兊逆i都不一樣。A方法的鎖是Obj這個對象，而B的鎖是Obj所屬的那個Class。

小結(jié)如下：

搞清楚synchronized鎖定的是哪個對象，就能幫助我們設(shè)計(jì)更安全的多線程程序。

還有一些技巧可以讓我們對共享資源的同步訪問更加安全：

1． 定義private 的instance變量+它的 get方法，而不要定義public/protected的instance變量。如果將變量定義為public，對象在外界可以

繞過同步方法的控制而直接取得它，并改動它。這也是JavaBean的標(biāo)準(zhǔn)實(shí)現(xiàn)方式之一。

2． 如果instance變量是一個對象，如數(shù)組或ArrayList什么的，那上述方法仍然不安全，因?yàn)楫?dāng)外界對象通過get方法拿到這個instance對象

的引用后，又將其指向另一個對象，那么這個private變量也就變了，豈不是很危險。 這個時候就需要將get方法也加上synchronized同步，并

且，只返回這個private對象的clone()――這樣，調(diào)用端得到的就是對象副本的引用了

posted @ 2012-08-29 17:47 japper 閱讀(344) | 評論 (0) | 編輯 收藏

MyEclipse的一些配置及優(yōu)化

MyEclipse的基礎(chǔ)配置：


1. 先安裝MyEclipse,安裝MyEclipse7.5需要VPN代理，安裝過程大概持續(xù)10-15分鐘，使用VPN測試帳號即可

2. 進(jìn)行MyEclipse的配置，
      從菜單欄中進(jìn)入“Windows --> Preferences”

3. 先要進(jìn)行JDK的配置，
    在左側(cè)欄中選擇“Java --> Installed JREs”，
    按“Add”按鈕進(jìn)行添加

4. 在彈出的“Add JRE”畫面中，選擇JRE的目錄，
    就是選擇你所在的JDK的目錄，我的為：C:\Program Files\Java\jre6
    在JRE名稱一欄中，填下想取的名稱，我這里叫“HiJackson's JRE”，
    然后“OK”確定

5. 返回到設(shè)置框中，將剛剛配置的JRE選中

6. 將Tomcat Server設(shè)為可用，并設(shè)置Tomcat的安裝目錄

7. 在Tomcat的JDK中選擇剛剛配置的JDK

8. 配置完成了，三個地方可以啟動它的服務(wù)，根據(jù)自己的喜好吧~~~

 

優(yōu)化MyEclipse：

經(jīng)過以上的優(yōu)化，myeclipse的啟動時間可以減少2/3，Tomcat的啟動速度可以減少1/2(視具體情況而定)，

特別6，7兩項(xiàng)的優(yōu)化效果最明顯，

如果只進(jìn)行前5項(xiàng)，優(yōu)化的效果有限，短期內(nèi)確實(shí)可以提高啟動速度，但是大概半個月后又會變的很慢（具體原因不明）
另外，使用myeclipse一段時間后，就會產(chǎn)生很多項(xiàng)目，即使這些項(xiàng)目是處于關(guān)閉狀態(tài)，myecliose在啟動時也會加載這些項(xiàng)目，這個過程會花費(fèi)很多時間，所以，建議將不用的項(xiàng)目都delete掉，用的時候再import

在用[MyEclipse] 寫代碼很容易卡死機(jī)，尤其是在對JSP文件的﹤%%﹥之間寫代碼的時候，只要一彈出智能提示就立刻卡死，程序失去響應(yīng)，我以為是MyEclipse版本的問題，結(jié)果換了6.0版-﹥6.5版-﹥7.0版全都一樣，難道是我機(jī)子的問題？可是還原系統(tǒng)后用還是一樣的結(jié)果。

百度一下你就知道，但是百度了N下才找到了一些門路，搜索也講究技巧，換了N個[關(guān)鍵字] 組合才搜出來。說是MyEclipse在智能提示的時候自動訪問網(wǎng)絡(luò)上sun公司的最新API文檔，只要關(guān)閉掉網(wǎng)絡(luò)連接就可以了。我試了試斷開網(wǎng)絡(luò)然后在用MyEclipse寫代碼，結(jié)果還真的搞定了。可是，我總不能因?yàn)閭€這就不上網(wǎng)了吧，繼續(xù)接著百度，找到了兩全其美的解決方法。

在自己創(chuàng)建的工程名上右鍵，選擇Properties--﹥在打開的窗口中點(diǎn)擊Java Build Path--﹥單擊Libraries選項(xiàng)卡，找到如圖中標(biāo)記2所示的地方--﹥選擇右邊的Remove更改成如標(biāo)記1所示的樣子--﹥點(diǎn)擊OK。

posted @ 2012-07-20 10:25 japper 閱讀(1010) | 評論 (0) | 編輯 收藏

jquery筆記0717

1、不常用的切換函數(shù)$("p").toggle();當(dāng)點(diǎn)擊切換按鈕時，隱藏元素為P行和顯示P行；


2、append() 函數(shù)向所匹配的 HTML 元素內(nèi)部追加內(nèi)容$(selector).append(content);
類似的還有：
$(selector).html(content) 改變被選元素的（內(nèi)部）HTML
$(selector).append(content) 向被選元素的（內(nèi)部）HTML 追加內(nèi)容
$(selector).prepend(content) 向被選元素的（內(nèi)部）HTML “預(yù)置”（Prepend）內(nèi)容
$(selector).after(content) 在被選元素之后添加 HTML
$(selector).before(content) 在被選元素之前添加 HTML

3、css操作：函數(shù) css({properties}) 同時為所有匹配元素的一系列 CSS 屬性設(shè)置值：
$(selector).css({properties})
$("p").css({"background-color":"red","font-size":"200%"});

jQuery 擁有兩種用于尺寸操作的重要函數(shù)：

• $(selector).height(value)
• $(selector).width(value)

總結(jié)如：
$(selector).css(name,value) 為匹配元素設(shè)置樣式屬性的值
$(selector).css({properties}) 為匹配元素設(shè)置多個樣式屬性
$(selector).css(name) 獲得第一個匹配元素的樣式屬性值
$(selector).height(value) 設(shè)置匹配元素的高度
$(selector).width(value) 設(shè)置匹配元素的寬度

4、AJAX：

jQuery AJAX 請求
$(selector).load(url,data,callback) 把遠(yuǎn)程數(shù)據(jù)加載到被選的元素中
$.ajax(options) 把遠(yuǎn)程數(shù)據(jù)加載到 XMLHttpRequest 對象中
$.get(url,data,callback,type) 使用 HTTP GET 來加載遠(yuǎn)程數(shù)據(jù)
$.post(url,data,callback,type) 使用 HTTP POST 來加載遠(yuǎn)程數(shù)據(jù)
$.getJSON(url,data,callback) 使用 HTTP GET 來加載遠(yuǎn)程 JSON 數(shù)據(jù)
$.getScript(url,callback) 加載并執(zhí)行遠(yuǎn)程的 JavaScript 文件

(url) 被加載的數(shù)據(jù)的 URL（地址）

(data) 發(fā)送到服務(wù)器的數(shù)據(jù)的鍵/值對象

(callback) 當(dāng)數(shù)據(jù)被加載時，所執(zhí)行的函數(shù)

(type) 被返回的數(shù)據(jù)的類型 (html,xml,json,jasonp,script,text)

(options) 完整 AJAX 請求的所有鍵/值對選項(xiàng)

略。。。

posted @ 2012-07-17 11:21 japper 閱讀(381) | 評論 (0) | 編輯 收藏

使用jxl導(dǎo)出大數(shù)據(jù)量EXCEL時內(nèi)存溢出的解決辦法

posted @ 2012-07-16 11:48 japper 閱讀(8905) | 評論 (1) | 編輯 收藏

一個簡單的分頁展示系統(tǒng)優(yōu)化總結(jié)

posted @ 2012-07-16 11:30 japper 閱讀(524) | 評論 (0) | 編輯 收藏

ORACLE復(fù)制千萬級數(shù)據(jù)表時用的存儲過程

CREATE OR REPLACE PROCEDURE "LARGEDATA_INSERT" (ip_table_name   in varchar2, --目標(biāo)表
                                          ip_table_column in varchar2, --目標(biāo)字段
                                          ip_table_select in varchar2, --SELECT 查詢語句
                                          return_result   out number --返回的結(jié)果1,表示成功，０表示失敗
                                          ) as
--適合大數(shù)據(jù)量的插入模板  create Templates by chenzhoumin 20110614
  runTime number;--運(yùn)行總次數(shù)
  i       number;--當(dāng)前行數(shù)
  amount  number;--總行數(shù)
  s_sql   varchar2(10000);--SQL語句
  e_sql   varchar2(10000);--執(zhí)行SQL語句
  countNumber number;--一次插入的數(shù)據(jù)量
begin
  --set serveroutput on size 20000000000000
  countNumber := 10000;
  return_result := 0; --開始初始化為0
  --核必邏輯內(nèi)容，可根據(jù)具體的業(yè)務(wù)邏輯來定義,統(tǒng)計(jì)數(shù)據(jù)總行數(shù)
  s_sql := 'select count(1) from (' || ip_table_select || ')';
  execute immediate s_sql
    into amount;
  --每100萬提交一次
  runTime := amount mod countNumber;
  if (runTime > 0) then
    runTime := 1 + trunc(amount / countNumber);
  end if;
  if (runTime = 0) then
    runTime := 0 + trunc(amount / countNumber);
  end if;
  FOR i IN 1 .. runTime LOOP
    e_sql := 'insert into '||ip_table_name ||'
    ('||ip_table_column ||')
     select '|| ip_table_column ||'
     from
     (select selectSec.*, rownum rownumType
          from ('|| ip_table_select ||') selectSec
         WHERE ROWNUM <= '|| i * countNumber ||')
    WHERE rownumType > '||(i - 1) * countNumber;
    dbms_output.enable(99999999999999);
    dbms_output.put_line(e_sql);
    execute immediate e_sql;
    --提交
    commit;
  END LOOP;
  return_result := 1;
  return;
exception
  when others then
    return_result := 0;
    raise;
    dbms_output.enable(99999999999999);
    dbms_output.put_line('結(jié)束');
    return;
end;



以上測試通過。

posted @ 2012-07-09 15:06 japper 閱讀(1967) | 評論 (0) | 編輯 收藏

ORACLE所在linux盤符空間不足的解決辦法

posted @ 2012-07-02 14:14 japper 閱讀(1323) | 評論 (0) | 編輯 收藏

oracle 臨時表空間的增刪改查

oracle 臨時表空間的增刪改查

posted @ 2012-06-28 14:54 japper 閱讀(31508) | 評論 (2) | 編輯 收藏

在JQuery中使用jsp頁面的select事件

posted @ 2012-06-15 14:52 japper 閱讀(2169) | 評論 (0) | 編輯 收藏

測試JAVA中SELECT COUNT(*) FROM XXX得到的ResultSet行數(shù)

posted @ 2012-06-07 11:24 japper 閱讀(3586) | 評論 (0) | 編輯 收藏

來點(diǎn)HTML基礎(chǔ)-HTML表單(Forms)屬性及用法

HTML表單(Form)是HTML的一個重要部分，主要用于采集和提交用戶輸入的信息。

舉個簡單的例子，一個讓用戶輸入姓名的HTML表單(Form)。示例代碼如下：

<form action="

請輸入你的姓名：

<input type="text" name="yourname">

<input type="submit" value="提交">

</form>

學(xué)習(xí)HTML表單(Form)最關(guān)鍵要掌握的有三個要點(diǎn)：

表單控件(Form Controls)
Action
Method
先說表單控件(Form Controls)，通過HTML表單的各種控件，用戶可以輸入文字信息，或者從選項(xiàng)中選擇，以及做提交的操作。比如上面的例句里，input type= "text"就是一個表單控件，表示一個單行輸入框。

用戶填入表單的信息總是需要程序來進(jìn)行處理，表單里的action就指明了處理表單信息的文件。比如上面例句里的http://www.linkzj.cn/asdocs/html_tutorials/yourname.asp。

至于method，表示了發(fā)送表單信息的方式。method有兩個值：get和post。get的方式是將表單控件的name/value信息經(jīng)過編碼之后，通過URL發(fā)送(你可以在地址欄里看到)。而post則將表單的內(nèi)容通過http發(fā)送，你在地址欄看不到表單的提交信息。那什么時候用get，什么時候用post呢？一般是這樣來判斷的，如果只是為取得和顯示數(shù)據(jù)，用get；一旦涉及數(shù)據(jù)的保存和更新，那么建議用post。

HTML表單(Form)常用控件(Controls)
HTML表單(Form)常用控件有：

input type="text" 單行文本輸入框
input type="submit" 將表單(Form)里的信息提交給表單里action所指向的文件
input type="checkbox" 復(fù)選框
input type="radio" 單選框
select 下拉框
textArea 多行文本輸入框
input type="password" 密碼輸入框(輸入的文字用*表示)
表單控件(Form Control)：單行文本輸入框(input type="text")
單行文本輸入框允許用戶輸入一些簡短的單行信息，比如用戶姓名。例句如下：

<input type="text" name="yourname">

表單控件(Form Control)：
復(fù)選框(input type="checkbox")
復(fù)選框允許用戶在一組選項(xiàng)里，選擇多個。示例代碼：

<input type="checkbox" name="fruit" value ="apple">蘋果<br>

<input type="checkbox" name="fruit" value ="orange">桔子<br>

<input type="checkbox" name="fruit" value ="mango">芒果<br>

用checked表示缺省已選的選項(xiàng)。

<input type="checkbox" name="fruit" value ="orange" checked>桔子<br>

表單控件(Form Control)：單選框(input type="radio")
使用單選框，讓用戶在一組選項(xiàng)里只能選擇一個。示例代碼：

<input type="radio" name="fruit" value = "Apple">蘋果<br>

<input type="radio" name="fruit" value = "Orange">桔子<br>

<input type="radio" name="fruit" value = "Mango">芒果<br>

用checked表示缺省已選的選項(xiàng)。

<input type="radio" name="fruit" value = "Orange" checked>桔子<br>

表單控件(Form Control)：下拉框(select)
下拉框(Select)既可以用做單選，也可以用做復(fù)選。單選例句如下：

<select name="fruit" >

<option value="apple">蘋果

<option value="orange">桔子

<option value="mango">芒果

</select>

如果要變成復(fù)選，加muiltiple即可。用戶用Ctrl來實(shí)現(xiàn)多選。例句：

<select name="fruit" multiple>

用戶還可以用size屬性來改變下拉框(Select)的大小。

表單控件(Form Control)：多行輸入框(textarea)
多行輸入框(textarea)主要用于輸入較長的文本信息。例句如下：

<textarea name="yoursuggest" cols ="50" rows = "3"></textarea>

其中cols表示textarea的寬度，rows表示textarea的高度。

表單控件(Form Control)：密碼輸入框(input type="password")
密碼輸入框(input type="password")主要用于一些保密信息的輸入，比如密碼。因?yàn)橛脩糨斎氲臅r候，顯示的不是輸入的內(nèi)容，而是黑點(diǎn)符號。。例句如下：

<input type="password" name="yourpw">

表單控件(Form Control)：提交(input type="submit")
通過提交(input type=submit)可以將表單(Form)里的信息提交給表單里action所指向的文件。例句如下：

<input type="submit" value="提交">

表單控件(Form Control)：圖片提交(input type="image")
input type=image 相當(dāng)于 input type=submit，不同的是，input type=image 以一個圖片作為表單的提交按鈕，其中 src 屬性表示圖片的路徑。

<input type="image" src ="

posted @ 2012-06-07 09:29 japper 閱讀(916) | 評論 (0) | 編輯 收藏

GET和POST兩種提交表單的方式說明

1.Get方式
這種方式是最簡單的參數(shù)傳遞方式。例如:
http://www.javaweb.cc/get.do?a=3&b=5&c=7

這個url中，a、b和c是url參數(shù)，具體的說是參數(shù)名，與之用“=”隔開的是對應(yīng)的參數(shù)值。也就是說參數(shù)a的值為3、參數(shù)b的值為5、參數(shù)c的值為7。get.do是請求地址，緊跟這個地址的參數(shù)a需要用“?”作為分隔符，其余參數(shù)用“&”做分隔符。

這種get請求發(fā)起后，服務(wù)器端可以通過request.getParameter()方法來獲得參數(shù)值。如要獲得參數(shù)a的值可以通過request.getParameter("a");

2.Post方式
相比get方式，post方式更為隱蔽。例如：http://www.javaweb.cc/post.do
在這個url中，你看不到任何參數(shù)，真正的參數(shù)隱藏在Http請求的數(shù)據(jù)體中。如果了解網(wǎng)絡(luò)監(jiān)聽的話，就會對這一點(diǎn)深有體會。
我們舉一個簡單的例子：通過表單做登錄操作。
我們簡化一個登錄表單：

<form action="login.do" method="post">
<ul>
<li><label for="username">用戶名</label><input id="username" name="username" type="text" /></li>
<li><label for="password">密碼</label><input id="password" type="password" /></li>
<li><label><input type="submit" value="登錄" /> <input
type="reset" value="重置" /></label></li>
</ul>
</form>
表單中有2個字段，用戶名（username）和密碼（password）
注意form標(biāo)簽中的method參數(shù)值是post！

即便是表單，在服務(wù)器端仍然可以通過request.getParameter()方法來獲得參數(shù)值。
Post方式，其實(shí)是將表單字段和經(jīng)過編碼的字段值經(jīng)過組合以數(shù)據(jù)體的方式做了參數(shù)傳遞。

經(jīng)過一番闡述，相信大家對兩種網(wǎng)絡(luò)參數(shù)傳遞方式都有所了解了。
Get方式比較簡單，通過構(gòu)建一個簡單HttpURLConnection就可以獲得，我們暫且不說。
我們主要來描述一下如何通過java代碼構(gòu)建一個表單提交。
仔細(xì)研究表單提交時所對應(yīng)的http數(shù)據(jù)體，發(fā)現(xiàn)其表單字段是以如下方式構(gòu)建的：

arg0=urlencode(value0)&arg1=urlencode(value1)
當(dāng)然，尤其要注意字段名，參數(shù)名只不能使用中文這類字符。
3、通過httpclient來模擬POST提交表單：

posted @ 2012-06-06 17:09 japper 閱讀(4468) | 評論 (1) | 編輯 收藏

表單提交的幾種方式

　　1、<!--通用提交按鈕-->
　　<input type="submit" value="提交">
　　2、<!--自定義提交按鈕-->
　　<button type="Submit">提交</button>
　　3、<!--圖像按鈕-->
　　<input type="image" src = "btn.png">
說明：用戶提交按鈕或圖像按鈕時，就會提交表單。使用<input>或<button>都可以定義提交按鈕，只要將其特性的值設(shè)置為“submit”即可，而圖像按鈕則是通過<input>的type特性值設(shè)置為”image”來定義的。因此，只要我們單擊一下代碼生成的按鈕，就可以提交表單。

    4、阻止表單提交

只要在表單中存在上面列出的任何一種按鈕，那么相應(yīng)表單控件擁有焦點(diǎn)的情況下，按回車鍵就可以提交表單。如果表單里沒有提交按鈕，按回車鍵不會提交表單。

　　以這種方式提交表單時，瀏覽器會在將請求發(fā)送給服務(wù)器之前觸發(fā)submit事件。這樣，我們就有機(jī)會驗(yàn)證表單數(shù)據(jù)，并據(jù)以決定是否允許表單提交。阻止這個事件的默認(rèn)行為就可以取消表單提交。例如，下面代碼會阻止表單提交：

var EventUtil = {
    addHandler: function (element, type, handler) {
        if (element.addEventListener) {
            element.addEventListener(type, handler, false);
        } else if (element.attachEvent) {
            element.attachEvent("on" + type, handler);
        } else {
            element["on" + type] = handler;
        }
    },
    getEvent: function (event) {
        return event ? event : window.event;
    },
    preventDefault: function (event) {
        if (event.preventDefault) {
            event.preventDefault();
        } else {
            event.returnValue = false;
        }
    }

}；

var form = document.getElementById("myForm");
EventUtil.addHandler(form, "submit", function () {
    //取得事件對象
    event = EventUtil.getEvent(event);
    //阻止默認(rèn)事件
    EventUtil.preventDefault(event);
});　　
調(diào)用preventDefault()方法阻止了表單提交。一般來說，在表單數(shù)據(jù)無效而不能發(fā)送給服務(wù)器時，可以使用這一技術(shù)。

5、在JavaScript中，以編程方式調(diào)用submit()方法也可以提交表單。
     這種方式無需表單包含提交按鈕，任何時候都可以正常提交表單。來看一個例子：

　　var form = document.getElementById("myForm");
　　//提交表單
　　form.submit();　　
     在以調(diào)用submit()方法的形式提交表單時，不會觸發(fā)submit事件，因此要記得在調(diào)用此方法之前先驗(yàn)證表單數(shù)字據(jù)。

　　提交表單時可能出現(xiàn)的最大問題，就是重復(fù)提交表單。在第一次提交表單后，如果長時間沒有反映，用戶可能會變得不耐煩。這時候，他們也許會反復(fù)單擊提交按鈕。結(jié)果往往很麻煩（因?yàn)榉?wù)器要處理重復(fù)請求），或者造成錯誤（如果是下了訂單，那么可能會多定好幾份）。
解決這一問題的辦法有兩個：
     在第一次提交表單后就禁用提交按鈕；
     利用onsubmit事件處理程序取消后續(xù)的表單提交操作。

 

posted @ 2012-06-06 10:16 japper 閱讀(11105) | 評論 (7) | 編輯 收藏

java的System.getProperty()方法可以獲取的值

java.version	Java 運(yùn)行時環(huán)境版本
java.vendor	Java 運(yùn)行時環(huán)境供應(yīng)商
java.vendor.url	Java 供應(yīng)商的 URL
java.home	Java 安裝目錄
java.vm.specification.version	Java 虛擬機(jī)規(guī)范版本
java.vm.specification.vendor	Java 虛擬機(jī)規(guī)范供應(yīng)商
java.vm.specification.name	Java 虛擬機(jī)規(guī)范名稱
java.vm.version	Java 虛擬機(jī)實(shí)現(xiàn)版本
java.vm.vendor	Java 虛擬機(jī)實(shí)現(xiàn)供應(yīng)商
java.vm.name	Java 虛擬機(jī)實(shí)現(xiàn)名稱
java.specification.version	Java 運(yùn)行時環(huán)境規(guī)范版本
java.specification.vendor	Java 運(yùn)行時環(huán)境規(guī)范供應(yīng)商
java.specification.name	Java 運(yùn)行時環(huán)境規(guī)范名稱
java.class.version	Java 類格式版本號
java.class.path	Java 類路徑
java.library.path	加載庫時搜索的路徑列表
java.io.tmpdir	默認(rèn)的臨時文件路徑
java.compiler	要使用的 JIT 編譯器的名稱
java.ext.dirs	一個或多個擴(kuò)展目錄的路徑
os.name	操作系統(tǒng)的名稱
os.arch	操作系統(tǒng)的架構(gòu)
os.version	操作系統(tǒng)的版本
file.separator	文件分隔符（在 UNIX 系統(tǒng)中是“/”）
path.separator	路徑分隔符（在 UNIX 系統(tǒng)中是“:”）
line.separator	行分隔符（在 UNIX 系統(tǒng)中是“/n”）
user.name	用戶的賬戶名稱
user.home	用戶的主目錄
user.dir	用戶的當(dāng)前工作目錄

獲取的代碼示例：

01.public class SystemProperty { 
02.    public static void main(String args[]) {    
03.    System.out.println("java_vendor:" + System.getProperty("java.vendor"));    
04.    System.out.println("java_vendor_url:"    
05.             + System.getProperty("java.vendor.url"));    
06.    System.out.println("java_home:" + System.getProperty("java.home"));    
07.    System.out.println("java_class_version:"    
08.             + System.getProperty("java.class.version"));    
09.    System.out.println("java_class_path:"    
10.            + System.getProperty("java.class.path"));    
11.    System.out.println("os_name:" + System.getProperty("os.name"));    
12.    System.out.println("os_arch:" + System.getProperty("os.arch"));    
13.    System.out.println("os_version:" + System.getProperty("os.version"));    
14.    System.out.println("user_name:" + System.getProperty("user.name"));    
15.    System.out.println("user_home:" + System.getProperty("user.home"));    
16.    System.out.println("user_dir:" + System.getProperty("user.dir"));    
17.    System.out.println("java_vm_specification_version:"    
18.            + System.getProperty("java.vm.specification.version"));    
19.    System.out.println("java_vm_specification_vendor:"    
20.            + System.getProperty("java.vm.specification.vendor"));    
21.    System.out.println("java_vm_specification_name:"    
22.            + System.getProperty("java.vm.specification.name"));    
23.    System.out.println("java_vm_version:"    
24.            + System.getProperty("java.vm.version"));    
25.    System.out.println("java_vm_vendor:"    
26.            + System.getProperty("java.vm.vendor"));    
27.    System.out    
28.            .println("java_vm_name:" + System.getProperty("java.vm.name"));    
29.    System.out.println("java_ext_dirs:"    
30.            + System.getProperty("java.ext.dirs"));    
31.    System.out.println("file_separator:"    
32.            + System.getProperty("file.separator"));    
33.    System.out.println("path_separator:"    
34.            + System.getProperty("path.separator"));    
35.    System.out.println("line_separator:"    
36.            + System.getProperty("line.separator"));    
37.}    

posted @ 2012-06-05 17:27 japper 閱讀(553) | 評論 (0) | 編輯 收藏