到目前为止,已经简单学习了Spring的Core模块、….于是我们就开启了Spring的AOP模块了…在讲解AOP模块之前,首先我们来讲解一下cglib代理、以及怎么手动实现AOP编程

在讲解cglib之前,首先我们来回顾一下静态代理和动态代理….我之前就写过了静态代理、动态代理的博文:http://blog.csdn.net/hon_3y/article/details/70655966

由于静态代理需要实现目标对象的相同接口,那么可能会导致代理类会非常非常多….不好维护—->因此出现了动态代理

动态代理也有个约束:目标对象一定是要有接口的,没有接口就不能实现动态代理…..—–>因此出现了cglib代理

cglib代理也叫子类代理,从内存中构建出一个子类来扩展目标对象的功能!

  • CGLIB是一个强大的高性能的代码生成包,它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用,例如Spring AOP和dynaop,为他们提供方法的interception(拦截)。

接下来我们就讲讲怎么写cglib代理:

  • 需要引入cglib – jar文件, 但是spring的核心包中已经包括了cglib功能,所以直接引入spring-core-3.2.5.jar即可。
  • 引入功能包后,就可以在内存中动态构建子类
  • 代理的类不能为final,否则报错【在内存中构建子类来做扩展,当然不能为final,有final就不能继承了】
  • 目标对象的方法如果为final/static, 那么就不会被拦截,即不会执行目标对象额外的业务方法。
  1. //需要实现MethodInterceptor接口
  2. public class ProxyFactory implements MethodInterceptor{
  3. // 维护目标对象
  4. private Object target;
  5. public ProxyFactory(Object target){
  6. this.target = target;
  7. }
  8. // 给目标对象创建代理对象
  9. public Object getProxyInstance(){
  10. //1. 工具类
  11. Enhancer en = new Enhancer();
  12. //2. 设置父类
  13. en.setSuperclass(target.getClass());
  14. //3. 设置回调函数
  15. en.setCallback(this);
  16. //4. 创建子类(代理对象)
  17. return en.create();
  18. }
  19. @Override
  20. public Object intercept(Object obj, Method method, Object[] args,
  21. MethodProxy proxy) throws Throwable {
  22. System.out.println("开始事务.....");
  23. // 执行目标对象的方法
  24. Object returnValue = method.invoke(target, args);
  25. System.out.println("提交事务.....");
  26. return returnValue;
  27. }
  28. }
  • 测试:
  1. public class App {
  2. public static void main(String[] args) {
  3. UserDao userDao = new UserDao();
  4. UserDao factory = (UserDao) new ProxyFactory(userDao).getProxyInstance();
  5. factory.save();
  6. }
  7. }

这里写图片描述

这里写图片描述

使用cglib就是为了弥补动态代理的不足【动态代理的目标对象一定要实现接口】


AOP 面向切面的编程:

  • AOP可以实现“业务代码”与“关注点代码”分离

下面我们来看一段代码:

  1. // 保存一个用户
  2. public void add(User user) {
  3. Session session = null;
  4. Transaction trans = null;
  5. try {
  6. session = HibernateSessionFactoryUtils.getSession(); // 【关注点代码】
  7. trans = session.beginTransaction(); // 【关注点代码】
  8. session.save(user); // 核心业务代码
  9. trans.commit(); //…【关注点代码】
  10. } catch (Exception e) {
  11. e.printStackTrace();
  12. if(trans != null){
  13. trans.rollback(); //..【关注点代码】
  14. }
  15. } finally{
  16. HibernateSessionFactoryUtils.closeSession(session); ////..【关注点代码】
  17. }
  18. }
  • 关注点代码,就是指重复执行的代码。
  • 业务代码与关注点代码分离,好处?
    • 关注点代码写一次即可
    • 开发者只需要关注核心业务
    • 运行时期,执行核心业务代码时候动态植入关注点代码; 【代理】
  • IUser接口
  1. public interface IUser {
  2. void save();
  3. }

我们一步一步来分析,首先我们的UserDao有一个save()方法,每次都要开启事务和关闭事务

  1. //@Component -->任何地方都能用这个
  2. @Repository //-->这个在Dao层中使用
  3. public class UserDao {
  4. public void save() {
  5. System.out.println("开始事务");
  6. System.out.println("DB:保存用户");
  7. System.out.println("关闭事务");
  8. }
  9. }
  • 在刚学习java基础的时候,我们知道:如果某些功能经常需要用到就封装成方法:
  1. //@Component -->任何地方都能用这个
  2. @Repository //-->这个在Dao层中使用
  3. public class UserDao {
  4. public void save() {
  5. begin();
  6. System.out.println("DB:保存用户");
  7. close();
  8. }
  9. public void begin() {
  10. System.out.println("开始事务");
  11. }
  12. public void close() {
  13. System.out.println("关闭事务");
  14. }
  15. }
  • 现在呢,我们可能有多个Dao,都需要有开启事务和关闭事务的功能,现在只有UserDao中有这两个方法,重用性还是不够高。因此我们抽取出一个类出来
  1. public class AOP {
  2. public void begin() {
  3. System.out.println("开始事务");
  4. }
  5. public void close() {
  6. System.out.println("关闭事务");
  7. }
  8. }
  • 在UserDao维护这个变量,要用的时候,调用方法就行了
  1. @Repository //-->这个在Dao层中使用
  2. public class UserDao {
  3. AOP aop;
  4. public void save() {
  5. aop.begin();
  6. System.out.println("DB:保存用户");
  7. aop.close();
  8. }
  9. }
  • 现在的开启事务、关闭事务还是需要我在userDao中手动调用。还是不够优雅。。我想要的效果:当我在调用userDao的save()方法时,动态地开启事务、关闭事务。因此,我们就用到了代理。当然了,真正执行方法的都是userDao、要干事的是AOP,因此在代理中需要维护他们的引用
  1. public class ProxyFactory {
  2. //维护目标对象
  3. private static Object target;
  4. //维护关键点代码的类
  5. private static AOP aop;
  6. public static Object getProxyInstance(Object target_, AOP aop_) {
  7. //目标对象和关键点代码的类都是通过外界传递进来
  8. target = target_;
  9. aop = aop_;
  10. return Proxy.newProxyInstance(
  11. target.getClass().getClassLoader(),
  12. target.getClass().getInterfaces(),
  13. new InvocationHandler() {
  14. @Override
  15. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  16. aop.begin();
  17. Object returnValue = method.invoke(target, args);
  18. aop.close();
  19. return returnValue;
  20. }
  21. }
  22. );
  23. }
  24. }
  • 把AOP加入IOC容器中
  1. //把该对象加入到容器中
  2. @Component
  3. public class AOP {
  4. public void begin() {
  5. System.out.println("开始事务");
  6. }
  7. public void close() {
  8. System.out.println("关闭事务");
  9. }
  10. }
  • 把UserDao放入容器中
  1. @Component
  2. public class UserDao {
  3. public void save() {
  4. System.out.println("DB:保存用户");
  5. }
  6. }
  • 在配置文件中开启注解扫描,使用工厂静态方法创建代理对象
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xmlns:context="http://www.springframework.org/schema/context"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context
  10. http://www.springframework.org/schema/context/spring-context.xsd">
  11. <bean id="proxy" class="aa.ProxyFactory" factory-method="getProxyInstance">
  12. <constructor-arg index="0" ref="userDao"/>
  13. <constructor-arg index="1" ref="AOP"/>
  14. </bean>
  15. <context:component-scan base-package="aa"/>
  16. </beans>
  • 测试,得到UserDao对象,调用方法

  1. public class App {
  2. public static void main(String[] args) {
  3. ApplicationContext ac =
  4. new ClassPathXmlApplicationContext("aa/applicationContext.xml");
  5. IUser iUser = (IUser) ac.getBean("proxy");
  6. iUser.save();
  7. }
  8. }

这里写图片描述

上面使用的是工厂静态方法来创建代理类对象。我们也使用一下非静态的工厂方法创建对象

  1. package aa;
  2. import java.lang.reflect.InvocationHandler;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Proxy;
  5. /**
  6. * Created by ozc on 2017/5/11.
  7. */
  8. public class ProxyFactory {
  9. public Object getProxyInstance(final Object target_, final AOP aop_) {
  10. //目标对象和关键点代码的类都是通过外界传递进来
  11. return Proxy.newProxyInstance(
  12. target_.getClass().getClassLoader(),
  13. target_.getClass().getInterfaces(),
  14. new InvocationHandler() {
  15. @Override
  16. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  17. aop_.begin();
  18. Object returnValue = method.invoke(target_, args);
  19. aop_.close();
  20. return returnValue;
  21. }
  22. }
  23. );
  24. }
  25. }

配置文件:先创建工厂,再创建代理类对象

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xmlns:context="http://www.springframework.org/schema/context"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context
  10. http://www.springframework.org/schema/context/spring-context.xsd">
  11. <!--创建工厂-->
  12. <bean id="factory" class="aa.ProxyFactory"/>
  13. <!--通过工厂创建代理-->
  14. <bean id="IUser" class="aa.IUser" factory-bean="factory" factory-method="getProxyInstance">
  15. <constructor-arg index="0" ref="userDao"/>
  16. <constructor-arg index="1" ref="AOP"/>
  17. </bean>
  18. <context:component-scan base-package="aa"/>
  19. </beans>

这里写图片描述


Aop: aspect object programming 面向切面编程

  • 功能: 让关注点代码与业务代码分离!
  • 面向切面编程就是指: 对很多功能都有的重复的代码抽取,再在运行的时候往业务方法上动态植入“切面类代码”。

关注点:

  • 重复代码就叫做关注点。
  1. // 保存一个用户
  2. public void add(User user) {
  3. Session session = null;
  4. Transaction trans = null;
  5. try {
  6. session = HibernateSessionFactoryUtils.getSession(); // 【关注点代码】
  7. trans = session.beginTransaction(); // 【关注点代码】
  8. session.save(user); // 核心业务代码
  9. trans.commit(); //…【关注点代码】
  10. } catch (Exception e) {
  11. e.printStackTrace();
  12. if(trans != null){
  13. trans.rollback(); //..【关注点代码】
  14. }
  15. } finally{
  16. HibernateSessionFactoryUtils.closeSession(session); ////..【关注点代码】
  17. }
  18. }

切面:

  • 关注点形成的类,就叫切面(类)!
  1. public class AOP {
  2. public void begin() {
  3. System.out.println("开始事务");
  4. }
  5. public void close() {
  6. System.out.println("关闭事务");
  7. }
  8. }

切入点:

  • 执行目标对象方法,动态植入切面代码。
  • 可以通过切入点表达式指定拦截哪些类的哪些方法; 给指定的类在运行的时候植入切面类代码

切入点表达式:

  • 指定哪些类的哪些方法被拦截

1) 先引入aop相关jar文件 (aspectj aop优秀组件)

  • spring-aop-3.2.5.RELEASE.jar 【spring3.2源码】
  • aopalliance.jar 【spring2.5源码/lib/aopalliance】
  • aspectjweaver.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
  • aspectjrt.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

注意: 用到spring2.5版本的jar文件,如果用jdk1.7可能会有问题

  • 需要升级aspectj组件,即使用aspectj-1.8.2版本中提供jar文件提供。

2) bean.xml中引入aop名称空间

  • xmlns:context="http://www.springframework.org/schema/context"
  • http://www.springframework.org/schema/context
  • http://www.springframework.org/schema/context/spring-context.xsd

引入4个jar包:

这里写图片描述

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xmlns:context="http://www.springframework.org/schema/context"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context
  10. http://www.springframework.org/schema/context/spring-context.xsd">
  11. </beans>

我们之前手动的实现AOP编程是需要自己来编写代理工厂的,现在有了Spring,就不需要我们自己写代理工厂了。Spring内部会帮我们创建代理工厂

  • 也就是说,不用我们自己写代理对象了。

因此,我们只要关心切面类、切入点、编写切入表达式指定拦截什么方法就可以了!

还是以上一个例子为案例,使用Spring的注解方式来实现AOP编程

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xmlns:context="http://www.springframework.org/schema/context"
  6. xmlns:aop="http://www.springframework.org/schema/aop"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context
  10. http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  11. <context:component-scan base-package="aa"/>
  12. <!-- 开启aop注解方式 -->
  13. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  14. </beans>
  • 切面类
  1. @Component
  2. @Aspect//指定为切面类
  3. public class AOP {
  4. //里面的值为切入点表达式
  5. @Before("execution(* aa.*.*(..))")
  6. public void begin() {
  7. System.out.println("开始事务");
  8. }
  9. @After("execution(* aa.*.*(..))")
  10. public void close() {
  11. System.out.println("关闭事务");
  12. }
  13. }
  • UserDao实现了IUser接口
  1. @Component
  2. public class UserDao implements IUser {
  3. @Override
  4. public void save() {
  5. System.out.println("DB:保存用户");
  6. }
  7. }
  • IUser接口
  1. public interface IUser {
  2. void save();
  3. }
  • 测试代码:
  1. public class App {
  2. public static void main(String[] args) {
  3. ApplicationContext ac =
  4. new ClassPathXmlApplicationContext("aa/applicationContext.xml");
  5. //这里得到的是代理对象....
  6. IUser iUser = (IUser) ac.getBean("userDao");
  7. System.out.println(iUser.getClass());
  8. iUser.save();
  9. }
  10. }

这里写图片描述


上面我们测试的是UserDao有IUser接口,内部使用的是动态代理…那么我们这次测试的是目标对象没有接口

  • OrderDao没有实现接口
  1. @Component
  2. public class OrderDao {
  3. public void save() {
  4. System.out.println("我已经进货了!!!");
  5. }
  6. }
  • 测试代码:
  1. public class App {
  2. public static void main(String[] args) {
  3. ApplicationContext ac =
  4. new ClassPathXmlApplicationContext("aa/applicationContext.xml");
  5. OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
  6. System.out.println(orderDao.getClass());
  7. orderDao.save();
  8. }
  9. }

这里写图片描述


  • @Aspect 指定一个类为切面类

  • @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))") 指定切入点表达式

  • @Before("pointCut_()") 前置通知: 目标方法之前执行

  • @After("pointCut_()") 后置通知:目标方法之后执行(始终执行)

  • @AfterReturning("pointCut_()") 返回后通知: 执行方法结束前执行(异常不执行)

  • @AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行

  • @Around("pointCut_()") 环绕通知: 环绕目标方法执行

  • 测试:

  1. // 前置通知 : 在执行目标方法之前执行
  2. @Before("pointCut_()")
  3. public void begin(){
  4. System.out.println("开始事务/异常");
  5. }
  6. // 后置/最终通知:在执行目标方法之后执行 【无论是否出现异常最终都会执行】
  7. @After("pointCut_()")
  8. public void after(){
  9. System.out.println("提交事务/关闭");
  10. }
  11. // 返回后通知: 在调用目标方法结束后执行 【出现异常不执行】
  12. @AfterReturning("pointCut_()")
  13. public void afterReturning() {
  14. System.out.println("afterReturning()");
  15. }
  16. // 异常通知: 当目标方法执行异常时候执行此关注点代码
  17. @AfterThrowing("pointCut_()")
  18. public void afterThrowing(){
  19. System.out.println("afterThrowing()");
  20. }
  21. // 环绕通知:环绕目标方式执行
  22. @Around("pointCut_()")
  23. public void around(ProceedingJoinPoint pjp) throws Throwable{
  24. System.out.println("环绕前....");
  25. pjp.proceed(); // 执行目标方法
  26. System.out.println("环绕后....");
  27. }

我们的代码是这样的:每次写Before、After等,都要重写一次切入点表达式,这样就不优雅了。

  1. @Before("execution(* aa.*.*(..))")
  2. public void begin() {
  3. System.out.println("开始事务");
  4. }
  5. @After("execution(* aa.*.*(..))")
  6. public void close() {
  7. System.out.println("关闭事务");
  8. }

于是乎,我们要使用@Pointcut这个注解,来指定切入点表达式,在用到的地方中,直接引用就行了!

  • 那么我们的代码就可以改造成这样了:
  1. @Component
  2. @Aspect//指定为切面类
  3. public class AOP {
  4. // 指定切入点表达式,拦截哪个类的哪些方法
  5. @Pointcut("execution(* aa.*.*(..))")
  6. public void pt() {
  7. }
  8. @Before("pt()")
  9. public void begin() {
  10. System.out.println("开始事务");
  11. }
  12. @After("pt()")
  13. public void close() {
  14. System.out.println("关闭事务");
  15. }
  16. }

首先,我们把所有的注解都去掉…

  • XML文件配置
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xmlns:context="http://www.springframework.org/schema/context"
  6. xmlns:aop="http://www.springframework.org/schema/aop"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context
  10. http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  11. <!--对象实例-->
  12. <bean id="userDao" class="aa.UserDao"/>
  13. <bean id="orderDao" class="aa.OrderDao"/>
  14. <!--切面类-->
  15. <bean id="aop" class="aa.AOP"/>
  16. <!--AOP配置-->
  17. <aop:config >
  18. <!--定义切入表达式,拦截哪些方法-->
  19. <aop:pointcut id="pointCut" expression="execution(* aa.*.*(..))"/>
  20. <!--指定切面类是哪个-->
  21. <aop:aspect ref="aop">
  22. <!--指定来拦截的时候执行切面类的哪些方法-->
  23. <aop:before method="begin" pointcut-ref="pointCut"/>
  24. <aop:after method="close" pointcut-ref="pointCut"/>
  25. </aop:aspect>
  26. </aop:config>
  27. </beans>
  • 测试:
  1. public class App {
  2. @Test
  3. public void test1() {
  4. ApplicationContext ac =
  5. new ClassPathXmlApplicationContext("aa/applicationContext.xml");
  6. OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
  7. System.out.println(orderDao.getClass());
  8. orderDao.save();
  9. }
  10. @Test
  11. public void test2() {
  12. ApplicationContext ac =
  13. new ClassPathXmlApplicationContext("aa/applicationContext.xml");
  14. IUser userDao = (IUser) ac.getBean("userDao");
  15. System.out.println(userDao.getClass());
  16. userDao.save();
  17. }
  18. }

测试OrderDao

这里写图片描述

测试UserDao

这里写图片描述


切入点表达式主要就是来配置拦截哪些类的哪些方法

..我们去文档中找找它的语法…

这里写图片描述

在文档中搜索:execution(

这里写图片描述

那么它的语法是这样子的:

  1. execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

符号讲解:

  • ?号代表0或1,可以不写
  • “*”号代表任意类型,0或多
  • 方法参数为..表示为可变参数

参数讲解:

  • modifiers-pattern?【修饰的类型,可以不写】
  • ret-type-pattern【方法返回值类型,必写】
  • declaring-type-pattern?【方法声明的类型,可以不写】
  • name-pattern(param-pattern)【要匹配的名称,括号里面是方法的参数】
  • throws-pattern?【方法抛出的异常类型,可以不写】

官方也有给出一些例子给我们理解:

这里写图片描述

  1. <!-- 【拦截所有public方法】 -->
  2. <!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->
  3. <!-- 【拦截所有save开头的方法 】 -->
  4. <!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->
  5. <!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->
  6. <!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->
  7. <!-- 【拦截指定类的所有方法】 -->
  8. <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->
  9. <!-- 【拦截指定包,以及其自包下所有类的所有方法】 -->
  10. <!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->
  11. <!-- 【多个表达式】 -->
  12. <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
  13. <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
  14. <!-- 下面2个且关系的,没有意义 -->
  15. <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
  16. <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
  17. <!-- 【取非值】 -->
  18. <!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

如果文章有错的地方欢迎指正,大家互相交流。习惯在微信看技术文章,想要获取更多的Java资源的同学,可以关注微信公众号:Java3y

版权声明:本文为Java3y原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/Java3y/p/8569271.html