反射、jdk动态代理、rpc

最新推荐文章于 2023-05-11 10:26:42 发布
最新推荐文章于 2023-05-11 10:26:42 发布
阅读量212 收藏
点赞数
文章标签： rpc java 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42242113/article/details/118762378
版权

反射

反射是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性和方法。

关于反射的几个类

Field类：代表的是反射中所获取到的对象属性

Constructor类：代表反射中获取到的类的构造函数

Method类：代表反射中获取到的类的方法

Class类：类对象

反射的用法示例

student类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private String name;
    private int age;
}

反射测试类

public class ReflectionTest {
    @Test
    public void test1() throws Exception{
        Student c = new Student("张三", 22);
        final Class<?> clazz = Class.forName("com.Student");
        //获取类的public属性如果属性不为public则不能够获取
        final Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
        System.out.println("----------------------所有属性----------------------");
        //获取类的所有属性包括private修饰的属性
        final Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getName());
        }
        System.out.println("----------------------所有方法----------------------");
        //获取类的所有方法包括private修饰的方法
        final Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName());
        }
        System.out.println("----------------------获取对象属性具体的值----------------------");
        final Field age = clazz.getDeclaredField("age");
        //当将这个属性设为true时才能够对对象的属性进行操作
        age.setAccessible(true);
        System.out.println(c);
        age.set(c,1111);
        System.out.println(c);
        System.out.println(age.get(c));
        //通过构造方法构造对象
        final Object o = clazz.newInstance();
        System.out.println(o);
        //获取构造方法
        final Constructor<?>[] constructors = clazz.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor.toString());
        }
    }
}

jdk动态代理

代理模式

head first设计模式中对代理模式的定义：代理模式为另一个对象提供一个替身或占位符以控制对这个对象的访问。

静态代理

//租房接口
public interface RentAble {

    void rent();
    
}

//房东类
public class Landlord implements RentAble{
    @Override
    public void rent() {
        System.out.println("出租房屋！！！");
    }
}

//中介类
public class Intermediary implements RentAble{

    private RentAble rentAble;

    public Intermediary(RentAble rentAble) {
        this.rentAble = rentAble;
    }

    @Override
    public void rent() {
        System.out.println("带人看房！！！");
        rentAble.rent();
    }
}

在这个例子中我们调用接口时只需调用中介类的租房方法就可以完成租房了，这也就是静态代理。

动态代理

动态代理其实就是将上面例子中的中介类在程序运行时由jvm根据反射等机制动态生成即可，代理类和委托类的关系是在程序运行时才确定。

public static void main(String[] args) {
    RentAble landlord=new Landlord();
    RentAble rentAble = (RentAble) Proxy.newProxyInstance(Landlord.class.getClassLoader(), new Class[]{RentAble.class}, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("带人看房！！！");
            Object invoke = method.invoke(landlord,args);
            return invoke;
        }
    });
    rentAble.rent();
}

RPC

RPC（Remote Procedure Call）远程过程调用协议

rpc其实也是基于动态代理实现的，我们可以通过网络将我们需要调用的接口、方法名、方法参数等信息发送到另一台计算机上，另一台计算机根据我们发送的信息，来调用他本地的方法然后将返回参数再传给我们。

客户端需要的代码

客户端获取代理对象

public class Stub {

    /**
     * 获取代理对象
     * @param clazz 需要获取的接口
     * @return
     */
    public static Object getService(Class clazz) {
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //连接远程服务器
                Socket socket = new Socket("127.0.0.1", 4396);
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
                //将接口名称、方法名、方法参数类型、方法参数列表发送到远程
                objectOutputStream.writeUTF(clazz.getName());
                objectOutputStream.writeUTF(method.getName());
                objectOutputStream.writeObject(method.getParameterTypes());
                objectOutputStream.writeObject(args);

                //接收返回值
                ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
                Object o = objectInputStream.readObject();


                //关闭流
                objectOutputStream.close();
                socket.close();
                return o;
            }
        };
        return Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, h);
    }
}

客户端需要调用的接口

public interface Service {

    /**
     * 获取学生对象
     * @param id 学生id
     * @return
     */
    Student queryStudentById(long id);

}

实体类

public class Student implements Serializable {

    private static final long serialVersionUID = 1L;

    //学生id
    private long id;

    //学生年龄
    private int age;

    //学生姓名
    private String name;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

客户端主函数

public class Client {
    public static void main(String[] args) {
        Service service = (Service) Stub.getService(Service.class);
        Student student = service.queryStudentById(123);
        System.out.println(JSON.toJSONString(student));
    }
}

服务端需要的代码

//服务端
public class Server {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(4396);
        while (true) {

            handle(serverSocket.accept());

        }
    }

    /**
     * 处理请求方法
     * @param socket 连接socket
     * @throws Exception
     */
    public static void handle(Socket socket) throws Exception {
        ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
        //获取参数
        String clazzName = objectInputStream.readUTF();
        String methodName = objectInputStream.readUTF();
        Class[] paramTypes = (Class[]) objectInputStream.readObject();
        Object[] args = (Object[]) objectInputStream.readObject();

        //通过spi获取service实现类
        Class<?> aClass = Class.forName(clazzName);
        ServiceLoader<?> serviceLoader = ServiceLoader.load(aClass);
        Object studentService = null;
        for (Object service : serviceLoader) {
            studentService = service;
        }
        if (studentService == null) {
            System.out.println("服务未找到");
            return;
        }

        //获取需要调用的方法
        Method method = studentService.getClass().getMethod(methodName, paramTypes);
        Object invoke = method.invoke(studentService, args);

        //发送返回值
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
        objectOutputStream.writeObject(invoke);

        //关闭流
        objectInputStream.close();
        objectOutputStream.close();
    }
}

被调用的接口

接口

public interface Service {

    /**
     * 获取学生对象
     * @param id 学生id
     * @return
     */
    Student queryStudentById(long id);

}

接口实现

public class StudentService implements Service{

    @Override
    public Student queryStudentById(long id) {
        Student student = new Student();
        student.setId(4396);
        student.setAge(27);
        student.setName("张三");
        return student;
    }
}

实体类

public class Student implements Serializable {

    private static final long serialVersionUID = 1L;

    //学生id
    private long id;

    //学生年龄
    private int age;

    //学生姓名
    private String name;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

SPI配置文件

image-20220114143313231

com.example.demo.rpc.StudentService
HazeOnHillside
关注
JDK动态代理在RPC框架中的实际应用
DevScribe的博客
09-28 95
通过使用JDK提供的Proxy类和InvocationHandler接口，我们可以在运行时动态生成代理对象，并在代理对象的方法调用前后加入自定义的逻辑。在RPC框架中，JDK动态代理是一种重要的技术，它可以简化远程调用的代码编写，并提供灵活的扩展性。服务代理生成：服务消费者通过RPC框架获取到服务接口的代理对象，代理对象负责将方法调用转发给远程的服务提供者。通过使用JDK动态代理，我们可以在RPC框架中实现透明的远程调用，并实现一些额外的逻辑，如负载均衡、容错处理等。二、JDK动态代理简介。
Java常见应用-反射,RPC
qq_43502858的博客
06-22 381
Java常见应用-反射,RPC 一.反射 简介：反射机制是在【运行状态】中： 对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能够调用它的任意一个方法和属性。 反射提供的功能： 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判断任意一个类所具有的成员变量和方法； 在运行时调用任意一个对象的方法； 生成动态代理。 三种获取反射入口的方法 pa...
反射与动态代理的应用（一）：在RPC中的使用
夜行观星
10-26 3023
在上一篇文章中，讲解了反射 与动态代理基本概念，没有看过点击此传送门。 接下来看看，动态代理在RPC中是如何使用的。在讲解过程中会去除掉一些无关的代码，如果读者相应看全部的代码，可以去开源项目的仓库中下载相关源码，进一步的专研，以下也会给出链接。实例1.第一个实例取自黄勇的轻量级分布式 RPC 框架 ，由于实现中通信框架使用了Netty，所以在分析中会有部分Netty代码的信息，不过不用担心，即使
JDK动态代理在RPC框架中的应用
weixin_33672400的博客
05-30 271
RPC框架中一般都有3个角色：服务提供者、服务消费者和注册中心。服务提供者将服务注册到注册中心，服务消费者从注册中心拉取服务的地址，并根据服务地址向服务提供者发起RPC调用。动态代理在这个RPC调用的过程中有什么作用？对于服务消费者，一般只会依赖服务接口，而服务的具体实现是在服务提供者这一端的，服务消费者和服务提供者分别部署在不同的机器上，服务消费者调用接口中的方法时怎么能够得到结果呢？JDK的动...
java之反射（RPC中应用demo）
BDLng的博客
12-04 635
在RPC和动态代理中  经常用到反射，反射就相当于解剖，根据一些jdk提供的方法，类里面的方法，成员变量，构造函数，继承的接口或者类  都可以拿到。 反射方式总结： 1、Class c1 = Class.forName(“Employee”) 2、Class c2 = Employee.class 3、Employee e = new Employee()    Class c3 = e
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
最新发布
06-21
JDK 动态代理是 Java 中的一种动态代理方式，使用 Java 反射机制来生成代理类。JDK 动态代理的优点是可以在运行时生成代理类，无需编写代理类代码。 四、 CGLIB 动态代理 CGLIB 动态代理是另外一种动态代理方式，...
（Java面试）JDK 动态代理和 CGLIB 动态代理的区别是什么？
qq_46158352的博客
05-11 365
JDK动态代理和CGLIB动态代理都是Java中常用的实现动态代理的方式。它们各有优缺点，适用于不同的场景。如果被代理的类已经实现了接口，那么我们可以使用JDK动态代理；如果被代理的类没有实现接口，那么我们可以使用CGLIB动态代理。在实际开发中，我们需要根据具体的场景来选择最合适的动态代理实现方式。动态代理的应用场景非常广泛，比如AOP、RPC框架等。在AOP中，我们可以通过动态代理来实现对方法的拦截和增强，从而实现面向切面编程；在RPC框架中，我们可以通过动态代理来实现客户端和服务端之间的通信。
MyRPCDemo netty+jdk动态代理+反射+序列化，反序列化手写rpc框架
qq445829096的博客
05-04 233
RPC RPC（remote procedure call）远程过程调用 RPC是为了在分布式应用中，两台主机的Java进程进行通信，当A主机调用B主机的方法时，过程简洁，就像是调用自己进程里的方法一样。 RPC框架的职责就是，封装好底层调用的细节，客户端只要调用方法，就能够获取服务提供者的响应，方便开发者编写代码。 RPC底层使用的是TCP协议，服务端和客户端和点对点通信。 RPC与http 以我写的rpcdemo为例，我在rpcserver端LogonService写了一个checkLogon方法
反射和动态代理（JDK Proxy和Cglib）
shayukaifa的博客
12-31 325
反射和动态代理放有一定的相关性，但单纯的说动态代理是由反射机制实现的，其实是不够全面不准确的，动态代理是一种功能行为，而它的实现方法有很多。要怎么理解以上这句话，请看下文。 一、反射 反射机制是 Java 语言提供的一种基础功能，赋予程序在运行时自省（introspect，官方用语）的能力。通过反射我们可以直接操作类或者对象，比如获取某个对象的类定义，获取类声明的属性和方法，调用方法或者构造对象，甚至可以运行时修改类定义。 1、获取类（Class）对象 获取类对象有三种方法： 通过forName() .
一文理解Java动态代理和Cglib代理，以及和RPC的区别
SU苏打水的博客
05-23 548
本来是想学习PRC（远程过程调用），其中提到了动态代理技术，结果兜兜转转就到了java动态代理，特意去学习了一下，为了防止以后忘记，特此记录，以下都是我学习之后的个人见解，如果有不对的地方，欢迎大家指正！
JavaRpc:JAVA RPC实现，基于动态代理与反射
05-15
RPC java实例 文章包括以下两个部分： RPC基本原理 RPC Java实例讲解 废话不多说，现在讲讲RPC到底是什么 RPC基本原理 RPC全程Remote Procedure Call Protocol，即远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。在服务器端，进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。 看到这可能比较晕，没关系，我的理解是这样的，就是服务器上正在运行一个服务app，app有一个函数或接口plus(int
自定义基于反射 Scoket jdk动态代理 RPC框架
qq_28422443的博客
05-10 320
使用工具IDEA， Myeclipse 编写服务端接口 HelloService 服务端实现类 编写服务端的调用类 package whu; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.lang.reflect.Method; import java.net.ServerSo...
Java实现一个简单的RPC框架(七) 反射机制调用类函数
赞美月亮的专栏
12-24 1185
ServiceRegister.java import java.util.HashMap; import java.lang.reflect.*; /** * 通过register（）去注册服务，通过get_service（）去获取服务名对应的function * @author xchen * */ public class ServiceRegister { int arg1
动态代理-RPC实现核心原理
JavaEdge全是干货的技术号
02-04 1480
因为代理类是在运行中生成的，那么代理框架生成代理类的速度、生成代理类的字节码大小等等，都会影响到其性能——生成的字节码越小，运行所占资源就越小。还有就是我们生成的代理类，是用于接口方法请求拦截的，所以每次调用接口方法的时候，都会执行生成的代理类，这时生成的代理类的执行效率就需要很高效。最后一个是从我们的使用角度出发的，我们肯定希望选择一个使用起来很方便的代理类框架，比如我们可以考虑：API设计是否好理解、社区活跃度、还有就是依赖复杂度等。
java 从零开始手写 RPC (06) reflect 反射实现通用调用之客户端
10-11 190
通用调用 java 从零开始手写 RPC (01) 基于 socket 实现 java 从零开始手写 RPC (02)-netty4 实现客户端和服务端 java 从零开始手写 RPC (03) 如何实现客户端调用服务端？ java 从零开始手写 RPC (04) -序列化 上一篇我们介绍了，如何实现基于反射的通用服务端。 这一节我们来一起学习下如何实现通用客户端。 因为内容较多，所以拆分为 2 个部分。 基本思路 所有的方法调用，基于反射进行相关处理实现。 核心类 为了便于拓展，我们把核心类调整如下： p
利用反射手写RPC简单框架
qq_36845328的博客
11-15 294
RPC框架入门通过反射手写RPC简单框架RPC简介RPC请求过程DEMO实例结构RPC框架实现测试类运行 通过反射手写RPC简单框架 调用本地的接口方法，远端执行接口的具体实现并返回结果。 RPC简介 RPC（Remote Procedure Call Protocol）远程调用：简单来说就是调用远程的服务就像调用本地服务一样，它允许运行于一台计算机的程序调用另一台计算机的子程序，同时将网络的通信细节隐藏，用户无须额外地为这个交互动作进行编程。其中涉及的知识有序列化和反序列化、动态代理、网络传输、动态加载、
代理 + 通信 + 反射实现rpc调用
Hanyinh的博客
09-21 414
以下仅自己作为笔记参考： 环境：有两个项目，A项目暴露接口供其他项目使用，其内部进行相关逻辑实现，B项目调用A项目暴露出来的接口，进行rpc调用。 步骤： 首先A项目要提供相关的接口、入参、出参、等等需要提供的jar 然后B项目需要去依赖A项目提供的jar，这样才可以使用 接着B项目使用动态代理来进行rpc调用 B项目中的代理实现了和A项目的通信(Socket)，并进行数据传输，数据有类名、方法名，参数，参数类型等等等等 A项目发布服务之后就等待客户端发送请求，可以使用线程池达到异步处理 A项目服务端接收
RPC中用到的 *动态代理，反射机制，NIO
silence的博客
09-17 2316
今天在学习RPC协议时，用到了动态代理和反射机制 所以，我们先来看看动态机制：在java的动态代理中，有两个重要的类或接口，一个是InvocationHandler（Interface）,另一个则是Proxy(Class0,这一个类和接口。首先我们来看看java的api对这两个类的描述 ： InvocationHandler: InvocationHandler is the interf
【专栏】RPC系列（理论）-动态代理
scwMason的博客
08-14 1082
《RPC实战系列》，今天我们讲一讲RPC中的对你透明的“”动态代理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值