本文共 31699 字，大约阅读时间需要 105 分钟。

认识反射机制

正

package com.yootk.demo;class Book {       public void read() {           System.out.println("认真学习李兴华老师出版的《Java从入门到项目实战》");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Book book = new Book() ; // 1，首先获取Book类的实例化对象        book.read(); // 通过实例化对象进行方法调用。    }}

反

package com.yootk.demo;class Book {       public void read() {           System.out.println("认真学习李兴华老师出版的《Java从入门到项目实战》");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Book book = new Book() ; // 1，首先获取Book类的实例化对象        System.out.println(book.getClass().getName());  // 对象所属类的完整名称        System.out.println(book.getClass().getSimpleName()); // 对象所属类的简化名称（不包含包名称）        System.out.println(book.getClass().getTypeName()); // 获得对象所属类的类型    }}

获取操作类型

package com.yootk.demo;class Book {       public void read() {           System.out.println("认真学习李兴华老师出版的《Java从入门到项目实战》");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Book book = new Book() ;        printClass(book.getClass());        printClass(new java.util.Date().getClass());    }    public static void printClass(Class<?> clazz) {           System.out.println("【当前操作的类型】" + clazz.getName());    }}

Class类与对象实例化

范例一

package com.yootk.demo;interface IBook {   }public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazzA = IBook.class ; //  属于Java的原生语法支持        Class<?> clazzB = java.util.Date.class ; //  属于Java的原生语法支持        System.out.println(clazzA);        System.out.println(clazzB);    }}

范例二

package com.yootk.demo;import java.util.Date;public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Date.class ; //  属于Java的原生语法支持        System.out.println(clazz);    }}

范例三：

package com.yootk.demo;public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("java.util.Date") ; // 根据类名称实现信息加载        System.out.println(clazz);    }}

反射机制与对象实例化

1、package com.yootk.demo;class Book {       public Book() {           System.out.println("【Book】实例化新的Book类对象");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Book book = new Book() ;    }}2、package com.yootk.demo;class Book {       public Book() {           System.out.println("【Book】实例化新的Book类对象");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> bookClazz = Class.forName("com.yootk.demo.Book") ; // 实例化Book类的对象        bookClazz.newInstance() ; // 在JDK 1.8的时候依然可以正常使用    }}3、package com.yootk.demo;class Book {       public Book() {           System.out.println("【Book】实例化新的Book类对象");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> bookClazz = Class.forName("com.yootk.demo.Book") ; // 实例化Book类的对象        bookClazz.getDeclaredConstructor().newInstance() ;    }}4、package com.yootk.demo;class Book {       public void read() {           System.out.println("认真学习李兴华老师出版的《Java从入门到项目实战》");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> bookClazz = Class.forName("com.yootk.demo.Book") ; // 实例化Book类的对象        // newInstance()返回的是一个Object类型，那么就必须进行对象的强制向下转型        Book book = (Book) bookClazz.getDeclaredConstructor().newInstance() ;        book.read();    }}5、package com.yootk.demo;import java.util.Date;public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> bookClazz = Class.forName("java.util.Date") ; // 实例化Book类的对象        // 如果强制转型了，那么就必须进行开发包的完整导入        Date date = (Date) bookClazz.getDeclaredConstructor().newInstance() ;        System.out.println(date.getTime());    }}6、package com.yootk.demo;interface IBook {      // 接口    public void read() ;}class MathBook implements IBook {       @Override    public void read() {           System.out.println("【MathBook】认真学习大学数学课程（线性代数、概率统计、离散数学）。");    }}class ProgramBook implements IBook {       @Override    public void read() {           System.out.println("【ProgramBook】认真学习李兴华老师出版的《Java从入门到项目实战》。");    }}class Factory {       private Factory() {   }    public static IBook getInstance(String className) {           if ("math".equalsIgnoreCase(className)) {               return new MathBook() ;        } else if ("program".equalsIgnoreCase(className)) {               return new ProgramBook() ;        } else {               return null ;        }    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           IBook book = Factory.getInstance("program") ;        book.read();    }}7、package com.yootk.demo;interface IBook {      // 接口    public void read() ;}class MathBook implements IBook {       @Override    public void read() {           System.out.println("【MathBook】认真学习大学数学课程（线性代数、概率统计、离散数学）。");    }}class ProgramBook implements IBook {       @Override    public void read() {           System.out.println("【ProgramBook】认真学习李兴华老师出版的《Java从入门到项目实战》。");    }}class Factory {       private Factory() {   }    public static IBook getInstance(String className) {    // 必须传递类的完整名称        try {    // 直接实例化对象            Object obj = Class.forName(className).getDeclaredConstructor().newInstance();            if (obj instanceof IBook) {    // 为了防止出现ClassCastException                return (IBook) obj ; // 强制性的向下转型            }            return null ;        } catch (Exception e) {               return null ;        }    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           IBook book = Factory.getInstance("com.yootk.demo.ProgramBook") ;        book.read();    }}8、package com.yootk.demo;class Singleton {      // 单例设计类    private static Singleton instance ; // 不进行对象实例化    private Singleton() {    // 构造方法私有化        System.out.println("【" + Thread.currentThread().getName() + "】实例化Singleton类的对象。");    }    public String toString() {           return "【VIP】李兴华编程训练营：yootk.ke.qq.com" ;    }    public static Singleton getInstance() {    // 获取Singleton类实例化对象        if (instance == null) {    // 现在还没有实例化            instance = new Singleton() ; // 对象实例化        }        return instance ; // 获取对象实例    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           for (int x = 0 ;  x < 10 ; x ++) {               Singleton singleton = Singleton.getInstance(); // 获取实例化对象            System.out.println(singleton);        }    }}9、package com.yootk.demo;class Singleton {      // 单例设计类    private static Singleton instance ; // 不进行对象实例化    private Singleton() {    // 构造方法私有化        System.out.println("【" + Thread.currentThread().getName() + "】实例化Singleton类的对象。");    }    public String toString() {           return "【VIP】李兴华编程训练营：yootk.ke.qq.com" ;    }    public static Singleton getInstance() {    // 获取Singleton类实例化对象        if (instance == null) {    // 现在还没有实例化            instance = new Singleton() ; // 对象实例化        }        return instance ; // 获取对象实例    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           for (int x = 0 ;  x < 10 ; x ++) {               new Thread(()->{                   Singleton singleton = Singleton.getInstance(); // 获取实例化对象                System.out.println(singleton);            }, "单例操作线程 - " + x).start();        }    }}10、package com.yootk.demo;class Singleton {      // 单例设计类    private static Singleton instance ; // 不进行对象实例化    private Singleton() {    // 构造方法私有化        System.out.println("【" + Thread.currentThread().getName() + "】实例化Singleton类的对象。");    }    public String toString() {           return "【VIP】李兴华编程训练营：yootk.ke.qq.com" ;    }    public static synchronized Singleton getInstance() {    // 获取Singleton类实例化对象        if (instance == null) {    // 现在还没有实例化            instance = new Singleton() ; // 对象实例化        }        return instance ; // 获取对象实例    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           for (int x = 0 ;  x < 10 ; x ++) {               new Thread(()->{                   Singleton singleton = Singleton.getInstance(); // 获取实例化对象                System.out.println(singleton);            }, "单例操作线程 - " + x).start();        }    }}11、package com.yootk.demo;class Singleton {      // 单例设计类    private static volatile Singleton instance ; // 不进行对象实例化    private Singleton() {    // 构造方法私有化        System.out.println("【" + Thread.currentThread().getName() + "】实例化Singleton类的对象。");    }    public String toString() {           return "【VIP】李兴华编程训练营：yootk.ke.qq.com" ;    }    public static Singleton getInstance() {    // 获取Singleton类实例化对象        if (instance == null) {    // 现在还没有实例化            synchronized (Singleton.class) {    // 同步代码块                if (instance == null) {                       instance = new Singleton(); // 对象实例化                }            }        }        return instance ; // 获取对象实例    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           for (int x = 0 ;  x < 10 ; x ++) {               new Thread(()->{                   Singleton singleton = Singleton.getInstance(); // 获取实例化对象                System.out.println(singleton);            }, "单例操作线程 - " + x).start();        }    }}

反射机制与类结构操作

范例1：获取包的信息

package com.yootk.demo;interface IBook {   }interface ISpec {   }abstract class AbstractPrint {   }class Book extends AbstractPrint implements IBook, ISpec {   }public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("com.yootk.demo.Book") ;        System.out.println(clazz.getPackage()); // 返回Package对象实例        System.out.println(clazz.getPackageName());    }}

范例2：获取继承的父类和实现的接口

package com.yootk.demo;interface IBook {   }interface ISpec {   }abstract class AbstractPrint {   }class Book extends AbstractPrint implements IBook, ISpec {   }public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("com.yootk.demo.Book") ;        Class<?> superClazz = clazz.getSuperclass() ;  // 获取父类        System.out.println("【继承父类】" + superClazz.getName());        System.out.println("【继承父类】" + superClazz.getSuperclass().getName());        Class<?> inters [] = clazz.getInterfaces() ; // 获取实现的接口        for (Class<?> temp : inters) {               System.out.println("【实现接口】" + temp.getName());        }    }}

反射获取构造方法

反射获取全部构造

package com.yootk.demo;import java.lang.reflect.Constructor;class Book {       // Book类中的构造方法使用了不同的访问权限    public Book() {   }    protected Book(String title) {   }    Book(String title, String author) {   }    private Book(String title, String author, double price) {   }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("com.yootk.demo.Book") ;        {               System.out.println("--------------------- getConstructors()获取构造 ---------------------");            for (Constructor<?> constructor : clazz.getConstructors()) {                   System.out.println("【1 - 构造信息】" + constructor);            }        }        {               System.out.println("--------------------- getDeclaredConstructors()获取构造 ---------------------");            for (Constructor<?> constructor : clazz.getDeclaredConstructors()) {                   System.out.println("【2 - 构造信息】" + constructor);            }        }    }}

通过反射使用有参构造实例化对象

package com.yootk.demo;import java.lang.reflect.Constructor;class Book {       // Book类中的构造方法使用了不同的访问权限    private String title;    private String author;    private double price;    public Book(String title, String author, double price) {           this.title = title;        this.author = author;        this.price = price;    }// 本类中的无参构造、setter、getter方法，略...    public String toString() {           return "【Book】图书名称：" + this.title + "、图书作者：" + this.author + "、图书价格：" + this.price ;    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("com.yootk.demo.Book");        Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, String.class, double.class);// 获取指定构造        Object obj = constructor.newInstance("Java从入门到项目实战", "李兴华", 99.8) ; // 反射对象实例化        System.out.println(obj);    }}

反射调用方法

package com.yootk.demo;import java.lang.reflect.Method;class Book {       public void read() throws RuntimeException {   }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("com.yootk.demo.Book");        Method methods [] = clazz.getMethods() ;        for (Method method : methods) {               System.out.println(method);        }    }}

范例：获取方法详细信息

package com.yootk.demo;import java.lang.reflect.Method;import java.lang.reflect.Modifier;import java.lang.reflect.Type;class Book {       public void read() throws RuntimeException {   }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("com.yootk.demo.Book");        Method methods [] = clazz.getMethods() ;        for (Method method : methods) {               System.out.print(Modifier.toString(method.getModifiers()) + " "); // 获取方法修饰符            System.out.print(method.getGenericReturnType().getTypeName() + " "); // 获取返回值类型            System.out.print(method.getName() + "("); // 获取方法名称            Type[] parameterTypes = method.getGenericParameterTypes();// 获取方法参数信息            for (int x = 0 ; x < parameterTypes.length ; x ++) {                   System.out.print(parameterTypes[x].getTypeName() + " arg" + x);                if (x < parameterTypes.length - 1) {       // 后面还有其他参数                    System.out.print(", ");                }            }            System.out.print(") ");            Type[] exceptions = method.getGenericExceptionTypes() ; // 获取所抛出的全部异常信息            if (exceptions.length > 0) {       // 有异常抛出                System.out.print("throws "); // 输出throws信息                for (int x = 0; x < exceptions.length; x++) {                       System.out.print(exceptions[x].getTypeName());                    if (x < exceptions.length - 1) {                           System.out.print(", ");                    }                }            }            System.out.println(); // 换行        }    }}

根据方法名调用方法

package com.yootk.demo;import java.lang.reflect.Method;class Book {       private String title ;    public void setTitle(String title) {           this.title = title;    }    public String getTitle() {           return title;    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           String fieldName = "title" ; // 明确给出了成员的属性名称        String fieldValue = "Java从入门到项目实战" ; // 成员属性的内容        Class<?> clazz = Class.forName("com.yootk.demo.Book");        // 1、如果要想通过Book类实现属性的操作，那么首先一定要获取Book类的对象        Object object = clazz.getDeclaredConstructor().newInstance() ; // 反射对象实例化        // 2、要找到指定调用的setter，setTitle()方法的参数类型为String        Method setMethod = clazz.getMethod("set" + initcap(fieldName), String.class) ;        // 3、利用反射结合对象实例（不是具体的Book类，而是Object类型）同时传入所需要的参数        setMethod.invoke(object, fieldValue) ; // 等价于“book类的对象.setTitle(fieldValue)”        // 4、找到getter方法，getter方法没有参数类型        Method getMethod = clazz.getMethod("get" + initcap(fieldName)) ;        // 5、通过反射获取getter方法的返回值        Object value = getMethod.invoke(object) ;// 等价于“book类对象.getTitle()”        System.out.println(value);    }    public static String initcap(String str) {           if (str == null || "".equals(str)) {               return str ;        }        if (str.length() == 1) {               return str.toUpperCase() ;        } else {               return str.substring(0, 1).toUpperCase() + str.substring(1) ;        }    }}

调用成员属性

package com.yootk.demo;import java.lang.reflect.Field;interface IBook {       public static final String FLAG = "沐言优拓：www.yootk.com" ;}abstract class AbstractBook implements IBook {       protected String type = "编程教育类图书" ;    private String company = "沐言科技软件学院" ;}class ProgramBook extends AbstractBook {       private String title ; // 图书名称}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Class.forName("com.yootk.demo.ProgramBook") ; // 获取操作类        {               System.out.println("----------- getFields()执行结果 ------------");            for (Field field : clazz.getFields()) {    // 获取所有的成员                System.out.println("【继承来的public成员】" + field);            }        }        {               System.out.println("----------- getDeclaredFields()执行结果 ------------");            for (Field field : clazz.getDeclaredFields()) {    // 获取所有的成员                System.out.println("【本类定义的成员】" + field);            }        }    }}

Unsafe工具类

获取Unsafe对象

package com.yootk.demo;import sun.misc.Unsafe;import java.lang.reflect.Field;public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe") ; // 通过反射获取成员        unsafeField.setAccessible(true); // 取消封装        Unsafe unsafe = (Unsafe) unsafeField.get(null) ; // 获取UnSafe对象        System.out.println(unsafe);    }}

范例：通过Unsafe类绕过JVM的对象管理机制实现方法调用

package com.yootk.demo;import sun.misc.Unsafe;import java.lang.reflect.Field;class Singleton {       private Singleton() {           System.out.println("【Singleton】实例化类对象");    }    public void print() {           System.out.println("李兴华编程训练营：yootk.ke.qq.com");    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe") ; // 通过反射获取成员        unsafeField.setAccessible(true); // 取消封装        Unsafe unsafe = (Unsafe) unsafeField.get(null) ; // 获取UnSafe对象        Singleton singleton = (Singleton) unsafe.allocateInstance(Singleton.class) ; // 获取对象实例        singleton.print();    }}

ClassLoader

package com.yootk.demo;public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           String message = "www.yootk.com" ; // 字符串，为系统类        System.out.println(message.getClass().getClassLoader());    }}

package com.yootk.demo;class Book {   }public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Class<?> clazz = Book.class ; // 获得自定义类的Class对象        System.out.println(clazz.getClassLoader());        System.out.println(clazz.getClassLoader().getParent());        System.out.println(clazz.getClassLoader().getParent().getParent()); // Bootstrap    }}

自定义ClassLoader

自定义类加载器

package com.yootk.util;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.InputStream;// 如果要想进行加载器的创建则必须继承自“ClassLoader”父类，并且依据方法进行调用public class FileClassLoader extends ClassLoader {    // 创建一个专属的文件加载器    // 定义要加载的字节码文件所处的绝对路径，必须通过File进行路径的拼凑    private static final String CLASS_FILE_PATH = "H:" + File.separator + "Message.class";    // 此时自定义了一个类加载的方法，这个类加载的方法一定不要重名    public Class<?> loadData(String className) throws Exception {           byte data [] = this.loadFileClassData() ; // 加载要使用的类文件        if (data != null) {    // 类信息已经成功的进行了加载            return super.defineClass(className, data, 0, data.length);        }        return null ;    }    // 自定义一个新的方法，将根据给定的文件路径进行加载，为了简化没有进行严格的异常控制    private byte[] loadFileClassData() throws Exception {           // 获取要加载文件的二进制字节输入流对象        InputStream input = new FileInputStream(new File(CLASS_FILE_PATH)) ;        // 最终需要将所有的数据保存在内存之中，并且要利用字节数组返回        ByteArrayOutputStream bos = new ByteArrayOutputStream() ; // 内存输出流        input.transferTo(bos) ; // 轻松的解决字节数据的读取        byte data [] = bos.toByteArray() ; // 获取全部的Class文件数据        input.close();        bos.close();        return data ; // 返回二进制数据    }}

package com.yootk.demo;import com.yootk.util.FileClassLoader;import java.lang.reflect.Method;public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           FileClassLoader fileClassLoader = new FileClassLoader() ;// 实例化自定义类加载器        Class<?> clazz = fileClassLoader.loadData("com.yootk.util.Message") ; // 加载类        Object messageObject = clazz.getDeclaredConstructor().newInstance() ;        Method method = clazz.getMethod("echo", String.class) ; // 获取echo()方法对象        System.out.println(method.invoke(messageObject, "沐言优拓：www.yootk.com"));    }}

自定义网络类加载器

范例：开发一个网络服务器

略

范例：开发一个网络加载器

package com.yootk.util;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.InputStream;import java.net.Socket;// 如果要想进行加载器的创建则必须继承自“ClassLoader”父类，并且依据方法进行调用public class NetClassLoader extends ClassLoader {    // 创建一个专属的文件加载器    // 此时需要通过特定的网络服务器进行类的加载，那么就必须明确的定义出服务器的地址以及连接端口    private static final String SERVER_HOST = "localhost" ; // 直接进行本机网络服务访问    private static final int SERVER_PORT = 9999 ; // 服务器的连接端口    // 此时自定义了一个类加载的方法，这个类加载的方法一定不要重名    public Class<?> loadData(String className) throws Exception {           byte data [] = this.loadFileClassData() ; // 加载要使用的类文件        if (data != null) {    // 类信息已经成功的进行了加载            return super.defineClass(className, data, 0, data.length);        }        return null ;    }    // 自定义一个新的方法，将根据给定的文件路径进行加载，为了简化没有进行严格的异常控制    private byte[] loadFileClassData() throws Exception {           // 获取要加载文件的二进制字节输入流对象        Socket client = new Socket(SERVER_HOST, SERVER_PORT) ; // 进行网络服务器的连接        // 获取网络服务器响应给客户端的字节输入流        InputStream input = client.getInputStream() ; // 网络输入流        // 最终需要将所有的数据保存在内存之中，并且要利用字节数组返回        ByteArrayOutputStream bos = new ByteArrayOutputStream() ; // 内存输出流        input.transferTo(bos) ; // 轻松的解决字节数据的读取        byte data [] = bos.toByteArray() ; // 获取全部的Class文件数据        client.shutdownInput(); // 等待网络数据接收完毕后关闭连接        input.close();        bos.close();        return data ; // 返回二进制数据    }}

反射机制与代理设计模式

静态代理设计模式

动态代理设计模式

示例代码：

package com.itkey.javareview.温故知新.反射机制;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;interface IMessage{    //核心业务接口    public String echo(String msg);}class MessageImpl implements IMessage{       @Override    public String echo(String msg) {           return "【ECHO】" + msg;    }}class ServerProxy implements InvocationHandler{     //此为公共的代理实现类    private Object target;      //核心业务对象    /**     * 由于动态代理设计模式需要保存有真实业务的主题对象，那么这个时候就需要将真实业务对象传递到本方法之中     * 同时基于proxy系统类，动态创建有一个代理业务类对象     * @param target 要绑定的真实业务对象     * @return 系统生成的代理类对象     */    public Object bind(Object target){         //保存真实业务对象        this.target = target;        //获取真实业务主题所在类对应的类加载器，因为需要分析真实业务主题接口所拥有的方法，才可以构建动态子类        // 所有动态代理者阳基于接口中的设计应用，那么此时就要获取全部的接口信息        // 当前的类为InvocationHandler接口子类，所以使用this描述的是本接口的实例化对象        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);    }    @Override    public Object invoke(Object o, Method method, Object[] args) throws Throwable {           Object returnValue = null;        if(this.connect()){               returnValue = method.invoke(this.target,args);            this.close();        }        return returnValue;    }    public boolean connect(){          //代理方法        System.out.println("【代理业务】连接远程服务器，建立消息发磅通道");        return true;    }    public void close(){           System.out.println("【代理业务】信息发送完毕，关闭远程消息通道");    }}public class jdk动态代理机制 {       public static void main(String[] args) {           IMessage messageObject = (IMessage) new ServerProxy().bind(new MessageImpl());      //获取代理对象        System.out.println(messageObject.echo("动态代理如此简单"));    }}

CGLB实现动态代理

https://mvnrepository.com/4、package com.yootk.demo;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;class Message {    // 不需要使用到接口    public String echo(String msg) {           return "【ECHO】" + msg;    }}class ServerProxy implements MethodInterceptor {      // 【CGLIB】方法拦截器    private Object target ; // 真实业务主题对象    public ServerProxy(Object target) {           this.target = target ;    }    public boolean connect() {    // 代理方法        System.out.println("【代理业务】连接远程服务器，建立消息发送通道。");        return true ;    }    public void close() {           System.out.println("【代理业务】信息发送完毕，关闭远程消息通道。");    }    @Override    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {           Object returnValue = null ; // 返回值        if (this.connect()) {               returnValue = method.invoke(this.target, objects) ; // 反射调用方法            this.close(); // 关闭服务器连接        }        return returnValue;    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           Message target = new Message() ; // 核心业务对象        Enhancer enhancer = new Enhancer();// 代理控制类        enhancer.setSuperclass(target.getClass()); // 模拟一个公共父类        enhancer.setCallback(new ServerProxy(target)); // 配置代理功能        Message proxy = (Message) enhancer.create() ; // 创建代理对象        System.out.println(proxy.echo("沐言优拓：www.yootk.com"));    }}

反射获取Annotation信息

package com.yootk.demo;import java.lang.annotation.Annotation;import java.lang.reflect.Method;@FunctionalInterface // 函数式接口定义@Deprecated(since = "1.1") // 此接口不推荐使用interface IMessage {       // 定义一个接口    public String echo(String msg) ;}@Deprecated(since = "3.0")class MessageImpl implements IMessage {       @Override    public String echo(String msg) {           return "【ECHO】" + msg ;    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           {               System.out.println("---------- 获取IMessage接口上的注解信息 ----------");            Class<?> clazz = IMessage.class ; // 获取接口的Class对象实例            for (Annotation annotation : clazz.getAnnotations()) {                   System.out.println(annotation);            }        }        {               System.out.println("---------- 获取MesageImpl子类上的注解信息 ----------");            Class<?> clazz = MessageImpl.class ; // 获取接口的Class对象实例            for (Annotation annotation : clazz.getAnnotations()) {                   System.out.println(annotation);            }        }        {               System.out.println("---------- 获取MesageImpl.echo()方法上的注解信息 ----------");            Class<?> clazz = MessageImpl.class ; // 获取接口的Class对象实例            Method method = clazz.getDeclaredMethod("echo", String.class) ;            for (Annotation annotation : method.getAnnotations()) {                   System.out.println(annotation);            }        }    }}

自定义Annotation

package com.yootk.demo;import java.lang.annotation.Annotation;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.reflect.Method;@Retention(RetentionPolicy.RUNTIME) // 在当前执行的时候此Annotation生效@interface Action {    // 自定义了一个Annotation    public String title() ; // 描述的是Annotation中的属性    public String value() ; // value是一个重要的标记}@Action(title = "沐言优拓：www.yootk.com", value = "李兴华编程训练营：yootk.ke.qq.com")class Message {       public String echo(String msg) {           return "【ECHO】" + msg ;    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           {               System.out.println("---------- 获取IMessage接口上的注解信息 ----------");            Class<?> clazz = Message.class ; // 获取接口的Class对象实例            for (Annotation annotation : clazz.getAnnotations()) {                   System.out.println(annotation);            }        }    }}

Annotation整合工厂设计模式

package com.yootk.demo;import java.lang.annotation.*;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;@Target({   ElementType.TYPE}) // 此注解可以应用在类定义上@Retention(RetentionPolicy.RUNTIME) // 在当前执行的时候此Annotation生效@interface Action {    // 自定义了一个Annotation    public String value() ; // value可以避免编写变量名称}@Target({   ElementType.CONSTRUCTOR}) // 此注解可以应用在类定义上@Retention(RetentionPolicy.RUNTIME) // 在当前执行的时候此Annotation生效@interface Instance {    // 实现实例化对象控制的类型    public String value() ; // value可以避免编写变量名称}interface IChannel extends AutoCloseable {       public boolean build() ; // 建立通道}class InternetChannel implements IChannel {       @Override    public boolean build() {           System.out.println("【InternetChannel】建立互联网通讯通道。");        return true;    }    @Override    public void close() throws Exception {           System.out.println("【InternetChannel】关闭互联网通讯通道。");    }}class RadioChannel implements IChannel {       @Override    public boolean build() {           System.out.println("【RadioChannel】建立无线电通讯通道。");        return true;    }    @Override    public void close() throws Exception {           System.out.println("【RadioChannel】关闭无线电通讯通道。");    }}class Factory {    // 编写工厂类    private Factory() {   }    public static <T> T getInstance(String className) {           try {      // 实现一个泛型工厂类            return (T) Class.forName(className).getDeclaredConstructor().newInstance();        } catch (Exception e) {               return null ;        }    }}@Action("com.yootk.demo.RadioChannel") // 通过注解配置了当前Message类所使用的通道信息class Message {    // 进行消息的发送处理    private IChannel channel ; // 如果需要发送消息就必须提供通道    @Instance("com.yootk.demo.Factory")    public Message() {     // 构造方法        try {   // 获取指定的注解配置的信息            Action actionAnnotation = super.getClass().getAnnotation(Action.class) ; // 获取类上的Annotation            Instance instanceAnnotation = super.getClass().getConstructor().getAnnotation(Instance.class); // 获取构造方法上的指定构造            String factoryClassName = instanceAnnotation.value() ;            Class factoryClazz = Class.forName(factoryClassName) ;            this.channel = (IChannel) factoryClazz.getMethod("getInstance", String.class).invoke(null, actionAnnotation.value()) ;        } catch (Exception e) {   }    }    public String echo(String msg) throws Exception {           String echoMessage = "〖ERROR〗消息发送失败！" ;        if (this.channel.build()) {    // 通道创建成功            echoMessage = "【ECHO】" + msg ; // 创建回应信息            this.channel.close();        }        return echoMessage ;    }}public class YootkDemo {       // 李兴华编程训练营：yootk.ke.qq.com    public static void main(String[] args) throws Exception {           System.out.println(new Message().echo("www.yootk.com"));    }}

反射机制与简单Java类

传统类属性赋值的弊端

属性的自动赋值实现思路

单级属性赋值

属性类型转换

级联对象的实例化