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

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 1024 设计师:上身试试 返回首页