2022-06-10 速石面试 记录

interface Subject {
    void request();
}

class RealSubject implements Subject {
    public void request(){
        System.out.println("RealSubject");
    }
}

class Proxy implements Subject {
    private Subject subject;

    public Proxy(Subject subject){
        this.subject = subject;
    }
    public void request(){
        System.out.println("begin");
        subject.request();
        System.out.println("end");
    }
}

public class ProxyTest {
    public static void main(String args[]) {
        RealSubject subject = new RealSubject();
        Proxy p = new Proxy(subject);
        p.request();
    }
}

public interface MyInterface {
    void doSth();    
    void doSthElse(String args);    
}

public class RealObject implements MyInterface {
    @Override
    public void doSth() {
        System.out.println("do something");
    }

    @Override
    public void doSthElse(String args) {
        System.out.println("do sth else "+ args);
    }
}

public class MyInvocatioHandler implements InvocationHandler {

    private Object target; //添加被代理类引用

    public MyInvocatioHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       System.out.println("-----before-----");
       Object result = method.invoke(target, args);
       System.out.println("-----end-----");

       return result;
    }

    public Object getProxy() {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        //类可以实现多个接口，因此这里的接口是个数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //this即MyInvocatioHandler实例，其包含被代理类的引用，以及重写的方法，newProxyInstance方法将利用这些参数创建一个代理类的实例
        return Proxy.newProxyInstance(loader, interfaces, this);
    }

}

public class JDKProxyTest {

    public static void main(String[] args) {
        // 1. 创建被代理实例
        RealObject realObject = new RealObject();
        // 2. 创建自己实现的InvocatioHandler实例
        MyInvocatioHandler handler = new MyInvocatioHandler(realObject);
        // 3. 创建代理实例
        MyInterface myInterface = (MyInterface) handler.getProxy();
        // 4. 通过代理调用方法
        myInterface.doSth();
    }

}

public final class Train {
    public void move(){  
        System.out.println("train running…");  
    }      
}

public class CGLibProxy implements MethodInterceptor {

    private Object proxied;

    public CGLibProxy(Object proxied) {
        this.proxied = proxied;
    }

    public Object getProxy(){
        //cglib 中增强器，用来创建动态代理
        Enhancer enhancer = new Enhancer();
        //设置要创建动态代理的类
        enhancer.setSuperclass(proxied.getClass());
        //设置回调，这里相当于是对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦截  
        enhancer.setCallback(this);
        //创建代理类
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("cglib proxy start...");
        proxy.invokeSuper(obj, args);
        System.out.println("cglib proxy end...");
        return null;
    }

}

public static void main(String[] args) {
    CGLibProxy proxy = new CGLibProxy(new Train());
    Train t = (Train)proxy.getProxy();
    t.move();
}

export function scheduleUpdateOnFiber(
  fiber: Fiber,
  expirationTime: ExpirationTime,
) {
  const priorityLevel = getCurrentPriorityLevel();

  if (expirationTime === Sync) {
    if (
      // Check if we're inside unbatchedUpdates
      (executionContext & LegacyUnbatchedContext) !== NoContext &&
      // Check if we're not already rendering
      (executionContext & (RenderContext | CommitContext)) === NoContext
    ) {
      performSyncWorkOnRoot(root);
    } else {
      ensureRootIsScheduled(root);
      schedulePendingInteractions(root, expirationTime);
      if (executionContext === NoContext) {
        // Flush the synchronous work now, unless we're already working or inside
        // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
        // scheduleCallbackForFiber to preserve the ability to schedule a callback
        // without immediately flushing it. We only do this for user-initiated
        // updates, to preserve historical behavior of legacy mode.
        flushSyncCallbackQueue();
      }
    }
  } else {
    // Schedule a discrete update but only if it's not Sync.
    if (
      (executionContext & DiscreteEventContext) !== NoContext &&
      // Only updates at user-blocking priority or greater are considered
      // discrete, even inside a discrete event.
      (priorityLevel === UserBlockingPriority ||
        priorityLevel === ImmediatePriority)
    ) {
      // This is the result of a discrete event. Track the lowest priority
      // discrete update per root so we can flush them early, if needed.
      if (rootsWithPendingDiscreteUpdates === null) {
        rootsWithPendingDiscreteUpdates = new Map([[root, expirationTime]]);
      } else {
        const lastDiscreteTime = rootsWithPendingDiscreteUpdates.get(root);
        if (
          lastDiscreteTime === undefined ||
          lastDiscreteTime > expirationTime
        ) {
          rootsWithPendingDiscreteUpdates.set(root, expirationTime);
        }
      }
    }
    // Schedule other updates after in case the callback is sync.
    ensureRootIsScheduled(root);
    schedulePendingInteractions(root, expirationTime);
  }
}

RUN apt-get update && apt-get install -y \
  bzr \
  cvs \
  git \
  mercurial \
  subversion \
  && rm -rf /var/lib/apt/lists/*