1. Spring的AOP简介

1.1 什么是AOP?

AOP 为 Aspect Oriented Programming 的缩写, 意思为面向切面编程,

是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP是OOP(Ojebct Oriented Programming)的延续, 是软件开发中的一个热点, 是Spring框架的一个重要内容部分,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

OOP的局限性

在业务代码中通常有日志控制,性能统计,安全控制,事务控制,异常处理等等操作, 尽管使用OOP可以通过封装或继承的方式达到代码的重用,但任然有同样的代码分散各个方法中,采用OOP处理日志等增强了开发者工作量，而且提高了升级维护困难

这一条条横线仿佛切开了 OOP 的树状结构，犹如一个大蛋糕被切开多层，每一层都会执行相同的辅助逻辑，所以大家将这些辅助逻辑称为层面或者切面。

1.2 AOP的优势

作用：在程序运行期间, 在不修改源代码的情况下对方法进行功能加强

优势：减少重复代码, 提高开发效率,便于维护。

1.3 AOP的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强

1.4 AOP的代理技术

常用的动态代理技术

JDK 代理：基于接口的动态代理技术
cglib 代理：基于父类的动态代理技术

常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术
cglib 代理：基于父类的动态代理技术

1.5 JDK的动态代理

目标类接口

public interface TargetInterface{
    void save();
}

2. 目标类

public class Target implements TargetInterface{
    
    public void save(){
       System.out.println("save running....");
    }
    
}

增加类

public class Advice{

    public void before(){
        System.out.println("前置增强");
    }
    
    public void afterReturning(){
        System.out.println("后置增强...");
    }
    
}

动态代理代码

public class ProxyTest{
    public static void main(String [] args){
    
    // 目标对象
    final Target target = new Target();
    
    // 增强对象
    final Advice advice = new Advice();
            
    //返回值 就是动态生成的代理对象
    TargetInterface proxy = (TargetInterface)Proxy.newProxyInstance(
        // 目标对象类加载器
        target.getClass().getClassLoader(),
        // 目标对象相同的接口字节码对象数组
        target.getClass().getInterfaces(),
        new InvocationHandler() {
            // 调用代理对象的任何方法 实质执行的都是invoke方法
            public Object invoke(Object proxy,Method method, Object[] args) throws InvocationTargetException, IllegalAccessException{
            advkce.before(); // 前置增加
           Object invoke = method.invoke(target,args) //执行目标方法
            advice.afterReturning(); //后置增加
            return invoke; // 返回值就是目标对象 -> null也行(尽量别)
            }
        }
    );
        
    // 调用代理对象方法
        proxy.save();
    // (调用接口的任意方法时,代理对象的代码都无需修改)
    }
}

输出结果：

 前置增加
 save running.....
 后置增加

1.6 cglib的动态代理

1）目标类

public class Target {
    public void save() {
        System.out.println("save running.....");
    }
}

2）增强类对象

public class Advice {

    public void before(){
        System.out.println("前置增强....");
    }

    public void afterReturning(){
        System.out.println("后置增强....");
    }

}

3）动态代理代码

public class ProxyTest {

    public static void main(String[] args) {

        // 目标对象
        final Target target = new Target();

        // 增加对象
        final Advice advice = new Advice();

        // 返回值 就是动态生成的代理对象 基于从cglib
        // 1. 创建增强器
        Enhancer enhancer = new Enhancer();
        // 2. 设置父类(目标)
        enhancer.setSuperclass(Target.class);
        // 3. 设置回调
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //执行前置
                advice.before();
                Object invoke = method.invoke(target, args);
                // 执行后置
                advice.afterReturning();
                return invoke;
            }
        });
        // 4. 创建代理对象
        Target proxy = (Target) enhancer.create();

        proxy.save();

    }
}

1.7 AOP的相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。
AOP 常用的相关术语如下：

Target（目标对象） : 代理的目标对象
Proxy (代理) ：一个类被AOP织入增强后,就会产生一个结果代理类
Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
Pointcut(切入点)：所谓的切入点是指我们要对那些 JoinPoint 进行拦截的定义
Advice(通知/增加)：所谓通知是拦截到 Joinpoint之后所要做的是事情就是通知
Aspect(切面)：是切入点和通知(引介)的结合
Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

Spring AOP术语：

连接点和切点的区别

连接点(Join point) : 连接点是应用执行过程中能够插入切面(Aspect) 的一个点, 这些点可以是调用方法时、甚至修改一个字段时。
切点（Pointcut): 切点时指通知(Adivce) 所要织入的地方的具体位置

连接点：连接点时一个虚拟的概念,他可以理解为所有满足切点条件的所有时机。

具体举个例子：比如开车经过一条高速公路,这条高速公路有很多个路口（连接点）,但是我们不会每个出口都会出去，指挥选择我们需要的那个出口（切点) 开出去。

简单可以理解为，每个出口都是连接点但是我们使用的那个出口才是切点，每个应用有多个位置适合织入通知,这些都是连接点,但是只有我们选择的那个具体的位置才是切点

小总结： 所有方法都需要连接点，切点是我们对连接点的实现，通过切点确定那些连接点需要被处理。

参考：https://blog.csdn.net/weixin_...

AOP 开发明确开发及总结

需要编写的内容

编写目标类的目标方)
编写切面类(内含有增强方法)
在配置文件中,配置织入关系,以及那些通知和连接点集合

总结

aop的重点概念

Pointcut（切入点）：被增强的方法

Advice（通知/ 增强）：封装增强业务逻辑的方法

Aspect（切面）：切点+通知

Weaving（织入）：将切点与通知结合的过程

开发者步骤

谁是切点(切点表达式)

谁是通知(切面类的增强方法)

将切点和通知进行织入配置

基于XML的AOP开发

2.1快速入门

maven AOP 的坐标
目标接口目标类(内部有切点)
切面类
在applicationContext.xml配置织入等
测试

1.导包


        
        
            org.springframework
            spring-context
            5.0.2.RELEASE
        
        
        
            org.aspectj
            aspectjweaver
            1.8.6
        
        
            junit
            junit
            4.12
            test
        
        
        
            org.springframework
            spring-test
            5.0.2.RELEASE

2.目标接口目标类（内部有切点）

package com.xxx.aop; // 目标接口
public interface TargetInterface {
    public void save();
}


package com.xxx.aop; // 目标类
public class Target implements TargetInterface {

    public void save() {
//        int i = 1/0;
        System.out.println("save running.....");
    }

}

3.切面类（内部有增强方法）

package com.xxx.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspect {

    public void before(){
        System.out.println("前置增强......");
    }

}

4.xml进行配置

aop命名空间及约束空间

xml代码

5.测试

@RunWith(SpringJUnit4ClassRunner.class) // spring测试类
@ContextConfiguration("classpath:applicationContext.xml") // 指定测试的文件 
public class AopTest {

    @Autowired // 把要测试的对象 注入进来
    private TargetInterface target;

    @Test
    public void test1() {
        target.save();
    }   
    
}

输出结果：

前置增强......
save running.....

xml配置AOP详解

1）切点表达式的写法

表达式语法

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号* 代表任意
包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

# 全
execution(public void com.xxx.aop.Target.method()) 
# 任意方法任意参数
execution(void com.xxx.aop.Target.*(..)) 
# 任意返回值com.xxx.aop包下任意类任意方法任意参数
execution(* com.xxx.aop.*.*(..)) 
# 任意返回值com.xxx.aop下以其子包下任意类任意参数
execution(* com.xxx.aop..*.*(..))
# 你故意找茬是吧
execution(* *..*.*(..))

小总结： 
修饰符可以不写 
第一个 * = 返回值 
第二个 * = 包 
第三个 * = 类
第四个 * = 方法
括号外.. = 自己包括子包下所有类的xxx
括号内的 .. = 任意参数

2）通知的类型

通知的配置语法：

名称	标签	说明
前置通知		用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知		用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知		于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知		用用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知		用于配置最终通知。无论增强方式执行是否有异常都会执行

3）切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。

通知方法存在于切面类中，根据切点表达式，对切点增强。

3. 基于注解的AOP开发

3.1 快速入门

步骤：
1、创建目标接口和目标类（开启注解扫描）
2、创建切面类（开启注解扫描配置织入关系）
3、xml开启启组件扫描和 AOP 的自动代理
4、测试

1、创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void save();
}

@Component
public class Target implements TargetInterface {
    public void save() {
        System.out.println("save running.....");
    }
}

2、创建切面类（内部有增强方法）

@Component("myAspect")
@Aspect //标签当前MyAspect是一个切面类
public class MyAspect {

    // 配置前置增强
    // @Before(value = "execution( * com.xxx.anno.*.*(..))")
    public void before(){
        System.out.println("前置增强......");
    }

  
}

5、在配置文件中开启组件扫描和 AOP 的自动代理

6、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-anno.xml")
public class AnnoTest {

    @Autowired
    private TargetInterface target;

    @Test
    public void test1() {
        target.save();
    }
}

输出：

前置增强......

save running.....

3.2 注解配置 AOP 详解

1）注解通知的类型

通知的配置语法：@通知注解("切点表达式")

名称	注解	说明
前置通知	`@Before`	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	`@AfterReturning`	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	`@Around`	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	`@AfterThrowing`	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	`@After`	用于配置最终通知。无论增强方式执行是否有异常都会执行

2）切点表达式的抽取

通xml 配置 aop 一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut 注解定义切点表达式，然后在在增强注解中进行引用。具体如下：

@Component("myAspect")
@Aspect //标注当前MyAspect是一个切面类
public class MyAspect {

    //Proceeding JoinPoint:  正在执行的连接点===切点
    //@Around("execution(* com.xxx.anno.*.*(..))")
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强....");
        Object proceed = pjp.proceed();//切点方法
        System.out.println("环绕后增强....");
        return proceed;
    }

    public void afterThrowing() {
        System.out.println("异常抛出增强..........");
    }

    //@After("execution(* com.xxx.anno.*.*(..))")
    @After("MyAspect.pointcut()")
    public void after() {
        System.out.println("最终增强..........");
    }

    //定义切点表达式
    @Pointcut("execution(* com.xxx.anno.*.*(..))")
    public void pointcut() {
    }
}

Spring第9天Aop简介,Aopxml开发,Aop注解开发

1. Spring的AOP简介

1.1 什么是AOP?

1.2 AOP的优势

1.3 AOP的底层实现

1.4 AOP的代理技术

1.5 JDK的动态代理

1.6 cglib的动态代理

1.7 AOP的相关概念

Spring AOP术语：

连接点和切点的区别

AOP 开发明确开发及总结

需要编写的内容

基于XML的AOP开发

2.1快速入门

1.导包

2.目标接口目标类（内部有切点）

3.切面类（内部有增强方法）

4.xml进行配置

5.测试

xml配置AOP详解

1）切点表达式的写法

2）通知的类型

3）切点表达式的抽取

3. 基于注解的AOP开发

3.1 快速入门

3.2 注解配置 AOP 详解

1）注解通知的类型

2）切点表达式的抽取

你可能感兴趣的:(java后端springxml)

Spring第9天Aop简介,Aopxml开发,Aop注解开发

1. Spring的AOP简介

1.1 什么是AOP?

1.2 AOP的优势

1.3 AOP的底层实现

1.4 AOP的代理技术

1.5 JDK的动态代理

1.6 cglib的动态代理

1.7 AOP的相关概念

Spring AOP术语：

连接点和切点的区别

AOP 开发明确开发及总结

需要编写的内容

基于XML的AOP开发

2.1快速入门

1.导包

2.目标接口目标类（内部有切点）

3.切面类（内部有增强方法）

4.xml进行配置

5.测试

xml配置AOP详解

1） 切点表达式的写法

2）通知的类型

3）切点表达式的抽取

3. 基于注解的AOP开发

3.1 快速入门

3.2 注解配置 AOP 详解

1）注解通知的类型

2）切点表达式的抽取

你可能感兴趣的:(java后端springxml)

1）切点表达式的写法