package com.climbran.spring.controller;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.apache.http.client.HttpClient;


import javax.servlet.http.HttpServletResponse;

/**
 * Created by swe on 15/10/26.
 */
@Controller
@RequestMapping("ajax")
public class AjaxTestController {

    @RequestMapping("getHTML")
    @ResponseBody
    public String getHTML(HttpServletResponse response){

        HttpClient httpclient = new DefaultHttpClient(new ThreadSafeClientConnManager());//创建一个客户端，类似打开一个浏览器
        HttpGet httpGet = new HttpGet("http://404.58.com/");
        String html = null;
        try {
            HttpResponse res = httpclient.execute(httpGet);
            HttpEntity entity = res.getEntity();
            html = EntityUtils.toString(entity);
            System.out.println(res.getStatusLine().getStatusCode());
            System.out.println(html);
        }
        catch (Exception e){
            e.printStackTrace();

        }
        response.setContentType("text/html;charset=UTF-8");
        return html;
    }
}

package com.climbran.designPatterns.proxy;

/**
 * Created by swe on 15/9/22.
 * 业务接口
 */
public interface Subject {

    public void doSomething(String str);
}

package com.climbran.designPatterns.proxy;

/**
 * Created by swe on 15/9/22.
 * 被代理类
 */
public class RealSubject implements Subject {

    //实际业务
    public void doSomething(String str){
        System.out.println("do something: " +str);
    }
}

package com.climbran.designPatterns.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * Created by swe on 15/9/22.
 * 业务处理类，对被代理对象操作进行处理
 */
public class DynamicProxyHandle implements InvocationHandler {
    private Object targer = null;

    public DynamicProxyHandle(Object obj){
        targer = obj;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{

        if(method.getName().equalsIgnoreCase("doSomething")) //设置point cut
            new BeforeAdvice().exec();      //执行前置通知(advie)

        return method.invoke(targer, args);
    }

}

package com.climbran.designPatterns.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * Created by ywq on 15/9/22.
 * 代理类
 */
public class DynamicProxy<T> {
    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler){
        //这里也可以设置一个aspect(aspect = point cut + advice)

        //根据传入的loader和interfaces生成代理对象的方法,并且生成的方法通过handler的invoke函数处理,返回代理对象
        return (T) Proxy.newProxyInstance(loader, interfaces, handler);
    }
}

package com.climbran.designPatterns.proxy;

/**
 * Created by ywq on 15/9/22.
 */
public interface IAdvice {
    public void exec();
}

package com.climbran.designPatterns.proxy;


/**
 * Created by ywq on 15/9/22.
 */
public class BeforeAdvice implements IAdvice {
    public void exec(){
        System.out.println("do before advice");
    }
}

package com.climbran.designPatterns.proxy;

import java.lang.reflect.InvocationHandler;

/**
 * Created by swe on 15/9/22.
 */
public class Client {

    public static void main(String[] args){
        Subject subject = new RealSubject();

        InvocationHandler handler = new DynamicProxyHandle(subject);

        Class<?> cla = subject.getClass();
        Subject proxy = DynamicProxy.newProxyInstance(cla.getClassLoader(), cla.getInterfaces(),handler);

        proxy.doSomething("test");
    }

}

public class RealSubject implements Subject{
	private String topic = "";
	
	public RealSubject(String topic){
		this.topic = topic;
	}
	public void doSomething(){
		System.out.println("do " + topic);
	}
}

public class Proxy implements Subject{
	private Subject subject = null;
	
	public Proxy(Subject subject){
		this.subject = subject;
	}
	
	public void doSomething(){
		this.before();
		this.subject.doSomething();
		this.after();
	}
	
	private void before(){
		//TODO: do something
	}
	
	private void after(){
		//TODO: do something
	}

}

public class RealSubject implements Subject{
	private String topic = "";
	
	public RealSubject(Subject _subject,String topic){
		if(_subject == null){
			throw new Exception("不能创建真实角色");//传入参数用来约束不能直接new一个实力，也可以通过团队内约定来实现
		}
	}
	public void doSomething(){
		System.out.println("do " + topic);
	}
}

public class Proxy implements Subject{
	private Subject subject = null;
	
	public Proxy(String topic){
		try{
			subject = new RealSubject(this,topic);
		}catch(Exception e){
			//TODO: 异常处理 
		}
	}
	
	public void doSomething(){
		this.before();
		this.subject.doSomething();
		this.after();
	}
	
	private void before(){
		//TODO: do something
	}
	
	private void after(){
		//TODO: do something
	}

}

public class RealSubject implements Subject{
	private String topic = "";
	private Subject proxy = null;
	
	public RealSubject(String topic){
		this.topic = topic;
	}
	
	public Subject getProxy(){
		this.proxy = new Proxy(this);
		return this.proxy;
	}
	
	public void doSomething(){
		if(isProxy())
			System.out.println("do " + topic);
		else
			System.out.println("error: please use proxy");
	}
	
	//判断是否是通过代理调用，其实调用getProxy方法后不通过代理也可以直接调用其他方法，和普通代理不能直接new一个被代理对象的约束一样，可通过团队内约定来约束
	private boolean isProxy(){
		return proxy==null?false:true;
	}
}

public class Proxy implements Subject,Accountant{
	private Subject subject = null;
	
	public Proxy(Subject subject){
		this.subject = subject;
	}
	
	public doSomething(){
		subject.doSomething();
		this.count();
	}
	publiv Subject getProxy(){
		return this;
	}
	
	public void count(){
		//TODO: do something
	}
}

package com.climbran.jms;

import javax.jms.Destination;
import org.springframework.jms.core.JmsTemplate;

/**
 * JMS消息生产者.
 * @author swe
 */

public class Producer {

	private JmsTemplate jmsTemplate;
	private Destination notifyQueue;
	private Destination notifyTopic;

	public void sendQueue(final String message) {
		sendMessage(message, notifyQueue);
	}

	public void sendTopic(final String message) {
		sendMessage(message, notifyTopic);
	}

	private void sendMessage(String message, Destination destination) {

		jmsTemplate.convertAndSend(destination, message);
	}

	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}

	public void setNotifyQueue(Destination notifyQueue) {
		this.notifyQueue = notifyQueue;
	}

	public void setNotifyTopic(Destination nodifyTopic) {
		this.notifyTopic = nodifyTopic;
	}
}

producer.sendTopic("a topic message");
   producer.sendQueue("a queue message");

ConnectionFactory factory = new ActiveMQConnectionFactory("vm://localhost");
Queue queue = new ActiveMQQueue("demoQueue");

Connection connection = factory.createConnection();
connection.start();

Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);

Message message = session.createTextMessage("Hello world");
MessageProducer producer = session.createProducer(queue);
producer.send(message);

MessageConsumer consumer = session.createConsumer(queue);
Message receive = comsumer.receive();

public class Singleton{
	private static final Singleton instance = new Singleton();
	
	private	Singleton(){
	}
	
	public static Singleton getInstance(){
		return instance;
	}
	
	//other method

}

public class Singleton{
	private static Singleton instance = null;
	
	private	Singleton(){
	}
	
	public static Singleton getInstance(){
		synchronized(Singleton.class){
			return instance==null?new Singleton:instance;
		}
	}
	
	//other method

}

public class Singleton{
	private static Singleton instance = null;
	
	private	Singleton(){
	}
	
	public static Singleton getInstance(){
		if(instance==null){
			synchronized(Singleton.class){
				if(instance==null)
					return new Singleton();
			}
		}
		return instance
	}
	
	//other method

}

Object o1 = new Object();
Object o2 = new Object();

synchronized(o1){
	//block1
}

synchronized(o1){
	//block2
}

synchronized(o2){
	//block3
}

class SynchronizedDemo{

	public void synchronized method1()	{//TODO} 
			
	public void method2()	{synchronized1(this){//TODO} }
	//method1效果等价于method2
	
	public static void synchronized method3(){//TODO} 
		
	public static void method4(){synchronized(SynchronizedDemo.class){//TODO} }
	//method3效果等价于method4
	
}

boolean hasNext(); //是否有下一个元素
E next();	//返回的下一个元素
remove()  //移除迭代器返回的最后一个元素

int size();
boolean isEmpty();
boolean contains(Object o);
Object[] toArray();
<T> T[] toArray(T[] a); 
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
/*retainAll于从列表中移除未包含在指定collection中的所有元素
如果List集合对象由于调用retainAll方法而发生更改，则返回 true*/
void clear();
boolean equals(Object o);
int hashCode();

get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator<E> listIterator();	  //比Interator多了hasPrevious、previous、nextIndex、previousIndex、set、add;
List<E> subList(int fromIndex, int toIndex);	//返回一个子list，注意对子list的操作会影响到原来的list

boolean offer(E e);		//添加一个元素并返回true       如果队列已满，则返回false
E remove();	// 移除并返问队列头部的元素,如果队列为空，则抛出一个NoSuchElementException
E poll();	//移除并返问队列头部的元素,如果队列为空，则返回null
E element();	//返回队列头部的元素,如果队列为空，则抛出一个NoSuchElementException异常
E peek();		//返回队列头部的元素,如果队列为空，则返回null

int size();
boolean isEmpty();
boolean containsKey(Object key);
boolean containsValue(Object value);
V get(Object key);
V put(K key, V value);
V remove(Object key);
void putAll(Map<? extends K, ? extends V> m);
void clear();
Set<K> keySet();	//返回key组成的一个set,多次调用返回同一个引用,该Set支持删除操作，不支持add、addAll，能影响到Map;
Collection<V> values();
Set<Map.Entry<K, V>> entrySet();
default boolean replace(K key, V oldValue, V newValue);
default V replace(K key, V value)	//如果map中已有key则覆盖，没有则返回null

E getFirst();
E getLast();
E removeFirst();
E removeLast();
void addFirst(E e);
void addLast(E e);

package com.climbran.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.JedisPool;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Tuple;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.jedis.exceptions.JedisException;

/**
 * JedisTemplate 提供了一个template方法，负责对Jedis连接的获取与归还。
 * JedisAction<T> 和 JedisActionNoResult两种回调接口，适用于有无返回值两种情况。
 */
public class JedisTemplate {

    private static Logger logger = LoggerFactory.getLogger(JedisTemplate.class);

    private JedisPool jedisPool;

    public JedisTemplate(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * Callback interface for template.
     */
    public interface JedisAction<T> {
        T action(Jedis jedis);
    }

    /**
     * Callback interface for template without result.
     */
    public interface JedisActionNoResult {
        void action(Jedis jedis);
    }

    /**
     * Execute with a call back action with result.
     */
    public <T> T execute(JedisAction<T> jedisAction) throws JedisException {
        Jedis jedis = null;
        boolean broken = false;
        try {
            jedis = jedisPool.getResource();
            return jedisAction.action(jedis);
        } catch (JedisException e) {
            broken = handleJedisException(e);
            throw e;
        } finally {
            closeResource(jedis, broken);
        }
    }

    /**
     * Execute with a call back action without result.
     */
    public void execute(JedisActionNoResult jedisAction) throws JedisException {
        Jedis jedis = null;
        boolean broken = false;
        try {
            jedis = jedisPool.getResource();
            jedisAction.action(jedis);
        } catch (JedisException e) {
            broken = handleJedisException(e);
            throw e;
        } finally {
            closeResource(jedis, broken);
        }
    }

  
    /**
     * Handle jedisException, write log and return whether the connection is broken.
     */
    protected boolean handleJedisException(JedisException jedisException) {
        if (jedisException instanceof JedisConnectionException) {
            logger.error("Redis connection " + jedisPool + " lost.", jedisException);
        } else if (jedisException instanceof JedisDataException) {
            if ((jedisException.getMessage() != null) && (jedisException.getMessage().indexOf("READONLY") != -1)) {
                logger.error("Redis connection " + jedisPool + " are read-only slave.", jedisException);
            } else {
                // dataException, isBroken=false
                return false;
            }
        } else {
            logger.error("Jedis exception happen.", jedisException);
        }
        return true;
    }

    /**
     * Return jedis connection to the pool, call different return methods depends on the conectionBroken status.
     */
    protected void closeResource(Jedis jedis, boolean conectionBroken) {
        try {
            if (conectionBroken) {
                jedisPool.returnBrokenResource(jedis);
            } else {
                jedisPool.returnResource(jedis);
            }
        } catch (Exception e) {
            logger.error("return back jedis failed, will fore close the jedis.", e);
            JedisUtils.destroyJedis(jedis);
        }

    }

    // / Common Actions ///
    public Boolean del(final String... keys) {
        return execute(new JedisAction<Boolean>() {

            @Override
            public Boolean action(Jedis jedis) {
                return jedis.del(keys) == keys.length ? true : false;
            }
        });
    }

    public void flushDB() {
        execute(new JedisActionNoResult() {

            @Override
            public void action(Jedis jedis) {
                jedis.flushDB();
            }
        });
    }

    // / String Actions ///
    public String get(final String key) {
        return execute(new JedisAction<String>() {

            @Override
            public String action(Jedis jedis) {
                return jedis.get(key);
            }
        });
    }

    public void set(final String key, final String value) {
        execute(new JedisActionNoResult() {

            @Override
            public void action(Jedis jedis) {
                jedis.set(key, value);
            }
        });
    }

	//Other Actions
	
	......
}

package com.climbran.redis;

import com.climbran.redis.JedisTemplate.JedisAction;
//import com.climbran.redis.pool.JedisPool;
import redis.clients.jedis.JedisPool;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.exceptions.JedisException;

public class JedisUtils {

	private static final String OK_CODE = "OK";
	private static final String OK_MULTI_CODE = "+OK";

	/**
	 * 判断 返回值是否ok.
	 */
	public static boolean isStatusOk(String status) {
		return (status != null) && (OK_CODE.equals(status) || OK_MULTI_CODE.equals(status));
	}

	/**
	 * 在Pool以外强行销毁Jedis.
	 */
	public static void destroyJedis(Jedis jedis) {
		if ((jedis != null) && jedis.isConnected()) {
			try {
				try {
					jedis.quit();
				} catch (Exception e) {
				}
				jedis.disconnect();
			} catch (Exception e) {
			}
		}
	}
}

import com.climbran.redis.JedisTemplate;

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisTest {

    public static void main(String[] args){
        JedisPool pool = new JedisPool(new JedisPoolConfig(),"localhost",6379);
        JedisTemplate template = new JedisTemplate(pool);
        template.set("foo","bar");
        System.out.println(template.get("foo"));
    }
}