首页 - 技术栈

品牌建设公司排名济南seo整站优化价格

作者: 五速梦信息网
时间: 2026年03月21日 10:15

当前位置：首页 > news >正文

品牌建设公司排名,济南seo整站优化价格,网站制作属于什么行业,国际物流网站模板第一天 Java反射及动态代理… 2 一、 Java反射… 2 1、什么是反射#xff1a;… 2 2、反射的原理… 2 3、反射的优缺点#xff1a;… 2 4、反射的用途#xff1a;… 3 5、反射机制常用的类#xff1a;… 3 1、获得Class#xff1a;主要有三…第一天           Java反射及动态代理… 2 一、       Java反射… 2 1、什么是反射… 2 2、反射的原理… 2 3、反射的优缺点… 2 4、反射的用途… 3 5、反射机制常用的类… 3 1、获得Class主要有三种方法… 3 2、创建实例通过反射来生成对象主要有两种方法… 4 3、通过反射获取构造方法并使用… 5 二、       Java反射案例… 6 反射和properties文件… 6 反射和xml文件… 7 什么是 XML… 7 宠物管理系统… 7 反射和泛型… 8 反射和注解… 9 1、注解… 9 2、反射… 12 性能分析… 25 反射操作注解… 28 三、       动态代理案例… 31 第二天 Spring入门之DI、IOC.. 52 第三天 Spring之AOP. 52 第四天 Spring之JDBC.. 52 第五天 Spring整合MyBatis. 52 Java107班三阶段课程学习 Java反射及动态代理 Java反射 1、什么是反射 1Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息从而操作类或对象的属性和方法。本质是JVM得到class对象之后再通过class对象进行反编译从而获取对象的各种信息。 2Java属于先编译再运行的语言程序中对象的类型在编译期就确定下来了而当程序在运行时可能需要动态加载某些类这些类因为之前用不到所以没有被加载到JVM。通过反射可以在运行时动态地创建对象并调用其属性不需要提前在编译期知道运行的对象是谁。 2、反射的原理下图是类的正常加载过程、反射原理与class对象 Class对象的由来是将class文件读入内存并为之创建一个Class对象。 3、反射的优缺点 1、优点在运行时获得类的各种内容进行反编译对于Java这种先编译再运行的语言能够让我们很方便的创建灵活的代码这些代码可以在运行时装配无需在组件之间进行源代码的链接更加容易实现面向对象。 2、缺点1反射会消耗一定的系统资源因此如果不需要动态地创建一个对象那么就不需要用反射 2反射调用方法时可以忽略权限检查因此可能会破坏封装性而导致安全问题。 4、反射的用途 1、反编译.class–.java 2、通过反射机制访问java对象的属性方法构造方法等 3、当我们在使用IDE,比如Ecplise时当我们输入一个对象或者类并想调用他的属性和方法是一按点号编译器就会自动列出他的属性或者方法这里就是用到反射。 4、反射最重要的用途就是开发各种通用框架。比如很多框架Spring都是配置化的比如通过XML文件配置Bean为了保证框架的通用性他们可能需要根据配置文件加载不同的类或者对象调用不同的方法这个时候就必须使用到反射了运行时动态加载需要的加载的对象。 5、反射机制常用的类 Java.lang.Class; Java.lang.reflect.Constructor; Java.lang.reflect.Field; Java.lang.reflect.Method; Java.lang.reflect.Modifier; 1、获得Class主要有三种方法 1Object–getClass 2任何数据类型包括基本的数据类型都有一个“静态”的class属性 3通过class类的静态方法forName(String className)最常用 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);     } 2、创建实例通过反射来生成对象主要有两种方法 1使用Class对象的newInstance()方法来创建Class对象对应类的实例。 //1.管理无参构造     Test     public void test2() throws Exception {         //1.获取到某个类的字节码文件对象即class的对象         ClassDog c Dog.class; //        2.帮你调用无参构造         Dog dog c.newInstance();         System.out.println(dog);     }
2先通过Class对象获取指定的Constructor对象再调用Constructor对象的newInstance()方法来创建对象这种方法可以用指定的构造器构造类的实例。 //2.管理有参构造     Test     public void test3() throws Exception { //        1.获取到某个类的字节码文件对象即class的对象         ClassDog c Dog.class; //        2.获取有参构造的管理对象–2个参数的那个         ConstructorDog con c.getDeclaredConstructor(String.class); //        3.帮助Dog类调用有参构造         Dog dog con.newInstance(旺财);         System.out.println(dog);     }
3、通过反射获取构造方法并使用 1批量获取的方法 public Constructor[] getConstructors()所有公有的构造方法 public Constructor[] getDeclaredConstructors()获取所有的构造方法(包括私有、受保护、默认、公有) 2单个获取的方法并调用 public Constructor getConstructor(Class… parameterTypes):获取单个的公有的构造方法 public Constructor getDeclaredConstructor(Class… parameterTypes):获取某个构造方法可以是私有的或受保护、默认、公有 3 调用构造方法 Constructor–newInstance(Object… initargs) newInstance是 Constructor类的方法管理构造函数的类 //3.管理属性     Test     public void test4() throws Exception {         //1.获取到某个类的字节码文件对象即Class的对象         ClassDog 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的对象         ClassDog 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));     } Java反射案例反射和properties文件先复习一个Propertis这个类在Emp类中写一个方法study 在resources中创建一个db.properties文件录入内容 classNamecom.hr.entity.EmpmethodNamestudy 创建测试方法 Testpublic 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文件什么是 XML XML 指可扩展标记语言EXtensible Markup Language。 XML 是一种很像HTML的标记语言。 XML的设计宗旨是传输数据而不是显示数据。 XML 标签没有被预定义。您需要自行定义标签。 XML 被设计为具有自我描述性。 XML 是 W3C的推荐标准。 XML 和 HTML 之间的差异 XML 不是 HTML 的替代。。 XML 和 HTML 为不同的目的而设计 XML 被设计用来传输和存储数据其焦点是数据的内容。 HTML 被设计用来显示数据其焦点是数据的外观。 HTML 旨在显示信息而 XML 旨在传输信息。宠物管理系统 1.预先定义好父类动物类子类狗狗类企鹅类大象类 2.在xml文件中配置各个宠物类的全路径名 3.编写一个宠物领养方法根据用户输入的宠物名称从xml读取相应的类路径使用反射构建宠物对象并返回。注意使用父类作为方法返回值字符串作为参数。 xml文件 ?xml version1.0 encodingUTF-8 ? animal     狗狗         name旺财/name         classreflect.pet.Dog/class     /狗狗     企鹅         name皮皮/name         classreflect.pet.Penguin/class     /企鹅     大象        name肉肉/name         classreflect.pet.Elephant/class     /大象 /animal
Java文件 Test     public void test1() throws Exception {         Scanner scnew 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 {         HashMapString, Object map new HashMap();         map.put(name,旺财);         map.put(age,3);         Dog dog getObject(map, Dog.class);         System.out.println(dog);     }     public TT getObject(MapString,Object map, ClassT c) throws Exception {         T t c.newInstance();         //1.拆开map         SetMap.EntryString, Object entries map.entrySet();         for (Map.EntryString, 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;     } 反射和注解 1、注解 1.1 注解Annotation的概念 1.注解的作用注解Annotation是从JDK1.5开始引入的新技术我们在编程中经常会使用到注解它的作用有 1) 编译检查比如SuppressWarningsDeprecated和Override都具有编译检查作用 2) 替代配置文件使用反射来读取注解信息。目前大部分框架如Spring都使用了注解简化代码并提高编码的效率使用注解之前使用的xml进行配置。注解其实就是对程序作出解释这一点和注释类似不是程序本身可以被其他程序读取。可以通过注解告诉类如何运行。 2.注解的使用范围在Java技术里注解的典型应用是可以通过反射技术去得到类里面的注解以决定怎么去运行类。注解可以标记在package包、class类、field属性、method方法等上面且在同一个地方可以同时标记多个注解。注解可以在编译(source),类加载(class),运行时(runtime)被读取并执行相应的处理以便于其他工具补充信息或者进行部署。 3.注解的格式注解名称参数名“参数值”… 例如SuppressWarnings(value unchecked) 4.注解的作用分类编写文档通过代码里标识的注解生成文档生成文档doc文档代码分析通过代码里标识的注解对代码进行分析使用反射编译检查通过代码里标识的注解让编译器能够实现基本的编译检查SuppressWarnings等 1.2 内置注解主要的内置注解有三个 Override -只适用于修饰方法表示一个方法声明打算重写超类中的另一个方法声明。 Deprecated -标记过时的方法不建议使用该方法。 SuppressWarnings -用来抑制编译时的警告信息还需要添加一个参数。 SuppressWarnings(all/unchecked)指示关闭警告的范围。 1.3 元注解元注解的作用就是负责注解其他注解Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明. 1.Target -用来描述注解可以使用的范围比如方法、类或字段其中ElementType是枚举类型。若没有Target则该注解可以用于任何地方。 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 }
比如Target(value {ElementType.TYPE,ElementType.METHOD})表示该注解可以用在类接口或者方法上。 2.Retention用来约束注解的生命周期分别有三个值源码级别source、类文件级别class和运行时级别runtime。若没有Retention则默认是类文件级别class。(生命周期sourceclassruntime) SOURCE注解将被编译器丢弃该类型的注解信息只会保留在源码里源码经过编译后注解信息会被丢弃不会保留在编译好的class文件里 CLASS注解在class文件中可用但会被JVM丢弃该类型的注解信息会保留在源码里和class文件里在执行的时候不会加载到虚拟机中。 RUNTIME注解信息将在运行期(JVM)也保留因此可以通过反射机制读取注解的信息源码、class文件和执行的时候都有注解的信息如SpringMvc中的Controller、Autowired、RequestMapping等。 3.Documented -说明该注解将被包含在用户文档javadoc中 4.Inherited -说明子类可以继承父类中的该注解。如当类B继承了类AInherited注解加到了A上则B也会带上该注解。 1.4 自定义注解使用interface来声明一个注解格式public interface 注解名{ 定义内容 }定义内容中的每一个“方法”实际上是声明了一个配置参数。如下定义了MyAnnotation注解 Target({ElementType.TYPE,ElementType.METHOD}) //作用范围 Retention(RetentionPolicy.RUNTIME) //生命周期 Documented // 生成javadoc中含有 Inherited // 子类可以继承 interface MyAnnotation{ String value() default ; //使用类型名称默认值的格式 int age(); String[ ] school() default {yndx, 清华大学}; } 该注解中有三个配置参数String类型的valueint类型的age和String数组类型的school其中使用default定义了默认值。注意定义注解时意味着它实现了 java.lang.annotation.Annotation 接口即该注解就是一个Annotation。和我们通常 implements实现接口的方法不同。Annotation 接口的实现细节都由编译器完成。通过 interface 定义注解后该注解不能继承其他注解或接口。 2、反射 2.1 Java反射机制概述 2.1.1 静态语言和动态语言 1.动态语言是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要的动态语言有C#、JavaScript、PHP、Python等 function f() { var x var a3;var b5;alert(ab); eval(x); //    运行时改变x的类型和值 } 2.静态语言与动态语言相对应的运行时结构不可变的语言就是静态语言。如Java、C、C。注Java不是动态语言但Java可以称之为“准动态语言”。即Java有一定的动态性我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活! 2.1.2 Reflection反射 Reflection反射)是java被视为动态语言的关键反射机制允许程序在指定期借助于Reflection API取得任何类的内部信息并能直接操作任意对象的内部属性及方法。 Class c Class.forName(java.lang.String); 加载完类之后在堆内存的方法区中就产生了一个Class类型的对象一个类只有一个Class对象)这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子透过这个镜子看到类的结构所以我们形象的称之为:反射。 2.1.3 Java反射机制提供的功能在运行时判断任意一个对象所属的类在运行时构造任意一个类的对象在运行时判断任意一个类所具有的成员变量和方法在运行时获取泛型信息在运行时调用任意一个对象的成员变量和方法在运行时处理注解生成动态代理 2.1.4 Java反射的优点和缺点优点可以实现动态创建对象和编译体现出很大的灵活性。缺点对性能有影响。使用反射基本上是一种解释操作我们可以告诉JVM我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作直接通过对象操作的方式。 2.2 理解Class类并获取Class实例 2.2.1 Class类 1.概述对象照镜子后可以得到一个信息某个类的属性、方法和构造器某个类到底实现了哪些接口。对于每个类而言JRE都为其保留一个不变的Class类型的对象一个Class对象包含了特定某个结构的有关信息。 Class本身也是一个类。 Class对象只能由系统建立。一个加载的类在JVM中只会有一个Class实例。一个Class对象对应的是一个加载到JVM中的.class文件。每个类的实例都会记得自己是由哪个Class实例所生成的。通过Class可以完整地得到一个类中的所有被加载的结构。 Class类是Reflection的根源针对任何你想动态加载、运行的类唯有先获得相应的Class对象。 2.Class类的常用方法 ClassforName(String name);返回指定类名name的Class对象。 Object newInstance();调用缺省构造函数返回Class对象的一个实例。 getName();返回此Class对象所表示的实体类类、接口、数组类或void的名称。 Class getSuperClass();返回当前Class对象的父类的Class对象。 Class[ ] getinterfaces();获取当前Class对象的接口。 ClassLoader getClassLoader();返回该类的类加载器。 Constructor[ ] getConstructors();返回一个包含某些Constructor对象的数组。 Method getMothed(String name,Class… T);返回一个Method对象此对象的形参类型为paramType。 Field[ ] getDeclaredFields();返回Field对象的一个数组。 2.2.2 获得Class类的方式 1.若已知具体的类通过类的class属性获取该方法最为安全可靠程序性能最高。如 Class clazz Person.class; 2.已知某个类的实例调用该实例的getClass()方法获取Class对象。如 Class clazz person.getClass(); 在Object类中定义了getClass()方法此方法被所有子类继承 public final Class getClass() 以上的方法返回值的类型是一个Class类此类是Java反射的源头实际上所谓反射从程序的运行结果来看也很好理解即:可以通过对象反射求出类的名称。因此所有类都继承了getClass()方法。 3.已知一个类的全类名且该类在类路径下可通过Class类的静态方法forName()获取可能抛出ClassNotFoundException。如 Class clazz Class.forName(demo01.Student); 4.内置基本数据类型可以直接用类名.Type。 Class c Integer.TYPE; 5.还可以利用ClassLoader。 2.2.3 哪些类型有Class对象 class外部类成员成员内部类静态内部类局部内部类匿名内部类 interface接口 [ ]数组 enum枚举 annotation注解interface primitive type基本数据类型 void空类型 import java.lang.annotation.ElementType; // 所有类型的class public class Test04 {     public static void main(String[] args) {         ClassObject c1 Object.class;    // 类         ClassComparable c2 Comparable.class;    // 接口         ClassString[] c3 String[].class; // 一维数组         Classint[][] c4 int[][].class;   // 二维数组         ClassOverride c5 Override.class;   // 注解         ClassElementType c6 ElementType.class;   // 枚举         ClassInteger c7 Integer.class;   // 基本数据类型         ClassVoid c8 void.class;   //void         ClassClass 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());     } } 2.3 类的加载与ClassLoader 2.3.1 Java内存分析堆存放new的对象和数组可以被所有的线程共享不会存放别的对象的引用。栈存放基本变量类型会包含这个基本类型的具体数值引用对象的变量会存放这个引用在堆里面的具体地址。方法区可以被所有的线程共享包含了所有的class和static变量。 2.3.2 类的加载过程当程序主动使用某个类时如果该类还未被加载到内存中则系统会通过这三个步骤对该类进行初始化 1.类的加载Load 将类的class文件读入内部并为之创建一个java.lang.Class对象。此过程由类加载器完成加载:将class文件字节码内容加载到内存中并将这些静态数据转换成方法区的运行时数据结构然后生成一个代表这个类的java.lang.Class对象。 2.类的链接Link 将类的二进制数据合并到JRE中链接:将Java类的二进制代码合并到JVM的运行状态之中的过程。包括验证:确保加载的类信息符合JVM规范没有安全方面的问题准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段这些内存都将在方法区中进行分配。解析:虚拟机常量池内的符号引用常量名替换为直接引用(地址)的过程。 3.类的初始化Initialize 1JVM负责对类进行初始化执行类构造器clinit()方法的过程。类构造器clinit()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的不是构造该类对象的构造器)。当初始化一个类的时候如果发现其父类还没有进行初始化则需要先触发其父类的初始化。虚拟机会保证一个类的clinit()方法在多线程环境中被正确加锁和同步。 2什么时候会发生类的初始化 1.类的主动引用一定会发生类的初始化当虚拟机启动先初始化main方法所在的类; new 一个类的对象; 调用类的静态成员除了final常量和静态方法; 使用java.lang.reflect包的方法对类进行反射调用; 当初始化一个类如果其父类没有被初始化则先会初始化它的父类。 2.类的被动引用不会发生类的初始化当访问一个静态域时只有真正声明这个域的类才会被初始化。如当通过子类引用父类的静态变量不会导致子类初始化。通过数组定义类引用不会触发此类的初始化引用常量不会触发此类的初始化常量在链接阶段就存入调用类的常量池中了。代码演示 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类的无参数构造函数初始化);     } } 解释执行过程 1.加载到内存会产生一个类对应Class对象 2.链接连接结束后分配内存设置初始值 m0 3.初始化 (){ //将静态代码块合并执行 System.out.println(A类静态代码块初始化); m300 m100} 2.3.3 类的加载器类加载器的作用将class文件字节码内容加载到内存中并将这些静态数据转换成方法区的运行时数据结构然后在堆中生成一个代表这个类的java.lang.Class对象作为方法区中类数据的访问入口。类缓存标准的JavaSE类加载器可以按要求查找类但一旦某个类被加载到类加载器中它将持续加载缓存一段时间。不过JVM垃圾回收机制可以回收这些Class对象。类加载器的分类引导类加载器用C编写的是JVM自带的类加载器负责Java平台核心库,用来装载核心类库该加载器无法直接获取。扩展类加载器负责jre/lib/ext目录下的jar包或-D Java.ext.dirs指定目录下的jar包装入工作库系统类加载器负责java -classpath或 -D java.class.path所指的目录下的类与jar包装入工作是最常用的加载器。 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));     } } 2.4 Class对象的作用 2.4.1 使用Class对象获得运行时类的完整结构通过反射获取运行时类的完整结构Field属性、Method方法、Constructor构造器、SuperClass父类、Interface接口、Annotation注解 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));     } }
2.4.2 创建对象创建类的对象调用Class对象的newInstance()方法 1.类必须有一个无参数的构造器没有无参构造器创建对象的方法只要在操作的时候明确的调用类中的构造器并将参数传递进去之后才可以实例化操作步骤 1.通过Class类的getDeclaredConstructor(Class…parameterTypes)取得本类的指定形参类型的构造器 2.向构造器的形参中传递一个对象数组进去里面包含了构造器中所需的各个参数 3.通过Constructor实例化对象。 2.类的构造器的访问权限需要足够。 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());     } } 2.4.3 调用指定方法调用指定的方法 1.通过Class类的getMethod(方法名, 参数类型列表)获得一个Method对象 2. Method.invoke(执行方法的对象,参数值列表)进行调用格式 Object invokeObject obj, Object…args Object对应原方法的返回值若原方法没有返回值此时返回null 若原方法为静态方法此时形参Object obj可为null 若原方法形参列表为空则Object[ ]args为null 若原方法声明为private则需要在调用此invoke方法前显式调用方法对象的setAccessible(true)方法才可访问该方法。代码示例同上性能分析 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();     } } 2.4.5 通过反射获取泛型信息通过反射获取泛型 Java采用泛型擦除的机制来引入泛型Java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型转换问题但是一旦编译完成﹐所有和泛型有关的类型全部擦除。为了通过反射操作这些类型Java新增了ParameterizedType , GenericArrayType ,TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。 ParameterizedType:表示一种参数化类型,比如Collection GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型 TypeVariabie:是各种类型变量的公共父接口 WildcardType:代表一种通配符类型表达 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(MapString,User map, ListUser list){         System.out.println(test01);     }     public MapString,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语言的拼接     } }
运行结果动态代理案例利用Jdk动态代理模拟MyBatis的Mapper功能本文将先介绍jdk动态代理的基本用法并对其原理和注意事项予以说明。之后将以两个最常见的应用场景为例进行代码实操。这两个应用场景分别是拦截器和声明性接口它们在许多开发框架中广泛使用。比如在spring和mybatis中均使用了拦截器模式在mybatis中还利用动态代理来实现声明性接口的功能。因此掌握动态代理的原理和代码书写方式对阅读理解这些开源框架非常有益。示例代码基于jdk8编写小示例先来看一个jdk代理的最小demo 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 请在这里插入代理的逻辑代码... 其中倒数第二行的businessProxy变量就是一个代理对象它是BusinessInterface接口的一个实例但我们并没有编写这个接口的实现类而是通过Proxy.newProxyInstance方法生成出了该接口的实例。那么这个动态代理实例对应的Class长什么样子呢上面的结果输出中已经打印出来了这个代理类名称为com.sun.proxy.\)Proxy0。实际上如果我们再为另外一个接口生成代理对象的话它的Class名称为com.sun.proxy.\(Proxy1依次类推。还有一个值得关注的问题最重要的逻辑代码应该写在哪里答案是写在InvocationHandler这个接口的invoke()方法中也就是上面示例代码的第⑵处。由此可以看出代理对象实际要执行的代码就是invoke()方法中的代码换言之代理对象所代理的所有接口方法最终要执行的代码都在invoke方法里因此这里是一切魔法的入口。编写一个jdk代理实例的基本步骤如下编写业务接口因为jdk代理是基于接口的因此只能将业务方法定义成接口但它可以一次生成多个接口的代理对象编写调用处理器即编写一个java.lang.reflect.InvocationHandler接口的实现类代理对象的业务逻辑就写在该接口的invoke方法中生成代理对象有了业务接口和调用处理器后将二者作为参数通过Proxy.newProxyInstance方法便可以生成这个或这些接口的代理对象。比如上述示例代码中的businessProxy对象它拥有greeting()这个方法调用该方法时实际执行的就是invoke方法。编写一个jdk代理实例的基本步骤如下编写业务接口因为jdk代理是基于接口的因此只能将业务方法定义成接口但它可以一次生成多个接口的代理对象编写调用处理器即编写一个java.lang.reflect.InvocationHandler接口的实现类代理对象的业务逻辑就写成该接口的invoke方法中生成代理对象有了业务接口和调用处理器后将二者作为参数通过Proxy.newProxyInstance方法便可以生成这个或这些接口的代理对象。比如上述示例代码中的businessProxy对象它拥有greeting()这个方法调用该方法时实际执行的就是invoke方法。代理对象生成原理代理的目的是为接口动态生成一个实例对象该对象有接口定义的所有方法。调用对象的这些方法时都将执行生成该对象时指定的“调用处理器”中的方法即invoke方法。 Proxy.newProxyInstance (ClassLoader loader, Class?[] interfaces, InvocationHandler handler) classloader一般选择当前类的类加载器interfaces是一个接口数组newProxyInstance方法将为这组接口生成实例对象handler中的代码则是生成的实例对象实际要执行的内容这些代码就位于invoke方法中。在生成代理对象前会先生成一个Class这个Class实现了interfaces中的所有接口且这些方法的内容为直接调用handler#invoke如下图所示代理对象生成原理代理的目的是为接口动态生成一个实例对象该对象有接口定义的所有方法。调用对象的这些方法时都将执行生成该对象时指定的“调用处理器”中的方法即invoke方法。生成代理对象的方法签名如下 Proxy.newProxyInstance (ClassLoader loader, Class?[] interfaces, InvocationHandler handler) classloader一般选择当前类的类加载器interfaces是一个接口数组newProxyInstance方法将为这组接口生成实例对象handler中的代码则是生成的实例对象实际要执行的内容这些代码就位于invoke方法中。在生成代理对象前会先生成一个Class这个Class实现了interfaces中的所有接口且这些方法的内容为直接调用handler#invoke如下图所示特别说明 InvocationHandler的invoke方法签名为 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 在该方法的实现代码中不要调用proxy参数的toString方法, 这会导致递归死循环下面将以小示例中的BusinessInterface接口和ProxyLogicHandler为基础用普通Java代码的方式模拟一下Proxy.newProxyInstance的代码逻辑如下 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});     } } 上面的代码是示意性的并不正确比如它没有使用到loader和interfaces参数调用hanlder.invoke方法时对于method参数只是简单的用greeting字符串替代类型都不正确。但这段示意代码很简单明了地呈现了真实的Proxy.newProxyInstance方法内部的宏观流程。下面再提供一个与真实的newProxyInstance方法稍微接近一点的模拟实现需要您对jdk里JavaCompiler类的使用有一定了解 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;             }         };         ListJavaFileObject 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
应用场景上面提到代理是在运行期为接口动态生成了一个实现类和这个实现类的实例。那这个功能有什么用呢我们直接写一个实现类不也是一样的么代理类与我们手动写代码的主要差异在于它的动态性它允许我们在程序的运行期间动态创建Class这对于框架类程序为其预设的业务组件增加公共特性提供了技术支持。因为这种额外特性的加持对业务代码没有直接的侵入性因此效果非常好。动态代理的两个最常用见应用场景为拦截器和声明性接口下面分别介绍。拦截器功能搭载器就是将目标组件劫持在执行目标组件代码的前后塞入一些其它代码。比如在正式执行业务方法前先进行权限校验如果校验不通过则拒绝继续执行。对于此类操作业界已经抽象出一组通用的编程模型面向切面编程AOP。接下来将以演员和导演为业务背景实现一个简易的拦截器各个组件介绍如下 Performer Interface 演员接口有play和introduction方法 DefaultActor Class 代表男性演员它实现了Performer接口也是拦截器将要拦截的对象 Director Interface 导演接口只有一个getCreations方法, 该方法返回一个字符串列表它代表导演的作品集 DefaultDirector Class Director接口的实现类同时也是拦截器将要拦截的对象 ProxyForInterceptor Class 拦截器核心类实现了InvocationHandler接口拦截器代码位于接口的invoke方法中。拦截器将持有Performer和Direcotor的真实实现实例并在调用Performer的play和introduction方法前先执行一段代码。这里实现为打印一段文本接着再调用play或introduction执行完后再执行一段代码也是打印一段文本。Director实例方法的拦截处理逻辑与此相同。这便是最简单的拦截器效果了。 IntercepterTestMain Class 拦截器测试类在main方法中验证上述组件的拦截器功能效果。这个例子中特意写了两个接口和两个实现类就是为了演示JDK的动态代理是支持多接口的。 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 作品名称列表      /     ListString getCreations(); } DefaultDirector package guzb.study.javacore.proxy.jdk; import java.util.ArrayList; import java.util.List; /** 这是导演接口的默认实现类 * 在本示例中它将作为原始的接口实现者被代理(拦截) / public class DefaultDirector implements Director{     Override     public ListString 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接口相关的方法         ListString 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 ]: 代理对象返回的导演作品列表     · 活着     · 盲井     · 走出夹边沟     · 少年派的奇幻漂流
可以看到在main方法中调用代理类的play方法后位于代码的①处在执行真实的DefaultActor#play方法前后均有额外的文本输出这些都不是DefaultActor#play方法的逻辑。这便实现了拦截器效果且对于使用者而言即编写DefaultActor类的开发者是无侵入无感知的。声明性接口声明性接口的特点是开发者只需要提供接口并在接口方法中声明该方法要完成的功能通常是以多个注解的方式声明但不用编写具体的功能实现代码而是通过框架的工厂方法来获取该接口的实例。当然该实例会完成接口方法中所声明的那些功能。比较典型的产品是MyBatis的Mapper接口。实现手段也是采用jdk动态代理在InvocationHandler的invoke方法中完成该接口方法所声明的那些特性功能。接下来本文将模拟MyBatis的Mapper功能组件说明如下 SqlMapper Annotaton 与MyBatis的Mapper注解等效用于标识一个接口为Sql映射接口但在本示例中这个接口并未使用到。因为这个标识接口的真实用途是在SpringBoot环境中用于自动扫描和加载Mapper接口的。本示例仅模拟Mapper本身的声明性功能因此用不上它。保留这个接口只是为了显得更完整。 Select Annotation 与MyBatis的Select注解等效它有一个sql属性用于指定要执行的SQL语句且支持#{}形式的插值 ParamName Annotation 与MyBatis的Param注解等效用于标识Mapper接口的方法参数名称以便用于Select注解中sql语句的插值替换 PerformerMapper Interface 演员实体的数据库访问接口与开发者使用MyBatis时日常编写的各类Mapper接口一样。在里边定义各种数据库查询接口方法并利用Select和ParamName注解声明数据操作的具体功能。 ProxyForDeclaration Class 整个Mapper功能的核心类实现了InvocationHandler接口在invoke方法中完成Mapper的所有功能 DeclarationTestMain Class 声明性接口的功能测试类在main方法中通过jdk代理获得一个PerformerMapper实例并调用其中的getQuantityByNameAndAage、getRandomPoetryOf和listAllOfAge方法分别传入不的SQL和参数用以验证3种不同的情况。下面是各个组件的源代码 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为参数对象         MapString, 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 MapString, Object extractParameterMap(Method method, Object[] args) {         Parameter[] parameters method.getParameters();         if (parameters.length 0) {             return Collections.EMPTY_MAP;         }         MapString, 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 nameJane 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)
以上代码共模拟了3个调用Mapper的场景调用getQuantityByNameAndAage()方法根据姓名的年龄查询演员数量。但并未真正执行JDBC查询只是将SQL进行了插值替换和输出然后随机返回了一个数字。这足以演示声明性接口这一特性了真实地执行jdbc查询那将一个代码量巨大的工作它的缺失并不影响本示例的主旨。调用getRandomPoetryOf()方法查询指定诗人的一段诗句。同样没有真正执行jdbc查询而是随机返回了一句诗文。调用listAllOfAge()方法查询指定年龄的所有演员。该方法有意设计为引发一个异常因为接口方法上声明的SQL中pageSize这个插值变量并未在方面签名中声明。