spring基础之AOP

6人阅读 评论(0) 收藏 举报
分类:

AOP:面向切面编程,相对于OOP面向对象编程

Spring中的AOP的存在目的是为了解耦。AOP可以让一组类共享相同的行为。在OOP中只能通过继承类和实现接口,来使代码的耦合度增强,且类继承只能为单继承,阻碍更多行为添加到一组类上,AOP弥补了OOP的不足。

Spring支持AspectJ的注解式切面编程。

(1)使用@AspectJ声明一个切面

(2)使用@After、@Before、@Around定义建言(advice),可直接将拦截规则(切点)作为参数。

(3)其中@After、@Before、@Around参数的拦截规则为切点(PointCut),为了使切点复用,可使用@PointCut专门定义拦截规则,然后在@After、@Before、@Around的参数中调用。

(4)其中符合条件的每一个被拦截处为连接点(JoinPoint)。


示例代码:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.minivision.caixing.learn</groupId>
    <artifactId>caixing_learn</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>

    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.5</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.5</version>
        </dependency>


    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

FunctionService.java

package com.minivison.caixing.learn;

import com.minivison.caixing.learn.aop.Action;
import org.springframework.stereotype.Service;

/**
 * <Description> <br>
 *
 * @author caixing<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018年04月12日 <br>
 */
@Service
public class FunctionService {

    @Action(name="该注解被调用")
    public String sayHello(String word){
        return "hello "+word+"!";
    }
}

UseFunctionService.java

package com.minivison.caixing.learn;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * <Description> <br>
 *
 * @author caixing<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018年04月12日 <br>
 */
@Service
public class UseFunctionService {

    @Autowired
    private FunctionService service;

    public String SayHello(String word){
        return  service.sayHello(word);
    }

}

Config.java

package com.minivison.caixing.learn;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * <Description> <br>
 *
 * @author caixing<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018年04月12日 <br>
 */
@Configuration
@ComponentScan({"com.minivison.caixing.learn","com.minivison.caixing.learn.aop"})
@EnableAspectJAutoProxy
public class Config {
}

Action.java

package com.minivison.caixing.learn.aop;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * <Description> <br>
 *
 * @author caixing<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018年04月16日 <br>
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Action {
    String name();
}

LogAspect.java

package com.minivison.caixing.learn.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * <Description> <br>
 *
 * @author caixing<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018年04月16日 <br>
 */
@Aspect
@Component
public class LogAspect {
    @Pointcut("@annotation(com.minivison.caixing.learn.aop.Action)")
    public void annotationPointCut(){};

    @After("annotationPointCut()")
    public void after(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        Method method = signature.getMethod();
        Action action = method.getAnnotation(Action.class);
        System.out.println(action.name());
    }

    @Before("execution(* com.minivison.caixing.learn.UseFunctionService.*(..))")
    public void before(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("调用之前:"+method.getName());
    }

}

Main.java

package com.minivison.caixing.learn;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * <Description> <br>
 *
 * @author caixing<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2018年04月12日 <br>
 */
public class Main {
    public static void main(String[] args){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        UseFunctionService service = context.getBean(UseFunctionService.class);
        System.out.println(service.SayHello("spring"));
    }
}

查看评论

Spring AOP学习笔记(1):AOP基础知识

一、使用AOP前的经验
  • lmy86263
  • lmy86263
  • 2016-02-27 01:49:28
  • 1223

Spring Aop完整实例

Spring Aop完整实例,按照下面说明配置和代码即可完成,因为在刚接触新东西时,最简单的就是一个可以运行的DEMO,可查了很多文章都是不全或者运行有问题,所以自己写一个。 说明:本文需要有Spr...
  • zhao50632
  • zhao50632
  • 2014-02-27 11:22:47
  • 1568

spring aop spring aop

  • 2011年06月29日 15:59
  • 23KB
  • 下载

Spring Aop基础总结

spring aop
  • liangwenmail
  • liangwenmail
  • 2015-08-13 20:35:50
  • 431

Spring框架 之 Spring AOP理论基础

一、Spring AOP是什么?    AOP(Aspect-Oriented Programming),被译为“面向切面编程”,是通过预编译的方式或运行时动态代理方法(详见:《Spring框架 之 ...
  • weixin_40185254
  • weixin_40185254
  • 2018-02-25 16:45:17
  • 21

Spring AOP:基本概念,基础接口,基础类,基本流程

一、基本概念 Aspect:切面就是一个关注点的模块化,如事务管理、日志管理、权限管理等; JoinPoint:程序执行的一个点,如方法的执行或者异常的捕获; Advice:在特定的连接点执行的...
  • bubaxiu
  • bubaxiu
  • 2014-12-28 21:52:11
  • 770

srping aop应用

  • 2018年03月15日 20:26
  • 4KB
  • 下载

【SSH进阶之路】Spring的AOP逐层深入——AOP的基本原理(六)

AOP(Aspect Oriented Programming),意思是面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。...
  • jiuqiyuliang
  • jiuqiyuliang
  • 2015-02-27 11:40:07
  • 12953

ioc AOP深入了解

  • 2014年11月25日 16:48
  • 842KB
  • 下载

spring切面AOP所使用的jar包

  • 2015年05月13日 17:01
  • 1.52MB
  • 下载
    个人资料
    持之以恒
    等级:
    访问量: 911
    积分: 258
    排名: 30万+
    最新评论