Spring框架(AOP篇)

AOP基本概念

1.什么是AOP

（1）面向切面的编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑的各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

例子：在登录功能的基础上添加功能

*权限判断

*原始方式：修改源代码实现

*不通过修改源代码方式添加新的功能实现

*权限判断模块

通俗的讲就是不通过修改源代码的方式，在主干功能里面添加新的功能。

AOP（底层原理）

1.AOP底层使用动态代理

（1）有两种情况的动态代理

第一种：有接口的情况，使用Jdk动态代理

*创建接口实现类的代理对象，增强类的方法

第二种：没有接口的情况，使用CGLIB动态代理

*创建子类的代理对象，增强类的方法

AOP（JDK动态代理）

1.使用JDK动态代理，使用Proxy类里面的方法创建代理对象

（1）调用newProxyInstrance方法

方法有三个参数：

第一个：类加载器

第二个：增强方法所在的类，这个类实现的接口，支持多个接口

第三个：实现这个接口InvocationHandler,创建代理对象，写增强的方法

2.JDK动态代理代码

（1）创建接口，定义方法

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

（2）创建接口的实现类

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

(3) 使用Proxy类创建接口代理对象

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());
        int add = dao.add(1, 2);
        System.out.println(add);
    }
}
//创建代理对象代码
class userDaoProxy implements InvocationHandler{
    //1.把创建的是谁的代理对象，把谁传递过来
    //有参构造传递
    private  Object obj;
    public userDaoProxy(){
        this.obj = obj;
    }
    //增强逻辑
    @Override
    public 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;
    }
}

AOP（术语）

1.连接点

类里面的哪些方法可以被增强，这些方法称为连接点

2.切入点

实际被真正增强的方法，称为切入点

3.通知（增强）

（1）实际上增强的逻辑部分称为通知

（2）通知有多种类型

*前置通知

*后置通知

*环绕通知

*异常通知

*最终通知

4.切面

是动作

（1）把通知应用到切入点的过程

AOP操作(准备)

1.Spring框架一般都是基于AspectJ实现的Aop操作

（1）什么是AspectJ

*AspectJ不是Spring组成部分，独立于Aop框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

2.基于AspectJ实现AOP操作

（1）基于xml方式

（2）基于注解方式（常使用）

3.在项目的工程里引入Aop依赖

4.切入点表达式

（1）切入点表达式的作用：知道对那个类里面的那个方法进行增强

（2）语法结构：

execution([权限修饰符][返回值类型][简单类名/全类名][方法名]([参数列表]))

execution (* cn.hlbrc.biz..*.*(..))

AOP操作（AspectJ注解）

1.创建类，在类里面定义方法

public class User {
    public void add(){
        System.out.println("add......");
    }
}

2.创建增强类（编写增强逻辑）

（1）在增强的类里面，创建方法，让不同的方法代表不同的通知类型

/**
 * 增强的类
 */
public class UserPorxy {
    //前置通知
    public void before(){
        System.out.println("before.......");
    }
​
}

3.进行通知的配置

（1）在Spring配置文件中，开启注解扫描

<!--        开启注解扫描-->
    <context:component-scan base-package="com.spring.aop"></context:component-scan>

（2）使用注解创建User和UserProxy对象

@Component
public class User {
    public void add(){
        System.out.println("add......");
    }
}

@Component
public class UserPorxy {
    //前置通知
    public void before(){
        System.out.println("before.......");
    }
​
}

（3）在增强类上面添加注解@Aspect

@Component
@Aspect  //生成代理对象
public class UserPorxy {
    //前置通知
    public void before(){
        System.out.println("before.......");
    }
​
}

（4）在Spring配置文件中开启生成代理对象

<!--开启AsepctJ生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4.配置不同类型的通知

（1）在增强类的里面，在作为通知方法上面添加通知类型的注解，使用切入点表达式进行配置

/**
 * 增强的类
 */
@Component
@Aspect  //生成代理对象
public class UserPorxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.spring.aop.User.add(..))")
    public void before(){
        System.out.println("before.......");
    }
​
}

​
//前置通知
//@Before注解表示作为前置通知
@Before(value = "execution(* com.spring.aop.User.add(..))")
public void before(){
    System.out.println("before.......");
}
//后置通知
@AfterReturning(value = "execution(* com.spring.aop.User.add(..))")
public void afterReturing(){
    System.out.println("AfterReturning.......");
}
​
​
//最终通知
@After(value = "execution(* com.spring.aop.User.add(..))")
public void after(){
    System.out.println("After.......");
}
​
​
@AfterThrowing(value = "execution(* com.spring.aop.User.add(..))")
public void aftertThrowing(){
    System.out.println("aftertThrowing.......");
}
//环绕通知
@Around(value = "execution(* com.spring.aop.User.add(..))")
public void around(ProceedingJoinPoint p) throws Throwable {
    System.out.println("环绕之前around.......");
    //被增强的方法执行
    p.proceed();
    System.out.println("环绕之后around.......");
}

5.公共切入点进行抽取

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

6.有多个增强类同一个方法进行增强，设置增强类的优先级

（1）在增强类的上面添加注解@O人的人（数字类型值），值越小优先值越高

@Component
@Aspect
@Order(1)

7.完全使用注解开发

（1）创建配置类，不需要创建xml配置文件

AOP操作（AspectJ在配置文件）

1.创建两个类，增强类和被增强类，创建方法

public class Book {
    public void buy(){
        System.out.println("buy.......");
    }
}

public class BookProxy {
​
    public void before(){
        System.out.println("before.....");
    }
}

2.在Spring配置文件中创建两个类对象

<!--创建对象-->
    <bean id="book" class="com.spring.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.spring.aopxml.BookProxy"></bean>

3.在Spring配置文件中配置切入点

<!--    配置aop增强-->
    <aop:config>
<!--        切入点-->
        <aop:pointcut id="p" expression="execution(* com.spring.aopxml.Book.buy(..))"/>
<!--        配置切面-->
        <aop:aspect ref="bookProxy">
<!--            增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>