一、注解
（一）注解定义
- Annotation是从JDK5.0开始引入的技术
- Annotation作用：
- 不是程序本身，可以对程序做出解释（和注释comment一样的地方）
- 可以被其他程序（如：编译器）读取
- Annotation格式：
- 以**@注释名**在代码中存在，可以添加参数值
@SuppressWarnings(value = "TYPE")
- Annotation使用
- 可以附加在 package、class、method、field 等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问
（二）内置注解
- @Override：定义在java.lang.Override 中，此注释只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明
//@Override源码
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
- @Deprecated：定义在java.lang.Deprecated中，此注释可以用于修饰方法、属性、类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择
//@Deprecated源码
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
- @SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息
- 与前两个注释有所不同，需要添加一个参数才能正常使用，这些参数都是已经定义好的
@SuppressWarnings(“all”)
@SuppressWarnings(“unchecked”)
@SuppressWarnings(value = {“unchecked”,“deprecation”})
- 与前两个注释有所不同，需要添加一个参数才能正常使用，这些参数都是已经定义好的
//@SuppressWarnings源码
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
String[] value();
}
（三）元注解
- 元注解的作用：
- 负责注解其他注解
- Java定义了4个标准的meta-annotation类型，被用来提供对其他annotation类型作说明
- 这些类型和他们所支持的类在 java.lang.annotation 包中可以找到（@Target，@Retention，@Documented，@Inherited）
- @Target：用于描述注解的使用范围（被描述的注解可以使用在什么地方）
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
/**
* Returns an array of the kinds of elements an annotation type
* can be applied to.
* @return an array of the kinds of elements an annotation type
* can be applied to
*/
ElementType[] value();
}
- @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期
SOURCE < CLASS < RUNTIME
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
/**
* Returns the retention policy.
* @return the retention policy
*/
RetentionPolicy value();
}
- @Documented：说明该注解被包含在javadoc中
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}
- @Inherited：说明子类可以继承父类中的该注解
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}
（四）自定义注解
- 使用 @interface 自定义注解时，自动继承了 java.lang.annotation.Annotation 接口
- 自定义：
- @interface用来声明一个注解，格式 public @interface 注解名 {定义内容}
- 每一个方法实际上是声明了一个配置参数
- 方法的名称就是参数的名称
- 返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）
- 可以通过 default 声明参数的默认值
- 如果只有一个参数成员，一般参数名为 value
- 注解元素必须要有值（空字符串、0一般作为默认值）
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
@Documented
@Inherited
@interface test {
String name() default "";
int age() default 0;
}
二、静态和动态语言
动态语言
- 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。简单来说就是在运行时代码可以根据某些条件改变自身结构
- 主要动态语言：Object-C、C#、JavaScript、PHP、python
静态语言
- 与动态语言相对应，运行时结构不可变的语言就是静态语言。例如：Java、C、C++
Java不是动态语言，但Java可以称为“准动态语言“。Java拥有一定的动态性，利用反射机制获得类似动态语言的特性。
三、反射
（一）Java Reflection定义
-
Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
-
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。通过这个对象，得到类的结构，称之为反射
一般方式：引入需要的”包类”名称——> 通过new实例化——> 取得实例化对象
反射方式：实例化对象——> getClass() 方法——> 得到完整的“包类”名称
（二）Java反射机制提供的功能
-
在运行时 判断任意一个对象所属的类
-
在运行时 构造任意一个类的对象
-
在运行时 判断任意一个类所具有的成员变量和方法
-
在运行时 调用任意一个对象的成员变量和方法
-
在运行时 获得泛型信息
-
在运行时 处理注解
-
生成动态代理
（三）反射优缺点
-
优点：可以实现动态创建对象和编译，体现出很大的灵活性
-
缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且使它满足我们的要求。这类操作总是慢于直接执行相同的操作
（四）反射相关的主要API
- java.lang.Class：代表一个类
- java.lang.reflect.Method：代表类的方法
- java.lang.reflect.Field：代表类的成员变量
- java.lang.reflect.Constructor：代表类的构造器
（五）Class类
1. getClass()方法
- 在Object类中定义了 getClass() 方法，此方法被所有子类所继承
- 该方法返回值是一个Class类，此类是Java反射的源头，可以通过对象反射求出类的名称
2. Class对象由JRE保留
对于每个类，JRE 都为其保留一个不变的 Class 类型的对象。
3. Class对象包含信息
- 一个Class对象包含了特定某个结果（class、interface、enum、annotation、primitive type、void、[]）的有关信息
-
Class本身也是一个类
-
Class对象只能由系统建立对象
-
一个加载的类在 JVM 中只会有一个Class实例
-
一个Class对象对应的是一个加载到JVM中的一个 .class文件
-
每个类的实例都会记得自己是由哪个 Class实例所生成
-
Class类是Reflection的根源，针对任何你想动态加载、运行的类、唯有先获得相应的Class对象
-
4. Class 类常用方法
| 方法名 | 功能 |
|---|---|
| static ClassforName(String name) | 返回指定类名name的Class对象 |
| T newInstance() | 调用缺省构造函数，返回Class对象的一个实例 |
| String getName() | 返回此Class对象所表示的实体（类、接口、数组类、void）的名称 |
| public native Class<? super T> getSuperclass() | 返回当前Class对象的父类的Class对象 |
| Class<?>[] getInterfaces() | 返回当前Class对象的接口（数组） |
| ClassLoader getClassLoader() | 返回该类的类加载器 |
| Constructor<?>[] getConstructors() | 返回一个包含某些Constructor对象的数组 |
| Method getMethod(String name, Class<?>… parameterTypes) | 返回一个Method对象，此对象的形参类型为paramType |
| Field[] getDeclaredFields() | 返回Field对象的一个数组 |
5. 获取Class类的实例
- （1）若已知具体的类，通过类的Class属性获取，该方法最为安全可靠，程序性能最高。
Class c = Parent.class;
- （2）已知某个类的实例，调用该实例的getClass() 方法获取Class对象
Parent parent = new Parent();
Class c = parent.getClass();
- （3）已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName() 获取（抛出异常：ClassNotFountException）
try {
Class c3 = Class.forName("reflection.Test01");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
- （4）内置基本数据类型可以直接用 类名.Type
- （5）还可以利用ClassLoader
6. 拥有Class对象的类型
- class：外部类，成员（成员内部类、静态内部类），局部内部类，匿名内部类
- interface：接口
- []，[][]：数组
- enum：枚举
- annotation：注解@interface
- primitive type：基本数据类型
- void
interface testInterface{ }
enum testEnum { }
@interface testAnnotation{ }
public static void main(String[] args) {
System.out.println(Test06.class);
System.out.println(testInterface.class);
System.out.println(int[].class);
System.out.println(String[][].class);
System.out.println(testEnum.class);
System.out.println(testAnnotation.class);
System.out.println(float.class);
System.out.println(void.class);
/*
class reflection.Test06
interface reflection.Test06$testInterface
class [I
class [[Ljava.lang.String;
class reflection.Test06$testEnum
interface reflection.Test06$testAnnotation
float
void
*/
}
四、Java内存
- 堆：
- 存放new的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
- 栈：
- 存放基本变量类型（会包含这个基本类型的具体数值）
- 引用对象的变量（会存放这个引用在堆里面的具体地址）
- 方法区（内存上属于堆）
- 可以被所有的线程共享
- 包含了所有的class和static变量
五、类加载过程
类的初始化：程序使用类，将类加载到内存中
1. 先是 类的加载（Load）
- 由类的加载器完成：
- 将类的class文件 字节码读入内存
- 并将这些 静态数据 换成 方法区 的运行时数据结构
- 然后创建一个代表这个类的 java.lang.Class对象
2. 再是 类的链接（Link）
- 将Java类的二进制代码合并到JVM的运行状态之中
- 验证：确保加载的类信息符合JVM规范，没有安全的问题
- 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将方法区中分配
- 解释：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）
3. 最后 类的初始化（Initialize）
- JVM负责对类进行初始化
- 执行类构造器 () 方法的过程。类构造器 () 方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
- 虚拟机会保证一个类的 () 方法在多线程环境中被正确加锁和同步
六、类初始化发生时机
-
类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new 一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用 java.lang.reflect 包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类
-
类的被动引用（不会发生类的初始化）
- 当访问一个静态域，只有真正声明这个（静态）域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池）
七、类加载器
-
类加载的作用：
- 将class文件字节码内容加载到内存中，并将这些静态数据转化成方法区的运行时数据结构，然后在堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口
-
类加载：
- 标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。
- JVM垃圾回收机制可以回收这些Class对象
-
源文件（java文件）——> Java编译器 ——> 字节码（class文件）——> 类加载器 ——> 字节码校验器 ——> 解释器 ——> 操作系统平台
-
JVM规范定义的类型加载器
- 引导类加载器：用C++编写，是JVM自带的类加载器，负责Java平台核心库（rt.jar），用来装载核心类库。该加载器无法直接获取
- 扩展类加载器：负责jre/lib/ext目录下的jar包或 - D java.ext.dirs 指定目录下的jar包安装入工具库
- 系统类加载器：负责java -classpath 或 -Ｄ java.class.path所指的目录下的类与jar包安装入工作路径，是常用的加载器
-
检查类是否已加载的方向
自定义类加载器 —— > System Classloader —— > Extension Classloader —— > Bootstap Classloader -
尝试加载类的方向
Bootstap Classloader —— > Extension Classloader —— > System Classloader —— > 自定义类加载器
//获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
//获取系统类加载器的父类------>扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
//获取扩展类加载器的父类------>根加载器（C++）
ClassLoader parentParent = parent.getParent();
System.out.println(systemClassLoader);
System.out.println(parent);
System.out.println(parentParent);
ClassLoader classLoader = null;
try {
//获得当前类由哪一个加载器加载
classLoader = Class.forName("reflection.Text02").getClassLoader();
System.out.println(classLoader);
//获得jdk中Object类由哪一个加载器加载
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//获得系统类加载器可以加载的路径
System.out.println(System.getProperty("java.class.path"));
八、获取运行时类的完整结构
- 通过反射（Class对象方法）获取运行时类的完整结构
- Field、Method、Constructor、Superclass、Interface、Annotation
- 实现的全部接口
- 所继承的父类
- 全部的构造器
- 全部的方法
- 全部的Field
- 注解
Class对象的作用
1. 创建类的对象
-
调用Class对象的 newInstance() 方法
-
类必须有一个无参数的构造器
-
类的构造器的访问权限要足够
-
当类没有无参数构造器时，必须要在操作的时候，明确的调用类中的构造器，并将参数传递进去，才可以实例化操作：
1）通过Class类的 getDeclaredConstructor(Class … parameterTypes) 取得本类的指定形参类型的构造器
2） 向构造器的形参中传递一个对象数组，里面包含了构造器所需要的各个参数
3）通过 Constructor 实例化对象
-
2. 调用指定的方法
-
通过反射，调用类中的方法，通过Method类完成
-
通过Class类的 getMethod(String name,Class…parameterTypes) 方法取得一个Method对象，并设置此方法操作时所需要的参数类型
-
之后使用 Method对象的 invoke(Object obj,Objectp[] args)进行调用，并向方法中传递要设置的obj对象的参数信息
-
-
两个重要的方法
-
Object invoke(Object obj,Objectp[] args)
1）Object 对应原方法的返回值，若原方法无返回值，此时为null
2）若原方法是静态方法，此时形参Object obj 可为null
3）若原方法形参列表为空，则Objectp[] args为null
4）若原方法声明为 private，则需要在调用此 invoke() 方法之前，显式调用方法对象的setAccessible(true) 方法，将可访问private 修饰的方法 -
void setAccessible(boolean flag)
1）Method、Field、Constructor 对象都有 setAccessible() 方法
2）setAccessible 作用：启动和禁用访问安全检查的开关
3）参数值为 true：指示反射的对象在使用时应该取消Java语言访问检查
4）参数值为 false：指示反射的对象应该实施java语言访问检查
5）设置 true的时机：想要使得原本无法访问的私有成员也可以访问；如果代码必须用反射，而且代码被频繁的调用，应该设置true
-
-
测试代码
package reflection;
public class Test03 {
public static void main(String[] args) throws Exception {
//获得Class对象
Class<?> userclass = Class.forName("reflection.User");
//构造一个对象
User user1 = (User)userclass.newInstance();//本质调用了该类的 无参构造方法
System.out.println(user1);
//通过构造器创建对象
//得到 指定参数 列表的构造方法
Constructor<?> constructor = userclass.getDeclaredConstructor(int.class, String.class);
User user2 = (User)constructor.newInstance(18, "测试获取的构造方法");
System.out.println(user2);
//通过反射获取 非构造方法
Method setName = userclass.getDeclaredMethod("setName", String.class);
setName.invoke(user1,"测试普通方法");
System.out.println(user1);
//通过反射操作 属性
Field age = userclass.getDeclaredField("age");//该属性是私有的
//不能操作私有属性
//accessible adj. 易接近的；可进入的；可理解的
age.setAccessible(true);//关闭安全检查。将属性设置为可接近的属性
age.set(user1,28);
System.out.println(user1);
Method setAge = userclass.getDeclaredMethod("setAge", int.class);
setAge.invoke(user1,23);
System.out.println(user1);
}
}
class User {
private int age;
private String name;
public User() {
}
public User(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
3. 反射操作泛型
-
Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
-
为了通过反射操作这些类型，Java新增了 ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 几种类型来代表：不能被归一到 Class类中的类型但是又和原始类型齐名的类型
- ParameterizedType：表示一种参数化类型，比如：Collection**
- GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
- TypeVariable ：是各种类型变量的公共父接口
- WildcardType ：代表一种通配符类型表达式
-
测试代码
public class Test {
public static void main(String[] args) {
try {
Class mapClass = Class.forName("reflection.MyMap");
Method setMap = mapClass.getMethod("setMap", Map.class, int.class);
//GenericArrayType：表示一种元素类型是 参数化类型或者类型变量 的数组类型
Type[] genericParameterTypes = setMap.getGenericParameterTypes();
for(Type type : genericParameterTypes) {
System.out.println(type);
//ParameterizedType：表示一种参数化类型，比如：Collection<String>
if(type instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();//实际类型参数
for (Type actualTypeArgument : actualTypeArguments) {
System.out.println(actualTypeArgument);
}
}
}
System.out.println("==========");
Method getMap = mapClass.getMethod("getMap", null);
Type genericReturnType = getMap.getGenericReturnType();
System.out.println(genericReturnType);
if(genericReturnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for(Type type : actualTypeArguments) {
System.out.println(type);
}
}
} catch (ClassNotFoundException | NoSuchMethodException e) {
e.printStackTrace();
}
}
}
class MyMap
{
private Map<String,Integer> map = null;
public Map<String, Integer> getMap() {
return map;
}
public void setMap(Map<String, Integer> map, int i) {
this.map = map;
}
}
4. ORM
-
Object relationship Mapping --> 对象关系映射
- 类和数据库表结构对应
- 属性和字段对应
- 对象和行记录对应
-
利用注解和反射完成类和表结构的映射关系
-
反射操作注解
public class Test05 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class personClass = Class.forName("reflection.Person");
//通过反射获得注解
Annotation[] annotations = personClass.getAnnotations();
for(Annotation annotation : annotations) {
System.out.println(annotation);
// System.out.println(annotation instanceof Table);
}
//获得指定注解 的value值
Table table = (Table)personClass.getAnnotation(Table.class);
System.out.println(table.value());
//获得类中指定属性的注解
Field id = personClass.getDeclaredField("id");
TableField annotation = id.getAnnotation(TableField.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@Table("db_Person")
class Person {
@TableField(columnName = "db_id",type = "int", length = 10)
private int id;
@TableField(columnName = "db_name",type = "varchar", length = 20)
private String name;
@TableField(columnName = "db_age", type = "int", length = 3)
private int age;
public Person() {
}
public Person(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
//数据库表的对应类名注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
String value();
}
//属性注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableField{
String columnName();
String type();
int length();
}
331
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
