Merge remote-tracking branch 'origin/master'

# Conflicts:
#	src/main/java/osc/git/eh3/test/TestCode.java
#	src/main/java/osc/git/eh3/testopen/TestOpenPuton.java

src/main/java/osc/git/eh3/cache/Cache.java

@@ -0,0 +1,71 @@
+package osc.git.eh3.cache;
+
+/**
+ * <p>
+ * Title:
+ * </p>
+ * 
+ * <p>
+ * Description: 缓存DTO
+ * </p>
+ * 
+ * <p>
+ * Copyright: Copyright (c) 2008
+ * </p>
+ * 
+ * <p>
+ * Company:
+ * </p>
+ * 
+ * @author Deepblue 2008-11-11
+ * @version 1.0
+ */
+public class Cache {
+	private String key;// 缓存ID
+	private Object value;// 缓存数据
+	private long timeOut;// 更新时间
+	private boolean expired; // 是否终止
+
+	public Cache() {
+		super();
+	}
+
+	public Cache(String key, Object value, long timeOut, boolean expired) {
+		this.key = key;
+		this.value = value;
+		this.timeOut = timeOut;
+		this.expired = expired;
+	}
+
+	public String getKey() {
+		return key;
+	}
+
+	public long getTimeOut() {
+		return timeOut;
+	}
+
+	public Object getValue() {
+		return value;
+	}
+
+	public void setKey(String string) {
+		key = string;
+	}
+
+	public void setTimeOut(long l) {
+		timeOut = l;
+	}
+
+	public void setValue(Object object) {
+		value = object;
+	}
+
+	public boolean isExpired() {
+		return expired;
+	}
+
+	public void setExpired(boolean b) {
+		expired = b;
+	}
+}

src/main/java/osc/git/eh3/cache/CacheManager.java

@@ -0,0 +1,220 @@
+package osc.git.eh3.cache;
+
+import java.util.*;
+import java.util.Map.Entry;
+
+/**
+ * <p>
+ * Title:
+ * </p>
+ * 
+ * <p>
+ * Description: 管理缓存
+ * </p>
+ * Deep blue 2008-11-28 think
+ * 可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间
+ * <p>
+ * Copyright: Copyright (c) 2008
+ * </p>
+ * 
+ * <p>
+ * Company:
+ * </p>
+ * 
+ * @author Deepblue 2008-11-11
+ * @version 1.0
+ */
+public class CacheManager {
+	private static HashMap<String, Object> cacheMap = new HashMap<String, Object>();
+
+	// 单实例构造方法
+	private CacheManager() {
+		super();
+	}
+
+	// 获取布尔值的缓存
+	public static boolean getSimpleFlag(String key) {
+		try {
+			return (Boolean) cacheMap.get(key);
+		} catch (NullPointerException e) {
+			return false;
+		}
+	}
+
+	public static long getServerStartdt(String key) {
+		try {
+			return (Long) cacheMap.get(key);
+		} catch (Exception ex) {
+			return 0;
+		}
+	}
+
+	// 设置布尔值的缓存
+	public synchronized static boolean setSimpleFlag(String key, boolean flag) {
+		if (flag && getSimpleFlag(key)) {// 假如为真不允许被覆盖
+			return false;
+		} else {
+			cacheMap.put(key, flag);
+			return true;
+		}
+	}
+
+	public synchronized static boolean setSimpleFlag(String key, long serverbegrundt) {
+		if (cacheMap.get(key) == null) {
+			cacheMap.put(key, serverbegrundt);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	// 得到缓存。同步静态方法
+	private synchronized static Cache getCache(String key) {
+		return (Cache) cacheMap.get(key);
+	}
+
+	// 判断是否存在一个缓存
+	private synchronized static boolean hasCache(String key) {
+		return cacheMap.containsKey(key);
+	}
+
+	// 清除所有缓存
+	public synchronized static void clearAll() {
+		cacheMap.clear();
+	}
+
+	// 清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配
+	public synchronized static void clearAll(String type) {
+		Iterator<Entry<String, Object>> i = cacheMap.entrySet().iterator();
+		String key;
+		ArrayList<String> arr = new ArrayList<String>();
+		try {
+			while (i.hasNext()) {
+				Entry<String, Object> entry = i.next();
+				key = (String) entry.getKey();
+				if (key.startsWith(type)) { // 如果匹配则删除掉
+					arr.add(key);
+				}
+			}
+			for (int k = 0; k < arr.size(); k++) {
+				clearOnly(arr.get(k));
+			}
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+	}
+
+	// 清除指定的缓存
+	public synchronized static void clearOnly(String key) {
+		cacheMap.remove(key);
+	}
+
+	// 载入缓存
+	public synchronized static void putCache(String key, Cache obj) {
+		cacheMap.put(key, obj);
+	}
+
+	// 获取缓存信息
+	public static Cache getCacheInfo(String key) {
+		if (hasCache(key)) {
+			Cache cache = getCache(key);
+			if (cacheExpired(cache)) { // 调用判断是否终止方法
+				cache.setExpired(true);
+			}
+			return cache;
+		} else {
+			return null;
+		}
+	}
+
+	// 载入缓存信息
+	public static void putCacheInfo(String key, Cache obj, long dt, boolean expired) {
+		Cache cache = new Cache();
+		cache.setKey(key);
+		cache.setTimeOut(dt + System.currentTimeMillis()); // 设置多久后更新缓存
+		cache.setValue(obj);
+		cache.setExpired(expired); // 缓存默认载入时，终止状态为FALSE
+		cacheMap.put(key, cache);
+	}
+
+	// 重写载入缓存信息方法
+	public static void putCacheInfo(String key, Cache obj, long dt) {
+		Cache cache = new Cache();
+		cache.setKey(key);
+		cache.setTimeOut(dt + System.currentTimeMillis());
+		cache.setValue(obj);
+		cache.setExpired(false);
+		cacheMap.put(key, cache);
+	}
+
+	// 判断缓存是否终止
+	public static boolean cacheExpired(Cache cache) {
+		if (null == cache) { // 传入的缓存不存在
+			return false;
+		}
+		long nowDt = System.currentTimeMillis(); // 系统当前的毫秒数
+		long cacheDt = cache.getTimeOut(); // 缓存内的过期毫秒数
+		if (cacheDt <= 0 || cacheDt > nowDt) { // 过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE
+			return false;
+		} else { // 大于过期时间 即过期
+			return true;
+		}
+	}
+
+	// 获取缓存中的大小
+	public static int getCacheSize() {
+		return cacheMap.size();
+	}
+
+	// 获取指定的类型的大小
+	public static int getCacheSize(String type) {
+		int k = 0;
+		Iterator<Entry<String, Object>> i = cacheMap.entrySet().iterator();
+		String key;
+		try {
+			while (i.hasNext()) {
+				Entry<String, Object> entry = i.next();
+				key = (String) entry.getKey();
+				if (key.indexOf(type) != -1) { // 如果匹配则删除掉
+					k++;
+				}
+			}
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+
+		return k;
+	}
+
+	// 获取缓存对象中的所有键值名称
+	public static ArrayList<String> getCacheAllkey() {
+		ArrayList<String> a = new ArrayList<String>();
+		try {
+			Iterator<Entry<String, Object>> i = cacheMap.entrySet().iterator();
+			while (i.hasNext()) {
+				Entry<String, Object> entry = i.next();
+				a.add((String) entry.getKey());
+			}
+		} catch (Exception ex) {
+		}
+		return a;
+	}
+
+	// 获取缓存对象中指定类型 的键值名称
+	public static ArrayList<String> getCacheListkey(String type) {
+		ArrayList<String> a = new ArrayList<String>();
+		String key;
+		try {
+			Iterator<Entry<String, Object>> i = cacheMap.entrySet().iterator();
+			while (i.hasNext()) {
+				Entry<String, Object> entry = i.next();
+				key = (String) entry.getKey();
+				if (key.indexOf(type) != -1) {
+					a.add(key);
+				}
+			}
+		} catch (Exception ex) {
+		}
+		return a;
+	}
+}

src/main/java/osc/git/eh3/cache/SimpleCache.java

@@ -0,0 +1,50 @@
+package osc.git.eh3.cache;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public final class SimpleCache<K, V> {
+
+	private final Lock lock = new ReentrantLock();
+	private final int maxCapacity;
+	private final Map<K, V> eden;
+	private final Map<K, V> perm;
+
+	public SimpleCache(int maxCapacity) {
+		this.maxCapacity = maxCapacity;
+		this.eden = new ConcurrentHashMap<K, V>(maxCapacity);
+		this.perm = new WeakHashMap<K, V>(maxCapacity);
+	}
+
+	public V get(K k) {
+		V v = this.eden.get(k);
+		if (v == null) {
+			lock.lock();
+			try {
+				v = this.perm.get(k);
+			} finally {
+				lock.unlock();
+			}
+			if (v != null) {
+				this.eden.put(k, v);
+			}
+		}
+		return v;
+	}
+
+	public void put(K k, V v) {
+		if (this.eden.size() >= maxCapacity) {
+			lock.lock();
+			try {
+				this.perm.putAll(this.eden);
+			} finally {
+				lock.unlock();
+			}
+			this.eden.clear();
+		}
+		this.eden.put(k, v);
+	}
+}

src/main/java/osc/git/eh3/cache/Test.java

@@ -0,0 +1,17 @@
+package osc.git.eh3.cache;
+
+public class Test {
+
+	public static void main(String[] args) {
+		SimpleCache<String, Object> cache = new SimpleCache<>(5);
+		
+		for (int i = 0; i < 10; i++) {
+			cache.put(""+i, i);
+		}
+		
+		for (int i = 0; i < 10; i++) {
+		
+			System.out.println(cache.get(i+""));
+		}
+	}
+}

src/main/java/osc/git/eh3/cache/TestCache.java

@@ -0,0 +1,32 @@
+package osc.git.eh3.cache;
+
+import java.util.ArrayList;
+
+public class TestCache {
+	public static void main(String[] args) {
+		System.out.println(CacheManager.getSimpleFlag("alksd"));
+		CacheManager.putCache("abc", new Cache("key", "value", 10, false));
+		CacheManager.putCache("def", new Cache());
+		CacheManager.putCache("ccc", new Cache());
+		CacheManager.clearOnly("");
+		Cache c = new Cache();
+		for (int i = 0; i < 10; i++) {
+			CacheManager.putCache("" + i, c);
+		}
+		CacheManager.putCache("aaaaaaaa", c);
+		CacheManager.putCache("abchcy;alskd", c);
+		CacheManager.putCache("cccccccc", c);
+		CacheManager.putCache("abcoqiwhcy", c);
+		System.out.println("删除前的大小：" + CacheManager.getCacheSize());
+		ArrayList<String> cacheAllkey = CacheManager.getCacheAllkey();
+		for (String key : cacheAllkey) {
+			System.out.println(key + ":" + CacheManager.getCacheInfo(key).getValue());
+		}
+		CacheManager.clearAll("aaaa");
+		System.out.println("删除后的大小：" + CacheManager.getCacheSize());
+		cacheAllkey = CacheManager.getCacheAllkey();
+		for (String key : cacheAllkey) {
+			System.out.println(key);
+		}
+	}
+}

src/main/java/osc/git/eh3/test/TestAudiQ2.java

@@ -0,0 +1,11 @@
+package osc.git.eh3.test;
+
+import osc.git.eh3.utils.HttpClientUtil;
+
+public class TestAudiQ2 {
+	public static String URL = "http://127.0.0.1:8080/Audi2016Q2Wap/getUserInfo";
+
+	public static void main(String[] args) throws Exception {
+		System.out.println(HttpClientUtil.sendPostJSONData(URL, ""));
+	}
+}

src/main/java/osc/git/eh3/testminisite/TestMinisite.java

@@ -0,0 +1,34 @@
+package osc.git.eh3.testminisite;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import osc.git.eh3.utils.HttpClientUtil;
+
+public class TestMinisite {
+	public static String URL = "http://127.0.0.1:8080/dsp-minisite/Audi2016Q2/getProvinces";
+
+	public static void main(String[] args) throws Exception {
+		Map<String, String> params = new HashMap<>();
+		params.put("project","1");
+		params.put("bid","1");
+		params.put("mapid","1");
+		params.put("name","1");
+		params.put("gender","1");
+		params.put("tel","1");
+		params.put("favoriteModel","1");
+		params.put("province","1");
+		params.put("city","1");
+		params.put("dealerName","1");
+		params.put("dealerCode","1");
+		params.put("scheduledTime","1");
+		params.put("budget","1");
+		
+		params.put("provinceName","北京");
+		params.put("cityName","北京");
+		
+//		System.out.println(HttpClientUtil.sendPostParam(URL, params));
+		System.out.println(HttpClientUtil.sendGet(URL));
+	}
+
+}