menu 若在
springIOC_02
40 浏览 | 2021-03-12 | 阅读时间: 约 8 分钟 | 分类: JAVA | 标签: Spring,Ioc

1. 使用spring的IoC的实现账户的CRUD

1.1 需求和技术要求

1.1.1 需求

​ 实现账户的CRUD操作

1.1.2 技术要求

​ 使用spring的IoC实现对象的管理

​ 使用DButils作为持久层解决方案

​ 使用c3p0数据源

1.2 环境搭建(maven)

<?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>cn.msy</groupId>
    <artifactId>Spring_Account</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>     
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
                <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>



    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <target>1.8</target>
                        <source>1.8</source>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

</project>

1.2.2 创建数据库和编写实体类

create table account( 
    id int primary key auto_increment, 
    name varchar(40), 
    money float 
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values('aaa',1000); 
insert into account(name,money) values('bbb',1000); 
insert into account(name,money) values('ccc',1000);
package cn.msy.domain;

import java.io.Serializable;

public class Account implements Serializable {

    private Integer id;
    private String name;
    private Float money;

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }
}

1.2.3 编写持久层代码

持久层接口

package cn.msy.dao;

import cn.msy.domain.Account;

import java.util.List;

public interface IAccountDao {
    List<Account> findAllAccount();

    Account findAccountById(Integer id);

    void saveAccount(Account account);

    void updateAccount(Account account);

    void deleteAccount(Integer id);
}

持久层实现类

package cn.msy.dao.impl;

import cn.msy.dao.IAccountDao;
import cn.msy.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.util.List;

public class AccountDaoImpl implements IAccountDao {

    private QueryRunner runner;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }
    @Override
    public List<Account> findAllAccount() {
        try{
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Account findAccountById(Integer accountId) {
        try{
            return runner.query("select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void saveAccount(Account account) {
        try{
            runner.update("insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void updateAccount(Account account) {
        try{
            runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void deleteAccount(Integer accountId) {
        try{
            runner.update("delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

1.2.4 编写业务层代码

业务层接口

package cn.msy.service;

import cn.msy.domain.Account;

import java.util.List;

public interface IAccountService {

    List<Account> findAllAccount();

    Account findAccountById(Integer id);

    void saveAccount(Account account);

    void updateAccount(Account account);

    void deleteAccount(Integer id);
}

业务层实现类

package cn.msy.service.impl;

import cn.msy.dao.IAccountDao;
import cn.msy.domain.Account;
import cn.msy.service.IAccountService;

import java.util.List;

public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer id) {
        accountDao.deleteAccount(id);
    }
}

1.2.5 创建并编写配置文件

<?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
context.xsd">
  
</beans>

1.3 配置步骤

1.3.1 配置对象

  
    <bean id="accountService" class="cn.msy.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    
    <bean id="accountDao" class="cn.msy.dao.impl.AccountDaoImpl">
        <property name="runner" ref="runner"></property>
    </bean>

    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///spring?serverTimezone=UTC"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123"></property>
    </bean>

1.4 测试案例

1.4.1 测试类代码

package cn.msy.test;

import cn.msy.domain.Account;
import cn.msy.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class AccountServiceTest {
    @Test
    public void testFindAll() {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService accountService = classPathXmlApplicationContext.getBean("accountService", IAccountService.class);
        List<Account> allAccount = accountService.findAllAccount();
        for (Account account : allAccount) {
            System.out.println(account);
        }

    }

    @Test
    public void testFindOne() {

    }

    @Test
    public void testSave() {

    }

    @Test
    public void testUpdate() {

    }
    @Test
    public void testDelete() {

    }
}

1.4.2 分析测试了中的问题

​ 通过上面的测试类,我们可以看出,每个测试方法都重新获取了一次spring的核心容器,造成了不必要的重复代码,增加了我们开发的工作量。这种情况,在开发中应该避免发生。

​ 我们把容器的获取定义到类中去,这种方式虽然能解决问题,但是仍然需要我们自己写代码来获取容器。 能不能测试时直接就编写测试方法,而不需要手动编码来获取容器呢?

2. 基于注解的IOC配置

2.1 明确:写在最前

​ 注解配置和xml配置要实现的功能都是一样的,都是要降低程序间的耦合。只是配置的形式不一样。

​ 关于实际的开发中到底使用xml还是注解,每家公司有着不同的使用习惯。所以这两种配置方式我们都需要掌握。

​ 我们在讲解注解配置时,采用上一章节的案例,把spring的xml配置内容改为使用注解逐步实现。

2.2 环境搭建

2.2.1 第一步:pom

<?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>cn.msy</groupId>
    <artifactId>Spring_Account_Anno_IOC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>



    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <target>1.8</target>
                        <source>1.8</source>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

</project>

2.2.2 第二步:使用@Component注解配置管理的资源

业务层实现类

package cn.msy.service.impl;

import cn.msy.dao.IAccountDao;
import cn.msy.domain.Account;
import cn.msy.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.util.List;

@Component("accountService")
public class AccountServiceImpl implements IAccountService {

    
    @Autowired
    private IAccountDao accountDao;

    @Override
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer id) {
        accountDao.deleteAccount(id);
    }
}

持久层实现类

package cn.msy.dao.impl;

import cn.msy.dao.IAccountDao;
import cn.msy.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.util.List;

@Component("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private QueryRunner runner;
    
    @Override
    public List<Account> findAllAccount() {
        try{
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Account findAccountById(Integer accountId) {
        try{
            return runner.query("select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void saveAccount(Account account) {
        try{
            runner.update("insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void updateAccount(Account account) {
        try{
            runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void deleteAccount(Integer accountId) {
        try{
            runner.update("delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

2.2.3 第三步:创建spring的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">



    <!--把对象的创建交给spring来管理-->
    <!--spring对bean的管理细节
        1.创建bean的三种方式
        2.bean对象的作用范围
        3.bean对象的生命周期
    -->

    <!--创建Bean的三种方式 -->
    <!-- 第一种方式:使用默认构造函数创建。
            在spring的配置文件中使用bean标签,配以id和class属性之后,且没有其他属性和标签时。
            采用的就是默认构造函数创建bean对象,此时如果类中没有默认构造函数,则对象无法创建。

    <bean id="accountService" class="AccountServiceImpl"></bean>
    -->

    <!-- 第二种方式: 使用普通工厂中的方法创建对象(使用某个类中的方法创建对象,并存入spring容器)
    <bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
    -->

    <!-- 第三种方式:使用工厂中的静态方法创建对象(使用某个类中的静态方法创建对象,并存入spring容器)
    <bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>
    -->

    <!-- bean的作用范围调整
        bean标签的scope属性:
            作用:用于指定bean的作用范围
            取值: 常用的就是单例的和多例的
                singleton:单例的(默认值)
                prototype:多例的
                request:作用于web应用的请求范围
                session:作用于web应用的会话范围
                global-session:作用于集群环境的会话范围(全局会话范围),当不是集群环境时,它就是session
    -->

    <!-- bean对象的生命周期
            单例对象
                出生:当容器创建时对象出生
                活着:只要容器还在,对象一直活着
                死亡:容器销毁,对象消亡
                总结:单例对象的生命周期和容器相同
            多例对象
                出生:当我们使用对象时spring框架为我们创建
                活着:对象只要是在使用过程中就一直活着。
                死亡:当对象长时间不用,且没有别的对象引用时,由Java的垃圾回收器回收
     -->

        
        
    <!--把对象的创建交给spring来管理-->
    <!--告知spring在创建容器时要扫描的包,配置所需要的标签不是在beans的约束中,而是一个名称为context名称空间和约束中-->
        
    <context:component-scan base-package="cn.msy"></context:component-scan>


    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
        
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///spring?serverTimezone=UTC"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123"></property>
    </bean>

</beans>

2.3 常用注解

2.3.1 用于创建对象的

​ 相当于:<bean id="" class="">

2.3.1.1 @Component

作用:

​ 把资源让spring来管理。相当于在xml中配置一个bean。

属性:

​ value:指定bean的id。如果不指定value属性,默认bean的id是当前类的类名。首字母小写。

2.3.1.2 @Controller @Service @Repository

​ 他们三个注解都是针对一个的衍生注解,他们的作用及属性都是一模一样的。 他们只不过是提供了更加明确的语义化。

​ @Controller:一般用于表现层的注解。

​ @Service:一般用于业务层的注解。

​ @Repository:一般用于持久层的注解。

细节:如果注解中有且只有一个属性要赋值时,且名称是value,value在赋值是可以不写。

如只有一个id

2.3.2 用于注入数据的

相当于:<property name="" ref="">

            <property name="" value="">

2.3.2.1 @Autowired

作用:

​ 自动按照类型注入。当使用注解注入属性时,set方法可以省略。它只能注入其他bean类型。当有多个类型匹配时,使用要注入的对象变量名称作为bean的id,在spring容器查找,找到了也可以注入成功。找不到就报错。

2.3.2.2 @Qualifier

作用:

​ 在自动按照类型注入的基础之上,再按照Bean的id注入。它在给字段注入时不能独立使用,必须和@Autowire一起使用;但是给方法参数注入时,可以独立使用。

属性:

​ value:指定bean的id。

2.3.2.3 @Resource

作用:

​ 直接按照Bean的id注入。它也只能注入其他bean类型。

属性:

​ name:指定bean的id。

2.3.2.4 @Value

作用:

​ 注入基本数据类型和String类型数据的

属性:

​ value:用于指定值

2.3.3 用于改变作用范围的:

相当于:<bean id="" class="" scope="">

2.3.3.1 @Scope

作用:

​ 指定bean的作用范围。

属性:

​ value:指定范围的值。

​ 取值:singleton prototype request session globalsession

2.3.4 和生命周期相关的:(了解)

相当于:<bean id="" class="" init-method="" destroy-method="" />

2.3.4.1 @PostConstruct

作用:

​ 用于指定初始化方法

2.3.4.2 @PreDestroy

作用:

​ 用于指定销毁方法。

2.3.5 关于Spring注解和XML的选择问题

注解的优势:

​ 配置简单,维护方便(我们找到类,就相当于找到了对应的配置)。

XML的优势:

​ 修改时,不用改源码。不涉及重新编译和部署。

Spring管理Bean方式的比较:

2.4 spring管理对象细节

​ 基于注解的spring IoC配置中,bean对象的特点和基于XML配置是一模一样的。

2.5 spring的纯注解配置

​ 写到此处,基于注解的IoC配置已经完成,但是大家都发现了一个问题:我们依然离不开spring的xml配置文件,那么能不能不写这个bean.xml

​ 当然,我们选择哪种配置的原则是简化开发和配置方便,而非追求某种技术。

2.5.1 待改造的问题

我们发现,之所以我们现在离不开xml配置文件,是因为我们有一句很关键的配置:

<!-- 告知spring框架在,读取配置文件,创建容器时,扫描注解,依据注解创建对象,并存入容器中 -->    
<context:component-scan base-package="cn.msy"></context:component-scan>
如果他要也能用注解配置,那么我们就离脱离xml文件又进了一步。


另外,数据源和JdbcTemplate的配置也需要靠注解来实现。
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
        
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///spring?serverTimezone=UTC"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123"></property>
    </bean>

</beans>

2.5.2 新注解说明

2.5.2.1 @Configuration

作用:

​ 用于指定当前类是一个spring配置类,当创建容器时会从该类上加载注解。获取容器时需要使用AnnotationApplicationContext(有@Configuration注解的类.class)。

属性:

​ value:用于指定配置类的字节码

示例代码: 
    /** * spring的配置类,相当于bean.xml文件  */
    @Configuration 
    public class SpringConfiguration { 
    }
注意: 已经把配置文件用类来代替了,但是如何配置创建容器时要扫描的包呢? 请看下一个注解。

2.5.2.2 @ComponentScan

作用:

​ 用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的:

​ <context:component-scan base-package="com.itheima"/>是一样的。

示例代码: 
    /** * spring的配置类,相当于bean.xml文件 */ 
    @Configuration 
    @ComponentScan("cn.msy")
    public class SpringConfiguration { 
    }
    

注意:

​ 已经配置好了要扫描的包,但是数据源和JdbcTemplate对象如何从配置文件中移除呢? 请看下一个注解

2.5.2.3 @Bean

作用:

​ 该注解只能写在方法上,表明使用此方法创建一个对象,并且放入spring容器。

属性:

​ name:给当前@Bean注解方法创建的对象指定一个名称(即bean的id)。

/** * 连接数据库的配置类 */ 
public class JdbcConfig { 
    /** 
    * 创建一个数据源,并存入spring容器中 
    * @return 
    */ 
    @Bean(name="dataSource") 
    public DataSource createDataSource() { 
        try { 
            ComboPooledDataSource ds = new ComboPooledDataSource();             ds.setUser("root"); ds.setPassword("1234");                         ds.setDriverClass("com.mysql.jdbc.Driver");                         ds.setJdbcUrl("jdbc:mysql:///spring_day02"); return ds; 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
  /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean(name="runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    } 
} 
注意:
    已经把数据源和DButils从配置文件中移除了,此时可以删除bean.xml了。 但是由于没有了配置文件,创建数据源的配置又都写死在类中了。如何把它们配置出来呢? 请看下一个注解

2.5.2.4 @PropertySource

​ 于加载.properties文件中的配置。例如我们配置数据源时,可以把连接数据库的信息写到properties配置文件中,就可以使用此注解指定properties配置文件的位置。

属性:

​ value[]:用于指定properties文件位置。如果是在类路径下,需要写上classpath:

package cn.msy.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;

/**
 * 和spring连接数据库相关的配置类
 */
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;

    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean(name="runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据源对象
     * @return
     */
    @Bean(name="dataSource")
    public DataSource createDataSource(){
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return ds;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

properties:

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///spring?serverTimezone=UTC
jdbc.username=root
jdbc.password=123

注意:

​ 此时我们已经有了两个配置类,但是他们还没有关系。

​ 如何建立他们的关系呢? 请看下一个注解。

2.5.2.5 @Import

作用:

​ 用于导入其他配置类,在引入其他配置类时,可以不用再写@Configuration注解。当然,写上也没问题。

属性:

​ value[]:用于指定其他配置类的字节码。

示例代码: 
    /** * spring的配置类,相当于bean.xml文件 */ 
    @Configuration
    @ComponentScan("cn.msy")
    @Import(JdbcConfig.class)
    @PropertySource("classpath:jdbcConfig.properties")
    public class SpringConfiguration { 
    }

注意:

​ 我们已经把要配置的都配置好了,但是新的问题产生了,由于没有配置文件了,如何获取容器呢?

2.5.2.6 通过注解获取容器:

ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);

3. Spring整合Junit[掌握]

3.1 测试类中的问题和解决思路

3.1.1 问题

​ 在测试类中,每个测试方法都有以下两行代码

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); 

IAccountService as = ac.getBean("accountService",IAccountService.class);

​ 这两行代码的作用是获取容器,如果不写的话,直接会提示空指针异常。所以又不能轻易删掉。

3.1.2 解决思路分析

​ 针对上述问题,我们需要的是程序能自动帮我们创建容器。一旦程序能自动为我们创建spring容器,我们就无须手动创建了,问题也就解决了。

​ 我们都知道,junit单元测试的原理,但显然,junit是无法实现的,因为它自己都无法知晓我们是否使用了spring框架,更不用说帮我们创建spring容器了。不过好在,junit给我们暴露了一个注解,可以让我们替换掉它的运行器。

​ 这时,我们需要依靠spring框架,因为它提供了一个运行器,可以读取配置文件(或注解)来创建容器。我们只需要告诉它配置文件在哪就行了。

3.2 配置步骤

3.2.1 第一步:pom

<?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>cn.msy</groupId>
    <artifactId>Spring_Account_Anno_WithoutXML_IOC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>



    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <target>1.8</target>
                        <source>1.8</source>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

</project>

3.2.2 第二步:使用@RunWith注解替换原有运行器

package cn.msy.test;

import cn.msy.config.SpringConfiguration;
import cn.msy.domain.Account;
import cn.msy.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;
/**
 * 使用Junit单元测试:测试我们的配置
 * Spring整合junit的配置
 *      1、导入spring整合junit的jar(坐标)
 *      2、使用Junit提供的一个注解把原有的main方法替换了,替换成spring提供的
 *             @Runwith
 *      3、告知spring的运行器,spring和ioc创建是基于xml还是注解的,并且说明位置
 *          @ContextConfiguration
 *                  locations:指定xml文件的位置,加上classpath关键字,表示在类路径下
 *                  classes:指定注解类所在地位置
 *
 *   当我们使用spring 5.x版本的时候,要求junit的jar必须是4.12及以上
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {
    @Autowired
    private IAccountService accountService=null;

    @Test
    public void testFindAll() {
/*        //ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean.xml");
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService accountService = annotationConfigApplicationContext.getBean("accountService", IAccountService.class);*/
        List<Account> allAccount = accountService.findAllAccount();
        for (Account account : allAccount) {
            System.out.println(account);
        }

    }

    @Test
    public void testFindOne() {

    }

    @Test
    public void testSave() {

    }

    @Test
    public void testUpdate() {

    }
    @Test
    public void testDelete() {

    }
}

3.2.3 第三步:使用@ContextConfiguration指定spring配置文件的位置

同上
  @ContextConfiguration注解: 
    locations属性:用于指定配置文件的位置。如果是类路径下,需要用classpath:表明     classes属性:用于指定注解的类。当不使用xml配置时,需要用此属性指定注解类的位置。 

3.2.4 第四步:使用@Autowired给测试类中的变量注入数据

同上

3.3 为什么不把测试类配到xml中

在解释这个问题之前,先解除大家的疑虑,配到XML中能不能用呢?

答案是肯定的,没问题,可以使用。

那么为什么不采用配置到xml中的方式呢?

这个原因是这样的:

​ 第一:当我们在xml中配置了一个bean,spring加载配置文件创建容器时,就会创建对象。

​ 第二:测试类只是我们在测试功能时使用,而在项目中它并不参与程序逻辑,也不会解决需求上的问题,所以创建完了,并没有使用。那么存在容器中就会造成资源的浪费。

所以,基于以上两点,我们不应该把测试配置到xml文件中。


本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。

发表评论

email
web

全部评论 (暂无评论)

info 还没有任何评论,你来说两句呐!