AOP:面向切面编程,采用横向抽取机制,取代了传统纵向继承体系重复性代码(性能监视,事务管理,安全检查,缓存)
对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间耦合度降低,提高程序可重用性,同时提高开发效率。
AOP技术术语:
joinpoint(连接点)--所谓连接点就是指那些被拦截到的点,在spring中,这些点指方法。因为spring只支持方法类型的连接点
pointcut(切入点)--指我们要对那些joinpoint之后所要做的事情,就是通知。通知分为 前置通知 后置通知 异常通知 最终通知 和环绕通知(切面要完成的功能)
target(目标对象)-- 代理的目标对象
weaving(织入)--是指吧增强应用目标对象来创建新的代理对象的过程
proxy(代理)--一个类被AOP织入增强后,就产生一个结果代理类Aspect(切面)--是切入点和通知的结合
在开始之前我们先简单叙述一下AOP的底层,基于代理模式实现
代理模式:
-
静态代理
角色分析:
-
抽象角色:一般会使用接口或者抽象类来解决
-
真实角色:被代理的角色
-
代理角色:代理真实的角色,代理真实的角色后,一般会做一些附属操作
-
客户:访问被对象的人
代码步骤
-
接口
//住房 public interface Rent { public void rent(); }
-
真实角色
//房东 public class Host implements Rent { @Override public void rent() { System.out.println("房东要出租房子!"); } }
-
代理角色
public class Proxy implements Rent { private Host host; public Proxy() { } public Proxy(Host host) { this.host = host; } @Override public void rent() { seeHouse(); host.rent(); hetong(); fare(); } public void seeHouse(){ System.out.println("中介带你看房"); } public void hetong(){ System.out.println("签租赁合同"); } public void fare(){ System.out.println("收中介费"); } }
-
客户端访问代理角色
public class Client { public static void main(String[] args) { //房东要出租房子 Host host = new Host(); // host.rent(); //代理,中介帮房东出租房子,但是会有附属操作 Proxy proxy = new Proxy(host); proxy.rent(); } }
静态代理模式的好处:
-
可以使真实角色的操作更加纯粹 ,不用去关注一些公共业务
-
公共业务就交给代理角色,实现业务分工
-
公共业务发生扩展的时候,方便集中管理
缺点:
-
一个真实角色就会产生一个代理角色,代码量变多
-
2.动态代理
-
动态代理和静态代理角色一样
-
动态代理的代理类是动态生成的,不是我们直接写好的
-
动态代理分为两大类:基于接口的动态代理,基于类的动态代理
-
基于接口的---JDK动态代理
-
基于类:cglib
-
Java字节码实现 :javasist
-
需要了解两个类:Proxy:代理,InvocationHandler:调用处理程序
Hsot和Rent类不变
代理类
//等会我们会用这个类 自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
//处理代理实例,并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
//动态代理的本质,就是使用反射机制实现
Object result = method.invoke(rent, args);
fare();
return result;
}
public void seeHouse(){
System.out.println("中介带你看房子");
}
public void fare(){
System.out.println("中介收钱");
}
}
客户端实现
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理:现在没有
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色来处理我们要调用的接口对象
pih.setRent(host);
Rent proxy = (Rent) pih.getProxy();//这里的proxy就是动态生成的,我们并没有写
proxy.rent();
}
}
动态代理的好处:
-
可以使真实角色的操作更加纯粹 ,不用去关注一些公共业务
-
公共业务就交给代理角色,实现业务分工
-
公共业务发生扩展的时候,方便集中管理
-
一个动态代理类代理一个接口,一般就是对应的一类业务
-
一个动态代理类可以代理多个类,只要是实现了同一个接口
如果与代理模式不熟悉的朋友请深刻了解一下反射机制,这样会更容易理解代理模式
Spring实现AOP
使用AOP织入,导入依赖包
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
方式一:使用Spring的API接口
编写业务和业务实现类
public interface UserService {
void add();
void delete();
void update();
void query();
}
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("添加一个用户");
}
@Override
public void delete() {
System.out.println("删除一个用户");
}
@Override
public void update() {
System.out.println("更新一个用户");
}
@Override
public void query() {
System.out.println("查询一个用户");
}
}
编写需要横向扩展的功能
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()+"被执行了");
}
}
public class AfterLog implements AfterReturningAdvice {
//returnValue:返回值
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了"+method.getName()+"方法,返回结果为:"+returnValue);
}
}
配置applicationContext.xml
<!--注册bean-->
<bean id="userService" class="com.qyh.service.UserServiceImpl"/>
<bean id="log" class="com.qyh.log.Log"/>
<bean id="afterLog" class="com.qyh.log.AfterLog"/>
<!--方式一:使用原生的Spring API接口-->
<!--配置AOP-->
<aop:config>
<!--切入点 expression:表达式,execution(要执行的位置! * * * * *)-->
<aop:pointcut id="pointcut" expression="execution(* com.qyh.service.UserServiceImpl.*(..))"/>
<!--执行环绕增加-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
编写测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理 代理的是接口 不是实现类
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
运行结果
方式二:自定义类实现AOP
自定义类:
public class DiyPointCut {
public void before(){
System.out.println("====方法执行前===");
}
public void after(){
System.out.println("====方法执行后===");
}
}
applicationContext.xml
<!--方式二:自定义类-->
<bean id="diy" class="com.qyh.diy.DiyPointCut"/>
<aop:config>
<!--自定义切面,ref 要引用的类-->
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="point" expression="execution(* com.qyh.service.UserServiceImpl.*(..))"/>
<!--通知-->
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
测试类不变
运行结果
第二种方法更为简单,当然用注解开发会更简单。
方式三:使用注解实现AOP
编写切面类:
//方式三:使用注解开发
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect//标注这是个切面
public class AnnotationPointCut {
@Before("execution(* com.qyh.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("方法执行之前");
}
}
applicationContext.xml
<!--方式三-->
<bean id="annotationPointCut" class="com.qyh.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>
测试类不变
运行结果