spring boot 中 xml文件中 if test是什么意思 spring.xml作用

转载

码海探险先锋 2024-01-30 01:39:14

文章标签 spring System 自动装配 文章分类 spring boot 后端开发

本偏主要介绍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文件。

spring boot 中 xml文件中 if test是什么意思 spring.xml作用_System

首先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();
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。