spring.xml入門使用及介紹

本偏主要介紹spring的基本使用。

首先創建好maven工程。導入一下jar包

<dependencies>
        <!-- spring 容器包導入 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!-- spring 測試支持包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.9.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <!-- 日誌支持-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.28</version>
        </dependency>

然後創建包、類和測試的xml文件。

首先xml的配置文件及說明

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- spring Context 自動掃描包   context標籤解析類ContextNamespaceHandler springcontext下的spring.hendlers中定義的標籤解析類 -->
    <context:component-scan base-package="com.wsj.spring">
    </context:component-scan>

    <!--
 (1）    id:Bean的唯一標識名。它必須是合法的XMLID，在整個XML文檔中唯一。
（2）、name:用來爲id創建一個或多個別名。它可以是任意的字母符合。多個別名之間用逗號或空格分開。
（3）、class:用來定義類的全限定名（包名＋類名）。只有子類Bean不用定義該屬性。
（4）、parent:子類Bean定義它所引用它的父類Bean。這時前面的class屬性失效。子類Bean會繼承父類Bean的所有屬性，子類Bean也可以覆蓋父類Bean的屬性。注意：子類Bean和父類Bean是同一個Java類。
（5）、abstract（默認爲”false”）：用來定義Bean是否爲抽象Bean。它表示這個Bean將不會被實例化，一般用於父類Bean，因爲父類Bean主要是供子類Bean繼承使用。
（6）、scope:定義Bean是否是作用域。singleton/prototype/session、request，和自定義SCOPE。默認爲：singleton。在BeanFactory作用範圍內，只維護此Bean的一個實例。如果設Prototype（原型）狀態，BeanFactory將爲每次Bean請求創建一個新的Bean實例,不會對實例進行緩存。request和session是web容器自定義的scope。
（7）、lazy-init（默認爲“default”）：用來定義這個Bean是否實現懶初始化。如果爲“true”，它將在BeanFactory啓動時初始化所有的SingletonBean。反之，如果爲“false”,它只在Bean請求時纔開始創建SingletonBean。
（8）、autowire（自動裝配，默認爲“default”）：它定義了Bean的自動裝載方式。
        1、“no”:不使用自動裝配功能。
        2、“byName”:通過Bean的屬性名實現自動裝配。
        3、“byType”:通過Bean的類型實現自動裝配。
        4、“constructor”:類似於byType，但它是用於構造函數的參數的自動組裝。
        5、“autodetect”:通過Bean類的反省機制（introspection）決定是使用“constructor”還是使用“byType”。
（9）、dependency-check（依賴檢查，默認爲“default”）：它用來確保Bean組件通過JavaBean描述的所以依賴關係都得到滿足。在與自動裝配功能一起使用時，它特別有用。
        1、none：不進行依賴檢查。
        2、objects：只做對象間依賴的檢查。
        3、simple：只做原始類型和String類型依賴的檢查
        4、all：對所有類型的依賴進行檢查。它包括了前面的objects和simple。
（10）、depends-on（依賴對象）：這個Bean在初始化時依賴的對象，這個對象會在這個Bean初始化之前創建。
（11）、init-method:用來定義Bean的初始化方法，它會在Bean組裝之後調用。它必須是一個無參數的方法。
（12）、destroy-method：用來定義Bean的銷燬方法，它在BeanFactory關閉時調用。同樣，它也必須是一個無參數的方法。它只能應用於singletonBean。
（13）、factory-method：定義創建該Bean對象的工廠方法。它用於下面的“factory-bean”，表示這個Bean是通過工廠方法創建。此時，“class”屬性失效。
（14）、factory-bean:定義創建該Bean對象的工廠類。如果使用了“factory-bean”則“class”屬性失效。
（15）、autowire-candidate：採用xml格式配置bean時，將<bean/>元素的autowire-candidate屬性設置爲false，這樣容器在查找自動裝配對象時，將不考慮該bean，即它不會被考慮作爲其它bean自動裝配的候選者，但是該bean本身還是可以使用自動裝配來注入其它bean的。    -->

    <!-- 初始化方法，和銷燬前執行的方法 -->
    <bean id="initDestoryTest" class="com.wsj.spring.bean.PropertyClass" init-method="initMehtod" destroy-method="destroyMethod"/>

    <!-- 下面倆個bean定義的類中並無父子繼承關係，使用spring的parent標籤使其變成父子類。其中父類定義爲 abstract 不會被容器實例化-->
    <bean id="parent" class="com.wsj.spring.bean.Parent" abstract="true">
        <property name="username" value="parent name"/>
    </bean>

    <!-- 這裏演示了屬性的注入，和依賴注入 以及spring中bean父子合併 -->
    <bean id="son" class="com.wsj.spring.bean.Son" parent="parent" lazy-init="false" autowire-candidate="false" autowire="byName">
        <!--<property name="username" value="son name"/>  這裏的這個屬性可以用 @Value("18") 代替 -->
        <property name="age" value="18"/>
    </bean>
    <bean id="mySon" class="com.wsj.spring.bean.MySon">
        <!-- 基於屬性注入  可用 @Autowired/@Resource註解替代  -->
        <property name="mySon" ref="son"/>
    </bean>
    <!--lookUp的使用示例 -->
    <bean id="lookUpSayHello" class="com.wsj.spring.bean.LookUpSayHello">
        <!-- 等價於@Lookup(value = "sayHelloB") -->
        <lookup-method name="getSayHello" bean="sayHelloB"></lookup-method>
    </bean>
    <bean id="sayHelloA" class="com.wsj.spring.bean.SayHelloA">
    </bean>
    <bean id="sayHelloB" class="com.wsj.spring.bean.SayHelloB">
    </bean>
    <!-- 使用factoryBean創建實例-->
    <bean id="testFactionBean" class="com.wsj.spring.bean.MyFactoryBean" >
        <meta key="key" value="test"/><!-- spring中的屬性配置 -->
    </bean>
    <bean id="propertyBean" class="com.wsj.spring.bean.PropertyClass" factory-bean="testFactionBean" factory-method="factoryMethod"></bean>
</beans>

下面爲bean的Java類文件及說明

這個是用於後面的循環依賴的測試bean

package com.wsj.spring.bean;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Data
@Service
public class CircularRefB {

    @Value("xxxk")
    private String username;

    @Autowired
    private CircularRefA circularRefA;
}
package com.wsj.spring.bean;

import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

/**
 * 循環依賴問題
 */
@Data
@Service
public class CircularRefA {

    @Value("123")
    private String username;

    @Autowired
    private CircularRefB circularRefB;
}

這段代碼時測試lookup的

package com.wsj.spring.bean;

public interface SayHello {

    public void sayHello();
}

package com.wsj.spring.bean;

public class SayHelloA implements SayHello {

    public void sayHello() {
        System.out.println("A say hello!!s");
    }
}
package com.wsj.spring.bean;

public class SayHelloB implements SayHello {
    public void sayHello() {
        System.out.println("B say hello");
    }
}


package com.wsj.spring.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Lookup;

import javax.annotation.Resource;

public class LookUpSayHello {

    @Resource(name = "sayHelloA")
    SayHello sayHello;

//    @Lookup(value = "sayHelloB")
    public SayHello getSayHello() {
//        return new SayHelloA();
        sayHello.sayHello();
        return sayHello;
    }

    public void sayHello(){
        getSayHello().sayHello();
        sayHello.sayHello();
        System.out.println("LookUpTest.sayHell");
    }

}

這段代碼是用於演示bean實例化完成後初始化方法，和銷燬前執行的方法

package com.wsj.spring.bean;

public class PropertyClass {

    public String initMehtod() {
        System.out.println("=======initMethod========");
        return "";
    }

    public void destroyMethod() {
        System.out.println("=======destroyMethod========");
    }
}

這段代碼是演示spring父子bean繼承，和以來注入的屬性注入，和引用注入

package com.wsj.spring.bean;

import org.springframework.beans.factory.annotation.Value;

public class Son {
    private String username;

//    @Value("18")
    private int age;

    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void initMethod(){
        System.out.println("執行了Son.initMethod方法");
    }
    public void destroyMethod(){
        System.out.println("執行了Son.destroyMethod方法");
    }

    public Son(){
        System.out.println("執行了Son的構造方法");
    }
}


package com.wsj.spring.bean;

public class Parent {
    private String username;

    private int age;

    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.wsj.spring.bean;

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

import javax.annotation.Resource;

public class MySon {

//    @Autowired
//    @Resource
    private Son mySon;

    public void  print(){
        System.out.println("MySon的名字："+mySon.getUsername()+"今年："+mySon.getAge()+"歲了");
    }

    public Son getMySon() {
        return mySon;
    }

    public void setMySon(Son mySon) {
        this.mySon = mySon;
    }
}

下面這段代碼演示的是factory'Bean的xml配置方式的使用

package com.wsj.spring.bean;

import com.wsj.spring.bean.PropertyBean;

public class MyFactoryBean {

    public Object factoryMethod(/*String id,List param*/) {
        System.out.println("=========factoryMethod=========");
        return new PropertyBean();
    }
}
package com.wsj.spring.bean;

import lombok.Data;

@Data
public class PropertyBean {

    private String username;

    private String password;
}

測試代碼這裏我沒有使用spring-test功能，爲了方便後續的調試跟源碼

package com.wsj.spring;

import com.wsj.spring.bean.LookUpSayHello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    public static void main(String[] args) {
        ApplicationContext app=new ClassPathXmlApplicationContext("test.xml");
        LookUpSayHello bean = app.getBean(LookUpSayHello.class);
        bean.sayHello();
    }
}

spring.xml入門使用及介紹

ThreadLocal源碼解析，及使用時需要注意項

SpringBoot多線程定時調度@Scheduled

spring.xml入門使用及介紹

ERROR - #org.jetbrains.idea.maven - com.google.inject.CreationException: Unable to create inje

spring源碼解讀（一）如何下載編譯spring源碼並如何調試中添加註解

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結