少年阿賓

package com.abin.lee.junit.httpasyncclient.service;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Map;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HttpAsyncClientService extends HttpServlet{
 private static final long serialVersionUID = 807336917776643578L;

 @SuppressWarnings("rawtypes")
 public void service(HttpServletRequest request,HttpServletResponse response) throws IOException{
  Map map=request.getParameterMap();
  String id=(String)((Object[])map.get("id"))[0].toString();
  if(null!=id&&!"".equals(id)){
   String result=id+" is response";
   System.out.println("result="+result);
   ServletOutputStream out=response.getOutputStream();
   BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out,"UTF-8"));
   writer.write(result);
   writer.flush();
   writer.close();
  }else{
   String result=id+" is null";
   System.out.println("result="+result);
   ServletOutputStream out=response.getOutputStream();
   BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out,"UTF-8"));
   writer.write(result);
   writer.flush();
   writer.close();
  }
 }
}

<servlet>
  <servlet-name>HttpAsyncClientService</servlet-name>
  <servlet-class>com.abin.lee.junit.httpasyncclient.service.HttpAsyncClientService</servlet-class>
 </servlet>
 <servlet-mapping>
  <servlet-name>HttpAsyncClientService</servlet-name>
  <url-pattern>/HttpAsyncClientService</url-pattern>
 </servlet-mapping>

package com.abin.lee.junit.httpasyncclient.example;

import java.util.concurrent.Future;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.nio.client.DefaultHttpAsyncClient;
import org.apache.http.nio.client.HttpAsyncClient;
import org.apache.http.util.EntityUtils;

public class CreateHttpAsyncClient {
 public static void main(String[] args) throws Exception {
        HttpAsyncClient httpclient = new DefaultHttpAsyncClient();
        httpclient.start();
        try {
            HttpGet request = new HttpGet("http://localhost:7000/global/HttpAsyncClientService?id=5");
            Future<HttpResponse> future = httpclient.execute(request, null);
            HttpResponse response = future.get();
            System.out.println("Response: " + response.getStatusLine());
            System.out.println("Response1: " + EntityUtils.toString(response.getEntity()));
            System.out.println("Shutting down");
        } finally {
            httpclient.shutdown();
        }
        System.out.println("Done");
    }

}

//這個適用于oracle10,11，以前oracle9操作CLOB字段相當的繁瑣，記著導入驅動包 
package com.abin.wto.dbs.oracle; 

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.PreparedStatement; 
import java.sql.ResultSet; 

public class OperateOracle { 
public static void main(String[] args) { 
Connection conn=null; 
PreparedStatement ps=null; 
ResultSet rs=null; 
try { 
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); 
String url="jdbc:oracle:thin:@localhost:1521:XE"; 
conn=DriverManager.getConnection(url,"abin","abin"); 
String sql="insert into bignumber values(?,?)"; 
ps=conn.prepareStatement(sql); 
ps.setInt(1, 1); 
oracle.sql.CLOB clob=oracle.sql.CLOB.createTemporary(conn, false, oracle.sql.CLOB.DURATION_SESSION); 
clob.open(oracle.sql.CLOB.MODE_READWRITE); 
clob.setString(3, "llll"); 
ps.setClob(2, clob); 
int result=ps.executeUpdate(); 
System.out.println("result="+result); 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 

} 

package com.abin.wto.dbs.oracle;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import oracle.sql.CLOB;

public class OperateOracle {
 public static void main(String[] args) {
  Connection conn=null;
  PreparedStatement ps=null;
  ResultSet rs=null;
  try {
   Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
   String url="jdbc:oracle:thin:@localhost:1521:XE";
   conn=DriverManager.getConnection(url,"abin","abin");
   String sql="insert into bignumber values(?,?)";
   ps=conn.prepareStatement(sql);
   ps.setInt(1, 8888);
   java.sql.Clob  clob=oracle.sql.CLOB.createTemporary(conn, false, oracle.sql.CLOB.DURATION_SESSION);
   clob.setString(1, "55555555555555");
   ps.setClob(2, clob);
   int result=ps.executeUpdate();
   System.out.println("result="+result);
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   if(ps!=null){
    try {
     ps.close();
    } catch (SQLException e) {
     e.printStackTrace();
    }
   }
   try {
    CLOB.freeTemporary(null);
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
 }

}

 

     摘要: 1、sed使用手冊（轉載）  sed使用手冊（轉載） 發信站: BBS 水木清華站 (Wed Sep 25 21:06:36 2002), 站內信件      Sed 命令列可分成編輯指令與文件檔部份。其中 , 編輯指令負責控制所有的編 輯工作 ; 文件檔表示所處理的檔案。    ...  閱讀全文

Semaphore當前在多線程環境下被擴放使用，操作系統的信號量是個很重要的概念，在進程控制方面都有應用。Java 并發庫 的Semaphore 可以很輕松完成信號量控制，Semaphore可以控制某個資源可被同時訪問的個數，通過 acquire() 獲取一個許可，如果沒有就等待，而 release() 釋放一個許可。比如在Windows下可以設置共享文件的最大客戶端訪問個數。 

Semaphore實現的功能就類似廁所有5個坑，假如有10個人要上廁所，那么同時只能有多少個人去上廁所呢？同時只能有5個人能夠占用，當5個人中 的任何一個人讓開后，其中等待的另外5個人中又有一個人可以占用了。另外等待的5個人中可以是隨機獲得優先機會，也可以是按照先來后到的順序獲得機會，這取決于構造Semaphore對象時傳入的參數選項。單個信號量的Semaphore對象可以實現互斥鎖的功能，并且可以是由一個線程獲得了“鎖”，再由另一個線程釋放“鎖”，這可應用于死鎖恢復的一些場合。

Semaphore維護了當前訪問的個數，提供同步機制，控制同時訪問的個數。在數據結構中鏈表可以保存“無限”的節點，用Semaphore可以實現有限大小的鏈表。另外重入鎖 ReentrantLock 也可以實現該功能，但實現上要復雜些。 

下面的Demo中申明了一個只有5個許可的Semaphore，而有20個線程要訪問這個資源，通過acquire()和release()獲取和釋放訪問許可。

package com.test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

public class TestSemaphore {

                public static void main(String[] args) {

                // 線程池

                ExecutorService exec = Executors.newCachedThreadPool();

                // 只能5個線程同時訪問

                final Semaphore semp = new Semaphore(5);

                 // 模擬20個客戶端訪問

                 for (int index = 0; index < 20; index++) {

                              final int NO = index;

                              Runnable run = new Runnable() {

                                                 public void run() {

                                                            try {

                                                                    // 獲取許可

                                                                    semp.acquire();

                                                                    System.out.println("Accessing: " + NO);

                                                                    Thread.sleep((long) (Math.random() * 10000));

                                                                    // 訪問完后，釋放

                                                                    semp.release();

                                                                    System.out.println("-----------------"+semp.availablePermits());

                                                            } catch (InterruptedException e) {

                                                                    e.printStackTrace();

                                                            }

                                                  }

                                      };

                      exec.execute(run);

             }

             // 退出線程池

             exec.shutdown();

       }

} 

執行結果如下：

Accessing: 0

Accessing: 1

Accessing: 3

Accessing: 4

Accessing: 2

-----------------0

Accessing: 6

-----------------1

Accessing: 7

-----------------1

Accessing: 8

-----------------1

Accessing: 10

-----------------1

Accessing: 9

-----------------1

Accessing: 5

-----------------1

Accessing: 12

-----------------1

Accessing: 11

-----------------1

Accessing: 13

-----------------1

Accessing: 14

-----------------1

Accessing: 15

-----------------1

Accessing: 16

-----------------1

Accessing: 17

-----------------1

Accessing: 18

-----------------1

Accessing: 19

http://www.cnblogs.com/whgw/archive/2011/09/29/2195555.html

View Code
 package generate.httpclient;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 
 import org.apache.http.HttpResponse;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.concurrent.FutureCallback;
 import org.apache.http.impl.nio.client.DefaultHttpAsyncClient;
 import org.apache.http.nio.client.HttpAsyncClient;
 import org.apache.http.nio.reactor.IOReactorException;
 
 public class AsynClient{
     /**
      * @param args
      * @throws IOReactorException
      * @throws InterruptedException
      */
     private List<String> urls;
     private HandlerFailThread failHandler;
     public AsynClient(List<String> list){
         failHandler=new HandlerFailThread();
         urls=list;
     }
     public Map<String,String> asynGet() throws IOReactorException,
             InterruptedException {
         final HttpAsyncClient httpclient = new DefaultHttpAsyncClient();
         httpclient.start();
         int urlLength=urls.size();
         HttpGet[] requests = new HttpGet[urlLength];
         int i=0;
         for(String url : urls){
             requests[i]=new HttpGet(url);
             i++;
         }
         final CountDownLatch latch = new CountDownLatch(requests.length);
         final Map<String, String> responseMap=new HashMap<String, String>();
         try {
             for (final HttpGet request : requests) {
                 httpclient.execute(request, new FutureCallback<HttpResponse>() {
 
                     public void completed(final HttpResponse response) {
                         latch.countDown();
                         responseMap.put(request.getURI().toString(), response.getStatusLine().toString());
                         try {
                             System.out.println(request.getRequestLine() + "->"
                                     + response.getStatusLine()+"->");
                             //+readInputStream(response.getEntity().getContent())
                            
                         } catch (IllegalStateException e) {
                             failHandler.putFailUrl(request.getURI().toString(),
                                     response.getStatusLine().toString());
                             e.printStackTrace();
                         } catch (Exception e) {
                             failHandler.putFailUrl(request.getURI().toString(),
                                     response.getStatusLine().toString());
                             e.printStackTrace();
                         }
                     }
 
                     public void failed(final Exception ex) {
                         latch.countDown();
                         ex.printStackTrace();
                         failHandler.putFailUrl(request.getURI().toString(),
                                 ex.getMessage());
                     }
 
                     public void cancelled() {
                         latch.countDown();
                     }
 
                 });
             }
             System.out.println("Doing...");
         } finally {
             latch.await();
             httpclient.shutdown();
         }
         System.out.println("Done");
         failHandler.printFailUrl();
         return responseMap;
     }
     private String readInputStream(InputStream input) throws IOException{
         byte[] buffer = new byte[128];
         int len = 0;
         ByteArrayOutputStream bytes = new ByteArrayOutputStream();
         while((len = input.read(buffer)) >= 0) {
             bytes.write(buffer, 0, len);
         }
         return bytes.toString();
     }
     /**
      * Test
      * @param args
      */
     public static void main(String[] args) {
         List<String> urls=new ArrayList<String>();
         urls.add("         urls.add("         urls.add("         for(int i=0;i<10;i++){
             urls.addAll(urls);
         }
         System.out.println(urls.size());
         AsynClient client=new AsynClient(urls);
         try {
             client.asynGet();
         } catch (IOReactorException e) {
             e.printStackTrace();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("done");
     }
 }

package com.abin.lii.han.limei;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

import org.junit.Test;

public class ImediaRegisterTest {
 @Test
 public void testImediaRegister(){
  String LIMEI_HTTP="  String appId="fk000";
  String udid="3A5S4D6F8G9K_3596140444464123";
  String requestUrl=LIMEI_HTTP+"?app="+appId+"&udid="+udid+"&source="+"where"";
  System.out.println(requestUrl);
  String result="";
  try {
   URL url=new URL(requestUrl);
   HttpURLConnection connection=(HttpURLConnection)url.openConnection();
   connection.setDoOutput(true);
   connection.setDoInput(true);
   connection.setRequestMethod("GET");
   connection.setUseCaches(false);
   // URLConnection.setInstanceFollowRedirects是成員函數，僅作用于當前函數
   connection.setInstanceFollowRedirects(false);
   connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded");
   connection.connect();
   //發送執行請求
   
   //接收返回請求
   BufferedReader reader=new BufferedReader(new InputStreamReader(connection.getInputStream(),"GBK"));
   String line="";
   StringBuffer buffer=new StringBuffer();
   while((line=reader.readLine())!=null){
    buffer.append(line);
   }
   result=buffer.toString();
   System.out.println("result="+result);
   connection.disconnect();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

}

1.tomcat下所有應用都強制https訪問

在tomcat\conf\web.xml中的</welcome-file-list>后面加上以下配置:

  <login-config>
      <!-- Authorization setting for SSL -->
      <auth-method>CLIENT-CERT</auth-method>
      <realm-name>Client Cert Users-only Area</realm-name>
  </login-config>
  <security-constraint>
      <!-- Authorization setting for SSL -->
      <web-resource-collection >
          <web-resource-name >SSL</web-resource-name>
          <url-pattern>/*</url-pattern>
      </web-resource-collection>
      <user-data-constraint>
          <transport-guarantee>CONFIDENTIAL</transport-guarantee>
      </user-data-constraint>
  </security-constraint>

2.單個應用強制https訪問

WEB-INF/web.xml的</welcome-file-list>后面加上以下配置:

  <login-config>
      <!-- Authorization setting for SSL -->
      <auth-method>CLIENT-CERT</auth-method>
      <realm-name>Client Cert Users-only Area</realm-name>
  </login-config>
  <security-constraint>
      <!-- Authorization setting for SSL -->
      <web-resource-collection >
          <web-resource-name >SSL</web-resource-name>
          <url-pattern>/*</url-pattern>
      </web-resource-collection>
      <user-data-constraint>
          <transport-guarantee>CONFIDENTIAL</transport-guarantee>
      </user-data-constraint>
  </security-constraint>

select t.*,t.rowid from abin1 t;
刪除重復的記錄，只保留一條：
delete from abin1 t where rowid not in (select max(rowid) from abin1 s group by s.id1  );
delete from abin1 t where t.rowid not in (select min(s.rowid) from abin1 s where t.id1=s.id1 group by s.id1)
刪除全部重復記錄：
delete from abin1 t where t.id1 in (select s.id1 from abin1 s group by s.id1 having count(s.id1)>1 );
delete from abin1 t where exists (select * from abin1 s where t.id1=s.id1 group by s.id1 having count(s.id1)>1)
取出有重復的記錄，沒有重復的單條記錄不取：
select * from abin1 t where t.id1 in (select s.id1 from abin1 s group by s.id1 having(count(s.id1))>1 );
select * from abin1 t where exists (select * from abin1 s where s.id1=t.id1 group by s.id1 having(count(s.id1))>1);
刪除重復記錄（保留一條）：
delete from abin1 t where t.id1 not in(select max(s.id1) from abin1 s group by s.name1 having count(s.name1)>0);