java面向切面编程

1、面向编程概念

AOP的全称是Aspect-Oriented Programming，即面向切面编程(也称面向方面编程)。它是面向对象编程(OOP)的一种补充，目前已成为一种比较成熟的编程方式。面向对象编程是按业务执行的时间轴执行，面向切面是对某个时间点的逻辑添加，是一个动态的过程。

首先：在spring包下闯将dao.Callnterface的java接口(录入以下内容)

package com.test.spring.dao;public interface Callnterface {int add(int num1,int num2);int sub(int num1,int num2);int mul(int num1,int num2);int div(int num1,int num2);
}

接着在spring包底下创建impl包中创建Callmpl类

Callmpl类内容如下：

package com.test.spring.impl;import com.test.spring.dao.Callnterface;public class Callmpl implements Callnterface {
//    @Override
//    public int add(int num1,int num2){
//        System.out.println("参数1" + num1 + "参数2"  + num2);
//        int sum = num1 + num2;
//        System.out.println("sum = " + sum);
//        return sum;
//    }@Overridepublic int add(int num1, int num2) {return num1+num2;}@Overridepublic int sub(int num1, int num2) {return num1-num2;}@Overridepublic int mul(int num1, int num2) {return num1*num2;}@Overridepublic int div(int num1, int num2) {return num1/num2;}
}

创建并继承上面Callnterface接口，并构造方法，如上述。

然后在我们spring包底下在构建一个util包创建JDKProxy类在里面继承InvocationHandler如下：

此时希望在业务执行前后记录日志。正常模拟处理在前后加打印语句

构造完整代码：导入包后直接粘贴复制即可注意大小写的区分

package com.test.spring.util;import com.test.spring.dao.Callnterface;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;public class JDKProxy implements InvocationHandler {private Callnterface callnterface;public Object createProxy(Callnterface callnterface){this.callnterface = callnterface;ClassLoader classLoader = JDKProxy.class.getClassLoader();Class<?>[] interfaces = callnterface.getClass().getInterfaces();return Proxy.newProxyInstance(classLoader,interfaces,this);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {String methodName = method.getName();System.out.println("方法:" + methodName + " 执行，参数为:" + Arrays.asList(args));Object result = method.invoke(callnterface,args);System.out.println("方法:" + methodName + " 执行，结果为:" + result); return result;}
}

接着打开之前创建的BeanTest1测试类构造一个@Test方法进行测试内容如下：

@Testpublic void testjdkProxy(){Callnterface callnterface = new Callmpl();JDKProxy jdkProxy = new JDKProxy();Callnterface proxy = (Callnterface)jdkProxy.createProxy(callnterface);int num = proxy.add(12, 3);System.out.println("num = " + num);}

设置参数为（12）（3）

执行查看结果：

可以看到测试通过

2.动态代理

JDK动态代理
第一步:导入依赖当前模块的pom.xml文件添加依赖:

<dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId>
</dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId>
</dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId>
</dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId>
</dependency>

在pom.xml中添加上面四个类

再创建包com.test.spring.util，在其下创建JDKProxy类，实现InvocationHandler接口，代码如下:

package com.test.spring.util;import com.test.spring.dao.Callnterface;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;public class JDKProxy implements InvocationHandler {private Callnterface callnterface;public Object createProxy(Callnterface callnterface){this.callnterface = callnterface;ClassLoader classLoader = JDKProxy.class.getClassLoader();Class<?>[] interfaces = callnterface.getClass().getInterfaces();return Proxy.newProxyInstance(classLoader,interfaces,this);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {String methodName = method.getName();System.out.println("方法:" + methodName + " 执行，参数为:" + Arrays.asList(args));Object result = method.invoke(callnterface,args);System.out.println("方法:" + methodName + " 执行，结果为:" + result); return result;}
}

当前项目结构：

在注解方式AOP下再导入：

<dependencyManagement><dependencies>
<!-- 此处省略之前添加的依赖，以下依赖为添加内容 --> <dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>5.2.9.RELEASE</version></dependency><dependency><groupId>aopalliance</groupId><artifactId>aopalliance</artifactId><version>1.0</version></dependency></dependencies>
</dependencyManagement>

在application.xml文件中一定要导入扫描引用如下：(没导入之前)

<?xmlversion="1.0"encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsd"><context:component-scan base-package="com.aop.test"/><!-- 开启切面自动代理 默认为JDK动态代理 --><aop:aspectj-autoproxy/></beans>

导入之后：（可直接复制粘贴使用这一类）

<?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:p="http://www.springframework.org/schema/p"xmlns:c="http://www.springframework.org/schema/c"xmlns:util="http://www.springframework.org/schema/util"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util.xsd
">

增加部分如下：

xmlns:aop="http://www.springframework.org/schema/aop" 2 xsi:schemaLocation="<!-- 此处省略其他内容 -->http://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsd"

接着在aop底下加入spring扫描组件

回到BeanTest1测试类新建一个测试方法如下：

 @Testpublic void testApectj(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");Calcalute calcalute = applicationContext.getBean("calcalute", Calcalute.class);int num = calcalute.add(12, 13);System.out.println("num = " + num);}

注意认真区分calcalute的单词拼写与大小写

测试结果：

感谢大家观看

java面向切面编程相关推荐

一个简单的Spring的AOP例子（JAVA面向切面编程）
公司要求分享技术,一个小组九个人,每周一个人,想想讲讲AOP吧,用处也挺大的,果断写了一个小例子,改了改也就成了.这是个简单AOP例子,包括前置通知,后置通知,环绕通知,和目标对象. 目标对象的接口: ...
java aop面向切面编程
最近一直在学java的spring boot,一直没有弄明白aop面向切面编程是什么意思.看到一篇文章写得很清楚,终于弄明白了,原来跟python的装饰器一样的效果.http://www.cnblog ...
浅谈Java和SAP ABAP的静态代理和动态代理，以及ABAP面向切面编程的尝试
文章目录 Java的静态代理静态代理的优缺点 ABAP的静态代理 Spring AOP的动态代理 JDK动态代理的优缺点 CGLIB动态代理的优缺点 ABAP CGLIB的模拟实现 ABAP Pre ...
java springboot aop_Spring Boot实战系列(3)AOP面向切面编程
AOP是一种与语言无关的程序思想.编程范式.项目业务逻辑中,将通用的模块以水平切割的方式进行分离统一处理,常用于日志.权限控制.异常处理等业务中. 快速导航编程范式主要以下几大类 AOP(Aspec ...
java spring 面向切面编程_Spring Boot实战系列(3)AOP面向切面编程
AOP是一种与语言无关的程序思想.编程范式.项目业务逻辑中,将通用的模块以水平切割的方式进行分离统一处理,常用于日志.权限控制.异常处理等业务中. 快速导航编程范式主要以下几大类 AOP(Aspec ...
java框架013——Spring AOP面向切面编程
一.Spring AOP简介 AOP的全称是Aspect-Oriented Programming,即面向切面编程(也称面向方面编程).它是面向对象编程(OOP)的一种补充,目前已成为一种比较成熟的编 ...
Java绝地求生—Spring AOP面向切面编程
Java绝地求生-Spring AOP面向切面编程背景动态代理构建被代理对象自动生成代理调用动态代理 Spring方法方式一:使用Spring的API接口方式二:使用自定义类方式三:使 ...
什么是 Java 中的 AOP（面向切面编程）？如何使用它来实现横切关注点？
AOP(Aspect-oriented programming,面向切面编程),是一种编程思想和技术,旨在将横切关注点和主业务逻辑分离,使得系统更容易扩展和维护.在 Java 中,AOP 主要通过代理 ...
java切面编程切面概念,面向切面编程(AOP)初探
面向对象编程通过设计和语言本身提供的模块化.封装.继承.多态来实现软件复用.尽管OOP在建模以及实现复杂软件方面非常成功,它仍然有一些问题.面向切面编程(AOP)被认为是一项有前途的新技术,它通过对交 ...

java面向切面编程

java面向切面编程相关推荐

最新文章

热门文章