spring的配置文件-applicationContext.xml

大家好，又见面了，我是你们的朋友全栈君。

1.<beans>标签是spring的配置文件的根标签，其包含相关的命名空间，用于约束子标签的标识

1.基本的约束

<?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">
</beans>

2.引入p命名空间

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

3.使用组件扫描开启bean的注解

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

http://www.springframework.org/schema/context 

http://www.springframework.org/schema/context/spring-context.xsd

3.引入aop

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

4.使用spring的声明式事务

xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd

4.比较全的约束头

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

</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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.2.xsd">

2.<bean>标签为beans的子标签，用于配置的对象将交由spring来创建，默认情况下他调用的是类中的无参构造来创建对象bean的，该标签的基本属性：

id属性：bean的实列在spring容器中的唯一标识

class属性：bean实列对应的类的全包名

scope属性：规定bean的实列的作用范围，有5个值：

        singleton：默认值，表示单列的，从spring的容器中获取到该bean的实列只有一个，它们的地址为同一个地址

        prototype: 标识多例的，每次从spring的容器中获取到的都是新的bean的实例

        request: WEB项目中，spring创建一个bean的实例，将该对象存入到request域中

        session：WEB项目中，spring创建一个bean，将该对象存入到session域中

其中singleton和prototype的加载机制是不一样的：

        singleton：当spring的配置文件被加载时（ClassPathXmlApplicationContext(“applicationContext.xml”)）就创建了bean的实列

        prototype：当spring的配置文件被加载时不会创建bean的实列，而是在调用getBean（）方法时创建实列

其中singleton和prototype的生命周期：

        singleton：

                对象创建：当应用加载时也就是创建容器时

                对象运行：只要spring容器一直存在，对象就存在

                对象销毁：当应用卸载时，销毁容器时

         prototype：

                对象创建：调用getBean（）方法时创建实列

                对象运行：只要对象在使用就一直存在

                对象销毁：当对象长时间不用时，会被java的垃圾回收器清理

init-method属性：指定类中的初始化方法名称，当这个bean被实例化时，就会执行该方法

destory-method属性: 指定类中的销毁方法的名称，当这个bean被销毁时，执行该方法

代码演示：

    <bean id="userdao" class="com.ck.dao.UserDaoImp" scope="prototype" init-method="init" destroy-method="destory"/>

3.bean实列化的三种方式

–无参构造方法实例化：这是默认情况下调用的就是类中的无参构造来创建实例的

–工厂静态方法：这是调用类中的静态方法，通过静态方法返回实例对象，在<bean>中使用属性factory-method=“类中的静态方法名”，就会调用这个静态方法获取到bean的实例

–工厂实例方法：这是调用类中的非静态方法来创建实例

        首先通过bean标签配置这个类的实例：

<bean id="factory" class="类的全包名"/> 

        再通过bean标签的属性actory-bean指向这个id为factory的这个实例，调用非静态方法

<bean id="userdao" factory-bean="factory" factory-method="非静态的方法名"/>

4.bean的依赖注入——引用Bean

由于Service层的实例和Dao层的实例都存在于容器中，在没有使用依赖注入前，我们是在容器的外部获取到他们的实例，然后在程序中进行结合，这种做法不太实际也比较复杂

依赖注入的概念：它是spring框架核心IOC的具体体现，在编写程序时，通过控制反转，把对象的创建交给了spring，但是代码中不肯彻底清除依赖关系，而IOC解耦只是降低他们的依赖关系，如：业务层会调用持久层，那这种业务层和持久层的依赖关系在使用spring之后，就让spring来维护了，简单的说，就是坐等框架把持久层对象传入到业务层，而不用我们自己去获取

bean的依赖注方式有两种：

1.set方法注入

在service层的实现类中创建 Dao层实现类的 私有类型的成员变量，生成set方法：

public class TestServiceImp implements TestService01 {

    //创建dao层的实例
    private UserDao userDao;

    //生成set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    
    //调用Dao层的方法
    @Override
    public void testRun() {
        userDao.run();
    }

}

在spring配置文件中配置依赖注入：使用ref引用bean的id

<!--创建dao层的UserDaoImp的bean的实列-->
    <bean id="userdao" class="com.ck.dao.UserDaoImp"/>


<!--   依赖注入 将dao层的实现类的bean注入service层的实现类中 -->
    <bean id="testServiceImp" class="com.ck.service.service_imp.TestServiceImp">
        //这里使用的是property标签 name 为 属性名 也就是方法名set之后的名称
        <property name="userDao" ref="userdao"/>
    </bean>

这时我们只要在测试类中通过id为testServiceImp获取到TestServiceImp的bean就同时已经获取了dao层的bean

    /**
     * 测试service层
     */
    @Test
    public void text05() {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        TestService01 ts = (TestService01) app.getBean("testServiceImp");
        ts.testRun();
    }

2.构造方法注入：

与set方法使用逻辑一样，只不过将set方法用构造方法取代了

public class TestServiceImp implements TestService01 {
    //创建Dao层的成员属性
    private UserDao userDao;

    //生成构造方法
    public TestServiceImp(UserDao userDao) {
        this.userDao = userDao;
    }

    //无参构造
    public TestServiceImp() {
    }


    //调用Dao层的方法
    @Override
    public void testRun() {
        userDao.run();
    }


}

在spring配置文件中配置依赖注入：使用ref引用bean的id

<!--创建dao层的UserDaoImp的bean的实列-->
    <bean id="userdao" class="com.ck.dao.UserDaoImp"/>

<!--   依赖注入 将dao层的实现类的bean注入service层的实现类中 -->
    <bean id="testServiceImp" class="com.ck.service.service_imp.TestServiceImp">
        //这里使用constructor-arg标签  name为构造方法中的参数名称
        <constructor-arg name="userDao" ref="userdao"/>
    </bean>

最后同样测试一下就不写了

5.bean的依赖注入——其他类型注入

上面的操作都是注入的引用类型，还可以注入基本数据类型，集合等，同样需要用到set方法

public class UserDaoImp implements UserDao {
    //基本类型
    private String userName;
    private int age;
    //集合类型
    private List<String> list;
    private Map<String, User> userMap;
    //Properties文件
    private Properties properties;

    //set方法
    public void setUserName(String userName) {
        this.userName = userName;
    }

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

    public void setList(List<String> list) {
        this.list = list;
    }

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

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

    public UserDaoImp() {
    }
    
    //打印结果
    @Override
    public void show() {
        System.out.println("list集合："+this.list);
        System.out.println("map集合："+this.userMap);
        System.out.println("properties格式文件："+this.properties);
    }

    @Override
    public void run() {
        System.out.println("hello spring");
        System.out.println("userName:" + this.userName);
        System.out.println("age:" + this.age);
    }


}

1.注入基本数据类型

<!--创建dao层的UserDaoImp的bean的实列-->
<bean id="userdao" class="com.ck.dao.UserDaoImp">

        <property name="userName" value="张三"/>
        <property name="age" value="20"/>

</bean>

2.注入集合类型

<!--创建dao层的UserDaoImp的bean的实列-->
    <bean id="userdao" class="com.ck.dao.UserDaoImp">

        <!--    给dao层的UserDaoImp实现类的list成员变量注入元素-->
        <property name="list" >
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>
        <!--    给dao层的UserDaoImp实现类的Map<String,User>成员变量注入键和值-->
        <property name="userMap">
            <map>
                <entry key="u1" value-ref="user1"/>
                <entry key="u2" value-ref="user2"/>
            </map>
        </property>

    </bean>

3.注入properoties类型

<!--创建dao层的UserDaoImp的bean的实列-->
    <bean id="userdao" class="com.ck.dao.UserDaoImp">

<!--     给dao层的UserDaoImp实现类properoties的成员变量注入键和值-->
        <property name="properties">
            <props>
                <prop key="aaa">888888888</prop>
                <prop key="bbb">777777777</prop>
                <prop key="ccc">111111111</prop>
            </props>
        </property>
    </bean>

最后将带有注入属性值的UserDaoImp类的bean 注入到TestServiceImp中

<!--    配置service层imp-->
    <bean id="testServiceImp" class="com.ck.service.service_imp.TestServiceImp">
        <property name="userDao" ref="userdao"/>
    </bean>

6.使用import标签引入其他spring配置文件

在实际开发中，spring的配置文件内容会非常多，这就导致spring配置文件繁杂且体积庞大，所以我们可以通过注解，或根据不同业务功能或分层，将配置文件中的内容按功能或层架构去拆解成多个对应的spring配置文件的分支，然后在spring主配置文件中引入他们

<import resource="applicationContext-xxx.xml"/>