给软件行业带来了春天——揭秘Spring究竟是何方神圣（二）

系列文章目录

给软件行业带来了春天——揭秘Spring究竟是何方神圣（一）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（二）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（三）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（四）
给软件行业带来了春天——揭秘Spring究竟是何方神圣（五）

文章目录

在这里插入图片描述

AOP简介

AOP（Aspect Oriented Programming） 意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。通俗表示：不通过修改源代码方式，在主干功能中添加新的功能。
eg:登录功能和权限判断可以分离，权限判断的功能的有无不影响登录功能。

image.png

AOP底层原理

AOP：面向切面编程，一种编程思想。

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（性能监视、事务管理、安全检查、缓存,日志记录等）。

AOP就是要对目标进行代理对象的创建，AOP底层使用动态代理的：JDK动态代理和CGLIB动态代理。

动态代理和静态代理区别？
动态代理：在虚拟机内部，运行的时候，动态生成代理类(运行时生成，runtime生成) ，并不是真正存在的类。
静态代理：存在代理类 （例如：struts2 Action的代理类 ActionProxy）

简单来说：有接口，实现接口的类对象，无接口，继承类，创建子对象。

JDK动态代理

JDK动态代理：基于接口的代理，一定是基于接口，会生成目标对象的接口类型的子对象。

image.png

JDK动态代理的一般步骤如下：
1.创建被代理的接口和类；
2.实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；
3.调用Proxy的静态方法，创建代理类并生成相应的代理对象；
实现原理：利用拦截器机制必须实现InvocationHandler接口中的invoke方法实现对我们的目标方法增强。

public class jdkproxy {
    public  static  void main(String[] args){

        //创建接口实现类的代理对象
        Class[] interfaces={UserDao.class};
           /* proxy实现
    调用newProxyInstance 方法
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) {}
    返回 指定接口的代理类的实例，

    三个参数： 1.类的加载器
             2.增强方法所在的类，这个类实现的接口，支持多个接口，。
             3.实现这个接口InvocationHandler，创建代理对象，写增强的部分

*/
        UserDaoImpl userDao=new UserDaoImpl();
        UserDao userDao1=(UserDao) Proxy.newProxyInstance(jdkproxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
        int result=userDao1.add(1,2);
        System.out.println(result);
       /*
       也可以使用内部类来实现
       Proxy.newProxyInstance(jdkproxy.class.getClassLoader(), interfaces, new InvocationHandler() {
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               return null;
           }
       })*/

    }
}
//创建代理对象代码

class UserDaoProxy implements InvocationHandler{
    //创建的是谁的代理对象，将他传递进来
    //有参构造传递进来
    private Object object;
    public UserDaoProxy(Object object){
        this.object=object;
    }
    //增强的逻辑，利用aop实现新增的功能
    /*invoke
    三个参数：1、代理对象
            2、当前的方法
            3、传入的参数
    * */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法之前
        System.out.println("方法之前执行...."+method.getName()+" :传递的参数..."+ Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(object, args);
        //方法之后
        System.out.println("方法之后执行...."+object);

        return res;
    }

}

Cglib代理


Cglib代理：基于类的代理，不需要基于接口，会生成目标对象类型的子对象。
1.Cglib是一个强大的，高性能，高质量的代码生成类库。它可以在运行期扩展JAVA类与实现JAVA接口。其底层实现是通过ASM字节码处理框架来转换字节码并生成新的类。大部分功能实际上是ASM所提供的，Cglib只是封装了ASM，简化了ASM操作，实现了运行期生成新的class。
2.运行时动态的生成一个被代理类的子类（通过ASM字节码处理框架实现），子类重写了被代理类中所有非final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势植入横切逻辑。
3.jdk7开始 jdk动态代理效率比cglib要高
image.png


public interface OrderService {
    /**
    * 添加数据
    */
    String addOrder(String orderName);
}

public class OrderServiceImpl implements OrderService {
//    @Override
    public String addOrder(String orderName) {
        log.info("<orderName:{}>", orderName);
        return "ok";
    }
}

@Slf4j
public class MayiktCglibMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        log.info("<目标方法之前开始执行....>");
      //  Object result = method.invoke(obj, args);

        Object result = proxy.invokeSuper(obj, args);
        log.info("<目标方法之后开始执行....>");
        return result;
    }
}

public class Test01 {
    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\ideaproject\\cglib");
        MayiktCglibMethodInterceptor mayiktCglibMethodInterceptor = new MayiktCglibMethodInterceptor();
        Enhancer enhancer = new Enhancer();
        // 设置代理
        enhancer.setSuperclass(OrderServiceImpl.class);
        // 设置cglib 回调类
        enhancer.setCallback(mayiktCglibMethodInterceptor);
        // 创建cglib代理类
        OrderServiceImpl orderServiceImpl = (OrderServiceImpl) enhancer.create();
        String result = orderServiceImpl.addOrder("mayikt");
        System.out.println(result);
    }
}

Aop术语

  1. 连接点（Join point）:连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在 Spring AOP 中，连接点总是方法的调用。

    类里面的哪些方法可以被增强，这些方法称为连接点

  2. 切点（PointCut）:可以插入增强处理的连接点，实际被真正增强的方法，称为切点

切点表达式：知道对哪个类里面的哪个方法进行增强。

切入点表达式
execution（[权限修饰符][返回类型][类全路径][方法名称][参数列表]）

@Pointcut(value = "execution(* aspect.*.add())")
//对于aspect包中所有类中的add()方法增强。

  1. 通知（Advice)/（增强）:真正增强的逻辑部分称为增强（通知）。通知描述了切面何时执行以及如何执行增强处理， 实际增强的业务逻辑。

    通知，实际就是在方法前后执行代码。<br />       通知多种类型：
  • 前置通知
  • 后置通知
  • 环绕通知
  • 异常通知
  • 最终通知（finally）


实例代码：

public class UserProxy {

    public UserProxy() {
    }

    //相同切入点
    @Pointcut(value = "execution(* aspect.*.add())")
    public void pointcut(){

    }

    //前置通知
    //@Before注解表示前置通知
    @Before(value = "pointcut()")
    public void before(){
        System.out.println("before 前置通知");
    }

    //后置通知（返回值后通知）
    @AfterReturning(value = "execution(* aspect.*.destory())")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知（不管有无异常都执行）
    @After(value = "execution(* aspect.*.add())")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知（）
    @AfterThrowing(value = "execution(* aspect.*.add())")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //环绕通知（方法之前和之后都通知）
    @Around(value = "execution(* aspect.*.add())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后.........");
    }
}
  1. 切面（Aspect）: 切面是通知和切点的结合，是一个动作过程。 把通知应用到的过程就是切面。
  2. 引入（Introduction）：允许我们向现有的类添加新的方法或者属性。
  3. 织入（Weaving）: 将增强处理添加到目标对象中，并创建一个被增强的代理对象。
Aop实现

AspectJ
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件,AspectJ不是Spring组成部分,独立AOP框架,一般把AspectJ和Spring框架一起使用,进行AOP操作.

maven依赖
添加相关maven依赖

<!--AspectJ 开始-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjtools</artifactId>
      <version>1.9.5</version>
    </dependency>

    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.0</version>
    </dependency>

    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.3.0</version>
    </dependency>
    <!--AspectJ 结束-->

基于AspectJ实现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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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="aspect"></context:component-scan>
    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
  • 基于注解方式实现
@Aspect
public class LogAspect {
    @Pointcut("execution(* com.ctj.service.*.*(..))")
    public void pointcutName(){}

    @Before("pointcutName()")
    public void performance(){
        System.out.println("Spring AOP");
    }
}

在多个增强类多同一个方法进行增强，设置增强类优先级
1.在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(2)
public class Username {

    @Before(value = "execution(* aspect.*.add())")
    public void before(){
        System.out.println("执行：");
    }
}

@Component
@Aspect
@Order(4)
public class User {

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

        System.out.println("add()");

    }
    public void destory(){
        System.out.println("销毁：");
    }
}

完全采用注解

@Configuration
@ComponentScan(basePackages = {"config"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
    
}

在本文中，我们深入探讨了 Spring 框架的核心特性AOP。然而，这只是 Spring 引领软件行业变革的冰山一角。在下一篇文章中，我们将进一步剖析 Spring 的其他特性，在不同应用场景下的实际运用，揭示更多关于其灵活性和强大功能的细节。让我们一同探索 Spring 如何继续塑造着未来软件开发的方向！
敬请期待下一篇文章的精彩内容！

在这里插入图片描述