package com.example;

public class Main {
    public static void main(String[] args) {
        // 1. 获取当前自定义类的加载器
        ClassLoader appClassLoader = Main.class.getClassLoader();
        System.out.println("应用程序类加载器 (AppClassLoader): " + appClassLoader);

        // 2. 获取其父加载器 -> 扩展类加载器
        ClassLoader extClassLoader = appClassLoader.getParent();
        System.out.println("扩展类加载器 (ExtClassLoader): " + extClassLoader);

        // 3. 获取扩展类加载器的父加载器 -> 启动类加载器
        ClassLoader bootstrapClassLoader = extClassLoader.getParent();
        // 因为启动类加载器是C++实现的，无法在Java中获取其实体，所以返回null
        System.out.println("启动类加载器 (BootstrapClassLoader): " + bootstrapClassLoader);
        
        System.out.println("--- JDK核心类的加载器 ---");
        
        // 4. 尝试获取String类的加载器
        // String类由启动类加载器加载，因此在Java层面获取不到，返回null
        ClassLoader stringClassLoader = String.class.getClassLoader();
        System.out.println("String.class的加载器: " + stringClassLoader);
    }
}

package com.example;

class User {}

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        // 方式一: .class 语法
        Class<User> clazz1 = User.class;

        // 方式二: object.getClass()
        User user = new User();
        Class<?> clazz2 = user.getClass();

        // 方式三: Class.forName()
        Class<?> clazz3 = Class.forName("com.example.User");

        // 三种方式获取到的都是同一个Class对象实例
        System.out.println("clazz1 == clazz2 : " + (clazz1 == clazz2)); // true
        System.out.println("clazz1 == clazz3 : " + (clazz1 == clazz3)); // true
    }
}

package com.example;

import java.lang.reflect.Constructor;

class Student {
    private String name;
    private int age;

    public Student() {
        this.name = "默认学生";
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private Student(String name) { // 私有构造器
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + "}";
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class<Student> clazz = Student.class;

        // 1. 调用公共无参构造器
        Constructor<Student> c1 = clazz.getConstructor();
        Student s1 = c1.newInstance();
        System.out.println("调用无参构造器: " + s1);

        // 2. 调用公共有参构造器
        Constructor<Student> c2 = clazz.getConstructor(String.class, int.class);
        Student s2 = c2.newInstance("Alice", 18);
        System.out.println("调用有参构造器: " + s2);

        // 3. 调用私有构造器（暴力反射）
        Constructor<Student> c3 = clazz.getDeclaredConstructor(String.class);
        c3.setAccessible(true); // 必须设置可访问，否则会抛出IllegalAccessException
        Student s3 = c3.newInstance("Bob");
        System.out.println("调用私有构造器: " + s3);
    }
}

package com.example;

import java.lang.reflect.Method;

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    private void showInfo(String message) {
        System.out.println("私有方法被调用: " + message);
    }
    public static void printVersion() {
        System.out.println("Calculator Version 1.0");
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class<Calculator> clazz = Calculator.class;
        // 注意，我们默认没有指定构造器的修饰符，那么他就是default的，必须通过Declared来获取
        Calculator calculator = clazz.getDeclaredConstructor().newInstance();

        // 1. 调用公共方法
        Method addMethod = clazz.getMethod("add", int.class, int.class);
        Object result = addMethod.invoke(calculator, 10, 20);
        System.out.println("调用add(10, 20)的结果: " + result);

        // 2. 调用私有方法
        Method showInfoMethod = clazz.getDeclaredMethod("showInfo", String.class);
        // 调用私有方法时必须授权
        showInfoMethod.setAccessible(true);
        showInfoMethod.invoke(calculator, "Hello Reflection");

        // 3. 调用静态方法
        Method printVersionMethod = clazz.getMethod("printVersion");
        // 调用静态方法时，第一个参数（对象实例）传入null即可
        printVersionMethod.invoke(null);
    }
}

package com.example;

import java.lang.reflect.Field;

class Person {
    public String name;
    private int age = 20;
}

public class Main {
    public static void main(String[] args) throws Exception {
        Class<Person> clazz = Person.class;
        Person person = clazz.getDeclaredConstructor().newInstance();

        // 1. 操作公共字段
        Field nameField = clazz.getField("name");
        nameField.set(person, "张三");
        System.out.println("获取公共字段name: " + nameField.get(person));

        // 2. 操作私有字段
        Field ageField = clazz.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(person, 30);
        System.out.println("获取私有字段age: " + ageField.get(person));
    }
}

package com.example;

// 这是一个被框架调用的业务类
class UserService {
    public void login() {
        System.out.println("用户服务：正在执行登录逻辑...");
    }
    public void register() {
        System.out.println("用户服务：正在执行注册逻辑...");
    }
}

package com.example;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

// 这是一个被框架调用的业务类
class UserService {
    public void login() {
        System.out.println("用户服务：正在执行登录逻辑...");
    }

    public void register() {
        System.out.println("用户服务：正在执行注册逻辑...");
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        InputStream in = Main.class.getClassLoader().getResourceAsStream("app.properties");
        props.load(in);
        // 2. 从配置中获取类名和方法名
        String className = props.getProperty("className");
        String methodName = props.getProperty("methodName");

        // 3. 使用反射动态执行
        // a. 加载类
        Class<?> clazz = Class.forName(className);
        // b. 创建对象
        Object instance = clazz.getDeclaredConstructor().newInstance();
        // c. 获取方法
        Method method = clazz.getMethod(methodName);
        // d. 调用方法
        method.invoke(instance);
    }
}

package com.example.custom;

// 一个用于模拟数据库信息的注解
public @interface DataBaseInfo {
    String url();

    String user();

    String password();

    // 带有默认值的属性
    String driver() default "com.mysql.cj.jdbc.Driver";

    int port() default 3306;

    String[] characterSets() default {"UTF-8", "GBK"};
}

package com.example;
import com.example.custom.DataBaseInfo;

public class Main {
    // 使用自定义注解并为属性赋值
    @DataBaseInfo(
        url = "jdbc:mysql://localhost",
        user = "root",
        password = "password123",
        characterSets = "UTF-8" // 数组属性只有一个元素，省略了花括号
    )
    public void connectToDatabase() {
        // ...
    }
}

@Target(ElementType.METHOD) // 用在方法上
@Retention(RetentionPolicy.SOURCE) // 生命周期为源代码级别
public @interface Override {
}

package com.example.annotation;

import java.lang.annotation.*;

// @Table注解，用于类上，指定表名
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
    String value(); // 用value属性来接收表名
}

package com.example.orm.annotations;

import java.lang.annotation.*;

// @Column注解，用于字段上，指定列名和类型
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    String name();
    String type() default "varchar(255)"; // 默认类型为varchar
    int length() default 255;
}

package com.example.orm.entities;

import com.example.orm.annotations.*;

@Table("t_user") // 指定该类对应的表名为 t_user
public class User {
    @Column(name = "id", type = "int")
    private int id;

    @Column(name = "user_name")
    private String username;
    
    @Column(name = "user_age", type = "int")
    private int age;

    // email字段没有注解，将被忽略
    private String email;
}

package com.example;

import com.example.annotation.Column;
import com.example.annotation.Table;

import java.lang.reflect.Field;

public class Main {
    public static String generateCreateTableSql(String className) throws Exception {
        // 1. 获取Class对象
        Class<?> clazz = Class.forName(className);
        // 2. 检查类上是否有@Table注解
        if (!clazz.isAnnotationPresent(Table.class)) {
            return null; // 如果没有，则不是实体类，直接返回
        }
        // 3. 获取@Table注解并读取表名
        Table tableAnnotation = clazz.getAnnotation(Table.class);
        String tableName = tableAnnotation.value();

        StringBuilder sql = new StringBuilder();
        sql.append("CREATE TABLE ").append(tableName).append(" (\n");

        // 4. 遍历所有字段，查找@Column注解
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Column.class)) {
                // 5. 获取@Column注解并读取列名和类型
                Column columnAnnotation = field.getAnnotation(Column.class);
                String columnName = columnAnnotation.name();
                String columnType = columnAnnotation.type();

                sql.append("    ").append(columnName).append(" ").append(columnType).append(",\n");
            }
        }
        // 移除最后一个多余的逗号和换行符
        if (sql.toString().contains(",")) {
            sql.delete(sql.length() - 2, sql.length());
        }

        sql.append("\n);");
        return sql.toString();
    }

    public static void main(String[] args) throws Exception {
        String userSql = generateCreateTableSql("com.example.entities.User");
        System.out.println("--- 自动生成的User表SQL ---");
        System.out.println(userSql);
    }
}