四.基于注解配置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实现代理类

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Spring AOP面向切面编程（三）

四.基于注解配置Spring AOP

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

1.Spring AOP的实现原理

2.静态代理

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

4.CGLib实现代理类

热门文章

最新文章

相关课程

相关电子书