/**
 * Copyright (c) 2005-2012 springside.org.cn
 */
package com.sdhsie.web.service;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.GeneralSecurityException;
import java.security.SecureRandom;
import java.util.Arrays;

/**
 * 支持HMAC-SHA1消息签名 及 DES/AES对称加密的工具类.
 * 
 * 支持Hex与Base64两种编码方式.
 * 
 * @author calvin
 */
public class Cryptos {

	private static final String AES = "AES";
	private static final String AES_CBC = "AES/CBC/PKCS5Padding";
	private static final String HMACSHA1 = "HmacSHA1";

	private static final String DEFAULT_URL_ENCODING = "UTF-8";
	private static final int DEFAULT_HMACSHA1_KEYSIZE = 160; // RFC2401
	private static final int DEFAULT_AES_KEYSIZE = 128;
	private static final int DEFAULT_IVSIZE = 16;

	private static final byte[] DEFAULT_KEY = new byte[] { -97, 88, -94, 9, 70, -76, 126, 25, 0, 3, -20, 113, 108, 28,
			69, 125 };

	private static SecureRandom random = new SecureRandom();

	// -- HMAC-SHA1 funciton --//
	/**
	 * 使用HMAC-SHA1进行消息签名, 返回字节数组,长度为20字节.
	 * 
	 * @param input 原始输入字符数组
	 * @param key HMAC-SHA1密钥
	 * @throws GeneralSecurityException 
	 */
	public static byte[] hmacSha1(byte[] input, byte[] key) throws GeneralSecurityException {
		SecretKey secretKey = new SecretKeySpec(key, HMACSHA1);
		Mac mac = Mac.getInstance(HMACSHA1);
		mac.init(secretKey);
		return mac.doFinal(input);
	}

	/**
	 * 校验HMAC-SHA1签名是否正确.
	 * 
	 * @param expected 已存在的签名
	 * @param input 原始输入字符串
	 * @param key 密钥
	 * @throws GeneralSecurityException 
	 */
	public static boolean isMacValid(byte[] expected, byte[] input, byte[] key) throws GeneralSecurityException {
		byte[] actual = hmacSha1(input, key);
		return Arrays.equals(expected, actual);
	}

	/**
	 * 生成HMAC-SHA1密钥,返回字节数组,长度为160位(20字节).
	 * HMAC-SHA1算法对密钥无特殊要求, RFC2401建议最少长度为160位(20字节).
	 * @throws GeneralSecurityException 
	 */
	public static byte[] generateHmacSha1Key() throws GeneralSecurityException {
		KeyGenerator keyGenerator = KeyGenerator.getInstance(HMACSHA1);
		keyGenerator.init(DEFAULT_HMACSHA1_KEYSIZE);
		SecretKey secretKey = keyGenerator.generateKey();
		return secretKey.getEncoded();
	}

	// -- AES funciton --//

	/**
	 * 使用AES加密原始字符串.
	 * 
	 * @param input 原始输入字符数组
	 * @throws GeneralSecurityException 
	 */
	public static String aesEncrypt(String input) throws GeneralSecurityException {
		try {
			return encodeHex(aesEncrypt(input.getBytes(DEFAULT_URL_ENCODING), DEFAULT_KEY));
		} catch (UnsupportedEncodingException e) {
			return "";
		}
	}

	/**
	 * 使用AES加密原始字符串.
	 * 
	 * @param input 原始输入字符数组
	 * @param key 符合AES要求的密钥
	 * @throws GeneralSecurityException 
	 */
	public static String aesEncrypt(String input, String key) throws GeneralSecurityException {
		try {
			return encodeHex(aesEncrypt(input.getBytes(DEFAULT_URL_ENCODING), decodeHex(key)));
		} catch (UnsupportedEncodingException e) {
			return "";
		}
	}

	/**
	 * 使用AES加密原始字符串.
	 * 
	 * @param input 原始输入字符数组
	 * @param key 符合AES要求的密钥
	 * @throws GeneralSecurityException 
	 */
	public static byte[] aesEncrypt(byte[] input, byte[] key) throws GeneralSecurityException {
		return aes(input, key, Cipher.ENCRYPT_MODE);
	}

	/**
	 * 使用AES加密原始字符串.
	 * 
	 * @param input 原始输入字符数组
	 * @param key 符合AES要求的密钥
	 * @param iv 初始向量
	 * @throws GeneralSecurityException 
	 */
	public static byte[] aesEncrypt(byte[] input, byte[] key, byte[] iv) throws GeneralSecurityException {
		return aes(input, key, iv, Cipher.ENCRYPT_MODE);
	}

	/**
	 * 使用AES解密字符串, 返回原始字符串.
	 * 
	 * @param input Hex编码的加密字符串
	 * @throws GeneralSecurityException 
	 */
	public static String aesDecrypt(String input) throws GeneralSecurityException {
		try {
			return new String(aesDecrypt(decodeHex(input), DEFAULT_KEY), DEFAULT_URL_ENCODING);
		} catch (UnsupportedEncodingException e) {
			return "";
		}
	}

	/**
	 * 使用AES解密字符串, 返回原始字符串.
	 * 
	 * @param input Hex编码的加密字符串
	 * @param key 符合AES要求的密钥
	 * @throws GeneralSecurityException 
	 */
	public static String aesDecrypt(String input, String key) throws GeneralSecurityException {
		try {
			return new String(aesDecrypt(decodeHex(input), decodeHex(key)), DEFAULT_URL_ENCODING);
		} catch (UnsupportedEncodingException e) {
			return "";
		}
	}

	/**
	 * 使用AES解密字符串, 返回原始字符串.
	 * 
	 * @param input Hex编码的加密字符串
	 * @param key 符合AES要求的密钥
	 * @throws GeneralSecurityException 
	 */
	public static byte[] aesDecrypt(byte[] input, byte[] key) throws GeneralSecurityException {
		return aes(input, key, Cipher.DECRYPT_MODE);
	}

	/**
	 * 使用AES解密字符串, 返回原始字符串.
	 * 
	 * @param input Hex编码的加密字符串
	 * @param key 符合AES要求的密钥
	 * @param iv 初始向量
	 * @throws GeneralSecurityException 
	 */
	public static byte[] aesDecrypt(byte[] input, byte[] key, byte[] iv) throws GeneralSecurityException {
		return aes(input, key, iv, Cipher.DECRYPT_MODE);
	}

	/**
	 * 使用AES加密或解密无编码的原始字节数组, 返回无编码的字节数组结果.
	 * 
	 * @param input 原始字节数组
	 * @param key 符合AES要求的密钥
	 * @param mode Cipher.ENCRYPT_MODE 或 Cipher.DECRYPT_MODE
	 * @throws GeneralSecurityException 
	 */
	private static byte[] aes(byte[] input, byte[] key, int mode) throws GeneralSecurityException {
		SecretKey secretKey = new SecretKeySpec(key, AES);
		Cipher cipher = Cipher.getInstance(AES);
		cipher.init(mode, secretKey);
		return cipher.doFinal(input);
	}

	/**
	 * 使用AES加密或解密无编码的原始字节数组, 返回无编码的字节数组结果.
	 * 
	 * @param input 原始字节数组
	 * @param key 符合AES要求的密钥
	 * @param iv 初始向量
	 * @param mode Cipher.ENCRYPT_MODE 或 Cipher.DECRYPT_MODE
	 * @throws GeneralSecurityException
	 */
	private static byte[] aes(byte[] input, byte[] key, byte[] iv, int mode) throws GeneralSecurityException {
		SecretKey secretKey = new SecretKeySpec(key, AES);
		IvParameterSpec ivSpec = new IvParameterSpec(iv);
		Cipher cipher = Cipher.getInstance(AES_CBC);
		cipher.init(mode, secretKey, ivSpec);
		return cipher.doFinal(input);
	}

	/**
	 * 生成AES密钥,返回字节数组, 默认长度为128位(16字节).
	 * @throws GeneralSecurityException 
	 */
	public static String generateAesKeyString() throws GeneralSecurityException {
		return encodeHex(generateAesKey(DEFAULT_AES_KEYSIZE));
	}

	/**
	 * 生成AES密钥,返回字节数组, 默认长度为128位(16字节).
	 * @throws GeneralSecurityException 
	 */
	public static byte[] generateAesKey() throws GeneralSecurityException {
		return generateAesKey(DEFAULT_AES_KEYSIZE);
	}

	/**
	 * 生成AES密钥,可选长度为128,192,256位.
	 * @throws GeneralSecurityException
	 */
	public static byte[] generateAesKey(int keysize) throws GeneralSecurityException {
		KeyGenerator keyGenerator = KeyGenerator.getInstance(AES);
		keyGenerator.init(keysize);
		SecretKey secretKey = keyGenerator.generateKey();
		return secretKey.getEncoded();
	}

	/**
	 * 生成随机向量,默认大小为cipher.getBlockSize(), 16字节.
	 */
	public static byte[] generateIV() {
		byte[] bytes = new byte[DEFAULT_IVSIZE];
		random.nextBytes(bytes);
		return bytes;
	}

	/**
	 * Hex编码.
	 */
	public static String encodeHex(byte[] input) {
		return new String(Hex.encodeHex(input));
	}

	/**
	 * Hex解码.
	 */
	public static byte[] decodeHex(String input) {
		try {
			return Hex.decodeHex(input.toCharArray());
		} catch (DecoderException e) {
			throw new RuntimeException(e);
		}
	}
}





package com.sdhsie.web.service;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.HttpParams;
import org.apache.http.util.EntityUtils;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.GeneralSecurityException;

/**
 * @author jingwei.sun
 * @Company AutoNavi Co.,Ltd.
 * @date 2017/11/3 下午5:14
 */
public class EventPushDemo {
    public static void main(String[] args) throws Exception {
        String url = "http://localhost:8080/event/receive/standard";

        String channel = "test";
        String key = "NTljZDI4slslslslsls";
        EventPushDemo eventPushDemo = new EventPushDemo();

        eventPushDemo.pushJson(url, channel, key);
    }

    public void pushJson(String url, String channel, String key) throws Exception {
        String _url = url + "/json?channel=" + channel;

        String sourceId = "YTllllTU0";
        String id = "test0000001";
        //计算签名
        String temp = channel + sourceId + id + "@" + key;
        String sign = DigestUtils.md5Hex(temp);

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("sign", sign);

        JSONArray jsonArray = new JSONArray();

        int stateFlag = 0;
        int type = 101;
        Integer subType = null;
        Integer cityCode = null;
        String roadName = null;
        String direction = null;
        int locType = 1;
        String[] loc = new String[]{"115.211223,39.232321", "115.342123,39.421123"};
        String[][] locs = null;
        int[] lanes = null;
        int[] tollLanes = null;
        Integer level = null;
        Integer daySel = null;
        int startDate = 152123123;
        Integer startTime = 1321;
        Integer endDate = null;
        Integer endTime = null;
        int[][] times = null;
        String desc = "test desc事实上test";
        JSONObject disposition = null;
        int infoSourceType = 1;
        String picUrl = null;
        String audioUrl = null;
        String videoUrl = null;
        JSONObject eventJson = helpEventJson(sourceId, id, stateFlag, type, subType, cityCode, roadName, direction, locType, loc, locs, lanes, tollLanes, level, daySel, startDate, startTime, endDate, endTime, times, desc, disposition, infoSourceType, picUrl, audioUrl, videoUrl);
        jsonArray.add(eventJson);

        id = "test0000002";
        type = 301;
        JSONObject eventJson2 = helpEventJson(sourceId, id, stateFlag, type, subType, cityCode, roadName, direction, locType, loc, locs, lanes, tollLanes, level, daySel, startDate, startTime, endDate, endTime, times, desc, disposition, infoSourceType, picUrl, audioUrl, videoUrl);
        jsonArray.add(eventJson2);


        jsonObject.put("data", jsonArray);
        String jsonStr = jsonObject.toJSONString();

        // 数据加密
        byte[] aesEncrypt = helpAESEncode(jsonStr, key);
        // 发送数据
        String s = helpSendPost(_url, aesEncrypt, key);
        System.out.println("event push json, response:" + s);
    }

    private JSONObject helpEventJson(String sourceId, String id, int stateFlag, int type, Integer subType, Integer cityCode, String roadName, String direction, int locType, String[] loc, String[][] locs, int[] lanes, int[] tollLanes, Integer level, Integer daySel, int startDate, Integer startTime, Integer endDate, Integer endTime, int[][] times, String desc, JSONObject disposition, int infoSourceType, String picUrl, String audioUrl, String videoUrl) throws Exception {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("sourceId", sourceId);
        jsonObject.put("id", id);
        jsonObject.put("stateFlag", stateFlag);
        jsonObject.put("type", type);
        jsonObject.put("subType", subType);
        jsonObject.put("cityCode", cityCode);

        JSONObject position = helpEventPositionJson(roadName, direction, locType, loc, locs, lanes, tollLanes);
        jsonObject.put("position", position);

        if (level != null) {
            jsonObject.put("level", level);
        }

        JSONObject duration = helpEventDurationJson(daySel, startDate, startTime, endDate, endTime, times);
        jsonObject.put("duration", duration);

        jsonObject.put("desc", desc);

        if (disposition != null) {
            jsonObject.put("disposition", disposition);
        }

        jsonObject.put("infoSourceType", infoSourceType);
        jsonObject.put("picUrl", picUrl);
        jsonObject.put("audioUrl", audioUrl);
        jsonObject.put("videoUrl", videoUrl);

        return jsonObject;
    }

    private JSONObject helpEventPositionJson(String roadName, String direction, int locType, String[] loc, String[][] locs, int[] lanes, int[] tollLanes) throws Exception {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("roadName", roadName);
        jsonObject.put("direction", direction);
        jsonObject.put("locType", locType);
        if (!ArrayUtils.isEmpty(loc)) {
            jsonObject.put("loc", loc);
        } else if (!ArrayUtils.isEmpty(locs)) {
            jsonObject.put("locs", locs);
        } else {
            throw new Exception("position loc and locs is all empty.");
        }
        if (!ArrayUtils.isEmpty(lanes)) {
            jsonObject.put("lanes", lanes);
        }
        if (!ArrayUtils.isEmpty(tollLanes)) {
            jsonObject.put("tollLanes", tollLanes);
        }

        return jsonObject;
    }

    private JSONObject helpEventDurationJson(Integer daySel, int startDate, Integer startTime, Integer endDate, Integer endTime, int[][] times) throws Exception {
        if (daySel == null || daySel.intValue() == 0) {
            if (startTime == null) {
                throw new Exception("event duration daySel is 0, startTime must not empty.");
            }
        } else if (daySel.intValue() == 1) {
            if (ArrayUtils.isEmpty(times)) {
                throw new Exception("event duration daySel is 1, times must not empty.");
            }
        } else {
            throw new Exception("event duration daySel is error:" + daySel);
        }

        JSONObject jsonObject = new JSONObject();
        if (daySel != null) {
            jsonObject.put("daySel", daySel);
        }

        jsonObject.put("startDate", startDate);
        if (startTime != null) {
            jsonObject.put("startTime", startTime);
        }
        if (endDate != null) {
            jsonObject.put("endDate", endDate);
        }
        if (endTime != null) {
            jsonObject.put("endTime", endTime);
        }
        if (times != null) {
            jsonObject.put("times", times);
        }

        return jsonObject;
    }

    private JSONObject helpEventDispositionJson(int type, int[] restrictions, String other, String roadName, String direction, int locType, String[] loc, String[][] locs, int[] lanes, int[] tollLanes, Integer level, Integer daySel, int startDate, Integer startTime, Integer endDate, Integer endTime, int[][] times, int[] promptTypes, String[] promptConts) throws Exception {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("type", type);
        jsonObject.put("restrictions", restrictions);
        jsonObject.put("other", other);

        JSONObject position = helpEventPositionJson(roadName, direction, locType, loc, locs, lanes, tollLanes);
        jsonObject.put("range", position);

        JSONObject duration = helpEventDurationJson(daySel, startDate, startTime, endDate, endTime, times);
        jsonObject.put("duration", duration);

        if (!ArrayUtils.isEmpty(promptTypes) && !ArrayUtils.isEmpty(promptConts)) {
            JSONObject prompt = new JSONObject();
            prompt.put("types", promptTypes);
            prompt.put("conts", promptConts);
            jsonObject.put("prompt", prompt);
        }

        return jsonObject;
    }

    public static byte[] helpAESEncode(String jsonStr, String key) {
        byte[] aesEncrypt = null;
        try {
            byte[] bytesKey = key.getBytes("UTF-8");
            aesEncrypt = Cryptos.aesEncrypt(jsonStr.getBytes("UTF-8"), bytesKey);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return aesEncrypt;
    }

    private byte[] helpAESEncode(byte[] data, String key) {
        byte[] aesEncrypt = null;
        try {
            byte[] bytesKey = key.getBytes("UTF-8");
            aesEncrypt = Cryptos.aesEncrypt(data, bytesKey);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return aesEncrypt;
    }

    public static String helpSendPost(String _url, byte[] aesEncrypt, String key) {
        if (aesEncrypt != null) {
            // 发送数据
            try {
                byte[] bytes = sendPost(_url, aesEncrypt, "UTF-8");
                // 解密返回内容
                String s = helpParse(bytes, key);
                return s;
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            System.err.println("AES encrypt failed.");
        }
        return null;
    }

    private static final int CONNECTION_TIMEOUT = 3000;
    private static final int SO_TIMEOUT = 30000;

    public static byte[] sendPost(String url, byte[] datas, String encoding) throws ClientProtocolException,
            IOException, Exception {
        DefaultHttpClient httpclient = new DefaultHttpClient();
        HttpParams httpParams = new BasicHttpParams();
        httpParams.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, CONNECTION_TIMEOUT);
        httpParams.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, SO_TIMEOUT);
        // 在提交请求之前 测试连接是否可用
        httpParams.setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, true);
        httpclient.setParams(httpParams);

        HttpPost httpPost = new HttpPost(url);

        InputStreamEntity reqEntity = new InputStreamEntity(new ByteArrayInputStream(datas), -1);

        httpPost.setEntity(reqEntity);

        try {
            HttpResponse res = httpclient.execute(httpPost);
            int response_code = res.getStatusLine().getStatusCode();// 返回状态码
            byte[] responseContent = null;// 响应内容
            if (response_code == HttpStatus.SC_OK) {
                HttpEntity resEntity = res.getEntity();
                responseContent = EntityUtils.toByteArray(resEntity);
                return responseContent;
            } else {
                HttpEntity resEntity = res.getEntity();
                responseContent = EntityUtils.toByteArray(resEntity);
                throw new Exception("http response code:" + response_code + ",content="
                        + new String(responseContent, encoding));
            }
        } finally {
            httpclient.getConnectionManager().shutdown();
        }
    }

    private static String helpParse(byte[] respStr, String key) {
        String re = null;
        try {
            re = new String(respStr, "UTF-8");
            byte[] bytesKey = key.getBytes("UTF-8");
            byte[] byteArray = respStr;
            byte[] aesDecrypt = Cryptos.aesDecrypt(byteArray, bytesKey);
            String decryptStr = new String(aesDecrypt, "UTF-8");
            return decryptStr;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return re;
    }
}




//调用：
public static void main(String[] args) {
        test();
    }

    public static void test() {
        String channel = "event_shandonghiway", sourceId = "event_shandonghiway", id = "8692", key = "irxny2gpv51Hg20I";
        //签名
        String sign = DigestUtil.md5Hex(channel + sourceId + id + "@" + key);
        cn.hutool.json.JSONObject obj = new cn.hutool.json.JSONObject();
        obj.put("sign", sign);
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key.getBytes());

        String url = "http://td.amap.com/event/receive/standard/json?channel=" + channel;

        JSONObject json = new JSONObject();
        json.put("sign", obj.get("sign"));
        JSONArray array = new JSONArray();
        JSONObject data = new JSONObject();
        data.put("sourceId", sourceId);
        data.put("stateFlag", 2);
        data.put("id", id);
        array.add(data);
        json.put("data", array);
        //json.put("data", aes.encryptHex(JSONUtil.toJsonStr(array)));
        String str = JSON.toJSONString(json);

        byte[] aesEncrypt = helpAESEncode(str, key);
        byte[] bytess = aes.encrypt(str);

        HttpRequest httpReq = HttpUtil.createPost("http://td.amap.com/event/receive/standard/json?channel=" + channel);

        Map<String, String> map = MapUtil.newHashMap();
        map.put("Transfer-Encoding", "chunked");
        map.put("Host", "td.amap.com");
        map.put("Connection", "Keep-Alive");
        httpReq.addHeaders(map);


        /*byte[] resultArr = httpReq.body(aesEncrypt).execute().bodyBytes();
        String s = helpSendPost(url, aesEncrypt, key);
        String str1 = aes.decryptStr(resultArr);*/
        String s = helpSendPost(url, aesEncrypt, key);
        System.out.println("============str=" + s + "===========");
    }

    @RequestMapping("/test1")
    @ResponseBody
    public R test1(HttpServletRequest request) throws IOException {
        //方式一，通过body提交
        JSONObject json = new JSONObject();
        json.put("user", "aaaaaaaaa");
        String jj = JSON.toJSONString(json);
        HttpUtil.post("http://localhost:11001/bigdata/external/test", jj);

        //通过map参数提交
        Map<String, Object> map = MapUtil.newHashMap();
        map.put("aaa", 1);
        map.put("bbbb", "bbbb");
        HttpUtil.post("http://localhost:11001/bigdata/external/test", map);
        return R.ok();
    }

    /**
    可以使用postman 软件调试 调用接口
    */
    @RequestMapping("/test")
    @ResponseBody
    public R test(HttpServletRequest request) throws IOException {
        //方式一，从request body中取值
        BufferedReader br = request.getReader();
        String str = "";
        String listString = "";
        while ((str = br.readLine()) != null) {
            listString += str;
        }
        JSONObject oj = JSON.parseObject(listString);

        //方式二、接收参数
        Map<String, String[]> params = request.getParameterMap(); 
        return R.ok(oj);

    }
     public R pushGDData(HttpServletRequest request) throws Exception {
        String channel = "xxx", sourceId = "xxx", id = "", key = "xxx";
        //签名 md5Hex
        String sign = DigestUtil.md5Hex(channel + sourceId + id + "@" + key);
        JSONObject obj = new JSONObject();
        obj.put("sign", sign);
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES,key.getBytes());

        //获取数据
        Map<String, String[]> params = request.getParameterMap();
        String[] gdArrStr = params.get("gdArr");
        JSONArray jsonObjList = JSONUtil.parseArray(gdArrStr[0]);
        obj.put("data", jsonObjList);
        System.out.println("=========obj="+obj+"========");
        String content = aes.encryptHex(JSONUtil.toJsonStr(obj));
        System.out.println("=============content="+content+"=============");
        HttpRequest httpReq = HttpUtil.createPost("http://td.amap.com/event/receive/standard/json?channel=" + channel);
        Map<String, String> map= Maps.newHashMap();
        map.put("Transfer-Encoding","chunked");
        map.put("Connection","Keep-Alive");
        httpReq.addHeaders(map);
        //httpost 返回byte[] 数组，hutool 用 bodyBytes() 接收
        byte[] resultArr=httpReq.body(content.getBytes()).execute().bodyBytes();
        String str = aes.decryptStr(resultArr);
        System.out.println("============str=" + str + "===========");
        return R.ok();
    }



//通过post请求
    public static byte[] post(String path, byte[] data) {
        try {
            URL url = new URL(path);
            //打开和url之间的连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            PrintWriter out = null;
            //设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("Transfer-Encoding","chunked");
//            conn.setRequestProperty("Host", "http://td.amap.com");
            conn.setRequestProperty("Connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            //设置是否向httpUrlConnection输出，设置是否从httpUrlConnection读入，此外发送post请求必须设置这两个
            //最常用的Http请求无非是get和post，get请求可以获取静态页面，也可以把参数放在URL字串后面，传递给servlet，
            //post与get的 不同之处在于post的参数不是放在URL字串里面，而是放在http请求的正文内。
            conn.setDoOutput(true);
            conn.setDoInput(true);
            //获取URLConnection对象对应的输出流
            out = new PrintWriter(conn.getOutputStream());
            //发送请求参数即数据
            out.print(data);
            //缓冲数据
            out.flush();
            //获取URLConnection对象对应的输入流
            InputStream is = conn.getInputStream();
            int total = 0;
            int len ;
            int contentLength=  conn.getContentLength();
            byte[] respBuffer = new byte[contentLength];
            byte[] respBuffer1 = new byte[contentLength];
            //构造一个字符流缓存

            String str = "";
            while ((len = is.read(respBuffer)) != -1 ){
                for (int i=0;i<len;i++){
                    respBuffer1[total+i] = respBuffer[i];
                }
                total = total + len;
            }
            //关闭流
            is.close();
            //断开连接，最好写上，disconnect是在底层tcp socket链接空闲时才切断。如果正在被其他线程使用就不切断。
            //固定多线程的话，如果不disconnect，链接会增多，直到收发不出信息。写上disconnect后正常一些。
            conn.disconnect();
            return respBuffer1;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

<div id="videoDiv" style="display:none;" > 
				<!-- 
					<video  style="width:700px;height:500px;" id="videoElement" crossorigin="*"  autoplay="true"></video>
				 -->
					<video  style="width:99%;height:98%;" id="videoElement" crossorigin="*"  autoplay="true"></video>
				 
				</div>
				
                <div class="img_show_wrap" style="display:none;">
                 <!-- 
                 <a id="screen_shot_btn"  class="screen_shot_btn" href="javascript:">截图</a>
                  -->
                 <a id="screen_save_btn" class="screen_save_btn" href="javascript:">截图</a>
                  <canvas width="720" height="450" id="V2I_canvas" style="display:none;"></canvas>
                  <img id="image_el" src=""  style="display:none;">
                </div>
		


var vm = new Vue({
			el: '#bigdataApp',
			data: {
				showLoading: false 
			},
			methods: {
				 play:function (){ 
				     if (flvjs.isSupported()) {
				    	//  alert("开始播放")
				         var videoElement = document.getElementById('videoElement');
				    	  flvPlayer= flvjs.createPlayer({//创建一个新的flv播放器对象
				             type: 'flv',
				             isLive: true,
				             //url: 'ws://10.190.60.60:8081/websocket/42'
				             //url: 'ws://10.16.10.19:9002/42'
							   url:'ws://10.187.19.221:9002/42'
				         }, {
				             enableWorker: true,
				             autoCleanupSourceBuffer: true,
				             autoCleanupMaxBackwardDuration: 10,
				             autoCleanupMinBackwardDuration: 10,
				             enableStashBuffer: false,
				             fixAudioTimestampGap: false,
				             stashInitialSize: 0
				         });
				         flvPlayer.attachMediaElement(videoElement);
				         flvPlayer.load();//载入视频
				         console.info("================播放00==========");
				         flvPlayer.play();//播放视频，如果不想要自动播放，去掉本行
				         console.info("================播放11==========");
				     }
				 },
				 pausePlay:function(){
					 flvPlayer.pause();
				 },
				 stopPlay:function(){
					    flvPlayer.pause();
						flvPlayer.unload();
						flvPlayer.detachMediaElement();
						flvPlayer.destroy();
						flvPlayer = null;
				 }
			}
		});	


	  var flvPlayer; 
    var mapObj;
    var marker;
	function mapInit() {
		mapObj = new AMap.Map("mapDiv", {
			// 设置中心点
			center: [118.227136, 36.407822],
			zoom: 8,
			dragEnable: true,
			zoomEnable: true
		});
		 //添加一个marker
		 marker = new AMap.Marker({
            icon: "//a.amap.com/jsapi_demos/static/demo-center/icons/poi-marker-default.png",
            position: [117.058601,36.636697],
            offset: new AMap.Pixel(-13, -30)
        });
        marker.setMap(mapObj); 
		AMap.event.addListener(marker, 'click', function() { 
		      layer.open({
                  type: 1,
                  content:$("#videoDiv") ,
                  btn: ['播放','关闭','截屏'],
                  area: ['720px','520px'],
                  title: '实时视频',
                  scrollbar:false,
                  yes: function () {//第一个按钮事件
                	  vm.play();
                  },//第二个按钮事件
                  btn2:function(){  
                	  vm.stopPlay();
                      layer.closeAll(); 
                  },
                  btn3:function(){  
                	  htmlToImage(); 
                	  $("#image_el").attr("src", mySrc); 
                	   if ($("#image_el").attr("src") != "") {  
//模拟<a> 点击事件
                          $("#screen_save_btn")[0].click(); 
                        
                      } else {
                          alert("内容为空");
                      }
                	  return false;//开启该代码可禁止点击该按钮关闭
                	 
                  }
              });
		      vm.play();
		});
	}
	mapInit();


  var mySrc = "";

//视频转图片
      function htmlToImage() {
          var canvas = document.getElementById("V2I_canvas");
          if (!canvas.getContext) {
              alert("您的浏览器暂不支持canvas");
              return false;
          } else {
              var context = canvas.getContext("2d");
              var video = document.getElementById("videoElement");
              context.drawImage(video, 0, 0, canvas.width, canvas.height);
              return mySrc = canvas.toDataURL("image/png");
          }
      }

      $("#screen_save_btn").click(function() {
          htmlToImage();
          if ($("#image_el").attr("src") != "") {
              downloadFile(mySrc);
          } else {
              alert("内容为空");
          }
      })
      //下载图片
      function downloadFile(src) {
    	  //获取当前时间 
    	 var mytime=new Date().Format("yyyyMMddHHmmss");
          var triggerDownload = $("#screen_save_btn").attr("href", src).attr("download", "视频截屏"+mytime+".png"); 
      }
      
      



//或者使用下面的函数



 var mytime=new Date().Format("yyyyMMddHHmmss");
  funDownload("视频截图11"+mytime+".png");


 function  funDownload(filename) {
             	  	    // 创建隐藏的可下载链接
             	  	    var eleLink = document.createElement('a');
             	  	    eleLink.download = filename;
             	  	    eleLink.style.display = 'none';
             	  	    eleLink.classList.add();
             	  	    // 图片转base64地址
             	  	    var canvas = document.createElement('canvas');
             	  	    var context = canvas.getContext('2d');
             	  	 
             	  	   var video = document.getElementById("videoElement"); 
             	  	    var width =video.videoWidth;
             		    var height = video.videoHeight;
             	  	    console.info("====width="+width+"=======height="+height+"==========");
             	     	 canvas.width=width;
             	  	    canvas.height=height;
             	  	    context.drawImage(video, 0, 0,720, 450);
             	  	    // 如果是PNG图片，则canvas.toDataURL('image/png')
             	  	   // eleLink.href = canvas.toDataURL('image/jpeg');
             	  	     eleLink.href = canvas.toDataURL('image/png');
             	  	    // 触发点击
             	  	    document.body.appendChild(eleLink);
             	  	    eleLink.click();
             	  	    // 然后移除
             	  	    document.body.removeChild(eleLink);
             	} 

package com.sdhsie.modules.mapweather.utils;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;


public class ExcelUtil{

	public static void main(String[] args) {
	    String path = "F:\\fog.xlsx";
        try {
            List<List<String>> result = new ExcelUtil().readXlsx(path);
            System.out.println(result.size());
            for (int i = 0; i < result.size(); i++) {
                List<String> model = result.get(i);
                System.out.println("orderNum:" + model.get(0) + "--> orderAmount:" + model.get(1));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

	}
	
	 // @描述：是否是2003的excel，返回true是2003
    public static boolean isExcel2003(String filePath) {
        return filePath.matches("^.+\\.(?i)(xls)$");
    }
 
    //@描述：是否是2007的excel，返回true是2007
    public static boolean isExcel2007(String filePath) {
        return filePath.matches("^.+\\.(?i)(xlsx)$");
    } 
	/**
     * 
    * @Title: readXls 
    * @Description: 处理xls文件
    * @param @param path
    * @param @return
    * @param @throws Exception    设定文件 
    * @return List<List<String>>    返回类型 
    * @throws
    * 
    * 从代码不难发现其处理逻辑：
    * 1.先用InputStream获取excel文件的io流
    * 2.然后穿件一个内存中的excel文件HSSFWorkbook类型对象，这个对象表示了整个excel文件。
    * 3.对这个excel文件的每页做循环处理
    * 4.对每页中每行做循环处理
    * 5.对每行中的每个单元格做处理，获取这个单元格的值
    * 6.把这行的结果添加到一个List数组中
    * 7.把每行的结果添加到最后的总结果中
    * 8.解析完以后就获取了一个List<List<String>>类型的对象了
    * 
     */
    private List<List<String>> readXls(String path) throws Exception {
        InputStream is = new FileInputStream(path);
        // HSSFWorkbook 标识整个excel
        HSSFWorkbook hssfWorkbook = new HSSFWorkbook(is);
        List<List<String>> result = new ArrayList<List<String>>();
        int size = hssfWorkbook.getNumberOfSheets();
        // 循环每一页，并处理当前循环页
        for (int numSheet = 0; numSheet < size; numSheet++) {
            // HSSFSheet 标识某一页
            HSSFSheet hssfSheet = hssfWorkbook.getSheetAt(numSheet);
            if (hssfSheet == null) {
                continue;
            }
            // 处理当前页，循环读取每一行
            for (int rowNum = 1; rowNum <= hssfSheet.getLastRowNum(); rowNum++) {
                // HSSFRow表示行
                HSSFRow hssfRow = hssfSheet.getRow(rowNum);
                int minColIx = hssfRow.getFirstCellNum();
                int maxColIx = hssfRow.getLastCellNum();
                List<String> rowList = new ArrayList<String>();
                // 遍历改行，获取处理每个cell元素
                for (int colIx = minColIx; colIx < maxColIx; colIx++) {
                    // HSSFCell 表示单元格
                    HSSFCell cell = hssfRow.getCell(colIx);
                    if (cell == null) {
                        continue;
                    }
                    rowList.add(getStringVal(cell));
                }
                result.add(rowList);
            }
        }
        return result;
    }

    /**
     * 
    * @Title: readXlsx 
    * @Description: 处理Xlsx文件
    * @param @param path
    * @param @return
    * @param @throws Exception    设定文件 
    * @return List<List<String>>    返回类型 
    * @throws
     */
    private List<List<String>> readXlsx(String path) throws Exception {
        InputStream is = new FileInputStream(path);
        XSSFWorkbook xssfWorkbook = new XSSFWorkbook(is);
        List<List<String>> result = new ArrayList<List<String>>();
        // 循环每一页，并处理当前循环页
        for (XSSFSheet xssfSheet : xssfWorkbook) {
            if (xssfSheet == null) {
                continue;
            }
            // 处理当前页，循环读取每一行
            for (int rowNum = 1; rowNum <= xssfSheet.getLastRowNum(); rowNum++) {
                XSSFRow xssfRow = xssfSheet.getRow(rowNum);
                int minColIx = xssfRow.getFirstCellNum();
                int maxColIx = xssfRow.getLastCellNum();
                List<String> rowList = new ArrayList<String>();
                for (int colIx = minColIx; colIx < maxColIx; colIx++) {
                    XSSFCell cell = xssfRow.getCell(colIx);
                    if (cell == null) {
                        continue;
                    }
                    rowList.add(cell.toString());
                }
                result.add(rowList);
            }
        }
        return result;
    }
    /**
     * 改造poi默认的toString（）方法如下
    * @Title: getStringVal 
    * @Description: 1.对于不熟悉的类型，或者为空则返回""控制串
    *               2.如果是数字，则修改单元格类型为String，然后返回String，这样就保证数字不被格式化了
    * @param @param cell
    * @param @return    设定文件 
    * @return String    返回类型 
    * @throws
     */
    public static String getStringVal(HSSFCell cell) {
        switch (cell.getCellType()) {
        case Cell.CELL_TYPE_BOOLEAN:
            return cell.getBooleanCellValue() ? "TRUE" : "FALSE";
        case Cell.CELL_TYPE_FORMULA:
            return cell.getCellFormula();
        case Cell.CELL_TYPE_NUMERIC:
            cell.setCellType(Cell.CELL_TYPE_STRING);
            return cell.getStringCellValue();
        case Cell.CELL_TYPE_STRING:
            return cell.getStringCellValue();
        default:
            return "";
        }
    }
}

当不存在目录aa文件夹时：

File file1=new File("/aa");

Boolean aa=file.mkdir();// true

File file1=new File("/aa/bb");

Boolean bb=file.mkdir();// false

Boolean bbc=file.mkdirs();// ture

mkdir()和mkdirs()的区别：

 

mkdir()  创建此抽象路径名指定的目录。如果父目录不存在则创建不成功。

mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。

 

创建文件

 

File file3=new File("/aa/text.tx");
Boo1ean b=file3.createNewFile();//如果目录aa存在返回true，不存在就返回false

//一，导入需要的jar包
axis.jar 、wsdl4j-1.5.1.jar 、、、

//二：配置web.xml


<servlet>
 <display-name>Apache-Axis Servlet</display-name>
    <servlet-name>AxisServlet</servlet-name>
   
    <servlet-class>
        org.apache.axis.transport.http.AxisServlet
    </servlet-class>
  </servlet>

  <servlet>
  <display-name>Axis Admin Servlet</display-name>
    <servlet-name>AdminServlet</servlet-name>
    
    <servlet-class>
        org.apache.axis.transport.http.AdminServlet
    </servlet-class>
    <load-on-startup>100</load-on-startup>
  </servlet>

  <servlet>
  <display-name>SOAPMonitorService</display-name>
    <servlet-name>SOAPMonitorService</servlet-name>
    
    <servlet-class>
        org.apache.axis.monitor.SOAPMonitorService
    </servlet-class>
    <init-param>
      <param-name>SOAPMonitorPort</param-name>
      <param-value>5001</param-value>
    </init-param>
    <load-on-startup>100</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>AxisServlet</servlet-name>
    <url-pattern>/servlet/AxisServlet</url-pattern>
  </servlet-mapping>

  <servlet-mapping>
    <servlet-name>AxisServlet</servlet-name>
    <url-pattern>*.jws</url-pattern>
  </servlet-mapping>

  <servlet-mapping>
    <servlet-name>AxisServlet</servlet-name>
    <url-pattern>/services/*</url-pattern>
  </servlet-mapping>

  <servlet-mapping>
    <servlet-name>SOAPMonitorService</servlet-name>
    <url-pattern>/SOAPMonitor</url-pattern>
  </servlet-mapping>
  
  <mime-mapping>
    <extension>wsdl</extension>
     <mime-type>text/xml</mime-type>
  </mime-mapping>
  

  <mime-mapping>
    <extension>xsd</extension>
    <mime-type>text/xml</mime-type>
  </mime-mapping>

//三：配置server-config.wsdd文件  在WEB-INF下添加WebService核心文件server-config.wsdd

<?xml version="1.0" encoding="UTF-8"?>
<deployment name="defaultClientConfig"
            xmlns="http://xml.apache.org/axis/wsdd/"
            xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"
            xmlns:handler="http://xml.apache.org/axis/wsdd/providers/handler">

 <globalConfiguration>
   <parameter name="disablePrettyXML" value="true"/>
   <parameter name="dotNetSoapEncFix" value="true"/>
   <parameter name="enableNamespacePrefixOptimization" value="false"/>
   <requestFlow>
     <handler type="java:org.apache.axis.handlers.JWSHandler">
        <parameter name="scope" value="session"/>
     </handler>
     <handler type="java:org.apache.axis.handlers.JWSHandler">
        <parameter name="scope" value="request"/>
        <parameter name="extension" value=".jwr"/>
     </handler>
     <!-- uncomment this if you want the SOAP monitor -->
     <!--
     <handler type="java:org.apache.axis.handlers.SOAPMonitorHandler"/>
     -->
   </requestFlow>
   <!-- uncomment this if you want the SOAP monitor -->
   <!--
   <responseFlow>
     <handler type="java:org.apache.axis.handlers.SOAPMonitorHandler"/>
   </responseFlow>
   -->
 </globalConfiguration>

 <handler type="java:org.apache.axis.handlers.http.URLMapper" name="URLMapper"/>
 <handler type="java:org.apache.axis.transport.local.LocalResponder" name="LocalResponder"/>
 <handler type="java:org.apache.axis.handlers.SimpleAuthenticationHandler" name="Authenticate"/>
  <!-- 核心重点：服务发布，name：表示发布的service名  WeatherService--> 
 <service name="WeatherService" provider="java:RPC">
  <parameter name="allowedMethods" value="*"/>
  <!-- 发布的service接口类 -->
  <parameter name="className" value="com.bst.dp.shiro.controller.WebServiceController"/>
 </service>
 
 <transport name="http">
  <parameter name="qs:list" 
               value="org.apache.axis.transport.http.QSListHandler"/>
  <parameter name="qs:method" 
               value="org.apache.axis.transport.http.QSMethodHandler"/>
  <parameter name="qs:wsdl" 
               value="org.apache.axis.transport.http.QSWSDLHandler"/>
  <requestFlow>
   <handler type="URLMapper"/>
   <handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler"/>
  </requestFlow>
 </transport>

 <transport name="local">
  <responseFlow>
   <handler type="LocalResponder"/>
  </responseFlow>
 </transport>
</deployment>

//四： 调用WebServices 接口

http://127.0.0.1:8080/services/WeatherService?wsdl

//五：代码测试
public class WebServiceUtil {

	public static void main(String[] args) throws ServiceException {
		 String endpoint="http://127.0.0.1:8080/services/WeatherService";
		 Service service=new Service();
		 Call call=(Call)service.createCall();
		 try {
			URL url=new URL(endpoint);
			call.setTargetEndpointAddress(url);
			call.setOperation("login");
			System.out.println(call.invoke(new Object[] {"admin","1111",""}));
		} catch (MalformedURLException | RemoteException e) { 
			e.printStackTrace();
		}
	}

}

/**


db.collection.find(query, projection)
query ：可选，使用查询操作符指定查询条件
projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。


MongoDB 查询文档使用 find() 方法。

find() 方法以非结构化的方式来显示所有文档。
pretty() 方法以格式化的方式来显示所有文档。
 findOne() 方法，它只返回一个文档。

MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规 SQL 的 AND 条件。

等于 {<key>:<value>} db.col.find({"by":"菜鸟教程"}).pretty() where by = '菜鸟教程' 
小于 {<key>:{$lt:<value>}} db.col.find({"likes":{$lt:50}}).pretty() where likes < 50 
小于或等于 {<key>:{$lte:<value>}} db.col.find({"likes":{$lte:50}}).pretty() where likes <= 50 
大于 {<key>:{$gt:<value>}} db.col.find({"likes":{$gt:50}}).pretty() where likes > 50 
大于或等于 {<key>:{$gte:<value>}} db.col.find({"likes":{$gte:50}}).pretty() where likes >= 50 
不等于 {<key>:{$ne:<value>}} db.col.find({"likes":{$ne:50}}).pretty() where likes != 50 

*/

db.getCollection('tableName).find({}).pretty()

db.getCollection('tableName').find({'列名':{$lt:value}}).pretty()


db.getCollection('tableName').findOne({'列名':{$lt:value}}).pretty()


/**
$or,
 
*/

db.getCollection('lhpDataWeatherStation').find( {
      $or:[
        {'pressure':977.43},{'pressure':977.32}
        ]
    })

/**
AND 和 OR 联合使用 
*/
db.getCollection('lhpDataWeatherStation').find( {
      $or:[
        {'pressure':977.43},{'pressure':977.32}
        ],
        'windSpeed':0.0
    })
/**
指定返回的键：_id 和 pointId
*/
db.getCollection('lhpDataWeatherStation').find( {
      $or:[
        {'pressure':977.43},{'pressure':977.32}
        ],
        'windSpeed':0.0
    },{'pointId':1})

/**
模糊查询

**/

db.getCollection('bstMessage').find({'messageContent':/K1441/}) //查询包含k1441
db.getCollection('bstMessage').find({'messageDescribe':/^空/})  //查询以“空” 开头的
db.getCollection('bstMessage').find({'messageDescribe':/米$/})  //查询以“米”结尾的

/***
SpringMVC 中，文件的上传，是通过 MultipartResolver 实现的。 所以，如果要实现文件的上传，只要在 spring-mvc.xml 中注册相应的 MultipartResolver 即可。

	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<property name="maxUploadSize" value="1000000000" />
	</bean>

MultipartResolver 的实现类有两个：

CommonsMultipartResolver
StandardServletMultipartResolver
两个的区别：

第一个需要使用 Apache 的 commons-fileupload 等 jar 包支持，但它能在比较旧的 servlet 版本中使用。
第二个不需要第三方 jar 包支持，它使用 servlet 内置的上传功能，但是只能在 Servlet 3 以上的版本使用。 
*/

//jsp

<input type="file" name="file" id="cover" value="选择文件" multiple="multiple">
<input type="file" name="pingfen" id="cover1" value="选择文件" multiple="multiple">

function upload(){
	var a=checkFileExt($('#cover').val(), ['csv']);
	var b=checkFileExt($('#cover1').val(), ['xlsx']);
	//判断上传文件格式 
	if(!a){
		alert("车辆明细表格式只支持.csv格式");
	};
	if(!b){
		alert("车辆综合评分表格式只支持.xlsx格式");
	};
	if(a && b){
		//var file=document.getElementById("cover").value;				
		$.ajaxFileUpload({
			 url:'../../lhp/fh/truck/alarm/upload?',
			 type: 'post',
             fileElementId: ['cover','cover1'],
             dataType: 'json',
             success: function (data) {
            	if("true" == data){
            		 alert("上传成功");
            	}
            	
             }
		 });
	}
}


//Java 
@RequestMapping("/upload")
	public String saveTruck(HttpServletRequest request,
			HttpServletResponse response) throws IOException, ParseException {
		PrintWriter out = response.getWriter();
		InputStream in = null;
		String alarmType = null;
		String address = null;	
		List<LhpFhTruckAlarmEntity> list = new ArrayList<LhpFhTruckAlarmEntity>();// 创建车辆报警集合用于封装对象
		CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());
	     if(multipartResolver.isMultipart(request)){
	    	 MultipartHttpServletRequest multiRequest = (MultipartHttpServletRequest) request;
	    	 MultipartFile multipartFile = multiRequest.getFile("file");//获取车辆报警明细的文件
	    	 MultipartFile multipartFile1 = multiRequest.getFile("pingfen");//获取车辆综合评分的文件	    	 
	    	 /********************车辆报警明细start***************************/
	    	 if (multipartFile != null) {
	    		 in = multipartFile.getInputStream();
	    		 InputStreamReader isr = new InputStreamReader(in);
	    		 BufferedReader br = new BufferedReader(isr);
	    		 String str = br.readLine();
	    		 while((str = br.readLine()) != null){
	    			 String[] strs = str.split(",");
	    			 String truckId = strs[0];
						String Type = strs[2];
												Double speed = Double.parseDouble(strs[4]);
						;						
						Date alarmTime=DateConvertUtils.parse(strs[5], "yyyy/MM/dd HH:mm:ss");
						if (strs.length == 7) {
							address = strs[6];
						} else {
							address = null;
						}						
						LhpFhTruckAlarmEntity alarm = new LhpFhTruckAlarmEntity(truckId,
								alarmType, speed, alarmTime, address);
						list.add(alarm);
	    		 }
	    		 
	    	 }
	    	 /********************车辆报警明细end**********************************/
	    	 /********************车辆综合评分start**********************************/
	    	 List<LhpFhTruckCourseEntity> courselist = new ArrayList<LhpFhTruckCourseEntity>();//创建车辆评分集合用于封装对象
	    	 if (multipartFile1 != null) {
	    		 in = multipartFile1.getInputStream();	    		 
	    		 XSSFWorkbook book = new XSSFWorkbook(in);
					LhpFhTruckCourseEntity model=null;
					// read the Sheet
					for (int numSheet = 0; numSheet < book.getNumberOfSheets(); numSheet++) {
						XSSFSheet sheet = book.getSheetAt(numSheet);
						if (null == sheet) {
							continue;
						}					
					for (int rowNum = 1; rowNum <= sheet.getLastRowNum(); rowNum++) {
						XSSFRow row = sheet.getRow(rowNum);												
						if(null != row && row.getCell(0)!=null && !row.getCell(0).equals("车牌号")){			
							XSSFCell truckId = row.getCell(0);
							XSSFCell course = row.getCell(3);
							XSSFCell deductKilo = row.getCell(4);
							XSSFCell fqpz = row.getCell(5);
							XSSFCell cjjk = row.getCell(6);
							XSSFCell cdpy = row.getCell(7);
							XSSFCell xrpz = row.getCell(8);
							XSSFCell cs = row.getCell(9);
							XSSFCell pljs = row.getCell(10);							
							model =new LhpFhTruckCourseEntity(truckId.toString(), Double.parseDouble(course.toString()),Double.parseDouble(deductKilo.toString()), fqpz.toString(), cjjk.toString(), cdpy.toString(), xrpz.toString(), cs.toString(), pljs.toString());
							courselist.add(model);
						}
					}				
	    	 }
					
	    	 }    	
	    	 
	     } 
	     out.print("true");
		return null;
}


//导出

public String Excel(HttpServletRequest request,
			HttpServletResponse response,List<LhpAlarmCount> list){
				//下载模板 		
				String newFile = request.getSession().getServletContext().getRealPath("statics/excelmuban/baobiao.xls");		  
				File file=new File(newFile);				
				InputStream is=null;	
				HSSFWorkbook workbook = null;
				HSSFSheet sheet = null;
				try {
					is = new FileInputStream(file);// 将excel文件转为输入流
					 workbook = new HSSFWorkbook(is);// 创建个workbook
					// 获取第一个sheet
					sheet = workbook.getSheetAt(0);
				} catch (Exception e) {
					e.printStackTrace();
				}
				if (sheet != null) {
					try {
																	
						
						for(int m=0;m<list.size();m++){
							HSSFRow row = sheet.getRow(m+1);
									if (row == null) {
										row = sheet.createRow(m+1);
									}							
							for (int i = 0; i < 17; i++) {
								HSSFCell cell = row.getCell(i);																		
								if (cell == null) {
									cell = row.createCell(i);																			
								}
								if(i==0){
									cell.setCellValue(list.get(m).getTruckId());
								}
								if(i==1){
									cell.setCellValue(list.get(m).getGroupName());
								}
								if(i==2){
									cell.setCellValue(list.get(m).getBy());
								}
								if(i==3){
									cell.setCellValue(list.get(m).getCs());
								}
								if(i==4){
									cell.setCellValue(list.get(m).getCdpy());
								}
								if(i==5){
									cell.setCellValue(list.get(m).getCjjk());
								}
								if(i==6){
									cell.setCellValue(list.get(m).getCy());
								}
								if(i==7){
									cell.setCellValue(list.get(m).getDdh());
								}
								if(i==8){
									cell.setCellValue(list.get(m).getDhq());
								}
								if(i==9){
									cell.setCellValue(list.get(m).getFqpz());
								}
								if(i==10){
									cell.setCellValue(list.get(m).getXrpz());
								}
								if(i==11){
									cell.setCellValue(list.get(m).getWsj());
								}
								if(i==12){
									cell.setCellValue(list.get(m).getZdbj());
								}
								if(i==13){
									cell.setCellValue(list.get(m).getCount());
								}
								if(i==14){
									cell.setCellValue(list.get(m).getCourse());
								}
								if(i==15){ 
									cell.setCellValue(list.get(m).getBgl());
								}
								if(i==16){
									cell.setCellValue(list.get(m).getAqxs());
								}																								
							}
						}										
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				try {
					String aa = new String("报表.xls".getBytes(), "ISO8859-1");
					 OutputStream output=response.getOutputStream();
				        response.reset();
				        response.setHeader("Content-disposition", "attachment; filename="+aa);
				        response.setContentType("application/msexcel");        
				        workbook.write(output);				    
				        output.close();
				} catch (Exception e) {
					e.printStackTrace();
				}				
				return null;
	}			


//POIExcelUtils:
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.VerticalAlignment;

public class POIExcelUtils {

	 /**
     * 导出Excel
     * @param sheetName sheet名称
     * @param title 标题
     * @param values 内容
     * @param wb HSSFWorkbook对象
     * @return
     */
    public static HSSFWorkbook getHSSFWorkbook(String sheetName,String []title,String [][]values, HSSFWorkbook wb){

        // 第一步，创建一个HSSFWorkbook，对应一个Excel文件
        if(wb == null){
            wb = new HSSFWorkbook();
        }

        // 第二步，在workbook中添加一个sheet,对应Excel文件中的sheet
        HSSFSheet sheet = wb.createSheet(sheetName);

        // 第三步，在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制
        HSSFRow row = sheet.createRow(0);

        // 第四步，创建单元格，并设置值表头 设置表头居中
        HSSFCellStyle style = wb.createCellStyle();
        style.setAlignment(HorizontalAlignment.CENTER);  
        style.setVerticalAlignment(VerticalAlignment.CENTER); 

        //声明列对象
        HSSFCell cell = null;

        //创建标题
        for(int i=0;i<title.length;i++){
            cell = row.createCell(i);
            cell.setCellValue(title[i]);
            cell.setCellStyle(style);
        }

        //创建内容
        for(int i=0;i<values.length;i++){
            row = sheet.createRow(i + 1);
            for(int j=0;j<values[i].length;j++){
                //将内容按顺序赋给对应的列对象
                row.createCell(j).setCellValue(values[i][j]);
            }
        }
        return wb;
    }
    
}

//一

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadTest {

    public static void main(String[] args) {

        Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                thread.start();                      //线程进入到就绪状态
            }
        }
        System.out.println("主线程for循环执行完毕..");
        try {
            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

class MyCallable implements Callable<Integer> {
    private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

}

/***

二
*/


public class WeatherUtilCallable implements Callable<ConcurrentHashMap>{
      ConcurrentHashMap map = new ConcurrentHashMap();
      private String startCalTime;
      private String endCalTime;
      private int i;
      private String gaodeKey;
      private int numInter;
      private int sectIndex;
      private double waySectTime;
      private  List<FhPathLngLat> lnglatList ;
      private String time;
      
       int alarmTypeNum0=0;//天气报警类型 总数
       int alarmTypeNum1=0;
       int alarmTypeNum2=0;
       int alarmTypeNum3=0;
       int alarmTypeNum4=0;
      
    
      
     public WeatherUtilCallable(){
    	 
     }
     public WeatherUtilCallable(List<FhPathLngLat> lnglatList,String time,String gaodeKey,String startCalTime,String endCalTime, int i,
     		int numInter,int sectIndex,double waySectTime){
    	 this.lnglatList=lnglatList;
    	 this.time=time;
     	this.gaodeKey=gaodeKey;
     	this.startCalTime=startCalTime;
     	this.endCalTime=endCalTime;
     	this.i=i;
     	this.numInter=numInter;
     	this.sectIndex=sectIndex;
     	this.waySectTime=waySectTime;
      }
@Override
	public ConcurrentHashMap call() {
		 ......
      
       return map;
    }

}
 
        //动态创建线程

       // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(50);
        List<Future<ConcurrentHashMap>> fuList=new ArrayList<Future<ConcurrentHashMap>>();
        for(int i=0;i<1000;i++){
           try {
					Thread.sleep(50);//间隔100ms 建立一个thread
				} catch (InterruptedException e) { 
					e.printStackTrace();
				}
	WeatherUtilCallable myWeathCall=new WeatherUtilCallable(lnglatList,time,gaodeKey,startCalTime,endCalTime,  i,numInter,sectIndex,waySectTime);
				 Future<ConcurrentHashMap> result = pool.submit(myWeathCall);//执行线程
				 fuList.add(result);//将此线程添加到线程list中
   
          }

for(Future<ConcurrentHashMap> f:fuList){ //遍历结果
    ConcurrentHashMap map1 =(ConcurrentHashMap) f.get();
}
pool.shutdown();





/***

三
*/


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
 
public class CallableFutureTest {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws ExecutionException,
            InterruptedException {
        CallableFutureTest test = new CallableFutureTest();
 
        // 创建一个线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        // 创建两个有返回值的任务
        Callable c1 = test.new MyCallable("A");
        Callable c2 = test.new MyCallable("B");
 
        // 执行任务并获取Future对象
        Future f1 = pool.submit(c1);
        Future f2 = pool.submit(c2);
 
        // 从Future对象上获取任务的返回值，并输出到控制台
        System.out.println(">>>" + f1.get().toString());
        System.out.println(">>>" + f2.get().toString());
 
        // 关闭线程池
        pool.shutdown();
    }
 
    @SuppressWarnings("unchecked")
    class MyCallable implements Callable {
        private String name;
 
        MyCallable(String name) {
            this.name = name;
        }
 
        public Object call() throws Exception {
            return name + "任务返回的内容";
        }
    }
}

 $(":radio[name='blowNum'][value='" +reg + "']").prop("checked", "checked");

/**
	备忘录模式(Memento)：在不破坏分装性的前提下，捕获一个对象的内部状态，并再该对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态。
*/

//发起人
class Originator{
 private string state;
 //需要保存的属性
 public string state{
  get{ return state;}
  set{state=value;}
 } 
 //创建备忘录，将当前需要保存的信息导入并实例化出一个Memento对象
 public Memento CreateMemento(){
  return (new Memento(state)); 
 }
 //恢复备忘录，将Memento导入并将相关数据恢复
 public void SetMemento(Memento memento){
  state=memento.State;
 }
 public void Show(){
 Console.WriteLine("State="+state);
 }
}

//备忘录
class Memento{
 private string state;
 public Memento(string state){
  this.state=state;
 } 
 public string State{ 
  get{ return state;}
 }
}

//管理者
class Caretaker{
 private Memento memento;
 
 public Memento Memento{
 get{ return memento;}
 set{ memento=value;}
 }

}

//客户端程序
static void Main(string[] args){
 Originator o=new Originator();
 o.State="On";
 o.Show();
 Caretaker c=new Caretaker();
 c.Memento=o.CreateMemento();//保存状态时，由于有了很好的封装，可以隐藏Originator的实现细节
 
 o.State="off";
 o.Show();//Originator 发起者改变了状态属性为"Off"

 o.SetMemento(c.Memento); //恢复原初始状态
 o.Show();
 Console.Read();
 }

/**
	观察者模式（Publish/Subscribe）模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
*/

//Subject
abstract class Subject{
 private IList<Observer> observers=new List<Observer>();

 // 增加观察者
 public void Attach(Observer observer){
   observers.Add(observer);
  }

 // 删除观察者
 public void Detach(Observer observer){
   observers.Remove(observer);
  }
 // 通知
 public void Notify(){
 foreach(Observer o in observers){
  o.Update();
 }
 }
}
//更新接口-更新方法
abstract class Observer{
  public abstract void Update();
 }

//具体主题/具体通知者
class ConcreteSubject:Subject{
 private string subjectState;
//具体被观察者状态
public string SubjectState{
get{return subjectState;}
set{subjectState=value;}
 }

}

//具体观察者
class ConcreteObserver:Observer{
 private string name;
 private string observerState;
 private ConcreteSubject subject;

 public  ConcreteObserver(ConcreteSubject subject,string name){
 this.subject=subject;
 this.name=name;
 }

 public override void update(){
  observerState=subject.SubjectState;
  Console.WriteLine("观察者{0} 的新状态是{1}",name,observerState);
 }
 public ConcreteSubject Subject{
 get{return subject;}
 set{ subject=value;}
 }
}

//客户端
static void Main(string[] args){

 ConcreteSubject s=new ConcreteSubject();
 s.Attach(mew ConcreteObserver(s,"X"));
 s.Attach(mew ConcreteObserver(s,"Y"));
 s.Attach(mew ConcreteObserver(s,"Z"));
 
 s.SubjectState="ABC";
 s.Notify();
 
 Console.Read();
}

/**
	建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
*/
//Product 类-产品类，由多个部件组成

class Product{
 IList<string> parts=new List<string>();
 public void Add(string part){
  parts.Add(part);
 }

 public void Show(){
  Console.WriteLine("\n产品 创建----");
  foreach(string part in parts){
   Console.WriteLine(part);
   } 
  }
}

//Builder 类-抽象建造类，确定产品由两个部件PartA和PartB组成，并声明一个得到产品建造后结果的方法GetResult
abstract class Builder{
 public abstract void BuildPartA();
 public abstract void BuildPartB();
 public abstract Product GetResult();
}

//ConcreteBuilder1 具体建造者类
class ConcreteBuilder1:Builder{
   private Product product=new Product();
   public override void BuildPartA(){
    product.Add("部件A");
   }
    public override void BuildPartB(){
    product.Add("部件B");
   }
   public override Product GetResult(){
   return product;
   }
 }

//ConcreteBuilder2 具体建造者类
class ConcreteBuilder2:Builder{
   private Product product=new Product();
   public override void BuildPartA(){
    product.Add("部件X");
   }
    public override void BuildPartB(){
    product.Add("部件Y");
   }
   public override Product GetResult(){
   return product;
   }
 }

//Director 类-指挥者类
class Director{
 public void Construct(Builder builder){
 builder.BuildPartA();
 builder.BuildPartB(); 
}
}

static void Main(string[] args){
 Director direator=new Direactor();
 Builder b1=new ConCreteBuilder1();
 Builder b2=new ConCreteBuilder2();

 director.Construct(b1);
 Product p1=b1.GetResult();
 p1.Show();

 director.Construct(b2);
 Product p2=b2.GetResult();
 p2.Show();
 Console.Read();
}

/**
	外观模式（Facade）：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
*/

//四个子系统的类
class SubSystemOne{
 public void MethodOne(){
  Console.WriteLine("子系统方法一");
 }
}
class SubSystemTwo{
 public void MethodTwo(){
  Console.WriteLine("子系统方法二");
 }
}
class SubSystemThree{
 public void MethodThree(){
  Console.WriteLine("子系统方法三");
 }
}

class SubSystemFour{
 public void MethodFour(){
  Console.WriteLine("子系统方法四");
 }
}

//外观类: 需要了解所有的子系统的方法或属性，进行组合，以备外界调用
class Facade{
 SubSystemOne one;
SubSystemTwo two;
SubSystemThree three;
SubSystemFour four;
public Facade(){
 one=new SubSystemOne();
 two=new SubSystemTwo();
 three=new SubSystemThree();
 four=new SubSystemFour();
}
public void MethodA(){
 Console.WriteLine("\n 方法组A()----");
 one.MethodOne();
 two.MethodTwo();
 four.MethodFour();
}

public void MethodB(){
 Console.WriteLine("\n 方法组B()----");
 two.MethodTwo();
 three.MethodFour();
}

static void Main(string[] args){
 Facade facade=new Facade();
 facade.MethodA();
 facade.MethodB();
 Console.Read();
 }
}

/**
	模板方法模式：定义一个操作汇总的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
**/

/****abstractClass是抽象类，一个抽象模板，定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作猴子那个，推迟到子类实现。

*/

abstract class AbstractClass{
 //一些抽象行为放到子类去实现
 public abstract void PrimitiveOperation1();
 public abstract void PrimitiveOperation2();
 
//模板方法给出了逻辑的骨架，而逻辑的组成是一些相应的抽象操作，它都推迟到子类实现
 public void TemplateMethod(){
 PrimitiveOperation1();
 PrimitiveOperation2();
 Console.WriteLine("")
 }
}

class class ConcreteClassA:AbstractClass{
 public override void PrimitiveOperation1(){
 Console.WriteLine("具体类A方法1实现");
 }

 public override void PrimitiveOperation2(){
 Console.WriteLine("具体类A方法2实现");
 }
}
 
 class ConcreteClassB:AbstractClass{
 public override void PrimitiveOperation1(){
 Console.WriteLine("具体类B方法1实现");
 }

 public override void PrimitiveOperation2(){
 Console.WriteLine("具体类B方法2实现");
 }
}

//客户端调用
static void Main(string[] args){
 AbstractClass c;
 c=new ConcreteClassA();
 c.TemplateMethod();

 c=new ConcreteClassB();
 c.TemplateMethod();
 Console.Read();
}

/**
	原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
       从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建细节。

**/
abstract class Prototype{
 private stirng id;
 public Prototype(string id){
  this.id=id;
 }
 public stirng Id{
 get{return id;}
 }
 public abstract Prototype Clone();
 }

class ConcretePrototype1:Prototype{
 public ConcretePrototype1(string id):base(id){}

 public override Prototype Clone(){
  /**
   创建当前对象的浅表副本。
   方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。
   如果字段是值类型的，则对该字段执行逐位复制；如果是引用类型的，则复制引用但不复制引用的对象；
   因此，原始对象及其副本引用同一对象。
  */
  return (Prototype)this.MemberwiseClone();
 }
}

//客户端代码
static void main(string[] args){
 ConcretePrototype1 p1=new ConcretePrototype1("I");
 ConcretePrototype1 c1=p1.Clone();
 Console.WriteLine("Cloned:{0}",c1.Id);
 Console.Read();
}

/**
	代理模式：为其他对象提供一种代理以控制对这个对象的访问。
*/

abstract class Subject{
  public abstract void Request();
}

//RealSubject 类，定义Proxy 所代表的真实实体
class RealSubject:Subject{
  public override void Request(){
   Console.WriteLine("真实的请求");
  }
}

//Proxy类，保存一个引用使得代理可以访问实体，并提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体
class Proxy:Subject{
  RealSubject realSubject;
  public override void Request(){
  if(realSubject==null){
    realSubject=new RealSubject();
   }
   realSubject.Request();
  }
}

//客户端代码
 static void main(string() args){
  Proxy proxy=new Proxy();
  proxy.Request();
  Console.Read();
 }

/***
装饰模式:
动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。
**/
//对象接口
abstract class Component{
 public abstract void operation();
}
class ConcreteComponent:Component{
 public override void Operation(){
 Console.WriteLine("具体对象的操作");
 }
}
abstract class Decorator : Component{
 protected Component component;
 public void SetComponent( Component component){
   this.component=component;
  }
 //重写Operation() 实际执行的是Component的Operation()
 public override void Operation(){
  if(component!=null){
   component.Operation();
  }
 }
class ConcreteDecoratorA:Decorator{
 private String addedState;
 public override void Operation(){ 
  base.Operation();//首先运行原Component的 Operation(),再执行本类的功能，如addedState ,相当于对原Component进行了装修
  addedState="new State";
  Consloe.WriteLine("具体装修对象A的操作");
  }
 }
class ConcreteDecoratorB:Decorator{
 public override void Operation(){ 
  base.Operation();//首先运行原Component的 Operation(),再执行本类的功能，如AddedBehavior ,相当于对原Component进行了装修
   AddedBehavior();
  Consloe.WriteLine("具体装修对象B的操作");
  }
 private void AddedBehavior();
 }
/***
客户端代码
*/
static void main(string[] args){
 ConcreteComponent c=new ConcreteComponent();
 ConcreteDecoratorA d1=new ConcreteDecoratorA();
 ConcreteDecoratorB d2=new ConcreteDecoratorG();
 d1.setComponent(c);
 d2.setComponent(d1);
 d2.Operation();
 Conslose.Read();
}

//抽象算法类 顶意思所有支持的算法的公共接口
abstract class Strategy{
   //算法方法
   public abstract void AlgorithmInterface();
}

//ConcreteStrategy,封装了具体的算法或行为，继承于Strategy
class ConcreteStrategyA : Strategy
{
 //算法A 实现方法
  public override void AlogrithmInterface(){
   Console.WriteLine("算法A实现");
  }
 }

class ConcreteStrategyB : Strategy
{
 //算法B 实现方法
  public override void AlogrithmInterface(){
   Console.WriteLine("算法B实现");
  }
 }

class ConcreteStrategyC : Strategy
{
 //算法C 实现方法
  public override void AlogrithmInterface(){
   Console.WriteLine("算法C实现");
  }
 }

//Context 用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用。
 class Context {
  Strategy strategy; 
  public Context(Strategy strategy){//初始化时，传入具体的策略对象
    this.strategy=strategy;
   }
  public void ContextInterface(){//根据具体的策略对象，调用其算法的方法
    strategy.AlogrithmInterface()；
   }
 }

/***
客户端代码
*/

static void Main(string[] args){
Context context;

//由于实例化不同的策略，所以最终在调用context.ContextInterface()时，结果就不相同
context=new Context(new ConcreteStrategyA());
context.ContextInterface();

context=new Context(new ConcreteStrategyB());
context.ContextInterface();

Console.Read();

}

//方法一：正则分析法 

function getQueryString(name) { 
var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)", "i"); 
var r = window.location.search.substr(1).match(reg); 
if (r != null) return unescape(r[2]); return null; 
} 
//调用方法： 
alert(GetQueryString("参数名1"));alert(GetQueryString("参数名2")); 
alert(GetQueryString("参数名3")); 


//方法二 

<Script language="javascript"> 
function GetRequest() { 
var url = location.search; //获取url中"?"符后的字串 
var theRequest = new Object(); 
if (url.indexOf("?") != -1) { 
var str = url.substr(1); 
strs = str.split("&"); 
for(var i = 0; i < strs.length; i ++) { 
theRequest[strs[i].split("=")[0]]=unescape(strs[i].split("=")[1]); 
} 
} 
return theRequest; 
} 
</Script>

//调用方法： 
<Script language="javascript"> 
var Request = new Object(); 
Request = GetRequest(); 
var 参数1,参数2,参数3,参数N; 
参数1 = Request['参数1']; 
参数2 = Request['参数2']; 
参数3 = Request['参数3']; 
参数N = Request['参数N']; 
</Script> 

 

在一般系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session
具体设置的方法有三种：
1.在web容器中设置（以tomcat为例）
在tomcat-7.0\conf\web.xml中设置，以下是tomcat7.0中默认配置：

1
2
3
<session-config>
<session-timeout>30</session-timeout>
</session-config>
tomcat默认session超时时间为30分钟，可以根据需要修改，负数或0为不限制session失效时间

这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所以如果在调试程序，应该是修改服务器端时间来测试，而不是客户端

2.在工程的web.xml中设置
<!--时间单位为分钟-->

1
2
3
<session-config>
<session-timeout>15</session-timeout>
</session-config>
　这里的15是指15分钟失效

3.通过java代码设置
session.setMaxInactiveInterval(30*60);//以秒为单位，即在没有活动30分钟后，session将失效

三种方式优先等级：1 < 2 < 3

在一般系统中，也可能需要在session失效后做一些操作：
1.控制用户数，当session失效后，系统的用户数减少一个，控制用户数量在一定范围内，确保系统的性能
2.控制一个用户多次登录，当session有效时，如果相同用户登录，就提示已经登录了，当session失效后，就可以不同提示，直接登录
那么如何在session失效后，进行一系列的操作呢？
这里就需要用到监听器了，即当session因为各种原因失效后，监听器就可以监听到，然后执行监听器中定义好的程序就可以了
监听器类为：HttpSessionListener类，有sessionCreated和sessionDestroyed两个方法
自己可以继承这个类，然后分别实现
sessionCreated指在session创建时执行的方法
sessionDestroyed指在session失效时执行的方法
例子：

复制代码
 1 public class OnlineUserListener implements HttpSessionListener{
 2     public void sessionCreated(HttpSessionEvent event){
 3         HttpSession session=event.getSession;
 4         String id=session.getId()+session.getCreationTime();
 5         SummerConstant.UserMap.put(id,Boolean.TRUE);//添加用户
 6     }
 7     
 8     public void sessionDestroyed(HttpSessionEvent event){
 9         HttpSession session=event.getSession;
10         String id=session.getId()+session.getCreationTime();
11         synchronized(this){
12             SummerConstant.USERNum--;//用户数减-
13             SummerConstant.UserMap.remove(id);//从用户组中移除掉，用户组为一个map
14         }
15     }
16 }
复制代码
然后只需要把这个监听器在web.xml中声明就可以了

<listener>
<listener-class>com.demo.OnlineUserListener</listener-class>
</listener>

清除mysql表中数据 (2012-03-07 15:36:30)转载▼
标签： it	分类： 其它知识技巧
delete from 表名;
truncate table 表名;
不带where参数的delete语句可以删除mysql表中所有内容，使用truncate table也可以清空mysql表中所有内容。
效率上truncate比delete快，但truncate删除后不记录mysql日志，不可以恢复数据。
delete的效果有点像将mysql表中所有记录一条一条删除到删完，
而truncate相当于保留mysql表的结构，重新创建了这个表，所有的状态都相当于新表。

import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.luguang.model.PowerAlarm;
import com.luguang.powerDevice.control.DataFormChange;
import com.luguang.powerDevice.control.MySocketReadThread;


public class PowerChanelEleRunner {
	//存放已经查询的电源Ip 以及 结果
	public static ConcurrentHashMap<String, String> powerIpEleMap = null;
	public  Queue<PowerAlarm> ppmQueue;
	public List<PowerAlarm> eleList=new ArrayList<PowerAlarm>();
    private int fetchedNum = 0; // 已经取得的任务数量，每次从队列中取一个ip就加1
    
    public PowerChanelEleRunner(List<PowerAlarm> ppmList){
//    	ppmQueue=new LinkedList<PowerAlarm>();
//    	for(int i=0;i<ppmList.size();i++){
//    		ppmQueue.offer(ppmList.get(i));
//    	}
    	powerIpEleMap = new ConcurrentHashMap<String, String>();
    	eleList.clear();
    	eleList=ppmList;
    }
    public List<PowerAlarm>  startPing() {// 创建一个线程池，多个线程同时跑
        int threadNum = 10;
        ExecutorService executor = Executors.newFixedThreadPool(threadNum);
        for (int i = 0; i < threadNum; i++) {
            executor.execute(new PingRunner());
        }
        executor.shutdown();
        try {
            while (!executor.isTerminated()) {
                Thread.sleep(100);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return eleList;
    }

    private class PingRunner implements Runnable {
        private PowerAlarm ppm=null;
        public void run() {
            try {
                while ((ppm = getPpm()) != null) {
     			   String pIp=ppm.getPowerIp();
     			   String hexStr="";
     			  boolean isReach=DataFormChange.isIpReach(pIp,3000);
     			  if(isReach){
     				 if(!powerIpEleMap.containsKey(pIp)){
         				   MySocketReadThread myRead=new MySocketReadThread(pIp);
         					Thread th = new Thread(myRead);
         					th.start();
         					try {
         						while(hexStr==null || hexStr.equals("")){
         							th.sleep(1000);
         							hexStr=myRead.getHexStr();
         						    if(null!=powerIpEleMap && null!=pIp && null!=hexStr && !"".equals(hexStr)){
         						    	powerIpEleMap.put(pIp, hexStr);
         						    }
         						}
         					} catch (InterruptedException e) {
         						e.printStackTrace();
         					}
       			   }else{//电源IP 已查询
       				  hexStr=powerIpEleMap.get(pIp);
       				   
       			   }
       			  if (hexStr != null && !hexStr.equals("")) {
  							// 十六进制字符串
  							char[] hexArr = hexStr.toCharArray();
  							if (hexArr != null && hexArr.length > 0) {
  								int id = (ppm.getPowerChan()-1);
  								String aNum = String.valueOf(hexArr[(id * 2 + 17) * 2])
  										+ String.valueOf(hexArr[(id * 2 + 17) * 2 + 1])
  										+ String.valueOf(hexArr[(id * 2 + 17) * 2 + 2])
  										+ String.valueOf(hexArr[(id * 2 + 17) * 2 + 3]);
  								int eleNum = Integer.parseInt(aNum, 16);
  								ppm.setAcTimeEleNum(eleNum+"");
  							}
  						}
     				  
     			  }else{
     				 ppm.setAcTimeEleNum("电源此时不在线"); 
     			  }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
		public PowerAlarm getPpm() {
			PowerAlarm ppm=null;
			synchronized (eleList) {
//				ppm=ppmQueue.poll();
				if(fetchedNum<eleList.size()){
					ppm=eleList.get(fetchedNum);
				}
			}
			if(ppm!=null){
				 fetchedNum++;	
			}
			return ppm;
		}   
    }
}

/**
 使用广播，本地网络中所有的主机都会受到一份数据副本。
 广播使用UDP报文，IPv4使用（255.255.255.255）地址发送广播，本地广播绝不会被路由器转发，即广播信息会被限制在本地网络之内。
    
广播域
首先我们来了解一下广播域的概念。
广播域是网络中能接收任一台主机发出的广播帧的所有主机集合。也就是说，如果广播域内的其中一台主机发出一个广播帧，同一广播域内所有的其它主机都可以收到该广播帧。
广播域的计算
如何知道一台主机是属于哪一个广播域呢？其实计算很简单，只要用主机的IP地址与子网掩码进行与运算即可知道该主机属于哪一个广播域。例如：一台主机的IP地址为192.168.23.150，子网掩码为255.255.255.0，那么它所属的广播域就是192.168.23.150&255.255.255.0=192.168.23.0。那么其它的在广播域192.168.23.0内的所有主机就可以到该设备发送的广播包。如果把子网掩码改为255.255.0.0，那么它所属的广播域就是192.168.23.150&255.255.0.0=192.168.0.0。那么其它的在广播域192.168.0.0内的所有主机都可以收到该设备发送的广播包。
广播地址的计算
要想相同广播域内的其它主机能收到的广播帧，还需要在发送广播包的时候指定当前所属广播域内的广播地址。广播地址的计算方法为子网掩码取反再与广播域进行或运算。
例如：如果主机当前所属广播域为192.168.0.0，子网掩码为255.255.0.0，那么广播地址则为192.168.255.255。
使用UDP进行跨网段广播
要使主机A发送的广播包能够被另一网段的主机B收到，那么只需要更改主机A的子网掩码使得与主机B在同一个广播域内，再使用新的广播域的广播地址发送广播包即可。
例如：要使用192.168.23.150发送广播包让192.168.27.135收到，只需要设置192.168.23.150的子网掩码为255.255.0.0，然后再使用广播地址192.168.255.255即可。
特别要指出的是：255.255.255.255是受限广播地址，不能使用该地址发送广播包。
*/

/**
 * 获取本网段的直接广播地址
 * */
public class IPBroadcastAddress {  
  
    public static void main(String[] args) {  
  
        printIpAddressAndSubnettest(); 
  
    }  
    public static String getBroadcastAddress(String subnet, String ip) {
		String[] ips = ip.split("\\.");
		String[] subnets = subnet.split("\\.");
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < ips.length; i++) {
			ips[i] = String.valueOf((~Integer.parseInt(subnets[i]))
					| (Integer.parseInt(ips[i])));
			sb.append(turnToStr(Integer.parseInt(ips[i])));
			if (i != (ips.length - 1))
				sb.append(".");
		}
		return turnToIp(sb.toString());
	}

	private static String turnToStr(int num) {
		String str = "";
		str = Integer.toBinaryString(num);
		int len = 8 - str.length();
		for (int i = 0; i < len; i++) {
			str = "0" + str;
		}
		if (len < 0)
			str = str.substring(24, 32);
		return str;
	}

	/**
	 * 转换成Str
	 * */
	private static String turnToIp(String str) {
		String[] ips = str.split("\\.");
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < ips.length; i++) {
			sb.append(turnToInt(ips[i]));
			sb.append(".");
		}
		sb.deleteCharAt(sb.length() - 1);
		return sb.toString();
	}

	/**
	 * 转换成int
	 * */
	private static int turnToInt(String str) {
		int total = 0;
		int top = str.length();
		for (int i = 0; i < str.length(); i++) {
			String h = String.valueOf(str.charAt(i));
			top--;
			total += ((int) Math.pow(2, top)) * (Integer.parseInt(h));
		}
		return total;
	}
  
    public static ArrayList<String> printIpAddressAndSubnettest() {  
    	ArrayList<String>  strArray = new ArrayList<String> ();
        try {  
            Enumeration<NetworkInterface> eni = NetworkInterface  
                    .getNetworkInterfaces();  
            while (eni.hasMoreElements()) {  
  
                NetworkInterface networkCard = eni.nextElement();  
                List<InterfaceAddress> ncAddrList = networkCard  
                        .getInterfaceAddresses();  
                Iterator<InterfaceAddress> ncAddrIterator = ncAddrList.iterator();  
                while (ncAddrIterator.hasNext()) {  
                    InterfaceAddress networkCardAddress = ncAddrIterator.next();  
                    InetAddress address = networkCardAddress.getAddress();  
                    if (!address.isLoopbackAddress()) {  
                        String hostAddress = address.getHostAddress();
                        if (hostAddress.indexOf(":") > 0) {  
                            // case : ipv6  
                            continue;  
                        } else {  
                            // case : ipv4  
//                            String maskAddress = calcMaskByPrefixLength(networkCardAddress.getNetworkPrefixLength());  
//                            String subnetAddress = calcSubnetAddress(hostAddress, maskAddress);  
                            String broadcastAddress = networkCardAddress.getBroadcast().getHostAddress();  
                            System.out.println("broadcast      =   "+ broadcastAddress+"\n");  
                            strArray.add(broadcastAddress);
                        }  
                    } else {  
                        String loopback = networkCardAddress.getAddress().getHostAddress();  
                    }  
                }  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return strArray;
    }  
  
    public static String calcMaskByPrefixLength(int length) {  
        int mask = -1 << (32 - length);  
        int partsNum = 4;  
        int bitsOfPart = 8;  
        int maskParts[] = new int[partsNum];  
        int selector = 0x000000ff;  
  
        for (int i = 0; i < maskParts.length; i++) {  
            int pos = maskParts.length - 1 - i;  
            maskParts[pos] = (mask >> (i * bitsOfPart)) & selector;  
        }  
  
        String result = "";  
        result = result + maskParts[0];  
        for (int i = 1; i < maskParts.length; i++) {  
            result = result + "." + maskParts[i];  
        }  
        return result;  
    }  
  
    public static String calcSubnetAddress(String ip, String mask) {  
        String result = "";  
        try {  
            // calc sub-net IP  
            InetAddress ipAddress = InetAddress.getByName(ip);  
            InetAddress maskAddress = InetAddress.getByName(mask);  
  
            byte[] ipRaw = ipAddress.getAddress();  
            byte[] maskRaw = maskAddress.getAddress();  
  
            int unsignedByteFilter = 0x000000ff;  
            int[] resultRaw = new int[ipRaw.length];  
            for (int i = 0; i < resultRaw.length; i++) {  
                resultRaw[i] = (ipRaw[i] & maskRaw[i] & unsignedByteFilter);  
            }  
  
            // make result string  
            result = result + resultRaw[0];  
            for (int i = 1; i < resultRaw.length; i++) {  
                result = result + "." + resultRaw[i];  
            }  
        } catch (UnknownHostException e) {  
            e.printStackTrace();  
        }  
  
        return result;  
    }  
}  

Java实现ping功能的三种方法
检测设备的运行状态,有的是使用ping的方式来检测的。所以需要使用java来实现ping功能。 
为了使用java来实现ping的功能,有人推荐使用java的 Runtime.exec()方法来直接调用系统的Ping命令,也有人完成了纯Java实现Ping的程序，使用的是Java的NIO包(native io, 高效IO包)。但是设备检测只是想测试一个远程主机是否可用。所以，可以使用以下三种方式来实现：
1.Jdk1.5的InetAddresss方式
自从Java 1.5，java.net包中就实现了ICMP ping的功能。
见：Ping类的ping(String)函数。
使用时应注意，如果远程服务器设置了防火墙或相关的配制，可能会影响到结果。另外，由于发送ICMP请求需要程序对系统有一定的权限，当这个权限无法满足时， isReachable方法将试着连接远程主机的TCP端口 7(Echo)。
2.最简单的办法，直接调用CMD
见Ping类的ping02(String)函数。
3.Java调用控制台执行ping命令
具体的思路是这样的：
通过程序调用类似“ping 127.0.0.1 -n 10 -w 4”的命令，这命令会执行ping十次，如果通顺则会输出类似“来自127.0.0.1的回复： 字节=32 时间<1ms TTL=64”的文本（具体数字根据实际情况会有变化），其中中文是根据环境本地化的，有些机器上的中文部分是英文，但不论是中英文环境， 后面的“<1ms TTL=62”字样总是固定的，它表明一次ping的结果是能通的。如果这个字样出现的次数等于10次即测试的次数，则说明127.0.0.1是百分之百能连通的。 
技术上：具体调用dos命令用Runtime.getRuntime().exec实现，查看字符串是否符合格式用正则表达式实现。
见Ping类的ping(String,int,int)函数。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Ping {
    
    public static boolean ping(String ipAddress) throws Exception {
        int  timeOut =  3000 ;  //超时应该在3钞以上        
        boolean status = InetAddress.getByName(ipAddress).isReachable(timeOut);     // 当返回值是true时，说明host是可用的，false则不可。
        return status;
    }
    
    public static void ping02(String ipAddress) throws Exception {
        String line = null;
        try {
            Process pro = Runtime.getRuntime().exec("ping " + ipAddress);
            BufferedReader buf = new BufferedReader(new InputStreamReader(
                    pro.getInputStream()));
            while ((line = buf.readLine()) != null)
                System.out.println(line);
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }
    }
    
    public static boolean ping(String ipAddress, int pingTimes, int timeOut) {  
        BufferedReader in = null;  
        Runtime r = Runtime.getRuntime();  // 将要执行的ping命令,此命令是windows格式的命令  
        String pingCommand = "ping " + ipAddress + " -n " + pingTimes    + " -w " + timeOut;  
        try {   // 执行命令并获取输出  
            System.out.println(pingCommand);   
            Process p = r.exec(pingCommand);   
            if (p == null) {    
                return false;   
            }
            in = new BufferedReader(new InputStreamReader(p.getInputStream()));   // 逐行检查输出,计算类似出现=23ms TTL=62字样的次数  
            int connectedCount = 0;   
            String line = null;   
            while ((line = in.readLine()) != null) {    
                connectedCount += getCheckResult(line);   
            }   // 如果出现类似=23ms TTL=62这样的字样,出现的次数=测试次数则返回真  
            return connectedCount == pingTimes;  
        } catch (Exception ex) {   
            ex.printStackTrace();   // 出现异常则返回假  
            return false;  
        } finally {   
            try {    
                in.close();   
            } catch (IOException e) {    
                e.printStackTrace();   
            }  
        }
    }
    //若line含有=18ms TTL=16字样,说明已经ping通,返回1,否則返回0.
    private static int getCheckResult(String line) {  // System.out.println("控制台输出的结果为:"+line);  
        Pattern pattern = Pattern.compile("(\\d+ms)(\\s+)(TTL=\\d+)",    Pattern.CASE_INSENSITIVE);  
        Matcher matcher = pattern.matcher(line);  
        while (matcher.find()) {
            return 1;
        }
        return 0; 
    }
    public static void main(String[] args) throws Exception {
        String ipAddress = "127.0.0.1";
        System.out.println(ping(ipAddress));
        ping02(ipAddress);
        System.out.println(ping(ipAddress, 5, 5000));
    }
}



小结：
第一种方法:Jdk1.5的InetAddresss,代码简单。
第二种方法:使用java调用cmd命令,这种方式最简单，可以把ping的过程显示在本地。
第三种方法:也是使用java调用控制台的ping命令，这个比较可靠，还通用，使用起来方便：传入个ip，设置ping的次数和超时，就可以根据返回值来判断是否ping通。



转自：http://www.blogjava.net/marchalex/archive/2015/03/08/423292.html

/**
MyDatabaseHelper：数据库工具类
*/

package com.example.questionnairesurvey;

import android.annotation.SuppressLint;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import android.widget.Toast;

@SuppressLint("NewApi")
public class MyDatabaseHelper extends SQLiteOpenHelper {
	private static final String TAG = "MyDatabaseHelper";
    public static final String CREATE_USERINFO="create table userinfo("+
     " id integer primary key autoincrement,"
    		+" age integer, "
            +" degree text, "
    		+" address text "
    		+")";
    
    public static final String CREATE_ANSWER="create table answer("
    		+ " id integer primary key autoincrement,"
    		+"  questionnaireId integer ,"
    		+"  userId integer ,"
    		+ " questNumber integer, "
    		+ " questAnswer text ,"
    		+ " surveyDate text "
    		+ ")";
    private Context mContext;
	
	public MyDatabaseHelper(Context context, String name,
			CursorFactory factory, int version) {
		super(context, name, factory, version);
		mContext=context;
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
		db.execSQL(CREATE_USERINFO);
		db.execSQL(CREATE_ANSWER);
		Toast.makeText(mContext, "Create succeeded", Toast.LENGTH_SHORT).show();
		Log.d(TAG,"create userinfo success");
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		db.execSQL("drop table if exists userinfo");
		db.execSQL("drop table if exists answer");
		onCreate(db);
	}
}

/**
数据库操作
*/
public class MainActivity extends Activity {
	// 数据库操作
	private MyDatabaseHelper dbHelper;
         @Override
	protected void onCreate(Bundle savedInstanceState) {
	  super.onCreate(savedInstanceState);
	   requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);
		dbHelper = new MyDatabaseHelper(this, "newQuestionnaireSurvey.db",
				null, 2);
		dbHelper.getWritableDatabase();
          }
Button btn = (Button) view.findViewById(R.id.btnViewSurvey);
btn.setOnClickListener(new Button.OnClickListener() {
@Override
public void onClick(View v) {
final SQLiteDatabase myDb = dbHelper.getWritableDatabase();
                 ContentValues values=new ContentValues();
	        values.put("age",ageStr);
	        values.put("degree",degreeStr);
	        values.put("address",addrStr);
	        myDb.insert("userinfo", null, values);
	       values.clear();
               // String sql = "insert into userinfo(age,degree,address) values (?,?,?)";
						//myDb.execSQL(sql, new Object[] { ageStr, degreeStr,
								addrStr});


	       // 获取最新记录的ID
	       Cursor cursor = myDb.rawQuery("select last_insert_rowid() from userinfo",null);
	      cursor.moveToFirst();
	      theLastUserId = cursor.getInt(0);
	      Log.d("userInfo id", " 最新ID="+theLastUserId);
	     viewPager.setCurrentItem(1);
					}
				});

}

/**
sqlite3 查看本地数据库
com.example.questionnairesurvey：项目包名
*/
C:\Users\glr>adb shell
root@generic:/ # cd /data/data/com.example.questionnairesurvey/databases
cd /data/data/com.example.questionnairesurvey/databases
root@generic:/data/data/com.example.questionnairesurvey/databases # ls
ls
QuestionnaireSurvey.db
newQuestionnaireSurvey.db
newQuestionnaireSurvey.db-journal
root@generic:/data/data/com.example.questionnairesurvey/databases # sqlite3 newQ
uestionnaireSurvey.db
e3 newQuestionnaireSurvey.db                                                  <
SQLite version 3.7.11 2012-03-20 11:35:50
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> .tables
.tables
android_metadata  answer            userinfo
sqlite> select * from userinfo;
select * from userinfo;
1|12|12|shandong
2|26|zhuanke|shandongjinan

/**
Intent是Android程序中各组件之间进行交互的一种重要方式，它不仅可以指明当前组件想要执行的动作，还可以在不同组件之间传递数据。Intent一般可被用于启动活动、启动服务、以及发送广播等场景

Intent的用法大致可以分为两种，显式Intent和隐式Intent。
构造函数:Intent(Context packageContext, Class<?> cls):，第一个参数Context要求提供一个启动活动的上下文，第二个参数Class则是指定想要启动的目标活动，通过这个构造函数就可以构建出Intent的“意图”。
*/
//一：在FirstActivity类中：显示Intent
        	Button button1 = (Button) findViewById(R.id.button_1);// 获取按钮资源
		    button1.setOnClickListener(new Button.OnClickListener() {// 创建监听
			public void onClick(View v) {
				//启动另一活动 intent:意图
				/***
				 * 显式：Intent(Context packageContext, Class<?> cls)
				 * 第一个参数:要求提供一个启动活动的上下文，
				 * 第二个参数Class则是指定想要启动的目标活动
				 * */
				Intent intent=new Intent(FirstActivity.this,SecondActivity.class);
				/**
				 * startActivity()方法，这个方法是专门用于启动活动的，它接收一个Intent参
				 * */
				startActivity(intent);
			}
		});
/***二：Intent 隐式
隐式Intent:它并不明确指出我们想要启动哪一个活动，而是指定了一系列更为抽象的action和category等信息，然后交由系统去分析这个Intent，并帮我们找出合适的活动去启动。
*/
  在AndroidManifest.xml中添加一代代码：
 <activity android:name=".SecondActivity">
            <intent-filter>
                <action android:name="com.example.activitytest.ACTION_START" />
                <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
        </activity>
		Button button1 = (Button) findViewById(R.id.button_1);// 获取按钮资源
		button1.setOnClickListener(new Button.OnClickListener() {// 创建监听
			public void onClick(View v) {
				//启动另一活动 intent:意图
								Intent intent = new Intent("com.example.activitytest.ACTION_START");
				startActivity(intent);
			}
		});

/**
三：使用Intent 启动其他活动
*/
  //查看网页
    Intent intent=new Intent(Intent.ACTION_VIEW);
    intent.setData(Uri.parse("http://www.baidu.com"));

  //拨打电话
  Intent intent=new Intent(Intent.ACTION_VIEW);
  intent.setData(Uri.parse("tel:10086"));
  startActivity(intent);

/**
* 活动之间传递数据
 * */
 String data="Hello SecondActivity";
 Intent intent=new Intent(FirstActivity.this,SecondActivity.class);
 intent.putExtra("extra_data",data);

 //获取从Intent中传过来的数据
  Intent intent=getIntent();
  String data=intent.getStringExtra("extra_data");
  Log.d("SecondActivity",data);

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class FirstActivity extends Activity {
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		// 隐藏标题栏
		// requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.first_layout);
		Log.d("ActivityTest", "测试");
		/**
		 * 使用Toast:提醒信息：，通过静态方法makeText()创建出一个Toast对象，然后调用show()将Toast显示出来就可以了.
		 * makeText()方法需要传入三个参数。
		 * 第一个参数是Context，也就是Toast要求的上下文，由于活动本身就是一个Context对象，因此这里直接传入FirstActivity.this即可。
		 * 第二个参数是Toast显示的文本内容，
		 * 第三个参数是Toast显示的时长，有两个内置常量可以选择Toast.LENGTH_SHORT和Toast.LENGTH_LONG。
		 * */

		/**
		 * OnClick 事件：第一种方式
		 * */
		Button button1 = (Button) findViewById(R.id.button_1);// 获取按钮资源
		button1.setOnClickListener(new Button.OnClickListener() {// 创建监听
			public void onClick(View v) {
				Toast.makeText(FirstActivity.this, "You clicked the Button 1",
						Toast.LENGTH_SHORT).show();
			}
		});

		/**
		 * OnClick 事件：第二种方式
		 * */
		Button btn2 = (Button) findViewById(R.id.button_2);
		btn2.setOnClickListener(listener);// 设置监听
	}

	// 第二种监听方式
	Button.OnClickListener listener = new Button.OnClickListener() {
		@Override
		public void onClick(View arg0) {
			Toast.makeText(FirstActivity.this, "You clicked the Button 2",
					Toast.LENGTH_SHORT).show();
		}
	};

	/**
	 * OnClick 事件：第三种方法（android1.6版本以上）
	 * */
	public void btn3OnClick(View view) {
		Toast.makeText(FirstActivity.this, "You clicked the Button 3",
				Toast.LENGTH_SHORT).show();
	}

}

//first_layout.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
    <!--@+id/button1:定义ID -->
    <Button
        android:id="@+id/button_1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button 1，第一个" />

    <Button
        android:id="@+id/button_2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button 2" />
    <Button
        android:id="@+id/button_3"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button 3" android:onClick="btn3OnClick"/>
</LinearLayout>

import org.apache.commons.net.ntp.NTPUDPClient;
import org.apache.commons.net.ntp.TimeInfo;
import org.apache.commons.net.ntp.TimeStamp;

public class SyncTime {
	public static void main(String[] args) {
		try {
			   NTPUDPClient timeClient = new NTPUDPClient();
			   String timeServerUrl = "pool.ntp.org";//NTP 时间服务器
			   InetAddress timeServerAddress = InetAddress.getByName(timeServerUrl);
			   System.out.println(timeServerAddress.getHostName()+" ip="+timeServerAddress.getHostAddress());
			   TimeInfo timeInfo = timeClient.getTime(timeServerAddress);
			   TimeStamp timeStamp = timeInfo.getMessage().getTransmitTimeStamp();
			   Date date = timeStamp.getDate();
			   System.out.println(date);
			   DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
			   System.out.println(dateFormat.format(date));
			  } catch (UnknownHostException e) {
			   e.printStackTrace();
			  } catch (IOException e) {
				e.printStackTrace();
			}
	}
}
结果：
pool.ntp.org ip=110.75.186.248
Wed Apr 13 15:23:18 CST 2016
2016-04-13 03:23:18