java：回调

java：回调

1 回调仿写

参考spring-core中的反射工具类ReflectionUtils，其中有个方法是doWithFields，第二个参数是回调接口，部分源码如下：

@FunctionalInterface
public interface FieldCallback {
    void doWith(Field var1) throws IllegalArgumentException, IllegalAccessException;
}

public static void doWithFields(Class<?> clazz, ReflectionUtils.FieldCallback fc, @Nullable ReflectionUtils.FieldFilter ff) {
    Class targetClass = clazz;

    do {
        Field[] fields = getDeclaredFields(targetClass);
        Field[] var5 = fields;
        int var6 = fields.length;

        for(int var7 = 0; var7 < var6; ++var7) {
            Field field = var5[var7];
            if (ff == null || ff.matches(field)) {
                try {
                    fc.doWith(field);
                } catch (IllegalAccessException var10) {
                    throw new IllegalStateException("Not allowed to access field '" + field.getName() + "': " + var10);
                }
            }
        }

        targetClass = targetClass.getSuperclass();
    } while(targetClass != null && targetClass != Object.class);

}

可知，源码的回调接口是一个函数式接口（接口中有且仅有一个实现接口后用于重写的方法），然后doWithFields在遍历完该类的所有Field字段后，继续获取父类targetClass = targetClass.getSuperclass()的Field字段进行递归遍历。参考该源码形式，可仿写回调如下：

新建XiaoXuCallBack.java文件：

package com.xiaoxu.base;

import com.sun.istack.internal.NotNull;

import java.lang.reflect.Field;
import java.util.Arrays;

/**
 * @author xiaoxu
 * @date 2022-02-17
 * Ymybatis:com.xiaoxu.base.XiaoXuCallBack
 */
public class XiaoXuCallBack {
    public String a;
    protected long b;
    private boolean c;
    public static void main(String[] args) {
        Class<? extends XiaoXuCallBack> clazz = XiaoXuCallBack.class;
        UseMyCallBack.doWithMe(clazz, new MyCallBack() {
            @Override
            public void processCallBack(Field f) throws RuntimeException {
                System.out.printf("我是回调操作的字段:%s%n",f);
                System.out.printf("字段名称为:%s%n", f.getName());
            }
        });
    }
}

@FunctionalInterface //可写可不写，接口满足函数式接口的要求时，默认为函数式接口
interface MyCallBack{
    void processCallBack(Field f) throws RuntimeException;
}

class UseMyCallBack{
    //1个.java文件有且仅能存在一个public类，其余的类的权限不写权限修饰符，默认是同个包下才可使用（权限效果类似于protected）
    //java类中方法的权限修饰受限于类的修饰符权限，即方法权限必须<=类的修饰权限，即类权限是protected,方法是public,
    //该方法还是只能算是protected权限，即只能在同包下使用
    public static void doWithMe(@NotNull Class<?> clazz, @NotNull MyCallBack mcb){
        Field[] declaredFields = clazz.getDeclaredFields();
        //使用方法引用，对declaredFields数组的每个Field字段，调用接口回调方法
        Arrays.stream(declaredFields).forEach(mcb::processCallBack);
    }
}

执行结果如下：

我是回调操作的字段:public java.lang.String com.xiaoxu.base.XiaoXuCallBack.a
字段名称为:a
我是回调操作的字段:protected long com.xiaoxu.base.XiaoXuCallBack.b
字段名称为:b
我是回调操作的字段:private boolean com.xiaoxu.base.XiaoXuCallBack.c
字段名称为:c

2 结论

由上述可知，java实现回调，此方式下，为了便于调用该回调方法（UseMyCallBack.doWithMe），会先提供一个函数式接口（接口是java多态的体现），然后定义回调类和回调方法，在方法中添加处理操作（Field[] declaredFields = clazz.getDeclaredFields();），或者其他希望调用该回调方法能够实现的具体逻辑（如遍历每个Field，或者计算数值返回给调用方等等），最后调用方调用该回调方法（UseMyCallBack.doWithMe），不需要传入具体的调用方的类的类型（比如需要在回调方法doWithMe中针对Field数据，调用调用方XiaoXuCallBack 的自定义处理字段Field的方法，不需将调用方XiaoXuCallBack类的this传递给回调方法，回调方法UseMyCallBack.doWithMe也不需要新增一个调用参数如XiaoXuCallBack x，因为这样不便于多个三方调用方调用该回调方法，故而使用接口实现java多态，让每个调用方，自己重写回调方法中，接口参数的方法，形式如匿名内部类或内部类，实现各自的逻辑），故而只需重写回调方法即可实现独有的逻辑。

当然，这里main方法本是一个单线程，为同步回调，因为回调方法需要将调用方需要的东西，计算或别的操作处理后，才返回给调用方处理，同步进行；如果是消息通知类型回调，多个线程进行，消息通知后，无法明确回调方法多久能返回结果，此为异步回调。