分享一下我对aop的一点个人见解（持续更新中....）

分享一下我对aop的一点个人见解（持续更新中…）

关于aop

AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。
通俗来说，aop就是拓展，可以让程序做更多的事情。打个比方，例如一盘西红柿炒蛋，主心骨就是西红柿和鸡蛋，当你加入一些葱花的时候，会令这盘菜更香，这个就是aop了。
这个图是网上找的，画的很生动，就拿来了，嘿嘿。

AOP的核心

(1)pointcut-切入点
(2)joinpoint-连接点
(3)order-优先级
(4)advice-通知

结合例子去分析

package com.cy.pj.common.aspect;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;@Aspect
@Component
public class SysTimeAspect {@Pointcut("bean(sysUserDeptServiceImpl)")public void doTime() {}@Before("doTime()")public void dobefore() {System.out.println("@before");}@After("doTime()")public void doafter() {System.out.println("@after");}@AfterReturning("doTime()")public void doafterreturning() {System.out.println("@doafterReturning");}@AfterThrowing("doTime()")public void doafterthrowing() {System.out.println("@doafterThrowing");}@Around("doTime()")public  Object doAround(ProceedingJoinPoint jp)throws Throwable{System.out.println("around.before");try {Object result=jp.proceed();		System.out.println("around.after");return result;} catch (Exception e) {System.out.println("around.exception");throw e;}}
}

#aspect作为横向切面对象，在开头用@Aspect声明
pointcut作为多个连接点的集合，在这个例子中他就连接了serviceimpl中的
sysUserDeptServiceImpl，意思即是我们后面做的动作都是在sysUserDeptServiceImpl中去实现。
而现在我们来谈谈pointcut中的bean和annotation的区别
bean后面是一个切入点的表达式
annotation后为一个整体的表达式，如（@annotation(com.require)）
此处所有包含@require的都能接收到动作

@Around 环绕，优先级最高
然后依次为
@Before
@After
如果有错，则抛出
@AfterThrowing
没错则
@AfterReturning

关于joinpoint和proceedingjoinpoint

proceedingjoinpoint是继承于joinpoint,只能用于@Around环绕注解的方法参数里。
两者通俗来说就是让目标方法去执行。

关于order

public @interface Order {/*** The order value.* <p>Default is {@link Ordered#LOWEST_PRECEDENCE}.* @see Ordered#getOrder()*/int value() default Ordered.LOWEST_PRECEDENCE;}

在order的源码中，我们可以看到，他是lowest的，意思则是若没有在order后标识数字，order的优先级是最低的。而当我们为order注入数字时，举个例子order(1)和order(9) 数字越小，优先级越高，而且他是相当于一个链式结构的，优先级越高的越后出来，相反，优先级越低的，越先出来。

关于aop中的异步

在开发系统中，通常会考虑系统的性能问题，为了让系统的性能能更加快更加快，一般会考虑将“*串行”改为“并行”，这就是异步的问题了…
接下来
聊聊spring中的@Async
在需要执行异步的方法中，声明async方法，并加入注释
@Async
@Transactional(propagation = Propagation.REQUIRES_NEW)
如需要获取业务层执行异步操作的结果，可在方法中加入线程，
System.out.println(".方法:"+
Thread.currentThread().getName());
try{Thread.sleep(5000);}catch(Exception e) {}
return new AsyncResult(*);

#另外我们还可以对异步进行封装，进行重新编写

@Slf4j
@Configuration
@ConfigurationProperties("spring.async.task")
@Setter
public class SpringAsycnConfig implements AsyncConfigurer {//异步执行器private int corePoolSize=5;private int maxPoolSize=100;private int keepAliveSeconds=60;private int queueCapacity=128;private String threadNamePrefix="task==>";@Overridepublic Executor getAsyncExecutor() {ThreadPoolTaskExecutor executor=new ThreadPoolTaskExecutor();executor.setCorePoolSize(corePoolSize);//设置核心线程数executor.setMaxPoolSize(maxPoolSize);//设置最大线程数executor.setKeepAliveSeconds(keepAliveSeconds);//设置释放资源executor.setQueueCapacity(queueCapacity);//设置队列容量executor.setThreadNamePrefix(threadNamePrefix);//设置前缀名称//自定义拒绝处理策略executor.setRejectedExecutionHandler(new RejectedExecutionHandler() {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {log.error("队列已满并且已无线程可用");}});executor.initialize();return executor;}@Overridepublic AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {return new AsyncUncaughtExceptionHandler() {@Overridepublic void handleUncaughtException(Throwable ex, Method method, Object... params) {log.error("任务执行时出现了 {}",ex.getMessage());}};}
}

如有不足之处，请各位大神多多指教！