java学习之spirng的aop

AOP技术

0x00前言

什么是AOP技术：在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

它的实际技术就是动态代理技术

0x01动态代理技术

相当于复习一下动态代理技术

package auto_proxy;

public interface tagerinterface {
    public void save();
}
//写一个接口及代理对象

package auto_proxy;

public class tager implements tagerinterface{

    @Override
    public void save() {
        System.out.println("save running");
    }
}
//写一个代理对象

package auto_proxy;

public class Advice {
    public void befor(){
        System.out.println("前置增强");
    }
    public void after(){
        System.out.println("后置增强");
    }
        }
//这是增强方法

package auto_proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Proxytest {
    public static void main(String[] args) {
        tager tager = new tager();
        Advice advice = new Advice();
        tagerinterface tagerinterface =(tagerinterface) Proxy.newProxyInstance(tager.getClass().getClassLoader(), tager.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            //调用代理对象的任何方法的时候都会执行invoke方法
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               advice.befor();
                method.invoke(tager, args);
                advice.after();
                return null;
            }
        });
        //调用代理对象方法
        tagerinterface.save();
    }
}

0x02AOP

0x1AOP相关概念

• Target(目标对象)：代理对象的吧目标
• Proxy(代理)：一个类被AOP织 入增强以后，产生了一个结果代理类
• Joinpoint（连接点）：所谓连接点，指那些被拦截到的点（方法），可以被增强的方法
• Pointcyt(切入点)：所谓切入点我们要对那些地方进行拦截。（连接点是指可以加强的方法，切入点说的是真正被增强的）

0x2AOP入门案例

开发模式：xml和注解开发

思路：

1. 导入坐标
2. 制作连接点（原始操作，Dao接口，实现类）
3. 制作共性功能
4. 定义切入点
5. 绑定切入点与通知关系

还是用动态代理的方式

先写一个接口

public interface tagerinterface {
    void add();

    void delete();

    void update();

    void qurey();

}

写一个实体函数去去继承接口

public class tager implements tagerinterface {

@Override
public void add() {
    System.out.println("执行增加");
}

@Override
public void delete() {
    System.out.println("执行删除");

}

@Override
public void update() {
    System.out.println("执行更新");

}

@Override
public void qurey() {
    System.out.println("执行整理");

}
}

写一个增强类去达到不改变原类去达到增强的效果

public class MyAspect {

        public void before(){
            System.out.println("方法执行前执行");
        }
        public void after(){
            System.out.println("方法执行后执行");
        }

}

写xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="targer" class="AOP.tager"/>
    <bean id="MyAspect" class="AOP.MyAspect"/>

    <!--配置织入，那些切点需要增强-->
    <aop:config>
        <!--        声明切面-->
        <aop:aspect ref="MyAspect">
            <!--            前置增强  pointcut:切点，选择我要增强的方法-->
            <aop:before method="before" pointcut="execution(public void AOP.tager.add())"/>
            <aop:before method="before" pointcut = "execution(public void AOP.tager.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

1. 可以使用通配符去通配整体方法
2. pointcut可以说是和你的切点，就是你要去增强那些方法
3. 增强的方法看aop标签有after before等等说

语法详解

• 返回值类型、包名、类名、方法名、可以使用*****号代替任意
• 包名和类名之间有一个.代表当前包下的类，两个个点代表当前包及其子包下面的类
• 参数列表使用两个点代表任意个数

0x3通知类型

前置通知：在方法执行前通知

@Before(value = “”)

//环绕通知：可以将要执行的方法（point.proceed()）进行包裹执行，可以在前后添加需要执行的操作

@Around(value = “”)

//后置通知：在方法正常执行完成进行通知，可以访问到方法的返回值的。

@AfterReturning(value = “”)

//异常通知：在方法出现异常时进行通知,可以访问到异常对象，且可以指定在出现特定异常时在执行通知。

@AfterThrowing(value = “”)

//方法执行后通知： 在目标方法执行后无论是否发生异常，执行通知,不能访问目标方法的执行的结果。

@After(value = “”)

0x03基于注解的开发

package AOP_auto;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component("MyAspect")
@Aspect//切面标志（增强方法）
public class MyAspect {
        @Before("execution(public void AOP.tager.*(..))")
        public void before(){
            System.out.println("方法执行前执行");
        }
        public void after(){
            System.out.println("方法执行后执行");
        }

}

@Component("tager")
public class tager implements tagerinterface {

    @Override
    @Autowired
    public void add() {
        System.out.println("执行增加");
    }

    @Override
    @Autowired
    public void delete() {
        System.out.println("执行删除");

    }

    @Override
    @Autowired
    public void update() {
        System.out.println("执行更新");

    }

    @Override
    @Autowired
    public void qurey() {
        System.out.println("执行整理");

    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"
>
    <context:component-scan base-package="AOP_auto"/>
    <aop:aspectj-autoproxy/>
</beans>

在xml文件中配置自动扫描和自动切面配置

0x04总结

AOP技术就一种动态代理技术的增强化，越学到后面发现一些原来不注意的注解和反射技术更重要。接下来会学习mvc了