注解和反射

最新推荐文章于 2022-05-21 23:13:46 发布
最新推荐文章于 2022-05-21 23:13:46 发布
阅读量140 收藏
点赞数 1
原文链接：https://blog.csdn.net/sinat_38259539/article/details/71799078 https://blog.csdn.net/lylwo317/article/details/52163304
版权

反射

原文

什么是反射

Java 反射机制是指在运行状态中，对于任意一个类，能够得到它的所有信息（成员变量、方法、构造方法、包等等）；对于任意一个对象，都能够调用它的任意一个属性和方法。

反射就是将 Java 类中的各种成分映射成一个个的 Java 对象

反射的使用

反射是框架设计的灵魂

反射使用的前提：得到代表字节码的 Class，Class 类用于表示 .class 文件（字节码）

Class 对象的由来是将 class 文件读入内存，并为之创建一个 Class 对象

在这里插入图片描述

Class类

在这里插入图片描述

Class 类的实例表示正在运行的 Java 应用程序中的类和接口：也就是 JVM 中有N多的实例每个类都有该 Class 对象（包括基本数据类型）。

Class 类没有公共构造方法：Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM 已经帮我们创建好了。

一个类在内存中只有一个 Class 对象

使用

这里使用 Student 类做演示。

获取 Class 对象一共有三种方式：

  • Object 类的 getClass()方法
  • 任何数据类型（包括基本数据类型）都有一个“静态”的 class 属性
  • 通过 Class 类的静态方法：forName(String className) （常用）

三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。

public class Test01 {

    @Test
    public void test01() {
        Student student = new Student();
        Class<? extends Student> studentClass = student.getClass();
        System.out.println(studentClass);

        Class<Student> studentClass1 = Student.class;
        System.out.println(studentClass1 == studentClass);

        try {
            Class<?> studentClass2 = Class.forName("com.example.demo.reflex.Student");
            System.out.println(studentClass1 == studentClass);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

/*
控制台输出：
class com.example.demo.reflex.Student
true
true
*/
通过反射获取构造方法并使用
返回值方法名说明
Constructor[]getConstructors()获取所有公有构造方法
ConstructorgetConstructor(Class<?>… parameterTypes)在公有构造方法中根据参数类型获取
Constructor[]getDeclaredConstructors()获取所有构造方法
ConstructorgetDeclaredConstructor(Class<?>… parameterTypes)在所有构造方法中根据参数类型获取
ObjectConstructor.newInstance()调用构造方法
student类
public class Student {

    //---------------构造方法-------------------
    //（默认的构造方法）
    Student(String str){
        System.out.println("(默认)的构造方法 s = " + str);
    }

    //无参构造方法
    public Student(){
        System.out.println("调用了公有、无参构造方法执行了。。。");
    }

    //有一个参数的构造方法
    public Student(char name){
        System.out.println("姓名：" + name);
    }

    //有多个参数的构造方法
    public Student(String name ,int age){
        System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
    }

    //受保护的构造方法
    protected Student(boolean n){
        System.out.println("受保护的构造方法 n = " + n);
    }

    //私有构造方法
    private Student(int age){
        System.out.println("私有的构造方法   年龄："+ age);
    }

}
测试类
public class Test01 {
    @Test
    public void test02() throws Exception {
        //1.加载Class对象
        Class clazz = Class.forName("com.example.demo.reflex.Student");

        //2.获取所有公有构造方法
        System.out.println("**********************所有公有构造方法*********************************");
        Constructor[] conArray = clazz.getConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }

        System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
        conArray = clazz.getDeclaredConstructors();
        for(Constructor c : conArray){
            System.out.println(c);
        }

        System.out.println("*****************获取公有、无参的构造方法*******************************");
        Constructor con = clazz.getConstructor(null);
        //1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
        //2>、返回的是描述这个无参构造函数的类对象。

        System.out.println("con = " + con);
        //调用构造方法
        Object obj = con.newInstance();
        //	System.out.println("obj = " + obj);
        //	Student stu = (Student)obj;

        System.out.println("******************获取私有构造方法，并调用*******************************");
        con = clazz.getDeclaredConstructor(int.class);
        System.out.println(con);
        //调用构造方法
        con.setAccessible(true);//暴力访问(忽略掉访问修饰符)，私有的构造方法直接访问会报错，需要打开权限
        obj = con.newInstance(20);
    }
}
后台输出
**********************所有公有构造方法*********************************
public com.example.demo.reflex.Student(java.lang.String,int)
public com.example.demo.reflex.Student(char)
public com.example.demo.reflex.Student()
************所有的构造方法(包括：私有、受保护、默认、公有)***************
private com.example.demo.reflex.Student(int)
protected com.example.demo.reflex.Student(boolean)
public com.example.demo.reflex.Student(java.lang.String,int)
public com.example.demo.reflex.Student(char)
public com.example.demo.reflex.Student()
com.example.demo.reflex.Student(java.lang.String)
*****************获取公有、无参的构造方法*******************************
con = public com.example.demo.reflex.Student()
调用了公有、无参构造方法执行了。。。
******************获取私有构造方法，并调用*******************************
private com.example.demo.reflex.Student(int)
私有的构造方法   年龄：20
获取成员变量并调用
返回值方法名说明
Field[]getFields()获取所有公有成员变量
FieldgetField(String name)根据变量名获取
Field[]getDeclaredFields()获取所有成员变量
FieldgetDeclaredField(String name)根据变量名获取
voidField.set(Object obj, Object value)为字段设置值；第一个参数：要传入设置的对象，第二个参数：要设置的值
student类
public class Student {
    public Student(){

    }
    //**********字段*************//
    public String name;
    protected int age;
    char sex;
    private String phoneNum;

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", sex=" + sex
                + ", phoneNum=" + phoneNum + "]";
    }
}
测试类
public class Test01 {

    @Test
    public void test03() throws Exception {
        //1.获取Class对象
        Class stuClass = Class.forName("com.example.demo.reflex.Student");
        
        //2.获取字段
        System.out.println("************获取所有公有的字段********************");
        Field[] fieldArray = stuClass.getFields();
        for(Field f : fieldArray){
            System.out.println(f);
        }
        
        System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
        fieldArray = stuClass.getDeclaredFields();
        for(Field f : fieldArray){
            System.out.println(f);
        }
        
        System.out.println("*************获取公有字段**并调用***********************************");
        Field f = stuClass.getField("name");
        System.out.println(f);
        //获取一个对象
        Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
        //为字段设置值
        f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
        //验证
        Student stu = (Student)obj;
        System.out.println("验证姓名：" + stu.name);

        System.out.println("**************获取私有字段****并调用********************************");
        f = stuClass.getDeclaredField("phoneNum");
        System.out.println(f);
        f.setAccessible(true);//暴力反射，解除私有限定
        f.set(obj, "18888889999");
        System.out.println("验证电话：" + stu);
    }
}
后台输出
************获取所有公有的字段********************
public java.lang.String com.example.demo.reflex.Student.name
************获取所有的字段(包括私有、受保护、默认的)********************
public java.lang.String com.example.demo.reflex.Student.name
protected int com.example.demo.reflex.Student.age
char com.example.demo.reflex.Student.sex
private java.lang.String com.example.demo.reflex.Student.phoneNum
*************获取公有字段**并调用***********************************
public java.lang.String com.example.demo.reflex.Student.name
验证姓名：刘德华
**************获取私有字段****并调用********************************
private java.lang.String com.example.demo.reflex.Student.phoneNum
验证电话：Student [name=刘德华, age=0, sex= , phoneNum=18888889999]
获取成员方法并调用
student类
返回值方法名说明
Method[]getMethods()获取所有公有方法（包括一些隐藏的父类方法）
MethodgetMethod(String name, Class<?>… parameterTypes)根据方法名和参数类型获取
Method[]getDeclaredMethods()获取所有方法
MethodgetDeclaredMethod(String name, Class<?>… parameterTypes)根据方法名和参数类型获取
ObjectMethod.invoke(Object obj, Object… args)调用方法；第一个参数是调用的对象，后面的参数是实参
public class Student {
    //**************成员方法***************//
    public void show1(String s){
        System.out.println("调用了：公有的，String参数的show1(): s = " + s);
    }
    protected void show2(){
        System.out.println("调用了：受保护的，无参的show2()");
    }
    void show3(){
        System.out.println("调用了：默认的，无参的show3()");
    }
    private String show4(int age){
        System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
        return "abcd";
    }
}
测试类
public class Test01 {

    @Test
    public void test04() throws Exception {
        //1.获取Class对象
        Class stuClass = Class.forName("com.example.demo.reflex.Student");
        
        //2.获取所有公有方法
        System.out.println("***************获取所有的”公有“方法*******************");
        stuClass.getMethods();
        Method[] methodArray = stuClass.getMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        
        System.out.println("***************获取所有的方法，包括私有的*******************");
        methodArray = stuClass.getDeclaredMethods();
        for(Method m : methodArray){
            System.out.println(m);
        }
        
        System.out.println("***************获取公有的show1()方法*******************");
        Method m = stuClass.getMethod("show1", String.class);
        System.out.println(m);
        //实例化一个Student对象
        Object obj = stuClass.getConstructor().newInstance();
        m.invoke(obj, "刘德华");

        System.out.println("***************获取私有的show4()方法******************");
        m = stuClass.getDeclaredMethod("show4", int.class);
        System.out.println(m);
        m.setAccessible(true);//解除私有限定
        Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
        System.out.println("返回值：" + result);
    }
}
后台输出
***************获取所有的”公有“方法*******************
public void com.example.demo.reflex.Student.show1(java.lang.String)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
***************获取所有的方法，包括私有的*******************
public void com.example.demo.reflex.Student.show1(java.lang.String)
private java.lang.String com.example.demo.reflex.Student.show4(int)
protected void com.example.demo.reflex.Student.show2()
void com.example.demo.reflex.Student.show3()
***************获取公有的show1()方法*******************
public void com.example.demo.reflex.Student.show1(java.lang.String)
调用了：公有的，String参数的show1(): s = 刘德华
***************获取私有的show4()方法******************
private java.lang.String com.example.demo.reflex.Student.show4(int)
调用了，私有的，并且有返回值的，int参数的show4(): age = 20
返回值：abcd
反射main方法
student类
public class Student {

    public static void main(String[] args) {
        System.out.println("main方法执行了。。。");
    }
}
测试类
public class Test01 {
    
    @Test
    public void test05() {
        try {
            //1、获取Student对象的字节码
            Class clazz = Class.forName("com.example.demo.reflex.Student");

            //2、获取main方法
            Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
            //3、调用main方法
            // methodMain.invoke(null, new String[]{"a","b","c"});
            //第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
            //这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
            methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
            // methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/*
控制台输出：main方法执行了。。。
*/
通过反射运行配置文件内容
student类
public class Student {
    public void show(){
        System.out.println("is show()");
    }
}
配置文件
className: com.example.demo.reflex.Student
methodName: show
测试类
public class Test01 {
    @Test
    public void test06() throws Exception {
        //通过反射获取Class对象
        Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
        //2获取show()方法
        Method m = stuClass.getMethod(getValue("methodName"));//show
        //3.调用show()方法
        m.invoke(stuClass.getConstructor().newInstance());
    }

    //此方法接收一个key，在配置文件中获取相应的value
    public static String getValue(String key) throws IOException {
        String property = System.getProperty("user.dir"); //获取当前工程所在路径
        Properties pro = new Properties();//获取配置文件的对象
        FileReader in = null;//获取输入流
        in = new FileReader(property+"/src/main/resources/application.yaml"); //配置文件全路径
        pro.load(in);//将流加载到配置文件对象中
        in.close();
        return pro.getProperty(key);//返回根据key获取的value值
    }
}

/*
控制台输出：is show()
*/
需求

当我们升级这个系统时，不要Student类，而需要新写一个 Student2 的类时，这时只需要更改配置文件内容就可以了。代码就一点不用改动

student2类

public class Student2 {
	public void show2(){
		System.out.println("is show2()");
	}
}

配置文件更改为

className: com.example.demo.reflex.Student2
methodName: show2
通过反射越过泛型检查
public class Test01 {
   @Test
    public void test07() throws Exception {
        ArrayList<String> strList = new ArrayList<>();
        strList.add("aaa");
        strList.add("bbb");

        //	strList.add(100);
        //获取ArrayList的Class对象，反向的调用add()方法，添加数据
        Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
        //获取add()方法
        Method m = listClass.getMethod("add", Object.class);
        //调用add()方法
        m.invoke(strList, 100);

        //遍历集合
        for(Object obj : strList){
            System.out.println(obj);
        }
    }
}

/*
控制台输出：
aaa
bbb
100
*/

注解

原文

什么是注解

注解是标记，也可以理解成一种应用在类、方法、参数、属性、构造器上的特殊修饰符。注解的作用有以下三种：

  • 生成文档，常用的有 @param @return 等。
  • 替代配置文件的作用，尤其是在 spring 等一些框架中，使用注解可以大量的减少配置文件的数量
  • 检查代码的格式，如 @Override，标识某一个方法是否覆盖了它的父类的方法

注解的底层实现原理

参考

注解的底层是使用反射实现的。注解和接口有些类似，不过申明注解类需要加上 @interface，注解类里面，只支持基本类型、String及枚举类型，里面所有属性被定义成方法，并允许提供默认值。

java 5.0开始，在java.lang.annotations中提供了四种元注解，专门注解其他的注解：

@Target

用于描述注解的使用范围(即:被描述的注解可以用在什么地方)

ElementType.TYPE  				//给类注解
ElementType.FIELD 				//给字段注解，不要忘了，字段可以是对象
ElementType.METHOD 				//给方法注解
ElementType.PARAMETER 			//给参数注解
ElementType.CONSTRUCTOR 		//给构造方法注解
ElementType.LOCAL_VARIABLE 		//给局部变量注解
ElementType.ANNOTATION_TYPE 	//给注解注解（这貌似把自己不当类来看）
ElementType.PACKAGE 			//给包注解
@Retention

注解运行状态

RetentionPolicy.SOURCE		//源码状态运行
RetentionPolicy.CLASS		//编译类文件时运行
RetentionPolicy.RUNTIME		//运行时运行
@Document

说明该注解将被包含在javadoc中(生成使用文档)

@Inherited

允许子类继承父类中的注解

自定义注解

//定义注解类
@Target(value = {ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Users {
    String name() default "zhangsan";
}

//由于我们的注解是类注解，所以我们创建一个类
@Users
public class Test {
}

//到了这里，注解可能还没起什么作用。我们需要通过反射去读取类中定义的注解，读出来使用就简单了
public class Testamin {
    public static void main(String[] args) throws ClassNotFoundException{
        Class<?> classTest=Class.forName("com.example.demo.annotation.Test");
        Annotation[] ann=classTest.getAnnotations();
        for(Annotation aa:ann){
            Users u=(Users)aa;
            System.out.println(u.name());
        }
    }
}

通过注解读取配置文件

//注解类
@Target(value = {ElementType.FIELD,ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface MyValue {
    String value();
}

//Student类
public class Student {
    @MyValue("methodName")
    private String name;

    public String getName() {
        return name;
    }

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

//此方法接收一个key，在配置文件中获取相应的value
public static String getValue(String key) throws IOException {
    String property = System.getProperty("user.dir"); //获取当前工程所在路径
    Properties pro = new Properties();//获取配置文件的对象
    FileReader in = null;//获取输入流
    in = new FileReader(property+"/src/main/resources/application.yaml");
    pro.load(in);//将流加载到配置文件对象中
    in.close();
    return pro.getProperty(key);//返回根据key获取的value值
}

@Test
public void test09() throws Exception {
    Class<?> student = Class.forName("com.example.demo.reflex.Student");
    Field name = student.getDeclaredField("name");	
    MyValue annotation = name.getAnnotation(MyValue.class);	//获取字段上的注解
    String value = getValue(annotation.value());	//通过注解的值，使用getValue方法来获取配置文件中的内容
}
脸鼓达人
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1142
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java：注解和反射
希望有点用
05-21 2264
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
android 注解和反射 (入门以及使用)
高级开发者进阶ing... QaQ
08-16 872
先来看一看今天的效果: 代码效果: 效果不重要,重要的是代码: 注解 官方解释: 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 百度百科 定义一个注解: public @interface SZJ{ } 元注解: 元注解是用来标示当前注解是干什么用的,什么时候用,常用的有2个 @Target E
Java进阶——注解和反射
万里顾一程的博客
03-26 5465
文章目录Java基础——注解和反射1、注解1.1、什么是注解(Annotation)1.2、内置注解1.3、自定义注解和元注解(meta-annotation)2、反射1、反射和反射机制2、CLass类3、哪些类型可以有Class对象4、类加载理解5、类加载器6、通过反射动态的创建对象7、反射操作注解 Java基础——注解和反射 1、注解 1.1、什么是注解(Annotation) 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记， 注解的作
java基础之注解和反射
08-05
java基础之注解和反射
Java中关于注解和反射机制的内容
11-04
Java中关于注解和反射机制的内容
Java使用注解和反射简化编程的方法示例
08-25
主要介绍了Java使用注解和反射简化编程的方法,结合实例形式分析了java使用注解和反射调用大量函数简化编程的相关操作技巧,需要的朋友可以参考下
注解和反射机制的学习笔记
03-05
注解和反射机制的学习笔记
node-v10.22.0-darwin-x64.tar.xz
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于JAVA的物流管理系统的源码设计与实现.zip
05-03
毕业设计-->物流管理系统的设计与实现（Java版本） 采用Struts2+hibernate+Oracle10g+Tomcat 涉及车辆管理，配送点管理，运输方式管理，订单管理，员工管理，用户管理，部门管理，权限管理，角色管理等基础管理功能。
基于VB+access实现的成绩分析统计系统(论文+源代码).zip
05-03
基于VB+access实现的成绩分析统计系统(论文+源代码) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
node-v10.14.2-linux-x64.tar.xz
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
ASP+ACCESS网上购物系统设计(源代码+设计说明书+调研报告).zip
05-03
ASP+ACCESS网上购物系统设计(源代码+设计说明书+调研报告).zip
AO工艺设计计算(全).xls
05-03
污水处理计算书
node-v7.3.0-x86.msi
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
ASP+ACCESS在线考试系统设计(源代码+设计说明书).zip
05-03
ASP+ACCESS在线考试系统设计(源代码+设计说明书).zip
node-v11.10.0-linux-ppc64le.tar.xz
最新发布
05-03
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
如何通过注解和反射获取借接口名
07-16
要通过注解和反射获取接口名，首先需要定义一个注解，并将其应用到接口上。然后使用反射机制来获取接口上的注解信息。 下面是一个示例代码： ```java // 定义一个注解 @Retention(RetentionPolicy.RUNTIME) @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值