// 查询SQL
String selectSql = sql"
select * from ${table} where name = ${name}
";
// 执行SQL
Data<User> data = jdbc.selectSql(sql, User.class);
//获取结果
boolean isEmpty = data.isEmpty();
User user = data.getOne(); // 可能为null
List<User> list = data.getList() // 不为null，但是size可为0
Map<Long, User> map = data.getMap(user -> user.getId);
String json = data.toJson();
// 对Data进行Stream支持
Data data = data.filter(user -> user.age > 10);

// 插入SQL
String insertOneSql = sql"
insert into ${table}(id, name, age) values(${user.id}, ${user.name}, ${user.age})
";

String insertListSql = sql"
insert into ${table}(id, name, age) values ${
for(User user in list) {
 sql(join=",")" (${user.id}, ${user.name}, ${user.age}) "
}
}
";

Data data = jdbc.update(insertOneSql);

public static void main(String[] argv) throws Exception
{
    int x = 2, y = 6;

    System.out.println("Hi!");
    System.out.println(x * y + y);
    try
    {
        int z = y * x;
    }
    catch (Exception e)
    {
        throw e;
    }
}

public static void main(java.lang.String[]) throws java.lang.Exception
{
    java.lang.String[] r0;
    int i0, i1, i2, $i3, $i4;
    java.io.PrintStream $r1, $r2;
    java.lang.Exception $r3, r4;

    r0 := @parameter0;
    i0 = 2;
    i1 = 6;
    $r1 = java.lang.System.out;
    $r1.println(``Hi!'');
    $r2 = java.lang.System.out;
    $i3 = i0 * i1;
    $i4 = $i3 + i1;
    $r2.println($i4);

 label0:
    i2 = i1 * i0;

 label1:
    goto label3;

 label2:
    $r3 := @caughtexception;
    r4 = $r3;
    throw r4;

 label3:
    return;

    catch java.lang.Exception from label0 to label1 with label2;
}

java.lang.String[] r0;
int i0, i1, i2, $i3, $i4;
java.io.PrintStream $r1, $r2;
java.lang.Exception $r3, r4;

catch java.lang.Exception from label0 to label1 with label2;

x = y + z;

x = y + 2;

    x = 5;
    goto l2;
    y = 3;
l2: z = 9;

s: goto l2;

l2:  goto l3;

public void readjustJumps(Unit s, Unit oldU, Unit newU)
{
    Iterator ubIt = s.getUnitBoxes.iterator();
    while (ubIt.hasNext())
    {
        StmtBox tb = (StmtBox)ubIt.next();
        Stmt targ = (Stmt)tb.getUnit();

        if (targ == oldU)
            tb.setUnit(newU);
    }
}

public void foldAdds(Unit u)
{
    Iterator ubIt = u.getUseBoxes().iterator();
    while (ubIt.hasNext())
    {
        ValueBox vb = (ValueBox) ubIt.next();
        Value v = vb.getValue();
        if (v instanceof AddExpr)
        {
            AddExpr ae = (AddExpr) v;
            Value lo = ae.getOp1(), ro = ae.getOp2();
            if (lo instanceof IntConstant && ro instanceof IntConstant)
            {
                IntConstant l = (IntConstant) lo,
                      r = (IntConstant) ro;
                int sum = l.value + r.value;
                vb.setValue(IntConstant.v(sum));
            }
        }
    }
}

public List getUseBoxes();
public List getDefBoxes();
public List getUseAndDefBoxes();

public List getUnitBoxes();

public List getBoxesPointingToThis();

public boolean fallsThrough();
public boolean branches();

public void redirectJumpsToThisTo(Unit newLocation);

package jnijava;

public class JniJava {
    public static void main(String[] args) {
        
        System.load("/Users/wangming/NetBeansProjects/jnicpp/dist/Debug/GNU-MacOSX/libjnicpp.dylib");
        System.out.println("JniJava");
        
        Obj obj = print();
        System.out.println(obj.str);
        System.out.println(obj.i);
    }
    
    public static native Obj print();
}

class Obj {
    public String str;
    public int i;
}

public State java.lang.Thread.getState() {
    // get current thread state
    return sun.misc.VM.toThreadState(threadStatus);
}

public static Thread.State sun.misc.VM.toThreadState(int threadStatus) {
    if ((threadStatus & JVMTI_THREAD_STATE_RUNNABLE) != 0) {
        return RUNNABLE;
    } else if ((threadStatus & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER) != 0) {
        return BLOCKED;
    } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_INDEFINITELY) != 0) {
        return WAITING;
    } else if ((threadStatus & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT) != 0) {
        return TIMED_WAITING;
    } else if ((threadStatus & JVMTI_THREAD_STATE_TERMINATED) != 0) {
        return TERMINATED;
    } else if ((threadStatus & JVMTI_THREAD_STATE_ALIVE) == 0) {
        return NEW;
    } else {
        return RUNNABLE;
    }
}

public class TestInSynchronized {

    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(8);

        Object lock = new Object();
        AtomicInteger atomicInteger = new AtomicInteger();

        Runnable runnable = () -> {
            synchronized (lock) {
                long start = System.currentTimeMillis();
                int sec = atomicInteger.addAndGet(2);
                System.out.println(Thread.currentThread().getName() + " running : " + sec + " seconds");
                while ((System.currentTimeMillis() - start) < sec * 1000) {}
                System.out.println(Thread.currentThread().getName() + " running finish");
            }
        };
        Thread thread1 = new Thread(runnable, "Flying Thread");
        Thread thread2 = new Thread(runnable, "Running Thread");

        thread1.start();
        thread2.start();

        ThreadUtil.printThreadState(thread1);
        ThreadUtil.printThreadState(thread2);

    }
}

import java.util.concurrent.TimeUnit;

public class TestThreadInWait {

    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(8);

        final Object lock = new Object();

        Thread thread = new Thread(() -> {
            ThreadUtil.running(2);
            synchronized (lock) {
                try {
                    lock.wait(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            ThreadUtil.running(2);
        }, "User");

        thread.start();

        ThreadUtil.printThreadState(thread);

    }
}

import java.util.concurrent.TimeUnit;

public class TestStateInSleep {

    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(8);

        Thread thread = new Thread(() -> {
            ThreadUtil.running(2);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            ThreadUtil.running(1);
        }, "User");
        thread.start();

        ThreadUtil.printThreadState(thread);
    }
}

import java.util.concurrent.TimeUnit;

public class ThreadJoin {

    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(6);

        Thread thread = new Thread(() -> {
            ThreadUtil.running(2);
        }, "User");
        thread.start();

        thread.join();
        ThreadUtil.running(2);
    }
}

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TestInLock {
    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(8);

        Lock lock = new ReentrantLock();

        AtomicInteger atomicInteger = new AtomicInteger();

        Runnable runnable = () -> {
            try {
                lock.lock();
                int sec = atomicInteger.addAndGet(2);
                System.out.println(Thread.currentThread().getName() + " running : " + sec + " seconds");
                ThreadUtil.running(sec);
                System.out.println(Thread.currentThread().getName() + " running finish");
            } finally {
                lock.unlock();
            }
        };
        Thread thread1 = new Thread(runnable, "Flying Thread");
        Thread thread2 = new Thread(runnable, "Running Thread");

        thread1.start();
        thread2.start();

        ThreadUtil.printThreadState(thread1);
        ThreadUtil.printThreadState(thread2);
    }
}

public class TestIO {

    public static void main(String[] args) throws InterruptedException {
        TimeUnit.SECONDS.sleep(8);

        Runnable runnable = () -> {
            File file = new File("/Users/dawangyu/123.mkv");
            try (FileInputStream fileInputStream = new FileInputStream(file);) {
                byte[] bytes = new byte[1024 * 1024 * 1024];
                fileInputStream.read(bytes);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        };
        Thread thread1 = new Thread(runnable, "Flying Thread");

        thread1.start();

        ThreadUtil.printThreadState(thread1);
    }
}

public JrcResult compile(String javaCode) throws Exception {

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();

        JrcJavaFileManager fileManager = JavaFileManagerFactory.getJavaFileManager(compiler.getStandardFileManager(diagnostics, null, null));

        ClassInfo classInfo = getClassFileFromJavaSource(javaCode);
        List<JavaFileObject> javaFileObjects = new ArrayList<>();
        javaFileObjects.add(new StringJavaFileObject(classInfo.className, javaCode));

        //使用编译选项可以改变默认编译行为。编译选项是一个元素为String类型的Iterable集合
        List<String> options = new ArrayList<>();
        options.add("-encoding");
        options.add("UTF-8");
        options.add("-classpath");
        options.add(classpath);

        StringWriter outWriter = new StringWriter();
        JavaCompiler.CompilationTask task = compiler.getTask(outWriter, fileManager, diagnostics, options, null, javaFileObjects);
        // 编译源程序
        boolean success = task.call();
    }

public class SpringBootJavaFileManager extends JrcJavaFileManager {

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

    SpringBootLauncher springBootLauncher;

    public SpringBootJavaFileManager(StandardJavaFileManager standardManager) {
        super(standardManager);

        try {
            springBootLauncher = new SpringBootLauncher();
            springBootLauncher.launch();
        } catch (Exception e) {
            logger.error("", e);
        }
    }

    @Override
    public ClassLoader getClassLoader(Location location) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        ClassLoaderUtil.setClassLoader(new JrcLaunchedURLClassLoader(cl));
        return cl;
    }

    @Override
    public Iterable<JavaFileObject> list(Location location, String packageName, Set set, boolean recurse) throws IOException {

        String packagePath = packageName.replaceAll("\\.", "/");
        List<SpringBootArchiveEntry> entries = springBootLauncher.getEntries(packagePath);

        List<JavaFileObject> list = entries.stream().map(it -> new JarJavaFileObject(it, JavaFileObject.Kind.CLASS)).collect(Collectors.toList());

        Iterable<JavaFileObject> superList = super.list(location, packageName, set, recurse);
        if (superList == null) {
            return list;
        }

        for (JavaFileObject o : superList) {
            list.add(o);
        }

        return list;
    }

    /**
     * 将 JavaFileObject 转换成className
     *
     * @param location PLATFORM_CLASS_PATH
     * @param file     /Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home/lib/ct.sym(META-INF/sym/rt.jar/java/lang/Comparable.class)
     * @return java.lang.Comparable
     */
    @Override
    public String inferBinaryName(Location location, JavaFileObject file) {
        if (file instanceof JarJavaFileObject) {
            return file.getName();
        } else {
            return super.inferBinaryName(location, file);
        }
    }

}

public class JrcLaunchedURLClassLoader implements JrcClassLoader {

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

    private ClassLoader launchedURLClassLoader;

    public JrcLaunchedURLClassLoader(ClassLoader launchedURLClassLoader) {
        this.launchedURLClassLoader = launchedURLClassLoader;
    }

    public Class defineClass(String name, byte[] b) {
        try {
            return launchedURLClassLoader.loadClass(name);
        } catch (ClassNotFoundException e) {
        }
        try {
            Method defineClassMethod = ClassLoader.class.getDeclaredMethod("defineClass", new Class[]{String.class, byte[].class, int.class, int.class});
            boolean isAccessible = defineClassMethod.isAccessible();
            if (!isAccessible) {
                defineClassMethod.setAccessible(true);
            }

            Object result = defineClassMethod.invoke(launchedURLClassLoader, name, b, 0, b.length);
            defineClassMethod.setAccessible(isAccessible);

            return (Class) result;
        } catch (NoSuchMethodException e) {
            logger.error("defineClass name:{}", name, e);
            return null;
        } catch (IllegalAccessException e) {
            logger.error("defineClass name:{}", name, e);
            return null;
        } catch (InvocationTargetException e) {
            logger.error("defineClass name:{}", name, e);
            return null;
        }
    }
}

@Configuration
public class ShiroConfig {

    private static final Logger LOGGER = LoggerFactory.getSystemLogger(ShiroConfig.class);

    @Autowired
    private ApplicationContext applicationContext;

    @Resource
    private SecurityManager securityManager;

    @PostConstruct
    private void initStaticSecurityManager() {
        SecurityUtils.setSecurityManager(securityManager);
    }

    @Bean(name = "securityManager")
    public DefaultWebSecurityManager defaultWebSecurityManager(@Autowired DatabaseRealm shiroDatabaseRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(shiroDatabaseRealm);
        securityManager.setSessionManager(buildSessionManager());
        return securityManager;
    }

    private SessionManager buildSessionManager() {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setSessionIdCookie(buildCookie());
        sessionManager.setSessionIdCookieEnabled(true);
        sessionManager.setSessionIdUrlRewritingEnabled(false);
        // 全局会话超时时间（单位毫秒），默认30分钟
        sessionManager.setGlobalSessionTimeout(AuthConstant.GlobalSessionTimeout);
        // 是否开启删除无效的session对象  默认为true
        sessionManager.setDeleteInvalidSessions(true);
        // 是否开启定时调度器进行检测过期session 默认为true
        sessionManager.setSessionValidationSchedulerEnabled(true);
        // 设置session失效的扫描时间, 清理用户直接关闭浏览器造成的孤立会话 默认30分钟
        sessionManager.setSessionValidationInterval(AuthConstant.SessionValidationInterval);
        return sessionManager;
    }

    public SimpleCookie buildCookie() {
        SimpleCookie simpleCookie = new SimpleCookie(TOKEN_NAME);
        simpleCookie.setPath("/");
        // 对服务器生成的TOKEN设置 HttpOnly 属性. 前端无法读写该TOKEN, 提供系统安全, 防止XSS攻击
        simpleCookie.setHttpOnly(true);
        // 设置浏览器关闭时失效此Cookie
        simpleCookie.setMaxAge(-1);
        return simpleCookie;
    }

    /**
     * 设置接口权限验证, 目前只针对api接口进行权限验证
     *
     * @param securityManager
     * @return
     */
    @Bean(name = "shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        LOGGER.info("start shiroFilter setting");

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        shiroFilterFactoryBean.setLoginUrl("/");
        shiroFilterFactoryBean.setSuccessUrl("/#/dashboard");
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");

        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();

        Map<String, Filter> filtersMap = new LinkedHashMap<>();
        filtersMap.put("apiAccessControlFilter", new ApiAccessControlFilter());
        shiroFilterFactoryBean.setFilters(filtersMap);

        filterChainDefinitionMap.put("/static/**", "anon");
        filterChainDefinitionMap.put("/#/login/**", "anon");
        filterChainDefinitionMap.put("/api/user/auth/login", "anon");
        filterChainDefinitionMap.put("/logout", "logout");
        filterChainDefinitionMap.put("/api/**", "apiAccessControlFilter");
        filterChainDefinitionMap.put("/**", "logFilter");
        filterChainDefinitionMap.put("/**", "authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);

        LOGGER.info("shirFilter config fineshed");
        return shiroFilterFactoryBean;
    }

    @Bean
    public CorsFilter corsFilter() {
        // CORS配置信息
        CorsConfiguration config = new CorsConfiguration();

        if (!SpringUtil.isInProduction(applicationContext)) {
            LOGGER.info("进行非生产模式CORS配置");
            config.addAllowedOrigin("*");
            config.setAllowCredentials(true);
            config.addAllowedMethod("*");
            config.addAllowedHeader("*");
            config.addExposedHeader("Set-Cookie");
        }

        UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
        configSource.registerCorsConfiguration("/**", config);
        return new CorsFilter(configSource);
    }
}

SimpleCookie simpleCookie = new SimpleCookie(TOKEN_NAME);
simpleCookie.setHttpOnly(true);

Map<String, Filter> filtersMap = new LinkedHashMap<>();
filtersMap.put("apiAccessControlFilter", new ApiAccessControlFilter());
filterChainDefinitionMap.put("/api/user/auth/login", "anon");
filterChainDefinitionMap.put("/api/**", "apiAccessControlFilter");

if (!SpringUtil.isInProduction(applicationContext)) {
            LOGGER.info("进行非生产模式CORS配置");
            config.addAllowedOrigin("*");
            config.setAllowCredentials(true);
            config.addAllowedMethod("*");
            config.addAllowedHeader("*");
            config.addExposedHeader("Set-Cookie");
}