Spring

在这里插入代码片## AOP概念

1、利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，提高开发效率

2、通俗的讲，不修改源代码的方式，在主干里面添加新的功能

a) AOP底层是用动态代理

第一种 有接口的情况 ，使用JDK动态代理，创建这个接口实现类的代理对象，增强类的方法
第二种 没有接口情况 ，使用CGLIB动态代理创建子类的代理对象，增强类的方法

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

public static Object newProxyInstance(ClassLoader loader,
                                      Class[] interfaces,
                                      InvocationHandler h)

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

b) 编写JDK动态代理代码

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

//实现类
public class UserDaoImpl implements UserDao {
    @Override
    public int  add(int a, int b) {
        return a+b;
    }

    @Override
    public String  update(String str) {
        return str;
    }
}

//测试，jdk动态代理
public class JDKProxy {
    public static void main(String[] args) {
//        创建接口实现类代理对象
        Class[] interface_ = {UserDao.class};
//        创建一个实列
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interface_, new Temp(userDao));
        int add = o.add(1, 8);
        System.out.println("结果："+add);
        System.out.println("==========================");
        String update = o.update("小浩纸~~");
        System.out.println(update);
    }
}
//创建对象代理类
class Temp implements InvocationHandler{
//    通过有参的构造方法传递参数
    public Object obj;
    public  Temp(Object obj){
        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;

    }
}

1、连接点：类里面那些方法可以被增强，这些方法称之为连接点
2、切入点：实际被真正增强的方法，称之为切入点
3、通知（增强）：实际增强的逻辑部分称之为通知（增强）
>前置通知 >后置通知 >环绕通知 >异常通知 >最终通知 finally
4、切面：是动作 把通知应用道切入点过程

​ a）Spring 框架一般都是基于 AspectJ 实现 AOP 操作，AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使 用，进行 AOP 操作

​ b）基于 AspectJ 实现 AOP 操作：1）基于 xml 配置文件实现 （2）基于注解方式实现（使用）

​ c）引入相关jar包

​ d）切入点表达式，如下：

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强 
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
（3）例子如下：
    例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强
		execution(* com.atguigu.dao.BookDao.add(..))
 	例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
		execution(* com.atguigu.dao.BookDao.* (..))
    例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
		execution(* com.atguigu.dao.*.* (..))