详解Java Spring AOP
程序员文章站
2022-03-13 18:51:11
目录前言一.aop底层原理1.aop底层使用动态代理二.aop术语1.连接点2.切入点3.通知(增强)4.切面三.aop 操作（准备工作）spring 框架一般都是基于 aspectj 实现 aop...
前言
面向切面编程，利用 aop 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
即不改变源代码而添加新功能,可插拔的.
提示：以下是本篇文章正文内容，下面案例可供参考
一.aop底层原理
1.aop底层使用动态代理
有接口:jdk动态代理,即创建接口实现类代理对象
无接口:cglib动态代理,即创建子类代理对象
jdk动态代理的实现
创建接口
package com.vector.spring5;
public interface userdao {
public int add(int a,int b);
public string update(string id);
}
接口实现类
接口实现类的方法,属于源代码,用aop思想增添新功能时这里不能动!
package com.vector.spring5;
public class userdaoimpl implements userdao{
@override
public int add(int a, int b) {
return a+b;
}
@override
public string update(string id) {
return id;
}
}
使用jdk动态代理对象,增添新功能
package com.vector.spring5;
import java.lang.reflect.array;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
import java.util.arrays;
public class jdkproxy {
public static void main(string[] args) {
//创建接口实现类代理对象
class[] interfaces = {userdao.class};
userdaoimpl userdao = new userdaoimpl();
userdao dao= (userdao) proxy.newproxyinstance(jdkproxy.class.getclassloader(),interfaces,new userdaoproxy(userdao));
int result = dao.add(1,2);
system.out.println("result: "+result);
}
}
//创建代理对象
class userdaoproxy implements invocationhandler{
//有参构造传递增强对象
private object obj;
public userdaoproxy(){};
public userdaoproxy(object obj){
this.obj=obj;
}
//增强的逻辑
@override
public object invoke(object proxy, method method, object[] args) throws throwable {
//方法之前
system.out.println("方法之前执行: "+method.getname()+":传递的参数: "+ arrays.tostring(args));
//被增强的方法执行
//可以根据method.getname()判断选择增强
object res = method.invoke(obj,args);
//方法之后
system.out.println("方法之后执行: "+obj);
return res;
}
}
jdk代理图像解析
二.aop术语
1.连接点
类里可以被增强的方法,称为连接点.
2.切入点
类中实际被增强的方法,成为切入点.
3.通知(增强)
(1)实际被增强的方法中的逻辑部分称为通知(增强).
(2)通知包含:前置通知,后置通知,环绕通知,异常通知,最终通知
4.切面
把增强应用到切入点的过程称为切面
三.aop 操作（准备工作）
spring 框架一般都是基于 aspectj 实现 aop 操作
（1）aspectj 不是 spring 组成部分，独立 aop 框架，一般把 aspectj 和 spirng 框架一起使用，进行 aop 操作
maven准备
<dependency>
<groupid>org.aspectj</groupid>
<artifactid>aspectjweaver</artifactid>
<version>1.9.8.rc1</version>
</dependency>
方式一:使用spring的接口实现增添功能
实现组合crud和日志功能结合
applicationcontext.xml
<context:component-scan base-package="com.vector"/>
<aop:config>
<!-- 切入点: expression:表达式 execution(要执行的位置!* * * * *)-->
<aop:pointcut id="pointcut" expression="execution(* com.vector.service.userserviceimpl.*(..))"/>
<!-- 执行环绕增加!-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>
</aop:config>
log.java
package com.vector.log;
import org.springframework.aop.methodbeforeadvice;
import org.springframework.stereotype.component;
import java.lang.reflect.method;
@component("log")
public class log implements methodbeforeadvice {
//method: 要执行的目标对象的方法
//args: 参数
//target: 目标对象
@override
public void before(method method, object[] args, object target) throws throwable {
system.out.println(target.getclass().getname()+"的"+method.getname()+"被执行了");
}
}
userservice.java
package com.vector.service;
public interface userservice {
public void add();
public void delete();
public void update();
public void query();
}
userserviceimpl.java
package com.vector.service;
import org.springframework.stereotype.service;
@service("userservice")
public class userserviceimpl implements userservice{
@override
public void add() {
system.out.println("增加了一个用户");
}
}
mytest.java
public class mytest {
public static void main(string[] args) {
applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
//动态代理的是接口
userservice userservice = (userservice) context.getbean("userservice");
userservice.add();
}
}
方式二:自定义类
diypoint.java
package com.vector.diy;
import org.springframework.stereotype.component;
@component("diypointcut")
public class diypointcut {
public void before(){
system.out.println("===方法执行前===");
}
public void after(){
system.out.println("===方法执行后===");
}
}
userserviceimpl.java
package com.vector.service;
import org.springframework.stereotype.service;
@service("userservice")
public class userserviceimpl implements userservice{
@override
public void add() {
system.out.println("增加了一个用户");
}
}
applicationcontext.xml
<aop:config>
<!-- 自定义切面,ref要引用的类-->
<aop:aspect ref="diypointcut">
<!-- 切入点-->
<aop:pointcut id="pointcut" expression="execution(* com.vector.service.userserviceimpl.*(..))"/>
<!-- 通知-->
<aop:before method="before" pointcut-ref="pointcut"/>
<aop:after method="after" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
mytest.java
public class mytest {
public static void main(string[] args) {
applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
//动态代理的是接口
userservice userservice = (userservice) context.getbean("userservice");
userservice.add();
}
}
方式三:全注解配置实现
userserviceimpl.java
package com.vector.service;
import org.springframework.stereotype.service;
@service("userservice")
public class userserviceimpl implements userservice{
@override
public void add() {
system.out.println("增加了一个用户");
}
}
annotationpointcut.java
package com.vector;
import org.aspectj.lang.annotation.after;
import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.springframework.context.annotation.enableaspectjautoproxy;
import org.springframework.stereotype.component;
//标注这个类是一个切面
@aspect
@component("annotationpointcut")
//开启aop注解驱动
@enableaspectjautoproxy
public class annotationpointcut {
@before("execution(* com.vector.service.userserviceimpl.*(..))")
public void before(){
system.out.println("===方法执行前===");
}
@after("execution(* com.vector.service.userserviceimpl.*(..))")
public void after(){
system.out.println("===方法执行后===");
}
}
mytest.java
public class mytest {
public static void main(string[] args) {
applicationcontext context = new classpathxmlapplicationcontext("applicationcontext.xml");
//动态代理的是接口
userservice userservice = (userservice) context.getbean("userservice");
userservice.add();
}
}
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!