Java107班三阶段课程学习

  @Test

    //获取Class --范围：所有的字节码文件

    public void test1() throws ClassNotFoundException {

        //方式一，通过类名

        Class c = Dog.class;   //Dog.java 编译后的字节码

        Class c1 = Book.class;   //Book.java编译后的字节码文件

//        方式二--通过对象

        Class c3 = new Dog().getClass();

//        方式三--通过类路径

        Class c4 = Class.forName("demo.Book");

        System.out.println(c4);

        System.out.println(c3);

    }

   //1.管理无参构造

    @Test

    public void test2() throws Exception {

        //1.获取到某个类的字节码文件对象，即class的对象

        Class<Dog> c = Dog.class;

//        2.帮你调用无参构造

        Dog dog = c.newInstance();

        System.out.println(dog);

    }

    //2.管理有参构造

    @Test

    public void test3() throws Exception {

//        1.获取到某个类的字节码文件对象，即class的对象

        Class<Dog> c = Dog.class;

//        2.获取有参构造的管理对象--2个参数的那个

        Constructor<Dog> con = c.getDeclaredConstructor(String.class);

//        3.帮助Dog类调用有参构造

        Dog dog = con.newInstance("旺财");

        System.out.println(dog);

    }

    //3.管理属性

    @Test

    public void test4() throws Exception {

        //1.获取到某个类的字节码文件对象，即Class的对象

        Class<Dog> c = Dog.class;

        //2.获取某个属性的管理对象

        Field f = c.getDeclaredField("name");

        //先创建一个狗狗对象

        Dog dog = c.newInstance();

        f.setAccessible(true); //开启私有属性操作权限

        //3.帮助dog给name属性赋值

        f.set(dog, "来福");

        System.out.println(dog);

    }

        //4.管理方法

    @Test

    public void test5() throws Exception {

        //1.获取到某个类的字节码文件对象，即Class的对象

        Class<Dog> c = Dog.class;

        //2.获取某个方法setAge(int age)的管理对象

        Method m = c.getDeclaredMethod("setAge", int.class);

        //先创建一个狗狗对象

        Dog dog = c.newInstance();

        //3.帮助dog给调用setAge方法

        m.invoke(dog, 3);

        System.out.println(dog);

        //管理toString方法

        Method m2 = c.getDeclaredMethod("toString");

        System.out.println(m2.invoke(dog));

    }

@Test

  public void testReflect() throws Exception {

    //加载文件

    Properties props = new Properties();

    ClassLoader classLoader = EmpServiceTest.class.getClassLoader();

    InputStream is = classLoader.getResourceAsStream("db.properties");

    props.load(is);

    //

    String className = props.getProperty("className");

    String methodName = props.getProperty("methodName");

    //

    Class<?> clazz = Class.forName(className);

    Object obj = clazz.newInstance();

    Method method = clazz.getMethod(methodName, String.class);

    method.invoke(obj, "熊康榕");

  }

<?xml version="1.0" encoding="UTF-8" ?>

<animal>

    <狗狗>

        <name>旺财</name>

        <class>reflect.pet.Dog</class>

    </狗狗>

    <企鹅>

        <name>皮皮</name>

        <class>reflect.pet.Penguin</class>

    </企鹅>

    <大象>

        <name>肉肉</name>

        <class>reflect.pet.Elephant</class>

    </大象>

</animal>

@Test

    public void test1() throws Exception {

        Scanner sc=new Scanner(System.in);

        System.out.println("请选择您要领养的宠物：狗狗，企鹅，大象");

        String name = sc.next();

        Animal animal = getAnimal(name);

        System.out.println(animal);

    }

    public Animal getAnimal(String name) throws Exception {

        // 1.创建解析器

        SAXReader reader = new SAXReader();

                     // 解析xml文档,得到document对象

        Document document = reader.read("src/reflect1/pet/pet.xml");

                     // 根据document对象获取根节点

        Element root = document.getRootElement();

                     // 查找根节点下的子节点 element() elements()

        Element animal = root.element(name);

        String className = animal.element("class").getText();

        //2.使用反射创建对象

        return (Animal) Class.forName(className).newInstance();

    }

@Test//案例一：将一个map中的数据转存到一个实体类对象中。

    public void test5() throws Exception {

        HashMap<String, Object> map = new HashMap<>();

        map.put("name","旺财");

        map.put("age",3);

        Dog dog = getObject(map, Dog.class);

        System.out.println(dog);

    }

    public <T>T getObject(Map<String,Object> map, Class<T> c) throws Exception {

        T t = c.newInstance();

        //1.拆开map

        Set<Map.Entry<String, Object>> entries = map.entrySet();

        for (Map.Entry<String, Object> entry : entries) {

            String key = entry.getKey();

            //2.将map中的值存入T这个类的对象属性中

            Field f = c.getDeclaredField(key);

            f.setAccessible(true);

            f.set(t,entry.getValue());

        }

        return t;

    }

public enum ElementType {

    /**标明该注解可以用于类、接口（包括注解类型）或enum声明*/

    TYPE,

    /** 标明该注解可以用于字段(域)声明，包括enum实例 */

    FIELD,

    /** 标明该注解可以用于方法声明 */

    METHOD,

    /** 标明该注解可以用于参数声明 */

    PARAMETER,

    /** 标明注解可以用于构造函数声明 */

    CONSTRUCTOR,

    /** 标明注解可以用于局部变量声明 */

    LOCAL_VARIABLE,

    /** 标明注解可以用于注解声明(应用于另一个注解上)*/

    ANNOTATION_TYPE,

    /** 标明注解可以用于包声明 */

    PACKAGE,

    /**

     * 标明注解可以用于类型参数声明（1.8新加入）

     * @since 1.8

     */

    TYPE_PARAMETER,

    /**

     * 类型使用声明（1.8新加入)

     * @since 1.8

     */

    TYPE_USE

}

import java.lang.annotation.ElementType; 

// 所有类型的class 

public class Test04 { 

    public static void main(String[] args) { 

        Class<Object> c1 = Object.class;    // 类 

        Class<Comparable> c2 = Comparable.class;    // 接口 

        Class<String[]> c3 = String[].class;  // 一维数组 

        Class<int[][]> c4 = int[][].class;   // 二维数组 

        Class<Override> c5 = Override.class;   // 注解 

        Class<ElementType> c6 = ElementType.class;   // 枚举 

        Class<Integer> c7 = Integer.class;   // 基本数据类型 

        Class<Void> c8 = void.class;   //void 

        Class<Class> c9 = Class.class;      // Class类型 

        System.out.println(c1); 

        System.out.println(c2); 

        System.out.println(c3); 

        System.out.println(c4); 

        System.out.println(c5); 

        System.out.println(c6); 

        System.out.println(c7); 

        System.out.println(c8); 

        System.out.println(c9); 

        // 只要元素类型与维度一样就是同一个Class。 

        int[] a = new int[10]; 

        int[] b = new int[100]; 

        System.out.println(a.getClass().hashCode()); 

        System.out.println(b.getClass().hashCode()); 

    } 

}

public class Test05 { 

    public static void main(String[] args) { 

        A a = new A(); 

        System.out.println(A.m); 

    } 

} 

class A{ 

    static { 

        System.out.println("A类静态代码块初始化"); 

        m = 300; 

    } 

    static int m = 100; 

    public A(){ 

        System.out.println("A类的无参数构造函数初始化"); 

    } 

}

public class Test07 { 

    public static void main(String[] args) throws ClassNotFoundException { 

        // 获取系统类的加载器 

        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); 

        //测试当前类是哪个类加载器加载的 

        ClassLoader classLoader = Class.forName("com.yjx.reflection.Test07").getClassLoader(); 

        System.out.println(classLoader); 

        // 测试JDK内置的类是谁加载的 

        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader(); 

        System.out.println(classLoader1); 

        //  如何获得系统类加载器可以加载的路径 

        System.out.println(System.getProperty("java.class.path")); 

    } 

}

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 ClassNotFoundException, NoSuchFieldException, NoSuchMethodException { 

        Class c1 = Class.forName("com.yjx.reflection.User"); 

//        User user = new User(); 

//        c1 = user.getClass();       //通过反射也能获得类Class 

        // 获得类的名字 

        System.out.println(c1.getName());       // 获得包名 + 类名 

        System.out.println(c1.getSimpleName());   // 获得类名 

        // 获得类的属性 

        System.out.println("================"); 

        Field[] fields = c1.getFields();      //  只能找到public属性 

        for (Field field : fields) { 

            System.out.println(field); 

        } 

        //  获得类的属性   能打印出来 

        System.out.println("=========="); 

        Field[] declaredFields = c1.getDeclaredFields();    // 找到全部的属性 

        for (Field declaredField : declaredFields) { 

            System.out.println(declaredField); 

        } 

        //  获得指定属性 

        System.out.println(c1.getDeclaredField("age")); 

        //获得类的方法 

        System.out.println("=====获得类的方法1=====");       //获得本类和父类的所有public方法：User类和Object类 

        Method[] methods = c1.getMethods(); 

        for (Method method : methods) { 

            System.out.println(method); 

        } 

        System.out.println("=====获得类的方法2====="); 

        Method[] declaredMethods = c1.getDeclaredMethods();       // 获得本类的所有方法 

        for (Method declaredMethod : declaredMethods) { 

            System.out.println(declaredMethod); 

        } 

        // 获得指定的方法 

        System.out.println("获得指定的方法============"); 

        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();    // 获得本类的public构造方法 

        for (Constructor constructor : constructors) { 

            System.out.println(constructor); 

        } 

        constructors = c1.getDeclaredConstructors();        // 获得本类所有的构造方法 

        for (Constructor constructor : constructors) { 

            System.out.println("****" + constructor); 

        } 

        // 需要指明构造器参数类型 

        System.out.println("获得指定构造器：" + c1.getDeclaredConstructor(null)); 

        System.out.println("获得指定构造器：" + c1.getDeclaredConstructor(int.class, int.class, String.class)); 

    } 

}

import java.lang.reflect.Field; 

import java.lang.reflect.InvocationTargetException; 

import java.lang.reflect.Method; 

//  动态的创建对象， 通过反射 

public class Test09 { 

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException { 

        // 获得class对象 

        Class c1 = Class.forName("com.yjx.reflection.User"); 

        // 构造一个对象   使用无参构造器 

//        User user = (User)c1.getDeclaredConstructor(null).newInstance();   //本质是调用了类的无参构造器 

//        System.out.println(user); 

        //  使用有参构造器创建对象 

        User user = (User) c1.getDeclaredConstructor(int.class, int.class, String.class).newInstance(18, 1, "yjx"); 

        System.out.println(user); 

        // 通过反射调用普通方法 

        User user1 = (User) c1.getDeclaredConstructor(int.class, int.class, String.class).newInstance(24, 2, "dyt"); 

        // 通过反射获取一个方法 

        Method setName = c1.getDeclaredMethod("setName", String.class); 

        setName.invoke(user1, "tt");       //invoke（）激活的意思，  (对象，“方法的值”) 

        System.out.println(user1.getName()); 

        // 通过反射操作属性 

        User user2 = (User) c1.getDeclaredConstructor(int.class, int.class, String.class).newInstance(22, 3, "dyt"); 

        Field name = c1.getDeclaredField("name"); 

        // 操作私有属性name   不能直接操作私有属性，我们需要关闭程序的安全检测，通过设置属性或者方法的setAccessible(true)实现  

        name.setAccessible(true);   // 关掉私有权限访问的问题 

        name.set(user2, "框看"); 

        System.out.println(user2.getName()); 

    } 

}

import java.lang.reflect.InvocationTargetException; 

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 < 1000000000; i++) { 

            user.getName(); 

        } 

        long endTime = System.currentTimeMillis(); 

        System.out.println("普通方式执行10亿次：" + (endTime - startTime) + "ms"); 

    } 

    // 反射方式调用 

    public static void test02() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { 

        User user = new User(); 

        Class c1 = user.getClass(); 

        Method getName = c1.getDeclaredMethod("getName",null); 

        long startTime = System.currentTimeMillis(); 

        for (int i = 0; i < 1000000000; i++) { 

            getName.invoke(user,null); 

        } 

        long endTime = System.currentTimeMillis(); 

        System.out.println("通过反射的方式调用10亿次：" + (endTime-startTime) + "ms"); 

    } 

    // 反射方式调用 + 关闭检测 

    public static void test03() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { 

        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 < 1000000000; i++) { 

            getName.invoke(user,null); 

        } 

        long endTime = System.currentTimeMillis(); 

        System.out.println("通过反射的方式和关闭检测调用10亿次：" + (endTime-startTime) + "ms"); 

    } 

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException { 

        test01(); 

        test02(); 

        test03(); 

    } 

}

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 static 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 NoSuchMethodException { 

        Method method = Test11.class.getDeclaredMethod("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(); 

                for (Type actualTypeArgument : actualTypeArguments) { 

                    System.out.println(actualTypeArgument); 

                } 

            } 

        } 

        Method method2 = Test11.class.getDeclaredMethod("test02", null); 

        Type genericReturnType = method2.getGenericReturnType(); 

        if (genericReturnType instanceof ParameterizedType){  //如果返回值类型是参数化类型/泛型 

            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments(); 

            for (Type actualTypeArgument : actualTypeArguments) { 

                System.out.println("**" + actualTypeArgument); 

            } 

        } 

    } 

}

// 类名的注解 

@Target(ElementType.TYPE) 

@Retention(RetentionPolicy.RUNTIME) 

@interface Tablekuang{ 

    String value(); 

} 

// 属性的注解 

@Target(ElementType.FIELD) 

@Retention(RetentionPolicy.RUNTIME) 

@interface Fieldkuang{ 

    String columnName(); 

    String type(); 

    int length(); 

}

@Tablekuang("db_student") 

class Student2{ 

    @Fieldkuang(columnName = "db_id",type = "int", length = 10) 

    private int id; 

    @Fieldkuang(columnName = "db_age",type = "int", length = 10) 

    private int age; 

    @Fieldkuang(columnName = "db_name",type = "varchar", length = 3) 

    private String name; 

    public Student2(int id, int age, String name) { 

        this.id = id; 

        this.age = age; 

        this.name = name; 

    } 

    @Override 

    public String toString() { 

        return "Student2{" + 

                "id=" + id + 

                ", age=" + age + 

                ", 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; 

    } 

    public String getName() { 

        return name; 

    } 

    public void setName(String name) { 

        this.name = name; 

    } 

    public Student2() { 

    } 

}

import java.lang.annotation.*; 

import java.lang.reflect.Field; 

// 练习反射操作注解 

public class Test12 { 

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException { 

        Class<?> c1 = Class.forName("com.yjx.reflection.Student2"); 

        // 通过反射获得注解 

        Annotation[] annotations = c1.getAnnotations(); 

        for (Annotation annotation : annotations) { 

            System.out.println(annotation); 

        } 

        // 获得指定注解的value的值 

        Tablekuang tablekuang = c1.getAnnotation(Tablekuang.class); 

        String value = tablekuang.value(); 

        System.out.println("tablekuang注解的值为：" + value); 

        // 获得类指定属性的指定值注解 

        Field f = c1.getDeclaredField("id"); 

        Fieldkuang annotation = f.getAnnotation(Fieldkuang.class); 

        System.out.println(annotation.columnName()); 

        System.out.println(annotation.type()); 

        System.out.println(annotation.length()); 

        // 反射框架的实现就是利用这个获得信息，实现SQL语言的拼接 

    } 

}

package demo.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

public class JdkProxyBasicDemo {

    // ⑴ 定义业务接口

    interface BusinessInterface {

        void greeting(String str);

    }

    // ⑵ 编写代理逻辑处理类

    static class ProxyLogicHandler implements InvocationHandler {

        @Override

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

            System.out.printf("运行的代理类为: %s\n", proxy.getClass().getName());

            System.out.printf("调用的代理方法为: %s\n", method.getName);

            System.out.printf("调用方法的参数为: %s\n", args[0]);

            System.out.println("请在这里插入代码逻辑代码...");  // ⑵.1

            return null;                                   // ⑵.2

        }

    }

    // ⑶ 生成代理实例，并使用

    public static void main(String[] args) {

        ProxyLogicHandler proxyLogicHandler = new ProxyLogicHandler();

        Class[] interfaces = new Class[]{BusinessInterface.class},

        BusinessInterface businessProxy = (BusinessInterface) Proxy.newProxyInstance(BusinessInterface.class.getClassLoader(), proxyLogicHandler);

        businessProxy.greeting("Hello, Jdk Proxy");

    }

}

运行的代理类为: class com.sun.proxy.$Proxy0

调用的代理方法为: greeting

调用方法的参数为: Hello, Jdk Proxy

请在这里插入代理的逻辑代码...

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

public static Object newProxyInstance(ClassLoader loader,  Class<?>[] interfaces, InvocationHandler handler) {

    return new Proxy0(handler);

}

static class Proxy0 implements BusinessInterface{

    private InvocationHandler handler;

    BusinessInterface(InvocationHandler handler) {

        this.handler = handler;

    }

    @Override

    public void greeting(String str) {

        handler.invoke(this, 'greeting', new Object[]{str});

    }

}

package guzb.diy.proxy;

import javax.tools.*;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.net.URI;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.List;

import java.util.Locale;

public class ImitateJdkProxy {

    public static void main(String[] args) throws Throwable{

        InvocationHandler handler = new InvocationHandler() {

            @Override

            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("执行invocationHandler#invoke()方法");

                System.out.println("调用的代理方法名为：" + method.getName());

                System.out.println("调用时传递的参数为：" + args[0]);

                return null;

            }

        };

        Foo foo = (Foo) newProxyInstance(ImitateJdkProxy.class.getClassLoader(), Foo.class, handler);

        foo.sayHi("East Knight");

    }

    /**

     * 模拟java.lang.reflect.Proxy#newProxyInstance方法

     * 这里简化了代理类的类名，固定为：guzb.diy.$Proxy0

     */

    public static final Object newProxyInstance(ClassLoader loader, Class<?> interfaces, InvocationHandler handler) throws Exception {

        // 1. 构建代理类源码对象

        JavaFileObject sourceCode = generateProxySourceCode();

        // 2. 编译代理源代码

        JavaBytesFileObject byteCodeFile = new JavaBytesFileObject("guzb.diy.$Proxy0");

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

        StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(null, Locale.CHINA, Charset.forName("utf8"));

        JavaFileManager fileManager = new ForwardingJavaFileManager(stdFileManager) {

            @Override

            public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {

                return byteCodeFile;

            }

        };

        List<JavaFileObject> compilationUnits = new ArrayList<>();

        compilationUnits.add(sourceCode);

        JavaCompiler.CompilationTask compilationTask = compiler.getTask(null, fileManager, null, null, null, compilationUnits);

        if (!compilationTask.call()) {

            return null;

        }

        // 3. 加载编译后的代理类字节码

        loader = new ClassLoader() {

            @Override

            public Class<?> findClass(String name) throws ClassNotFoundException {

                byte[] bytes = byteCodeFile.getBytes();

                return defineClass(name, bytes, 0, bytes.length);

            }

        };

        Class clazz = loader.loadClass("guzb.diy.$Proxy0");

        // 4. 创建代理类实例并返回

        Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

        return constructor.newInstance(handler);

    }

    /**

     * 生成代理Class的源代码，该代码将在运行期间动态编译和加载。

     * 为了便于直观查看代理类的原理，故意采用了这个使用源码编译的方式，实际上，

     * JDK真实的newProxyInstance方法，内部是采用纯反射+直接生成字节码数组的方式实现的，比较晦涩。

     * 这里也简化了代理代码，比如：

     *   1. 写死了代理类的类名：guzb.diy.$Proxy0

     *   2. 写死了要实现的接口和方法

     *      不写死的话，需要通过反射遍历所有接口的所有方法，并基于Method对象的方法名、返回类型、参数列表和异常列表，

     *      创建实现类的方法签名文本，这样的话，代码就太冗长了，干扰了对代理主线逻辑的理解，也不是本文的重点

     *   3. 没有使用调用者传递的ClassLoader来加载编译后的字节码文件，原因同上，涉及加载器的隔离问题，代码过于冗长

     */

    private static JavaFileObject generateProxySourceCode() throws NoSuchMethodException {

        String[] codeLines = new String[]{

                "package guzb.diy;",

                "import java.lang.reflect.*;",

                "import guzb.diy.proxy.ImitateJdkProxy.Foo;",

                "public class $Proxy0 implements Foo {                    ",

                "    private InvocationHandler handler;                   ",

                "                                                         ",

                "    public $Proxy0 (InvocationHandler handler) {         ",

                "        this.handler = handler;                          ",

                "    }                                                    ",

                "                                                         ",

                "    @Override                                            ",

                "    public void sayHi(String name) throws Throwable {    ",

                "        Method method = Foo.class.getMethod(\"sayHi\", new Class[]{String.class}); ",

                "        this.handler.invoke(this, method, new Object[]{name}); ",

                "    }",

                "}"

        };

        String code = "";

        for (String codeLine : codeLines) {

            code += codeLine + "\n";

        }

        return new JavaStringFileObject("guzb.diy.$Proxy0", code);

    }

    /** 一个简单的业务接口 */

    public interface Foo {

        void sayHi(String name) throws Throwable;

    }

    /** 基于字符串的Java源代码对象 */

    public static class JavaStringFileObject extends SimpleJavaFileObject {

        // 源代码文本

        final String code;

        /**

         *  @param name Java源代码文件名，要包含完整的包名，比如guzb.diy.Proxy

         *  @param code Java源代码文本

         */

        JavaStringFileObject(String name, String code) {

            super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);

            this.code = code;

        }

        @Override

        public CharSequence getCharContent(boolean ignoreEncodingErrors) {

            return code;

        }

    }

    /** 编译后的字节码文件 */

    public static class JavaBytesFileObject extends SimpleJavaFileObject {

        // 接收编译后的字节码

        private ByteArrayOutputStream byteCodesReceiver;

        /** @param name Java源代码文件名，要包含完整的包名，比如guzb.diy.Proxy */

        protected JavaBytesFileObject(String name) {

            super(URI.create("bytes:///" + name + name.replace(".", "/")), Kind.CLASS);

            byteCodesReceiver = new ByteArrayOutputStream();

        }

        @Override

        public OutputStream openOutputStream() throws IOException {

            return byteCodesReceiver;

        }

        public byte[] getBytes() {

            return byteCodesReceiver.toByteArray();

        }

    }

}

执行invocationHandler#invoke()方法

调用的代理方法名为：sayHi

调用时传递的参数为：East Knight

Performer

package guzb.diy.proxy;

/**

 * 演员接口

 * 在这个示例中，将为该接口生成代理实例

 */

public interface Performer {

    /**

     * 根据主题即兴表演一段

     * @param subject 表演的主题

     */

    void play(String subject);

    /** 自我介绍 */

    String introduction();

}

DefaultActor

package guzb.diy.proxy;

/**

 * 这是演员接口的默认实现类

 * 在本示例中，它将作为原始的接口实现者，被代理(拦截)

 */

public class DefaultActor implements Performer {

    @Override

    public void play(String subject) {

        System.out.println("[DefaultActor]: 默认男演员正在即兴表演《"+ subject +"》");

    }

    @Override

    public String introduction() {

        return "李白·上李邕： 大鹏一日同风起，扶摇直上九万里。假令风歇时下来，犹能颠却沧溟水。世人见我恒殊调，闻余大言皆冷笑。宣父尚能畏后生，丈夫未可轻年少。";

    }

}

Director

package guzb.diy.proxy;

import java.util.List;

/**

 * 导演接口

 * 在这个示例中，将为该接口生成代理实例

 */

public interface Director {

    /**

     * 获取曾导演过的作品集

     * @return 作品名称列表

     */

    List<String> getCreations();

}

DefaultDirector

package guzb.study.javacore.proxy.jdk;

import java.util.ArrayList;

import java.util.List;

/**

 * 这是导演接口的默认实现类

 * 在本示例中，它将作为原始的接口实现者，被代理(拦截)

 */

public class DefaultDirector implements Director{

    @Override

    public List<String> getCreations() {

        return new ArrayList(){

            {

                add("活着");

                add("盲井");

                add("走出夹边沟");

                add("少年派的奇幻漂流");

            }

        };

    }

}

ProxyForInterceptor

package guzb.diy.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

/**

 * 代理应用场景一：拦截器

 * 即在原来的业务逻辑上追加额外的代码，这是代理功能最常见的应用场景。

 *

 * 在本示例中，导演与演员实例代表原始业务，

 * 由于代理的目的是在执行真实的接口实现类方法的前后，执行一段其它代码。

 * 因此，本类需要持有原始的导演和演员实例。

 */

public class ProxyForInterceptor implements InvocationHandler {

    // 原始的演员对象

    private Performer performer;

    // 原始的导演对象

    private Director director;

    public ProxyForInterceptor(Director director, Performer performer) {

        this.director = director;

        this.performer = performer;

    }

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        String methodName = method.getName();

        System.out.printf("[DirectorActorProxyHandler]: 调用的代理方法为：%s\n", methodName);

        System.out.printf("[DirectorActorProxyHandler]: >>> 调用 %s 之前的逻辑\n", methodName);

        Object result = null;

        // 因为本代理处理器，只针对Director和Actor接口，因此，如果方法名为play，则一定调用的是Actor的play方法

        // 根据Actor#play方法的参数定义，它只有一个String参数，所以直接取args[0]即可

        if(methodName.equals("play")) {

            performer.play((String)args[0]);

        } else if (methodName.equals("introduction")) {

            result = performer.introduction();

        } else if (methodName.equals("getCreations")) {

            result = director.getCreations();

        }

        System.out.printf("[DirectorActorProxyHandler]: <<< 调用 %s 之后的逻辑\n", methodName);

        return result;

    }

}

IntercepterTestMain

package guzb.diy.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

import java.util.List;

public class IntercepterTestMain {

    public static void main(String[] args) {

        Performer actor = new DefaultActor();

        Director director = new DefaultDirector();

        InvocationHandler interceptor = new ProxyForInterceptor(director, actor);

        // 要代理的接口，这里称之为委托接口，即委托给代理实例，去实现相应的功能

        Class[] principalInterfaces = new Class[]{Director.class, Performer.class};

        // 创建一个代理实例，该实例实现了委托接口所定义的方法，因此，这个实例可以强转为Performer和Director

        Object directorPerformerProxy = Proxy.newProxyInstance(IntercepterTestMain .class.getClassLoader(), principalInterfaces, interceptor);

        Performer performerProxy = (Performer) directorPerformerProxy;

        Director directorProxy = (Director) directorPerformerProxy;

        // ① 调用代理实例中，Performer接口相关的方法

        performerProxy.play("长板坡");

        String introduction = performerProxy.introduction();

        System.out.printf("[IntercepterTestMain ]: 代理对象返回的个人简介内容为： %s\n", introduction);

        // 调用代理实例中，Director接口相关的方法

        List<String> creations = directorProxy.getCreations();

        System.out.println("[IntercepterTestMain ]: 代理对象返回的导演作品列表：");

        for (String creation : creations) {

            System.out.printf("    · %s\n", creation);

        }

    }

}

[DirectorActorProxyHandler]: 调用的代理方法为：play

[DirectorActorProxyHandler]: >>> 调用 play 之前的逻辑

[DefaultActor]: 默认男演员正在即兴表演《长板坡》

[DirectorActorProxyHandler]: <<< 调用 play 之后的逻辑

[DirectorActorProxyHandler]: 调用的代理方法为：introduction

[DirectorActorProxyHandler]: >>> 调用 introduction 之前的逻辑

[DirectorActorProxyHandler]: <<< 调用 introduction 之后的逻辑

[IntercepterTestMain ]: 代理对象返回的个人简介内容为： 李白·上李邕： 大鹏一日同风起，扶摇直上九万里。假令风歇时下来，犹能颠却沧溟水。世人见我恒殊调，闻余大言皆冷笑。宣父尚能畏后生，丈夫未可轻年少。

[DirectorActorProxyHandler]: 调用的代理方法为：getCreations

[DirectorActorProxyHandler]: >>> 调用 getCreations 之前的逻辑

[DirectorActorProxyHandler]: <<< 调用 getCreations 之后的逻辑

[IntercepterTestMain ]: 代理对象返回的导演作品列表：

    · 活着

    · 盲井

    · 走出夹边沟

    · 少年派的奇幻漂流

SqlMapper

package guzb.diy.proxy;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * 标识一个接口是一个SQL映射类，用于模拟MyBatis的mapper功能

 */

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.TYPE})

public @interface SqlMapper {

}

Select

package guzb.diy.proxy;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * 为一个mapper方法指定查询类sql语句

 * 本类用于模拟MyBatis的mapper功能

 */

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface Select {

    /**

     * 查询sql语句，支持#{}这样的插值占位符

     */

    String sql();

}

ParamName

package guzb.diy.proxy;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

 * 为一个mapper方法的参数，指定一个名称，以便在sql语句中进行插值替换

 * 本类用于模拟MyBatis的mapper功能

 */

@Target(ElementType.PARAMETER)

@Retention(RetentionPolicy.RUNTIME)

public @interface ParamName {

    /** 参数的名称 */

    String value();

}

PerformerMapper

package guzb.diy.proxy;

/**

 * 演员实体查询接口。

 * 本类用于模拟MyBatis的mapper功能

 */

@SqlMapper

public interface PerformerMapper {

    @Select(sql = "select count(*) from performer where name=#{name} and age = #{ age }")

    Long getQuantityByNameAndAage(@ParamName("name") String name, @ParamName("age") Integer age);

    @Select(sql = "select poetry_item from poetry where performer_name = #{ name }")

    String getRandomPoetryOf(@ParamName("name") String name);

    // ② SQL中故障引入了一个pageSize的变量，由于方法签名中没有声明这个参数，因此会导致SQL在插值替换阶段发生异常

    @Select(sql = "select * from performer where age >= #{age} limit #{ pageSize }")

    Object listAllOfAge(@ParamName("age") int age);

}

ProxyForDeclaration

package guzb.diy.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Parameter;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * 〔声明性接口〕功能的核心实现类

 */

public class ProxyForDeclaration implements InvocationHandler {

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.printf("[ProxyForDeclaration]: 调用的方法名为：%s\n", method.getName());

        // 1. 先提取出原始的SQL

        String rawSql = extractSql(method);

        if (rawSql == null || rawSql.trim().length() == 0) {

            System.out.printf("[ProxyForDeclaration]: 方法%s()未指定SQL语句，无法执行。请通过@Select注解指定Sql\n", method.getName());

            return null;

        }

        System.out.printf("[ProxyForDeclaration]: 原始sql为：%s\n", rawSql);

        // 2. 对原始SQL做插值替换，String类型的参数追加''号，其它类型原样替换

        String finalSql = interpolateSql(rawSql, method, args);

        System.out.printf("[ProxyForDeclaration]: 插值替换后的sql为：%s\n", finalSql);

        // 3. 模拟执行SQL语句

        return imitateJdbcExecution(finalSql, method.getReturnType());

    }

    private String extractSql(Method method) {

        Select selectAnnotation = method.getAnnotation(Select.class);

        return selectAnnotation == null ? null : selectAnnotation.sql();

    }

    private String interpolateSql(String rawSql, Method method, Object[] args) {

        // 使用正则表达式来完成插值表达式#{}的内容替换

        Pattern interpolationTokenPattern = Pattern.compile("(#\\{\\s*([a-zA-Z0-9]+)\\s*\\})");

        Matcher matcher = interpolationTokenPattern.matcher(rawSql);

        // 提取出方法参数名称与参数对象的对应关系，key为参数名（通过@ParamName注解指定），value为参数对象

        Map<String, Object> paramMap = extractParameterMap(method, args);

        // 插值替换

        String finalSql = rawSql;

        while (matcher.find()) {

            String interpolationToken = matcher.group(1);

            String parameterName = matcher.group(2);

            if (!paramMap.containsKey(parameterName)) {

                throw new SqlMapperExecuteException("未知参数：" + parameterName);

            }

            Object value = paramMap.get(parameterName);

            String valueStr = value instanceof String ? "'" + value.toString() + "'" : value.toString();

            finalSql = finalSql.replace(interpolationToken, valueStr);

        }

        return finalSql;

    }

    private Map<String, Object> extractParameterMap(Method method, Object[] args) {

        Parameter[] parameters = method.getParameters();

        if (parameters.length == 0) {

            return Collections.EMPTY_MAP;

        }

        Map<String, Object> sqlParamMap = new HashMap<>();

        for (int i = 0; i < parameters.length; i++) {

            Parameter parameter = parameters[i];

            ParamName paramName = parameter.getAnnotation(ParamName.class);

            // 这里不用检查数组越界问题，因为args参数本身就是调用接口方法时的传递的参数，只要是正常调用(不是通过反射）就不会越界

            sqlParamMap.put(paramName.value(), args[i]);

        }

        return sqlParamMap;

    }

    /** 模拟执行jdbc sql, 这里仅对数字和字符串进行了模拟，其它返回null */

    private Object imitateJdbcExecution(String finalSql, Class<?> returnType) {

        if(Number.class.isAssignableFrom(returnType)){

            return (long)(Math.random() * 1000 + 1);

        }

        if (returnType == String.class) {

            String[] poetry = new String[]{

                    "黄四娘家花满蹊，千朵万朵压枝低。",

                    "留连戏蝶时时舞，自在妖莺恰恰啼。",

                    "荷尽已无擎雨盖，菊残犹有傲霜枝。",

                    "一年好景君须记，最是橙黄橘绿时。"

            };

            int index = (int)(Math.random() * 4);

            return poetry[index];

        }

        return null;

    }

    static class SqlMapperExecuteException extends RuntimeException {

        public SqlMapperExecuteException(String message) {

            super(message);

        }

    }

}

DeclarationTestMain

package guzb.diy.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

import java.util.List;

/**

 * 〔声明性接口〕功能测试入口类

 */

public class DeclarationTestMain {

    public static void main(String[] args) {

        Class[] principalInterfaces = new Class[]{PerformerMapper.class};

        ProxyForDeclaration declarationHandler = new ProxyForDeclaration();

        PerformerMapper performerMapper = (PerformerMapper) Proxy.newProxyInstance(JdkProxyStudyMain.class.getClassLoader(), principalInterfaces, declarationHandler);

        Long count = performerMapper.getQuantityByNameAndAage("Jane Lotus", 47);

        System.out.printf("[DeclarationTestMain]: 代理实例方法方法的返回值为：%s\n\n", count);

        String poetryItem = performerMapper.getRandomPoetryOf("杜甫");

        System.out.printf("[DeclarationTestMain]: 代理实例方法的返回值为：%s\n\n", poetryItem);

        // ③ 本方法调用后将发生异常，因为PerformerMapper中的②处，声明的SQL有未知的插值变量，这里特意测试验证

        performerMapper.listAllOfAge(100);

    }

}

以上代码的执行结果为：

[ProxyForDeclaration]: 调用的方法名为：getQuantityByNameAndAage

[ProxyForDeclaration]: 原始sql为：select count(*) from performer where name=#{name} and age = #{ age }

[ProxyForDeclaration]: 插值替换后的sql为：select count(*) from performer where name='Jane Lotus' and age = 47

[DeclarationTestMain]: 代理实例方法方法的返回值为：40

[ProxyForDeclaration]: 调用的方法名为：getRandomPoetryOf

[ProxyForDeclaration]: 原始sql为：select poetry_item from poetry where performer_name = #{ name }

[ProxyForDeclaration]: 插值替换后的sql为：select poetry_item from poetry where performer_name = '杜甫'

[DeclarationTestMain]: 代理实例方法的返回值为：黄四娘家花满蹊，千朵万朵压枝低。

[ProxyForDeclaration]: 调用的方法名为：listAllOfAge

[ProxyForDeclaration]: 原始sql为：select * from performer where age >= #{age} limit #{ pageSize }

Exception in thread "main" guzb.diy.proxy.ProxyForDeclaration$SqlMapperExecuteException: 未知参数：pageSize

       at guzb.diy.proxy.ProxyForDeclaration.interpolateSql(ProxyForDeclaration.java:55)

       at guzb.diy.proxy.ProxyForDeclaration.invoke(ProxyForDeclaration.java:29)

       at com.sun.proxy.$Proxy1.listAllOfAge(Unknown Source)

       at guzb.diy.proxy.DeclarationTestMain.main(JdkProxyStudyMain.java:24)