Java通知及应用场景

野性酷女 2024-03-17 00:02 53阅读 0赞

### 概述 ###

在Java编程中，通知是一种非常重要的编程思想。它可以将一些通用的代码逻辑从业务逻辑中分离出来，从而提高代码的可复用性和可维护性。通知是AOP（面向切面编程）的核心概念之一，它可以在目标方法的执行前、执行后、返回时、抛出异常时等不同的时间点插入一些通用的代码逻辑。

本文将详细介绍Java中通知的实现方式、核心概念、通知的种类以及通知的应用场景等方面的内容。希望读者通过本文的学习，能够更好地理解Java中通知的作用和应用场景，从而提高自己的编程水平。

### 实现方式 ###

在Java中，通知的实现方式主要有两种：基于代理的方式和基于字节码增强的方式。

#### 基于代理的方式 ####

基于代理的方式是指在运行时动态地生成一个代理类，这个代理类可以拦截目标对象的方法调用，并在方法调用前、调用后、返回时、抛出异常时等不同的时间点插入一些通用的代码逻辑。基于代理的方式可以通过Java自带的Proxy类和InvocationHandler接口来实现，也可以通过第三方框架如Spring AOP来实现。

下面是一个基于代理的示例代码：

public interface UserService {
        void addUser(String name, String password);
    }
    
    public class UserServiceImpl implements UserService {
        @Override
        public void addUser(String name, String password) {
            System.out.println("添加用户：" + name);
        }
    }
    
    public class LogAspect implements InvocationHandler {
        private Object target;
    
        public LogAspect(Object target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("调用方法前");
            Object result = method.invoke(target, args);
            System.out.println("调用方法后");
            return result;
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            UserService userService = new UserServiceImpl();
            UserService proxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
                    userService.getClass().getInterfaces(), new LogAspect(userService));
            proxy.addUser("张三", "123456");
        }
    }

在上面的示例代码中，我们定义了一个UserService接口和一个UserServiceImpl类，LogAspect是一个代理类，它实现了InvocationHandler接口，并在invoke方法中插入了一些通用的代码逻辑。在Main类中，我们通过调用Proxy.newProxyInstance方法来生成一个代理对象，并将LogAspect对象传入其中。当我们调用代理对象的addUser方法时，LogAspect对象的invoke方法会被自动调用，从而实现了在方法调用前、调用后插入通用的代码逻辑的功能。

#### 基于字节码增强的方式 ####

基于字节码增强的方式是指在编译期或类加载期间，对目标类的字节码进行修改，从而实现在方法调用前、调用后、返回时、抛出异常时等不同的时间点插入一些通用的代码逻辑。基于字节码增强的方式可以通过第三方框架如AspectJ来实现。

下面是一个基于字节码增强的示例代码：

public class UserService {
        public void addUser(String name, String password) {
            System.out.println("添加用户：" + name);
        }
    }
    
    public aspect LogAspect {
        pointcut addUserPointcut(String name, String password) : execution(* UserService.addUser(String, String)) && args(name, password);
    
        before(String name, String password) : addUserPointcut(name, password) {
            System.out.println("调用方法前");
        }
    
        after(String name, String password) : addUserPointcut(name, password) {
            System.out.println("调用方法后");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            UserService userService = new UserService();
            userService.addUser("张三", "123456");
        }
    }

在上面的示例代码中，我们定义了一个UserService类和一个LogAspect切面类。在LogAspect类中，我们定义了一个pointcut来匹配UserService类中的addUser方法，并在before和after通知中分别插入了一些通用的代码逻辑。在Main类中，我们直接调用UserService类的addUser方法，AspectJ会自动将LogAspect类的通知插入到addUser方法的调用前和调用后。

### 核心概念 ###

在AOP编程中，通知是一个非常重要的核心概念。除了通知之外，还有一些其他的核心概念，如切面、连接点和切点等。

#### 切面 ####

切面是一个横切关注点的抽象概念，它可以横切多个对象和方法，将一些通用的代码逻辑从业务逻辑中分离出来，从而提高代码的可复用性和可维护性。切面通常由切点和通知组成。

#### 连接点 ####

连接点是指在程序执行过程中能够插入切面的点，比如方法调用、异常抛出等。连接点是AOP中最基本的概念之一，它是切面的具体实现。

#### 切点 ####

切点是指在连接点中需要被拦截的点，它定义了切面的作用范围。切点通常是通过一些表达式来定义的，比如execution表达式、within表达式等。

### 通知的种类 ###

在AOP编程中，通知通常分为以下几种类型：

#### 前置通知 ####

前置通知在目标方法调用前执行，可以在前置通知中进行一些参数校验、权限检查等操作。前置通知通常是通过@Before注解来实现的。

下面是一个前置通知的示例代码：

@Before("execution(* com.example.UserService.addUser(..))")
    public void beforeAddUser() {
        System.out.println("调用方法前");
    }

在上面的示例代码中，我们定义了一个@Before注解，并指定了一个execution表达式，它表示匹配com.example.UserService类中的所有addUser方法，并在方法调用前执行beforeAddUser方法。

#### 后置通知 ####

后置通知在目标方法调用后执行，可以在后置通知中进行一些结果处理、日志记录等操作。后置通知通常是通过@After注解来实现的。

下面是一个后置通知的示例代码：

@After("execution(* com.example.UserService.addUser(..))")
    public void afterAddUser() {
        System.out.println("调用方法后");
    }

在上面的示例代码中，我们定义了一个@After注解，并指定了一个execution表达式，它表示匹配com.example.UserService类中的所有addUser方法，并在方法调用后执行afterAddUser方法。

#### 返回通知 ####

返回通知在目标方法返回结果后执行，可以在返回通知中进行一些结果处理、日志记录等操作。返回通知通常是通过@AfterReturning注解来实现的。

下面是一个返回通知的示例代码：

@AfterReturning(value = "execution(* com.example.UserService.addUser(..))", returning = "result")
    public void afterReturningAddUser(Object result) {
        System.out.println("调用方法后，返回结果：" + result);
    }

在上面的示例代码中，我们定义了一个@AfterReturning注解，并指定了一个execution表达式和一个returning参数，它表示匹配com.example.UserService类中的所有addUser方法，并在方法调用后执行afterReturningAddUser方法，并将返回结果传入该方法中。

#### 异常通知 ####

异常通知在目标方法抛出异常后执行，可以在异常通知中进行一些异常处理、日志记录等操作。异常通知通常是通过@AfterThrowing注解来实现的。

下面是一个异常通知的示例代码：

@AfterThrowing(value = "execution(* com.example.UserService.addUser(..))", throwing = "e")
    public void afterThrowingAddUser(Exception e) {
        System.out.println("调用方法出现异常：" + e.getMessage());
    }

在上面的示例代码中，我们定义了一个@AfterThrowing注解，并指定了一个execution表达式和一个throwing参数，它表示匹配com.example.UserService类中的所有addUser方法，并在方法调用出现异常后执行afterThrowingAddUser方法，并将异常信息传入该方法中。

#### 环绕通知 ####

环绕通知可以在目标方法执行前、执行后、返回时、抛出异常时等不同的时间点插入一些通用的代码逻辑。环绕通知通常是通过@Around注解来实现的。

下面是一个环绕通知的示例代码：

@Around("execution(* com.example.UserService.addUser(..))")
    public Object aroundAddUser(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("调用方法前");
        Object result = joinPoint.proceed();
        System.out.println("调用方法后");
        return result;
    }

在上面的示例代码中，我们定义了一个@Around注解，并指定了一个execution表达式，它表示匹配com.example.UserService类中的所有addUser方法，并在方法调用前、调用后插入通用的代码逻辑。

### 通知的应用场景 ###

通知的应用场景非常广泛，下面介绍几个常见的应用场景。

#### 日志记录 ####

日志记录是通知的一个非常重要的应用场景。通过在目标方法调用前、调用后插入一些通用的代码逻辑，我们可以方便地记录一些日志信息，比如方法调用时间、方法参数、方法返回结果等。

下面是一个日志记录的示例代码：

@Around("execution(* com.example.UserService.addUser(..))")
    public Object aroundAddUser(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        System.out.println("方法执行时间：" + (endTime - startTime) + "毫秒");
        return result;
    }

在上面的示例代码中，我们定义了一个@Around注解，并指定了一个execution表达式，它表示匹配com.example.UserService类中的所有addUser方法，并在方法调用前、调用后插入通用的代码逻辑，从而记录方法执行时间。

#### 权限控制 ####

权限控制是通知的另一个重要的应用场景。通过在目标方法调用前插入一些通用的代码逻辑，我们可以方便地进行一些权限检查操作，比如检查用户是否有权限执行某个方法。

下面是一个权限控制的示例代码：

@Before("execution(* com.example.UserService.addUser(..))")
    public void beforeAddUser(JoinPoint joinPoint) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String username = request.getParameter("username");
        if (!"admin".equals(username)) {
            throw new RuntimeException("无权限执行该操作");
        }
    }

在上面的示例代码中，我们定义了一个@Before注解，并指定了一个execution表达式，它表示匹配com.example.UserService类中的所有addUser方法，并在方法调用前插入通用的代码逻辑，从而进行权限检查操作。

#### 性能监控 ####

性能监控是通知的另一个常见的应用场景。通过在目标方法调用前、调用后插入一些通用的代码逻辑，我们可以方便地进行一些性能监控操作，比如记录方法执行时间、方法调用次数等。

下面是一个性能监控的示例代码：

### 总结 ###

通知是AOP编程中的一个非常重要的概念，它可以将一些通用的代码逻辑从业务逻辑中分离出来，提高代码的可复用性和可维护性。在Java中，通知主要有基于代理的方式和基于字节码增强的方式两种实现方式。通知的种类包括前置通知、后置通知、返回通知、异常通知和环绕通知等。通知的应用场景非常广泛，比如日志记录、权限控制和性能监控等。希望本文对大家有所帮助，能够更好地理解Java中通知的作用和应用场景。

**公众号请关注"果酱桑", 一起学习,一起进步!**