关于Spring aop
一、概念
AOP（Aspect Oriented Programming），即面向切面编程，能够说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来创建一种对象层次结构，用于模拟公共行为的一个集合。不过OOP容许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码每每横向地散布在全部对象层次中，而与它对应的对象的核心功能毫无关系对于其余类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它致使了大量代码的重复，而不利于各个模块的重用。java
AOP技术偏偏相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减小系统的重复代码，下降模块之间的耦合度，并有利于将来的可操做性和可维护性。git
使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特色是，他们常常发生在核心关注点的多处，而各处基本类似，好比权限认证、日志、事物。AOP的做用在于分离系统中的各类关注点，将核心关注点和横切关注点分离开来。spring
二、相关术语
一、横切关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点编程
二、切面（aspect）：类是对物体特征的抽象，切面就是对横切关注点的抽象安全
三、链接点（joinpoint）：被拦截到的点，由于Spring只支持方法类型的链接点，因此在Spring中链接点指的就是被拦截到的方法，实际上链接点还能够是字段或者构造器app
四、切入点（pointcut）：对链接点进行拦截的定义ide
五、通知（advice）（interceptor）：所谓通知指的就是指拦截到链接点以后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类oop
六、目标对象：代理的目标对象测试
七、织入（weave）：将切面应用到目标对象并致使代理对象建立的过程this
八、引入（introduction）：在不修改代码的前提下，引入能够在运行期为类动态地添加一些方法或字段
三、 AOP的实现机制
3.一、JDK动态代理
3.1.一、动态代理
Java在JDK1.3后引入的动态代理机制，使咱们能够在运行期动态的建立代理类。使用动态代理实现AOP须要有四个角色：被代理的类，被代理类的接口，织入器，和InvocationHandler，而织入器使用接口反射机制生成一个代理类，而后在这个代理类中织入代码。被代理的类是AOP里所说的目标，InvocationHandler是切面，它包含了Advice和Pointcut。
3.1.二、代码实现（相关代码来自Spring.3.x企业应用开发实战）
// 使用动态代理必须涉及到接口
// 动态代理自己就是基于接口的代理机制
public interface ForumService {
void removeTopic(int topicId);
void removeForum(int forumId);
}
// 接口实现类
public class ForumServiceImpl implements ForumService {
@Override
public void removeTopic(int topicId) {
// TODO Auto-generated method stub
System.out.println("模拟删除Topic记录:" + topicId);
try {
Thread.currentThread().sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void removeForum(int forumId) {
// TODO Auto-generated method stub
System.out.println("模拟删除Forum记录:" + forumId);
try {
Thread.currentThread().sleep(40);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 切面
// 在切入点上须要加入的额外处理
public class PerformanceMonitor {
private static ThreadLocal<MethodPerformance> performanceRecord = new ThreadLocal<MethodPerformance>();
public static void begin(String method) {
System.out.println("begin monitor...");
MethodPerformance mp = new MethodPerformance(method);
performanceRecord.set(mp);
}
public static void end() {
System.out.println("end monitor...");
MethodPerformance mp = performanceRecord.get();
mp.printPerformance();
}
}
// 动态代理
public class TestForumService {
public static void test() {
// 建立好要被代理的对象，再经过动态代理机制生成代理对象
final ForumService target = new ForumServiceImpl();
// proxy 并非target对象，可是都是实现自ForumService接口的实例
ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), new InvocationHandler() {
// InvocationHandler对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 执行该切入点方法以前，须要切面处理
PerformanceMonitor.begin(target.getClass().getName() + method.getName());
Object obj = method.invoke(target, args);
PerformanceMonitor.end();
return obj;
}
});
proxy.removeForum(10);
proxy.removeTopic(1012);
}
public static void main(String[] args) {
test();
}
}
3.1.三、小结
从代码实现的角度来讲，JDK动态代理技术其实很是简单，关键的代码是：
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h);
而动态代理自己的原理不外呼就是将咱们执行的对象转为执行经过动态代理生成的InvocationHandler类型的实例对象的invoke方法。至于要细致到底层实现原理，建议经过代码去分析，本文关注点在于了解aop，并了解如何去实现，没有考虑到具体的代码分析，因此不作赘述。
3.二、 动态字节码生成
3.2.一、动态字节码
使用动态字节码生成技术实现AOP原理是在运行期间目标字节码加载后，生成目标类的子类，将切面逻辑加入到子类中，因此使用Cglib实现AOP不须要基于接口。
3.2.二、代码实现（相关代码来自Spring.3.x企业应用开发实战）
// CGlib代理机制则是实现自接口MethodInterceptor
// 能够理解为'拦截器'
//
public class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
/**
* 动态建立带有横切逻辑的代理实例
*
* @param enhancer 加强对象（织入器 ）
* @param method
* @param args
* @param methodProxy 拦截目标对象类的全部方法的子类
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object enhancer, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
PerformanceMonitor.begin(enhancer.getClass().getName() + method.getName());
Object obj = methodProxy.invokeSuper(enhancer, args);// 经过代理子类调用父类的方法
PerformanceMonitor.end();
return obj;
}
public Object getProxy(Class clazz) {
enhancer.setSuperclass(clazz);// 目标对象类
enhancer.setCallback(this);
return enhancer.create();// 经过字节码技术建立目标对象类的子类实例做为代理
}
}
public class TestForumService {
public static void testCglib() {
// 该代理实现过程并未涉及接口
// 也就是说cglib技术并不要求必定要经过实现接口的方式来作切面
ForumServiceImpl proxy = (ForumServiceImpl) new CglibProxy().getProxy(ForumServiceImpl.class);
proxy.removeForum(10);
proxy.removeTopic(1012);
}
public static void main(String[] args) {
testCglib();
}
}
}
3.2.三、小结
本质上，cglib是生成了一个扩展自ForumServiceImpl 的子类，而后经过子类调用父类的方式来实现的动态代理。因此它没有了JDK动态代理的基于接口的限制。
四、Spring aop
4.一、经过ProxyFactoryBean来使用spring aop功能
// 在切面中切入日志控制
public class LoggerBeforeAdvice implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("=======保存更新日志=========");
}
}
// 在切面中切入权限控制
public class SecurityInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("==========执行安全校验====================");
return methodInvocation.proceed();
}
}
// 注意看两个类分别实现了两个不一样的接口
// 一个是advicor，一个是interceptor
/**
* 测试代理工厂类
*
* @author Administrator
*
*/
public class TestProxyFactory {
public static void main(String[] args) {
test();
}
public static void test() {
ForumService target = new ForumServiceImpl();
// 2.AOP 代理工厂
ProxyFactory proxyFactory = new ProxyFactory(target);
// 3.装配Advice
proxyFactory.addAdvice(new SecurityInterceptor());
proxyFactory.addAdvice(new LoggerBeforeAdvice());
//proxyFactory.addAdvisor(new DefaultPointcutAdvisor(new LoggerBeforeAdvice()));
//// 4.获取代理对象
ForumService proxy = (ForumService) proxyFactory.getProxy();
proxy.removeForum(1);
proxy.removeTopic(2);
}
}
4.2 基于@AspectJ
// 实现方式很是简单
// 可是要注意orderd的排序，由于有可能这个点有多个切面
// ordered能够决定执行的顺序
@Aspect
@Component
public class ForumLoggerAspect implements Ordered{
// pointcut
@Before("execution(* com.example.aop.common.*Impl.*(..))")
public void before() {
System.out.println("=======保存更新日志=========");
}
@Override
public int getOrder() {
// TODO Auto-generated method stub
return 1;
}
}
4.3 使用BeanNameAutoProxyCreator建立代理
// 拦截器
public class LoggerMethodInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("调用前，=======打印日志=========");
Object object = invocation.proceed();
System.out.println("调用后，=======打印日志=========");
return object;
}
}
@Configuration
public class AppConfig {
// 要建立代理的目标Bean
@Bean
public ForumService forumService() {
return new ForumServiceImpl();
}
// 建立Advice或Advisor（Interceptor）
@Bean
public Advice loggerMethodInterceptor() {
return new LoggerMethodInterceptor();
}
// 使用BeanNameAutoProxyCreator来建立代理
@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
// 设置要建立代理的那些Bean的名字
beanNameAutoProxyCreator.setBeanNames("forumService*");
// 设置拦截链名字(这些拦截器是有前后顺序的)
beanNameAutoProxyCreator.setInterceptorNames("loggerMethodInterceptor");
return beanNameAutoProxyCreator;
}
}
public class TestBeanNameAutoProxyCreator {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
ForumService forumService = applicationContext.getBean(ForumService.class);
forumService.removeForum(1);
forumService.removeTopic(2);
}
}
4.四、使用DefaultAdvisorAutoProxyCreator建立代理
// 拦截器
public class LoggerMethodInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("调用前，=======打印日志=========");
Object object = invocation.proceed();
System.out.println("调用后，=======打印日志=========");
return object;
}
}
@Configuration
public class AppConfig1 {
// 要建立代理的目标Bean
@Bean
public ForumService forumService() {
return new ForumServiceImpl();
}
// 建立Advice或Advisor(Interceptor)
@Bean
public Advice loggerMethodInterceptor() {
return new LoggerMethodInterceptor();
}
// 使用Advice建立Advisor
@Bean
public NameMatchMethodPointcutAdvisor nameMatchMethodPointcutAdvisor() {
NameMatchMethodPointcutAdvisor nameMatchMethodPointcutAdvisor = new NameMatchMethodPointcutAdvisor();
nameMatchMethodPointcutAdvisor.setMappedNames("remove*");
nameMatchMethodPointcutAdvisor.setAdvice(loggerMethodInterceptor());
return nameMatchMethodPointcutAdvisor;
}
@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
return new DefaultAdvisorAutoProxyCreator();
}
}
public class TestDefaultAdvisorAutoProxyCreator {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig1.class);
ForumService forumService = applicationContext.getBean(ForumService.class);
forumService.removeForum(1);
forumService.removeTopic(2);
}
}
五、总结
本文并未涉及相关实现源码以及底层相关技术细节的描述，目的是但愿能够简单了解aop的相关技术（其实java aop上的实现并不仅是jdk动态代理和cglib，还有好比利用类加载，字节码转换器等等），由于spring 上对于aop的实现是基于这两种，因此就简单聊聊这两种。后续若是对源码有一点了解也会记录下来。
总的来讲，aop技术是对oop技术的一个完善，在实际开发中使用很是普遍，包括咱们经常使用的日志，权限，事务后来咱们在处理多数据源上也是使用aop来作（后边抽空整理一下Spring动态切换数据源技术）。
因此掌握aop技术是很是重要的！！！
参考文章：
相关文章
- 1. Spring，关于aop的理解
- 2. 关于Spring Aop和事务记录
- 3. Spring AOP 基于AspectJ
- 4. 关于Spring
- 5. 动态AOP-Spring AOP 基于@AspectJ
- 6. Spring（五）Spring AOP--关于面向切面编程的理解
- 7. 关于Spring框架
- 8. spring AOP的相关术语
- 9. 【Spring】AOP的相关概念
- 10. Spring aop相关术语
- 更多相关文章...
- • Spring使用AspectJ开发AOP：基于XML和基于Annotation - Spring教程
- • Spring基于Annotation装配Bean - Spring教程
- • NewSQL-TiDB相关
- • ☆基于Java Instrument的Agent实现
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章