/**
 * 抽象对象接口
 */
public interface Subject {
    /**
     * 声明需要被代理的方法
     * 让代理对象来帮我们买一台Switch
     */
    public void buySwitch();
}

/**
 * 真实对象
 */
public class RealSubject implements Subject {
    /**
     * 我只想买一台Switch
     */
    @Override
    public void buySwitch() {
        System.out.println("我只想买一台Switch");
    }
}

**
 * 代理对象（代购）
 */
public class Proxy implements Subject {
    @Override
    public void buySwitch() {
        //引用并创建真实对象实例
        RealSubject realSubject = new RealSubject();
        //调用真实对象的方法，进行代理购买Switch
        realSubject.buySwitch();
        //代购进行一些额外的操作
        this.buyGameCard();
    }
    /**
     * 顺便买一些游戏卡
     */
    private void buyGameCard() {
        System.out.println("再顺便买一些游戏卡");
    }
}

/**
 * 客户端调用
 */
public class Run {
    public static void main(String[] args){
        Subject proxy = new Proxy();
        proxy.buySwitch();
    }
}

/**
 * JDK动态代理
 */
public class DynamicHandler implements InvocationHandler {
    // 真实对象
    private Object targetObject;
    // 创建代理对象 这段也可以不在此类，也可以放在客户端里面
    public Object createProxy(Object targetOjbect) {
        this.targetObject = targetOjbect;
        /*
         * 创建代理对象
         * Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
         * loader：代理类的类加载器
         * interfaces：指定代理类所实现的接口
         * h：动态代理对象在调用方法的时候，关联的InvocationHandler对象
         */
        return Proxy.newProxyInstance(targetOjbect.getClass().getClassLoader(),
                targetOjbect.getClass().getInterfaces(), this);
    }
    /**
     * InvocationHandler接口所定义的唯一的一个方法，该方法负责集中处理动态代理类上的所有方法的调用。
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上执行
     *
     * @param proxy  代理类的实例
     * @param method 代理类被调用的方法
     * @param args   调用方法的参数
     * @return Object
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //触发真实对象之前或者之后可以做一些额外操作
        Object result = null;
        System.out.println("method:" + method.getName() + " proxy:" + proxy.getClass().getName());
        result = method.invoke(this.targetObject, args);//通过反射执行某个类的某方法
        this.buyGameCard();
        return result;
    }
    /**
     * 顺便买一些游戏卡
     */
    private void buyGameCard() {
        System.out.println("再顺便买一些游戏卡");
    }
}

/**
 * 客户端调用
 */
public class Run {
    public static void main(String[] args) throws Exception  {
        DynamicHandler dynamicHandler = new DynamicHandler();
        Subject subject = (Subject) dynamicHandler.createProxy(new RealSubject());
        subject.buySwitch();
        subject.buyPS4();
    }
}

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        /*
         * 生成指定的代理类
         */
        Class<?> cl = getProxyClass0(loader, intfs);
        /*
         * 调用代理类的构造函数
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

public class DynamicHandler implements MethodInterceptor {
    private Object target;//业务类对象，供代理方法中进行真正的业务方法调用
    //相当于JDK动态代理中的绑定
    public Object getInstance(Object target) {
        this.target = target;  //给业务对象赋值
        Enhancer enhancer = new Enhancer(); //创建加强器，用来创建动态代理类
        enhancer.setSuperclass(this.target.getClass());  //为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
        //设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
        enhancer.setCallback(this);
        // 创建动态代理类对象并返回
        return enhancer.create();
    }
    // 实现回调方法
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        proxy.invokeSuper(obj, args); //调用业务类（父类中）的方法
        this.buyGameCard();
        return null;
    }
    /**
     * 顺便买一些游戏卡
     */
    private void buyGameCard() {
        System.out.println("再顺便买一些游戏卡");
    }
}

/**
 * 客户端调用
 */
public class Run {
    public static void main(String[] args) throws Exception  {
        DynamicHandler handler = new DynamicHandler();
        RealSubject subject = (RealSubject) handler.getInstance(new RealSubject());
        subject.buySwitch();
        subject.buyPS4();
    }
}

/**
 * 前置增强
 */
public interface BeforeAdvice {
    public void before();
}

/**
 * 后置增强
 */
public interface AfterAdvice {
    public void after();
}

/**
 * JDK动态代理
 */
public class DynamicHandler implements InvocationHandler {
    // 真实对象
    private Object targetObject;
    //前值增强
    private BeforeAdvice beforeAdvice;
    //后置增强
    private AfterAdvice afterAdvice;
    public BeforeAdvice getBeforeAdvice() {
        return beforeAdvice;
    }
    public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
        this.beforeAdvice = beforeAdvice;
    }
    public AfterAdvice getAfterAdvice() {
        return afterAdvice;
    }
    public void setAfterAdvice(AfterAdvice afterAdvice) {
        this.afterAdvice = afterAdvice;
    }
    // 创建代理对象 这段也可以不在此类，也可以放在客户端里面
    public Object createProxy(Object targetOjbect) {
        this.targetObject = targetOjbect;
        /*
         * 创建代理对象
         * Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
         * loader：代理类的类加载器
         * interfaces：指定代理类所实现的接口
         * h：动态代理对象在调用方法的时候，关联的InvocationHandler对象
         */
        return Proxy.newProxyInstance(targetOjbect.getClass().getClassLoader(),
                targetOjbect.getClass().getInterfaces(), this);
    }
    /**
     * InvocationHandler接口所定义的唯一的一个方法，该方法负责集中处理动态代理类上的所有方法的调用。
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上执行
     *
     * @param proxy  代理类的实例
     * @param method 代理类被调用的方法
     * @param args   调用方法的参数
     * @return Object
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //触发真实对象之前或者之后可以做一些额外操作
        Object result = null;
        if(beforeAdvice != null) {
            beforeAdvice.before();
        }
        result = method.invoke(this.targetObject, args);//通过反射执行某个类的某方法
        if(afterAdvice != null) {
            afterAdvice.after();
        }
        return result;
    }
}

/**
 * 客户端调用
 */
public class Run {
    public static void main(String[] args) throws Exception  {
        DynamicHandler dynamicHandler = new DynamicHandler();
        Subject subject = (Subject) dynamicHandler.createProxy(new RealSubject());
        dynamicHandler.setBeforeAdvice(new BeforeAdvice() {
            @Override
            public void before() {
                System.out.println("听说任天堂出了一款不错的游戏，所以。。。");
            }
        });
        dynamicHandler.setAfterAdvice(new AfterAdvice() {
            @Override
            public void after() {
                System.out.println("再买点游戏卡");
            }
        });
        subject.buySwitch();
    }
}

/**
 * 单例模式 (饿汉式)
 */
public final class HungerSingleton {
    /**
     * 杜绝外面直接new 只有一种获取方式
     */
    private HungerSingleton() {}
    /**
     * 实例化
     */
    private static final HungerSingleton INSTANCE = new HungerSingleton();
    /**
     * 获取实例
     */
    public static HungerSingleton getInstance() {
        return INSTANCE;
    }
}

/**
 * 单例模式 (懒汉式)
 */
public final class LazySingleton {
    /**
     * 杜绝外面直接new 只有一种获取方式
     */
    private LazySingleton() {}
    /**
     * 实例化
     */
    private static volatile LazySingleton INSTANCE;
    /**
     * 获取实例
     */
    public static LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

/**
 * 单例模式 (懒汉式)
 */
public final class LazySingleton {
    /**
     * 杜绝外面直接new 只有一种获取方式
     */
    private LazySingleton() {}
    /**
     * 实例化
     */
    private static volatile LazySingleton INSTANCE;
    /**
     * 获取实例（双重检查）
     */
    public static LazySingleton getInstance() {
        if (INSTANCE == null){
            synchronized (LazySingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new LazySingleton();
                }
            }
        }
        return INSTANCE;
    }
}

/**
 * 枚举是天然单例
 */
public enum EnumSingleton {
    INSTANCE;
    @Override
    public String toString() {
        return super.toString();
    }
}

/**
 * 影片
 *
 * @author vayi
 * @date 2018/7/30
 * @since 0.0.1
 */
public class Movie {
    public static final int regular = 0; //常规片
    public static final int new_release = 1; //新片
    public static final int childrens = 2; //儿童片
    private String title;
    private int priceCode;
    public Movie(String title, int priceCode) {
        super();
        this.title = title;
        this.priceCode = priceCode;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public int getPriceCode() {
        return priceCode;
    }
    public void setPriceCode(int priceCode) {
        this.priceCode = priceCode;
    }
}

/**
 * 租赁
 *
 * @author vayi
 * @date 2018/7/30
 * @since 0.0.1
 */
public class Rental {
    
    private Movie movie; // 租的电影
    private int dayRented; // 租的时间
    public Rental(Movie movie, int dayRented) {
        super();
        this.movie = movie;
        this.dayRented = dayRented;
    }
    public Movie getMovie() {
        return movie;
    }
    public int getDayRented() {
        return dayRented;
    }
}

/**
 * 消费者
 *
 * @author vayi
 * @date 2018/7/30
 * @since 0.0.1
 */
public class Customer {
    private Vector rentals = new Vector(); // 存租的影片
    private String name;
    public Customer(String name) {
        super();
        this.name = name;
    }
    public void addRental(Rental arg) {
        rentals.addElement(arg);
    }
    public String getName() {
        return name;
    }
    public String statement() {
        double totalAmount = 0;
        int frequentRenterPoints = 0;
        Enumeration rentalss = rentals.elements();
        String result = "RentalNew Record for" + " " + getName() + "\n";
        while (rentalss.hasMoreElements()) {
            double thisAmount = 0;
            Rental each = (Rental) rentalss.nextElement();
            switch (each.getMovie().getPriceCode()) {
                case Movie.regular:
                    thisAmount += 2;
                    if (each.getDayRented() > 2)
                        thisAmount += (each.getDayRented() - 2) * 1.5;
                    break;
                case Movie.new_release:
                    thisAmount += each.getDayRented() * 3;
                    break;
                case Movie.childrens:
                    thisAmount += 1.5;
                    if (each.getDayRented() > 3)
                        thisAmount += (each.getDayRented() - 3) * 1.5;
                    break;
            }
            //积分  每借一张加1个积分
            frequentRenterPoints++;
            //积分累加条件  新版本的片子,借的时间大于1天
            if ((each.getMovie().getPriceCode() == Movie.new_release) && each.getDayRented() > 1) {
                frequentRenterPoints++;
            }
            result += "\t" + each.getMovie().getTitle() + "\t"
                    + String.valueOf(thisAmount) + "\n";
            totalAmount += thisAmount;
        }
        result += "Amount owed is " + String.valueOf(totalAmount) + "\n";
        result += "You earned " + String.valueOf(frequentRenterPoints) + " "
                + "frequent renter points";
        return result;
    }
}

/**
 * 测试类
 *
 * @author vayi
 * @date 2018/7/30
 * @since 0.0.1
 */
class test01 {
    public static void main(String[] args) {
        System.out.println("=========================重构前结果=========================");
        Movie mov = new Movie("xxx", 2);
        Rental ren = new Rental(mov, 8);
        Customer cus = new Customer("Cheng");
        cus.addRental(ren);
        System.out.println(cus.statement());
        System.out.println("=========================重构前结果=========================");
        System.out.println("=========================重构后结果=========================");
        MovieNew newMov = new MovieNew("xxx", 2);
        RentalNew newRen = new RentalNew(newMov, 8);
        CustomerNew cusNew = new CustomerNew("Cheng");
        cusNew.addRentalNew(newRen);
        System.out.println(cusNew.statement());
        System.out.println("=========================重构后结果=========================");
    }
}

package com.hc.thread.chapterOne.SemaPhore;
import java.util.concurrent.Semaphore;
/**
 * 同一时间内  限制多个线程通过
 */
public class SemaPhoreT {
    private Semaphore semaphore = new Semaphore(1);
    public void testMethod() {
        try {
            //限制
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + " begin time:" + System.currentTimeMillis());
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " end time:" + System.currentTimeMillis());
            //释放
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
        SemaPhoreT semaPhoreT = new SemaPhoreT();
        new Thread(new Runnable() {
            @Override
            public void run() {
                semaPhoreT.testMethod();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                semaPhoreT.testMethod();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                semaPhoreT.testMethod();
            }
        }).start();
    }

package com.hc.thread.chapterOne.SemaPhore;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
 *  Semaphore实现生产者、消费者
 *  created by cheng on 2018/5/16
 */
public class RepastService {
    /**
     * 设置5个厨师（生产者）
     */
    private volatile Semaphore setSemaphore = new Semaphore(5);
    /**
     * 设置10个顾客（消费者）
     */
    private volatile Semaphore getSemaphore = new Semaphore(10);
    private volatile ReentrantLock reentrantLock = new ReentrantLock();
    private volatile Condition setCondition = reentrantLock.newCondition();
    private volatile Condition getCondition = reentrantLock.newCondition();
    /**
     * 最多一次上4盘菜
     */
    private volatile Object[] producePosition = new Object[4];
    private boolean isEmpty() {
        boolean isEmpty = true;
        for (int i = 0; i < producePosition.length; i++) {
            if (producePosition[i] != null) {
                isEmpty = false;
                break;
            }
        }
        return  isEmpty;
    }
    /**
     * 判断有没有空盘子
     * @return true：没有空盘子 反之则有
     */
    private boolean isFull() {
        boolean isFull = true;
        for (int i = 0; i < producePosition.length; i++) {
            if (producePosition[i] == null) {
                isFull = false;
                break;
            }
        }
        return  isFull;
    }
    public void set() {
        try {
            setSemaphore.acquire();
            reentrantLock.lock();
            while (isFull()) {
                //没有空盘子  厨师要等待
                setCondition.await();
            }
            for (int i = 0; i < producePosition.length; i++) {
                if (producePosition[i] == null) {
                    //发现有空盘子了  可以上菜
                    producePosition[i] = "xx菜";
                    System.out.println(Thread.currentThread().getName() + " 生产了 " + producePosition[i]);
                    break;
                }
            }
            //上菜
            getCondition.signalAll();
            reentrantLock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            setSemaphore.release();
        }
    }
    public void get() {
        try {
            getSemaphore.acquire();
            reentrantLock.lock();
            while (isEmpty()) {
                //菜已经上齐了  没盘子装了  吃完了才能上
                getCondition.await();
            }
            for (int i = 0; i < producePosition.length; i++) {
                if (producePosition[i] != null) {
                    //发现有菜上来  可以开饭了
                    System.out.println(Thread.currentThread().getName() + " 消费了 " + producePosition[i]);
                    producePosition[i] = null;
                    break;
                }
            }
            //端盘子下去
            setCondition.signalAll();
            reentrantLock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            getSemaphore.release();
        }
    }
}

package com.hc.thread.chapterOne.SemaPhore;
public class Run {
    public static void main(String[] args) throws InterruptedException {
        RepastService repastService = new RepastService();
        ThreadP[] arrayP = new ThreadP[20];
        ThreadC[] arrayC = new ThreadC[20];
        for (int i = 0; i < 20; i++) {
            arrayP[i] = new ThreadP(repastService);
            arrayC[i] = new ThreadC(repastService);
        }
        Thread.sleep(2000);
        for (int i = 0; i < 20; i++) {
            arrayP[i].start();
            arrayC[i].start();
        }
    }
}

package com.hc.thread.chapterOne.SemaPhore;
public class ThreadP extends Thread {
    private RepastService service;
    public ThreadP(RepastService service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.set();
    }
}

package com.hucheng.xmlParse;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class XmlUtils
{
    
    public static void main(String[] args)
    {
        long lasting = System.currentTimeMillis();
        try
        {
            //获取xml文件
            File f = new File("data.xml");
            SAXReader reader = new SAXReader();
            Document doc = reader.read(f);
            //获取到根节点
            Element node = doc.getRootElement();
            //判断跟节点下面是否还有子节点
            if (node.elementIterator().hasNext())
            {
                Element next = (Element)node.elementIterator().next();
            }
            Iterator<Element> iterator = node.elementIterator();
            //开始循环子节点
            while(iterator.hasNext()){  
                Element e = iterator.next();  
                listNodes(e);
            }  
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");
    }
    
    /**
     * @描述：循环子节点
     * @作者：chen
     * @时间：2017年8月17日 上午10:53:06
     * @param node
     */
    protected static void listNodes(Element node)
    {
        //首先获取当前节点的所有属性节点  
        List<Attribute> list = node.attributes();  
        //遍历属性节点  
        for(Attribute attribute : list){  
            System.out.println("属性"+attribute.getName() +":" + attribute.getValue());  
        }  
        //如果当前节点内容不为空，则输出  
        if(!(node.getTextTrim().equals(""))){
             System.out.println( node.getName() + "：" + node.getText());
        }  
        
        //同时迭代当前节点下面的所有子节点  
        //使用递归  
        Iterator<Element> iterator = node.elementIterator();  
        while(iterator.hasNext()){  
            Element e = iterator.next();  
            listNodes(e);  
        }  
    }
}