澳门威利斯人_威利斯人娱乐「手机版」

来自 办公软件 2020-01-12 03:21 的文章
当前位置: 澳门威利斯人 > 办公软件 > 正文

Spring框架第五篇之Spring与AOP

Sring AOP通过PointCut来钦定在那么些类的那个方法上织入横断逻辑,通过Advice来钦赐在切点上具体做什么样业务。如方法前做怎么着,方法后做如何,抛出极度做什么。

Spring AOP 

一、AOP概述

AOP(Aspect Orient ProgrammingState of Qatar,面向切面编制程序,是面向对象编制程序OOP的风姿洒脱种补偿。面向对象编制程序是从静态角度构思程序的布局,而面向切面编程是从动态角度考虑程序运维进度。

AOP底层就是运用动态代理格局完结的,接受了三种代理:JDK的动态代理与CGLIB的动态代理。

面向切面编制程序,就是将时断时续作业逻辑封装成切面,利用AOP容器的效劳将切面织入到主业务逻辑中。所谓交叉作业逻辑是指,通用的、与主业务逻辑无关的代码。如安检、事务、日志等。

若不是用AOP,则会出当代码纠结,即交叉作业逻辑与主业务逻辑混合在联合具名,那样会使主业务逻辑变的掺和不清。

再来看一下图

  AOP为Aspect Oriented Programming的缩写,意为:面向切面编制程序
  日志记录,品质总括,安控,事务管理,十分管理等等

二、通知Advice

图片 1

AOP与OOP区别

1、文告详细解释

定义PointCut

Spring中有二种办法定义Pointcut:

  • XML文件
  • 注解

在xml文件中,入门中做了的示范:

<aop:config> <!-- 定义切点 --> <aop:pointcut expression="execution(public * * "></aop:pointcut> ...</aop:config>

讲授的方法:

@Component@Aspectpublic class HelloWorld { @Pointcut("execution(public * *  public void sayHello(){ System.out.println; } ...}

XML与表明方式左近,学会了大器晚成种,另外豆蔻梢头种无难度上手,大家应用XML演示。

  OOP(面向对象编制程序)针对工作管理进程的实体及其性质和行为开展抽象封装,以获取越来越鲜明高效的逻辑单元区划。
  而AOP则是本着职业管理进度中的切面举办领取,它所面临的是管理进度中的有个别步骤或阶段,以得到逻辑进程中各部分之间低耦合性的隔绝效果。那三种设计思想在对象上有着本质的分化。

(1)前置通告MethodBeforeAdvice

概念前置通告,要求达成MethodBeforeAdvice接口。该接口中有一个措施before(State of Qatar,会在对象措施推行早先实践。

停放文告的特点:

1、在对象措施实施早先实践。

2、不校正目的措施的施行流程,前置文告代码不可能阻碍目标措施施行。

3、不改造目的措施试行的结果。

 举例:

创建IService接口:

package com.ietree.spring.basic.aop.beforeadvice;

public interface IService {

    void doFirst();

    void doSecond();

}

开创接口的完毕类:

package com.ietree.spring.basic.aop.beforeadvice;

public class SomeServiceImpl implements IService {

    @Override
    public void doFirst() {
        System.out.println("执行doFirst()方法");
    }

    @Override
    public void doSecond() {
        System.out.println("执行doFirst()方法");
    }

}

创建前置公告类MyMethodBeforeAdvice,该类必得兑现MethodBeforeAdvice接口:

package com.ietree.spring.basic.aop.beforeadvice;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 前置通知
 * 
 * @author Root
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

    // 当前方法在目标方法执行之前执行
    // method:目标方法
    // args:目标方法参数列表
    // target:目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        // 对于目标方法的增强代码就写在这里
        System.out.println("执行前置通知...");
    }

}

配置XML文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1、注册目标对象 -->
    <bean id="someService" class="com.ietree.spring.basic.aop.beforeadvice.SomeServiceImpl"/>

    <!-- 2、注册切面:通知 -->
    <bean id="myAdvice" class="com.ietree.spring.basic.aop.beforeadvice.MyMethodBeforeAdvice"/>

    <!-- 3、生成代理对象 -->
    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 指定目标对象 -->
        <!-- <property name="targetName" value="someService"/> -->
        <property name="target" ref="someService"/>
        <!-- 指定切面 -->
        <property name="interceptorNames" value="myAdvice"/>
    </bean>

</beans>

测试:

package com.ietree.spring.basic.aop.beforeadvice;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test() {

        String resource = "com/ietree/spring/basic/aop/beforeadvice/applicationContext.xml";

        ApplicationContext ac = new ClassPathXmlApplicationContext(resource);

        IService service = (IService)ac.getBean("serviceProxy");

        service.doFirst();
        System.out.println("==============");
        service.doSecond();
    }

}

输出:

执行前置通知...
执行doFirst()方法
==============
执行前置通知...
执行doFirst()方法

瞩目:推行早前要求导入spring-aop-4.3.9.RELEASE.jar包

增强

通过Idea,看一下Advice接口的接口世襲类:[图片上传退步...(image-d49d25-1530458748566卡塔尔(قطر‎]

第一可分为5类加强:

  • MthodBeforeAdvice:指标措施实施前提升

  • AfterReturningAdvice:指标措施实行后增高

  • ThrowsAdvice 非常抛出拉长

  • IntroductionAdvice 引导介绍巩固,为目的类增加新的性子和章程。能够营造组合对象来促成多三番九遍

  • MethodInterceptor 方法拦截器,环绕巩固,在艺术的光景施行操作

AfterAdvice,BeforeAdvice当前是用作标识使用,内部无接口方法,为新兴增加使用。Interceptor接口亦不是平昔接受,雷同作为标志类,可使用其子接口。

AOP相关术语

(2)前置通告AfterReturningAdvice

概念前置公告,须要落实AfterReturningAdvice接口。该接口中有三个方法afterReturning(State of Qatar,会在目的措施试行之后奉行。

前置通告的特点:

1、在指标措施施行之后实行。

2、不改造指标措施的举行流程,前置布告代码不能够拦截指标措施试行。

3、不更正指标措施实践的结果。

差非常的少流程和松开布告大约,这里就大约列举一下不一样之处:

创建后置布告类并落实AfterReturningAdvice接口,重写afterReturning(卡塔尔国方法:

package com.ietree.spring.basic.aop.afterreturningadvice;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

/**
 * 后置通知:可以获取到目标方法的返回结果,但是无法改变目标方法的结果
 * 
 * @author Root
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {

    // 在目标方法执行之后执行
    // returnValue:目标方法的返回值
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行后置通知方法 returnValue = "   returnValue);
    }

}

配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1、注册目标对象 -->
    <bean id="someService" class="com.ietree.spring.basic.aop.afterreturningadvice.SomeServiceImpl"/>

    <!-- 2、注册切面:通知 -->
    <bean id="myAdvice" class="com.ietree.spring.basic.aop.afterreturningadvice.MyAfterReturningAdvice"/>

    <!-- 3、生成代理对象 -->
    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 指定目标对象 -->
        <property name="target" ref="someService"/>
        <!-- 指定切面 -->
        <property name="interceptorNames" value="myAdvice"/>
    </bean>

</beans>

注意:前置文告能够取获得目的措施的回来结果,不过无法改观指标措施推行的归来结果。

放到加强

嵌入巩固重大在十分到的切点运维在此以前推行,在XML配置中采纳<aop:before>,相应的接口为MethodBeforeAdvice,其方法为

 /** * @param method 要被激发的方法 * @param args 方法的参数 * @param target 目标对象,可能为null * @throws Throwable 如果这个对象想要终止调用,那么抛出异常,异常会返回给方法调用者,否则异常会被包装为运行时异常 */void before(Method method, Object[] args, Object target) throws Throwable;

当二个Bean对象实现了MethodBeforeAdvice,在XML配置文件中钦赐那么些bean为advice,Spring会自动在切点方法实施前履行MethodBeforeAdvice的接口。

 <bean /> <!-- timelog实现了MethodBeforeAdvice接口 --> <bean /> <aop:config> <aop:pointcut expression="execution(public * * "></aop:pointcut> <!-- advisor的作用为将Pointcut和Advice组装起来 --> <aop:advisor advice-ref="timeLog" pointcut-ref="hello" /> </aop:config>

在调用相应的切点方法早前,前置巩固都会生效。

  目的对象target:指的是急需被提升的指标,由于spring aop是经过代理格局达成,进而这么些目标永恒是被代理对象。
  连接点(join point卡塔尔(قطر‎:所谓连接点是指那二个被阻碍到的点,在spring中这个点指的是办法,因为spring只帮助措施类型的连接点
  切入点(pointcut卡塔尔(قطر‎:轻易说切入点是指大家要对怎么着连接点实行拦阻的定义
  通知(advice卡塔尔:所谓文告是指拦截到连接点之后所要做的事务正是通报,文告分为前置布告,后置通告,万分通告,最后公告,环绕文告

(3)环绕文告MethodInterceptor

 定义环绕布告,要求落实MethodInterceptor接口。环绕文告,也叫方法拦截器,能够在对象措施调用在此以前及之后做管理,能够改善指标措施的重回值,也能够改动程序试行流程。

始建环绕通告类MyMethodInterceptor,达成MethodInterceptor接口:

package com.ietree.spring.basic.aop.methodinterceptor;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

// 环绕通知:可以修改目标方法的返回结果
public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {

        System.out.println("执行环绕通知:目标方法执行之前");
        // 执行目标方法
        Object result = invocation.proceed();

        System.out.println("执行环绕通知:目标方法执行之后");
        if(null != result)
        {
            result = ((String)result).toUpperCase();
        }
        return result;
    }

}

陈设文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1、注册目标对象 -->
    <bean id="someService" class="com.ietree.spring.basic.aop.methodinterceptor.SomeServiceImpl"/>

    <!-- 2、注册切面:通知 -->
    <bean id="myAdvice" class="com.ietree.spring.basic.aop.methodinterceptor.MyMethodInterceptor"/>

    <!-- 3、生成代理对象 -->
    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 指定目标对象 -->
        <!-- <property name="targetName" value="someService"/> -->
        <property name="target" ref="someService"/>
        <!-- 指定切面 -->
        <property name="interceptorNames" value="myAdvice"/>
    </bean>

</beans>

测试:

package com.ietree.spring.basic.aop.methodinterceptor;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test() {

        String resource = "com/ietree/spring/basic/aop/methodinterceptor/applicationContext.xml";

        ApplicationContext ac = new ClassPathXmlApplicationContext(resource);

        IService service = (IService)ac.getBean("serviceProxy");

        service.doFirst();
        System.out.println("==============");

        String result = service.doSecond();
        System.out.println(result);
    }

}

输出:

执行环绕通知:目标方法执行之前
执行doFirst()方法
执行环绕通知:目标方法执行之后
==============
执行环绕通知:目标方法执行之前
执行doSecond()方法
执行环绕通知:目标方法执行之后
ABCDE

瞩目:环绕布告不只能够收获到艺术的回来结果,何况还足以改正章程的回到结果。

前置巩固

弄驾驭了内置加强,后置巩固也是同四个道理,然而前置巩固是在切点运转后实践。接口为AfterReturningAdvice,方法为

/** * 当方法成功返回之后运行 * @param returnValue 如果方法有返回值,那么returnValue就是返回值 * @param method 激发的方法 * @param args 方法的参数 * @param target 目标对象 * @throws Throwable 同上 */ void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;

在切点方法运转之后,后置加强会立见功效。

Advice 定义了在 pointcut 里面定义的程序点具体要做的操作

(4)非常公告ThrowsAdvice

特别分三种:
1)运营时那多少个,不举办拍卖,也能够经过编译。若三个类世襲自Run提姆eException,则该极度便是运转时非常
 2)编写翻译时特别,受查相当,Checked Exception。不开展拍卖,则不能够通过编写翻译。若多少个类世襲自Exception,则该非常就是受查卓殊。

开创接口IService:

package com.ietree.spring.basic.aop.throwsadvice;

public interface IService {
    // 用户登录
    boolean login(String username, String password) throws UserException;
}

成立接口实现类SomeServiceImpl:

package com.ietree.spring.basic.aop.throwsadvice;

public class SomeServiceImpl implements IService {

    @Override
    public boolean login(String username, String password) throws UserException {
        if (!"jack".equals(username)) {
            throw new UsernameException("用户名错误!");
        }
        if (!"123".equals(password)) {
            throw new PasswordException("密码错误!");
        }
//        double i = 3 / 0;
        return true;
    }

}

始建多个自定义极其:

package com.ietree.spring.basic.aop.throwsadvice;

/**
 * 自定义异常
 * 异常分两种:
 * 1)运行时异常,不进行处理,也可以通过编译。若一个类继承自RunTimeException,则该异常就是运行时异常
 * 2)编译时异常,受查异常,Checked Exception。不进行处理,则无法通过编译。若一个类继承自Exception,则该异常就是受查异常。
 * 
 * @author Root
 */
public class UserException extends Exception {

    public UserException() {
        super();
    }

    public UserException(String message) {
        super(message);
    }

}

顾客名可怜:

package com.ietree.spring.basic.aop.throwsadvice;

public class UsernameException extends UserException {

    public UsernameException() {
        super();
    }

    public UsernameException(String message) {
        super(message);
    }

}

密码极度:

package com.ietree.spring.basic.aop.throwsadvice;

public class PasswordException extends UserException {

    public PasswordException() {
        super();
    }

    public PasswordException(String message) {
        super(message);
    }

}

概念相当布告:

package com.ietree.spring.basic.aop.throwsadvice;

import org.springframework.aop.ThrowsAdvice;

/**
 * 异常通知 当目标方法抛出与指定类型的异常具有is-a关系的异常时,执行当前方法afterThrowing()
 * 
 * @author Root
 */
public class MyThrowsAdvice implements ThrowsAdvice {

    // 当目标方法抛出UsernameException异常时,执行当前方法
    public void afterThrowing(UsernameException ex) {
        System.out.println("发生用户名异常 ex = "   ex.getMessage());
    }

    // 当目标方法抛出UsernameException异常时,执行当前方法
    public void afterThrowing(PasswordException ex) {
        System.out.println("发生密码异常 ex = "   ex.getMessage());
    }

    // 当目标方法抛出UsernameException异常时,执行当前方法
    public void afterThrowing(Exception ex) {
        System.out.println("发生其它异常 ex = "   ex.getMessage());
    }
}

结构文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1、注册目标对象 -->
    <bean id="someService" class="com.ietree.spring.basic.aop.throwsadvice.SomeServiceImpl"/>

    <!-- 2、注册切面:通知 -->
    <bean id="myAdvice" class="com.ietree.spring.basic.aop.throwsadvice.MyThrowsAdvice"/>

    <!-- 3、生成代理对象 -->
    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 指定目标对象 -->
        <!-- <property name="targetName" value="someService"/> -->
        <property name="target" ref="someService"/>
        <!-- 指定切面 -->
        <property name="interceptorNames" value="myAdvice"/>
    </bean>

</beans>

测试:

package com.ietree.spring.basic.aop.throwsadvice;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test() throws UserException {

        String resource = "com/ietree/spring/basic/aop/throwsadvice/applicationContext.xml";

        ApplicationContext ac = new ClassPathXmlApplicationContext(resource);

        IService service = (IService)ac.getBean("serviceProxy");

        service.login("jack", "123");
    }

}

十二分抛出增进

当切点方法抛出非常时,卓殊抛出增加才会被施行。其接口为ThrowsAdvice,接口未有一点点名方法,实现这些接口的靶子是因而反射来调用其加强方法的。

// 异常增强方法格式如下// 前面的三个参数是可选的,ThrowableSubclass为Throwable的子类void afterThrowing([Method, args, target], ThrowableSubclass)//案例如下public void afterThrowing(Exception ex)public void afterThrowing(RemoteException)public void afterThrowing(Method method, Object[] args, Object target, Exception ex)public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)

  引导介绍introduction:引导介绍是风流倜傥种极其的文告,在不修正类代码的前提下,introduction能够在运维期为类动态地抬高级中学一年级些办法或品质
  切面aspect:是切入点和通报的三结合
  织入weaving:织入是一个历程,是将切面应用到对象对象进而开更创AOP代理对象的长河,织入能够在编写翻译期,类装载期,运维期举行。

 (5)同期利用五个文告的配备方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1、注册目标对象 -->
    <bean id="someService" class="com.ietree.spring.basic.aop.multipleadvice.SomeServiceImpl"/>

    <!-- 2、注册切面:通知 -->
    <!-- 前置通知 -->
    <bean id="beforeAdvice" class="com.ietree.spring.basic.aop.multipleadvice.MyMethodBeforeAdvice"/>
    <!-- 后置通知 -->
    <bean id="afterAdvice" class="com.ietree.spring.basic.aop.multipleadvice.MyAfterReturningAdvice"/>

    <!-- 3、生成代理对象 -->
    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 指定目标对象 -->
        <property name="target" ref="someService"/>
        <!-- 指定切面 -->
        <!-- 方式一 -->
        <property name="interceptorNames" value="beforeAdvice,afterAdvice"/>
        <!-- 方式二 -->
        <!-- <property name="interceptorNames">
            <array>
                <value>beforeAdvice</value>
                <value>afterAdvice</value>
            </array>
        </property> -->
    </bean>

</beans>

 

抓好案例

据说前边的松手,前置,格外抛出增进,看一个完整的案例:

// TimeLoggingAop实现了前置增强,后置增强,异常环绕增强public class TimeLoggingAop implements MethodBeforeAdvice,AfterReturningAdvice,ThrowsAdvice { private long startTime = 0; @Override public void before(Method method, Object[] objects, Object o) throws Throwable { startTime = System.nanoTime(); } @Override public void afterReturning(Object returnValue, Method method, Object[] objects, Object target) throws Throwable { long spentTime = System.nanoTime() - startTime; String clazzName = target.getClass().getCanonicalName(); String methodName = method.getName(); System.out.println("执行"   clazzName   "#"   methodName   "消耗"   new BigDecimal(spentTime).divide(new BigDecimal   "毫秒"); } public void afterThrowing(Method method, Object[] args, Object target, Exception ex){ System.out.println("执行"   method.getName()   "出现异常,"   "异常消息为:"   ex.getMessage; }}// 普通的HelloWorld对象public class HelloWorld { public void sayHello(){ System.out.println; } public void sayHelloWithException(){ System.out.println; throw new RuntimeException("Hello World运行时出了一点问题"); }} public static void main(String[] args) { //普通对象 HelloWorld helloWorld = new HelloWorld(); //增强对象 BeforeAdvice beforeAdvice = new TimeLoggingAop(); //组装普通对象和增强对象 ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setTarget(helloWorld); proxyFactory.addAdvice(beforeAdvice); //获取组装后的代理对象 HelloWorld proxyHelloWorld = (HelloWorld) proxyFactory.getProxy(); //运行 proxyHelloWorld.sayHello(); proxyHelloWorld.sayHelloWithException(); }//运行结果hello执行me.aihe.exam.controller.HelloWorld#sayHello消耗29.392268毫秒hello执行sayHelloWithException出现异常,异常消息为:Hello World运行时出了一点问题

经过地点这几个案例,大家差相当少知道怎么样是增进,字面意思:在本来方法之上扩充部相当加的东西,原来的成效巩固了,所以叫加强,那是汉译过来的加强。印度语印尼语名字为Advice,建议,在措施周边建议措施做如何事情,然后真的做了...

Spring接收动态织入,而aspectj选择静态织入

三、顾问Advisor

 通告(Advice)是Spring提供的后生可畏种切面(Aspect)。但其意义过于简短:只好将切面织入到目的类的享有办法中,不能实现将切面织入到钦定目的措施中。

军师(Advisor)是Spring提供的另少年老成种切面。它能够成功更为复杂的断面织入功能。PointcutAdvisor是奇士谋臣的生机勃勃种,能够钦命具体的切入点。军师将通知进行了包装,会依赖分歧的文告类型,在区别的时间点,将切面织入到分裂的切入点。

PointcutAdvisor接口有四个相比常用的落到实处类:

NameMatchMethodPointcutAdvisor:名称相称方法切入点策士

RegexpMethodPointcutAdvisor:正则表达式相配方法切入点谋臣

围绕加强

围绕巩固可以看到为停放加强,前置巩固,相当抛出拉长的结合体,唯有三个接口MethodInterceptor,其方法为:

// MethodInvocation封装了目标对象和参数数组,调用它的invocation.proceed()方法即激发目标对象的方法。Object invoke(MethodInvocation invocation) throws Throwable;

三个用法案例:

 public Object invoke(MethodInvocation invocation) throws Throwable { System.out.println; try { Object result = invocation.proceed(); System.out.println; return result; }catch (Exception e){ System.out.println("异常抛出增强执行"); //做其它的动作 } return null; }

  代理Proxy:三个类被AOP织入加强后,就发出三个结实代理类

1、名称相配方法切入点总参NameMatchMethodPointcutAdvisor

 NameMatchMethodPointcutAdvisor,即名称相称方法切入点智囊团。容器可依据计划文件中钦赐的不二秘技名来设置切入点。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1、注册目标对象 -->
    <bean id="someService" class="com.ietree.spring.basic.aop.advisor.namematchmethodpointcutadvisor.SomeServiceImpl"/>

    <!-- 2、注册切面:通知 -->
    <bean id="myAdvice" class="com.ietree.spring.basic.aop.advisor.namematchmethodpointcutadvisor.MyMethodBeforeAdvice"/>

    <!-- 3、注册顾问:顾问 -->
    <bean id="myAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <!-- 指定切面 -->
        <property name="advice" ref="myAdvice"/>
        <!-- 指定切入点 -->
        <!-- <property name="mappedName" value="doFirst"/> -->
        <!-- <property name="mappedNames" value="doFirst,doSecond"/> -->
        <property name="mappedNames" value="*ir*"/>
    </bean>

    <!-- 4、生成代理对象 -->
    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 指定目标对象 -->
        <property name="target" ref="someService"/>
        <!-- 指定顾问-->
        <property name="interceptorNames" value="myAdvisor"/>
    </bean>

</beans>

 

增进顺序

当多个提升作用与同一个切点的时候,具体哪二个增高会先实行吗?

Spring依照@Order评释可能落成了Ordered接口的提升类来开展剖断。

public interface Ordered { int HIGHEST_PRECEDENCE = -2147483648; int LOWEST_PRECEDENCE = 2147483647; int getOrder();}

AOP底层:

2、正则表明式相称方法切入点奇士谋士RegexpMethodPointcutAdvisor

 RegexpMethodPointcutAdvisor,即正则表达式方法策士。容器可依照正则表明式来安装切入点。注意,与正则表明式举办相配的靶子是接口中的方法名,而非指标类(接口完毕类)的不二等秘书籍名。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop 
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <!--1、注册目标类-->
    <bean id="someServiceImpl" class="com.ietree.spring.aop.advisor.SomeServiceImpl"></bean>
    <!-- 2、注册通知 -->
    <bean id="myAdvice" class="com.ietree.spring.aop.advisor.MyMethodBeforeAdvice"></bean>

    <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="myAdvice"></property>
        <!-- 这里的正则表达式匹配的对象是全限定性方法名 -->
        <!-- 方式一 -->
        <!--<property name="pattern" value=".*doFirst"/>-->
        <!-- 方式二 -->
        <!--<property name="patterns" value=".*doFirst,.*doSecond"/>-->
        <!-- 方式三 -->
        <!--<property name="pattern" value=".*doFirst|.*doSecond"/>-->
    </bean>

    <!-- 生成代理对象 -->
    <bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="someServiceImpl"/>
        <property name="interceptorNames" value="myAdvisor"/>
    </bean>

</beans>

测试:

package com.ietree.spring.aop.advisor;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by Root on 2017/7/3.
 */
public class Test {

    @org.junit.Test
    public void test01(){

        String resource = "com/ietree/spring/aop/advisor/applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(resource);

        ISomeService service = (ISomeService)ac.getBean("serviceProxy");
        service.doFirst();
        System.out.println("==========================");
        service.doSecond();
        System.out.println("==========================");
        service.doThird();

    }

}

 

疏解相关加强

增进的概念同样,在运用格局上有一点点有一些分别,加强的相干评释有:@Before@AfterReturning@AfterThrowing(@After //约等于try-catch-finally中的final,平时用来释放能源@Around

利用上与接口大概

  JDK动态代理:在运营 ,在JVM内部动态生成class字节码对象(Class对象State of Qatar

四、自动代理生成器

最后

巩固是AOP中基本概念之大器晚成,本文在提升上稍作一些商讨,深刻还要靠大家,最终希望能帮到我们

Jdk动态代理只针对于接口操作

 1、暗中认可advisor自动代理生成器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <!--1、注册目标类-->
    <bean id="someServiceImpl" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
    <bean id="someServiceImpl2" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
    <!-- 2、注册通知 -->
    <bean id="myAdvice" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.MyMethodBeforeAdvice"></bean>

    <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="myAdvice"></property>
        <!-- 这里的正则表达式匹配的对象是全限定性方法名 -->
        <property name="pattern" value=".*doFirst"/>
    </bean>

    <!-- 注册默认自动代理生成器 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

</beans> 

测试:

package com.ietree.spring.aop.defaultadvisorautoproxycreator;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by Root on 2017/7/3.
 */
public class Test {

    @org.junit.Test
    public void test01(){

        String resource = "com/ietree/spring/aop/defaultadvisorautoproxycreator/applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(resource);

        ISomeService service = (ISomeService)ac.getBean("someServiceImpl");
        service.doFirst();
        System.out.println("==========================");
        service.doSecond();
        System.out.println("==========================");
        service.doThird();

        System.out.println("----------------------------------");

        ISomeService service2 = (ISomeService)ac.getBean("someServiceImpl2");
        service2.doFirst();
        System.out.println("==========================");
        service2.doSecond();
        System.out.println("==========================");
        service2.doThird();
    }

}

只顾:使用DefaultAdvisorAutoProxyCreator自动代理生成器会有以下多少个难点:

1)无法选取对象对象。

2)不能够选取切面类型,切面只可以是advisor。

3)不可能选择advisor,全数的advisor都将被作为切面织入到指标措施中。

急需解决这个难题,须求运用Bean名称自动代理生成器达成。

参考

  • 《Spring Reference》
  • 《明白Spring 4.x 公司级应用开荒实战》

newProxyInstance的八个参数:

2、Bean名称自动代理生成器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <!--1、注册目标类-->
    <bean id="someService" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
    <bean id="someService2" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.SomeServiceImpl"></bean>
    <!-- 2、注册通知 -->
    <bean id="myAdvice" class="com.ietree.spring.aop.defaultadvisorautoproxycreator.MyMethodBeforeAdvice"></bean>
    <!-- 3、注册顾问 -->
    <bean id="myAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="myAdvice"></property>
        <!-- 这里的正则表达式匹配的对象是全限定性方法名 -->
        <property name="pattern" value=".*doFirst"/>
    </bean>

    <!-- 注册默认自动代理生成器 -->
    <!--<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>-->

    <!-- 注册Bean名称自动代理生成器 -->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames" value="someService"/>
        <property name="interceptorNames" value="myAdvisor"/>
    </bean>

</beans>

 

  第叁个参数:目的类的类加载器对象
  第四个参数:指标类的兑现接口的Class[]
  第八个参数:InvocationHandler它是二个接口,它的成效是是代理实例的调用项理程序 实现的接口,接口中定义了一个方法

五、AspectJ对AOP的实现

上面举个例证:

1、AspectJ基本概念 

AspectJ切入表明式原型:

execution(
      [modifiers-pattern] 访问权限类型
      ret-type-pattern 返回值类型
      [declaring-type-pattern] 全限定性类名
      name-pattern(param-pattern)方法名(参数名)
      [throws-pattern] 抛出异常类型
 )

其中,带有[ ]的朝气蓬勃部分是能够简轻松单的,红棕的一些是无法差没有多少的一些。

还能利用以下符号:

符号 意义
* 0至多个任意字符
..

用在方法参数中,表示任意多个参数。

用在包名后,表示当前包及其子包路径。

用在类名后,表示当前类及其子类。

用在接口后,表示当前接口及其实现类。

 

本文由澳门威利斯人发布于办公软件,转载请注明出处:Spring框架第五篇之Spring与AOP

关键词: 澳门威利斯人 Spring AOP Advice