Spring1

Spring技术是JavaEE开发必备技能，企业开发技术选型命中率>90%。
专业角度：
　　简化开发，降低企业级开发的复杂性。
　　框架整合，高效整合其他技术，提高企业级应用开发与运行效率。

Spring Framework系统架构
　　Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基。

Spring核心概念

代码书写现状：耦合度偏高
解决方案：使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象
IoC（Inversion of Control）控制反转：对象的创建控制权由程序转移到外部，这种思想称为控制反转

IoC（Inversion of Control）控制反转

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转

Spring技术对IoC思想进行了实现
　　Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的“外部”
　　IoC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

DI（Dependency Injection）依赖注入

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

目标：充分解耦
　　使用IoC容器管理bean（IoC)
　　在IoC容器内将有依赖关系的bean进行关系绑定（DI）
最终效果：使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

IOC和DI入门案例（重点）

Ioc入门案例

1、在pom.xml中导入Spring坐标

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

2、定义Spring管理的类（接口）
　　BookDao接口和BookDaoImpl实现类

public interface BookDao {
    public void save();
}

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

　　BookService接口和BookServiceImpl实现类

public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

3、创建Spring配置文件，配置对应类作为Spring管理的bean对象
　　在resources下定义applicationContext.xml配置文件并配置BookServiceImpl

<?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标签：表示配置bean
        id属性：表示给bean起名字
        class属性：表示给bean定义类型
    -->
    <bean id="bookService" class="com.test.service.impl.BookServiceImpl"></bean>

</beans>

　　注：bean定义时id属性在同一个上下文中(IOC容器中)不能重复
4、初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象

public class App {
    public static void main(String[] args) {
        //1.创建IoC容器对象，加载spring核心配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC容器中获取Bean对象(BookService对象)
        BookService bookService= (BookService)ctx.getBean("bookService");
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();  //book service save ...  book dao save ...
    }
}

DI入门案例

1、删除使用new的形式创建对象的代码

public class BookServiceImpl implements BookService {
    private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

2、提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //【第二步】提供依赖对象对应的setter方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

3、配置service与dao之间的关系
　　在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标签：表示配置bean
        id属性：表示给bean起名字
        class属性：表示给bean定义类型
    -->
    <bean id="bookDao" class="com.test.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.test.service.impl.BookServiceImpl">
        <!--配置server与dao的关系
            property标签：表示配置当前bean的属性
            name属性：表示配置哪一个具体的属性
            ref属性：表示参照哪一个bean
        -->
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

　　图解演示

　　

bean

bean配置

bean基础配置（重点）

Bean别名配置

注：获取bean无论是通过id还是name获取，如果无法获取到，将抛出异常NoSuchBeanDefinitionException
　　NoSuchBeanDefinitionException: No bean named 'bookServiceImpl' available

Bean作用范围配置（重点）

扩展：scope的取值不仅仅只有singleton和prototype，还有request、session、application、 websocket ，表示创建出的对象放置在web容器(tomcat)对应的位置。比如：request表示保存到request域中。
注：在我们的实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性。

bean实例化

bean本质上就是对象，创建bean使用构造方法完成

实例化bean的三种方式——构造方法（常用）

BookDaoImpl实现类-提供可访问的构造方法（默认，可不写）

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

applicationContext.xml配置

<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl"/>

无参构造方法如果不存在，将抛出异常BeanCreationException

实例化bean的三种方式——静态工厂（了解）

OrderDao接口和OrderDaoImpl实现类

public interface OrderDao {
    public void save();
}
public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}

OrderDaoFatory工厂类

//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}

applicationContext.xml配置

<bean id="orderDao" class="com.test.factory.OrderDaoFactory" factory-method="getOrderDao"/>

实例化bean的三种方式——实例工厂（了解）

UserDao接口和UserDaoImpl实现类

public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}

UserDaoFactory工厂类

//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

applicationContext.xml配置

<bean id="userFactory" class="com.test.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

实例化bean的第四种方式————实现FactoryBean<T>方式（扩展,了解）

定义UserDaoFactoryBean实现FactoryBean<UserDao>
　　UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
}

applicationContext.xml配置

<bean id="userDao" class="com.test.factory.UserDaoFactoryBean"/>

Bean的生命周期【了解】

生命周期：从创建到消亡的完整过程。
bean生命周期：bean从创建到销毁的整体过程。
bean生命周期控制：在bean创建后到销毁前做一些事情。

Bean生命周期控制

1、提供生命周期控制方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
}

applicationContext.xml配置

<!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名-->
<!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名-->
<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

测试类

public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //关闭容器，执行销毁的方法
        ctx.close();
    }
}

2、实现InitializingBean, DisposableBean接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}

初始化容器
　　1.创建对象（内存分配）
　　2.执行构造方法
　　3.执行属性注入（set操作）
　　4.执行bean初始化方法
使用bean
　　1.执行业务操作
关闭/销毁容器
　　1.执行bean销毁方法

Bean销毁时机

容器关闭前触发bean的销毁。
关闭容器方式：
　　手工关闭容器；
　　　　ConfigurableApplicationContext接口close()操作
　　注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机。
　　　　ConfigurableApplicationContext接口registerShutdownHook()操作

public class AppForLifeCycle {
    public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //注册关闭钩子函数，在虚拟机退出之前回调此函数，关闭容器
        ctx.registerShutdownHook();
        //关闭容器
        //ctx.close();
    }
}

依赖注入(DI配置)

依赖注入方式（重点）

依赖注入的两种方式：
1、setter注入
　　简单类型
　　引用类型(很常用)
2、构造器注入
　　简单类型
　　引用类型

1.1 setter注入——引用类型

在bean中定义引用类型属性并提供可访问的set方法

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

配置中使用property标签ref属性注入引用类型对象

<bean id="bookService" class="com.test.service.impl.BookServiceImpl">   
    <property name="bookDao" ref="bookDao"/>
</bean>
<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl"/>

1.2 setter注入——简单类型

在bean中定义简单类型属性并提供可访问的set方法

public class BookDaoImpl implements BookDao {
    private int connectionNumber;
    public void setConnectionNumber(int connectionNumber) {
        this.connectionNumber = connectionNumber;
    }
}

配置中使用property标签value属性注入简单类型数据

<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl">
    <property name="connectionNumber" value="10"/>
</bean>

2.1 构造器注入——引用类型

在bean中定义引用类型属性并提供可访问的构造方法

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

配置中使用constructor-arg标签ref属性注入引用类型对象

<bean id="bookService" class="com.test.service.impl.BookServiceImpl">
    <constructor-arg name="bookDao" ref="bookDao"/>
</bean>
<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl"/>

2.2 构造器注入——简单类型

在bean中定义简单类型属性并提供可访问的构造方法

public class BookDaoImpl implements BookDao {
    private int connectionNumber;   
    public void BookDaoImpl(int connectionNumber) {      
        this.connectionNumber = connectionNumber;   
    }
}

配置中使用constructor-arg标签value属性注入简单类型数据

<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl">
    <constructor-arg name="connectionNumber" value="10"/>
</bean>

2.3 构造器注入——参数适配（了解）

配置中使用constructor-arg标签type属性设置按形参类型注入

<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl">
    <constructor-arg type="int" value="10"/>
    <constructor-arg type="java.lang.String" value="mysql"/>
</bean>

配置中使用constructor-arg标签index属性设置按形参位置注入

<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl">
    <constructor-arg index="0" value="10"/>
    <constructor-arg index="1" value="mysql"/>
</bean>

依赖注入方式选择

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

依赖自动装配（理解）

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配
自动装配方式：
　　按类型（常用）
　　按名称
　　按构造方法
　　不启用自动装配

配置中使用bean标签autowire属性设置自动装配的类型

<bean id="bookDao" class="com.test.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.test.service.impl.BookServiceImpl" autowire="byType"/>

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

集合注入

注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>

注入List类型数据

<property name="list">
    <list>
        <value>itcast</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>

注入Set类型数据

<property name="set">
    <set>
        <value>itcast</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>

注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>

注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

注：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签。

第三方资源配置管理

管理DataSource连接池对象

管理Druid连接池（重点）

在pom.xml中添加Druid连接池依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

配置DruidDataSource连接池Bean对象

<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="root"/>
</bean>

在测试类中从IOC容器中获取连接池对象并打印

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

管理c3p0连接池

在pom.xml中添加c3p0连接池依赖

<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>

配置c3p0连接池Bean对象

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
    <property name="maxPoolSize" value="1000"/>
</bean>

在测试类中从IOC容器中获取连接池对象并打印

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

加载properties属性文件（重点）

目的：将数据库的连接参数抽取到一个单独的文件中，与Spring配置文件解耦。

基本用法

编写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

在applicationContext.xml中开启context命名空间，加载jdbc.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: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">
</beans>

使用context命名空间，加载指定properties文件

<context:property-placeholder location="jdbc.properties"/>

在配置连接池Bean的地方使用EL表达式获取jdbc.properties属性文件中的值

<bean 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>

配置不加载系统属性

如果属性文件中配置的不是jdbc.username，而是username=root666，那么使用${username}获取到的不是root666，而是计算机的名称。
原因：系统属性的优先级比我们属性文件中的高，替换了我们的username=root666。
解决：
　　解决1：换一个名称，例如不叫username，叫jdbc.username。
　　解决2：使用system-properties-mode="NEVER"属性表示不使用系统属性。

<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

加载properties文件写法

不加载系统属性

<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>

加载多个properties文件

<context:property-placeholder location="jdbc.properties,msg.properties"/>

加载所有properties文件

<context:property-placeholder location="*.properties"/>

加载properties文件-标准格式

<context:property-placeholder location="classpath:*.properties"/>

从类路径或jar包中搜索并加载properties文件

<context:property-placeholder location="classpath*:*.properties"/>

Spring容器

创建容器

方式一：类路径加载配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

方式二：文件路径加载配置文件

ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\applicationContext.xml");

加载多个配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("bean1.xml", "bean2.xml");

获取bean对象

方式一：使用bean名称获取（弊端：需要自己强制类型转换）

BookDao bookDao = (BookDao) ctx.getBean("bookDao");

方式二：使用bean名称获取并指定类型（推荐使用）

BookDao bookDao = ctx.getBean("bookDao", BookDao.class);

方式三：使用bean类型获取（如果IOC容器中同类型的Bean对象有多个，此处获取会报错）

BookDao bookDao = ctx.getBean(BookDao.class);

容器类层次结构

BeanFactory

类路径加载配置文件：

Resource resources = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resources);
BookDao bookDao = bf.getBean("bookDao", BookDao.class);
bookDao.save();

BeanFactory创建完毕后，所有的Bean均为延迟加载，也就是说我们调用getBean()方法获取Bean对象时才创建Bean对象并返回给我们。
ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载。

核心容器总结

bean相关

依赖注入相关

Spring注解开发

注解开发定义Bean对象（重点）

 基本使用

1、在applicationContext.xml中开启Spring注解包扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
     <!--扫描com.test包及其子包下的类中注解-->
    <context:component-scan base-package="com.test"/>
</beans>

2、在类上使用@Component注解定义Bean

@Component("bookDao")
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
@Component
public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

补充说明：如果@Component注解没有使用参数指定Bean的名称，那么类名首字母小写就是Bean在IOC容器中的默认名称。例如：BookServiceImpl对象在IOC容器中的名称是bookServiceImpl。
3、在测试类中获取Bean对象

public class AppForAnnotation {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        //按类型获取bean
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

@Component三个衍生注解

Spring提供@Component注解的三个衍生注解：
　　@Controller：用于表现层bean定义
　　@Service：用于业务层bean定义
　　@Repository：用于数据层bean定义

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
}

@Service
public class BookServiceImpl implements BookService {
}

纯注解开发模式（重点）

Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道。
Java类代替Spring核心配置文件：

　　@Configuration注解用于设定当前类为配置类
　　@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式

@ComponentScan({com.test.service","com.test.dao"})

读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

//加载配置文件初始化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

注解开发Bean作用范围和生命周期管理

bean作用范围注解配置

使用@Scope定义bean作用范围

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
}

bean生命周期注解配置

使用@PostConstruct、@PreDestroy定义bean生命周期

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor ...");
    }
    @PostConstruct
    public void init(){
        System.out.println("book init ...");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("book destory ...");
    }
}

注：@PostConstruct和@PreDestroy注解是jdk中提供的注解，从jdk9开始，jdk中的javax.annotation包被移除了，也就是说这两个注解就用不了了，可以额外导入一下依赖解决这个问题。

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>

注解开发依赖注入（重点）

使用@Autowired注解开启自动装配模式（按类型）

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用类型，自动装配模式，默认按类型装配
    @Autowired
    private BookDao bookDao;
}

说明：不管是使用配置文件还是配置类，都必须进行对应的Spring注解包扫描才可以使用。@Autowired默认按照类型自动装配，如果IOC容器中同类的Bean有多个，那么默认按照变量名和Bean的名称匹配，建议使用@Qualifier注解指定要装配的bean名称
注：
　　自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供setter方法。
　　自动装配建议使用无参构造方法创建对象（默认），如果不提供对应构造方法，请提供唯一的构造方法。

使用@Qualifier注解指定要装配的bean名称

目的：解决IOC容器中同类型Bean有多个装配哪一个的问题

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用类型，自动装配模式，默认按类型装配
    @Autowired
    //@Qualifier：自动装配bean时按bean名称装配
    @Qualifier("bookDao")
    private BookDao bookDao;
}

注：@Qualifier注解无法单独使用，必须配合@Autowired注解使用

使用@Value实现简单类型注入

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("100")
    private String connectionNum;
}

加载properties文件

jdbc.properties属性文件：

name=spring

使用@PropertySource注解加载properties文件:

@Configuration
@ComponentScan("com.test")
//@PropertySource加载properties配置文件
@PropertySource({"classpath:jdbc.properties"}) //单文件{}可以省略不写；多文件使用{}
public class SpringConfig {
}

注：@PropertySource()中加载多文件请使用数组格式配置，不允许使用通配符*
@Value注解中使用${name}从属性文件中读取name值：

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    //@Value：注入简单类型（无需提供set方法）
    @Value("${name}")
    private String name;

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

注解开发管理第三方Bean（重点）

第三方bean管理

使用@Bean配置第三方bean

@Configuration
public class SpringConfig {
    //@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

使用独立的配置类管理第三方bean

方式一：导入式

public class JdbcConfig {
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

使用@Import注解手动加入配置类到核心配置，此注解只能添加一次，多个数据请用数组格式

@Configuration
//@Import:导入配置信息
@Import({JdbcConfig.class})
public class SpringConfig {
} 

方式二：扫描式（不推荐，在SpringConfig和JdbcConfig等中有多个@Configuration配置类）

@Configuration
public class JdbcConfig {
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

使用@ComponentScan注解扫描配置类所在的包，加载对应的配置类信息

@Configuration
@ComponentScan({"com.test.config","com.test.service","com.test.dao"})  //只要com.test.config包扫到了就行，三个包可以合并写成com.test
public class SpringConfig {
}

第三方bean依赖注入（重点）

简单类型依赖注入

public class JdbcConfig {
    //1.定义一个方法获得要管理的对象
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db")
    private String url;
    @Value("root")
    private String userName;
    @Value("root")
    private String password;
    //2.@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

说明：如果@Value()中使用了EL表达式读取properties属性文件中的内容，那么就需要加载properties属性文件。

引用类型依赖注入

//Spring会自动从IOC容器中找到BookDao对象赋值给参数bookDao变量，如果没有就会报错。
@Bean 
public DataSource dataSource(BookDao bookDao){
    System.out.println(bookDao);
    DruidDataSource ds = new DruidDataSource();
    ds.setDriverClassName(driver);
    ds.setUrl(url);
    ds.setUsername(userName);
    ds.setPassword(password);
    return ds;
}

说明：引用类型注入只需要为bean定义方法设置形参即可，容器会根据类型自动装配对象

XML配置与注解配置比较

Spring整合其他技术【重点】

Spring整合mybatis【重点】

前置工作

1. 在pom.xml中添加spring-context、druid、mybatis、mysql-connector-java等基础依赖。
2. 准备service和dao层基础代码：

public interface AccountService {
    void save(Account account);
    void delete(Integer id);
    void update(Account account);
    List<Account> findAll();
    Account findById(Integer id);
}
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;
    
    public void save(Account account) {
        accountDao.save(account);
    }
    public void update(Account account){
        accountDao.update(account);
    }
    public void delete(Integer id) {
        accountDao.delete(id);
    }
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }
    public List<Account> findAll() {
        return accountDao.findAll();
    }
}
public interface AccountDao {
    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);
    
    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);

    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);

    @Select("select * from tbl_account")
    List<Account> findAll();

    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

【第一步】在pom.xml中导入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>

【第二步】创建JdbcConfig配置DataSource数据源

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root

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;
    }
}

【第三步】创建MybatisConfig整合mybatis

public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.test.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.test.dao");
        return msc;
    }
}

使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息

使用MapperScannerConfigurer加载Dao接口，创建代理对象保存到IOC容器中

【第四步】创建SpringConfig主配置类进行包扫描和加载其他配置类

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

【第五步】定义测试类进行测试

public class App {
    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);
    }
}

Spring整合Junit单元测试【重点】

【第一步】在pom.xml中导入整合的依赖坐标spring-test

<!--junit-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
<!--spring整合junit-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.1.9.RELEASE</version>
</dependency>

【第二步】使用Spring整合Junit专用的类加载器

【第三步】加载配置文件或者配置类

//【第二步】使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
//【第三步】加载配置文件或者配置类
@ContextConfiguration(classes = {SpringConfig.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));
    }
    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}

注：junit的依赖至少要是4.12版本,可以是4.13等版本,否则出现如下异常：