java注解与反射--3

类的加载与ClassLoader

java内存

• 堆
  • 存放new的对象和数组
  • 可以被所有的线程共享，不会存放别的对象引用
• 栈
  • 存放基本变量类型
  • 引用对象的变量
• 方法区
  • 可以被所有线程共享
  • 包含了所有的class和static变量

类的加载过程 1->2->3

1. 类的加载（load）：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。
2. 类的链接（Link）：将类的二进制数据合并到 JRE中。
3. 类的初始化（Initialize)：JVM负责对类进行初始化。

package com.ssl.demo02;

public class Test05 {

    public static void main(String[] args) {

        A a = new A();

        System.out.println(A.m);

        /*

        A类静态代码块初始化

        A类的无参构造初始化

        100

         */

        /**

         * 1.加载到内存，会产生一个类对应的class对象

         * 2.链接，链接结束后 m = 0

         * 3.初始化

         *      <clinit>(){

         *              System.out.println("A类静态代码块初始化");

         *              m=300;

         *              m=100;

         *      }

         */

    }

}

class A{

    static {

        System.out.println("A类静态代码块初始化");

        m=300;

    }

    static int m = 100;

    public A() {

        System.out.println("A类的无参构造初始化");

    }

}

什么时候发生类的初始化

• 类的主动引用（一定会发生类的初始话）
  • 当虚拟机启动，先初始化main方法所在的类
  • new 一个类的对象
  • 调用类的静态成员(除了final常量)和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类没有被初始化，则先会出初始化它的父类
• 类的被动引用（不会发生类的初始化）
  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
  • 通过数组定义类引用，不会触发此类的初始化
  • 引用常量不会触发此类的初始化。

package com.ssl.demo02;

//测试类什么时候会初始化

public class Test06 {

    static {

        System.out.println("Main类被加载");

    }

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

        //1.主动引用

        //Son son = new Son();

        //反射也会产生主动调用

        //Class.forName("com.ssl.demo02.Son");

        /*

            Main类被加载

            父类被加载

            子类被加载

         */

        //不会产生类的引用的方法

        //子类引用父类的静态变量，不会导致子类初始化。

        //System.out.println(Son.b);

        /*

            Main类被加载

            父类被加载

            2

         */

        //通过数组定义类引用，不会触发此类的初始化

        //Son[] array = new Son[5];

        /*

            Main类被加载

         */

        //引用常量不会触发此类的初始化。

        System.out.println(Son.M);

        /*

            Main类被加载

            1

         */

    }

}

class Father{

    static int b = 2;

    static {

        System.out.println("父类被加载");

    }

}

class Son extends Father{

    static {

        System.out.println("子类被加载");

        m=300;

    }

    static int m = 100;

    static final int M = 1;

}

类加载器的作用 ClassLoader

• 类加载的作用:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
• 类缓存:标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

过程：源文件(.java)->java编译器->字节码(.class)->类装载器->字节码校验器->解释器->操作系统平台**

package com.ssl.demo02;

public class Test07 {

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

        //获取系统类的加载器

        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器-->扩展类加载器

        ClassLoader parent = systemClassLoader.getParent();

        System.out.println(parent);

        //获取扩展类加载器的父类加载器 --> 根加载器(C/C++)

        ClassLoader parent1 = parent.getParent();

        System.out.println(parent1);

        /**

         * sun.misc.Launcher$AppClassLoader@18b4aac2

         * sun.misc.Launcher$ExtClassLoader@4554617c

         * null

         */

        //测试当前类是哪个加载器加载的

        ClassLoader aClass = Class.forName("com.ssl.demo02.Test07").getClassLoader();

        System.out.println(aClass);

        //测试JDK内部类是哪个加载器加载的

        aClass = Class.forName("java.lang.Object").getClassLoader();

        System.out.println(aClass);

        /**

         * sun.misc.Launcher$AppClassLoader@18b4aac2

         * null

         */

        //如何获取系统类加载器可以加载的路径

        System.out.println(System.getProperty("java.class.path"));

        //双亲委派机制，保证安全性。

    }

}

创建运行时类的对象

获取运行时类的完整结构

通过反射获取运行时类的完整结构

Field（字段）、Method、Constructor、Superclass、Interface、Annotation

package com.ssl.demo02;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class Test08 {

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

        Class c1 = Class.forName("com.ssl.demo02.User");

        //获得类的名字

        System.out.println(c1.getName());   //获取包名+类名

        System.out.println(c1.getSimpleName());     //获得类名

        //获得类的属性

        Field[] fields = c1.getFields();   //找到公有的方法

        fields = c1.getDeclaredFields();   //找到所有的方法

        for(Field field:fields){

            System.out.println(field);

        }

        //获得指定属性的值

        Field name = c1.getDeclaredField("name");

        System.out.println(name);

        System.out.println("=================================");

        //获得类的方法

        Method[] methods = c1.getMethods();    //获得本类及其父类的全部public方法

        for(Method method:methods){

            System.out.println("正常的"+method);

        }

        methods = c1.getDeclaredMethods();     //获得本类的所有方法

        for(Method method:methods){

            System.out.println("getDeclaredMethods"+method);

        }

        //获得指定方法

        //重载

        Method getname = c1.getMethod("getName",null);

        Method setname = c1.getMethod("setName",String.class);

        System.out.println(getname);

        System.out.println(setname);

        System.out.println("=================================");

        //获得指定的构造器

        Constructor[] constructors = c1.getConstructors();

        for(Constructor constructor:constructors){

            System.out.println(constructor);

        }

        constructors = c1.getDeclaredConstructors();

        for(Constructor constructor:constructors){

            System.out.println("getDeclaredConstructors"+constructor);

        }

        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);

        System.out.println(constructor);

    }

}

小结：

1. 在实际的操作中，取得类的信息的操作代码，并不会经常开发。
2. 一定要熟悉java.lang.reflect包的作用，反射机制。
3. 如何取得属性、方法、构造器的名称，修饰符等。

调用运行时类的指定结构

动态创建对象执行方法

package com.ssl.demo02;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class Test09 {

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

        //获得Class对象

        Class c1 = Class.forName("com.ssl.demo02.User");

        //构造一个对象   和new 一样

        User user = (User) c1.newInstance();  //本质是调用了类的无参构造器

        System.out.println(user);

        //通过构造器创建对象

        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);

        User ssl = (User)declaredConstructor.newInstance("ssl", 1, 18);

        System.out.println(ssl);

        //通过反射调用普通方法

        User user3 = (User)c1.newInstance();

        //通过反射获取一个方法

        Method setName = c1.getDeclaredMethod("setName", String.class);

        //激活方法（对象、方法值）

        setName.invoke(user3,"kk");

        System.out.println(user3);

        //通过反射操作属性

        User user4 = (User)c1.newInstance();

        //获取属性

        Field name = c1.getDeclaredField("name");

        //不能直接操作私有属性，需要关闭程序的安全检测，默认为false

        //安全权限的开关 setAccessible

        name.setAccessible(true);

        name.set(user4,"ssl2");

        System.out.println(user4);

    }

}

分析性能问题

package com.ssl.demo02;

import java.lang.reflect.Method;

//分析性能问题

public class Test10 {

    //普通方式调用

    public static void test01(){

        User user = new User();

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10_0000_0000; i++) {

            user.getName();

        }

        long endTime = System.currentTimeMillis();

        System.out.println("普通方法执行10亿次："+(endTime-startTime)+"ms");

    }

    //反射方式调用

    public static void test02()throws Exception{

        User user = new User();

        Class c1 = user.getClass();

        Method getName = c1.getDeclaredMethod("getName", null);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10_0000_0000; i++) {

            getName.invoke(user,null);

        }

        long endTime = System.currentTimeMillis();

        System.out.println("反射方式执行10亿次："+(endTime-startTime)+"ms");

    }

    //反射方式调用 关闭检测

    public static void test03()throws Exception{

        User user = new User();

        Class c1 = user.getClass();

        Method getName = c1.getDeclaredMethod("getName", null);

        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 10_0000_0000; i++) {

            getName.invoke(user,null);

        }

        long endTime = System.currentTimeMillis();

        System.out.println("setAccessible执行10亿次："+(endTime-startTime)+"ms");

    }

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

        test01();

        test02();

        test03();

        /**

         * 普通方法执行10亿次：3ms

         * 反射方式执行10亿次：1736ms

         * setAccessible执行10亿次：954ms

         */

    }

}

反射操作泛型

• Java采用泛型擦除的机制来引入泛型,Java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型转换问题﹐但是，一旦编译完成﹐所有和泛型有关的类型全部擦除
• 为了通过反射操作这些类型，Java新增了ParameterizedType , GenericArrayType ,TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型.
  • ParameterizedType ：表示一种参数化类型，比如Collection
  • GenericArrayType :表示一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable：是各种类型变量的公共父接口
  • WildcardType：代表一种通配符类型表达式

package com.ssl.demo02;

import java.lang.reflect.Method;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.util.List;

import java.util.Map;

//通过反射获取泛型

public class Test11 {

    public void test01(Map<String,User> map, List<User> list){

        System.out.println("test01");

    }

    public Map<String,User> test02(){

        System.out.println("test02");

        return null;

    }

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

        Method method = Test11.class.getMethod("test01", Map.class, List.class);

        Type[] genericParameterTypes = method.getGenericParameterTypes();

        for(Type genericParameterType:genericParameterTypes ){

            System.out.println("#"+genericParameterType);

            if(genericParameterType instanceof ParameterizedType){

                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();

                System.out.println(actualTypeArguments);

            }

        }

        //返回值类型

        method = Test11.class.getMethod("test02", null);

        Type genericReturnType = method.getGenericReturnType();

        if(genericReturnType instanceof ParameterizedType){

            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();

            for(Type actualTypeArgument:actualTypeArguments){

                System.out.println(actualTypeArgument);

            }

        }

    }

}

获取注解信息

• getAnnotations
• getAnnotation

练习：ORM

ORM:Object relationship Mapping --> 对象关系映射

• 类和表结构对应
• 属性和字段对应
• 对象和记录对应

利用注解和反射完成类和表结构的映射关系。

package com.ssl.demo02;

import java.lang.annotation.*;

import java.lang.reflect.Field;

//练习反射注解

public class Test12 {

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

        Class c1 = Class.forName("com.ssl.demo02.Student2");

        //通过反射获得注解

        Annotation[] annotations = c1.getAnnotations();

        for(Annotation annotation:annotations){

            System.out.println(annotation);

        }

        //获得注解的value的值

        Table1 table1 = (Table1)c1.getAnnotation(Table1.class);

        String value = table1.value();

        System.out.println(value);

        //获得类指定的注解

        Field f = c1.getDeclaredField("name");

        Field1 annotation = f.getAnnotation(Field1.class);

        System.out.println(annotation.columnName());

        System.out.println(annotation.type());

        System.out.println(annotation.length());

    }

}

@Table1("db_student")

class Student2{

    @Field1(columnName = "db_id",type = "int",length = 10)

    private int id;

    @Field1(columnName = "db_age",type = "int",length = 10)

    private int age;

    @Field1(columnName = "db_name",type = "varchar",length = 3)

    private String name;

    public Student2() {

    }

    public Student2(int id, int age, String name) {

        this.id = id;

        this.age = age;

        this.name = name;

    }

    public int getId() {

        return id;

    }

    public int getAge() {

        return age;

    }

    public String getName() {

        return name;

    }

    public void setId(int id) {

        this.id = id;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public void setName(String name) {

        this.name = name;

    }

}

//类名的注解

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@interface Table1{

    String value();

}

//属性的注解

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@interface Field1{

    String columnName();

    String type();

    int length();

}

最新文章

1. asp.net mvc4 MvcMusicStore
2. java--UDP屏幕广播代码
3. Xcode自定义Eclipse中常用的快捷键
4. JetBrains公司介绍（Java、Python、PHP、Ruby、前端和代码测试与重构的IDE）
5. box2d 遍历世界中 body 的方法
6. jq 幻灯片插件制作
7. 309. Best Time to Buy and Sell Stock with Cooldown
8. mysql performance_schema 初探
9. 《ASP.NET 本质论》HttpApplication的处理管道 ,HttpMoudle,HttpHandler
10. Google机器学习教程心得（二）决策树与可视化
11. jsp小商城
12. [置顶] Android常用适配器控件
13. JJG 623-2005 电阻应变仪计量检定规程
14. poj 2378 树型dp
15. 个人理解---在开发中何时加入日志记录功能[java]
16. 1492: [NOI2007]货币兑换Cash
17. hdu 5442 (后缀数组)
18. Win10 下Cmake编译配置 Opencv3.1 + Cuda7.5 + VS2013
19. laravel belongsTo使用
20. linux下查询java进程以及杀掉其进程

热门文章

1. PHP Redis - Hash (哈希)
2. CORS预检
3. 昨天写了个ATM系统，学了点思想
4. python投票一致性指数（IVC）实现代码
5. 【python】第一模块 步骤五 第一课、内存管理机制
6. 2月27日Android开发学习
7. Linux SMB传输文件命令
8. ReSharp的安装和使用教程
9. Hive 操作与应用 词频统计
10. pip 临时切换 国内源