• JAXB实现JavaBean与XML相互转换（详尽）

    本文针对使用JAXB实现JavaBean与XML之间的相互转换，基本涵盖所有场景。

    概念

    JAXB是Java Architecture for XML Binding的缩写。可以将一个Java对象转变成为XML格式，反之亦然。 
        我们把对象与关系数据库之间的映射称为ORM，其实也可以把对象与XML之间的映射称为OXM(Object XML Mapping)。原来JAXB是Java EE的一部分，在JDK1.6中，SUN将其放到了Java SE中，这也是SUN的一贯做法。JDK1.6中自带的这个JAXB版本是2.0，比起1.0(JSR 31)来，JAXB2(JSR 222)用JDK5的新特性Annotation来标识要作绑定的类和属性等，这就极大简化了开发的工作量。

    常见的注解说明

    JAXBContext类：是应用的入口，用于管理XML/Java绑定信息。
    Marshaller接口：将Java对象序列化为XML数据。
    Unmarshaller接口：将XML数据反序列化为Java对象。
    @XmlRootElement：将Java类或枚举类型映射到XML元素，用在Java类上，用于标注该类是xml的一个根节点。
    @XmlElement：将Java类的一个属性映射到与属性同名的一个XML元素。通常与@XmlTransient搭配使用。
    @XmlTransient：通常与 @XmlElement 须搭配使用的。@XmlElement用在属性上，用于指定生成xml的节点名，@XmlTransient用在对应的getter方法上，起到关联的作用。
    @XmlElementWrapper ：对于数组或集合（即包含多个元素的成员变量），生成一个包装该数组或集合的XML元素（称为包装器）。通常配合XmlElement一起使用，XmlElementWrapper指定数组名，XmlElement指定生成xml的节点名。
    @XmlElementRef：用在类属性的getter方法上（即该属性是一个JavaBean），并且该属性是某些子类的父类，起到引用的作用。同时标注得有@XmlElementRef的类属性，其子类上需要使用@XmlRootElement标注，否则转换异常，提示找不到具体的引用实现。另外，转换时，需要将其子类的class一起传递到JAXBContext上下文中，否则也无法转换。
    @XmlAccessorOrder：控制JAXB 绑定类中属性和字段的排序。

    @XmlType：将Java类或枚举类型映射到XML模式类型
    @XmlAccessorType(XmlAccessType.FIELD) ：控制字段或属性的序列化。FIELD表示JAXB将自动绑定Java类中的每个非静态的（static）、非瞬态的（由@XmlTransient标 注）字段到XML。还有XmlAccessType.PROPERTY和XmlAccessType.NONE。
    @XmlJavaTypeAdapter：使用定制的适配器（即扩展抽象类XmlAdapter并覆盖marshal()和unmarshal()方法），以序列化Java类为XML。
    @XmlAttribute，将Java类的一个属性映射到与属性同名的一个XML属性。

    1.工具方法

    1. public class XmlBeanUtils {
    2.  
    3.     /**
    4.      * Java Bean 转 Xml
    5.      *
    6.      * @param bean         - Java Bean
    7.      * @param inheritClazz - Java Bean中嵌套的类，且有继承关系的Java Class
    8.      * @return - xml
    9.      */
    10.     public static String beanToXml(Object bean, Class... inheritClazz) {
    11.         try {
    12.             JAXBContext context = initContext(bean.getClass(), inheritClazz);
    13.             Marshaller marshaller = context.createMarshaller();
    14.             // 格式化xml
    15.             marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    16.             marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
    17.             // 是否去掉xml头
    18.             marshaller.setProperty(Marshaller.JAXB_FRAGMENT, false);
    19.             StringWriter writer = new StringWriter();
    20.             marshaller.marshal(bean, writer);
    21.             return writer.toString();
    22.         } catch (JAXBException e) {
    23.             e.printStackTrace();
    24.         }
    25.         return null;
    26.     }
    27.  
    28.     /**
    29.      * Xml 转 Java Bean
    30.      *
    31.      * @param xml          - xml
    32.      * @param beanClazz    - Java Bean Class
    33.      * @param inheritClazz - Java Bean中嵌套的类，且有继承关系的Java Class
    34.      * @return - bean
    35.      */
    36.     public static Object xmlToBean(String xml, Class beanClazz, Class... inheritClazz) {
    37.         try {
    38.             JAXBContext context = initContext(beanClazz, inheritClazz);
    39.             Unmarshaller um = context.createUnmarshaller();
    40.             StringReader sr = new StringReader(xml);
    41.             return um.unmarshal(sr);
    42.         } catch (JAXBException e) {
    43.             e.printStackTrace();
    44.         }
    45.         return null;
    46.     }
    47.  
    48.     /**
    49.      * 初始化JAXBContext
    50.      *
    51.      * @param mainClazz    - 序列化或反序列化Class
    52.      * @param inheritClazz - Java Bean中嵌套的类，且有继承关系的Java Class
    53.      * @return - JAXBContext
    54.      */
    55.     private static JAXBContext initContext(Class mainClazz, Class... inheritClazz) throws JAXBException {
    56.         JAXBContext context;
    57.         if (inheritClazz != null) {
    58.             Class[] clazzArr = new Class[inheritClazz.length + 1];
    59.             clazzArr[0] = mainClazz;
    60.             System.arraycopy(inheritClazz, 0, clazzArr, 1, clazzArr.length - 1);
    61.             context = JAXBContext.newInstance(clazzArr);
    62.         } else {
    63.             context = JAXBContext.newInstance(mainClazz);
    64.         }
    65.         return context;
    66.     }
    67.  
    68. }

    2.应用实例

    1.1.普通对象的转换

    1. import lombok.AllArgsConstructor;
    2. import lombok.NoArgsConstructor;
    3. import lombok.Setter;
    4. import lombok.ToString;
    5.  
    6. import javax.xml.bind.annotation.XmlElement;
    7. import javax.xml.bind.annotation.XmlRootElement;
    8. import javax.xml.bind.annotation.XmlTransient;
    9.  
    10. /**
    11.  * 简单JavaBean与XML转换
    12.  */
    13. public class SimpleTest {
    14.     public static void main(String[] args) {
    15.         Cat cat = new Cat("猫咪", "爱吃鱼");
    16.         String xml = XmlBeanUtils.beanToXml(cat);
    17.         System.out.println("bean->xml = " + xml);
    18.         System.out.println("xml->bean = " + XmlBeanUtils.xmlToBean(xml, Cat.class));
    19.     }
    20.  
    21.     @ToString
    22.     @NoArgsConstructor
    23.     @AllArgsConstructor
    24.     @Setter
    25.     @XmlRootElement(name = "Cat")
    26.     static class Cat {
    27.         @XmlElement(name = "CatName")
    28.         private String name;
    29.  
    30.         @XmlElement(name = "Hobby")
    31.         private String hobby;
    32.  
    33.         @XmlTransient
    34.         public String getName() {
    35.             return name;
    36.         }
    37.  
    38.         @XmlTransient
    39.         public String getHobby() {
    40.             return hobby;
    41.         }
    42.     }
    43. }
    44.  
    45.

    1.2.有继承关系的对象转换

    1. import lombok.AllArgsConstructor;
    2. import lombok.NoArgsConstructor;
    3. import lombok.Setter;
    4. import lombok.ToString;
    5.  
    6. import javax.xml.bind.annotation.XmlElement;
    7. import javax.xml.bind.annotation.XmlRootElement;
    8. import javax.xml.bind.annotation.XmlTransient;
    9.  
    10. /**
    11.  * 继承关系JavaBean与XML转换
    12.  */
    13. public class InheritBeanTest {
    14.     public static void main(String[] args) {
    15.         // 具有继承关系，使用Cat 或 Animal 接收都可以。
    16.         // Cat cat = new Cat("猫咪", "爱吃鱼");
    17.         Animal cat = new Cat("猫咪", "爱吃鱼");
    18.         String xml = XmlBeanUtils.beanToXml(cat);
    19.         System.out.println("bean->xml = " + xml);
    20.         // 此处不能使用父类Animal来接收，因为无法推断具体的实现类是哪个，必须使用具体的实现类Cat来接收
    21.         System.out.println("xml->bean = " + XmlBeanUtils.xmlToBean(xml, Cat.class));
    22.     }
    23.  
    24.     @Setter
    25.     abstract static class Animal {
    26.         // 不建议定义属性，因为从XML->Bean时，父类属性会丢失
    27.     }
    28.  
    29.     @ToString
    30.     @NoArgsConstructor
    31.     @AllArgsConstructor
    32.     @Setter
    33.     @XmlRootElement(name = "Cat")
    34.     static class Cat extends Animal {
    35.         @XmlElement(name = "CatName")
    36.         private String name;
    37.  
    38.         @XmlElement(name = "Hobby")
    39.         private String hobby;
    40.  
    41.         @XmlTransient
    42.         public String getName() {
    43.             return name;
    44.         }
    45.  
    46.         @XmlTransient
    47.         public String getHobby() {
    48.             return hobby;
    49.         }
    50.     }
    51. }

    1.3.嵌套的类属性是普通对象的转换

    1. import lombok.AllArgsConstructor;
    2. import lombok.NoArgsConstructor;
    3. import lombok.Setter;
    4. import lombok.ToString;
    5.  
    6. import javax.xml.bind.annotation.XmlElement;
    7. import javax.xml.bind.annotation.XmlRootElement;
    8. import javax.xml.bind.annotation.XmlTransient;
    9.  
    10. /**
    11.  * 有嵌套关系的JavaBean与XML转换
    12.  */
    13. public class NestBeanTest {
    14.     public static void main(String[] args) {
    15.         Cat cat = new Cat("猫咪", "爱吃鱼");
    16.         Person person = new Person("貂蝉", 18, cat);
    17.         String xml = XmlBeanUtils.beanToXml(person);
    18.         System.out.println("bean->xml = " + xml);
    19.         System.out.println("xml->bean = " + XmlBeanUtils.xmlToBean(xml, Person.class));
    20.     }
    21.  
    22.     @ToString
    23.     @NoArgsConstructor
    24.     @AllArgsConstructor
    25.     @Setter
    26.     @XmlRootElement(name = "Person")
    27.     static class Person {
    28.         @XmlElement(name = "UserName")
    29.         private String name;
    30.  
    31.         @XmlElement(name = "Age")
    32.         private int age;
    33.  
    34.         // 嵌套的JavaBean
    35.         @XmlElement(name = "Pet")
    36.         private Cat cat;
    37.  
    38.         @XmlTransient
    39.         public String getName() {
    40.             return name;
    41.         }
    42.  
    43.         @XmlTransient
    44.         public int getAge() {
    45.             return age;
    46.         }
    47.  
    48.         @XmlTransient
    49.         public Cat getCat() {
    50.             return cat;
    51.         }
    52.     }
    53.  
    54.  
    55.     @ToString
    56.     @NoArgsConstructor
    57.     @AllArgsConstructor
    58.     @Setter
    59.     @XmlRootElement(name = "Cat")
    60.     static class Cat {
    61.         @XmlElement(name = "CatName")
    62.         private String name;
    63.  
    64.         @XmlElement(name = "Hobby")
    65.         private String hobby;
    66.  
    67.         @XmlTransient
    68.         public String getName() {
    69.             return name;
    70.         }
    71.  
    72.         @XmlTransient
    73.         public String getHobby() {
    74.             return hobby;
    75.         }
    76.     }
    77. }
    78.  
    79.

    1.4.嵌套类属性是的集合（数组）普通对象的转换

    1. import lombok.AllArgsConstructor;
    2. import lombok.NoArgsConstructor;
    3. import lombok.Setter;
    4. import lombok.ToString;
    5.  
    6. import javax.xml.bind.annotation.XmlElement;
    7. import javax.xml.bind.annotation.XmlElementWrapper;
    8. import javax.xml.bind.annotation.XmlRootElement;
    9. import javax.xml.bind.annotation.XmlTransient;
    10. import java.util.ArrayList;
    11. import java.util.List;
    12.  
    13. /**
    14.  * 有嵌套关系的集合JavaBean与XML转换
    15.  */
    16. public class NestListBeanTest {
    17.     public static void main(String[] args) {
    18.         List cats = new ArrayList<>();
    19.         cats.add(new Cat("大猫咪", "爱吃大鱼"));
    20.         cats.add(new Cat("小猫咪", "爱吃小鱼"));
    21.         Person person = new Person("貂蝉", 18, cats);
    22.         String xml = XmlBeanUtils.beanToXml(person);
    23.         System.out.println("bean->xml = " + xml);
    24.         System.out.println("xml->bean = " + XmlBeanUtils.xmlToBean(xml, Person.class));
    25.     }
    26.  
    27.     @ToString
    28.     @NoArgsConstructor
    29.     @AllArgsConstructor
    30.     @Setter
    31.     @XmlRootElement(name = "Person")
    32.     static class Person {
    33.         @XmlElement(name = "UserName")
    34.         private String name;
    35.  
    36.         @XmlElement(name = "Age")
    37.         private int age;
    38.  
    39.         // 嵌套的集合JavaBean：XmlElementWrapper指定集合数组XML节点名，XmlElement指定具体的节点名
    40.         @XmlElementWrapper(name = "PetArray")
    41.         @XmlElement(name = "Pet")
    42.         private List cats;
    43.  
    44.         @XmlTransient
    45.         public String getName() {
    46.             return name;
    47.         }
    48.  
    49.         @XmlTransient
    50.         public int getAge() {
    51.             return age;
    52.         }
    53.  
    54.         @XmlTransient
    55.         public List getCats() {
    56.             return cats;
    57.         }
    58.     }
    59.  
    60.  
    61.     @ToString
    62.     @NoArgsConstructor
    63.     @AllArgsConstructor
    64.     @Setter
    65.     @XmlRootElement(name = "Cat")
    66.     static class Cat {
    67.         @XmlElement(name = "CatName")
    68.         private String name;
    69.  
    70.         @XmlElement(name = "Hobby")
    71.         private String hobby;
    72.  
    73.         @XmlTransient
    74.         public String getName() {
    75.             return name;
    76.         }
    77.  
    78.         @XmlTransient
    79.         public String getHobby() {
    80.             return hobby;
    81.         }
    82.     }
    83. }
    84.  
    85.

    1.5.嵌套的类属性是继承关系对象的转换

    1. import lombok.AllArgsConstructor;
    2. import lombok.NoArgsConstructor;
    3. import lombok.Setter;
    4. import lombok.ToString;
    5.  
    6. import javax.xml.bind.annotation.XmlElement;
    7. import javax.xml.bind.annotation.XmlElementRef;
    8. import javax.xml.bind.annotation.XmlRootElement;
    9. import javax.xml.bind.annotation.XmlTransient;
    10.  
    11. /**
    12.  * 有嵌套且有继承关系的JavaBean与XML转换
    13.  */
    14. public class NestInheritBeanTest {
    15.     public static void main(String[] args) {
    16.         // 此处使用Animal或Cat来接收都是可以的，因为已经创建了具体的Bean
    17.         Animal cat = new Cat("猫咪", "爱吃鱼");
    18.         Person person = new Person("貂蝉", 18, cat);
    19.         // 转换时需要将Person中Animal类属性的实现类Cat.class传入。否则无法无法转换，因为不清楚具体的实现。
    20.         String xml = XmlBeanUtils.beanToXml(person, Cat.class);
    21.         System.out.println("bean->xml = " + xml);
    22.         // 转换时需要将Person中Animal类属性的实现类Cat.class传入。否则无法无法转换，因为不清楚具体的实现。
    23.         System.out.println("xml->bean = " + XmlBeanUtils.xmlToBean(xml, Person.class, Cat.class));
    24.     }
    25.  
    26.     @ToString
    27.     @NoArgsConstructor
    28.     @AllArgsConstructor
    29.     @Setter
    30.     @XmlRootElement(name = "Person")
    31.     static class Person {
    32.         @XmlElement(name = "UserName")
    33.         private String name;
    34.  
    35.         @XmlElement(name = "Age")
    36.         private int age;
    37.  
    38.         // 嵌套的JavaBean，且是父类，此处不能使用@XmlElement标注，否则会报错，
    39.         // 原因是父类不知道具体的子类实现，需要在子类中使用@XmlRootElement标注具体的实现
    40.         private Animal animal;
    41.  
    42.         @XmlTransient
    43.         public String getName() {
    44.             return name;
    45.         }
    46.  
    47.         @XmlTransient
    48.         public int getAge() {
    49.             return age;
    50.         }
    51.  
    52.         // 必须使用@XmlElementRef来标注父类，起到引用的作用
    53.         @XmlElementRef
    54.         public Animal getAnimal() {
    55.             return animal;
    56.         }
    57.     }
    58.  
    59.  
    60.     @Setter
    61.     abstract static class Animal {
    62.     }
    63.  
    64.     @ToString
    65.     @NoArgsConstructor
    66.     @AllArgsConstructor
    67.     @Setter
    68.     @XmlRootElement(name = "Cat")
    69.     static class Cat extends Animal {
    70.         @XmlElement(name = "CatName")
    71.         private String name;
    72.  
    73.         @XmlElement(name = "Hobby")
    74.         private String hobby;
    75.  
    76.         @XmlTransient
    77.         public String getName() {
    78.             return name;
    79.         }
    80.  
    81.         @XmlTransient
    82.         public String getHobby() {
    83.             return hobby;
    84.         }
    85.     }
    86. }
    87.  
    88.

    1.6.嵌套的类属性是集合（数组）继承关系对象的转换

    1. import lombok.AllArgsConstructor;
    2. import lombok.NoArgsConstructor;
    3. import lombok.Setter;
    4. import lombok.ToString;
    5.  
    6. import javax.xml.bind.annotation.*;
    7. import java.util.ArrayList;
    8. import java.util.List;
    9.  
    10. /**
    11.  * 有嵌套且有继承关系的集合JavaBean与XML转换
    12.  */
    13. public class NestInheritListBeanTest {
    14.     public static void main(String[] args) {
    15.         // 此处使用Animal来接，属于List泛型知识，此处不再赘述
    16.         List animals = new ArrayList<>();
    17.         animals.add(new Cat("大猫咪", "爱吃大鱼"));
    18.         animals.add(new Cat("小猫咪", "爱吃小鱼"));
    19.         Person person = new Person("貂蝉", 18, animals);
    20.         // 转换时需要将Person中Animal类属性的实现类Cat.class传入。否则无法无法转换，因为不清楚具体的实现。
    21.         String xml = XmlBeanUtils.beanToXml(person, Cat.class);
    22.         System.out.println("bean->xml = " + xml);
    23.         // 转换时需要将Person中Animal类属性的实现类Cat.class传入。否则无法无法转换，因为不清楚具体的实现。
    24.         System.out.println("xml->bean = " + XmlBeanUtils.xmlToBean(xml, Person.class, Cat.class));
    25.     }
    26.  
    27.     @ToString
    28.     @NoArgsConstructor
    29.     @AllArgsConstructor
    30.     @Setter
    31.     @XmlRootElement(name = "Person")
    32.     static class Person {
    33.         @XmlElement(name = "UserName")
    34.         private String name;
    35.  
    36.         @XmlElement(name = "Age")
    37.         private int age;
    38.  
    39.         // 嵌套的JavaBean，且是父类，此处不能使用@XmlElement标注，否则会报错，
    40.         // 原因是父类不知道具体的子类实现，需要在子类中使用@XmlRootElement标注具体的实现
    41.         private List animals;
    42.  
    43.         @XmlTransient
    44.         public String getName() {
    45.             return name;
    46.         }
    47.  
    48.         @XmlTransient
    49.         public int getAge() {
    50.             return age;
    51.         }
    52.  
    53.         // 必须使用@XmlElementRef来标注父类，起到引用的作用
    54.         // 必须使用@XmlElementWrapper指定集合数组XML节点名
    55.         @XmlElementRef
    56.         @XmlElementWrapper(name = "PetArray")
    57.         public List getAnimals() {
    58.             return animals;
    59.         }
    60.     }
    61.  
    62.     @Setter
    63.     abstract static class Animal {
    64.     }
    65.  
    66.     @ToString
    67.     @NoArgsConstructor
    68.     @AllArgsConstructor
    69.     @Setter
    70.     @XmlRootElement(name = "Cat")
    71.     static class Cat extends Animal {
    72.         @XmlElement(name = "CatName")
    73.         private String name;
    74.  
    75.         @XmlElement(name = "Hobby")
    76.         private String hobby;
    77.  
    78.         @XmlTransient
    79.         public String getName() {
    80.             return name;
    81.         }
    82.  
    83.         @XmlTransient
    84.         public String getHobby() {
    85.             return hobby;
    86.         }
    87.     }
    88. }

    1.7.有继承关系且父类有属性的对象的转换

    （不推荐使用，XML->Bean转换时父类属性会丢失）

    1. import lombok.AllArgsConstructor;
    2. import lombok.NoArgsConstructor;
    3. import lombok.Setter;
    4. import lombok.ToString;
    5.  
    6. import javax.xml.bind.annotation.XmlElement;
    7. import javax.xml.bind.annotation.XmlElementRef;
    8. import javax.xml.bind.annotation.XmlRootElement;
    9. import javax.xml.bind.annotation.XmlTransient;
    10.  
    11. /**
    12.  * 有嵌套且有继承关系的JavaBean与XML转换
    13.  * 且父类中定义了属性，XML->Bean，父类属性会丢失（除非必要，不要再父类中定义属性）
    14.  */
    15. public class NoSupportNestInheritBeanTest {
    16.     public static void main(String[] args) {
    17.         // 此处使用Animal或Cat来接收都是可以的，因为已经创建了具体的Bean
    18.         Cat cat = new Cat("猫咪", "爱吃鱼");
    19.         cat.setCountry("中国");
    20.         Person person = new Person("貂蝉", 18, cat);
    21.         // 转换时需要将Person中Animal类属性的实现类Cat.class传入。否则无法无法转换，因为不清楚具体的实现。
    22.         String xml = XmlBeanUtils.beanToXml(person, Cat.class);
    23.         System.out.println("bean->xml = " + xml);
    24.         // 转换时需要将Person中Animal类属性的实现类Cat.class传入。否则无法无法转换，因为不清楚具体的实现。
    25.         System.out.println("xml->bean = " + XmlBeanUtils.xmlToBean(xml, Person.class, Cat.class));
    26.     }
    27.  
    28.     @ToString
    29.     @NoArgsConstructor
    30.     @AllArgsConstructor
    31.     @Setter
    32.     @XmlRootElement(name = "Person")
    33.     static class Person {
    34.         @XmlElement(name = "UserName")
    35.         private String name;
    36.  
    37.         @XmlElement(name = "Age")
    38.         private int age;
    39.  
    40.         // 嵌套的JavaBean，且是父类，此处不能使用@XmlElement标注，否则会报错，
    41.         // 原因是父类不知道具体的子类实现，需要在子类中使用@XmlRootElement标注具体的实现
    42.         private Animal animal;
    43.  
    44.         @XmlTransient
    45.         public String getName() {
    46.             return name;
    47.         }
    48.  
    49.         @XmlTransient
    50.         public int getAge() {
    51.             return age;
    52.         }
    53.  
    54.         // 必须使用@XmlElementRef来标注父类，起到引用的作用
    55.         @XmlElementRef
    56.         public Animal getAnimal() {
    57.             return animal;
    58.         }
    59.     }
    60.  
    61.  
    62.     @Setter
    63.     abstract static class Animal {
    64.         @XmlElement(name = "Country")
    65.         private String country;
    66.  
    67.         @XmlTransient
    68.         public String getCountry() {
    69.             return country;
    70.         }
    71.     }
    72.  
    73.     @ToString
    74.     @NoArgsConstructor
    75.     @AllArgsConstructor
    76.     @Setter
    77.     @XmlRootElement(name = "Cat")
    78.     static class Cat extends Animal {
    79.         @XmlElement(name = "CatName")
    80.         private String name;
    81.  
    82.         @XmlElement(name = "Hobby")
    83.         private String hobby;
    84.  
    85.         @XmlTransient
    86.         public String getName() {
    87.             return name;
    88.         }
    89.  
    90.         @XmlTransient
    91.         public String getHobby() {
    92.             return hobby;
    93.         }
    94.     }
    95. }

  • 相关阅读:
    用python实现基本数据结构【03/4】
    曼哈顿距离和-打印菱形
    基于lstm DNN的多变量单变量时间预测项目-完整数据+代码
    LintCode 3208：String splitting字符串处理入门题
    HOW TO EASILY CREATE BARPLOTS WITH ERROR BARS IN R
    微信自动批量添加好友的方法
    34.线程的生命周期【20220812】
    JCJC-基于剪贴板的碎片信息收集工具
    常用建模工具
    Vue+Elementui历史导航标签实现
  • 原文地址：https://blog.csdn.net/gengzhy/article/details/127564536