`

反射实现 AOP 动态代理模式(1)

阅读更多

其实AOP的意思就是面向切面编程.
OO注重的是我们解决问题的方法(封装成Method),而AOP注重的是许多解决解决问题的方法中的共同点,是对OO思想的一种补充!
还是拿人家经常举的一个例子讲解一下吧:
比如说,我们现在要开发的一个应用里面有很多的业务方法,但是,我们现在要对这个方法的执行做全面监控,或部分监控.也许我们就会在要一些方法前去加上一条日志记录,
我们写个例子看看我们最简单的解决方案
我们先写一个接口IHello.java代码如下:

 1package sinosoft.dj.aop.staticaop;
 2
 3public interface IHello {
 4    /** *//**
 5     * 假设这是一个业务方法
 6     * @param name
 7     */

 8    void sayHello(String name);
 9}

10


里面有个方法,用于输入"Hello" 加传进来的姓名;我们去写个类实现IHello接口

package sinosoft.dj.aop.staticaop;

public class Hello implements IHello {

    
public void sayHello(String name) {
        System.out.println(
"Hello " + name);
    }


}


现在我们要为这个业务方法加上日志记录的业务,我们在不改变原代码的情况下,我们会去怎么做呢?也许,你会去写一个类去实现IHello接口,并依赖Hello这个类.代码如下:

 1package sinosoft.dj.aop.staticaop;
 2
 3public class HelloProxy implements IHello {
 4    private IHello hello;
 5
 6    public HelloProxy(IHello hello) {
 7        this.hello = hello;
 8    }

 9
10    public void sayHello(String name) {
11        Logger.logging(Level.DEBUGE, "sayHello method start.");
12        hello.sayHello(name);
13        Logger.logging(Level.INFO, "sayHello method end!");
14
15    }

16
17}

18


其中.Logger类和Level枚举代码如下:
Logger.java

 1package sinosoft.dj.aop.staticaop;
 2
 3import java.util.Date;
 4
 5public class Logger{
 6    /** *//**
 7     * 根据等级记录日志
 8     * @param level
 9     * @param context
10     */

11    public static void logging(Level level, String context) {
12        if (level.equals(Level.INFO)) {
13            System.out.println(new Date().toLocaleString() + " " + context);
14        }

15        if (level.equals(Level.DEBUGE)) {
16            System.err.println(new Date() + " " + context);
17        }

18    }

19
20}

21

Level.java

1package sinosoft.dj.aop.staticaop;
2
3public enum Level {
4    INFO,DEBUGE;
5}

6

那我们去写个测试类看看,代码如下:
Test.java

1package sinosoft.dj.aop.staticaop;
2
3public class Test {
4    public static void main(String[] args) {
5        IHello hello = new HelloProxy(new Hello());
6        hello.sayHello("Doublej");
7    }

8}

9

运行以上代码我们可以得到下面结果:

Tue Mar 04 20:57:12 CST 2008 sayHello method start.
Hello Doublej
2008-3-4 20:57:12 sayHello method end!


从上面的代码我们可以看出,hello对象是被HelloProxy这个所谓的代理态所创建的.这样,如果我们以后要把日志记录的功能去掉.那我们只要把得到hello对象的代码改成以下:

1package sinosoft.dj.aop.staticaop;
2
3public class Test {
4    public static void main(String[] args) {
5        IHello hello = new Hello();
6        hello.sayHello("Doublej");
7    }

8}

9


上面代码,可以说是AOP最简单的实现!
但是我们会发现一个问题,如果我们像Hello这样的类很多,那么,我们是不是要去写很多个HelloProxy这样的类呢.没错,是的.其实也是一种很麻烦的事.在jdk1.3以后.jdk跟我们提供了一个API   java.lang.reflect.InvocationHandler的类. 这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事.让我们把以上的代码改一下来看看效果.
同样,我们写一个IHello的接口和一个Hello的实现类.在接口中.我们定义两个方法;代码如下 :

IHello.java

 1package sinosoft.dj.aop.proxyaop;
 2
 3public interface IHello {
 4    /** *//**
 5     * 业务处理A方法
 6     * @param name
 7     */

 8    void sayHello(String name);
 9    /** *//**
10     * 业务处理B方法
11     * @param name
12     */

13    void sayGoogBye(String name);
14}

15



Hello.java

 1package sinosoft.dj.aop.proxyaop;
 2
 3public class Hello implements IHello {
 4
 5    public void sayHello(String name) {
 6        System.out.println("Hello " + name);
 7    }

 8    public void sayGoogBye(String name) {
 9        System.out.println(name+" GoodBye!");
10    }

11}

12


我们一样的去写一个代理类.只不过.让这个类去实现java.lang.reflect.InvocationHandler接口,代码如下:

 1package sinosoft.dj.aop.proxyaop;
 2
 3import java.lang.reflect.InvocationHandler;
 4import java.lang.reflect.Method;
 5import java.lang.reflect.Proxy;
 6
 7public class DynaProxyHello implements InvocationHandler {
 8
 9    /** *//**
10     * 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
11     */

12    private Object delegate;
13
14    /** *//**
15     * 动态生成方法被处理过后的对象 (写法固定)
16     * 
17     * @param delegate
18     * @param proxy
19     * @return
20     */

21    public Object bind(Object delegate) {
22        this.delegate = delegate;
23        return Proxy.newProxyInstance(
24                this.delegate.getClass().getClassLoader(), this.delegate
25                        .getClass().getInterfaces(), this);
26    }

27    /** *//**
28     * 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
29     * 此方法是动态的,不是手动调用的
30     */

31    public Object invoke(Object proxy, Method method, Object[] args)
32            throws Throwable {
33        Object result = null;
34        try {
35            //执行原来的方法之前记录日志
36            Logger.logging(Level.DEBUGE, method.getName() + " Method end .");
37            
38            //JVM通过这条语句执行原来的方法(反射机制)
39            result = method.invoke(this.delegate, args);
40            //执行原来的方法之后记录日志
41            Logger.logging(Level.INFO, method.getName() + " Method Start!");
42        }
 catch (Exception e) {
43            e.printStackTrace();
44        }

45        //返回方法返回值给调用者
46        return result;
47    }

48
49}

50


上面类中出现的Logger类和Level枚举还是和上一上例子的实现是一样的.这里就不贴出代码了.

分享到:
评论

相关推荐

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    这种通过代理模式实现的AOP方法,可以很好地将业务逻辑代码与额外的横切关注点分离,使得代码更加清晰,易于维护。如果将来需要去除日志记录功能,只需要替换掉代理类的实例,而不需要修改任何业务逻辑代码。此外,...

    反射实现 AOP 动态代理模式(Spring AOP 的实现 原理) - Java 例子 -

    本文将深入探讨Spring AOP的实现原理,以及如何使用反射来实现动态代理模式。 首先,我们需要了解AOP的基本概念。AOP的核心思想是切面,它包含两个主要部分:切点(Pointcut)和通知(Advice)。切点定义了在程序...

    AOP动态代理(反射机制)

    6. **代理模式的其他实现**:除了Java的动态代理,还有其他实现方式,比如CGLIB库,它通过字节码生成技术创建代理对象,即使目标类没有实现接口也能进行代理。 学习AOP动态代理有助于我们理解面向切面编程的核心...

    AOP之JDK动态代理和CGLib动态代理

    JDK动态代理基于Java的反射API实现,适用于接口代理。当目标对象实现了至少一个接口时,Spring会创建一个代理对象,这个代理对象实现了与目标对象相同的接口,并在调用接口方法时插入额外的切面逻辑。代理对象在运行...

    springAOP之代理模式.docx

    代理模式是实现AOP的关键。代理模式的核心思想是创建一个代理类,它充当原对象的代理,控制对原对象的访问。在Spring AOP中,代理模式使得我们可以在不修改原始业务逻辑的情况下,插入额外的逻辑,比如事务管理、...

    利用C#实现AOP常见的几种方法详解

    例如,`Castle.DynamicProxy`库就是基于动态代理实现AOP的。动态代理在运行时创建代理类,可以针对接口或者抽象类,而不需要重新编译源代码。这使得代码更加灵活,但性能相比静态织入略低。 3. **特性驱动编程**: ...

    复习反射利用反射机制和AOP代理模式

    reflection是一系列的API,用于表示或者处理当前JVM中的类,接口和对象. java.lang.reflect/java.lang.Class 在运行时判断任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理。

    JAVA的反射机制与动态代理

    在实际应用中,Spring AOP(面向切面编程)就是利用动态代理技术实现的。它可以让我们编写关注点分离的代码,比如日志、事务等通用功能,而无需侵入业务逻辑。此外,动态代理也被广泛应用于RPC框架,如Dubbo、gRPC,...

    动态代理设计模式 日志和源码

    在Java中,动态代理有两种主要实现方式:一是使用Java的反射API,即`java.lang.reflect.Proxy`类;二是使用JDK动态代理。另一种常见的方式是使用CGLIB库,它是在字节码级别创建代理对象,适用于无法实现接口的目标类...

    代理模式(含动态代理讲解)【Spring AOP实质】

    在Java中,代理模式主要有两种实现方式:静态代理和动态代理。 1. 静态代理: 在静态代理中,我们需要手动创建一个代理类,这个代理类实现了与目标类相同的接口。代理类中会持有目标对象的引用,并在调用目标对象...

    springAop默认代理方式.zip

    4. **代理模式的创建**:Spring AOP 使用`org.springframework.aop.framework.ProxyFactoryBean`或`@EnableAspectJAutoProxy`注解来配置代理。`ProxyFactoryBean`是XML配置方式,而`@EnableAspectJAutoProxy`是基于...

    利用Java的反射与代理实现AOP.docx

    Spring框架广泛使用AOP来实现这些功能,而Java的反射和动态代理机制是实现AOP的基础。 首先,AOP的核心思想是将横切关注点(如日志、事务管理)从核心业务逻辑中分离出来,形成独立的模块,以提高代码的可读性和可...

    基于Java动态代理的AOP实现.zip

    实现方式通过手动编写代理类,实现代理模式。 特点在编译期就生成了代理类,代理类持有委托类的实例,代为执行具体类实例方法。 应用场景适用于简单的代理需求,代码直观易懂。 2. JDK动态代理 实现方式利用...

    使用动态代理演示Spring的AOP编程原理

    为了说明Spring的AOP原理,本人使用代理模式中的动态代理完成演示AOP编程的原理的演示。相信,如果你耐心看完整个程序(几乎一行注释一行代码),那么你对Spring这个东西就不是觉得有什么神秘了! 阅读对象:凡是喜爱...

    AOP技术及其在J2EE中动态代理实现

    在J2EE(Java 2 Platform, Enterprise Edition)环境中,AOP的动态代理实现机制是一种常用的技术手段,它利用了Java的反射机制。Java的动态代理可以分为接口型和类型两种。接口型动态代理要求目标对象实现一个接口,...

    java 动态代理模式 适配器模式

    在实际应用中,动态代理模式常用于AOP(面向切面编程)框架,例如Spring AOP,它可以方便地实现日志、事务控制等功能。而适配器模式则广泛应用于各种集成场景,比如将第三方库的API转换为项目统一的接口,或者在不同...

    Java反射机制与动态代理

    代理模式通常用于实现AOP(面向切面编程),比如日志记录、性能监控、事务管理等。当需要在调用目标方法前后添加额外操作时,动态代理就显得非常方便。通过实现`InvocationHandler`,我们可以控制代理对象的行为,当...

    JAVA 反射机制与动态代理ppt

    代理模式是一种设计模式,它在Java中可以通过两种方式实现:静态代理和动态代理。静态代理是通过编写一个代理类来实现接口,代理类在编译时就已经确定。而动态代理则是在运行时动态生成代理类,通常使用`java.lang....

    Java 代理 代理模式 静态代理与动态代理 常见的动态代理实现 .md

    为了更好地理解代理模式的工作原理,我们通过下面的例子来实现一个简单的代理模式。 **定义接口**: ```java public interface SellPerfume { void sellPerfume(double price); } ``` **定义真实对象**: ```java...

Global site tag (gtag.js) - Google Analytics