Spring AOP讲解

最新推荐文章于 2022-01-27 18:14:29 发布
最新推荐文章于 2022-01-27 18:14:29 发布
阅读量127 收藏
点赞数
分类专栏： spring 文章标签： spring aop java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jintianzheng/article/details/116224724
版权

三、Spring AOP

1. AOP前奏

1.1 需求

  • 日志，在程序执行期间追踪正在发生的活动
  • 验证，程序执行期间处理合法数据

1.2 代码

UserDao接口以及实现类

public interface UserDao {
    void insertUser();
    void updateUser();
    void deleteUser(int id);
    List<String> selectUser();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void insertUser() {
        //在方法种主要业务逻辑代码开始之前，加入日志记录
        System.out.println("日志：用户新增...");

        System.out.println("通过JDBC实现用户新增...");
    }

    @Override
    public void updateUser() {
        System.out.println("日志：用户修改...");

        System.out.println("通过JDBC实现用户修改...");
    }

    @Override
    public void deleteUser(int id) {
        System.out.println("日志：用户删除...");

        System.out.println("通过JDBC实现用户删除...");
    }

    @Override
    public List<String> selectUser() {
        System.out.println("日志：用户查询...");

        System.out.println("通过JDBC实现用户查询...");
        return null;
    }
}

测试

public class ProxyTest {
    @Test
    public void test(){
        UserDao userDao = new UserDaoImpl();

        userDao.insertUser();

        userDao.updateUser();

        userDao.deleteUser(10);

        List<String> list =  userDao.selectUser();
        System.out.println(list);
    }
}

1.3 问题

  • 代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点
  • 代码分散：以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块

2. 代理模式

使用代理模式解决上述问题

在这里插入图片描述

代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上

2.1 静态代理

每个业务接口都需要有一个对应的代理类，并实现业务接口

public class UserDaoProxy implements UserDao {
    private UserDao userDao;

    public UserDaoProxy(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void insertUser() {
        System.out.println("日志记录：用户新增...");
        userDao.insertUser();
    }

    @Override
    public void updateUser() {
        System.out.println("日志记录：用户修改...");
        userDao.updateUser();
    }

    @Override
    public void deleteUser(int id) {
        System.out.println("日志记录：用户删除..." + id);
        userDao.deleteUser(id);
    }

    @Override
    public List<String> selectUser() {
        System.out.println("日志记录：用户查询...");
        return userDao.selectUser();
    }
}

测试

public class ProxyTest {
    @Test
    public void testStaticProxy(){
        UserDao userDao = new UserDaoProxy(new UserDaoImpl());

        userDao.insertUser();

        userDao.updateUser();

        userDao.deleteUser(10);

        List<String> list =  userDao.selectUser();
        System.out.println(list);
    }
}
  • 优点: 简单、易于理解
  • 缺点: 项目庞大后业务接口过多，造成代理类过多

2.2 JDK动态代理

JDK动态代理：采用Java反射机制中的动态代理，实现InvocationHandler接口

public class LoggerProxy implements InvocationHandler {
    /**
     * 执行目标（最终要执行业务逻辑类）方法
     * @param proxy 代理类对象
     * @param method 目标方法对象
     * @param args 目标方法的参数值列表
     * @return 目标方法的返回值
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //日志记录的代码
        System.out.println("代理日志：目标方法--前置" + method.getName() + "....");
        //执行目标方法（业务逻辑方法）
        Object result_val = null;
        try{
            result_val =  method.invoke(targetClass.newInstance(), args);
            System.out.println("代理日志：目标方法--返回" + method.getName() + "....");
        }catch (Exception e){
            System.out.println("代理日志：目标方法--异常" + method.getName() + "....");
        }
        System.out.println("代理日志：目标方法--后置" + method.getName() + "....");
        return result_val;
    }
    /**
     * 目标对象的Class类型
     */
    private Class targetClass;

    /**
     * 获取代理对象
     *
     * 注意：JDK中的动态代理，要求业务类必须是接口+实现类的形式
     */
    public Object getProxy(Class targetClass){
        this.targetClass = targetClass;
        return Proxy.newProxyInstance(targetClass.getClassLoader(),targetClass.getInterfaces(),this);
    }
}

测试

public class ProxyTest {
    @Test
    public void testDynamicProxy(){
        UserDao userDao = (UserDao) new LoggerProxy().getProxy(UserDaoImpl.class);
        System.out.println(userDao);
        userDao.insertUser();
        userDao.updateUser();
        userDao.deleteUser(10);
        List<String> list =  userDao.selectUser();
        System.out.println(list);
        System.out.println("---------------------------");
        PersonDao personDao = (PersonDao) new LoggerProxy().getProxy(PersonDaoImpl.class);
        personDao.insertPerson();
    }
}

2.3 Cglib动态代理

Cglib动态代理，实现cglib包下的MethodInterceptor接口

public class CglibProxy implements MethodInterceptor {
    /**
     *
     * @param obj CGLib动态生成的代理类对象
     * @param method 目标方法对象
     * @param args 目标方法的参数值列表
     * @param proxy 代理类对方法的代理对象
     * @return 目标方法的返回值
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Cglib动态代理...");
        //执行目标方法（业务逻辑方法）
        Object result_val = null;
        try{
            result_val =  method.invoke(targetClass.newInstance(), args);
        }catch (Exception e){
        }
        return result_val;
    }

    /**
     * 目标对象的Class类型
     */
    private Class targetClass;

    /**
     * 获取代理对象
     *
     * 注意：JDK中的动态代理，要求业务类必须是接口+实现类的形式
     */
    public Object getProxy(Class targetClass){
        //为目标对象target赋值
        this.targetClass = targetClass;
        Enhancer enhancer = new Enhancer();
        //设置父类,因为Cglib是针对指定的类生成一个子类，所以需要指定父类
        enhancer.setSuperclass(targetClass);
        //设置回调
        enhancer.setCallback(this);
        //创建并返回代理对象
        Object result = enhancer.create();
        return result;
    }
}

测试

public class ProxyTest {
    @Test
    public void testCglibProxy(){
        UserDao userDao = (UserDao) new CglibProxy().getProxy(UserDaoImpl.class);
        System.out.println(userDao);
        userDao.insertUser();
        userDao.updateUser();
        userDao.deleteUser(10);
        List<String> list =  userDao.selectUser();
        System.out.println(list);
    }
}

3. AOP简介

  • AOP(Aspect Orienten Programming)面向切面编程，是一种新的方法论，是对传统 OOP(Object-Oriented Programming)面向对象编程的补充
  • AOP的主要编程对象是切面(aspect)，而切面模块化的横切关注点
  • 在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的对象(切面)里
  • AOP的好处：每个事物逻辑位于一个位置，代码不分散，便于维护和升级。业务模块更简洁，只包含核心业务代码

在这里插入图片描述

4. AOP术语

  • 切面aspect：横切关注点(跨越多个模块的功能)，使其成为一个独立，应用于其他模块之中的模块。被模块化的特殊对象
  • 通知adivce：切面需要完成的工作
  • 目标target：被通知的对象
  • 代理proxy：向目标对象通知之后创建的对象
  • 连接点joinPoint：程序执行的某个特殊位置
    ​比如：某个方法在被调用时，方法执行之前，方法执行之后，方法返回值之后，方法抛出异常之后
  • 切点pointCut：由众多连接点组成的

通知类型

  • 前置通知：在方法执行之前实施的通知
  • 后置通知：在方法执行之后实施的通知
  • 返回通知：在方法返回结束之后实施的通知
  • 异常通知：在方法出现异常并抛出异常之后实施的通知
  • 环绕通知：围绕着目标方法实施通知，实际上就是以上所有通知的综合

5. AOP的开发步骤

5.1 加入相应的jar包

在这里插入图片描述

maven依赖配置

<dependencies>
  <!-- spring核心包-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.3.18.RELEASE</version>
  </dependency>
  <!-- springbean包 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>4.3.18.RELEASE</version>
  </dependency>
  <!-- springcontext包 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.18.RELEASE</version>
  </dependency>
  <!-- spring表达式包 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>4.3.18.RELEASE</version>
  </dependency>
  <!-- springAOP包 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.3.18.RELEASE</version>
  </dependency>
  <!-- springAspects包 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.18.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
  </dependency>
</dependencies>

5.2 命名空间以及标签规范

在spring的配置文件中加入aop命名空间以及aop标签规范

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

5.3 编写切面类

定义一个普通Java类，在其中添加功能方法

/**
 * 日志切面类：日志记录功能
 */
public class LogAspect {

    /**
     * 前置通知：在目标方法执行之前实现的功能
     */
    public void beforeMethod(){
        System.out.println("AOP日志记录：前置通知......");
    }
}

切面完整代码

/**
 * 日志切面类：日志记录功能
 */
public class LogAspect {

    /**
     * 前置通知：在目标方法执行之前实现的功能
     * 参数：JoinPoint连接点对象，可获取当前要执行的目标方法的信息
     */
    public void beforeMethod(JoinPoint joinPoint){
        //通过连接点对象获取方法的名称
        String methodName = joinPoint.getSignature().getName();
        //方法的参数值列表
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP日志记录：前置通知......" + methodName + Arrays.toString(args));
    }
    /**
     * 后置通知：在目标方法执行之后实现的功能
     */
    public void afterMethod(JoinPoint joinPoint){
        //通过连接点对象获取方法的名称
        String methodName = joinPoint.getSignature().getName();
        //方法的参数值列表
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP日志记录：后置通知......" + methodName + Arrays.toString(args));
    }

    /**
     * 返回通知：在目标方法有返回值之后实现的功能
     * 通过方法的参数获取目标方法的返回值数据
     */
    public void afterReturnMethod(JoinPoint joinPoint, Object resultValue){
        //通过连接点对象获取方法的名称
        String methodName = joinPoint.getSignature().getName();
        //方法的参数值列表
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP日志记录：返回通知......" + methodName + Arrays.toString(args));
        System.out.println("方法的返回值为：" + resultValue);
    }

    /**
     * 异常通知：在目标方法抛出异常之后实现的功能
     * 通过方法参数获取目标方法抛出的异常对象
     */
    public void afterThrowMethod(JoinPoint joinPoint, Exception ex){
        //通过连接点对象获取方法的名称
        String methodName = joinPoint.getSignature().getName();
        //方法的参数值列表
        Object[] args = joinPoint.getArgs();
        System.out.println("AOP日志记录：异常通知......" + methodName + Arrays.toString(args));
        System.out.println("方法抛出的异常对象：" + ex);
    }

    /**
     * 环绕通知：综合以上所有的通知
     */
    public void aroundMethod(ProceedingJoinPoint proceedingJoinPoint){
        System.out.println("AOP日志记录：环绕通知之前置......");
        try {
            //手动执行目标方法
            //proceed()就是在执行目标方法，其返回值为目标方法的返回值
            Object resultValue = proceedingJoinPoint.proceed();
            System.out.println("AOP日志记录：环绕通知之返回......");
        } catch (Throwable throwable) {
            System.out.println("AOP日志记录：环绕通知之异常......");
            throwable.printStackTrace();
        }
        System.out.println("AOP日志记录：环绕通知之后置......");
    }
}

5.4 配置AOP

  • 将目标类和切面类都配置到IOC容器中
  • 配置AOP：配置切点表达式，配置切面类，配置通知
<?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:util="http://www.springframework.org/schema/util"
  xmlns:p="http://www.springframework.org/schema/p"
  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.xsd
  http://www.springframework.org/schema/util
  http://www.springframework.org/schema/util/spring-util.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd">

  <!-- 1.配置bean-->
  <bean id="userDao" class="com.newcapec.dao.UserDaoImpl"/>
  <bean id="personDao" class="com.newcapec.dao.PersonDaoImpl"/>
  <bean id="log" class="com.newcapec.aspect.LogAspect"/>

  <!-- 2.配置AOP-->
  <aop:config>
    <!--  公用切点表达式
		 	id : 切点表达式的名称
		 	expression : 切点表达式的内容
		-->
    <aop:pointcut id="exp1" expression="execution(* com.newcapec.dao.*Impl.*(..))"/>
    <aop:pointcut id="exp2" expression="execution(public void com.newcapec.dao.UserDaoImpl.insertUser())"/>
    <aop:pointcut id="exp3" expression="execution(* com.newcapec.dao.UserDaoImpl.findUser(..))"/>
    <aop:pointcut id="exp4" expression="execution(* com.newcapec.dao.PersonDaoImpl.insertPerson(..))"/>

    <!-- 2.1 配置切面类-->
    <aop:aspect ref="log">
      <!-- 2.2 配置通知-->
      <!--
			<aop:before>：表示前置通知
            <aop:after>：表示后置通知
            <aop:after-returning>：表示返回通知
            <aop:after-throwing>：表示异常通知
            <aop:around>：表示环绕通知

			method ： 切面对象中执行该通知的方法，通知的方法名称
			2.3 配置切点表达式
			告知spring，通知应用在哪些方法（目标方法，业务逻辑方法）上
			pointcut ： 切点表达式
			编写规则：以execution()包裹起来的内容
				1.单个方法，具体方法
				语法：execution(方法访问修饰符 返回值类型 方法所在的包名.类名.方法名(参数类型,...))
				例如：execution(public void com.newcapec.dao.UserDaoImpl.insertUser())
				2.多个方法，批量方法：*符号作为通配符
				语法：execution(* 方法所在的包名.类名.*(..))
				例如：execution(* com.newcapec.dao.UserDaoImpl.*(..))
				例如：execution(* com.newcapec.*.dao.*.*(..))
				3.通配，所有方法
				语法：execution(* *.*.*(..))

			pointcut-ref : 引用公共切点表达式
			returning : 在返回通知中接收方法返回值的参数名称
			throwing : 在异常通知中接收方法抛出的异常对象的参数名称
			-->
      <!--<aop:before method="beforeMethod" pointcut="execution(public void com.newcapec.dao.UserDaoImpl.insertUser())"/>-->
      <!--<aop:before method="beforeMethod" pointcut="execution(* com.newcapec.dao.*Impl.*(..))"/>-->
      <aop:before method="beforeMethod" pointcut-ref="exp1"/>
      <aop:after method="afterMethod" pointcut-ref="exp2"/>
      <aop:after-returning method="afterReturnMethod" pointcut-ref="exp3" returning="resultValue"/>
      <aop:after-throwing method="afterThrowMethod" pointcut-ref="exp4" throwing="ex"/>
      <!--<aop:around method="aroundMethod" pointcut-ref="exp1"/>-->
    </aop:aspect>
  </aop:config>
</beans>

5.5 测试

public class AOPTest {

    @Test
    public void test(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao = ac.getBean("userDao", UserDao.class);

        userDao.insertUser();
        System.out.println("------------------");

        userDao.updateUser();
        System.out.println("------------------");

        userDao.deleteUser(1);
        System.out.println("------------------");

        userDao.selectUser();
        System.out.println("------------------");

        PersonDao personDao = ac.getBean("personDao", PersonDao.class);
        personDao.insertPerson();

    }
}

注意：在目标方法出现异常后，返回通知不再执行。但是在目标方法没有出现异常时，异常通知不会执行

5.6 切面的优先级

<aop:aspect>标签中配置order属性，属性值为数字。数字越小优先级越高，该切面功能越先被执行

/**
 * 另一个切面类
 */
public class OtherAspect {

    public void beforeM(){
        System.out.println("OtherAspect的beforeM方法.....");
    }
}

<bean id="other" class="com.newcapec.aspect.OtherAspect"/>

<aop:config>
    <!--
        切面优先级：决定哪个切面中通知先执行，哪个后执行
        在前置通知中：优先级高的先执行，优先级低的后执行
        在后置通知中：优先级高的后执行，优先级低的先执行
        <aop:aspect>标签中的order属性决定了优先级的高低，其值越小优先级越高
    -->
    <aop:aspect ref="log" order="2">
    </aop:aspect>
    <aop:aspect ref="other" order="1">
        <aop:before method="beforeM" pointcut-ref="exp1"/>
    </aop:aspect>
</aop:config>
JTZ001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring AOP详解
Lzc的博客
06-16 3009
一、AOP 1.1、AOP介绍 1.1.1、什么是AOP？ 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从...
利用AOP实现打印接口调用基本信息（统计接口调用时长）
liangsheng_g的专栏
04-30 828
文章目录前言一、AOP是什么二、打印接口调用信息1.why？2. code2.读入数据总结 前言 之前写过一篇博客，利用AOP进行接口调用频控设置；这次写一篇利用AOP打印接口调用基本信息。 一、AOP是什么 aop的基本使用和解释，可以参考其他博客，或者Spring的官网：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-api 二、打印接口调用信息 1.why？ 有时候线上或者某个环境发
Spring中实现AOP的三种方式
dadadaliang的博客
02-15 651
第一种使用Spring的API接口实现 写在前头：要实现AOP第一需要做的就是需要导入织入依赖包 <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> </dependency>
Spring的AOP实现原理
m0_57229961的博客
01-27 9316
本学习笔记将尽可能的将AOP的知识讲解的通俗易懂，先从一个典型的问题出发，引入AOP这个概念，介绍AOP的基本概念，再到Spring中的AOP的实现方案，最后进行一个简单的总结归纳。本学习笔记中不考虑cglib、也不会太关注Spring AOP如何使用，而是尽可能的简单的说清楚AOP的工作原理。 笔记中贴出的源代码均是Spring 5.1.7-RELEASE 版本 问题提出 如下代码块，现在需要统计这个方法执行的耗时情况 public void runTask() { doSome
Spring AOP实验
06-05
一、 实验目的 1、了解AOP的概念和作用； 2、理解AOP中的相关术语； 3、了解Spring中两种动态代理方式的区别； 4、掌握基于XML和注解的AspectJ开发。 二、 实验内容 1、按图所示的类图结构，设计接口及其实现类，并完成另外两附加要求：（1）日志功能：在程序执行期间追踪正在发生的活动（打印出调用的方法，以及参数的参数值）；（2）验证功能：希望计算器只能处理正数的运算，当有负数参与运算时，给出提示说明。 分别使用基于XML和注解的AspectJ实现上述功能(创建两个项目)。 （图就是int加减乘除）
SpringAOP示例讲解
02-25
`SpringAop.ppt`文件很可能包含了一个详细的讲解，涵盖了Spring AOP的基本概念、配置方式、使用注解声明切面、基于XML的配置以及如何自定义切面。PPT通常会通过图表、代码示例和流程图来帮助理解复杂的概念，使得...
springAOP代理讲解
07-15
spring框架的AOP代理模式讲解及例子
Spring AOP 基于注解详解及实例代码
01-08
Spring AOP 基于注解详解及实例代码 1.启用spring对@AspectJ注解的支持: <beans xmlns:aop=http://www.springframework.org/schema/aop...> <!--启动支持--> <aop> 也可以配置...
Java应用开发实验二.docx
05-14
一、实验目的 1、了解AOP的概念和作用； 2、理解AOP中的相关术语； 3、了解Spring中两种动态代理方式的区别； 4、掌握基于XML和注解的AspectJ开发。 二、实验内容 1、按图所示的类图结构，设计接口及其实现类，并完成另外两附加要求：（1）日志功能：在程序执行期间追踪正在发生的活动（打印出调用的方法，以及参数的参数值）；（2）验证功能：希望计算器只能处理正数的运算，当有负数参与运算时，给出提示说明。 分别使用基于XML和注解的AspectJ实现上述功能(创建两个项目)。
Spring4—AOP编程
06-09
aop写一个简单的计算器：（1）日志功能：在程序执行期间追踪正在发生的活动（打印出调用的方法，以及参数的参数值）；（2）验证功能：希望计算器只能处理正数的运算，当有负数参与运算时，给出提示说明。 利用简单的实例来理解spring的aop编程，以aspectJ为例，理解环绕通知的真正含义。
SpringAop学习笔记以及实现Demo
06-17
SpringAOP学习笔记以及四个可运行的Demo，涵盖经典代理模式、基于注解、基于xml配置这3方面的Demo
java计算器.zip
07-17
java计算器 加减乘除 .该程序实现带有优先级的数学运算，支持的运算包括加、减、乘、除、乘方、开方运算，并支持括号操作三、功能介绍: 符合基本计算器的优先级运算,支持加、减、乘、除、乘方、开方运算。 GUI图形用户界面。 四、架构设计： 1.界面布局，对菜单的实现，按钮的显示。 2.监听接口。 3.计算过程（计算优先级）。
SpringAOP.zip
07-25
Spring AOP，全称为Aspect Oriented Programming，是Spring框架中的一个重要模块，主要负责处理系统中的...文件"5.SpringAOP_01"和"6.SpringAOP_02"很可能是课程的分阶段内容，涵盖了从基础概念到进阶实践的详细讲解。
spring ioc和aop讲解项目demo
最新发布
05-09
本项目"spring ioc和aop讲解项目demo"旨在通过实际操作来帮助开发者深入理解这两个核心概念。 首先，让我们详细讨论一下Spring的IOC，全称Inversion of Control，即控制反转。在传统的程序设计中，对象创建和管理的...
Spring - (4) AOP前奏：代理模式
myllxy
10-12 184
一.情景再现 数学计算器 ： ①执行加减乘除运算 ②日志：在程序执行期间追踪正在发生的活动 ③验证：希望计算器只能处理正数的运算 问题： ①代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。 ②代码分散: 以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需...
Spring之AOP
ShuJk的博客
04-05 306
AOP前奏 需求1-日志：在程序执行期间追踪正在发生的活动 需求2-验证：希望计算器只能处理正数的运算 （1）ArithmeticCalculator接口： package com.sjk.spring.aop; public interface ArithmeticCalculator { public double add(double i,double j); ...
Spring AOP
请叫我法斗先生
07-16 227
需求1-日志：在程序执行期间追踪正在发生的活动出现的问题是 代码混乱：越来越多的非业务需求（日志和验证）加入后，原有的业务方法极具膨胀 代码分散： 以日志需求为例，为了满足单一需求，就不得不在多个模块里多次重复的日志代码使用动态代理解决上述问题 代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要代理，代理对象决定是否以及何时将方法调用到原始对象
spring aop实例讲解
04-26
好的，讲解一下spring aop实例。在Spring框架中，AOP(Aspect-oriented programming)可以帮助我们更好地实现面向切面的编程，解耦业务代码和非业务代码，提高系统的可维护性和可扩展性。下面是一个基本的AOP实例： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JTZ001

你的鼓励是我创作的最大动力？

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值