澳门皇冠金沙网站▎在线官网
做最好的网站

Spring AOP梳理

2019-10-09 作者:网络服务   |   浏览(134)

二、AOP配置范例:

二、AOP配置范例:

一、Srping AOP

  AOP(Aspect Oriented Programming)解释为面向切面编程,何为切面,用刀把一块面包切成两半,刀切下去形成的面就叫切面,那么面向切面的就是形成切面的这把,刀切在哪(切入点),怎么切(通知),切成什么样(通知实现方法),切的过程就是切面织入的过程。这种编程方式主要为了分离关注点并且能够增强类的辅助功能。比如做日志管理,权限控制等工作,在特定的时候和位置做特定的事情,而无需在原来方法中做特殊处理。

  AOP概念:

      • 切面:多个对象或方法要实现的交叉功能的集合。
      • 连接点:被关注的方法,执行了该方法会触发通知。
      • 切入点:一系列连接点的集合。
      • 通知:切面的实际实现,在连接点方法被执行的时候在适当的地方插入通知。
      • 目标对象:被通知的对象,可以是自己的编写的类也可以是,第三方类对象。(连接点就是目标对象中的某些方法)
      • 代理:将通知应用到目标对象后创建的对象。
      • 织入:将切面应用到目标对象从而创建一个新的代理对象的过程。
      • 引入:为类添加新的方法和属性。(<aop:declare-parents ../>)

  1.spring中的aop的xml配置方式简单实例

Spring AOP梳理,springaop梳理

一、Srping AOP

  AOP(Aspect Oriented Programming)解释为面向切面编程,何为切面,用刀把一块面包切成两半,刀切下去形成的面就叫切面,那么面向切面的就是形成切面的这把,刀切在哪(切入点),怎么切(通知),切成什么样(通知实现方法),切的过程就是切面织入的过程。这种编程方式主要为了分离关注点并且能够增强类的辅助功能。比如做日志管理,权限控制等工作,在特定的时候和位置做特定的事情,而无需在原来方法中做特殊处理。

  AOP概念:

      • 切面:多个对象或方法要实现的交叉功能的集合。

      • 连接点:被关注的方法,执行了该方法会触发通知。

      • 切入点:一系列连接点的集合。
      • 通知:切面的实际实现,在连接点方法被执行的时候在适当的地方插入通知。
        1. before:前置通知,在方法被调用之前调用
        2. after:后置通知,在方法执行结束之后调用,无论方法是否执行成功
        3. around:环绕通知,在目标方法执行前和执行结束之后分别执行自定义方法
        4. after-return:在方法成功执行之后调用,
        5. after-throwing:在方法抛出异常后调用
      • 目标对象:被通知的对象,可以是自己的编写的类也可以是,第三方类对象。(连接点就是目标对象中的某些方法)
      • 代理:将通知应用到目标对象后创建的对象。
      • 织入:将切面应用到目标对象从而创建一个新的代理对象的过程。
      • 引入:为类添加新的方法和属性。(<aop:declare-parents ../>)

三.以代理对象的方式实现AOP:

  1.前置通知:

 1 /**
 2  * 前置通知:实现MethodBeforeAdvice接口,在目标方法执行之前执行
 3  * 相当于aop配置<aop:before method="before" pointcut-ref="当前类的bean"/>
 4  */
 5 public class BeforeNotify implements MethodBeforeAdvice {
 6 
 7     public void before(Method method, Object[] objects, Object o) throws Throwable {
 8         System.out.println("=========== 前置通知 =========");
 9     }
10 }

  

  2.后置通知:

 1 /**
 2  * 后置(返回)通知:在方法结束返回时调用,一般包含在环绕通知结束前执行,
 3  * 方法成功执行有效,异常结束则该方法无效。
 4  * 相当于aop配置:<aop:after-returning method="afterReturning" pointcut-ref="当前类的bean"/>
 5  */
 6 public class AfterNotify implements AfterReturningAdvice {
 7     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
 8         System.out.println("=========== 后置通知 =========");
 9     }
10 }

  

  3.环绕通知:

 1 /**
 2  * 环绕通知:在方法执行前和执行后均可以执行自定义的方法,
 3  * 相当于aop配置:<aop:around method="invoke" pointcut-ref="当前类的Bean"/>
 4  */
 5 public class AroundNotify implements MethodInterceptor {
 6 
 7     public Object invoke(MethodInvocation methodInvocation) throws Throwable {
 8         System.out.println("=========== 环绕通知 =========");
 9         Object obj = methodInvocation.proceed();//执行目标方法
10         System.out.println("=========== 环绕通知 =========");
11         return obj;
12     }
13 }

  

  4.异常通知:

 1 /**
 2  * 异常通知:在目标方法执行异常时执行,
 3  * 注意:ThrowsAdvice是个空接口,里面未定义任何待实现类
 4  * 相当于aop配置:<aop:after-throwing method="afterThrowing" pointcut-ref="当前类的bean"/>
 5  */
 6 public class ExceptionNotify implements ThrowsAdvice {
 7     public void afterThrowing(Method method, Object[] args, Object target, Exception ex){
 8         System.out.println("方法:"+method.getName()+"出错了n原因:"+ex.getMessage());
 9     }
10 }

   此处的ThrowAdvice接口是没有实现方法的,但是又不允许随便定义,在源码中我们看到了规定的几个方法,因为此接口中,没有任何实现方法,当被利用反射机制调用的时候,必须实现一下方法中的一种,这是源码注释的说明:

图片 1

图片 2

  5.bean配置

 1 <beans xmlns="http://www.springframework.org/schema/beans"
 2        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 4 
 5         <!--  被代理对象 -->
 6         <bean class="com.springAop.proxyAOP.UserDao" id="userDao"/>
 7 
 8         <!-- 关联通知 -->
 9         <bean class="com.springAop.proxyAOP.BeforeNotify" id="before"/>
10         <bean class="com.springAop.proxyAOP.AroundNotify" id="aroundNotify"/>
11         <bean class="com.springAop.proxyAOP.ExceptionNotify" id="exceptionNotify"/>
12         <bean class="com.springAop.proxyAOP.AfterNotify" id="afterNotify"/>
13 
14         <!-- 代理对象 -->
15         <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
16             <!-- 代理对象接口,接口方法就是连接点 -->
17             <property name="proxyInterfaces">
18                 <list>
19                     <!--  目标对象实现的接口类,实现了那些接口都可以补充进去,接口的方法就是一个个连接点 -->
20                     <value>com.springAop.proxyAOP.IUserDao</value>
21                     <value>com.springAop.proxyAOP.BookDao</value>
22                 </list>
23             </property>
24 
25             <!-- 关联通知类型 -->
26             <property name="interceptorNames">
27                 <list>
28                     <value>before</value><!-- 前置通知织入 -->
29                     <value>aroundNotify</value><!-- 环绕通知织入 -->
30                     <value>exceptionNotify</value><!-- 异常通知织入 -->
31                     <value>afterNotify</value><!-- 后置通知织入 -->
32                 </list>
33             </property>
34 
35             <!-- 关联被代理对象(aop的目标对象) -->
36             <property name="target" ref="userDao"/>
37         </bean>
38 </beans>

 

  6.目标对象:(实现了两个接口)

 1 public class UserDao implements IUserDao,BookDao{
 2     public void save() {
 3         System.out.println("保存用户信息中。。。。");
 4         // int i=1/0;
 5     }
 6 
 7     public void getBook() {
 8         System.out.println("拿到一本书");
 9     }
10 }

 

  7.测试类:

 1 public class Test{
 2     @org.junit.jupiter.api.Test
 3     public void testDemo(){
 4         ApplicationContext app = new FileSystemXmlApplicationContext("file:G:\DevelopSoftware\IDEA\workspace\springDemo\src\main\java\com\springAop\proxyAOP\bean.xml");
 5         /**
 6          * 获取的bean是目标对象的代理对象,可以将代理对象强转成任何目标对象实现的接口对象
 7          */
 8         IUserDao userDao = app.getBean("proxyFactoryBean",IUserDao.class);
 9         userDao.save();
10         System.out.println("=========================");
11         /**
12          * 将代理对象强转成BookDao接口对象,并调用该接口方法。
13          */
14         ((BookDao)userDao).getBook();
15     }
16 }

 

   运行结果:

图片 3

 

 

 

 

 

 

 

 

  

 

http://www.bkjia.com/Javabc/1230131.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1230131.htmlTechArticleSpring AOP梳理,springaop梳理 一、Srping AOP AOP(Aspect Oriented Programming)解释为面向切面编程,何为切面,用刀把一块面包切成两半,刀切下去形成...

  3.利用切面为特定的类添加新功能:

<aop:config>
        <!-- 两个切面-->
        <aop:aspect ref="company">
            <!-- 利用切面为特定的类添加新功能 -->
            <aop:declare-parents types-matching="com.springAop.InstanceMine+" <!-- 实现了InstanceMine接口的实现类可以强转成InstanceOtheer类型的对象并使用他的实现类的方法的方法 -->
        implement-interface="com.springAop.InstanceOther"  
             default-impl="com.springAop.OtherImpl"/>  <!--InstanceOther的默认实现类,当InstanceMine对象强转成InstanceOther的对象时,默认实现类为OtherImpl-->
        </aop:aspect>
    </aop:config>

 

   接口类:instanceMine和instanceOther

public interface InstanceMine {
    public void speak1(String meg);
}


public interface InstanceOther {
    public void speak2(String meg);
}

 

  接口实现类: OtherImple和MineImpl

public class MineImpl implements instanceMine {

    public void speak1(String meg) {
        System.out.println("s1");
    }
}



public class OtherImpl implements instanceOther {
    public void speak2(String meg) {
        System.out.println(meg);
    }
}

  测试类:Test

public class Test {
    @org.junit.jupiter.api.Test
    public void TestDemo(){
        ApplicationContext app = new FileSystemXmlApplicationContext("src/main/java/com/springAop/bean.xml");

        InstanceMine mine = app.getBean("mine",instanceMine.class);
        ((InstanceOther)mine).speak2("我可以说话吗");//强转成InstanceOther,并调用实现类OtherImpl的实现方法
    }
}

  结果:

  图片 4

本文由澳门皇冠金沙网站发布于网络服务,转载请注明出处:Spring AOP梳理

关键词: