Spring的xml配置文件中bean通过无参(默认的、自定义的)、有参构造器完成对象初始化（涉及抽象、字符转义、成员变量为对象时：内部bean、ref）
Spring容器完成TestDemo01类对象的创建
方式：通过bean文件配置TestDemo01相关内容
对象初始化：使用无参构造器（配置TestDemo01相关内容无涉及，默认无参构造）
bean作用域：单例（配置相关内容无涉及，默认单例）
是否抽象bean: 否（配置相关内容配置，默认不是抽象bean）
对应配置文件内容：bean-springioc01.xml-> id 为TestDemo010_id的bean
package ss.java.springioc01;
/**
* @author XYang
* @date 2020-06-29 22:10
*/
public class TestDemo01 {
public int a;
public TestDemo01() {
System.out.println("无参构造器被调用");
}
public TestDemo01(String a) {
System.out.println("有参构造器被调用");
}
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public void testFunction(){
System.out.println("a:"+this.getA());
System.out.println("通过该类对象调用了此方法");
}
}
小结：
1.Spring容器完成TestDemo01类对象的创建,为xml文件所有非抽象的单例的bean创建对象（包括内部bean）
2.抽象bean不能够实例化（不能够创建对象）
抽象bean定义 abstract=“true”
抽象bean 可以不需要具体类 不写class=“XX”
3.bean中无成员变量赋值时，则使用的自定义的无参（默认的）构造器
Spring容器完成TestDemo02类对象的创建
方式：通过bean文件配置TestDemo02相关内容
对象初始化：使用自定义有参构造器
bean作用域：单例（配置相关内容无涉及，默认单例）
是否抽象bean: 否（配置相关内容配置，默认不是抽象bean）
对应配置文件内容：bean-springioc01.xml-> id 为TestDemo020_id、TestDemo021_id、TestDemo022_id、 TestDemo023_id、TestDemo024_id的bean
package ss.java.springioc01;
/**
* @author XYang
* @date 2020-06-29 23:01
*/
public class TestDemo02 {
//规范要求，写了有参就必须加上无参构造器，不然容易在某些地方报错
public TestDemo02() {
}
public TestDemo02(int a, String b, boolean c, float d) {
this.a = a;
this.b = b;
this.c = c;
this.d = d;
}
public TestDemo02(int a, String b, boolean c, int e) {
this.a = a;
this.b = b;
this.c = c;
this.e = e;
}
public TestDemo02(int a, String b) {
this.a = a;
this.b = b;
}
public TestDemo02(String b) {
this.b = b;
}
public int a;
public String b;
public boolean c;
public float d;
public int e;
@Override
public String toString() {
return "TestDemo02{" +
"a=" + a +
", b='" + b + '\'' +
", c=" + c +
", d=" + d +
", e=" + e +
'}';
}
public String getB() {
return b;
}
public void setA(int a) {
this.a = a;
}
public void setB(String b) {
this.b = b;
}
}
小结：
1.通过有参构造器给类TestDemo02 成员变量赋值
若多个有参构造器时，bean配置中的配置参数个数、参数类型甄别选择哪个构造器
bean配置中 index=“X” 对应构造器入参中第 X+1 个参数
无index=“X” 排序时，跟着构造器的参数入参顺序来
构造器参数中其个数相等、对应每一位类型都相同时直接报错
bean中按照构造器给成员变量赋值，匹配不到构造器时报错
（每个构造器都必须有一个独一无二的参数类型列表）
2.初始化对象属性时，有自定义有参构造器时，bean中必须使用构造器赋值，不然报错
3.bean配置中可以加上 name type，进行参数判断进而甄别选择哪个构造器
index=“1” value=“你好” type=“java.lang.String”
4.bean配置中特殊字符的赋值：<,>,!,&之类的，这时候需要转义字符或者解析函数 来解析，避免报错
Spring容器完成TestDemo03类对象的创建
方式：通过bean文件配置TestDemo03相关内容
对象初始化：成员变量通过set方法赋值
bean作用域：单例（配置相关内容无涉及，默认单例）
是否抽象bean: 否（配置相关内容配置，默认不是抽象bean）
对应配置文件内容：bean-springioc01.xml-> id 为TestDemo030_id、TestDemo031_id 的bean
package ss.java.springioc01;
/**
* @author XYang
* @date 2020-06-30 01:07
*/
public class TestDemo03 {
public int n;
public TestDemo02 testDemo020;
public TestDemo02 testDemo021;
public TestDemo01 testDemo01;
public String m;
public void setN(int n) {
this.n = n;
}
public void setM(String m) {
this.m = m;
}
public void setTestDemo01(TestDemo01 testDemo01) {
this.testDemo01 = testDemo01;
}
public void setTestDemo020(TestDemo02 testDemo020) {
this.testDemo020 = testDemo020;
}
public void setTestDemo021(TestDemo02 testDemo021) {
this.testDemo021 = testDemo021;
}
@Override
public String toString() {
return "TestDemo03{" +
"n=" + n +
", testDemo021=" + testDemo020 +
", testDemo022=" + testDemo021 +
", testDemo01=" + testDemo01 +
", m='" + m + '\'' +
'}';
}
}
小结：
1.通过调用无参构造器、set方法给类TestDemo03 （部分）成员变量赋值
<property name = "变量名" value = "变量的值"/>2.没有自定义有参构造器时，使用
<property name = "变量名" value = "变量的值"/>（通过无参set方法）来赋值。
3.成员变量类型为其他类时的赋值（成员变量为其他类对象时），***在通过set方法的情况中
方式一 通过ref:
<property name = "其他类的对象名" ref = "其他类的bean的id标识符"/>(抽象bean不能被ref)
方式二 通过內部 bean:
<property name = "其他类的对象名">
<bean class="其他类的路径">
<property name = "其他类变量1" value = "其他类变量的值"/>
<property name = "其他类变量2" value = "其他类变量的值"/>
</bean>
</property>
或者
<property name = "其他类的对象名">
<bean class="其他类的路径">
<constructor-arg index="0" value="自定义构造器第一个参数的值"/>
<constructor-arg index="1" value="自定义构造器第二个参数的值"/>
</bean>
</property>
（內部bean不用根据类是否有自定义有参构造器判定 用set方法、还是构成器 给对象初始化成员变量）
（内部bean中，使用set方法赋值，类中必须调用无参（或者默认的）构造器，当有自定义有参构造器时，必须有自定义的无参构造器，不然报错）
4.当成员变量为其他类对象时，那个类没有重写的toString，则打印对象内容为该类路径+@+hasCode
有则打印其toString方法内容。
5.给一个成员变量赋值 null 或者 bean不涉及该变量名
<property name="变量名"><null/></property>Spring容器完成TestDemo01类对象的创建
方式：通过bean文件配置TestDemo04相关内容
对象初始化：使用自定义有参构造器
bean作用域：单例（配置相关内容无涉及，默认单例）
是否抽象bean: 否（配置相关内容配置，默认不是抽象bean）
对应配置文件内容：bean-springioc02.xml-> id 为TestDemo040_id的bean
package ss.java.springioc01;
/**
* @author XYang
* @date 2020-07-05 22:42
*/
public class TestDemo04 {
public int n;
public TestDemo01 testDemo01;
public TestDemo02 testDemo020;
public TestDemo02 testDemo021;
public TestDemo04(int n, TestDemo01 testDemo01, TestDemo02 testDemo020, TestDemo02 testDemo021) {
this.n = n;
this.testDemo01 = testDemo01;
this.testDemo020 = testDemo020;
this.testDemo021 = testDemo021;
}
@Override
public String toString() {
return "TestDemo04{" +
"n=" + n +
", testDemo01=" + testDemo01 +
", testDemo020=" + testDemo020 +
", testDemo021=" + testDemo021 +
'}';
}
}
小结:
1.成员变量类型为其他类时的赋值（成员变量为其他类对象时），在通过自定义构造器情况中
方式一通过ref
<constructor-arg index="1" ref="其他类的bean的id标识符"/>或者
<constructor-arg index="2">
<ref bean="TestDemo020_id"/>
</constructor-arg>
(抽象bean不能被ref)方式二 通过內部 bean:
<constructor-arg index="3">
<bean class="ss.java.springioc01.TestDemo02">
<property name="参数名" value="参数的值"/>
</bean>
</constructor-arg>
（**內部bean不会被类是否有自定义有参构造器而是否限制通过set方法 给对象初始化成员变量）
主方法:
package ss.java.springioc01;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author XYang
* @date 2020-06-29 22:10
*
* 1.spring容器对于对象的实例化(创建),抽象bean不能被实例化
*
* 2.bean中涉及以构造器完成对象的初始化,甄别选择构造器
*
* 3.Spring利用java反射机制创建这个bean.
*
*/
public class TestMain01 {
public static void main(String[] args) {
// ClassPathXmlApplicationContext是spring ioc容器，是从类路径下去加载spring的配置文件
//创建springioc容器（此时bean作用域为单例的，都已经已经实例化对象（抽象bean除外））
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("ss/configurationfile/springioc/bean-springioc01.xml");
//获取TestDemo01的对象
TestDemo01 testDemo01 = (TestDemo01) classPathXmlApplicationContext.getBean("TestDemo010_id");
// 通过类型去获取bean 需要spring配置文件中，有且只有一个该类型的bean
// 如果有多个，会报异常： qualifying bean of type 'com.neusoft.cd.HelloWorld' available: expected single matching bean but found 2: XXXX
//类TestDemo01的对象testDemo01调用方法
testDemo01.setA(11);
testDemo01.testFunction();
//直接打印对象，会打印出该类路径+@+hasCode（这里说明确实存在该对象，该对象拥有内存地址）
System.out.println(testDemo01);
System.out.println("==========================================================");
//报错，抽象bean不能够实例化（继而不能够获取对象）
//TestDemo01 testDemo02 = (TestDemo01) classPathXmlApplicationContext.getBean("TestDemo011_id");
//这里testDemo020是获取 类中第2个构造器完成初始化的对象，入参为 int, String, boolean,float
TestDemo02 testDemo020 = (TestDemo02) classPathXmlApplicationContext.getBean("TestDemo020_id");
//TestDemo02中重写了 直接打印对象 的方法，使其打印出成员变量的值
System.out.println("构造器入参为 int, String, boolean,float");
System.out.println(testDemo020);
System.out.println("-----------------------------------------------------------");
//这里testDemo021是获取 类中第3个构造器完成初始化的对象,入参为 int, String, boolean, int
TestDemo02 testDemo021 = (TestDemo02) classPathXmlApplicationContext.getBean("TestDemo021_id");
System.out.println("构造器入参为 int, String, boolean, int");
System.out.println(testDemo021);
System.out.println("-----------------------------------------------------------");
//这里testDemo022是获取 类中第4个构造器完成初始化的对象，入参为 int, String
TestDemo02 testDemo022 = (TestDemo02) classPathXmlApplicationContext.getBean("TestDemo022_id");
System.out.println("构造器入参为 int, String");
System.out.println(testDemo022);
System.out.println("-----------------------------------------------------------");
//这个bean配置中加了name、type甄别选择了第2个构造器
TestDemo02 testDemo023 = (TestDemo02) classPathXmlApplicationContext.getBean("TestDemo023_id");
System.out.println("name、type甄别选择了第2个构造器");
System.out.println(testDemo023);
System.out.println("============================================================");
//这里testDemo024是获取 类中第5个构造器完成初始化的对象，入参为 String
TestDemo02 testDemo024 = (TestDemo02) classPathXmlApplicationContext.getBean("TestDemo024_id");
System.out.println("特殊字符赋值,使用转义字符或解析函数 ");
System.out.println(testDemo024.getB());
System.out.println("============================================================");
//这里testDemo030是获取创建的初始化的对象
TestDemo03 testDemo030 = (TestDemo03) classPathXmlApplicationContext.getBean("TestDemo030_id");
System.out.println(testDemo030);
System.out.println("-----------------------------------------------------------");
//这里testDemo031是获取创建的初始化的对象
TestDemo03 testDemo031 = (TestDemo03) classPathXmlApplicationContext.getBean("TestDemo031_id");
System.out.println(testDemo031);
System.out.println("-----------------------------------------------------------");
//这里testDemo032是获取创建的初始化的对象
TestDemo03 testDemo032 = (TestDemo03) classPathXmlApplicationContext.getBean("TestDemo032_id");
System.out.println(testDemo032);
System.out.println("============================================================");
TestDemo04 testDemo040 =(TestDemo04) classPathXmlApplicationContext.getBean("TestDemo040_id");
System.out.println(testDemo040);
}
}
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.xsd">
<!--类TestDemo01的相关bean配置内容-->
<bean id="TestDemo010_id" class="ss.java.springioc01.TestDemo01">
<constructor-arg value="111"/>
</bean>
<!--类TestDemo01的相关抽象bean配置内容，默认abstract="false"-->
<bean id="TestDemo011_id" class="ss.java.springioc01.TestDemo01" abstract="true">
</bean>
<!--类TestDemo02的相关bean配置内容-->
<!--bean配置类TestDemo02有参构造器，完成类TestDemo02对象的初始化-->
<bean id="TestDemo020_id" class="ss.java.springioc01.TestDemo02">
<constructor-arg index="0" value="11"/>
<constructor-arg index="1" value="&&&&"/>
<!--在用特殊字符赋值时，需用用转义字符来实现（这里：&&&& 就等于 &&&&）-->
<constructor-arg index="2" value="true"/>
<constructor-arg index="3" value="11.11"/>
</bean>
<bean id="TestDemo021_id" class="ss.java.springioc01.TestDemo02">
<constructor-arg index="0" value="11" />
<constructor-arg index="1" value="你好"/>
<constructor-arg index="3" value="111"/>
<constructor-arg index="2" value="true"/>
</bean>
<bean id="TestDemo022_id" class="ss.java.springioc01.TestDemo02">
<constructor-arg index="0" value="11" />
<constructor-arg index="1" value="你好"/>
</bean>
<!--
无index="X" 排序时，跟着构造器参数入参顺序来
<bean id="TestDemo022_id" class="ss.java.springioc01.TestDemo02">
<constructor-arg value="11" />
<constructor-arg value="你好啊"/>
</bean>
-->
<bean id="TestDemo023_id" class="ss.java.springioc01.TestDemo02">
<constructor-arg index="0" value="11" name="a"/>
<constructor-arg index="1" value="多加了name、type" type="java.lang.String"/>
<constructor-arg index="2" value="true" type="boolean"/>
<constructor-arg index="3" value="11.11" name="d"/>
</bean>
<!--value 若为 &！<s！& 时，使用解析函数 <![CDATA[X]]> -->
<bean id="TestDemo024_id" class="ss.java.springioc01.TestDemo02">
<constructor-arg>
<value><![CDATA[&！<s！&]]></value>
</constructor-arg>
</bean>
<bean id="TestDemo030_id" class="ss.java.springioc01.TestDemo03">
<property name="n" value="11"/>
<property name="m" value="你好啊"/>
</bean>
<!--成员变量为其他类对象时赋值 ref关键字-->
<bean id="TestDemo031_id" class="ss.java.springioc01.TestDemo03">
<property name="n" value="11"/>
<property name="testDemo020" ref="TestDemo024_id"/>
<property name="testDemo01" ref="TestDemo010_id"/>
</bean>
<!--成员变量为其他类对象时赋值 通过內部bean-->
<!--给成员变量赋值null -->
<bean id="TestDemo032_id" class="ss.java.springioc01.TestDemo03">
<property name="n" value="11"/>
<property name="testDemo020">
<bean class="ss.java.springioc01.TestDemo02">
<property name="a" value="111"/>
<property name="b">
<value>
<![CDATA[<&&<!>]]>
</value>
</property>
</bean>
</property>
<property name="testDemo021">
<bean class="ss.java.springioc01.TestDemo02">
<constructor-arg index="0" value="11" name="a"/>
<constructor-arg index="1" value="多加了name、type" type="java.lang.String"/>
</bean>
</property>
<property name="testDemo01">
<bean class="ss.java.springioc01.TestDemo01">
<property name="a" value="1111"/>
</bean>
</property>
<property name="m"><null/></property>
</bean>
<bean id="TestDemo040_id" class="ss.java.springioc01.TestDemo04">
<constructor-arg index="0" value="111"/>
<constructor-arg index="1" ref="TestDemo010_id"/>
<constructor-arg index="2">
<ref bean="TestDemo020_id"/>
</constructor-arg>
<constructor-arg index="3">
<bean class="ss.java.springioc01.TestDemo02">
<property name="a" value="111"/>
<property name="b" value="参数b的值"/>
</bean>
</constructor-arg>
</bean>
</beans>自学不易，内容不妥或用词不准确请多包涵、请自动忽略。
内容有点多，需要的话加Q2396980870，在idea里面好看很多。