精华内容
下载资源
问答
  • idea中如何创建接口

    万次阅读 2019-11-12 09:44:33
    1、选择文件夹的包名,右键【New】------>【Java Class】,如下图: 2、在弹出的【Create New Class】窗口中,Name选择框中输入接口名称,Kind选择框中选择【Interface】类型。...3、创建好的接口如下图所示: ...

    1、选择文件夹的包名,右键【New】------>【Java Class】,如下图:
    在这里插入图片描述2、在弹出的【Create New Class】窗口中,Name选择框中输入接口名称,Kind选择框中选择【Interface】类型。如下图:
    在这里插入图片描述3、创建好的接口如下图所示:
    在这里插入图片描述

    展开全文
  • 主要介绍了Java中如何动态创建接口的实现方法的相关资料,需要的朋友可以参考下
  • IDEA如何快速创建接口的实现类

    千次阅读 2019-11-11 17:13:29
    IDEA快速创建接口的实现类只要分成两步 第一步:先创建一个接口 第二步:用鼠标点击接口的名字上,同时按住Alt+Enter键 如图所示,出现下面的窗口 选择 implement interface,会出现下面的窗口 需要改名字的就改...

    IDEA快速创建接口的实现类只要分成两步

    第一步:先创建一个接口

    第二步:用鼠标点击接口的名字上,同时按住Alt+Enter键

    如图所示,出现下面的窗口

    在这里插入图片描述
    选择 implement interface,会出现下面的窗口
    在这里插入图片描述
    需要改名字的就改名字,如果不需要就直接点击OK,会进入下面的窗口,我这里就直接点击OK
    在这里插入图片描述
    因为是实现接口,所以所有的方法都需要重写,所以选择全部方法,然后点击Ok,然后就大功告成
    在这里插入图片描述

    展开全文
  • Java中如何动态创建接口的实现 有很多应用场景,用到了接口动态实现,下面举几个典型的应用: 1、mybatis / jpa 等orm框架,可以在接口上加注解进行开发,不需要编写实现类,运行时动态产生实现。 2、dubbo等...

    Java中如何动态创建接口的实现

    有很多应用场景,用到了接口动态实现,下面举几个典型的应用:

    1、mybatis / jpa 等orm框架,可以在接口上加注解进行开发,不需要编写实现类,运行时动态产生实现。

    2、dubbo等分布式服务框架,消费者只需要引入接口就可以调用远程的实现,分析源代码,其实在消费端产生了接口的代理实现,再由代理调用远程接口。

    3、spring aop 这是最典型的动态代理了。

    创建接口的动态实现,有二种最常用的方式:JDK动态代理和CGLIB动态代理。

    代理模式是一种常用的设计模式,其目的就是为其他对象提供一个代理以控制对某个真实对象的访问。

    代理类负责为委托类预处理消息,过滤消息并转发消息,以及进行消息被委托类执行后的后续处理。

    通过代理层这一中间层,有效的控制对于真实委托类对象的直接访问,同时可以实现自定义的控制策略(spring的AOP机制),设计上获得更大的灵活性。

     

    下面用JDK动态代理加一点简单的代码来演示这个过程:

    1、接口

    package com.yhouse.modules.daos;
    
    public interface IUserDao {
        public String getUserName();
    }

    2、创建代理

    复制代码
    package com.yhouse.modules.daos;
    
    import java.lang.reflect.Proxy;
    /**
     * 创建代理
     * @author clonen.cheng
     *
     */
    public class Invoker {
        
       
        public Object getInstance(Class<?> cls){        
            MethodProxy invocationHandler = new MethodProxy();        
            Object newProxyInstance = Proxy.newProxyInstance(  
                    cls.getClassLoader(),  
                    new Class[] { cls }, 
                    invocationHandler); 
            return (Object)newProxyInstance;
        }
    }
    复制代码

    3、运行时调用接口的方法时的实现(这一过程也称为接口的方法实现)

    复制代码
    package com.yhouse.modules.daos;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class MethodProxy implements InvocationHandler {
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)  throws Throwable {        
            //如果传进来是一个已实现的具体类(本次演示略过此逻辑)
            if (Object.class.equals(method.getDeclaringClass())) {  
                try {  
                    return method.invoke(this, args);  
                } catch (Throwable t) {  
                    t.printStackTrace();  
                }  
            //如果传进来的是一个接口(核心)
            } else {  
                return run(method, args);  
            }  
            return null;
        }
        
        /**
         * 实现接口的核心方法 
         * @param method
         * @param args
         * @return
         */
        public Object run(Method method,Object[] args){  
            //TODO         
            //如远程http调用
            //如远程方法调用(rmi)
            //....
           return "method call success!";
        }  
    
    }
    复制代码

    4、测试

    复制代码
    package com.yhouse.modules.daos;
    
    public class ProxyTest {
    
        
        public static void main(String[] args) {
            IUserDao invoker=(IUserDao)new Invoker().getInstance(IUserDao.class);
            System.out.println(invoker.getUserName());
        }
    
    }
    复制代码

    在这段测试代码中,并没有接口的任何实现,大家猜猜会是什么结果?
    控制台打印:

    说明接口在调用时,把实现委托给了代理,最后具体要做的就是这个代理里面的处理:

    在上面这段代码当中,可以看出,拿到了接口的method以及args,那么就可以做很多的事情,如根据方法名或者配合方法上面的注解来实现比较丰富的功能。

     

    一个简单的例子只是用来说明这个原理,下面再举一个远程接口动态调用的例子来加深理解。

    1、创建代理类和目标类需要实现共同的接口Service

    复制代码
    package com.markliu.remote.service;
    /**
     * Service接口。代理类和被代理类抖需要实现该接口
     */
    public interface Service {
        public String getService(String name, int number);
    }
    复制代码

     

    2、服务器端创建RemoteService类,实现了Service 接口。

    复制代码
    package com.markliu.remote.serviceimpl;
    import com.markliu.remote.service.Service;
    /**
     * 服务器端目标业务类,被代理对象
     */
    public class RemoteService implements Service {
        @Override
        public String getService(String name, int number) {
            return name + ":" + number;
        }
    }
    复制代码

     

    3、创建封装客户端请求和返回结果信息的Call类

    为了便于按照面向对象的方式来处理客户端与服务器端的通信,可以把它们发送的信息用 Call 类来表示。一个 Call 对象表示客户端发起的一个远程调用,它包括调用的类名或接口名、方法名、方法参数类型、方法参数值和方法执行结果。

    复制代码
    package com.markliu.local.bean;
    import java.io.Serializable;
    /**
     * 请求的javabean
     */
    public class Call implements Serializable{
        private static final long serialVersionUID = 5386052199960133937L;
        private String className; // 调用的类名或接口名
        private String methodName; // 调用的方法名
        private Class<?>[] paramTypes; // 方法参数类型
        private Object[] params; // 调用方法时传入的参数值
        /**
         * 表示方法的执行结果 如果方法正常执行,则 result 为方法返回值,
         * 如果方法抛出异常,那么 result 为该异常。
         */
        private Object result;
        public Call() {}
        public Call(String className, String methodName, Class<?>[] paramTypes, Object[] params) {
            this.className = className;
            this.methodName = methodName;
            this.paramTypes = paramTypes;
            this.params = params;
        }
        // 省略了get和set方法
    }
    复制代码

     

    4、创建动态代理模式中实际的业务处理类,实现了InvocationHandler 接口

    复制代码
    package com.markliu.local.service;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import com.markliu.local.bean.Call;
    
    public class ServiceInvocationHandler implements InvocationHandler {
    
        private Class<?> classType;
        private String host;
        private Integer port;
    
        public Class<?> getClassType() {
            return classType;
        }
        public ServiceInvocationHandler(Class<?> classType, String host, Integer port) {
            this.classType = classType;
            this.host = host;
            this.port = port;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
            // 封装请求信息
            Call call = new Call(classType.getName(), method.getName(), method.getParameterTypes(), args);
            // 创建链接
            Connector connector = new Connector();
            connector.connect(host, port);
            // 发送请求
            connector.sendCall(call);
            // 获取封装远程方法调用结果的对象
            connector.close();
            Object returnResult = call.getResult();
            return returnResult;
        }
    }
    复制代码

     

    5、创建获取代理类的工厂RemoteServiceProxyFactory

    复制代码
    package com.markliu.local.service;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    /**
     * 动态创建RemoteService代理类的工厂
     */
    public class RemoteServiceProxyFactory {
    
        public static Object getRemoteServiceProxy(InvocationHandler h) {
            Class<?> classType = ((ServiceInvocationHandler) h).getClassType();
            // 获取动态代理类
            Object proxy = Proxy.newProxyInstance(classType.getClassLoader(), 
                    new Class[]{classType}, h);
            return proxy;
        }
    }
    复制代码

     

    6、创建底层Socket通信的Connector类,负责创建拦截、发送和接受Call对象

    复制代码
    package com.markliu.local.service;
    // 省略import 
    
    /**
     * 负责创建链接
     */
    public class Connector {
        private Socket linksocket;
        private InputStream in;
        private ObjectInputStream objIn;
        private OutputStream out;
        private ObjectOutputStream objOut;
    
        public Connector(){}
        /**
         * 创建链接
         */
        public void connect(String host, Integer port) throws UnknownHostException, IOException {
            linksocket = new Socket(host, port);
            in = linksocket.getInputStream();
            out = linksocket.getOutputStream();
            objOut = new ObjectOutputStream(out);
            objIn = new ObjectInputStream(in);
        }
        /**
         * 发送请求call对象
         */
        public void sendCall(Call call) throws IOException {
            objOut.writeObject(call);
        }
        /**
         * 获取请求对象
         */
        public Call receive() throws ClassNotFoundException, IOException {
            return (Call) objIn.readObject();
        }
        /**
         * 简单处理关闭链接
         */
        public void close() {
            try {
                linksocket.close();
                objIn.close();
                objOut.close();
                in.close();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    复制代码

     

    7、创建远程服务器

    复制代码
    package com.markliu.remote.main;
    // 省略import 
    
    public class RemoteServer {
    
        private Service remoteService;
        public RemoteServer() {
            remoteService  = new RemoteService();
        }
        public static void main(String[] args) throws Exception {
            RemoteServer server = new RemoteServer();
            System.out.println("远程服务器启动......DONE!");
            server.service();
        }
    
        public void service() throws Exception {
            @SuppressWarnings("resource")
            ServerSocket serverSocket = new ServerSocket(8001);
            while (true) {
                    Socket socket = serverSocket.accept();
                    InputStream in = socket.getInputStream();
                    ObjectInputStream objIn = new ObjectInputStream(in);
                    OutputStream out = socket.getOutputStream();
                    ObjectOutputStream objOut = new ObjectOutputStream(out);
                    // 对象输入流读取请求的call对象
                    Call call = (Call) objIn.readObject();
                    System.out.println("客户端发送的请求对象:" + call);
                    call = getCallResult(call);
                    // 发送处理的结果回客户端
                    objOut.writeObject(call);
                    objIn.close();
                    in.close();
                    objOut.close();
                    out.close();
                    socket.close();
            }
        }
    
        /**
         * 通过反射机制调用call中指定的类的方法,并将返回结果设置到原call对象中
         */
        private Call getCallResult(Call call) throws Exception {
            String className = call.getClassName();
            String methodName = call.getMethodName();
            Object[] params = call.getParams();
            Class<?>[] paramsTypes = call.getParamTypes();
    
            Class<?> classType = Class.forName(className);
            // 获取所要调用的方法
            Method method = classType.getMethod(methodName, paramsTypes);
            Object result = method.invoke(remoteService, params);
            call.setResult(result);
            return call;
        }
    }
    复制代码

     

    8、创建本地客户端

    复制代码
    package com.markliu.local.main;
    import java.lang.reflect.InvocationHandler;
    import com.markliu.local.service.RemoteServiceProxyFactory;
    import com.markliu.local.service.ServiceInvocationHandler;
    import com.markliu.remote.service.Service;
    
    public class LocalClient {
        public static void main(String[] args) {
            String host = "127.0.0.1";
            Integer port = 8001;
            Class<?> classType = com.markliu.remote.service.Service.class;
            InvocationHandler h = new ServiceInvocationHandler(classType, host, port);
            Service serviceProxy = (Service) RemoteServiceProxyFactory.getRemoteServiceProxy(h);
            String result = serviceProxy.getService("SunnyMarkLiu", 22);
            System.out.println("调用远程方法getService的结果:" + result);
        }
    }
    复制代码

     控制台打印结果:

    这个过程可以简单的归纳为:本地接口调用(客户端)--->本地接口代理实现(客户端)---->远程实现(服务器端)

    展开全文
  • 创建线程的最简单的方法就是创建一个实现Runnable 接口的类。Runnable抽象了一个执行代码单元。你可以通过实现Runnable接口的方法创建每一个对象的线程。为实现Runnable 接口,一个类仅需实现一个run()的简单方法,...

    大多数情况,通过实例化一个Thread对象来创建一个线程。Java定义了两种方式:
    · 实现Runnable 接口。
    · 可以继承Thread类。

    下面的先介绍了第一种方式: 实现Runnable接口

    创建线程的最简单的方法就是创建一个实现Runnable 接口的类。Runnable抽象了一个执行代码单元。你可以通过实现Runnable接口的方法创建每一个对象的线程。为实现Runnable 接口,一个类仅需实现一个run()的简单方法,该方法声明如下:

    public void run( ) 
    

    在run()中可以定义代码来构建新的线程。理解下面内容是至关重要的:run()方法能够像主线程那样调用其他方法,引用其他类,声明变量。仅有的不同是run()在程序中确立另一个并发的线程执行入口。当run()返回时,该线程结束。

    在你已经创建了实现Runnable接口的类以后,你要在类内部实例化一个Thread类的对象。Thread 类定义了好几种构造函数。我们会用到的如下:

    Thread(Runnable threadOb, String threadName) 
    

    该构造函数中,threadOb是一个实现Runnable接口类的实例。这定义了线程执行的起点。新线程的名称由threadName定义。建立新的线程后,它并不运行直到调用了它的start()方法,该方法在Thread 类中定义。本质上,start() 执行的是一个对run()的调用。

    Start()方法声明如下:

    // Create a second thread. 
    class NewThread implements Runnable { 
     Thread t; 
     NewThread() { 
     // Create a new, second thread 
     t = new Thread(this, "Demo Thread"); 
     System.out.println("Child thread: " + t); 
     t.start(); // Start the thread 
     } 
     // This is the entry point for the second thread. 
     public void run() { 
     try { 
     for(int i = 5; i > 0; i--) { 
     System.out.println("Child Thread: " + i); 
     Thread.sleep(500); 
     } 
     } catch (InterruptedException e) { 
     System.out.println("Child interrupted."); 
     } 
     System.out.println("Exiting child thread."); 
     } 
    } 
    class ThreadDemo { 
     public static void main(String args[]) { 
     new NewThread(); // create a new thread 
     try { 
     for(int i = 5; i > 0; i--) { 
     System.out.println("Main Thread: " + i); 
     Thread.sleep(1000); 
     } 
     } catch (InterruptedException e) { 
     System.out.println("Main thread interrupted."); 
     } 
     System.out.println("Main thread exiting."); 
     } 
    }
    

    在NewThread 构造函数中,新的Thread对象由下面的语句创建:

    t = new Thread(this, "Demo Thread"); 
    

    通过前面的语句this 表明在this对象中你想要新的线程调用run()方法。然后,start() 被调用,以run()方法为开始启动了线程的执行。这使子线程for 循环开始执行。

    调用start()之后,NewThread 的构造函数返回到main()。当主线程被恢复,它到达for 循环。两个线程继续运行,共享CPU,直到它们的循环结束。该程序的输出如下:

    Child thread: Thread[Demo Thread,5,main] 
    Main Thread: 5 
    Child Thread: 5 
    Child Thread: 4 
    Main Thread: 4 
    Child Thread: 3 
    Child Thread: 2 
    Main Thread: 3 
    Child Thread: 1 
    Exiting child thread. 
    Main Thread: 2 
    Main Thread: 1 
    Main thread exiting. 
    

    如前面提到的,在多线程程序中,通常主线程必须是结束运行的最后一个线程。实际上,一些老的JVM,如果主线程先于子线程结束,Java的运行时间系统就可能“挂起”。

    前述程序保证了主线程最后结束,因为主线程沉睡周期1000毫秒,而子线程仅为500毫秒。这就使子线程在主线程结束之前先结束。简而言之,你将看到等待线程结束的更好途径。

    展开全文
  • 前后端分离开发过程中,为了避免前端开发人员等待后端开发完相应API,前端人员可以使用MockAPI进行开发。这种方法不仅可以减少不必要的等待时间,使用MockAPI后还...一些API管理工具可通过可视化界面创建MockAPI(如Eol
  • 主要介绍了Python 如何创建一个简单的REST接口,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 有很多应用场景,用到了接口动态实现,下面举几个典型的应用: 1、mybatis / jpa 等orm框架,可以在接口上加注解进行开发,不需要编写实现类,运行时动态产生实现。 ...创建接口的动态实现,有...
  • 小弟也是被逼无奈,自己研究网络...在Windows下自己创建接口: 1、进入nginx下载地址http://nginx.org/en/download.html 2、下载当前页面的nginx-1.12.2 3、解压到当前文件夹 4、点击exe文件运行 5、打开浏览器
  • 1、创建一个测试环境2、创建接口信息3、添加接口的入参规则4、增加报文和场景5、场景测试1、创建一个测试环境 支持http/https/socket/websocket/dubbo接口协议。 2、创建接口信息 点击接口自动化->接口管理->...
  • 接口的实现类创建对象时,都要用多态吗?还是有什么其他的情况?因情而异?
  • 有时候需要在一块物理网卡上配置多个IP地址,这时就可以用到本文介绍的"子接口",这篇文章使用CentOS演示如何在一块物理网卡上创建多个子接口(在一些参考资料中,“子接口"也被称作"IP别名”)。有关Linux网络配置...
  • 一个接口对应一个权限,可以把一堆接口权限,都分给一个新创建的groups,然后,需要这些权限的users,直接加入groups,就可以轻松实现,接口粒度的权限管理。 全程代码不多,但是需要对源码有一定程度的理解,其他...
  • IFeatureWorkspace接口是在工作空间中创建对象主要使用的接口。方法: AllProperties Methods Description CreateFeatureClass Creates a new standalone feature class under the ...
  • 【摘要】PHP即“超文本预...下面是php如何实现接口,让我们一起来看看php如何实现接口的具体内容吧!php如何实现接口php实现接口的方法:首先创建一个后缀为php名称为interface的文件,并在文件中加入php标记;然后...
  • 创建一个接口(定义一个方法) A类继承接口,实现其方法,并新增虚方法 B类继承A类,实现接口,并重写A类的方法 实现代码: using System; using System.Collections.Generic; using System.Linq; using System...
  • 在index里引入数据库并创建接口 router.get('/register',function (req,res,next) { const reqData = req.query; const sqlStr = select * from user where email ='${reqData.email}'; connection.query...
  • 1.如何通过实现Runnable接口创建线程方法? 步骤: (1).定义一个类,实现Runnable接口,实现run()方法 (2).创建实现类的实例, (3).创建Thread类的一个实例,将上一步中实现类的实例作为参数传入 (4).调用start()...
  • 想开发一个模块供其他人使用,想问下流程,是不是我先写好一些方法函数,然后封成.a 文件,然后将.a文件提供给别人就可以了?还需要写好一个.h文件给他么?谢谢。还需要别的什么文件给他么??
  • 多线程的创建常用继承Thtead类与实现Runnable接口,下面就来展现如何创建接口 一、继承Thread 代码 /* *继承Thread */ public class Text { public static void main(String[] args) { //创建线程 MyThread m =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,140
精华内容 4,856
关键字:

如何创建接口