spring aop

最新推荐文章于 2022-08-26 23:20:39 发布

「已注销」

最新推荐文章于 2022-08-26 23:20:39 发布

阅读量256

点赞数

CC 4.0 BY-SA版权

分类专栏： java Spring java基础

本文链接：https://blog.youkuaiyun.com/zkk930817/article/details/50916004

java基础同时被 3 个专栏收录

10 篇文章

订阅专栏

java

4 篇文章

订阅专栏

Spring

3 篇文章

订阅专栏

7.AOP
1).什么是AOP
· AOP ： a. Aspect Oriented Programming; 面向切面编程
b. 两种实现方式：预编译方式(AspectJ) 运行期动态代理方式(JDK动态代理、CGLib动态代理)(SpringAOP、JbossAOP)
c. 目的：实现程序功能的统一维护的一种技术。
d. 主要功能是：日志记录，性能统计，安全控制，事务处理，异常处理
2).相关概念：
a.切面(Aspect) : 一个关注点的模块化，这个关注点可能会横切多个对象
b.连接点(Joinpoint) : 程序执行过程中的某个特定的点
c.通知(advice) : 在切面的某个特定的链接点上执行的动作
d.切入点(Pointcut) : 匹配连接点的断言，在AOP中通知和一个切入点表达式关联
e.引入(Introduction) : 在不修改类代码的前提下，为类添加新的方法和属性
f.目标对象(Target Object) : 被一个或者多个切面所通知的对象
g.AOP代理(AOP Proxy)　： AOP框架创建的对象，用来实现切面契约(aspect contract)(包括通知方法执行等功能)
h.织入(weaving) : 把切面连接到其他的应用程序类型或者对象上，并创建一个被通知的对象，分为：编织时织入，类加载时织入，执行时织入
3).通知类型Advice：
a. 前置通知(Before advice) : 在某连接点(join point)之前执行的通知，但不能阻止连接点之前的执行(除非抛出一个异常)
b.返回后通知(After returning advice) : 在某连接点(join point)正常完成后执行的通知
c.抛出异常后通知(After throwing advice) : 在方法抛出异常退出时执行的通知
d.后通知(After(finally) advice) : 当连接点推出的时候执行的通知(不论是正常返回还是异常退出)
f.环绕通知(Around Advice) : 包围一个连接点(join point)的通知
4)Spring框架中AOP的用途
a.提供了声明式的企业服务，特别是EJB的替代服务的声明
b.允许用户定制自己的切面，以完成OOP与AOP的互补使用
5)Spring的AOP实现
a.纯java实现，无需特殊的编译过程，不需要控制类加载器层次
b.目前只支持方法执行连接点(通知Spring Bean的方法执行)
c.不是为了提供最完整的AOP实现(尽管它非常强大); 而是侧重于提供一种AOP实现和Spring Ioc容器之间的整合，用于帮助解决企业应用中的
常见问题
e.Spring AOP不会与AspectJ竞争，从而提供综合全面的AOP解决方案
f.有接口和无接口的Spring AOP实现区别
i.有接口的使用的是JavaSE动态代理，
ii.无接口的使用CGLIB代理
6) 基于Schema-based的AOP实现
需要引入三个包，不然会报错 aopalliance-1.0.jar aspectjweaver-1.5.3.jar javassist-3.9.0.GA.jar(我没有用到)

    xml配置：
    <bean id="kangAspect" class="com.spring.java.aop.schema.advice.KangAspect"></bean>

    <bean id="aspectBiz" class="com.spring.java.aop.schema.advice.biz.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="kangAspectAOP" ref="kangAspect">
            <aop:pointcut expression="execution(* com.spring.java.aop.schema.advice.biz.*Biz.*(..))" id="kangPiontcut"/>
            <aop:before method="before" pointcut-ref="kangPiontcut"/>
            <aop:after-returning method="afterReturning" pointcut-ref="kangPiontcut"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="kangPiontcut"/>
            <aop:after method="after" pointcut-ref="kangPiontcut"/> 
            <aop:around method="around" pointcut-ref="kangPiontcut"/>

            <aop:around method="aroundinit" pointcut="execution(* com.spring.java.aop.schema.advice.biz.AspectBiz.init(String,int)) and args(bizName,times)"/>
        </aop:aspect>
    </aop:config

I. 其中设置切入点的语法有：
都可以用的(execution())：
public * *(..) 切入点为执行所有的public方法时
* set*(..)
* com.xyz.service.AccountService.*(..)
* com.xyz.service..(..) 不包括子包中的
* com.xyz.service…(..) 包括子包中的
只可以在Spring AOP中用的
within(com.xyz.service.*)
within(com.xyz.service..*)
this(com.xyz.service.AccountService)
target() args() annotation() bean()等
II.肯定执行
III.中around方法如下：
不带参数。

public Object around(ProceedingJoinPoint pjp) {
System.out.println("KangAspect around  1");
Object obj = null;
try {
obj = pjp.proceed();
} catch (Throwable e) {
e.printStackTrace();
}
System.out.println("KangAspect around  2");
return obj;
}
public Object aroundinit(ProceedingJoinPoint pjp, String bizName, int times) {
                System.out.println("aroundinit " + bizName + "  " + times);

                Object obj = null;
                try {
                    System.out.println("KangAspect aroundInt  1");
                    obj = pjp.proceed();
                    System.out.println("KangAspect aroundInt  2");
                } catch (Throwable e) {
                    e.printStackTrace();
                }

                return obj;
            }

7).Introduction应用：允许一个切面声明一个实现指定接口的通知对象，并且提供了一个接口实现类来代表这些对象(不改变类的情况下向一组类中添加行为，通过自定义的接口以及接口实现类的方式来添加，向切面配置中声明）
配置如下：

<aop:declare-parents types-matching="com.spring.java.aop.schema.advice.biz.*(+)" 
                implement-interface="com.spring.java.aop.schema.advice.Fit"
                default-impl="com.spring.java.aop.schema.advice.Filter"/>

8).Advisors:就像一个小的自包含的方面，只有一个advice
切面自身通过一个bean表示，并且必须实现某个advice接口，同时，advisor也可以很好的利用AspectJ的切入点表达式
Spring通过配置文件中元素支持advisor实际使用中，大多数情况下它会和transactional advice配合使用
为了定义一个advisor的优先级以便让advice可以有序，可以使用order属性来定义advisor的顺序
9).Spring AOP API:
前置通知(Before advice) ——- MethodBeforeAdvice

public class KangBeforeAdvice implements MethodBeforeAdvice {

            @Override
            public void before(Method method, Object[] args, Object target) throws Throwable {
                System.out.println("KangBeforeAdvice : " + method.getName() + "    " + target.getClass().getName());
            }
        }

环绕通知(Around Advice)(拦截器)——– MethodInterceptor

public class KangMethodInterceptor implements MethodInterceptor {

            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("KangMethodInterceptor 1: " + invocation.getMethod().getName() + "  "
                    + invocation.getStaticPart().getClass().getName());
                Object  obj = invocation.proceed();
                System.out.println("KangMethodInterceptor 2: " + obj);
                return obj;
            }
        }

返回后通知(After returning advice) ——– AfterReturningAdvice

public class KangAfterReturningAdvice implements AfterReturningAdvice {

            @Override
            public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
                System.out.println("KangAfterReturningAdvice :" + method.getName() + "    "
                                + target.getClass().getName() + "   " + returnValue );
            }
        }

抛出异常后通知(After throwing advice) —— ThrowsAdvice

        public class KangThrowsAdvice implements ThrowsAdvice {

            public void afterThrowing(Exception ex) throws Throwable{
                System.out.println("KangThrowsAdvice afterThrowing 1");
            }
            public void afterThrowing(Method method, Object[]  args, Object target, Exception ex) throws Throwable{
                System.out.println("KangThrowsAdvice afterThrowing 2 : " + method.getName() + "    " + 
                    target.getClass().getName());
            }
        }

xml 配置(使用ProxyFactoryBean代理)如下：
1)设置切入点

            <bean id="bizLogicImplTarget" class="com.spring.java.aop.api.BizlogicImpl"></bean>

            <bean id="pointcutBean" class="org.springframework.aop.support.NameMatchMethodPointcut">
                <property name="mappedNames">
                    <list>
                        <value>sq*</value>
                    </list>
                </property>
            </bean>

            <bean id="defaultAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
                <property name="advice" ref="kangBeforeAdvice"></property>
                <property name="pointcut" ref="pointcutBean"></property>
            </bean>

            <bean id="bizLogicImpl" class="org.springframework.aop.framework.ProxyFactoryBean">
                <property name="target">
                <ref bean="bizLogicImplTarget"/>
                </property>
                <property name="interceptorNames">
                    <list>
                        <value>defaultAdvisor</value>
                        <value>kangAfterReturningAdvice</value>
                        <value>kangMethodInterceptor</value>
                        <value>kangThrowsAdvice</value>
                    </list>
                </property>
            </bean>

2)没有设置切入点


            <bean id="bizLogicImplTarget" class="com.spring.java.aop.api.BizlogicImpl"></bean>

            <bean id="bizLogicImpl" class="org.springframework.aop.framework.ProxyFactoryBean">
                <property name="proxyInterfaces">
                    <value>com.spring.java.aop.api.Bizlogic</value>
                </property>
                <property name="target">
                    <ref bean="bizLogicImplTarget"/>
                </property>
                <property name="interceptorNames">
                    <list>
                        <value>kangBeforeAdvice</value>
                        <value>kangAfterReturningAdvice</value>
                        <value>kangMethodInterceptor</value>
                        <value>kangThrowsAdvice</value>
                    </list>
                </property>
            </bean>
            3)内部定义bean
            <bean id="bizLogicImpl" class="org.springframework.aop.framework.ProxyFactoryBean">
                <property name="proxyInterfaces">
                    <value>com.spring.java.aop.api.Bizlogic</value>
                </property>
                <property name="target">
                    <bean class="com.spring.java.aop.api.BizlogicImpl">
                    </bean>
                </property>
                <property name="interceptorNames">
                    <list>
                        <value>kangBeforeAdvice</value>
                        <value>kangAfterReturningAdvice</value>
                        <value>kangMethodInterceptor</value>
                        <value>kangThrowsAdvice</value>
                    </list>
                </property>
            </bean>
            4)定义抽象bean，
            <bean id="baseProxyBean" class="org.springframework.aop.framework.ProxyFactoryBean"
                lazy-init="true" abstract="true"></bean>

            <bean id="bizLogicImpl" parent="baseProxyBean">
                <property name="proxyInterfaces">
                    <value>com.spring.java.aop.api.Bizlogic</value>
                </property>
                <property name="target">
                    <bean class="com.spring.java.aop.api.BizlogicImpl">
                </bean>
                </property>
                <property name="interceptorNames">
                    <list>
                    <value>kangBeforeAdvice</value>
                    <value>kangAfterReturningAdvice</value>
                    <!-- <value>kangMethodInterceptor</value> -->
                    <value>kang*</value><!-- 拦截器可以用通配符 -->
                    <value>kangThrowsAdvice</value>
                    </list>
                </property>
            </bean>