一 第三方資源配置管理

說明：以管理DataSource連接池對象為例講解第三方資源配置管理

1 管理DataSource連接池對象

問題導入

配置數(shù)據(jù)庫連接參數(shù)時，注入驅(qū)動類名是用driverClassName還是driver？

1.1 管理Druid連接池

數(shù)據(jù)庫準備

create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
    id int primary key auto_increment,
    name varchar(20),
    money double
);
insert into tbl_account values(null,'Tom',1000);
insert into tbl_account values(null,'Jerry',1000);

【第一步】添加Druid連接池依賴

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.20</version>
</dependency>

注意：除了添加以上兩個依賴之外，別忘了添加spring-context依賴。

【第二步】配置DruidDataSource連接池Bean對象

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=Asia/Shanghai&amp;rewriteBatchedStatements=true"/>
    <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);
    }
}

打印結(jié)果

1.2 管理c3p0連接池

【第一步】添加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.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf8&amp;useSSL=false&amp;serverTimezone=Asia/Shanghai&amp;rewriteBatchedStatements=true"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

注意：同一個Spring容器中不能有兩個id="dataSource"的連接池。

【第三步】在測試類中從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);
    }
}

運行結(jié)果：

com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 0, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, dataSourceName -> 1hge0yzax1fmo0yo1qse2m7|4f7d0008, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.cj.jdbc.Driver, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, identityToken -> 1hge0yzax1fmo0yo1qse2m7|4f7d0008, idleConnectionTestPeriod -> 0, initialPoolSize -> 3, jdbcUrl -> jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 0, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 15, maxStatements -> 0, maxStatementsPerConnection -> 0, minPoolSize -> 3, numHelperThreads -> 3, numThreadsAwaitingCheckoutDefaultUser -> 0, preferredTestQuery -> null, properties -> {user=******, password=******}, propertyCycle -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, usesTraditionalReflectiveProxies -> false ]

2 加載properties屬性文件

目的：將數(shù)據(jù)庫的連接參數(shù)抽取到一個單獨的文件中，與Spring配置文件解耦。

問題導入

問題1：如何解決使用EL表達式讀取屬性文件中的值結(jié)果讀取到了系統(tǒng)屬性問題？
問題2：加載properties文件寫法標準寫法該怎么寫？

2.1 基本用法

【第一步】編寫jdbc.properties屬性文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
jdbc.username=root
jdbc.password=root

【第二步】在applicationContext.xml中開啟開啟context命名空間，加載jdbc.properties屬性文件

小技巧：如果同學們覺得上述復制粘貼方式不好改或者容易改錯，其實idea是有提示功能的，注意不要選錯就行了。有些版本的idea沒有這個提示，那么就按照上面復制粘貼的方式改，改完之后可以做成live template模板，后期直接用。

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

配置完成之后，運行之前的獲取Druid連接池代碼，可以獲取到連接池對象就表示配置成功。

2.2 配置不加載系統(tǒng)屬性

問題

如果屬性文件中配置的不是jdbc.username，而是username=root666，那么使用${username}獲取到的不是root666，而是計算機的名稱。

原因

系統(tǒng)屬性的優(yōu)先級比我們屬性文件中的高，替換了我們的username=root666。

解決

解決1：換一個名稱，例如不叫username，叫jdbc.username。

解決2：使用system-properties-mode="NEVER"屬性表示不使用系統(tǒng)屬性。

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

2.3 加載properties文件寫法

• 不加載系統(tǒng)屬性

<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容器

1 Spring核心容器介紹

問題導入

問題：按照Bean名稱獲取Bean有什么弊端，按照Bean類型獲取Bean有什么弊端？

1.1 創(chuàng)建容器

• 方式一：類路徑加載配置文件

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

• 方式二：文件路徑加載配置文件

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

• 加載多個配置文件

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

1.2 獲取bean對象

• 方式一：使用bean名稱獲取
  • 需要自己強制類型轉(zhuǎn)換

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

• 方式二：使用bean名稱獲取并指定類型
  • 推薦使用

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

• 方式三：使用bean類型獲取
  • 如果IOC容器中同類型的Bean對象有多個，此處獲取會報錯

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

1.3 容器類層次結(jié)構(gòu)

1.4 BeanFactory

• 類路徑加載配置文件

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

• BeanFactory創(chuàng)建完畢后，所有的Bean均為延遲加載，也就是說我們調(diào)用getBean()方法獲取Bean對象時才創(chuàng)建Bean對象并返回給我們

2 Spring核心容器總結(jié)

2.1 容器相關(guān)

• BeanFactory是IoC容器的頂層接口，初始化BeanFactory對象時，加載的bean延遲加載
• ApplicationContext接口是Spring容器的核心接口，初始化時bean立即加載
• ApplicationContext接口提供基礎的bean操作相關(guān)方法，通過其他接口擴展其功能
• ApplicationContext接口常用初始化類
  • ClassPathXmlApplicationContext(常用)
  • FileSystemXmlApplicationContext

2.2 bean相關(guān)

2.3 依賴注入相關(guān)

三 Spring注解開發(fā)

1 注解開發(fā)定義Bean對象

目的：xml配置Bean對象有些繁瑣，使用注解簡化Bean對象的定義

問題導入

問題1：使用什么標簽進行Spring注解包掃描？
問題2：@Component注解和@Controller、@Service、@Repository三個衍生注解有什么區(qū)別？

1.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.itheima包及其子包下的類中注解-->
    <context:component-scan base-package="com.itheima"/>
</beans>

【第二步】在類上使用@Component注解定義Bean。

//@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注解沒有使用參數(shù)指定Bean的名稱，那么類名首字母小寫就是Bean在IOC容器中的默認名稱。例如：BookServiceImpl對象在IOC容器中的名稱是bookServiceImpl。

【第三步】在測試類中獲取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);
    }
}

注意：在測試類中不要調(diào)用bookService的save方法，因為還沒有給BookServiceImpl中的bookDao賦值，調(diào)用bookService的save方法會出現(xiàn)空指針異常。

運行結(jié)果

1.2 @Component三個衍生注解

說明：加粗的注解為常用注解

• Spring提供 @Component 注解的三個衍生注解
  • @Controller：用于表現(xiàn)層bean定義
  • @Service：用于業(yè)務層bean定義
  • @Repository：用于數(shù)據(jù)層bean定義

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

@Service
public class BookServiceImpl implements BookService {
}

2 純注解開發(fā)模式

問題導入

問題1：配置類上使用什么注解表示該類是一個配置類？
問題2：配置類上使用什么注解進行Spring注解包掃描？

2.1 純注解開發(fā)模式介紹

• Spring3.0開啟了純注解開發(fā)模式，使用Java類替代配置文件，開啟了Spring快速開發(fā)賽道
• Java類代替Spring核心配置文件
  
• @Configuration注解用于設定當前類為配置類
• @ComponentScan注解用于設定掃描路徑，此注解只能添加一次，多個數(shù)據(jù)請用數(shù)組格式

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

• 讀取Spring核心配置文件初始化容器對象切換為讀取Java配置類初始化容器對象

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

2.2 代碼演示

【第一步】定義配置類代替配置文件

//聲明當前類為Spring配置類
@Configuration
//Spring注解掃描，相當于<context:component-scan base-package="com.itheima"/>
@ComponentScan("com.itheima")
//設置bean掃描路徑，多個路徑書寫為字符串數(shù)組格式
//@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}

【第二步】在測試類中加載配置類，獲取Bean對象并使用

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

3 注解開發(fā)Bean作用范圍和生命周期管理

問題導入

在類上使用什么注解定義Bean的作用范圍？

3.1 bean作用范圍注解配置

• 使用@Scope定義bean作用范圍
  • 單例模式：@Scope(“singleton”)
  • 非單例模式：@Scope(“prototype”)

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

3.2 bean生命周期注解配置

• 使用@PostConstruct
  • 設置bean的初始化方法
• @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 ...");
    }
}

public class AppForAnnotation {
    public static void main(String[] args) {
        //AnnotationConfigApplicationContext加載Spring配置類初始化Spring容器
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao1 =ctx.getBean(BookDao.class);
        BookDao bookDao2 =ctx.getBean(BookDao.class);
        System.out.println(bookDao1);
        System.out.println(bookDao2);
        ctx.close();

注意：@PostConstruct和@PreDestroy注解是jdk中提供的注解，從jdk9開始，jdk中的javax.annotation包被移除了，也就是說這兩個注解就用不了了，可以額外導入一下依賴解決這個問題。

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

4 注解開發(fā)依賴注入

問題導入

問題1：請描述@Autowired注解是如何進行自動裝配的？
問題2：請描述@Qualifier注解的作用

4.1 使用@Autowired注解開啟自動裝配模式（按類型）

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用類型，自動裝配模式，默認按類型裝配
    @Autowired
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

說明：不管是使用配置文件還是配置類，都必須進行對應的Spring注解包掃描才可以使用。@Autowired默認按照類型自動裝配，如果IOC容器中同類的Bean有多個，那么默認按照變量名和Bean的名稱匹配，建議使用@Qualifier注解指定要裝配的bean名稱

注意：自動裝配基于反射設計創(chuàng)建對象并暴力反射對應屬性為私有屬性初始化數(shù)據(jù)，因此無需提供setter方法。

4.2 使用@Qualifier注解指定要裝配的bean名稱

目的：解決IOC容器中同類型Bean有多個裝配哪一個的問題

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用類型，自動裝配模式，默認按類型裝配
    @Autowired
    //@Qualifier：自動裝配bean時按bean名稱裝配
    @Qualifier("bookDao")
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

注意：@Qualifier注解無法單獨使用，必須配合@Autowired注解使用

4.3 使用@Value實現(xiàn)簡單類型注入

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

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

以上@Value注解中使用${name}從屬性文件中讀取name值，那么就需要在配置類或者配置文件中加載屬性文件。

@Configuration
@ComponentScan("com.itheima")
//@PropertySource加載properties配置文件
@PropertySource({"classpath:jdbc.properties"}) //{}可以省略不寫
public class SpringConfig {
}

注意：@PropertySource()中加載多文件請使用數(shù)組格式配置，不允許使用通配符*

5 注解開發(fā)管理第三方Bean

問題導入

導入自己定義的配置類有幾種方式？

【第一步】單獨定義配置類

public class JdbcConfig {
    //@Bean：表示當前方法的返回值是一個bean對象，添加到IOC容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("mysql://localhost:3306/spring_db?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

【第二步】將獨立的配置類加入核心配置

方式1：@Import注解導入式

@Configuration
@ComponentScan("com.itheima")
//@Import:導入配置信息
@Import({JdbcConfig.class})
public class SpringConfig {
}

方式2：@ComponentScan掃描式

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

6 注解開發(fā)為第三方Bean注入資源

問題導入

配置類中如何注入簡單類型數(shù)據(jù)，如何注入引用類型數(shù)據(jù)？

6.1 簡單類型依賴注入

public class JdbcConfig {
    //1.定義一個方法獲得要管理的對象
    @Value("com.mysql.cj.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true")
    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屬性文件中的內(nèi)容，那么就需要加載properties屬性文件。

6.2 引用類型依賴注入

//Spring會自動從IOC容器中找到BookDao對象賦值給參數(shù)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定義方法設置形參即可，容器會根據(jù)類型自動裝配對象

7 注解開發(fā)總結(jié)

四 Spring整合其他技術(shù)

1 Spring整合mybatis

1.1 思路分析

問題導入

mybatis進行數(shù)據(jù)層操作的核心對象是誰？

1.1.1 MyBatis程序核心對象分析

1.1.2 整合MyBatis

• 使用SqlSessionFactoryBean封裝SqlSessionFactory需要的環(huán)境信息
  
• 使用MapperScannerConfigurer加載Dao接口，創(chuàng)建代理對象保存到IOC容器中
  

1.2 代碼實現(xiàn)

問題導入

問題1：Spring整合mybatis的依賴叫什么？
問題2：Spring整合mybatis需要管理配置哪兩個Bean，這兩個Bean作用分別是什么？

【前置工作】

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

【第一步】導入Spring整合Mybatis依賴

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</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>8.0.20</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.18</version>
        </dependency>
    </dependencies>

【第二步】創(chuàng)建JdbcConfig配置DataSource數(shù)據(jù)源

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
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;
    }
}

【第三步】創(chuàng)建MybatisConfig整合mybatis

public class MybatisConfig {
    //定義bean，SqlSessionFactoryBean，用于產(chǎn)生SqlSessionFactory對象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定義bean，返回MapperScannerConfigurer對象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

【第四步】創(chuàng)建SpringConfig主配置類進行包掃描和加載其他配置類

@Configuration
@ComponentScan("com.itheima")
//@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);
    }
}

2 Spring整合Junit單元測試

問題導入

Spring整合Junit的兩個注解作用分別是什么？

【第一步】導入整合的依賴坐標spring-test

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.18</version>
        </dependency>
		<!--spring整合junit-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.18</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</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>8.0.20</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

【第二步】使用Spring整合Junit專用的類加載器

【第三步】加載配置文件或者配置類

//【第二步】使用Spring整合Junit專用的類加載器
@RunWith(SpringJUnit4ClassRunner.class)
//【第三步】加載配置文件或者配置類
@ContextConfiguration(classes = {SpringConfiguration.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等版本,否則出現(xiàn)如下異常：
文章來源地址http://www.zghlxwxcb.cn/news/detail-626088.html

到了這里，關(guān)于DAY02_Spring第三方資源配置管理&Spring容器&Spring注解開發(fā)&Spring整合Mybatis和Junit的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！