public static void main(String[] args) {
    ActorSystem actorSystem = ActorSystem.create();
    ActorRef bunchingActorRefPool = actorSystem.actorOf(Props.create(BunchingActor.class)
            .withRouter(new RoundRobinPool(8)));
    // Or
    // 我们可能之前已经创建了一些actor 然后要把这些actor 组织在一起
    List<String> paths = Arrays.asList("/user/w1", "/user/w2", "/user/w3");

    ActorRef bunchingActorRefGroup = actorSystem.actorOf(new RoundRobinGroup(paths).props());
}

ActorRef bunchingActorRefPool = actorSystem.actorOf(Props.create(BunchingActor.class)
                .withRouter(new RoundRobinPool(8).withSupervisorStrategy(OneForOneStrategy.defaultStrategy())));
        

ActorRef bunchingActorRefPool = actorSystem.actorOf(Props.create(BunchingActor.class)
                .withRouter(new RoundRobinPool(8)
                        .withSupervisorStrategy(OneForOneStrategy.defaultStrategy())
                        .withDispatcher("my-dispatcher")));

Executor executor = context().system().dispatchers().lookup("blocking-io-dispatcher");
        CompletableFuture<String> completableFuture = CompletableFuture
                .supplyAsync(() -> "analyse something", executor);

new OneForOneStrategy(2,Duration.create("1 minute"), PartialFunction)

package com.akkademy.article;

import akka.actor.AbstractActorWithStash;
import akka.japi.pf.ReceiveBuilder;
import com.akkademy.messages.GetRequest;

/**
 * @author dafuchen
 * 2019-03-03
 */
public class MessageStachActor extends AbstractActorWithStash {
    private Boolean online = Boolean.FALSE;
    @Override
    public Receive createReceive() {
        ReceiveBuilder.create().match(GetRequest.class, x -> {
            if (online) {

            } else {
                stash();
            }
        }).match(Connected.class, x -> {
            online = true;
            unstash();
        }).match(Disconnect.class, x -> online = false)
                .build();
        return null;
    }
}

package com.akkademy.messages;

import akka.actor.AbstractActorWithStash;
import akka.actor.ActorRef;
import akka.japi.pf.ReceiveBuilder;
import com.akkademy.article.Connected;
import com.akkademy.article.Disconnect;

/**
 * @author dafuchen
 * 2019-03-03
 */
public class BecomeActor extends AbstractActorWithStash {
    private final ActorRef actorRef;

    public BecomeActor(String refLocation) {
        actorRef = context().actorFor(refLocation);
    }

    @Override
    public Receive createReceive() {

        return ReceiveBuilder.create()
                .match(GetRequest.class, x -> stash())
                .match(Connected.class, x -> {
                    context().become(ReceiveBuilder.create()
                            .match(GetRequest.class, b -> actorRef.tell("", self())).build().onMessage());
                    unstash();
                }).match(Disconnect.class, x -> context().unbecome())
                .build();
    }
}

package com.akkademy.messages;

import akka.actor.AbstractActorWithStash;
import akka.actor.ActorRef;
import akka.japi.pf.ReceiveBuilder;
import com.akkademy.article.Connected;
import com.akkademy.article.ConnectionTimeoutException;
import com.akkademy.article.Disconnect;
import com.akkademy.article.TestConnected;
import scala.concurrent.duration.Duration;

import java.sql.Time;
import java.util.concurrent.TimeUnit;

/**
 * @author dafuchen
 * 2019-03-03
 */
public class BecomeActor extends AbstractActorWithStash {
    private final ActorRef actorRef;
    private Boolean connected;

    public BecomeActor(String refLocation) {
        actorRef = context().actorFor(refLocation);
    }

    @Override
    public Receive createReceive() {

        return ReceiveBuilder.create()
                .match(GetRequest.class, x -> stash())
                .match(Connected.class, x -> {
                    context().become(ReceiveBuilder.create()
                            .match(GetRequest.class, b -> actorRef.tell("", self())).build().onMessage());
                    unstash();
                }).match(Disconnect.class, x -> context().unbecome())
                .match(TestConnected.class, x -> {
                    if (! connected) {
                        throw new ConnectionTimeoutException();
                    }
                })
                .build();
    }
    

    @Override
    public void preStart() {
        context().system()
                .scheduler()
                
                .scheduleOnce(
                        // 延迟执行的时间
                        Duration.create(1000, TimeUnit.MICROSECONDS), 
                        self(),
                        new TestConnected(),
                        context().dispatcher(),
                        null
                        );
    }
}

public enum Status {
    /**
     * 中断连接
     */
    DISCONNECTED,
    /**
     * 连接
     */
    CONNECTED,
    /**
     * 连接等待
     */
    CONNECTED_PENDING
}

public class BunchingActor extends AbstractFSM<Status,
        LinkedBlockingQueue<GetRequest>> {
    public BunchingActor() {
        startWith(Status.DISCONNECTED, null);
				//在离线的情况下
      	// 如果有清空的请求 -> 保持原状
        // 如果有发送消息的请求 -> 把这个请求放到队列中
      	// 如果连接上了网络
      	//	请求队列中有没有内容 状态变迁到连接中
      	//					 有内容 变迁到填充中状态中
        when(Status.DISCONNECTED,
                matchEvent(FlushMsg.class, (msg, container) -> stay())
                .event(SendRequest.class, (msg, container) -> {
                    container.add(msg);
                    return stay();
                })
                .event(Tcp.Connected.class, (msg, container) -> {
                    if (Objects.isNull(container.peek())) {
                        return goTo(Status.CONNECTED);
                    } else {
                        return goTo(Status.CONNECTED_PENDING);
                    }
                })
        );
				//在在线的情况下
      	// 如果有清空的请求 -> 保持原状(因为队列是空的, 不能进行清空)
      	// 如果有发送消息的请求 -> 保存到队列 同时将状态变迁到填充中的状态
        when(Status.CONNECTED,
                matchEvent(FlushMsg.class, (msg, container) -> stay())
                        .event(SendRequest.class, (msg, container) -> {
                            container.add(msg);
                            return goTo(Status.CONNECTED_PENDING);
                        })
                        .event(String.class, (msg, container) -> {
                            System.out.println(msg);
                            return stay();
                        }));
			//在 填充中的状态
      // 清空请求 -> 进行清空, 同时将状态变迁到连接中(没有内容可以被清空了)
        when(Status.CONNECTED_PENDING,
                matchEvent(FlushMsg.class, (msg, container) -> {
                    container.clear();
                    return stay();
                }).event(SendRequest.class, (msg, container) -> {
                    container.add(msg);
                    return goTo(Status.CONNECTED_PENDING);
                }));
    }
}

org.apache.ibatis.transaction.jdbc.JdbcTransaction
org.apache.ibatis.transaction.managed.ManagedTraction 

package org.apache.ibatis.transaction.jdbc;

import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.apache.ibatis.transaction.TransactionException;

/**
 * {@link Transaction} that makes use of the JDBC commit and rollback facilities directly.
 * It relies on the connection retrieved from the dataSource to manage the scope
* of the transaction.
 * Delays connection retrieval until getConnection() is called.
 * Ignores commit or rollback requests when autocommit is on.
 *
 * @see JdbcTransactionFactory
 */
/**
 * Jdbc事务
 * @author Clinton Begin
 */
public class JdbcTransaction implements Transaction {

  private static final Log log = LogFactory.getLog(JdbcTransaction.class);

  protected Connection connection;			//数据库连接
  protected DataSource dataSource;			//数据源
  protected TransactionIsolationLevel level;//事务隔离级别
  protected boolean autoCommmit;			//是否自动提交

  public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
    dataSource = ds;
    level = desiredLevel;
    autoCommmit = desiredAutoCommit;
  }

  public JdbcTransaction(Connection connection) {
    this.connection = connection;
  }

  @Override
  public Connection getConnection() throws SQLException {
    if (connection == null) {
      openConnection();
    }
    return connection;
  }

  @Override
  public void commit() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) { //连接非空且事务不是自动提交时
      if (log.isDebugEnabled()) {
        log.debug("Committing JDBC Connection [" + connection + "]");
      }
      connection.commit();
    }
  }

  @Override
  public void rollback() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) { //连接非空且事务不是自动提交时
      if (log.isDebugEnabled()) {
        log.debug("Rolling back JDBC Connection [" + connection + "]");
      }
      connection.rollback();
    }
  }

  @Override
  public void close() throws SQLException {
    if (connection != null) {
      resetAutoCommit();	//重置自动提交为true
      if (log.isDebugEnabled()) {
        log.debug("Closing JDBC Connection [" + connection + "]");
      }
      connection.close();
    }
  }

  /**
   * @description 设置是否自动提交事务 
   * @author xudj
   * @date 2016年7月15日 下午5:37:37
   * @param desiredAutoCommit
   */
  protected void setDesiredAutoCommit(boolean desiredAutoCommit) {
    try {
    	//和之前的不相等时进行设置
      if (connection.getAutoCommit() != desiredAutoCommit) {
        if (log.isDebugEnabled()) {
          log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");
        }
        connection.setAutoCommit(desiredAutoCommit);
      }
    } catch (SQLException e) {
      // Only a very poorly implemented driver would fail here,
      // and there's not much we can do about that.
      throw new TransactionException("Error configuring AutoCommit.  "
          + "Your driver may not support getAutoCommit() or setAutoCommit(). "
          + "Requested setting: " + desiredAutoCommit + ".  Cause: " + e, e);
    }
  }

  /**
   * @description 重置事务自动提交 
   * @author xudj
   * @date 2016年7月15日 下午5:41:40
   */
  protected void resetAutoCommit() {
    try {
      if (!connection.getAutoCommit()) {
        // MyBatis does not call commit/rollback on a connection if just selects were performed.
        // Some databases start transactions with select statements
        // and they mandate a commit/rollback before closing the connection.
        // A workaround is setting the autocommit to true before closing the connection.
        // Sybase throws an exception here.
        if (log.isDebugEnabled()) {
          log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");
        }
        connection.setAutoCommit(true);
      }
    } catch (SQLException e) {
      if (log.isDebugEnabled()) {
        log.debug("Error resetting autocommit to true "
          + "before closing the connection.  Cause: " + e);
      }
    }
  }

  /**
   * @description 打开数据库连接 
   * @author xudj
   * @date 2016年7月15日 下午1:55:38
   * @throws SQLException
   */
  protected void openConnection() throws SQLException {
    if (log.isDebugEnabled()) {		//先判断是否是debug模式，其它地方作用相同
      log.debug("Opening JDBC Connection");
    }
    connection = dataSource.getConnection();	//获取数据库连接
    if (level != null) {
   //设置事务隔离级别，通过枚举进行获取
      connection.setTransactionIsolation(level.getLevel());		
    }
    setDesiredAutoCommit(autoCommmit);		//设置是否自动提交
  }

}

// runnable
new Thread(() -> System.out.println("hello world")).start();

//callable 
FutureTask<String> futureTask = new FutureTask<>(() -> "this is Future");
		   new Thread(futureTask).start();
        String result = futureTask.get();

class ConcurrentStack<E> {
    AtomicReference<Node<E>> top = new AtomicReference<>();

    public void push(E item) {
        Node<E> newHead = new Node<>(item);
        Node<E> oldHead;

        for(;;) {
            oldHead = top.get();
            newHead.next = oldHead;
            if (top.compareAndSet(oldHead, newHead)) {
                break;
            }
        }
    }

    public E pop() {
        Node<E> oldHead = null;
        Node<E> newHead = null;

        for(;;) {
            oldHead = top.get();
            if (Objects.isNull(oldHead)) {
                return null;
            }
            newHead = oldHead;
            if (top.compareAndSet(oldHead, newHead)) {
                break;
            }
        }
        return oldHead.item;
    }
    private static class Node<E> {
        public final E item;
        public Node<E> next;

        public Node(E item) {
            this.item = item;
        }
    }
}

public native void unpark(Thread jthread);
public native void park(boolean isAbsolute, long time);

   /**
 * Possible state transitions:
    * NEW -> COMPLETING -> NORMAL
    * NEW -> COMPLETING -> EXCEPTIONAL
    * NEW -> CANCELLED
    * NEW -> INTERRUPTING -> INTERRUPTED
    * /
private volatile int state;
   private static final int NEW          = 0;
   private static final int COMPLETING   = 1;
   private static final int NORMAL       = 2;
   private static final int EXCEPTIONAL  = 3;
   private static final int CANCELLED    = 4;
   private static final int INTERRUPTING = 5;
   private static final int INTERRUPTED  = 6;

/** The underlying callable; nulled out after running */
   private Callable<V> callable;
   /** The result to return or exception to throw from get() */
   private Object outcome; // non-volatile, protected by state reads/writes
   /** The thread running the callable; CASed during run() */
   private volatile Thread runner;
   /** Treiber stack of waiting threads */
   private volatile WaitNode waiters;

static final class WaitNode {
    volatile Thread thread;
    volatile WaitNode next;
    WaitNode() { thread = Thread.currentThread(); }
}

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
	
	private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            else if (!queued)
			/**
             * compareAndSwapObject(Object var1, long var2, Object var3, Object var4)
             * var1 操作的对象
             * var2 操作的对象属性
             * var3 var2与var3比较，相等才更新
             * var4 更新值
             * waitersOffset = UNSAFE.objectFieldOffset
                (k.getDeclaredField("waiters")
			 * 用了CAS 相当于 把当前的线程的信息写入到waiters中, 失败了就会到这个for中然后还是继续到这个if分支, 继续做CAS 直到成功.
             */
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                LockSupport.park(this);
        }
    }

   public void run() {
       if (state != NEW ||
           !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                        null, Thread.currentThread()))
           return;
       try {
           Callable<V> c = callable;
           if (c != null && state == NEW) {
               V result;
               boolean ran;
               try {
                   result = c.call();
                   ran = true;
               } catch (Throwable ex) {
                   result = null;
                   ran = false;
                   setException(ex);
               }
               if (ran)
                   set(result);
           }
       } finally {
           // runner must be non-null until state is settled to
           // prevent concurrent calls to run()
           runner = null;
           // state must be re-read after nulling runner to prevent
           // leaked interrupts
           int s = state;
           if (s >= INTERRUPTING)
               handlePossibleCancellationInterrupt(s);
       }
   }

  protected void set(V v) {
       if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
           outcome = v;
           UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
           finishCompletion();
       }
   }
// 通过CAS的方式唤醒每一个被pack的线程,将他们unpack
private void finishCompletion() {
       // assert state > COMPLETING;
       for (WaitNode q; (q = waiters) != null;) {
           if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
               for (;;) {
                   Thread t = q.thread;
                   if (t != null) {
                       q.thread = null;
                       LockSupport.unpark(t);
                   }
                   WaitNode next = q.next;
                   if (next == null)
                       break;
                   q.next = null; // unlink to help gc
                   q = next;
               }
               break;
           }
       }

       done();

       callable = null;        // to reduce footprint
   }

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);

public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor);

public static CompletableFuture<Void> runAsync(Runnable runnable);

public static CompletableFuture<Void> runAsync(Runnable runnable,
                                                   Executor executor)

List<CompletableFuture<ContractAuditResponseDTO>> futures = contractAuditReportList.stream().map(auditReport ->
             CompletableFuture.supplyAsync(() -> {
               // create contractAuditResponseDTO
            }).thenApplyAsync(contractAuditResponseDTO -> {
                // file the other part
                return contractAuditResponseDTO;
            })
        ).collect(Collectors.toList());
List<ContractAuditResponseDTO> contractAuditResponseDTOS = Futures.sequence(futures).get();

package akkademy.message;

import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import com.akkademy.pingpong.JavaPongActor;
import org.junit.Test;
import scala.concurrent.Future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;

import static akka.pattern.Patterns.ask;
import static scala.compat.java8.FutureConverters.toJava;

/**
 * @author dafuchen
 * 2019-02-17
 */
public class JavaPongActorTest {
    ActorSystem actorSystem = ActorSystem.create();
    ActorRef actorRef = actorSystem.actorOf(Props.create(JavaPongActor.class));
    @Test
    public void shouldReplyToPingWithPong() throws Exception {
        Future sFuture = ask(actorRef, "Ping", 1000);
        final CompletionStage<String> cs = toJava(sFuture);
        final CompletableFuture<String> jFuture = (CompletableFuture<String>) cs;
        assert (jFuture.get(1000, TimeUnit.MILLISECONDS).equals("Pong"));
    }
}

// aksPong 返回的是completeStage 的子类
askPong("cause error").handle((x, t) -> {
	if(t != null){
	System.out.println("Error: " + t);
	}
	return null;
});

CompletionStage<String> cs = askPong("cause error")
	.exceptionally(t -> {
	return "default";
});

askPong("cause error").handle( (pong, ex) -> ex == null
	? CompletableFuture.completedFuture(pong)
	: askPong("Ping")
).thenCompose(x -> x);

askPong("Ping")
	.thenCombine(askPong("Ping"), (a,b) -> {
		return a + b; //"PongPong"
});

public class AskDemoArticleParser extends AbstractActor {
    private final ActorSelection cacheActor;
    private final ActorSelection httpClientActor;
    private final ActorSelection articleParseActor;
    private final Timeout timeout;

    public AskDemoArticleParser(String cacheActor,
                                String httpClientActor,
                                String articleParseActor,
                                Timeout timeout) {
       
        this.cacheActor = context().actorSelection(cacheActor);
        this.httpClientActor = context().actorSelection(httpClientActor);
        this.articleParseActor = context().actorSelection(articleParseActor);
        this.timeout = timeout;
    }

    @Override
    public Receive createReceive() {
        final ActorRef senderRef = sender();
        
        return ReceiveBuilder.create().match(ParseArticle.class, msg -> {
            toJava(ask(cacheActor, new GetRequest(msg.getUrl()), timeout)).handle((x, t) ->
                    ! Objects.isNull(x)
                            ? CompletableFuture.completedFuture(x)
                            : toJava(ask(httpClientActor, msg.getUrl(), timeout))
                    .thenCompose(rawArticle -> toJava(ask(articleParseActor, new ParseHtmlArticle(msg.getUrl(),
                            ((HttpResponse) rawArticle).getBody()), timeout)))
            ).handle((x, t) -> {
                if (Objects.isNull(x)) {
                    if (x instanceof ArticleBody) {
                        String body = ((ArticleBody) x).getBody();

                        cacheActor.tell(body, self());
                        senderRef.tell(body, self());
                    } else {
                        senderRef.tell(new Status.Failure((Throwable)t), self());
                        return null;
                    }
                }
                return null;
            });
        }).build();

    }
}

package top.andrewchen1.chapter3;

import akka.actor.*;
import akka.japi.pf.ReceiveBuilder;
import akka.util.Timeout;
import top.andrewchen1.chapter2.db.GetRequest;
import top.andrewchen1.chapter2.db.SetRequest;

import java.util.concurrent.TimeoutException;

/**
 * @author dafuchen
 * 2019-03-17
 */
public class ArticleTellParserActor extends AbstractActor {
    private final ActorSelection cacheActor;
    private final ActorSelection httpClientActor;
    private final ActorSelection articleParseActor;
    private final Timeout timeout;

    public ArticleTellParserActor (String cacheActor,
                             String httpClientActor,
                             String articleParseActor,
                             Timeout timeout) {
        this.cacheActor = context().actorSelection(cacheActor);
        this.httpClientActor = context().actorSelection(httpClientActor);
        this.articleParseActor = context().actorSelection(articleParseActor);
        this.timeout = timeout;
    }
    @Override
    public Receive createReceive() {
        return ReceiveBuilder.create()
                .match(ParseArticle.class, message -> {
                    ActorRef extraActor = buildExtraActor(sender(), message.getUrl());
                    cacheActor.tell(new GetRequest(message.getUrl()), extraActor);
                    httpClientActor.tell(message.getUrl(), extraActor);
                    context().system().scheduler().scheduleOnce(
                            timeout.duration(),
                            extraActor,
                            "timeout",
                            context().system().dispatcher(),
                            ActorRef.noSender()
                    );
                })
                .build();
    }
    private ActorRef buildExtraActor(ActorRef senderRef, String uri) {
        class MyActor extends AbstractActor {

            @Override
            public Receive createReceive() {
                return ReceiveBuilder.create().matchEquals(String.class, x ->  x.equals("timeout"), x -> {
                    senderRef.tell(new Status.Failure(new TimeoutException("timeout")), self());
                    context().stop(self());
                })
                        .match(HttpResponse.class, httpResponse -> {
                            articleParseActor.tell(new ParseHtmlArticle(uri, httpResponse.getBody()), self());
                        }).match(String.class, body -> {
                            senderRef.tell(body, self());
                            context().stop(self());
                        }).match(ArticleBody.class, articleBody -> {
                            cacheActor.tell(new SetRequest(articleBody.getUri(), articleBody.getBody()), self());
                            context().stop(self());
                        }).matchAny(t ->
                                System.out.println("ignoring msg" + t.getClass()))
                        .build();
            }
        }
        return context().actorOf(Props.create(MyActor.class, MyActor::new));
    }
}

pipe(future, system.dispatcher()).to(sender());

public enum Color {
    RED(255, 0, 0);
    Color(int r, int b, int g) {
        this.r = r;
        this.b = b;
        this.g = g;
    }
    private int r;
    private int b;
    private int g;

    public int getRed() {
        return r;
    }
    //... etc

    @Override
    public String toString() {
        return "the rbg is {" + r +", " + b + ", " + g + "}";
    }
}

public enum Main {
    RED(255, 0, 0);
    Main(int r, int b, int g) {
        this.r = r;
        this.b = b;
        this.g = g;
    }
    private int r;
    private int b;
    private int g;

    public int getRed() {
        return r;
    }
    //... etc

    @Override
    public String toString() {
        return "the rbg is {" + r +", " + b + ", " + g + "}";
    }
}

public final class Main extends java.lang.Enum<Main> {
  public static final Main RED;
  public static Main[] values();
  public static Main valueOf(java.lang.String);
  public int getRed();
  public java.lang.String toString();
  static {};
}

public enum ConstantSpecificMethod {
    DATE_TIME {
        String getInfo() {
            return "I AM DATE_TIME";
        }
    };
    
    abstract String getInfo();
}

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface DbTable {
    public String name() default "";
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface ConStraints {
    boolean primaryKey() default false;
    boolean allowNull() default true;
    boolean unqiue() default false;
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface SQLString {
    int value() default 0;
    String name() default "";
    //
    ConStraints conStraints() default @ConStraints;
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface SQLInter {
    String name() default "";
    ConStraints conStraints() default @ConStraints;
}

@DbTable(name = "member")
@Date
public class Member {
    @SQLString(30)
    private String firstName;
    @SQLString(50)
    private String lastName;
    @SQLInter
    private Integer age;
    @SQLString(value = 30, conStraints = @ConStraints(primaryKey = true))
    private String handler;
}

public class Main {
    public static void main(String[] args) {
        Class member = Member.class;
        DbTable dbTable = member.getAnnotationsByType(DbTable.class);
        if (! Objects.isNull(dbTable)) {
            String tableName = dbTable.name();
            if (! Objects.isNull(tableName) && tableName.length() > 0) {
                tableName = tableName.toUpperCase();
            } else {
                tableName = member.getName().toUpperCase();
            }
            Field[] fields = member.getDeclaredFields();
            StringBuilder[] fieldsDefs = new StringBuilder[fields.length];

            for (int i = 0; i < fields.length; i ++) {
                Field field = fields[i];
                fieldsDef[i] = new StringBuilder();

                Annotation[] annotations = field.getAnnotations();
                if (annotations.length == 0) {
                    continue;
                }
                for (Annotation annotation : annotations) {
                    String columnName = "";
                    if (annotation instanceof SQLInter) {
                        SQLInter sqlInter = (SQLInter) annotation;
                        fieldsDef[i].append(" INT ").append( getConstrains(sqlInter.conStraints()));
                    }
                }
                // many many other type
            }

            StringBuilder createCommand = new StringBuilder();
            createCommand.append("crate table ").append(tableName).append(" (");
            for (StringBuilder stringBuilder : fieldsDefs ) {
                createCommand.append(stringBuilder).append(" , ");
            }
            // 去掉最后一个逗号
            createCommand = createCommand.subSequence(0, createCommand.length() - 2);
            createCommand.append(" );");             
        }
    }

    private static String getConstrains(ConStraints con) {
        StringBuilder constraints = new StringBuilder();
        if (! con.allowNull()) {
            constraints.append(" NOT NUll ");
        }

        if (con.primaryKey()) {
            constraints.append(" PRIMARY KEY ");
        }

        if (con.unqiue()) {
            constraints.append(" UNIQUE ");
        }

        return constraints.toString();
    }
}