java实现OTOP算法 java实现aop方法

实现AOP的三种方式

AOP是什么

Spring的一种横切技术，在开发时可能需要对原来的业务进行增强或者加日志，这个时候就可以使用AOP来对其进行操作。

java实现动态代理的两种方式

JDK动态代理

操作的实现了接口的实体类，利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

CGLIB动态代理

利用ASM（开源的Java字节码编辑库，操作字节码）开源包，将代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

区别：JDK代理只能对实现接口的类生成代理；CGlib是针对类实现代理，对指定的类生成一个子类，并覆盖其中的方法，这种通过继承类的实现方式，不能代理final修饰的类。

实现AOP之前的准备工作

1、创建一个UserService接口

package com.cheng.service;

public interface UserService {
    void add();

    void delete();

    void update();

    void query();
}

2、创建UserServiceImpl类实现这个接口

package com.cheng.service;

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("更新了一个用户");
    }

    public void query() {
        System.out.println("查询了一个用户");
    }
}

在Spring配置文件中注册Bean

<bean id="userService" class="com.cheng.service.UserServiceImpl"/>

创建好代理对象之后就可以进行之后的操作了。

方式一：spring自带API接口

1、编写两个类实现MethodBeforeAdvice和AfterReturningAdvice接口

before类：

public class Log implements MethodBeforeAdvice {

    //method： 要执行的目标对象的方法
    //args: 参数
    //target: 目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}

after类：

public class AfterLog implements AfterReturningAdvice {

    //returnValue 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法，返回结果为:" + returnValue);
    }
}

2、在Spring配置文件中配置AOP切入点

<!--方式一：使用原生spring API接口-->
    <!--配置aop:需要导入aop约束-->
    <aop:config>
    <!--切入点 execution(要执行的位置)-->
    <aop:pointcut id="pointCut" expression="execution(* com.cheng.service.UserServiceImpl.*(..))"/>

    <!--执行环绕增加！-->
    <aop:advisor advice-ref="log" pointcut-ref="pointCut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointCut"/>

    </aop:config>

3、查看运行结果：

方式二：自定义类

使用自定义类的方式来对代理对象进行增强

1、首先需要DIY一个切入类实现需要切入的方法

public class diyPointCut {

    public void before() {
        System.out.println("========方法执行前========");
    }

    public void after() {
        System.out.println("========方法执行后========");
    }
}

2、在applicationContext.xml文件中进行配置

<!--方式二:自定义类-->
    <bean id="diy" class="com.cheng.diy.diyPointCut"/>

    <aop:config>
    <!--自定义切面 : ref 要引入的类-->
    <aop:aspect ref="diy">
    <!--切入点-->
    <aop:pointcut id="point" expression="execution(* com.cheng.service.UserServiceImpl.*(..))"/>
    <!--通知-->
    <aop:before method="before" pointcut-ref="point"/>
    <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
    </aop:config>

3、运行结果：

方式三：注解实现

使用注解相对而言就比较简单，只需要在Spring配置文件中开启注解支持 aop:aspectj-autoproxy/

并将对应切入类注册Bean就可以使用了

1、创建AnnotationPointCut类使用注解切入

@Aspect//标注这个类是切面
public class AnnotationPointCut {

    @Before("execution(* com.cheng.service.UserServiceImpl.*(..))")//切入位置
    public void before() {
        System.out.println("方法执行前");
    }

    @After("execution(* com.cheng.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("方法执行后");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.cheng.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前：");

        Signature signature = joinPoint.getSignature();
        System.out.println("signature: " + signature);
        //执行方法
        Object proceed = joinPoint.proceed();

        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

可以看出如果需要使用注解进行切入：

1、首先需要在类前注解@Aspect表明这是一个切面类

2、可以使用注解@Before,@After,@Around并给定一个execution()参数表明切入点来对其需要的位置进行切入

2、注册Bean并打开注解支持

<!--方式三：注解实现-->
<bean id="annotationPointCut" class="com.cheng.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>

3、运行结果：