java spring AOP

shura.xl

已于 2023-09-14 22:33:13 修改

阅读量88

点赞数

文章标签： java spring 开发语言

于 2023-09-13 20:02:45 首次发布

本文链接：https://blog.csdn.net/2301_79108021/article/details/132863660

版权

AOP

概念
AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP 的作用及其优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
优势：减少重复代码，提高开发效率，并且便于维护

常用的动态代理技术

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

在这里插入图片描述
JDK代理

/**
 * 接口类
 */
public interface TargetInterface {

    void say();
}

/**
 * 目标类
 */
public class Target implements TargetInterface {
    public void say() {
        System.out.println("目标类执行了");
    }
}


 public static void main( String[] args ) {
        final Target target = new Target();
        TargetInterface proxy = (TargetInterface)Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("前面增强");
                        Object invoke = method.invoke(target, args);
                        System.out.println("后置增强");
                        return invoke;
                    }
        });
        proxy.say();
    }

Proxy.newProxyInstance() 方法是生成代理对象的，有三个参数，类加载器，目标类的所有接口字节码对象，InvocationHandler
InvocationHandler ：可以理解为一个回调函数，里面的invoke()是关键，代理对象执行方法就是在执行invoke()方法
method.invoke(target, args);属于反射，方法的执行，

public class Target {
    
    public void say1(String name) {
        System.out.println("你好"+name);
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Class<Target> targetClass = Target.class;
        Method method= targetClass.getMethod("say1", String.class);
        method.invoke(targetClass.newInstance(),"tom");
    }
}

cglib代理
使用cglib的时候需要导入依赖

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

代码

 public static void main( String[] args ) {
    final Target target = new Target(); //创建目标对象
    Enhancer enhancer = new Enhancer();   //创建增强器
    enhancer.setSuperclass(Target.class);//设置父类
    enhancer.setCallback(new MethodInterceptor() { //设置回调
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("前置代码增强....");
            Object invoke = method.invoke(target, objects);
            System.out.println("后置代码增强....");
            return invoke;
        }
    });
    Target proxy =(Target) enhancer.create();//创建代理对象
    proxy.say();
}

AOP 相关概念

Target（目标对象）：代理的目标对象

Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类

Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点。

Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知

Aspect（切面）：是切入点和通知的结合

Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。安装的过程

书写步骤

1 导入 AOP 相关坐标

  <!--导入spring的context坐标，context依赖aop-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.5.RELEASE</version>
    </dependency>
    <!-- aspectj的织入 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>

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

/**
 * 接口类
 */
public interface TargetInterface {

    void say();
}

/**
 * 目标类
 */
public class Target implements TargetInterface {
 	@Override
    public void say() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("目标类执行了");
    }
}

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

public class MyAspect {
     //前置增强方法
    public void before(){
        System.out.println("前置代码增强了");
    }
    //后置增强方法
    public void after(){
        System.out.println("后置");
    }
    //环绕增强
    public Object around(ProceedingJoinPoint p){
        long start = System.currentTimeMillis();
        String className = p.getSignature().getDeclaringTypeName();
        String method =  p.getSignature().getName();
        Object proceed = null;
        try {
            proceed = p.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("类名：" + className);
        System.out.println("方法名是：" + method);
        System.out.println("执行时间长是:"+(end-start));
        return proceed;
    }
}

4 将目标类和切面类的对象创建权交给 spring

<!--配置目标类-->
<bean id="target" class="com.xz.service.impl.Target"/>
<!--配置切面类-->
<bean id="myAspect" class="com.xz.aspect.MyAspect"/>

5 在 applicationContext.xml 中配置织入关系

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="myAspect" class="com.xinzhi.aspect.MyAspect" />

    <bean id="target" class="com.xinzhi.target.impl.TargetInterfaceImpl" />

    <aop:config>
        <aop:aspect ref="myAspect">
<!--            <aop:before method="before" pointcut="execution(* com.xinzhi.target.impl.*.*(..))"/>-->
<!--            <aop:after method="after" pointcut="execution(* com.xinzhi.target.impl.*.*(..))"/>-->
            <aop:around method="around" pointcut="execution(* com.xz.target.impl.*.*(..))"/>
        </aop:aspect>
    </aop:config>

</beans>

6 测试代码

public static void main( String[] args ) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        TargetInterface bean = (TargetInterface)applicationContext.getBean("target");
        bean.say();
 }

2 切点表达式

execution([修饰符] 返回值类型 包名.类名.方法名(参数))
	常用的书写格式：
	execution(* 包名.*.*(..))

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

注解的AOP

1 书写步骤

1创建目标接口和目标类（内部有切点）
2 创建切面类（内部有增强方法）
3 将目标类和切面类的对象创建权交给 spring
4 在切面类中使用注解配置织入关系
5 在配置文件中开启组件扫描和 AOP 的自动代理
6 测试

/**
 * 目标类
 */
@Component("target")
public class Target implements TargetInterface {

    public void say() {
        System.out.println("目标类执行了");
    }
}

@Component
@Aspect
public class MyAspect {
    //前置增强方法
    @Before("execution(* com.xz.target.impl.*.*(..))")
    public void before(){
        System.out.println("前置代码增强了");
    }
    //后置增强方法
    @After("execution(* com.xz.target.impl.*.*(..))")
    public void after(){
        System.out.println("后置");
    }
    //环绕增强
    @Around("execution(* com.xz.target.impl.*.*(..))")
    public Object around(ProceedingJoinPoint p){
        long start = System.currentTimeMillis();
        String className = p.getSignature().getDeclaringTypeName();
        String method =  p.getSignature().getName();
        Object proceed = null;
        try {
            proceed = p.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("类名：" + className);
        System.out.println("方法名是：" + method);
        System.out.println("执行时间长是:"+(end-start));
        return proceed;
    }
}

<!--组件扫描-->
<context:component-scan base-package="com.xz"/>
<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

shura.xl

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java spring AOP

书写步骤1 导入 AOP 相关坐标--导入spring的context坐标，context依赖aop--> < dependency > < groupId > org.springframework < artifactId > spring-context < version > 5.0.5.RELEASE
复制链接

扫一扫