写在前面：
首先，我们在编程语言学习的时候，了解过C语言是一种面向过程编程，C++,Java是面向对象编程，而AOP则是面向切面编程。
AOP编程概念及步骤：
AOP：Aspect object programming，面向切面编程，是指在运行时期，执行核心业务代码时，通过动态代理或Cglib代理的方式，植入关注点代码。AOP是OOP的延续。
关注点代码：就是指程序中可以复用的代码。
实现AOP编程有两种方式:
(1) 注解方式
（2）XML方式
这篇博客中，我们先来总结一下注解方式实现AOP编程。首先，看一下实现AOP编程的步骤：
（1）在项目中引入AOP相关Jar
（2）在bean.xml中引入AOP名称空间
（3）在bean.xml中开启AOP注解方式
（4）用注解@Aspect指定AOP类为切面类
（3）用注解@Pointcut,指定拦截哪些类的哪些方法
AOP编程实现原理
AOP类，是通过JDK代理或Cglib代理，当拦截到指定类的指定方法时，就会为指定类根据需求创建不同的代理对象。
AOP编程简单案例
下面用一个简单的案例，来实现注解方式的AOP编程
切面类代码：
package aopdemo1;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect // 指定当前类为切面类
public class AOP {
// 指定切入点表达式，拦截当前包的所有类的save方法
@Pointcut("execution(* aopdemo1.*.save(..))")
public void pointcut() {
System.out.println("开始");
}
@Before("pointcut()")
public void begin() {
System.out.println("开始");
}
@After("pointcut()")
public void end() {
System.out.println("结束");
}
}IUserDao接口代码
package aopdemo1;
public interface IUserDao {
public void save();
}UserDao实现类代码
package aopdemo1;
import org.springframework.stereotype.Component;
@Component //加入IOC容器
public class UserDao implements IUserDao{
@Override
public void save() {
System.out.println("-----User:使用AOP------");
}
}另一个StudentDao，但不实现任何接口
package aopdemo1;
import org.springframework.stereotype.Component;
@Component //加入IOC容器
public class StudentDao {
public void save() {
System.out.println("-----Student:使用AOP------");
}
}APP测试类
package aopdemo1;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class APP {
ApplicationContext ac = new ClassPathXmlApplicationContext("aopdemo1/bean.xml");
// 有接口的，使用动态代理
@Test
public void testApp1() {
IUserDao userDao = (IUserDao) ac.getBean("userDao");
userDao.save();
System.out.println(userDao.getClass());
}
// 没有接口的，使用Cglib代理
@Test
public void testApp2() {
StudentDao studentDao = (StudentDao) ac.getBean("studentDao");
studentDao.save();
System.out.println(studentDao.getClass());
}
}bean.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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="aopdemo1"></context:component-scan>
<!-- 开启Aop注解方式 -->
<aop:aspectj-autoproxy proxy-target-class="false"></aop:aspectj-autoproxy>
</beans>程序执行流程说明：
通过IOC创建一个UserDao或者StudentDao的代理对象，并在AOP类中增加了代理对象的功能，并且通过切入点表达式，指定了拦截哪个类的哪个方法，所以在测试类，当代理对象调用save方法时，不仅仅会输出正常的save方法，还会在save方法的前后，输出AOP的一些功能实现。
在APP测试类中有两个测试方法，testApp1的结果为
开始
-----User:使用AOP------
结束
class com.sun.proxy.$Proxy10testApp2的结果为
开始
-----Student:使用AOP------
结束
class aopdemo1.StudentDao$$EnhancerByCGLIB$$1770b917（1）实现接口的Dao类，会使用动态代理
（2）没有实现接口的Dao类，会使用Cglib代理，生成一个StudentDao的子类作为代理对象。
在AOP类中的几种注解
（1）@Aspect :指定为切面类
（2）@Before :前置通知，在执行目标方法之前执行
（3）@After :后置通知，在执行目标方法之后执行
（4）@AfterReturning :在调用目标方法结束后执行
（5）@AfterThrowing :异常通知，当目标方法异常时，执行关注点代码
注意: 当目标方法出现异常的时候，@AfterReturning下的方法，则不会再执行，大家可以自己测试一下。
（6）@Around :环绕通知，在目标方法的前后都执行
（7）@Pointcut :指定为切入点表达式
