实验测试 Spring Aop

最新推荐文章于 2024-04-03 21:23:00 发布

xingqing_

最新推荐文章于 2024-04-03 21:23:00 发布

阅读量355

点赞数

文章标签： spring java 后端

本文链接：https://blog.csdn.net/xingqing_/article/details/123310252

版权

本文详细介绍了Spring AOP中的代理模式，包括静态代理和动态代理的区别，以及通过代码实现的步骤。重点讲解了如何在不修改原有业务代码的情况下，使用代理模式添加日志功能，展示了其在业务分工和扩展管理的优势。

摘要由CSDN通过智能技术生成

一.了解代理模式

为什么了借代理模式，因为代理模式是SpringAOP的底层，慎重万丈高楼平地起

代理模式有

静态代理模式
动态代理模式

1.静态代理

角色分析

抽象角色：一般会使用接口类或者抽象类
真实角色：被代理角色
代理角色：代理真实角色，并有一些附属操作
客户：访问代理对象的人

静态代理好处

缺点

可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
公共也就交给代理角色！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理！
一个真实角色就会产生一个代理角色；
代码量会翻倍-开发效率会变低（最重要的一点）

研究方法一般因为有需求，那需求来了，现在我们需要增加一个日志功能，怎么实现！

思路1 ：在实现类上增加代码【麻烦！】
思路2：使用代理来做，能够不改变原来的业务情况下就是不用动原始daim，实现此功能就是最好的了

2.动态代理

动态代理和静态代理角色一样

动态代理的代理类是动态生成的，不是我们直接写好的！

动态代理分为两大类：基于接口的动态代理、基于类的动态代理

动态代理的好处：

可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
公共也就交给代理角色！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理！
一个动态代理类代理的是一个接口，一般就是对应的一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可【核心】

这里需要了解两个类

Proxy：代理，

InvocationHandler：调用处理程序

了解完代理开始

3.代码实现

建立三接口三实现类

UserDao
ScoreDao
StudentDao
UserDaoImpl
ScoreDaoImpl
StudentDaoImpl

Dao 层下的代码

package com.sl.aop.dao;

public interface ScoreDao {
    public void addScore();
    public  void deleteScore();
}

package com.sl.aop.dao;

public interface StudentDao {
    public void addStudent();
    public  void deleteStudent();
}

package com.sl.aop.dao;

public interface UserDao {
    public void addUser();
    public  void deleteUser();
}

Implement层代码如下

package com.sl.aop.Impl;

import com.sl.aop.dao.ScoreDao;
import org.springframework.stereotype.Repository;

@Repository("scoreDao")
public class ScoreDaoImpl implements ScoreDao {
    @Override
    public void addScore() {
        //int i=10/0;
        System.out.println("添加");
    }

    @Override
    public void deleteScore() {
        System.out.println("删除成绩");
    }
}

package com.sl.aop.Impl;

import com.sl.aop.dao.StudentDao;
import org.springframework.stereotype.Repository;

@Repository("studentDao")
public class StudentDaoImpl implements StudentDao {
    @Override
    public void addStudent() {
        //int i=10/0;
        System.out.println("添加");
    }

    @Override
    public void deleteStudent() {
        System.out.println("删除成绩");
    }
}

package com.sl.aop.Impl;

import com.sl.aop.dao.UserDao;
import org.springframework.stereotype.Repository;

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void addUser() {
       // int i = 10 / 0;
        System.out.println("添加");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除成绩");
    }
}

Log代码如下

package com.sl.aop.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(
                "执行了"+method.getName()+"结果为"+returnValue
        );
    }
}

package com.sl.aop.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(
                target.getClass().getName()+"的"+method.getName()+"执行"
        );
    }
}

point 切点类

package com.sl.aop.point;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//注解方式去做aop
///标注这个类为切面
@Aspect
public class AnnotationPointCut {

    @Before("execution(* com.sl.aop.Impl.ScoreDaoImpl.*(..))")
    public void scorebefor() {
        System.out.println("score方法前使用这个方法");

    }

    @Before("execution(* com.sl.aop.Impl.StudentDaoImpl.*(..) )")
    public void studentbefor() {
        System.out.println("student方法前使用这个方法");
    }

    @Before("execution(* com.sl.aop.Impl.UserDaoImpl.*(..) )")
    public void userbefor() {
        System.out.println("user方法前使用这个方法");
    }

    @After("execution(* com.sl.aop.Impl.ScoreDaoImpl.*(..))")
    public void scoreafter() {
        System.out.println("scoreafter方法后使用这个方法");
    }

    @After("execution(* com.sl.aop.Impl.StudentDaoImpl.*(..))")
    public void studentafter() {
        System.out.println("studentafter方法后使用这个方法");
    }

    @After("execution(* com.sl.aop.Impl.UserDaoImpl.*(..))")
    public void userafter() {
        System.out.println("userafter方法后使用这个方法");
    }

    //在环绕增强中 ，我们可以给定一个参数，代表我们要获取这个参数的切入点
    @Around("execution(* com.sl.aop.Impl.ScoreDaoImpl.*(..))")
    public void Scorearound(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //获得签名
        Signature signature = jp.getSignature();
        System.out.println(jp.getSignature() + "Signature");
        //执行前 过滤
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
    @Around("execution(* com.sl.aop.Impl.StudentDaoImpl.*(..))")
    public void Studentaround(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //获得签名
        Signature signature = jp.getSignature();
        System.out.println(jp.getSignature() + "Signature");
        //执行前 过滤
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
    @Around("execution(* com.sl.aop.Impl.UserDaoImpl.*(..))")
    public void Useraround(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //获得签名
        Signature signature = jp.getSignature();
        System.out.println(jp.getSignature() + "Signature");
        //执行前 过滤
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

package com.sl.aop.point;

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

配置XML 并注册bean applicationContext.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
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="userDao" class="com.sl.aop.Impl.UserDaoImpl"/>
    <bean id="scoreDao" class="com.sl.aop.Impl.ScoreDaoImpl"/>
    <bean id="studentDao" class="com.sl.aop.Impl.StudentDaoImpl"/>

    <bean id="AfterLog" class="com.sl.aop.log.AfterLog"/>
    <bean id="Log" class="com.sl.aop.log.Log"/>

    <bean id="annotationPointcut" class="com.sl.aop.point.AnnotationPointCut"/>
    <aop:aspectj-autoproxy/>
</beans>

Mytext测试类

import com.sl.aop.dao.UserDao;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Mytest {
    public static void main(String[] args) {
        //动态代理得是接口 不是实现类
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao =(UserDao)context.getBean("userDao");
        userDao.addUser();
    }
}

运行结果