1、什么是AOP
AOP(Aspect-Oriented Programming), 即 面向切面编程, 它与OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角。
在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)。
2、AOP的基本概念
- Aspect(切面):通常是一个类,里面可以定义切入点和通知
- JointPoint(连接点):程序执行过程中明确的点,一般是方法的调用
- Advice(通知/增强):AOP在特定的切入点上执行的增强处理,有before,after,afterReturning,afterThrowing,around
- Pointcut(切入点):就是带有通知的连接点,在程序中主要体现为书写切入点表达式
- AOP代理:AOP框架创建的对象,代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理,也可以是CGLIB代理,前者基于接口,后者基于子类
s
3、关于AOP该怎么玩?
实现AOP的技术,主要分为两大类:
一、是采用动态代理技术,利用截取消息的方式,对该消息进行装饰,以取代原有对象行为的执行;
二、是采用静态织入的方式,引入特定的语法创建“方面”,从而使得编译器可以在编译期间织入有关“方面”的代码。
我们在AOP底层实现重点关注动态代理技术:
1)JDK代理:基于接口的代理,一定是基于接口,会生成目标对象的接口类型的子对象。
2)Cglib代理:基于类的代理,不需要基于接口,会生成目标对象类型的子对象。
小贴士:【代理】在生活中,更像一个经纪人、中介。
4、趣谈动态代理(黑客入侵)
- jdk黑客:只能入侵实现接口的对象。针对接口实现类 。【JDK动态代理技术】
代码实现:
1) 定义一个UserDao接口:
package com.lq.dao;
public interface UserDao {
int add(int a, int b);
}
2) 接口UserDao的实现类:
package com.lq.dao.impl;
import com.lq.dao.UserDao;
public class UserDaoImpl implements UserDao {
//add方法:实现a+b的值
public int add(int a, int b) {
return a+b;
}
}
3) 定义一个JdkHk类(JDK黑客)
package com.lq.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import javax.management.loading.PrivateClassLoader;
import com.lq.dao.UserDao;
/*
* 黑客类 :(证--规范--接口:一组功能的约定)
*/
public class JdkHk implements InvocationHandler{
//目标对象
private Object target;
public JdkHk(UserDao userDao) {
this.target=userDao;
}
/**
* 黑客类入侵的方法
* proxy:代理对象
* method:入侵的目标的方法
* args:入侵的目标的方法的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("黑客开始入侵!!");
//干坏事(在这里我们可以通过修改参数,来控制最后结果的输出!结果为:1+2=3)
args[0]=1;
args[1]=2;
//调用目标方法
Object result = method.invoke(target, args);
System.out.println("黑客入侵接结束");
return result;
}
}
4) 定义一个测试类 Test
package com.lq.proxy;
import java.lang.reflect.Proxy;
import com.lq.dao.UserDao;
import com.lq.dao.impl.UserDaoImpl;
public class Test01 {
public static void main(String[] args) {
//客户端---调用目标类(UserDaoImpl)的目标方法add方法
// UserDao userDao = new UserDaoImpl();
// int result = userDao.add(3, 5);
// System.out.println("result==>:"+result);
//目标对象
UserDao target=new UserDaoImpl();
//黑客对象
JdkHk jdkHk=new JdkHk(target);
//代理对象
/*
* loader 类加载器
* ClassLoader.getSystemClassLoader() 获取当前程序的类加载器
* interfaces 目标的实现的接口class
* h invocationHandler对象--黑客对象
* 字节码拼接技术
*/
UserDao userDao = (UserDao)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] {
UserDao.class}, jdkHk);
//客户端
int result = userDao.add(55, 22);
System.err.println("结果为===》"+result);
}
}
5)输出结果为:
2.spring黑客:针对类(aspect包—spring提供的)。
aopalliance: MethodInteceptor 当类实现接口内部用的jdk黑客;如果类没有实现接口 ,用cglib动态代理。
代码实现:
1)定义一个UserDaoImpl类
package com.lq.dao.impl;
public class UserDaoImpl {
public int add(int a,int b) {
System.out.println("调用UserDaoImpl的add方法");
return a+b;
}
}
2) 定义一个SpringHk对象:
package com.lq.proxy;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class SpringHk implements MethodInterceptor{
/**
* invocation :目标对象的目标方法
*/
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("1、鉴权");
//调用目标方法
Object result=invocation.proceed();
System.out.println("1、日志留痕");
return result;
}
}
- 配置spring_beans.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--1、目标对象 -->
<bean id="userDao" class="com.lq.dao.impl.UserDaoImpl">
</bean>
<!-- 2、Spring黑客对象 -->
<bean id="springHk" class="com.lq.proxy.SpringHk">
</bean>
<!-- 3、代理对象 -->
<bean id="userDaoProxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 3.1目标对象 -->
<property name="target" ref="userDao"></property>
<!-- 3.2黑客对象 -->
<property name="interceptorNames">
<array>
<value>springHk</value>
</array>
</property>
</bean>
</beans>
4)编写测试类SpringHkTest.java
package com.lq.proxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.lq.dao.impl.UserDaoImpl;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-beans.xml")
public class SpringHkTest {
@Autowired // 默认按类型注入,通过@Qualifier修改为按名称注入
@Qualifier("userDaoProxy")
private UserDaoImpl userDao;
@Test
public void test01() {
System.out.println(userDao.add(22, 22));
}
}
- 测试结果为:
总结:可以使用JDK动态代理(实现接口类) 也可以使用Cglib动态代理(类或实现接口类)