Spring之IOC案例分析以及注解案例

最新推荐文章于 2023-03-07 15:40:09 发布
最新推荐文章于 2023-03-07 15:40:09 发布
阅读量369 收藏
点赞数
分类专栏： Spring 文章标签： IOC案例 spring和junit整合 spring几个新注解

day2..........

一、spring中IOC的常用注解

1.注解创建对象

@Component

2.自动按照类型注入

如果有唯一一个匹配时，直接注入；若有多个匹配，则首先圈出匹配的对象，接着使用变量名称

作为bean的id在圈定的对象中继续查找，若圈中的对象一样则匹配成功，否则匹配失败；

3.该边作用范围和生命周期的注解

二、基于XML的IOC案例

案例分析：用基于XML的IOC实现对一个标的CURD操作

 

1）创建数据库，添加数据

CREATE TABLE `t_account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `aname` varchar(30) DEFAULT NULL,
  `money` float DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8

2）创建西maven项目，导入必要的；依赖编写实体类、数据持久层、以及业务层的接口类和实现类，项目结构如图所示

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>com.dzg</groupId>
    <artifactId>spring-day2-xml-ioc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.3.RELEASE</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.6</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>

    </dependencies>
</project>

实体类：

public class Account implements Serializable {

    private Integer id;
    private String aname;
    private float money;

    生成对应的set和get方法
}

业务层：

/**
 * 账户的业务接口层
 */
public interface IAccountService{

    /**
     * 查询所有账户信息
     * @return
     */
    List<Account> findAllAccount();

    /**
     * 根据id查询一个账户
     * @param accountId
     * @return
     */
    Account findAccountById(Integer accountId);

    /**
     * 增加账户信息
     * @param account
     */
    void insertAccount(Account account);

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

    /**
     * 根据id删除账户信息
     * @param accountId
     */
    void deleteAccount(Integer accountId);
}

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;

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

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

    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    public void insertAccount(Account account) {
        accountDao.insertAccount(account);
    }

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

    public void deleteAccount(Integer accountId) {
        accountDao.deleteAccount(accountId);
    }
}

持久层：持久层接口和业务层接口方法相同，只需要实现持久层实现类，实现和数据库的交互

/**
 * 账户持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {

    private QueryRunner qr;

    public void setQr(QueryRunner qr) {
        this.qr = qr;
    }

    public List<Account> findAllAccount() {
        try {
            return qr.query("select * from t_account",new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

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

    public void insertAccount(Account account) {

        try {
            qr.update("insert into t_account(aname,money) values(?,?)",account.getAname(),account.getMoney());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public void updateAccount(Account account) {

        try {
            qr.update("update t_account set aname = ?,money=? where id = ?",account.getAname(),account.getMoney(),account.getId());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public void deleteAccount(Integer accountId) {
        try {
            qr.update("delete from t_account where id = ?",accountId);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

上述步骤完成之后，配置spring环境：

<?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="accountService" class="com.dzg.service.impl.AccountServiceImpl">
        <!--注入dao-->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="com.dzg.dao.impl.AccountDaoImpl">
        <!--注入QueryRunner-->
        <property name="qr" ref="runner"></property>
    </bean>

    <!--配置QueryRunner-->
    <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.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db_spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

编写junit单元测试，对上述代码进行测试:

/**
 * 使用juint单元测试，测试配置
 */
public class AccountServiceTest {

    @Test
    public void testFindAll(){
        //1.获取数据信息
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //2.得到业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        List<Account> accountList = as.findAllAccount();
        for (Account account:
             accountList) {
            System.out.println(account);
        }
    }

    @Test
    public void testFindOne(){
        //1.获取数据信息
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //2.得到业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        Account account = as.findAccountById(3);
        System.out.println(account);
    }

    @Test
    public void testAdd(){
        Account account = new Account();
        account.setAname("ddd");
        account.setMoney(1234f);
        //1.获取数据信息
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //2.得到业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);

        as.insertAccount(account);
    }

    @Test
    public void testUpdate(){

        Account account = new Account();
        account.setId(4);
        account.setAname("dddupdate");
        account.setMoney(4434f);
        //1.获取数据信息
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //2.得到业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        as.updateAccount(account);
    }

    @Test
    public void testDelete(){
        //1.获取数据信息
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //2.得到业务层对象
        IAccountService as = ac.getBean("accountService",IAccountService.class);
        //3.执行方法
        as.deleteAccount(4);
    }

}

 

三、注解开发ioc案例

使用注解开发，更改上述案例：

      对于JavaBean，持久层和业务层的实现类，使用注解的方式进行更改，则对应的beans.xml文件中删除已经注解的bean；通知spring

在创建容器时需要扫描的包；

    在对相应的实现类进行注解后，则类中的成员变量不再需要相应的set方法，删除即可；同时将变量注解为Autowired

 

注解开发，更改之后的beans.xml文件

<!--告知spring在创建容器时需要扫描的包-->
        <context:component-scan base-package="com.dzg"></context:component-scan>
    <!--配置QueryRunner-->
    <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.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db_spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

四、去掉beans.xml文件的注解开发

1.spring的新注解Configuation和ComponentScan

但是并不绝对！

2.spring的新注解bean

在config包下

 

删除xml文件

进行测试：

 @Test
    public void testFindAll(){
        //1.获取数据信息
//        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        ApplicationContext ac = new AnnotationConfigApplicationContext("com.dzg");
        //2.得到业务层对象
        IAccountService as = ac.getBean("accountService", IAccountService.class);
        //3.执行方法
        List<Account> accountList = as.findAllAccount();
        for (Account account:
             accountList) {
            System.out.println(account);
        }

3.AnnotationConfigApplicationContext的使用

注意，曾经的QueryRunner是一个多例的，现在是一个单例子的；

test测试下：

在createQueryRunner上添加注解 @Scope("prototype")

4.spring的新注解Import

将内容拷贝到JdbcConfig

即@Configuration注解不写

        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);


此时使用另一个方法来创建ApplicationContext对象，传递的参数为注解的类

5.spring的新注解PropertySource

将数据库连接信息提取出，写入一个properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_spring
jdbc.username=root
jdbc.password=root

自己写的类使用注解开发，jar包中的类使用xml配置

五、spring和junit整合

1.分析：

 

2.整合

 

AnimalsD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring IOC案例
06-04
Spring IOC案例
《一头扎进Spring4》学习笔记（二）Spring 之 ioc 详解
weixin_30699741的博客
02-11 150
第一节 Spring ioc 简介 IOC（控制反转：Inverse of Control），又称作 依赖注入，是一种重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 第二节 Spring ico 实例 1、接口类 1 public interface Tester { 2 public void test(); 3 } 2、实体类...
Spring IoC 简单案例
GoldenaArcher的博客
10-26 429
IoC（Inversion of Control）是一种设计模式，维基百科的说法是这样的：Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式地用 new 建立 B 的对象。采用依赖注入技术之后，A 的代码只需要定义一个 private 的B对象，不需要直接 new 来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。而具体获取的方法、对象被获取时的状态由配置文件（如XML）来指定。
Spring(一)IOC小案例
a910247的博客
06-11 185
大家好呀，今天跟大家分享一个IOC容器小案例，希望对大家有所帮助哦！喜欢记得点个关注哦，更多精彩等你哦。一、首先我们来创建一个service层包，在包中再建一个UserService类. 二、然后在建一个dao包，在包中分别建一个UserDao接口类和继承接口的UserDaoiml类。 三、接下来就是在xml文件中配置相应的数据咯 四、最后当然是建立一个测试类啦。...
Spring之IOC入门案例
qq_61313896的博客
12-31 919
Spring之IOC入门案例
Spring的IoC实现案例
01-18
创建Priter类和pater类，分别代表打印机和纸张，然后利用Spring的IoC对打印机进行组装，分别实现A4纸打印和b5纸打印。
用项目案例彻底理解SpringIOC容器
02-24
●运用工厂模式设计程序●理解JavaBean和POJO对象●理解控制反转思想●理解IOC容器在一个乡村小学校，一天只上三节课，有三名老师和一个校长。张老师负责教学生语文，王老师教学生数学，李老师教音乐，校长负责安排...
springIOC案例
09-23
包含spring的和Junit的jar包，采用Junit测试，一共四个案例，主要讲述：1.怎么利用IOC容器获得实例化对象；2.ＩＯＣ容器到底是如何工作 ；3.静态工厂方式实例化Bean；4.依赖和依赖注入的几种方式。以及一张<<IOC应用...
Spring IOC实例
Mr_Newbie的博客
08-18 635
前言 IOC是利用 工厂模式 通过java反射机制实现自动注入，本文主要用普通java工程采用注解的方式进行演示 IOC其实就是创建一个ioc容器，把实例化对象的工作交给spring，利用反射机制自动注入，在执行程序执行之前首先实例化后期要被用到的对象（如service层），存放到ioc容器中，方便我们进行调用和管理。 目录： 一、dao层 GoodDao.java public interface GoodDao { public void sayHello(); } GoodDaoImpl.jav
Spring IOC 简单例子
weixin_38891150的博客
03-25 2655
结构图package henu.bean; public interface Animal { public void info(); } package henu.bean; public class Bird implements Animal{ @Override public void info() { // TODO Auto-generated method stu...
Spring IOC常用注解的详解及案例
夏沐的博客
05-24 301
注：用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/> （1）Spring IOC常用注解的解释 代码参考： https://blog.csdn.net/weixin_40391011/article/details/104191033 https://www.cnblogs.com/hoobe
spring Ioc案例（1）
qq_41620231的博客
04-25 131
对控制反转和依赖注入的讲解 一个班级是由老师和同学组成的，那么班级就依赖于多个老师和同学。spring提供依赖注入的功能，使得我们管理各个对象之间的关系。 班级，同学和老师这3个对象的关系，我们需要一个容器。在spring中把每个对象称为spring bean（简称bean），而spring管理这些bean的容器，称为spring ioc容器 ...
Spring IoC的简单案例
可小辉的博客
04-08 668
定义一下四个类或接口 1. 使用 Spring 注解装配它们 2. 从 BeanFactory 获得一个 PC 实例 3. - usb1 连接鼠标 4. - usb2 连接键盘 工程目录（不需要手动添加依赖） package com.newer.ioc1; import org.springframework.beans.factory.annotation.Autowire...
Spring框架—IOC简单案例
qq_37022135的博客
06-06 239
IOC简单使用**Spring-IOC简单案例**一、使用Spring管理对象1.1 创建java工程，导入Spring jar包1.1.1 Spring 核心jar包：1.1.2 其他依赖的jar包：1.2 创建相关Bean与配置文件1.2.1 创建Student类1.2.2 创建Spring配置文件(applicationContext.xml)1.2.2 创建测试类1.2.3 控制台输出二、 获取Bean的几种形式2.1 **ac.getBean(Student.class)**:通过类型获取容器中
Spring框架(六)：spring ioc案例
yu1755128147的博客
12-16 115
一、基于xml的IOC案例 1、创建maven工程并导入jar包坐标 2、创建实体 package com.wedu.spring04.domain; import java.io.Serializable; import java.util.Date; /** * 用户实体 */ public class UserInfo implements Serializable { ...
Spring学习笔记（一）---IOC入门案例
康师傅没有眼泪
05-27 299
Spring框架—控制反转（IOC） 1 Spring框架概述 1.1 什么是Spring 1.2 Spring的优点 1.3 Spring的体系结构 2 入门案例:（IoC） 2.1导入jar包 2.2目标类 2.3 配置文件 2.4测试
Spring的小IOC案例
qq_20909411的博客
05-30 166
spring项目 创建maven项目 ，引入junit、spring的jar包：在maven工程的pom.xml文件的根标签（project）内添加如下配置： <dependencies> <!-- 添加junit的jar包 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.1
springIOC入门案例
Eliot的博客
03-07 210
IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。
Spring-IOC案例(注解实现)
hxy1625309592的博客
03-19 185
1.1 项目目录 1.2 代码示例 客户实体类 package cn.guardwhy.domain; /** * 客户实体类 */ @Data @NoArgsConstructor @AllArgsConstructor public class Customer { // 成员变量 private Long custId; private String custName; private String custSource; private String
1、Spring配置文件 2、Spring IoC基于注解的操作和案例
最新发布
05-28
2、Spring IoC基于注解的操作和案例 除了使用XML配置文件之外，Spring IoC容器还支持基于注解的Bean定义和注入操作。在Spring中，使用注解可以大大简化配置文件的编写，提高开发效率和可读性。 常用的Spring注解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值