精华内容
下载资源
问答
  • 一、RMI 远程方法调用 RMI(Remote Method Invocation)远程方法调用。能够让在客户端Java虚拟机上的对象像调用本地对象一样调用服务端java 虚拟机中的对象上的方法。使用代表:EJB RMI远方法程调用步骤: 1、...

    一、RMI 远程方法调用

    • RMI(Remote Method Invocation)远程方法调用。能够让在客户端Java虚拟机上的对象像调用本地对象一样调用服务端java 虚拟机中的对象上的方法。使用代表:EJB
    • RMI远方法程调用步骤:
      • 1、客户调用客户端辅助对象stub上的方法
      • 2、客户端辅助对象stub打包调用信息(变量、方法名),通过网络发送给服务端辅助对象skeleton
      • 3、服务端辅助对象skeleton将客户端辅助对象发送来的信息解包,找出真正被调用的方法以及该方法所在对象
      • 4、调用真正服务对象上的真正方法,并将结果返回给服务端辅助对象skeleton
      • 5、服务端辅助对象将结果打包,发送给客户端辅助对象stub
      • 6、客户端辅助对象将返回值解包,返回给调用者
      • 7、客户获得返回值

    在这里插入图片描述
    参考:https://blog.csdn.net/guyuealian/article/details/51992182

    二、RPC 远程过程调用

    • RPC(Remote Procedure Call Protocol)远程过程调用协议,通过网络从远程计算机上请求调用某种服务。它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。 使用代表:Dubbo
    • 一次RPC调用的过程大概有10步:
      • 1、执行客户端调用语句,传送参数
      • 2、调用本地系统发送网络消息
      • 3、消息传送到远程主机
      • 4、服务器得到消息并取得参数
      • 5、根据调用请求以及参数执行远程过程(服务)
      • 6、执行过程完毕,将结果返回服务器句柄
      • 7、服务器句柄返回结果,调用远程主机的系统网络服务发送结果
      • 8、消息传回本地主机
      • 9、客户端句柄由本地主机的网络服务接收消息
      • 10、客户端接收到调用语句返回的结果数据

    远程过程调用带来的新问题
    在远程调用时,我们需要执行的函数体是在远程的机器上的,也就是说,Multiply是在另一个进程中执行的。这就带来了几个新问题:

    Call ID映射。我们怎么告诉远程机器我们要调用Multiply,而不是Add或者FooBar呢?在本地调用中,函数体是直接通过函数指针来指定的,我们调用Multiply,编译器就自动帮我们调用它相应的函数指针。但是在远程调用中,函数指针是不行的,因为两个进程的地址空间是完全不一样的。所以,在RPC中,所有的函数都必须有自己的一个ID。这个ID在所有进程中都是唯一确定的。客户端在做远程过程调用时,必须附上这个ID。然后我们还需要在客户端和服务端分别维护一个 {函数 <–> Call ID} 的对应表。两者的表不一定需要完全相同,但相同的函数对应的Call ID必须相同。当客户端需要进行远程调用时,它就查一下这个表,找出相应的Call ID,然后把它传给服务端,服务端也通过查表,来确定客户端需要调用的函数,然后执行相应函数的代码。
    序列化和反序列化。客户端怎么把参数值传给远程的函数呢?在本地调用中,我们只需要把参数压到栈里,然后让函数自己去栈里读就行。但是在远程过程调用时,客户端跟服务端是不同的进程,不能通过内存来传递参数。甚至有时候客户端和服务端使用的都不是同一种语言(比如服务端用C++,客户端用Java或者Python)。这时候就需要客户端把参数先转成一个字节流,传给服务端后,再把字节流转成自己能读取的格式。这个过程叫序列化和反序列化。同理,从服务端返回的值也需要序列化反序列化的过程。
    网络传输。远程调用往往用在网络上,客户端和服务端是通过网络连接的。所有的数据都需要通过网络传输,因此就需要有一个网络传输层。网络传输层需要把Call ID和序列化后的参数字节流传给服务端,然后再把序列化后的调用结果传回客户端。只要能完成这两者的,都可以作为传输层使用。因此,它所使用的协议其实是不限的,能完成传输就行。尽管大部分RPC框架都使用TCP协议,但其实UDP也可以,而gRPC干脆就用了HTTP2。Java的Netty也属于这层的东西。
    所以,要实现一个RPC框架,其实只需要把以上三点实现了就基本完成了。

    Call ID映射可以直接使用函数字符串,也可以使用整数ID。映射表一般就是一个哈希表。
    序列化反序列化可以自己写,也可以使用Protobuf或者FlatBuffers之类的。
    网络传输库可以自己写socket,或者用asio,ZeroMQ,Netty之类。

    参考:https://my.oschina.net/zjllovecode/blog/1790024

    三、RMI与RPC的区别

    • 1、方法调用方式不同:
      • RMI调用方法,RMI中是通过在客户端的Stub对象作为远程接口进行远程方法的调用。每个远程方法都具有方法签名。如果一个方法在服务器上执行,但是没有相匹配的签名被添加到这个远程接口(stub)上,那么这个新方法就不能被RMI客户方所调用。
      • RPC调用函数,RPC中是通过网络服务协议向远程主机发送请求,请求包含了一个参数集和一个文本值,通常形成“classname.methodname(参数集)”的形式。这就向RPC服务器表明,被请求的方法在“classname”的类中,名叫“methodname”。然后RPC服务器就去搜索与之相匹配的类和方法,并把它作为那种方法参数类型的输入。这里的参数类型是与RPC请求中的类型是匹配的。一旦匹配成功,这个方法就被调用了,其结果被编码后通过网络协议发回。
    • 2、适用语言范围不同:
      • RMI只用于Java,支持传输对象。
      • RPC是基于C语言的,不支持传输对象,是网络服务协议,与操作系统和语言无关。
    • 3、调用结果的返回形式不同:
      • RMI是面向对象的,Java是面向对象的,所以RMI的调用结果可以是对象类型或者基本数据类型。
      • RPC的结果统一由外部数据表示(External Data Representation,XDR)语言表示,这种语言抽象了字节序类和数据类型结构之间的差异。只有由XDR定义的数据类型才能被传递,可以说RMI是面向对象方式的Java RPC。

    四、附录

    • RPC(Remote Procedure Call Protocol)远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。RPC不依赖于具体的网络传输协议,tcp、udp等都可以。
    • 由于存在各式各样的变换和细节差异,相应的RPC也派生出了各式远程过程通信协议。RPC是跨语言的通信标准,SUN和微软都有其实现,比如:RMI可以被看作SUN对RPC的Java版本(实现),而微软的DCOM就是建立在ORPC协议之上。
    • 一言以蔽之,RPC是协议,而无论是SUN的RMI还是微软的DCOM都是对该协议的不同实现,二者都为编程人员提供了应用PRC技术的程序接口(API)

    • RMI是Java的一组拥护开发分布式应用程序的API。RMI使用Java语言接口定义了远程对象,它集合了Java序列化Java远程方法协议(Java Remote Method Protocol)。简单地说,这样使原先的程序在同一操作系统的方法调用,变成了不同操作系统之间程序的方法调用,由于J2EE是分布式程序平台,它以RMI机制实现了程序组件在不同操作系统之间的通信
    • 比如,一个EJB可以通过RMI调用Web上另一台机器上的EJB远程方法。
    • RMI(Remote Method Invocation,远程方法调用)是用Java在JDK1.1中实现的,它大大增强了Java开发分布式应用的能力。

    • Java作为一种风靡一时的网络开发语言,其巨大的威力就体现在它强大的开发分布式网络应用的能力上,而RMI就是开发百分之百纯Java的网络分布式应用系统的核心解决方案之一。其实RMI可以被看作是RPC的Java版本(实现)。
    • 传统RPC并不能很好地应用于分布式对象系统,而Java RMI 则支持存储于不同地址空间的程序级对象之间彼此进行通信,实现远程对象之间的无缝远程调用
    • RMI目前使用Java远程消息交换协议(JRMP,Java Remote Messaging Protocol)进行通信。JRMP是专为Java的远程对象制定的协议。因此,Java RMI具有Java的“Write Once,Run Anywhere”的优点,是分布式应用系统的百分之百纯Java解决方案。用Java RMI开发的应用系统可以部署在任何支持JRE(Java Run Environment Java,Java运行环境)的平台上。但由于JRMP是专为Java对象制定的,因此,RMI对于用非Java语言开发的应用系统的支持不足。不能与用非Java语言书写的对象进行通信。

    • Hadoop作为一个存储与服务的基础性平台,同时它的内部有采用了master/slave架构,那么其内部通信和与客户端的交互就是必不可少的了。Hadoop在实现时抛弃了JDK自带的一个RPC实现–RMI,而自己基于IPC模型实现了一个更高效的轻量级RPC。

    • RMI的局限性之一:RMI对服务器的IP地址和端口依赖很紧密,但是在开发的时候不知道将来的服务器IP和端口如何,但是客户端程序依赖这个IP和端口。这个问题有两种解决途径:一是通过DNS来解决,二是通过封装将IP暴露到程序代码之外。注意:我们在实际开发中,我们是知道服务器IP和端口的。
    • RMI的局限性之二:是RMI是Java语言的远程调用,两端的程序语言必须是Java实现,对于不同语言间的通讯可以考虑用WebService或者公用对象请求代理体系(CORBA)来实现。

    • JMS:Java 消息服务(Java Messaging Service) 是一种允许应用程序创建、发送、接受和读取消息的Java API。JMS 在其中扮演的角色与JDBC 很相似,正如 JDBC 提供了一套用于访问各种不同关系数据库的公共APIJMS 也提供了独立于特定厂商的企业消息系统访问方式。 
    • 使用JMS 的应用程序被称为JMS客户端,处理消息路由与传递的消息系统被称为 JMS Provider,而JMS 应用则是由多个JMS 客户端和一个 JMS Provider 构成的业务系统。发送消息的JMS 客户端被称为生产者(producer),而接收消息的JMS 客户端则被称为消费者(consumer)。同一JMS 客户端既可以是生产者也可以是消费者。
    • JMS 的编程过程很简单,概括为:应用程序A 发送一条消息到消息服务器(也就是JMS Provider)的某个目的地(Destination),然后消息服务器把消息转发给应用程序B。因为应用程序A 和应用程序B 没有直接的代码关连,所以两者实现了解偶

    • RMI和JMS的区别:
    • 1、传输方式上
      • JMS 与 RMI 的区别在于:采用 JMS 服务,对象是在物理上被异步从网络的某个 JVM 上直接移动到另一个 JVM 上。
      • RMI 对象是绑定在本地 JVM 中,只有函数参数和返回值是通过网络传送的。
    • 2、方法调用上
      • RMI 一般都是同步的,也就是说,当client端调用Server端的一个方法的时候,需要等到对方的返回,才能继续执行client端,这个过程跟调用本地方法感觉上是一样的,这也是RMI的一个特点。
      • JMS 一般只是一个点发出一个Message到Message Server端,发出之后一般不会关心谁用了这个message。
      • 一般RMI的应用是紧耦合,JMS的应用相对来说是松散耦合的应用。
    展开全文
  • JAVA类之间方法调用

    万次阅读 多人点赞 2018-11-02 23:39:15
    JAVA类方法的调用一、静态方法调用其他方法:1. 静态方法调用非静态方法2.静态方法调用静态方法二、非静态方法调用其他方法1.非静态方法在同一类内调用其他方法2.非静态方法在不同类之间调用其他方法 注:调用方法...

    注:调用方法——调用另一方法的方法
    被调用方法——被调用的方法

    一、静态方法调用其他方法:

    1. 静态方法调用非静态方法

    无论是否在同一类内,均需要通过对象调用

    //Test类
    package main;
    
    public class Test {
    
        public void IsSon1(){//非静态方法
            System.out.println("java大爷,你成功调用了你非静态方法里的儿子1");
        }
    
        public static void main(String[] args) {
            Test son1=new Test();
            son1.IsSon1();//静态方法通过对象调用此类中的非静态方法
            Son son=new Son();//静态方法通过对象调用Son类中的非静态方法
            son.IsSon();
        }
    }
    
    //Son类
    package main;
    
    public class Son {
        public  void IsSon(){
            System.out.println("java大爷,你成功的调用了你另一个类里的儿子");
        }//Son类里的非静态方法
    }
    

    输出结果

    2.静态方法调用静态方法

    同一类内直接调用,不同类内直接通过类名.方法名(参数表)调用

    package main;
    
    public class Test {
    
        public static void IsSon2(){//静态方法
            System.out.println("java大爷,你成功调用了你静态方法里的儿子2");
        }
    
        public static void main(String[] args) {
            IsSon2();//静态方法直接调用类内的静态方法
            Son.IsSon3();//静态方法通过类名直接调用Son类中的静态方法
        }
    }
    
    package main;
    
    public class Son {
        public  static void IsSon3(){
            System.out.println("java大爷,你成功的调用了你另一个类里的静态儿子3");
        }//Son类里的静态方法
    }
    
    

    输出结果

    二、非静态方法调用其他方法

    1.非静态方法在同一类内调用其他方法

    在同一类内,非静态方法可以直接调用静态方法和非静态方法

    package main;
    
    public class Test {
    
        public void Son1(){//非静态方法
            System.out.println("java大爷,你成功调用了你非静态方法里的儿子1");
        }
        public static void Son2(){//静态方法
            System.out.println("java大爷,你成功调用了你静态方法里的儿子2");
        }
        public void alloutput(){
            Son1();//非静态方法直接调用类内的非静态方法△
            Son2();//非静态方法直接调用类内的静态方法△
        }
        public static void main(String[] args) {
            Test test = new Test();
            test.alloutput();//前边已学静态方法通过对象调用非静态方法
        }
    }
    

    输出结果

    2.非静态方法在不同类之间调用其他方法

    在不同类之间,非静态方法需要通过对象才能调用非静态方法。
    非静态方法既可以通过对象调用静态方法又可以通过类名直接调用(由于对象的调用方式属于非静态调用方式,所以建议使用类名直接调用静态方法)

    package main;
    
    public class Test {
    
        public void output(){
            Son.IsSon1();//通过类名直接调用Son类中的静态方法,不建议使用对象调用静态方法
            Son son = new Son();
            son.IsSon2();//通过对象调用Son类中的非静态方法
        }
    
        public static void main(String[] args) {
            //同一类中的静态方法调用非静态方法output,前边已经涉及到
            Test test = new Test();
            test.output();
        }
    }
    
    package main;
    
    public class Son {
    
        public  static void IsSon1(){//Son类里的静态方法
            System.out.println("java大爷,你成功的调用了你另一个类里的静态儿子1");
        }
    
        public  void IsSon2(){//Son类里的非静态方法
            System.out.println("java大爷,你成功的调用了你另一个类里的非静态儿子2");
        }
    }
    
    

    输出结果

    借鉴前人的经验1

    借鉴前人的经验2
    小白上路,如有问题希望各路神手指教 /抱拳

    展开全文
  • C++类方法调用

    千次阅读 2019-10-29 09:23:09
    在C++类内部方法调用时,一般都是先去定义一个类的变量,实例化之后再通过类对象去调用类内部的函数。在项目中发现另一种比较方便的方法,不需要定义类对象,话不多说直接上代码。 实例代码如下: #include <...

    在C++类内部方法调用时,一般都是先去定义一个类的变量,实例化之后再通过类对象去调用类内部的函数。在项目中发现另一种比较方便的方法,不需要定义类对象,话不多说直接上代码。

    实例代码如下:

    #include <iostream>
    using namespace std;
    
    class A{
    public:
        A(int iNum){ i = iNum; }
        void    readName(){cout<<"i = "<<i<<endl;}
    private:
        int i;
    	
    public:
        static A*	_obj(){ return _object; }
        static void	_InitObj();
        static void	_FreeObj();
        void    read_it(){cout<<"it = "<<it<<endl;}
    	
    private:
        static A* _object;
        static int it;
    };
    
    void A::_InitObj()
    {
        A::_object = new A(4);
    }
    
    void A::_FreeObj()
    {
        if(A::_object != NULL)
        {
    	delete _object;
    	A::_object = NULL;
        }
    }
    
    A* A::_object = NULL;
    int A::it = 9;
    
    int main()
    {
        A::_InitObj();
    	
        A::_obj()->readName();
        A::_obj()->read_it();
    	
        A::_FreeObj();
    	
        return 0;
    }

    上述代码执行结果:

    通过上述代码可以清楚的知道,通过在类内部定义静态变量向外部类提供相应的接口去调用类的内部方法,该办法确实非常实用。

    展开全文
  • 在静态方法调用@Autowired或@Resource注解的Spring注入的service的方法问题。 分析:1.首先,静态方法中不可调用非静态方法,这与JVM加载类的机制有关。    2.spring自动注入,使用spring框架的很常用如果在...

    问题:1.在静态方法中调用@Autowired或@Resource注解的Spring注入的service的方法问题。

    分析:1.首先,静态方法中不可调用非静态方法,这与JVM加载类的机制有关。

     

       2.spring自动注入,使用spring框架的很常用如果在静态方法中调用此注入类的方法,发现注入为'null';原因不是spring未注入,而是被static方法给'清空'了。

     

    解决方法一:

     

    0      @Component //此处注解不能省却(0)
     1      public class NtClient {
     2      /** 
     3         * 日志 
     4         */ 
     5         private static String clazzName = NtClient.class.getName(); 
     6          /** 
     7             * 此处是要使用的service需要spring注入(1) 
     8             */ 
     9          @Autowired 
    10           private NotifyTimeService notifyTimeService; 
    11           private static NtClient ntClient; 
    12           /** 
    13              * 注意此处注解(2) */
    14           @PostConstruct  
    15           public void init() {       
    16                    ntClient = this; 
    17                    ntClient.notifyTimeService = this.notifyTimeService; 
    18            } 
    19             /** 
    20                * 主要使用场景(3) 
    21                */ 
    22            public static void insertParam(int id){ 
    23                    /** 
    24                       * 注意此处的调用方法(4) 
    25                       */    
    26                   if(ntClient.notifyTimeService.deleteNotifyTime(id)){
    27                   }
    28            }
    29 }    
    
    

    注释:(0)处作用是将(2)ntClient = this;this进行赋值(注:如果无注解ntClient 将null)     (1)处为spring自动注入,使用spring框架的很常用,但是如果在静态方法中调用此注入类的方法,发现注入为'null';原因不是spring未注入,而是被static方法给'清空'了,在无法先于static方法初始化之前想了一个办法    (2)处为想到的办法:通过(注:@PostConstruct修饰的方法会在服务器加载Servle的时候运行,并且只会被服务器执行一次。PostConstruct在构造函数之后执行,init()方法之前执行。PreDestroy()方法在destroy()方法执行执行之后执行)的方法public void init()先给该类赋值,然后通过(1)出注入进来。这样不影响dao等service下面调用的注入!    (3)处要处理的特殊方法static(经典是 main()方法,自己想想基础,它里面可以使用的方法调用的模式)    (4)处是使用这样模式的调用方式notifyTimeService现在是作为ntClient的属性

       

     

    上面的解决方法是查看别人的,确实可以,感谢博主。

    解决方法二:

          出现这种问题的场景多是操作数据库,注入的service中的方法调用dao层造成。

          这里给出最笨的一种方法,写一个Util,里面写静态方法,用原生的JDBC去操作库,在静态方法类中不用注入,直接调用该静态方法即可。

          下面给出部分JDBC操作数据库代码:

    package com.zichen.xhkq.util;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Service;
    
    import com.zichen.xhkq.pojo.weixin.Wechat;
    
    /**
     * 
     * 项目名称:weChatJavaTokenValidate 类名称:WeChatUtil 类描述: 从数据库读取wechat 的类 创建人:xpz
     * 创建时间:2018/7/16 下午2:00:13 修改人: 修改时间:2018/7/16 下午2:00:13 修改备注:
     * 
     * @version
     */
    @Service
    public class WeChatUtil {
    
    	private static Logger log = LoggerFactory.getLogger(WeChatUtil.class);
    
    	/**
    	 * 
    	 * @Title: getTokenFromDB
    	 * @Description: TODO(从数据库里面获取token,id=1)
    	 * @param @return
    	 * @return Map<String,Object>
    	 * @throws
    	 */
    	public static Wechat getWeChatFromDB(int schoolId) {
    
    		log.info("开始进入数据库获取Wechat");
    		Connection con = null;
    		PreparedStatement stmt = null;
    		ResultSet rs = null;
    		// 查询schoolId的数据
    		String c = "select * from wechat_token_h where schoolId = " + schoolId;
    
    		Wechat wechat = new Wechat();
    		try {
    			// 创建数据库链接
    			con = DBUtility.getConnection();
    			// 创建处理器
    			stmt = con.prepareStatement(c);
    			// 查询Token,读取1条记录
    			rs = stmt.executeQuery();
    			if (rs.next()) {
    
    				wechat.setAppid(rs.getString("appid"));
    				wechat.setAppsecret(rs.getString("appsecret"));
    				wechat.setToken(rs.getString("token"));
    				// wechat.setSchoolId(rs.getString("schoolId"));
    
    			}
    
    		} catch (SQLException ex) {
    			System.out.println("获取token的数据库操作异常:" + ex.getMessage());
    		} finally {
    			DBUtility.closeConnection(con);
    		}
    		log.info("获取wechat的数据库查完了返回" + wechat.toString());
    		return wechat;
    	}
    
    }

    JDBC工具类

    package com.zichen.xhkq.util;
    
    import java.io.IOException;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Properties;
    
    import org.apache.commons.dbcp.BasicDataSource;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    
    /**
     * 
     * 项目名称:weChatJavaTokenValidate   
     * 类名称:DBUtility   
     * 类描述:   连接数据库工具类
     * 创建人:lk
     * 创建时间:2017-11-28 下午6:59:14   
     * 修改人:   
     * 修改时间:2017-11-28 下午6:59:14   
     * 修改备注:   
     * @version
     */
    public class DBUtility {
        private static BasicDataSource dataSource = null;
        private static Logger log = LoggerFactory.getLogger(CommonUtil.class);
        public DBUtility() {
        }
    
        public static void init() {
    
            Properties dbProps = new Properties();
            // 取配置文件可以根据实际的不同修改
            try {
            	log.info("获取配置文件中的数据库配置");
                dbProps.load(DBUtility.class.getClassLoader().getResourceAsStream("jdbc.properties"));
                log.info("获取配置文件中的数据库配置完成");
            } catch (IOException e) {
                e.printStackTrace();
                log.info("获取配置文件中的数据库配置出现异常");
            }
    
            try {
            	 log.info("获取配置文件中的数据库配置中各属性及值");
                String driveClassName = dbProps.getProperty("driverClassName");
                String url = dbProps.getProperty("url");
                String username = dbProps.getProperty("username");
                String password = dbProps.getProperty("password");
    
                String initialSize = dbProps.getProperty("initialSize");
                String minIdle = dbProps.getProperty("minIdle");
                String maxIdle = dbProps.getProperty("maxIdle");
                String maxWait = dbProps.getProperty("maxWait");
                String maxActive = dbProps.getProperty("maxActive");
    
                dataSource = new BasicDataSource();
                dataSource.setDriverClassName(driveClassName);
                dataSource.setUrl(url);
                dataSource.setUsername(username);
                dataSource.setPassword(password);
    
                // 初始化连接数
                if (initialSize != null)
                    dataSource.setInitialSize(Integer.parseInt(initialSize));
    
                // 最小空闲连接
                if (minIdle != null)
                    dataSource.setMinIdle(Integer.parseInt(minIdle));
    
                // 最大空闲连接
                if (maxIdle != null)
                    dataSource.setMaxIdle(Integer.parseInt(maxIdle));
    
                // 超时回收时间(以毫秒为单位)
                if (maxWait != null)
                    dataSource.setMaxWait(Long.parseLong(maxWait));
    
                // 最大连接数
                if (maxActive != null) {
                    if (!maxActive.trim().equals("0"))
                        dataSource.setMaxActive(Integer.parseInt(maxActive));
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("创建连接池失败!请检查设置!!!");
                log.info("创建连接池失败!请检查设置!!!log");
            }
        }
    
        /**
         * 数据库连接
         * 
         * @return
         * @throws SQLException
         */
        public static synchronized Connection getConnection() throws SQLException {
            if (dataSource == null) {
                init();
            }
            Connection conn = null;
            if (dataSource != null) {
    
            	conn = dataSource.getConnection();
            }
            return conn;
        }
    
        /**
         * 关闭数据库
         * 
         * @param conn
         */
        public static void closeConnection(Connection conn) {
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    System.out.println("关闭资源失败");
                    e.printStackTrace();
                }
            }
        }
    
    }
    

    JDBC配置文件jdbc.properties

    driverClassName=com.mysql.jdbc.Driver
    #url=jdbc\:mysql\://localhost\:3306/xinhe_weixin?useUnicode\=true&characterEncoding\=utf8&autoReconnect\=yes&failOverReadOnly\=no&tinyInt1isBit\=false
    #本地数据库链接
    url=jdbc\:mysql\://rm-2zez68k598ener9pt.mysql.rds.aliyuncs.com\:3306/educloud_db?useUnicode\=true&characterEncoding\=gbk&autoReconnect\=yes&failOverReadOnly\=no&tinyInt1isBit\=false
    #上线数据库链接
    #url=jdbc\:mysql\://rm-2zez68k598ener9pti.mysql.rds.aliyuncs.com\:3306/educloud_db?useUnicode\=true&characterEncoding\=gbk&autoReconnect\=yes&failOverReadOnly\=no&tinyInt1isBit\=false
    
    username=edu
    password=Zxp62672000
    #配置监控统计拦截的filters
    filters=stat
    #定义初始连接�?
    initialSize=10
    #定义�?��连接�?
    maxActive=300
    #定义�?��空闲
    maxIdle=20
    #定义�?��空闲
    minIdle=1
    #定义�?��等待时间
    maxWait=60000
    #配置间隔多久才进行一次检测,�?���?��关闭的空闲连接,单位是毫�?
    timeBetweenEvictionRunsMillis=60000
    #配置�?��连接在池中最小生存的时间,单位是毫秒
    minEvictableIdleTimeMillis=300000
    validationQuery=SELECT 1
    testWhileIdle=true
    testOnBorrow=false
    testOnReturn=false
    poolPreparedStatements=false
    maxPoolPreparedStatementPerConnectionSize=200

     

     

     

     

    展开全文
  • uni-app中组件间方法调用

    千次阅读 2019-12-16 10:46:06
    在此总结下,供参考! 一、先上结果图,如下: 二、项目说明 ...红色圈起来的为子组件,绿色圈起来的为父组件。...uni-app项目,所以具体组件引入流程不在详细说明,直接列出代码。... 点击调用...
  • Java方法调用的过程是怎样的?

    千次阅读 热门讨论 2021-05-11 23:40:29
    方法(Java中称为方法,其他语言一般称为函数)调用主要是通过栈来存储相关的数据,系统就方法调用者和方法如何使用栈做了约定,返回值可以简单认为是通过一个专门的返回值存储器来存储的。 补充 举例说明 上面的...
  • java的静态方法调用

    万次阅读 多人点赞 2019-01-13 21:29:34
    首先你要知道java中静态方法调用有哪几种? 例如一个静态方法如下:   (1) 通过类名直接调用 调用格式: 类名.方法名 Test.aa()  前提是这个静态方法是要有返回值!这个静态方法是公共的(public),本类调用的话...
  • vue 方法调用 this指向

    千次阅读 2019-02-22 10:38:59
    原文地址:https://blog.csdn.net/WatermelonMk/article/details/83060468 转载内容:1.错误代码 2.正确代码   调用的时候 把此vue对象的指向作为参数 传递给被调用的函数...
  • Java RMI远程方法调用详解

    万次阅读 多人点赞 2016-07-22 17:45:43
    远程方法调用RMI(Remote Method Invocation),是允许运行在一个Java虚拟机的对象调用运行在另一个Java虚拟机上的对象的方法。 这两个虚拟机可以是运行在相同计算机上的不同进程中,也可以是运行在网络上的不同...
  • 3.使用了@Transactional的方法,对同一个类里面的方法调用, @Transactional无效。比如有一个类Test,它的一个方法A,A再调用Test本类的方法B(不管B是否public还是private),但A没有声明注解事务,而B有。则外部...
  • 为了更加深入的理解方法的覆盖和覆写原理需要了解java方法的调用原理首先解释一下方法调用方法调用不等同于方法执行,方法调用阶段的唯一任务就是确定被调用方法的版本(即确定具体调用那一个方法),不涉及方法...
  • JVM中方法调用的底层实现

    万次阅读 2020-08-06 21:02:15
    方法调用的底层实现 我们编写的Java代码,经过编译后编程class文件,最后经过类加载器加载后进入了JVM的运行时数据区。 但作为程序员真正关心是代码的执行,代码的执行其实本质上是方法的执行,站在JVM 的角度...
  • private 方法调用范围

    千次阅读 2019-11-13 21:06:30
    private 修饰的方法只能在当前类中被当前类中方法调用。但是一个类中的方法不能调用另一个类中的private 方法。
  • java 反射获取方法属性和方法调用

    千次阅读 2019-05-08 21:04:14
    指在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法,对于任意一个对象,都能调用它的任意一个方法.这种动态获取信息,以及动态调用对象方法的功能叫java语言的反射机制;(通俗点讲, 通过反射,该类对...
  • java 类方法和实例方法 调用关系

    万次阅读 多人点赞 2018-04-20 23:49:55
    java 类方法和实例方法 1. 类方法 也可称静态方法,使用static修饰的类中方法; 2.实例方法 非静态方法,没有用static修饰的方法。 3.测试案例 public class Test { private int a = 5; private ...
  • Mockito 验证方法调用次数

    千次阅读 2019-08-15 19:36:45
    // 验证方法调用次数 Mockito.verify(data, Mockito.times(1)).add("a"); Mockito.verify(data, Mockito.times(2)).add("b"); Mockito.verify(data, Mockito.never()).clear(); Mockito.verify(data, ...
  • 【vue】vue组件间方法调用

    千次阅读 2019-08-01 16:44:14
    父组件调用子组件的方法 在子组件中加上ref即可通过this.$refs.ref.method调用子组件的方法 父组件部分: <template> <div id="parent"> <v-child ref="vchild"></v-child> </div>...
  • IDEA查看方法调用

    万次阅读 2019-06-15 20:32:07
    一图胜千言: 如果想要查询到是否被第三方库调用,需将第三方库的源码下载即可。
  • 深入理解JVM方法调用的内部机制

    千次阅读 2017-08-18 15:11:42
    我们都知道,Java源代码需要编译成字节码文件,由JVM解释执行,而方法调用可以说是很常见的操作。Java不同于C++,Java中的实例方法默认是虚方法,因此父类引用调用被子类覆盖的方法时能体现多态性。下面我们来看看...
  • 静态方法调用非静态方法

    千次阅读 2017-12-27 15:47:49
    静态方法不能(直接)调用非静态变量,非静态方法可以引用静态变量。 静态方法不属于对象,是属于类的,不需要实例化; 而非静态变量是属于对象的,需要先实例化。 在一个类的静态成员中去访问其非静态成员,因为...
  • PHP --方法调用

    万次阅读 2018-07-24 16:31:21
    1.本类中普通方法调用 $fundList =$this-&gt;getOnsaleFundList(); 2.本类中静态方法调用 $fundList =self::getOnsaleFundList(); 2.调用其他类的普通方法  $objFix = new ApiAssemble();  $objFix-&...
  • idea 跳转到方法调用

    千次阅读 2019-12-25 10:40:43
    ctrl + B 跳转到方法调用的地方 alt + F7 会显示调用方法的地方 ctrl + alt + H 会显示所有调用方法的地方 根据个人习惯 随便挑一个吧。 我之前一直用 ctrl + alt + H 后来发现 ctrl + B 更便捷。 ...
  • vuex,module间的方法调用

    千次阅读 2019-08-10 18:45:06
    我们用vuex时通常会分功能创建多的module,单个module里的操作...现在我有两个module:user和 menu,要在user中调用menu的actions方法,操作如下: const user = { state: { permissions: [] }, mutations: { ...
  • JAVA方法调用过程(最详细的解释)

    千次阅读 2018-10-29 22:28:53
    弄清楚方法调用过程,对于我们学习java极为重要,下面是调用过程的详细描述: 1、编译器查看对象的声明类型和方法名。 编译器去寻找所有名字为f但参数类型不同的方法。例如可能存在方法f(int)和方法f(String),...
  • 什么是异步调用? 异步调用是相对于同步调用而言的,同步调用是指程序按预定顺序一步步执行,每一步必须等到上一步执行完后才能执行,异步调用则无需等待上一步程序执行完即可执行。 如何实现异步调用? 多线程,...
  • 因此,从上面的分析可以看出,methodB没有被AopProxy通知到,导致最终结果是:被Spring的AOP增强的类,在同一个类的内部方法调用时,其被调用方法上的增强通知将不起作用。    而这种结果,会造成什么影响呢:  1...
  • java 主类的main方法调用其他方法

    万次阅读 2018-09-24 19:15:15
    方法1:A a=new test().... 内部类对象通过外部类的实例对象调用其内部类构造方法产生,如下: 1 public class test{ 2 class A{ 3 void fA(){ 4 System.out.println("we are students"); 5 ...
  • vue中公共方法调用

    千次阅读 2019-06-03 14:25:26
    首先,在assets文件夹下,新建js文件夹,创建common.js export default { text(){ console.log("测试,测试!!!") } } (1)如果是全局(多页面)使用: 1.在main.js中引入 ...Vue....
  • Java静态方法调用非静态方法

    千次阅读 2018-09-19 20:23:42
    静态方法(static mehod)不能直接调用非静态方法(non-static method),可以通过一个对象的引用传入静态方法中,再去调用该对象的非静态方法。在主函数(static方法)中,经常创建某个类的实例,再利用其引用变量调用他...
  • Java应用的方法调用链分析插件

    千次阅读 2019-02-06 11:23:58
    很多新人进入一家新公司后,最头疼的就是如何快速了解公司的业务和项目架构。 因为文档很少,没有文档,或者是文档严重落伍, 根本没法看;...在那时,我就诞生了做一款可视化方法调用链分析插件的想法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,103,923
精华内容 2,441,569
关键字:

方法调用