精华内容
下载资源
问答
  • java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的; ? IBM 的开发者网络 ...

    Homepage URL

    http://flysky-1.at.vwdhosting.net

    FTP server name:

    ftp://flysky-1@ftp6.vwdhosting.net Login:

    flysky-1

    Password:

    k%x5WY(0zp

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    Default Website Address: http://www40.brinkster.com/flyskys Website IP: 65.182.102.102

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    申请域名::::::....

    您的域名已注册成功:http://beginsky.0033.cn

    您的转向地址是:http://songfei.vhosting.cn

    222.186.200.129 IP地址ftp://222.186.200.129/

    FTP地址ftp39.websamba.com(国外的)

    用户名cnbbs1

    222.186.200.129 IP地址ftp://222.186.200.129/

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    http://cnbbs.tengyi.cn/

    http://flysky.zk.cn/

    http://flyskys.free.cnwsky.com/

    http://skyfly.vhosting.cn/

    http://cnbbs.s43.eatj.com/http://www39.websamba.com/cnbbs1

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    222.186.200.129 IP地址ftp://222.186.200.129/

    struts的项目

    ? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志就是他们出版的,你可以在上面提出问题,马上就有人回答你,如果你觉得好,你可以给那人加分;

    ? Java 研究组织 http://www.javaresearch.org/ 上面有很多原创文章,高手还是挺多的;

    ? Java 开发者 http://www.chinajavaworld.com/ 那里 Java 资料比较全;

    ? java.com.cn http://www.java.com.cn/ 看这域名就知道有多牛,注册用户快接近一万了,同时在线人数也在一千左右,人气很旺的;

    ? IBM 的开发者网络 http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM 永远的蓝色巨人;

    展开全文
  • 在Android开发中经常用到回调机制,其中最典型的就是控件被触发的实现方式,简单而言,如Button被Click后,是系统调用了OnClick方法,而...下面举一个简单的例子介绍回调的实现方式:回调函数使用的简单例子程序员A...

    在Android开发中经常用到回调机制,其中最典型的就是控件被触发的实现方式,简单而言,如Button被Click后,是系统调用了OnClick方法,而我们为Button注册了OnClickListener监听器,当被触发Click后,OnClickListener中的OnClick方法就会被回调,我们就能在其中执行相应操作了。

    下面举一个简单的例子介绍回调的实现方式:

    回调函数使用的简单例子

    程序员A写了一段程序(程序a),其中预留有回调函数接口,并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法,于是,他通过a中的接口回调自己b中的方法。目的达到。

    在JAVA中通过接口(interface)来实现定义回调函数。

    下面是程序员A的程序a

    public class A {

    public CallBack mCallBack;

    public void setCallfuc(MyCallInterface mc){

    this.mc= mc;

    }

    public void call(){

    this.mCallBack.method();

    }

    }

    定义一个接口,以便程序员B根据我的定义编写程序实现接口。

    public interface CallBack {

    public void method();

    }

    于是,程序员B只需要实现这个接口就能达到回调的目的了:

    public class B implements MyCallInterface {

    //实现这个接口

    @override

    public void method() {

    System.out.println("当程序a调用了method方法时我就会答应出来");

    }

    }

    测试方法

    //测试方法

    public static void main(String args[]) {

    A a = new A();

    //相当于把A和B通过CallBack接口建立了联系

    a.setListener(new B());

    //调用了该方法,B中的接口方法打印

    a.call();

    }

    *****************************************************************************************************************************************************************************************

    回调函数经典示例

    使用java回调函数来实现一个测试函数运行时间的工具类:

    public class TestObject {

    /**

    * 一个用来被测试的方法,进行了一个比较耗时的循环

    */

    public static void testMethod(){

    for ( int i= 0 ; i< 100000000 ; i++){

    }

    }

    /**

    * 一个简单的测试方法执行时间的方法

    */

    public void testTime(){

    long begin = System.currentTimeMillis(); //测试起始时间

    testMethod(); //测试方法

    long end = System.currentTimeMillis(); //测试结束时间

    System.out.println("[use time]:" + (end - begin)); //打印使用时间

    }

    public static void main(String[] args) {

    TestObject test=new TestObject();

    test.testTime();

    }

    }

    大家看到了testTime()方法,就只有"//测试方法"是需要改变的,下面我们来做一个函数实现相同功能但更灵活:

    首先定一个回调接口:

    public interface CallBack {

    //执行回调操作的方法

    void execute();

    } 定义工具类

    public class Tools {

    /**

    * 测试函数使用时间,通过定义CallBack接口的execute方法

    * @param callBack

    */

    public void testTime(CallBack callBack) {

    long begin = System.currentTimeMillis(); //测试起始时间

    callBack.execute(); ///进行回调操作

    long end = System.currentTimeMillis(); //测试结束时间

    System.out.println("[use time]:" + (end - begin)); //打印使用时间

    }

    测试方法

    public static void main(String[] args) {

    Tools tool = new Tools();

    tool.testTime(new CallBack(){

    //定义execute方法

    public void execute(){

    //这里可以加放一个或多个要测试运行时间的方法

    TestObject.testMethod();

    }

    });

    }

    原文:http://blog.csdn.net/zpf8861/article/details/37690187

    展开全文
  • 文章目录前言什么是回调函数第0个版本第1个版本第2个版本第3个版本第4个版本第5个版本第6个版本回头解析前言描述的问题1. MethodIntrospector.selectMethods()2. 抽象类MethodIntrospector3. 方法selectMethods()4. ...

    前言

    在看Handler时看到了这么语段代码顿时就蒙了

    Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
    	(MethodIntrospector.MetadataLookup<T>) method -> {
    		try {
    			return getMappingForMethod(method, userType);
    		}
    		catch (Throwable ex) {
    			throw new IllegalStateException("Invalid mapping on handler class [" +
    					userType.getName() + "]: " + method, ex);
    		}
        });
    

    经过指点知道这是回调函数,马上来补充一下~

    什么是回调函数

    回调函数,是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。
    在Java中,指针即所谓的引用。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应。
    第一次看这知识点,是真的懵。下面看我拆解后逐步理解它的思路。

    第0个版本

    初代版本
    我调用了你,在我调用你的方法里你又调用了我(回调)

    public class ClassA {
        public void a() {
            System.out.println("执行了a方法");
            ClassB b = new ClassB();
            b.b();
        }
        public void backs(){
            System.out.println("A:我就是A的回调函数!");
        }
    }
    
    public class ClassB {
        public void b() {
            System.out.println("我执行了b");
            System.out.println("B:我开始调用A的回调-->");
            ClassA a = new ClassA();
            a.backs();
            System.out.println("B: <--我完成调用A的回调");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            ClassA a = new ClassA();
            a.a();
        }
    }
    

    执行结果

    执行了a方法
    我执行了b
    B:我开始调用A的回调-->
    A:我就是A的回调函数!
    B: <--我完成调用A的回调
    

    第1个版本

    演变一下把在B里创建的A,用对象的形式在A里调用时就带过去。
    写一个回调用的接口

    public class ClassA {
        public void a() {
            System.out.println("执行了a方法");
            ClassB b = new ClassB();
            b.b(this);
        }
        public void backs(){
            System.out.println("A:我就是A的回调函数!");
        }
    }
    
    
    public class ClassB {
        public void b(ClassA a) {
            System.out.println("我执行了b");
            System.out.println("B:我开始调用A的回调-->");
            a.backs();
            System.out.println("B: <--我完成调用A的回调");
        }
    }
    

    Main方法不用变
    执行结果,执行结果不变

    执行了a方法
    我执行了b
    B:我开始调用A的回调-->
    A:我就是A的回调函数!
    B: <--我完成调用A的回调
    

    第2个版本

    把第1个版本中的这个类换成接口Interface
    创建一个接口

    public interface Interface {
        public void backs();
    }
    
    public class ClassA {
        public void a() {
            System.out.println("执行了a方法");
            ClassB b = new ClassB();
            b.b(new Interface() {
                @Override
                public void backs() {
                    System.out.println("A:我就是A的回调函数!");
                }
            });
        }
    }
    
    public class ClassB {
        public void b(Interface in) {
            System.out.println("我执行了b");
            System.out.println("B:我开始调用A的回调-->");
            in.backs();
            System.out.println("B: <--我完成调用A的回调");
        }
    }
    

    Main依然不变
    执行结果也不变

    执行了a方法
    我执行了b
    B:我开始调用A的回调-->
    A:我就是A的回调函数!
    B: <--我完成调用A的回调
    

    第3个版本

    给接口加一个入参,让回调方法可以传参

    public interface Interface {
        public void backs(String n);
    }
    
    public class ClassA {
        public void a() {
            System.out.println("执行了a方法");
            ClassB b = new ClassB();
            b.b(new Interface() {
                @Override
                public void backs(String n) {
                    System.out.println("A:我就是A的回调函数!我打印:" + n);
                }
            });
        }
    }
    
    public class ClassB {
        public void b(Interface in) {
            System.out.println("我执行了b");
            System.out.println("B:我开始调用A的回调-->");
            in.backs("《我是B传的参数》");
            System.out.println("B: <--我完成调用A的回调");
        }
    }
    

    执行结果

    执行了a方法
    我执行了b
    B:我开始调用A的回调-->
    A:我就是A的回调函数!我打印:《我是B传的参数》
    B: <--我完成调用A的回调
    

    第4个版本

    给接口加个返回的参数

    public interface Interface {
        public String backs(String n);
    }
    
    public class ClassA {
        public void a() {
            System.out.println("执行了a方法");
            ClassB b = new ClassB();
            b.b(new Interface() {
                @Override
                public String backs(String n) {
                    System.out.println("A:我就是A的回调函数!我打印:" + n);
                    return "A:我就是A的回调函数!我打印:" + n + "的返回。";
                }
            });
        }
    }
    
    public class ClassB {
        public void b(Interface in) {
            System.out.println("我执行了b");
            System.out.println("B:我开始调用A的回调-->");
            String backs = in.backs("《我是B传的参数》");
            System.out.println("B:我收到了回调的结果:"+backs);
            System.out.println("B: <--我完成调用A的回调");
        }
    }
    

    执行结果

    执行了a方法
    我执行了b
    B:我开始调用A的回调-->
    A:我就是A的回调函数!我打印:《我是B传的参数》
    B:我收到了回调的结果:A:我就是A的回调函数!我打印:《我是B传的参数》的返回。
    B: <--我完成调用A的回调
    

    第5个版本

    public interface Interface {
        public String backs(String n);
    }
    
    public class ClassA {
        public void a() {
            System.out.println("执行了a方法");
            ClassB b = new ClassB();
            String b1 = b.b(new Interface() {
                @Override
                public String backs(String n) {
                    System.out.println("A:我就是A的回调函数!我打印:" + n);
                    return "A:我就是A的回调函数!我打印:" + n + "的返回。";
                }
            });
            System.out.println("A:执行完得到的结果:" + b1);
        }
    }
    
    public class ClassB {
        public String b(Interface in) {
            System.out.println("我执行了b");
            System.out.println("B:我开始调用A的回调-->");
            String backs = in.backs("《我是B传的参数》");
            System.out.println("B:我收到了回调的结果:"+backs + "<--我完成调用A的回调");
            return "《我是B的返回》";
        }
    }
    

    执行结果:

    执行了a方法
    我执行了b
    B:我开始调用A的回调-->
    A:我就是A的回调函数!我打印:《我是B传的参数》
    B:我收到了回调的结果:A:我就是A的回调函数!我打印:《我是B传的参数》的返回。<--我完成调用A的回调
    A:执行完得到的结果:《我是B的返回》
    

    第6个版本

    先声明回调函数,再使用

    public class ClassA {
        public void a() {
            System.out.println("执行了a方法");
            Interface in = (n -> {
                System.out.println("A:我是直接使用回调接口,我接收的参数是:" + n);
                return "我是回调的返回数据";
            });
    
            String backs = in.backs("我A,我是《in》的使用者");
            System.out.println("backes:" + backs);
        }
    }
    

    调用

    public class Main {
        public static void main(String[] args) {
            ClassA a = new ClassA();
            a.a();
        }
    }
    

    执行结果

    执行了a方法
    A:我是直接使用回调接口,我接收的参数是:我A,我是《in》的使用者
    backes:我是回调的返回数据
    

    回头解析前言描述的问题

    1. MethodIntrospector.selectMethods()

    Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
        // 接口需要MetadataLookup类型,做一个类型转换。
        // T:Set<Scheduled>,这个参数是被调用类传过来的。
        // 看调用代码,点方法selectMethods进去
        // 里面这句代码为回调 metadataLookup.inspect(specificMethod);
        // 
    	(MethodIntrospector.MetadataLookup<Set<Scheduled>>) method -> {
            // 使用方法和类型级别的RequestMapping注解来创建RequestMappingInfo。
    		Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(
    			method, Scheduled.class, Schedules.class);
    		return (!scheduledMethods.isEmpty() ? scheduledMethods : null);
    	});
    

    2. 抽象类MethodIntrospector

    在这之前先看下这个回调的接口,这是MethodIntrospector类里的内部类

    public abstract class MethodIntrospector {
        public interface MetadataLookup<T> {
            T inspect(Method method);
        }
    }
    

    3. 方法selectMethods()

    public static <T> Map<Method, T> selectMethods(Class<?> targetType, final MetadataLookup<T> metadataLookup) {
        final Map<Method, T> methodMap = new LinkedHashMap<>();
        Set<Class<?>> handlerTypes = new LinkedHashSet<>();
        Class<?> specificHandlerType = null;
    
        // 是否是代理类
        if (!Proxy.isProxyClass(targetType)) {
            // 通过这个类取到这个类,检测是否是CGLIB 生成的子类,是则返回原始类。
            specificHandlerType = ClassUtils.getUserClass(targetType);
            // 添加到set哈希表中
            handlerTypes.add(specificHandlerType);
        }
        // 把这个类的所有接口类添加到set哈希表中
        handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
    
        for (Class<?> currentHandlerType : handlerTypes) {
            // 这个不知道为啥,不使用循环里的类。也就是不使用接口,要使用实际的实现类,是这个意思?
            final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);
    
            // 霍,刚那个回调函数还没完成,又来一个。
            // 3个参数,1-接口或实现类 2-被调函数传过来的 
            // 3-预构建的 MethodFilter 匹配所有未在java.lang.Object声明的非桥非合成方法。
            ReflectionUtils.doWithMethods(currentHandlerType, method -> {
                // 从这个类中找到这个方法
                Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
                // 再向上回调到调用此方法的类中执行对应的方法,带着这个类。返回的是RequestMappingInfo的对象 /admin/test
                T result = metadataLookup.inspect(specificMethod);
                if (result != null) {
                    // 找到提供的bridge Method的原始方法。
                    Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
                    if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) {
                        methodMap.put(specificMethod, result);
                    }
                }
            }, ReflectionUtils.USER_DECLARED_METHODS);
        }
    
        // <Method,RequestMappingInfo>的Map
        return methodMap;
    	}
    

    4. 成员变量USER_DECLARED_METHODS

    // 这里又是一个回调函数的使用,在ReflectionUtils里的成员变量
    public static final MethodFilter USER_DECLARED_METHODS =
        (method -> !method.isBridge() && !method.isSynthetic());
    
    // 看下回调接口,这也是个内部类
    public abstract class ReflectionUtils {
        public interface MethodFilter {
            boolean matches(Method method);
        }
    }
    // 理解:这个就是上面没写调用直接使用里面的回调了生成了一个里面只有一个接口的对象,接口里面已经有实现
    // 调用这个就是相当于调用了这个方法。
    

    5. 方法doWithMethods()

    接selectMethods调用doWithMethods。对给定类和超类(或给定接口和超接口)的所有匹配方法执行给定的回调操作。

    public static void doWithMethods(Class<?> clazz, MethodCallback mc, @Nullable MethodFilter mf) {
        // Keep backing up the inheritance hierarchy.
        // 缓存下,并该类中的所有方法
        Method[] methods = getDeclaredMethods(clazz, false);
        for (Method method : methods) {
            // 使用回调函数得到的接口对象。判断是否不是桥且不是可执行文件是合成结构  不是跳过
            if (mf != null && !mf.matches(method)) {
                // 是桥或是可执行文件跳过
                continue;
            }
            try {
                // 这个就是调用doWithMethods的回调在调用它的类里执行,传过去的是这个类中的方法
                mc.doWith(method);
            }
            catch (IllegalAccessException ex) {
                throw new IllegalStateException("Not allowed to access method '" + method.getName() + "': " + ex);
            }
        }
        if (clazz.getSuperclass() != null && (mf != USER_DECLARED_METHODS || clazz.getSuperclass() != Object.class)) {
            doWithMethods(clazz.getSuperclass(), mc, mf);
        }
        else if (clazz.isInterface()) {
            for (Class<?> superIfc : clazz.getInterfaces()) {
                doWithMethods(superIfc, mc, mf);
            }
        }
    }
    

    6. doWithMethods()方法里调用的getMappingForMethod()方法

    protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
        // 根据提供的annotatedElement是类还是方法提供适当的自定义RequestCondition 。
        // 接收的是一个 AnnotatedElement 类型,
        // Method 继承 Executable,Executable 实现 GenericDeclaration
        // GenericDeclaration 继承 AnnotatedElement,可以看下
        // 创建方法上的 RequestMappingInfo
        RequestMappingInfo info = createRequestMappingInfo(method);
        if (info != null) {
            // 创建方法的类上的 RequestMappingInfo
            RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
            if (typeInfo != null) {
                // 把两个 RequestMappingInfo 组合在一起
                info = typeInfo.combine(info);
            }
            String prefix = getPathPrefix(handlerType);
            if (prefix != null) {
                info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
            }
        }
        return info;
    }
    

    看下效果更深刻
    在这里插入图片描述

    组合
    在这里插入图片描述

    组合完后的RequestMappingInfo
    在这里插入图片描述

    7. getMappingForMethod()方法里调用的createRequestMappingInfo()

    private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
        // 找到这个方法第一个@RequestMapping
        RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
        // 两个方法都是返回的null,看上去能被覆盖。不过这个启动没有直接返回的null,所以condition是null
        RequestCondition<?> condition = (element instanceof Class ?
                                         getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
        // 生成RequestMappingInfo对象
        return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
    }
    

    好奇,find什么样
    在这里插入图片描述

    实际我这个方法我怎么标记的?
    在这里插入图片描述

    调用创建RequestMappingInfo的构造

    protected RequestMappingInfo createRequestMappingInfo(
        RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {
        RequestMappingInfo.Builder builder = RequestMappingInfo
            .paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
            .methods(requestMapping.method())
            .params(requestMapping.params())
            .headers(requestMapping.headers())
            .consumes(requestMapping.consumes())
            .produces(requestMapping.produces())
            .mappingName(requestMapping.name());
        if (customCondition != null) {
            builder.customCondition(customCondition);
        }
        return builder.options(this.config).build();
    }
    

    创建完长这样
    在这里插入图片描述

    结言
    所以最后的结果就是把这个类下所有方法标RequestMapping注解的方法以<Method,RequestMappingInfo>放入Map

    全文完~

    文文的博客,博学躬行。欢迎指正~

    展开全文
  • 下面使用java回调函数来实现一个测试函数运行时间的工具类:如果我们要测试一个类的方法的执行时间,通常我们会这样做:public class TestObject {/*** 一个用来被测试的方法,进行了一个比较耗时的循环*/public ...

    下面使用java回调函数来实现一个测试函数运行时间的工具类:

    如果我们要测试一个类的方法的执行时间,通常我们会这样做:

    public class TestObject {

    /**

    * 一个用来被测试的方法,进行了一个比较耗时的循环

    */

    public static void testMethod(){

    for ( int i= 0 ; i< 100000000 ; i++){

    }

    }

    /**

    * 一个简单的测试方法执行时间的方法

    */

    public void testTime(){

    long begin = System.currentTimeMillis(); //测试起始时间

    testMethod(); //测试方法

    long end = System.currentTimeMillis(); //测试结束时间

    System.out.println("[use time]:" + (end - begin)); //打印使用时间

    }

    public static void main(String[] args) {

    TestObject test=new TestObject();

    test.testTime();

    }

    }

    大家看到了testTime()方法,就只有"//测试方法"是需要改变的,下面我们来做一个函数实现相同功能但更灵活:

    首先定一个回调接口:

    public interface CallBack {

    //执行回调操作的方法

    void execute();

    }

    然后再写一个工具类:

    public class Tools {

    /**

    * 测试函数使用时间,通过定义CallBack接口的execute方法

    * @param callBack

    */

    public void testTime(CallBack callBack) {

    long begin = System.currentTimeMillis(); //测试起始时间

    callBack.execute(); ///进行回调操作

    long end = System.currentTimeMillis(); //测试结束时间

    System.out.println("[use time]:" + (end - begin)); //打印使用时间

    }

    public static void main(String[] args) {

    Tools tool = new Tools();

    tool.testTime(new CallBack(){

    //定义execute方法

    public void execute(){

    //这里可以加放一个或多个要测试运行时间的方法

    TestObject.testMethod();

    }

    });

    }

    }

    大家看到,testTime()传入定义callback接口的execute()方法就可以实现回调功能

    展开全文
  • 回调函数定义:传递一个函数A到另一个函数B中,并且这个函数B执行函数A。我们就说函数A叫做回调函数。...java回调函数的实现:java不支持指针,但是可以通过定义接口的方式实现回调。定义一个只有回调...
  • java回调函数在网上了看了些例子,比较绕,不够清晰,自己写的一个例子比较通俗,java回调其实很简单。举个例子我是类B,我有个方法叫b(),现在我要调用类A中的方法a(),写个代码就是:public class ClassB{ //我是...
  • 一、回调函数定义:首先说说什么叫回调函数?在WINDOWS中,程序员想让系统DLL调用自己编写的一个方法,...这样的解释似乎还是比较难懂,这里举个简 单的例子:程序员A写了一段程序(程序a),其中预留有回调函数接口,...
  • 继续探究Java回调函数

    2021-02-28 14:39:01
    回调函数是一个相当难以理解和...在C或者C++中回调函数的定义:程序在调用一个函数时,将自己的函数的地址作为参数传递给程序调用的函数时(那么这个自己的函数称回调函数)Java中没有指针,不能传递方法的地址,一般...
  • 回调的使用场景就是在参数还未知的时候对其进行处理,参数在其他地方定义。...回调函数的demo案例如下:package com.jufanshare.demo;public class CallbackDemo {public static void main(String[] args...
  • 再谈java回调函数

    2021-02-28 15:49:29
    又遇到了回调函数,这次打算写下来分享一下。所谓回调函数,或者在面向对象语言里叫回调方法,简单点讲,就是回头在某个时间(事件发生)被调用的函数。再详细点:就是一个函数A,作为参数,传入了另一个函数B,然后被B...
  • 举个例子所谓的回调,就是程序员A写了一段程序(程序a),其中预留有回调函数接口,并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法,于是,他通过a中的接口回调自己b中的方法。举个例子:1. 首先定义一个...
  • 详解Java回调机制 (Callback) 讲解+实例Java中的回调(callback)是很重要的一个概念,spring整合hibernate大量使用了这种技术。究竟怎样才是回调呢?这是网上最多见到的说明:1.class A,class B2.class A实现接口...
  • Java实现的回调函数

    千次阅读 2021-02-12 21:25:16
    一个回调函数例子,首先是我为了完成在工厂工作的任务,但是我不能一直在工厂工作,我必须知道工作完以后,就要下班回家。所以做了一个回调函数,通知我,今天工作做完了,可以下班回家啦。具体可以看代码的实现...
  • java回调函数-异步回调-简明讲解叙言:异步回调常用于某些业务需要很长时间处理,但是又需要立刻返回结果,这种情况都需要开辟线程独立处理需要长时间多的业务,也无处理完了,回调回调函数,再去处理与之有关的需要...
  • 背景:想写一个工具类 Tool.java ,其中方法 public void readOneLine() 负责一行一行地读文件,然后根据不同的业务,对每一行进行不同处理。最后输出到文件 out.txt那么问题来了,根据不同的业务,进行不同处理 ...
  • 回调函数是一个程序员不能显式调用的函数;通过将回调函数的地址传给调用者从而实现调用。回调函数使用是必要的,在我们想通过一个统一接口实现不同的内容,这时用回掉函数非常合适。比如,我们为几个不同的设备分别...
  • 怎么说好呢,只可意会不可言传呐,非也,回调在实际开发中使用频率其实是很高的,恰好我小时候也被回调函数欺负过,竟然问了,那么肯定要好好分享一下我的一些经验.网传回调的理解所谓的回调函数就是:在A类中定义了一个...
  • java中的回调函数

    2021-02-24 20:39:57
    CALLBACK,即回调函数,是一个通过函数指针调用的函数。...在java中也是存在回掉函数的,我们可以把回调函数理解为一个被作为参数传递的函数。 就英语单词的角度上,我们把CALLBACK这个单词拆开,即CALL和BACK,
  • c++与java中的回调函数

    2021-03-06 05:55:48
    标签:首先,说明一下,因为java中没有指针的概念,所以java与c++中回调函数虽然原理差不多,但是实现方法不同。说实话,如果c++是简单暴力直接的话,java更像一个小姑娘扭扭捏捏,本人也是过了很多次才了解到这个...
  • java回调函数

    2021-02-27 19:59:48
    在WINDOWS中,程序员想让系统DLL调用自己编写的一个方法,于是利用DLL当中回调函数(CALLBACK)的接口来编写程序,使它调用,这个就称为回调。在Java里面,我们使用接口来实现回调。所谓的回调,就是程序员A写了一段...
  • 本文研究的主要是Java回调函数与观察者模式的实现,具体介绍和实现代码如下。观察者模式(有时又被称为发布(publish )-订阅(Subscribe)模式、模型-视图(View)模式、源-收听者(Listener)模式或从属者模式)是软件设计...
  • 1、java的接口定义以及向上转型...感谢csdn两篇文章让我彻底理解回调函数:其实我很愿意理解网上那个关于打电话需求帮助的回调函数例子在此我也写了一个与此类似的例子:1、首先定义一个接口(即回调接口)(帮助接口,...
  • 回调函数回调函数一般是在封装接口的时候,回调显得特别重要,我们首先假设有两个程序员在写代码,A程序员写底层驱动接口,B程序员写上层应用程序,然而此时底层驱动接口A有一个数据d需要传输给B,此时有两种方式:1...
  • 回调函数,顾名思义,用于回调的函数。回调函数只是一个功能片段,由用户按照回调函数调用约定来实现的一个函数。回调函数是一个工作流的一部分,由工作流来决定函数的调用(回调)时机。回调原本应该是一个非常简单的...
  • C++ 中回调函数详解及简单实例回调函数调用关系图对于第一种情况,主程序可以从执行到回调函数,也可以不执行回调函数,关键看宿主函数是否调用了回调函数。对于第二种情况,主程序可以从执行到回调函数,也可以不...
  • 回调函数例子包括窗口进程以及我们在打印过程中设置的回调(为后台打印程序提供回调函数的地址,使其能更新状态,并在必要的时候中止打印)。另一个例子是API函数EnumWindows(),它能枚举目前系统内所有顶级窗口。...
  • 钩子函数和回调函数

    2021-03-13 12:53:39
    一般认为,钩子函数就是回调函数的一种,其实还是有差异的,差异地方就是:触发的时机不同。先说钩子函数:钩子(Hook)概念源于Windows的消息处理机制,通过设置钩子,应用程序对所有消息事件进行拦截,然后执行钩子...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,541
精华内容 55,416
关键字:

java回调函数例子

java 订阅