2. 程式人生 > >Spring核心技術學習總結

Spring核心技術學習總結

阿新 • • 發佈：2019-01-02

這段時間，看了一些Spring文件和資料，對其有了一個基本的瞭解。Spring的核心技術由兩大部分組成：IoC和AOP，下面我們就分別對它們進行介紹。
1  IoC技術
1.1  預備知識
     IoC即Inversion of Control（控制反轉）的簡寫，它是一種設計模式，Spring只不過是實現了該模式。IoC是工廠模式的昇華，同時涉及到了反射的概念。所以，在正式介紹IoC之前，首先介紹一下幾個基本的概念及技術：介面、工廠模式、反射。
1.1.1  介面
     作為面向物件的語言，和C++不同的是，JAVA不支援多重繼承，即一個子類只能繼承自一個父類，像Son extends FatherA,FatherB 是錯誤的。於是產生了介面這個概念，即JAVA可以實現多個介面，比如：Son extends FatherA implements FatherB, FatherC是允許的。介面的主要特徵包括：
     A、其中的方法均沒有實體（即只聲名未實現），就這一點而言就相當於abstact class，如：
interface ITF
  {
    void func(int i);
  }
上例中，ITF是一個介面，它僅僅聲明瞭一個方法func，而沒有具體實現它。
     B、一個類欲實現某介面，則必須實現該介面內的所有方法。例如： 字串5
class aclass implements ITF
  {
    public void func (int i)
      {
        //在這裡你可以不作任何處理，但是必須實現該方法
      }
  }
     C、一個類可以實現多個介面。
     D、介面沒有例項變數。
     E、介面中所有變數都必須被定義為final static。
     F、介面可以繼承多個介面。
     以上只是介面的幾個典型特徵，與其相關的內容還有很多，如果您想對其有更深的理解，請訪問其他相關資源。
1.1.2  工廠模式
     工廠模式是最常用的設計模式之一（我對所謂的設計模式沒有仔細研究過，該模式是我看到次數最多的一個，所以才這麼說，呵呵）。今天看了一些例子，覺得工廠模式這個名字起得相當有創意，這是因為在該模式中，"工廠"、"車間"、"原料"、"加工裝置"、"原型產品"、"產品"等概念樣樣俱全。下面，我們在一個經典例子的基礎上，引用上述概念，對工廠模式進行較為形象的解釋。
     現在我們模擬一個火腿（Ham）加工廠，該工廠可以生產若干種類型的Ham，在該廠中，上述概念可依次描述如下：
字串8


A、"原型產品"：即"產品"的模型，該模型定義（但未實現）了各類"產品"必須要具備的功能，各類"產品"對應的"加工裝置"可根據該"產品"的特點實現這些功能。所以，在工廠模式中，"原型產品"可以用一個介面來表示：

Java程式碼 複製程式碼
  1. interface Ham   
  2.   {    
  3. void show();//由Ham"加工裝置"生產出的各種Ham將有show()的功能
  4.   }  
interface Ham
  { 
    void show();//由Ham"加工裝置"生產出的各種Ham將有show()的功能
  }



B、"工廠"：即包含了"車間"、加工所需的"原料"、"加工裝置"、最終加工的"產品"等實體的複合型實體。在工廠模式中，"工廠"可以用一個類來表示，"車間"可以用該類中的函式來表示，"原料"可以用該函式中的實參來表示，最終的"產品"可以用該函式的返回值來表示。在這裡，"車間"遠端呼叫了"加工裝置"（即每種"產品"的建構函式）。下面是"工廠"類的具體實現程式碼：

Java程式碼 複製程式碼
  1. publicclass FatoryModule    
  2. //"工廠"類，用於生產不同種類的Ham
  3.  {    
  4. public Ham getHam(String HamType) throws Exception   
  5. //"工廠"中加工Ham的"車間"；HamType為該"車間"中的"原料"
  6.       {    
  7. if (HamType.equals("HamA"))    
  8.           {   
  9. returnnew HamA();//根據不同的"原料"得到不同的"產品"，下同
  10.           }   
  11. if (HamType.equals("HamB"
    ))    
  12.           {   
  13. returnnew HamB();   
  14.           }   
  15. if (HamType.equals("HamC"))    
  16.           { 字串8
  17. returnnew HamC();   
  18.           }   
  19. else
  20. thrownew Exception();           
  21.       }   
  22. publicstaticvoid main(String[] args)    
  23. //測試函式
  24.       {   
  25.         FatoryModule fatorymodule = new FatoryModule();   
  26. try
  27.  {   
  28.             Ham myHam = fatorymodule.getHam(args[0]);            
  29.             myHam.show();//實際上呼叫的是args[0]所對應某類具體產品的show()
  30.           }    
  31. catch (Exception ex)    
  32.           {   
  33.             ex.printStackTrace();   
  34.           }   
  35.       }   
  36.   }  
public class FatoryModule 
//"工廠"類，用於生產不同種類的Ham
 { 



    public Ham getHam(String HamType) throws Exception
    //"工廠"中加工Ham的"車間"；HamType為該"車間"中的"原料"
      { 
        if (HamType.equals("HamA")) 
          {
            return new HamA();//根據不同的"原料"得到不同的"產品"，下同
          }
        if (HamType.equals("HamB")) 
          {
            return new HamB();
          }
        if (HamType.equals("HamC")) 
          { 字串8 
            return new HamC();
          }
        else
            throw new Exception();        
      }
    public static void main(String[] args) 
    //測試函式
      {
        FatoryModule fatorymodule = new FatoryModule();
        try  
 {
            Ham myHam = fatorymodule.getHam(args[0]);         
            myHam.show();//實際上呼叫的是args[0]所對應某類具體產品的show()
          } 
        catch (Exception ex) 
          {
            ex.printStackTrace();
          }
      }
  }


    
C、"產品"：即"原型產品"的模型實現實體。"車間"根據具體的"原料"呼叫對應的"加工裝置"來實現"原型產品"定義的所有功能，最後得到所需的"產品"。所以，"產品"可以用一個類來表示，具體程式碼如下：

Java程式碼 複製程式碼
  1. class HamA implements Ham    
  2. // "產品"HamA 
  3.   {    
  4. publicvoid show()    
  5.       {   
  6.         System.out.println("You got a HamA.");   
  7.       }   
  8.   }   
  9. class HamB implements Ham    
  10. // "產品"HamB
  11.   {    
  12. publicvoid show()    
  13.       {   
  14.         System.out.println("You got a HamB.");   
  15.       }   
  16.   }   
  17. class HamC implements Ham    
  18. // "產品"HamC
  19.   {    
  20. publicvoid show()    
  21.       {   
  22.         System.out.println("You got a HamC.");   
  23.       }   
  24.   }  
class HamA implements Ham 
// "產品"HamA 
  { 
    public void show() 
      {
        System.out.println("You got a HamA.");
      }
  }
class HamB implements Ham 
// "產品"HamB
  { 
    public void show() 
      {
        System.out.println("You got a HamB.");
      }
  }
class HamC implements Ham 
// "產品"HamC
  { 
    public void show() 
      {
        System.out.println("You got a HamC.");
      }
  }

   

小結：總體感覺工廠模式是介面的典型應用。該模式最大特點是方便我們"加工"指定引數條件下的產品。以上述情況為例，假如我們不採用該模式的話，要得到一種產品就必須new一個該產品類的例項，而且在程式中不同產品類的例項變數不能採用同一個變數名。假如有一天我們想更換某一類產品的名字，考慮到程式的可讀性，該類產品的例項變數名也需要修改，這個工作量也需會很大（所有涉及到該變數名的地方都需要修改）。從這一點來講，工廠模式能夠減輕我們程式碼維護量。

1.1.3  反射（主要應用於Spring的四種Bean封裝機制中的Bean Wrapper機制）
     反射是java的一種非常有趣且有用的特徵，而且也是Java被視為動態（或準動態）語言的一個非常關鍵的性質。該機制允許java程式在執行時通過Reflection APIs（java.lang.reflect.*）取得任何一個已知名稱的class的內部資訊，包括其modifiers（諸如public, static 等等）、superclass（如Object等）、所實現的interfaces（如Cloneable等），以及fields和methods的所有資訊，並可在程式執行時改變fields的內容或喚起methods。其實，反射的最重要作用就是允許我們通過類（方法）名呼叫類（方法）。
     更具體的內容請看候捷先生的文章："Java反射機制"，具體網址為：http://www.j2medev.com/Article/Class3/Class7/200604/1995.html。如果您想在短時間內對java的反射機制有一個大體的瞭解，請看一個網友的一篇部落格："java的reflect機制（反射）"，網址為：http://jackleliu.spaces.live.com/blog/cns!426307897fa1054e!125.entry。



1.2  正式進入IoC
     IoC實際上是一個高層次的概念，是一種思想或者設計模式，Spring等J2EE框架或者技術只不過是該思想的實現產品。簡單的來講，IoC要求我們利用容器，而不是我們自己編寫的程式碼去控制系統中應用程式之間的關係。即對應用程式之間的關係由原來的手工編碼控制轉換為利用容器控制。所以，我們把這種思想叫做控制反轉（IoC）。
     IoC有多種實現方法，其中，Spring是通過一種名為DI（Dependency Injection，即依賴注入）的方法實現的。用夏昕先生的話來講，"所謂依賴注入，即元件之間的依賴關係由容器在執行期決定，形象的來說，即由容器動態的將某種依賴關係注入到元件之中。"在Spring中，上面所說的容器一般是一種配置檔案（.Xml等型別的檔案）。
     通過使用DI，當元件之間關係發生變化時，我們只需要修改系統中相關的配置檔案，不需要改動我們的程式碼，這既減少了我們的程式維護量，又提高了我們程式的可重用性。
     DI主要有三種實現方式：介面注入、設值注入、構造子注入，下面分別加以介紹：
1.2.1   介面注入
     該方式利用介面將呼叫元件和實現元件相分離。請看下面的程式碼：

Java程式碼 複製程式碼
  1. publicclass ClassA    
  2.   {   
  3. private InterfaceB clzB;   
  4. public Object doSomething(InterfaceB b)    
  5.       {   
  6.         clzB = b;   
  7. return clzB.doIt();   
  8.       }   
  9.     ………   
  10.   }  
public class ClassA 
  {
    private InterfaceB clzB;
    public Object doSomething(InterfaceB b) 
      {
        clzB = b;
        return clzB.doIt();
      }
    ………
  }

   
上面的實參b的值由容器（spring中的相關配置檔案）定義，並在執行期間由該容器提供。相關配置檔案的內容我們以後會專門加以介紹。
1.2.2   設值注入
     設值注入是spring中應用最廣泛的DI模式，與其它模式相比，該模式更為直觀、自然。該模式主要通過類的setter方法來完成依賴關係的設定。請看下面的程式碼：

Java程式碼 複製程式碼
  1. publicclass DIByConstructor    
  2.   {   
  3. privatefinal DataSource dataSource;   
  4. privatefinal String message;   
  5.     ………   
  6. public setDataSource(DataSource ds)    
  7.       {   
  8. this.dataSource = ds;   
  9.       }   
  10. public setmessage(String msg)    
  11.       {   
  12. this.message = msg;   
  13.       }   
  14. public getDataSource()    
  15.       {   
  16. returnthis.dataSource;   
  17.       }    
  18. public getmessage()   
  19.       {   
  20. returnthis.message;   
  21.       }   
  22.     ………   
  23.   }  
public class DIByConstructor 
  {
    private final DataSource dataSource;
    private final String message;
    ………
    public setDataSource(DataSource ds) 
      {
        this.dataSource = ds;
      }
    public setmessage(String msg) 
      {
        this.message = msg;
      }
    public getDataSource() 
      {
        return this.dataSource;
      } 
    public getmessage()
      {
        return this.message;
      }
    ………
  }

   

上面的實參ds和msg的值由容器（spring中的相關配置檔案）定義，並在執行期間由該容器提供。相關配置檔案的內容我們以後會專門加以介紹。
1.2.3   構造子注入
     構造子注入，即通過建構函式完成依賴關係的設定，請看下面的程式碼：

Java程式碼 複製程式碼
  1. publicclass DIByConstructor    
  2.   {   
  3. privatefinal DataSource dataSource;   
  4. privatefinal String message;   
  5. public DIByConstructor(DataSource ds, String msg)    
  6.       {   
  7. this.dataSource = ds;   
  8. this.message = msg;   
  9.       }   
  10.   }  
public class DIByConstructor 
  {
    private final DataSource dataSource;
    private final String message;
    public DIByConstructor(DataSource ds, String msg) 
      {
        this.dataSource = ds;
        this.message = msg;
      }
   
  }

   

可以看到，在該模式中，依賴關係是通過類建構函式建立的，容器通過呼叫類的構造方法，將其所需的依賴關係注入其中。其中，建構函式的實參ds和msg的值由容器（spring中的相關配置檔案）定義，並在執行期間由該容器提供。相關配置檔案的內容我們以後會專門加以介紹。
1.2.4   幾種注入模式的比較
     個人覺得，這部分屬於理論研究的範疇，所以在此不予介紹。如果您對此感興趣的話，請參考相關資料。
2  AOP技術
2.1  AOP基本概念
     AOP（Aspect-Oriented Programming，面向切面程式設計）是一種程式設計思想，該思想的主要目標是將系統分為兩部分：一部分封裝了系統中各元件的通用功能（羅輯或者責任），形成一個切面，該切面被稱為應用系統的"橫切關注點"，此部分包含了與系統核心商業邏輯關係不大的部分；系統的其餘部分，即核心商業邏輯部分，被稱為系統的"核心關注點"，此部分包含了系統中業務處理的主要流程。其中，"橫切關注點"經常出現在"核心關注點"的周圍，但無論出現在何處，它們的基本功能是相似的，比如許可權認證、日誌、事務處理等。應用中採用這種思想的好處在於：一方面可以使我們在系統開發過程中的責任分工更為明確（比如，可以讓高階工程師負責"橫切關注點"的開發，初級工程師負責"核心關注點"的開發，配置工程師負責將以上兩部分搭建成一個完整的應用系統）；另一方面，清晰的系統結構將使我們以後的系統維護工作變得更為輕鬆。
字串3

     下面是AOP的幾個基本概念（理解它們極為重要）：
2.1.1  Join point（連線點）：是程式執行中的一個精確執行點，例如類中的一個方法。它是一個抽象的概念，在實現AOP時，並不需要去定義一個Join point。
2.1.2  Point cut（切入點）：本質上是一個捕獲連線點的結構（或稱連線點的集合）。在AOP中，可以定義一個Point cut，來捕獲相關方法（通知中的邏輯）的呼叫。
2.1.3  Advice（通知）：Point cut的執行程式碼，它是執行"切面"的具體邏輯。
2.1.4  Aspect（切面）：Point cut和Advice的組合，它類似於OOP中定義的一個類，但它代表的更多的是物件間橫向的關係。
2.1.5  Introduce（引入）：為物件引入附加的方法或屬性，從而達到修改物件結構的目的（此概念不是很理解）。
2.1.6  Target Object(目標物件)：包含Join point的物件，它是被Advice的類，也是商務邏輯物件。這個物件永遠是一個被代理的物件。
2.1.7  AOP Proxy(AOP代理)：由AOP框架建立的物件，它是真正執行Advice的實體。
2.1.8  Weaving(織入)：將Aspec模組與核心商務邏輯（即目標物件）進行關聯的過程，比如，將事務處理模組和銀行櫃員機程式通過配置結合起來，決定什麼情況下事務處理模組被通知呼叫。 字串3
2.2  AOP  in  Spring2.0應用程式開發基本步驟
     在2.0版本以前，Spring所提供的內建AOP支援是基於Java Dynamic Proxy和CGLib實現的，是一種動態的AOP機制。Spring 2.0版本之後，AOP的使用變得更簡單，同時功能也更為強大。通過與AspectJ 5的整合, Spring 2.0提供了更完整的AOP。在Spring 2.0中，AOP主要有三種實現方式：基於AspectJ語言的實現方式；基於模式（schema-based）的實現方式；基於 Dynamic Proxy和CGLib（即同以前版本的Spring是相容的）的實現方式。
     下面是一個用Spring2.0的AOP所做的一個例子，該例採用了上面所說的第一種實現方式。限於篇幅，有關AspectJ方面的內容這裡不再敘述，您可以參考相關的資料以對其有一個基本的瞭解。另外，可以通過MyEclipse最新版本實現該例，該版本提供了對Spring2.0的全面支援。
Step1  首先建立一個普通的Java專案：com.longthsoft.learn.spring
Step2  然後編寫兩個簡單的類，程式碼如下：

Java程式碼 複製程式碼
  1. package com.longthsoft.learn.spring.models;      
  2. publicclass A //"目標物件"A，AOP框架將自動為該物件建立一個"代理物件"
  3.   {      
  4. publicvoid sayHello()    
  5.       {      
  6.         System.out.println("Hello, I'm a");      
  7.       }      
  8.   };  
package com.longthsoft.learn.spring.models;   
public class A //"目標物件"A，AOP框架將自動為該物件建立一個"代理物件"
  {   
    public void sayHello() 
      {   
        System.out.println("Hello, I'm a");   
      }   
  };
Java程式碼 複製程式碼
  1. package com.longthsoft.learn.spring.models;      
  2. publicclass B //"目標物件"B，AOP框架將自動為該物件建立一個"代理物件"
  3.   {      
  4. publicvoid sayHi()    
  5.       {      
  6.         System.out.println("Hi, I'm b");    字串1
  7.       }      
  8.   }     
package com.longthsoft.learn.spring.models;   
public class B //"目標物件"B，AOP框架將自動為該物件建立一個"代理物件"
  {   
    public void sayHi() 
      {   
        System.out.println("Hi, I'm b");    字串1 
      }   
  }



Step3  接下來編寫AOP中的"切面"類，程式碼如下：

Java程式碼 複製程式碼
  1. package com.longthsoft.learn.spring;      
  2. import org.aspectj.lang.annotation.AfterReturning;      
  3. import org.aspectj.lang.annotation.Aspect;      
  4. import org.aspectj.lang.annotation.Pointcut;      
  5. @Aspect//利用AspectJ語法建立一個"切面"
  6. publicclass SimpleAspect    
  7.   {      
  8. @Pointcut("execution(* com.longthsoft.learn.spring.models.*.say*())")     
  9. //建立"切入點"，該"切入點"捕獲了指定專案中相關類的方法（"連線點"） 
  10. publicvoid simplePointcut() { }      
  11. @AfterReturning(pointcut="simplePointcut()")       
  12. 字串4
  13. //建立"通知"，該"通知"綁定了具體的"切入點"
  14. publicvoid simpleAdvice() //"切入點"的執行程式碼，將被"目標物件"的"代理物件"執行
  15.       {      
  16.         System.out.println("Merry Christmas");      
  17.       }      
  18.   }     
package com.longthsoft.learn.spring;   

import org.aspectj.lang.annotation.AfterReturning;   
import org.aspectj.lang.annotation.Aspect;   
import org.aspectj.lang.annotation.Pointcut;   

@Aspect  //利用AspectJ語法建立一個"切面"
public class SimpleAspect 
  {   
    @Pointcut("execution(* com.longthsoft.learn.spring.models.*.say*())")  
    //建立"切入點"，該"切入點"捕獲了指定專案中相關類的方法（"連線點"） 
    public void simplePointcut() { }   
       
    @AfterReturning(pointcut="simplePointcut()")    
字串4

    //建立"通知"，該"通知"綁定了具體的"切入點"
    public void simpleAdvice() //"切入點"的執行程式碼，將被"目標物件"的"代理物件"執行
      {   
        System.out.println("Merry Christmas");   
      }   
  }

   

Step4  編寫配置檔案（applicationContext.xml），內容如下：

Java程式碼 複製程式碼
  1. <?xml version="1.0" encoding="GBK"?>   
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xmlns:aop="http://www.springframework.org/schema/aop"
  5.          xmlns:tx="http://www.springframework.org/schema/tx"
  6.          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  7.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
  8.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"> 
  9.     <aop:aspectj-autoproxy /> //織入"目標物件"和"切面"之間的關聯關係 
  10.     <bean id="a"class="com.longthsoft.learn.spring.models.A" />     
  11.     <bean id="b"class="com.longthsoft.learn.spring.models.B" />    
  12.     <bean id="simpleAspect"class="com.longthsoft.learn.spring.SimpleAspect" />     
  13. </beans>   
<?xml version="1.0" encoding="GBK"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	     xmlns:aop="http://www.springframework.org/schema/aop"
	     xmlns:tx="http://www.springframework.org/schema/tx"
	     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd"> 
    
    <aop:aspectj-autoproxy /> //織入"目標物件"和"切面"之間的關聯關係 
  
    <bean id="a" class="com.longthsoft.learn.spring.models.A" />  
    <bean id="b" class="com.longthsoft.learn.spring.models.B" /> 
       
    <bean id="simpleAspect" class="com.longthsoft.learn.spring.SimpleAspect" />  
</beans>


    
Step5  編寫測試程式，程式碼如下：

Java程式碼 複製程式碼
  1. package com.longthsoft.learn.spring;      
  2. import org.springframework.context.ApplicationContext;      
  3. import org.springframework.context.support.ClassPathXmlApplicationContext;      
  4. import com.longthsoft.learn.spring.models.A;      
  5. import com.longthsoft.learn.spring.models.B;      
  6. publicfinalclass Boot   
  7.   {      
  8. publicstaticvoid main(String[] args)   
  9.       {      
  10.         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");    
  11.         A a = (A) ctx.getBean("a");      
  12.         a.sayHello();      
  13.         B b = (B) ctx.getBean("b");      
  14.         b.sayHi();      
  15.       }      
  16.   }    
package com.longthsoft.learn.spring;   
  
import org.springframework.context.ApplicationContext;   
import org.springframework.context.support.ClassPathXmlApplicationContext;   
  
import com.longthsoft.learn.spring.models.A;   
import com.longthsoft.learn.spring.models.B;   
  
public final class Boot
  {   
    public static void main(String[] args)
      {   
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
        A a = (A) ctx.getBean("a");   
        a.sayHello();   
           
        B b = (B) ctx.getBean("b");   
        b.sayHi();   
      }   
  }

    

最後執行結果如下：
Hello, I'm a
Merry Christmas
Hi, I'm b
Merry Christmas

3  引用資源
3.1  候捷 《Java反射機制》
3.2  夏昕 《Spring開發指南 V0.8》
3.3  佚名 《AOP技術介紹－－（AOP技術基礎）》

相關推薦

Spring核心技術學習總結

這段時間，看了一些Spring文件和資料，對其有了一個基本的瞭解。Spring的核心技術由兩大部分組成：IoC和AOP，下面我們就分別對它們進行介紹。 1  IoC技術 1.1  預備知識      IoC即Inversion of Control（控制反轉）的簡寫，它是一種

Java核心技術學習筆記-繼承

java 繼承按照我們中文通俗的理解是不需要付出努力，就獲得別人的能力或資產，比如繼承父輩的家產，繼承父輩的表達能力，繼承父輩的外貌等等。在類裏面的繼承，可以理解不需要重新開發代碼，就能復用父類的方法和域。 在繼承關系裏面，可以分為父類和子類，子類繼承父類，那子類就有了跟父類一樣對外的方法

java多線程編程核心技術——全書總結

結束 遺憾 nbsp 可能 找到 真的 感慨 總結 是你 這本書大致上是看完了，不過第七章結束的匆匆忙忙很不好。 不過好在還是看完了，勉強算吧。 回想這一年，挺感慨的，心裏一直謀求著進步，卻很難行動起來。 仔細想想確實啊，想一直進步肯定要犧牲自己的業余時間，雖然一點也不排斥

2017年度個人技術學習總結

個人學習總結 2017年馬上就過去了，記得年初的時候對2017年的技術學習規劃還歷歷在目，當時定下的年度目標是通過報一個學習課程系統的學習和掌握Linux技術，從而為Openstack雲計算打好基礎，最終通過比較和篩選，我選擇了51CTO網絡學院的馬哥教育Linux系統架構師培訓課程。 馬哥課程的邏輯思路、概

技術學習總結

線性布局 接下來 並且 總結 應用 實現 ext size 界面 技術學習總結 我們小組開發的項目為“任務助手”App，在團隊中，我主要是負責界面設計與美化。在今天，我綜合考慮了我們的項目所涉及的界面，對接下來的幾天做出了一個初步的設計規劃，同時，我也對App界面設

【Java】 Spring 框架初步學習總結（一）簡單實現 IoC 和 AOP

1.0 其中 表示 只需要 第一篇 否則 info fin pojo 　　Spring 是一個開源的設計層面的輕量級框架，Spring 的好處網上有太多，這裏就不在贅述。 　　IoC 控制反轉和 AOP 面向切面編程是 Spring 的兩個重要特性。 　　IoC（Inver

JavaScript核心技術學習筆記（1）——DOM基礎

無法 strong 元素節點 tor cli val 獲取元素 是什麽 標準 DOM基礎 一、DOM是什麽 　　Document object Model，文檔對象模型，是由W3C定義的一個標準。簡單來說，DOM裏面有很多方法，我們通過它提供的方法來操作一個頁面中的某個元素

JavaScript核心技術學習筆記（2）——DOM基礎（2）

轉換 替換元素 沒有 ack true html中 事件 想要 dom基礎 DOM基礎（2） 一、插入元素 上一篇文章中我們學會了如何創建元素，但僅僅是創建一個元素而沒有插入到HTML中，這是沒有意義的。插入元素有以下兩種方法： ? appendChild() ? inse

JavaScript核心技術學習筆記（4）——事件基礎

() block 發生 UNC spa on() strong 1.2 type 事件基礎 一、事件 事件是什麽？ 舉個例子，我們在點擊一個按鈕時，會彈出一個對話框。其中，“點擊”就是一個事件，“彈出對話框”就是我們在點擊這個事件後發生的動作。 在JS中，一個事件應該有三個

JAVA核心技術筆記總結--第6章 抽象類、接口、內部類和Lambda表達式

重載方法 lam 類變量 cat 而在 訪問 負責 3.4 第一次 6.1 抽象類 抽象類是指定義時有 abstract 修飾的類，例如： public abstract class Person{ ... public abstract String getD

JAVA核心技術筆記總結--第5章 繼承

指定 方法重載 阻止 決定 基礎 驗證 cep 兩個類 屏蔽 第五章 繼承 繼承是指基於已有的類構造一個新類，繼承已有類就是復用（繼承）這些類的成員變量和方法。並在此基礎上，添加新的成員變量和方法，以滿足新的需求。java不支持多繼承。 5.1 類、超類和子類 5.1.1

OPC技術學習總結

1. 什麼是OPC 1.1 名詞解釋 Ø  OPC——OLE for Process Contrl，微軟公司物件連結和嵌入技術在過程控制方面的應用，是一系列介面、方法和屬性的標準集。它基於OLE、COM、DCOM技術、XML，採用客戶端/伺服器（Client/S

spring data jpa——學習總結

JPA Spring Data 概述 JPA Spring Data : 致力於減少資料訪問層 (DAO) 的開發量. 開發者唯一要做的，就只是宣告持久層的介面，其他都交給 Spring Data JPA 來幫你完成！ 框架怎麼可能代替開發者實現業務邏輯呢？比如：當有一個 Us

java技術學習總結：過濾器鏈的實現方法、配置和案例分析

今天給大家分享的是Java技術學習總結：過濾器鏈的實現方法、配置和案例分析。 過濾器能夠對網站中的各種內容進行過濾（頁面、Servlet、圖片、檔案），可以在網站內容請求和響應時進行一些操作，完成一些通用的功能。 過濾器鏈 在專案中可以建立多個過濾器，網站內容可能會經過多個過濾器，多個過

Spring核心技術面向切面程式設計AOP

這種在執行時，動態地將程式碼切入到類的指定方法、指定位置上的程式設計思想就是面向切面的程式設計。 個人理解就是動態代理，舉例：web中的攔截器就是個典型動態代理。 面向切面程式設計（AOP是Aspect Oriented Program的首字母縮寫） ，

深入理解Spring核心技術---Spring中的依賴注入

         在前面的幾篇部落格中給大家介紹了Spring中的IOC容器，現在大家應該都知道IOC容器的概念和實現的原理了吧，IOC容器是Spring的核心，他的功能就是幫助開發者去儲存物件以及管理物件之間的關係。不用讓開發者自己去管理物件之間的關係，使開發者只需要專注於

Spring IO Platform學習總結

1:Spring IO Platform Spring IO Plat是一個附帶包，不會編譯到專案中，它只是將核心Spring API框架內聚整合到一個現代應用程式的平臺中。它提供了已經測試完畢能很好協同工作的許多專案的Spring組合版本以及它們的依賴項。你

java核心技術-（總結自楊曉峰-java核心技術36講）

1. 談談你對java平臺的理解 首先是java最顯著的兩個特性，一次寫入處處執行；還有垃圾收集器gc，gc能夠對java記憶體進行管理回收，程式設計師不需要關心記憶體的分配和回收問題 然後談談jre和jdk的區別，jre包含了jvm和java類庫；jdk除了jvm和java類庫，還包含了一些ja

Java 核心技術學習筆記_卷1_（第9版） 基礎知識 002（實踐出真知）

第 1 章 Java程式設計概述 1. Java語言特性 （1）簡單性         1）語法上拋棄了C++很多晦澀的特性         2）基本直譯器及相關類支援僅需要40KB ; 增加基礎的標準類庫和對執行緒的支援，需要增加175KB （2）面向物件

java多執行緒程式設計核心技術學習-1

實現多執行緒的兩種方式 繼承Thread類，重寫Thread類中的run方法 public class MyThread extends Thread{ @Override public void run(){ super.run();