中篇：第3章 类的加载过程（类的生命周期）详解

已于 2022-05-06 22:28:22 修改
阅读量281 收藏
点赞数
分类专栏： jvm 文章标签： java
于 2022-05-06 22:12:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45364328/article/details/124615942
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

01-概述

在这里插入图片描述
在这里插入图片描述
注意：
我们所说的加载完毕包括：加载、链接、初始化三个阶段都完成之后类进入方法区中

大厂面试题

在这里插入图片描述
在这里插入图片描述

02-过程一：Loading（加载）阶段

1-加载完成的操作

在这里插入图片描述

2-二进制流的获取方式

在这里插入图片描述

3-类模型与Class实例的位置

在这里插入图片描述
在这里插入图片描述

4-数组类的加载

在这里插入图片描述

03-过程二：Linking（链接）阶段

1-环节1：链接阶段之Verification（验证）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2-环节2：链接阶段之Preparation（准备）

在这里插入图片描述
在这里插入图片描述
举例：

/**
 * @author shkstart
 * @create 2020-09-13 10:50
 *
 * 过程二：链接阶段
 *
 * 基本数据类型：非final修饰的变量，在准备环节进行默认初始化赋值。
 *              final修饰以后，在准备环节直接进行显示赋值。
 *
 *  拓展：如果使用字面量的方式定义一个字符串的常量的话，也是在准备环节直接进行显示赋值。
 */
public class LinkingTest {

    private static long id;//

    private static final int num = 1; //

    public static final String constStr = "CONST";

    public static final String constStr1 = new String("CONST");


}

在这里插入图片描述
以num为例
在这里插入图片描述
在这里插入图片描述
因此可以说明num在准备的阶段就显式赋值为1，同比constStr也是如此

可以得出结论：

  • 基本数据类型：非final修饰的变量，在准备环节进行默认初始化赋值。
    final修饰以后，在准备环节直接进行显示赋值。

  • 如果使用字面量的方式定义一个字符串的常量的话，也是在准备环节直接进行显示赋值。

其实对于final和static修饰的变量，它的数值赋值，还是比较复杂的，请继续往下看，初始化阶段会详细说明
对于准备阶段就显式赋值的，其字段下面的有属性ConstantValue，否则是没有属性ConstantValue的

3-环节3：链接阶段之Resolution（解析）

在这里插入图片描述
在这里插入图片描述

04-过程三：Initialization（初始化）阶段

在这里插入图片描述
在这里插入图片描述
哪些场景下，java编译器就不会生成< clinit>()方法

  • 场景1：对应非静态的字段，不管是否进行了显式赋值，都不会生成< clinit>()方法
  • 场景2：静态的字段，没有显式的赋值，不会生成< clinit>()方法
  • 场景3：比如对于声明为static final的基本数据类型的字段，不管是否进行了显式赋值，都不会生成< clinit>()方法
public class InitializationTest1 {
    //场景1：对应非静态的字段，不管是否进行了显式赋值，都不会生成<clinit>()方法
    public int num = 1;
    //场景2：静态的字段，没有显式的赋值，不会生成<clinit>()方法
    public static int num1;
    //场景3：比如对于声明为static final的基本数据类型的字段，不管是否进行了显式赋值，都不会生成<clinit>()方法
    public static final int num2 = 1;
}

在这里插入图片描述

1-static与final的搭配问题

/**
 *
 * 说明：使用static + final修饰的字段的显式赋值的操作，到底是在哪个阶段进行的赋值？
 * 情况1：在链接阶段的准备环节赋值
 * 情况2：在初始化阶段<clinit>()中赋值
 *
 * 结论：
 * 在链接阶段的准备环节赋值的情况：
 * 1. 对于基本数据类型的字段来说，如果使用static final修饰，则显式赋值(直接赋值常量，而非调用方法）通常是在链接阶段的准备环节进行
 * 2. 对于String来说，如果使用字面量的方式赋值，使用static final修饰的话，则显式赋值通常是在链接阶段的准备环节进行
 *
 * 在初始化阶段<clinit>()中赋值的情况：
 * 排除上述的在准备环节赋值的情况之外的情况。
 *
 * 最终结论：使用static + final修饰，且显示赋值中不涉及到方法或构造器调用的基本数据类型或String类型的显式赋值，是在链接阶段的准备环节进行。
 */
public class InitializationTest2 {
    public static int a = 1;//在初始化阶段<clinit>()中赋值
    public static final int INT_CONSTANT = 10;//在链接阶段的准备环节赋值

    public static final Integer INTEGER_CONSTANT1 = Integer.valueOf(100);//在初始化阶段<clinit>()中赋值
    public static Integer INTEGER_CONSTANT2 = Integer.valueOf(1000);//在初始化阶段<clinit>()中赋值

    public static final String s0 = "helloworld0";//在链接阶段的准备环节赋值
    public static final String s1 = new String("helloworld1");//在初始化阶段<clinit>()中赋值

    public static String s2 = "helloworld2";

    public static final int NUM1 = new Random().nextInt(10);//在初始化阶段<clinit>()中赋值
}

如果理解了什么时候生成< clinit>()方法，那 static 、 final修饰也就比较容易理解了。
在这里插入图片描述
在这里插入图片描述
上面这个例子怎么理解呢，其实对于这种 public static final int INT_CONSTANT = 10，其实在类的编译时候就已经知道了数值（在成员变量表中有ConstantValue），而上述两个变量编译后并不知道数值（没有ConstantValue），因此它们是通过调用方法赋值的，因此需要在执行类初始化方法的时候，进行赋值操作。对于上述中其他的例子也是一样的。

2-< client>()的线程安全性

在这里插入图片描述

3-类的初始化情况：主动使用vs被动使用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

类的主动使用（调用< clinit>()方法）举例：

1.当创建一个类的实例时，比如使用new关键字，或者通过反射、克隆、反序列化。

class Order{
    static {
        System.out.println("Order类的初始化过程");
    }
}
  • 首先测试new关键字
public class ActiveUse1 {
    public static void main(String[] args) {
        Order order = new Order();
    }

}

执行结果：

Order类的初始化过程
  • 测试序列化和反序列化
    为了让Order能够被序列化，需要其实现Serializable接口。
class Order implements Serializable{
    static {
        System.out.println("Order类的初始化过程");
    }
}


 //序列化的过程：
    @Test
    public void test1() {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("order.dat"));

            oos.writeObject(new Order());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null)
                    oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

执行结果
在这里插入图片描述

//反序列化的过程：（验证）
    @Test
    public void test2() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("order.dat"));

            Order order = (Order) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null)
                    ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

在这里插入图片描述
事实说明序列化和反序列化都执行类初始化方法

2 .当调用类的静态方法时，即当使用了字节码invokestatic指令

class Order implements Serializable{
    static {
        System.out.println("Order类的初始化过程");
    }

    public static void method(){
        System.out.println("Order method()....");
    }
}
 @Test
    public void test3(){
        Order.method();
    }

在这里插入图片描述
3. 当使用类、接口的静态字段时(final修饰特殊考虑)，比如，使用getstatic或者putstatic指令。（对应访问变量、赋值变量操作）

下面是User类，测试分别调用静态变量num 、num1 、num2 时，会不会打印"User类的初始化过程"

class User{
    static{
        System.out.println("User类的初始化过程");
    }

    public static int num = 1;
    public static final int num1 = 1;
    public static final int num2 = new Random().nextInt(10);

}

 @Test
    public void test1(){
        System.out.println(User.num);
    }

在这里插入图片描述

    @Test
    public void test1(){
        System.out.println(User.num1);
    }

在这里插入图片描述

  @Test
    public void test1(){
        System.out.println(User.num2);
    }

在这里插入图片描述

num1 是在类的链接阶段的准备环节显式赋值的，不在< clinit>()方法中赋值，类的主动使用其实就是执行< clinit>()方法，因此，调用User中的变量num1时，不调用< clinit> ()方法，也就不打印静态代码块的内容。

下面测试接口

interface CompareA{
    public static final Thread t = new Thread(){
        {
            System.out.println("CompareA的初始化");
        }
    };

    public static final int NUM1 = 1;
    public static final int NUM2 = new Random().nextInt(10);

}

因为接口中不能有静态代码块，这里用了一个小技巧：定义了一个上述的变量 t，虽然这个t是 static final 修饰的，但是赋值是new出来的，因此它会在执行 < clinti>方法的时候显式赋值。进而打印"CompareA的初始化"。

 @Test
    public void test2(){
        System.out.println(CompareA.NUM1);
    }

在这里插入图片描述

 @Test
    public void test2(){
        System.out.println(CompareA.NUM2);
    }

在这里插入图片描述

4. 当使用java.lang.reflect包中的方法反射类的方法时。比如：Class.forName(“com.atguigu.java.Test”)

class Order implements Serializable{
    static {
        System.out.println("Order类的初始化过程");
    }

    public static void method(){
        System.out.println("Order method()....");
    }
}


@Test
    public void test1() {
        try {
            Class clazz = Class.forName("com.atguigu.java1.Order");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

在这里插入图片描述

5. 当初始化子类时，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化（由父及子，静态先行）。

class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}

class Son extends Father{
    static {
        System.out.println("Son类的初始化过程");
    }

    public static int num = 1;
}

@Test
    public void test4() {
        System.out.println(Son.num);
    }

在这里插入图片描述
小技巧： -XX:+TraceClassLoading
在这里插入图片描述
追踪类的加载路径
在这里插入图片描述

在这里插入图片描述

  • 针对5，补充说明：
    当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口。
    在初始化一个类时，并不会先初始化它所实现的接口
    在初始化一个接口时，并不会先初始化它的父接口
    因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态字段时，
    才会导致该接口的初始化。
class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}

class Son extends Father implements CompareB{
    static {
        System.out.println("Son类的初始化过程");
    }

    public static int num = 1;
}

interface CompareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };

}

  @Test
    public void test4() {
        System.out.println(Son.num);
    }

在这里插入图片描述
我们追踪一下加载路径
在这里插入图片描述
事实上也证明了【在初始化一个类时，并不会先初始化它所实现的接口】，但是没有初始化不代表没有加载，这个一定要注意，没有初始化不代表没有加载，如果没加载，调用肯定是报错的。

interface CompareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };
    public default void method1(){
        System.out.println("你好！");
    }

}

interface CompareC extends CompareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareC的初始化");
        }
    };

    public static final int NUM1 = new Random().nextInt();
}



@Test
    public void test3(){
        System.out.println(CompareC.NUM1);
    }

在这里插入图片描述
上述代码证明了初始化一个接口时，并不会初始化该接口的父接口。

6. 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，该接口要在其之前被初始化。

class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}

class Son extends Father implements CompareB{
    static {
        System.out.println("Son类的初始化过程");
    }

    public static int num = 1;
}

interface CompareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };
    public default void method1(){
        System.out.println("你好！");
    }

}


@Test
    public void test4() {
        System.out.println(Son.num);
    }

在这里插入图片描述
7. 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。

public class ActiveUse3 {
    static{
        System.out.println("ActiveUse3的初始化过程");
    }
    
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

在这里插入图片描述

类的被动使用举例

关于类的被动使用，即不会进行类的初始化操作，即不会调用()
1. 当访问一个静态字段时，只有真正声明这个字段的类才会被初始化。
当通过子类引用父类的静态变量，不会导致子类初始化

class Parent{
    static{
        System.out.println("Parent的初始化过程");
    }

    public static int num = 1;
}

class Child extends Parent{
    static{
        System.out.println("Child的初始化过程");
    }

  @Test
    public void test1(){
        System.out.println(Child.num);
    }

在这里插入图片描述

子类没有初始化，不代表没有加载

2. 通过数组定义类引用，不会触发此类的初始化

 @Test
    public void test2(){
        Parent[] parents = new Parent[10];
        System.out.println(parents.getClass());
        System.out.println(parents.getClass().getSuperclass());
    }

在这里插入图片描述
一旦我们给数组中的属性赋值，就会进行初始化

 @Test
    public void test2(){
        Parent[] parents = new Parent[10];
        System.out.println(parents.getClass());
        System.out.println(parents.getClass().getSuperclass());

        parents[0] = new Parent();
        parents[1] = new Parent();
    }

在这里插入图片描述

类的初始化方法只会执行一次

3. 引用常量不会触发此类或接口的初始化。因为常量在链接阶段就已经被显式赋值了。

class Person{
    static{
        System.out.println("Person类的初始化");
    }
    public static final int NUM = 1;//在链接过程的准备环节就被赋值为1了。
   
}

@Test
    public void test1(){
       System.out.println(Person.NUM);
    
    }

在这里插入图片描述
如果想初始化，就得这样：

class Person{
    static{
        System.out.println("Person类的初始化");
    }
    public static final int NUM = 1;//在链接过程的准备环节就被赋值为1了。
    public static final int NUM1 = new Random().nextInt(10);//此时的赋值操作需要在<clinit>()中执行
}

 @Test
    public void test1(){

        System.out.println(Person.NUM1);
    }

在这里插入图片描述
接口也是一样的：

interface SerialA{
    public static final Thread t = new Thread() {
        {
            System.out.println("SerialA的初始化");
        }
    };

    int ID = 1;   
    int ID1 = new Random().nextInt(10);//此时的赋值操作需要在<clinit>()中执行
}

在这里插入图片描述

在这里插入图片描述
4. 调用ClassLoader类的loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

 @Test
    public void test3(){
        try {
            Class clazz = ClassLoader.getSystemClassLoader().loadClass("com.atguigu.java1.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

在这里插入图片描述

05-过程四：类的Using（使用）

在这里插入图片描述

06-过程五：类的Unloading（卸载）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

回顾：方法区的垃圾回收

在这里插入图片描述

香树
关注
专栏目录
jvm中篇-第三章-类的加载过程详解
08-15 1047
jvm中篇-06-类的加载过程详解1. 概述过程一：Loading（加载）阶段1. 加载完成的操作2. 二进制流的获取方式3. 类模型与Class实例的位置4. 数组类的加载过程二：Linking（链接）阶段1. Verification(验证)2. Preparation(准备)3. Resolution(解析)二级目录三级目录 1. 概述 在Java中数据类型分为基本数据类型和引用数据类型。基本数据类型由虚拟机预先定义，引用数据类型则需要进行类的加载 按照Java虚拟机规范，从class文件到加载到内存
＜JVM中篇：字节码与类的加载篇＞03-类的加载过程（类的生命周期）详解
VectorX's Blog
05-01 1363
https://gitee.com/vectorx/NOTE_JVM https://codechina.csdn.net/qq_35925558/NOTE_JVM https://github.com/uxiahnan/NOTE_JVM 文章目录1. 概述大厂面试题2. 过程一：Loading（加载）阶段2.1. 加载完成的操作2.2. 二进制流的获取方式2.3. 类模型与Class实例的位置2.4. 数组类的加载3. 过程二：Linking（链接）阶段3.1. 环节1：链接阶段之Verificati.
JVM中篇：字节码与类的加载篇-03-类的加载过程（类的生命周期）详解
yuanmomoya的博客
08-30 738
在 Java 中数据类型分为基本数据类型和引用数据类型。基本数据类型由虚拟机预先定义，引用数据类型则需要进行类的加载。按照 Java 虚拟机规范，从 class 文件到加载到内存中的类，到类卸载出内存为止，它的整个生命周期包括如下 7 个阶段：其中，验证、准备、解析 3 个部分统称为链接（Linking）从程序中类的使用过程看。
JVM中篇（4）： 类的加载过程详解
Mr_tianyanxiaobai的博客
07-15 473
文章目录概述过程一：Loading（加载）阶段加载完成的操作二进制流的获取方式类模型与Class实例的位置数组类的加载过程二：Linking（链接）阶段环节1：链接阶段之 Verification(验证)环节2：链接阶段之Preparation（准备）环节3：链接过程之 Resolution(解析)过程三：Initialization（初始化）阶段1. static与final的搭配问题2.\()的线程安全性3.类的初始化情况：主动使用vs被动使用一、主动使用二、被动使用过程四：类的Using使用过程五：类
尚硅谷2020最新版宋红康JVM教程-中篇-第3章类的加载过程(类的生命周期)详解-4-过程三:Initialization(初始化)阶段
admin741admin的博客
10-10 264
static与final的搭配问题 初始化阶段，简言之，为类的静态变量赋予正确的初始值。 具体描述 类的初始化是类装载的最后一个阶段。如果前面的步骤都没有问题，那么表示类可以顺利装载到系统中。此时，类才会开始执行Java字节码。（即：到了初始化阶段，才真正开始执行类中定义的Java程序代码。） 初始化阶段的重要工作是执行类的初始化方法：<clinit>()方法。 该方法仅能由Java编译器生成并由JVM调用，程序开发者无法自定义一个同名的方法，更无法直接在Java程序中调用该方法，虽然该方法
JVM中篇：字节码与类的加载篇
chenfl的博客
05-27 537
0.概述 0.1字节码文件的跨平台性 0.1.1.Java语言：跨平台的语言(write once,run anywhere) 当]ava源代码成功编译成字节码后，如果想在不同的平台上面运行，则无须再次编译 这个优势不再那么吸引人了。Python、PHP、Perl、Ruby、Lisp等有强大的解释器。 跨平台似乎已经快成为一门语言必选的特性。 0.1.2.Java虚拟机：跨语言的平台 Java虚拟机不和包括]ava在内的任何语言绑定，它只与“C1ass文件”这种特定的二进制文件格式所关联。无论使用何种语
尚硅谷2020最新版宋红康JVM教程-中篇-第3章类的加载过程(类的生命周期)详解-2-过程一:Loading(加载)阶段
admin741admin的博客
10-08 251
加载完成的操作 加载的理解 所谓加载，简而言之就是将Java类的字节码文件加载到机器内存中，并在内存中构建出Java类的原型——类模板对象。所谓类模板对象，其实就是Java类在]VM内存中的一个快照，JVM将从字节码文件中解析出的常量池、类字段、类方法等信息存储到类模板中，这样]VM在运行期便能通过类模板而获取Java类中的任意信息，能够对Java类的成员变量进行遍历，也能进行Java方法的调用。 反射的机制即基于这一基础。如果JVM没有将Java类的声明信息存储起来，则JVM在运行期也无法反射。 加载
尚硅谷2020最新版宋红康JVM教程-中篇-第3章类的加载过程(类的生命周期)详解-1-概述
admin741admin的博客
10-08 317
引言 在Java中数据类型分为基本数据类型和引用数据类型。基本数据类型由虚拟机预先定义，引用数据类型则需要进行类的加载。 按照Java虚拟机规范，从class文件到加载到内存中的类，到类卸载出内存为止，它的整个生命周期包括如下7个阶段： 其中，验证、准备、解析3个部分统称为链接（Linking） 从程序中类的使用过程看： 大厂面试题 蚂蚁金服： 描述一下JvM加载Class文件的原理机制？ 一面：类加载过程 百度： 类加载的时机 java类加载过程？ 简述java类加载机制？ 腾讯： JVM
尚硅谷2020最新版宋红康JVM教程-中篇-第3章类的加载过程(类的生命周期)详解-3-过程二:Linking(链接)阶段
admin741admin的博客
10-08 281
环节1：链接阶段之Verification（验证） 当类加载到系统后，就开始链接操作，验证是链接操作的第一步。 它的目的是保证加载的字节码是合法、合理并符合规范的。 验证的步骤比较复杂，实际要验证的项目也很繁多，大体上Java虚拟机需要做以下检查，如图所示。 整体说明： 验证的内容则涵盖了类数据信息的格式验证、语义检查、字节码验证，以及符号引用验证等。 其中格式验证会和加载阶段一起执行。验证通过之后，类加载器才会成功将类的二进制数据信息加载到方法区中。 格式验证之外的验证操作将会在方法区中进行。
尚硅谷 宋红康 JVM教程_02_字节码与类的加载篇
狗剩的专栏
01-18 1222
目录 尚硅谷 宋红康 JVM教程 学习笔记 https://www.bilibili.com/video/BV1PJ411n7xZ ppt地址： https://download.csdn.net/download/wei198621/14040543 JVM参数列表： https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html P204-JVM中篇内容概述 11:51 P205-字节码文件的跨平台性 13:12 P2
【JavaEE基础与高级 第49章】Java中的线程等待和唤醒、线程死锁、常用的线程池类（多线程下篇含线程池的使用及原理）
KJ.JK
09-19 1万+
等待和唤醒，指的是 "两个线程" 或 "多个线程" 之间的 "相互等待或唤醒" * Java 中提供了几个方法可以实现线程的等待和唤醒，这几个方法都 "来自Object类"
Spring中的依赖注入注解、第三方资源配置管理@Bean注解、XML配置 和 注解配置的区别（Spring纯注解开发中篇）
KJ.JK
08-24 1万+
文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习。
尚硅谷2020最新版宋红康JVM教程更新至中篇(java虚拟机详解，jvm从入门到精通)
Mason97的博客
02-02 1384
1
Spring中的创建对象的三种方式、第三方资源配置管理详细描述及使用（XML版完结篇）
热门推荐
KJ.JK
08-08 2万+
文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 290
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 824
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1387
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 897
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 267
默认对常规Session的理解和使用，如何使用Set-Cookie。
ACE程序员教程-中篇：自适配通信环境详解
"ACE程序员指南-中篇，由Umar Syyid著，马维达译，是一本关于ACE自适配通信环境的中文技术文档，主要面向网络编程和通信软件开发。该文档详细介绍了ACE这一面向对象的网络编程工具包，包括其核心的并发、同步、进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值