Spring-01

Spring-day01

必须了解：

​ 1）两个核心功能：依赖注入 和 控制反转

​ 2）bean 标签 id class scope 属性 + API的结合使用

​ 3）能够使用xml配置文件实现spring整合mybatis

​ 4）能够使用 property 标签实现bean对象的注入

​ 5）构造方法和集合注入有所了解即可

1. Spring简介

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

◆目的：解决企业应用开发的复杂性

◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

◆范围：任何Java应用

Spring是一个轻量级**控制反转(IoC)和面向切面(AOP)**的容器框架。

1.1 Spring优势

⚫ 方便解耦，简化开发

⚫ 方便集成各种优秀框架

⚫ 方便程序的测试

⚫ AOP编程的支持

⚫ 声明式事务的支持

⚫ 降低JavaEEAPI的使用难度

⚫ Java源码是经典学习范例

2. IoC简介

IOC 致力于解决我们日常开发中代码耦合的问题，Spring作者基于工厂模式衍化出IOC容器，我们也称其为bean容器；该容器帮我们管理开发中需要用到的类的实例（对象），从两个角度出发：

• 一：我们不需要自己去new 任何一个类的对象，而是将类的 “包名.类名” 配置给spring的xml 表中，让spring帮我们去创建类的实例化，该过程有一个好听的名字：“控制反转”，我们将new 对象和给变量赋值的操作权交给spring去做。

  注意：spring创建好了对象之后，都会放到bean容器中，这里同学们不需要较真这个容器到底是什么东西，简单理解为：“spring维护了一个map集合，存放着各种我们让它实例化的对象”。

• 二：我们创建对象的目的是为了使用对象调用方法，现在对象都在bean容器中，当我们需要使用容器中某个对象的时候，我们需要用到spring的方式，将具体对象给我们定义的引用赋值，该过程也有个好听的名字：“依赖注入”，将类类型或者基础类型的变量依赖的对象或值通过spring的方式赋值给该变量，就是所谓的注入。

**总结：**正因为spring搞出bean容器，围绕容器实现依赖注入和控制反转，才使得我们代码耦合度降低，bean容器底层基于工厂模式衍化而来（了解即可）。

注意：从功能上出发，依赖注入和控制反转本身就存在部分雷同。

3. 入门案例

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>Spring_day01_01_ioc入门程序</artifactId>
    <version>1.0-SNAPSHOT</version>

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

</project>

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1.创建spring控制的资源-->
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl"/>

</beans>

UserServiceImpl.java

package com.itheima.service.impl;

import com.itheima.service.UserService;

public class UserServiceImpl implements UserService {
   
    public void save() {
        System.out.println("user service running...");
    }
}

UserApp.java

import com.itheima.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserApp {
    public static void main(String[] args) {
        //2.加载配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //3.获取资源
        UserService userService = (UserService) ctx.getBean("userService");
        userService.save();
    }
}

4. IoC配置（XML格式）

4.1 bean标签 id, class, name 属性

id和name本质上其实是相同的，都可以唯一地标识一个bean。区别是id只能定义一个值，name可以定义多个值（separated by a comma (,), semicolon (😉, or white space）。

1. 配置一个bean的时候，可以不设置id，也可以不设置name，spring默认会使用类的全限定名作为bean的标识符。
2. 如果设置id属性，那么id就是bean的唯一标识符，在spring容器中必需唯一。
3. 如果仅设置name属性，那么name就是bean的唯一标识符，必需在容器中唯一。
4. 如果同时设置id和name，那么id是唯一标识符，name是别名。如果id和name的值相同，那么spring容器会自动检测并消除冲突：让这个bean只有标识符，而没有别名。
5. name属性设置多个值且不设置id属性，那么第一个被用作标识符，其他的被视为别名。如果设置了id，那么name的所有值都是别名。
6. 不管是标识符，还是别名，在容器中必需唯一。因为标识符和别名，都是可以用来获取bean的，如果不唯一，显然不知道获取的到底是哪儿一个bean。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean基本属性id,name,class实验-->
    <!-- bean基本属性id,name,class实验 -->
    <!-- bean基本属性id,name,class实验 -->
    <!-- bean基本属性id,name,class实验 -->
    <!-- bean可以定义多个名称，使用name属性完成，中间使用,分割-->
    <bean id="userService" name="userService1,userService2" class="com.itheima.service.impl.UserServiceImpl"/>


</beans>

import com.itheima.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserApp {
    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService1 = (UserService) ctx.getBean("userService");
        UserService userService2 = (UserService) ctx.getBean("userService1");
        UserService userService3 = (UserService) ctx.getBean("userService2");
        System.out.println(userService1);
        System.out.println(userService2);
        System.out.println(userService3);
        
    }
}

4.2 bean标签scope 属性

• scope="singleton"默认值， Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象
• scope="prototype"原型， Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象 。
• scope=request、session、application、websocket ：设定创建出的对象放置在web容器对应的位置

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean创建后的对象是多实例的 -->
    <!--<bean id="userService3" scope="prototype" class="com.itheima.service.impl.UserServiceImpl"/>-->
    
    <!--默认值 单利-->
    <bean id="userService3" scope="singleton" class="com.itheima.service.impl.UserServiceImpl"/>

</beans>

4.3 bean标签声明周期 （了解）

• bean标签 init-method=“init方法名” destroy-method=“destroy方法名”

• 不能带有形参

• 取值：bean对应的类中对应的具体方法名

• 注意事项：

  ◆ 当scope=“singleton”时，spring容器中有且仅有一个对象，init方法在创建容器时仅执行一次

  ◆ 当scope=“prototype”时，spring容器要创建同一类型的多个对象，init方法在每个对象创建 时均执行一次

  ◆ 当scope=“singleton”时，关闭容器会导致bean实例的销毁，调用destroy方法一次

  ◆ 当scope=“prototype”时，对象的销毁由垃圾回收机制gc()控制，destroy方法将不会被执行

<bean init-method="init" destroy-method="destroy></bean>

package com.itheima.service.impl;

import com.itheima.service.UserService;

public class UserServiceImpl implements UserService {

    public UserServiceImpl(){
        System.out.println(" constructor is running...");
    }

    public void init(){
        System.out.println("init....");
    }

    public void destroy(){
        System.out.println("destroy....");
    }

    public void save() {
        System.out.println("user service running...");
    }
}

4.4 bean对象创建方式（了解）

4.4.1 静态工厂创建bean对象

• class属性必须配置成静态工厂的包名.类名
• factory-method属性必须配置为静态工厂类创建对象的 静态方法

<!--静态工厂创建bean-->
<bean id="userService4" class="com.service.UserServiceFactory" factory-method="getService"/>

package com.service;

import com.service.impl.UserServiceImpl;

public class UserServiceFactory {
    public static UserService getService(){
        System.out.println("factory create object...");
        return new UserServiceImpl();
      }
}

4.4.2 实例工厂创建bean对象

• 使用实例工厂创建bean首先需要将实例工厂配置bean，交由spring进行管理
• factory-bean属性是实例工厂的beanId
• factory-method属性必须配置为静态工厂类创建对象的 普通方法

<!--实例工厂对应的bean-->
<bean id="factoryBean" class="com.service.UserServiceFactory2"/>

<!--实例工厂创建bean，依赖工厂对象对应的bean-->
<bean id="userService5" factory-bean="factoryBean" factory-method="getService" />

package com.service;

import com.service.impl.UserServiceImpl;

public class UserServiceFactory2 {

    public UserService getService(){
        System.out.println(" instance factory create object...");
        return new UserServiceImpl();
    }
}

4.5 依赖注入（DI）

4.5.1 setter注入（推荐）

• property 标签

• 属性：

  ◆ name：对应bean中的属性名，要求该属性必须提供可访问的set方法（严格规范为此名称是set方法对应名称）

  ◆ value：设定非引用类型属性对应的值，不能与ref同时使用

  ◆ ref：设定引用类型属性对应bean的id ，不能与value同时使用

• 注意：

  1）一个bean可以有多个property标签

  2）value 或 ref 设置为 类的属性名时，必须使用idea为属性提供setter 方法，因为spring底层基于setter方法完成的属性赋值；

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- set注入实验- -->
    <bean id="userService" class="com.impl.UserServiceImpl">
        <!--3.将要注入的引用类型的变量通过property属性进行注入，对应的name是要注入的变量名，使用ref属性声明要注入的bean的id-->
        <property name="userDao" ref="userDao"/>
        <property name="num" value="666"/>
        <property name="version" value="itheima"/>
    </bean>

</beans>

package com.itheima.service.impl;

import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;
import com.itheima.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private BookDao bookDao;
    private int num;
    private String version;

    public UserServiceImpl() {
    }

    public UserServiceImpl(UserDao userDao, int num, String version){
        this.userDao = userDao;
        this.num = num;
        this.version = version;
    }

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    public void setVersion(String version) {
        this.version = version;
    }
    public void setNum(int num) {
        this.num = num;
    }
    //1.对需要进行诸如的变量添加set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save() {
        System.out.println("user service running..."+num+" "+version);
        userDao.save();
        bookDao.save();
    }
}

4.5.2 构造器注入（了解）

• constructor-arg 标签

• 属性：

  ◆ name：对应bean中的构造方法所携带的参数名

  ◆ value：设定非引用类型属性对应的值，不能与ref同时使用

  ◆ ref：设定引用类型属性对应bean的id ，不能与value同时使用

  ◆ index（了解）：指定参数索引下标进行指定赋值, 默认从 0 开始。

  ◆ type （了解）：设定构造方法参数的类型，用于按类型匹配参数或进行类型校验

• 注意：

  1）一个bean可以有多个constructor-arg标签

  2）name 与 index 不推荐结合使用

  3）构造输入时，index 或 name 任选其一进行使用，不推荐采用默认的一致顺序或类型来赋值；

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.impl.UserServiceImpl">
        <!--使用构造方法进行set注入，需要保障注入的属性与bean中定义的属性一致-->
        <!--一致指顺序一致或类型一致或使用index解决该问题-->
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="num" value="666666"/>
        <constructor-arg name="version" value="itcast"/>
    </bean>

    <!-- 了解即可 -->
    <bean id="userDao" class="com.impl.UserDaoImpl">
        <constructor-arg index="2" value="123"/>
        <constructor-arg index="1" value="root"/>
        <constructor-arg index="0" value="com.mysql.jdbc.Driver"/>
    </bean>

</beans>

package com.itheima.service.impl;

import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;
import com.itheima.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    private BookDao bookDao;
    private int num;
    private String version;

    public UserServiceImpl() {
    }

    public UserServiceImpl(UserDao userDao, int num, String version){
        this.userDao = userDao;
        this.num = num;
        this.version = version;
    }

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    public void setVersion(String version) {
        this.version = version;
    }
    public void setNum(int num) {
        this.num = num;
    }
    //1.对需要进行诸如的变量添加set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save() {
        System.out.println("user service running..."+num+" "+version);
        userDao.save();
        bookDao.save();
    }
}

4.5.3 集合类型注入（了解）

• array，list，set，map，props 标签

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 集合注入顺序实验- -->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <!-- list注入 -->
        <property name="al">
            <list>
                <value>itheima</value>
                <value>66666</value>
            </list>
        </property>
        
        <!-- properties注入 -->
        <property name="properties">
            <props>
                <prop key="name">itheima666</prop>
                <prop key="value">666666</prop>
            </props>
        </property>
        
        <!-- array注入 -->
        <property name="arr">
            <array>
                <value>123456</value>
                <value>66666</value>
            </array>
        </property>
        
        <!-- set注入 -->
        <property name="hs">
            <set>
                <value>itheima</value>
                <value>66666</value>
            </set>
        </property>
        
        <!-- map注入 -->
        <property name="hm">
            <map>
                <entry key="name" value="itheima66666"/>
                <entry key="value" value="6666666666"/>
            </map>
        </property>
    </bean>


</beans>

package com.itheima.dao.impl;

import com.itheima.dao.BookDao;

import java.util.*;

public class BookDaoImpl implements BookDao {

    private List al;
    private Properties properties;
    private int[] arr;
    private Set hs;
    private Map hm ;

    public void setAl(List al) {
        this.al = al;
    }

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

    public void setArr(int[] arr) {
        this.arr = arr;
    }

    public void setHs(Set hs) {
        this.hs = hs;
    }

    public void setHm(Map hm) {
        this.hm = hm;
    }
}

4.5.4 p命名空间 （了解）

• beans 标签引入：xmlns:p=“http://www.springframework.org/schema/p”
• 语法：p:属性名-ref=“属性值beanid”, 例如：p:userDao-ref=“userDao” userDao是真实存在bean标签id 属性值。
• 好处：简化我们bean标签的抒写，内容过多也不利于阅读
• 如果是给该类String int 等类型赋值格式如下：p:属性名-ref=“属性值”, 例如：p:userName=“张三” p:passWord=“123456”, 类中可以有String userName; int passWord; 两个属性；

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 构造器注入实验- -->
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
        <constructor-arg index="2" value="123"/>
        <constructor-arg index="1" value="root"/>
        <constructor-arg index="0" value="com.mysql.jdbc.Driver"/>
    </bean>
   
    <!-- 集合注入顺序实验- -->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"> 
    </bean>


    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <property name="bookDao" ref="bookDao"/>
    </bean>
    <!-- p命名空间简化注入书写实验- -->
    <bean
        id="userService"
        class="com.itheima.service.impl.UserServiceImpl"
        p:userDao-ref="userDao"
        p:bookDao-ref="bookDao"
        />

</beans>

4.5.5 SpEl表达式注入 （了解）

• 所有格式统一使用 value=“********”

  ◆ 常量 #{10} #{3.14} #{2e5} #{‘itcast’}

  ◆ 引用bean #{beanId}

  ◆ 引用bean属性 #{beanId.propertyName}

  ◆ 引用bean方法 #{beanId.methodName()}

  …

• 用处：所有类型的注入都是value属性来完成，替代掉ref 属性。

• 最后：spel 用的不多，了解即可。

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 构造器注入实验- -->
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
     </bean>
    <!-- 构造器注入实验- -->
    <bean id="bookDao" class="com.itheima.dao.impl.UserDaoImpl">   
    </bean>
    
   <!-- Spring EL表达式实验- -->
    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
        <property name="userDao" value="#{userDao}"/>
        <property name="bookDao" value="#{bookDao}"/>
        <property name="num" value="#{666666666}"/>
        <property name="version" value="#{'itcast'}"/>
    </bean>
</beans>

4.5.6 读取外部properties文件信息

• 引入命名空间

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

• 配置properties文件

  <?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:p="http://www.springframework.org/schema/p"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
          https://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          https://www.springframework.org/schema/context/spring-context.xsd">
  
      <!-- 加载properties文件属性实验- -->
      <!--加载配置文件: 模糊匹配-->
      <context:property-placeholder location="classpath:*.properties"/>
      
      <!--加载配置文件：带文件夹层级模糊匹配 -->
      <context:property-placeholder location="classpath:*/*.properties"/>
      
      <!--加载配置文件：指定文件夹 -->
      <context:property-placeholder location="classpath:config/jdbc.properties"/>
      
      <!-- 加载配置文件：指定文件 -->
      <context:property-placeholder location="classpath:jdbc.properties"/>
  
      <bean id="userDao" class="com.dao.impl.UserDaoImpl">
          <property name="userName" value="${username}"/>
          <property name="password" value="${pwd}"/>
      </bean>
  
  </beans>
  

• 注意事项：${} 要被 “” 号包裹起来, {} 中的文本应该为properties文件中的key.

4.5.7 import导入配置文件

• import 标签

• 属性:

  1）resource：加载的配置路径，如果有文件夹名，则：文件夹名称/文件名.xml

• <!-- applicationContext.xml 文件内容如下 -->
  <beans .....此处省略>
      
      <!-- 团队合作import实验- -->
      <import resource="applicationContext-user.xml"/>
      <import resource="applicationContext-book.xml"/>
  
  </beans>
  

  new ClassPathXmlApplicationContext("applicationContext.xml");
  

• Spring容器也可以加载多个配置文件（了解）

  new ClassPathXmlApplicationContext("applicationContext-user.xml","applicationContext-book.xml");       
  

• Spring容器中的bean定义冲突问题

◆ 同id的bean，后定义的覆盖先定义的

◆ 导入配置文件可以理解为将导入的配置文件复制粘贴到对应位置

◆ 导入配置文件的顺序与位置不同可能会导致最终程序运行结果不同

注意：相同名称bean id 不允许在同一个xml配置文件中配置两次，import 引入的外部bean id 可以；

4.5.8 ApplicationContext 层次结构 （了解）

ApplicationContext

• ApplicationContext是一个接口，提供了访问spring容器的API

• ClassPathXmlApplicationContext是一个类，实现了上述功能

• ApplicationContext的顶层接口是BeanFactory

• BeanFactory定义了bean相关的最基本操作

• ApplicationContext在BeanFactory基础上追加了若干新功能

对比BeanFactory

• BeanFactory创建的bean采用延迟加载形式，使用才创建
• ApplicationContext创建的bean默认采用立即加载形式

FileSystemXmlApplicationContext

• 可以加载文件系统中任意位置的配置文件，而ClassPathXmlApplicationContext只能加载类路径下的配置文件

4.5.9 三方jar 类bean配置

• 注意:

  1）三方类中定义的属性名

  2）三方类构造方法是什么情况，有无参数，setter/构造方法赋值

<!-- applicationContext.xml 文件内容如下 -->
<beans .....此处省略>
    
    <!-- 加载第三方类库资源实验- -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
        <property name="username" value="root"/>
        <property name="password" value="itheima"/>
    </bean>
</beans>

import com.alibaba.druid.pool.DruidDataSource;
import com.itheima.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserApp {

    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        DruidDataSource dataSource = (DruidDataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

5. 综合案例-用spring整合mybatis

整合前基础准备工作

1. spring配置文件，加上context命名空间，用于加载properties文件
2. 开启加载properties文件
3. 配置数据源druid（备用）
4. 定义service层bean，注入dao层bean
5. dao的bean无需定义，使用代理自动生成

整合工作

1. 导入Spring整合MyBatis坐标

2. 将mybatis配置成spring管理的bean（SqlSessionFactoryBean）

   ◆ 将原始配置文件中的所有项，转入到当前配置中

   ​ ◼ 数据源转换

   ​ ◼ 映射转换

​ 3.通过spring加载mybatis的映射配置文件到spring环境中

​ 4.设置类型别名

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>Spring_day01_05_（spring整合mybatis）</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.3</version>
    </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        
        <!-- 该jar包为了我们做了很多事情 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
    </dependencies>

</project>

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

    <!--加载perperties配置文件的信息-->
    <context:property-placeholder location="classpath:*.properties"/>

    <!--加载druid资源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--配置service作为spring的bean,注入dao-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!--spring整合mybatis后控制的创建连接用的对象-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.itheima.domain"/>
    </bean>

    <!--加载mybatis映射配置的扫描，将其作为spring的bean进行管理-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurerss">
        <property name="basePackage" value="com.itheima.dao"/>
    </bean>


</beans>

总结

⚫ 需要专用的spring整合mybatis的jar包

⚫ Mybatis核心配置文件消失

​ ◼ 环境environment转换成数据源对象

​ ◼ 映射Mapper扫描工作交由spring处理

​ ◼ 类型别名交由spring处理

⚫ 业务发起使用spring上下文对象获取对应的bean