简单模拟java动态动态代理机制的底层实现原理

在网上学习了马士兵老师的设计模式视屏,过程中也有认真的做相应的笔记。在次分享我的一些
成果,方便大家的进一步学习。

1、接口
public interface Moveable {
    void move();
}

2、被代理的对象
public class Tank implements Moveable {

@Override
    public void move() {
        
        System.out.println("Tank Moving...");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }
    
}

3、测试主类

public class Test {
    public static void main(String[] args) throws Exception{
        String rt = "\r\n";

//代理类的字符串代码
        String src =
                "public class TankTimeProxy implements Moveable {"+rt+
                "    Moveable t;"+rt+

"    public TankTimeProxy(Moveable t) {"+rt+
                "    this.t = t;"+rt+
                "    }"+rt+

"    @Override"+rt+
                "    public void move() {"+rt+
                "        long start = System.currentTimeMillis();"+rt+
                "        System.out.println(\"start time is \"+start);"+rt+
                "        t.move();"+rt+
                "        long end = System.currentTimeMillis();"+rt+
                "        System.out.println(\"end time is \"+end);"+rt+
                "        System.out.println(\"time is \"+(end - start));"+rt+
                "    }"+rt+
                "}";

//将字符串写入java文件********************************************************************************
        String fileName = System.getProperty("user.dir")+"/src/TankTimeProxy.java";//放置在(根目录+文件名)下
        File f = new File(fileName);
        FileWriter fw = new FileWriter(f);
     //写入内容
        fw.write(src);  
        fw.flush();
        fw.close();

//进行编译********************************************************************************************
        //首先获得编译器
        //compiler 为java编译器  即javac
        //获得编译器对象
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

//参数含义 (编译诊断,locale,charset)
        //管理动态生成的文件的StandardJavaFileManager对象
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null,null,null);//默认值

//根据参数获取多个java文件   返回java文件对象集
        Iterable units = fileManager.getJavaFileObjects(fileName);

//“编译任务”对象
        JavaCompiler.CompilationTask task = compiler.getTask(null,fileManager,null,null,null,units);
        task.call();//调用
        fileManager.close();

//************以上过程获得了java文件源码,编译java文件生成了相对应的class文件****************

//***************以下过程为将class文件加载至内存,生成新对象*****************************
        //Class.load() 是加载path路径的class文件
        //URLClassLoader是将硬盘中的class文件加载进入

//通过Url引入本地文件
        URL[] urls = new URL[]{new URL("file:/"+System.getProperty("user.dir")+"/out/production/proxy")}; //访问本地class文件,这里我用的是IntellijIDEA,默认   生成的class文件的目录在  /out/production/  下

//去指定路径寻找class文件
        URLClassLoader urlClassLoader = new URLClassLoader(urls);

Class c = urlClassLoader.loadClass("TankTimeProxy");

System.out.println(c);

//执行
        //c.newInstance(); 是调用空的构造方法

//获得构造方法
        //根据java虚拟机,每一个构造方法也相当于一个对象
        Constructor constructor = c.getConstructor(Moveable.class);

//产生新对象
        Moveable m = (Moveable) constructor.newInstance(new Tank());  //new Tank()为构造方法的参数   即被代理对象

m.move();

}
}

4、执行结果

时间: 2024-10-05 03:31:27

简单模拟java动态动态代理机制的底层实现原理的相关文章

那些年读过的书《Java并发编程的艺术》一、并发编程的挑战和并发机制的底层实现原理

一.并发编程的挑战 1.上下文切换 (1)上下文切换的问题 在处理器上提供了强大的并行性就使得程序的并发成为了可能.处理器通过给不同的线程分配不同的时间片以实现线程执行的自动调度和切换,实现了程序并行的假象. 在单线程中:线程保存串行的执行,线程间的上下文切换不会造成很大的性能开销. 而在多线程中:线程之间频繁的调度需要进行上下文切换以保存当前执行线程的上下文信息和加载将要执行线程的上下文信息,而上下文切换时需要底层处理器.操作系统.Java虚拟机提供支持的会消耗很多的性能开 销.如果频繁的进行

【java并发编程艺术学习】(三)第二章 java并发机制的底层实现原理 学习记录(一) volatile

章节介绍 这一章节主要学习java并发机制的底层实现原理.主要学习volatile.synchronized和原子操作的实现原理.Java中的大部分容器和框架都依赖于此. Java代码 ==经过编译==>Java字节码 ==通过类加载器==>JVM(jvm执行字节码)==转化为汇编指令==>CPU上执行. Java中使用的并发机制依赖于JVM的实现和CPU的指令. volatile初探 volatile是是轻量级的synchronized,它在多处理器开发中保证了共享变量的可见性.可见性

Java并发机制和底层实现原理

Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码转化为汇编指令在CPU上执行.Java中的并发机制依赖于JVM的实现和CPU的指令. Java语言规范第三版中对volatile的定义如下:Java编程语言允许线程访问共享变量,为了确保共享变量能被准确和一致的更新,线程应该确保通过排它锁单独获得这个变量.Java语言提供了volatile.若一个字段被声明为volatile,Java线程内存模型确保所有线程看到这个变量的值是一致的.volatile不会引起

LeetCode874 模拟行走机器人(简单模拟—Java之HashSet简单应用)

题目: 机器人在一个无限大小的网格上行走,从点 (0, 0) 处开始出发,面向北方.该机器人可以接收以下三种类型的命令: -2:向左转 90 度-1:向右转 90 度1 <= x <= 9:向前移动 x 个单位长度在网格上有一些格子被视为障碍物. 第 i 个障碍物位于网格点  (obstacles[i][0], obstacles[i][1]) 如果机器人试图走到障碍物上方,那么它将停留在障碍物的前一个网格方块上,但仍然可以继续该路线的其余部分. 返回从原点到机器人的最大欧式距离的平方. 示例

第2章 Java并发机制的底层实现原理

2.2 synchronized的实现原理与应用 当一个线程A执行字节码时遇到monitorenter指令时,会首先检查该指令关联的Object的对象头中的Mark Word状态. 2.2.1 如果是偏向锁 如果2bit标志位为01代表此时处于偏向锁状态. 如果2bit标志位为01且1bit的标志位为1,代表该对象此时处于偏向锁且锁被获取状态. 如果Mark Word的线程ID是当前线程的ID,代表该线程之前已经获得了该偏向锁,那么可以继续执行同步代码块 如果当前Mark Word存的线程的ID

[并发编程的艺术] 02-Java并发机制的底层实现原理

Java代码在编译后会变成Java字节码,字节码被类加载起加载到JVM里,JVM执行字节码,最终需要转化为汇编指令在CPU上执行, Java中所使用的并发机制依赖于JVM的实现和CPU的指令. 一.volatile的应用 在多处理器开发中保证共享变量的 "可见性", 可见性的意思是: 当一个线程修改一个共享变量时,另外一个线程能够读到这个修改的值.  如果 volatile变量修饰符使用恰当的话, 它比synchronized的使用和执行成本更低, 因为它不会引起线程上下文的切换和调度

第二章 并发机制的底层实现原理

Java代码在编译后 编程Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转化为汇编指令在CPU上执行,Java中所使用的并发机制依赖于JVM的实现和CPU的指令. volatiled的应用 volatile是轻量级的synchronized,它在多处理器开发中保证了共享变量的"可见性".可见性的意思是一个线程修改一个共享变量时,其他线程能读到这个修改的值. volatile的定义与实现原理 Java语言规范第3版中对volatile的定义如下:Java编程语

Java面试必问之Hashmap底层实现原理(JDK1.8)

1. 前言 上一篇从源码方面了解了JDK1.7中Hashmap的实现原理,可以看到其源码相对还是比较简单的.本篇笔者和大家一起学习下JDK1.8下Hashmap的实现.JDK1.8中对Hashmap做了以下改动. 默认初始化容量=0 引入红黑树,优化数据结构 将链表头插法改为尾插法,解决1.7中多线程循环链表的bug 优化hash算法 resize计算索引位置的算法改进 先插入后扩容 2. Hashmap中put()过程 笔者的源码是OpenJDK1.8的源码. JDK1.8中,Hashmap将

使用Go来模拟Java中的接口 实现类

针对项目中,相同的流程业务进行重构,使用Go来简单模拟Java中的接口,实现类的方式进行重构.分享一简单例子: package main //模拟java中的接口,实现类 import "fmt" // 声明一个接口, type workthread interface { do(name string) } // 传入的wt的子类不同,do方法执行的逻辑也不同 func Handle(wt workthread, name string) { fmt.Println("--