详解spring6.0新特性汇总

spring6新特性汇总

part1 spring6.0新特性

spring6.0 2022年11月。新一代框架带jdk17&jakarta ee9

https://www.graalvm.org/

part2 AOP&事务

1.AOP:面向切面编程

• 通过预编译方式和运行期动态 代理实现程序功能的统一维护的一种技术。

• 使用场景：
  权限的校验
  日志记录
  事务处理
  性能检测

• 常用代理方式

  1. jdk动态代理，只能代理接口
  2. Cglib动态代理，spring提供，只能代理类

• jdk动态代理：Proxy类，该类中有一个静态方法，可以创建代理对象

 
 /**
 *classloader:类加载器，加载代理对象，Class对象就可以获取类加载器
 *
 *Class<?>[] interfaces 接口的字节码数组对象，通过该参数，生成代理对象，可以知道该接口*有那些方法
 *
 *InvocationHandler h ：执行句柄，也是一个接口; 当生成代理对象后，调用原目标方法的时候，自动进入到InvocationHandler中invoke方法；
 *
 *invoke(Object proxy,Method method,Object[] args):
 *   Object proxy:代理对象
 *   Method method：代理对象目前正在调用的方法，invoke(Object ...param)
 *   Object[] args:目标方法参数
 *
 */
 @CallerSensitive
 public static Object newProxyInstance(ClassLoader loader,
                                       Class<?>[] interfaces,
                                       InvocationHandler h) {
     Objects.requireNonNull(h);
 
     @SuppressWarnings("removal")
     final Class<?> caller = System.getSecurityManager() == null
                                 ? null
                                 : Reflection.getCallerClass();
 
     /*
      * Look up or generate the designated proxy class and its constructor.
      */
     Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
 
     return newProxyInstance(caller, cons, h);
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• Cglib动态代理
  Enhance cglib的核心类，主要作用是先设置属性，再创建代理对象

  1. setSuperClass(被代理对象.getClass()):设置目标类的字节码对象
  2. setCallback(MethodInceptor对象)设置回调函数,让代理对象执行的时候进入回调函数执行具体逻辑;
     该方法的参数 ：callback接口，传递的是子接口MethodInceptor匿名内部类
  3. create() 创建代理对象的方法

  自定义实现cglib动态代理：

  1.导入cglib依赖库

  <!--使用Cglib动态代理，需要导入spring-context-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>6.1.3</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>6.1.3</version>
    </dependency>
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

2.代码实现：

package com.spring;

public class PersonService {
    public void work(){
        System.out.println("我爱上班");
    }
}

package com.spring;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**
 * 创建代理对象
 */
public class ProxyBeanFactoryCglib {
    //1.定义代理对象
    private  PersonService target;
    //2.构造方法初始化代理对象
    public ProxyBeanFactoryCglib(PersonService target){
        this.target=target;
    }
    //3.编写一个获取代理对象的方法
    public Object getProxy(){
        //1.创建enchance
      Enhancer enhancer=new Enhancer();
      //2.给enhancer对象设置setSuperclass
        enhancer.setSuperclass(target.getClass());

        //3.给enhancer设置回调函数
        enhancer.setCallback(new MethodInterceptor() {
            /**
             *
             * @param proxy 代理对象
             * @param method 代理对象正在调用的方法对象
             * @param args  代理对象方法传递的参数
             * @param methodProxy 方法的代理对象
             * @return
             */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //1.通过method对象，反射调用原始类的方法
                method.invoke(target);
                //2.补充一个记录日志的功能
                System.out.println("记录日志，记录工作状态。。");
                return null;
            }
        });

        //4.调用enhancer的create方法，创建代理对象
        return enhancer.create();
    }
}


package com.spring;

/**
 * 测试类
 */
public class PersonServiceTest {
    public static void main(String[] args) {
        //1.创建PersonService 这个的被代理对象
        PersonService personService=new PersonService();
        //2.创建ProxyBeanFactoryCglib
        ProxyBeanFactoryCglib proxyBeanFactoryCglib=new ProxyBeanFactoryCglib(personService);
        //3.调用ProxyBeanFactoryCglib的getProxy方法
        PersonService proxy= (PersonService) proxyBeanFactoryCglib.getProxy();

        //4.调用work方法，看是否有日志
        proxy.work();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

AOP术语：

1. 目标类target:就是需要增强的那个类
2. 代理类proxy:就是自定义的代理的对象
3. 连接点joinPoint:程序执行的一个特定位置，spring仅支持方法的连接点
4. 切入点pointCut:就是在目标类中实际增强的方法
5. 织入weave:就是将代理类中需要增强的方法放入到目标类中去执行的过程
6. 引介Introduction:引介是一种特殊的 增强，他为类添加一些属性和方法
7. 通知advice:将代理对象中的方法应用到目标类 的过程中产生的结果
8. 切面aspect:所有的切入点和代理对象的方法组成在一起构成了切面

切点表达式：

5种通知方式：

1. 前置通知（beforeAdvice）：增强的逻辑在目标方法之前执行
2. 后置通知(afterReturningAdvice)：增强的逻辑在目标方法之后执行
3. 异常通知(throwableAdvice)：目标方法出现异常，则增强逻辑运行
4. 环绕通知(aroundAdvice)：增强的逻辑在目标方法的前后执行
5. 最终通知(afterAdvice)：增强的逻辑在目标方法的之后执行，不管有没有异常都会执行

2.事务：保证一组操作执行过程要么成功要么失败

1. 目的：保持多并发情况下数据一致性
2. 目的：如果出现错误的操作可以进行修改

事务的特性(ACID):

1. 原子性：一个事务是最小的执行单元，不可分割
2. 一致性：事务执行前后，数据要保持 一致性
3. 持久性:事务一旦提交或回滚，在数据库中持久的改变
4. 隔离性：隔离性用来保证多个用户操作数据库的同一份数据，不会受到相关干扰

并发操作数据库会出现问题：

1. 脏读：一个事务读到了另一个事务的还没有提交数据。
   

2. 不可重复读：一个事务中多次读到的数据不一致。一个事务读到了另一个事务修改后的数据。

3. **幻读(虚读)
   声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/720409