AOP的简单练习

---恢复内容开始---

1、AOP的主要作用及概念简介

　　AOP最大的用处在于事务处理上，业务层在项目中主要负责以下的操作：

　　　　·调用数据层进行处理；

　　　　·进行事务的处理；

　　　　·关闭数据库的连接操作；

　　但在实际操作中，往往还要进行日志处理，事务提交等等辅助性操作，此时aop就派上用场。一个优秀的代理模式是将不同的切入点代码单独定义，而后组织在一个程序网上。AOP就在spring中充当了这样一个角色。

　　AOP有以下几个概念：

　　　　·切入点：可以理解为所有要操作的方法定义。要求业务层的方法必须统一风格。

　　　　·分离点：将那些不可再分的组件单独提取出去定义为单独的操作功能；

　　　　·横切关注点：将所有与开发无关的程序组成类单独提取而后组织运行；

　　　　·植入：将所有的切入点、关注点的代码组成在一张完整的程序结构中。

　　在Spring中采用通知的形式完成，即当触发到了某些操作之后自然地进行一些固定的操作。在整个SpringAOP中包含有以下几类通知形式：

　　　　·前置通知：在某一操作执行之前处理。

　　　　·后置通知：在某一操作执行之后处理，但后置通知有以下几种子通知：

　　　　　　|-后置返回通知：负责处理返回结果的时候进行拦截；

　　　　　　|-后置异常通知：当出现异常后进行拦截；

　　　　　　|-后置最终通知：执行到最后无论如何都会进行拦截；

　　　　·环绕通知：具有以上通知到特点。（功能最强大）

2、AOP的简单练习

　　(1) 简单地构建Spring环境

　　　　1⃣️、定义IMemberService.java:

 package cn.ckw.IService;

 import cn.ckw.vo.Member;

 public interface IMemberService {
     boolean insert(Member vo);
 }

IMemberService.java

　　　　2⃣️、定义Membe.java

 package cn.ckw.vo;

 public class Member {
     private String name;
     private String id;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getId() {
         return id;
     }
     public void setId(String id) {
         this.id = id;
     }
     @Override
     public String toString() {
         return "Member [name=" + name + ", id=" + id + "]";
     }

 }

Member

　　　　3⃣️、定义MemberServiceImpl.java

 package cn.ckw.serviceImpl;

 import org.springframework.stereotype.Service;

 import cn.ckw.IService.IMemberService;
 import cn.ckw.vo.Member;
 @Service
 public class MemberServiceImpl implements IMemberService{
     @Override
     public boolean insert(Member vo) {
         //throw new NullPointerException("this is a exception");
         System.out.println("这是业务层的调用");
         return true;
     }

 }

MemberServiceImpl

　　　　以上模拟了业务实现，随后要加入的辅助性操作，都是通过Spring容器的配置完成。

　　　　首先要在application.xml.文件中加入annotation支持,加入时不要忘记检查命名空间是否已经被引入：

 <?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:p="http://www.springframework.org/schema/p"
 4     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 8     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-2.5.xsd">
12     <context:annotation-config />
13     <context:component-scan base-package="cn.ckw" />
 </beans>

　　　　然后要在3⃣️中类名的上一行加入注解@service，接着建立测试类：

 package cn.ckw.test;

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

 import cn.ckw.IService.IMemberService;
 import cn.ckw.vo.Member;

 public class Test {
     public static void main(String[] args) {
         ApplicationContext ctx = new ClassPathXmlApplicationContext(
                 "applicationContext.xml");
         IMemberService ser=ctx.getBean("memberServiceImpl",IMemberService.class);
         Member vo=new Member();
         vo.setId("001");
         vo.setName("ckw");
         System.out.println(ser.insert(vo));
     }
 }

Test

 　　(2) 在(1)的基础上加入切面

　　　　4⃣️、定义切面方法类ServiceAspect.java:

 package cn.ckw.aspect;

 import org.springframework.stereotype.Component;

 @Component
 public class ServiceAspect {
     public void serviceBefore(){
         System.out.println("在操作之前调用");
     }
     public void serviceBefore2(Object arg){
         System.out.println("在操作之前调用,传入的参数是："+arg);
     }
     public void serviceAfterReturning(Object arg){
         System.out.println("在操作之后调用,返回值是："+arg);
     }
     public void serviceAfter(){
         System.out.println("在操作之后调用");
     }
 }

ServiceAspect.java

　　　　之后要在application.xml中加入配置,黄色为引用的命名空间，红色部分为定义的切入点，表达式为AspectJ包所定义的表达式（可以深入时再去探索）。蓝色部分必须相同，表示切面函数关联到哪个切入点，可以是引用已经定义的pointcut(切入点)，也可以重新定义新的切入点：

<?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:p="http://www.springframework.org/schema/p"
     xmlns:context="http://www.springframework.org/schema/context"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
     <context:annotation-config />
     <context:component-scan base-package="cn.ckw" />
     <aop:config>
         <!--首先定义程序的切入点-->
         <aop:pointcut expression="execution(* cn.ckw..*.*(..))"
             id="pointcut" />
        <!--指定切入点的切入函数-->
         <aop:aspect ref="serviceAspect">
             <aop:before method="serviceBefore" pointcut-ref="pointcut"/>
             <aop:after method="serviceAfter" pointcut="execution(* cn.ckw..*.*(..))" />
         </aop:aspect>
     </aop:config>
 </beans> 

　　(3) 加入可传参数的切面函数

　　　　在4⃣️类中加入以下方法的定义：

public void serviceBefore2(Object arg){ System.out.println("在操作之前调用,传入的参数是："+arg); }

　　　　在xml中定义此方法，红色标记点为与（2）比较的改变的地方：

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-2.5.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
    <context:annotation-config />
    <context:component-scan base-package="cn.ckw" />
    <aop:config>
        <aop:pointcut expression="execution(* cn.ckw..*.*(..)) and args(vo)"
            id="pointcut" />
        <aop:aspect ref="serviceAspect">
            <aop:before method="serviceBefore" pointcut-ref="pointcut"
                arg-names="vo" />
            <aop:after method="serviceAfter" pointcut="execution(* cn.ckw..*.*(..))" />
        </aop:aspect>
    </aop:config>
</beans>

　　(4)加入可返回的切面函数 

　　　　在4⃣️类中加入以下方法的定义，其中arg为返回值：

public void serviceAfterReturning(Object arg){ System.out.println("在操作之后调用,返回值是："+arg); }

　　　　在xml配置文件中的<aop:config>下添加，其中returning属性和arg-names属性只是起到标示作用，但两个要相同：

<aop:after-returning method="serviceAfterReturning" pointcut="execution(* cn.ckw..*.*(..))" returning="ret" arg-names="ret" />

 　（5）异常拦截处理

　　　　在业务层中抛一个异常出来，比如在3⃣️类中的insert函数中抛出一个异常：

public boolean insert(Member vo) { throw new NullPointerException("throw exception"); }

　　　　在类4⃣️中加入以下方法：

public void serviceAfterThrowing(Exception exp){
  System.out.println(exp);
}

　　　　在xml中写入如下配置：

<aop:after-throwing method="serviceAfterThrowing" pointcut="execution(* cn.ckw..*.*(..))" arg-names="abc" throwing="abc"/>

　　(6)环绕拦截

　　　　在4⃣️类中加入以下方法，环绕不仅可以拦截，甚至可以对传入参数和返回结果进行控制：

     public Object serviceAround(ProceedingJoinPoint point) throws Throwable {
         System.out.println("方法调用之前，返回值是："+Arrays.toString(point.getArgs()));
         Member vo=new Member();
         vo.setId("002");
         vo.setName("ckw2");
         Object retVal=point.proceed(new Object[]{vo});//执行业务代码
         System.out.println("在操作之后调用，返回值是--："+retVal);
         return true;//真正的返回值
     }

　　　　同样的，要在xml中配置内容后，执行测试代码：

<aop:around method="serviceAround" pointcut="execution(* cn.ckw..*.*(..))"/>

　　学习AOP的读者，建议先将代理设计模式理解透彻。

　　(7)利用Annotation配置AOP

　　　　在xml之中加入AOP的annotation支持：

 <?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:p="http://www.springframework.org/schema/p"
     xmlns:context="http://www.springframework.org/schema/context"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context-2.5.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
     <context:annotation-config />
     <context:component-scan base-package="cn.ckw" />
     <!--<aop:config>
         <aop:pointcut expression="execution(* cn.ckw..*.*(..)) and args(vo)"
             id="pointcut" />
         <aop:aspect ref="serviceAspect">
              <aop:before method="serviceBefore2" pointcut-ref="pointcut"
                 arg-names="vo" />
             <aop:after method="serviceAfter" pointcut="execution(* cn.ckw..*.*(..))" />
             <aop:after-returning method="serviceAfterReturning"
                 pointcut="execution(* cn.ckw..*.*(..))" returning="ret" arg-names="ret" />
             <aop:around method="serviceAround" pointcut="execution(* cn.ckw..*.*(..))"/>
         </aop:aspect>
     </aop:config>-->
     <aop:aspectj-autoproxy/>
 </beans>

　　　　修改ServiceAspect类：

 package cn.ckw.aspect;

 import java.util.Arrays;

 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.AfterReturning;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
 import org.springframework.stereotype.Component;

 import cn.ckw.vo.Member;

 @Component
 @Aspect
 public class ServiceAspect {
     @Before(value="execution(* cn.ckw..*.*(..))")
     public void serviceBefore(){
         System.out.println("在操作之前调用");
     }
     @Before(value="execution(* cn.ckw..*.*(..)) and args(vo)")
     public void serviceBefore2(Object arg){
         System.out.println("在操作之前调用,传入的参数是："+arg);
     }
     @AfterReturning(value="execution(* cn.ckw..*.*(..))", argNames="ret" ,returning="ret")
     public void serviceAfterReturning(Object arg){
         System.out.println("在操作之后调用,返回值是："+arg);
     }
     @Around(value="execution(* cn.ckw..*.*(..))")
     public Object serviceAround(ProceedingJoinPoint point) throws Throwable {
         System.out.println("方法调用之前，返回值是："+Arrays.toString(point.getArgs()));
         Member vo=new Member();
         vo.setId("002");
         vo.setName("ckw2");
         Object retVal=point.proceed(new Object[]{vo});//执行业务代码
         System.out.println("在操作之后调用，返回值是--："+retVal);
         return true;//真正的返回值
     }
     public void serviceAfter(){
         System.out.println("在操作之后调用");
     }
 }

-------转载请说明出处----------

---恢复内容结束---