sayi / sayi.github.com Goto Github PK

int a = 10;
// 无符号的高16位值
System.out.println(a >>> 16);

// 1111 1111 1111 1111
int mask = (1 << 16) - 1;
// 无符号的低16位值
System.out.println(a & mask);

// 高位加1
System.out.println((a + (1 << 16)) >>> 16);
// 低位加1
System.out.println((a + 1 ) & mask);

public class AtomicInteger extends Number implements java.io.Serializable {

  // setup to use Unsafe.compareAndSwapInt for updates
  private static final Unsafe unsafe = Unsafe.getUnsafe();
  private static final long valueOffset;

  static {
    try {
      valueOffset = unsafe.objectFieldOffset
        (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
  }

  private volatile int value;

public final int get() {
  return value;
}

public final void set(int newValue) {
  value = newValue;
}

 /**
 * Atomically sets the value to the given updated value
 * if the current value {@code ==} the expected value.
 *
 * @param expect the expected value
 * @param update the new value
 * @return {@code true} if successful. False return indicates that
 * the actual value was not equal to the expected value.
 */
public final boolean compareAndSet(int expect, int update) {
  return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final int getAndIncrement() {
  return unsafe.getAndAddInt(this, valueOffset, 1);
}
public final int getAndDecrement() {
  return unsafe.getAndAddInt(this, valueOffset, -1);
}
public final int getAndAdd(int delta) {
  return unsafe.getAndAddInt(this, valueOffset, delta);
}
public final int incrementAndGet() {
  return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
public final int getAndSet(int newValue) {
  return unsafe.getAndSetInt(this, valueOffset, newValue);
}
public final int decrementAndGet() {
  return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}

public final int getAndIncrement() {
  for (;;) {
    int current = get();
    int next = current + 1;
    if (compareAndSet(current, next))
      return current;
  }
}
public final boolean compareAndSet(int expect, int update) {
  return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

public class LockSupport {
  private LockSupport() {} // Cannot be instantiated.

  private static void setBlocker(Thread t, Object arg) {
    // Even though volatile, hotspot doesn't need a write barrier here.
    UNSAFE.putObject(t, parkBlockerOffset, arg);
  }

  public static void unpark(Thread thread) {
    if (thread != null)
      UNSAFE.unpark(thread);
  }

  public static void park(Object blocker) {
    Thread t = Thread.currentThread();
    setBlocker(t, blocker);
    UNSAFE.park(false, 0L);
    setBlocker(t, null);
  }

  public static void parkNanos(Object blocker, long nanos) {
    if (nanos > 0) {
      Thread t = Thread.currentThread();
      setBlocker(t, blocker);
      UNSAFE.park(false, nanos);
      setBlocker(t, null);
    }
  }

  public static void parkUntil(Object blocker, long deadline) {
    Thread t = Thread.currentThread();
    setBlocker(t, blocker);
    UNSAFE.park(true, deadline);
    setBlocker(t, null);
  }

  public static Object getBlocker(Thread t) {
    if (t == null)
      throw new NullPointerException();
    return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
  }

  public static void park() {
    UNSAFE.park(false, 0L);
  }

  public static void parkNanos(long nanos) {
    if (nanos > 0)
      UNSAFE.park(false, nanos);
  }

  public static void parkUntil(long deadline) {
    UNSAFE.park(true, deadline);
  }

  // Hotspot implementation via intrinsics API
  private static final sun.misc.Unsafe UNSAFE;
  private static final long parkBlockerOffset;
  private static final long SEED;
  private static final long PROBE;
  private static final long SECONDARY;
  static {
    try {
      UNSAFE = sun.misc.Unsafe.getUnsafe();
      Class<?> tk = Thread.class;
      parkBlockerOffset = UNSAFE.objectFieldOffset
        (tk.getDeclaredField("parkBlocker"));
      SEED = UNSAFE.objectFieldOffset
        (tk.getDeclaredField("threadLocalRandomSeed"));
      PROBE = UNSAFE.objectFieldOffset
        (tk.getDeclaredField("threadLocalRandomProbe"));
      SECONDARY = UNSAFE.objectFieldOffset
        (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
    } catch (Exception ex) { throw new Error(ex); }
  }
}

class FIFOMutex {
   private final AtomicBoolean locked = new AtomicBoolean(false);
   private final Queue<Thread> waiters
     = new ConcurrentLinkedQueue<Thread>();

   public void lock() {
     boolean wasInterrupted = false;
     Thread current = Thread.currentThread();
     waiters.add(current);

     // Block while not first in queue or cannot acquire lock
     while (waiters.peek() != current ||
            !locked.compareAndSet(false, true)) {
       LockSupport.park(this);
       if (Thread.interrupted()) // ignore interrupts while waiting
         wasInterrupted = true;
     }

     waiters.remove();
     if (wasInterrupted)          // reassert interrupt status on exit
       current.interrupt();
   }

   public void unlock() {
     locked.set(false);
     LockSupport.unpark(waiters.peek());
   }
 }

LinkedList<String> linkedListDeque = new LinkedList<>();
linkedListDeque.offer("hello");
linkedListDeque.offer("i");
linkedListDeque.offer("am");
linkedListDeque.offer("queue");

org.junit.Assert.assertEquals("hello", linkedListDeque.peek());
org.junit.Assert.assertEquals("hello", linkedListDeque.poll());

public interface Queue<E> extends Collection<E> {
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
}

private static final int DEFAULT_INITIAL_CAPACITY = 11;

public PriorityQueue(int initialCapacity) {
    this(initialCapacity, null);
}

public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    modCount++;
    int i = size;
    if (i >= queue.length)
        grow(i + 1);
    size = i + 1;
    if (i == 0)
        queue[0] = e;
    else
        siftUp(i, e);
    return true;
}

private void grow(int minCapacity) {
    int oldCapacity = queue.length;
    // Double size if small; else grow by 50%
    int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                     (oldCapacity + 2) :
                                     (oldCapacity >> 1));
    // overflow-conscious code
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    queue = Arrays.copyOf(queue, newCapacity);
}

public E peek() {
    return (size == 0) ? null : (E) queue[0];
}

public E poll() {
    if (size == 0)
        return null;
    int s = --size;
    modCount++;
    E result = (E) queue[0];
    E x = (E) queue[s];
    queue[s] = null;
    if (s != 0)
        siftDown(0, x);
    return result;
}

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

Node<E> node(int index) {
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

public boolean hasNext() {
    return nextIndex < size;
}

public E next() {
    checkForComodification();
    if (!hasNext())
        throw new NoSuchElementException();

    lastReturned = next;
    next = next.next;
    nextIndex++;
    return lastReturned.item;
}
final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

LinkedList<String> linkedListDeque = new LinkedList<>();
linkedListDeque.push("hello");
linkedListDeque.push("i");
linkedListDeque.push("am");
linkedListDeque.push("stack");
org.junit.Assert.assertEquals("stack", linkedListDeque.pop());

public interface Deque<E> extends Queue<E> {

    // *** deque methods ***
    void addFirst(E e);
    void addLast(E e);
    boolean offerFirst(E e);
    boolean offerLast(E e);
    E removeFirst();
    E removeLast();
    E pollFirst();
    E pollLast();
    E getFirst();
    E getLast();
    E peekFirst();
    E peekLast();
    boolean removeFirstOccurrence(Object o);
    boolean removeLastOccurrence(Object o);

    // *** Queue methods ***
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();

    // *** Stack methods ***
    void push(E e);
    E pop();

    // *** Collection methods ***
    boolean remove(Object o);
    boolean contains(Object o);
    public int size();
    Iterator<E> iterator();
    Iterator<E> descendingIterator();
}

private static final int MIN_INITIAL_CAPACITY = 8;

public ArrayDeque() {
    elements = new Object[16];
}
public ArrayDeque(int numElements) {
    allocateElements(numElements);
}

private void allocateElements(int numElements) {
    int initialCapacity = MIN_INITIAL_CAPACITY;
    // Find the best power of two to hold elements.
    // Tests "<=" because arrays aren't kept full.
    if (numElements >= initialCapacity) {
        initialCapacity = numElements;
        initialCapacity |= (initialCapacity >>>  1);
        initialCapacity |= (initialCapacity >>>  2);
        initialCapacity |= (initialCapacity >>>  4);
        initialCapacity |= (initialCapacity >>>  8);
        initialCapacity |= (initialCapacity >>> 16);
        initialCapacity++;

        if (initialCapacity < 0)   // Too many elements, must back off
            initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
    }
    elements = new Object[initialCapacity];
}

public void addFirst(E e) {
    if (e == null)
        throw new NullPointerException();
    elements[head = (head - 1) & (elements.length - 1)] = e;
    if (head == tail)
        doubleCapacity();
}

public void addLast(E e) {
    if (e == null)
        throw new NullPointerException();
    elements[tail] = e;
    if ( (tail = (tail + 1) & (elements.length - 1)) == head)
        doubleCapacity();
}

private void doubleCapacity() {
    assert head == tail;
    int p = head;
    int n = elements.length;
    int r = n - p; // number of elements to the right of p
    int newCapacity = n << 1;
    if (newCapacity < 0)
        throw new IllegalStateException("Sorry, deque too big");
    Object[] a = new Object[newCapacity];
    System.arraycopy(elements, p, a, 0, r);
    System.arraycopy(elements, 0, a, r, p);
    elements = a;
    head = 0;
    tail = n;
}

public E peekFirst() {
    // elements[head] is null if deque empty
    return (E) elements[head];
}

public E peekLast() {
    return (E) elements[(tail - 1) & (elements.length - 1)];
}

public E getFirst() {
    @SuppressWarnings("unchecked")
    E result = (E) elements[head];
    if (result == null)
        throw new NoSuchElementException();
    return result;
}

/**
 * @throws NoSuchElementException {@inheritDoc}
 */
public E getLast() {
    @SuppressWarnings("unchecked")
    E result = (E) elements[(tail - 1) & (elements.length - 1)];
    if (result == null)
        throw new NoSuchElementException();
    return result;
}

public E pollFirst() {
    int h = head;
    @SuppressWarnings("unchecked")
    E result = (E) elements[h];
    // Element is null if deque empty
    if (result == null)
        return null;
    elements[h] = null;     // Must null out slot
    head = (h + 1) & (elements.length - 1);
    return result;
}

public E pollLast() {
    int t = (tail - 1) & (elements.length - 1);
    @SuppressWarnings("unchecked")
    E result = (E) elements[t];
    if (result == null)
        return null;
    elements[t] = null;
    tail = t;
    return result;
}

public boolean removeFirstOccurrence(Object o) {
    if (o == null)
        return false;
    int mask = elements.length - 1;
    int i = head;
    Object x;
    while ( (x = elements[i]) != null) {
        if (o.equals(x)) {
            delete(i);
            return true;
        }
        i = (i + 1) & mask;
    }
    return false;
}
private boolean delete(int i) {
    checkInvariants();
    final Object[] elements = this.elements;
    final int mask = elements.length - 1;
    final int h = head;
    final int t = tail;
    final int front = (i - h) & mask;
    final int back  = (t - i) & mask;

    // Invariant: head <= i < tail mod circularity
    if (front >= ((t - h) & mask))
        throw new ConcurrentModificationException();

    // Optimize for least element motion
    if (front < back) {
        if (h <= i) {
            System.arraycopy(elements, h, elements, h + 1, front);
        } else { // Wrap around
            System.arraycopy(elements, 0, elements, 1, i);
            elements[0] = elements[mask];
            System.arraycopy(elements, h, elements, h + 1, mask - h);
        }
        elements[h] = null;
        head = (h + 1) & mask;
        return false;
    } else {
        if (i < t) { // Copy the null tail as well
            System.arraycopy(elements, i + 1, elements, i, back);
            tail = t - 1;
        } else { // Wrap around
            System.arraycopy(elements, i + 1, elements, i, mask - i);
            elements[mask] = elements[0];
            System.arraycopy(elements, 1, elements, 0, t);
            tail = (t - 1) & mask;
        }
        return true;
    }
}

private class DeqIterator implements Iterator<E> {
  /**
   * Index of element to be returned by subsequent call to next.
   */
  private int cursor = head;

  /**
   * Tail recorded at construction (also in remove), to stop
   * iterator and also to check for comodification.
   */
  private int fence = tail;

  /**
   * Index of element returned by most recent call to next.
   * Reset to -1 if element is deleted by a call to remove.
   */
  private int lastRet = -1;

  public boolean hasNext() {
    return cursor != fence;
  }

  public E next() {
    if (cursor == fence)
      throw new NoSuchElementException();
    @SuppressWarnings("unchecked")
    E result = (E) elements[cursor];
    // This check doesn't catch all possible comodifications,
    // but does catch the ones that corrupt traversal
    if (tail != fence || result == null)
      throw new ConcurrentModificationException();
    lastRet = cursor;
    cursor = (cursor + 1) & (elements.length - 1);
    return result;
  }

  public void remove() {
    if (lastRet < 0)
      throw new IllegalStateException();
    if (delete(lastRet)) { // if left-shifted, undo increment in next()
      cursor = (cursor - 1) & (elements.length - 1);
      fence = tail;
    }
    lastRet = -1;
  }

  public void forEachRemaining(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    Object[] a = elements;
    int m = a.length - 1, f = fence, i = cursor;
    cursor = f;
    while (i != f) {
      @SuppressWarnings("unchecked") E e = (E)a[i];
      i = (i + 1) & m;
      if (e == null)
        throw new ConcurrentModificationException();
      action.accept(e);
    }
  }
}

(tail != fence || result == null)

package com.deepoove.onerpc.server;

import static com.deepoove.onerpc.util.NameMangle.mangleName;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class OneRpcServlet extends HttpServlet {

    private static final long serialVersionUID = -6904007509665776812L;

    private Class<?> serviceInterface;
    private Object service;

    private Map<String, Method> methodNameMaping = new HashMap<>();

    @Override
    public void init(ServletConfig config) throws ServletException {
        String serviceInterfaceName = config.getInitParameter("serviceInterface");
        String serviceClassName = config.getInitParameter("service");

        try {
            //根据servlet参数初始化服务和服务实现类
            serviceInterface = loadClass(serviceInterfaceName);
            Class<?> serviceClass = loadClass(serviceClassName);
            service = serviceClass.newInstance();

            //构造服务方法名称和方法的映射
            Method[] methods = serviceInterface.getMethods();
            for (int i = 0; i < methods.length; i++) {
                Method method = methods[i];
                methodNameMaping.put(mangleName(method), method);
            }

        } catch (Exception e) {
            throw new ServletException(e);
        }
    }

    private Class<?> loadClass(String serviceInterfaceName) throws ClassNotFoundException {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        if (null != classLoader) {
            return Class.forName(serviceInterfaceName, false, classLoader);
        } else {
            return Class.forName(serviceInterfaceName);
        }
    }

    @Override
    public void service(ServletRequest request, ServletResponse response)
            throws ServletException, IOException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;

        //限定为post方法
        String httpmethod = req.getMethod();
        if (!"POST".equals(httpmethod)) {
            res.setStatus(500);
            PrintWriter out = res.getWriter();
            res.setContentType("text/html");
            out.println("<h1>Requires POST</h1>");
            out.close();
            return;
        }

        ServletInputStream inputStream = req.getInputStream();
        ServletOutputStream outputStream = res.getOutputStream();
        
        ObjectInputStream ois = new ObjectInputStream(inputStream);
        ObjectOutputStream oos = new ObjectOutputStream(outputStream);
        try {
            //使用JDK自带的反序列化：读取方法名和参数
            String methodName = (String) ois.readObject();
            int length = ois.readInt();
            Object[] args = new Object[length];
            for (int i = 0; i < length; i++) {
                args[i] = ois.readObject();
            }

            //调用指定方法，获得结果
            Method method = methodNameMaping.get(methodName);
            Object result = method.invoke(service, args);

            //序列化方法返回值，写入response流
            oos.writeObject(result);
            oos.flush();

        } catch (Exception e) {
            throw new ServletException(e);
        }
        finally {
            ois.close();
            oos.close();
        }
    }

}

package com.deepoove.onerpc.client;

import static com.deepoove.onerpc.util.NameMangle.mangleName;

import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class OneRpcClient implements InvocationHandler {

    private URL url;
    private Class<?> serviceInterface;

    private OneRpcClient() {}

    /**
     * 采用动态代理，获取服务接口的实例
     */
    public static <T> T create(Class<T> serviceInterface, String url) throws MalformedURLException {
        OneRpcClient client = new OneRpcClient();
        client.url = new URL(url);
        client.serviceInterface = serviceInterface;

        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        return (T) Proxy.newProxyInstance(loader, new Class<?>[] { client.serviceInterface },
                client);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        URLConnection conn = url.openConnection();
        conn.setConnectTimeout(10000);
        conn.setReadTimeout(10000);
        conn.setDoOutput(true);
        conn.setRequestProperty("Content-Type", "x-application/onerpc");
        conn.setRequestProperty("Accept-Encoding", "deflate");

        OutputStream outputStream = conn.getOutputStream();
        // 将方法名和参数序列化
        ObjectOutputStream oos = new ObjectOutputStream(outputStream);
        oos.writeObject(mangleName(method));
        oos.writeInt(args.length);
        for (int i = 0; i < args.length; i++) {
            oos.writeObject(args[i]);
        }
        oos.flush();

        // 获得HTTP返回信息
        HttpURLConnection httpConn = (HttpURLConnection) conn;

        int _statusCode = 500;

        try {
            _statusCode = httpConn.getResponseCode();
        } catch (Exception e) {}
        if (_statusCode != 200) {
            throw new RuntimeException("code:" + _statusCode);
        } else {
            // 将返回值反序列化
            InputStream inputStream = conn.getInputStream();
            ObjectInputStream ois = new ObjectInputStream(inputStream);
            Object readObject = ois.readObject();
            ois.close();
            return readObject;

        }
    }

}

package com.deepoove.hessian.api.service;

import com.deepoove.hessian.api.pojo.User;

public interface UserService {
    
    User get(String id);
    
    User get(int id);
    
    void add(User user);

}

package com.deepoove.hessian.example.service;

import com.deepoove.hessian.api.pojo.User;
import com.deepoove.hessian.api.service.UserService;

public class UserServiceImpl implements UserService {

    @Override
    public User get(String id) {
        User user = new User();
        user.setName("Sayi");
        System.out.println("string method");
        return user;
    }

    @Override
    public void add(User user) {}

    @Override
    public User get(int id) {
        System.out.println("int method");
        return null;
    }

}

public static void main(String[] args) throws MalformedURLException {
    UserService userService = OneRpcClient.create(UserService.class, "http://127.0.0.1:8077/userService");
    System.out.println(userService.get("").getName());
}

public void handleRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {

    try {
        RemoteInvocation invocation = readRemoteInvocation(request);
        RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());
        writeRemoteInvocationResult(request, response, result);
    }
    catch (ClassNotFoundException ex) {
        throw new NestedServletException("Class not found during deserialization", ex);
    }
}

class Pool {
   private static final int MAX_AVAILABLE = 100;
   private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

   public Object getItem() throws InterruptedException {
     available.acquire();
     return getNextAvailableItem();
   }

   public void putItem(Object x) {
     if (markAsUnused(x))
       available.release();
   }

   // Not a particularly efficient data structure; just for demo
   protected Object[] items = ... whatever kinds of items being managed
   protected boolean[] used = new boolean[MAX_AVAILABLE];

   protected synchronized Object getNextAvailableItem() {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (!used[i]) {
          used[i] = true;
          return items[i];
       }
     }
     return null; // not reached
   }

   protected synchronized boolean markAsUnused(Object item) {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (item == items[i]) {
          if (used[i]) {
            used[i] = false;
            return true;
          } else
            return false;
       }
     }
     return false;
   }
 }

Semaphore available = new Semaphore(MAX_AVAILABLE, true);

abstract static class Sync extends AbstractQueuedSynchronizer {

  Sync(int permits) {
    setState(permits);
  }

  final int getPermits() {
    return getState();
  }

  final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
      int available = getState();
      int remaining = available - acquires;
      if (remaining < 0 ||
        compareAndSetState(available, remaining))
        return remaining;
    }
  }

  protected final boolean tryReleaseShared(int releases) {
    for (;;) {
      int current = getState();
      int next = current + releases;
      if (next < current) // overflow
        throw new Error("Maximum permit count exceeded");
      if (compareAndSetState(current, next))
        return true;
    }
  }

  // 略
}

static final class FairSync extends Sync {

  FairSync(int permits) {
    super(permits);
  }

  protected int tryAcquireShared(int acquires) {
    for (;;) {
      if (hasQueuedPredecessors())
        return -1;
      int available = getState();
      int remaining = available - acquires;
      if (remaining < 0 ||
        compareAndSetState(available, remaining))
        return remaining;
    }
  }
}

public class Semaphore implements java.io.Serializable {
  private final Sync sync;
  public Semaphore(int permits) {
    sync = new NonfairSync(permits);
  }
  public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
  }
  public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
  }
  public void acquireUninterruptibly() {
    sync.acquireShared(1);
  }
  public boolean tryAcquire() {
    return sync.nonfairTryAcquireShared(1) >= 0;
  }
  public void release() {
    sync.releaseShared(1);
  }
  public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
  }
  public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
  }
  public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
  }
  // 略
}

class Driver2 { // ...
   void main() throws InterruptedException {
     CountDownLatch doneSignal = new CountDownLatch(N);
     Executor e = ...

     for (int i = 0; i < N; ++i) // create and start threads
       e.execute(new WorkerRunnable(doneSignal, i));

     doneSignal.await();           // wait for all to finish
   }
 }

 class WorkerRunnable implements Runnable {
   private final CountDownLatch doneSignal;
   private final int i;
   WorkerRunnable(CountDownLatch doneSignal, int i) {
     this.doneSignal = doneSignal;
     this.i = i;
   }
   public void run() {
     try {
       doWork(i);
       doneSignal.countDown();
     } catch (InterruptedException ex) {} // return;
   }

   void doWork() { ... }
}

CountDownLatch doneSignal = new CountDownLatch(N);

doneSignal.countDown();

class Driver { // ...
   void main() throws InterruptedException {
     CountDownLatch startSignal = new CountDownLatch(1);
     CountDownLatch doneSignal = new CountDownLatch(N);

     for (int i = 0; i < N; ++i) // create and start threads
       new Thread(new Worker(startSignal, doneSignal)).start();

     doSomethingElse();            // don't let run yet
     startSignal.countDown();      // let all threads proceed
     doSomethingElse();
     doneSignal.await();           // wait for all to finish
   }
 }

 class Worker implements Runnable {
   private final CountDownLatch startSignal;
   private final CountDownLatch doneSignal;
   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
     this.startSignal = startSignal;
     this.doneSignal = doneSignal;
   }
   public void run() {
     try {
       startSignal.await();
       doWork();
       doneSignal.countDown();
     } catch (InterruptedException ex) {} // return;
   }

   void doWork() { ... }
}

CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch doneSignal = new CountDownLatch(N);

private static final class Sync extends AbstractQueuedSynchronizer {
  private static final long serialVersionUID = 4982264981922014374L;

  Sync(int count) {
    setState(count);
  }

  int getCount() {
    return getState();
  }

  protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
  }

  protected boolean tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    for (;;) {
      int c = getState();
      if (c == 0)
        return false;
      int nextc = c-1;
      if (compareAndSetState(c, nextc))
        return nextc == 0;
    }
  }
}

public class CountDownLatch {
  private final Sync sync;
  public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
  }
  public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
  }
  public void countDown() {
    sync.releaseShared(1);
  }
  // 略
}

class Solver {
   final int N;
   final float[][] data;
   final CyclicBarrier barrier;

   class Worker implements Runnable {
     int myRow;
     Worker(int row) { myRow = row; }
     public void run() {
       while (!done()) {
         processRow(myRow);

         try {
           barrier.await();
         } catch (InterruptedException ex) {
           return;
         } catch (BrokenBarrierException ex) {
           return;
         }
       }
     }
   }

   public Solver(float[][] matrix) {
     data = matrix;
     N = matrix.length;
     Runnable barrierAction =
       new Runnable() { public void run() { mergeRows(...); }};
     barrier = new CyclicBarrier(N, barrierAction);

     List<Thread> threads = new ArrayList<Thread>(N);
     for (int i = 0; i < N; i++) {
       Thread thread = new Thread(new Worker(i));
       threads.add(thread);
       thread.start();
     }
}

barrier = new CyclicBarrier(N, barrierAction);

/** The lock for guarding barrier entry */
private final ReentrantLock lock = new ReentrantLock();
/** Condition to wait on until tripped */
private final Condition trip = lock.newCondition();

/**
 * Updates state on barrier trip and wakes up everyone.
 * Called only while holding lock.
 */
private void nextGeneration() {
  // signal completion of last generation
  trip.signalAll();
  // set up next generation
  count = parties;
  generation = new Generation();
}

/**
 * Sets current barrier generation as broken and wakes up everyone.
 * Called only while holding lock.
 */
private void breakBarrier() {
  generation.broken = true;
  count = parties;
  trip.signalAll();
}

/**
 * Main barrier code, covering the various policies.
 */
private int dowait(boolean timed, long nanos)
  throws InterruptedException, BrokenBarrierException,
       TimeoutException {
  final ReentrantLock lock = this.lock;
  lock.lock();
  try {
    final Generation g = generation;

    if (g.broken)
      throw new BrokenBarrierException();

    if (Thread.interrupted()) {
      breakBarrier();
      throw new InterruptedException();
    }

    int index = --count;
    if (index == 0) {  // tripped
      boolean ranAction = false;
      try {
        final Runnable command = barrierCommand;
        if (command != null)
          command.run();
        ranAction = true;
        nextGeneration();
        return 0;
      } finally {
        if (!ranAction)
          breakBarrier();
      }
    }

    // loop until tripped, broken, interrupted, or timed out
    for (;;) {
      try {
        if (!timed)
          trip.await();
        else if (nanos > 0L)
          nanos = trip.awaitNanos(nanos);
      } catch (InterruptedException ie) {
        if (g == generation && ! g.broken) {
          breakBarrier();
          throw ie;
        } else {
          // We're about to finish waiting even if we had not
          // been interrupted, so this interrupt is deemed to
          // "belong" to subsequent execution.
          Thread.currentThread().interrupt();
        }
      }

      if (g.broken)
        throw new BrokenBarrierException();

      if (g != generation)
        return index;

      if (timed && nanos <= 0L) {
        breakBarrier();
        throw new TimeoutException();
      }
    }
  } finally {
    lock.unlock();
  }
}

if (index == 0) {  // tripped
  boolean ranAction = false;
  try {
    final Runnable command = barrierCommand;
    if (command != null)
      command.run();
    ranAction = true;
    nextGeneration();
    return 0;
  } finally {
    if (!ranAction)
      breakBarrier();
  }
}

public static void main(String[] args) {
  JSONArray parseArray = JSON.parseArray(str);
  Map<String, List<String>> result = new TreeMap<String, List<String>>(
      new Comparator<String>() {
              public int compare(String obj1, String obj2) {
                  // 降序排序
                  return obj2.charAt(0) - obj1.charAt(0) == 0 ? 1 : obj2.charAt(0) - obj1.charAt(0);
              }
      }
  );
  Map<String, List<String>> ret = new HashMap<String, List<String>>();
  for (int i = 0; i < parseArray.size(); i++) {
    Map map = JSON.parseObject(parseArray.get(i).toString(), Map.class);
    StringBuilder sb = new StringBuilder();
    sb.append("[").append(map.get("title")).append("](").append(map.get("html_url")).append(")\n");
//      System.out.println(sb.toString());
    Object lables = map.get("labels");
    JSONArray parseArray2 = JSON.parseArray(lables.toString());
    for (int j = 0; j < parseArray2.size(); j++) {
      Map parseObject = JSON.parseObject(parseArray2.get(j).toString(), Map.class);
      List<String> list = ret.get(parseObject.get("name"));
      if (null != list) {
        list.add(sb.toString());
      }else {
        list = new ArrayList<String>();
        list.add(sb.toString());
        ret.put(parseObject.get("name").toString(), list);
      }
    }
  }
  for (Map.Entry<String, List<String>> entry : ret.entrySet()) {
    result.put(entry.getValue().size() + entry.getKey(), entry.getValue());
  }
  for (Map.Entry<String, List<String>> entry : result.entrySet()) {
    System.out.println("### " + entry.getKey().substring(1));
    for (String value : entry.getValue()) {
      System.out.println(value);
    }
  }
  
}

Lock lock = ...;
lock.lock();
try {
  // access the resource protected by this lock
} finally {
  lock.unlock();
}

static class Friend {
  private final String name;
  private final Lock lock = new ReentrantLock();

  public Friend(String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }

  public boolean impendingBow(Friend bower) {
    Boolean myLock = false;
    Boolean yourLock = false;
    try {
      myLock = lock.tryLock();
      yourLock = bower.lock.tryLock();
    } finally {
      if (! (myLock && yourLock)) {
        if (myLock) {
          lock.unlock();
        }
        if (yourLock) {
          bower.lock.unlock();
        }
      }
    }
    return myLock && yourLock;
  }
    
  public void bow(Friend bower) {
    if (impendingBow(bower)) {
      try {
        System.out.format("%s: %s has"
          + " bowed to me!%n", 
          this.name, bower.getName());
        bower.bowBack(this);
      } finally {
        lock.unlock();
        bower.lock.unlock();
      }
    } else {
      System.out.format("%s: %s started"
        + " to bow to me, but saw that"
        + " I was already bowing to"
        + " him.%n",
        this.name, bower.getName());
    }
  }

  public void bowBack(Friend bower) {
    System.out.format("%s: %s has" +
      " bowed back to me!%n",
      this.name, bower.getName());
  }
}

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
}

/**
 * The synchronization state.
 */
private volatile int state;

// 排它锁模下尝试通过state变量获取许可
protected boolean tryAcquire(int arg) {
  throw new UnsupportedOperationException();
}

// 排它锁模式下通过设置变量state的值来反映释放许可
protected boolean tryRelease(int arg) {
  throw new UnsupportedOperationException();
}

// 共享锁模下尝试通过state变量获取许可，返回值-1表获取锁失败
protected int tryAcquireShared(int arg) {
  throw new UnsupportedOperationException();
}

// 共享锁模式下通过设置变量state的值来反映释放许可
protected boolean tryReleaseShared(int arg) {
  throw new UnsupportedOperationException();
}
protected boolean isHeldExclusively() {
  throw new UnsupportedOperationException();
}

 class Mutex implements Lock, java.io.Serializable {

   // Our internal helper class
   private static class Sync extends AbstractQueuedSynchronizer {
     // Reports whether in locked state
     protected boolean isHeldExclusively() {
       return getState() == 1;
     }

     // 如果state值为0，则获得锁
     public boolean tryAcquire(int acquires) {
       assert acquires == 1; // Otherwise unused
       if (compareAndSetState(0, 1)) {
         setExclusiveOwnerThread(Thread.currentThread());
         return true;
       }
       return false;
     }

     // 释放锁，设置state值为0
     protected boolean tryRelease(int releases) {
       assert releases == 1; // Otherwise unused
       if (getState() == 0) throw new IllegalMonitorStateException();
       setExclusiveOwnerThread(null);
       setState(0);
       return true;
     }

     // Provides a Condition
     Condition newCondition() { return new ConditionObject(); }

   }

   // The sync object does all the hard work. We just forward to it.
   private final Sync sync = new Sync();

   public void lock()                { sync.acquire(1); }
   public boolean tryLock()          { return sync.tryAcquire(1); }
   public void unlock()              { sync.release(1); }
   public Condition newCondition()   { return sync.newCondition(); }
   public boolean isLocked()         { return sync.isHeldExclusively(); }
   public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
   public void lockInterruptibly() throws InterruptedException {
     sync.acquireInterruptibly(1);
   }
   public boolean tryLock(long timeout, TimeUnit unit)
       throws InterruptedException {
     return sync.tryAcquireNanos(1, unit.toNanos(timeout));
   }
 }

public final void acquire(int arg) {
  if (!tryAcquire(arg) &&
    acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
    selfInterrupt();
}

private Node addWaiter(Node mode) {
  Node node = new Node(Thread.currentThread(), mode);
  // Try the fast path of enq; backup to full enq on failure
  Node pred = tail;
  if (pred != null) {
    node.prev = pred;
    if (compareAndSetTail(pred, node)) {
      pred.next = node;
      return node;
    }
  }
  enq(node);
  return node;
}

final boolean acquireQueued(final Node node, int arg) {
  boolean failed = true;
  try {
    boolean interrupted = false;
    for (;;) {
      final Node p = node.predecessor();
      if (p == head && tryAcquire(arg)) {
        setHead(node);
        p.next = null; // help GC
        failed = false;
        return interrupted;
      }
      if (shouldParkAfterFailedAcquire(p, node) &&
        parkAndCheckInterrupt())
        interrupted = true;
    }
  } finally {
    if (failed)
      cancelAcquire(node);
  }
}

public final boolean release(int arg) {
  if (tryRelease(arg)) {
    Node h = head;
    if (h != null && h.waitStatus != 0)
      unparkSuccessor(h);
    return true;
  }
  return false;
}

private void unparkSuccessor(Node node) {
  /*
   * If status is negative (i.e., possibly needing signal) try
   * to clear in anticipation of signalling.  It is OK if this
   * fails or if status is changed by waiting thread.
   */
  int ws = node.waitStatus;
  if (ws < 0)
    compareAndSetWaitStatus(node, ws, 0);

  /*
   * Thread to unpark is held in successor, which is normally
   * just the next node.  But if cancelled or apparently null,
   * traverse backwards from tail to find the actual
   * non-cancelled successor.
   */
  Node s = node.next;
  if (s == null || s.waitStatus > 0) {
    s = null;
    for (Node t = tail; t != null && t != node; t = t.prev)
      if (t.waitStatus <= 0)
        s = t;
  }
  if (s != null)
    LockSupport.unpark(s.thread);
}

abstract static class Sync extends AbstractQueuedSynchronizer {
  private static final long serialVersionUID = -5179523762034025860L;

  /**
   * Performs {@link Lock#lock}. The main reason for subclassing
   * is to allow fast path for nonfair version.
   */
  abstract void lock();

  /**
   * Performs non-fair tryLock.  tryAcquire is implemented in
   * subclasses, but both need nonfair try for trylock method.
   */
  final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
      if (compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(current);
        return true;
      }
    }
    else if (current == getExclusiveOwnerThread()) {
      int nextc = c + acquires;
      if (nextc < 0) // overflow
        throw new Error("Maximum lock count exceeded");
      setState(nextc);
      return true;
    }
    return false;
  }

  protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
      throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
      free = true;
      setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
  }

  protected final boolean isHeldExclusively() {
    // While we must in general read state before owner,
    // we don't need to do so to check if current thread is owner
    return getExclusiveOwnerThread() == Thread.currentThread();
  }

  final ConditionObject newCondition() {
    return new ConditionObject();
  }

  // 略
}

static final class NonfairSync extends Sync {
  /**
   * Performs lock.  Try immediate barge, backing up to normal
   * acquire on failure.
   */
  final void lock() {
    if (compareAndSetState(0, 1))
      setExclusiveOwnerThread(Thread.currentThread());
    else
      acquire(1);
  }

  protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
  }
}

static final class FairSync extends Sync {

  final void lock() {
    acquire(1);
  }

  /**
   * Fair version of tryAcquire.  Don't grant access unless
   * recursive call or no waiters or is first.
   */
  protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
      if (!hasQueuedPredecessors() &&
        compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(current);
        return true;
      }
    }
    else if (current == getExclusiveOwnerThread()) {
      int nextc = c + acquires;
      if (nextc < 0)
        throw new Error("Maximum lock count exceeded");
      setState(nextc);
      return true;
    }
    return false;
  }
}

if (compareAndSetState(0, 1))
  setExclusiveOwnerThread(Thread.currentThread());

public final boolean hasQueuedPredecessors() {
  // The correctness of this depends on head being initialized
  // before tail and on head.next being accurate if the current
  // thread is first in queue.
  Node t = tail; // Read fields in reverse initialization order
  Node h = head;
  Node s;
  return h != t &&
    ((s = h.next) == null || s.thread != Thread.currentThread());
}

public class ReentrantLock implements Lock, java.io.Serializable {
  private final Sync sync;
  public ReentrantLock() {
    sync = new NonfairSync();
  }
  public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
  }
  public void lock() {
    sync.lock();
  }
  public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
  }
  public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
  }
  public boolean tryLock(long timeout, TimeUnit unit)
      throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
  }
  public void unlock() {
    sync.release(1);
  }
  public Condition newCondition() {
    return sync.newCondition();
  }
  public boolean isHeldByCurrentThread() {
    return sync.isHeldExclusively();
  }
  public final boolean isFair() {
    return sync instanceof FairSync;
  }
  // 略
}

public interface ReadWriteLock {
  /**
   * Returns the lock used for reading.
   *
   * @return the lock used for reading
   */
  Lock readLock();

  /**
   * Returns the lock used for writing.
   *
   * @return the lock used for writing
   */
  Lock writeLock();
}

class CachedData {
   Object data;
   volatile boolean cacheValid;
   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

   void processCachedData() {
     rwl.readLock().lock();
     if (!cacheValid) {
       // Must release read lock before acquiring write lock
       rwl.readLock().unlock();
       rwl.writeLock().lock();
       try {
         // Recheck state because another thread might have
         // acquired write lock and changed state before we did.
         if (!cacheValid) {
           data = ...
           cacheValid = true;
         }
         // Downgrade by acquiring read lock before releasing write lock
         rwl.readLock().lock();
       } finally {
         rwl.writeLock().unlock(); // Unlock write, still hold read
       }
     }

     try {
       use(data);
     } finally {
       rwl.readLock().unlock();
     }
   }
 }

/*
* Read vs write count extraction constants and functions.
* Lock state is logically divided into two unsigned shorts:
* The lower one representing the exclusive (writer) lock hold count,
* and the upper the shared (reader) hold count.
*/
static final int SHARED_SHIFT   = 16;
static final int SHARED_UNIT  = (1 << SHARED_SHIFT);
static final int MAX_COUNT    = (1 << SHARED_SHIFT) - 1;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

/** Returns the number of shared holds represented in count  */
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
/** Returns the number of exclusive holds represented in count  */
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

final boolean tryReadLock() {
  Thread current = Thread.currentThread();
  for (;;) {
    int c = getState();
    if (exclusiveCount(c) != 0 &&
      getExclusiveOwnerThread() != current)
      return false;
    int r = sharedCount(c);
    if (r == MAX_COUNT)
      throw new Error("Maximum lock count exceeded");
    if (compareAndSetState(c, c + SHARED_UNIT)) {
      if (r == 0) {
        firstReader = current;
        firstReaderHoldCount = 1;
      } else if (firstReader == current) {
        firstReaderHoldCount++;
      } else {
        HoldCounter rh = cachedHoldCounter;
        if (rh == null || rh.tid != getThreadId(current))
          cachedHoldCounter = rh = readHolds.get();
        else if (rh.count == 0)
          readHolds.set(rh);
        rh.count++;
      }
      return true;
    }
  }
}

/** Inner class providing readlock */
private final ReentrantReadWriteLock.ReadLock readerLock;
/** Inner class providing writelock */
private final ReentrantReadWriteLock.WriteLock writerLock;

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("hello,world");
    }
}

Compiled from "HelloWorld.java"
public class HelloWorld {
  public HelloWorld();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String hello,world
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

//生成ClassFile对象，对应着Java .class文件
DataInputStream dis = new DataInputStream(new BufferedInputStream(inputStream));
ClassFile cls = new ClassFile(dis);

//获取方法
cls.getMethods();

//获取属性
cls.getFields();

//获取类的Runtime注解
(AnnotationsAttribute) cls.getAttribute(AnnotationsAttribute.visibleTag)
//获取属性的Runtime注解
(AnnotationsAttribute) field.getAttribute(AnnotationsAttribute.visibleTag);
//获取属性的Class注解
(AnnotationsAttribute) field.getAttribute(AnnotationsAttribute.invisibleTag);
//获取方法的Runtime注解
(AnnotationsAttribute) method.getAttribute(AnnotationsAttribute.visibleTag);

//获取方法参数的注解
List<ParameterAnnotationsAttribute> parameterAnnotationsAttributes = Lists.newArrayList((ParameterAnnotationsAttribute) method.getAttribute(ParameterAnnotationsAttribute.visibleTag),
                (ParameterAnnotationsAttribute) method.getAttribute(ParameterAnnotationsAttribute.invisibleTag));

@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@Target({ FIELD, METHOD })
public @interface Parameter {

  /**
   * An array of allowed command line parameters (e.g. "-d", "--outputdir", etc...).
   * If this attribute is omitted, the field it's annotating will receive all the
   * unparsed options. There can only be at most one such annotation.
   */
  String[] names() default {};

  /**
   * A description of this option.
   */
  String description() default "";

  /**
   * Whether this option is required.
   */
  boolean required() default false;

  /**
   * The key used to find the string in the message bundle.
   */
  String descriptionKey() default "";

  /**
   * How many parameter values this parameter will consume. For example,
   * an arity of 2 will allow "-pair value1 value2".
   */
  public static int DEFAULT_ARITY = -1;
  int arity() default DEFAULT_ARITY;

  /**
   * If true, this parameter is a password and it will be prompted on the console
   * (if available).
   */
  boolean password() default false;

  /**
   * The string converter to use for this field. If the field is of type <tt>List</tt>
   * and not <tt>listConverter</tt> attribute was specified, JCommander will split
   * the input in individual values and convert each of them separately.
   */
  Class<? extends IStringConverter<?>> converter() default NoConverter.class;

  /**
   * The list string converter to use for this field. If it's specified, the
   * field has to be of type <tt>List</tt> and the converter needs to return
   * a List that's compatible with that type.
   */
  Class<? extends IStringConverter<?>> listConverter() default NoConverter.class;

  /**
   * If true, this parameter won't appear in the usage().
   */
  boolean hidden() default false;

  /**
   * Validate the parameter found on the command line.
   */
  Class<? extends IParameterValidator>[] validateWith() default NoValidator.class;

  /**
   * Validate the value for this parameter.
   */
  Class<? extends IValueValidator>[] validateValueWith() default NoValueValidator.class;

  /**
   * @return true if this parameter has a variable arity. See @{IVariableArity}
   */
  boolean variableArity() default false;

  /**
   * What splitter to use (applicable only on fields of type <tt>List</tt>). By default,
   * a comma separated splitter will be used.
   */
  Class<? extends IParameterSplitter> splitter() default CommaParameterSplitter.class;
  
  /**
   * If true, console will not echo typed input
   * Used in conjunction with password = true
   */
  boolean echoInput() default false;

  /**
   * If true, this parameter is for help. If such a parameter is specified,
   * required parameters are no longer checked for their presence.
   */
  boolean help() default false;
  
  /**
   * If true, this parameter can be overwritten through a file or another appearance of the parameter
   * @return nc
   */
  boolean forceNonOverwritable() default false;

  /**
   * If specified, this number will be used to order the description of this parameter when usage() is invoked.
   * @return
   */
  int order() default -1;
  
}

/**
 * 
 * @author Sayi
 * @version
 */
public class CLI {

  private static final String OUTPUT_MODE_MARKDOWN = "markdown";

  @Parameter(names = "-old", description = "old api-doc location:Json file path or Http url", required = true, order = 0)
  private String oldSpec;

  @Parameter(names = "-new", description = "new api-doc location:Json file path or Http url", required = true, order = 1)
  private String newSpec;

  @Parameter(names = "-v", description = "swagger version:1.0 or 2.0", validateWith = RegexValidator.class, order = 2)
  @Regex("(2\\.0|1\\.0)")
  private String version = SwaggerDiff.SWAGGER_VERSION_V2;

  @Parameter(names = "-output-mode", description = "render mode: markdown or html", validateWith = RegexValidator.class, order = 3)
  @Regex("(markdown|html)")
  private String outputMode = OUTPUT_MODE_MARKDOWN;

  @Parameter(names = "--help", help = true, order = 5)
  private boolean help;

  @Parameter(names = "--version", description = "swagger-diff tool version", help = true, order = 6)
  private boolean v;

  public static void main(String[] args) {
    CLI cli = new CLI();
    JCommander jCommander = JCommander.newBuilder().addObject(cli).build();
    jCommander.parse(args);
    cli.run(jCommander);
  }

  public void run(JCommander jCommander) {
    if (help) {
      jCommander.setProgramName("java -jar swagger-diff.jar");
      jCommander.usage();
      return;
    }
    if (v) {
      JCommander.getConsole().println("1.2.0");
      return;
    }

    //SwaggerDiff diff = null;
  }
}

/**
 * An interface that converts strings to any arbitrary type.
 * 
 * If your class implements a constructor that takes a String, this
 * constructor will be used to instantiate your converter and the
 * parameter will receive the name of the option that's being parsed,
 * which can be useful to issue a more useful error message if the
 * conversion fails.
 * 
 * You can also extend BaseConverter to make your life easier.
 * 
 * @author cbeust
 */
public interface IStringConverter<T> {
  /**
   * @return an object of type <T> created from the parameter value.
   */
  T convert(String value);
}

/**
 * The class used to validate parameters.
 *
 * @author Cedric Beust <[email protected]>
 */
public interface IParameterValidator {

  /**
   * Validate the parameter.
   *
   * @param name The name of the parameter (e.g. "-host").
   * @param value The value of the parameter that we need to validate
   *
   * @throws ParameterException Thrown if the value of the parameter is invalid.
   */
  void validate(String name, String value) throws ParameterException;

}

package com.deepoove.swagger.diff.cli;

import static java.lang.annotation.ElementType.FIELD;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
@Target({ FIELD })
public @interface Regex {

  String value() default "";

}

package com.deepoove.swagger.diff.cli;

import java.lang.reflect.Field;
import java.util.regex.Pattern;

import com.beust.jcommander.IParameterValidator2;
import com.beust.jcommander.ParameterDescription;
import com.beust.jcommander.ParameterException;
import com.beust.jcommander.Parameterized;

public class RegexValidator implements IParameterValidator2 {

  private static final String PARAMETERIZED_FIELD_NAME = "field";

  @Override
  public void validate(String name, String value) throws ParameterException {
    return;
  }

  @Override
  public void validate(String name, String value, ParameterDescription pd)
      throws ParameterException {
    Parameterized parameterized = pd.getParameterized();
    Class<? extends Parameterized> clazz = parameterized.getClass();
    try {
      Field declaredField = clazz.getDeclaredField(PARAMETERIZED_FIELD_NAME);
      declaredField.setAccessible(true);
      Field paramField = (Field) declaredField.get(parameterized);
      Regex regex = paramField.getAnnotation(Regex.class);
      if (null == regex) return;
      String regexStr = regex.value();
      if (!Pattern.matches(regexStr, value)) { throw new ParameterException(
          "Parameter " + name + " should match " + regexStr + " (found " + value + ")"); }
    } catch (NoSuchFieldException e) {
      return;
    } catch (IllegalArgumentException e) {
      return;
    } catch (IllegalAccessException e) {
      return;
    }
  }
}

@Parameter(names = "-v",  validateWith = RegexValidator.class)
@Regex("(2\\.0|1\\.0)")
private String version = "2.0";

package com.deepoove.diexample.service;

public interface AccountService {
  String get();
}

package com.deepoove.diexample.service;

public class AccountServiceImpl implements AccountService {

  @Override
  public String get() {
    return "Sayi";
  }
}

@Test
public void testXMLConifg() {
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

  AccountService accountService = context.getBean("accountService", AccountService.class);
  Assert.assertEquals(accountService.get(), "Sayi");

  context.close();

}

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
    // Prepare this context for refreshing.
    prepareRefresh();

    // Tell the subclass to refresh the internal bean factory.
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

    // Prepare the bean factory for use in this context.
    prepareBeanFactory(beanFactory);

    try {
      // Allows post-processing of the bean factory in context subclasses.
      postProcessBeanFactory(beanFactory);

      // Invoke factory processors registered as beans in the context.
      invokeBeanFactoryPostProcessors(beanFactory);

      // Register bean processors that intercept bean creation.
      registerBeanPostProcessors(beanFactory);

      // Initialize message source for this context.
      initMessageSource();

      // Initialize event multicaster for this context.
      initApplicationEventMulticaster();

      // Initialize other special beans in specific context subclasses.
      onRefresh();

      // Check for listener beans and register them.
      registerListeners();

      // Instantiate all remaining (non-lazy-init) singletons.
      finishBeanFactoryInitialization(beanFactory);

      // Last step: publish corresponding event.
      finishRefresh();
    }

    catch (BeansException ex) {
      if (logger.isWarnEnabled()) {
        logger.warn("Exception encountered during context initialization - " +
            "cancelling refresh attempt: " + ex);
      }

      // Destroy already created singletons to avoid dangling resources.
      destroyBeans();

      // Reset 'active' flag.
      cancelRefresh(ex);

      // Propagate exception to caller.
      throw ex;
    }

    finally {
      // Reset common introspection caches in Spring's core, since we
      // might not ever need metadata for singleton beans anymore...
      resetCommonCaches();
    }
  }
}

  DefaultListableBeanFactory beanFactory = createBeanFactory();
  beanFactory.setSerializationId(getId()); // 设置唯一ID
  customizeBeanFactory(beanFactory); 
  loadBeanDefinitions(beanFactory); // 读取Bean的定义，可以是XML形式，也可以是其它形式
  synchronized (this.beanFactoryMonitor) {
    this.beanFactory = beanFactory;
  }

/**
 * Load bean definitions into the given bean factory, typically through
 * delegating to one or more bean definition readers.
 * @param beanFactory the bean factory to load bean definitions into
 * @throws BeansException if parsing of the bean definitions failed
 * @throws IOException if loading of bean definition files failed
 * @see org.springframework.beans.factory.support.PropertiesBeanDefinitionReader
 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
 */
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
        throws BeansException, IOException;

beanFactory.setBeanClassLoader(getClassLoader());

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
  beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
  beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
  beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}

public interface BeanPostProcessor {

  @Nullable
  default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    return bean;
  }

  @Nullable
  default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    return bean;
  }

}

Log logger = LogFactory.getLog(getClass());

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    throws BeanCreationException {

  // Instantiate the bean.
  BeanWrapper instanceWrapper = null;
  if (mbd.isSingleton()) {
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  if (instanceWrapper == null) {
    instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  final Object bean = instanceWrapper.getWrappedInstance();
  Class<?> beanType = instanceWrapper.getWrappedClass();
  if (beanType != NullBean.class) {
    mbd.resolvedTargetType = beanType;
  }

  // Allow post-processors to modify the merged bean definition.
  synchronized (mbd.postProcessingLock) {
    if (!mbd.postProcessed) {
      try {
        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      }
      catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Post-processing of merged bean definition failed", ex);
      }
      mbd.postProcessed = true;
    }
  }

  // Eagerly cache singletons to be able to resolve circular references
  // even when triggered by lifecycle interfaces like BeanFactoryAware.
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
  if (earlySingletonExposure) {
    if (logger.isDebugEnabled()) {
      logger.debug("Eagerly caching bean '" + beanName +
          "' to allow for resolving potential circular references");
    }
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  }

  // Initialize the bean instance.
  Object exposedObject = bean;
  try {
    populateBean(beanName, mbd, instanceWrapper);
    exposedObject = initializeBean(beanName, exposedObject, mbd);
  }
  catch (Throwable ex) {
    if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
      throw (BeanCreationException) ex;
    }
    else {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    }
  }

  if (earlySingletonExposure) {
    Object earlySingletonReference = getSingleton(beanName, false);
    if (earlySingletonReference != null) {
      if (exposedObject == bean) {
        exposedObject = earlySingletonReference;
      }
      else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
        String[] dependentBeans = getDependentBeans(beanName);
        Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
        for (String dependentBean : dependentBeans) {
          if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
            actualDependentBeans.add(dependentBean);
          }
        }
        if (!actualDependentBeans.isEmpty()) {
          throw new BeanCurrentlyInCreationException(beanName,
              "Bean with name '" + beanName + "' has been injected into other beans [" +
              StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
              "] in its raw version as part of a circular reference, but has eventually been " +
              "wrapped. This means that said other beans do not use the final version of the " +
              "bean. This is often the result of over-eager type matching - consider using " +
              "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
        }
      }
    }
  }

  // Register bean as disposable.
  try {
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
  }
  catch (BeanDefinitionValidationException ex) {
    throw new BeanCreationException(
        mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  }

  return exposedObject;
}

// Need to determine the constructor...
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
    mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
    mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
  return autowireConstructor(beanName, mbd, ctors, args);
}

// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);

try {
  ReflectionUtils.makeAccessible(ctor);
  return (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
      KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
}

PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
if (Object.class != pd.getPropertyType()) {
  MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
  // Do not allow eager init for type matching in case of a prioritized post-processor.
  boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
  DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
  Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
  if (autowiredArgument != null) {
    pvs.add(propertyName, autowiredArgument);
  }
  for (String autowiredBeanName : autowiredBeanNames) {
    registerDependentBean(autowiredBeanName, beanName);
    if (logger.isDebugEnabled()) {
      logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
          propertyName + "' to bean named '" + autowiredBeanName + "'");
    }
  }
  autowiredBeanNames.clear();
}

if (bean instanceof Aware) {
  if (bean instanceof EnvironmentAware) {
    ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
  }
  if (bean instanceof EmbeddedValueResolverAware) {
    ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
  }
  if (bean instanceof ResourceLoaderAware) {
    ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
  }
  if (bean instanceof ApplicationEventPublisherAware) {
    ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
  }
  if (bean instanceof MessageSourceAware) {
    ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
  }
  if (bean instanceof ApplicationContextAware) {
    ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
  }
}

<!-- the factory bean, which contains a method called createInstance() -->
<bean id="serviceLocator" class="examples.DefaultServiceLocator">
    <!-- inject any dependencies required by this locator bean -->
</bean>

<!-- the bean to be created via the factory bean -->
<bean id="clientService"
    factory-bean="serviceLocator"
    factory-method="createClientServiceInstance"/>

public interface FactoryBean<T> {

  T getObject() throws Exception;

  Class<?> getObjectType();

  boolean isSingleton();

}

  Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
        descriptor, requestingBeanName);

protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
  Assert.state(getBeanFactory() instanceof DefaultListableBeanFactory,
      "BeanFactory needs to be a DefaultListableBeanFactory");
  final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
  TargetSource ts = new TargetSource() {
    @Override
    public Class<?> getTargetClass() {
      return descriptor.getDependencyType();
    }
    @Override
    public boolean isStatic() {
      return false;
    }
    @Override
    public Object getTarget() {
      Object target = beanFactory.doResolveDependency(descriptor, beanName, null, null);
      if (target == null) {
        Class<?> type = getTargetClass();
        if (Map.class == type) {
          return Collections.emptyMap();
        }
        else if (List.class == type) {
          return Collections.emptyList();
        }
        else if (Set.class == type || Collection.class == type) {
          return Collections.emptySet();
        }
        throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
            "Optional dependency not present for lazy injection point");
      }
      return target;
    }
    @Override
    public void releaseTarget(Object target) {
    }
  };
  ProxyFactory pf = new ProxyFactory();
  pf.setTargetSource(ts);
  Class<?> dependencyType = descriptor.getDependencyType();
  if (dependencyType.isInterface()) {
    pf.addInterface(dependencyType);
  }
  return pf.getProxy(beanFactory.getBeanClassLoader());
}

package org.aopalliance.aop;
public interface Advice {
}

 class DebuggingInterceptor implements MethodInterceptor, 
     ConstructorInterceptor, FieldInterceptor {

   Object invoke(MethodInvocation i) throws Throwable {
     debug(i.getMethod(), i.getThis(), i.getArgs());
     return i.proceed();
   }

   Object construct(ConstructorInvocation i) throws Throwable {
     debug(i.getConstructor(), i.getThis(), i.getArgs());
     return i.proceed();
   }
 
   Object get(FieldAccess fa) throws Throwable {
     debug(fa.getField(), fa.getThis(), null);
     return fa.proceed();
   }

   Object set(FieldAccess fa) throws Throwable {
     debug(fa.getField(), fa.getThis(), fa.getValueToSet());
     return fa.proceed();
   }

   void debug(AccessibleObject ao, Object this, Object value) {
     ...
   }
 }

public static Object newProxyInstance(ClassLoader loader,
  Class<?>[] interfaces,
  InvocationHandler h)
throws IllegalArgumentException

public interface InvocationHandler {
 public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;
}

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(new net.sf.cglib.proxy.MethodInterceptor() {
   
   @Override
   public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
       throws Throwable {
     
   }
});
Object instance = enhancer.create();

ProxyFactory f = new ProxyFactory();
f.setSuperclass(key.getType());
Class<?> c = f.createClass();

Object object = c.newInstance();
((javassist.util.proxy.Proxy)object).setHandler(new MethodHandler() {
  
  @Override
  public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args)
      throws Throwable {
    
  }
});
return object;

package com.deepoove.liteinject.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.List;

import org.aopalliance.intercept.MethodInterceptor;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyFactory {
  
  private Object target;
  private Class<?> interfaceClass;
  
  private List<MethodInterceptor> advisor;
  
  public ProxyFactory(Class<?> clazz, MethodInterceptor... interceptors) {
    this.interfaceClass = clazz;
    if (null != interceptors) this.advisor = Arrays.asList(interceptors);
  }
  
  
  public ProxyFactory(Object obj, MethodInterceptor... interceptors) {
    this.target = obj;
    if (null != interceptors) this.advisor = Arrays.asList(interceptors);
  }
  
  
  public Object getProxy(){
     if (null != interfaceClass && interfaceClass.isInterface()) {
       //jdk dynamic proxy
       return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{interfaceClass}, new InvocationHandler() {
         @Override
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           ReflectMethodInvocation methodInvocation = new ReflectMethodInvocation(method, args,  null, new Pointcut(), advisor);
           return methodInvocation.proceed();
         }
       });
     }else{
       //bytecode dynamic proxy
       Enhancer enhancer = new Enhancer();
       enhancer.setSuperclass(target.getClass());
       enhancer.setCallback(new net.sf.cglib.proxy.MethodInterceptor() {
         
         @Override
         public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
             throws Throwable {
           CglibMethodInvocation  methodInvocation = new CglibMethodInvocation(method, args, target, proxy,  new Pointcut(), advisor);
           return methodInvocation.proceed();
         }
       });
       return enhancer.create();
       
     }
  }
}

package com.deepoove.liteinject.aop;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.util.List;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class ReflectMethodInvocation implements MethodInvocation {

  private Object obj;
  private Pointcut pointcut;
  private List<MethodInterceptor> interceptors;

  private Method method;
  private Object[] args;
  
  private int i = 0;

  public ReflectMethodInvocation(Method method, Object[] args, Object newInstance,
      Pointcut pointcut, List<MethodInterceptor> interceptors) {
    this.method = method;
    this.args = args;
    this.obj = newInstance;
    this.pointcut = pointcut;
    this.interceptors = interceptors;
  }

  @Override
  public Object[] getArguments() {
    return args;
  }

  @Override
  public Object proceed() throws Throwable {
    if (!pointcut.matcher(method)) return method.invoke(obj, args);
    
    if (i == interceptors.size()) return method.invoke(obj, args);
    
    return interceptors.get(i++).invoke(this);
  }

  @Override
  public Object getThis() {
    return obj;
  }

  @Override
  public AccessibleObject getStaticPart() {
    return null;
  }

  @Override
  public Method getMethod() {
    return null;
  }

}

@Test
public void testProxyFactory() {
  
  UserService proxy = (UserService)new ProxyFactory(UserService.class, new MethodInterceptor() {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
      System.out.println("jdk AOP .");
      return null;
    }
  }).getProxy();
  
  System.out.println(proxy.get(""));
  
  UserService userService = new LiteService();
  UserService proxy2 = (UserService)new ProxyFactory(userService, new MethodInterceptor() {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
      System.out.println("cglib AOP Before.");
      Object proceed = invocation.proceed();
      System.out.println("cglib AOP After.");
      return proceed;
    }
  }).getProxy();
  
  User user = proxy2.get("id");
  System.out.println(user.getName());
}

package com.deepoove.liteinject.aop;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Pointcut {

  private List<Class<?>> clazzes = new ArrayList<>();
  private List<Class<? extends Annotation>> clazzAnnotationes = new ArrayList<>();;

  private List<Class<? extends Annotation>> methodAnnotationes = new ArrayList<>();;

  public Pointcut() {}

  public Pointcut clazz(Class<?> clazz) {
    clazzes.add(clazz);
    return this;
  }

  public Pointcut clazzOrAnnotatedWith(Class<? extends Annotation> anno) {
    clazzAnnotationes.add(anno);
    return this;
  }

  public Pointcut methodAnnotatedWith(Class<? extends Annotation> clazz) {
    methodAnnotationes.add(clazz);
    return this;
  }

  public boolean matcher(Class<?> clazz) {
    if (null != clazzes && -1 != clazzes.indexOf(clazz)) return true;
    if (null == clazzAnnotationes || clazzAnnotationes.isEmpty()) return false;
    Annotation[] annotations = clazz.getAnnotations();
    if (null == annotations || annotations.length == 0) return false;
    return new ArrayList<>(clazzAnnotationes).retainAll(Arrays.asList(annotations));
  }

  public boolean matcher(Method method) {
    if (null == methodAnnotationes || methodAnnotationes.isEmpty()) return true;
    Annotation[] annotations = method.getAnnotations();
    if (null == annotations || annotations.length == 0) return false;
    return new ArrayList<>(methodAnnotationes).retainAll(Arrays.asList(annotations));
  }

}