public class ThreadLocal<T> {
    
    public void set(T value) {
        // 获取当前线程对象
        Thread t = Thread.currentThread();
        // 获得当前线程的 ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        // 将值放入 ThreadLocalMap 中
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    // ...
}

public class Thread implements Runnable {
    /* 与此线程相关的 ThreadLocal 值。这个 Map 由 ThreadLocal 类维护。 */
    ThreadLocal.ThreadLocalMap threadLocals = null;
    
    // ...
}

public class Thread implements Runnable {
    /**
     * 系统调用此方法是为了让线程在实际退出之前有机会进行清理。
     */
    private void exit() {
        if (group != null) {
            group.threadTerminated(this);
            group = null;
        }
        /* 侵略性地清除所有引用字段:参见bug 4006245 */
        target = null;
        /* 加快这些资源的释放 */
        threadLocals = null;
        inheritableThreadLocals = null;
        inheritedAccessControlContext = null;
        blocker = null;
        uncaughtExceptionHandler = null;
    }
}

/**
* ThreadLocalMap是一个定制的哈希映射，只适合维护线程本地值。
* 在ThreadLocal类之外不导出任何操作。类是包私有的，允许在类线程中声明字段。
* 为了帮助处理非常大且长期存在的使用，哈希表项对键使用弱引用。
* 但是，由于没有使用引用队列，因此只有在表开始耗尽空间时才保证删除过时的条目。
*/
static class ThreadLocalMap {

    /**
     * 该类继承了WeakReference是方便垃圾回收，在底层map扩容之前进行entry的回收，
     * 减少扩容的概率,提高性能
     */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }

    /**
     * 初始容量
     */
    private static final int INITIAL_CAPACITY = 16;

    /**
     * 底层数组
     */
    private Entry[] table;

    /**
     * map中entry的个数
     */
    private int size = 0;

    /**
     * 阈值，超过这个阈值之后就需要进行扩容
     */
    private int threshold; // Default to 0

    /**
     * 阈值是底层数组长度的2/3
     */
    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }

    /**
     * 计算下一个索引，hash算法定位失败的时候（也就是该索引位置存在元素）
     */
    private static int nextIndex(int i, int len) {
        return ((i + 1 < len) ? i + 1 : 0);
    }

    /**
     * 上一个位置索引，hash算法定位失败的时候（也就是该索引位置存在元素）
     */
    private static int prevIndex(int i, int len) {
        return ((i - 1 >= 0) ? i - 1 : len - 1);
    }

    /**
     * 根据 key 和 value 构建 ThreadLocalMap
     */
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        //初始化table
        table = new Entry[INITIAL_CAPACITY];
        //计算索引
        // & (INITIAL_CAPACITY - 1) 这是取模的一种方式，对于2的幂作为模数取模，用此代替%(2^n)
        // firstKey.threadLocalHashCode 其主要目的就是为了让哈希码能均匀的分布在2的n次方的数组里, 也就是Entry[] table中
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        //设置值
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        //设置阈值
        setThreshold(INITIAL_CAPACITY);
    }

    /**
     * 根据父容器构造ThreadLocalMap
     *
     * @param parentMap the map associated with parent thread.
     */
    private ThreadLocalMap(ThreadLocalMap parentMap) {
        Entry[] parentTable = parentMap.table;
        int len = parentTable.length;
        setThreshold(len);
        table = new Entry[len];
        //复制遍历
        for (int j = 0; j < len; j++) {
            Entry e = parentTable[j];
            if (e != null) {
                @SuppressWarnings("unchecked")
                ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                if (key != null) {
                    Object value = key.childValue(e.value);
                    Entry c = new Entry(key, value);
                    //该句相当于 hashcode % len但是&运算更加高效
                    int h = key.threadLocalHashCode & (len - 1);
                    //hash算法定位失败，找下一个索引
                    while (table[h] != null)
                        h = nextIndex(h, len);
                    table[h] = c;
                    size++;
                }
            }
        }
    }

    /**
     * ThreadLocalMap使用线性探测法来解决哈希冲突，线性探测法的地址增量di = 1, 2, … , m-1，
     * 其中，i为探测次数。该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。
     * 假设当前table长度为16，也就是说如果计算出来key的hash值为14，如果table[14]上已经有值，并且其key与当前key不一致，
     * 那么就发生了hash冲突，这个时候将14加1得到15，取table[15]进行判断，
     * 这个时候如果还是冲突会回到0，取table[0],以此类推，直到可以插入。
     *
     */
    private void set(ThreadLocal<?> key, Object value) {

        Entry[] tab = table;
        int len = tab.length;
         //计算索引。
        int i = key.threadLocalHashCode & (len-1);

        // 根据获取到的索引进行循环，如果当前索引上的table[i]不为空，在没有return的情况下，
        // 就使用nextIndex()获取下一个（方法注释上提到到线性探测法）。
        for (Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) {
            ThreadLocal<?> k = e.get();
            //table[i]上key不为空，并且和当前key相同，更新value
            if (k == key) {
                e.value = value;
                return;
            }
            //table[i]上的key为空，说明被回收了（上面的弱引用中提到过）。
            //这个时候说明改table[i]可以重新使用，用新的key-value将其替换,并删除其他无效的entry
            if (k == null) {
                replaceStaleEntry(key, value, i);
                return;
            }
        }
        //找到为空的插入位置，插入值，在为空的位置插入需要对size进行加1操作
        tab[i] = new Entry(key, value);
        int sz = ++size;
        /**
         * cleanSomeSlots用于清除那些e.get()==null，也就是table[index] != null && table[index].get()==null
         * 之前提到过，这种数据key关联的对象已经被回收，所以这个Entry(table[index])可以被置null。
         * 如果没有清除任何entry,并且当前使用量达到了负载因子所定义(长度的2/3)，那么进行rehash()
         */
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

    /**
     * 替换无效entry
     */
    private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                   int staleSlot) {
        Entry[] tab = table;
        int len = tab.length;
        Entry e;

        /**
         * 根据传入的无效entry的位置（staleSlot）,向前扫描
         * 一段连续的entry(这里的连续是指一段相邻的entry并且table[i] != null),
         * 直到找到一个无效entry，或者扫描完也没找到
         */
        int slotToExpunge = staleSlot;//之后用于清理的起点
        for (int i = prevIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = prevIndex(i, len))
            if (e.get() == null)
                slotToExpunge = i;

        // 向后扫描一段连续的entry
        for (int i = nextIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = nextIndex(i, len)) {
            ThreadLocal<?> k = e.get();

            //  如果找到了key，将其与传入的无效entry替换，也就是与table[staleSlot]进行替换
            if (k == key) {
                e.value = value;

                tab[i] = tab[staleSlot];
                tab[staleSlot] = e;

                //如果向前查找没有找到无效entry，则更新slotToExpunge为当前值i
                if (slotToExpunge == staleSlot)
                    slotToExpunge = i;
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                return;
            }

            // 如果向前查找没有找到无效entry，并且当前向后扫描的entry无效，则更新slotToExpunge为当前值i
            if (k == null && slotToExpunge == staleSlot)
                slotToExpunge = i;
        }

        // 如果没有找到key,也就是说key之前不存在table中，就直接最开始的无效entry——tab[staleSlot]上直接新增即可
        tab[staleSlot].value = null;
        tab[staleSlot] = new Entry(key, value);

        // slotToExpunge != staleSlot,说明存在其他的无效entry需要进行清理。
        if (slotToExpunge != staleSlot)
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
    }

    /**
     * 连续段清除
     * 根据传入的staleSlot,清理对应的无效entry——table[staleSlot],
     * 并且根据当前传入的staleSlot,向后扫描一段连续的entry(这里的连续是指一段相邻的entry并且table[i] != null),
     * 对可能存在hash冲突的entry进行rehash，并且清理遇到的无效entry.
     *
     * @param staleSlot key为null,需要无效entry所在的table中的索引
     * @return 返回下一个为空的solt的索引。
     */
    private int expungeStaleEntry(int staleSlot) {
        Entry[] tab = table;
        int len = tab.length;

        // 清理无效entry，置空
        tab[staleSlot].value = null;
        tab[staleSlot] = null;
        //size减1，置空后table的被使用量减1
        size--;

        // Rehash until we encounter null
        Entry e;
        int i;
        // 从staleSlot开始向后扫描一段连续的entry
        for (i = nextIndex(staleSlot, len);
             (e = tab[i]) != null;
             i = nextIndex(i, len)) {
            ThreadLocal<?> k = e.get();
            //如果遇到key为null,表示无效entry，进行清理.
            if (k == null) {
                e.value = null;
                tab[i] = null;
                size--;
            } else {
                //如果key不为null,计算索引
                int h = k.threadLocalHashCode & (len - 1);
                /**
                 * 计算出来的索引——h，与其现在所在位置的索引——i不一致，置空当前的table[i]
                 * 从h开始向后线性探测到第一个空的slot，把当前的entry挪过去。
                 */
                if (h != i) {
                    tab[i] = null;

                    // Unlike Knuth 6.4 Algorithm R, we must scan until
                    // null because multiple entries could have been stale.
                    while (tab[h] != null)
                        h = nextIndex(h, len);
                    tab[h] = e;
                }
            }
        }
        //下一个为空的solt的索引。
        return i;
    }

    /**
     * 启发式的扫描清除，扫描次数由传入的参数n决定
     *
     * @param i 从i向后开始扫描（不包括i，因为索引为i的Slot肯定为null）
     *
     * @param n 控制扫描次数，正常情况下为 log2(n) ，
     * 如果找到了无效entry，会将n重置为table的长度len,进行段清除。
     *
     * map.set()点用的时候传入的是元素个数，replaceStaleEntry()调用的时候传入的是table的长度len
     *
     * @return true if any stale entries have been removed.
     */
    private boolean cleanSomeSlots(int i, int n) {
        boolean removed = false;
        Entry[] tab = table;
        int len = tab.length;
        do {
            i = nextIndex(i, len);
            Entry e = tab[i];
            if (e != null && e.get() == null) {
                n = len;
                removed = true;
                i = expungeStaleEntry(i);
            }
        } while ( (n >>>= 1) != 0);
        return removed;
    }

    /**
     * Re-pack and/or re-size the table. First scan the entire
     * table removing stale entries. If this doesn't sufficiently
     * shrink the size of the table, double the table size.
     */
    private void rehash() {
        //全清理
        expungeStaleEntries();

        // threshold = 2/3 * len，所以threshold - threshold / 4 = 1en/2
        // 这里主要是因为上面做了一次全清理所以size减小，需要进行判断。
        // 判断的时候把阈值调低了。
        if (size >= threshold - threshold / 4)
            resize();
    }

    /**
     * 扩容，扩大为原来的2倍（这样保证了长度为2的冥）
     */
    private void resize() {
        Entry[] oldTab = table;
        int oldLen = oldTab.length;
        int newLen = oldLen * 2;
        Entry[] newTab = new Entry[newLen];
        int count = 0;

        for (int j = 0; j < oldLen; ++j) {
            Entry e = oldTab[j];
            if (e != null) {
                ThreadLocal<?> k = e.get();
                //虽然做过一次清理，但在扩容的时候可能会又存在key==null的情况。
                if (k == null) {
                    e.value = null; // Help the GC
                } else {
                    //同样适用线性探测来设置值。
                    int h = k.threadLocalHashCode & (newLen - 1);
                    while (newTab[h] != null)
                        h = nextIndex(h, newLen);
                    newTab[h] = e;
                    count++;
                }
            }
        }
        //设置新的阈值
        setThreshold(newLen);
        size = count;
        table = newTab;
    }

    /**
     * 全清理，清理所有无效entry
     */
    private void expungeStaleEntries() {
        Entry[] tab = table;
        int len = tab.length;
        for (int j = 0; j < len; j++) {
            Entry e = tab[j];
            if (e != null && e.get() == null)
                //使用连续段清理
                expungeStaleEntry(j);
        }
    }
}

public T get() {
    //同set方法类似获取对应线程中的ThreadLocalMap实例
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //为空返回初始化值
    return setInitialValue();
}
/**
 * 初始化设值的方法，可以被子类覆盖。
 */
protected T initialValue() {
   return null;
}

private T setInitialValue() {
    //获取初始化值，默认为null(如果没有子类进行覆盖)
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    //不为空不用再初始化，直接调用set操作设值
    if (map != null)
        map.set(this, value);
    else
        //第一次初始化，createMap在上面介绍set()的时候有介绍过。
        createMap(t, value);
    return value;
}

private ThreadLocal.ThreadLocalMap.Entry getEntry(ThreadLocal<?> key) {
    //根据key计算索引，获取entry
    int i = key.threadLocalHashCode & (table.length - 1);
    ThreadLocal.ThreadLocalMap.Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

/**
 * 通过直接计算出来的key找不到对于的value的时候适用这个方法.
 */
private ThreadLocal.ThreadLocalMap.Entry getEntryAfterMiss(ThreadLocal<?> key, int i, ThreadLocal.ThreadLocalMap.Entry e) {
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;

    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            //清除无效的entry
            expungeStaleEntry(i);
        else
            //基于线性探测法向后扫描
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

private void remove(ThreadLocal<?> key) {
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;
    //计算索引
    int i = key.threadLocalHashCode & (len-1);
    //进行线性探测，查找正确的key
    for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            //调用weakrefrence的clear()清除引用
            e.clear();
            //连续段清除
            expungeStaleEntry(i);
            return;
        }
    }
}

package com.littlefxc.examples.base.thread;

/**
 * @author fengxuechao
 * @date 2019/2/21
 **/
public class VolatileSample extends Thread {

    private int number;

    static boolean ready = true;

    @Override
    public void run() {
        while (ready) {
            number++;
        }
        System.out.println(ready);
        System.out.println(number);
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new VolatileSample();
        t1.start();
        Thread.sleep(1000);
        ready = false;
    }
}

package com.littlefxc.examples.base.thread.pipe;

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;

/**
 * 管道输入/输出主要用于线程间的数据传输，传输的媒介是内存。具体实现：
 * <br>面向字节:
 * <ul>
 * <li>PipedWriter</li>
 * <li>PipedReader</li>
 * </ul>
 * <br>面向字符:
 * <ul>
 * <li>PipedOutputStream</li>
 * <li>PipedInputStream</li>
 * </ul>
 *
 * @author fengxuechao
 * @date 2019/2/26
 **/
public class Piped {

    public static void main(String[] args) throws IOException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        // 将输出流和输入流进行必要的连接
        writer.connect(reader);
        Thread printThread = new Thread(new Print(reader), "PrintThread");
        printThread.start();
        int receive = 0;
        try {
            while ((receive = System.in.read()) != -1) {
                writer.write(receive);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            writer.close();
        }
    }

    static class Print implements Runnable {

        private PipedReader reader;

        public Print(PipedReader reader) {
            this.reader = reader;
        }

        @Override
        public void run() {
            int receive = 0;
            try {
                while ((receive = reader.read()) != -1) {
                    System.out.print((char) receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.littlefxc.examples.base.thread;

/**
 * @author fengxuechao
 */
public class JoinLongTest {

    public static void main(String[] args) {
        try {
            MyThread threadTest = new MyThread();
            threadTest.start();

            threadTest.join(1000);// 主线成等待子线程1秒
//            Thread.sleep(1000);
            System.out.println("主线程结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static public class MyThread extends Thread {

        @Override
        public void run() {
            try {
                Thread.sleep(2000);
                System.out.println("子线程结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.littlefxc.examples.base.thread.threadlocal;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author fengxuechao
 * @date 2019/2/26
 **/
public class ThreadLocal1 {

    private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            es.execute(new ParseDate(i));
        }
        es.shutdown();
    }

    private static class ParseDate implements Runnable {

        int i = 0;

        public ParseDate(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
ParseDateWithSync
                    Date date = SDF.parse("2019-02-26 16:23:" + i % 60);
                    System.out.println(i + ":" + date);
//                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.littlefxc.examples.base.thread.threadlocal;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author fengxuechao
 * @date 2019/2/26
 **/
public class ParseDateWithThreadLocal {

    static final String pattern = "yyyy-MM-dd HH:mm:ss";
    private static final ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>();

    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            es.execute(new ParseDate(i));
        }
        es.shutdown();
    }

    private static class ParseDate implements Runnable {

        int i = 0;

        public ParseDate(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                // 如果当前线程不持有 SimpleDateFormat 对象。那就新建并保存设置在当前线程中，如果已持有，则直接使用。
                if (threadLocal.get()==null) {
                    threadLocal.set(new SimpleDateFormat(pattern));
                }
                Date date = threadLocal.get().parse("2019-02-26 16:23:" + i % 60);
                System.out.println(i + ":" + date);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.littlefxc.examples.log4j2;

import com.alibaba.druid.pool.DruidDataSource;

import javax.sql.DataSource;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * Log4j2 ConnectionFactory
 *
 * @author fengxuechao
 */
public class ConnectionFactory {

    private final DataSource dataSource;

    private ConnectionFactory() {
        Properties properties = new Properties();
        String lineSeparator = File.separator;
        String fileName = String.join(lineSeparator,
                System.getProperty("user.dir"), "Log4j2-JDBCAppender", "src", "main", "resources", "db.properties");
        try (InputStream stream = new FileInputStream(fileName)) {
            properties.load(stream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.dataSource = new DruidDataSource();
        ((DruidDataSource) this.dataSource).configFromPropety(properties);
    }

    public static Connection getDatabaseConnection() throws SQLException {
        return Singleton.INSTANCE.dataSource.getConnection();
    }

    private static interface Singleton {
        final ConnectionFactory INSTANCE = new ConnectionFactory();
    }
}

package com.littlefxc.examples.log4j2;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author fengxuechao
 * @date 2019/2/11
 **/
public class App {

    private static final Logger log = LoggerFactory.getLogger(App.class);

    public static void main(String[] args) {
        log.debug("This is debug");
        log.info("This is info");
        log.warn("This is warn");
        log.error("This is error");
        log.error("This is error", new RuntimeException("this is a exception"));
    }
}

public class SpelTest {
    ExpressionParser parser;

    // 测试 XML 配置 SpEl
    User user;

    BeanFactory beanFactory;

    // 测试注解配置 SpEl
    FieldValueTestBean fieldValueTestBean;

    MovieRecommender movieRecommender;

    PropertyValueTestBean propertyValueTestBean;

    StandardEvaluationContext context;

    // 发明家列表
    List<Inventor> inventorList = new ArrayList<>();

    // 发明家特斯拉
    Inventor inventorTesla;

    // 发明家爱迪生
    Inventor inventorEdlson;

    // 发明家贝尔
    Inventor inventorBell;

    // 发明家数组
    Inventor[] inventorArrays;

    Society society;


    /**
     * 初始化Spring
     */
    @Before
    public void setUp() {
        beanFactory = new ClassPathXmlApplicationContext("classpath:spring-root.xml");
        {
            // 允许 SpEl 表达式访问 IOC 容器中的 bean
            // SpEL支持使用 "@" 符号来引用Bean, 在引用Bean时需要使用BeanResolver接口实现来查找Bean, Spring提供BeanFactoryResolver实现
            context = new StandardEvaluationContext();
            context.setBeanResolver(new BeanFactoryResolver(beanFactory));
        }

        // SpEl 解析器
        parser = (ExpressionParser) beanFactory.getBean("parser");

        // XML 配置 SpEl
        user = (User) beanFactory.getBean("user");

        // 注解配置 SpEl
        fieldValueTestBean = (FieldValueTestBean) beanFactory.getBean("fieldValueTestBean");
        movieRecommender = (MovieRecommender) beanFactory.getBean("movieRecommender");
        propertyValueTestBean = (PropertyValueTestBean) beanFactory.getBean("propertyValueTestBean");

        {
            // 设置 SpEl 的 根对象
            inventorTesla = new Inventor("尼古拉·特斯拉", "塞尔维亚裔美籍");
            inventorTesla.setPlaceOfBirth(new PlaceOfBirth("利卡-塞尼县", "克罗地亚"));

            inventorEdlson = new Inventor("托马斯·阿尔瓦·爱迪生", "美国");
            inventorEdlson.setPlaceOfBirth(new PlaceOfBirth("米兰", "美国俄亥俄州"));

            inventorBell = new Inventor("亚历山大·格拉汉姆·贝尔", "美国");
            inventorBell.setPlaceOfBirth(new PlaceOfBirth("爱丁堡", "英国苏格兰"));

            inventorList.add(inventorTesla);
            inventorList.add(inventorEdlson);
            inventorList.add(inventorBell);

            // 数组和列表的内容通过使用方括号表示法获得
            Inventor[] inventorArrays = new Inventor[3];
            inventorArrays = inventorList.toArray(inventorArrays);

            society = new Society();
            society.getOfficers().put(Society.President, inventorEdlson);
            society.getOfficers().put(Society.Advisors, inventorList);
        }
    }
}

@Test
public void test1() {
    ExpressionParser parser = new SpelExpressionParser();
    Expression exp = parser.parseExpression("'Hello World'");
    String message = (String) exp.getValue();
    Assert.assertEquals("Hello World", message);
}

@Test
public void test2() {
    ExpressionParser parser = new SpelExpressionParser();
    // 调用方法
    Expression exp = parser.parseExpression("'Hello World'.concat('!')");
    String message = (String) exp.getValue();
    Assert.assertEquals("Hello World!", message);

    // 调用属性
    exp = parser.parseExpression("'Hello World'.bytes");
    byte[] bytesE = "Hello World".getBytes();
    byte[] bytesA = (byte[]) exp.getValue();
    Assert.assertArrayEquals(bytesE, bytesA);

    // SpEL还通过使用标准点表示法（例如prop1.prop2.prop3）和属性值的设置来支持嵌套属性。也可以访问公共字段。
    exp = parser.parseExpression("'Hello World'.bytes.length");
    int lengthE = "Hello World".getBytes().length;
    int lengthA = (int) exp.getValue();
    Assert.assertEquals(lengthE, lengthA);

    // 调用构造方法
    exp = parser.parseExpression("new String('hello world').toUpperCase()");
    String constructorA = exp.getValue(String.class);
    Assert.assertEquals("HELLO WORLD", constructorA);
    }

@Test
public void test3() {
    ExpressionParser parser = new SpelExpressionParser();

    Expression exp = parser.parseExpression("username == 'fxc'");
    Boolean expValue = exp.getValue(user, Boolean.class);
    Assert.assertEquals(true, expValue);
}

package com.littlefxc.examples.spel;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @author fengxuechao
 * @date 2019/1/24
 **/
@Component
public class FieldValueTestBean {

    @Value("#{ systemProperties['user.country'] }")
    private String defaultLocale;

    // 省略 setter getter

}

@Component
public class MovieRecommender {

    private String movieName;
    private String defaultLocale;

    @Autowired
    public MovieRecommender(@Value("#{ systemProperties['user.country'] }") String defaultLocale) {
        this.defaultLocale = defaultLocale;
    }

    // 省略 setter getter
}

package com.littlefxc.examples.spel;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class PropertyValueTestBean {

    private String defaultLocale;

    public String getDefaultLocale() {
        return this.defaultLocale;
    }

    @Value("#{ systemProperties['user.country'] }")
    public void setDefaultLocale(String defaultLocale) {
        this.defaultLocale = defaultLocale;
    }

}

@Test
public void test4() {
    // 允许 SpEl 表达式访问 IOC 容器中的 bean
    // SpEL支持使用 "@" 符号来引用Bean, 在引用Bean时需要使用BeanResolver接口实现来查找Bean, Spring提供BeanFactoryResolver实现
    // ClassPathXmlApplicationContext 实现默认会把"System.getProperties()"注册为"systemProperties"Bean，因此我们使用 "@systemProperties"来引用该Bean
    Properties result1 = parser.parseExpression("@systemProperties").getValue(context, Properties.class);
    System.out.println(result1.getProperty("user.dir", "环境变量中没有该属性"));

    // XML 配置
    User userActual = parser.parseExpression("@user").getValue(context, User.class);
    Assert.assertSame(user, userActual);

    // 注解配置
    Assert.assertSame(movieRecommender, parser.parseExpression("@movieRecommender").getValue(context, MovieRecommender.class));
    Assert.assertSame(propertyValueTestBean, parser.parseExpression("@propertyValueTestBean").getValue(context, PropertyValueTestBean.class));
}

@Test
public void test5() {
    ExpressionParser parser = new SpelExpressionParser();

    // evals to "Hello World"
    String helloWorld = (String) parser.parseExpression("'Hello World'").getValue();
    Assert.assertEquals("Hello World", helloWorld);

    // 浮点型字面量
    double avogadrosNumber = (Double) parser.parseExpression("6.0221415E+23").getValue();
    Assert.assertEquals(Double.valueOf("6.0221415E+23"), avogadrosNumber, Double.MIN_VALUE);

    // evals to 2147483647
    int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();
    Assert.assertEquals(2147483647, maxValue);

    boolean trueValue = (Boolean) parser.parseExpression("true").getValue();
    Assert.assertTrue(trueValue);

    Object nullValue = parser.parseExpression("null").getValue();
    Assert.assertNull(nullValue);
}

/**
     * 集合的表达式
     *
     * @see java.util.Properties
     * @see java.util.Arrays
     * @see java.util.List
     * @see java.util.Map
     * Index 索引
     */
    @Test
    public void test6() {
        // 属性名称的第一个字母不区分大小写
        // 数组和列表的内容通过使用方括号表示法获得
        int year = (Integer) parser.parseExpression("Birthdate.Year = 1856").getValue(context);
        String city = (String) parser.parseExpression("placeOfBirth.City").getValue(context);
        Assert.assertEquals(1856, year);
        Assert.assertEquals("利卡-塞尼县", city);

        // 列表
        context.setRootObject(inventorList);
        String birthCity = parser
                .parseExpression("[0].placeOfBirth.City")
                .getValue(context, String.class);
        Assert.assertEquals("利卡-塞尼县", birthCity);

        // 字典
        context.setRootObject(society);
        // 改变字典的值的某个属性
        parser.parseExpression("Officers['president'].placeOfBirth.City")
                .setValue(context, "随便");
        // 获取字典的值的某个属性
        birthCity = (String) parser
                .parseExpression("officers['president'].placeOfBirth.City")
                .getValue(context);
        Assert.assertEquals("随便", birthCity);
    }

/**
 * 内联列表(Inline Lists)
 */
@Test(expected = UnsupportedOperationException.class)
public void test7_1() {
    // 将返回不可修改的空List
    List list = parser.parseExpression("{}").getValue(List.class);

    // 对于字面量列表也将返回不可修改的List
    List list2 = parser.parseExpression("{1,2,3,4}").getValue(List.class);
    // 不会进行不可修改处理
    list2.set(0, 2);
}

/**
 * 内联列表(Inline Lists)
 */
@Test
public void test7_2() {
    // 对于列表中只要有一个不是字面量表达式，将只返回原始List
    List<List<Integer>> list = parser.parseExpression("{{1+2, 2+4},{3, 4+4}}").getValue(List.class);
    // 操作的不是原始列表
    list.get(0).set(0, 1);
    Integer value = parser.parseExpression("{{1+2, 2+4},{3, 4+4}}[0][0]").getValue(Integer.class);
    Assert.assertEquals(1, list.get(0).get(0).intValue());
    Assert.assertEquals(3, value.intValue());
}

/**
    * 内联字典(Inline Maps)
    */
   @Test
   public void test8() {
       // evaluates to a Java map containing the two entries
       Map inventorInfo = (Map) parser.parseExpression("{name:'Nikola',dob:'10-July-1856'}").getValue(context);
       Assert.assertEquals("Nikola", inventorInfo.get("name"));

       // 字典中的字典
       Map mapOfMaps = (Map) parser
               .parseExpression("{name:{first:'Nikola',last:'Tesla'},dob:{day:10,month:'July',year:1856}}")
               .getValue(context);
       Map tesla = (Map) mapOfMaps.get("name");
       Assert.assertEquals("Tesla", tesla.get("last"));

       // 空字典 {:}
       Map emptyMap = (Map) parser.parseExpression("{:}").getValue(context);
       Assert.assertEquals(0, emptyMap.size());
   }

/**
     * 数组创建(Array Construction):相似的 Java 数组语法
     */
    @Test
    public void test9() {
        int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context);
        Assert.assertArrayEquals(new int[4], numbers1);

        // Array with initializer
        int[] numbers2 = (int[]) parser.parseExpression("new int[]{1,2,3}").getValue(context);
        Assert.assertArrayEquals(new int[]{1, 2, 3}, numbers2);

        // Multi dimensional array
        int[][] numbers3 = (int[][]) parser.parseExpression("new int[4][5]").getValue(context);
        Assert.assertArrayEquals(new int[4][5], numbers3);
    }

/**
    * 方法调用
    */
   @Test
   public void test10() {
       // string literal, evaluates to "bc"
       String bc = parser.parseExpression("'abc'.substring(1, 3)").getValue(String.class);
       Assert.assertEquals("bc", bc);

       society.getMembers().add(inventorTesla);
       context.setRootObject(society);
       // evaluates to true
       boolean isMember = parser.parseExpression("isMember('尼古拉·特斯拉')")
               .getValue(context, Boolean.class);
       Assert.assertTrue(isMember);
   }

/**
     * 运算符：关系运算符
     */
    @Test
    public void test11() {
        // 关系运算符(等于、不等于、小于、小于或等于、大于、大于或等于、instanceof、正则表达式)
        // lt (<) gt (>) le (<=) ge (>=) eq (==) ne (!=) div (/) mod (%) not (!) 可以在XML文档中替换相应的符号
        // evaluates to true
        boolean flag = parser.parseExpression("2 == 2").getValue(Boolean.class);
        Assert.assertTrue(flag);

        // evaluates to false
        flag = parser.parseExpression("2 < -5.0").getValue(Boolean.class);
        Assert.assertFalse(flag);

        // evaluates to true
        flag = parser.parseExpression("'black' < 'block'").getValue(Boolean.class);
        Assert.assertTrue(flag);

        // evaluates to false
        flag = parser.parseExpression(
                "'xyz' instanceof T(Integer)").getValue(Boolean.class);
        Assert.assertFalse(flag);

        // evaluates to true
        flag = parser.parseExpression(
                "'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);
        Assert.assertTrue(flag);

        //evaluates to false
        flag = parser.parseExpression(
                "'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);
        Assert.assertFalse(flag);
    }

/**
     * 运算符：逻辑运算符
     */
    @Test
    public void test12() {
        society.getMembers().add(inventorTesla);
        society.getMembers().add(inventorEdlson);
        context.setRootObject(society);

        // -- AND --

        // evaluates to false
        boolean flagAnd = parser.parseExpression("true and false").getValue(Boolean.class);
        Assert.assertFalse(flagAnd);

        // evaluates to true
        String expression = "isMember('尼古拉·特斯拉') and isMember('托马斯·阿尔瓦·爱迪生')";
        flagAnd = parser.parseExpression(expression).getValue(context, Boolean.class);
        Assert.assertTrue(flagAnd);

        // -- OR --

        // evaluates to true
        boolean flagOr = parser.parseExpression("true or false").getValue(Boolean.class);
        Assert.assertTrue(flagOr);

        // evaluates to true
        expression = "isMember('尼古拉·特斯拉') or isMember('托马斯·阿尔瓦·爱迪生')";
        flagOr = parser.parseExpression(expression).getValue(context, Boolean.class);
        Assert.assertTrue(flagOr);

        // -- NOT --

        // evaluates to false
        boolean flagNot = parser.parseExpression("!true").getValue(Boolean.class);
        Assert.assertFalse(flagNot);

        // -- AND and NOT --
        expression = "isMember('尼古拉·特斯拉') and !isMember('托马斯·阿尔瓦·爱迪生')";
        boolean flagAndNot = parser.parseExpression(expression).getValue(context, Boolean.class);
        Assert.assertFalse(flagAndNot);
    }

/**
  * 运算符：赋值运算符
  */
 @Test
 public void test14() {
    Inventor inventor = new Inventor();

    parser.parseExpression("Name").setValue(context, inventor, "Alexander Graham");

    // alternatively
    String bell = parser.parseExpression(
        "Name = 'Alexander Graham Bell'").getValue(context, inventor, String.class);

    Assert.assertEquals("Alexander Graham Bell", bell);
}

/**
     * 类类型表达式：使用"T(Type)"来表示java.lang.Class实例，"Type"必须是类全限定名，"java.lang"包除外，即该包下的类可以不指定包名；
     * 使用类类型表达式还可以进行访问类静态方法及类静态字段。
     */
    @Test
    public void test15() {
        Inventor einstein = parser.parseExpression(
                "new com.littlefxc.examples.spel.Inventor('爱因斯坦', '德国')")
                .getValue(Inventor.class);
        Assert.assertEquals(new Inventor("爱因斯坦", "德国").getName(), einstein.getName());

        context.setRootObject(society);
        //create new inventor instance within add method of List
        parser.parseExpression("Members.add(new com.littlefxc.examples.spel.Inventor('爱因斯坦', '德国'))").getValue(context);
    }

/**
     * 变量定义及引用
     * <p>
     * 变量定义通过 EvaluationContext 接口的 setVariable(variableName, value) 方法定义；<br>
     * 在表达式中使用 "#variableName" 引用；<br>
     * 除了引用自定义变量，SpEL还允许引用根对象及当前上下文对象，使用 "#root" 引用根对象，使用 "#this" 引用当前上下文对象；<br>
     * </p>
     */
    @Test
    public void test16() {
        Inventor tesla = new Inventor("Nikola Tesla", "Serbian");

        EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
        context.setVariable("newName", "Mike Tesla");

        parser.parseExpression("Name = #newName").getValue(context, tesla);// "Mike Tesla"
//        parser.parseExpression("#root.Name = #newName").getValue(context, tesla);// "Mike Tesla"
        Assert.assertEquals("Mike Tesla", tesla.getName());

        // create an array of integers
        List<Integer> primes = new ArrayList<>();
        primes.addAll(Arrays.asList(2, 3, 5, 7, 11, 13, 17));

        // create parser and set variable 'primes' as the array of integers
        context.setVariable("primes", primes);

        // 通过使用诸如 (using selection ?{...}) 这样的选择表达式，选择列表中所有大于10的数字
        // evaluates to [11, 13, 17]
        List<Integer> primesGreaterThanTen = (List<Integer>) parser
                .parseExpression("#primes.?[#this>10]").getValue(context);

        System.out.println(primesGreaterThanTen);
    }