SSM框架-Spring1

目录

一、Sping框架介绍

二、第一个Spring程序

三、Spring核心容器的介绍

四、使用控制反转

五、Spring的运行原理

六、Spring的配置文件中标签的解析

[七、基于XML的注入DI(Dependency Injection)](#七、基于XML的注入DI(Dependency Injection))

---

一、Sping框架介绍

1.Spring全称叫Sping FrameWork，是目前世界上最受欢迎的框架。

2.Spring是一个开源框架，最早由Rod Johnson发起。Spring为简化企业级开发而生，使用Spring开发可以将Bean对象交给Spring容器来管理，这样使得很多复杂的代码在Spring中开发会变得非常的优雅和简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

3.官网：https://spring.io 。

4.简单来说：Spring是一个轻量级控制反转(IOC)和面向切面(AOP)为核心的容器框架。

（1）控制反转：就是由Spring容器框架将我们写好的java类去编译，编译完new对象，然后将new好的对象放入Spring中的对象单例池(对象缓存池)中，我们要使用的时候，直接从Spring的对象缓冲池里面取就可以了。也就是说，这个对象的创建过程不需要我们开发人员来写了，我们只需要写好一个类，然后交给Spring容器，Spring容器会帮助我们自动创建好这个对象，我们只需要到Spring的对象缓存池中去取就可以了

5.Spring是一个容器，可以帮助我们创建对象，和Tomcat差不多。

6.正转：

7.总结：控制正转就是需要手动创建对象，而控制反转是由Spring容器去自动创建对象的。

二、第一个Spring程序

1.导入spring的核心jar包。

2.导入日志包。

三、Spring核心容器的介绍

四、使用控制反转

1.先写一个spring.xml的配置文件。

2.加载spring.xml配置文件：

（1）使用new ClassPathXmlApplicationContext("spring.xml")来加载配置文件。

（2）注意：

• spring.xml文件要放在src目录下。
• 返回的类型是ClassPathXmlApplicationContext，我们要把这个类型改为ApplicationContext，这个ApplicationContext是一个接口，这里就变成了接口的引用指向了实现了这个接口的对象，可以理解为多态。

3.从spring容器的bean缓存池中获取Users对象：

（1）使用加载配置文件new出来的对象.getBean("配置文件的bean标签的id")来获取。

（2）注意：因为对象存放到缓存池里面会默认提升为Object，所有需要将对象强转为你需要的类型，如：我们获取的是Users对象，就需要强转为Users。

4.接下来就可以使用了。

5.案例：

（1）spring.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">
        <!--当前这个配置文件是给spring容器启动的时候在读取的-->

    <!--
    这个相当于：Users u = new Users()的过程
    这个对象u被保存到了spring容器的bean缓存池中
    map数据 id:对象
    -->
    <bean id="u" class="com.myspring.pojo.Users"></bean>
</beans>

（2）控制反转的使用：

package com.myspring.test;

import com.myspring.pojo.Users;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo {
    /**
     * 使用控制反转
     */
    @Test
    public void run(){
        //加载spring.xml配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        //根据对象的id从spring容器的bean缓存池中获取user对象
        Users u = (Users) ac.getBean("u");
        u.setUsername("秋香");
        u.setPassword("321");
        System.out.println(u);
    }
}

五、Spring的运行原理

六、Spring的配置文件中<bean>标签的解析

1.bean标签是用来帮助我们来让spring去自动new对象的标签，里面会用到两个标签属性，一个是id，一个是class：

（1）id是我们获取new好的对象的凭据，我们会在加载好配置文件后，使用配置文件对象.getBean("id")去获取new好的对象。

（2）class里面存放的是我们要new对象的实体类的全路径，就是我们要让spring去把哪个包下的哪个实体类new成对象。

2.默认情况下，同一个bean标签获取的多个实体类对象都是同一个，也就是说，除非你重新在写一个bean标签，否则无论你获取多少次，获取的对象都是同一个。如果想要获取相同类的不同对象，只需要在重新写个一模一样的bean标签，然后去获取这个bean标签new的对象，就可以了，这个新写的bean标签new出来的对象和之前的就不是同一个对象了。

3.Bean的单态模式singleton\原型模式prototype：

（1）单态模式：就是同一个bean标签获取的多个对象都是同一个，bean标签默认是就是这个模式。

（2）原型模式：就是同一个bean标签获取的多个对象都是不同的，也就说获取的不是同一个对象。

（3）设置这两个模式的话是通过bean标签的标签属性scope去设置的：

• scope="prototype"代表的是原型模式。
• scope="singleton"代表的是单态模式，如果不写这个标签属性的话，默认的是这个。

（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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--当前这个配置文件是给spring容器启动的时候在读取的-->

    <!--
    这个相当于：Users u = new Users()的过程
    这个对象u被保存到了spring容器的bean缓存池中
    map数据 id:对象
    scope如果不写，默认值是singleton，单态模式，产生的对象在spring的bean缓存池中是同一个对象
    scope="prototype"原型模式为不同的对象
    -->
    <bean id="u" class="com.myspring.pojo.Users" scope="prototype"></bean>
    <!--<bean id="u2" class="com.myspring.pojo.Users"></bean>-->
</beans>

七、基于XML的注入DI(Dependency Injection)

1.所谓注入，可以理解为为对象的属性赋值。

2.注入分为：

（1）简单数据类型和引用数据类型注入：

• 这种注入是通过在bean标签之间在写一个property标签去注入，这个property标签需要写三个属性，一个是name，一个是value，还有一个是ref：
  • name标签属性：这个代表的是给实体类中的哪个属性赋值，也就是说，这里放的是属性名。
  • value标签属性：这个代表的是给实体类中的这个属性赋什么值，而这里放的是给这个属性名所赋的值。
  • ref标签属性：这个代表的是给实体类中的引用数据类型赋值，比如给一个实体类中所持有的另一个实体类赋值。
  • 注意：ref属性和value属性的作用是一样的，只不过一个是给简单数据类型赋值，一个是给引用数据类型赋值，这两个属性只需要写其中一个就可以了。
• 常用引用数据类型注入值：
  • 数组：
    • 通过property标签之间包含一个array标签，然后在这个array标签之间使用一个value标签给数组注入值。
    • 注意：property标签只需要写一个name属性就可以，而内部包含的array标签不需要写属性，直接去包含value标签就可以了，最后把要注入的值写在value标签之间。
    • 这个property标签是在bean标签之间的。
  • list集合：
    • 往list集合中注入值和往数组中注入值差不多，只不过是把array标签换成了list标签，其他的都一样。
  • set集合：
    • 往set集合中注入值和往数组中注入值也是差不多的，把array标签换成set标签，set标签之间写value标签，value标签之间写要注入的值。
  • map集合：
    • 往map集合中注入值就是把array标签换成map标签，还要把value标签换成entry标签。
    • entry标签会有两个属性，一个是key，一个value。这两个属性是用来对应map集合中的key和value，因为map集合是键值对形式的。
  • Properties类：
    • 往Properties类中注入值，需要把array标签替换为props标签，把value标签替换为prop标签。
    • 这个prop标签需要写一个key属性，这个key是用来获取值的，而注入的值是写在prop标签之间的。

（2）通过构造器注入：

• 这种注入是通过在bean标签之间在写一个constructor-arg标签去注入，这个constructor-arg标签也需要写两个属性，一个是name，一个是value，和上面的property标签是一样的，name属性和value属性的含义也是一样的。

（3）域属性自动注入(byName\byType:局部和全局配置)：

• 局部自动注入：
  • 局部自动注入是通过在bean标签加上一个autowire属性去完成的。
  • 如果这个autowire属性的值为byType代表根据类型自动注入，如果是byName代表根据名字自动注入：
    • 根据类型注入是类型必须一致。
    • 根据名字注入是你要注入的那个bean标签id值必须和实体类中持有的其他类的变量名一致。
    • 在开发中根据类型注入使用的更多一些。
• 全局自动注入：
  • 全局自动注入是写在beans根标签内的，添加一个default-autowire属性，这个属性的值还是byType和byName，在写完这个后，整个xml文档内的bean标签都是自动注入了。

（4）空字符串或null的注入：

• 使用<value/>相当于：""。
• 使用<null/>相当于：null。
• 格式：
  • <property name="name"><value/></property>。
  • <property name="name"><null/></property>。

（5）空值注入。

（6）集合属性注入(array、set、list、map、properties)。

3.案例：

（1）基于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">
        <!--当前这个配置文件是给spring容器启动的时候在读取的-->

    <!--
    这个相当于：Users u = new Users()的过程
    这个对象u被保存到了spring容器的bean缓存池中
    map数据 id:对象
    scope如果不写，默认值是singleton，单态模式，产生的对象在spring的bean缓存池中是同一个对象
    scope="prototype"原型模式为不同的对象
    -->
    <bean id="u" class="com.myspring.pojo.Users" scope="prototype">
        <!--相当于u.setUserName="唐伯虎"-->
        <property name="username" value="唐伯虎"></property>
        <!--相当于u.setPassWord="123"-->
        <property name="password" value="123"></property>
    </bean>
    <!--<bean id="u2" class="com.myspring.pojo.Users"></bean>-->

    <!--下面相当于Users u2 = new Users("小丽","123456")-->
    <bean id="u2" class="com.myspring.pojo.Users">
        <constructor-arg name="username" value="小丽"></constructor-arg>
        <constructor-arg name="password" value="123456"></constructor-arg>
        <!--相当于setAccount(account)-->
        <property name="account" ref="account"></property>
    </bean>
    <bean id="account" class="com.myspring.pojo.Account">
        <property name="aid" value="1"></property>
        <property name="money" value="2000"></property>
    </bean>

    <!--测试常用的引用数据类型注入值-->
    <bean id="data" class="com.myspring.pojo.Data">
        <!--给数组属性注入值-->
        <property name="arr">
            <array>
                <value>北京</value>
                <value>上海</value>
                <value>深圳</value>
            </array>
        </property>
        <!--给list集合属性注入值-->
        <property name="list">
            <list>
                <value>11</value>
                <value>12</value>
                <value>13</value>
                <value>14</value>
                <value>15</value>
            </list>
        </property>
        <!--给set集合属性注入值-->
        <property name="set">
            <set>
                <value>浙江</value>
                <value>江苏</value>
                <value>福建</value>
                <value>广东</value>
            </set>
        </property>
        <!--给map集合属性注入值-->
        <property name="map">
            <map>
                <entry key="10" value="北京"></entry>
                <entry key="20" value="广州"></entry>
                <entry key="30" value="重庆"></entry>
                <entry key="40" value="天津"></entry>
            </map>
        </property>
        <!--给属性Properties集合注入值-->
        <property name="pro">
            <props>
                <prop key="prvince">河北</prop>
                <prop key="username">root</prop>
                <prop key="driver">com.mysql.connect</prop>
            </props>
        </property>
    </bean>
</beans>

（2）自动注入案例：

<?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"
       default-autowire="byName"
>
        <!--当前这个配置文件是给spring容器启动的时候在读取的-->

    <!--
    自动注入
    autowire="byType" 表示表示根据需要的数据类型自动注入引用数据类型的对象
    Users类中持有的account的值会由spring自动去bean缓存池中搜索根据类型(com.myspring.pojo.Account)自动注入
    -->
    <bean id="user" class="com.myspring.pojo.Users" autowire="byType">
        <property name="username" value="曹操"></property>
        <property name="password" value="123"></property>
    </bean>
    <bean id="account" class="com.myspring.pojo.Account">
        <property name="aid" value="101"></property>
        <property name="money" value="3000"></property>
    </bean>

    <!--
    autowire="byName"
    表示根据需要的数据类型属性名自动注入引用数据的对象
    Users类中持有的account的值会由spring自动去bean缓存池中搜索id为account的bean对象自动注入
    -->
    <bean id="user2" class="com.myspring.pojo.Users" autowire="byName">
        <property name="username" value="曹操"></property>
        <property name="password" value="123"></property>
    </bean>
</beans>