在jdk开发包实现AOP

 

相信大家都对spring 很所了解  ，spring ioc 和aop 也是它的重要的，也是它的基础

现在聊一下在没有spring AOP中在只有jdk自带的开发包怎么实现

下面就是实现的代码：

 

/**//**
 * 
 */
package SpringAop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//import java.util.logging.Logger;
//import java.util.logging.Level;
import java.lang.reflect.Proxy;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;

/**//**
 * @author Administrator
 * @date or time 2007-1-5 23:08:30
 * @project AppTest
 */

//首先创建一个接口--在面向对象语言提倡面向接口
interface  IToApplyForJob
...{
    public void sayForward(String corporation);
    
    
}
class ToApplyForJobImpl implements IToApplyForJob//实现接口的类
...{

    public void sayForward(String corporation) ...{
        // TODO 呵呵。
        System.out.println("没有别的意思，现在还没有工作，我向"+corporation+"就职应聘");
    }
    }
 //自定义调用处理类必须实现InvocationHandler，InvocationHandler 是代理实例的调用处理程序 实现的接口
class ForJobHandler implements InvocationHandler
...{   Object delegate;
    public ForJobHandler(Object delegate)
    ...{
        this.delegate=delegate;
        
        
    }
    Logger logger=Logger.getLogger(this.getClass().getName());//跟log4j一样要得到类名
    public Object invoke(Object proxy, Method method, Object... args) throws Throwable ...{
        // TODO 这里就是在spring中AOP中的aroundAdvice  
       logger.log(Level.INFO,"大学生活快结束了"); 
        System.out.println("大学生活快结束了");
       
        Object target=method.invoke(delegate,args);//这个就是用来调用要调用的方法
        System.out.println("本人还是很喜欢java");
        logger.log(Level.INFO,"本人还是很喜欢java");
        return target;
    }
     
}
public class AOPTest ...{
    public static void main(String[] args) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
    ...{
            //创建一个目标对象
      IToApplyForJob job=new ToApplyForJobImpl();
        //构造一个handle
      ForJobHandler handle=new ForJobHandler(job);
      //方法一
      //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序
      //IToApplyForJob target=(IToApplyForJob) Proxy.newProxyInstance(job.getClass().getClassLoader(),job.getClass().getInterfaces(),handle);
      //方法二
      //构造IToApplyForJob的代理类
      Class proxyClass = Proxy.getProxyClass(
             IToApplyForJob.class.getClassLoader(), new Class[] ...{ IToApplyForJob.class });
      IToApplyForJob target=(IToApplyForJob)proxyClass.getConstructor(new Class[] ...{ InvocationHandler.class }).newInstance(new Object[] ...{ handle });
      
      target.sayForward("全国企业");
    }
    }

 

这个把日志切入到业务方法的之前和之后就像 SpringAOP 中的AroundAdvice 

结果就是

 

14:07:16,468  INFO ForJobHandler:48 - 大学生活快结束了
大学生活快结束了
没有别的意思，现在还没有工作，我向全国企业就职应聘
本人还是很喜欢java
14:07:16,468  INFO ForJobHandler:53 - 本人还是很喜欢java

 

在jdk帮助文档中这样解释的
 

public class Proxy extends Objectimplements SerializableProxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。 

创建某一接口 IToApplyForJob 的代理： 
这里比较重要的两个方法就是proxy.newProxyInstance和method.invoke
其中 
      Class proxyClass = Proxy.getProxyClass(
             IToApplyForJob.class.getClassLoader(), new Class[] ...{ IToApplyForJob.class });
      IToApplyForJob target=(IToApplyForJob)proxyClass.getConstructor(new Class[] ...{ InvocationHandler.class }).newInstance(new Object[] ...{ handle });
 或使用以下更简单的方法： 
     IToApplyForJob target=(IToApplyForJob) Proxy.newProxyInstance(job.getClass().getClassLoader(),job.getClass().getInterfaces(),handle);
 动态代理类（以下简称为代理类）是一个实现在创建类时在运行时指定的接口列表的类，该类具有下面描述的行为。 代理接口 是代理类实现的一个接口。 代理实例 是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序 对象，它可以实现接口 InvocationHandler。通过其中一个代理接口的代理实例上的方法调用将被指派到实例的调用处理程序的 Invoke 方法，并传递代理实例、识别调用方法的 java.lang.reflect.Method 对象以及包含参数的 Object 类型的数组。调用处理程序以适当的方式处理编码的方法调用，并且它返回的结果将作为代理实例上方法调用的结果返回。 

代理类具用以下属性： 

代理类是公共的、最终的，而不是抽象的。 
未指定代理类的非限定名称。但是，以字符串 "$Proxy" 开头的类名空间应该为代理类保留。 
代理类扩展 java.lang.reflect.Proxy。 
代理类会按同一顺序准确地实现其创建时指定的接口。 
如果代理类实现了非公共接口，那么它将在与该接口相同的包中定义。否则，代理类的包也是未指定的。注意，包密封将不阻止代理类在运行时在特定包中的成功定义，也不会阻止相同类加载器和带有特定签名的包所定义的类。 
由于代理类将实现所有在其创建时指定的接口，所以对其 Class 对象调用 getInterfaces 将返回一个包含相同接口列表的数组（按其创建时指定的顺序），对其 Class 对象调用 getMethods 将返回一个包括这些接口中所有方法的 Method 对象的数组，并且调用 getMethod 将会在代理接口中找到期望的一些方法。 
如果 Proxy.isProxyClass 方法传递代理类（由 Proxy.getProxyClass 返回的类，或由 Proxy.newProxyInstance 返回的对象的类），则该方法返回 true，否则返回 false。 
代理类的 java.security.ProtectionDomain 与由引导类加载器（如 java.lang.Object）加载的系统类相同，原因是代理类的代码由受信任的系统代码生成。此保护域通常被授予 java.security.AllPermission。 
每个代理类都有一个可以带一个参数（接口 InvocationHandler 的实现）的公共构造方法，用于设置代理实例的调用处理程序。并非必须使用反射 API 才能访问公共构造方法，通过调用 Proxy.newInstance 方法（将调用 Proxy.getProxyClass 的操作和调用带有调用处理程序的构造方法结合在一起）也可以创建代理实例。 
代理实例具有以下属性： 

提供代理实例 proxy 和一个由其代理类 Foo 实现的接口，以下表达式将返回 true： 
     proxy instanceof IToApplyForJob
 并且以下的强制转换操作将会成功（而不抛出 ClassCastException）： 
     (IToApplyForJob) proxy
 每个代理实例都有一个关联的调用处理程序，它会被传递到其构造方法中。静态 Proxy.getInvocationHandler 方法将返回与作为其参数传递的代理实例相关的调用处理程序。 
代理实例上的接口方法调用将按照该方法的文档描述进行编码，并被指派到调用处理程序的 Invoke 方法。 
在代理实例上的 java.lang.Object 中声明的 hashCode、equals 或 toString 方法的调用将按照与编码和指派接口方法调用相同的方式进行编码，并被指派到调用处理程序的 invoke 方法，如上所述。传递到 invoke 的 Method 对象的声明类是 java.lang.Object。代理类不重写从 java.lang.Object 继承的代理实例的其他公共方法，所以这些方法的调用行为与其对 java.lang.Object 实例的操作一样。

在多代理接口中重复的方法

当代理类的两个或多个接口包含一个具有相同名称和参数签名的方法时，代理类的接口顺序变得非常重要。在代理实例上调用重复方法 时，传递到调用处理程序的 Method 对象没有必要成为其声明类可以从接口（通过该接口调用代理方法）的引用类型指派的对象。此限制存在的原因是，生成的代理类中的相应方法实现无法确定它通过哪一个接口调用。因此，在代理实例上调用重复方法时，第一个接口中的方法的 Method 对象包含接口的代理类列表中的方法（直接或通过超级接口继承），该对象会传递到调用处理程序的 invoke 方法，无论该方法调用通过哪一种引用类型发生。 

如果代理接口包含某一方法，它的名称和参数签名与 java.lang.Object 的 hashCode、equals 或 toString 方法相同，那么在代理实例上调用这样的方法时，传递到调用处理程序的 Method 对象将使 java.lang.Object 成为其声明类。换句话说，java.lang.Object 公共的非最终方法理论上在所有代理接口之前，以便确定哪一个 Method 对象传递到调用处理程序。 

还要注意，当重复方法被指派到调用处理程序时，invoke 方法只可以抛出经过检查的异常类型，该异常类型可以使用所有 代理接口（可以通过它调用）中方法的 throws 子句指派一种异常类型。如果 invoke 方法抛出一个经过检查的异常，该异常没有指派给任何由一个代理接口（可以通过它调用）中的方法声明的异常类型，那么该代理实例上的调用将抛出一个未经检查的 UndeclaredThrowableException。此限制表示并非所有的由传递到 invoke 方法的 Method 对象上调用 getExceptionTypes 返回的异常类型都可以由 invoke 方法成功抛出。

 
//////////////////////////////////////////////////////////////////////////////

newProxyInstance
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于： 
     Proxy.getProxyClass(loader, interfaces).
         getConstructor(new Class[] ...{ InvocationHandler.class }).
         newInstance(new Object[] ...{ handler });
 Proxy.newProxyInstance 抛出 IllegalArgumentException，原因与 Proxy.getProxyClass 相同。

 

参数：
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序
返回：
一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口
抛出：
IllegalArgumentException - 如果违反传递到 getProxyClass 的参数上的任何限制
NullPointerException - 如果 interfaces 数组参数或其任何元素为 null，或如果调用处理程序 h 为 null

 //////////////////////////////////////////////////////////////////////////////////

 

getProxyClass
public static Class<?> getProxyClass(ClassLoader loader,
                                     Class<?>... interfaces)
                              throws IllegalArgumentException返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。该代理类将由指定的类加载器定义，并将实现提供的所有接口。如果类加载器已经定义了具有相同排列接口的代理类，那么现有的代理类将被返回；否则，类加载器将动态生成并定义这些接口的代理类。 

对可以传递给 Proxy.getProxyClass 的参数有以下几个限制：

interfaces 数组中的所有 Class 对象必须表示接口，而不能表示类或基本类型。
interfaces 数组中的两个元素不能引用同一 Class 对象。
所有接口类型的名称通过特定的类加载器必须可见。换句话说，对于类加载器 cl 和所有接口 i，以下表达式必须为 true：
     Class.forName(i.getName(), false, cl) == i
 所有非公共接口必须位于同一包中；否则，该代理类将不可能实现所有的接口，无论它在哪一个包中定义。
对于有相同签名的指定接口中任何成员方法集：
如果任何方法的返回类型是基本类型或 void，那么所有的方法必须具有与此相同的返回类型。
否则，该方法之一必须是返回类型，它可以指派给该方法其余的所有返回类型。
得到的代理类必须不超过虚拟机在类上施加的任何限制。例如，虚拟机可以限制某一类实现至多 65535 的接口数；在这种情况下，interfaces 数组的大小必须不超过 65535。
如果违反了这些限制，Proxy.getProxyClass 将抛出 IllegalArgumentException。如果 interfaces 数组参数或其任何元素为 null，则将抛出 NullPointerException。

注意，指定的代理接口的顺序非常重要：对接口组合相同但顺序不同的代理类的两个请求会导致两个不同的代理类。

参数：
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
返回：
用指定的类加载器定义的代理类，它可以实现指定的接口
抛出：
IllegalArgumentException - 如果违反传递到 getProxyClass 的参数上的任何限制
NullPointerException - 如果 interfaces 数组参数或其任何元素为 null

///////////////////////////////////////////////////////////////////////////////////

invoke
public Object invoke(Object obj,
                     Object... args)
              throws IllegalAccessException,
                     IllegalArgumentException,
                     InvocationTargetException对带有指定参数的指定对象调用由此 Method 对象表示的基础方法。个别参数被自动解包，以便与基本形参相匹配，基本参数和引用参数都随需服从方法调用转换。 
如果基础方法是静态的，那么可以忽略指定的 obj 参数。该参数可以为 null。

 

如果基础方法所需的形参数为 0，则所提供的 args 数组长度可以为 0 或 null。

如果基础方法是实例方法，则使用动态方法查找来调用它，这一点记录在 Java Language Specification, Second Edition 的第 15.12.4.4 节中；在发生基于目标对象的运行时类型的重写时更应该这样做。

如果基础方法是静态的，并且尚未初始化声明此方法的类，则会将其初始化。

如果方法正常完成，则将该方法返回的值返回给调用方；如果该值为基本类型，则首先适当地将其包装在对象中。但是，如果该值的类型为一组基本类型，则数组元素不 被包装在对象中；换句话说，将返回基本类型的数组。如果基础方法返回类型为 void，则该调用返回 null。

参数：
obj - 从中调用基础方法的对象
args - 用于方法调用的参数
返回：
使用参数 args 在 obj 上指派该对象所表示方法的结果
抛出：
IllegalAccessException - 如果此 Method 对象强制执行 Java 语言访问控制，并且基础方法是不可访问的。
IllegalArgumentException - 如果该方法是实例方法，且指定对象参数不是声明基础方法的类或接口（或其中的子类或实现程序）的实例；如果实参和形参的数量不相同；如果基本参数的解包转换失败；如果在解包后，无法通过方法调用转换将参数值转换为相应的形参类型。
InvocationTargetException - 如果基础方法抛出异常。
NullPointerException - 如果指定对象为 null，且该方法是一个实例方法。
ExceptionInInitializerError - 如果由此方法引起的初始化失败。