java注解与反射--3
java注解与反射--3
类的加载与ClassLoader
java内存
- 堆
- 存放new的对象和数组
- 可以被所有的线程共享,不会存放别的对象引用
- 栈
- 存放基本变量类型
- 引用对象的变量
- 方法区
- 可以被所有线程共享
- 包含了所有的class和static变量
类的加载过程 1->2->3
- 类的加载(load):将类的class文件读入内存,并为之创建一个java.lang.Class对象。此过程由类加载器完成。
- 类的链接(Link):将类的二进制数据合并到 JRE中。
- 类的初始化(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);
}
}
小结:
- 在实际的操作中,取得类的信息的操作代码,并不会经常开发。
- 一定要熟悉java.lang.reflect包的作用,反射机制。
- 如何取得属性、方法、构造器的名称,修饰符等。
调用运行时类的指定结构
动态创建对象执行方法
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();
}
java注解与反射--3的更多相关文章
- Java注解与反射
概要 本文主要是总结Java注解与反射的相关知识,加深自己对Java类动态语言的理解,同时为日后学习Spring打下基础. 注解: 什么是注解 Annotation的作用 不是程序本身,但是可以对程序 ...
- 小白都能学会的Java注解与反射机制
前言 Java注解和反射是很基础的Java知识了,为何还要讲它呢?因为我在面试应聘者的过程中,发现不少面试者很少使用过注解和反射,甚至有人只能说出@Override这一个注解.我建议大家还是尽量能在开 ...
- Java注解和反射笔记
Java注解和反射笔记 1 注解 1.1 定义 Annotation是从JDK1.5开始引入的技术 作用 不是程序本身,可以对程序作出解释 可以被其他程序(编译器等)读取 格式 @注释名,可以添加一些 ...
- Java注解和反射
1.注解(Annotation) 1.1.什么是注解(Annotation) 注解不是程序本身,可以在程序编译.类加载和运行时被读取,并执行相应的处理.注解的格式为"@注释名(参数值)&qu ...
- java注解实例-反射生成sql
定义描述用户表的注解: package dao; import java.lang.annotation.ElementType; import java.lang.annotation.Retent ...
- JAVA 注解和反射
通过反射来获取类 Class MyTest{ private String name; public String showName{ System.out.println(this.name); } ...
- java注解和反射学习
spring框架很多地方都应用了注解,如@controller,所以要学会自定义注解及注解处理器. Class<?> cl=Class.froName(className) //通过类名加 ...
- java自定义注解与反射
java注解与反射一.Java中提供了四种元注解,专门负责注解其他的注解,分别如下 1.@Retention元注解,表示需要在什么级别保存该注释信息(生命周期).可选的RetentionPoicy参数 ...
- Java基于注解和反射导入导出Excel
代码地址如下:http://www.demodashi.com/demo/11995.html 1. 构建项目 使用Spring Boot快速构建一个Web工程,并导入与操作Excel相关的POI包以 ...
- Java注解Annotation与自定义注解详解
Java注解简介 开发中经常使用到注解,在项目中也偶尔会见到过自定义注解,今天就来探讨一下这个注解是什么鬼,以及注解的应用场景和如何自定义注解. 下面列举开发中常见的注解 @Override:用于标识 ...
随机推荐
- element的el-table合计显示不出来
在updated中写入 this.$nextTick(() => { this.$refs["printStatisticsTableData"].doLayout(); } ...
- echarts 折柱表混合图(折线,柱状图,表格)
效果图如下: 代码如下: <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> ...
- Mysql存储类型长度
分析MySQL数据类型的长度 MySQL有几种数据类型可以限制类型的"长度",有CHAR(Length).VARCHAR(Length).TINYINT(Length).SMALL ...
- mysql查询mapper返参类型为List
List<String> lists = mapper.select(); 返参类型为List,查询没有数据的时候,lists不会为null,lists.size() 为 0.
- kali 下安装tplmap
kali 下安装tplmap 1. 安装kali下的python2的pip工具 kali2020版及以上, 输入python2命令会执行python2, python3也存在. 但pip默认是pip3 ...
- 通过Linux的socket套接字实现客户端与服务器端的通信
具体案例:使用树莓派ds18b20温度传感器实现温度上报 首先需要获得传感器文件中保存的温度信息: 温度信息通常保存在路径为"/sys/bus/w1/devices/28-xxxxxxxxx ...
- 连接打印机Lodop
<div class="panel-body"> <div class="row show-grid"> <div class=& ...
- Tomcat启动—本地文件夹
打开tomcat文件夹 打开bin目录 在路径这里输入cmd 就可以直接跳转到当前页面下 接下来我们在cmd命令中启动startup.bat (记得设置java环境变量) 这里我没设置utf-8 我无 ...
- torch直接更改参数
使用model.layer1.weight.data.copy_(w1) 其中model是自定义的参数名字,layer1是某个具体的层,使用某个具体的w1来修改
- 20181224《网络攻防技术》Exp7 网络欺诈防范
20181224<网络攻防技术>Exp7 网络欺诈防范 目录 20181224<网络攻防技术>Exp7 网络欺诈防范 相关知识点总结 ARP Spoofing IP源地址欺骗 ...