最近再学习java相关框架,发现注解和反射是很重要的基础知识,所以找了相关文档复习巩固一下,以下是学习笔记
注解和反射
注解和反射01:什么是注解
注解:是给程序看的,为程序作出解释,可以被程序读取
注释:是给程序员看的
例如:
@override 重写
注解和反射02:内置注解
@Deprecated 表示已经过时,不推荐使用,并且有更好的方法替换它
@SuppressWarning(“all”)镇压警告
注解和反射03:元注解
元注解是解释其他注解的注解,说白了就是写在注解上的注解,用来解释注解的功能
java中有4个元注解:
注解的格式:
public @interface XX{
}
java中的4个元注解:
```java
//表示这个注解只能用在方法上,也可以使用value={},定义多个
@Target(value = ElementType.METHOD)
//表示注解在什么周期有作用, runtime>class>source
@Retention(value = RetentionPolicy.RUNTIME)
//表示是否将我们的注生成在javadoc中
@Documented
//子类可以继承父类拥有注解
@Inherited
public @interface MyAnnotation{
}
注解和反射04:自定义注解
public class helloComponent {
// 注解可以显示默认值,如果不写默认值,那么一定要给参数赋值
@MyAnnotation(name = "hupf")
public String hello(){
return "hello hupf";
}
}
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface MyAnnotation{
// 注解的参数:参数类型 + 参数名()
String[] name() default "";// default表示默认值,写上默认值的话,参数可以不赋值
}
如果注解中的参数只有一个值,必须叫value,并且参数赋值的时候可以省略value
注解和反射05:反射概述
反射 使java变成了准动态语言
动态语言:在运行时,可以改变结构的语言
静态语言:不可以改变结构的语言,java
反射(Reflection)可以获取任意类的属性,方法,构造器,注解
正常创建对象的方式:
引入需要的包类的名称–通过new实例化–获取实例化对象
反射的方式:
实例化对象–getClass()方法–得到完整的包类名称
注解和反射06:获取反射对象
反射的核心类是:Class
优点:可以实现动态创建对象和编译,体现出很大的灵活性
缺点:对性能有影响,所以反射是一把双刃剑,要慎重使用
// 反射测试类
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class c1 = Class.forName("com.example.hupfspringbootdemp.component.User");
Class c2 = Class.forName("com.example.hupfspringbootdemp.component.User");
// 一个类在内存中只有一个Class对象
// 一个类被加载后,类的整个结构都会封装在Class对象中
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
}
}
class User {
private String name;
private int id;
private int age;
public User() {
}
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", id=" + id +
", age=" + age +
'}';
}
}
注解和反射07:得到Class类的集中方式
Class本身是一个类
Class对象只能由系统创建
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个class文件
每个类的实例都会记得自己是由哪个Class实例所生成的的
通过Class可以完整的得到一个类中的所有被加载的结构
Class类是Relection的根源,针对任何你想动态加载、运行的类,唯有先获取相应的Class对象
获取Class类的实例:
// 通过forName加全路径获取
Class c1 = Class.forName("com.example.hupfspringbootdemp.component.User");
// 通过对象获取
User user = new User();
Class c2 = user.getClass();
// 通过类名.class获取
Class c3 = User.class;
注解和反射08:所有类型的Class对象
public static void main(String[] args) throws ClassNotFoundException {
Class c1 = Object.class;// 类
Class c2 = Comparable.class;// 接口
Class c3 = String[].class;// 一维数组
Class c4 = int[][].class;// 二维数组
Class c5 = Override.class;// 注释
Class c6 = ElementType.class;// 枚举
Class c7 = Integer.class;// 基本数据类型
Class c8 = void.class;// void
Class c9 = Class.class;// Class
}
只要元素类型与纬度一样,就是同一个Class
注解和反射09:类加载内存分析
java内存分为:
堆:存放new的对象和数组,可以被所有的线程共享,不会存放别的对象引用
栈:存放基本变量类型,引用对象的变量
方法区:可以被所有的线程共享,包含了所有的class和static变量
类的加载:
加载:将class字节码文件加载到内存
链接:将javan的二进制代码合并到JVM中
初始化:将所有的static方法合并到一起先初始化,执行类构造器init方法
// 所有类型的Class
public class Test {
static {
m=20;
}
static int m = 10;
public static void main(String[] args) throws ClassNotFoundException {
/**
* 1.加载到内存,会产生一个类对应的Class对象
* 2.链接,链接结束后m=0
* 3.初始化:
* <clinit>(){
* System.out.println("静态代码块运行")
* m=20
* m=10
* }
*
* 最后m=10
*/
System.out.println(m);
}
}
输出结果:10
注解和反射10:分析类的初始化
主动引用:一定会发生类的初始化
当虚拟机启动,先初始化main方法所在的类
new一个类的对象
调用类的静态成员(除final常量)和静态方法
使用java.lang.reflect包的方法对类惊醒反射调用
当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类
被动引用:不会发生类的初始化
当访问一个静态域时,只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化
通过数组定义子类引用,不会发生此类的初始化
引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)
public class Test {
static {
System.out.println("main加载");
}
public static void main(String[] args) throws ClassNotFoundException {
// 1.主动引用
Son son = new Son();
// 反射也会主动引用
Class.forName("com.example.hupfspringbootdemp.component.Son");
// 不会产生类的引用的方法,因为静态属性是放在方区,不需要创建对象
System.out.println(Son.b);
Son[] sons = new Son[5];
}
}
class Father{
static int b = 2;
static {
System.out.println("父类加载");
}
}
class Son extends Father{
static {
System.out.println("子类加载");
}
static int m = 100;
static final int M = 1;
}
输出:
main加载
父类加载
子类加载
注解和反射11:类加载器
类加载器的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的Class对象,作为方法区中类数据的访问入口
类缓存:标准的javaSE类加载器可以按要求查找类,但是一旦某个类被加载到类加载器中,它将维持(缓存)一段时间,不过JVM垃圾回收机制可以回收这些Class对象
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
// 获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
// 获取系统类加载器的父类加载器--》扩展类的加载器
ClassLoader parent = systemClassLoader.getParent();
// 获取扩展类加载器的父类的加载器--》根加载器(C++编写)
ClassLoader parent1 = parent.getParent();
// 测试当前类是哪个加载器加载的
Class c = Class.forName("com.example.hupfspringbootdemp.component.Test");
ClassLoader classLoader = c.getClassLoader();
// 测试JDK内置的类是哪个加载器加载的
Class c1 = Class.forName("java.lang.Object");
ClassLoader classLoader1 = c.getClassLoader();
// 获取系统环境变量中的path的所有内容
String property = System.getProperty("java.class.path");
// 双亲委派机制:一层一层向上查找加载器
}
}
注解和反射12:获取类的运行时结构
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("com.example.hupfspringbootdemp.component.User");
// 获取类的名字
c1.getName();// 获取包名+类名
c1.getSimpleName();// 获取类名
// 获取类的属性
Field[] fields = c1.getFields();// 获取所有的属性(public)
Field[] declaredFields = c1.getDeclaredFields();// 获取所有的属性
Field name = c1.getField("name");// 获取指定的属性的值(public)
Field name1 = c1.getDeclaredField("name");// 获取指定的属性的值
// 获取所有方法
Method[] methods = c1.getMethods();//获取本类的及其父类的全部方法(public)
Method[] declaredMethods = c1.getDeclaredMethods();//获取本类的所有方法
// 获取指定方法
Method getName = c1.getMethod("getName", null);// 获取指定方法
Method setName = c1.getMethod("setName", String.class);//
// 获取指定的构造器
Constructor[] constructors = c1.getConstructors();// 获取所有的构造器(public)
Method[] declaredMethods1 = c1.getDeclaredMethods();// 获取全部的构造器
}
注解和反射13:动态创建对象执行方法
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
// 创建Class对象
Class c1 = Class.forName("com.example.hupfspringbootdemp.component.User");
// 构造一个对象
User user = (User)c1.newInstance();// 本质就是调用无参构造器
// 通过构造器创建对象
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
User hupf = (User) declaredConstructor.newInstance("hupf", 1, 1);
// 通过反射获取方法,调用方法
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(hupf, "hupf");
// 通过反射获取私有属性
Field name = c1.getDeclaredField("name");
name.setAccessible(true);// 关闭属性安全访问的开关
}
注解和反射14:性能对比分析
反射的性能不如new创建对象
注解和反射15:反射操作泛型
public class Test {
public void test01(Map<String, User> map, List<User> list){
}
public void test02(){
}
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Method test01 = Test.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = test01.getGenericParameterTypes();
for (Type genericParameterType : genericParameterTypes) {
if(genericParameterType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
}
}
}
Method test02 = Test.class.getMethod("test02", null);
}
}
注解和反射16:获取注解信息
ORM:对象关系映射
public class Test {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c = Class.forName("com.example.hupfspringbootdemp.component.User");
// 通过反射获得注解
Annotation[] annotations = c.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 获取指定的注解
TableKuang t = (TableKuang) c.getAnnotation(TableKuang.class);
String value = t.value();
// 获取类的指定注解
Field f = c.getDeclaredField("name");
TableHupf annotation = f.getAnnotation(TableHupf.class);
annotation.columnName();
annotation.length();
annotation.type();
}
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableKuang{
String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableHupf{
String columnName();
String type();
int length();
}
@TableKuang("db_struct")
class User {
@TableHupf(columnName = "db_name", type="varchar", length = 3)
private String name;
@TableHupf(columnName = "db_id", type="int", length = 10)
private int id;
@TableHupf(columnName = "db_age", type="int", length = 2)
private int age;
public User() {
}
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", id=" + id +
", age=" + age +
'}';
}
}