SSM框架（一）：Spring 容器

---

一、Spring Framework系统框架

二、IoC控制反转 与 DI依赖注入 简单入门

在pom.xml导入依赖

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

使用 IoC 与 DI 目的：applicationContext.xmlSpring的配置文件中实现bean与bean依赖关系（即DI依赖注入），将创建new一个对象的权限交给Ioc容器（即配置文件）。
applicationContext.xml 目的：配置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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--1.导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->

    <!--2.配置bean-->
    <!--bean标签标示配置bean
        id属性标示给bean起名字
        class属性表示给bean定义类型-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <!--7.配置server与dao的关系-->
        <!--property标签表示配置当前<bean>的属性
            name属性表示配置哪一个具体的属性:BookServiceImpl类的bookDao属性
            ref属性表示参照哪一个<bean>: applicationContext.xml中的id为bookDao的bean-->
        <property name="bookDao" ref="bookDao"/>
    </bean>

</beans>

APP2.java 目的：获取IoC容器，从容器中获取对象进行方法调用

public class App2 {
    public static void main(String[] args) {
        //3.获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //4.获取bean（根据bean配置id获取）
//        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
//        bookDao.save();

        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();

    }
}

BookServiceImpl.java 注意：要删除业务层的new，并且为属性提供setter方法

public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new的方式创建的dao对象
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //6.提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

BookDaoImpl.java

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

三、Bean

3.1 Bean的配置

基础配置

别名配置

作用范围配置

解释：单例模式下访问同一个bean的地址是相同的，非单例则相反

1. 为什么bean默认为单例?
   bean为单例的意思是在Spring的IoC容器中只会有该类的一个对象，bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高
2. bean在容器中是单例的，会不会产生线程安全问题?
   如果对象是有状态对象，即该对象有成员变量可以用来存储数据的，因为所有请求线程共用一个bean对象，所以会存在线程安全问题。
   如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的，因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
3. 哪些bean对象适合交给容器进行管理?
   表现层对象、业务层对象、数据层对象、工具对象
4. 哪些bean对象不适合交给容器进行管理?
   封装实例的域对象，因为会引发线程安全问题，所以不适合

3.2 实例化Bean的四种方式

1. 采用默认无参构造方法【默认，常用】
   

2. 通过静态工厂创建对象【了解】
   

3. 通过实例工厂创建对象
   

4. 通过FactoryBean创建对象【第三种的改良】【要求掌握】；默认单例模式，要改成多例模式，实现FactoryBean的isSingleton() 方法，将其设置为true
   

3.3 Bean的生命周期

bean其实就是一个对象，bean的生命周期指的就是bean对象从创建到销毁的整体过程。bean生命周期控制就是在bean创建后到销毁前做一些事情。
方式一：自定义init和destory方法

方式二：接口配置【了解】

销毁bean的时机

四、依赖注入

4.1 setter注入

4.2 构造器注入

注意：因为构造器注入< constructor-arg >的name属性匹配的是构造器的形参名，耦合度过高，可以使用type（代表参数类型）和index（代表参数位置）属性匹配参数

4.3 注入方式选择

1. 强制依赖（必须要new的参数）使用构造器进行，因为使用setter注入有概率不进行注入导致null对象出现；强制依赖指对象在创建的过程中必须要注入指定的参数
2. 可选依赖使用setter注入进行，灵活性强；可选依赖指对象在创建过程中注入的参数可有可无
3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
5. 实际开发过程中还要根据实际情况分析，别人提供提供setter方法就用setter注入，提供构造器就使用构造器注入
6. 自己开发的模块推荐使用setter注入

4.4 依赖自动装配

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配。

自动装配方式有哪些?

1. 按类型（常用）：autowire=“byType”
2. 按名称：autowire=“byName”
3. 按构造方法：autowire=“constructor”
4. 不启用自动装配：autowire=“no”

注意：

1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

4.5 集合注入

前面我们已经能完成引用数据类型和简单数据类型的注入，但是还有一种数据类型集合，集合中既可以装简单数据类型也可以装引用数据类型，对于集合，在Spring中该如何注入呢?
先来回顾下，常见的集合类型有哪些?数组、List、Set、Map、Properties

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">
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <!--数组注入-->
        <property name="array1">
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
        <!--list集合注入-->
        <property name="list1">
            <list>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>chuanzhihui</value>
            </list>
        </property>
        <!--set集合注入-->
        <property name="set1">
            <set>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>boxuegu</value>
            </set>
        </property>
        <!--map集合注入-->
        <property name="map1">
            <map>
                <entry key="country" value="china"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <!--Properties注入-->
        <property name="properties1">
            <props>
                <prop key="country">china</prop>
                <prop key="province">henan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>
</beans>

BookDaoImpl

package com.itheima.dao.impl;

import com.itheima.dao.BookDao;

import java.util.*;

public class BookDaoImpl implements BookDao {

    private int[] array1;

    private List<String> list1;

    private Set<String> set1;

    private Map<String,String> map1;

    private Properties properties1;




    public void setArray(int[] array) {
        this.array1 = array;
    }

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

    public void setSet(Set<String> set) {
        this.set1 = set;
    }

    public void setMap(Map<String, String> map) {
        this.map1 = map;
    }

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




    public void save() {
        System.out.println("book dao save ...");

        System.out.println("遍历数组:" + Arrays.toString(array1));

        System.out.println("遍历List" + list1);

        System.out.println("遍历Set" + set1);

        System.out.println("遍历Map" + map1);

        System.out.println("遍历Properties" + properties1);
    }
}

4.6 案例：配置数据库

4.7、加载Properties文件

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

    <!--    1.开启context命名空间-->
    <!--    2.使用context空间加载properties文件-->
    <context:property-placeholder location="jdbc.properties"/>
    <!--    <context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>-->
    <!--    <context:property-placeholder location="jdbc.properties,jdbc2.properties" system-properties-mode="NEVER"/>-->
    <!--    classpath:*.properties  ：   设置加载当前工程类路径中的所有properties文件-->
    <!--    system-properties-mode属性：是否加载系统属性-->
    <!--    <context:property-placeholder location="*.properties" system-properties-mode="NEVER"/>-->

    <!--classpath*:*.properties  ：  设置加载当前工程类路径和当前工程所依赖的所有jar包中的所有properties文件-->
    <!--    <context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>-->

    <!--    3.使用属性占位符${}读取properties文件中的属性-->
    <!--    说明：idea自动识别${}加载的属性值，需要手工点击才可以查阅原始书写格式-->
    <bean id="dataSourse" 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>

</beans>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

五、容器总结

创建容器的两种方式

获取bean的三种方式

配置bean

依赖注入

六、注解开发模式【替代上述配置文件方式】

6.1 Java类【SpringConfig.java】替代配置文件【applicationContext.xml】

SpringConfig.java

// 声明当前类为Spring配置类
@Configuration
// 设置bean扫描路径，多个路径书写为字符串数组格式
@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}

6.2 注解开发bean

使用纯注解模式设置配置文件，就可不用写<context:component-san base-package=" ">

6.3 加载配置文件

AppForAnnotation.java

public class AppForAnnotation {
    public static void main(String[] args) {
        //AnnotationConfigApplicationContext加载Spring配置类初始化Spring容器
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        //按类型获取bean
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

6.4 bean的生命周期

@Repository
//@Scope设置bean的作用范围:singleton表示单例模式
@Scope("singleton")
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println("book dao save ...");
    }
    //@PostConstruct设置bean的初始化方法
    @PostConstruct
    public void init() {
        System.out.println("init ...");
    }
    //@PreDestroy设置bean的销毁方法
    @PreDestroy
    public void destroy() {
        System.out.println("destroy ...");
    }
}

6.5 依赖注入-自动装配与加载Properties文件

6.6 管理第三方bean

1. 在pom.xml中导入第三方库

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>

2. 定义一个配置类
   创建一个方法用于要管理的对象，使用**@Bean**注解表示当前方法的返回类型是一个Bean，简单类型使用@Value对成员变量进行注入，引用类型是自动注入但要写进方法的形参中

public class JdbcConfig {
    @Value("com.jdbc.mysql.Driver")
    private String dirver;
    @Value("jdbc:mysql://localhost:3306/mydb")
    private String url;
    @Value("root")
    private String username;
    @Value("root")
    private String password;
    @Bean
    public DataSource dataSourse(BookDao bookDao){
        System.out.println(bookDao);
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(dirver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

3. 在总配置类中导入
   使用**@Import注解导入自定义第三方配置类**

@Configuration
// 设置bean扫描路径，多个路径书写为字符串数组格式
@ComponentScan({"com.itheima.service","com.itheima.dao"})
@PropertySource("jdbc.properties")
@Import({JdbcConfig.class})
public class SpringConfig {
}

6.7 XML配置与注解配置比较

6.8 Spring整合mybatis

1. 导入Spring整合mybatis的坐标【注意不同坐标的版本有对应关系】

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
  </dependency>

  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.6</version>
  </dependency>

  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
  </dependency>
  <!-- 以下就是Spring整合mybatis的坐标-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
  </dependency>

  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.0</version>
  </dependency>

2. 配置jdbc的bean【DataSource】
   JdbcConfig.java

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

3. 将xml配置文件改成注解形式，即配置SqlSessionFactory与Mapper的bean【SqlSessionFactoryBean、MapperScannerConfigurer】
   

MybatisConfig.java

public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        // 这里的DataSource即第二步配置的bean,要写在方法的形参中,由系统自动装配
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

4. 导入上述第三方bean

@Configuration
@ComponentScan("com.itheima")
//@PropertySource：加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

5. 使用
   其中关于操作数据的domain、dao、service省略

public class App2 {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

        AccountService accountService = ctx.getBean(AccountService.class);

        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}

6.9 Spring整合Junit

导入坐标

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>