动态代理和AOP人（面向切面编程）

1.什么是动态代理

1）动态代理就是利用JDK的API动态的在内存中构建代理对象，因此，动态代理也叫做JDK代理，或者接口代理，在动态代理中，代理对象不需要实现接口，但是被代理对象还是需要实现对象的。

2）动态代理就是通过使用反射，动态地获取抽象接口的类型，从而获取相关特性进行代理

举例：张杰开演唱会，我抢不到门票，可以找黄牛排队买票。（黄牛可以帮我买票但是不能替我去看）我不一定能抢到，但是黄牛可以。

2.动态代理的三个要点

1）必须实现 InvocationHandler 接口，表明该类是一个动态代理执行类。

2）InvocationHandler 接口内有一实现方法如下： public Object invoke(Object proxy, Method method, Object[] args) 。使用时需要重写这个方法

3）获取代理类，需要使用 Proxy.newProxyInstance(Clas loader, Class[] interfaces, InvocationHandler h) 这个方法去获取Proxy对象（Proxy 类类型的实例）。

3.为什么要进行动态代理

没代理之前，在某个类中，他的事务控制，权限判断，日志记录等操作需要进行n次重复，进行动态代理以后只需要在xml中书写一次即可。

没用之前

 使用之后

1）因为Proxy类必须基于接口进行动态代理，所以首先创建接口，定义接口的规范，即功能方法的定义。

2）定义实现接口的子类，实现接口定义的方法，此方法只需要把核心功能实现即可，其他增强的操作可以在代理类中实现。

3）定义代理类，在代理类中对被代理对象进行方法增强。

AOP

4.什么是AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方
式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个
热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑
的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高
了开发的效率。

5.AOP的相关术语

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

6.AOP基于XML配置的入门案例

1）导包

2）创建BookService类，这个类完成核心功能操作 

package com.gao.service.impl;

import com.gao.service.BookService;

public class BookServiceImpl implements BookService {
    @Override
    public void read() {

        System.out.println("好好学习天天向上");
    }

    @Override
    public void lision() {

        System.out.println("天天向上好好学习");
    }

    @Override
    public void write() {
        System.out.println("好好学习天天向上");
    }

    @Override
    public void renumber() {
        System.out.println("好好学习天天向上");
    }
}

3）创建Student类，这个类是用来做功能的增强。

package com.gao.advice;

public class Student {
    public void before(){
        System.out.println("前置通知。。。。。before");
    }

    public void afterReturn(){
        System.out.println("后置通知。。。。。afterReturn");
    }
    public void afterThrow(){
        System.out.println("异常通知。。。。。afterThrow");
    }
    public void after(){
        System.out.println("最终通知。。。。。after");
    }
}

4）在spring.xml中开始进行AOP的配置

• 首先把核心类和增强类的bean配置到IOC的容器中
• 使用<aop:config>标签在进行AOP的配置，先通过aop:aspect标签标明谁是增强类。然后在标签中进行aop:before（前置）、aop:after-returning（后置）、aop:after-throwing（异常）、aop:after（最终）的配置，让增强类的某个方法对核心功能类的某一类方法进行功能增强。

<?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.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">

    <!--1.把所有类的对象交给IOC容器进行管理-->
    <bean id="student" class="com.gao.advice.Student"></bean>
    <bean id="bookService" class="com.gao.service.impl.BookServiceImpl"></bean>
    <!--2.AOP的配置-->
    <aop:config>
        <!--：让增强类 的 哪个方法  动态进行何种增强   核心类 的 哪个方法-->
        <aop:aspect>
            <aop:before method="before" pointcut="execution(* *..BooService.*(..))"/>
            <aop:before method="afterReturn" pointcut="execution(* *..BooService.*(..))"/>
            <aop:before method="afterThrow" pointcut="execution(* *..BooService.*(..))"/>
            <aop:before method="after" pointcut="execution(* *..BooService.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

5）在测试类中测试BookService的方法是否被增强。

package com.gao.servlet;

import com.gao.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestServlet {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        BookService bookService = context.getBean(BookService.class);

        bookService.read();
        System.out.println("我是分割线~~~~~~~~~");
        bookService.lision();
        System.out.println("我是分割线~~~~~~~~~");
        bookService.renumber();
        System.out.println("我是分割线~~~~~~~~~");
        bookService.write();
    }
}

结果