本文详细介绍了Spring框架的基础知识，包括Spring的主要作用、优点和体系结构。重点讲解了IoC（控制反转）的概念和实现，通过XML配置文件展示了对象的创建、属性注入，包括set注入、构造注入、引用类型的自动注入，并探讨了基于名称和类型的自动注入策略。此外，还讨论了如何通过多个Spring配置文件来组织项目。
目录
第一章、Spring介绍
1.1 概述
Spring可以解决企业开发的难度，减轻对项目模块之间的管理、类和类之间的管理，帮助开发人员创建对象，管理对象之间的关系。Spring的主要作用就是为代码解耦合，降低代码间的耦合度，就是让对象和对象(模块和模块)之间关系不是使用代码关联，而是通过配置来说明，即在Spring中说明对象(模块)之间的关系。
Spring的核心技术是Ioc和AOP。Spring根据代码的功能特点，使用Ioc降低业务对象之间耦合度。Ioc使得主业务在相互调用过程中，不用再自己维护关系了，即不用再自己创建要使用的对象了，而是由Spring容器统一管理，自动“注入”，注入即赋值。而AOP使得系统级服务得到了最大复用，且不用再由程序员手工将系统级服务“混杂”到主业务逻辑中了，而是由 Spring 容器统一完成“织入”。
什么样的对象放入Spring容器中？
dao类、service类、controller类、工具类。
什么样的对象不放入Spring容器中？
实体类对象(实体类数据是来自于数据库的)、serclet类、listener类、filter类。
1.2 Spring的优点
Spring是一个框架，它是一个容器管理对象，容器内装的是对象，即Spring是存储对象的容器。
其优点：
①轻量：Spring框架使用的jar包都比较下，且Spring框架运行占用的资源少，运行效率高，不
依赖其他jar包。
②针对接口编程，解耦合：Spring提供了ioc控制反转，由容器管理对象和对象的依赖关系。
原本在程序代码中的对象创建方式，现在由容器完成，对象之间的依赖解耦合。
③AOP编程的支持：通过Spring提供的aop功能，方便进行面向切面的编程，许多不容易用传
统OOP实现的功能可以通过aop轻松应付。在Spring中，开发人员可以从繁杂的事务管理代
码中解脱出现，通过声明方式灵活地进行事务的管理，提高开发效率和质量。
④方便集成各种优秀框架：Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框
架(如Mybatis等)的直接支持。
1.3 Spring体系结构
Spring由20多个模块组成，它们可以分为数据访问/集成(Data Access/Integration)、Web、面向切面编程(AOP、Aspects)、提供JVM的代理(Instrumentation)、消息发送(Messaging)、核心容器(Core Container)和测试(Test)。
第二章、IoC控制反转
2.1 介绍
IoC：Inversion of Control，控制反转，是一个概念，是一种思想，指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建、属性赋值、依赖的管理。
控制：创建对象，给对象的属性赋值，对象之间的关系管理。
反转：把原来的开发人员管理、创建对象的权限转移给代码之外的容器实现。由容器代替开
发人员管理对象，创建对象。(正转：由开发人员在代码中，使用new构造方法来创建对象)。
为什么要使用ioc？
目的就是减少对代码的改动，也能实现不同的功能，实现解耦合。
前面学习的课程中关于ioc的体现？
Servlet中就有体现，创建类继承HttpServlet，在web.xml注册servlet，但是我们并没有手动自
己new一个servlet对象，而是由Tomcat服务器创建servlet对象。因此Tomcat服务器也称为容
器，里面存放有Servlet对象、Listener对象、Filter对象。
Spring是一个容器，管理对象、给属性赋值，底层是利用反射来创建对象。
目前学习的java中创建对象的方式：
①new 构造方法
②反射
③序列化
④克隆
⑤动态代理
⑥ioc
ioc能够实现业务对象之间的解耦合，例如service和dao对象之间的解耦合。
2.2 IoC的技术实现
Spring框架使用依赖注入DI实现ioc。
DI：Dependency Injection，依赖注入。指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。Spring的依赖注入对调用者与被调用者几乎没有任何要求，完全支持对象之间依赖关系的管理。
2.3 容器创建对象的第一个例子
实现步骤：
①创建maven项目；
②在pom.xml文件中加入依赖。spring的依赖，版本为5.2.5版本，junit依赖；
③创建类(接口和它的实现类)，和没有使用框架一样，就是普通的类；
④创建spring需要使用的配置文件(一般取名为applicationContext.xml)，声明类的信息，这些
类由spring创建和管理；
⑤测试spring创建的对象。
1.加入依赖：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>2.创建接口和类：
package com.bjpowernode.service;
public interface SomeService {
void doSome();
}public class SomeServiceImpl implements SomeService {
public SomeServiceImpl() {
System.out.println("SomeServiceImpl的无参数构造方法");
}
@Override
public void doSome() {
System.out.println("执行了SomeServiceImpl的doSome()方法");
}
}3.创建spring配置文件：
<?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">
<!--
告诉spring创建对象
声明bean，就是告诉spring要创建某个类的对象
id：对象的自定义名称，唯一值。spring通过这个名称找到对象
class：类的全限定名称(不能是接口，因为spring是反射机制创建对象，必须是类)
spring就完成SomeService someService = new SomeServiceImpl();
spring把创建好的对象放入到map中，spring框架有一个map存放对象的。
springMap.put(id的值,对象);
例如：
springMap.put(someService,new SomeServiceImpl());
一个bean标签申明一个对象。
-->
<bean id="someService" class="com.bjpowernode.service.impl.SomeServiceImpl"/>
<bean id="someService1" class="com.bjpowernode.service.impl.SomeServiceImpl"/>
<!--
spring能创建一个非自定义类的对象吗，创建一个存在的某个类的对象。
-->
<bean id="mydate" class="java.util.Date"/>
</beans>
<!--
spring的配置文件：
1.beans：是根标签，spring把java对象称为bean
2.spring-beans.xsd：是约束文件，和mybatis指定dtd是一样的。
-->4.测试类：
public class MyTest {
@Test
public void test01(){
SomeService someService = new SomeServiceImpl();
someService.doSome();
}
/**
* spring默认创建对象的时间：在创建spring的容器时，会创建配置文件中的所有对象。
* spring创建对象：默认调用的是无参数构造方法
*/
@Test
public void test02(){
//使用spring容器创建的对象
//1.指定spring配置文件的名称
String config = "beans.xml";
//2.创建表示spring容器的对象，ApplicationContext
//ApplicationContext就是表示spring容器，通过容器来获取对象
//ClassPathXmlApplicationContext：表示从类路径中加载spring的配置文件
ApplicationContext ac = new ClassPathXmlApplicationContext(config);//这句话执行时创建出了对象
//从容器中获取某个对象，你要调用对象的方法
//getBean("配置文件中的bean的id的值")
//返回值类型Object，需要类型强转
SomeService someService = (SomeService) ac.getBean("someService");
//使用spring创建好的对象
someService.doSome();
}
/**
* 获取spring容器中java对象的信息
*/
@Test
public void test03(){
String config = "beans.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
//使用spring提供的方法，获取容器中定义的对象的数量
int nums = applicationContext.getBeanDefinitionCount();
System.out.println(nums);
//容器中每个定义的对象的名称
String[] names = applicationContext.getBeanDefinitionNames();
for (String name : names){
System.out.println(name);
}
}
//获取一个非自定义的类对象
@Test
public void test04(){
String config = "beans.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Date date = (Date)ac.getBean("mydate");
System.out.println(date);
}
}ApplicationContext是一个接口，其继承实现关系：
2.4 基于XML的DI实现
bean实例在调用无参构造器创建对象后，就要对bean对象的属性进行初始化，初始化是由容器自动完成的，成为注入。
根据注入方式的不同，常用的有两类：set注入、构造注入
2.4.1 set注入
设值注入，spring调用类的set方法，在set方法中可以实现属性的赋值。
1.简单类型的设值注入：
public class Student {
private String name;
private int age;
public Student() {
System.out.println("spring会调用类的无参数构造方法创建对象");
}
//必须要有set方法，没有set方法是会报错的。
//先执行无参数构造方法，再执行set方法完成属性赋值
public void setName(String name) {
System.out.println("setName = " + name);
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}<?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">
<!--声明student对象
注入：就是赋值的意思
简单类型：spring中规定java的基本数据类型和String都是简单类型。
di：给属性赋值
1.set注入（设值注入）：spring调用类的set方法，你可以在set方法中完成属性赋值
1)简单类型的set注入
<bean id="" class="">
<property name="属性名字" value="此属性的值"/>
一个property只能给一个属性赋值
<property...>
</bean>
-->
<bean id="myStudent" class="com.bjpowernode.ba01.Student">
<property name="name" value="李四"/><!--setName("李四")-->
<property name="age" value="20"/><!--setAge(20)-->
</bean>
<bean id="myDate" class="java.util.Date">
<property name="time" value="31312312"/><!--setTime(31312312)-->
</bean>
</beans>public class MyTest {
@Test
public void test01(){
String config = "ba01/applicationContext.XML";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//从容器中获取Student对象
Student myStudent = (Student)ac.getBean("myStudent");
System.out.println(myStudent);
Date date = (Date) ac.getBean("myDate");
System.out.println(date);
}
}必须要有set方法，并且是先调用构造方法创建对象，再调用set方法进行赋值。spring只是调
用这些set方法，而set方法内部的具体实现还是由程序员自己定义。因此，假如说有一个
setEmail()方法，但是没有email属性，此时在配置文件中给email赋值，仍旧是可以正常运行
的，有一个属性的set方法，对这个属性的赋值就是可以正常进行的，无论这个类是否有这个属
性。
不管属性值是什么类型的，value都要放在" "中。
2.引用类型的设值注入：
public class School {
private String name;
private String address;
public void setName(String name) {
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}public class Student {
private String name;
private int age;
//申明一个引用类型
private School school;
public Student() {
System.out.println("spring会调用类的无参数构造方法创建对象");
}
//需要有set方法，没有set方法是会报错的。
//先执行无参数构造方法，再执行set方法完成属性赋值
public void setName(String name) {
System.out.println("setName = " + name);
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setSchool(School school) {
System.out.println("setSchool = " + school);
this.school = school;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school=" + school +
'}';
}
}
<?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">
<!--
2)引用类型的set注入：spring调用类的set方法
<bean id="" class="">
<property name="属性名字" ref="bean的id(对象的名称)"/>
</bean>
-->
<bean id="myStudent" class="com.bjpowernode.ba02.Student">
<property name="name" value="李四"/><!--setName("李四")-->
<property name="age" value="20"/><!--setAge(20)-->
<!--引用类型-->
<property name="school" ref="mySchool"/><!--setSchool(mySchool)-->
</bean>
<bean id="mySchool" class="com.bjpowernode.ba02.School">
<property name="name" value="北京大学"/>
<property name="address" value="北京"/>
</bean>
</beans>public class MyTest02 {
@Test
public void test02(){
Student student = new Student();
student.setName("lisi");
student.setAge(20);
School school = new School();
school.setName("动力节点");
school.setAddress("北京");
student.setSchool(school);
System.out.println(student);
}
@Test
public void test03(){
String config = "ba02/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student student = (Student)ac.getBean("myStudent");
System.out.println(student);
}
}2.4.2 构造注入
spring调用类的有参构造方法，创建对象。
public class School {
private String name;
private String address;
public void setName(String name) {
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}public class Student {
private String name;
private int age;
//申明一个引用类型
private School school;
public Student() {
}
/**
* 创建有参数构造方法
*/
public Student(String myname,int myage,School mySchool){
System.out.println("Student有参数构造方法");
this.name = myname;
this.age = myage;
this.school = mySchool;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school=" + school +
'}';
}
}<?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">
<!--
2.构造注入：spring调用类的有参构造方法，在创建对象的同时，在构造方法中给属性赋值
构造注入使用<constructor-arg>标签
<constructor-arg>标签：一个<constructor-arg>标签表示构造方法的一个参数
<constructor-arg>标签属性：
name：表示构造方法的形参名
index：表示构造方法的形参的位置，参数从左往右位置是0，1，2的顺序
value：构造方法的形参类型是简单类型的，使用value
ref：构造方法的形参类型是引用类型的，使用ref
-->
<!--使用name属性实现构造注入-->
<bean id="myStudent" class="com.bjpowernode.ba03.Student">
<constructor-arg name="myname" value="张三"/>
<constructor-arg name="myage" value="20"/>
<constructor-arg name="mySchool" ref="mySchools"/>
</bean>
<!--使用index属性-->
<bean id="myStudent2" class="com.bjpowernode.ba03.Student">
<constructor-arg index="0" value="张三"/>
<constructor-arg index="1" value="24"/>
<constructor-arg index="2" ref="mySchools"/>
</bean>
<!--省略index，必须按照参数顺序写-->
<bean id="myStudent3" class="com.bjpowernode.ba03.Student">
<constructor-arg value="张三"/>
<constructor-arg value="27"/>
<constructor-arg ref="mySchools"/>
</bean>
<bean id="mySchools" class="com.bjpowernode.ba03.School">
<property name="name" value="北京大学"/>
<property name="address" value="北京"/>
</bean>
<!--创建File,使用构造注入-->
<bean id="myFile" class="java.io.File">
<constructor-arg name="parent" value="D:\javalesson\第四阶段\spring-project\02-给类的属性赋值"/>
<constructor-arg name="child" value="readme.txt"/>
</bean>
</beans>public class MyTest03 {
@Test
public void test03(){
String config = "ba03/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student student = (Student)ac.getBean("myStudent");
System.out.println(student);
Student student2 = (Student)ac.getBean("myStudent2");
System.out.println(student2);
Student student3 = (Student)ac.getBean("myStudent3");
System.out.println(student3);
File file = (File)ac.getBean("myFile");
System.out.println(file.getName());
}
}2.4.3 引用类型的自动注入
对于引用类型属性的注入，也可以不在配置文件中显示的注入。可以通过为<bean/>标签设置autowire属性值，为引用类型属性进行隐式自动注入(默认是不自动注入引用类型属性)。根据自动输入判断标准的不同，可以分为两种：
①byName根据名称自动注入；
②byType根据类型自动注入。
2.4.4 自动注入byName
当配置文件中被调用者bean的id值与代码中调用者bean类的属性名相同时，可使用byName方式，让容器自动将调用者bean注入给调用者bean。容器是通过调用者的bean类的属性名与配置文件的被调用者bean的id进行比较而实现自动注入的。
public class School {
private String name;
private String address;
public void setName(String name) {
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}public class Student {
private String name;
private int age;
//申明一个引用类型
private School school;
public Student() {
//System.out.println("spring会调用类的无参数构造方法创建对象");
}
//需要有set方法，没有set方法是会报错的。
//先执行无参数构造方法，再执行set方法完成属性赋值
public void setName(String name) {
//System.out.println("setName = " + name);
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setSchool(School school) {
System.out.println("setSchool = " + school);
this.school = school;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school=" + school +
'}';
}
}<?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">
<!--
引用类型的自动注入：spring框架根据某些规则可以给引用类型赋值。不用自己给引用类型赋值
使用的规则常用的是byName，byType。
1.byName(按名称注入)：java类中引用类型的属性名和spring容器中(配置文件)<bean>的id一样，
且数据类型是一样的，这样的容器中的bran，spring能够赋值给引用类型。
语法：
<bean id="" class="" autowire="byName">
简单类型属性赋值
</bean>
-->
<!--byName-->
<bean id="myStudent" class="com.bjpowernode.ba04.Student" autowire="byName">
<property name="name" value="李四"/>
<property name="age" value="20"/>
<!--引用类型-->
<!--<property name="school" ref="mySchool"/>-->
</bean>
<!--属性名和bean的id要一样，都是school-->
<bean id="school" class="com.bjpowernode.ba04.School">
<property name="name" value="清华大学"/>
<property name="address" value="北京"/>
</bean>
</beans>public class MyTest04 {
@Test
public void test04(){
String config = "ba04/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student student = (Student)ac.getBean("myStudent");
System.out.println(student);
}
}2.4.5 自动注入byType
使用byType方式自动注入，要求配置文件中被调用者bean的class属性指定的类，要与代码中调用者bean类的某引用类型属性类型同源。即要么相同，要么有is-a关系(子类，或是实现类)。但这样的同源的被调用bean只能有一个。多于一个，容器就不知该匹配哪一个了。
public class PrimarySchool extends School {
}public class School {
private String name;
private String address;
public void setName(String name) {
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}
public class Student {
private String name;
private int age;
//申明一个引用类型
private School school;
public Student() {
//System.out.println("spring会调用类的无参数构造方法创建对象");
}
//需要有set方法，没有set方法是会报错的。
//先执行无参数构造方法，再执行set方法完成属性赋值
public void setName(String name) {
//System.out.println("setName = " + name);
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setSchool(School school) {
System.out.println("setSchool = " + school);
this.school = school;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school=" + school +
'}';
}
}<?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">
<!--
2.byType(按类型注入)：java类中引用类型的数据类型和spring容器中(配置文件)<bean>的class属性
是同源关系的，这样的bean能够赋值给引用类型
同源就是一类的关系：
1.java类中引用类型的数据类型和bean的class的值是一样的。
2.java类中引用类型的数据类型和bean的class的值是父子类关系的。
3.java类中引用类型的数据类型和bean的class的值是接口和实现类关系的。
语法：
<bean id="" class="" autowire="byType">
简单类型属性赋值
</bean>
注意：在byType中，在xml配置文件中声明bean只能有一个符合条件的，多余一个是错误的。
-->
<bean id="myStudent" class="com.bjpowernode.ba05.Student" autowire="byType">
<property name="name" value="李六"/>
<property name="age" value="20"/>
<!--引用类型-->
<!--<property name="school" ref="mySchool"/>-->
</bean>
<bean id="mySchool" class="com.bjpowernode.ba05.School">
<property name="name" value="人民大学"/>
<property name="address" value="北京"/>
</bean>
<!--声明School的子类-->
<!-- <bean id="primarySchool" class="com.bjpowernode.ba05.PrimarySchool" autowire="byType">-->
<!-- <property name="name" value="北京小学"/>-->
<!-- <property name="address" value="北京"/>-->
<!-- </bean>-->
</beans>public class MyTest05 {
@Test
public void test05(){
String config = "ba05/applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student student = (Student)ac.getBean("myStudent");
System.out.println(student);
}
}注意：在byType中，在xml配置文件中声明bean只能有一个符合条件的，多于一个是错误的
2.4.6 为应用制定多个Spring配置文件
在实际应用里，随着应用规模的增加，系统中Bean数量也大量增加，导致配置文件变得非常庞大、臃肿。为了避免这种情况的产生，提高配置文件的可读性与可维护性，可以将Spring配置文件分解成多个配置文件。
包含关系的配置文件：多个配置文件中有一个总文件，总配置文件将其各子文件通过<import/>引入，在java代码中只需要使用总配置文件对容器进行初始化即可。
多配置文件的优势：
①每个文件的大小比一个文件要小很多，效率高；
②避免多人竞争带来的冲突。
多配置文件的分配方式：
①按功能模块分配，一个模块一个配置文件。
②按类的功能分配，数据库相关的功能一个配置文件，做事务的功能一个配置文件，做
service功能的一个配置文件等。
public class School {
private String name;
private String address;
public void setName(String name) {
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}public class Student {
private String name;
private int age;
//申明一个引用类型
private School school;
public Student() {
//System.out.println("spring会调用类的无参数构造方法创建对象");
}
//需要有set方法，没有set方法是会报错的。
//先执行无参数构造方法，再执行set方法完成属性赋值
public void setName(String name) {
//System.out.println("setName = " + name);
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setSchool(School school) {
System.out.println("setSchool = " + school);
this.school = school;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school=" + school +
'}';
}
}<?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">
<!--
包含关系的配置文件：
spring-total表示主配置文件：包含其他的配置文件的
主配置文件一般不定义对象
语法：
<import resource="其他配置文件的路径">
关键字：
"classpath：" 表示类路径(class文件所在的目录)，在spring的配置文件中要指定其他文件的位置
需要使用classpath，告诉spring到哪去加载读取文件。
-->
<!--加载的是文件列表-->
<!-- <import resource="classpath:ba06/spring-school.xml"/>-->
<!-- <import resource="classpath:ba06/spring-student.xml"/>-->
<!--
在包含关系的配置文件中，可以使用通配符(*：表示任意字符)
注意：主的配置文件名称不能包含在通配符的范围内(不能叫做spring-total.xml)
并且各个子配置文件要放在同一个文件夹中(同一级目录)
-->
<import resource="classpath:ba06/spring-*.xml"/>
</beans><?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">
<!--
school模块所有bean的声明，School模块的配置文件
-->
<bean id="mySchool" class="com.bjpowernode.ba06.School">
<property name="name" value="南航大学"/>
<property name="address" value="南京"/>
</bean>
</beans><?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">
<!--
student模块所有bean的声明
-->
<!--byName-->
<bean id="myStudent" class="com.bjpowernode.ba06.Student" autowire="byType">
<property name="name" value="李六"/>
<property name="age" value="28"/>
<!--引用类型-->
<!--<property name="school" ref="mySchool"/>-->
</bean>
</beans>public class MyTest06 {
@Test
public void test06(){
//加载的是总配置文件
String config = "ba06/total.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
Student student = (Student)ac.getBean("myStudent");
System.out.println(student);
}
}PS：根据动力节点课程整理，如有侵权，联系删除。
扫一扫
539
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
