AOP 为 Aspect Oriented Programming 的缩写,意思为面向切面编程,是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP 是 OOP 的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
/**
* 接口类
*/
public interface TargetInterface {
void say();
}
/**
* 目标类
*/
public class Target implements TargetInterface {
public void say() {
System.out.println("目标类执行了");
}
}
public static void main( String[] args ) {
final Target target = new Target();
TargetInterface proxy = (TargetInterface)Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("前面增强");
Object invoke = method.invoke(target, args);
System.out.println("后置增强");
return invoke;
}
});
proxy.say();
}
public class Target {
public void say1(String name) {
System.out.println("你好"+name);
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class<Target> targetClass = Target.class;
Method method= targetClass.getMethod("say1", String.class);
method.invoke(targetClass.newInstance(),"tom");
}
}
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.0.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.8.13version>
dependency>
public static void main( String[] args ) {
final Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer(); //创建增强器
enhancer.setSuperclass(Target.class);//设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("前置代码增强....");
Object invoke = method.invoke(target, objects);
System.out.println("后置代码增强....");
return invoke;
}
});
Target proxy =(Target) enhancer.create();//创建代理对象
proxy.say();
}
# Target(目标对象):代理的目标对象 98K
# Proxy (代理):一个类被 AOP 织入增强后,就产生一个结果代理类 安装了8倍镜的98K
# Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。 可以安装8倍境的地方
# Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。 安装了8被镜的地方
# Advice(通知/ 增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知 8倍镜
# Aspect(切面):是切入点和通知的结合
# Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入,而AspectJ采用编译期织入和类装载期织入。 安装的过程
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.0.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.8.13version>
dependency>
/**
* 接口类
*/
public interface TargetInterface {
void say();
}
/**
* 目标类
*/
public class Target implements TargetInterface {
@Override
public void say() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("目标类执行了");
}
}
public class MyAspect {
//前置增强方法
public void before(){
System.out.println("前置代码增强了");
}
//后置增强方法
public void after(){
System.out.println("后置");
}
//环绕增强
public Object around(ProceedingJoinPoint p){
long start = System.currentTimeMillis();
String className = p.getSignature().getDeclaringTypeName();
String method = p.getSignature().getName();
Object proceed = null;
try {
proceed = p.proceed();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("类名:" + className);
System.out.println("方法名是:" + method);
System.out.println("执行时间长是:"+(end-start));
return proceed;
}
}
<bean id="target" class="com.xinzih.service.impl.Target"/>
<bean id="myAspect" class="com.xinzih.aspect.MyAspect"/>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="myAspect" class="com.xinzhi.aspect.MyAspect" />
<bean id="target" class="com.xinzhi.target.impl.TargetInterfaceImpl" />
<aop:config>
<aop:aspect ref="myAspect">
<aop:around method="around" pointcut="execution(* com.xinzhi.target.impl.*.*(..))"/>
aop:aspect>
aop:config>
beans>
public static void main( String[] args ) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
TargetInterface bean = (TargetInterface)applicationContext.getBean("target");
bean.say();
}
execution([修饰符] 返回值类型 包名.类名.方法名(参数))
常用的书写格式:
execution(* 包名.*.*(..))
/**
* 目标类
*/
@Component("target")
public class Target implements TargetInterface {
public void say() {
System.out.println("目标类执行了");
}
}
@Component
@Aspect
public class MyAspect {
//前置增强方法
@Before("execution(* com.xinzhi.target.impl.*.*(..))")
public void before(){
System.out.println("前置代码增强了");
}
//后置增强方法
@After("execution(* com.xinzhi.target.impl.*.*(..))")
public void after(){
System.out.println("后置");
}
//环绕增强
@Around("execution(* com.xinzhi.target.impl.*.*(..))")
public Object around(ProceedingJoinPoint p){
long start = System.currentTimeMillis();
String className = p.getSignature().getDeclaringTypeName();
String method = p.getSignature().getName();
Object proceed = null;
try {
proceed = p.proceed();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("类名:" + className);
System.out.println("方法名是:" + method);
System.out.println("执行时间长是:"+(end-start));
return proceed;
}
}
<!--组件扫描-->
<context:component-scan base-package="com.xinzhi"/>
<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>