反射

类加载器

类加载

当程序要使用某个类时，如果该类还没有加载到内存中，则系统会通过类的加载、类的连接、类的初始化这三个步骤来对类进行初始化。如果不出现意外情况，JVM将连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或类初始化。

类的加载器的作用
  • 就是指将class文件读入内存，并为之创建一个java.lang.Class对象
  • 任何类被使用时，系统都会为之建立一个java.lang.Class对象

JVM的类加载机制
  • 全盘负责：
  • 父类委托：
  • 缓存机制：

类的连接
  • 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
  • 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
  • 解析阶段：将的类的二进制数据中的符号引用替换为直接引用

类的初始化
  • 在该阶段，主要就是对类变量进行初始化

类初始化的步骤

  • 假如类还未被加载和连接，则程序先加载并连接该类
  • 假如该类的直接父类还未被初始化，则先初始化其直接父类
  • 假如该类有初始化语句，则系统依次执行这些初始化语句

需要注意的是：在执行第二个步骤的时候，系统对直接父类的初始化步骤也遵循初始化步骤1-3

类的初始化时机/什么时候会触发类初始化

  • 创建类的实例
  • 调用类的类方法
  • 访问类或者接口的类变量，或者为该类变量赋值
  • 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
  • 初始化某个类的子类
  • 直接使用java.exe命令来运行某个主类

反射类

反射类的构造方法

反射类的字段

反射类的方法

JSON

JSON是一种数据格式，本质上是一个字符串。JSON是JavaScript对象的字符串表现形式，在JS中对象是用{}表示，数组使用[]表示。

  1. let student = {
  2.     age: 18,
  3.     name: 'zs'
  4. }
  6. let fruits = ['apple', 'tomato', 'banana']

使用JSON-lib解析JSON

JSON 转对象
  1.  String json = "{age:18,name:'zs'}";
  2. JSONObject jsonObject = new JSONObject(json);
  3. int age = jsonObject.getInt("age");
  4. String name = jsonObject.getString("zs");
  5. Student student = new Student(age, name);
  6. System.out.println(student);

JSON转复杂对象
  1. public static void main(String[] args) throws JSONException {
  2.     String json = "{age:19,name:'ls',score:{java:10,php:20,database:40,c:58}}";
  3.     JSONObject jsonObject = new JSONObject(json);
  4.     int age = jsonObject.getInt("age");
  5.     String name = jsonObject.getString("name");
  6.     JSONObject score1 = jsonObject.getJSONObject("score");
  7.     int java = score1.getInt("java");
  8.     int php = score1.getInt("php");
  9.     int database = score1.getInt("database");
  10.     int c = score1.getInt("c");
  11.     Score score = new Score(java, php, database, c);
  12.     Student student = new Student(age, name, score);
  13.     System.out.println(student);
  14. }

JSON转数组
  1. public static void main(String[] args) throws JSONException {
  2.     String json = "[{java:2,php:3,database:5,c:22},{java:3,php:5,database:6,c:26}]";
  3.     JSONArray jsonArray = new JSONArray(json);
  4.     List<Score> scoreList = new ArrayList<>();
  5.     for (int i = 0; i < jsonArray.length(); i++) {
  6.         JSONObject jsonObject = jsonArray.getJSONObject(i);
  7.         int java = jsonObject.getInt("java");
  8.         int php = jsonObject.getInt("php");
  9.         int database = jsonObject.getInt("database");
  10.         int c = jsonObject.getInt("c");
  11.         scoreList.add(new Score(java, php, database, c));
  12.     }
  13.     System.out.println(scoreList);
  14. }

JSON转复杂数组对象
  1. public static void main(String[] args) throws JSONException {
  2.     String json = "[{age:2,name:'zs',score:{java:2,php:3,database:5,c:22}},{age:19,name:'ls',score:{java:3,php:5,database:6,c:26}}]";
  3.     List<Student> studentList = new ArrayList<>();
  4.     JSONArray jsonArray = new JSONArray(json);
  5.     for (int i = 0; i < jsonArray.length(); i++) {
  6.         JSONObject jsonObject = jsonArray.getJSONObject(i);
  7.         int age = jsonObject.getInt("age");
  8.         String name = jsonObject.getString("name");
  9.         JSONObject scoreJsonObject = jsonObject.getJSONObject("score");
  10.         int java = scoreJsonObject.getInt("java");
  11.         int php = scoreJsonObject.getInt("php");
  12.         int database = scoreJsonObject.getInt("database");
  13.         int c = scoreJsonObject.getInt("c");
  14.         studentList.add(new Student(age, name, new Score(java, php, database, c)));
  15.     }
  16.     System.out.println(studentList);
  17. }

对象转JSON
  1. public static void main(String[] args) {
  2.     Student student = new Student(19, "zs");
  3.     JSONObject jsonObject = new JSONObject(student);
  4.     System.out.println(jsonObject.toString());
  5. }

数组转JSON
  1. public static void main(String[] args) {
  2.     List<Student> studentList = new ArrayList<>();
  3.     studentList.add(new Student(19, "za", new Score(1, 2, 3, 45)));
  4.     studentList.add(new Student(12, "zc", new Score(12, 32, 23, 15)));
  5.     studentList.add(new Student(13, "zg", new Score(13, 22, 23, 25)));
  6.     studentList.add(new Student(15, "zc", new Score(15, 25, 23, 35)));
  8.     JSONArray jsonArray = new JSONArray(studentList);
  9.     System.out.println(jsonArray.toString());
  10. }

使用fastjson

  1. public static void main(String[] args) {
  2.         // 1. json -> 对象
  3.         String json = "{age:18,name:'zs'}";
  4.         Student student = JSON.parseObject(json, Student.class);
  5.         System.out.println(student);
  7.         // 2. json -> 对象
  8.         String json1 = "{age:19,name:'ls',score:{java:10,php:20,database:40,c:58}}";
  9.         Student student1 = JSON.parseObject(json1, Student.class);
  10.         System.out.println(student1);
  12.         // 3. json -> 对象数组
  13.         String json2 = "[{java:2,php:3,database:5,c:22},{java:3,php:5,database:6,c:26}]";
  14.         List student2 = JSON.parseArray(json2, Student.class);
  15.         for (int i = 0; i < student2.size(); i++) {
  16.             Object o = student2.get(i);
  17.             System.out.println(o);
  18.         }
  20.         // 4. json -> 泛型对象数组
  21.         String json3 = "[{age:2,name:'zs',score:{java:2,php:3,database:5,c:22}},{age:19,name:'ls',score:{java:3,php:5,database:6,c:26}}]";
  22. //        Type typeToken = new TypeToken<ArrayList<Student>>(){}.getType();
  23.         List<Student> studentList = JSON.parseArray(json3, Student.class);
  24.         for (int i = 0; i < studentList.size(); i++) {
  25.             System.out.println(studentList.get(i));
  26.         }
  28.         // 5. 普通对象 -> json
  29.         Student o = new Student(19, "zs");
  30.         System.out.println(JSON.toJSONString(o));
  32.         // 6. 数组对象 -> json
  33.         List<Student> s1 = new ArrayList<>();
  34.         s1.add(new Student(19, "za", new Score(1, 2, 3, 45)));
  35.         s1.add(new Student(12, "zc", new Score(12, 32, 23, 15)));
  36.         s1.add(new Student(13, "zg", new Score(13, 22, 23, 25)));
  37.         s1.add(new Student(15, "zc", new Score(15, 25, 23, 35)));
  38.         System.out.println(JSON.toJSONString(s1));
  39. }

使用gson

  1. public static void main(String[] args) {
  2.         // 1. json -> 对象
  3.         String json = "{age:18,name:'zs'}";
  4.         Gson gson = new Gson();
  5.         Student student = gson.fromJson(json, Student.class);
  6.         System.out.println(student);
  8.         // 2. json -> 对象
  9.         String json1 = "{age:19,name:'ls',score:{java:10,php:20,database:40,c:58}}";
  10.         Student student1 = gson.fromJson(json1, Student.class);
  11.         System.out.println(student1);
  13.         // 3. json -> 对象数组
  14.         String json2 = "[{java:2,php:3,database:5,c:22},{java:3,php:5,database:6,c:26}]";
  15.         List student2 = gson.fromJson(json2, ArrayList.class);
  16.         for (int i = 0; i < student2.size(); i++) {
  17.             Object o = student2.get(i);
  18.             System.out.println(o);
  19.         }
  21.         // 4. json -> 泛型对象数组
  22.         String json3 = "[{age:2,name:'zs',score:{java:2,php:3,database:5,c:22}},{age:19,name:'ls',score:{java:3,php:5,database:6,c:26}}]";
  23.         Type typeToken = new TypeToken<ArrayList<Student>>(){}.getType();
  24.         List<Student> studentList = gson.fromJson(json3, typeToken);
  25.         for (int i = 0; i < studentList.size(); i++) {
  26.             System.out.println(studentList.get(i));
  27.         }
  29.         // 5. 普通对象 -> json
  30.         Student o = new Student(19, "zs");
  31.         System.out.println(gson.toJson(o));
  33.         // 6. 数组对象 -> json
  34.         List<Student> s1 = new ArrayList<>();
  35.         s1.add(new Student(19, "za", new Score(1, 2, 3, 45)));
  36.         s1.add(new Student(12, "zc", new Score(12, 32, 23, 15)));
  37.         s1.add(new Student(13, "zg", new Score(13, 22, 23, 25)));
  38.         s1.add(new Student(15, "zc", new Score(15, 25, 23, 35)));
  39.         System.out.println(gson.toJson(s1));
  41.     }

实现一个简单的JSON解析工具

  1. package com.shaw.json;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Objects;
  7. public class RabbitJSON {
  8.     /* key-value 映射 key:属性 value:值 */
  9.     private Map<String, String> map;
  10.     /* 调式 */
  11.     public Map<String, String> getMap() {
  12.         return map;
  13.     }
  15.     public RabbitJSON() {
  16.         this.map = new HashMap<>();
  17.     }
  19.     /**
  20.      *
  21.      * @param JSONString JSON字符串
  22.      */
  23.     public RabbitJSON(String JSONString) {
  24.         this(new JSONCharParser(JSONString));
  25.     }
  27.     /**
  28.      *
  29.      * @param jsonCharParser JSON字符解析器 com.shaw.json.JSONCharParser
  30.      */
  31.     public RabbitJSON(JSONCharParser jsonCharParser) {
  32.         this();
  33.         // JSON对象字符串不是以'{'开头
  34.         if (jsonCharParser.next() != '{') {
  35.             throw new JSONSyntaxException("JSON对象字符串不是以 { 开头");
  36.         }
  37.         while (true) {
  38.             char c = jsonCharParser.nextClean();
  39.             // a
  40. //            System.out.println(c);
  41.             switch (c) {
  42.                 case '\u0000': // \u0000 Unicode 空白字符
  43.                     throw new JSONSyntaxException("JSON对象格式不正确,包含空格");
  44.                 case '}': // }:JSON语法结束标记
  45.                     return;
  46.                 default:
  47.                     // 回退
  48.                     jsonCharParser.back();
  49.                     // 读取对象的key
  50.                     String key = jsonCharParser.nextValue().toString();
  51.                     System.out.println("key = " + key);
  52.                     // :
  53.                     c = jsonCharParser.nextClean();
  54.                     System.out.println("c = " + c);
  55.                     if (c != ':') {
  56.                         throw new JSONSyntaxException("JSON 语法错误,在附近" + key + c);
  57.                     }
  58.                     // 读取对象的value
  59.                     this.map.put(key, jsonCharParser.nextValue().toString());
  60.                     switch (jsonCharParser.nextClean()) {
  61.                         case ',':
  62.                         case ';':
  63.                             if (jsonCharParser.nextClean() == '}') {
  64.                                 return;
  65.                             }
  66.                             jsonCharParser.back();
  67.                             break;
  68.                         case '}':
  69.                             return;
  70.                         default:
  71.                             throw new JSONSyntaxException("JSON语法错误");
  72.                     }
  73.             }
  74.         }
  75.     }
  77.     /**
  78.      * JSON语法错误异常
  79.      * @author Shaw
  80.      */
  81.     private static class JSONSyntaxException extends IllegalArgumentException {
  82.         public JSONSyntaxException() {
  83.             super();
  84.         }
  86.         public JSONSyntaxException(String s) {
  87.             super(s);
  88.         }
  90.         public JSONSyntaxException(String message, Throwable cause) {
  91.             super(message, cause);
  92.         }
  94.         public JSONSyntaxException(Throwable cause) {
  95.             super(cause);
  96.         }
  97.     }
  99.     public Object get(String key) {
  100.         Object value = this.map.get(key);
  101.         return Objects.requireNonNull(value, "value 为 null");
  102.     }
  104.     public boolean getBoolean(String key) {
  105.         Object value = this.get(key);
  108.         if (value.equals(Boolean.TRUE) || ((value instanceof String) && ((String) value).equalsIgnoreCase("true"))) {
  109.             return true;
  110.         } else if (value.equals(Boolean.FALSE) || ((value instanceof String) && ((String) value).equalsIgnoreCase(
  111.                 "false"))) {
  112.             return false;
  113.         } else {
  114.             throw new JSONSyntaxException("值解析失败" + value);
  115.         }
  116.         // 不等于 Boolean.FALSE 并且也不是 String类型 或者 强转成String类型忽略大小写匹配不等于false
  117. //        if (!value.equals(Boolean.FALSE) && (!(value instanceof String) || !((String) value).equalsIgnoreCase("false"))) {
  118. //            if (!value.equals(Boolean.TRUE) && (!(value instanceof String) || !((String) value).equalsIgnoreCase("true"))) {
  119. //                throw new JSONSyntaxException("值解析失败:" + value);
  120. //            } else {
  121. //                return false;
  122. //            }
  123. //        } else {
  124. //            return false;
  125. //        }
  126.     }
  128.     public double getDouble(String key) throws ClassCastException {
  129.         Object value = this.get(key);
  130.         return value instanceof Number ? ((Number) value).doubleValue() : Double.parseDouble((String) value);
  131.     }
  133.     public int getInt(String key) {
  134.         Object value = this.get(key);
  135.         return value instanceof Number ? ((Number) value).intValue() : Integer.parseInt((String) value);
  136.     }
  138.     public String getString(String key){
  139.         return this.get(key).toString();
  140.     }
  141. }
  1. package com.shaw.json;
  3. import java.io.IOException;
  4. import java.io.Reader;
  5. import java.io.StringReader;
  7. public class JSONCharParser {
  8.     /* 字符读取器 */
  9.     private Reader reader;
  11.     /* 是否到达结尾 */
  12.     private boolean eof;
  14.     /* 字符数量 */
  15.     private int charCount;
  17.     /* 行数 */
  18.     private int lineCount;
  20.     /* 索引 */
  21.     private int index;
  23.     /* 上一个字符 */
  24.     private char previous;
  26.     /* 是否有上一个字符 */
  27.     private boolean hasPrevious;
  29.     public JSONCharParser(String JSONString) {
  30.         this(new StringReader(JSONString));
  31.         this.eof = false;
  32.         this.charCount = 0;
  33.         this.lineCount = 0;
  34.         this.index = 0;
  35.         this.previous = 0;
  36.         this.hasPrevious = false;
  37.     }
  39.     public JSONCharParser(Reader reader) {
  40.         this.reader = reader;
  41.     }
  43.     /**
  44.      * 获取JSON字符串中的下一个字符
  45.      *
  46.      * @return 下一个字符 如果没有将返回  ASCII 对应的0 也就是空白字符
  47.      */
  48.     public char next() {
  49.         int c = -1;
  50.         if (this.hasPrevious) {
  51.             this.hasPrevious = false;
  52.             c = this.previous;
  53.         } else {
  54.             try {
  55.                 // 读取下一个字符
  56.                 c = this.reader.read();
  57.             } catch (IOException e) {
  58.                 e.printStackTrace();
  59.             }
  60.             // 到达文件结尾
  61.             if (c < 0) {
  62.                 this.eof = true;
  63.                 c = 0;
  64.             }
  65.         }
  66.         // 记录索引+1
  67.         this.index++;
  68.         // 换行符
  69.         /*
  70.          * ASCII:
  71.          * 0 空字符
  72.          * 1 标题开始
  73.          * 10 换行键
  74.          * */
  75.         if (c == '\r') {
  76.             // 记录行数+1
  77.             this.lineCount++;
  78.             this.charCount = c == 10 ? 0 : 1;
  79.         } else if (c == 10) {
  80.             this.lineCount++;
  81.             this.charCount = 0;
  82.         } else {
  83.             this.charCount++;
  84.         }
  86.         this.previous = (char) c;
  87.         return this.previous;
  88.     }
  90.     /**
  91.      * 获取非空白字符的下一个字符 不包括
  92.      * 1. 空白字符
  93.      * 2. 换行字符
  94.      *
  95.      * @return 字符
  96.      */
  97.     public char nextClean() {
  98.         char c;
  99.         do {
  100.             c = this.next();
  101.         } while (c != 0 && c <= ' ');
  102.         return c;
  103.     }
  105.     /**
  106.      * 回退
  107.      */
  108.     public void back() {
  109. //        if (this.hasPrevious && this.index > 0) {
  110.         if (this.index > 0) {
  111.             this.charCount--;
  112.             this.index--;
  113.             this.hasPrevious = true;
  114.             this.eof = true;
  115.         } else {
  116.             throw new JSONException();
  117.         }
  118.     }
  120.     private static class JSONException extends IllegalArgumentException {
  121.         public JSONException() {
  122.             super();
  123.         }
  125.         public JSONException(String s) {
  126.             super(s);
  127.         }
  129.         public JSONException(String message, Throwable cause) {
  130.             super(message, cause);
  131.         }
  133.         public JSONException(Throwable cause) {
  134.             super(cause);
  135.         }
  136.     }
  138.     /**
  139.      * 返回JSON字符串的key或者value
  140.      *
  141.      * @return 字符串的value 或者 对象的value
  142.      */
  143.     public Object nextValue() {
  144.         int c = this.nextClean();
  145.         switch (c) {
  146.             // key 已 " 或 '包含,例 'age'
  147.             case '"':
  148.             case '\'':
  149.                 // \'
  150.                 return this.nextString((char) c);
  151.             // 对象
  152.             case '{':
  153.                 this.back();
  154.                 // return new Object();
  155.                 break;
  156.             // 其他情况 比如 {age:10} 不已 ' 或 " 包含
  157.             default:
  158.                 StringBuilder sb = new StringBuilder();
  159.                 // :}]" 表示结束
  160.                 // ,;=# 表示非法字符
  161. //                System.out.println("(char)c = " + (char) c);
  162.                 for (; c >= ' ' && ",:]}\\\";=#".indexOf(c) < 0; c = this.next()) {
  163.                     sb.append((char) c);
  164.                 }
  165. //                System.out.println("sb.toString() = " + sb.toString());
  166.                 this.back();
  167.                 String s = sb.toString().trim();
  168. //                System.out.println("s = " + s);
  169.                 if ("".equals(s)) {
  170.                     throw new JSONException("JSON语法错误");
  171.                 } else {
  172.                     // stringToValue
  173.                     return s;
  174.                 }
  175. //                break;
  176.         }
  177.         return null;
  178.     }
  180.     /**
  181.      * @param quote \'
  182.      * @return key
  183.      */
  184.     public String nextString(char quote) {
  185.         StringBuilder sb = new StringBuilder();
  186.         while (true) {
  187.             // a
  188.             char c = this.next();
  189.             switch (c) {
  190.                 // 包含 空格、换行
  191.                 // Windows : \r\n
  192.                 // Linux: \r
  193.                 // Mac: \n
  194.                 case '\u0000':
  195.                 case '\r':
  196.                 case '\n':
  197.                     throw new JSONException("json格式错误");
  200.                     // 匹配转义字符
  201.                     // \r
  202.                     // \t
  203.                     // \\
  204.                 case '\\':
  205.                     c = this.next();
  206.                     switch (c) {
  207.                         // 转义符
  208.                         case '\'':
  209.                         case '"':
  210.                         case '\\':
  211.                         case '/':
  212.                             sb.append(c);
  213.                             continue;
  214.                             // 匹配回车 换行 制表符....
  215.                             // \b \f \n \r \t
  216.                         case 'b':
  217.                             sb.append('\b');
  218.                             continue;
  219.                         case 'f':
  220.                             sb.append('\f');
  221.                             continue;
  222.                         case 'n':
  223.                             sb.append('\n');
  224.                             continue;
  225.                         case 'r':
  226.                             sb.append('\r');
  227.                             continue;
  228.                         case 't':
  229.                             sb.append('\t');
  230.                             continue;
  231.                         default:
  232.                             throw new JSONException("非法转义字符 \\" + c);
  233.                     }
  234.                 default:
  235.                     if (c == quote) {
  236.                         return sb.toString();
  237.                     }
  238.                     sb.append(c);
  239.             }
  240.         }
  241.     }
  242. }

注解

注释，解释是代码级别的说明，增强代码的作用性，对于反射，只能反射RUNNTIME注解。

原注解

作用在注解上的注解

@Target

指示注解类型适用的上下文。注解类型可能适用的声明上下文和类型上下文。

EelementType

这个枚举常量提供了Java程序中可能出现注解语法位置的简单分类，用于Target元注解，以指定写入给定类型注释的合法位置。

  • ANNOTATION_TYPE:注解类型声明
  • CONSTRUCTOR:构造函数声明
  • FIELD:字段声明包括枚举常数
  • METHOD:方法声明
  • MODULE:模块声明
  • PACKAGE:包装声明
  • PARAMETER:参数声明
  • TYPE:类、接口（包括注解类型）或枚举声明
  • TYPE_PARAMETER:键入参数声明
  • TYPE_USE:使用类型

@Retention

指示要注释具有注解类型的注解保留时间。如果注解类型声明中没有保留注解，则保留策略默认为RetentionPolicy.CLASS。保留原注注解仅在原注解类型直接用于注解时才起作用。如果原注解类型用作另一注解类型的成员类型，则它不起作用。

Retention Policy

  • CLASS:注解将由编译器记录在类文件中，但VM不需要在运行时保留。
  • SOURCE:注解将由编译器丢弃。
  • RUNTIME:注解将被编译器记录在类文件中，并由VM在运行时保留，因此可以反射获取。