spring春天入門


備註

Spring Framework是一個開源的應用程序框架和Java平台的控件容器的反轉。

版本

發布日期
版本4.3.x 2016年6月10日
4.2.x版 2015年7月31日
4.1.x版 2014年9月14日
4.0.x版 二零一三年十二月十二日
3.2.x中 二零一二年十二月一十三日
3.1.X 2011-12-13
3.0.x的 2009-12-17
2.5.X 2007-12-25
2.0.x版本 2006-10-04
1.2.x版本 2005-05-13
1.1.x版本 2004-09-05
1.0.x的 2003-03-24

設置(XML配置)

創建Hello Spring的步驟:

  1. 調查Spring Boot以查看是否更適合您的需求。
  2. 使用正確的依賴項設置項目。建議您使用MavenGradle
  3. 創建一個POJO類,例如Employee.java
  4. 創建一個XML文件,您可以在其中定義類和變量。例如beans.xml
  5. 創建您的主類,例如Customer.java
  6. 包含spring-beans (及其傳遞依賴項!)作為依賴項。

Employee.java

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}
 

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>
 

Customer.java

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}
 

通過示例展示Core Spring功能

描述

這是一個獨立的運行示例,包括/ showcasing:所需的最小依賴項 ,Java 配置 ,註釋和Java配置的Bean聲明 ,構造函數和屬性的依賴注入 ,以及Pre / Post掛鉤。

依賴

類路徑中需要這些依賴項:

  1. 彈簧核心
  2. 春天上下文
  3. 彈簧豆
  4. 春天的AOP
  5. 彈簧表達
  6. 共享記錄

主類

從最後開始,這是我們的Main類,它充當main() 方法的佔位符,它通過指向Configuration類來初始化Application Context並加載展示特定功能所需的所有各種bean。

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}
 

應用配置文件

配置類由@Configuration 註釋,並在初始化的應用程序上下文中用作參數。配置類的類級別的@ComponentScan 註釋指向要掃描的Bean和使用註釋註冊的依賴項的包。最後, @Bean 註釋在配置類中用作bean定義。

package com.stackoverflow.documentation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}
 

註釋的Bean聲明

@Component 註釋用於將POJO劃分為可在組件掃描期間註冊的Spring bean。

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}
 

應用程序配置的Bean聲明

請注意,我們不需要註釋或以其他方式標記我們的POJO,因為bean聲明/定義發生在Application Configuration類文件中。

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}
 

構造函數注入

請注意,@ @Autowired 註釋是在構造函數級別設置的。另請注意,除非通過名稱明確定義,否則將根據 bean 的類型 (在此實例中為BeanToBeInjected )進行默認自動BeanToBeInjected

package com.stackoverflow.documentation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}
 

物業注入

請注意,@ @Autowired 註釋劃分了名稱遵循JavaBeans標準的setter方法。

package com.stackoverflow.documentation;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}
 

PostConstruct / PreDestroy掛鉤

我們可以通過@PostConstruct@PreDestroy 鉤子攔截Bean的初始化和銷毀。

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}
 

什麼是Spring Framework,我們為什麼要這樣做呢?

Spring是一個框架,它提供了一堆類,通過使用它我們不需要在代碼中編寫樣板函數,因此Spring在J2ee上提供了一個抽象層。


例如,簡單JDBC應用程序程序員負責

  1. 加載驅動程序類
  2. 創建連接
  3. 創建語句對象
  4. 處理異常
  5. 創建查詢
  6. 執行查詢
  7. 關閉連接

這被視為樣板代碼,因為每個程序員都編寫相同的代碼。因此,為簡單起見,框架負責樣板邏輯,程序員必須只編寫業務邏輯。因此,通過使用Spring框架,我們可以使用最少的代碼行快速開發項目,沒有任何錯誤,開發成本和時間也減少了。

所以為什麼選擇Spring作為struts就在那裡

Strut是一個框架,它只為web方面提供解決方案,struts本質上是侵入性的。 Spring比struts有很多功能所以我們必須選擇Spring。

  1. Spring本質上是非侵入性的:這意味著您不需要擴展任何類或實現任何類的接口。
  2. Spring是多功能的 :這意味著它可以與項目中的任何現有技術集成。
  3. Spring提供端到端的項目開發:這意味著我們可以開發所有模塊,如業務層,持久層。
  4. Spring 重量輕 :這意味著如果你想在特定的模塊上工作,你不需要學習完整的彈簧,只學習那個特定的模塊(例如Spring Jdbc,Spring DAO)
  5. Spring支持依賴注入
  6. Spring支持多項目開發,例如:核心java應用程序,Web應用程序,分佈式應用程序,企業應用程序
  7. Spring支持面向方面編程以滿足橫切關注。

最後我們可以說Spring是Struts的替代品。但Spring並不是J2EE API的替代品,因為Spring提供的類在內部使用J2EE API類。 Spring是一個龐大的框架,因此它分為幾個模塊。除了Spring Core之外,沒有模塊依賴於另一個模塊。一些重要的模塊是

  1. 春天核心
  2. Spring JDBC
  3. 春天AOP
  4. 春季交易
  5. 春天ORM
  6. Spring MVC