C#委託與事件學習筆記

時間  2019-12-23
標籤 c# 委託 事件 學習 筆記 欄目 C# 简体版
原文   原文鏈接

    本筆記摘抄自：https://www.cnblogs.com/leslies2/archive/2012/03/22/2389318.html，記錄一下學習過程以備後續查用。html

    1、委託類型的來由安全

    在使用C語言的年代，整個項目中都充滿着針指的身影，那時候流行使用函數指針來建立回調函數，使用回調能夠把函數回調給程序中的另外一個函數。但函數指針多線程

只是簡單地把地址指向另外一個函數，並不能傳遞其餘額外信息。異步

    在.NET中，大部分時間裏都沒有指針的身影，由於指針被封閉在內部函數當中。但是回調函數卻依然存在，它是以委託的方式來完成的。委託能夠被視爲一個更ide

高級的指針，它不只僅能把地址指向另外一個函數，並且還能傳遞參數、返回值等多個信息。系統還爲委託對象自動生成了同步、異步的調用方式，開發人員使用函數

BeginInvoke、EndInvoke方法就能夠拋開Thread而直接使用多線程調用 。工具

    2、創建委託類學習

    使用delegate能夠直接建立委託類型，當進行系統編譯時，系統就會自動生成此類型，可使用delegate void MyDelegate()方式建立一個委託類。測試

    class Program
    {
        delegate void MyDelegate();
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World.");
            Console.Read();
        }
    }
View Code

    使用ILDASM.exe觀察委託成員，能夠看到它繼承了System.MulticastDelegate類，並自動生成BeginInvoke、EndInvoke、Invoke 等三個經常使用方法。ui

    Invoke 方法是用於同步調用委託對象的對應方法，而BeginInvoke、EndInvoke是用於以異步方式調用對應方法。

    public class MyDelegate:MulticastDelegate
     {
         //同步調用委託方法
         public virtual void Invoke();
         //異步調用委託方法
         public virtual IAsyncResult BeginInvoke(AsyncCallback callback,object state);
         public virtual void EndInvoke(IAsyncResult result);
     }
View Code

    MulticastDelegate是System.Delegate的子類，它是一個特殊類，編譯器和其餘工具能夠今後類派生，可是自定義類不能顯式地今後類進行派生。它支持多路

廣播委託，並擁有一個帶有連接的委託列表。在調用多路廣播委託時，系統將按照調用列表中的委託出現順序來同步調用這些委託。

    MulticastDelegate具備兩個經常使用屬性：Method、Target。其中Method用於獲取委託所表示的方法，Target用於獲取當前調用的類實例。

    MulticastDelegate有如下幾個經常使用方法：

方法名稱 說明
 Clone   建立委託的淺表副本。
 GetInvocationList   按照調用順序返回此多路廣播委託的調用列表。
 GetMethodImpl   返回由當前的 MulticastDelegate 表示的靜態方法。
 GetObjectData   用序列化該實例所需的全部數據填充 SerializationInfo 對象。
 MemberwiseClone   建立當前 Object 的淺表副本。
 RemoveImpl   調用列表中移除與指定委託相等的元素

    MulticastDelegate與Delegate給委託對象創建了強大的支持。

    3、委託使用方式    

    3.1 簡單的委託

    當創建委託對象時，委託的參數類型必須與委託方法相對應。只要向創建委託對象的構造函數中輸入方法名稱example.Method，委託就會直接綁定此方法。

使用myDelegate.Invoke(string message)，就能顯式調用委託方法。

    但在實際的操做中，咱們無須用到Invoke方法，而只要直接使用myDelegate(string message)，就能調用委託方法。

    下面代碼演示簡單的委託：

    class Program
    {
        delegate void MyDelegateVoid(string message);

        public class Example
        {
            public void ShowMessage(string message)
            {
                Console.WriteLine(message);
            }
        }

        static void Main(string[] args)
        {
            #region 簡單的委託
            Example example = new Example();
            MyDelegateVoid myDelegateVoid = new MyDelegateVoid(example.ShowMessage);
            myDelegateVoid("Hello World");
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    3.2 帶返回值的委託

    當創建委託對象時，委託的返回值必須與委託方法相對應。

    下面代碼演示帶返回值的委託：

    class Program
    {
        delegate string MyDelegateString(string message);

        public class Example
        {
            public string SayHi(string name)
            {
                return "Hello " + name;
            }
        }

        static void Main(string[] args)
        {
            #region 帶返回值的委託
            Example example = new Example();
            MyDelegateString myDelegateString = new MyDelegateString(example.SayHi);
            string message = myDelegateString("Atomy");
            Console.WriteLine(message);
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    3.3 多路廣播委託

    在第二節前曾經提過，委託類繼承於MulticastDelegate，這使委託對象支持多路廣播，即委託對象能夠綁定多個方法。

    下面代碼演示多路廣播委託：

    class Program
    {
        delegate double MyDelegateDouble(double message);

        public class Example
        {
            public double Ordinary(double price)
            {
                double price1 = 0.95 * price;
                Console.WriteLine($"Ordinary price={price1}");
                return price1;
            }

            public double Favourable(double price)
            {
                double price1 = 0.85 * price;
                Console.WriteLine($"Favourable price={price1}");
                return price1;
            }
        }

        static void Main(string[] args)
        {
            #region 多路廣播委託
            Example example = new Example();
            MyDelegateDouble myDelegateDouble = new MyDelegateDouble(example.Ordinary);
            myDelegateDouble += new MyDelegateDouble(example.Favourable);
            Console.WriteLine($"Current Price={myDelegateDouble(100)}");
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    3.4 淺談Observer模式（觀察者模式）

    簡單回顧一下Observer模式，它使用一對多的方式，可讓多個觀察者同時關注同一個事物，並做出不一樣的響應。

    以下例，Manager的底薪爲基本工資的1.5倍，Assistant的底薪爲基本工資的1.2倍。WageManager類的RegisterWorker方法與RemoveWorker方法能夠

用於註冊和註銷觀察者，最後執行Execute方法能夠對多個已註冊的觀察者同時輸入參數。

    下面代碼演示使用非委託方式實現觀察者模式：

    class Program
    {
        #region 非委託觀察者模式
        /// <summary>
        /// 工做者類
        /// </summary>
        public abstract class Worker
        {
            public abstract double GetWages(double basicWages);
        }

        /// <summary>
        /// 管理級類
        /// </summary>
        public class Manager : Worker
        {
            public override double GetWages(double basicWages)
            {
                double totalWages = 1.5 * basicWages;
                Console.WriteLine($"Manager's wages is:{totalWages}");
                return totalWages;
            }
        }

        /// <summary>
        /// 助理級類
        /// </summary>
        public class Assistant : Worker
        {
            public override double GetWages(double basicWages)
            {
                double totalWages = 1.2 * basicWages;
                Console.WriteLine($"Assistant's wages is:{totalWages}");
                return totalWages;
            }
        }

        /// <summary>
        /// 工資管理類
        /// </summary>
        public class WageManager
        {
            IList<Worker> workerList = new List<Worker>();

            public void RegisterWorker(Worker worker)
            {
                workerList.Add(worker);
            }

            public void RemoveWorker(Worker worker)
            {
                workerList.Remove(worker);
            }

            public void Excute(double basicWages)
            {
                if (workerList.Count != 0)
                {
                    foreach (var worker in workerList)
                    {
                        worker.GetWages(basicWages);
                    }
                }
            }
        }
        #endregion

        static void Main(string[] args)
        {
            #region 非委託觀察者模式
            WageManager wageManager = new WageManager();
            //註冊觀察者
            wageManager.RegisterWorker(new Manager());
            wageManager.RegisterWorker(new Assistant());
            //同時輸入底薪3000元，分別進行計算。
            wageManager.Excute(3000);
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    開發Observer模式時若藉助委託，能夠進一步簡化開發過程。因爲委託對象支持多路廣播，因此能夠把Worker類省略。在WageManager類中創建了一個

委託對象wageHandler，經過Attach與Detach方法能夠分別加入及取消委託。若是觀察者想對事物進行監測，只須要加入一個委託對象便可。在第二節提過，

委託的GetInvodationList方法能獲取多路廣播委託列表，在Execute方法中，就是經過多路廣播委託列表去判斷所綁定的委託數量是否爲0。

    下面代碼演示使用委託方式實現觀察者模式：

    class Program
    {
        #region 委託觀察者模式
        public delegate double Handler(double basicWages);

        public class Manager
        {
            public double GetWages(double basicWages)
            {
                double totalWages = 1.5 * basicWages;
                Console.WriteLine($"Manager's wages is:{totalWages}");
                return totalWages;
            }
        }

        public class Assistant
        {
            public double GetWages(double basicWages)
            {
                double totalWages = 1.2 * basicWages;
                Console.WriteLine($"Assistant's wages is:{totalWages}");
                return totalWages;
            }
        }

        public class WageManager
        {
            private Handler wageHandler;

            //加入觀察者
            public void Attach(Handler wageHandler1)
            {
                wageHandler += wageHandler1;
            }

            //刪除觀察者
            public void Detach(Handler wageHandler1)
            {
                wageHandler -= wageHandler1;
            }

            //經過GetInvodationList方法獲取多路廣播委託列表，若是觀察者數量大於0即執行方法。
            public void Execute(double basicWages)
            {
                if (wageHandler != null)
                {
                    if (wageHandler.GetInvocationList().Count() != 0)
                    {
                        wageHandler(basicWages);
                    }
                }
            }
        }
        #endregion

        static void Main(string[] args)
        {
            #region 委託觀察者模式
            WageManager wageManager = new WageManager();
            //加入Manager觀察者
            Manager manager = new Manager();
            Handler managerHandler = new Handler(manager.GetWages);
            wageManager.Attach(managerHandler);

            //加入Assistant觀察者
            Assistant assistant = new Assistant();
            Handler assistantHandler = new Handler(assistant.GetWages);
            wageManager.Attach(assistantHandler);

            //同時加入底薪3000元，分別進行計算
            wageManager.Execute(3000);
            Console.ReadKey();
            #endregion
        }
    }
View Code

    運行結果以下：

    3.5 委託的協變與逆變

    在Framework 2.0出現以前，委託協變這個概念尚未出現。此時由於委託是安全類型，它們不遵照繼承的基礎規則。即會這下面的狀況：Manager雖然

是Worker的子類，但GetWorkerHander委託不能直接綁定GetManager方法，由於在委託當中它們的返回值Manager與Worker被視爲徹底無關的兩個類型。

    自Framework 2.0面世之後，委託協變的概念就應運而生，此時委託能夠按照傳統的繼承規則進行轉換。即GetWorkerHandler委託能夠直接綁定

GetManager方法。

    下面代碼演示委託的協變：

    class Program
    {
        #region 委託的協變
        /// <summary>
        /// 在Framework 2.0以上可綁定GetWorker與GetManager兩個方法
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public delegate Worker GetWorkerHandler(int id);

        public class Worker
        {
            public Worker() { }

            public Worker(int id)
            {
                Id = id;
            }

            public int Id { get; set; }

            public void ShowId()
            {
                Console.WriteLine($"Id={Id}");
            }
        }

        public class Manager : Worker
        {
            public Manager() { }
            public Manager(int id)
            {
                Id = id;
            }
        }

        public static Worker GetWorker(int id)
        {
            Worker worker = new Worker(id);
            return worker;
        }

        public static Manager GetManager(int id)
        {
            Manager manager = new Manager(id);
            return manager;
        }
        #endregion

        static void Main(string[] args)
        {
            #region 委託的協變
            GetWorkerHandler workerHandler = new GetWorkerHandler(GetWorker);
            Worker worker = workerHandler(1);
            worker.ShowId();
            GetWorkerHandler managerHandler = new GetWorkerHandler(GetManager);
            Manager manager = managerHandler(2) as Manager;
            manager.ShowId();
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    委託逆變，是指委託方法的參數一樣能夠接收 「繼承」 這個傳統規則。像下面的例子，以object爲參數的委託，能夠接受任何object子類的對象做爲參數。

最後能夠在處理方法中使用is對輸入數據的類型進行判斷，分別處理對不一樣的類型的對象。

    下面代碼演示委託的逆變：

    class Program
    {
        #region 委託的逆變
        public delegate void Handler(object obj);

        public static void GetMessage(object message)
        {
            if (message is string)
                Console.WriteLine("His name is:" + message.ToString());
            if (message is int)
                Console.WriteLine("His age is:" + message.ToString());
        }
        #endregion

        static void Main(string[] args)
        {
            #region 委託的逆變
            Handler handler = new Handler(GetMessage);
            handler(29);
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    注：委託與其綁定方法的參數必須一至，即當 Handler 所輸入的參數爲 A 類型，其綁定方法 GetMessage 的參數也必須爲 A 類或者 A 的父類 。相反，

當綁定方法的參數爲 A 的子類，系統也沒法辨認。

    3.6 泛型委託

    委託逆變雖然實用，但若是都以object做爲參數，則須要每次都對參數進行類型的判斷，這不由使人感到厭煩。

    爲此，泛型委託應運而生，泛型委託有着委託逆變的優勢，同時利用泛型的特性，可使一個委託綁定多個不一樣類型參數的方法，並且在方法中不須要

使用is進行類型判斷，從而簡化了代碼。

    下面代碼演示泛型委託：

    class Program
    {
        #region 泛型委託
        public delegate void Handler<T>(T obj);

        /// <summary>
        /// 工做者類
        /// </summary>
        public class Worker
        {
            public double Wages { get; set; }
        }

        /// <summary>
        /// 管理級類
        /// </summary>
        public class Manager : Worker
        {
        }

        public static void GetWorkerWages(Worker worker)
        {
            Console.WriteLine("Worker's total wages is:" + worker.Wages);
        }

        public static void GetManagerWages(Manager manager)
        {
            Console.WriteLine("Manager's total wages is:" + manager.Wages);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 泛型委託
            Handler<Worker> workerHander = new Handler<Worker>(GetWorkerWages);
            Worker worker = new Worker
            {
                Wages = 3000
            };
            workerHander(worker);

            Handler<Manager> managerHandler = new Handler<Manager>(GetManagerWages);
            Manager manager = new Manager
            {
                Wages = 4500
            };
            managerHandler(manager);

            Console.ReadKey();
            #endregion
        }
    }
View Code

    運行結果以下：

    4、深刻解析事件

    4.1 事件的由來

    在介紹事件以前你們能夠先看看下面的例子，PriceManager負責對商品價格進行處理，當委託對象GetPriceHandler的返回值大於100元，按8.8折計算，

低於100元按原價計算。

    class Program
    {
        #region 事件的由來
        public delegate double PriceHandler();
        public class PriceManager
        {
            public PriceHandler GetPriceHandler;

            //委託處理，當價格高於100元按8.8折計算，其餘按原價計算。
            public double GetPrice()
            {
                if (GetPriceHandler.GetInvocationList().Count() > 0)
                {
                    if (GetPriceHandler() > 100)
                        return GetPriceHandler() * 0.88;
                    else
                        return GetPriceHandler();
                }
                return -1;
            }
        }
        //書本價格爲98元
        public static double BookPrice()
        {
            return 98.0;
        }
        //計算機價格爲8800元
        public static double ComputerPrice()
        {
            return 8800.0;
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的由來
            PriceManager priceManager = new PriceManager
            {
                //調用priceManager的GetPrice方法獲取價格
                //直接調用委託的Invoke獲取價格，二者進行比較。
                GetPriceHandler = new PriceHandler(ComputerPrice)
            };
            Console.WriteLine(string.Format("GetPrice\n Computer's price is {0}",priceManager.GetPrice()));
            Console.WriteLine(string.Format("Invoke\n Computer's price is {0}",priceManager.GetPriceHandler.Invoke()));
            Console.WriteLine();
            priceManager.GetPriceHandler = new PriceHandler(BookPrice);
            Console.WriteLine(string.Format("GetPrice\n Book's price is {0}",priceManager.GetPrice()));
            Console.WriteLine(string.Format("Invoke\n Book's price is {0}",priceManager.GetPriceHandler.Invoke()));
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    觀察運行的結果，若是把委託對象GetPriceHandler設置爲public，外界能夠直接調用GetPriceHandler.Invoke獲取運行結果而移除了GetPrice方法的處理，

這正是開發人員最不想看到的。

    爲了保證系統的封裝性，開發每每須要把委託對象GetPriceHandler設置爲private，再分別加入AddHandler、RemoveHandler方法對GetPriceHandler委託

對象進行封裝。爲了保存封裝性，不少操做都須要加入AddHandler、RemoveHandler這些類似的方法代碼，這未免使人感到厭煩。

    爲了進一步簡化操做，事件這個概念應運而生。

    4.2 事件的定義

    事件（event）可被視做爲一種特別的委託，它爲委託對象隱式地創建起add_XXX、remove_XXX兩個方法，用做註冊與註銷事件的處理方法，並且事件對

應的變量成員將會被視爲private變量，外界沒法超越事件所在對象直接訪問它們，這使事件具有良好的封裝性，並且免除了add_XXX、remove_XXX等繁瑣

的代碼。

#region 事件的定義
public class EventTest
{
    public delegate void MyDelegate();
    public event MyDelegate MyEvent;
}
#endregion

    使用ILDASM.exe觀察事件成員，系統爲MyEvent事件自動創建add_MyEvent、remove_MyEvent 方法。

    4.3 事件的使用方式

    事件能經過+=和-=兩個方式註冊及註銷對其處理的方法，使用+=與-=操做符的時候，系統會自動調用對應的add_XXX、remove_XXX進行處理。

    值得留意，在PersonManager類的Execute方法中，若是MyEvent綁定的處理方法不爲空，便可使用MyEvent(string)引起事件。但若是在外界的Main方法中

直接使用personManager.MyEvent(string)來引起事件，系統將引起錯誤報告。這正是由於事件具有了良好的封裝性，使外界不能超越事件所在的對象訪問其變

量成員。

    注：在事件所處的對象以外，事件只能出如今+=、-=的左方。

    下面代碼演示事件的使用：

    class Program
    {
        #region 事件的使用
        public delegate void MyDelegate(string name);

        public class PersonManager
        {
            public event MyDelegate MyEvent;

            //執行事件
            public void Execute(string name)
            {
                if (MyEvent != null)
                {
                    MyEvent(name);
                }
            }
        }

        public static void GetName(string name)
        {
            Console.WriteLine("My name is " + name);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的使用
            PersonManager personManager = new PersonManager();
            //綁定事件處理方法
            personManager.MyEvent += new MyDelegate(GetName);
            personManager.Execute("Atomy");
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    4.4 事件處理方法的綁定

    在綁定事件處理方法的時候，事件出如今+=、-= 操做符的左邊，對應的委託對象出如今+=、-= 操做符的右邊。對應以上例子，事件提供了更簡單的綁定方式，

只須要在+=、-= 操做符的右方寫上方法名稱，系統就能自動辯認。

    下面代碼演示事件處理方法的綁定：

    class Program
    {
        #region 事件的使用及方法綁定
        public delegate void MyDelegate(string name);

        public class PersonManager
        {
            public event MyDelegate MyEvent;

            //執行事件
            public void Execute(string name)
            {
                if (MyEvent != null)
                {
                    MyEvent(name);
                }
            }
        }

        public static void GetName(string name)
        {
            Console.WriteLine("My name is " + name);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的使用及方法綁定
            PersonManager personManager = new PersonManager();
            //綁定事件處理方法方式一
            personManager.MyEvent += new MyDelegate(GetName);
            //綁定事件處理方法方式二
            personManager.MyEvent += GetName;
            personManager.Execute("Atomy");
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    若是以爲編寫GetName方法過於麻煩，還可使用匿名方法綁定事件的處理。

    下面代碼演示事件處理方法的匿名方法綁定：

    class Program
    {
        #region 事件的使用
        public delegate void MyDelegate(string name);

        public class PersonManager
        {
            public event MyDelegate MyEvent;

            //執行事件
            public void Execute(string name)
            {
                if (MyEvent != null)
                {
                    MyEvent(name);
                }
            }
        }

        public static void GetName(string name)
        {
            Console.WriteLine("My name is " + name);
        }
        #endregion

        static void Main(string[] args)
        {
            #region 事件的使用及方法綁定
            PersonManager personManager = new PersonManager();
            //綁定事件處理方法方式一
            personManager.MyEvent += new MyDelegate(GetName);
            //綁定事件處理方法方式二
            personManager.MyEvent += GetName;
            //綁定事件處理方法方式三(匿名方法)
            personManager.MyEvent += delegate (string name) { Console.WriteLine("My name is " + name); };
            personManager.Execute("Atomy");
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    4.5 C#控件中的事件

    在C#控件中存在不少的事件，好比Click、TextChanged、SelectIndexChanged等等，不少都是經過EventHandler委託綁定事件的處理方式，EventHandler可說是C#控件中最多見的委託 。

    public delegate void EventHandler (Object sender, EventArgs e)

    EventHandler委託並沒有返回值，sender表明引起事件的控件對象，e表明由該事件生成的數據 。

    下面代碼演示C#控件中的事件綁定：

    public partial class EventTest : Form
    {
        public EventTest()
        {
            InitializeComponent();
        }

        private void EventTest_Load(object sender, EventArgs e)
        {
            btnEvent.Click += new EventHandler(btnEvent_onclick);
        }

        public void btnEvent_onclick(object sender,EventArgs e)
        {
            Button button = (Button)sender;
            MessageBox.Show(button.Text);
        }
    }
View Code

    運行結果以下：

    EventHandler只是EventHandler<TEventArgs>泛型委託的一個簡單例子。事實上，你們能夠利用 EventHandler<TEventArgs> 構造出所須要的委託。

    public delegate void EventHandler<TEventArgs> (Object sender, TEventArgs e)

    在EventHandler<TEventArgs>中，sender表明事件源，e表明派生自EventArgs類的事件參數。開發人員能夠創建派生自EventArgs的類，從中加入須要使用到的事件參數，而後創建

EventHandler<TEventArgs>委託。

    下面的例子中，先創建一個派生自EventArgs的類MyEventArgs做爲事件參數，而後在EventManager中創建事件myEvent , 經過Execute方法能夠激發事件。最後在測試中綁定myEvent

的處理方法ShowMessage，在ShowMessage顯示myEventArgs的事件參數Message。

    class Program
    {
        #region EventArgs派生
        public class MyEventArgs : EventArgs
        {
            private string args;

            public MyEventArgs(string message)
            {
                args = message;
            }

            public string Message
            {
                get { return args; }
                set { args = value; }
            }
        }

        public class EventManager
        {
            public event EventHandler<MyEventArgs> myEvent;

            public void Execute(string message)
            {
                myEvent?.Invoke(this, new MyEventArgs(message));
            }
        }

        public static void ShowMessage(object obj, MyEventArgs e)
        {
            Console.WriteLine(e.Message);
        }
        #endregion

        static void Main(string[] args)
        {
            #region EventArgs派生
            EventManager eventManager = new EventManager();
            eventManager.myEvent += new EventHandler<MyEventArgs>(ShowMessage);
            eventManager.Execute("How are you?");
            Console.Read();
            #endregion
        }
    }
View Code

    運行結果以下：

    4.6 爲用戶控件創建事件

    開發過程當中，每每會出現不少相似的控件與代碼，開發人員能夠經過用戶控件來避免重複的代碼。但每每同一個用戶控件，在不一樣的頁面中須要有不一樣的響應。此時爲用戶控件創建事件，

即可輕鬆地解決此問題。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程