目录

一、动态代理（Jdk动态代理和CGLib代理）

Jdk动态代理

在com.itheima.jdk包下，创建UserDao接口及其实现类UserDaoImpl类

在包com.itheima.aspect下创建MyAspect切面类

创建代理类

 创建测试类

运行效果

总结

CGLib代理

在包com.itheima.cglib下，创建目标类

使用切面类

 创建测试类

运行效果

总结

二、基于代理类的AOP实现

导包

本案例引用CGLib的目标类UserDao作为本案例的目标类

创建切面类

创建配置文件

创建测试类

运行效果

总结

三、AspectJ开发（基于Xml声明式和基于注解的声明式）

基于Xml声明式

目标类有接口和实现类

切面类

配置文件

测试类

运行效果

总结

基于注解的声明式

目标类

切面类

配置文件

测试类

运行效果

总结

首先，导入Spring的四个核心包和第三方依赖包在lib目录下，并添加到工作路径中。

其他包是后面的代码案例中需要用到的

一、动态代理（Jdk动态代理和CGLib代理）

Jdk动态代理

在com.itheima.jdk包下，创建UserDao接口及其实现类UserDaoImpl类

package com.itheima.jdk;public interface UserDao {public void addUser();public void deleteUser();
}

package com.itheima.jdk;import org.springframework.stereotype.Repository;public class UserDaoImpl implements UserDao {@Overridepublic void addUser() {System.out.println("添加用户");}@Overridepublic void deleteUser() {System.out.println("删除用户");}}

在包com.itheima.aspect下创建MyAspect切面类

package com.itheima.aspect;public class MyAspect {public void check_Permissions() {System.out.println("模拟检查权限。。。");}public void log() {System.out.println("模拟记录日志。。。");}
}

创建代理类

package com.itheima.jdk;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;import com.itheima.aspect.MyAspect;public class JdkProxy implements InvocationHandler {//声明目标类private UserDao userDao; public Object createProxy(UserDao userDao1) {userDao = userDao1;//类加载器ClassLoader classLoader = JdkProxy.class.getClassLoader();//实现的目标类的所有接口Class[] clazz = userDao.getClass().getInterfaces();//使用代理类，进行增强，返回的是代理类对象return Proxy.newProxyInstance(classLoader, clazz, this);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {MyAspect myAspect = new MyAspect();myAspect.check_Permissions();//前增强Object obj = method.invoke(userDao, args);myAspect.log();//后增强return obj;}}

 创建测试类

package com.itheima.jdk;public class JdkTest {public static void main(String[] args) {JdkProxy jdkProxy = new JdkProxy();UserDao userDao = new UserDaoImpl();UserDao userDao1 = (UserDao) jdkProxy.createProxy(userDao);userDao1.addUser();userDao1.deleteUser();}
}

运行效果

总结

创建一个目标类的接口和目标类（被增强的类），创建一个切面类（其方法被织入到目标类中的类），创建一个动态代理类（生成被增强后的类的对象）

jdk动态代理类继承java.lang.reflect.InvocationHandler，声明目标类的接口，创建返回被增强后的类的对象的方法，重写其方法invoke（）。

创建返回被增强后的类的对象的方法时，将传入的目标类赋值给声明的目标类的接口，获得代理类自身的类加载器和实现的目标类的所有接口数组，返回Proxy.newProxyInstance(classLoader, clazz, this);

重写其方法invoke时，要实例化一个该切面类的对象，用于调用相应的方法来设置前增强和后增强，中间的调用目标类方法使用method.invoke(userDao, args);

目标类必须有接口

CGLib代理

在包com.itheima.cglib下，创建目标类

package com.itheima.cglib;public class UserDao {public void addUser() {System.out.println("添加用户。。。");}public void deleteUser() {System.out.println("删除用户。。。");}
}

使用切面类

package com.itheima.aspect;public class MyAspect {public void check_Permissions() {System.out.println("模拟检查权限。。。");}public void log() {System.out.println("模拟记录日志。。。");}
}

创建CGLib代理类

package com.itheima.cglib;import java.lang.reflect.Method;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import com.itheima.aspect.MyAspect;
//代理类
public class CglibProxy implements MethodInterceptor {public Object createProxy(Object target) {
//		创建一个动态类对象Enhancer enhancer = new Enhancer();
//		设置需要增强的类的父类enhancer.setSuperclass(target.getClass());
//		添加回调函数enhancer.setCallback(this);
//		返回创建的代理类return enhancer.create();}/** proxy CGLIB根据指定父类生成的代理对象* method 拦截的方法* args 拦截方法的参数数组* methodProxy 方法的代理对象，用于执行父类的方法*/@Overridepublic Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//		创建切面类对象MyAspect myAspect = new MyAspect();
//		前增强myAspect.check_Permissions();
//		目标方法执行Object obj = methodProxy.invokeSuper(proxy, args);
//		后增强myAspect.log();return obj;}}

 创建测试类

package com.itheima.cglib;public class CglibTest {public static void main(String[] args) {CglibProxy cglibProxy = new CglibProxy();UserDao userDao = new UserDao();
//		获取被增强后的目标对象UserDao userDao1 = (UserDao) cglibProxy.createProxy(userDao);
//		执行方法userDao1.addUser();userDao1.deleteUser();}}

运行效果

总结

创建目标类、切面类、代理类和测试类

目标类不需要接口

切面类和上例中相同，定义了通知（加入目标类的方法）

代理类继承MethodInterceptor, 创建一个返回被增强目标类的对象的方法，重写方法invoke（）

创建一个返回被增强目标类的对象的方法时，创建一个动态类Enhancer的对象，设置需要增强的类为该对象的父类，设置回调函数为当前类，返回enhancer.create()。

重写方法invoke（）方法时，实例化一个切面类的对象，调用相应的方法为前增强和后增强。调用目标方法用 methodProxy.invokeSuper(proxy, args)

二、基于代理类的AOP实现

导包

使用AOP框架实现切面编程，需要再导入两个jar包

本案例引用CGLib的目标类UserDao作为本案例的目标类

无需再创建

package com.itheima.cglib;public class UserDao {public void addUser() {System.out.println("添加用户。。。");}public void deleteUser() {System.out.println("删除用户。。。");}
}

创建切面类

package com.itheima.factorybean;import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;public class MyAspect implements MethodInterceptor {@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {check_Permissions();//执行目标方法Object obj = mi.proceed();log();return obj;}public void check_Permissions() {System.out.println("权限检查、、、、");}public void log() {System.out.println("记录日志、、、、");}}

创建配置文件

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans-4.3.xsd"><bean id="userDao" class="com.itheima.jdk.UserDaoImpl"></bean><bean id="myAspect" class="com.itheima.factorybean.MyAspect"></bean><bean id="userDaoProxy"class="org.springframework.aop.framework.ProxyFactoryBean"><property name="proxyInterfaces" value="com.itheima.jdk.UserDao" /><property name="target" ref="userDao" /><property name="interceptorNames" value="myAspect" /><property name="proxyTargetClass" value="true"/></bean></beans>

创建测试类

package com.itheima.factorybean;import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import com.itheima.jdk.UserDao;//测试类
public class ProxyFactoryBeanTest {public static void main(String[] args) {String xmlPath = "com/itheima/factorybean/applicationContext.xml";ApplicationContext applicationContext = newClassPathXmlApplicationContext(xmlPath);UserDao userDao = (UserDao) applicationContext.getBean("userDaoProxy");//执行方法userDao.addUser();userDao.deleteUser();}}

运行效果

总结

创建目标类、切面类、配置文件和测试类。不需要创建代理类的代码

切面类实现MethodInterceptor接口，定义前增强和后增强的方法，并在invoke方法中调用，中间的调用目标方法用mi.proceed()，返回

Object obj = mi.proceed();的obj。

配置文件：配置目标类和切面类的bean属性id和class，此外，还需要配置代理类的bean。

配置代理类的bean属性id和class（org.springframework.aop.framework.ProxyFactoryBean），其子元素还需配置proxyInterface（代理实现的接口）、target（代理的目标对象）、interceptorNames（需要织入目标类的通知即切面类）和ProxyTargetClass（代理方式）

三、AspectJ开发（基于Xml声明式和基于注解的声明式）

要使用AspectJ开发，除开Spring的主要jar包和第三方依赖包外，还需要两个类AspectJ的相关jar包。一共使用到的jar包如下：

两个剪头指着的是AspectJ的jar包

基于Xml声明式

目标类有接口和实现类

这里的目标类和jdk动态代理类里的目标类相同，可以直接引用，在配置文件里设置为之前的路径，也可以自己创建在切面类的包里，但是配置文件时，需要注意配置目标类包路径，代码：

package com.itheima.jdk;public interface UserDao {public void addUser();public void deleteUser();
}

package com.itheima.jdk;import org.springframework.stereotype.Repository;@Repository("userDao")
public class UserDaoImpl implements UserDao {@Overridepublic void addUser() {System.out.println("添加用户");}@Overridepublic void deleteUser() {System.out.println("删除用户");}}

切面类

package com.itheima.aspectj.xml;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;/** 切面类，在此类中编写通知*/
public class MyAspect {
//	前置通知public void myBefore(JoinPoint joinPoint) {System.out.println("前置通知：模拟执行权限检查，，，");System.out.println("目标类是："+joinPoint.getTarget());System.out.println(",被植入增强处理的目标方法是："+joinPoint.getSignature().getName());}//	后置通知public void myAfterReturning(JoinPoint joinPoint) {System.out.println("后置通知：模拟记录日志。。。。");System.out.println("被植入增强处理的目标方法是："+joinPoint.getSignature().getName());}/** 环绕通知* ProceedingJoinPoint 是JoinPoint子接口，表示可以执行目标方法* 必须事Object的返回类型* 必须接收一个参数，类型为ProceedingJoinPoint* 必须throw Throwable*/public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
//		开始System.out.println("环绕开始：执行目标方法开始之前，模拟开启事务");
//		执行当前目标方法Object obj = proceedingJoinPoint.proceed();//结束System.out.println("环绕结束：执行目标方法之后，模拟关闭事务");return obj;}//异常通知public void myAfterThrowing(JoinPoint joinPoint,Throwable e) {System.out.println("异常通知："+"出错了"+e.getMessage());}//最终通知public void myAfter() {System.out.println("最终通知：模拟方法结束后的释放资源。。。");}}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.3.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-4.3.xsd"> <!-- 目标类 --><bean id="userDao" class="com.itheima.jdk.UserDaoImpl"></bean><!-- 切面 --><bean id="myAspect" class="com.itheima.aspectj.xml.MyAspect"></bean><!-- aop编程 --><aop:config><!-- 配置切面 --><aop:aspect ref="myAspect"><!-- 切入点 --><aop:pointcut id="myPointCut" expression="execution(* com.itheima.jdk.*.*(..))" /><!-- 关联通知advice和pointcut切入点 --><!-- 前置通知 --><aop:before method="myBefore" pointcut-ref="myPointCut"/>  	<!-- 后置通知 在方法返回之后执行，就可以获得返回值 returning属性：用于设置后置通知的第二个参数的名字，类型是Object --><aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut"returning="returnVal"/> 	<!-- 环绕通知 --><aop:around method="myAround" pointcut-ref="myPointCut"/><!-- 抛出通知  :用于处理程序发生异常注意：如果程序没有发生异常，就不会发生增强throwing属性：用于设置通知的第二个属性的名字，类型Throwable--><aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/><!-- 最终通知 ：无论程序发生任何事情，都要执行--><aop:after method="myAfter" pointcut-ref="myPointCut" /></aop:aspect>  </aop:config>   
</beans>

测试类

package com.itheima.aspectj.xml;import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import com.itheima.jdk.UserDao;public class TestXmlAspectj {public static void main(String[] args) {String xmlPath = "com/itheima/aspectj/xml/applicationContext.xml";ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);UserDao userDao = (UserDao) applicationContext.getBean("userDao");userDao.addUser();}}

运行效果

总结

基于Xml声明式的AspectJ开发，参与的文件：目标类、切面类、配置文件和测试类

切面类不需要实现任何接口，像普通的类一样，但需要创建前置通知、后置通知、环绕通知、异常抛出通知和最后通知的相应方法。

配置文件：除开要配置目标类和切面类的bean属性id与class外，还需要通过标签<aop:config>的子元素配置切面、切入点、前置通知、后置通知、环绕通知、异常通知和最后通知。

配置切面<aop:aspect >属性只有ref="切面类id"

切入点<aop:pointcut>属性id，expression，值"execution(* com.itheima.jdk.*.*(..))"

所有的通知都有属性method值为切面类中相应的方法、pointcut-ref值为切入点的id

基于注解的声明式

目标类

引用在com.itheima.jdk包下的类UserDaoImpl类，在该类上添加注解@Repository("userDao")

package com.itheima.jdk;import org.springframework.stereotype.Repository;@Repository("userDao")
public class UserDaoImpl implements UserDao {@Overridepublic void addUser() {System.out.println("添加用户");}@Overridepublic void deleteUser() {System.out.println("删除用户");}}

切面类

package com.itheima.aspectj.annotion;import org.aspectj.lang.JoinPoint;
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 MyAspect {//定义切入点表达式@Pointcut("execution(* com.itheima.jdk.*.*(..))")//使用一个返回值为void，方法体为空的方法来命名切入点private void myPointCut() {}
//	前置通知@Before("myPointCut()")public void myBefore(JoinPoint joinPoint) {System.out.println("前置通知：模拟执行权限检查，，，");System.out.println("目标类是："+joinPoint.getTarget());System.out.println(",被植入增强处理的目标方法是："+joinPoint.getSignature().getName());}//	后置通知@AfterReturning(value="myPointCut()")public void myAfterReturning(JoinPoint joinPoint) {System.out.println("后置通知：模拟记录日志。。。。");System.out.println("被植入增强处理的目标方法是："+joinPoint.getSignature().getName());}/** 环绕通知* ProceedingJoinPoint 是JoinPoint子接口，表示可以执行目标方法* 必须事Object的返回类型* 必须接收一个参数，类型为ProceedingJoinPoint* 必须throw Throwable*/@Around("myPointCut()")public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
//		开始System.out.println("环绕开始：执行目标方法开始之前，模拟开启事务");
//		执行当前目标方法Object obj = proceedingJoinPoint.proceed();//结束System.out.println("环绕结束：执行目标方法之后，模拟关闭事务");return obj;}//异常通知@AfterThrowing(value="myPointCut()",throwing="e")public void myAfterThrowing(JoinPoint joinPoint,Throwable e) {System.out.println("异常通知："+"出错了"+e.getMessage());}//最终通知@After("myPointCut()")public void myAfter() {System.out.println("最终通知：模拟方法结束后的释放资源。。。");}	}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.3.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-4.3.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.3.xsd"> <!-- 指定扫描的包，使注解生效 --><context:component-scan base-package="com.itheima"></context:component-scan><!-- 启动基于注解的声明式AspectJ的支持 --><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>

测试类

package com.itheima.aspectj.annotion;import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;import com.itheima.jdk.UserDao;public class TestAnnotion {public static void main(String[] args) {String xmlPath = "com/itheima/aspectj/annotion/applicationContext.xml";ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);UserDao userDao = (UserDao) applicationContext.getBean("userDao");userDao.addUser();}}

运行效果

总结

目标类、切面类、配置文件和测试类

目标类：在目标类上添加注解@Repository，并设置id即可

切面类：在该类上方添加注释@Aspect和@Component。需要创建一个方法作为切入点，并在该方法上添加注释@Pointcut，属性值为expression的值。

此外的代码和基于xml案例中的代码相同，只是在相应的通知上添加了注解和切入点属性值，前置通知（@Before），后置通知（@AfterReturning），环绕通知（@Around），异常抛出通知（@AfterThrowing），最后通知（@After）

配置文件：无需配置相应类的bean，只需要配置基于注解的声明式AspectJ的支持和扫描的包

<context:component-scan base-package="com.itheima">

<aop:aspectj-autoproxy>