SpringAOP理解

Aspect Oriented Programming  面向切面编程。解耦是程序员编码开发过程中一直追求的。AOP也是为了解耦所诞生。

具体思想是:定义一个切面,在切面的横向定义处理方法,处理完成之后,回到纵向业务流。

AOP 在Spring框架中被作为核心组成部分之一,的确Spring将AOP发挥到很强大的功能。最常见的就是事务控制。工作之余,对于使用的工具,不免需要了解其所以然。学习了一下,写了些程序帮助理解。

AOP 主要是利用代理模式的技术来实现的。

1、静态代理:就是设计模式中的proxy模式

a、业务接口

/**
 * 抽象主题角色:声明了真实主题和代理主题的共同接口。
 *
 * @author yanbin
 *
 */
public interface ITalk {

    public void talk(String msg);

}

b、业务实现

/**
 * 真实主题角色:定义真实的对象。
 *
 * @author yanbin
 *
 */
public class PeopleTalk implements ITalk {

    public String username;
    public String age;

    public PeopleTalk(String username, String age) {
        this.username = username;
        this.age = age;
    }

    public void talk(String msg) {
        System.out.println(msg + "!你好,我是" + username + ",我年龄是" + age);
    }

    public String getName() {
        return username;
    }

    public void setName(String name) {
        this.username = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

}

c、代理对象

/**
 * 代理主题角色:内部包含对真实主题的引用,并且提供和真实主题角色相同的接口。
 *
 * @author yanbin
 *
 */
public class TalkProxy implements ITalk {

    private ITalk talker;

    public TalkProxy(ITalk talker) {
        // super();
        this.talker = talker;
    }

    public void talk(String msg) {
        talker.talk(msg);
    }

    public void talk(String msg, String singname) {
        talker.talk(msg);
        sing(singname);
    }

    private void sing(String singname) {
        System.out.println("唱歌:" + singname);
    }

}

d、测试类

/**
 * 代理测试类,使用代理
 *
 * @author yanbin
 *
 */
public class ProxyPattern {

    public static void main(String[] args) {
        // 不需要执行额外方法的。
        ITalk people = new PeopleTalk("AOP", "18");
        people.talk("No ProXY Test");
        System.out.println("-----------------------------");

        // 需要执行额外方法的(切面)
        TalkProxy talker = new TalkProxy(people);
        talker.talk("ProXY Test", "代理");
    }

}

从这段代码可以看出来,代理模式其实就是AOP的雏形。 上端代码中talk(String msg, String singname)是一个切面。在代理类中的sing(singname)方法是个后置处理方法。

这样就实现了,其他的辅助方法和业务方法的解耦。业务不需要专门去调用,而是走到talk方法,顺理成章的调用sing方法

再从这段代码看:1、要实现代理方式,必须要定义接口。2、每个业务类,需要一个代理类。

2、动态代理:jdk1.5中提供,利用反射。实现InvocationHandler接口。

业务接口还是必须得,业务接口,业务类同上。

a、代理类:

/**
 * 动态代理类
 *
 * @author yanbin
 *
 */
public class DynamicProxy implements InvocationHandler {

    /** 需要代理的目标类 */
    private Object target;

    /**
     * 写法固定,aop专用:绑定委托对象并返回一个代理类
     *
     * @param delegate
     * @return
     */
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    /**
     * @param Object
     *            target:指被代理的对象。
     * @param Method
     *            method:要调用的方法
     * @param Object
     *            [] args:方法调用时所需要的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        // 切面之前执行
        System.out.println("切面之前执行");
        // 执行业务
        result = method.invoke(target, args);
        // 切面之后执行
        System.out.println("切面之后执行");
        return result;
    }

}

b、测试类

/**
 * 测试类
 *
 * @author yanbin
 *
 */
public class Test {

    public static void main(String[] args) {
        // 绑定代理,这种方式会在所有的方法都加上切面方法
        ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk());
        iTalk.talk("业务说明");
    }
}

输出结果会是:

切面之前执行
people talk业务说法
切面之后执行

说明只要在业务调用方法切面之前,是可以动态的加入需要处理的方法。

从代码来看,如果再建立一个业务模块,也只需要一个代理类。ITalk iTalk = (ITalk) new DynamicProxy().bind(new PeopleTalk());  将业务接口和业务类绑定到动态代理类。

但是这种方式:还是需要定义接口。

3、利用cglib

CGLIB是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强。采用的是继承的方式。不细说,看使用

a、业务类

/**
 * 业务类
 *
 * @author yanbin
 *
 */
public class PeopleTalk {

    public void talk(String msg) {
        System.out.println("people talk" + msg);
    }

}

b、cglib代理类

/**
 * 使用cglib动态代理
 *
 * @author yanbin
 *
 */
public class CglibProxy implements MethodInterceptor {

    private Object target;

    /**
     * 创建代理对象
     *
     * @param target
     * @return
     */
    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object result = null;
        System.out.println("事物开始");
        result = methodProxy.invokeSuper(proxy, args);
        System.out.println("事物结束");
        return result;
    }

}

c.测试类

/**
 * 测试类
 *
 * @author yanbin
 *
 */
public class Test {

    public static void main(String[] args) {
        PeopleTalk peopleTalk = (PeopleTalk) new CglibProxy().getInstance(new PeopleTalk());
        peopleTalk.talk("业务方法");
        peopleTalk.spreak("业务方法");
    }

}

最后输出结果:

事物开始
people talk业务方法
事物结束
事物开始
spreak chinese业务方法
事物结束

转自:http://www.cnblogs.com/yanbincn/archive/2012/06/01/2530377.html

时间: 2024-10-12 22:43:29

SpringAOP理解的相关文章

关于 spring-aop理解

对于Aop 一直理解很是不到位  谈谈自己理解! Aop : Aspect: 切面    joinpoint 连接点  pointCut 切点  Advice 增强  targert 目标对象   weaving 织入  introduction等组成 理解几个关键字: 采用springboot 方式来快速实现的理解: 故事:月黑风高杀人夜,一个人作案,但是被一个老王看见了 ,由于天气原因老王只看见是一个男的  高175公分,公安局要将10个175 男性抓起来,进行审问. pointCut:切点

Spring-----AOP深度理解

AOP定义了一些新的概念,要想深入的理解AOP的原理,就必须掌握这些概念的具体含义,本人菜鸡一枚,一下是自己对一些概念的理解,如果哪里不对,欢迎评论区指正 AOP核心概念AOP即Aspect-Oriented Programming的缩写,中文意思是面向切面(或方面)编程.AOP实际上是一种编程思想,可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种思想.1.切面(aspect)类是对物体特征的抽象,切面就是对横切关注点的抽象2.连接点(joinpoint)

SpringAOP的xml实例、注解形式实例、概念理解 以及execution表达式实例与概念说明

(1)Spring AOP的简单应用: -->AOP:(Aspect Orinted Programming)面向切面编程,用于具有横切逻辑的场合,如:访问控制,事务管理,性能检测,由切入点和增强处理组成. AOP主要核心是:在什么位置(pointcut:切入点)执行什么功能(advice:增强处理),AOP在Java里是利用反射机制实现, 关键词:-->Aspect(切面):一个模块化的横切逻辑,类似于 Java 中的类声明.-->Join Point(连接点):原程序执行过程中的某一

深入理解Spring AOP之二代理对象生成

深入理解Spring AOP之二代理对象生成 spring代理对象 上一篇博客中讲到了Spring的一些基本概念和初步讲了实现方法,当中提到了动态代理技术,包含JDK动态代理技术和Cglib动态代理 动态代理这部分我有过一篇博客介绍:动态代理,想深入了解的朋友能够看一看,再回想一下,Spring中怎样区分採用JDK动态代理和CGlib动态代理: 假设目标对象的实现类实现了接口.Spring AOP 将会採用 JDK 动态代理来生成 AOP 代理类: 假设目标对象的实现类没有实现接口,Spring

SSM框架理解(转)

SSM框架理解 最近两星期一直在学JavaEE的MVC框架,因为之前学校开的JavaEE课程就一直学的吊儿郎当的,所以现在真正需要掌握就非常手忙脚乱,在此记录下这段时间学习的感悟,如有错误,希望大牛毫不客气地指出. SpringSpring就像是整个项目中装配bean的大工厂,在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象.Spring的核心思想是IoC(控制反转),即不再需要程序员去显式地`new`一个对象,而是让Spring框架帮你来完成这一切. SpringMVCSp

AOP技术应用和研究--SpringAop实现原理

Spring 的AOP实现遵守了AOP联盟的约定.同时 Spring 又扩展了它,增加了如 Pointcut.Advisor 等一些接口使得更加灵活.在Spring的AOP模块中,包括AOP的基本概念,通知,切入点等,以及最核心的AopProxy代理对象生成和Spring AOP拦截器调用的实现. 1,Spring Aop的基本概念 我们在前面 AOP基本概念对AOP基本概念进行了理论上的定义,现在我们将Spring AOP基本概念作为例子来说明AOP的基本概念,这样可以更好的理解AOP基本概念

Spring-AOP用法总结

前言     Spring AOP的实现方法很多,在项目开发中具体采用什么方式,需要按实际情况来选择,每一种的用法,有其一定的实用价值,所以本文将各种使用方法进行了具体实现.主要包括Advice的before.after.throwing.around四种拦截方式的实现,如何进行正则匹配,自动化代理及AspectJ注解形式的实现. AOP的定义 Spring AOP(Aspect-oriented programming) 面向切面编程,是一种特殊的拦截器,将一组程序中的公共部分抽离出来进行单独

Spring容器AOP的理解

一句话理解:根据被代理对象信息通过Proxy动态生成我们具体的代理类. 实现就动态代理.那动态代理是什么呢? 动态代理其实并不是什么新鲜的东西,学过设计模式的人都应该知道代理模式,代理模式就是一种静态代理.而动态代理就是利用反射和动态编译将代理模式变成动态的.原理跟动态注入一样,代理模式在编译的时候就已经确定代理类将要代理谁,而动态代理在运行的时候才知道自己要代理谁. 别说不知道静态代理?规则:一般静态代理类需要和被代理类实现同样的接口.就说这么多吧,还是进入今天的核心吧. JDK动态代理实现思

Spring AOP的理解

这是在网上发现的一篇关于Spring AOP编程的教程,读完这篇文章后,Spring AOP不再难以理解,因此我把它译成中文,推荐给Spring AOP的初学者. AOP正在成为软件开发的下一个圣杯.使用AOP,你可以将处理aspect的代码注入主程序,通常主程序的主要目的并不在于处理这些aspect.AOP可以防止代码混乱.  为了理解AOP如何做到这点,考虑一下记日志的工作.日志本身不太可能是你开发的主程序的主要任务.如果能将“不可见的”.通用的日志代码注入主程序中,那该多好啊.AOP可以帮