引言
Java 动态代理机制的出现，使得 Java 开发人员不用手工编写代理类，只要简单地指定一组接口及委托类对象，便能动态地获得代理类。代理类会负责将所有的方法调用分派到委托对象上反射执行，在分派执行的过程中，开发人员还可以按需调整委托类对象及其功能，这是一套非常灵活有弹性的代理框架。通过阅读本文，读者将会对 Java 动态代理机制有更加深入的理解。本文首先从 Java 动态代理的运行机制和特点出发，对其代码进行了分析，推演了动态生成类的内部实现。
代理：设计模式
代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。
图 1. 代理模式
为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。
相关的类和接口
要了解 Java 动态代理的机制，首先需要了解以下相关的类或接口：
https://www.doczj.com/doc/884835308.html,ng.reflect.Proxy：这是 Java 动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
清单 1. Proxy 的静态方法
?https://www.doczj.com/doc/884835308.html,ng.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。
清单 2. InvocationHandler 的核心方法
每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象（参见 Proxy 静态方法 4 的第三个参数）。
?https://www.doczj.com/doc/884835308.html,ng.ClassLoader：这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。
每次生成动态代理类对象时都需要指定一个类装载器对象（参见 Proxy 静态方法 4 的第一个参数）
代理机制及其特点
首先让我们来了解一下如何使用 Java 动态代理。具体有如下四步骤：
1.通过实现 InvocationHandler 接口创建自己的调用处理器；
2.通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
3.通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
4.通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。
清单 3. 动态代理对象创建过程
实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下
清单 4. 简化的动态代理对象创建过程
接下来让我们来了解一下 Java 动态代理机制的一些特点。
首先是动态生成的代理类本身的一些特点。1）包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是
com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；2）类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；3）类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。4）类继承关系：该类的继承关系如图：
图 2. 动态代理类的继承图
由图可见，Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。
接下来让我们了解一下代理类实例的一些特点。每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行，此外，值得注意的是，代理类的根类 https://www.doczj.com/doc/884835308.html,ng.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们
是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。
接着来了解一下被代理的一组接口有哪些特点。首先，要注意不能有重复的接口，以避免动态代理类代码生成时的编译错误。其次，这些接口对于类装载器必须可见，否则类装载器将无法链接它们，将会导致类定义失败。再次，需被代理的所有非 public 的接口必须在同一个包中，否则代理类生成也会失败。最后，接口的数目不能超过 65535，这是 JVM 设定的限制。
最后再来了解一下异常处理方面的特点。从调用处理器接口声明的方法中可以看到理论上它能够抛出任何类型的异常，因为所有的异常都继承于 Throwable 接口，但事实是否如此呢？答案是否定的，原因是我们必须遵守一个继承原则：即子类覆盖父类或实现父接口的方法时，抛出的异常必须在原方法支持的异常列表之内。所以虽然调用处理器理论上讲能够，但实际上往往受限制，除非父接口中的方法支持抛 Throwable 异常。那么如果在 invoke 方法中的确产生了接口方法声明中不支持的异常，那将如何呢？放心，Java 动态代理类已经为我们设计好了解决方法：它将会抛出 UndeclaredThrowableException 异常。这个异常是一个 RuntimeException 类型，所以不会引起编译错误。通过该异常的 getCause 方法，还可以获得原来那个不受支持的异常对象，以便于错误诊断。
代码是最好的老师
机制和特点都介绍过了，接下来让我们通过源代码来了解一下 Proxy 到底是如何实现的。
首先记住 Proxy 的几个重要的静态变量：
清单 5. Proxy 的重要静态变量
然后，来看一下 Proxy 的构造方法：
清单 6. Proxy 构造方法
接着，可以快速浏览一下 newProxyInstance 方法，因为其相当简单：
清单 7. Proxy 静态方法 newProxyInstance
由此可见，动态代理真正的关键是在 getProxyClass 方法，该方法负责为一组接口动态地生成代理类类型对象。在该方法内部，您将能看到 Proxy 内的各路英雄（静态变量）悉数登场。有点迫不及待了么？那就让我们一起走进 Proxy 最最神秘的殿堂去欣赏一番吧。该方法总共可以分为四个步骤：
1.对这组接口进行一定程度的安全检查，包括检查接口类对象是否对类装载器可见并且与类装载器
所能识别的接口类对象是完全相同的，还会检查确保是 interface 类型而不是 class 类型。这个步骤通过一个循环来完成，检查通过后将会得到一个包含所有接口名称的字符串数组，记
为 String[] interfaceNames。总体上这部分实现比较直观，所以略去大部分代码，仅保留留如何判断某类或接口是否对特定类装载器可见的相关代码。
清单 8. 通过 Class.forName 方法判接口的可见性
2.从 loaderToCache 映射表中获取以类装载器对象为关键字所对应的缓存表，如果不存在就创建一
个新的缓存表并更新到 loaderToCache。缓存表是一个 HashMap 实例，正常情况下它将存放键值对（接口名字列表，动态生成的代理类的类对象引用）。当代理类正在被创建时它会临时保存（接口名字列表，pendingGenerationMarker）。标记 pendingGenerationMarke 的作用是通知后续的同类请求（接口数组相同且组内接口排列顺序也相同）代理类正在被创建，请保持等待直至创建完成。
清单 9. 缓存表的使用
3.动态创建代理类的类对象。首先是确定代理类所在的包，其原则如前所述，如果都为 public 接
口，则包名为空字符串表示顶层包；如果所有非 public 接口都在同一个包，则包名与这些接口的包名相同；如果有多个非 public 接口且不同包，则抛异常终止代理类的生成。确定了包后，就开始生成代理类的类名，同样如前所述按格式“$ProxyN”生成。类名也确定了，接下来就是见证奇迹的发生——动态生成代理类：
清单 10. 动态生成代理类
由此可见，所有的代码生成的工作都由神秘的 ProxyGenerator 所完成了，当你尝试去探索这个类时，你所能获得的信息仅仅是它位于并未公开的 sun.misc 包，有若干常量、变量和方法以完成这个神奇的代码生成的过程，但是 sun 并没有提供源代码以供研读。至于动态类的定义，则由Proxy 的 native 静态方法 defineClass0 执行。
4.代码生成过程进入结尾部分，根据结果更新缓存表，如果成功则将代理类的类对象引用更新进缓
存表，否则清楚缓存表中对应关键值，最后唤醒所有可能的正在等待的线程。
走完了以上四个步骤后，至此，所有的代理类生成细节都已介绍完毕，剩下的静态方法如getInvocationHandler 和 isProxyClass 就显得如此的直观，只需通过查询相关变量就可以完成，所以对其的代码分析就省略了。
代理类实现推演
分析了 Proxy 类的源代码，相信在读者的脑海中会对 Java 动态代理机制形成一个更加清晰的理解，但是，当探索之旅在 sun.misc.ProxyGenerator 类处嘎然而止，所有的神秘都汇聚于此时，相信不少读者也会对这个 ProxyGenerator 类产生有类似的疑惑：它到底做了什么呢？它是如何生成动态代理类的代码的呢？诚然，这里也无法给出确切的答案。还是让我们带着这些疑惑，一起开始探索之旅吧。
事物往往不像其看起来的复杂，需要的是我们能够化繁为简，这样也许就能有更多拨云见日的机会。抛开所有想象中的未知而复杂的神秘因素，如果让我们用最简单的方法去实现一个代理类，唯一的要求是同样结合调用处理器实施方法的分派转发，您的第一反应将是什么呢？“听起来似乎并不是很复杂”。的确，掐指算算所涉及的工作无非包括几个反射调用，以及对原始类型数据的装箱或拆箱过程，其他的似乎都已经水到渠成。非常地好，让我们整理一下思绪，一起来完成一次完整的推演过程吧。
清单 11. 代理类中方法调用的分派转发推演实现
模拟推演为了突出通用逻辑所以更多地关注正常流程，而淡化了错误处理，但在实际中错误处理同样非常重要。从以上的推演中我们可以得出一个非常通用的结构化流程：第一步从代理接口获取被调用的方法对象，第二步分派方法到调用处理器执行，第三步返回结果。在这之中，所有的信息都是可以已知的，比如接口名、方法名、参数类型、返回类型以及所需的装箱和拆箱操作，那么既然我们手工编写是如此，那又有什么理由不相信 ProxyGenerator 不会做类似的实现呢？至少这是一种比较可能的实现。
接下来让我们把注意力重新回到先前被淡化的错误处理上来。在异常处理 1 处，由于我们有理由确保所有的信息如接口名、方法名和参数类型都准确无误，所以这部分异常发生的概率基本为零，所以基本可以忽略。而异常处理 2 处，我们需要思考得更多一些。回想一下，接口方法可能声明支持一个异常列表，而调用处理器 invoke 方法又可能抛出与接口方法不支持的异常，再回想一下先前提及的 Java 动态代理的关于异常处理的特点，对于不支持的异常，必须抛 UndeclaredThrowableException 运行时异常。所以通过再次推演，我们可以得出一个更加清晰的异常处理 2 的情况：
清单 12. 细化的异常处理 2
这样我们就完成了对动态代理类的推演实现。推演实现遵循了一个相对固定的模式，可以适用于任意定义的任何接口，而且代码生成所需的信息都是可知的，那么有理由相信即使是机器自动编写的代码也有可能延续这样的风格，至少可以保证这是可行的。
美中不足
诚然，Proxy 已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface 代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，原因是多继承在 Java 中本质上就行不通。
有很多条理由，人们可以否定对 class 代理的必要性，但是同样有一些理由，相信支持 class 动态代理会更美好。接口和类的划分，本就不是很明显，只是到了 Java 中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。
但是，不完美并不等于不伟大，伟大是一种本质，Java 动态代理就是佐例。
本文希望将 Java 动态代理机制从接口扩展到类，使得类能够享有与接口类似的动态代理支持。
设计及特点
新扩展的类名为 ProxyEx，将直接继承于 https://www.doczj.com/doc/884835308.html,ng.reflect.Proxy，也声明了与原 Proxy 类中同名的public 静态方法，目的是保持与原代理机制在使用方法上的完全一致。
图 1. ProxyEx 类继承图
与原代理机制最大的区别在于，动态生成的代理类将不再从 Proxy 类继承，改而继承需被代理的类。由于Java 的单继承原则，扩展代理机制所支持的类数目不得多于一个，但它可以声明实现若干接口。包管理的机制与原来相似，不支持一个以上的类和接口同时为非 public；如果仅有一个非 public 的类或接口，假设其包为 PackageA，则动态生成的代理类将位于包 PackageA；否则将位于被代理的类所在的包。生成的代理类也被赋予 final 和 public 访问属性，且其命名规则类似地为“父类名+ProxyN”（N 也是递增的阿拉伯数字）。最后，在异常处理方面则与原来保持完全一致。
图 2. 动态生成的代理类的继承图
模板
通过对 Java 动态代理机制的推演，我们已经获得了一个通用的方法模板。可以预期的是，通过模板来定制和引导代理类的代码生成，是比较可行的方法。我们将主要使用两个模板：类模板和方法模板。
清单 1. 类模板
类模板定制了代理类的代码框架。其中带“&”前缀的标签位被用来引导相应的代码替换。在此预留了包（&Package）、类名（&ClassName）、类继承（&Extends）、接口实现（&Implements）、构造函数集（&Constructors）及方法集（&Methods）的标签位。类模板还同时声明了一个私有型的调用处理器对象作为类成员。
清单 2. 方法模板
方法模板定制了代理类方法集合中各个方法的代码框架，同样的带“&”前缀的标签位被用来引导相应的代码替换。在此预留了修饰符（&Modifiers）、返回类型（&ReturnType）、方法名（&MethodName）、参数列表（Parameters）、异常列表（&Throwables）、方法的声明类（&Class）、参数类型列表（&ParameterTypes）、调用处理器的参数值列表（&ParameterValues），异常处理（&Exceptions）及返回值（&Return）的标签位。
代码生成
有了类模板和方法模板，代码生成过程就变得有章可依。基本过程可分为三步：1）生成代理类的方法集合；2）生成代理类的构造函数；3）最后生成整个代理类。
生成代理类的方法集
第一步，通过反射获得被代理类的所有 public 或 protected 且非 static 的 Method 对象列表，这些方法将被涵盖的原因是它们是可以被其他类所访问的。
第二步，遍历 Method 对象列表，对每个 Method 对象，进行相应的代码生成工作。
清单 3. 对标签位进行代码替换生成方法代码
这里涉及了一些 ProxyEx 类的私有的辅助函数如 getMethodModifiers 和 getMethodReturnType 等等，它们都是通过反射获取所需的信息，然后动态地生成各部分代码。函数 getMethodEntity 是比较重要的辅助函数，它又调用了其他的辅助函数来生成代码并替换标签位。
清单 4. ProxyEx 的静态方法 getMethodEntity()
当为 Class 类型对象生成该类型对应的字符代码时，可能涉及数组类型，反推过程会需要按递归方法生成代码，这部分工作由 getTypeHelper 方法提供
清单 5. ProxyEx 的静态方法 getTypeHelper()
第三步，将所生成的方法保存进一个 map 表，该表记录的是键值对（方法声明，方法实现）。由于类的多态性，父类的方法可能被子类所覆盖，这时以上通过遍历所得的方法列表中就会出现重复的方法对象，维护该表可以很自然地达到避免方法重复生成的目的，这就维护该表的原因所在。
生成代理类的构造函数
相信读者依然清晰记得代理类是通过其构造函数反射生成的，而构造时传入的唯一参数就是调用处理器对象。为了保持与原代理机制的一致性，新的代理类的构造函数也同样只有一个调用处理器对象作为参数。模板简单如下
清单 6. 构造函数模板
需要特别提一下的是 super 方法的参数值列表 &Parameters 的生成，我们借鉴了 Mock 思想，侧重于追求对象构造的成功，而并未过多地努力分析并寻求最准确最有意义的赋值。对此，相信读者会多少产生一些疑虑，但稍后我们会提及改进的方法，请先继续阅读。
生成整个代理类
通过以上步骤，构造函数和所有需被代理的方法的代码已经生成，接下来就是生成整个代理类的时候了。这个过程也很直观，通过获取相关信息并对类模板中各个标签位进行替换，便可以轻松的完成整个代理类的代码生成。
被遗忘的角落：类变量
等等，似乎遗忘了什么？从调用者的角度出发，我们希望代理类能够作为被代理类的如实代表呈现在用户面前，包括其内部状态，而这些状态通常是由类变量所体现出来的，于是就涉及到类变量的代理问题。
要解决这个问题，首先需要思考何时两者的类变量可能出现不一致？回答了这个问题，也就找到了解决思路。回顾代理类的构造函数，我们以粗糙的方式构造了代理类实例。它们可能一开始就已经不一致了。还有每次方法调用也可能导致被两者的类变量的不一致。如何解决？直观的想法是：1）构造时需设法进行同步；2）方法调用之前和之后也需设法进行同步。这样，我们就能够有效避免代理类和被代理类的类变量不一致的问题的出现了。
但是，如何获得被代理类的实例呢？从当前的的设计中已经没有办法做到。既然如此，那就继续我们的扩展之旅。只不过这次扩展的对象是调用处理器接口，我们将在扩展后的接口里加入获取被代理类对象的方法，且扩展调用处理器接口将以 static 和 public 的形式被定义在 ProxyEx 类中。
清单 7. ProxyEx 类内的静态接口 InvocationHandlerEx
新的调用处理器接口具备了获取被代理类对象的能力，从而为实现类变量的同步打开了通道。接下来还需要的就是执行类变量同步的 sync 方法，每个动态生成的代理类中都会被悄悄地加入这个私有方法以供调用。每次方法被分派转发到调用处理器执行之前和之后，sync 方法都会被调用，从而保证类变量的双向实时更新。相应的，方法模板也需要更新以支持该新特性。
清单 8. 更新后的方法模板（部分）
sync 方法还会在构造函数尾部被调用，从而将被代理类对象的变量信息同步到代理类对象，实现类似于拷贝构造的等价效果。相应的，构造函数模板也需要更新以支持该新特性。
清单 9. 更新后的构造函数模板
接下来介绍 sync 方法的实现，其思想就是首先获取被代理类的所有 Field 对象的列表，并通过扩展的调用处理器获得方法的声明类说对应的 stub 对象，然后遍历 Field 对象列表并对各个变量进行拷贝同步。
清单 10. 声明在动态生成的代理类内部的 snyc 函数
这里涉及到一个用于获取类的所有 Field 对象列表的静态辅助方法 getFields。为了提高频繁查询时的性能，配合该静态方法的是一个静态的 fieldsMap 对象，用于记录已查询过的类其所包含的 Field 对象列表，使得再次查询时能迅速返回其对应列表。相应的，类模板也需进行更新。
清单 11. 增加了静态 fieldsMap 变量后的类模板
清单 12. 声明在动态生成的代理类内部的静态方法 getFields
动态编译及装载
代码生成以后，需要经过编译生成 JVM 所能识别的字节码，而字节码还需要通过类装载器载入 JVM 才能最终被真正使用，接下来我们将阐述如何动态编译及装载。
首先是动态编译。这部分由 ProxyEx 类的 getProxyClassCodeSource 函数完成。该函数分三步进行：第一步保存源代码到 .java 文件；第二步编译该 .java 文件；第三步从输出的 .class 文件读取字节码。
清单 13. ProxyEx 的静态方法 getProxyClassCodeSource
得到代理类的字节码，接下来就可以动态装载该类了。这部分由 ProxyEx 类的 defineClassHelper 函数完成。该函数分两步进行：第一步通过反射获取父类 Proxy 的静态私有方法 defineClass0；第二步传入字节码数组及其他相关信息并反射调用该方法以完成类的动态装载。
清单 14. ProxyEx 的静态方法 defineClassHelper
性能改进
原动态代理机制中对接口数组有一些有趣的特点，其中之一就是接口的顺序差异会在一定程度上导致生成新的代理类，即使其实并无必要。其中的原因就是因为缓存表是以接口名称列表作为关键字，所以不同的顺序就意味着不同的关键字，如果对应的关键字不存在，就会生成新但是作用重复的代理类。在 ProxyEx 类中，我们通过主动排序避免了类似的问题，提高动态生成代理类的效率。而且，如果发现数组中都是接口类型，则直接调用父类 Proxy 的静态方法 getProxyClass 生成代理类，否则才通过扩展动态代理机制生成代理类，这样也一定程度上改进了性能。
兼容性问题
接下来需要考虑的是与原代理机制的兼容性问题。曾记否，Proxy 中还有两个静态方法：isProxyClass 和getInvocationHandler，分别被用于判断 Class 对象是否是动态代理类和从 Object 对象获取对应的调用处理器（如果可能的话）。
清单 15. Proxy 的静态方法 isProxyClass 和 getInvocationHandler
现在的兼容性问题，主要涉及到 ProxyEx 类与父类 Proxy 在关于动态生成的代理类的信息方面所面临的如何保持同步的问题。曾介绍过，在 Proxy 类中有个私有的 Map 对象 proxyClasses 专门负责保存所有动态生成的代理类类型。Proxy 类的静态函数 isProxyClass 就是通过查询该表以确定某 Class 对象是否为动态代理类，我们需要做的就是把由 ProxyEx 生成的代理类类型也保存入该表。这部分工作由 ProxyEx 类的静态方法 addProxyClass 辅助完成。
清单 16. ProxyEx 的静态方法 addProxyClass
相对而言，原来 Proxy 类的静态方法 getInvocationHandler 实现相当简单，先判断是否为代理类，若是则直接类型转换到 Proxy 并返回其调用处理器成员，而扩展后的代理类并不非从 Proxy 类继承，所以在获取调用处理器对象的方法上需要一些调整。这部分由 ProxyEx 类的同名静态方法getInvocationHandler 完成。
清单 17. ProxyEx 的静态方法 getInvocationHandler
坦言：也有局限
受限于 Java 的类继承机制，扩展的动态代理机制也有其局限，它不能支持：
1.声明为 final 的类；
2.声明为 final 的函数；
3.构造函数均为 private 类型的类；
实例演示
阐述了这么多，相信读者一定很想看一下扩展动态代理机制是如何工作的。本文最后将以 2010 世博门票售票代理为模型进行演示。
首先，我们定义了一个售票员抽象类 TicketSeller。
清单 18. TicketSeller
动态代理 简单介绍 代理可分为静态代理和动态代理。静态代理在源代码级实现，而动态代理在运行时实现。 代理的几个概念： 抽象角色：声明真实对象和代理对象的共同接口。（就是接口） 代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。（就是实现上述接口的代理，即代理对象）真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。（就是要代理的真正对象，即被代理对象，或称目标对象） 在使用JDK中的动态代理时，要注意目标对象必须实现接口。动态代理的几个概念： 动态代理类：实现了一系列的接口，而这些接口是在动态代理类被创建时指定的。 代理接口：就是由动态代理类所实现的接口。 代理实例：就是动态代理类的实例。 动态代理类和其实例可以由https://www.doczj.com/doc/884835308.html,ng.reflect.Proxy来创建。如要创造接口Foo的代理： InvocationHandler handler = new MyInvocationHandler(...); //创建动态代理类 Class proxyClass = Proxy.getProxyClass( Foo.class.getClassLoader(), new Class[] { Foo.class }); //创建动态代理类的实例 Foo f = (Foo) proxyClass. getConstructor(new Class[] { InvocationHandler.class }). newInstance(new Object[] { handler }); 或者使用（更简单，一步完成创建动态代理类的实现）： Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class[] { Foo.class }, handler); 实例演示 DynamicProxy.java
Java程序员必须了解的20个lib库 一般一个经验丰富的开发者，一般都喜欢使用开源的第三方api库来进行开发，毕竟这样能够提高开发效率，并且能够简单快速的集成到项目中去，而不用花更多的时间去在重复造一些无用的轮子，多了解一些第三方库可以提高我们的开发效率，下面就来看一下在开发过程中经常会用到的一些开发第三方库，也可能不是太全，就列举一些常见或者常用的吧。 1，日志库 日志库是最常用的，毕竟在开发项目的过程中都需要使用日志来记录项目的运行信息，从而很快的定位项目的发生的问题。尽管JDK附带了自己的日志库，但是还有更好的选择，例如Log4j、SLF4j和LogBack。一般建议使用SLF4j。比如Alibaba开发手册上也是这样说的，毕竟SLF4J使您的代码独立于任何特定的日志API，就是在项目的其它框架中使用了其它的日志框架库也能够很好的集成。 2，JSON转换库 在当今的web服务、手机api接口开发和物联网世界中，JSON已经成为将信息从客户端传送到服务器的首选协议。它们前端要学好必须每天坚持学习。为了方便大家的交流学习，也是创建了一个群每天都有分享学习方法和专业老师直播
前端课程，这个扣裙首先是132 中间是667 最后是127 前端学习零基础想要学习的同学欢迎加入，如果只是凑热闹就不要来了!!!已经取代了XML，成为以独立于平台的方式传输信息的首选方式。不幸的是，JDK没有JSON库。但是，有许多优秀的第三方库允许您解析和创建JSON消息，比如Jackson和Gson，FastJson。 3，单元测试库库 单元测试是区分普通开发人员和优秀开发人员的最重要的东西。程序员经常被给予不写单元测试的借口，但是最常见的避免单元测试的借口是缺乏流行的单元测试库的经验和知识，包括JUnit、Mockito和PowerMock。 4，通用类库 Java开发人员可以使用一些优秀的通用第三方库，比如Apache Commons和谷歌Guava。我总是在我的项目中包含这些库，因为它们简化了许多任务。正如约书亚?布洛赫(Joshua Bloch)在《Effective Java》一书中正确指出的那样，重新发明轮子是没有意义的。我们应该使用经过测试的库，而不是时不时地编写我们自己的程序。对于开发人员来说，熟悉Apache Commons和谷歌Guava 是很有用的。 5，HTTP库
java开发常用jar包 mail.jar与activation.jar 里面包含了activation.jar和mail.jar两个包.通过里面的类的调用便可以达到发送电子邮件的目的 commons-beanutils.jar Apache Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。 commons-collections.jar Apache Commons包中的一个,包含了一些Apache开发的集合类，功能比java.util.*强大 commons-lang.jar Apache Commons包中的一个，包含了一些数据类型工具类，是https://www.doczj.com/doc/884835308.html,ng.*的扩展。必须使用的jar包。 commons-logging.jar: Apache Commons包中的一个,包含日志功能 commons-io.jar Apache Commons包中的一个,java.io.*的扩展,输入输出,支持文件上传 commons-fileupload.jar Apache Commons包中的一个,是一个通过Http接收上传的文件并处理结果文件的库 dom4j-1.4.jar 和jaxen-1.1.1.jar 是一个Java的XML API，类似于jdom，用来读写XML文件的。Hibernate使用dom4j解析XML配置文件和XML映射元文件。必需的。 ehcache-1.2.jar
Hibernate可以使用不同cache缓存工具作为二级缓存。EHCache是缺省的cache缓存工具。如果没有其它的可选缓存工具，则为必需的。 hibernate3.jar hibernate3的核心类库。 itext.jar 是用于生成PDF文档的一个java类库。通过iText不仅可以生成PDF或rtf的文档，而且可以将XML、Html文件转化为PDF文件。 iTextAsian.jar itext中关于亚洲编码的类库，在这里用于中文字体的输入。 junit.jar Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。 commons-digester.jar Apache Commons包中的一个,通过它可以很方便的解析xml文件生成java对象aspectjrt.jar 和aspectjweaver.jar Annotation 方式实现AOP commons-dbcp.jar commons-pool-1.2.jar DBCP数据库连接池 cglib-nodep-2.1_3.jar CGLIB是一个强大的高质量高性能的代码生成库,在运行时可以用它来扩展Java类 jfreechart-1.0.12.jar
ava最新常见面试题+ 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示： 可能对于初学者不需要后面的框架和JVM 模块的知识，读者朋友们可根据自己的情况，选择对应的模块进行阅读。 适宜阅读人群 需要面试的初/中/高级java 程序员 想要查漏补缺的人 想要不断完善和扩充自己java 技术栈的人 java 面试官 具体面试题 下面一起来看208 道面试题，具体的内容。 一、Java 基础 1.JDK 和JRE 有什么区别？ 2.== 和equals 的区别是什么？ 3.两个对象的hashCode()相同，则equals()也一定为true，对吗？ 4.final 在java 中有什么作用？ 5.java 中的Math.round(-1.5) 等于多少？ 6.String 属于基础的数据类型吗？ 7.java 中操作字符串都有哪些类？它们之间有什么区别？ 8.String str="i"与String str=new String(“i”)一样吗？ 9.如何将字符串反转？ 10.String 类的常用方法都有那些？ 11.抽象类必须要有抽象方法吗？ 12.普通类和抽象类有哪些区别？ 13.抽象类能使用final 修饰吗？
14.接口和抽象类有什么区别？ 15.java 中IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21.HashMap 和Hashtable 有什么区别？ 22.如何决定使用HashMap 还是TreeMap？ 23.说一下HashMap 的实现原理？ 24.说一下HashSet 的实现原理？ 25.ArrayList 和LinkedList 的区别是什么？ 26.如何实现数组和List 之间的转换？ 27.ArrayList 和Vector 的区别是什么？ 28.Array 和ArrayList 有何区别？ 29.在Queue 中poll()和remove()有什么区别？ 30.哪些集合类是线程安全的？ 31.迭代器Iterator 是什么？ 32.Iterator 怎么使用？有什么特点？ 33.Iterator 和ListIterator 有什么区别？ 34.怎么确保一个集合不能被修改？
JA V A的反射机制与动态代理 李海峰（QQ:61673110）-Andrew830314@https://www.doczj.com/doc/884835308.html, 运行时类型信息（RunTime Type Information，RTTI）使得你在程序运行时发现和使用类型信息。RTTI主要用来运行时获取向上转型之后的对象到底是什么具体的类型。 1.Class对象： JAVA使用Class对象来执行RTTI。每个类都有一个Class对象，它用来创建这个类的所有对象，反过来说，每个类的所有对象都会关联同一个Class对象（对于数组来说，维数、类型一致的数组的Class对象才是相同的），每个对象的创建都依赖于Class对象的是否创建，Class对象的创建发生在类加载（https://www.doczj.com/doc/884835308.html,ng.ClassLoader）的时候。 https://www.doczj.com/doc/884835308.html,ng.Class类实现了Serializable、GenericDeclaration、Type、AnnotatedElement四个接口，分别实现了可序列化、泛型定义、类型、元数据（注解）的功能。 你可以把Class对象理解为一个类在内存中的接口代理（它代理了这个类的类型信息、方法签名、属性），JVM加载一个类的时候首先创建Class对象，然后创建这个类的每个实例的时候都使用这个Class对象。 Class只有一个私有的无参构造方法，也就是说Class的对象创建只有JVM可以完成。 如何验证同一个类的多个对象的Class对象是一个呢？ Cf1 cf1 = new Cf1(); Class clazz = Cf1.class; System.out.println(cf1.getClass() == clazz); 我们知道==用来比较引用是否相等（也就是同一个引用），上面的输出语句结果是true。那么Class对象是否相等是JAVA对象中唯一可以使用==判断的。 如何获取Class对象： 1.所有的引用数据类型（类-类型）的类名、基本数据类型都可以通过.class方式获取其Class 对象（对于基本数据类型的封装类还可以通过.TYPE的方式获取其Class对象，但要注意.TYPE实际上获取的封装类对应的基本类型的Class对象的引用，那么你可以判断出int.class==Integer.TYPE返回true，int.class==Integer.class返回false！），通过这种方式不会初始化静态域，使用.class、.TYPE的方式获取Class对象叫做类的字面常量； 2.Class的forName(String name)传入一个类的完整类路径也可以获得Class对象，但由于使用的是字符串，必须强制转换才可以获取泛型的Class
教学内容 第七讲Java常用类库介绍 7.1 Java类库的结构 类库就是Java API(Application Programming Interface，应用程序接口)，是系统提供的已实现的标准类的集合。在程序设计中，合理和充分利用类库提供的类和接口，不仅可以完成字符串处理、绘图、网络应用、数学计算等多方面的工作，而且可以大大提高编程效率，使程序简练、易懂。 Java类库中的类和接口大多封装在特定的包里，每个包具有自己的功能。表7．1列出了Java中一些常用的包及其简要的功能。其中，包名后面带“. *”的表示其中包括一些相关的包。有关类的介绍和使用方法，Java中提供了极其完善的技术文档。我们只需了解技术文档的格式就能方便地查阅文档。 表7．1Java提供的部分常用包 注：在使用Java时，除了https://www.doczj.com/doc/884835308.html,ng外，其他的包都需要import语句引入之后才能使用。 7.2 https://www.doczj.com/doc/884835308.html,ng包中的常用类
https://www.doczj.com/doc/884835308.html,ng是Java语言最广泛使用的包。它所包括的类是其他包的基础，由系统自动引入，程序中不必用import语句就可以使用其中的任何一个类。https://www.doczj.com/doc/884835308.html,ng中所包含的类和接口对所有实际的Java程序都是必要的。下面我们将分别介绍几个常用的类。 7.2.1 String类和StringBuffer类 许多语言中，字符串是语言固有的基本数据类型。但在Java语言中字符串通过String类和StringBuffer类来处理。 1．String类 Java语言中的字符串属于String类。虽然有其它方法表示字符串（如字符数组），但Java使用String 类作为字符串的标准格式。Java编译器把字符串转换成String对象。String对象一旦被创建了，就不能被改变。如果需要进行大量的字符串操作，应该使用StringBuffer类或者字符数组，最终结果可以被转换成String格式。 （1）创建字符串 创建字符串的方法有多种方式，通常我们用String类的构造器来建立字符串。表6．2列出了String 类的构造器及其简要说明。 表7．2 String类构造器概要 【例7．1】使用多种方法创建一个字符串并输出字符串内容。 public class StrOutput { public static void main(Sring[] args) { //将字符串常量作为String对象对待，实际上是将一个String对象赋值给另一个 String s1 = "Hello,java!"; //声明一个字符串，然后为其赋值 String s2; s2 = "Hello,java!";
泛型(Generic) —泛形的作用 JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。 注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。 泛形的基本术语，以ArrayList
Java.long 和Java.util 常用类 1.Enum 2.包装类 3.Math 4.String 5.StringBuffer 6.日期时间类 7.Random类
Enum（https://www.doczj.com/doc/884835308.html,ng.Enum的子类） 枚举的定义语法： [Modifier] enum enumName{ EnumContantName1[,EnumContantName1...[;]] //[field,method] } 》Modifier 是访问修饰符，如public等 》enum是关键字 》EnumContantName1 , EnumContantName1...表示枚举常量列表，枚举常量之间以逗号隔开》//[field,method]表示其他成员，包括构造方法，至于枚举常量的后面 》在枚举中，如果除了定义枚举常量，还定义其他成员，则枚举常量类表必须以分号（；）结尾
enum好处 》枚举使代码更易于维护，有助于确保为变量指定合法的，期望的值 》枚举更易于输入，使用枚举赋值，只需要输入枚举名（.）,加点 》枚举使代码更清晰，允许描述性的名称表示数据，使用时直观方便 包装类 // 基本数据类型-转换-包装类 public void jiben() { String bian = "11"; Integer integer = new Integer(bian);// 初始化 Integer integer1 = Integer.valueOf(11);// 赋值 Integer integer2 = Integer.parseInt("1998");// String-int String str = integer2.toString();// int-String Integer integer3 = Integer.valueOf(bian, 2); /* * valueOf(bian, 2)方法不是把第几位转化为int类型！！这个int参数是你的这个字符串是什么基数！！2 就是二进制10 就是十进制返回值是 * 以这个基数的十进制整数例如(Integer.parseInt("11",2))返回时3 不是11这是把11解析为二进制 */ System.out.println("基本数据类型转换为包装类：" + integer3); }
————————————————————————————— 动态代理原理简析 一、概述 1.动态编译https://www.doczj.com/doc/884835308.html,pilationTask 动态编译想理解自己查API文档 2.反射被代理类主要使用Method.invoke(Object o,Object... args);对带有指定参数的指定对象调用由此Method 对象表示的底层方法。 3.类的加载URLClassLoader可以加载硬盘任意位置的.java文件。class.getClassLoader只能加载classPath目录下的类。 动态代理可以理解为动态生成发射代理的类。这其中可以动态增加逻辑操作。比如日志的打印，事物的处理等。spring的AOP操作也是动态代理的。 二、创建业务接口 假设我们有一个接口GrowAble可成长的。 1.package https://www.doczj.com/doc/884835308.html,; 2. 3.public interface GrowAble { 4. void growUp(); 5.} 一棵小树苗实现了这个接口 1.package https://www.doczj.com/doc/884835308.html,; 2.public class Tree implements GrowAble { 3. @Override 4. public void growUp() { 5. System.out.println('I am a tree , I'm grow up!'); 6. } 7. 8.} 这时我们想不在不改变源码的情况下想知道树长了多少这个操作？ 我们需要一个转换接口。
————————————————————————————— 1.package https://www.doczj.com/doc/884835308.html,; 2.import https://www.doczj.com/doc/884835308.html,ng.reflect.Method; 3. 4.public interface InvactionHandle { 5. void invoke(Object o,Method m); 6.} 一个实现接口类。 01.package https://www.doczj.com/doc/884835308.html,; 02.import https://www.doczj.com/doc/884835308.html,ng.reflect.Method; 03.import java.util.Random; 04. 05.public class HeightInvactionHandle implements InvactionHandle { 06. @Override 07. public void invoke(Object c, Method m) { 08. try { 09. m.invoke(this.o); 10. System.out.println('这棵树长了' + new Random().nextInt(9527)+'米！！！' ); 11. } catch (Exception e) { 12. e.printStackTrace(); 13. } 14. } 15. private Object o; 16. public HeightInvactionHandle(Object o) { 17. super(); 18. this.o = o; 19. } 20.} 三、其他重要类 现在最重要的Proxy类了。把上述两个接口接口起来。 01.package https://www.doczj.com/doc/884835308.html,;
Java常用方法大全 2009-08-22 20:59:03 来源：网络评论：0点击：1087 字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同前缀 startsWith(String s) 后缀 endsWith(String s) 3、比较两个字符串equals(String s) 4、把字符串转化为相应的数值 int型 字符串 1、获取字符串的长度 length() 2 、判断字符串的前缀或后缀与已知字符串是否相同 前缀 startsWith(String s) 后缀 endsWith(String s) 3、比较两个字符串 equals(String s) 4、把字符串转化为相应的数值 int型 Integer.parseInt(字符串) long型 Long.parseLong(字符串) float型 Folat.valueOf(字符串).floatValue() double型 Double.valueOf(字符串).doubleValue() 4、将数值转化为字符串 valueOf(数值) 5、字符串检索 indexOf(Srting s) 从头开始检索 indexOf(String s ,int startpoint) 从startpoint处开始检索 如果没有检索到，将返回-1 6、得到字符串的子字符串 substring(int startpoint) 从startpoint处开始获取 substring(int start,int end) 从start到end中间的字符 7、替换字符串中的字符,去掉字符串前后空格 replace(char old,char new) 用new替换old trim() 8、分析字符串 StringTokenizer(String s) 构造一个分析器，使用默认分隔字符（空格，换行，回车，Tab，进纸符） StringTokenizer(String s,String delim) delim是自己定义的分隔符 nextToken() 逐个获取字符串中的语言符号 boolean hasMoreTokens() 只要字符串还有语言符号将返回true，否则返回false countTokens() 得到一共有多少个语言符号
一.相关类及其方法: https://www.doczj.com/doc/884835308.html,ng.reflect.Proxy, Proxy 提供用于创建动态代理类和实例的静态方法. newProxyInstance() 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序 (详见api文档) https://www.doczj.com/doc/884835308.html,ng.reflect.InvocationHandler, InvocationHandler 是代理实例的调用处理程序实现的接口。 invoke() 在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。 (详见api文档) 二.源代码: 被代理对象的接口及实现类: package com.ml.test; public interface Manager { public void modify(); } package com.ml.test; public class ManagerImpl implements Manager { @Override public void modify() {
System.out.println("*******modify()方法被调用"); } } 业务代理类: package com.ml.test; import https://www.doczj.com/doc/884835308.html,ng.reflect.InvocationHandler; import https://www.doczj.com/doc/884835308.html,ng.reflect.Method; public class BusinessHandler implements InvocationHandler { private Object object = null; public BusinessHandler(Object object) { this.object = object; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("do something before method"); Object ret = method.invoke(this.object, args); System.out.println("do something after method"); return ret; } }
前言，在Java运行时刻，能否知道一个类的属性方法并调用改动之？对于任意一个对象，能否知道他的所属类，并调用他的方法？答案是肯定的。这种动态的获取信息及动态调用方法的机制在Java中称为“反射”（reflection）。 Java反射机制主要提供以下功能： 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判断任意一个类所具有的成员变量和方法； 在运行时调用任意一个对象的方法。 Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Serializable），也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。 一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。 在JDK中，主要由以下类来实现Java反射机制，这些类都位于 https://www.doczj.com/doc/884835308.html,ng.reflect包中： Class类：代表一个类； Field 类：代表类的成员变量（成员变量也称为类的属性）； Method类：代表类的方法； Constructor 类：代表类的构造方法； Array类：提供了动态创建数组，以及访问数组的元素的静态方法； 例程DateMethodsTest类演示了Reflection API的基本作用，它读取命令行参数指定的类名，然后打印这个类所具有的方法信息，代码如下： Java代码 1.public class DateMethodsTest 2.{ 3. public static void main(String args[]) throws Exception 4. { 5. // 加载并初始化命令行参数指定的类 6. Class classType = Class.forName("java.util.Date"); 7. // 获得类的所有方法 8. Method methods[] = classType.getDeclaredMethods(); 9. for (int i = 0; i < methods.length; i++) 10. { 11. System.out.println(methods[i].toString());
Java 基础常见英语词汇( 共 70 个) OO: object-oriented , 面向对象 OOP: object-oriented programming, 面向对象编程 JDK:Java development kit, java 开发工具包 JVM:java virtual machine ,java虚拟机 Compile: 编绎 Run:运行 Class:类 Object: 对象 System:系统 out:输出 print: 打印 line:行 variable:变量 type:类型 operation:操作 ,运算 array:数组 parameter:参数 method:方法 function: 函数 member-variable: 成员变量 member-function: 成员函数 get:得到 set:设置 public: 公有的 private: 私有的 protected:受保护的 default: 默认 access:访问 package:包 import: 导入 static:静态的 void: 无 (返回类型 ) extends:继承 parent class:父类 base class:基类 super class:超类 child class: 子类
derived class:派生类 override: 重写 ,覆盖 overload: 重载 final: 最终的 ,不能改变的 abstract:抽象 interface: 接口 implements: 实现 exception: 异常 Runtime: 运行时 ArithmeticException: 算术异常ArrayIndexOutOfBoundsException:数组下标越界异常NullPointerException: 空引用异常 ClassNotFoundException: 类没有发现异常NumberFormatException: 数字格式异常(字符串不能转化为数字) Catch:捕捉 Finally: 最后 Throw: 抛出 Throws: ( 投掷 )表示强制异常处理 Throwable:( 可抛出的 )表示所有异常类的祖先类 Lang:language,语言 Util: 工具 Display: 显示 Random:随机 Collection: 集合 ArrayList:( 数组列表 )表示动态数组 HashMap: 散列表 ,哈希表 Swing: 轻巧的 Awt:abstract window toolkit:抽象窗口工具包 Frame:窗体 Size:尺寸 Title: 标题 Add: 添加 Panel:面板 Layout: 布局 Scroll: 滚动 Vertical: 垂直 Horizonatal: 水平 Label: 标签 TextField: 文本框 TextArea: 文本域 Button: 按钮
Java常用包及其类总结 java.* https://www.doczj.com/doc/884835308.html,ng包，最基础的包、核心类库。常用类有String、Math、Thread、Object、包装类Integer、Character等，常用接口有Runnable、Iterable、Comparable。 2.java.util包，实用工具包。常用类有Arrays、Scanner、Random、HashSet、HashMap、ArrayList、Date等，常用接口有Collection、Set、List等。 3.java.io包，提供数据输入输出。常用类有File、FileInputStream、Reader等提供文件、字节输入输出的类。 https://www.doczj.com/doc/884835308.html,包，为网络连接提供服务。常用类有Socket、ServerSocket、URL等。 5.java.sql包，连接数据库的包。要实现jdbc类库。 6.java.awt、(javax.awt)包，创建用户界面、绘图的。常用类有Button、Panel、（JButton、JPanel）等。 javax.* javax.accessibliity定义UI组件访问的技术规范 java.crypto 包含与加密相关的类和接口 javax.imageio为图形的I/O处理提供支持 javax.management提供与JMX(Java Managment Extensions)相关的类 javax.naming 包含与访问名字服务器相关的类和接口 https://www.doczj.com/doc/884835308.html, 包含网络应用需要的类 javax.print 包含打印所需要的类和接口 javax.rmi 包含RMI_IIOP服务的类和接口 javax.security.auth提供了一个认证和授权框架 javax.security.cert包含支持公钥证书的相关类 javax.security.sasl包含与支持SASL(Simple Authentication and Security Layer)相关的类和接口javax.sound.midi包含与MIDI数据操作相关的类和接口 javax.sound.sampled包含与抓取、加工、回放音频数据相关的类和接口 javax.sql 包含与服务器端访问和数据源处理相关的API javax.transaction包含事务管理器和资源管理器的规则 javax.xml 包含XML规范描述的常亮和要求
动态代理实现Authorization（授权） * https://www.doczj.com/doc/884835308.html,ng.reflect包中的 Proxy和InvocationHandler接口提供了创建（指定类[接口更准确些]的）动态代理类的能力。 我们知道，对象是类的实例，一般使用内存来模拟对象，对象是依据类为模板来创建的，创建时使用new来分配一块内存区（其布局 参考相应类的内存布局），为变量做一些赋值便是对象的初始化了。我们知道通常类是设计时的产物，在设计时我们编写对象的模板（即——类），运行时 产生类的实例。类所处的文件是 .java文件——源文件，之后编译为jvm-----java虚拟机可解释执行的.class字节码文件，在类解析 过程中这些.class文件由类加载器加载到虚拟机（可实现自己的类加载器来加载处于特定路径下的类，或加载用某种加密算法加密过的类文件---这样 便于进行安全控制——具体描述参考（Core java ——Java核心卷二））。在遇到创建对象的指令时使用加载的类来创建对象内存 空间。动态代理是不用创建类文件（当然也不用创建java源文件），就能在虚拟机中构造出类文件区域来（相当于使用Proxy类来 创建一块类内存区域，该区域中的内容相当于加载某个.class文件产生的区域；比如我们在使用DOM技术时，从一个XML文件构造一个 DOM内存表示，它是XML文件的内存表示，但我们也可以直接使用DOM API在内存中构建一个dom树，最终结果就是一个内存DOM树，你不用关心 这个dom树是来自于xmL文件还是直接的运行时构造）。 * ** 关于代理设计模式，这里不再敷述。代理和被代理类（目标类）实现共同的接口。我们在调用时不需区别它是否是真正的目标对象。 代理会转发请求到目标对象的。比如互联网上的代理服务器，我们不必关心它是不是代理，就当它不存在一样。对客户调用端 他是不关心具体是谁来提供这个服务功能；在服务端选择使用代理的原因可能是：安全，日志，防火墙等。就是说代理可提供一些 非功能性功能，比如缓存功能____来加速服务的响应的速度。在面向方面技术（AOP）中这些非功能性需求被称作“方面”他们横切于功能类 的实现中，比如：某个SubServerImpl（子服务实现）中的某个服务方法： subServer.doService(){ //在日志输出中常有类似的代码出现于多个类实现中 loger.log("
jar包用途 axis.jar SOAP引擎包 commons-discovery-0.2.jar 用来发现、查找和实现可插入式接口，提供一些一般类实例化、单件的生命周期管理的常用方法. jaxrpc.jar Axis运行所需要的组件包saaj.jar 创建到端点的点到点连接的方法、创建并处理SOAP消息和附件的方法，以及接收和处理SOAP错误的方法. wsdl4j-1.5.1.jar Axis运行所需要的组件包 activation.jar JAF框架的jar包 annotations-api.jar 使用注解所需jar ant.jar 用于自动化调用程序完成项目的编译，打包，测试等 aopalliance-1.0.jar 支持Spring AOP asm-2.2.3.jar ASM字节码库 asm-commons-2.2.3.jar ASM字节码库 asm-util-2.2.3.jar Java字节码操纵和分析框架 aspectjrt.jar 处理事务和AOP所需的包 aspectjweaver.jar 处理事务和AOP所需的包 axiom-api-1.2.7.jar Axis 对象模型 axiom-impl-1.2.7.jar Axis 对象模型 bcprov-jdk15-140.jar 基于java1.5 的加密算法实现 bfmclientmodel.jar 使用WebSphere所需jar包 bpcclientcore.jar 使用WebSphere所需jar包 bpe137650.jar 提供远程访问BPE容器的实现。 bsh-2.0b4.jar 解决负载逻辑运算 c3p0-0.9.0.jar 开放源代码的JDBC连接池 cglib-nodep-2.1_3.jar Spring中自动代理所需jar包 cobertura.jar 测量测试覆盖率 commons-beanutils-1.7.0.jar 动态的获取/设值Java Bean的属性 commons-chain-1.1.jar 实现责任链设计模式的Java 类库 commons-codec-1.3.jar 用来处理常用的编码方法的工具类包，例如DES、SHA1、MD5、Base64等等 commons-collections-3.1.jar 对标准java Collection的扩展 commons-collections.jar 对标准java Collection的扩展 commons-digester-1.8.jar 用于处理struts-config.xml配置文件 commons-fileupload-1.1.1.jar struts上传文件 commons-httpclient-3.1.jar 用来简化HTTP客户端与服务器端进行各种通信编程实现commons-io-1.1.jar 针对java.io.InputStream和Reader进行了扩展 commons-lang-2.4.jar 对https://www.doczj.com/doc/884835308.html,ng.*的扩展 commons-logging-1.1.1.jar 日志包 commons-pool-1.3.jar 实现对象池化框架 commons-validator-1.3.1.jar 用来把验证规则程序提取出来，以供重复使用 db2jcc.jar java连接DB2所需jar db2jcc_license_cu.jar java连接DB2所需jar dom4j-1.6.1.jar 解析XML ehcache-1.2.4.jar hibernate的二级缓存如果用ehcache的时候需要此jar包