Spring AOP

第一章静态代理设计模式

1.为什么需要代理设计模式

1.1 问题

在JavaEE分层开发中，哪个层次最重要

DAO ---> Service ---> Controller

JavaEE分层开发中，Service层次最重要

Service层中包含哪些代码？

Service层中 = 核心功能+额外功能
1. 核心功能
   业务运算
   DAO调用
2. 额外功能
   不属于业务  可有可无  代码量小
   
   事务，日志，性能...

额外功能书写在Service层中好不好？

Service层的调用者的角度（Controller）:需要在Service层书写额外功能。
					      软件设计者：Service层不需要额外功能

现实生活如何解决

2.代理模式

1.1 概念

通过代理类，为原始类（目标）增加额外功能
好处：利于原始类（目标）的维护

1.2 名词解释

1. 目标类 原始类：指的是业务类（核心功能 --> 业务运算 DAO调用）
2. 目标方法 原始方法：目标类中的方法，就是目标方法（原始方法）
3. 额外功能：日志，事务，性能

1.3 代理开发的核心要素

代理类 = 目标类 + 额外功能 + 目标类实现相同的接口

1.4 编码

静态代理：为每一个原始类手工编写一个代理类

public class UserServiceProxy implements UserService {

    private UserServiceImpl userServiceimpl = new UserServiceImpl();

    @Override
    public void register(User user) {
        System.out.println("----log----");
        userServiceimpl.register(user);
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("----log----");
        userServiceimpl.login(name,password);
        return false;
    }
}

1.5 静态代理存在的问题

1.静态文件数量过多，不利于项目管理
	一个原始文件，提供一个代理类
2.额外功能维护性能差
  代理类中 额外功能修改复杂（麻烦）

第二章 Spring的动态代理开发

1.Spring动态代理的概念

概念：通过代理类为原始类（目标类）增加额外功能
好处：利于原始类（目标类）的维护

2.搭建开发环境

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.2</version>
    <scope>runtime</scope>
</dependency>

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.9</version>
</dependency>

3.Spring动态代理的开发步骤

1.创建原始对象

public class UserServiceImpl implements UserService {
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register");
    }
    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return false;
    }
}

<bean id="userService" class="com.hyy.proxy.UserServiceImpl"/>

2.额外功能

MethodBeforeAdvice接口

额外的功能书写在接口的实现中，运行在原始方法之前执行额外功能

public class Before implements MethodBeforeAdvice {
    /*
    *  作用：需要把运行在原始方法之前的额外功能，书写在before之前
    * */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("------MethodBeforeAdvice log-------");
    }
}

<bean id="before" class="com.hyy.dynamic.Before"/>

3.定义切入点

切入点：额外功能加入的位置
目的：由程序员根据自己的需要，决定额外功能加入给哪个原始方法

简单的测试：所有方法都作为切入点，都加入额外的功能

<aop:config>
    <!--所有的方法都作为切入点，加入额外功能-->
    <aop:pointcut id="pc" expression="execution(* *(.. ))"></aop:pointcut>
</aop:config>

4.组装（2 3 步进行整合）

<aop:config>
    <!--所有的方法都作为切入点，加入额外功能-->
    <aop:pointcut id="pc" expression="execution(* *(.. ))"></aop:pointcut>
    <!--组装：把切入点和额外功能就行整合-->
    //所有的功能都加入before功能
    <aop:advisor advice-ref="before" pointcut-ref="pc"/>
</aop:config>

5.调用

目的：获得Spring工厂创建的动态代理对象，并进行调用
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
注意：
    1.Spring的工厂通过原始对象id值获得的是代理对象
    2.获得代理对象后，可以通过声明接口类型，进行对象的存储
UserService userService =(UserService)ctx.getBean("userService");

4.动态代理细节分析

1.Spring创建的动态代理类在哪？

Spring框架在运行是，通过动态字节码技术，在Jvm创建的，运行在JVM内部，程序结束后，和JVM一起消失。
动态字节码技术：通过第三方动态字节码框架，在JVM中创建对应类的字节码，进而创建对象

结论：动态代理不需要定义类文件，都是JVM运行过程中创建的，不会造成静态代理文件过多

2.动态代理编程简化代理的开发

在额外功能不改变的情况下，我们创建其他目标类的代理对象时，只需要指定目标类即可。

3.动态代理的维护性大大增强

第三章 Spring动态代理详解

AOP编程

1.额外功能的详解

MethodBeforeAdvice分析

1.MethodBeforeAdvice接口作用：额外功能运行在原始方法执行之前，进行额外功能操作
    /*
    *  作用：需要把运行在原始方法之前的额外功能，书写在before之前
    *
    *  Method: 额外功能所增加给的原始方法
    *
    *  objects：额外功能所增加给的参数
    *
    *  Object: 额外功能所增加给的原始对象
    * */
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
    System.out.println("------new MethodBeforeAdvice log-------");
}

2.before的三个参数在实战中，该如何使用
  before的三个参数在实战中，会根据需要进行使用，不一定都能使用到

MethodInterceptor(方法拦截器)

MethodBeforeAdvice --> 原始方法之前

MethodInterceptor接口：额外功能可以根据需要运行在原始方法之前，之后，之前和之后

什么样的额外功能，运行在原始方法执行之前，之后都要添加?
   事务
public class Around implements MethodInterceptor {
    /*
    * invoke方法的作用：额外功能写在invoke方法中
    *                   额外功能   原始方法之前
    *                   额外功能   原始方法之后
    *                   额外功能   原始方法前后
    *   确定原始方法运行
    *   参数：methodInvocation : 额外功能所增加的那个原始方法
    *   返回值：Object 原始方法执行后的返回值
    * */
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("原始方法运行之前");
        Object ret = methodInvocation.proceed();
        System.out.println("原始方法运行之后");
        return ret;
    }
}

额外功能在原始方法抛出异常的时候运行

@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    Object ret=null;
    try {
        ret= methodInvocation.proceed();
    }catch (Exception e){
        System.out.println("原始方法抛出异常");
    }
    return ret;
}

MethodInterceptor 可以影响原始方法的返回值

把原始方法的返回值，直接作为invoke方法的返回值返回，MethodInterceptor 不会影响原始方法的返回值

2.切入点详解

切入点决定额外功能加入位置（方法）

<aop:pointcut id ="pc" expression="execution(* *(..))" />
execution(* *(..)):匹配所有的方法

1.execution() 切入点函数
2.* *(..) 切入点表达式

2.1 切入点表达式

方法切入点表达式

* *(..)  ---> 所有方法
* ---> 修饰符 返回值
* ---> 方法名
() ---> 参数表
.. ---> 对于参数没有要求(参数类型，参数个数)

定义login方法作为切入点

* login(..)

# 定义register方法作为切入点
* register(..)

定义login方法且login方法有两个字符串类型的参数作为切入点

* login(String,String)

#注意：非java.lang包中的类型，必须写全限类名
* register(com.hyy.proxy.User)

# ..可以和其他类型一起用
* login(String,..)

上面的方法切入点表达式不精准

精准方法切入点限定

修饰符 返回值   包.类.方法（参数）

<aop:pointcut id="pc" expression="execution(* com.hyy.proxy.UserServiceImpl.login(String,String ))"/>

类切入点

指定特定类作为切入点（额外功能加入的位置），这个类中所有方法，都会加上对应额外功能
<aop:pointcut id="pc" expression="execution(* com.hyy.proxy.UserServiceImpl.*(.. ))"/>

# 忽略包
1. 类只存在一级包 com.UserServiceImpl
* *.UserServiceImpl.*(..)

2. 类存在多级包 com.hyy.proxy.UserServiceImpl
* *..UserServiceImpl.*(..)

包切入点
```
语法与类切入点类似
```

2.2 切入点函数

切入点函数：用于执行切入点表达式

execution

最为重要的切入点函数，功能最全
执行 方法切入点表达式  类切入点表达式 包切入点表达式

弊端：execution执行切入点表达式，书写麻烦
	execution(* com.hyy.proxy..*.*(..))
注意：其他切入点函数，简化execution书写复杂度，功能上完全一致

args（省去修饰符返回值和方法）

作用：主要用于函数（方法）参数的匹配

切入点：方法参数必须是2个字符串类型的参数
execution(* *(String,String))

args(String,String)

within （省去修饰符返回值和参数）

作用：主要用于类，包切入点表达式的匹配
切入点：UserServiceImpl这个类

execution(* *..UserServiceImpl.*(..))

within(*..UserServiceImpl)

execution(* com.hyy.proxy.*.*(..))

within(com.hyy.proxy.*)

@annotation

作用：为具有特殊注解的方法加入额外功能

<aop:pointcut id="pc" expression="@annotation(com.hyy.Log)"/>

切入点函数的逻辑运算

指的是 整合多个切入点函数一起配合工作，进而完成更为复杂的需求

and与操作

案例：login 同时 参数 2个字符串
1. execution(* login(String,String))

2. execution(* login(..)) and args(String,String)

<aop:pointcut id="pc" expression="execution(* login(..)) and args(String,String))"/>

注意：与操作不能用于同种类型的切入点函数
execution and execution  ×
execution(* login(..)) and execution(* register(..))

or或操作

execution or execution  √
execution(* login(..)) or execution(* register(..))

第四章 AOP编程

1.AOP概念

//以切面为基本单位的程序开发，通过切面间的彼此协同，相互调用，完成程序的构建
AOP(Aspect Oriented Programing) 面向切面编程
切面 = 切入点 + 额外功能

//以对象为基本单位的程序开发，通过对象间的彼此协同，相互调用，完成程序的构建
OOP(Object Oriented Programing) 面向对象编程

//以过程为基本单位的程序开发，通过过程间的彼此协同，相互调用，完成程序的开发
POP(Producer Oriented Programing) 面向过程编程

AOP的概念：
	本质就是Spring的动态代理开发，通过代理类为原始类增加额外功能
	好处：利于原始类的维护
注意：AOP编程不可取代OOP,对OOP的补充

2.AOP编程的开发步骤

1.原始对象
2.额外功能（MethodInterceptor）
3.切入点
4.组装切面（额外功能+切入点）

3.切面的名词解释

切面 = 切入点 + 额外功能

几何学
	面 = 点 + 相同的性质

第五章 AOP的底层实现原理

1.核心问题

1.AOP如何创建动态代理类(动态字节码技术)
2.Spring工厂如何加工创建代理对象
	通过原始类对象的id指，获得的是代理对象

2.动态代理类的创建

2.1 JDK的动态代理

Proxy.newProxyInstance方法参数详解

编码

public class TestJdkProxy {
    public static void main(String[] args) {
        //创建原始对象
        UserService userService =new UserServiceImpl();

        //Jdk创建动态代理

        InvocationHandler handler = new InvocationHandler(){

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("-----Proxy log -----");
                //原始方法运行
                Object ret = method.invoke(userService, args);

                return ret;
            }
        };

        UserService userServiceProxy = (UserService)Proxy.newProxyInstance(TestJdkProxy.class.getClassLoader(), userService.getClass().getInterfaces(), handler);

        userServiceProxy.login("迷雾神","123456" );

        userServiceProxy.register(new User());

    }
}

2.2 CGlib的动态代理

CGlib创建动态代理的原理：父子继承关系创建代理对象

编码

public class TestCGlib {

    public static void main(String[] args) {
        //创建原始对象
        UserServiceI userServiceI =new UserServiceI();
        /*
        * 通过cglib创建代理对象
        * enhancer.setClassLoader
        * enhancer.setSuperclass
        * enhancer.setCallback
        *
        * Enhancer.create --> 代理
        * */
        Enhancer enhancer =new Enhancer();
        enhancer.setClassLoader(TestCGlib.class.getClassLoader());
        enhancer.setSuperclass(userServiceI.getClass());

        MethodInterceptor interceptor =new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("-----Cglib log-----");
                Object ret = method.invoke(userServiceI, objects);
                return ret;
            }
        };
        enhancer.setCallback(interceptor);

        UserServiceI userProxy = (UserServiceI)enhancer.create();
        userProxy.login("迷雾小神","123456" );
        userProxy.register(new User());
    }
}

总结

1.JDK动态代理：Proxy.newInstance() 通过接口创建代理类的实现
2.CGlib动态代理：Enhance.create()  通过继承原始类创建的代理类

3.Spring工厂如何加工原始对象

编码

public class ProxyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    /*
    * Proxy.newInstance
    * */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("-----log------");

                Object ret = method.invoke(bean, args);
                return ret;
            }
        });
    }
}

    <bean id="userService" class="com.hyy.factory.UserServiceImpl"/>

    <!--1.实现BeanPostProcessor 进行加工-->
    <!--2.配置文件中对BeanPostProcessor进行配置-->

    <bean id="proxy" class="com.hyy.factory.ProxyBeanPostProcessor"/>

第六章基于注解的AOP编程

1.基于注解的AOP编程的开发步骤

1.原始对象

2.额外功能

3.切入点

4.组装切面

通过切面类 定义了 额外功能@Around
		 定义了 切入点
		 @Aspect i切面类

/*
*  1.额外功能
*           public class MyAround implements MethodInterceptor{
*
*               public object invoke(MethodInvocation invocation){
*                      object ret = invocation.proceed();
*                      return ret;
*               }
*           }
*  2.切入点
*
* */
@Aspect
public class MyAspect {

    @Around(value = "execution(* login(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------log--------");
        Object ret = joinPoint.proceed();
        return ret;
    }
}

<bean class="com.hyy.aspect.UserServiceImpl" id="userService"></bean>

<!--切面
        1.额外功能
        2.切入点
        3.组装切面
    -->
<bean id="around" class="com.hyy.aspect.MyAspect"></bean>

<!--告知Spring要基于注解进行AOP编程-->
<aop:aspectj-autoproxy/>

2.细节

1.切入点复用

切入点复用:在切面类定义一个函数，上面 @Pointcut注解，通过这种方式，
    	 定义切入点表达式，后续更加有利于切入点复用
    
@Aspect
public class MyAspect {
    @Pointcut注解，通过这种方式，定义切入点表达式，后续更加有利于切入点复用("execution(* login(..))")
    public void myPointcut(){

    }

    @Around(value = "myPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------aspect log--------");
        Object proceed = joinPoint.proceed();
        return proceed;
    }

    @Around(value = "myPointcut()")
    public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("------aspect tx--------");
        Object proceed = joinPoint.proceed();
        return proceed;
    }
}

2.动态代理的创建方式

AOP底层实现 2种代理创建方式
1. JDK通过实现接口 做新的实现类方式 创建代理对象
2. Cglib通过继承父类 做新的子类    创建代理对象

默认情况下 AOP编程 底层应用JDK动态代理创建方式

如果切换成cglib
1.基于注解AOP开发
	<aop:aspectj-autoproxy proxy-target-class="true"/>
2.传统的AOP开发
	<aop:config proxy-target-class="true">

第七章 AOP开发种的一个坑

坑：在同一个业务类中，进行业务方法间的相互调用，只有最外层的方法，才是加入了额外功能。(内部方法，通过普通的方法调用，都是调用的原始方法)。如果想让内层的方法也调用代理对象的方法，实现ApplicationContextAware，获得工厂，进而获得代理对象

public class UserServiceImpl implements UserService,ApplicationContextAware {

    private ApplicationContext ctx;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.ctx=applicationContext;
    }

    @Log
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register");
        //原始对象的login方法---> 核心功能
        /*
        * 设计目的：代理对象的login方法 -->额外功能+核心功能
        * ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
           UserService userService = (UserService)ctx.getBean("userService");
           userService.login("迷雾神","123456" );

           Spring重量级资源 一个应用中只创建一次
        * */
        UserService userService = (UserService)ctx.getBean("userService");
        userService.login("迷雾神","123456" );
    }
    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return false;
    }

}

Spring AOP学习笔记

Spring AOP

第一章静态代理设计模式

1.为什么需要代理设计模式

2.代理模式

1.1 概念

1.2 名词解释

1.3 代理开发的核心要素

1.4 编码

1.5 静态代理存在的问题

第二章 Spring的动态代理开发

1.Spring动态代理的概念

2.搭建开发环境

3.Spring动态代理的开发步骤

4.动态代理细节分析

第三章 Spring动态代理详解

1.额外功能的详解

2.切入点详解

2.1 切入点表达式

方法切入点表达式

类切入点

包切入点

2.2 切入点函数

execution

args（省去修饰符返回值和方法）

within （省去修饰符返回值和参数）

切入点函数的逻辑运算

第四章 AOP编程

1.AOP概念

第五章 AOP的底层实现原理

1.核心问题

2.动态代理类的创建

2.1 JDK的动态代理

2.2 CGlib的动态代理

3.Spring工厂如何加工原始对象

第六章基于注解的AOP编程

1.基于注解的AOP编程的开发步骤

2.细节

第七章 AOP开发种的一个坑

第八章 AOP阶段知识总结

Spring AOP学习笔记

Spring AOP

第一章 静态代理设计模式

1.为什么需要代理设计模式

2.代理模式

1.1 概念

1.2 名词解释

1.3 代理开发的核心要素

1.4 编码

1.5 静态代理存在的问题

第二章 Spring的动态代理开发

1.Spring动态代理的概念

2.搭建开发环境

3.Spring动态代理的开发步骤

4.动态代理细节分析

第三章 Spring动态代理详解

1.额外功能的详解

2.切入点详解

2.1 切入点表达式

方法切入点表达式

类切入点

包切入点

2.2 切入点函数

execution

args（省去修饰符返回值 和 方法）

within （省去修饰符返回值 和 参数）

切入点函数的逻辑运算

第四章 AOP编程

1.AOP概念

第五章 AOP的底层实现原理

1.核心问题

2.动态代理类的创建

2.1 JDK的动态代理

2.2 CGlib的动态代理

3.Spring工厂如何加工原始对象

第六章 基于注解的AOP编程

1.基于注解的AOP编程的开发步骤

2.细节

第七章 AOP开发种的一个坑

第八章 AOP阶段知识总结

第一章静态代理设计模式

args（省去修饰符返回值和方法）

within （省去修饰符返回值和参数）

第六章基于注解的AOP编程