什么是aop？

这个命题其实是讲了的，但是之前没有做，发现一些面试会问到，结合自己之前的学习经历。简单把这个问题描述一下。

aop是跟oop相对应的一个概念。分别是aspect oriented programming 和 object oriented programming。也即面向切面编程和面向对象编程。那面向对象是我们一个很熟悉的概念了，【在面向对象之前还有面向过程的编程，这个概念这里面就不厘了】。画个示意图，希望能够阐述这样一个概念。

那么对于前面的就是得到一个对象，或者得到一个完整的过程，直接对他进行操作。【事实上前面儿这个图画的也不理想】

对于后面的图来说，面向的是整个过程的一个剖儿面。

比如说下面的存储过程。

原来的逻辑是 一个数据库的存储操作，现在，我们要在这个 完成的逻辑上面添加一些日志，比如说，在存储之前，我们让日志信息记录说，UserDaoImpl请求添加一条记录到数据库中，在存储操作完成以后，让日志信息再打印一个 UserDaoImpl已经成功添加了一条数据。

对于这个完整过程来说，原来的逻辑是完完全全没有问题的。但是如果在一个大型系统中出了问题，如果在每个地方都有相应的提示信息的话，可以帮助我们快速定位到问题从而顺利解决。所以如果打印到“UserDaoImpl请求添加一条记录到数据库中”，然后报了错，下面那句话没有执行，是不是就很方便可以定位到存储时候出了问题。【这里只是举个例子说明织入也就是aop这个概念。之前dao都没出过问题，加上了切面反而出了问题，那还要这个切面干毛线？这个假设简直不能再糟糕，笑哭】【想到一个可能的逻辑，囧，比如在oracle里面的年龄字段写了check 18 to 60，而在前端的校验只定义成了0-150合理，这样在junit测试里面没有把例子跑全，或者自己只写了一个简单的测试用例比如数字都是23，34，59。导致在集成测试的时候有一个78被放行，这样就有可能出问题，在修改的时候可能回去数据库里面更改check 或者 去js验证里面，更改放行数字。终于圆回来了，反正总之现在的需求就是加一个aop！！！】

好了问题引入完毕，先来扯点儿蛋。

aop的知识点是从代理模式引入的。

那么什么是代理，为什么要代理。代理是怎么一回事儿？

代理分为两种形式，静态代理，动态代理。

假设有一个接口UserDao，【这个包名我就很喜欢】

package com.letben.dao;

/**
 * userdao的 接口
 * @author Administrator
 *
 */
public interface UserDao {
    public void saveUser();
}

还有一个它的实现类UserDaoImpl。

package com.letben.dao;
/**
 * 这个地方用来实现userdao的 真实逻辑
 * @author Administrator
 */
public class UserDaoImpl implements UserDao {
    @Override
    public void saveUser() {
        System.out.println("存储用户到数据库");
    }
}

那原来这两个就能完成存储逻辑。

现在需求改变我们要加一个代理，实现在存储之前之后打印日志。那么新写一个UserDaoStaticProxy

package com.letben.dao;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 * 同样是userdao的一个 实现类，没有更多的业务逻辑。只是为了在 实现逻辑的前后 打印日志
 * @author Administrator
 */
public class UserDaoStaticProxy implements UserDao {
    //得到打印日志的对象,它属于util包
    Logger logger = Logger.getLogger(UserDaoStaticProxy.class.getName());
    UserDao userDao;
    public UserDaoStaticProxy(UserDao userDao){
        this.userDao = userDao;
    }
    @Override
    public void saveUser() {
        logger.log(Level.INFO, "存储用户之前");
        userDao.saveUser();
        logger.log(Level.INFO,"存储用户之后");
    }
}

然后添加一段测试代码：

package com.letben.dao;
public class Test {
    public static void main(String[] args) {
        UserDao userDao = new UserDaoImpl();
        UserDao userDaoApplication = new UserDaoStaticProxy(userDao);
        userDaoApplication.saveUser();
    }
}

运行结果：

二月 15, 2016 9:50:34 上午 com.letben.dao.UserDaoStaticProxy saveUser
信息: 存储用户之前
存储用户到数据库
二月 15, 2016 9:50:35 上午 com.letben.dao.UserDaoStaticProxy saveUser
信息: 存储用户之后

在测试代码中就能够理解是为什么了。我们首先创建了一个UserDaoImpl也就是最开始用来完成存储业务的类。然后又创建了UserDaoImpl来增加日志信息。这样aop的概念，就比较好解释了，就是在这个逻辑不改变的情况下，多那么一点点东西，让整个流程更加清楚、完善。

但是静态代理毕竟可复用性太差，要重新写java代码，这就比较糟糕。

那动态代理的部分，就是利用框架，来实现这样一种需求的嵌入。这还有两种形式，一种是xml的配置形式，还有一种是 注解的形式。

形式一：xml配置形式

创建web工程。

导入jar包。【没有的在下面写邮箱吧，或者小纸条我也行。】

目录结构。

1、那我们其实真正做的就是后来，导入了一些专用的jar包。

2、添加一个切面包。以及文件：AspectDemo.java。

package com.letben.aspect;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 * 切面类
 * @author Administrator
 */
public class AspectDemo {
    Logger log = Logger.getLogger(AspectDemo.class.getName());
    /**
     *  在某断点之前添加通知，我们这里就是 给 添加方法 之前设置的 所以 这个 方法的名字，也是 这么取名的
     */
    public void beforeSaveUser(){
        log.log(Level.INFO, "存储前");
    }
    /**
     * 在saveUser方法 调用之后 执行此方法
     */
    public void afterSaveUser(){
        log.log(Level.INFO,"存储后");
    }
    public void aroundSaveUser(ProceedingJoinPoint point){
        log.log(Level.INFO,"环绕-前");
        try {
            point.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        log.log(Level.INFO,"环绕-后");
    }
    public void exceptionAboutSave(Exception e){
        //在这里并不会有结果，因为 上一个 已经 处理了异常，并且 我们 的存储方法 是正确的 不存在 输入错误 这回事。。所以 为了巩固 我们再写一个 面向切面代理出错版本。
        log.log(Level.WARNING,"出现异常");
    }
}

3、在beans.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"
       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.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

    <!-- 要有 对应 实现逻辑的 userDao -->
    <bean id="userDao" class="com.letben.dao.UserDaoImpl"></bean>

    <!-- 切面类 对应的 实体对象 -->
    <bean id="aspectDemo" class="com.letben.aspect.AspectDemo"></bean>
    <!-- aop的配置 -->
    <aop:config>

        <!-- 选定某一个类为切面 -->
        <aop:aspect ref="aspectDemo">
            <!-- 切入点表达式，就是 我们为了做切入，一定要有一个切入点，用来表示 在某一个地方开始 执行我们的某些程序-->
            <!-- 文档中 6.2.3.4里面的各个 示例 -->
            <!-- 解释：任意的修饰符  【空格】 这个 包下的 这个 方法里面的所有方法(这里面带着所有的参数)-->
            <aop:pointcut expression="execution(* com.letben.dao.UserDao.*(..))" id="point" />

            <!-- 通知类型+插入方法+切入点 =连接点 -->
            <aop:before method="beforeSaveUser" pointcut-ref="point" />
            <!--
                上面这句话有两种书写方式：
                <aop:before method="beforeSaveUser" pointcut="execution(* com.letben.dao.UserDao.*(..))">
                要么直接 写切入点，要么采用引入的方式 写 切入点
             -->
             <aop:after method="afterSaveUser" pointcut-ref="point"/>
             <aop:around method="aroundSaveUser" pointcut-ref="point"></aop:around>

        </aop:aspect>
    </aop:config>
</beans>

这样就完成了动态代理的xml形式的书写。

注解方式：

注解编程里面，配置就比较简单。

jar包还是那些。

beans.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"
       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.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

    <!-- 启动注解编程 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <bean id="userDao" class="com.letben.dao.impl.UserDaoImpl"></bean>

    <!-- 因为 当前注解类 并不需要 给谁使用，所以 直接注册 并不需要 别的什么逻辑 -->
    <bean class="com.letben.aspect.AspectForUserDao"/>

</beans>

切面类：

package com.letben.aspect;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
/**
 * 声明这是一个 注解类
 * @author Administrator
 */
@Aspect
public class AspectForUserDao {
    Logger logger = Logger.getLogger(AspectForUserDao.class.getName());
    /**
     * 前置 方法 里面需要一个 切入点
     */
    @Before("execution(* com.letben.dao.UserDao.*(..))")
    public void test1(){
        logger.log(Level.INFO,"之前");
    }
    /**
     * 在7.0里面 那个 value 不能加上。但是 在 6.0里面这个 参数 是需要的
     * @Around(value="exection(*com.letben.dao.UserDao.*(..))")这是不正确的写法 在7.0里面
     */
    @After("execution(* com.letben.dao.UserDao.*(..))")
    public void test2(){
        logger.log(Level.INFO,"之后");
    }
    /**
     * 不，不是 那个 value 也不知道 是哪里，这个 注解编程 很奇怪，就是 很奇怪。我也不知道 那里 写错了，但是 就是 报了 一些 处理了20min的异常就在这个 写注解的地方
     * @param point
     */
    @Around(value="execution(* com.letben.dao.UserDao.*(..))")
    public void test3(ProceedingJoinPoint point){
        logger.log(Level.INFO,"环绕-前");
        try {
            point.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        logger.log(Level.INFO,"环绕-后");
    }
}

所以动态的代理就是 我们所说的aop也就是织入了一个逻辑。织入这个词，感觉翻译起来还是很贴切的。就是在完整的东西上加进去一些东西，让他更加完美。上面是对日志的织入。

下面有事务的织入。略有不同。

只说修改的地方了，原来的那个工程还是有点儿小。。。

对于事务这样的操作，想来应该是放到service层里面最合适。比如存取钱的操作同时完成。不应该封装到dao层理面，而应该是 服务层理面，但是其实，这样的操作也可在dao里面写，但是框架提供了这样的方式，可以让我们进行事务操作。所以我们来应用一下。

【完整样例代码：欢迎写邮箱，或者小纸条我，主要十几个包里面的十几个类，复制粘贴确实容易让人没有兴趣看下去。但是都是前面儿的一些知识点的总结。】

serviceImpl 里面添加：

/**
     * 事务这样的操作都写在 业务层 而非 持久化层
     */
    public void tryTransaction(){
        UserPo user1 = getUserById(2);
        UserPo user2 = getUserById(3);
        user1.setUserAge(39);
        userDao.updateUser(user1);
        user2.setUserAge(Integer.parseInt("23"));
        userDao.updateUser(user2);
    }

在beans.xml里面新增事务工厂：

    <!-- 事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 事务管理器 管理的是哪一个 数据源 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务的代理工厂 -->
    <bean id="proxyFactoryBean" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <!-- 给事务代理工厂一个 事务管理器  -->
        <property name="transactionManager" ref="transactionManager"></property>
        <!-- 告诉代理工厂 的代理权限——要管理那些接口 -->
        <property name="proxyInterfaces">
            <list><!-- 列表给值 底层 list和 set 是一个 类型的 -->
                <value>com.letben.service.UserService</value>
            </list>
        </property>
        <!-- 告诉代理工厂要管理的 实现类 -->
        <property name="target" ref="UserService"></property>
        <!-- 告诉事务管理器 要管理的规则 和方法 -->
        <property name="transactionAttributes">
            <props><!-- 参数给值  底层 props 和 map 是一个类型的 -->
                <!-- 下面这个 key对应的是实现类里面的方法。符合通配符的使用规则* -->
                <prop key="tryTransaction">PROPAGATION_REQUIRED</prop><!-- 需要传播 -->
            </props>
        </property>
    </bean>    

这样就完成了 带有工厂的新增事务的配置方式。

当然还有两种。一种是不使用事务工厂的方式，还有一种是自动代理的方式。

当然这种织入不仅有日志的添加，事务的处理，还包括权限的检查等等多个方面。所谓切面编程就是在不影响原来事情处理逻辑的基础上，添加内容，让这个流程变得更加完善合情理合逻辑。