一、什么是AOP

1、什么是AOP

• 面向切面（方面）编程，利用AOP可以对业务逻辑的各部分进行隔离，降低耦合度，提高可重用性。
• 不通过修改源码的方式，在主干功能里面添加新功能

2、AOP中的术语

• 连接点：类里面哪些方法可以被增强，这些方法称之为连接点
• 入点：实际被真正增强的方法，称为切入点
• 通知（增强）：实际增强的逻辑部分，称为通知；通知有多种类型（前置通知、后置通知、环绕通知、异常通知、最终通知）
• 切面：把通知应用到切入点的过程

二、AOP底层原理

AOP的底层使用的是动态代理，其中分为有接口和无接口两种情况

• 第一种：有接口情况，使用JDK动态代理
  方法：创建接口实现类代理对象，增强类的方法

动态代理：有接口（伪代码）
interface　UserDao｛public　void　login（）；
｝
class　UserDaoImpl　implement　UserDao｛public　void　login（）｛／／登录实现过程｝
｝
JDK动态代理：
1、创建USerDao接口实现类代理对象

• 第二种：无接口，使用CGLIB动态代理
  方法：创建子类的代理对象，增强类的方法

动态代理：没有接口（伪代码）
class User{public void add(){====}
}
子类：（原始方法）
class Person extends User{public void add(){super.add();//增强逻辑}
}
CGLIB动态代理：
1、创建当前类子类的代理对象   【代理对象】和子类的增强功能一样

三、JDK动态代理

1、使用JDK的动态代理，使用Proxy类里面的方法创建代理对象
（1）调用newProxyInstance方法

Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), JDKProxy.class..getInterfaces(), new InvocationHandler()

• 第一个参数：类加载器
• 第二个参数：增强方法所在的类，这个类的接口（支持多个接口）
• 第三个参数：实现接口InvocationHandler，创建代理对象，写增强的方法

2、编写JDK动态代理代码
（1）、创建UserDao接口，第一几个方法

public interface UserDao {public int add(int a,int b);public String update(String id);
}

（2）、创建UserDao接口的实现类，并实现接口中的方法

public class UserDaoImpl implements UserDao {@Overridepublic int add(int a, int b) {return a+b;}@Overridepublic String update(String id) {return id;}
}

（3）、在测试方法中，使用Proxy类创建接口代理对象
注意：在以下代码中InvocationHandler的实现原本为匿名内部类，在编写的过程中，为了方便方法的实现，将类的方法提出来，进行重写

public class JDKProxy {public static void main(String[] args) {//创建接口实现类代理对象Class[] interfaces={UserDao.class};UserDaoImpl userDao=new UserDaoImpl();UserDao dao=(UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));int result=dao.add(2, 3);System.out.println("result"+result);}
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{//1、把创建是谁的代理对象，把谁传递过来//有参数构造传递private Object obj;public UserDaoProxy(Object obj){this.obj=obj;}//写增强的部分的逻辑@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//方法之前System.out.println("方法执行之前==="+method.getName()+":传递的参数"+ Arrays.toString(args));//被增强的方法执行Object res=method.invoke(obj,args);//方法之后System.out.println("方法执行之后==="+obj);return res;}
}测试结果：
方法执行之前===add:传递的参数[2, 3]
方法执行之后===com.study.user.UserDaoImpl@5d099f62
result：5

四、Aspect J注解

（一）、概念介绍
1、Aspect J是什么
AspectJ不是Spring的组成部分，是独立的AOP框架，一般把Aspect J和Spring框架一起使用，进行AOP操作

2、切入点表达式
（1）、切入点表达式的作用，知道对哪一个类中的哪些方法进行增强
（2）、语法结构

execution（［权限修饰符（一般用＊表示）］［返回类型（可不写）］［类全路径］［方法名称］［参数列表（用．．表示）］）例1：对ｃｏｍ．ｓｔｕｄｙ．ｕｓｅｒ．ＵｓｅｒＤａｏ类里面的ａｄｄ方法进行增强
execution（＊　com．study．user．UserDao．add（．．））例2：对类中的所有方法进行增强
execution（＊　com．study．user．UserDao．＊（．．））例3：对包中所有类的所有方法进行增强
execution（＊　com．study．user．＊．＊（．．））

（二）、实际代码说明

• 第一步，编写两个类：User类（被增强的类），UserProxy类（增强的类）
• 第二步，使用@Conponent注解创建User和UserProxy对象
• 第三步，在Spring的配置文件中开启注解扫描
• 第四步，在增强类（UserProxy类）上添加@Aspect注解
• 第五步，在Spring配置文件中开启生成代理对象
• 第六步，在增强的类中，在通知方法上面添加注解，使用切入点表达式配置
• 第七步，编写测试程序进行测试

配置完成之后的代码：

//被增强的类
@Component
public class User {public void add(){System.out.println("User add......");}
}//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {//前置通知//@Before注解表示作为前置通知@Before(value = "execution(* com.study.user.aopanno.User.add(..))")public void before(){System.out.println("before....");}//最终通知@After(value = "execution(* com.study.user.aopanno.User.add(..))")public void after(){System.out.println("after......");}//后置通知或返回通知@AfterReturning(value = "execution(* com.study.user.aopanno.User.add(..))")public void afterReturning(){System.out.println("afterReturning......");}//异常通知@AfterThrowing(value = "execution(* com.study.user.aopanno.User.add(..))")public void afterThrowing(){System.out.println("afterThrowing......");}//环绕通知@Around(value = "execution(* com.study.user.aopanno.User.add(..))")public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{System.out.println("环绕之前====");//被增强的方法执行proceedingJoinPoint.proceed();System.out.println("环绕之后====");}
}

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: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.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"><!--<开启注解扫描>--><context:component-scan base-package="com.study.user.aopanno"></context:component-scan><!--<开启AspectJ，生成代理对象>--><aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

注意1：在代码中，有很多公共重叠的代码，可以进行抽取，提高代码的易读性。示例如下：

//抽取相同的切入点
@Pointcut(value = "execution(* com.study.user.aopanno.User.add())")
public void pointCut(){
}
//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointCut()")
public void before(){System.out.println("before....");
}

**注意2：**在上面的代码中，我使用的是一个增强类和一个被增强类，但在实际开发中，当出现多个增强类对同一个方法进行增强时，可以设立优先级；使用@Order注解，值越小，优先级越高。示例如下：

@Component
@Aspect
@Order(0)　　 //从０开始，设置优先级
public class PersonProxy {//前置通知@Before(value = "execution(* com.study.user.aopanno.User.add(..))")public void Before(){System.out.println("Person Before====");}
}

注意3：当使用完全注解开发时，使用配置类，替代配置文件：

@Configuration
@ComponentScan(basePackages = {"com.study.user"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigXml {
}

（三）、将上面的用注解增强改为使用配置文件增强的方式

• 第一步，创建两个类，增强类和被增强类
• 第二步，在Spring配置文件中创建者两个类
• 第三步，在Spring配置文件中配置切入点，然后进行增强
• 第四步，编写测试程序进行测试

创建的增强类和被增强类：

／／被增强类
public class Book {public void buy(){System.out.println("buy......");}
}
／／增强类
public class BookProxy {public void before(){System.out.println("before......");}
}

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: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.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">--<创建对象>--><bean id="book" class="com.study.user.aopXml.Book"></bean><bean id="bookProxy" class="com.study.user.aopXml.BookProxy"></bean>  <!--配置aop增强--><aop:config><!--切入点--><aop:pointcut id="p" expression="execution(* com.study.user.aopXml.Book.buy())"/><!--配置切面--><aop:aspect ref="bookProxy"><aop:before method="before" pointcut-ref="p"/></aop:aspect>
</aop:config>  
</beans>

测试程序：

@Test
public void testAopXml(){ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");Book book=context.getBean("book",Book.class);book.buy();
}
测试结果：（before在ｂｕｙ方法之前执行，表示配置成功）
before......
buy......

通过比较注解和配置文件的两种增强方式，其中使用注解的方式较为简洁，也容易理解，建议在使用AOP的时候使用注解方式进行方法的增强。