java之 Timer 类的简单使用案例

          (如果您看到本文章务必看结尾！)

第一次用Timer类，记录一下个人理解。

场景：做苹果内容结果验证时，根据苹果支付凭证去苹果官方服务器验证是否支付成功。但因为苹果服务器比较慢，第一次验证的结果也许不是实时结果，需要多次验证。

所以就使用到了Timer类，定时限制次数去验证支付结果。

我设计的是每秒验证一次，共验证十次。

其实就Timer来讲就是一个调度器,而TimerTask呢只是一个实现了run方法的一个类,而具体的TimerTask需要由你自己来实现,例如这样:

Timer timer = new Timer();
timer.schedule(new TimerTask() {
        public void run() {
            System.out.println("每秒执行一次");
        }
}, 500 , 1000);

方法摘要：

void cancel()    终止此计时器，丢弃所有当前已安排的任务。

int purge()     从此计时器的任务队列中移除所有已取消的任务。

void schedule(TimerTask task, Date time)     安排在指定的时间执行指定的任务。

void schedule(TimerTask task, Date firstTime, long period)     安排指定的任务在指定的时间开始进行重复的固定延迟执行。

void schedule(TimerTask task, long delay)     安排在指定延迟后执行指定的任务。

void schedule(TimerTask task, long delay, long period)     安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)     安排指定的任务在指定的时间开始进行重复的固定速率执行。

void scheduleAtFixedRate(TimerTask task, long delay, long period)     安排指定的任务在指定的延迟后开始进行重复的固定速率执行。

知识点：线程中的变量参数用专门的变量类，如： ConcurrentMap<String, Integer> map

Test类：

 package com.xxxx.controller;

 import java.io.BufferedOutputStream;
 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.net.URL;
 import java.security.cert.CertificateException;
 import java.security.cert.X509Certificate;
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;

 import javax.net.ssl.HttpsURLConnection;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;

 import com.alibaba.fastjson.JSONObject;
 import com.wfcm.utils.R;

 public class Test {

     private static ConcurrentMap<String, Integer> map = new ConcurrentHashMap<>();

     private static final String certificateUrlTest = "https://sandbox.itunes.apple.com/verifyReceipt"; 

     public static void main(String[] args) {

          System.out.println(tim().toString());

     }

     private static R tim () {
         final Timer timer = new Timer();
         final String certificateCode1 = "234234234234";
          timer.schedule(new TimerTask() {

              @Override
              public void run() {
                  if (map.get(certificateCode1) != null) {
                  map.put(certificateCode1, map.get(certificateCode1) + 1);
                  } else {
                      map.put(certificateCode1, 1);
                  }
                  if (map.get(certificateCode1) >= 20) {
                      map.remove(certificateCode1);
                      timer.cancel();
                  }
                  String r1 = sendHttpsCoon(certificateUrlTest, certificateCode1);
                  if (JSONObject.parseObject(r1).getString("status").equals("0")) {
                      map.remove(certificateCode1);
                      timer.cancel();
                  }
                  System.out.println("设定指定任务task在指定延迟delay后执行");
              }
         },500 , 1000);
         System.out.println("******************方法结束");
         return R.error("68");
     }

     private static String sendHttpsCoon(String url, String code){
         if(url.isEmpty()){
             return null;
         }
         try {
             //设置SSLContext
             SSLContext ssl = SSLContext.getInstance("SSL");
             ssl.init(null, new TrustManager[]{myX509TrustManager}, null);  

             //打开连接
             HttpsURLConnection conn = (HttpsURLConnection) new URL(url).openConnection();
             //设置套接工厂
             conn.setSSLSocketFactory(ssl.getSocketFactory());
             //加入数据
             conn.setRequestMethod("POST");
             conn.setDoOutput(true);
             conn.setRequestProperty("Content-type","application/json");  

             JSONObject obj = new JSONObject();
             obj.put("receipt-data", code);  

             BufferedOutputStream buffOutStr = new BufferedOutputStream(conn.getOutputStream());
             buffOutStr.write(obj.toString().getBytes());
             buffOutStr.flush();
             buffOutStr.close();  

             //获取输入流
             BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));  

             String line = null;
             StringBuffer sb = new StringBuffer();
             while((line = reader.readLine())!= null){
                 sb.append(line);
             }
             return sb.toString();  

         } catch (Exception e) {
             return null;
         }
     }  

     private static TrustManager myX509TrustManager = new X509TrustManager() {  

         @Override
         public X509Certificate[] getAcceptedIssuers() {
             return null;
         }  

         @Override
         public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {  

         }  

         @Override
         public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {  

         }
     };
 }
         

---

第二次修订：

在后续的学习中发现了一个更好的方法，同时也发现了Timer的不足之处。更多请看下面文章，写的很好：

Timer的缺陷分析

.综上所述，推荐使用ScheduleExecutorService ，在以后的开发中尽可能使用ScheduledExecutorService（JDK1.5以后）替代Timer。

或者使用Quartz，据说它也改善了这两大缺陷