杂七杂八的知识

最新推荐文章于 2022-05-18 15:32:50 发布

tuskigmj

最新推荐文章于 2022-05-18 15:32:50 发布

阅读量100

点赞数

本文链接：https://blog.csdn.net/tuskigmj/article/details/119329438

版权

1.反射及注释

反射的其中一个方法：Class.forName(包名.类名）

利用反射获取类的信息（属性，方法，构造器）

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 获得相关注解
 * 应用反射的API，获取类的信息(名字，属性，方法，构造器)
 */
public class Demo03 {
    public static void main(String[] args) {
        try {
            Class clazz=Class.forName("annotation.student");
            //获得类的指定注解
            table t=(table)clazz.getAnnotation(table.class);
            System.out.println(t.value());
            //获得类的属性的注解
            Field f=clazz.getDeclaredField("age");
            field fd=f.getAnnotation(field.class);
            System.out.println(fd.columnName()+"-->"+fd.type()+"-->"+fd.length());


            //获得类的名字
            System.out.println(clazz.getName());//包名加类名
            System.out.println(clazz.getSimpleName());//类名

            //获得属性的信息
            Field[] fields1=clazz.getDeclaredFields();//获得公共的属性
            Field[] fields=clazz.getDeclaredFields();//获得全部属性的信息
            Field field=clazz.getDeclaredField("age");//获得指定属性
            for(Field temp:fields){
                System.out.println("属性："+temp);
            }
            System.out.println("---------------------------------------------------------------");

            //获得方法的信息
            Method[] methods=clazz.getDeclaredMethods();//获得全部的方法
            for(Method m:methods){
                System.out.println("方法："+m);
            }
            Method method=clazz.getDeclaredMethod("setAge", int.class);//获得指定的方法
            //如果有参，则必须传递参数类型对应的class对象
            System.out.println("---------------------------------------------------------------");

            //获得构造器的信息
            Constructor[] constructors=clazz.getDeclaredConstructors();
            for(Constructor c:constructors){
                System.out.println("构造器："+c);
            }
            Constructor constructor=clazz.getDeclaredConstructor(int.class,int.class,String.class);
            System.out.println("获得构造器："+constructor);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.利用反射动态操作构造器，属性，方法

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 通过反射API动态的操作构造器，方法，属性
 */
public class Demo01 {
    public static void main(String[] args) {
        try {
            Class<student> clazz=(Class<student>)Class.forName("annotation.student");
            //通过反射API调用构造方法，构造对象
            student s=clazz.newInstance();
            Constructor<student> c=clazz.getDeclaredConstructor(int.class,int.class,String.class);
            student s2=c.newInstance(1001,18,"张三");
            System.out.println(s2.getAge());

            //通过反射API调用普通方法
            Method method=clazz.getDeclaredMethod("setId", int.class);
            student s3=clazz.newInstance();
            method.invoke(s3,1001);
            System.out.println(s3.getId());

            //通过反射API操作属性
            student s4=clazz.newInstance();
            Field f=clazz.getDeclaredField("studentName");
            f.setAccessible(true);//这个属性不需要做安全检查，可以直接访问
            f.set(s4,"王五");
            System.out.println(s4.getStudentName());
            System.out.println(f.get(s4));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.通过反射获取注解信息

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

/**
 * 通过反射获取注解信息
 */
public class Demo02 {
    public static void main(String[] args) {
        try{
            Class clazz=Class.forName("annotation.student");

            //获得类的所有有效注解
            Annotation[] annotations=clazz.getAnnotations();
            for(Annotation a:annotations){
                System.out.println(a);
            }
            //获得类的指定注解
            table t=(table)clazz.getAnnotation(table.class);
            System.out.println(t.value());

            //获得类的属性的注解
            Field f=clazz.getDeclaredField("studentName");
            field f1= f.getAnnotation(field.class);
            System.out.println(f1.columnName()+"---"+f1.type()+"---"+f1.length());

        }catch (Exception e){

        }
    }
}

4.动态编译的其中一个方法

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;

public class Demo04 {
    public static void main(String[] args) {
        //动态编译
        JavaCompiler compiler= ToolProvider.getSystemJavaCompiler();
        int result=compiler.run(null,null,null,"C:/myjava/HelloWord.java");
        System.out.println(result==0?"编译成功":"编译失败");
    }
}

5.javascript简单应用（创建一个类）

import javassist.*;

import java.io.IOException;

public class Demo05 {
    public static void main(String[] args) throws Exception {
        ClassPool pool=ClassPool.getDefault();
        CtClass cc=pool.makeClass("annotation.Emp");
        //创建属性
        CtField f1=CtField.make("private int empno;",cc);
        CtField f2=CtField.make("private  String ename;",cc);
        cc.addField(f1);
        cc.addField(f2);

        //创建方法
        CtMethod m1=CtMethod.make("public int getEmpno() { return empno; }",cc);
        CtMethod m2=CtMethod.make("public void setEmpno(int empno) { this.empno = empno; }",cc);
        CtMethod m3=CtMethod.make("public String getEname() { return ename; }",cc);
        CtMethod m4=CtMethod.make("public void setEname(String ename) { this.ename = ename; }",cc);
        cc.addMethod(m1);
        cc.addMethod(m2);
        cc.addMethod(m3);
        cc.addMethod(m4);

        //添加构造器
        CtConstructor c=new CtConstructor(new CtClass[]{CtClass.intType,pool.get("java.lang.String")},cc);
        c.setBody("{ this.ename = ename;this.empno=empno; }");
        cc.addConstructor(c);

        cc.writeFile("c:/myjava");
        System.out.println("成功生成类！");
    }
}

6.javaassist的一些基本用法


import javassist.*;
import jdk.swing.interop.SwingInterOpUtils;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * 测试javassist的API
 */
@SuppressWarnings("all")
public class Demo06 {
    //处理类的基本用法
    public static void test01() throws Exception {
        ClassPool pool=ClassPool.getDefault();
        CtClass cc=pool.get("annotation.Emp");
        byte[] bytes=cc.toBytecode();
        System.out.println(Arrays.toString(bytes));
        System.out.println(cc.getName());//获取包名+类名
        System.out.println(cc.getSimpleName());//获取类名
        System.out.println(cc.getSuperclass());//获得父类
        System.out.println(cc.getInterfaces());//获得接口
    }

    //改变原方法，添加新方法
    public static void test02() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("annotation.Emp");
        CtMethod m=new CtMethod(CtClass.intType,"add",
                new CtClass[]{CtClass.intType,CtClass.intType},cc);
        m.setModifiers(Modifier.PUBLIC);
        m.setBody("{return $1+$2;}");
        cc.addMethod(m);
        //通过反射调用新生成的方法
        Class clazz=cc.toClass();
        Object obj=clazz.newInstance();
        Method method=clazz.getDeclaredMethod("add",int.class,int.class);
        Object result=method.invoke(obj,200,300);
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception {
        test01();
    }
}