Spring Aop 小练习（Idea+Maven+Spring++MVC+Aop+注解）实现

左手的ㄟ右手 2021-11-10 06:04 224阅读 0赞

昨天我们对Spring Aop的概念有了一个清晰的认识，今天我看了很多网上很多人的博客，写了一个Spring Aop的小练习，以此来加深对Aop的印象和理解。

使用的工具是Idea ,用Maven 建了一个Maven工程，其中引入了Spring 和 SpringMVC 和 AOP，使用注解的方式来实现了一个AOP的小练习，并在这里做了一个整理和记录，方便以后查看。

首先，使用Maven 新建一个Maven 项目，并且引入对 Spring MVC的依赖，这一点不会的同学可以去我的博客去看另一篇：

[https://blog.csdn.net/liuying1802028915/article/details/90643364][https_blog.csdn.net_liuying1802028915_article_details_90643364]

我的项目结构是这样的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXlpbmcxODAyMDI4OTE1_size_16_color_FFFFFF_t_70][]

这是最终的项目结构

我们先实现不使用AOP的功能。

很简单就是一个Controller,一个Service

对了首先现在pom文件中引入我们想要的jar包

<dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>3.1.0</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>4.3.13.RELEASE</version>
        </dependency>
    
    
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>4.3.13.RELEASE</version>
        </dependency>
    
    
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>4.3.13.RELEASE</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>4.3.13.RELEASE</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aspects</artifactId>
          <version>4.3.13.RELEASE</version>
        </dependency>
    
    
    
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>4.3.13.RELEASE</version>
        </dependency>

接下来我帖上Controller和Service

HelloController

package com.taoj.controller;
    
    import com.taoj.service.DemoService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    @Controller
    public class HelloController {
    
        @Autowired
        private DemoService demoService;
    
        @RequestMapping("hello")
        @ResponseBody
        public String sayHello(){
            demoService.doSome1();
            demoService.doSome2();
            demoService.doSome3();
            System.out.println(demoService.doSome4("小虎", 24));
            return "helo  dddd";
        }
    
    }

DemoService

package com.taoj.service;
    
    public interface DemoService {
    
        public void doSome1();
    
        public void doSome2();
    
        public void doSome3();
    
        public String doSome4(String name, int age);
    
    }

DemoServiceImpl

package com.taoj.service.impl;
    
    import com.taoj.service.DemoService;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    import org.springframework.stereotype.Service;
    
    @Service
    @EnableAspectJAutoProxy
    public class DemoServiceImpl implements DemoService {
        @Override
        public void doSome1() {
            System.out.println("DemoServiceImpl---doSome1");
        }
    
        @Override
        public void doSome2() {
            System.out.println("DemoServiceImpl---doSome2");
        }
    
        @Override
        public void doSome3() {
            System.out.println("DemoServiceImpl---doSome3");
        }
    
        @Override
        public String doSome4(String name, int age) {
            String msg = name+"今年"+age+"岁了";
            System.out.println("msg:"+msg);
            return msg;
        }
    }

接下来我们在配置文件DispatcherService.xml中添加 注解扫描的代码：

<context:component-scan base-package="com.taoj" />

我认为以上已经是添加完Tomcat了，然后启动tomcat, 访问：[http://localhost:8080/aop/hello.form][http_localhost_8080_aop_hello.form]

界面展示如下：

![20190802114601342.png][]

没问题

后台Console输出为：

DemoServiceImpl---doSome1
    DemoServiceImpl---doSome2
    DemoServiceImpl---doSome3
    msg:小虎今年24岁了
    小虎今年24岁了

可以依次理解其中的含义，以上都是SpringMVC的知识，不理解的可以去看SpringMVC相关的知识。

接下来AOP登场了，我定义了一个切面类LogAspect.java

输出结果为：

DemoServiceImpl---doSome1  
doSome2运行了，参数列表是\[Ljava.lang.Object;@121cfd0  
DemoServiceImpl---doSome2  
DemoServiceImpl---doSome3  
msg:小虎今年24岁了  
小虎今年24岁了

我们看到引入切面类之后多了这句：

doSome2运行了，参数列表是\[Ljava.lang.Object;@121cfd0

接下来我们来分析一下LogAspect,我们认为 LogAspect.java为一个切面类（这样理解应该对吧，如果有不对之处，还请指正）

首先LogAspect 类 头上引入了@Aspect注解，说明这是一个切面类，@Component 是为了Spring 把这个类扫描进去

@pointCut 后面的是切点表达式 ：

execution(public void com.taoj.service.impl.DemoServiceImpl.doSome2() 这个为切点表达式，这一看一目了然，只针对

com.taoj.service.impl.DemoServiceImpl 类中的 doSome() 方法

然后后面的

@Before("pointCut()")
        public void logStart(JoinPoint joinPoint){
            Object[] args = joinPoint.getArgs();
            String functionName = joinPoint.getSignature().getName();
            System.out.println(functionName+"运行了，参数列表是"+args);
        }

这个方法表示在在切点（满足切点表达式的方法）方法执行前执行，所以我们再来看输出结果：

DemoServiceImpl---doSome1  
doSome2运行了，参数列表是\[Ljava.lang.Object;@121cfd0  
DemoServiceImpl---doSome2  
DemoServiceImpl---doSome3  
msg:小虎今年24岁了  
小虎今年24岁了

我们看到 doSome2运行了，参数列表是\[Ljava.lang.Object;@121cfd0 是在 DemoServiceImpl---doSome2 之前执行

这样就能说明结果了。

接下来再来看：LogAspect.java

package com.taoj.aspect;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    @Aspect
    @Component
    public class LogAspect {
    
        @Pointcut("execution(public void com.taoj.service.impl.DemoServiceImpl.doSome2())")
        public void pointCut(){
    
        }
    
    //    @Before("pointCut()")
    //    public void logStart(JoinPoint joinPoint){
    //        Object[] args = joinPoint.getArgs();
    //        String functionName = joinPoint.getSignature().getName();
    //        System.out.println(functionName+"运行了，参数列表是"+args);
    //    }
    
        @Before("pointCut()")
        public void logStart(){
            System.out.println("LogAspect----logStart");
        }
    
        @AfterReturning("execution(public String com.taoj.service.impl.DemoServiceImpl.*(..))")
        public void afterReturning(JoinPoint joinPoint){
            String methodName = joinPoint.getSignature().getName();
            Object[] args = joinPoint.getArgs();
            System.out.println("LogAspect---afterReturning--返回结果前,该方法名为"+methodName+",方法参数为"+args);
        }
    
        @After("execution(* com.taoj.service.impl.DemoServiceImpl.*())")
        public void logEnd(){
            System.out.println("LogAspect---logEnd");
        }
    
    
    
    }

输出结果为：

DemoServiceImpl---doSome1  
LogAspect---logEnd  
LogAspect----logStart  
DemoServiceImpl---doSome2  
LogAspect---logEnd  
DemoServiceImpl---doSome3  
LogAspect---logEnd  
msg:小虎今年24岁了  
LogAspect---afterReturning--返回结果前,该方法名为doSome4,方法参数为\[Ljava.lang.Object;@e971b3b  
小虎今年24岁了

以上结果我们可以通过分析切点表达式来分析得到，很简单，我这里就不再赘述 （\*的使用，还可以用within,this等）以后再学习

以上这就是一个简单的aop的实现。方便以后查看

不积跬步，无以至千里

不积小流，无以成江海

[https_blog.csdn.net_liuying1802028915_article_details_90643364]: https://blog.csdn.net/liuying1802028915/article/details/90643364
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXlpbmcxODAyMDI4OTE1_size_16_color_FFFFFF_t_70]: /images/20211109/1bee191aeedc4a98a80c86b4a27f6056.png
[http_localhost_8080_aop_hello.form]: http://localhost:8080/aop/hello.form
[20190802114601342.png]: /images/20211109/0cfd2664fa78417b944d7846586a27c4.png