重新学习之spring第二个程序，配置AOP面向切面编程

第一步：在配置好的ioc容器的基础上，导入面向切面编程所需要的jar包

(本案例用的是spring3.2.4，由于spring3.2.4的官网jar包中不再有依赖包，所以依赖包都是从网上找的)

第二步：配置applicationContext.xml（包括ioc对象配置，以及面向切面编程的相关配置）

<?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"
        xmlns:tx="http://www.springframework.org/schema/tx"
        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
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    
    <!-- 
        lazy-init:true 懒加载，初始ioc化容器的时候，不建立对象
        lazy-init:false(默认) 不懒加载，初始化ioc容器的时候，就讲applicationContext.XML中所有配置的类的对象创建，并建立关系
        scope:prototype每次取对应id的类的对象，都新创建一个
        scope:singleton（默认）类似于单例模式，只要容器初始化一个类对象，以后所有的取用，都是取这一个
      -->
      
      <!-- 通过setter方法，依赖注入对象。控制反转 -->
    <bean id="userDao" class="com.bjsxt.shang.dao.UserDao" lazy-init="default" scope="singleton"></bean>
    <bean id="MyAction" class="com.bjsxt.shang.action.MyAction" lazy-init="default" scope="prototype">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    
    <!-- 定义一个切面（连接点，切入点，通知） -->
    <bean id="log" class="com.bjsxt.shang.aop.LogTextAop"></bean>
    <aop:config >
        <!-- 切入点，将dao包下所有有参数或无参数传入的，有返回值或无返回值类型的公共方法，进行代理。 -->
        <aop:pointcut expression="execution(public * com.bjsxt.shang.dao.*.*(..))" id="logCut"/>
        <aop:pointcut expression="execution(public String com.bjsxt.shang.dao.*.*(..))" id="logCut2"/>
        <aop:pointcut expression="execution(public * com.bjsxt.shang.dao.*.find*(..))" id="logCut3"/>
        <!-- 通知，也就是代理对象中增强功能代码的编写 -->
        <aop:aspect ref="log">
            <!-- 代理，是为了抽出一些通用需求的功能，因此该属性指定的代理时调用增强功能的方法 -->
            <!-- 连接点执行前或后，执行通用的代码 -->
            <aop:before method="beforeRun1" pointcut-ref="logCut"/>
            <aop:after method="afterRun2" pointcut-ref="logCut2"/>
            <!-- 环绕通知，有参数的传递，可对参数传递进行处理 -->
            <aop:around method="aroundRun" pointcut-ref="logCut3"/>
        </aop:aspect>
    </aop:config>
    
    
    
</beans>

第三步：在appliactionContext.xml中指定的面向切面编程的代理切面类。

package com.bjsxt.shang.aop;

import java.util.Date;

import org.aspectj.lang.ProceedingJoinPoint;

import com.alibaba.fastjson.JSONObject;
/**
 * 面向切面编程，是对一个集合的方法（切入点切中的符合表达式的所有方法）进行代理，也就是说在执行这些集合中的方法时，会执行该代理切面类中的相关指定方法，做到日志记录，增强功能，等等效果。
 * 而且属于热插拔式的。像usb一样，可去掉，可插入。而不影响项目的主要功能
* @ClassName: LogTextAop 
* @Description: TODO(这里用一句话描述这个类的作用) 
* @author 尚晓飞
* @date 2014-8-29 下午2:55:38 
*
 */
public class LogTextAop {
    /**
     * 连接点（方法）执行前执行该方法
    * @Title: beforeRun1 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @return void    返回类型 
    * @author 尚晓飞
    * @date 2014-8-29 上午11:08:41
     */
    public void beforeRun1(){
        System.out.println("LogTextAop.beforeRun1()连接点执行前，我执行了该方法。aop-----前---------");
    }
    /**
     * 连接点（方法）执行后执行该方法
    * @Title: afterRun2 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @return void    返回类型 
    * @author 尚晓飞
    * @date 2014-8-29 下午1:47:40
     */
    public void afterRun2(){
        System.out.println("LogTextAop.afterRun2()连接点执行后，我执行了该方法、aop-----后--------");
    }
    
    /**
     * 连接点（方法）执行前后都会执行的方法
    * @Title: aroundRun 
    * @Description: TODO(这里用一句话描述这个方法的作用) 
    * @param pjp
    * @return
    * @return Object    返回类型 
    * @author 尚晓飞
    * @date 2014-8-29 下午2:05:39
     */
    public Object aroundRun(ProceedingJoinPoint pjp){
        //获取委托类方法传入的参数
        Object[] objs=pjp.getArgs();
        //获取委托类方法的名字
        String methdoName=pjp.getSignature().getName();
        //获取委托类的一个对象
        Object object=pjp.getTarget();
        
        //生成一个jsonobject对象
        JSONObject jsonObject=new JSONObject();
        
        try {
                if(!methdoName.startsWith("find")){
                    System.out.println("LogTextAop.aroundRun(连接点执行前执行----aop-around---前)");
                        Object obj=pjp.proceed();
                    System.out.println("LogTextAop.aroundRun(连接点执行后执行----aop-around---后)");
                    return obj;
                
                }else{
                    System.out.println("LogTextAop.aroundRun(连接点执行前执行----aoparound---前)");
                    System.out.println("LogTextAop.aroundRun(操作时间)"+new Date().toLocaleString());
                    System.out.println("LogTextAop.aroundRun(操作类型)"+methdoName);
                    System.out.println("LogTextAop.aroundRun(操作内容)"+jsonObject.toJSONString(objs));
                    Object obj=pjp.proceed();
                    System.out.println("LogTextAop.aroundRun(连接点执行后----aoparound----后)");
                    return obj;
                }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return null;
    }

}

第四步：测试面向切面编程的demo（省去了action,dao包下的类的源代码）

package com.bjsxt.shang.test;

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

import com.bjsxt.shang.action.MyAction;
import com.bjsxt.shang.dao.UserDao;

public class Test {
    public static void main(String[] args) {
        
        
    
                //官方推荐，建立xml文件，配置程序中对象，和建立对象间关系的是applicationContext.xml
                //平民版的xml是 beans.xml controller.xml dao.xml service.xml
                //获取解析，并依赖注入applicationContext.XML文件的ioc容器
                //ApplicationContext acIoc=new ClassPathXmlApplicationContext("applicationContext.xml");
                ApplicationContext ioc=new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
            
                
                //获取所有的ioc容器
                //BeanFactory是所有Spring Ioc容器的父接口
                //BeanFactory beanFactory=new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});
                
                UserDao dao=(UserDao)ioc.getBean("userDao");
                UserDao dao1=(UserDao) ioc.getBean("userDao");
                //测试IOC容器中生成的对象是不是单例的。
                System.out.println(dao==dao1);
                
                MyAction userAction=(MyAction) ioc.getBean("MyAction");
                //userAction.add();
                //userAction.lang();
                userAction.ds();
    }

}

测试截图

AOP介绍
   Aspect Oriented Programing 面向切面编程
　　　　（1）如果说面向对象编程是关注将需求功能划分为不同的并且相对独立，封装良好的类，并让它们有着属于自己的行为，依靠继承和多态等来定义彼此的关系的话；
　　　　（2）面向方面编程则是希望能够将通用需求功能从不相关的类当中分离出来，能够使得很多类共享一个行为，一旦发生变化，不必修改很多类，而只需要修改这个行为即 可。
  AOP主要应用于日志记录，性能统计，安全控制,事务处理等方面。
　　　　　（1）前面我们讲的struts2中的拦截器，就是AOP的一种实现！

AOP的内部实现都是通过动态代理来实现。动态代理有两种常见的方式：
　　1.    JDK提供的代理生成方式(Proxy,  InvocationHandle)
　　2.    cglib 类库(spring和hibernate使用它)

AOP基本概念
}    连接点（Joinpoint）
◦     在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。 在Spring AOP中，一个连接点 总是 代表一个方法的执行。
}    切入点（Pointcut）
◦    匹配连接点（Joinpoint）的断言（是一种连接点的条件，判断特征）。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
　　　　-->public void com.bjsxt.dao.userDao.*.*()
      　　　　　　  :所有userDao包下的无返回值，无参数传入的，公共方法
　　　　-->public *()
     　　　　　　   ：所有的公共方法
　　　　-->public void com.bjsxt.dao.userDao.*.(..)
       　　　　　　 ：所有userDao包下的有参传入的无返回值的，公共的方法。
}    通知（Advice）
◦    在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。
增强功能的代码编写区 。如日志记录，访问控制，增强功能。
}    切面（Aspect）
◦    一个关注点的模块化，这个关注点可能会横切多个对象。
包含了：连接点、切入点、通知。可以通过@Aspect定义为一个类
}    目标对象（Target Object）
     说白话就是----》委托类
◦    被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做被通知（advised） 对象。
}    织入（Weaving）
        制作代理类，和代理对象的过程
◦    把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。

通知的类型
}    前置通知（Before advice）
◦    在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。
}    返回后通知（After returning advice）
◦    在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
}    抛出异常后通知（After throwing advice）
◦    在方法抛出异常退出时执行的通知。
}    后通知（After （finally）advice）
◦    当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
}    环绕通知（Around Advice）
◦    包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。