精华内容
下载资源
问答
  • Python callable() 函数描述callable() 函数用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。对于函数、方法、lambda 函式、 类以及...

    Python callable() 函数

    描述

    callable() 函数用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。

    对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。

    语法

    callable()方法语法:callable(object)

    参数object -- 对象

    返回值

    可调用返回 True,否则返回 False。

    实例

    以下实例展示了 callable() 的使用方法:>>>callable(0)

    False

    >>> callable("test")

    False

    >>> def add(a, b):

    ...     return a + b

    ...

    >>> callable(add)             # 函数返回 True

    True

    >>> class A:                  # 类

    ...     def method(self):

    ...             return 0

    ...

    >>> callable(A)               # 类返回 True

    True

    >>> a = A()

    >>> callable(a)               # 没有实现 __call__, 返回 False

    False

    >>> class B:

    ...     def __call__(self):

    ...             return 0

    ...

    >>> callable(B)

    True

    >>> b = B()

    >>> callable(b)               # 实现 __call__, 返回 True

    True

    展开全文
  • python内置函数 callable用于检查一个对象是否是可调用的,如果函数返回True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。一.callable函数简介语法如下:callable(object...

    本篇文章小编给大家分享一下Python callable内置函数原理解析,小编觉得挺不错的,现在分享给大家供大家参考,有需要的小伙伴们可以来看看。

    python内置函数 callable用于检查一个对象是否是可调用的,如果函数返回True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。

    一.callable函数简介

    语法如下:

    callable(object)

    参数介绍:

    object : 调用的对象;

    返回值:返回bool值,如果object对象可以被调用返回true,不能被调用返回false;

    值得注意的是:即便函数返回true,object也有可能调用失败,返回false意味着觉得不会成功!

    对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

    二.callable函数使用

    # !usr/bin/env python

    # -*- coding:utf-8 _*-

    """

    @Author:何以解忧

    @Blog(个人博客地址): shuopython.com

    @WeChat Official Account(微信公众号):猿说python

    @Github:www.github.com

    @File:python_len.py

    @Time:2020/2/24 21:25

    @Motto:不积跬步无以至千里,不积小流无以成江海,程序人生的精彩需要坚持不懈地积累!

    """

    def test(func):

    # 判断func如果是函数,就执行他,如果不是函数,直接返回

    # 判断func是否可调用,如果可以调用,就是true

    if callable(func):

    print("函数可以被调用")

    return func

    else:

    print("函数不可以被调用")

    def test2():

    return 'shuopython.com'

    if __name__ == "__main__":

    print(test(test2())) #等价 test(str) 字符串不是对象

    print("***"*20)

    print(test(test2)) #等价 test(func) 函数是对象

    print("***"*20)

    print(test(123)) #等价 test(int) 整形不是对象

    输出结果:

    函数不可以被调用

    None

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

    函数可以被调用

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

    函数不可以被调用

    None

    展开全文
  • 1.Callable接口 2.Callable与Runnable不同 *1.Callable是java.util.concurrent下的接口,有返回值,可以跑出被检查出的异常 ...3.怎么Callable一步一步去让Thread实现呢? 通过源码和结构我们可以发现。Runnabl

    1.Callable接口
    在这里插入图片描述
    2.Callable与Runnable不同

    *1.Callable是java.util.concurrent下的接口,有返回值,可以跑出被检查出的异常
    *2Runable是java.lang下的接口,没有返回值,不可以抛出检查出的异常
    *3.二者重写调用的方法不同,前者是call(),后者是run()方法
    *4.Thread实现了Runnable接口,但没有实现Callable

    3.怎么让Callable一步一步去让Thread实现呢?
    通过源码和结构我们可以发现。Runnable接口有一个实现类—FutureTask,再点进去看,FutureTask的构造方法中所传的参数就是callable
    在这里插入图片描述

    在这里插入图片描述
    于是乎,我们可以梳理出这样一个流程:
    Callable—>FutureTask(Callable)—>Runnable—>new Thread(Runnable).start==new Thread(FutureTask).start

    4.简单代码实现

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * @program: juc
     * @description
     * @author: 不会编程的派大星
     * @create: 2021-04-24 10:15
     **/
    public class CallableTest {
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
    
            //new Thread(new FutureTask<>(new MyThread()),"A").start();
    
            /**
             * callable无法直接通过new Thread()开启,需要通过适配类FutureTask启动
             * 来看一下callable是怎么一步步勾搭上Thread的
             * callable-->FutureTask-->Runnable-->Thread
             * FutureTask是Runnable的实现类
             */
            MyThread myThread = new MyThread();
    
            FutureTask<Integer> futureTask = new FutureTask<>(myThread);
    
            new Thread(futureTask,"B").start();
    
            //get方法可能会出现阻塞!把它放在最后一行,或者使用异步通信来处理
            Integer result = futureTask.get();
            System.out.println(result);
    
        }
    }
    
    
    class MyThread implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("callable");
            return 1024;
        }
    }
    

    运行结果:
    在这里插入图片描述
    **注:

        Integer result = futureTask.get();
    

    这里是获取callable返回的结果,需要抛出异常,get方法可能会出现阻塞!把它放在最后一行,或者使用异步通信来处理。

    这次的讨论就到这里,欢迎小伙伴们留言讨论!

    展开全文
  • 向线程池提交Callable任务,会创建一个新线程(执行任务的线程)去执行这个Callable任务,但是通过Future#get获取任务的执行结果是在提交任务的调用者线程中,那问题一:调用者线程如何获取执行任务的线程的结果?...

    谈谈 Callable 任务是怎么运行的?它的执行结果又是怎么获取的?

    向线程池提交Callable任务,会创建一个新线程(执行任务的线程)去执行这个Callable任务,但是通过Future#get获取任务的执行结果是在提交任务的调用者线程中,那问题一:调用者线程如何获取执行任务的线程的结果?

    在JDK中,有2种类型的任务,Runnable和Callable,但是具体到线程池执行任务的java.util.concurrent.ThreadPoolExecutor#execute(Runnable)方法,它只接收Runnable任务,那问题二:Callable任务是提交给线程池后是如何执行的呢?

    Callable 任务是怎么运行的?

    import java.util.concurrent.*;
    
    public class FutureTest {
        public static void main(String[] args) {
            Callable<Integer> callable = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    //sleep 是为了调试方便
                    TimeUnit.SECONDS.sleep(4);
                    return 3;
                }
            };
            //创建一个 ThreadPoolExecutor 对象
            ExecutorService executorService = Executors.newFixedThreadPool(1);
            
            Future<Integer> future = executorService.submit(callable);
    
            try {
                Integer i = future.get();
                System.out.println(i);
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }

    Future<Integer> future = executorService.submit(callable);

    //java.util.concurrent.AbstractExecutorService#submit(java.util.concurrent.Callable<T>)    
    public <T> Future<T> submit(Callable<T> task) {
            if (task == null) throw new NullPointerException();
            //FutureTask其实是个RunnableFuture, RunnableFuture其实是个Runnable
            //重点是: Runnable#run方法的执行,其实就是 FutureTask#run方法的执行!!!
            RunnableFuture<T> ftask = newTaskFor(task);
            //java.util.concurrent.ThreadPoolExecutor#execute
            execute(ftask);
            return ftask;
        }

    RunnableFuture<T> ftask = newTaskFor(task);

    //java.util.concurrent.AbstractExecutorService#newTaskFor(java.util.concurrent.Callable<T>)
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
            return new FutureTask<T>(callable);
        }

    当submit一个Callable任务时,会生成一个RunnableFuture接口对象,默认情况下 RunnableFuture对象是一个FutureTask对象。看java.util.concurrent.AbstractExecutorService类的源码注释:我们也可以重写 newTaskFor 方法生成我们自己的 RunnableFuture。一个具体的示例可参考ES源码org.elasticsearch.common.util.concurrent.PrioritizedEsThreadPoolExecutor#newTaskFor(java.util.concurrent.Callable<T>),它就重写了 newTaskFor 方法,实现了执行优先级任务时,获取任务执行结果的逻辑。

    the implementation of submit(Runnable) creates an associated RunnableFuture that is executed and returned. Subclasses may override the newTaskFor methods to return RunnableFuture implementations other than FutureTask

    然后再来看FutureTask这个类的run()方法:java.util.concurrent.FutureTask#run,它会触发执行我们定义的Callable#call()方法。搞清楚java.util.concurrent.FutureTask#run方法是怎么被调用的,就搞清楚了线程池执行Callable任务的原理。该方法主要是做了2件事:

    • 执行Callable#call方法,即:FutureTest.java中 我们定义的处理逻辑:返回一个Integer 3
    • 设置任务的执行结果:set(result)

    java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable) 中execute(ftask)提交任务(注意:FutureTask implements Runnable)

    ThreadPoolExecutor是AbstractExecutorService具体实现类,因此最终会执行到:java.util.concurrent.ThreadPoolExecutor#execute提交任务。

    //java.util.concurrent.ThreadPoolExecutor#execute, 重点看addWorker()实现
    if (workerCountOf(c) < corePoolSize) {
                if (addWorker(command, true))
                    return;
                c = ctl.get();
            }

    java.util.concurrent.ThreadPoolExecutor#addWorker 有2行代码很关键:

    //java.util.concurrent.ThreadPoolExecutor#addWorker
    try {
                w = new Worker(firstTask);//关键代码1, firstTask 本质上是 FutureTask对象
                final Thread t = w.thread;
                if (t != null) {
                  //...省略非关键代码
                    if (workerAdded) {
                        t.start();//关键代码 2
                        workerStarted = true;
                    }
                }
            }

    w = new Worker(firstTask)创建一个新线程!把Worker作为this对象传进去,因为Worker implements Runnable,并且实现了java.lang.Runnable#run方法。

            Worker(Runnable firstTask) {
                setState(-1); // inhibit interrupts until runWorker
                this.firstTask = firstTask;//
                this.thread = getThreadFactory().newThread(this);
            }

    这意味着啥?执行java.lang.Runnable#run 就会去真正地执行 java.util.concurrent.ThreadPoolExecutor.Worker#run,那么java.lang.Runnable#run是被谁调用的呢?

    聪明的你一定知道了,new Thread(Runnable).start()执行时,会由jvm去自动调用java.lang.Runnable#run

    所以,上面java.util.concurrent.ThreadPoolExecutor#addWorker 中的关键代码2 t.start();,触发了java.util.concurrent.ThreadPoolExecutor.Worker#run的调用。

    java.util.concurrent.ThreadPoolExecutor.Worker#run里面只是调用了runWoker(this)而已。

    //java.util.concurrent.ThreadPoolExecutor.Worker#run
    /** Delegates main run loop to outer runWorker. */
            public void run() {
                runWorker(this);
            }

    重点来了!再跟进去看看runWoker是何方神圣:

    //java.util.concurrent.ThreadPoolExecutor#runWorker
    final void runWorker(Worker w) {
            Thread wt = Thread.currentThread();
            Runnable task = w.firstTask;//task 实际上是FutureTask类型的对象
            w.firstTask = null;
            try {
                while (task != null || (task = getTask()) != null) {
                  //省略一些 非关键代码....
                    try {
                        beforeExecute(wt, task);//
                        try {
                            //重点代码!触发 java.util.concurrent.FutureTask#run 执行
                            task.run();
                            afterExecute(task, null);
                        } catch (Throwable ex) {
                            //去看看afterExecute方法注释,无论线程执行过程中是否抛异常,afterExecute()都会 执行,看了源码,明白为什么是这样了,因为catch异常处理里面会执行afterExecute
                            afterExecute(task, ex);
                            throw ex;
                        }
                    } finally {
                        task = null;
                        w.completedTasks++;
                        w.unlock();
                    }
                }

    看懂了java.util.concurrent.ThreadPoolExecutor#runWorker几乎就明白线程池执行任务时的beforeExecute、afterExecute方法的所起的作用了(比如经常在afterExecute方法里面做一些线程池任务运行时间的统计工作)。

    总结以下点:

    • Callable任务被submit时,会生成一个FutureTask对象,封装Callable,在FutureTask的run方法里面执行Callable#call方法,并且调用java.util.concurrent.FutureTask#set设置Callable任务的执行结果(结果保存在一个FutureTask的Object类型的实例变量里面:private Object outcome;)。

    • Future<Integer> future = executorService.submit(callable);返回一个Future,它实际上是一个FutureTask对象,通过java.util.concurrent.FutureTask#get()获取Callable任务的执行结果。

    • java.util.concurrent.FutureTask#run方法是由java.util.concurrent.ThreadPoolExecutor#runWorker触发调用的;而java.util.concurrent.ThreadPoolExecutor#runWorker又是由java.util.concurrent.ThreadPoolExecutor.Worker#run触发调用的;而java.util.concurrent.ThreadPoolExecutor.Worker#run又是由java.util.concurrent.ThreadPoolExecutor#addWorker里面的t.start();这条语句触发调用的;而t.start();会触发Runnable#run方法的执行。这就是前面提到的这个原理:new Thread(Runnable).start()会由jvm来调用Runnable#run。具体可参考:

      用一个词表示就是多态。用一张图表示就是:715283-20190826110232418-222204028.jpg

    • 继承 ThreadPoolExecutor 实现自定义的线程池时,可重写 afterExecute()方法做一些异常处理逻辑的实现,不管任务正常执行完成、还是抛出异常,都会调用afterExecute(),具体可看JDK源码关于ThreadPoolExecutor#runWorker方法的注释。有兴趣可研究下ES SEARCH线程池源码就使用afterExecute来统计提交给线程池的每个任务的等待时间、执行时间,从而根据Little's law 自动调整线程池任务队列的长度:org.elasticsearch.common.util.concurrent.QueueResizingEsThreadPoolExecutor#afterExecute

    最后,想说的是:Callable任务,到ThreadPoolExecutor线程池执行 层面,它实际上是一个Runnable任务在执行。因为,ExecutorService submit Callable时,其实是将Callable封装到FutureTask/RunnableFuture中,而RunnableFuture implements Runnable,因此可以提交给线程池的java.util.concurrent.ThreadPoolExecutor#execute(Runnable command)执行,这就回答了本文开头提出的第二个问题。

    //java.util.concurrent.RunnableFuture
    public interface RunnableFuture<V> extends Runnable, Future<V> {
        /**
         * Sets this Future to the result of its computation
         * unless it has been cancelled.
         */
        void run();
    }
    

    用一张图表示就是:
    715283-20190826110209681-1047636931.jpg

    Callable任务的设置与获取,则都是在FutureTask这个层面上完成,把Callable封装到FutureTask中,而FutureTask implements Runnable,从而转化成ThreadPoolExecutor#execute执行Runnable任务。

    Callable任务的执行结果又是怎么获取的?Future.get为什么会阻塞?

    java.util.concurrent.FutureTask 的private volatile int state;变量:

    //java.util.concurrent.FutureTask#run
    public void run() {
            if (state != NEW ||
                !RUNNER.compareAndSet(this, null, Thread.currentThread()))
                return;
            try {
                Callable<V> c = callable;
                if (c != null && state == NEW) {
                    V result;
                    boolean ran;
                    try {
                        //Callable#call执行成功, ran=true
                        result = c.call();
                        ran = true;
                    } catch (Throwable ex) {
                        result = null;
                        ran = false;
                        setException(ex);
                    }
                    //ran=true,才会设置Callable任务的执行结果
                    if (ran)
                        set(result);
                }
            } finally {
                // runner must be non-null until state is settled to
                // prevent concurrent calls to run()
                runner = null;
                // state must be re-read after nulling runner to prevent
                // leaked interrupts
                int s = state;
                if (s >= INTERRUPTING)
                    handlePossibleCancellationInterrupt(s);
            }
        }

    set方法设置Callable任务的执行结果时,会修改 FutureTask的 state 实例变量的值!

        //java.util.concurrent.FutureTask#set   
        protected void set(V v) {
            if (STATE.compareAndSet(this, NEW, COMPLETING)) {
                outcome = v;
                STATE.setRelease(this, NORMAL); // final state
                finishCompletion();
            }
        }

    java.util.concurrent.FutureTask#get()方法,也正是通过检查 state 的值,来确定是否能够拿到Callable任务的执行结果。

        //java.util.concurrent.FutureTask#get()
        public V get() throws InterruptedException, ExecutionException {
            int s = state;
            if (s <= COMPLETING)
                //如果 state 不是在 NORMAL 状态,FutureTask#get()就会阻塞
                //这就是 java.util.concurrent.Future#get() 阻塞的原因
                s = awaitDone(false, 0L);//这里面会调用:Thread.yield()、LockSupport.park(this)
            return report(s);
        }

    java.util.concurrent.FutureTask#awaitDone

    //java.util.concurrent.FutureTask#awaitDone
    private int awaitDone(boolean timed, long nanos)
            throws InterruptedException {
            WaitNode q = null;
            //省略一些无关代码...
            for (;;) {//for循环一直检查任务的运行状态....直到可以"结束"
                int s = state;
                //state的值大于 COMPLETING 说明已经有Callable任务的结果了
                //java.util.concurrent.FutureTask#set 设置了Callable任务的结果,修改了state的值
                if (s > COMPLETING) {
                    if (q != null)
                        q.thread = null;
                    return s;
                }
                //COMPLETING 任务的运行状态是:正在执行中
                else if (s == COMPLETING)
                    // We may have already promised (via isDone) that we are done
                    // so never return empty-handed or throw InterruptedException
                    Thread.yield();//挂起获取执行结果的线程(这就是Futur#get阻塞的原因)
                else if (Thread.interrupted()) {
                    removeWaiter(q);//任务可能被中断了,当然就不需要等待获取执行结果了
                    throw new InterruptedException();
                }
                else if (q == null) {
                    if (timed && nanos <= 0L)
                        return s;
                    q = new WaitNode();
                }
                else if (!queued)
                    queued = WAITERS.weakCompareAndSet(this, q.next = waiters, q);
                //java.util.concurrent.Future#get(long, java.util.concurrent.TimeUnit)超时阻塞的实现原理
                else if (timed) {
                    final long parkNanos;
                    if (startTime == 0L) { // first time
                        startTime = System.nanoTime();
                        if (startTime == 0L)
                            startTime = 1L;
                        parkNanos = nanos;
                    } else {
                        long elapsed = System.nanoTime() - startTime;
                        if (elapsed >= nanos) {
                            removeWaiter(q);
                            return state;
                        }
                        parkNanos = nanos - elapsed;
                    }
                    // nanoTime may be slow; recheck before parking
                    if (state < COMPLETING)
                        LockSupport.parkNanos(this, parkNanos);
                }
                else
                    LockSupport.park(this);
            }
        }

    总结一下:通过 state变量来判断Callable任务的执行结果是否已经生成。如果已经生成了执行结果,那么 java.util.concurrent.FutureTask#set会把结果放到private Object outcome;outcome这个变量中。然后设置state的值为NORMAL,那么java.util.concurrent.FutureTask#get()通过检查 state 的值,就能拿到执行结果了,当然了,如果执行结果还未生成,java.util.concurrent.FutureTask#awaitDone就会导致 get 阻塞。

    最后的最后,留一个问题:由于JDK里面Future#get都是阻塞的,那有没有什么方法使得获取 Callable 任务的执行结果不阻塞?

    看看Netty的源码?借鉴一下Listener回调机制。哈哈……

    转载于:https://www.cnblogs.com/hapjin/p/11407011.html

    展开全文
  • 项目需求 调用his的存储过程。 加上这个月没写文章,就顺便记录下来吧。 项目 SpringBoot+Mybatis 首先创建存储过程。 项目中是boot搭配了多数据源。调sqlserver的存储过程 创建好存储过程后 bean serverimpl ...
  • 根据网上材料写的mybatis 调用mysql储存过程报错 这是测试类里面的 try { String resource = "com/qipei/mapper/DdmlMapper.xml"; Reader reader= Resources.getResourceAsReader(resource); ...
  • Java技术栈www.javastack.cn关注阅读更多优质文章转载自公众号:17coding技术博客一、Thread 与 Runnable1、创建线程的两种方法在java中你怎么创建线程?相信你很快能够想到继承Thread类和实现Runnable接口这两种...
  • 1.Callable 与Runnable类似,可以执行线程,与Runnable不同的是,它不是调用run方法,而是调用call方法...我们搭建一个小的Demo来演示怎么使用callable接口 public class callableTest { public static void main(Str
  • 第三方远程服务调用用HTTP Request远程请求元件来请求服务器端内容并返回结果或执行服务器处理自定义独立服务器端的服务并在其他项目中调用自定义服务器端可调用逻辑用Callable Service(可调用的服务器端处理元件)来...
  • <sql-query name="getUserList" callable="true"> {call getUserList()} 这是单表操作单表的,请问哪位高手可以帮我解决么?
  • 经常会遇到一些性能问题,比如调用某个接口,可能要循环调用100次,并且需要拿到每一次调用的返回结果,通常我们都是放在for循环中一次次的串行调用,这种方式可想而知道有多慢,那怎么解决这个问题呢? 二、多线程 ...
  • <p><img alt="" height="670" src=...在谷歌驱动下载了对应的版本插件怎么还是会出现模块对象不可调用啊,来自python小白的默默提问。</p>
  • 正常的写法使穿行化: 只能等嗲用完信息接口,在调用积分接口, 时间累加 可以通过使用线程,并行化,节省时间 线程使用callable:因为她有返回值 userInfoTask.get(). 阻塞拿结果。执行完userInfoTask.get().才能...
  • 该article描述了一种在阅读时避免阻塞的方法.它给出了代码片段,您可以根据我在评论中指出的内容进行修改.import ...public class ConsoleInputReadTask implements Callable {public String call() throws IOExcepti...
  • 这是python定时器apschedurler的scheduler.add_job(iotmain(), “cron”, hour = 7, minute = 00)语句里面,调用的方法iotmain()不能带(),改写为:scheduler.add_job(iotmain, ...疑问:带参数的方法怎么定时调用
  • 调用数据库里的一个函数一个函数本质上一个返回一个结果的存储过程,这个例子示范了怎么调用有in、out和in/out参数的函数***********************************/CallableStatement cs;try {// 调用一个没有参数的函数...
  • 天涯尽头无女友调用数据库里的一个函数一个函数本质上一个返回一个结果的存储过程,这个例子示范了怎么调用有in、out和in/out参数的函数***********************************/CallableStatement cs;try {// 调用一个...
  • /**调用数据库里的一个函数一个函数本质上一个返回一个结果的存储过程,这个例子示范了怎么调用有in、out和in/out参数的函数***********************************/CallableStatement cs;try {// 调用一个没有参数的...
  • 这是我的一个测试类,测试调用mysql存储过程的: String resource = "com/qipei/mapper/DdmlMapper.xml"; try { Reader reader = Resources.getResourceAsReader(resource); SqlSessionFactory ssf = ...
  • 无聊~,怎么在Mybatis中调用存储过程。 和普通sql调用差不多,但需要配置statementType=”CALLABLE” 首先看无参数的存储过程调用,调用很简单,只贴配置...带输出参数的存储过程就不说了,看一下Mybatis是怎么调用
  • JAVA的异步调用

    千次阅读 2017-12-11 10:14:53
    那么后台的异步调用怎么实现呢?1、 使用callable接口,加线程池 2、 使用JAVA的回调机制 3、 使用spring框架默认的异步调用方式一、第一种方式是比较简单,也比较常用的方式,下面看一段示例代码:public void ...
  • 一个函数本质上一个返回一个结果的存储过程,这个例子示范了怎么调用有in、out和in/out参数的函数。 大同小异的方法。    CallableStatement cs;  try {  // 调用一个没有参数的函数; 函数返回 a VARCHAR  ...
  • java中使用mybatis调用存储过程(存储过程返回数据集)我只想取其中的一个字段,怎么写?我的返回字段有mg_dept,energy_name,s_energy_name,target_date,sum_use_value,total_price。但我只想要sum_use_value如...
  • 内容或简介:/**调用数据库里的一个函数一个函数本质上一个返回一个结果的存储过程,这个例子示范了怎么调用有in、out和in/out参数的函数***********************************/CallableStatement cs;try {// 调用一...
  • python无法调用对象的错误

    千次阅读 2017-06-12 13:39:37
    今天在学python的时候,不知道怎么使用str()函数显示错误,错误提示是typrError:'str' object is not callable; 在网上查了一下,终于发现问题的所在,因为我在之前使用了str作为变量,然后这个变量把str()函数给...
  • 调用存储过程也是一次额C/S架构模式下经常使用的手段,我们知道,ibatis调用存储过程有一个专门的标签,在mybats里面已经没有这本标签了,而是通过一个参数statementType="CALLABLE"来区分。废话不多说,直接看...

空空如也

空空如也

1 2 3 4 5
收藏数 87
精华内容 34
关键字:

怎么调用callable