接口的动态实现（注释）

主函数

public class InterTest {
    public static void main(String[] args) {
        ThreadMethod method = Util.getInstance(ThreadMethod.class, new Instance());
        method.runHttp();
        method.saveData("aaa");
        method.draw();
    }
}

自定义注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SubThread {
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CurrentThread {
}

定义接口

public interface ThreadMethod {
    void runHttp();
    void saveData(String data);
    void draw();
}

定义Instance类来实现接口

public class Instance implements ThreadMethod {
    @Override
    @SubThread
    public void runHttp() {
        System.out.println("Instance.runHttp");
        System.out.println(Thread.currentThread());
    }

    @Override
    @SubThread
    public void saveData(String data) {
        System.out.println("Instance.saveData");
        System.out.println("data = [" + data + "]");
        System.out.println(Thread.currentThread());
    }

    @Override
    @CurrentThread
    public void draw() {
        System.out.println("Instance.draw");
        System.out.println(Thread.currentThread());
    }
}

建立一个Util类

public class Util {
    public static<T> T getInstance(Class<T> cl, Object instance) {
        Object o = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
            new Class[]{cl},
            new MyHandler(instance)
        );
        return (T) o;
    }
    private static class MyHandler implements InvocationHandler {
        private Object instance;

        public MyHandler(Object instance) {
            this.instance = instance;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Method method1 = instance.getClass().getMethod(method.getName(), method.getParameterTypes());
            CurrentThread current = method1.getAnnotation(CurrentThread.class);
            if (current != null) {
                method1.invoke(instance, args);
            }
            SubThread sub = method1.getAnnotation(SubThread.class);
            if (sub != null) {
                new Thread(() -> {
                    try {
                        method1.invoke(instance, args);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                }).start();
            }
            return null;
        }
    }
}