2020-06-18

SSM-Spring【IOC进阶三】

字数统计: 1.7k字 | 阅读时长: 8分

一、前言

SSM-Spring【IOC进阶二】主要总结了通过xml和注解相结合来实现CRUD操作，本篇文章则主要总结纯注解方式来实现CRUD操作。

二、需求

假设有一个和账户相关的项目，现需要实现基本的CRUD操作。

三、实现

（一）技术选择

持久层选用 dbUtils、数据库连接池选用 c3p0.

（二）项目结构

项目结构

（三）数据库

数据库spring中的account表的结构与数据如下图所示：
account表的结构：

account表的数据：

（四）domain层

public class Account implements Serializable {
    private int id;
    private String name;
    private float money;

    public int getId() {
        return id;
    }

    public void setId(int 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;
    }

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

（五）dao层实现

IAccountDao.java

/**
 * 操作账户的dao接口
 */
public interface IAccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id进行查询
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 添加账户
     * @param account
     */
    void addAccount(Account account);

    /**
     * 删除账户
     * @param id
     */
    void delAccount(Integer id);

    /**
     * 修改账户信息
     * @param account
     */
    void updateAccount(Account account);
}

AccountDaoImpl.java
注意：需要添加注解
对于类需要添加：@Repository(“accountDao”)
对于成员变量runner需要添加：@Autowired; @Value(“#{runner}”)也可以

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

    @Value("#{runner}")
    private QueryRunner runner;

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

    /**
     * 查询所有
     * @return
     */
    public List<Account> findAll() {
        try {
            return runner.query("select * from account", new BeanListHandler<Account>(Account.class));
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 根据id进行查询
     * @param id
     * @return
     */
    public Account findById(Integer id) {
        try {
            return runner.query("select * from account where id = ?", new BeanHandler<Account>(Account.class), id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 添加账户
     * @param account
     */
    public void addAccount(Account account) {
        try {
            runner.update("insert into account(name, money) values(?, ?)", account.getName(), account.getMoney());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 删除账户
     * @param id
     */
    public void delAccount(Integer id) {
        try {
            runner.update("delete from account where id = ?", id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 更新账户信息
     * @param account
     */
    public void updateAccount(Account account) {
        try {
            runner.update("update account set name=?, money=? where id=?", account.getName(), account.getMoney(), account.getId());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

（六）service层实现

IAccountService.java

public interface IAccountService {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id进行查询
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 添加账户
     * @param account
     */
    void addAccount(Account account);

    /**
     * 删除账户
     * @param id
     */
    void delAccount(Integer id);

    /**
     * 修改账户信息
     * @param account
     */
    void updateAccount(Account account);
}

AccountServiceImpl.java
注意：需要添加注解
对于类需要添加：@Service(“accountService”)
对于成员变量runner需要添加：@Resource(name = “accountDao”)

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

    @Resource(name = "accountDao")
    private IAccountDao accountDao;

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

    /**
     * 查询所有账户
     * @return
     */
    public List<Account> findAll() {
        return accountDao.findAll();
    }

    /**
     * 根据id查找单个账户
     * @param id
     * @return
     */
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    /**
     * 添加账户
     * @param account
     */
    public void addAccount(Account account) {
        accountDao.addAccount(account);
    }

    /**
     * 删除账户
     * @param id
     */
    public void delAccount(Integer id) {
        accountDao.delAccount(id);
    }

    /**
     * 更新账户信息
     * @param account
     */
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
}

（七）编写配置文件保存数据库连接所需要的参数

jdbcConfig.properties配置文件：

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

（八）编写注解

1、在纯注解的方式中，我们需要使用一个配置类来达到xml文件的效果，如下：
JdbcConfiguration.java:

@Configuration
@PropertySource("classpath:jdbcConfig.properties")
public class JdbcConfiguration {

    @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(name = "runner")
    @Scope("prototype")         //此处一定记得将其作用范围修改为多例模式
    //此处参数的查找原理和AutoWired的原理一样，现根据类型查找，然后才根据变量名匹配
    public QueryRunner getQueryRunner(ComboPooledDataSource dataSource){        
        return new QueryRunner(dataSource);     //此处的参数会自动去容器中查找，所以不需要注入
    }

    @Bean(name = "dataSource")
    public ComboPooledDataSource getDataSource(){
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setDriverClass(driver);
            dataSource.setJdbcUrl(url);
            dataSource.setUser(username);
            dataSource.setPassword(password);
            return dataSource;
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return null;
    }
}

注：
a. 使用 @Configuration 注解来表明该类是一个配置类；
b. 使用 @PropertySource(“classpath:jdbcConfig.properties”) 注解来加载外部的properties配置文件；
c. 使用 @Value(“${jdbc.driver}”) 注解来从容器中获取值，然后注入数据给相关参数变量；
d. 使用 @Bean(name = “runner”) 注解将方法返回的对象添加到ioc核心容器中，并且name的值就是这个bean对象的id；
e. 使用 @Scope(“prototype”) 注解将bean对象的作用范围调整为多例模式。

2、通常在一个项目中，配置类不止一个，因为我们更希望不同的层次中使用不同的配置类。但是最后，我们都会编写一个总的配置类进行整合，如：
SpringConfiguration.java:

/**
 * 使用注解进行配置的类       												--Configuration注解
 * 原理：
 * 1、自己写的能使用注解进行配置的类，则只需要在使用注解进行配置完之后，进行扫描即可    --ComponentScan注解
 * 2、外部jar包的类的对象则需要自己创建，并且手动加入到ioc容器中                      -- Bean注解
 * 3、尤其注意，每个对象的创建对应一个方法，该方法的返回值对象就是创建好的对象
 */
@Configuration
@ComponentScan(value = {"com.zuobiao"})
@Import(value = {JdbcConfiguration.class})
public class SpringConfiguration {
}

注：
a. 使用 @Configuration 注解来表明该类是一个配置类；
b. 使用 @ComponentScan(value = {“com.zuobiao”}) 注解来告诉Spring，在进行创建容器时，需要扫描指定的包，根据配置的注解，生成对应的对象，然后加入到ioc容器中；
c. 使用 @Import(value = {JdbcConfiguration.class}) 注解将其他配置类导入进来，从而在加载该类时，其他类也会被加载。

（九）测试

public class test {
    //获取容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    //获取对象
    IAccountService accountService = (AccountServiceImpl)ac.getBean("accountService");

    @Test
    public void testFindAll(){
        //调用方法
        List<Account> accounts = accountService.findAll();
        //对数据进行处理
        for (Account account : accounts) {
            System.out.println(account);
        }
    }

    @Test
    public void testFindById() {
        Account account = accountService.findById(2);
        System.out.println(account);
    }

    @Test
    public void testAddAccount() {
        Account account = new Account();
        account.setName("跑调大叔");
        account.setMoney(19000f);
        accountService.addAccount(account);
    }

    @Test
    public void testDelAccount() {
        accountService.delAccount(4);
    }

    @Test
    public void testUpdateAccount() {
        Account account = new Account();
        account.setName("跑调大叔");
        account.setMoney(20000000f);
        account.setId(4);
        accountService.updateAccount(account);
    }
}

四、总结

1、当使用纯注解方式时，由于是第一次使用，可能就会觉得有点比较麻烦，有点难，但其实多使用几次之后就会发现，其实也不过如此，所以在项目中也可以考虑使用该种方式；
2、该案例中使用了比较多的注解，第一次可能会记不住，因此在SSM-Spring【常用注解整合】中有总结了经常使用的注解；
3、对于测试也可以使用Spring整合junit后的方式。
参考文章：SSM-Spring【对junit的整合】

Java新手，若有错误，欢迎指正！

| 阅读量次