关于java:Spring第9天Aop简介Aopxml开发Aop注解开发

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

是通过预编译形式和运行期动静代理实现程序性能的对立保护的一种技术。

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

OOP 的局限性

在业务代码中通常有日志管制, 性能统计, 安全控制, 事务管制, 异样解决等等操作, 只管应用 OOP 能够通过封装或继承的形式达到代码的重用, 但任然有同样的代码扩散各个办法中, 采纳 OOP 解决日志等加强了开发者工作量，而且进步了降级保护艰难

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

作用：在程序运行期间, 在不批改源代码的状况下对办法进行性能增强

劣势：缩小反复代码, 进步开发效率, 便于保护。

实际上，AOP 的底层是通过 Spring 提供的的动静代理技术实现的。在运行期间，Spring 通过动静代理技术动静的生成代理对象，代理对象办法执行时进行加强性能的染指，在去调用指标对象的办法，从而实现性能的加强

罕用的动静代理技术

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

罕用的动静代理技术

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

指标类接口

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）指标类

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();}
}

Spring 的 AOP 实现底层就是对下面的动静代理的代码进行了封装，封装后咱们只须要对须要关注的局部进行代码编写，并通过配置的形式实现指定指标的办法加强。
AOP 罕用的相干术语如下：

Target（指标对象） : 代理的指标对象
Proxy (代理) ：一个类被 AOP 织入加强后, 就会产生一个后果代理类
Joinpoint(连接点): 所谓连接点是指那些被拦挡到的点。在 spring 中, 这些点指的是办法，因为 spring 只反对办法类型的连接点
Pointcut(切入点)：所谓的切入点是指咱们要对那些 JoinPoint 进行拦挡的定义
Advice(告诉 / 减少)：所谓告诉是拦挡到 Joinpoint 之后所要做的是事件就是告诉
Aspect(切面)：是切入点和告诉 (引介) 的联合
Weaving（织入）：是指把加强利用到指标对象来创立新的代理对象的过程。spring 采纳动静代理织入，而 AspectJ 采纳编译期织入和类装载期织入

连接点和切点的区别

连接点 (Join point) : 连接点是利用执行过程中可能插入切面(Aspect) 的一个点, 这些点能够是调用办法时、甚至批改一个字段时。
切点（Pointcut): 切点时指告诉 (Adivce) 所要织入的中央的具体位置

连接点 ：连接点时一个 虚构 的概念, 他能够了解为所有满足切点条件的所有机会。

具体举个例子：比方开车通过一条高速公路, 这条高速公路有很多个路口（连接点）, 然而咱们不会每个进口都会进来，指挥抉择咱们须要的那个进口（切点) 开进来。

简略能够了解为，每个进口都是 连接点 然而咱们应用的那个进口才是 切点 ，每个利用有多个地位适宜织入告诉, 这些都是 连接点,然而只有咱们抉择的那个具体的地位才是切点

小总结： 所有办法都须要连接点，切点是咱们对连接点的实现，通过切点确定那些连接点须要被解决。

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

须要编写的内容

编写指标类的指标方)
编写切面类(内含有加强办法)
在配置文件中, 配置织入关系, 以及那些 告诉 和连接点 汇合

总结

aop 的重点概念

Pointcut（切入点）：被加强的办法

Advice（告诉 / 加强）：封装加强业务逻辑的办法

Aspect（切面）：切点 + 告诉

Weaving（织入）：将切点与告诉联合的过程

开发者步骤

谁是切点(切点表达式)

谁是告诉(切面类的加强办法)

将切点和告诉进行织入配置

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

1. 导包

<dependencies>
        <!-- 导入 spirng 的 context 坐标,context 依赖 aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <!-- aop 小框架 aspectj 的织入 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- 这是一个 spring 自带的测试等等我会演示 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

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 代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       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-4.2.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
">
    <!-- 指标对象 -->
    <bean id="target" class="com.xxx.aop.Target"></bean>

    <!-- 切面对象 -->
    <bean id="myAspect" class="com.xxx.aop.MyAspect"></bean>

    <!-- 配置织入: 通知 spring 框架 那些办法 (切点) 须要进行那些加强(前置, 后置..)-->
    <aop:config>
        <!-- 申明切面 -->
        <aop:aspect ref="myAspect">
            <!-- 配置 Target 的 save 办法执行时要进行 myAspect 的 before 办法前置加强 -->
            
            <!-- 切面：切点 + 告诉(减少)   pointcut 切点 -->
            <aop:before method="before" pointcut="execution(public void com.xxx.aop.Target.())"/>
        </aop:aspect>
    </aop:config>
    
</beans>

5. 测试

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

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

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

输入后果：

前置加强 ……
save running…..

表达式语法

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
括号内的 .. = 任意参数

告诉的配置语法：

<aop: 告诉类型 method="切面类中办法名" pointcut="切点表达式"></aop: 告诉类型 >

名称	标签	阐明
前置告诉	`<aop:before>`	用于配置前置告诉。指定加强的办法在切入点办法之前执行
后置告诉	`<aop:after-returning>`	用于配置后置告诉。指定加强的办法在切入点办法之后执行
盘绕告诉	`<aop:around>`	于配置盘绕告诉。指定加强的办法在切入点办法之前和之后都执行
异样抛出告诉	`<aop:throwing>`	用用于配置异样抛出告诉。指定加强的办法在出现异常时执行
最终告诉	`<aop:after>`	用于配置最终告诉。无论加强形式执行是否有异样都会执行

当多个加强的切点表达式雷同时，能够将切点表达式进行抽取，在加强中应用 pointcut-ref 属性代替 pointcut 属性来援用抽取后的切点表达式。

<aop:config>
    <!-- 援用 myAspect 的 Bean 为切面对象 -->
    <aop:aspect ref="myAspect">
        <!-- 抽取切点表达式 -->
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"></aop:pointcut>
        <aop:around method="around" pointcut-ref="myPointcut"/>
        <aop:after method="after" pointcut-ref="myPointcut"/>
    </aop:aspect>
</aop:config>

告诉办法存在于切面类中，依据切点表达式，对切点加强。

步骤：
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 的主动代理

<!-- 组件扫描 -->
<context:component-scan base-package="com.itheima.anno"/>

<!--aop 主动代理 -->
<aop:aspectj-autoproxy/>

6、测试

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

    @Autowired
    private TargetInterface target;

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

输入：

前置加强 ……

save running…..

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

名称	注解	阐明
前置告诉	`@Before`	用于配置前置告诉。指定加强的办法在切入点办法之前执行
后置告诉	`@AfterReturning`	用于配置后置告诉。指定加强的办法在切入点办法之后执行
盘绕告诉	`@Around`	用于配置盘绕告诉。指定加强的办法在切入点办法之前和之后都执行
异样抛出告诉	`@AfterThrowing`	用于配置异样抛出告诉。指定加强的办法在出现异常时执行
最终告诉	`@After`	用于配置最终告诉。无论加强形式执行是否有异样都会执行

通 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() {}
}

关于java: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）切点表达式的抽取