spring项目中aop的使用

　　AOP：是一种面向切面的编程范式，是一种编程思想，旨在通过分离横切关注点，提高模块化，可以跨越对象关注点。Aop的典型应用即spring的事务机制，日志记录。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。主要功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等；主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

　　AspectJ和Spring AOP 是AOP的两种实现方案，Aspectj是aop的java实现方案，是一种编译期的用注解形式实现的AOP；Spring aop是aop实现方案的一种，它支持在运行期基于动态代理的方式将aspect织入目标代码中来实现aop，其中动态代理有两种方式（jdk动态代理和cglib动态代理），这里不展开说。这里有几个概念，需要正确理解：

　　joinPoint:连接点。在spring中只支持方法连接点，连接点指的是可以使用advice(增强)的地方，例如一个类中有5个方法，那么这5个方法，那么这5个方法都可以是连接点。

　　pointcut:切点。可理解为实实在在的连接点，即切入advice(增强)的点。例如一个类中有5个方法，其中有3个方法（连接点）需要织入advice(增强)，那么这3个需要织入advice的连接点就是切点。

　　advice:增强。实际中想要添加的功能，如日志、权限校验。

　　advisor:切面。由切点和增强相结合而成，定义增强应用到哪些切点上。

　　Spring支持AspectJ的注解式切面编程。使用方式如下：

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

　　(2)使用@After、@Before、@Around定义增强（advice），可以直接将拦截规则作为参数（pointcut），其中@Around可以控制目标方法是否执行，并且改变返回结果。

　　(3)为了使切点复用，可以使用@PointCut专门定义拦截规则，拦截规则方式有两种：基于注解拦截和基于方法规则拦截，其中注解式拦截能够很好的控制拦截粒度和获取丰富的信息，Spring本身在处理事务和数据缓存也是使用此种方式的拦截。

　　spring-aop使用demo如下：

　　1、pom.xml，加入以下依赖

<dependency>

          <groupId>org.springframework</groupId>

          <artifactId>spring-aop</artifactId>

          <version>4.2.5.RELEASE</version>

      </dependency>

      <dependency>

          <groupId>org.aspectj</groupId>

          <artifactId>aspectjrt</artifactId>

          <version>1.7.4</version>

      </dependency>

      <dependency>

          <groupId>org.aspectj</groupId>

          <artifactId>aspectjweaver</artifactId>

          <version>1.8.10</version>

      </dependency>

　　2、自定义一个注解，作为拦截规则

package powerx.io;

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;

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface Mylog {

    String level() default "info";

}

　　3、编写功能类

package powerx.io;

import org.springframework.stereotype.Service;

@Service

public class UserService {

    @Mylog(level="debug")

    public void add() {

        System.out.println("添加用户");

    }

    @Mylog

    public void find() {

        System.out.println("查看用户");

    }

}

package powerx.io;

import org.springframework.stereotype.Service;

@Service

public class StudentService {

    public void add() {

        System.out.println("添加student");

    }

    @Mylog(level="debug")

    public Object update(String name) {

        System.out.println("更新student");

        return "更新成功";

    }

}

　　4、切面

package powerx.io;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.Around;

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;

@Aspect

@Component

public class LogAspect {

    @Pointcut("@annotation(powerx.io.Mylog)")

    public void annotationPointCut() {};

    @After("annotationPointCut()")

    public void after(JoinPoint joinPoint) {

        MethodSignature ms = (MethodSignature) joinPoint.getSignature();

        Method method = ms.getMethod();

        Mylog mylog = method.getAnnotation(Mylog.class);

        System.out.println("日志等级"+ mylog.level()+ "注解式拦截");

    }

    @Before("execution(* powerx.io.StudentService.*(..))")

    public void before(JoinPoint joinPoint) {

        MethodSignature ms = (MethodSignature) joinPoint.getSignature();

        Method method = ms.getMethod();

        System.out.println("方法规则拦截" + method.getName());

    }

    @Around("@annotation(powerx.io.Mylog)&&execution(* powerx.io.StudentService.*(..))")

    public Object around(ProceedingJoinPoint  joinPoint) {

        Object result = null;

        Object[] obs = joinPoint.getArgs();

        if(obs != null && obs.length >0) {

            String name = (String) obs[0];

            if("zhangsan".equals(name)) {

                try {

                    result = joinPoint.proceed();

                } catch (Throwable e) {

                    e.printStackTrace();

                }

            }else {

                result =  "只有张三才允许修改";

            }

        }

        return result;

    }

}

　　5、java配置

package powerx.io;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration

@ComponentScan("powerx.io")

@EnableAspectJAutoProxy//启动Spring对AspectJ的支持

public class JavaConfig {

}

　　6、主类

package powerx.io;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);

        UserService us = ac.getBean(UserService.class);

        us.add();

        us.find();

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

        StudentService ss = ac.getBean(StudentService.class);

        ss.add();

        Object ob = ss.update("zhangsan");

        System.out.println(ob);

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

        Object ob2 = ss.update("lisi");

        System.out.println(ob2);

        ac.close();

    }

}

　　运行主类，控制台显示如下：

巴特西

spring项目中aop的使用

最新文章

热门文章