Spring---学习第二天（Spring基于注解的IOC配置+依赖注入+Spring整合Junit+基于Spring的信息管理系统小案例）

朴灿烈づ我的快乐病毒、 2023-02-19 07:26 33阅读 0赞

### Spring学习第二天 ###

*  IOC配置
 *   *  用于创建对象
     *   *  基于@Component注解配置管理的资源
         *   *  @Component
         *  基于@component衍生的三个注解
         *   *  @Controller&&@Service&&@Repository
 *  依赖注入
 *   *   *  用于注入数据
         *   *  @Autowired
             *  @Qualifier
             *  @Resource
             *  @Value
         *  用于改变bean的作用范围
         *   *  @Scope
         *  用于设置生命周期的
         *   *  @PostConstruct
             *  @PreDestroy
         *  配置类的注解
         *   *  @Configuration
             *  @ComponentScan
             *  @Bean
             *  @PropertySource
             *  @Import
         *  通过注解获取容器
 *  Spring 整合 Junit
 *   *   *  \*\*问题场景\*\*
         *  使用方法
         *  为什么不把测试类配到 xml 中?
 *  信息管理系统
 *   *   *   *  jbbc配置类代码
             *  主配置类代码
             *  持久层接口实现类代码
             *  业务逻辑层接口实现类代码
             *  测试类代码

# IOC配置 #

## 用于创建对象 ##

### 基于@Component注解配置管理的资源 ###

#### @Component ####

> 作用：把资源让 spring 来管理。相当于在 xml 中配置一个 bean**相当于我们在配置文件中的 < bean id="" class="">**

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

**使用方法：**

> 1.拷贝必备 jar 包到工程的 lib 目录。  
> 2.使用@Component 注解配置管理的资源  
> 3.创建 spring 的 xml 配置文件并开启对注解的支持  
> <context:component-scan base-package=“com.gzgs”></context:component-scan>

**示例代码**

@Component("accoutService")
    public class AccoutServiceImpl implements AccoutService {
    }

### 基于@component衍生的三个注解 ###

#### @Controller&&@Service&&@Repository ####

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

*  @Controller： 一般用于表现层的注解。
 *  @Service： 一般用于业务层的注解。
 *  @Repository： 一般用于持久层的注解。

> **细节：如果注解中有且只有一个属性要赋值时，且名称是 value， value 在赋值是可以不写， @Controller(accoutService)即可**

# 依赖注入 #

### 用于注入数据 ###

#### @Autowired ####

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

**示例代码**

@Component("accoutService")
    public class AccoutServiceImpl implements AccoutService {
        @Autowired
        private AccoutDao accoutDao;
    
        public AccoutServiceImpl(AccoutDao accoutDao){
            this.accoutDao=accoutDao;
        }
        public void saveMoney() {
          accoutDao.saveMoney();
        }
    }

**工作原理**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70]

#### @Qualifier ####

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

> 属性value：指定 bean 的 id。

**代码示例**

@Autowired
    @Qualifier("accoutDao2")
     private AccoutDao accoutDao;

#### @Resource ####

> 作用：直接按照 Bean 的 id 注入。它也只能注入其他 bean 类型。

> 属性name：指定 bean 的 id。

**代码示例：**

@Resource(name = "accoutDao2")
    private AccoutDao accoutDao;

#### @Value ####

前面的三个注解**Autowired、Qualifier、Resource都只能用于给bean对象赋值，不能用于给基本数据类型和String类型赋值，**要给基本数据类型和String赋值的话需要用@Value这个注解。

> 作用：注入基本数据类型和 String 类型数据的

> 属性value：用于指定值

**示例代码**

@Value("333")
    String string;

**注意事项**

> 1.不能作用于静态变量（static）；  
> 2.不能作用于常量（final）;  
> 3.不能在非注册的类中使用（类需要被注册在spring上下文中，如用@Service,@Repository,@Component等）  
> 4.使用这个类时，只能通过依赖注入的方式，用new的方式是不会自动注入这些配置的。

### 用于改变bean的作用范围 ###

#### @Scope ####

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

> 作用：指定 bean 的作用范围。

> 属性value：指定范围的值。  
> 取值： singleton prototype request session globalsession

**代码示例**

@Scope("prototype")
    public class AccountServiceImpl implements IAccountService {

### 用于设置生命周期的 ###

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

#### @PostConstruct ####

> 作用：用于指定初始化方法。

**代码示例**

@PostConstruct
    public void  init(){
        System.out.println("初始化方法执行了");
    }

#### @PreDestroy ####

> 作用：用于指定销毁方法。

**代码示例**

@PreDestroy
    public void  destroy(){
        System.out.println("销毁方法执行了");
    }

### 配置类的注解 ###

#### @Configuration ####

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

> 属性value:用于指定配置类的字节码

**代码示例**

/**
     *这是一个配置类，相当于bean.xml
     */
    @Configuration
    public class SpringConfiguration {
    
    }

#### @ComponentScan ####

> 作用：既然用配置类来取代xml文件，那么肯定要有一个注解能够实现与之前在配置文件中这个标签同样的功能<context:component-scan base-package=“com.gzgs”/>,也就是用于指定 spring 在初始化容器时要扫描的包。

> 属性basePackages：用于指定要扫描的包。和该注解中的 value 属性作用一样

**示例代码**

@ComponentScan("com.gzgs")
    public class SpringConfiguration {
    
    }

#### @Bean ####

> 作用：该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器,由于@Component只能用于类上的，以致于在使用jar包生成对象的时候不能使用这个注解，这时候就可以使用这个注解来顶替实现同样的功能。

> 属性name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）

**示例代码**

@Bean(name="runner")
    @Scope("prototype")
     QueryRunner createQueryRunner(@Qualifier("ds") DataSource dataSource){ 
    	 new QueryRunner(dataSource);
     }

#### @PropertySource ####

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

> 属性：value\[\]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:

> 应用场景：当我们希望有写配置不希望再代码里面写死的时候，可以定义一个properties文件来保存我们的配置信息，然后使用这个注解讲他们关联起来，例如在配置数据库连接的时候所需要的数据库路径以及用户名和密码等。

**示例代码**

@PropertySource("classpath:jdbcConfig.properties")
    public class SpringConfiguration {
    
    }

#### @Import ####

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

> 属性：value\[\]：用于指定其他配置类的字节码。

> 应用场景：当由于项目需要分别定义不同模块的配置类时，可以将各个模块的配置类导入到一个总的配置类中。

**示例代码**

@Import(jdbcConfig.class)
    public class SpringConfiguration {
    
    }

### 通过注解获取容器 ###

**示例代码**

ApplicationContext ac =new AnnotationConfigApplicationContext(SpringConfiguration.class);

# Spring 整合 Junit #

### **问题场景** ###

> 一般的程序入口是一个main方法，但是当我们在使用@Test进行单元测试的时候，程序的运行就不走main方法了，所以我们就没有办法去创建IOC容器，因为Junit无法知晓我们是否使用了 spring 框架，更不用说帮我们创建 spring 容器了。于是Junit针对了这个问题暴露一个注解，可以让我们替换掉它的运行器。

### 使用方法 ###

**一、拷贝整合 junit 的必备 jar 包到 lib 目录，可就是导入依赖，使用Maven管理工具。**  
**二、使用@RunWith 注解替换原有运行器**

**示例代码**

/**
     * 测试运行类
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    public class AccountTest {
    }

**三、使用@ContextConfiguration 指定 spring 配置文件的位置**

**示例代码**

/**
     * 测试运行类
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = SpringConfiguration.class)
    public class AccountTest {
    }

**四、使用@Autowired 给测试类中的变量注入数据**

**示例代码**

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = SpringConfiguration.class)
    public class AccountTest {
        @Autowired
        private AccountService as;
    	...
    }

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

首先测试类是可以配置到xml文件中的，配置之后可以使用，但是我们还是不推荐将它配置到xml文件中，主要有两个原因：

*  当我们在 xml 中配置了一个 bean， spring 加载配置文件创建容器时，就会创建对象。
 *  测试类只是我们在测试功能时使用，而在项目中它并不参与程序逻辑，也不会有程序的逻辑或者功能上需要用到这个测试类，所以创建完了，并没有使用。那么存在容器中就会造成资源的浪费。

综上所述我们不应该将一个测试类配置到xml文件中。

# 信息管理系统 #

#### jbbc配置类代码 ####

package 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 org.springframework.stereotype.Repository;
    
    import javax.sql.DataSource;
    import java.beans.PropertyVetoException;
    
    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(name="runner")
        @Scope("prototype")
        public QueryRunner createQueryRunner(@Qualifier("ds") DataSource dataSource){ 
            return new QueryRunner(dataSource);
        }
    
        @Bean(name = "ds")
        public DataSource createDataSource(){ 
            try { 
                ComboPooledDataSource ds=new ComboPooledDataSource();
                ds.setDriverClass(driver);
                ds.setJdbcUrl(url);
                ds.setUser(username);
                ds.setPassword(password);
                return ds;
            } catch (PropertyVetoException e) { 
                throw new RuntimeException(e);
            }
        }
    }

#### 主配置类代码 ####

package config;
    
    import org.springframework.context.annotation.*;
    
    /** * 这是一个配置类，相当于bean.xml */
    
    @ComponentScan("com.gzgs")
    @PropertySource("classpath:jdbcConfig.properties")
    @Import(jdbcConfig.class)
    public class SpringConfiguration { 
    
    }

#### 持久层接口实现类代码 ####

package com.gzgs.dao.impl;
    
    import com.gzgs.dao.AccountDao;
    import com.gzgs.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.Repository;
    
    import java.util.List;
    
    /** * 持久层实现类 */
    @Repository
    public class AccountDaoImpl implements AccountDao { 
        @Autowired
        private QueryRunner queryRunner;
        public List<Account> findAll() { 
            try { 
                return queryRunner.query("select * from account", new BeanListHandler<Account>(Account.class));
            }catch (Exception e){ 
                throw new RuntimeException(e);
            }
        }
    
        public Account findAccountById(int id) { 
            try { 
                return queryRunner.query("select * from account where id=?", new BeanHandler<Account>(Account.class),id);
            }catch (Exception e){ 
                throw new RuntimeException(e);
            }
        }
    
        public void insertAccount(Account account) { 
            try { 
                queryRunner.update("insert into account(name,money) values(?,?)", account.getName(),account.getMoney());
            }catch (Exception e){ 
                throw new RuntimeException(e);
            }
        }
    
        public void deleteAccount(int id) { 
            try { 
                queryRunner.update("delete from account where id=?",id);
            }catch (Exception e){ 
                throw new RuntimeException(e);
            }
        }
    
        public void updateAccount(int id, Account account) { 
            try { 
                queryRunner.update("update account set id=?,name=?,money=?", account.getId(),account.getName(),account.getMoney(),id);
            }catch (Exception e){ 
                throw new RuntimeException(e);
            }
        }
    }

#### 业务逻辑层接口实现类代码 ####

package com.gzgs.service.impl;
    
    import com.gzgs.dao.AccountDao;
    import com.gzgs.domain.Account;
    import com.gzgs.service.AccountService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    /** * 业务逻辑层实现类 */
    @Service
    public class AccountServiceImpl implements AccountService { 
        @Autowired
        private AccountDao accountDao;
        public List<Account> findAll() { 
            return accountDao.findAll();
        }
    
        public Account findAccountById(int id) { 
            return accountDao.findAccountById(id);
        }
    
        public void insertAccount(Account account) { 
            accountDao.insertAccount(account);
        }
    
        public void deleteAccount(int id) { 
            accountDao.deleteAccount(id);
        }
    
        public void updateAccount(int id, Account account) { 
            accountDao.updateAccount(id,account);
        }
    }

#### 测试类代码 ####

package com.gzgs.test;
    
    import com.gzgs.domain.Account;
    import com.gzgs.service.AccountService;
    import config.SpringConfiguration;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import java.util.List;
    
    /** * 测试运行类 */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = SpringConfiguration.class)
    public class AccountTest { 
        @Autowired
        private AccountService as;
    
        @Test
        public void testFindAll() { 
            //3.执行方法
            List<Account> accounts = as.findAll();
            for(Account account : accounts){ 
                System.out.println(account);
            }
        }
    
        @Test
        public void testFindOne() { 
            //3.执行方法
            Account account = as.findAccountById(1);
            System.out.println(account);
        }
    
        @Test
        public void testSave() { 
            Account account = new Account();
            account.setName("test anno");
            account.setMoney(12345f);
            //3.执行方法
            as.insertAccount(account);
    
        }
    
        @Test
        public void testUpdate() { 
            //3.执行方法
            Account account = as.findAccountById(4);
            account.setMoney(23456f);
            as.updateAccount(4,account);
        }
    
        @Test
        public void testDelete() { 
            //3.执行方法
            as.deleteAccount(4);
        }
    }

**学习代码：https://download.csdn.net/download/weixin\_45680962/12539194**  
**本博客纯属个人学习笔记，学习资源来自黑马训练营，如有错误，感激指正**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200619170733426.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg==,size_16,color_FFFFFF,t_70