Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结-CFANZ编程社区

写在前面

我的《Java进阶篇》系列博客今天上线了，还是像往期的《Java学习篇》、《JavaWeb学习篇》一样把学习历程记录下来

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_xml

其实有点矛盾到底该不该继续记录此系列博客，

记录的过程可以加深一些印象，便于以后遇到遗忘的陌生的知识点可以复习一下，这固然挺不错的

但是记录的话确实会多花一些时间和精力，学习的进度就不会那么快

确实有点犹豫拿不定主意，最后想想采取一个折中的办法吧，就是记录的不在那么详细，因为进阶的内容主要是框架的学习

更加需要不断的练习，会尽量把大部分时间转化到敲代码上~

最后还是熟悉的那句话：虽然我走的很慢，但我仍在前进！！ 与君共勉~

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_xml_02

开始

一、Spring简介

是一种目前流行的框架

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_bean_03

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_spring_04

EJB可以说是Spring的前身

百度百科：
EJB是sun的JavaEE服务器端组件模型，设计目标与核心应用是部署分布式应用程序。简单来说就是把已经编写好的程序(即:类)打包放在服务器上执行。凭借java跨平台的优势，用EJB技术部署的分布式系统可以不限于特定的平台。EJB (Enterprise JavaBean)是J2EE(javaEE)的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。其特点包括网络服务中心支持和核心开发工具(SDK)。在J2EE里，Enterprise Java Beans(EJB)称为Java 企业Bean，是Java的核心代码，分别是会话Bean(Session Bean)，实体Bean(Entity Bean)和消息驱动Bean(MessageDriven Bean)。在EJB3.0推出以后，实体Bean被单独分了出来，形成了新的规范JPA。

一个技术规范:EJB 从技术上而言不是一种"产品",EJB 是一种描述了构建应用组件要解决的标准:

可扩展 (Scalable)
分布式 (Distributed)
事务处理(Transactional)
数据存储(Persistent)
安全性 (Secure)

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_spring_05

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_bean_06

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_xml_07

如何实现解耦合：简单理解就是把创建对象的任务交给Spring，需要对象的时候只需要跟Spring要对象就行

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_spring_08

对应的文字解释

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_spring_09

1.1快速入门

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_bean_10

<!--    导入Spring的坐标-->

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>
</dependencies>

报错：

Error:java: 错误: 不支持发行版本 5
maven报错：不再支持源选项 5。请使用 6 或更高版本。

解决：

本地JDK的版本过高，在pom.xml又没有指定Java编译的版本，因此会报错，解决办法是在pom.xml文件指定本地JDK的版本

<!--    指定JDK的版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <java.version>11</java.version>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_spring_11

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_JavaEE_12

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_JavaEE_13

二、Spring配置文件

在applicationContext.xml配置文件的<bean>标签的属性

scope对象的范围配置
Bean的生命周期配置
Bean实例化的三种方式（Dao层）
Bean的依赖注入分析

2.1Bean标签范围配置scope属性

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_JavaEE_14

<!--    导入Junit单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_xml_15

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_JavaEE_16

上述两个配置对应的创建对象的时机不同

singleton：对应只有一个对象，加载完配置文件就创建对象，在getBean()之前就创建了

这里的容器指Spring

prototype：对应多个对象，执行完getBean()后才创建

2.2Bean标签Bean的生命周期配置

生命周期: 主要指Bean的创建、销毁

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_java_17

对应的两个属性

init-method —》用来指定Bean中初始化时会被自动执行的成员方法
destroy-method —》用来指定Bean中销毁时会被自动执行的成员方法

需要注意的是：

ApplicationContext是接口，没有手动关闭容器Spring的方法
ClassPathXmlApplicationContext是实现类，可以实现close()关闭容器,实现销毁自动执行成员方法的执行

2.3Bean标签Bean实例化的三种方式

无参构造方法实例化
工厂静态方法实例化
工厂实例方法实例化

工厂静态方法实例化

调用工厂的静态方法获取对象

不载使用无参构造，使用工厂类的静态方法返回一个对象
然后需要告诉Spring,修改配置文件,把工厂的全类名传给class属性，设置属性 factory-method="getUserDao"

StaticFactory工厂类

package henu.soft.xiaosi.factory;

import henu.soft.xiaosi.dao.UserDao;
import henu.soft.xiaosi.dao.impl.UserDaoImpl;

public class StaticFactory {

    public static UserDao getUserDao(){

        //不载使用无参构造，使用工厂类的静态方法返回一个对象
        return new UserDaoImpl();

        //然后需要告诉Spring,修改配置文件,把工厂的全类名传给class属性，设置属性 factory-method="getUserDao"


    }
}

applicationContext.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">


<!--    配置UserDao的全包名，和id标识-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>-->

<!--    这是工厂的静态方法，返回一个对象-->
    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>

</beans>

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_JavaEE_18

工厂实例方法实例化

先创建工厂对象，再调用方法

DynamicFactory工厂类

package henu.soft.xiaosi.factory;

import henu.soft.xiaosi.dao.UserDao;
import henu.soft.xiaosi.dao.impl.UserDaoImpl;

public class DynamicFactory {

    public  UserDao getUserDao(){



        //不载使用无参构造，使用工厂类实例方法实例化对象
        return new UserDaoImpl();

        //然后需要告诉Spring,修改配置文件,把工厂的全类名传给class属性
        //设置两个<bean>
        //先创建工厂实例化对象
        //然后工厂实例化对象调用指定的获取对象的方法，返回一个对象


    }
}

applicationContext.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">


<!--    配置UserDao的全包名，和id标识-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>-->

<!--    这是工厂的静态方法，返回一个对象-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>-->

<!--    工厂对象调用方法返回对象-->

    <bean id="factory" class="henu.soft.xiaosi.factory.DynamicFactory" scope="singleton" ></bean>
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>
</beans>

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_JavaEE_19

用处：

对象创建的时候，并不一定需要无参构造获取对象，例如数据库连接池的Connection对象，

不是自己new 出来的，而是DriverManager调用方法得到的

因此，像上述这种对象，不能够通过无参构造获取，需要使用到工厂类，在工厂内部获取

2.3Bean标签Bean的依赖注入分析

前面设计对象创建都是Dao层的，如果我们需要应用层的呢

同样的步骤

applicationContext.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">


<!--    配置UserDao的全包名，和id标识-->
    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>

<!--    这是工厂的静态方法，返回一个对象-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>-->

<!--    工厂对象调用方法返回对象-->

<!--    <bean id="factory" class="henu.soft.xiaosi.factory.DynamicFactory" scope="singleton" ></bean>-->
<!--    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>-->

<!--    依赖注入-->
<!--    从容器中获取UserServiceImpl对象service-->
    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl"></bean>

</beans>

UserServiceImpl类

package henu.soft.xiaosi.service.impl;

import henu.soft.xiaosi.dao.UserDao;
import henu.soft.xiaosi.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService {
    @Override
    public void showAll() {

        //向Spring要UserDaoImpl对象
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //强转类型
        UserDao userDao1 = (UserDao) app.getBean("userDao");

        userDao1.show();
    }
}

虚假的Servlet

package henu.soft.xiaosi.demo;

import henu.soft.xiaosi.service.UserService;
import henu.soft.xiaosi.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 充当Servlet的方法
 */
public class UserController {
    public static void main(String[] args) {

        /**
         *          //这是UserService未配到Spring容器中的时候
         *         UserService service = new UserServiceImpl();
         *
         *         service.showAll();
         */

        //我们可以配置从容器中 获取 service对象
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService service = (UserServiceImpl)app.getBean("userService");
        service.showAll();



    }
}

上述操作随是可行的，但是存在问题：

UserDaoImpl实现类、UserServiceImpl实现类都是通过Spring容器获取的
因为UserDaoImpl 在实现逻辑代码的时候，需要创建UserDaoImpl对象来操作数据库，所以，UserDaoImpl对象实例获取的时机在UserServiceImpl实例内部

我们现在并不关心UserDaoImpl对象，需要的不是UserDaoImpl对象在容器外得到

而是直接在容器内部 service就能操作userDao对象

即在容器内部完成注入

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_spring_20

关键是怎么把数据设置（注入）到某个对象内部：

set（）方法：把userDao对象给userService对象
构造方法

依赖注入

它是Spring框架IOC控制反转的具体体现

编写程序时，对象的创建权交给Spring,但是对象之间有联系，对象之间有可能存在依赖

我们要降低在容器外的耦合关系，将userService对象对userDao对象的处理放在Spring容器内

不在需要关注持久层，只需关注业务层

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_xml_21

注入方法

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_xml_22

set方法

业务层创建set方法：在UserServiceImpl内部需要有一个set方法
告诉Spring：配置applicationContext.xml配置文件

UserServiceImpl业务层

package henu.soft.xiaosi.service.impl;

import henu.soft.xiaosi.dao.UserDao;
import henu.soft.xiaosi.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }


    @Override
    public void showAll() {

        /**
         *      未注入之前的
         *
         *          向Spring要UserDaoImpl对象
         *         ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
         *         //强转类型
         *         UserDao userDao1 = (UserDao) app.getBean("userDao");
         *
         *         userDao1.show();
         */
        userDao.show();

    }
}

applicationContext.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">


<!--    配置UserDao的全包名，和id标识-->
    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>

<!--    这是工厂的静态方法，返回一个对象-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>-->

<!--    工厂对象调用方法返回对象-->

<!--    <bean id="factory" class="henu.soft.xiaosi.factory.DynamicFactory" scope="singleton" ></bean>-->
<!--    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>-->

<!--    依赖注入-->


<!--    从容器中获取UserServiceImpl对象service-->
    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl">
        <!--  name 为被注入对象的set方法后面的内容属性-->
        <!--  ref  为被注入的对象id引用-->
        <property name="userDao" ref="userDao"></property>

    </bean>


</beans>

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_java_23

P命名空间的注入

set方法依赖注入一种简单的写法，省去property子标签

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_xml_24

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:p="http://www.springframework.org/schema/p"

       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">



<!--    配置UserDao的全包名，和id标识-->
    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>

<!--    这是工厂的静态方法，返回一个对象-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>-->

<!--    工厂对象调用方法返回对象-->

<!--    <bean id="factory" class="henu.soft.xiaosi.factory.DynamicFactory" scope="singleton" ></bean>-->
<!--    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>-->

<!--    依赖注入-->


<!--    从容器中获取UserServiceImpl对象service-->
<!--    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl">-->
<!--        <!–  name 为被注入对象的set方法后面的内容属性–>-->
<!--        <!–  ref  为被注入的对象id引用–>-->
<!--        <property name="userDao" ref="userDao"></property>-->

<!--    </bean>-->

    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>



</beans>

构造注入方法

添加构造方法
配置文件告诉Spring，设置ref

UserServiceIml

package henu.soft.xiaosi.service.impl;

import henu.soft.xiaosi.dao.UserDao;
import henu.soft.xiaosi.dao.impl.UserDaoImpl;
import henu.soft.xiaosi.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService {

    private UserDao userDao;



    /**
     * set注入
     *
     * public void setUserDao(UserDao userDao){
     *         this.userDao = userDao;
     *     }
     *
     *
     */


//    构造注入

    public UserServiceImpl() {
    }


    public UserServiceImpl(UserDaoImpl userDao) {
        this.userDao = userDao;
    }


    @Override
    public void showAll() {

        /**
         *      未注入之前的
         *
         *          向Spring要UserDaoImpl对象
         *         ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
         *         //强转类型
         *         UserDao userDao1 = (UserDao) app.getBean("userDao");
         *
         *         userDao1.show();
         */
        userDao.show();

    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:p="http://www.springframework.org/schema/p"

       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">



<!--    配置UserDao的全包名，和id标识-->
    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>

<!--    这是工厂的静态方法，返回一个对象-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>-->

<!--    工厂对象调用方法返回对象-->

<!--    <bean id="factory" class="henu.soft.xiaosi.factory.DynamicFactory" scope="singleton" ></bean>-->
<!--    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>-->

<!--    依赖注入set-->


<!--    从容器中获取UserServiceImpl对象service-->
<!--    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl">-->
<!--        <!–  name 为被注入对象的set方法后面的内容属性–>-->
<!--        <!–  ref  为被注入的对象id引用–>-->
<!--        <property name="userDao" ref="userDao"></property>-->

<!--    </bean>-->

<!--p命名空间注入-->
<!--    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>-->



<!--    构造注入-->

    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl" scope="singleton" >
        <constructor-arg name="userDao" ref="userDao">

        </constructor-arg>
    </bean>

</beans>

2.4 Bean标签Bean的依赖注入的数据类型

上面的注入都是通过对象的引用注入的，主要是在容器中将UserDao注给UserService

除了对象的引用可以注入，还可以注入：普通数据类型、集合等

注入数据的三种数据类型

普通数据类型
引用数据类型
集合数据类型

普通数据类型的注入

给UserDaoImpl添加成员变量，setter方法
告诉Spring

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:p="http://www.springframework.org/schema/p"

       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">



<!--    配置UserDao的全包名，和id标识-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>-->

<!--    这是工厂的静态方法，返回一个对象-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>-->

<!--    工厂对象调用方法返回对象-->

<!--    <bean id="factory" class="henu.soft.xiaosi.factory.DynamicFactory" scope="singleton" ></bean>-->
<!--    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>-->

<!--    依赖注入set-->


<!--    从容器中获取UserServiceImpl对象service-->
<!--    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl">-->
<!--        <!–  name 为被注入对象的set方法后面的内容属性–>-->
<!--        <!–  ref  为被注入的对象id引用–>-->
<!--        <property name="userDao" ref="userDao"></property>-->

<!--    </bean>-->

<!--p命名空间注入-->
<!--    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>-->



<!--    构造注入-->

    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl" scope="singleton" >
        <constructor-arg name="userDao" ref="userDao">

        </constructor-arg>
    </bean>

<!--    一般数据类型的注入-->

    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl">
        <property name="age" value="20"></property>
        <property name="name" value="xiaosi"></property>
    </bean>
</beans>

注意：

普通数据类型不需要引用ref,只需要设置value属性

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_bean_25

集合数据类型的注入

给UserDaoImpl添加集合成员变量List、Map、Properties
告诉Spring进行注入

UserDaoImpl

package henu.soft.xiaosi.dao.impl;

import henu.soft.xiaosi.dao.UserDao;
import henu.soft.xiaosi.domain.User;

import java.util.List;
import java.util.Map;
import java.util.Properties;

public class UserDaoImpl implements UserDao {

    /**
     * 基本数据类型的注入

    private String name;
    private int age;

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

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

     */

    /**
     * 集合数据类型的注入
     */
    private List<String> strList;
    private Map<String, User> userMap;
    private Properties properties;

    //需要设置set方法

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void show() {
        System.out.println("入门使用...");
        //System.out.println(name + "=========" + age);

        System.out.println(strList);
        System.out.println(userMap);
        System.out.println(properties);

    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:p="http://www.springframework.org/schema/p"

       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">



<!--    配置UserDao的全包名，和id标识-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl" scope="singleton"></bean>-->

<!--    这是工厂的静态方法，返回一个对象-->
<!--    <bean id="userDao" class="henu.soft.xiaosi.factory.StaticFactory" scope="singleton" factory-method="getUserDao"></bean>-->

<!--    工厂对象调用方法返回对象-->

<!--    <bean id="factory" class="henu.soft.xiaosi.factory.DynamicFactory" scope="singleton" ></bean>-->
<!--    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>-->

<!--    依赖注入set-->


<!--    从容器中获取UserServiceImpl对象service-->
<!--    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl">-->
<!--        <!–  name 为被注入对象的set方法后面的内容属性–>-->
<!--        <!–  ref  为被注入的对象id引用–>-->
<!--        <property name="userDao" ref="userDao"></property>-->

<!--    </bean>-->

<!--p命名空间注入-->
<!--    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>-->



<!--    构造注入-->

    <bean id="userService" class="henu.soft.xiaosi.service.impl.UserServiceImpl" scope="singleton" >
        <constructor-arg name="userDao" ref="userDao">

        </constructor-arg>
    </bean>

<!--    一般数据类型的注入-->

<!--    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl">-->
<!--        <property name="age" value="20"></property>-->
<!--        <property name="name" value="xiaosi"></property>-->
<!--    </bean>-->

<!--    集合数据类型注入-->

    <bean id="userDao" class="henu.soft.xiaosi.dao.impl.UserDaoImpl">

<!--        list-->
        <property name="strList">
            <list>
                <value>xxx</value>
                <value>iii</value>
                <value>aaa</value>
                <value>ooo</value>
            </list>
        </property>

<!--        注入Map，键为字符串，值为对象-->
        <property name="userMap">
            <map>
                <entry key="u1" value-ref="user1"></entry>
                <entry key="u2" value-ref="user2"></entry>
            </map>
        </property>

        <!--    Properties,键和值都是字符串-->
        <property name="properties">
            <props>

                <prop key="p1">sss</prop>
                <prop key="p2">iii</prop>
            </props>
        </property>

    </bean>

<!--    创建对象注入，存在Map中-->
    <bean id="user1" class="henu.soft.xiaosi.domain.User">
        <property name="name" value="xiaosi1"></property>
        <property name="age" value="21"></property>
    </bean>

    <bean id="user2" class="henu.soft.xiaosi.domain.User">
        <property name="name" value="xiaosi2"></property>
        <property name="age" value="22"></property>
    </bean>




</beans>

Java进阶篇1_Spring的简介、配置文件、依赖注入、注入方法、重点配置小结_JavaEE_26