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/>测试类不变
运行结果
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
