【SpringFramework】Spring IOC

Spring IOC

IOC 的常用注解

之前的 XML 配置：

    <bean  id="accountService" class="cn.parzulpan.service.AccountServiceImpl"
           scope="" init-method="" destroy-method=""
           <perperty name="" value="" | ref=""/>
    />

常用注解的分类：

用于创建对象的，它们的作用就和 XML 配置中编写一个 <bean id="" class=""> 标签实现的功能相同。
用于注入数据的，它们的作用就和 XML 配置中编写一个 <bean> 标签中写一个 <perperty> 标签实现的功能相同。
用于改变作用范围的，它们的作用就和 XML 配置中编写一个 <bean> 标签中 scope 属性实现的功能相同。
用于体现生命周期的，它们的作用就和 XML 配置中编写一个 <bean> 标签中 init-method 和 destroy-method 属性实现的功能相同。

用于创建对象的

用于创建对象的，它们的作用就和 XML 配置中编写一个 <bean id="" class=""> 标签实现的功能相同。
- @Component 用于把当前类对象存入 Spring 容器中，value 属性 指定 bean 的 id，如果不指定 value 属性，默认 bean 的 id 是当前类的类名，首字母小写。
- @Controller 一般用于表现层的注解。
- @Service 一般用于业务层的注解。
- @Repository 一般用于持久层的注解。
- 注意：上面三个注解都是针对 Componet 的衍生注解，他们的作用及属性都是一模一样的，只不过是提供了更加明确的语义化。

注意：如果注解中有且只有一个属性要赋值时，且名称是 value，value 在赋值是可以不写。

package cn.parzulpan.service;


import org.springframework.stereotype.Component;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc :
 */

@Component()
public class AccountServiceImpl implements AccountService {
}

package cn.parzulpan.ui;

import cn.parzulpan.service.AccountService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc :
 */

public class Client {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        AccountService as = ac.getBean("accountServiceImpl", AccountService.class);
        System.out.println(as);

    }
}

注意：由于用到了注解，所以需要配置 bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 告知 Spring 在创建容器时要扫描的包 -->
    <context:component-scan base-package="cn.parzulpan"></context:component-scan>

</beans>

用于注入数据的

用于注入数据的，它们的作用就和 XML 配置中编写一个 <bean> 标签中写一个 <perperty> 标签实现的功能相同。
- @Autowired 自动按照类型注入。当使用注解注入属性时，set 方法可以省略。它只能注入其他 bean 类型，当有多个类型匹配时，使用要注入的对象变量名称作为 bean 的 id，在 spring 容器查找，找到了也可以注入成功，找不到就报错。
- @Qualifier 在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给成员注入时不能独立使用，必须和 @Autowire 一起使用；但是给方法参数注入时，可以独立使用。它也只能注入其他 bean 类型。value 属性 指定 bean 的 id。
- @Resource 直接按照 Bean 的 id 注入，能独立使用。它也只能注入其他 bean 类型。name 属性 指定 bean 的 id。
- @Value 注入基本数据类型和 String 类型数据。value属性 用于指定值，它也可以使用 Spring 的 SpEL，即 Spring 的 EL 表达式（${表达式}）。

package cn.parzulpan.service;


import cn.parzulpan.dao.AccountDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc :
 */

@Service
public class AccountServiceImpl implements AccountService {

//    @Autowired
//    private AccountDAO accountDAO;

//    @Autowired
//    @Qualifier("accountDAOImpl2")
//    private AccountDAO accountDAO;

    @Resource(name = "accountDAOImpl2")
    private AccountDAO accountDAO;

    @Override
    public void saveAccount() {
        System.out.println(accountDAO);
        accountDAO.saveAccount();
    }
}

注意：集合类型的注入只能通过 XML 来实现。

用于改变作用范围的

用于改变作用范围的，它们的作用就和 XML 配置中编写一个 <bean> 标签中 scope 属性实现的功能相同。
- @Scope 指定 bean 的作用范围。value 属性 指定范围的值。取值为 singleton prototype request session globalsession

@Scope("prototype")
public class AccountServiceImpl implements AccountService {}

用于体现生命周期的

用于体现生命周期的，它们的作用就和 XML 配置中编写一个 <bean> 标签中 init-method 和 destroy-method 属性实现的功能相同。
- @PostConstruct 用于指定初始化方法。
- @PreDestroy 用于指定销毁方法。

@Service
@Scope("singleton")
public class AccountServiceImpl implements AccountService {
    @PostConstruct
    public void init() {
        System.out.println("AccountService 对象初始化...");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("AccountService 对象销毁...");
    }
}

xml 单表 CRUD

需求：实现银行账户的 CRUD 操作。采用 xml 配置。使用 Spring IOC 实现对象的管理，使用 DBUtils 和 C3P0 作为持久层解决方案。小节源码

银行账户表结构

use springT;

# ---
# 银行账户表结构

drop table if exists `bankAccount`;

create table `bankAccount`(
    `id` int(11) primary key auto_increment,
    `name` varchar(32) not null comment '账户名称',
    `money` float not null comment '账户余额'
) engine=InnoDB default charset=utf8;

insert into bankAccount(name, money) values
('aaa', 1000), ('bbb', 2000), ('ccc', 3000);

# ---

银行账户的实体类

package cn.parzulpan.domain;

import java.io.Serializable;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 银行账户的实体类
 */

public class BankAccount implements Serializable {
    private Integer id;
    private String name;
    private Double money;

    public BankAccount() {
    }

    public BankAccount(Integer id, String name, Double money) {
        this.id = id;
        this.name = name;
        this.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 Double getMoney() {
        return money;
    }

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

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

银行账户的持久层接口的实现类

package cn.parzulpan.dao;

import cn.parzulpan.domain.BankAccount;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.sql.SQLException;
import java.util.List;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 银行账户的持久层接口的实现类
 */

public class BankAccountDAOImpl implements BankAccountDAO {
    private QueryRunner runner;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public List<BankAccount> findAll() {
        try {
            return runner.query("select * from bankAccount",
                    new BeanListHandler<BankAccount>(BankAccount.class));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public BankAccount findById(Integer id) {
        try {
            return runner.query("select * from bankAccount where id = ?",
                    new BeanHandler<BankAccount>(BankAccount.class), id);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public void save(BankAccount bankAccount) {
        try {
            runner.update("insert into bankAccount(name, money) values (?, ?)",
                    bankAccount.getName(), bankAccount.getMoney());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public void update(BankAccount bankAccount) {
        try {
            runner.update("update bankAccount set name = ?, money = ? where id = ?",
                    bankAccount.getName(), bankAccount.getMoney(), bankAccount.getId());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public void deleteById(Integer id) {
        try {
            runner.update("delete from bankAccount where id = ?",
                    id);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

银行账户的业务层接口的实现类

package cn.parzulpan.service;

import cn.parzulpan.dao.BankAccountDAO;
import cn.parzulpan.domain.BankAccount;

import java.util.List;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 银行账户的业务层接口的实现类
 */

public class BankAccountServiceImpl implements BankAccountService {
    private BankAccountDAO bankAccountDAO;

    public void setBankAccountDAO(BankAccountDAO bankAccountDAO) {
        this.bankAccountDAO = bankAccountDAO;
    }

    public List<BankAccount> findAll() {
        return bankAccountDAO.findAll();
    }

    public BankAccount findById(Integer id) {
        return bankAccountDAO.findById(id);
    }

    public void save(BankAccount bankAccount) {
        bankAccountDAO.save(bankAccount);
    }

    public void update(BankAccount bankAccount) {
        bankAccountDAO.update(bankAccount);
    }

    public void deleteById(Integer id) {
        bankAccountDAO.deleteById(id);
    }
}

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

    <!-- 配置 Service -->
    <bean id="bankAccountService" class="cn.parzulpan.service.BankAccountServiceImpl">
        <!-- 注入DAO，set() 形式-->
        <property name="bankAccountDAO" ref="bankAccountDAO"/>
    </bean>

    <!-- 配置 DAO -->
    <bean id="bankAccountDAO" class="cn.parzulpan.dao.BankAccountDAOImpl">
        <!-- 注入QueryRunner，set() 形式-->
        <property name="runner" ref="runner"/>
    </bean>

    <!-- 配置 QueryRunner -->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!-- 注入数据源，构造函数形式-->
        <constructor-arg name="ds" ref="dataSource"/>
    </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/springT?useSSL=false"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>
</beans>

对银行账户的业务层接口的实现类进行单元测试

package cn.parzulpan.service;

import cn.parzulpan.domain.BankAccount;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;


/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 对银行账户的业务层接口的实现类进行单元测试
 * 可以看到，每个测试方法都重新获取了一次 Spring 的核心容器，造成了不必要的重复代码，这个问题可以整合 Junit 解决
 */

public class BankAccountServiceImplTest {

    @Test
    public void findAll() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
        List<BankAccount> accounts = as.findAll();
        for (BankAccount account : accounts) {
            System.out.println(account);
        }
    }

    @Test
    public void findById() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
        BankAccount account = as.findById(1);
        System.out.println(account);
    }

    @Test
    public void save() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
        as.save(new BankAccount(null, "ta", 4325.12314));
    }

    @Test
    public void update() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
        BankAccount account = as.findById(1);
        account.setMoney(5153.325);
        as.update(account);
    }

    @Test
    public void deleteById() {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
        as.deleteById(4);
    }
}

annotaion 单表 CRUD

新注解说明

由于 xml 文件中，依然需要告知 Spring 在创建容器时要扫描的包，以及配置数据源等。

现在是如何用注解替代这些配置。

新注解：

@Configuration 指定当前类是一个 Spring 配置类。value 属性 用于指定配置类的字节码。
@ComponentScan 指定 Spring 在初始化容器时要扫描的包。basePackages/value 属性 用于指定要扫描的包。
@Bean 该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 Spring 容器。name 属性 给当前 @Bean 注解方法创建的对象指定一个名称（即 bean 的 id）。
@PropertySource 用于加载 .properties 文件中的配置。value[] 属性 用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath。
@Import 用于导入其他配置类，在引入其他配置类时，可以不用再写 @Configuration 注解，但是建议写上。value[] 属性 用于指定其他配置类的字节码。

整合 Junit

public class AccountServiceTest {
    @Autowired
    private AccountService as;

    @Test
    public void findAllTest() {
        as.findAllAccount();    //  nullPointerExcepetion
    }
}

在 Junit 中：

应用程序的入口是 main()，但是在 Junit 中，没有 main() 也能运行，因为 Junit 集成了一个 main()，该方法会判断当前测试类中哪些方法有 @Test 注解，然后让其执行
Junit 不会知道是否使用了 SPring 框架，所以也不会在读取配置文件/配置类时创建 Spring 核心容器
所以，当测试方法执行时，没有 IOC 容器，就算写了 @Autowired 注解，也无法实现注入

但是 Junit 给暴露了一个注解，可以替换掉它的运行器（替换 main() ）。这时，需要依靠 Spring 框架，因为它提供了一个运行器，可以读取配置文件（或注解）来创建容器。只需要告诉它配置文件在哪就行了。

@RunWith 替换 main 方法
@ContextConfiguration 告知 Spring 的运行其，Spring IOC 创建是基于 xml 还是注解的，并且说明文字。locations 属性 用于指定配置文件的位置。如果是类路径下，需要用 classpath: 表明。classes 属性 用于指定注解的类。当不使用 xml 配置时，需要用此属性指定注解类的位置。

需求：实现银行账户的 CRUD 操作。采用 annotation 配置。使用 Spring IOC 实现对象的管理，使用 DBUtils 和 C3P0 作为持久层解决方案。小节源码

银行账户的持久层接口的实现类，添加注入数据

@Repository("bankAccountDAO")
public class BankAccountDAOImpl implements BankAccountDAO {
    @Autowired
    private QueryRunner runner;
}

银行账户的业务层接口的实现类，添加注入数据

@Service("bankAccountService")
public class BankAccountServiceImpl implements BankAccountService {
    @Autowired
    private BankAccountDAO bankAccountDAO;
}

连接数据库的配置类

package cn.parzulpan.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.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 连接数据库的配置类，代替 配置 QueryRunner 和 配置 数据源，并且导入数据库的配置文件
 *
 *     <!-- 配置 QueryRunner -->
 *     <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
 *         <!-- 注入数据源，构造函数形式-->
 *         <constructor-arg name="ds" ref="dataSource"/>
 *     </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/springT?useSSL=false"/>
 *         <property name="user" value="root"/>
 *         <property name="password" value="root"/>
 *     </bean>
 *
 */

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driverClass;

    @Value("${jdbc.url}")
    private String jdbcUrl;

    @Value("${jdbc.username}")
    private String user;

    @Value("${jdbc.password}")
    private String password;

    /**
     * 创建 QueryRunner，使用 数据源 1
     * @param dataSource
     * @return
     */
    @Bean(name = "runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(@Qualifier("dataSource1") DataSource dataSource) {
        return new QueryRunner(dataSource);
    }

    /**
     * 创建 数据源 1
     * @return
     */
    @Bean(name = "dataSource1")
    public DataSource createDataSource1() {
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driverClass);
            ds.setJdbcUrl(jdbcUrl);
            ds.setUser(user);
            ds.setPassword(password);
            return ds;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建 数据源 2
     * @return
     */
    @Bean(name = "dataSource2")
    public DataSource createDataSource2() {
        try {
            ComboPooledDataSource ds2 = new ComboPooledDataSource();
            ds2.setDriverClass(driverClass);
            ds2.setJdbcUrl(jdbcUrl);
            ds2.setUser(user);
            ds2.setPassword(password);
            return ds2;
        } catch (PropertyVetoException e) {
            throw new RuntimeException(e);
        }
    }
}

Spring 的配置类

package cn.parzulpan.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : Spring 的配置类，作用和 bean.xml 相同，并且导入连接数据库的配置类
 *
 *     <!-- 告知 Spring 在创建容器时要扫描的包 -->
 *     <context:component-scan base-package="cn.parzulpan"/>
 *
 */

@Configuration
@ComponentScan("cn.parzulpan")
@Import(JdbcConfig.class)
public class SpringConfiguration {
}

对银行账户的业务层接口的实现类进行单元测试，整合 Junit 解决重复代码问题，使用注解

package cn.parzulpan.service;

import cn.parzulpan.config.SpringConfiguration;
import cn.parzulpan.domain.BankAccount;
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.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;


/**
 * @Author : parzulpan
 * @Time : 2020-12
 * @Desc : 对银行账户的业务层接口的实现类进行单元测试，整合 Junit 解决重复代码问题，使用注解
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class BankAccountServiceImplAndJunitTest {
    @Autowired
    private BankAccountService as;

    @Test
    public void findAll() {
        // 通过注解获取容器
        AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
        List<BankAccount> accounts = as.findAll();
        for (BankAccount account : accounts) {
            System.out.println(account);
        }
    }

    @Test
    public void findById() {
        // 整合 Junit
        BankAccount account = as.findById(1);
        System.out.println(account);
    }

    @Test
    public void save() {
        // 整合 Junit
        as.save(new BankAccount(null, "ta", 4325.12314));
    }

    @Test
    public void update() {
        // 整合 Junit
        BankAccount account = as.findById(1);
        account.setMoney(5153.325);
        as.update(account);
    }

    @Test
    public void deleteById() {
        // 整合 Junit
        as.deleteById(4);
    }
}

可以看到，纯注解开发实际上也比较繁琐，所以推荐混合开发。XML 配置适用于 Bean 来自第三方实现，而注解配置适用于 Bean 来自自己实现。

练习和总结

posted @ 2020-12-21 16:22 Parzulpan 阅读(56) 评论(0) 收藏举报

刷新页面返回顶部

Loading

Parzulpan Blogs