.net 系列化与反序列化（转载）

时间  2019-11-19
标签 系列化 序列 转载 繁體版
原文   原文链接

.net序列化及反序列化

转载自：http://www.cnblogs.com/Tim_Liu/archive/2010/11/09/1872587.htmlhtml

 

序列化是指一个对象的实例能够被保存，保存成一个二进制串，固然，一旦被保存成二进制串，那么也能够保存成文本串了。
好比，一个计数器，数值为2，咱们能够用字符串“2”表示。
若是有个对象，叫作connter，当前值为2，那么能够序列化成“2”，反向的，也能够从“2”获得值为2的计数器实例。
这样，关机时序列化它，开机时反序列化它，每次开机都是延续的。不会都是从头开始。web

序列化概念的提出和实现，可使咱们的应用程序的设置信息保存和读取更加方便。编程

序列化有不少好处，好比，在一台机器上产生一个实例，初始化完毕，而后能够序列化，经过网络传送到另外一台机器，而后反序列化，获得对象实例，以后再执行某些业务逻辑，获得结果，再序列化，返回第一台机器，第一台机器获得对象实例，获得结果。
这个例子是目前比较先进的“智能代理”的原理。api

当前比较热火的web services使用soap协议，soap协议也是以对象的可序列化为基础的。数组

一 概述
.NET Framework为处理XML数据提供了许多不一样的类库。XmlDocument类能让你像处理文件同样处理xml数据，而XmlReader、XmlWriter和它们的派生类使你可以将xml数据做为数据流处理。
XmlSerializer则提供了另外的方法，它使你可以将本身的对象串行化和反串行化为xml。串行化数据既可以让你像处理文件同样对数据进行随机处理，同时又能跳过你不感兴趣的数据。
二 主要类库介绍
   .NET 支持对象xml序列化和反序列化的类库主要位于命名空间System.Xml.Serialization中。
   1.  XmlSerializer 类
   该类用一种高度松散耦合的方式提供串行化服务。你的类不须要继承特别的基类，并且它们也不须要实现特别的接 口。相反，你只需在你的类或者这些类的公共域以及读/写属性里加上自定义的特性。XmlSerializer经过反射机制读取这些特性并用它们将你的类和 类成员映射到xml元素和属性。
   2. XmlAttributeAttribute 类
   指定类的公共域或读/写属性对应xml文件的Attribute。
   例：[XmlAttribute(“type”)] or [XmlAttribute(AttributeName=”type”)]
   3. XmlElementAttribute类
   指定类的公共域或读/写属性对应xml文件的Element。
   例：[XmlElement(“Maufacturer”)] or [XmlElement(ElementName=”Manufacturer”)]
   4. XmlRootAttribute类
   Xml序列化时，由该特性指定的元素将被序列化成xml的根元素。
   例：[XmlRoot(“RootElement”)] or [XmlRoot(ElementName = “RootElements”)]
   5. XmlTextAttribute 类
   Xml序列化时，由该特性指定的元素值将被序列化成xml元素的值。一个类只容许拥有一个该特性类的实例，由于xml元素只能有一个值。
   6. XmlIgnoreAttribute类
   Xml序列化时不会序列化该特性指定的元素。
三 实例
   下面例子中的xml schema 描述了一个简单的人力资源信息，其中包含了xml的大部分格式，如xml 元素相互嵌套， xml元素既有元素值，又有属性值。
   1. 待序列化的类层次结构
    [XmlRoot("humanResource")]
    public class HumanResource
    {
        #region private data.
        private int m_record = 0;
        private Worker[] m_workers = null;
        #endregion
 
        [XmlAttribute(AttributeName="record")]
        public int Record
        {
            get { return m_record; }
            set { m_record = value; }
        }
 
        [XmlElement(ElementName="worker")]
        public Worker[] Workers
        {
            get { return m_workers; }
            set { m_workers = value; }
        }
}
 
    public class Worker
    {
        #region private data.
        private string m_number = null;
        private InformationItem[] m_infoItems = null;
        #endregion
 
        [XmlAttribute("number")]
        public string Number
        {
            get { return m_number; }
            set { m_number = value; }
        }
 
        [XmlElement("infoItem")]
        public InformationItem[] InfoItems
        {
            get { return m_infoItems; }
            set { m_infoItems = value; }
        }
}
 
    public class InformationItem
    {
        #region private data.
        private string m_name = null;
        private string m_value = null;
        #endregion
 
        [XmlAttribute(AttributeName = "name")]
        public string Name
        {
            get { return m_name; }
            set { m_name = value; }
        }
 
        [XmlText]
        public string Value
        {
            get { return m_value; }
            set { m_value = value; }
        }
}
   2. 序列化生成的xml结构
       <?xml version="1.0" ?>
- <humanResource xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd=" http://www.w3.org/2001/XMLSchema" record=" 2">
- <worker number=" 001">
                 <infoItem name=" name"> Michale</infoItem>
                 <infoItem name=" sex"> male</infoItem>
                 <infoItem name=" age"> 25</infoItem>
            </worker>
- <worker number=" 002">
                 <infoItem name=" name"> Surce</infoItem>
                 <infoItem name=" sex"> male</infoItem>
                 <infoItem name=" age"> 28</infoItem>
           </worker>
         </humanResource>
   3. 利用XmlSerializer类进行序列化和反序列化的实现（通常利用缓存机制实现xml文件只解析一次。）
    public sealed class ConfigurationManager
    {
        private static HumanResource m_humanResource = null;
        private ConfigurationManager(){}
 
        public static HumanResource Get(string path)
        {
            if (m_humanResource == null)
            {
                FileStream fs = null;
                try
                {
                    XmlSerializer xs = new XmlSerializer(typeof(HumanResource));
                    fs = new FileStream(path, FileMode.Open, FileAccess.Read);
                    m_humanResource = (HumanResource)xs.Deserialize(fs);
                    fs.Close();
                    return m_humanResource;
                }
                catch
                {
                    if (fs != null)
                        fs.Close();
                    throw new Exception("Xml deserialization failed!");
                }
 
            }
            else
            {
                return m_humanResource;
            }
        }
 
        public static void Set(string path, HumanResource humanResource)
        {
            if (humanResource == null)
                throw new Exception("Parameter humanResource is null!");
           
            FileStream fs = null;
            try
            {
                XmlSerializer xs = new XmlSerializer(typeof(HumanResource));
                fs = new FileStream(path, FileMode.Create, FileAccess.Write);
                xs.Serialize(fs, humanResource);
                m_humanResource = null;
                fs.Close();
            }
            catch
            {
                if (fs != null)
                    fs.Close();
                throw new Exception("Xml serialization failed!");
            }
        }
    }
四 说明
   1. 须要序列化为xml元素的属性必须为读/写属性；
   2. 注意为类成员设定缺省值，尽管这并非必须的。
 有关.NET中序列化的一些知识

    “序列化”可被定义为将对象的状态存储到存储媒介中的过程。在此过程当中，对象的公共字段和私有字段以及类的名称（包括包含该类的程序集）都被转换为字节流，而后写入数据流。在之后“反序列化”该对象时，建立原始对象的精确复本。
1、为何要选择序列化
    一个缘由是将对象的状态保持在存储媒体中，以即可以在之后从新建立精确的副本；
    另外一个缘由是经过值将对象从一个应用程序域发送到另外一个应用程序域中。
    例如，序列化可用于在 ASP.NET 中保存会话状态并将对象复制到 Windows 窗体的剪贴板中。远程处理还可使用序列化经过值将对象从一个应用程序域传递到另外一个应用程序域中。
2、如何实现对象的序列化及反序列化
    要实现对象的序列化，首先要保证该对象能够序列化。并且，序列化只是将对象的属性进行有效的保存，对于对象的一些方法则没法实现序列化的。
    实现一个类可序列化的最简便的方法就是增长Serializable属性标记类。如：
    [Serializable()]
    public class MEABlock
    {
        private int m_ID;
        public string Caption;缓存

        public MEABlock()
        {
            ///构造函数
        }
    }
    便可实现该类的可序列化。
    要将该类的实例序列化为到文件中？.NET FrameWork提供了两种方法：
    一、XML序列化
        使用 XmLSerializer 类，可将下列项序列化。 安全

  • 公共类的公共读／写属性和字段
  • 实现 ICollection 或 IEnumerable 的类。（注意只有集合会被序列化，而公共属性却不会。）
  • XmlElement 对象。
  • XmlNode 对象。
  • DataSet 对象。

         要实现上述类的实例的序列化，可参照以下例子：
        MEABlock myBlock = new MEABlock();
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(MEABlock));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter("myFileName.xml");
        mySerializer.Serialize(myWriter, MEABlock);
    须要注意的是XML序列化只会将public的字段保存，对于私有字段不予于保存。
    生成的XML文件格式以下：
        <MEABlock>
            <Caption>Test</Caption>
        </MEABlock>
    对于对象的反序列化，则以下：
        MEABlock myBlock;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(MEABlock));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream("myFileName.xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        myBlock = (MEABlock)mySerializer.Deserialize(myFileStream)
    二、二进制序列化
        与XML序列化不一样的是，二进制序列化能够将类的实例中全部字段（包括私有和公有）都进行序列化操做。这就更方便、更准确的还原了对象的副本。
        要实现上述类的实例的序列化，可参照以下例子：
        MEABlock myBlock = new MEABlock();
        // Insert code to set properties and fields of the object.
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream("MyFile.bin",FileMode.Create,FileAccess.Write, FileShare.None);
        formatter.Serialize(stream, myBlock);
        stream.Close();
    对于对象的反序列化，则以下：
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream("MyFile.bin", FileMode.Open,FileAccess.Read, FileShare.Read);
        MEABlock myBlock = (MEABlock) formatter.Deserialize(stream);
        stream.Close();

3、如何变相实现自定义可视化控件的序列化、反序列化
        对于WinForm中自定义控件，因为继承于System.Windows.Form类，而Form类又是从MarshalByRefObject继承的，窗体自己没法作到序列化，窗体的实现基于Win32下GUI资源，不能脱离当前上下文存在。
        固然能够采用变通的方法实现控件的序列化。这里采用的是记忆类模型。
        定义记忆类（其实就是一个可序列化的实体类）用于记录控件的有效属性，须要序列化控件的时候，只须要将该控件的实例Copy到记忆类，演变成序列化保存该记忆类的操做。
        反序列化是一个逆过程。将数据流反序列化成为该记忆类，再根据该记忆类的属性生成控件实例。而对于控件的一些事件、方法则能够继续使用。服务器

 介绍 XML 序列化
 
.NET Framework 开发员指南  
序列化是将对象转换为容易传输的格式的过程。例如，能够序列化一个对象，而后使用 HTTP 经过 Internet 在客户端和服务器之间传输该对象。在另外一端，反序列化将从该流从新构造对象。

XML 序列化仅将对象的公共字段和属性值序列化为 XML 流。XML 序列化不包括类型信息。例如，若是您有一个存在于 Library 命名空间中的 Book 对象，将不能保证它将会被反序列化为同一类型的对象。网络

注意   XML 序列化不转换方法、索引器、私有字段或只读属性（只读集合除外）。若要序列化对象的全部字段和属性（公共的和私有的），请使用 BinaryFormatter，而不要使用 XML 序列化。

XML 序列化中最主要的类是 XmlSerializer 类，它的最重要的方法是 Serialize 和 Deserialize 方法。XmlSerializer 生成的 XML 流符合万维网联合会 (www.w3.org) XML 架构定义语言 (XSD) 1.0 的建议。另外，生成的数据类型符合标题为“XML Schema Part 2: Datatypes”（XML 架构第二部分：数据类型）的文档。架构

对象中的数据是用编程语言构造（如类、字段、属性、基元类型、数组，甚至 XmlElement 或 XmlAttribute 对象形式的嵌入 XML）来描述的。您能够建立本身的用属性批注的类，或者使用 XML 架构定义工具生成基于现有 XML 架构的类。

若是您有 XML 架构，就可运行 XML 架构定义工具生成一组强类型化为架构并用属性批注的类。当序列化这样的类的实例时，生成的 XML 符合 XML 架构。使用这样的类，就可针对容易操做的对象模型进行编程，同时确保生成的 XML 符合 XML 架构。这是使用 .NET Framework 中的其余类（如 XmlReader 和 XmlWriter 类）分析和写 XML 流的一种替换方法。（有关使用这些类的更多信息，请参见使用 .NET Framework 中的 XML。）这些类使您能够分析任何 XML 流。与此相反，当须要 XML 流符合已知的 XML 架构时，请使用 XmlSerializer。

属性控制由 XmlSerializer 类生成的 XML 流，使您能够设置 XML 流的 XML 命名空间、元素名、属性名等。有关这些属性和它们如何控制 XML 序列化的更多信息，请参见使用属性控制 XML 序列化。若想得到一个列示对所生成的 XML 起控制做用的那些属性的表，请参见控制 XML 序列化的属性。

XmlSerializer 类可进一步序列化对象并生成编码的 SOAP XML 流。生成的 XML 符合标题为“Simple Object Access Protocol (SOAP) 1.1”的万维网联合会文档的第 5 节。有关此过程的更多信息，请参见用 XML 序列化生成 SOAP 消息。有关控制生成的 XML 的属性表，请参见控制编码的 SOAP 序列化的属性。

XmlSerializer 类生成由 XML Web services 建立和传递给 XML Web services 的 SOAP 消息。若要控制 SOAP 消息，可将属性应用于 XML Web services 文件 (.asmx) 中的类、返回值、参数和字段。您能够同时使用在“控制 XML 序列化的属性”中列出的属性和在“控制编码的 SOAP 序列化的属性”中列出的属性，由于 XML Web services 可使用文本样式，也可使用编码的 SOAP 样式。有关使用属性控制 XML Web services 所生成的 XML 的更多信息，请参见 XML Web services 的 XML 序列化。有关 SOAP 和 XML Web services 的更多信息，请参见自定义 SOAP 消息。

保护 XmlSerializer 应用程序

在建立使用 XmlSerializer 的应用程序时，您应当了解如下几点以及它们的影响：

  • XmlSerializer 建立 C# 文件 (.cs 文件)，并将其编译成 .dll 文件，这些 .dll 文件位于由 TEMP 环境变量指定的目录中；这些 DLL 文件将发生序列化。

    代码和 DLL 在建立和进行编译时，易于遭受恶意进程的攻击。若是所使用的计算机运行的是 Microsoft Windows NT 4.0 或更高版本，则有可能会有两个或更多用户共享临时目录。若是同时存在如下两种状况，则共享临时目录是有危险性的：(1) 两个账户有不一样的安全特权；(2) 具备较高特权的账户运行一个使用 XmlSerializer 的应用程序。在这种状况下，某一用户能够替换所编译的 .cs 或 .dll 文件，由此破坏计算机的安全性。为了不发生这一问题，请始终确保计算机上的每一账户都有本身的配置文件。若是可以保证这一点的话，默认状况下，TEMP 环境变量就会为不一样的账户指定不一样的目录。

  • 若是一名恶意用户向 Web 服务器发送持续的 XML 数据流（拒绝服务攻击），XmlSerializer 会一直处理这一数据，直到计算机资源不够用才中止。

    若是您所使用的计算机运行 Internet 信息服务 (IIS)，而且您的应用程序是在 IIS 下运行，就能够避免这类攻击。IIS 带有一个控制门，用于禁止处理大于设定数量（默认值是 4 KB）的数据流。若是您所建立的应用程序不使用 IIS，同时该应用程序使用 XmlSerializer 进行反序列化，则应该实现一个相似的控制门，以阻止拒绝服务攻击。

  • XmlSerializer 将使用给予它的任何类型，对数据进行序列化，并运行任何代码。

    恶意对象施加威胁的方式有两种。一种是运行恶意代码，另外一种是将恶意代码插入到由 XmlSerializer 建立的 C# 文件中。在第一种状况下，若是恶意对象试图运行破坏性过程，代码访问安全性将帮助防止发生任何破坏。在第二种状况下，在理论上，恶意对象有可能会以某种方式将代码插入到由 XmlSerializer 建立的 C# 文件中。尽管对这一问题已进行了完全的检验，并且这类攻击被认为是不可能的，但您仍是应该当心一些，必定不要序列化那些不可信的未知类型的数据。

  • 已序列化的重要数据可能易于遭到攻击。

    XmlSerializer 对数据进行了序列化以后，数据能够被存储为 XML 文件，或存储在其余数据存储区。若是其余进程能够访问到您的数据存储区，或是能够在 Intranet 或 Internet 上看到该数据存储区，数据就可能被窃取，并被恶意使用。例如，若是您建立了一个应用程序，对包含信用卡号码的订单进行序列化，这一数据就很是重要。为了防 止发生这一问题，请始终保护您的数据存储区，并对数据采起保密措施。

简单类的序列化

下面的示例显示一个具备公共字段的简单类：

[Visual Basic]Public Class OrderForm    Public OrderDate As DateTimeEnd Class[C#]public class OrderForm{ public DateTime OrderDate;}

当将此类的实例序列化时，该实例可能相似于下面的代码：

<OrderForm>    <OrderDate>12/12/01</OrderDate></OrderForm>

有关序列化的更多示例，请参见 XML 序列化的示例。

能够序列化的项

使用 XmLSerializer 类，可将下列项序列化。

  • 公共类的公共读／写属性和字段
  • 实现 ICollection 或 IEnumerable 的类。（注意只有集合会被序列化，而公共属性却不会。）
  • XmlElement 对象。
  • XmlNode 对象。
  • DataSet 对象。

序列化和反序列化对象

若要序列化对象，首先建立要序列化的对象并设置它的公共属性和字段。为此，必须肯定要用以存储 XML 流的传输格式（或者做为流，或者做为文件）。例如，若是 XML 流必须以永久形式保存，则建立 FileStream 对象。当您反序列化对象时，传输格式肯定您将建立流仍是文件对象。肯定了传输格式以后，就能够根据须要调用 Serialize 或 Deserialize 方法。

序列化对象

  1. 建立对象并设置它的公共字段和属性。
  2. 使用该对象的类型构造 XmlSerializer。有关更多信息，请参见 XmlSerializer 类构造函数。
  3. 调用 Serialize 方法以生成对象的公共属性和字段的 XML 流表示形式或文件表示形式。下面的示例建立一个文件。 
    [Visual Basic]Dim myObject As MySerializableClass = New MySerializableClass()' Insert code to set properties and fields of the object.Dim mySerializer As XmlSerializer = New XmlSerializer(GetType(MySerializableClass))' To write to a file, create a StreamWriter object.Dim myWriter As StreamWriter = New StreamWriter("myFileName.xml")mySerializer.Serialize(myWriter, myObject)[C#]MySerializableClass myObject = new MySerializableClass();// Insert code to set properties and fields of the object.XmlSerializer mySerializer = new XmlSerializer(typeof(MySerializableClass));// To write to a file, create a StreamWriter object.StreamWriter myWriter = new StreamWriter("myFileName.xml");mySerializer.Serialize(myWriter, myObject);

反序列化对象

  1. 使用要反序列化的对象的类型构造 XmlSerializer。
  2. 调用 Deserialize 方法以产生该对象的副本。在反序列化时，必须将返回的对象强制转换为原始对象的类型，以下面的示例中所示。下面的示例将该对象反序列化为文件，尽管它也能够被反序列化为流。 
    [Visual Basic]Dim myObject As MySerializableClass' Constructs an instance of the XmlSerializer with the type' of object that is being deserialized.Dim mySerializer As XmlSerializer = New XmlSerializer(GetType(MySerializableClass))' To read the file, creates a FileStream.Dim myFileStream As FileStream = _New FileStream("myFileName.xml", FileMode.Open)' Calls the Deserialize method and casts to the object type.myObject = CType( _mySerializer.Deserialize(myFileStream), MySerializableClass)[C#]MySerializableClass myObject;// Constructs an instance of the XmlSerializer with the type// of object that is being deserialized.XmlSerializer mySerializer = new XmlSerializer(typeof(MySerializableClass));// To read the file, creates a FileStream.FileStream myFileStream = new FileStream("myFileName.xml", FileMode.Open);// Calls the Deserialize method and casts to the object type.myObject = (MySerializableClass) mySerializer.Deserialize(myFileStream)

有关 XML 序列化的更多示例，请参见 XML 序列化的示例。

使用 XML 序列化的好处

XmlSerializer 类在您将对象序列化为 XML 时为您提供完整而灵活的控制。若是您正在建立 XML Web services，则能够将控制序列化的属性应用于类和成员以确保 XML 输出符合特定的架构。

例如，XmlSerializer 使您可以：

  • 指定应将字段或属性编码为特性仍是元素。
  • 指定要使用的 XML 命名空间。
  • 若是字段或属性名不合适，则指定元素或特性的名称。

XML 序列化的另外一个好处是：只要生成的 XML 流符合给定的架构，则对于所开发的应用程序就没有约束。假定有这样一个用于描述图书的架构，它具备标题、做者、出版商和 ISBN 编号元素。您能够开发一个以您但愿的任何方式（例如，做为图书订单，或做为图书清单）处理 XML 数据的应用程序。在任一种状况下，惟一的要求是 XML 流应当符合指定的 XML 架构定义语言 (XSD) 架构。

XML 序列化注意事项

使用 XmlSerializer 类时，应考虑下列状况：

  • 序列化数据只包含数据自己以及类的结构。不包括类型标识和程序集信息。
  • 只能序列化公共属性和字段。若是须要序列化非公共数据，请使用 BinaryFormatter 类而不是 XML 序列化。
  • 类必须有一个将由 XmlSerializer 序列化的默认构造函数。
  • 不能序列化方法。
  • XmlSerializer 能够以不一样方式处理实现 IEnumerable 或 ICollection 的类（条件是这些类知足某些要求）。实现 IEnumerable 的类必须实现带单个参数的公共 Add 方法。Add 方法的参数必须与从 GetEnumerator 方法返回的 IEnumerator.Current 属性所返回的类型一致（多态）。除实现 IEnumerable 外还实现 ICollection 的类（如 CollectionBase）必须有一个取整数的公共 Item 索引属性（在 C# 中为索引器），而且它必须有一个整数类型的公共 Count 属性。传递给 Add 方法的参数必须与从 Item 属性返回的类型相同或与该类型的某个基的类型相同。对于实现 ICollection 的类，要序列化的值将从索引 Item 属性检索，而不是经过调用 GetEnumerator 来检索。另外请注意，除返回另外一个集合类（实现 ICollection 的集合类）的公共字段以外，将不序列化公共字段和属性。有关示例，请参见 XML 序列化的示例。

XSD 数据类型映射

标题为“XML Schema Part 2: Datatypes”的万维网联合会 (www.W3.org) 文档指定在 XML 架构定义语言 (XSD) 架构中容许使用的简单数据类型。对于这些数据类型中的许多类型（例如，int 和 decimal），在 .NET Framework 中都有对应的数据类型。可是，某些 XML 数据类型在 .NET Framework 中没有对应的数据类型（例如，NMTOKEN 数据类型）。在这样的状况下，若是使用 XML 架构定义工具 (Xsd.exe) 从架构生成类，就会将适当的特性应用于字符串类型的成员，并会将其 DataType 属性设置为 XML 数据类型名称。例如，若是架构包含一个数据类型为 XML 数据类型 NMTOKEN 的、名为“MyToken”的元素，则生成的类可能包含如下示例中的成员。

[Visual Basic]<XmlElement(DataType:="NMTOKEN")>Public MyToken As String[C#][XmlElement(DataType = "NMTOKEN")]public string MyToken;

与此相似，若是建立一个必须符合特定 XML 架构 (XSD) 的类，应当应用适当的特性并将它的 DataType 属性设置为所需的 XML 数据类型名称。

有关类型映射的完整列表，请参见下列任意一个特性类的 DataType 属性：SoapAttributeAttribute、SoapElementAttribute、XmlArrayItemAttribute、XmlAttributeAttribute、XmlElementAttribute 或 XmlRootAttribute。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程