四、通过注解的方式实现Spring AOP

下面我们使用纯注解的方式实现上面的业务需求，程序执行addUser()这个方法之前，通过Spring AOP技术切入一个检查安全性的服务。

1.还是和之前一样，首先明确横切性关注点是谁，根据上面的需求我们知道了检查安全性的服务为横切性关注点。

2.将横切性关注点进行模块化，定义一个SecurityHandler这个也就是切面（Aspect）

代码实例：

3.添加@Aspect注解，表名这个类是一个切面，并且添加@Component注解表名将其交给spring ioc进行管理

package com.wangwei.springaop.service.impl;
import org.aspectj.lang.annotation.Aspect;
@Aspect
@Component
public class SecurityHandler {
   private void checkSecurity() {
      System.out.println("-------checkSecurity-------");
   }
}

3.将横切性关注点具体实现，也就是通知（advice）我们需要将其设置设置为前置通知，添加@Before注解

package com.wangwei.springaop.service.impl;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
@Component
public class SecurityHandler {
   @Before("")
   private void checkSecurity() {
      System.out.println("-------checkSecurity-------");
   }
}

4.定义切点，定义通知（Advice）应用到那些JoinPoint上，我们这儿的连接点是addUser()这个方法。

package com.wangwei.springaop.service.impl;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class SecurityHandler {
//  @Pointcut("execution(* com.wangwei.springaop.service.impl.UserManagerImpl.addUser(..))")
//  public void myServiceMethods() {}
//
//  @Before("myServiceMethods()")
//  private void checkSecurity(JoinPoint joinPoint) {
//    System.out.println("-------checkSecurity-------");
//  }
  @Before("execution(public * com.wangwei.springaop.service.impl.UserManagerImpl.addUser(..))")
  private void checkSecurity(JoinPoint joinPoint) {
    //可以通过在advice中添加JoinPoint类型的参与来获取客户端调用的方法名或者参数等等...
    for (int i = 0; i < joinPoint.getArgs().length; i++) {
      //打印参数
      System.out.println(joinPoint.getArgs()[i]);
    }
    //获取方法名
    System.out.println(joinPoint.getSignature().getName());
    System.out.println("-------checkSecurity-------");
  }
}

5.另外将其UserManagerImpl类通过@Service也纳入Spring 容器管理

package com.wangwei.springaop.service.impl;
import com.wangwei.springaop.service.UserManager;
import org.springframework.stereotype.Service;
@Service
public class UserManagerImpl implements UserManager {
  public void addUser(String username, String password) {
    System.out.println("---------UserManagerImpl.add()--------");
  }
  public void delUser(int userId) {
    System.out.println("---------UserManagerImpl.delUser()--------");
  }
  public int findUserById(int userId) {
    System.out.println("---------UserManagerImpl.findUserById()--------");
    return userId;
  }
  public void modifyUser(int userId, String username, String password) {
    System.out.println("---------UserManagerImpl.modifyUser()--------");
  }
}

6.客户端进行调用

package com.wangwei.springaop.client;
import com.wangwei.springaop.service.UserManager;
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
@ComponentScan("com.wangwei.springaop")
//启动Aspect的自动代理，Spring默认不会自动启用AspectJ的自动代理功能
@EnableAspectJAutoProxy
public class Client {
  public static void main(String[] args) {
//    BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
//    UserManager userManager = (UserManager)factory.getBean("userManager");
//    userManager.addUser("wangwei", "123");
    //我们使用AnnotationConfigApplicationContext来加载配置类，使用MyAppApplication.class作为配置类，即告诉Spring使用MyAppApplication这个类中的注解来构建应用程序上下文
    ApplicationContext context = new AnnotationConfigApplicationContext(Client.class);
    /*
    使用context对象来获取我们的bean并进行依赖注入和使用。注意由于使用Spring Aop时将其目标类进行了代理，所以在Spring IOC容器中
    UserManagerImpl的类型变为了代理类
    下面是打印容器中的对象和对象的类型，可以看到UserManagerImpl的类型为Proxy类型
     */
    String[] beanNames = context.getBeanDefinitionNames();
    for (String beanName : beanNames) {
      Class<?> beanType = context.getType(beanName);
      System.out.println("Bean Name: " + beanName);
      System.out.println("Bean Type: " + beanType);
      System.out.println("-----------------------");
    }
    //由于UserManagerImpl的类型变为了代理类，所以这里通过默认的bean的名称进行获取
    UserManager userManager = (UserManager) context.getBean("userManagerImpl");
    userManager.addUser("wangwei","123");
  }
}

7.运行效果

五、Spring对AOP的支持

Spring通过JDK的动态代理实现AOP，可以通过使用CGLIB代理实现AOP。

如果目标对象实现了接口，在默认情况下会采用JDK的动态代理实现AOP
如果目标对象实现了接口，也可以强制使用CGLIB生成代理实现AOP
如果目标对象没有实现接口，那么必须引入CGLIB，spring会在JDK的动态代理和CGLIB代理之间切换

如何强制使用CGLIB

在Spring中可以通过配置文件或注解来强制使用CGLIB代理。

xml文件方式

使用proxy-target-class="true"属性来强制使用CGLIB代理。

<aop:config>
    <aop:proxy proxy-target-class="true"/>
    <!-- 其他的切面和通知配置 -->
</aop:config>

注解的方式

在@EnableAspectJAutoProxy注解中设置proxyTargetClass = true，表示强制使用CGLIB代理。

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AppConfig {
    // 配置其他的Bean和切面
}

通过注解方式强制使用CGLIB的示例：

客户端代码

package com.wangwei.springaop.client;
import com.wangwei.springaop.service.UserManager;
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
@ComponentScan("com.wangwei.springaop")
//启动Aspect的自动代理，Spring默认不会自动启用AspectJ的自动代理功能
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class Client {
  public static void main(String[] args) {
//    BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
//    UserManager userManager = (UserManager)factory.getBean("userManager");
//    userManager.addUser("wangwei", "123");
    //我们使用AnnotationConfigApplicationContext来加载配置类，使用MyAppApplication.class作为配置类，即告诉Spring使用MyAppApplication这个类中的注解来构建应用程序上下文
    ApplicationContext context = new AnnotationConfigApplicationContext(Client.class);
    /*
    使用context对象来获取我们的bean并进行依赖注入和使用。注意由于使用Spring Aop时将其目标类进行了代理，所以在Spring IOC容器中
    UserManagerImpl的类型变为了代理类
    下面是打印容器中的对象和对象的类型，可以看到UserManagerImpl的类型为Proxy类型
     */
    String[] beanNames = context.getBeanDefinitionNames();
    for (String beanName : beanNames) {
      Class<?> beanType = context.getType(beanName);
      System.out.println("Bean Name: " + beanName);
      System.out.println("Bean Type: " + beanType);
      System.out.println("-----------------------");
    }
    //由于UserManagerImpl的类型变为了代理类，所以这里通过默认的bean的名称进行获取
    UserManager userManager = (UserManager) context.getBean("userManagerImpl");
    userManager.addUser("wangwei","123");
  }
}

运行截图：

可以看到目标类的类型由之前的proxy变为了CGLIB

JDK动态代理的特点

优势：

基于接口的代理，适用于接口实现类的代理。
使用Java自带的反射机制实现代理，无需额外的依赖库。

劣势：

代理的目标对象必须实现至少一个接口。
动态代理的性能相对较低，因为每次调用代理方法都会涉及到反射调用。
对于无接口的类，无法直接使用JDK动态代理。

CGLIB动态代理的特点

优势：

基于继承的代理，适用于无接口或者无法通过接口进行代理的类。
无需目标对象实现接口，可以直接代理普通类。
CGLIB通过生成子类的方式实现代理，因此性能相对较高。

利弊：

生成的代理类是目标类的子类，如果目标类被声明为final，将无法使用CGLIB代理。
CGLIB需要额外的依赖库。

区别

JDK动态代理基于接口，通过实现接口的方式进行代理，适用于接口实现类的代理；而CGLIB基于继承，通过生成子类的方式进行代理，适用于无接口或者无法通过接口进行代理的类。
JDK动态代理基于接口，通过实现接口的方式进行代理，适用于接口实现类的代理；而CGLIB基于继承，通过生成子类的方式进行代理，适用于无接口或者无法通过接口进行代理的类。
DK动态代理的性能相对较低，因为每次调用代理方法都会涉及到反射调用；而CGLIB通过生成子类的方式实现代理，性能相对较高。
JDK动态代理对于无接口的类无法直接使用，而CGLIB可以直接代理普通类。

六、总结

将Spring AOP运行到具体业务的步骤：

抽象出横切性关注点

将横切性关注点进行模块化，模块化的结果就是切面（Aspect）
将横切性关注点具体实现，实现的结果为通知（advice）并定义通知的类型
定义切点，也就是将通知advice应用到那些连接点上（joinpoint）
这个过程中涉及到代理、织入（weave）、引入。

如果选择JDK动态代理还是CGLIB代理：

选择使用JDK动态代理还是CGLIB取决于具体的需求。

如果目标类实现了接口且性能要求较低，可以选择JDK动态代理；
.如果目标类无接口或者无法通过接口进行代理，或者性能要求较高，可以选择CGLIB代理。
spring框架会自动在动态代理和CGLIB代理之间切换

【Spring框架四】——Spring AOP 注解实现和xml方式实现2

四、通过注解的方式实现Spring AOP

五、Spring对AOP的支持

如何强制使用CGLIB

xml文件方式

注解的方式

通过注解方式强制使用CGLIB的示例：

JDK动态代理的特点

CGLIB动态代理的特点

六、总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景