四.基于注解配置Spring AOP

我还是用之前的项目来演示，把applicationContext的bean和AOP都去掉。然后通过注解来配置，然后再xml设置注解扫描。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启组件注解扫描-->
    <context:component-scan base-package="com.haiexijun"/>
    <!--启用Spring IoC的注解模式-->
    <aop:aspectj-autoproxy/>
</beans>

为dao和service增加注解：

UserDao.java

package com.haiexijun.dao;
import org.springframework.stereotype.Repository;
/**
 *用户表Dao
 */
@Repository
public class UserDao {
    public void insert(){
        System.out.println("新增用户数据");
    }
}

EmployeeDao.java

package com.haiexijun.dao;
import org.springframework.stereotype.Repository;
/**
 * 员工表Dao
 */
@Repository
public class EmployeeDao {
    public void insert(){
        System.out.println("新增员工数据");
    }
}

EmployeeService.java

package com.haiexijun.service;
import com.haiexijun.dao.EmployeeDao;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
 * 员工服务
 */
@Service
public class EmployeeService {
    @Resource
    private EmployeeDao employeeDao;
    public void entry(){
        System.out.println("执行员工入职业务逻辑");
        employeeDao.insert();
    }
    public EmployeeDao getEmployeeDao() {
        return employeeDao;
    }
    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }
}

UserService.java

package com.haiexijun.service;
import com.haiexijun.dao.UserDao;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
 * 用户服务
 */
@Service
public class UserService {
    @Resource
    private UserDao userDao;
    public void createUser(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行创建用户的业务逻辑");
        userDao.insert();
    }
    public String generateRandomPassword(String type,Integer length){
        System.out.println("按"+type+"方式生成"+length+"位随机密码");
        return "abcdeffdasf";
    }
    public UserDao getUserDao() {
        return userDao;
    }
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

上面都是IoC的配置，下面来进行AOP的配置

打开切面类，进行如下的配置：

package com.haiexijun.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * 切面类
 */
@Component//标记当前类为一个IoC的组件
@Aspect //说明当前类是一个切面类
public class MethodAspect {
    /**
     * 环绕通知
     * @param pjp ProceedingJoinPoint是一个特殊的连接点。是JoinPoint的升级版，在原有
     *            功能外，还可以控制目标方法是否执行。
     */
    //环绕通知，参数为PointCut切点表达式
    @Around("execution(public * com.haiexijun..*.*(..))")
    public Object printExecutionTime(ProceedingJoinPoint pjp) throws Throwable {
        try {
            //得到起始时间
            Long startTime=new Date().getTime();
            Object obj= pjp.proceed();//执行目标方法
            //得到结束时间
            Long endTime=new Date().getTime();
            //执行时间
            long runTime=endTime-startTime;
            //如果目标方法的运行时间超过了1秒，就输出日志
            if (runTime>1000){
                String className=pjp.getTarget().getClass().getName();
                String methodName=pjp.getSignature().getName();
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
                String now =sdf.format(new Date());
                System.out.println("======"+now+":"+className+"."+methodName+" ( "+runTime+" ms) ====== ");
            }
            return obj;
        } catch (Throwable e) {
            //环绕通知，它通常只会去捕获对应异常的产生
            //但如果目标方法产生了异常，作为产生的异常
            //大多数情况下，它会向外抛出去。
            //把异常抛出去是因为在我们当前系统中，未来运行时可能
            //并不只有一个通知，那如果在当前的环绕通知中，对这个异常进行了消化
            //那就意味着其他后序的处理都不会捕捉到这个异常，就可能会产生一些意料之外的问题
            System.out.println("Exception message:"+e.getMessage());
            throw e;
        }
    }
}

当然，还有其他的通知的注解，比如@After、@Before、@AfterReturning等。这里不做演示了。

最后，我们打开程序入口类，运行一下，没有问题：

五.AOP中的代理模式的应用

1.Spring AOP的实现原理

在未来，我们去找工作的时候，有一个问题，面试官会经常提起。那就是请你给我讲一下Spring AOP底层的实现原理是什么？

这个问题实在是太常见了，那作为Spring AOP底层的实现原理是什么呢？如下：

Spring是基于代理模式实现功能动态拓展，包含以下两种形式：

第一种是如果目标类实现了接口，则会通过JDK动态代理实现功能拓展。第二种是如果目标类没有实现接口，则Spring AOP底层通过CGLib这个第三方的组件实现功能的扩展。

此时就涉及到一个核心的问题，什么是代理模式？

2.静态代理

代理模式是指通过代理对象对原对象实现功能拓展。

那代理对象又是什么呢?其实在我们日常生活中随处可见，比如你去到一个全新的城市，希望租一套房子。这时你会怎么做，难道是我到处从电线杆上看这些求租的信息吗？肯定不会，大多数人的第一选择是找到中介公司，通过中介系统的数据库，去查询附近有哪些符合我要求的房子，看价钱是否合适。如果觉得还OK,那就由中介带着我去实地考察，看一下我是否满意，如果满意，那就成交，不满意的话，就继续找。而反过来，房东也依赖于中介。因为房东往往也有自己的工作，不可能天天拿着钥匙给租房的人开门去吧？这时房东就可以委托中介，房东把钥匙给中介，让中介的人带租房的人去看房子。可以看到中介的办事人员就是一个典型的代理人。这个案例放到我们程序中就称之为代理模式。

所谓代理模式，其核心的理念是我们要去创建一个代理类，在代理类中，持有最原始的委托类。作为代理类和委托类，他们要共同实现相同的接口。而客户则是则是通过代理类，完成客户所需要的功能。按照刚才的例子，那个客户类呢，就是租房的人。代理类就是中介的办事人员，而委托类是房东。作为中介和房东，他们的目的是一致的。都是要把房子给租出去。正是因为有着相同的目的，所以他们就实现了共同的接口，这个接口中提供了一个租房的方法，代理类和委托类都去实现租房的这个逻辑。作为代理类，它内部持有了委托类的对象，所以在代理类被实例化以后，也就是代理对象执行的过程中，可以对原始的逻辑产生额外的行为。比如说这个中介代理类，在为客户看完房子以后，除了交付给原始的房东原始的租金以外，它还要向客户收取代理费，这就是额外的扩展逻辑了。放在程序中也是一样的。

那作为代理模式，我们如何去实现呢？下面通过代码来演示一下。

下面来创建一个新的Maven工程：

增加一个service包，在service包中增加一个接口。刚才强调过，无论是代理类和委托类他们都要实现相同的接口，这个接口名为UserService。我们模拟一下现实的环境，在这个用户服务接口中，提供一个createUser()方法，所有实现类都要去实现这个方法。那与此同时，在service包下再创建一个新的实现类，名为UserServiceImpl，它实现UserService接口和里面的方法。我们示意性书写一下。

UserService.java

package com.haiexijun.service;
public interface UserService {
    public void createUser();
}

UserServiceImpl.java

package com.haiexijun.service;
public class UserServiceImpl implements UserService {
    @Override
    public void createUser() {
        System.out.println("执行创建用户的业务逻辑");
    }
}

作为这段代码，我们调用其实非常简单，新增加一个Application类，在类中增加Main方法，然后编写代码：

package com.haiexijun.service;
public class Application {
    public static void main(String[] args) {
        UserService userService=new UserServiceImpl();
        userService.createUser();
    }
}

然后运行，当然没问题。

但是我提出新的要求，希望将这个方法执行的时间打印出来，该这么办呢？这个需求我们之前在学习Spring AOP的时候已经遇到过了。但是是通过开发切面类来完成的。但是，如果放在我们代理模式中如何做呢？如果需要实现这个功能的扩展，就必须基于UserService接口创建对应的代理类。同时在代理类中去持有与之对应的具体实现。

下面来看一下具体做法：

在service包下面创建一个全新的类，名为UserServiceProxy 。代理的英文单词就是proxy。作为当前的代理类，其核心特点就是持有委托类的对象。定义一个私有的UserService类型的属性。接下来，关键的地方来了，这里定义一个带参的构造方法，参数为UserService。这个参数是在我们代理类实例化的时候，从外侧传入进来的，同时对内部的UserService来进行赋值。这样是不是就相当于在我们创建代理对象的时候，通过外侧传入的某个UserService的实现类，为内部的这个类的UserService赋值，相当于持有委托类的对象了。于此同时，不要忘记作为代理类和委托类都要实现相同的接口，也就是UserService，然后实现createUser()方法。在当前的代理类方法中，因为之前已经持有了委托类的对象，我们可以在createUser方法中发起委托类具体的职责，比如所createUser。同时，在这个方法执行前，我们还可以扩展其他的代码，比如对当前时间运行时的时间。这是不是就是功能的拓展啊？

UserServiceProxy.java

package com.haiexijun.service;
import java.text.SimpleDateFormat;
import java.util.Date;
public class UserServiceProxy implements UserService {
    //持有委托类的对象
    private UserService userService;
    public UserServiceProxy(UserService userService){
        this.userService=userService;
    }
    @Override
    public void createUser() {
        System.out.println("======"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
        userService.createUser();
    }
}

与此同时，作为我们的客户，也就是使用者来说，不在直接面向UserServiceImpl，取而代之的是UserServiceProxy ，去面向这个代理类来调用。那么在代理类调用时，需要传入一个具体的UserServiceImpl。

application.java

package com.haiexijun.service;
public class Application {
    public static void main(String[] args) {
        UserService userService=new UserServiceProxy(new UserServiceImpl());
        userService.createUser();
    }
}

运行结果，这就是通过代理类实现功能的额外扩展

代理模式可以嵌套使用的。

再打个比方，你手不是见过这样的情况，某一个租户，他把房子整栋租下来，然后再把房间租给很多其他的租客，这种形式在北京上海深圳这种房价高的地方，是很常见的。我们也称这种租客叫二房东。

那在代理模式中也是支持的。因为委托类和代理类都实现了相同的接口。同时，在创建对象的时候，又允许传入对应接口的实现类。因此，我们可以再创建一个全新的代理UserServiceProxy1，具体的做法和之前是一样的，实现UserService接口和方法。然后我们可以为create内扩展一些其他的业务代码，在UserService的createUser方法后拓展执行一个输出语句。这时，系统中就出现了两个代理类，一个是在createUser方法前执行，一个是在createUser方法后执行拓展

package com.haiexijun.service;
public class UserServiceProxy1  implements UserService{
    private UserService userService;
    public UserServiceProxy1(UserService userService){
        this.userService=userService;
    }
    @Override
    public void createUser() {
        userService.createUser();
        System.out.println("======后置扩展功能=====");
    }
}

那租客肯定是要面向二房东来执行的，下面就是new UserServiceProxy1了,里面传一房东UserServiceProxy。感觉有一点套娃。

package com.haiexijun.service;
public class Application {
    public static void main(String[] args) {
        UserService userService=new UserServiceProxy1(new UserServiceProxy(new UserServiceImpl()));
        userService.createUser();
    }
}

运行后，发现前置和后置的额外拓展功能都打印出来了。

这就是代理模式的精妙之处。可以实现对功能的无限层次的拓展。但在这里，我们每进行一次功能的拓展，都要自己来创建一个代理类啊，这样有一个缺点，随着我们的功能的不断地扩大，每一个具体的实现类，他都要至少拥有一个代理类。而这个代理类是要按照这个规则来自己进行书写的。这样呢，假如我们系统中，有成百上千个具体的业务实现类，那就意味着，也有成百上千个具体的代理类来为具体实现类实现扩展职责。这会让我们系统变得无比的臃肿。对于这种必须要手动创建代理类的使用方式，我们称之为静态代理。静态代理是最简单的一种代理模式的使用方式，但是也是最麻烦的一种使用方式。

那说起手动创建，就有与之对应的自动创建。在JDK1.2以后，由于反射机制的引入，为我们自动创建代理类提供了可能。那下面就来学习与静态代理对应的动态代理。

3.AOP底层原理—JDK动态代理

下面新创建一个Maven工程，因为JDK动态代理的功能不用到其他第三方组件，所以我们不用在Maven中添加任何依赖。然后，把上一个案例的UserService接口和UserServiceImpl实现类拿过来。

要想实现基于JDK动态代理来实现UserServiceImpl的功能扩展，首先要在service包下再额外的创建一个类ProxyInvocationHandler ，这个类要实现一个至关重要的接口InvocationHandler 。我们要实现它的invoke方法。这个invoke是不是在那里遇见过呢？没错，是在之前学习反射中遇到过，通过invoke来调用目标方法。这里的invoke也是一样的道理。

ProxyInvocationHandler实现InvocationHandler，它的职能非常明确。InvocationHandler是JDK提供的反射类，用于在JDK动态代理中对目标方法进行增强。 InvocationHandler实现类与Spring AOP的切面类的环绕通知类似。我们在invoke方法里面对目标方法进行增强。其中，invoke方法包含了3个参数。第一个参数Object代表了代理类对象，作为这个代理类对象，通常是由我们JDK动态代理自动生成的。第二个参数Method是目标方法对象，说明了目标方法的信息，包括方法名等。而第三个参数是一个Object数组，表示目标方法的实参。该方法返回一个Object，代表目标方法运行后的返回值。而最后抛出Throwable表示抛出目标方法异常。

package haiexijun.service;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;//目标对象
    public ProxyInvocationHandler(Object target) {
        this.target = target;
    }
    /**
     * 在invoke方法对目标方法进行增强
     * @param proxy 代理类对象
     * @param method 目标方法
     * @param args 目标方法的实参
     * @return 目标方法运行后的返回值
     * @throws Throwable 目标方法抛出的异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("======"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date())+" ========");
        Object ret =method.invoke(target,args);//调用目标方法
        return ret;
    }
}

然后在Application类中编写代码使用：

package haiexijun.service;
import java.lang.reflect.Proxy;
public class Application {
    public static void main(String[] args) {
        //UserService为目标对象
        UserService userService=new UserServiceImpl();
        ProxyInvocationHandler invocationHandler= new ProxyInvocationHandler(userService);
        //invoke方法要从传入代理类Proxy
        //创建动态代理类,
        // 通过newProxyInstance方法来创建，传入类加载器，类要实现的接口，还有对目标方法进行扩展的InvocationHandler
        UserService userServiceProxy  = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),userService.getClass().getInterfaces(),invocationHandler);
        userServiceProxy.createUser();
    }
}

但是，动态代理必须要实现一个实现类的接口才能够运行，如果没有实现接口，反射过程必然会报错。可是在我们实际情况下，有着大量的类都没有实现接口，该怎么做呢？这时候，Spring又为我们提供了另外一种解决方案。依赖于spring的第三方组件CGLib实现对类的增强。

4.CGLib实现代理类

CGLib是运行时字节码增强技术。全名为Code Generation Library

当我们某一个类它没有实现接口的时候， Spring AOP 会在运行时生成目标继承类字节码的方式进行扩展。

下面来具体逻辑一下所谓生成目标继承类字节码：

上面有一个Service类，里面有一个findById的按id号查询的方法。里面写入具体的业务代码。可以看到里面的Service是没有实现任何接口的，那显然Jdk动态代理无法对其进行扩展。Spring看到这个类没有实现接口，则自动会使用CGLib通过继承的方式来对类进行扩展。这个继承类是在JVM运行过程中自动生成的，他的生成规则是，前面是类的原始名字，后面增加两个$$符号,然后加EnhancerByCGLIB（spring5以后是EnhancerBySpringCGLIB）。然后继承自Service父类。可以对findById方法进行重写，方法里面通过super指向父类的业务代码，并可以添加拓展的前置代码和后置代码等。客户端在调用的时候，面向的是这个增强的子类。

总结：

要增强的目标类实现了接口时，AOP底层调用的是JDK动态代理，没有实现接口时，AOP底层调用的是CGLib代理

Spring AOP面向切面编程（三）

四.基于注解配置Spring AOP

五.AOP中的代理模式的应用

1.Spring AOP的实现原理

2.静态代理

3.AOP底层原理—JDK动态代理

4.CGLib实现代理类

热门文章

最新文章

相关课程

相关电子书

相关实验场景