第九章 Spring5 高级应用及核心原理（二）

最新推荐文章于 2025-05-14 15:38:22 发布
最新推荐文章于 2025-05-14 15:38:22 发布
阅读量590 收藏 11
点赞数 25
分类专栏： Java高级程序员晋升 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_52514893/article/details/136992529
版权

一、代理模式

代理对象：增强目标对象。
  
1.1 静态代理
- 定义接口 
  package com.gupaoedu.service;
  
  public interface CynidService {
      public String sing(String song);
  }
  
- 创建目标对象 
  package com.gupaoedu.service.impl;
  
  import com.gupaoedu.service.CynidService;
  
  public class CynidServiceImpl implements CynidService {
      public String sing(String song) {
          System.out.println("目标对象方法执行了......(Cynid 同意演唱" + song + ")");
          return "爱你";
      }
  }
   
- 创建静态代理类 
  package com.gupaoedu.service;
  
  public class StaticCynidProxy implements CynidService {
  
      private CynidService cynidService;  // 需要增强的目标对象
  
      public StaticCynidProxy(CynidService cynidService) {
          this.cynidService = cynidService;
      }
  
      public String sing(String song) {
          System.out.println("目前对象执行之前的操作......(订酒店，安排行程等)");
          String res = cynidService.sing(song);
          System.out.println("目标对象执行之后的操作......(演出完之后的安排)");
          return "演唱曲目：" + res;
      }
  }
  
- 测试方法 

  package com.gupaoedu.service;
  
  import com.gupaoedu.service.impl.CynidServiceImpl;
  
  public class Test {
      public static void main(String[] args) {
          // 获取目标对象
          CynidService cynidService = new CynidServiceImpl();
          // 获取代理对象 增强目标对象
          CynidService proxy = new StaticCynidProxy(cynidService);
          // 处理
          System.out.println(proxy.sing("爱你"));
      }
  }
  
执行结果：
目前对象执行之前的操作......(订酒店，安排行程等)
目标对象方法执行了......(Cynid 同意演唱爱你)
目标对象执行之后的操作......(演出完之后的安排)
演唱曲目：爱你
  
1.2 动态代理
1.2.1 JDK 动态代理
目标实现有接口，那么我们就可以使用 JDK 代理模式。
  
- 测试方法 
package com.gupaoedu;

import com.gupaoedu.service.CynidService;
import com.gupaoedu.service.impl.CynidServiceImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class TestDyn {
    public static void main(String[] args) {
        // 获取目标对象
        final CynidService target = new CynidServiceImpl();
        // 获取代理对象
        CynidService proxy = (CynidService) Proxy.newProxyInstance(
                target.getClass().getClassLoader()  // 类加载器
                , target.getClass().getInterfaces() // 目标对象实现的接口数组
                , new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("目前对象执行之前的操作......");
                        String msg = (String)method.invoke(target, args[0]);
                        System.out.println("目标对象执行之后的操作......");
                        return "演唱一首：" + msg;
                    }
                }
        );
        System.out.println(proxy.sing("爱你"));
    }
}
  
执行结果：
目前对象执行之前的操作......
目标对象方法执行了......(Cynid 同意演唱爱你)
目标对象执行之后的操作......
演唱一首：爱你
 
1.2.2 CGLIB 动态代理
目标对象没有实现任何的接口，只能使用 CGLIB 代理，CGLIB 的本质其实的代理类继承了目标对象，并重写相关方法。
 
- 引入 CGLIB 的依赖 
  <dependencies>
      <!-- https://mvnrepository.com/artifact/cglib/cglib -->
      <dependency>
          <groupId>cglib</groupId>
          <artifactId>cglib</artifactId>
          <version>2.2.2</version>
      </dependency>
  </dependencies>
  
- 创建目标对象 
  package com.gupaoedu.service.impl;
  
  import com.gupaoedu.service.CynidService;
  
  public class CynidServiceImpl implements CynidService {
      public String sing(String song) {
          System.out.println("目标对象方法执行了......(Cynid 同意演唱" + song + ")");
          return "爱你";
      }
  }
  
- 创建代理类 
  package com.gupaoedu.proxy;
  
  import com.gupaoedu.service.impl.JjServiceImpl;
  import net.sf.cglib.proxy.Enhancer;
  import net.sf.cglib.proxy.MethodInterceptor;
  import net.sf.cglib.proxy.MethodProxy;
  import java.lang.reflect.Method;
  
  public class CglibProxy implements MethodInterceptor {
  
      private JjServiceImpl target;
  
      public CglibProxy(JjServiceImpl target) {
          this.target = target;
      }
  
      public JjServiceImpl createProxy() {
          Enhancer enhancer = new Enhancer();
          // 指定父类
          enhancer.setSuperclass(JjServiceImpl.class);
          // 指定回调方法
          enhancer.setCallback(this);
          // 创建对象代理对象
          return (JjServiceImpl)enhancer.create();
      }
  
      /**
       * 执行代理方法
       */
      public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
          System.out.println("before......");
          String msg = (String) method.invoke(target, objects[0]);
          System.out.println("after......");
          return "演唱曲目：" + msg;
      }
  }
  
- 测试方法 
  package com.gupaoedu;
  
  import com.gupaoedu.proxy.CglibProxy;
  import com.gupaoedu.service.impl.JjServiceImpl;
  
  public class TestCglib {
      public static void main(String[] args) {
          // 获取目标对象
          JjServiceImpl target = new JjServiceImpl();
          // 获取代理对象
          JjServiceImpl proxy = new CglibProxy(target).createProxy();
          System.out.println(proxy.sing("江南"));
      }
  }
  
执行结果：
before......
目标对象 Jj 执行了......江南
after......
演唱曲目：江南
  

二、Spring AOP 介绍

面向切面编程，就是将交叉业务逻辑封装成切面，利用 AOP 的功能将切面织入到主业务逻辑中。所谓交叉业务逻辑是指，通用的、与主业务逻辑无关的代码，如安全检查、事务、日志等。若不使用 AOP，则会出现代码纠缠，即交叉业务逻辑与主业务逻辑混合在一起。这样，会使主业务逻辑变的混杂不清。 
| 术语          | 说明                                                         |
| ------------- | :----------------------------------------------------------- |
| 切面          | 切面泛指交叉业务逻辑。比如事务处理、日志处理就可以理解为切面。常用的切面有通知与顾问。实际就是对主业务逻辑的一种增强 |
| 织入          | 织入是指将切面代码插入到目标对象的过程。                     |
| 连接点        | 连接点指切面可以织入的位置。                                 |
| 切入点        | 切入点指切面具体织入的位置。                                 |
| 通知(Advice)  | 通知是切面的一种实现，可以完成简单织入功能（织入功能就是在这里完成的）。通知定义了增强代码切入到目标代码的时间点，是目标方法执行之前执行，还是之后执行等。通知类型不同，切入时间不同。 |
| 顾问(Advisor) | 顾问是切面的另一种实现，能够将通知以更为复杂的方式织入到目标对象中，是将通知包装为更复杂切面的装配器。 不仅指定了切入时间点,还可以指定具体的切入点 |
  
添加依赖 
<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.17.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.1</version>
    </dependency>
</dependencies>
  
2.1 AspectJ
package com.gupaoedu.service;

public interface IUserService {

    public void fun1();

    public String fun2();

    public String fun3(String userName);

}
package com.gupaoedu.service.impl;

import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    public String fun3(String userName) {
        System.out.println("fun3......");
        return "fun3";
    }
}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy	// 放开AspectJ的使用
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        bean.fun1();
    }
}
  
执行结果：(正常调用)
fun1......
   
package com.gupaoedu.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect     // 显示的表明当前类是一个切面类
@Component  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("execution(* com.gupaoedu.service.impl.*.*(..))")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        bean.fun1();
    }
}
  
执行结果：
before ...... 
fun1......
 
修改切入点表达式 
package com.gupaoedu.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect     // 显示的表明当前类是一个切面类
@Component  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        bean.fun1();
        bean.fun2();
    }
}
  
执行结果：fun1 之前没有输入 before ...... ，而 fun2 之前有 before ...... 。
fun1......
before ......
fun2......
  
简化提供复用 
package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

}
package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

    /**
     * within 指定要切入的类型
     */
    @Before("within(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod02() {
        System.out.println("before ...... 02");
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        bean.fun2();
    }
}
  
执行结果：
before ......
before ...... 02
fun2......
  
package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

    /**
     * within 指定要切入的类型
     */
    @Before("within(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod02() {
        System.out.println("before ...... 02");
    }

    /**
     * 在AOP中默认使用的是JDK代理模式 如果目标对象有实现接口
     * this 指的就是代理对象
     * 修改@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
     */
    @Before("this(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod03() {
        System.out.println("before ...... 03");
    }

    /**
     * target 目标对象是com.gupaoedu.service.impl.UserServiceImpl
     */
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod04() {
        System.out.println("before ...... 04");
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        bean.fun2();
    }
}
  
执行结果：
before ......
before ...... 02
before ...... 03
before ...... 04
fun2......
   
package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

    /**
     * within 指定要切入的类型
     */
    @Before("within(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod02() {
        System.out.println("before ...... 02");
    }

    /**
     * 在AOP中默认使用的是JDK代理模式 如果目标对象有实现接口
     * this 指的就是代理对象
     * 修改@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
     */
    @Before("this(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod03() {
        System.out.println("before ...... 03");
    }

    /**
     * target 目标对象是com.gupaoedu.service.impl.UserServiceImpl
     */
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod04() {
        System.out.println("before ...... 04");
    }
    
    //@Before("args(String)")
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl) && args(String)")
    public void aspectMethod05() {
        System.out.println("before ...... 05");
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        bean.fun3("");
    }
}
  
执行结果：
before ...... 02
before ...... 03
before ...... 04
before ...... 05
fun3......
   
package com.gupaoedu.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface GpAnnotation01 {
}
package com.gupaoedu.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface GpAnnotation02 {
}
package com.gupaoedu.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface GpAnnotation03 {
}
package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

    /**
     * within 指定要切入的类型
     */
    @Before("within(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod02() {
        System.out.println("before ...... 02");
    }

    /**
     * 在AOP中默认使用的是JDK代理模式 如果目标对象有实现接口
     * this 指的就是代理对象
     * 修改@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
     */
    @Before("this(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod03() {
        System.out.println("before ...... 03");
    }

    /**
     * target 目标对象是com.gupaoedu.service.impl.UserServiceImpl
     */
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod04() {
        System.out.println("before ...... 04");
    }

    //@Before("args(String)")
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl) && args(String)")
    public void aspectMethod05() {
        System.out.println("before ...... 05");
    }

    /**
     * 调用某个方法的入参被GpAnnotation01注解所修饰
     */
    @Before("@args(com.gupaoedu.annotation.GpAnnotation01)")
    public void aspectMethod06() {
        System.out.println("before ...... 06");
    }

}

package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;

@GpAnnotation01
public class Student {
}
package com.gupaoedu.service;

import com.gupaoedu.service.impl.Student;

public interface IUserService {

    public void fun1();

    public String fun2();

    public String fun3(String userName);

    public String fun4(Student student);

}

package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;
import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    //public String fun3(String userName) {
    public String fun3(@GpAnnotation01 String userName) {
        System.out.println("fun3......");
        return "fun3";
    }

    public String fun4(Student student) {
        System.out.println("fun4......");
        return "fun4";
    }
}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
before ...... 02
before ...... 03
before ...... 04
before ...... 06
fun4......
   
package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;
import com.gupaoedu.annotation.GpAnnotation03;
import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
@GpAnnotation03
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    //public String fun3(String userName) {
    public String fun3(@GpAnnotation01 String userName) {
        System.out.println("fun3......");
        return "fun3";
    }

    public String fun4(Student student) {
        System.out.println("fun4......");
        return "fun4";
    }
}
package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

    /**
     * within 指定要切入的类型
     */
    @Before("within(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod02() {
        System.out.println("before ...... 02");
    }

    /**
     * 在AOP中默认使用的是JDK代理模式 如果目标对象有实现接口
     * this 指的就是代理对象
     * 修改@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
     */
    @Before("this(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod03() {
        System.out.println("before ...... 03");
    }

    /**
     * target 目标对象是com.gupaoedu.service.impl.UserServiceImpl
     */
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod04() {
        System.out.println("before ...... 04");
    }

    //@Before("args(String)")
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl) && args(String)")
    public void aspectMethod05() {
        System.out.println("before ...... 05");
    }

    /**
     * 调用某个方法的入参被GpAnnotation01注解所修饰
     */
    @Before("@args(com.gupaoedu.annotation.GpAnnotation01)")
    public void aspectMethod06() {
        System.out.println("before ...... 06");
    }

    /**
     * 拦截 被GpAnnotation03所修饰的类型
     */
    @Before("@within(com.gupaoedu.annotation.GpAnnotation03)")
    public void aspectMethod07() {
        System.out.println("before ...... 07");
    }
}

package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
before ...... 02
before ...... 03
before ...... 04
before ...... 06
before ...... 07
fun4......
   
package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;
import com.gupaoedu.annotation.GpAnnotation02;
import com.gupaoedu.annotation.GpAnnotation03;
import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
@GpAnnotation03
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    //public String fun3(String userName) {
    public String fun3(@GpAnnotation01 String userName) {
        System.out.println("fun3......");
        return "fun3";
    }

    @GpAnnotation02
    public String fun4(Student student) {
        System.out.println("fun4......");
        return "fun4";
    }
}


package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

    /**
     * within 指定要切入的类型
     */
    @Before("within(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod02() {
        System.out.println("before ...... 02");
    }

    /**
     * 在AOP中默认使用的是JDK代理模式 如果目标对象有实现接口
     * this 指的就是代理对象
     * 修改@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
     */
    @Before("this(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod03() {
        System.out.println("before ...... 03");
    }

    /**
     * target 目标对象是com.gupaoedu.service.impl.UserServiceImpl
     */
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod04() {
        System.out.println("before ...... 04");
    }

    //@Before("args(String)")
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl) && args(String)")
    public void aspectMethod05() {
        System.out.println("before ...... 05");
    }

    /**
     * 调用某个方法的入参被GpAnnotation01注解所修饰
     */
    @Before("@args(com.gupaoedu.annotation.GpAnnotation01)")
    public void aspectMethod06() {
        System.out.println("before ...... 06");
    }

    /**
     * 拦截 被GpAnnotation03所修饰的类型
     */
    @Before("@within(com.gupaoedu.annotation.GpAnnotation03)")
    public void aspectMethod07() {
        System.out.println("before ...... 07");
    }

    @Before("@annotation(com.gupaoedu.annotation.GpAnnotation02)")
    public void aspectMethod08() {
        System.out.println("before ...... 08");
    }
}

package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
before ...... 02
before ...... 03
before ...... 04
before ...... 06
before ...... 07
before ...... 08
fun4......
  
2.2 切入点表达式
| 表达式类型  | 说明                     |
| ----------- | ------------------------ |
| execution   | 定位到目标对象的方法上   |
| within      | 定位到具体的类型上       |
| this        | 代理对象的类型           |
| target      | 目标对象的类型           |
| args        | 参数的类型               |
| @args       | 传入的参数有被该注解修饰 |
| @within     | 类型修饰的注解           |
| @annotation | 方法修饰的注解           |
 
execution 表达式
语法：execution([访问权限类型] 返回值类型 [全限定类名] 方法名(参数名) [抛出的异常类型]) 
| 符合 | 含有 |
| ---- | ----------------------------------------------------- |
| * | 0 到多个符合 |
| .. | 方法参数中表示任意个参数,用在包名后表示当前包及其子包 |
| + | 用在类名后表示当前类及其子类,用在接口后表接口及其实现 |
  
实例： 
execution(public * *(. .))
//指定切入点为：任意公共方法。
execution(* set *(. .))
//指定切入点为：任何一个以“set”开始的方法。
execution(* com.xyz.service.*.*(. .))
//指定切入点为：定义在service包里的任意类的任意方法。
execution(* com.xyz.service. .*.*(. .))
//指定切入点为：定义在service包或者子包里的任意类的任意方法。“..”出现在类名中时，后面必须跟“*”，表示包、子包下的所有类。
execution(* *.service.*.*(. .))
//指定只有一级包下的serivce子包下所有类(接口)中的所有方法为切入点
execution(* *. .service.*.*(. .))
//指定所有包下的serivce子包下所有类(接口)中的所有方法为切入点
   
2.3 通知类型
| 通知类型     | 说明                                                         |
| :----------- | :----------------------------------------------------------- |
| 前置通知     | 目标方法执行之前调用                                         |
| 后置通知     | 目标方法执行完成之后调用                                     |
| 环绕通知     | 目标方法执行前后都会调用方法，且能增强结果                   |
| 异常处理通知 | 目标方法出现异常调用                                         |
| 最终通知     | 无论程序执行是否正常，该通知都会执行。类似于try..catch中finally代码块 |
   
package com.gupaoedu.aspect;

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  // 将该对象加载到IoC容器中
public class MyAspectJ01 {

    /**
     * 提供复用
     */
    @Pointcut("execution(* com.gupaoedu.service.impl.*.fun2(..))")
    public void pointcut1(){}

    /**
     * 要增强目标对象的方法
     *      指定目标对象
     *      切入点表达式
     */
    @Before("pointcut1()")
    public void aspectMethod01() {
        System.out.println("before ...... ");
    }

    /**
     * within 指定要切入的类型
     */
    @Before("within(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod02() {
        System.out.println("before ...... 02");
    }

    /**
     * 在AOP中默认使用的是JDK代理模式 如果目标对象有实现接口
     * this 指的就是代理对象
     * 修改@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
     */
    @Before("this(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod03() {
        System.out.println("before ...... 03");
    }

    /**
     * target 目标对象是com.gupaoedu.service.impl.UserServiceImpl
     */
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl)")
    public void aspectMethod04() {
        System.out.println("before ...... 04");
    }

    //@Before("args(String)")
    @Before("target(com.gupaoedu.service.impl.UserServiceImpl) && args(String)")
    public void aspectMethod05() {
        System.out.println("before ...... 05");
    }

    /**
     * 调用某个方法的入参被GpAnnotation01注解所修饰
     */
    @Before("@args(com.gupaoedu.annotation.GpAnnotation01)")
    public void aspectMethod06() {
        System.out.println("before ...... 06");
    }

    /**
     * 拦截 被GpAnnotation03所修饰的类型
     */
    @Before("@within(com.gupaoedu.annotation.GpAnnotation03)")
    public void aspectMethod07() {
        System.out.println("before ...... 07");
    }

    @Before("@annotation(com.gupaoedu.annotation.GpAnnotation02)")
    public void aspectMethod08() {
        System.out.println("before ...... 08");
    }
}
package com.gupaoedu.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAspectJ02 {

    /**
	 * 前置通知
     */
    @Before("execution(* com.gupaoedu.service.impl.*.*(..))")
    public void before() {
        System.out.println("before ... ... ");
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
before ... ...
fun4......
   
package com.gupaoedu.aspect;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAspectJ02 {

    /**
     * 前置通知
     */
    @Before("execution(* com.gupaoedu.service.impl.*.*(..))")
    public void before() {
        System.out.println("before ... ... ");
    }

    /**
     * 后置通知 获取返回结果
     * @param res
     */
    @AfterReturning(value = "within(com.gupaoedu.service.impl.*)", returning = "res")
    public void afterReturning(Object res) {
        System.out.println("后置通知 ... ... " + res);
    }
}
package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;
import com.gupaoedu.annotation.GpAnnotation02;
import com.gupaoedu.annotation.GpAnnotation03;
import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
@GpAnnotation03
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    //public String fun3(String userName) {
    public String fun3(@GpAnnotation01 String userName) {
        System.out.println("fun3......");
        return "fun3";
    }

    @GpAnnotation02
    public String fun4(Student student) {
        System.out.println("fun4......");
        return "fun4";
    }
}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
before ... ...
fun4......
后置通知 ... ... fun4
   
package com.gupaoedu.aspect;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAspectJ02 {

    /**
     * 前置通知
     */
    @Before("execution(* com.gupaoedu.service.impl.*.*(..))")
    public void before() {
        System.out.println("before ... ... ");
    }

    /**
     * 后置通知 获取返回结果
     * @param res
     */
    @AfterReturning(value = "within(com.gupaoedu.service.impl.*)", returning = "res")
    public void afterReturning(Object res) {
        System.out.println("后置通知 ... ... " + res);
    }

    @Around(value = "within(com.gupaoedu.service.impl.*)")
    public void around() {
        System.out.println("环绕通知 ... ... ");
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
环绕通知 ... ...
后置通知 ... ... null
   
package com.gupaoedu.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAspectJ02 {

    /**
     * 前置通知
     */
    @Before("execution(* com.gupaoedu.service.impl.*.*(..))")
    public void before() {
        System.out.println("before ... ... ");
    }

    /**
     * 后置通知 获取返回结果
     * @param res
     */
    @AfterReturning(value = "within(com.gupaoedu.service.impl.*)", returning = "res")
    public void afterReturning(Object res) {
        System.out.println("后置通知 ... ... " + res);
    }

    /**
     * 环绕通知
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "within(com.gupaoedu.service.impl.*)")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("目标对象 before ... ... ");
        Object[] args = proceedingJoinPoint.getArgs();
        Object res = proceedingJoinPoint.proceed(); // 目标对象方法执行
        System.out.println("目标对象 after ... ... ");
        return res;
    }

}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
目标对象 before ... ...
before ... ...
fun4......
目标对象 after ... ...
后置通知 ... ... fun4
   
package com.gupaoedu.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAspectJ02 {

    /**
     * 前置通知
     */
    @Before("execution(* com.gupaoedu.service.impl.*.*(..))")
    public void before() {
        System.out.println("before ... ... ");
    }

    /**
     * 后置通知 获取返回结果
     * @param res
     */
    @AfterReturning(value = "within(com.gupaoedu.service.impl.*)", returning = "res")
    public void afterReturning(Object res) {
        System.out.println("后置通知 ... ... " + res);
    }

    /**
     * 环绕通知
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "within(com.gupaoedu.service.impl.*)")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("目标对象 before ... ... ");
        Object[] args = proceedingJoinPoint.getArgs();
        Object res = proceedingJoinPoint.proceed(); // 目标对象方法执行
        System.out.println("目标对象 after ... ... ");
        return res;
    }

    /**
     * 异常通知
     * @param ex
     */
    @AfterThrowing(value = "within(com.gupaoedu.service.impl.*)", throwing = "ex")
    public void afterThrowing(Exception ex) {
        System.out.println("异常通知产生了 ... ... " + ex);
    }
}

package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;
import com.gupaoedu.annotation.GpAnnotation02;
import com.gupaoedu.annotation.GpAnnotation03;
import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
@GpAnnotation03
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    //public String fun3(String userName) {
    public String fun3(@GpAnnotation01 String userName) {
        System.out.println("fun3......");
        return "fun3";
    }

    @GpAnnotation02
    public String fun4(Student student) {
        System.out.println("fun4......" + 1/0);
        return "fun4";
    }
}
  
执行结果： 
目标对象 before ... ... 
before ... ... 
异常通知产生了 ... ... java.lang.ArithmeticException: / by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.gupaoedu.service.impl.UserServiceImpl.fun4(UserServiceImpl.java:30)
	at com.gupaoedu.service.impl.UserServiceImpl$$FastClassBySpringCGLIB$$7395f8d0.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:752)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:56)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:88)
	at com.gupaoedu.aspect.MyAspectJ02.around(MyAspectJ02.java:32)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:644)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:633)
	at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:70)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:55)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:62)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:93)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:691)
	at com.gupaoedu.service.impl.UserServiceImpl$$EnhancerBySpringCGLIB$$4afe69b4.fun4(<generated>)
	at com.gupaoedu.JavaConfig.main(JavaConfig.java:23)
   
package com.gupaoedu.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAspectJ02 {

    /**
     * 前置通知
     */
    @Before("execution(* com.gupaoedu.service.impl.*.*(..))")
    public void before() {
        System.out.println("before ... ... ");
    }

    /**
     * 后置通知 获取返回结果
     * @param res
     */
    @AfterReturning(value = "within(com.gupaoedu.service.impl.*)", returning = "res")
    public void afterReturning(Object res) {
        System.out.println("后置通知 ... ... " + res);
    }

    /**
     * 环绕通知
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "within(com.gupaoedu.service.impl.*)")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("目标对象 before ... ... ");
        Object[] args = proceedingJoinPoint.getArgs();
        Object res = proceedingJoinPoint.proceed(); // 目标对象方法执行
        System.out.println("目标对象 after ... ... ");
        return res;
    }

    /**
     * 异常通知
     * @param ex
     */
    @AfterThrowing(value = "within(com.gupaoedu.service.impl.*)", throwing = "ex")
    public void afterThrowing(Exception ex) {
        System.out.println("异常通知产生了 ... ... " + ex);
    }

    /**
     * 最终通知
     */
    @After(value = "within(com.gupaoedu.service.impl.*)")
    public void after(){
        System.out.println("最终通知...");
    }
}

package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;
import com.gupaoedu.annotation.GpAnnotation02;
import com.gupaoedu.annotation.GpAnnotation03;
import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
@GpAnnotation03
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    //public String fun3(String userName) {
    public String fun3(@GpAnnotation01 String userName) {
        System.out.println("fun3......");
        return "fun3";
    }

    @GpAnnotation02
    public String fun4(Student student) {
        System.out.println("fun4......");
        //System.out.println("fun4......" + 1/0);
        return "fun4";
    }
}
package com.gupaoedu;

import com.gupaoedu.service.IUserService;
import com.gupaoedu.service.impl.Student;
import com.gupaoedu.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 修改默认的代理模式为CGLIB代理模式
@ComponentScan
public class JavaConfig {

    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(JavaConfig.class);
        IUserService bean = ac.getBean(IUserService.class);
        //bean.fun1();
        //bean.fun2();
        //bean.fun3("");
        bean.fun4(new Student());
    }
}
  
执行结果：
目标对象 before ... ...
before ... ...
fun4......
目标对象 after ... ...
最终通知...
后置通知 ... ... fun4
  
放开异常，再次执行。 
package com.gupaoedu.service.impl;

import com.gupaoedu.annotation.GpAnnotation01;
import com.gupaoedu.annotation.GpAnnotation02;
import com.gupaoedu.annotation.GpAnnotation03;
import com.gupaoedu.service.IUserService;
import org.springframework.stereotype.Service;

@Service
@GpAnnotation03
public class UserServiceImpl implements IUserService {

    public void fun1() {
        System.out.println("fun1......");
    }

    public String fun2() {
        System.out.println("fun2......");
        return "fun2";
    }

    //public String fun3(String userName) {
    public String fun3(@GpAnnotation01 String userName) {
        System.out.println("fun3......");
        return "fun3";
    }

    @GpAnnotation02
    public String fun4(Student student) {
        //System.out.println("fun4......");
        System.out.println("fun4......" + 1/0);
        return "fun4";
    }
}
  
执行结果： 
目标对象 before ... ... 
before ... ... 
最终通知...
异常通知产生了 ... ... java.lang.ArithmeticException: / by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.gupaoedu.service.impl.UserServiceImpl.fun4(UserServiceImpl.java:31)
	at com.gupaoedu.service.impl.UserServiceImpl$$FastClassBySpringCGLIB$$7395f8d0.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:752)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor.invoke(MethodBeforeAdviceInterceptor.java:56)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint.proceed(MethodInvocationProceedingJoinPoint.java:88)
	at com.gupaoedu.aspect.MyAspectJ02.around(MyAspectJ02.java:38)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:644)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:633)
	at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:70)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.aspectj.AspectJAfterAdvice.invoke(AspectJAfterAdvice.java:47)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:55)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.aspectj.AspectJAfterThrowingAdvice.invoke(AspectJAfterThrowingAdvice.java:62)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:93)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:691)
	at com.gupaoedu.service.impl.UserServiceImpl$$EnhancerBySpringCGLIB$$604db0cf.fun4(<generated>)
	at com.gupaoedu.JavaConfig.main(JavaConfig.java:23)
Spring第二讲：SpringBoot 原理及应用
Jet_qi的博客
03-19 681
SpringBoot简化了Spring配置文件，无需再使用SpringMVC，只需要引入相关的starter即可。本文是Spring第二讲：SpringBoot 原理及应用
Spring Boot框架的原理及应用详解（二）
凛鼕将至的博客
06-18 810
Spring Boot是一个基于Spring框架的开源项目，旨在通过约定大于配置的原则来简化Spring应用的初始搭建以及开发过程。它通过使用特定的方式来进行配置，减少了样板化的配置，使开发人员能够更专注于业务逻辑的实现。 本文将跟随《Spring Boot框架的原理及应用详解（一）》的进度，继续介绍Spring Boot框架。希望通过本系列文章的学习，您将能够更好地理解Spring Boot框架的内部工作原理，掌握Spring Boot框架的使用技巧，以及通过合理的设
Spring 高级编程
10-16
很好的一本Spring文档，Spring 之父推荐。
Spring 5.X系列教程:满足你对Spring5的一切想象-持续更新
程序那些事
05-20 1万+
是什么让java世界变得更好，程序员变得更友爱，秃头率变得不是那么的高，让程序员不必再每天996，有时间找个女朋友？ 是Spring。 是什么让企业级java应用变得简单易懂，降低了java程序员的进入门槛，导致了现在遍地都是java程序员的窘境？ 是Spring。 是什么从无冕之王变成了事实上的企业标准，让规则制定者也要颤抖几分？ 是Spring。 简单的说，Spring满足了你们对于java程序的所有想象。是个java程序员都会投入Spring的怀抱。 今天这篇文件就是对Spring基础的总结。
Spring 5高级编程，投入Spring的怀抱
老男孩的架构路
10-31 374
是什么让java世界变得更好，程序员变得更友爱，秃头率变得不是那么的高，让程序员不必再每天996，有时间找个女朋友？是Spring。是什么让企业级java应用变得简单易懂，降低了java程序员的进入门槛，导致了现在遍地都是java程序员的窘境？是Spring。是什么从无冕之王变成了事实上的企业标准，让规则制定者也要颤抖几分？是Spring。简单的说，Spring满足了你们对于java程序的所有想象。是个java程序员都会投入Spring的怀抱。
springboot 自动装配_springboot 自动装配
weixin_39725193的博客
12-09 133
springboot最大特点就是自动装配一.什么是自动配置？根据特定条件自动将一些配置类的bean注册进ioc容器，使得可以在需要的地方直接从容器中获取和使用​ “自动”的表现形式就是我们只需要引我们想用功能的jar包，相关的配置我们完全不用管(springboot内置了很多的**start配置信息)二.如何实现自动配置？**@EnableAutoConfiguration+@Conditiona...
阿里高级程序员感慨：曾经我也风光无限，如今却看不到希望
热门推荐
优快云头条
01-23 2万+
熟悉阿里职级的小伙伴可能知道，P8算是很高的级别了，正常来讲十来年工作经验加上优秀的能力才能拿到这样的级别。 不过，有一名阿里P8却在互联网论坛大倒苦水，感慨自己曾经也是风云人物风光无限，如今却到了奔四的年纪，看不到希望。 如上就是这名阿里员工的感慨兼吐槽，其如此写道：前五年年年高绩效，被历任多个老板追捧，从6一路升到8，升8那年却搞了个年度低绩效，从此状态一直不好了，在原部门及换了2个B...
Spring5高级编程第五版 英文版
04-14
《Spring5高级编程第五版》是一本深入探讨Spring框架核心特性和高级用法的专业书籍，主要面向已经具备一定Java和Spring基础的开发者。本指南旨在帮助读者深化对Spring的理解，提升开发效率，以及掌握最新的Spring5...
Java核心知识-Spring 原理（二）-IOC
最新发布
技术引领业务创新
05-14 5305
Spring IOC（控制反转）是Spring框架的核心，通过配置文件描述Bean及其依赖关系，利用反射机制实例化Bean并建立依赖。Spring容器在启动时读取配置信息，生成Bean配置注册表，并实例化Bean，装配依赖关系，提供运行环境。BeanFactory是Spring的基础设施，而ApplicationContext则面向开发者，提供了更多高级功能。Spring支持多种Bean作用域，如单例、原型、请求、会话和全局会话，并管理Bean的生命周期，包括实例化、依赖注入、初始化和销毁等阶段。通过这些机
《Java EE企业级应用开发教程Spring+Spring MVC+MyBatis》_源代码.zip
11-29
《Java EE企业级应用开发教程Spring+Spring MVC+MyBatis》是一本深入探讨Java企业级应用程序开发的书籍，源代码包含多个章节的实例，旨在帮助读者理解和掌握使用Spring、Spring MVC和MyBatis框架进行实际开发的关键...
Spring框架高级编程完整源码
09-23
Spring框架是主要的开源应用程序开发框架，它使得Java/J2EE开发更容易、效率更高。本书不仅向读者展示了Spring能做什么?而且揭示了Spring完成这些功能的原理，解释其功能和动机，以帮助读者使用该框架的所有部分来开发成功的应用程序。本书涵盖Spring的所有特性，并且演示了如何将其构成一个连贯的整体，帮助读者理解Spring方法的基本原理、何时使用Sping以及如何效仿最佳实践。所有这些都以完整的样本应用程序来举例说明。读完本书，读者将能够有效地在各种应用中(从简单的web应用程序到复杂的企业级应用程序)使用Spring。 作者：(美)约翰逊 译者：蒋培 Rod Johnsn是Spring框架的创始人，并且是Java和J2EE领域的著名专家。 　　Rod获悉民大学博士学位。他具有C/C++开发背景，从Java和J2EE发布以来就作为开发者、休系结构设计者和顾问涉足了Java和J2EE领域。 　　他撰写了两本最普及并最有影响力的J2EE书籍：《Expert One-on-one J2EE Design and Deuelo Pment》（Wrox，2002），和《J2EE without EJB》（Wrox，2004.与Juergen Hoelle合著）。这两本书在“敏捷J2EE的兴起和心变过度复杂的传统J2EE体系结构方面都起了得要作用。 　　Rod是Spring框架的共同领导之一。他的发言很受欢迎，并且经常出现在美国、欧洲和亚洲举行的Java重要活动中。了是一些JSR的专家组的成员，为Java社区发展计划（Java Community Process,JCP）EBTL。 　　他还具有在银行和金融、保险、软件、媒体等领域从事顾问的广泛经验。他是Interface21的CEO，Interface21是一家致力于提供专家级J2EE和Spring框架服务的咨询公司。他各极参与客户项目和Spring开发。
spring5 +reactive编程
11-11
主要介绍spring5 webflux模块相关的内容，包括spring5的一些新特性，webflux的简单使用，异步常见的处理方式，webclient处理微服务的一些场景；Reactive-Streams 编程的实现规范，目前主流的一些响应式编程框架；以及异步访问数据库的一些应用；
Spring 5 Design Patterns-Packt Publishing(2017).pdf
02-24
Spring 5 Design Patterns is for all Java developers who want to learn Spring for the enterprise application. Therefore, enterprise Java developers will find it particularly useful in the understanding of design patterns used by the Spring Framework and how it solves common design problems in the enterprise application, and they will fully appreciate the examples presented in this book. Before reading this book, readers should have basic knowledge of Core Java, JSP, Servlet, and XML. Spring 5 Framework is newly launched by Pivotal with reactive programming. Spring 5 introduces many new features and enhancements from its previous version. We will discuss all this in the book. Spring 5 Design Patterns will give you in-depth insight about the Spring Framework. The great part of today's Spring Framework is that all companies have already taken it as a primary framework for development of the enterprise application. For Spring, no external enterprise server is needed to start working with it. The goals of writing this book are to discuss all design patterns used behind the Spring Framework and how they are implemented in the Spring Framework. Here, the author has also given you some best practices that must be used in the design and development of the application. The book contains 12 chapters that cover everything from the basics to more complex design pattern such as reactive programming. Spring 5 Design Patterns is divided into three sections. The first section introduces you to the essentials of the design patterns and the Spring Framework. The second section steps behind the front end and shows where Spring fits in the back end of an application. The third section expands on this by showing how to build web applications with Spring and introducing a new feature of the Spring 5 reactive programming. This part also shows how to handle concurrency in the enterprise application.
java spring pdf下载_Spring5高级编程（第5版）PDF 下载
weixin_42531779的博客
02-13 1640
检索域对象 2106.10 使用ResultSetExtractor检索嵌套域对象 2116.11 建模JDBC操作的Spring类 2136.12 使用MappingSqlQuery查询数据 2156.13 插入数据并检索生成的键 2206.14 使用BatchSqlUpdate进行批处理操作 2216.15 使用SqlFunction调用存储函数...
spring5高级编程_Spring 5.2.2 核心技术
weixin_39636707的博客
12-18 220
今天开始正式进入主题Spring 5.2.2 Core Technologies(核心技术)的内容。 参考手册文档的这一部分涵盖了Spring框架绝对不可或缺的所有技术。其中最重要的是Spring框架的控制反转(IoC，Inversion of Control)容器。对Spring框架的IoC容器进行完全的了解之后，Spring的面向方面编程(AOP，Aspect-Oriented Progra...
完美，这份世界顶级架构师编写的550页Spring5高级编程
代码界的扛把子
04-15 311
国外名人录 Iuliana Cosmina是一名Spring认证的Web应用程序开发人员，也是Spring认证的Spring专家(由Pivotal定义，Pivotal是Spring框架、Spring Boot以及其他工具的制造商)。她曾与Apress出版社合作出版了多本关于核心Spring认证和Spring认证Web开发的书籍。她是来自Bearing Point Software的一名软件架构师，也是GitHub、Stack Overflow等平台上活跃的编码者和软件贡献者。小编今天就分享一份来自他编写的
spring5高级编程_Java稳坐TOIBE编程语言排行榜第一，你还不懂Spring？
weixin_39748838的博客
12-02 146
程序员书库(ID：CodingBook) 综合整理书单来自：https://bookauthority.org/books/new-spring-framework-books前不久，TIOBE公布了2020年1月份编程语言排行榜，毫无悬念，Java稳坐第一。虽然我们都知道今年流行度最高的编程语言是Python，但无论Python增速如何强劲，短期内，编程语言的龙头依然是Java，因此，许多人依然...
spring书籍_十年沉淀之作，手写spring精华思想，Java架构师成长必备
weixin_39900206的博客
12-17 429
书籍介绍：《Spring 5核心原理与30个类手写实战》基于编程开发实践，不仅深度解析Spring 5的原理与新特性，更从环境准备、顶层结构设计、数据访问等方面一步步地推导出Spring的设计原理。在每个知识点上，均以大量的经典代码案例辅助讲解，使理论紧密联系实际。最后手写30个类，以体会Spring作者的创作过程，让每一位读者学以致用。对于立志成为Java架构师的技术人员，以及对以Spring为...
Spring5 高级教程（三）
龙哥盟
08-20 881
原文：Pro Spring 5 协议：CC BY-NC-SA 4.0 五、Spring AOP 简介 除了依赖注入(DI)，Spring 框架提供的另一个核心特性是支持面向方面编程(AOP)。AOP 通常被称为实现横切关注点的工具。术语横切关注点指的是应用中不能从应用的其余部分分解的逻辑，它可能导致代码重复和紧密耦合。通过使用 AOP 将逻辑的各个部分模块化，称为关注点，您可以将它们应用到应用的许多部分，而无需复制代码或创建硬依赖。日志和安全性是许多应用中都存在的横切关注点的典型例子。考虑一个为调试目的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

方寸之间不太闲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值