什么是AOP
  AOP Aspect Oriented Programing 面向切面编程
  AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码(性能监视、事务管理、安全检查、缓存)
  Spring AOP使用纯Java实现,不需要专门的编译过程和类加载器,在运行期通过代理方式向目标类织入增强代码
  AspecJ是一个基于Java语言的AOP框架,Spring2.0开始,Spring AOP引入对Aspect的支持,AspectJ扩展了Java语言,提供了一个专门的编译器,在编译时提供横向代码的织入
Spring的AOP代理
  JDK动态代理:对实现了接口的类生成代理
  CGLib代理机制:对类生成代理
AOP的术语
  Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
  Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
  Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
  Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
  Target(目标对象):代理的目标对象
  Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.spring采用动态代理织入,而AspectJ采用编译期织入和类装载期织入
  Proxy(代理):一个类被AOP织入增强后,就产生一个结果代理类
  Aspect(切面): 是切入点和通知(引介)的结合

  

AOP的底层实现

  JDK动态代理演示

  1. public interface UserDao {
  2. public void add();
  3. public void update();
  4. }

UserDao

  1. public class UserDaoImpl implements UserDao {
  2. public void add() {
  3. System.out.println("添加用户...");
  4. }
  5. public void update() {
  6. System.out.println("修改用户...");
  7. }
  8. }

UserDaoImpl

  1. public class JDKProxy implements InvocationHandler{
  2. private UserDao userDao;
  3. public JDKProxy(UserDao userDao) {
  4. super();
  5. this.userDao = userDao;
  6. }
  7. public UserDao createProxy() {
  8. UserDao proxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), this);
  9. return proxy;
  10. }
  11. // 调用目标对象的任何一个方法 都相当于调用invoke();
  12. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  13. if("add".equals(method.getName())){
  14. // 记录日志:
  15. System.out.println("日志记录=================");
  16. Object result = method.invoke(userDao, args);
  17. return result;
  18. }
  19. return method.invoke(userDao, args);
  20. }
  21. }
  1. @Test
  2. public void demo2(){
  3.   // 被代理对象
  4. UserDao userDao = new UserDaoImpl();
  5. // 创建代理对象的时候传入被代理对象.
  6. UserDao proxy = new JDKProxy(userDao).createProxy();
  7. proxy.add();
  8. proxy.update();
  9. /**
  10. * 输出:
  11. * 日志记录=================
  12. * 添加用户...
  13. * 修改用户...
  14. */
  15. }

  CGLIB动态代理演示
    CGLIB(Code Generation Library)是一个开源项目!是一个强大的,高性能,高质量的Code生成类库,它可以在运行期扩展Java类与实现Java接口。 Hibernate支持它来实现PO(Persistent Object 持久化对象)字节码的动态生成(Hibernate实际使用Javassist生成代理,该代理对象就是持久化类的子类的实例),现在做cglib的开发,可以不用直接引入cglib的包.因为spring核心中已经集成了cglib
    CGLIB生成代理机制:其实生成了一个真实对象的子类

  1. public class ProductDao {
  2. public void add(){
  3. System.out.println("添加商品...");
  4. }
  5. public void update(){
  6. System.out.println("修改商品...");
  7. }
  8. }

ProductDao

  1. public class CGLibProxy implements MethodInterceptor{
  2. private ProductDao productDao;
  3. public CGLibProxy(ProductDao productDao) {
  4. super();
  5. this.productDao = productDao;
  6. }
  7. public ProductDao createProxy(){
  8. // 使用CGLIB生成代理:
  9. // 1.创建核心类:
  10. Enhancer enhancer = new Enhancer();
  11. // 2.为其设置父类:
  12. enhancer.setSuperclass(productDao.getClass());
  13. // 3.设置回调:
  14. enhancer.setCallback(this);
  15. // 4.创建代理:
  16. return (ProductDao) enhancer.create();
  17. }
  18. public Object intercept(Object proxy, Method method, Object[] args,MethodProxy methodProxy) throws Throwable {
  19. if("add".equals(method.getName())){
  20. System.out.println("日志记录==============");
  21. Object obj = methodProxy.invokeSuper(proxy, args);
  22. return obj;
  23. }
  24. return methodProxy.invokeSuper(proxy, args);
  25. }
  26. }
  1. public void demo2(){
  2.   ProductDao productDao = new ProductDao();
  3.   ProductDao proxy = new CGLibProxy(productDao).createProxy();
  4.   proxy.add();
  5.   proxy.update();
  6.   /**
  7.   * 输出:
  8.   * 日志记录=================
  9.   * 添加用户...
  10.   * 修改用户...
  11.   */
  12. }

  结论:Spring框架,如果类实现了接口,就使用JDK的动态代理生成代理对象,如果这个类没有实现任何接口,使用CGLIB生成代理对象

Spring中的AOP

  Spring的传统AOP 
    AOP:不是由Spring定义.AOP联盟的组织定义.
    Spring中的通知(增强代码)
      前置通知 org.springframework.aop.MethodBeforeAdvice:在目标方法执行前实施增强
      后置通知 org.springframework.aop.AfterReturningAdvice:在目标方法执行后实施增强
      环绕通知 org.aopalliance.intercept.MethodInterceptor:在目标方法执行前后实施增强
      异常抛出通知 org.springframework.aop.ThrowsAdvice:在方法抛出异常后实施增强
      引介通知 org.springframework.aop.IntroductionInterceptor(不研究):在目标类中添加一些新的方法和属性
  Spring中的切面类型

    Advisor(Spring中传统切面)就是对PointCut应用Advice(通常所说Advisor指只有一个Point和一个Advice,Aspect:多个切点和多个通知组合
    Advisor : 代表一般切面,Advice本身就是一个切面,对目标类所有方法进行拦截 (没有切点)
    PointcutAdvisor : 代表具有切点的切面,可以指定拦截目标类哪些方法
    IntroductionAdvisor : 代表引介切面,针对引介通知而使用切面(不要求掌握)

Spring的AOP的开发

  针对所有方法的增强(不带有切点的切面)
    第一步:导入相应jar包
      spring-aop-3.2.0.RELEASE.jar
      com.springsource.org.aopalliance-1.0.0.jar

    第二步:编写被代理对象

  1. public interface CustomerDao {
  2. public void add();
  3. public void update();
  4. public void delete();
  5. public void find();
  6. }

CustomerDao

  1. public class CustomerDaoImpl implements CustomerDao {
  2. public void add() {
  3. System.out.println("添加客户");
  4. }
  5. public void update() {
  6. System.out.println("修改客户");
  7. }
  8. public void delete() {
  9. System.out.println("删除客户");
  10. }
  11. public void find() {
  12. System.out.println("查询客户");
  13. }
  14. }

CustomerDaoImpl

    第三步:编写增强的代码

  1. public class MyBeforeAdvice implements MethodBeforeAdvice{
  2. /**
  3. * method:执行的方法
  4. * args:参数
  5. * target:目标对象
  6. */
  7. public void before(Method method, Object[] args, Object target) throws Throwable {
  8. System.out.println("前置增强...");
  9. }
  10. }

    第四步:生成代理(配置生成代理)
      生成代理Spring基于ProxyFactoryBean类.底层自动选择使用JDK的动态代理还是CGLIB的代理.
        属性:
          target : 代理的目标对象
          proxyInterfaces : 代理要实现的接口
            如果多个接口可以使用以下格式赋值
              <list>
                <value></value>
                ....
              </list>
          proxyTargetClass : 是否对类代理而不是接口,设置为true时,使用CGLib代理
          interceptorNames : 需要织入目标的Advice
          singleton : 返回代理是否为单实例,默认为单例
          optimize : 当设置为true时,强制使用CGLib

  1. <!-- 不带有切点的切面 -->
  2. <!-- 定义目标对象 -->
  3. <bean id="customerDao" class="cn.yzu.spring3.demo3.CustomerDaoImpl"></bean>
  4. <!-- 定义增强 -->
  5. <bean id="beforeAdvice" class="cn.yzu.spring3.demo3.MyBeforeAdvice"></bean>
  6. <!-- Spring支持配置生成代理: -->
  7. <bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  8.   <!-- 设置目标对象 -->
  9.   <property name="target" ref="customerDao"/>
  10.   <!-- 设置实现的接口 ,value中写接口的全路径 -->
  11. <property name="proxyInterfaces" value="cn.yzu.spring3.demo3.CustomerDao"/>
  12. <!-- 需要使用value:要的名称 -->
  13. <property name="interceptorNames" value="beforeAdvice"/>
  14. <!-- 强制使用CGLIB代理 -->
  15. <property name="optimize" value="true"></property>
  16. </bean>

    第五步:注入测试

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class SpringTest3 {
  4. @Autowired
  5. //不可注入@Qualifier("customerDao"),必须注入代理对象.
  6. @Qualifier("customerDaoProxy")
  7. private CustomerDao customerDao;
  8. @Test
  9. public void demo1(){
  10. customerDao.add();
  11. customerDao.update();
  12. customerDao.delete();
  13. customerDao.find();
  14. /**
  15. * 输出:
  16. * 前置增强...
  17.   添加客户
  18.   前置增强...
  19.   修改客户
  20.   前置增强...
  21.   删除客户
  22.   前置增强...
  23.   查询客户
  24. */
  25. }
  26. }

  带有切点的切面:(针对目标对象的某些方法进行增强)
    PointcutAdvisor 接口
      DefaultPointcutAdvisor 最常用的切面类型,它可以通过任意Pointcut和Advice 组合定义切面
      RegexpMethodPointcutAdvisor 构造正则表达式切点切面

    第一步:创建被代理对象.

  1. public class OrderDao {
  2. public void add(){
  3. System.out.println("添加订单");
  4. }
  5. public void update(){
  6. System.out.println("修改订单");
  7. }
  8. public void delete(){
  9. System.out.println("删除订单");
  10. }
  11. public void find(){
  12. System.out.println("查询订单");
  13. }
  14. }

OrderDao

    第二步:编写增强的类

  1. public class MyAroundAdvice implements MethodInterceptor{
  2. public Object invoke(MethodInvocation methodInvocation) throws Throwable {
  3. System.out.println("环绕前增强...");
  4. Object result = methodInvocation.proceed();// 执行目标对象的方法
  5. System.out.println("环绕后增强...");
  6. return result;
  7. }
  8. }

    第三步:生成代理

  1. <!-- 带有切点的切面 -->
  2. <!-- 定义目标对象 -->
  3. <bean id="orderDao" class="cn.yzu.spring3.demo4.OrderDao"></bean>
  4. <!-- 定义增强 -->
  5. <bean id="aroundAdvice" class="cn.yzu.spring3.demo4.MyAroundAdvice"></bean>
  6. <!-- 定义切点切面: -->
  7. <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  8.   <!-- 定义表达式,规定哪些方法执行拦截 -->
  9.   <!-- . 任意字符 * 任意个 -->
  10.   <!-- <property name="pattern" value=".*"/> -->
  11.   <!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/> -->
  12.   <!-- <property name="pattern" value=".*add.*"></property> -->
  13.   <property name="patterns" value=".*add.*,.*find.*"></property>
  14.   <!-- 应用增强 -->
  15.   <property name="advice" ref="aroundAdvice"/>
  16. </bean>
  17. <!-- 定义生成代理对象 -->
  18. <bean id="orderDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
  19.   <!-- 配置目标 -->
  20.   <property name="target" ref="orderDao"></property>
  21.   <!-- 针对类的代理 -->
  22.   <property name="proxyTargetClass" value="true"></property>
  23.   <!-- 在目标上应用增强 -->
  24.   <property name="interceptorNames" value="myPointcutAdvisor"></property>
  25. </bean>

    第四步:注入测试

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class SpringTest4 {
  4. @Autowired
  5. @Qualifier("orderDaoProxy")
  6. private OrderDao orderDao;
  7. @Test
  8. public void demo1(){
  9. orderDao.add();
  10. orderDao.delete();
  11. orderDao.update();
  12. orderDao.find();
  13. /**
  14. * 输出:
  15. * 环绕前增强...
  16. 添加订单
  17. 环绕后增强...
  18. 删除订单
  19. 修改订单
  20. 环绕前增强...
  21. 查询订单
  22. 环绕后增强...
  23. */
  24. }
  25.  
  26. }

  自动代理
    前面的案例中,每个代理都是通过ProxyFactoryBean织入切面代理,在实际开发中,非常多的Bean每个都配置ProxyFactoryBean开发维护量巨大

    自动创建代理(基于后处理Bean.在Bean创建的过程中完成的增强.生成Bean就是代理)
      BeanNameAutoProxyCreator 根据Bean名称创建代理
      DefaultAdvisorAutoProxyCreator 根据Advisor本身包含信息创建代理

    BeanNameAutoProxyCreator :按名称生成代理

  1. <!-- 定义目标对象 -->
  2. <bean id="customerDao" class="cn.yzu.spring3.demo3.CustomerDaoImpl"></bean>
  3. <bean id="orderDao" class="cn.yzu.spring3.demo4.OrderDao"></bean>
  4. <!-- 定义增强 -->
  5. <bean id="beforeAdvice" class="cn.yzu.spring3.demo3.MyBeforeAdvice"></bean>
  6. <bean id="aroundAdvice" class="cn.yzu.spring3.demo4.MyAroundAdvice"></bean>
  7. <!-- 自动代理:按名称的代理 基于后处理Bean,后处理Bean不需要配置ID-->
  8. <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
  9.   <property name="beanNames" value="*Dao"/>
  10.   <property name="interceptorNames" value="beforeAdvice"/>
  11. </bean>
  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext2.xml")
  3. public class SpringTest5 {
  4. @Autowired
  5. @Qualifier("orderDao")
  6. private OrderDao orderDao;
  7. @Autowired
  8. @Qualifier("customerDao")
  9. private CustomerDao customerDao;
  10. @Test
  11. public void demo1(){
  12. orderDao.add();
  13. orderDao.delete();
  14. customerDao.update();
  15. /**
  16. * 输出:
  17. * 前置增强...
  18. 添加订单
  19. 前置增强...
  20. 删除订单
  21. 前置增强...
  22. 修改客户
  23. */
  24. }
  25. }

    DefaultAdvisorAutoProxyCreator :根据切面中定义的信息生成代理

  1. <!-- 定义目标对象 -->
  2. <bean id="customerDao" class="cn.yzu.spring3.demo3.CustomerDaoImpl"></bean>
  3. <bean id="orderDao" class="cn.yzu.spring3.demo4.OrderDao"></bean>
  4. <!-- 定义增强 -->
  5. <bean id="beforeAdvice" class="cn.yzu.spring3.demo3.MyBeforeAdvice"></bean>
  6. <bean id="aroundAdvice" class="cn.yzu.spring3.demo4.MyAroundAdvice"></bean>
  7. <!-- 定义一个带有切点的切面 -->
  8. <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
  9.   <property name="pattern" value=".*add.*"/>
  10.   <property name="advice" ref="aroundAdvice"/>
  11. </bean>
  12. <!-- 自动生成代理 -->
  13. <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>

    区分基于ProxyFattoryBean的代理与自动代理区别?
      ProxyFactoryBean:先有被代理对象,将被代理对象传入到代理类中生成代理
      自动代理基于后处理Bean.在Bean的生成过程中,就产生了代理对象,把代理对象返回.生成Bean已经是代理对象

Spring的AspectJ的AOP(重要!!!!!)
  AspectJ是一个面向切面的框架,它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。
  Spring2.0以后新增了对AspectJ切点表达式支持,@AspectJ 是AspectJ1.5新增功能,通过JDK5注解技术,允许直接在Bean类中定义切面
  新版本Spring框架,建议使用AspectJ方式来开发AOP

  AspectJ表达式:
    语法:execution(表达式)
      execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

      execution(“* cn.itcast.spring3.demo1.dao.*(..)”) ---只检索当前包
      execution(“* cn.itcast.spring3.demo1.dao..*(..)”) ---检索包及当前包的子包.
      execution(* cn.itcast.dao.GenericDAO+.*(..)) ---检索GenericDAO及子类

  AspectJ增强
    @Before 前置通知,相当于BeforeAdvice
    @AfterReturning 后置通知,相当于AfterReturningAdvice
    @Around 环绕通知,相当于MethodInterceptor
    @AfterThrowing抛出通知,相当于ThrowAdvice
    @After 最终final通知,不管是否异常,该通知都会执行
    @DeclareParents 引介通知,相当于IntroductionInterceptor (不要求掌握)

  基于注解开发
    第一步:引入相应jar包
      aspectj依赖aop环境
      spring-aspects-3.2.0.RELEASE.jar
      com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

    第二步:编写被增强的类:

  1. public class UserDao {
  2. public void add(){
  3. System.out.println("添加用户");
  4. }
  5. public int update(){
  6. System.out.println("修改用户");
  7. return 1;
  8. }
  9. public void delete(){
  10. System.out.println("删除用户");
  11. }
  12. public void find(){
  13. System.out.println("查询用户");
  14. //int d = 1/ 0;
  15. }
  16. }

UserDao

    第三步:使用AspectJ注解形式

  1. @Aspect
  2. public class MyAspect {
  3. @Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")
  4. public void before(JoinPoint joinPoint){
  5. System.out.println("前置增强...."+joinPoint);
  6. }
  7. @AfterReturning(value="execution(* cn.itcast.spring3.demo1.UserDao.update(..))",returning="returnVal")
  8. public void afterReturin(Object returnVal){
  9. System.out.println("后置增强....方法的返回值:"+returnVal);
  10. }
  11. @Around(value="MyAspect.myPointcut()")
  12. public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
  13. System.out.println("环绕前增强....");
  14. Object obj = proceedingJoinPoint.proceed();
  15. System.out.println("环绕后增强....");
  16. return obj;
  17. }
  18. @AfterThrowing(value="MyAspect.myPointcut()",throwing="e")
  19. public void afterThrowing(Throwable e){
  20. System.out.println("不好了 出异常了!!!"+e.getMessage());
  21. }
  22. @After("MyAspect.myPointcut()")
  23. public void after(){
  24. System.out.println("最终通知...");
  25. }
  26. @Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")//切点的定义
  27. private void myPointcut(){}
  28. }

    第四步:创建applicationContext.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:aop="http://www.springframework.org/schema/aop"
  5. xsi:schemaLocation="
  6.       http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
  7.       http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop.xsd">
  8. <!-- 自动生成代理 底层就是AnnotationAwareAspectJAutoProxyCreator -->
  9. <aop:aspectj-autoproxy />
  10. <bean id="userDao" class="cn.yzu.spring3.demo1.UserDao"></bean>
  11. <bean id="myAspect" class="cn.yzu.spring3.demo1.MyAspect"></bean>
  12. </beans>

    第五步:测试

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class SpringTest1 {
  4. @Autowired
  5. @Qualifier("userDao")
  6. private UserDao userDao;
  7. @Test
  8. public void demo1(){
  9. userDao.add();
  10. userDao.delete();
  11. userDao.update();
  12. userDao.find();
  13. /**
  14. * 输出:
  15. * 前置增强....execution(void cn.itcast.spring3.demo1.UserDao.add())
  16. 添加用户
  17. 删除用户
  18. 修改用户
  19. 后置增强....方法的返回值:1
  20. 环绕前增强....
  21. 查询用户
  22. 环绕后增强....
  23. 最终通知...
  24. */
  25. }
  26. }

    AspectJ的通知类型
      @Before 前置通知,相当于BeforeAdvice:就在方法之前执行.没有办法阻止目标方法执行的
      @AfterReturning 后置通知,相当于AfterReturningAdvice:后置通知,获得方法返回值
      @Around 环绕通知,相当于MethodInterceptor:在可以方法之前和之后来执行的,而且可以阻止目标方法的执行
      @AfterThrowing抛出通知,相当于ThrowAdvice
      @After 最终final通知,不管是否异常,该通知都会执行
      @DeclareParents 引介通知,相当于IntroductionInterceptor (不要求掌握)

    面试
      Advisor和Aspect的区别?
        Advisor:Spring传统意义上的切面:支持一个切点和一个通知的组合.
        Aspect:可以支持多个切点和多个通知的组合.
  基于XML开发
    第一步:编写被增强的类:

  1. public class ProductDao {
  2. public int add(){
  3. System.out.println("添加商品...");
  4. //int d = 10/0;
  5. return 100;
  6. }
  7. public void update(){
  8. System.out.println("修改商品...");
  9. }
  10. public void delete(){
  11. System.out.println("删除商品...");
  12. }
  13. public void find(){
  14. System.out.println("查询商品...");
  15. }
  16. }

ProductDao

    第二步:定义切面

  1. public class MyAspectXML {
  2. public void before(){
  3. System.out.println("前置通知...");
  4. }
  5. public void afterReturing(Object returnVal){
  6. System.out.println("后置通知...返回值:"+returnVal);
  7. }
  8. public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
  9. System.out.println("环绕前增强....");
  10. Object result = proceedingJoinPoint.proceed();
  11. System.out.println("环绕后增强....");
  12. return result;
  13. }
  14. public void afterThrowing(Throwable e){
  15. System.out.println("异常通知..."+e.getMessage());
  16. }
  17. public void after(){
  18. System.out.println("最终通知....");
  19. }
  20. }

    第三步:配置applicationContext.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:aop="http://www.springframework.org/schema/aop"
  5. xsi:schemaLocation="
  6.       http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
  7.       http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop.xsd">
  8. <!-- 定义被增强的类 -->
  9. <bean id="productDao" class="cn.yzu.spring3.demo2.ProductDao"></bean>
  10. <!-- 定义切面 -->
  11. <bean id="myAspectXML" class="cn.yzu.spring3.demo2.MyAspectXML"></bean>
  12. <!-- 定义aop配置 -->
  13. <aop:config>
  14. <!-- 定义切点: -->
  15. <aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
  16. <aop:aspect ref="myAspectXML">
  17. <!-- 前置通知 -->
  18. <!-- <aop:before method="before" pointcut-ref="mypointcut"/> -->
  19. <!-- 后置通知 -->
  20. <!-- <aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/> -->
  21. <!-- 环绕通知 -->
  22. <!-- <aop:around method="around" pointcut-ref="mypointcut"/> -->
  23. <!-- 异常通知 -->
  24. <!-- <aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/> -->
  25. <!-- 最终通知 -->
  26. <aop:after method="after" pointcut-ref="mypointcut"/>
  27. </aop:aspect>
  28. </aop:config>
  29. </beans>

    第四步:测试

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext2.xml")
  3. public class SpringTest2 {
  4. @Autowired
  5. @Qualifier("productDao")
  6. private ProductDao productDao;
  7. @Test
  8. public void demo1(){
  9. productDao.add();
  10. productDao.find();
  11. productDao.update();
  12. productDao.delete();
  13. /**
  14. * 输出:
  15. * 添加商品...
  16. 最终通知....
  17. 查询商品...
  18. 修改商品...
  19. 删除商品...
  20. */
  21. }
  22. }

AOP详解的更多相关文章

  1. Spring4 AOP详解

    Spring4 AOP详解 第一章Spring 快速入门并没有对Spring4 的 AOP 做太多的描述,是因为AOP切面编程概念不好理解.所以这章主要从三个方面详解AOP:AOP简介(了解),基于注 ...

  2. 【转载】Spring AOP详解 、 JDK动态代理、CGLib动态代理

    Spring AOP详解 . JDK动态代理.CGLib动态代理  原文地址:https://www.cnblogs.com/kukudelaomao/p/5897893.html AOP是Aspec ...

  3. [Spring学习笔记 5 ] Spring AOP 详解1

    知识点回顾:一.IOC容器---DI依赖注入:setter注入(属性注入)/构造子注入/字段注入(注解 )/接口注入 out Spring IOC容器的使用: A.完全使用XML文件来配置容器所要管理 ...

  4. AOP 详解

    1. 需求:统计方法执行的性能情况(来源:<精通Spring 4.x>) // 性能监视类 PerformanceMonitor package com.noodles.proxy; pu ...

  5. Spring AOP详解(转载)所需要的包

    上一篇文章中,<Spring Aop详解(转载)>里的代码都可以运行,只是包比较多,中间缺少了几个相应的包,根据报错,几经百度搜索,终于补全了所有包. 截图如下: 在主测试类里面,有人怀疑 ...

  6. Spring AOP详解及简单应用

    Spring AOP详解   一.前言 在以前的项目中,很少去关注spring aop的具体实现与理论,只是简单了解了一下什么是aop具体怎么用,看到了一篇博文写得还不错,就转载来学习一下,博文地址: ...

  7. 转:Spring AOP详解

    转:Spring AOP详解 一.前言 在以前的项目中,很少去关注spring aop的具体实现与理论,只是简单了解了一下什么是aop具体怎么用,看到了一篇博文写得还不错,就转载来学习一下,博文地址: ...

  8. Spring全家桶——SpringBoot之AOP详解

    Spring全家桶--SpringBoot之AOP详解 面向方面编程(AOP)通过提供另一种思考程序结构的方式来补充面向对象编程(OOP). OOP中模块化的关键单元是类,而在AOP中,模块化单元是方 ...

  9. Spring Aop 详解二

    这是Spring Aop的第二篇,案例代码很详解,可以查看https://gitee.com/haimama/java-study/tree/master/spring-aop-demo. 阅读前,建 ...

  10. AOP详解之三-创建AOP代理后记,创建AOP代理

    AOP详解之三-创建AOP代理后记,创建AOP代理. 上篇文章已经获取到了AOP的信息,接下来就是拿着这些AOP的信息去创建代理了. 首先我们看下创建AOP代理的入口处. //这个方法将返回代理类 p ...

随机推荐

  1. git gui 还原部分提交文件

    有时候用git提交文件的时候会一起提交了多个文件,但是突然后悔了,想把其中一个文件撤销提交,其他文件不做修改.这个时候该怎么办呢? 我觉得有很多办法,比如可以先checkout到上次的提交,然后复制要 ...

  2. Java国际化(i18n)

    Java国际化(i18n) 最近在做一个网站国际化的功能.用Java做开发,使用spring+velocity. Java提供了对i18n的支持,spring对其做了集成,可以很方便的配置.主要思想就 ...

  3. yum 操作复习

    RPM与YUM是配合使用的. rpm负责从网站或指定的文件路径,获取到rpm软件包.也就是说你要安装什么服务或软件,就要先找到rpm包,下载下来.也就是通常说的配置yum源. 啥是yum源.你下载下的 ...

  4. Sublime Text 3 安装Package Control

    原来Subl3安装Package Control很麻烦,现在简单的方法来了 一.简单的安装方法 使用Ctrl+`快捷键或者通过View->Show Console菜单打开命令行,粘贴如下代码: ...

  5. STM32f103 定时器之编码器接口模式

    背景 买了个Arduino的旋转编码器模块,配合STM32定时器的编码器模式实现了旋转角度以及圈数的计数.这种旋转编码器我能想到的实际应用场景暂时只有实体音量旋钮,鼠标的滚轮等,所以只实现了计数.阅读 ...

  6. python的反转(切片)

    看下面代码吧,简单来说不如直接看代码.如下: #coding=utf-8 __author__ = 'debude' a = 'python' print a[::-1] #从最后n开始,每走一位都打 ...

  7. mac 关闭&&显示隐藏文件命令

    打开终端,输入: defaults write com.apple.finder AppleShowAllFiles -bool true 此命令显示隐藏文件 defaults write com.a ...

  8. Python 之旅

    Python2 之旅:   https://funhacks.net/explore-python/ <Python Cookbook>第三版   PYTHON3   http://pyt ...

  9. c模拟c++ const 转换

    #include <stdio.h> int main(){ const int constant = 21; const int* const_p = &constant; in ...

  10. 一篇很好的Java、C、PHP、前端、Android、IOS的文章

    http://www.cctime.com/html/2016-11-8/1238265.htm 很好的讲了这些技术的学习路线,其中的文档资料很丰富,值得学习参考