Spring（3）IOC及依赖注入（基于注解的实现）
学习基于注解的 IoC 配置，大家脑海里首先得有一个认知，即注解配置和 xml 配置要实现的功能都是一样
的，都是要降低程序间的耦合。只是配置的形式不一样。
关于实际的开发中到底使用xml还是注解，每家公司有着不同的使用习惯。所以这两种配置方式我们都需要掌
握。
环境配置
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
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管理-->
<context:component-scan base-package="domain"></context:component-scan>
</beans>
对具体类的配置
package domain.service.impl;
import domain.service.IAccountService;
import domain.dao.IAccountDao;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
@Service("accountService")
@Scope
public class AccountServiceImpl implements IAccountService {
// @Autowired
// @Qualifier("accountDao1")
@Resource(name = "accountDao1")
private IAccountDao accountDao = null;
public AccountServiceImpl() {
System.out.println("对象创建成功");
// System.out.println("a = "+ a);
}
public void saveAccount() {
accountDao.saveAccount();
}
@PostConstruct
public void init() {
System.out.println("初始化。。");
}
@PreDestroy
public void destory() {
System.out.println("销毁方法。。");
}
}
1、常用注解
<bean id="accountService" class="domain.service.impl.AccountServiceImpl" scope="singleton" init-method="" destroy-method="">
<property name="" value="" ref=""></property>
</bean>
1.1、用于创建对象的
作用等同于xml配置中的bean标签
<bean id="" class=""></bean>
1.1.1、Component
作用：把被注解的类创建对象后放入spring容器中
属性：
value：指定当前的bean的id，如果不写那么他的默认值是被注解的类的类名，且首字母小写
@Service("accountDao1")
public class AccountDaoImpl implements IAccountDao {
public void saveAccount() {
System.out.println("保存账户成功！！！11111111111");
}
}
1.1.2、Controller，Service，Repository
以上三个注解的作用和属性与Component完全相同，
它们是spring提供的三层架构的注解，使三层对象更加清晰
@Controller ：一般用于表现层的注解。
@Service ：一般用于业务层的注解。
@Repository ：一般用于持久层的注解。
细节：如果注解中有且只有一个属性 要赋值时是 ，且名称是 value ，value 在赋值是可以不写。
1.2、用于注入数据
作用等同于xml中的bean标签下的properties标签
<bean id="" class="">
<property name="" value=""/ref=""></property>
</bean>
1.2.1、@Autowired
作用：自动按照类型注入，只要有唯一的一个bean对象与要注入的类型匹配，就可以注入成功
如果IOC容器中没有与要注入变量同类型的bean，则报错
如果IOC容器中有多个与之类型匹配，在不使用其他注解的情况下，依据要注入变量的名称和bean对象的id进行比较，如果变量名与id相同就可以注入，如果无匹配id则报错
出现位置：
变量和方法上都可以出现
细节：使用注解注入时，set方法非必须
@Autowired
private IAccountDao accountDao = null;
1.2.2、Qualifier:
作用：
在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给字段注入时不能独立使用，必须和
@Autowire 一起使用；但是给方法参数注入时，可以独立使用。
属性：
value：指定 bean 的 id。
@Autowired
@Qualifier("accountDao1")
private IAccountDao accountDao = null;
1.2.3、@Resource
作用：
直接按照 Bean 的 id 注入。它也只能注入其他 bean 类型。
属性：
name：指定 bean 的 id。
@Resource(name = "accountDao1")
private IAccountDao accountDao = null;
1.2.4、@Value
作用：
注入基本数据类型和 String 类型数据的
属性：
value：用于指定数据的值。它可以使用spring中的spEl（spring中的EL表达式）
spEL写法：${表达式}
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
1.3、用于改变作用范围的
作用等同于xml配置中bean标签的scope属性
@Service("accountDao1")
@Scope("prototype")
public class AccountDaoImpl implements IAccountDao {
public void saveAccount() {
System.out.println("保存账户成功！！！11111111111");
}
}
1.3.1、 @Scope
作用：
指定 bean 的作用范围。
属性：
value：指定范围的值。
取值：singleton prototype request session globalsession
1.4、改变作用范围
作用等同于xml配置中的init-method和destory-method属性
@PostConstruct
public void init() {
System.out.println("初始化。。");
}
@PreDestroy
public void destory() {
System.out.println("销毁方法。。");
}
1.4.1、@PostConstruct
作用：
用于指定初始化方法。== init-method
1.4.2、@PreDestroy
作用：
用于指定销毁方法。==destory-method
1.5、关于 Spring 注解和 XML
注解的优势：
配置简单，维护方便（我们找到类，就相当于找到了对应的配置）。适用于自己定义的类
XML 的优势：
修改时，不用改源码。不涉及重新编译和部署。适用于通过jar导入的类
2、spring 的纯注解配置
写到此处，基于注解的 IoC 配置已经完成，但是大家都发现了一个问题：我们依然离不开 spring 的 xml 配
置文件，那么能不能不写这个 bean.xml，所有配置都用注解来实现呢？
2.1、问题
之所以我们现在离不开 xml 配置文件，是因为我们有一句很关键的配置：
<!-- 告知spring框架在，读取配置文件，创建容器时，扫描注解，依据注解创建对象，并存入容器中 -->
<context:component-scan base-package="com.itheima"></context:component-scan>
如果他要也能用注解配置，那么我们就离脱离 xml 文件又进了一步。
另外，数据源和 JdbcTemplate 的配置也需要靠注解来实现。
<!-- 配置 dbAssit -->
<bean id="dbAssit" class="com.itheima.dbassit.DBAssit">
<property name="dataSource" ref="dataSource"></property>
</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:///spring_day02"></property>
<property name="user" value="root"></property>
<property name="password" value="1234"></property>
</bean>
2.2、新注解说明
2.2.1、@Configuration
作用：
用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。获取容器时需要使用
AnnotationApplicationContext(有@Configuration 注解的类.class)。
属性：
value:用于指定配置类的字节码
细节：当配置类作为AnnotationConfigApplicationContext对象创建容器的参数该注解可以省略
@Configuration
public class SpringCinfiguration {
}
注意：
我们已经把配置文件用类来代替了，但是如何配置创建容器时要扫描的包呢？
请看下一个注解。
2.2.2、@ComponentScan
作用：通过注解指定spring容器在创建时要扫描的包
属性：value：和basePackages作用相同，都是指定要创建容器要扫描的包
该注解作用相当于在xml中配置的：
<context:component-scan base-package="wf"></context:component-scan
@Configuration
@ComponentScan(basePackages = {"wf","config"})//wf，config是包名
public class SpringCinfiguration {
}
注意：
我们已经配置好了要扫描的包，但是数据源和 JdbcTemplate 对象如何从配置文件中移除呢？
请看下一个注解。
2.2.3、@Bean
作用：把当前方法的返回值作为bean对象存入spring的ioc容器中
属性：
name：用于指定bean对象的id，当不写时默认是当前方法名
细节：
当我们使用注解配置方法时，如果方法有参数，sprig框架就会去容器中查找看是否由可用bean对象
查找方式和Autowired注解的作用一样
@Bean(name = "runner")
public QueryRunner creatQueryRunner(@Qualifier("ds1") DataSource dataSource){
return new QueryRunner(dataSource);
}
注意:
我们已经把数据源和 DBAssit 从配置文件中移除了，此时可以删除 bean.xml 了。
但是由于没有了配置文件，创建数据源的配置又都写死在类中了。如何把它们配置出来呢？
请看下一个注解。
2.2.4、@PropertySource
jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring
jdbc.username=root
jdbc.password=123456
作用：
用于加载.properties 文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到
properties 配置文件中，就可以使用此注解指定 properties 配置文件的位置。
属性：
value[]：用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath:
@Configuration
@PropertySource("classpath:jdbc.properties")
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;
}
注意：
此时我们已经有了两个配置类，但是他们还没有关系。如何建立他们的关系呢？
请看下一个注解。
2.2.5、@Import
作用：用于导入其他的配置类，在引入其他配置类时，可以不用再写@Configuration 注解。当然，写上也没问
题。
属性：
value[]：用于指定其他配置类的字节码。
@Configuration
@ComponentScan(basePackages = {"wf","config"})
@Import({JdbcConfig.class})
public class SpringCinfiguration {
}
注意：
我们已经把要配置的都配置好了，但是新的问题产生了，由于没有配置文件了，如何获取容器呢？
请看下一小节。
2.2.6、通过注解获取容器：
AnnotationConfigApplicationContext ca = new AnnotationConfigApplicationContext(SpringCinfiguration.class);
3、Spring 整合 Junit
3.1、问题
在测试类中，每个测试方法都有以下两行代码：
ApplicationContext ac = new ClassPathXmlApplicationContext(“bean.xml”);
IAccountService as = ac.getBean(“accountService”,IAccountService.class);
这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。
3.2、解决思路分析
针对上述问题，我们需要的是程序能自动帮我们创建容器。一旦程序能自动为我们创建 spring 容器，我们就无须手动创建了，问题也就解决了。
我们都知道，junit 单元测试的原理（在 web 阶段课程中讲过），但显然，junit 是无法实现的，因为它自己都无法知晓我们是否使用了 spring 框架，更不用说帮我们创建 spring 容器了。不过好在，junit 给我们暴露了一个注解，可以让我们替换掉它的运行器。
这时，我们需要依靠 spring 框架，因为它提供了一个运行器，可以读取配置文件（或注解）来创建容器。我们只需要告诉它配置文件在哪就行了。
3.3 、 配置步骤
3.3.1、导入相关坐标
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.6.RELEASE</version>
</dependency>
3.3.2、使用@RunWith 注解替换原有运行器
@RunWith(SpringJUnit4ClassRunner.class)
public class AccountServiceTest {}
3.3.3、使用@ContextConfiguration 指定 spring 配置文件的位置
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringCinfiguration.class)
public class AccountServiceTest {}
@ContextConfiguration 注解：
locations 属性：用于指定配置文件的位置。如果是类路径下，需要用 classpath:表明
classes 属性：用于指定注解的类。当不使用 xml 配置时，需要用此属性指定注解类的位置。
3.3.4、使用@Autowired
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringCinfiguration.class)
public class AccountServiceTest {
@Autowired
private IAccountService as;
}
完整代码
package test;
import config.SpringCinfiguration;
import org.apache.commons.dbutils.QueryRunner;
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 wf.domain.Account;
import org.junit.Test;
import wf.service.IAccountService;
import java.util.List;
/**
* 使用junit进行单元测试
* spring整合junit的配置
* 1.导入spring整合junit的jar
* 2.
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringCinfiguration.class)
public class AccountServiceTest {
@Autowired
private IAccountService as;
@Test
public void testQuery(){
//1.加载配置文件
AnnotationConfigApplicationContext ca = new AnnotationConfigApplicationContext(SpringCinfiguration.class);
//2.获取服务层对象
QueryRunner as = ca.getBean("runner", QueryRunner.class);
QueryRunner as1 = ca.getBean("runner", QueryRunner.class);
System.out.println(as ==as1);
}
@Test
public void testFindAll(){
/* //1.加载配置文件
//, JdbcConfig.class
AnnotationConfigApplicationContext ca = new AnnotationConfigApplicationContext(SpringCinfiguration.class);
//2.获取服务层对象
IAccountService as = ca.getBean("accountService", IAccountService.class);*/
//3.根据对象执行方法
List<Account> accounts = as.findAllAccount();
for (Account account:accounts){
System.out.println(account);
}
}
@Test
public void testFindById(){
/* //1.加载配置文件
AnnotationConfigApplicationContext ca = new AnnotationConfigApplicationContext(SpringCinfiguration.class);
//2.获取服务层对象
IAccountService as = ca.getBean("accountService", IAccountService.class);*/
//3.根据对象执行方法
Account a = as.findOneById(3);
System.out.println(a);
}
@Test
public void testSave(){
Account account = new Account();
account.setName("gx");
account.setMoney(1234.0f);
/*//1.加载配置文件
AnnotationConfigApplicationContext ca = new AnnotationConfigApplicationContext(SpringCinfiguration.class);
//2.获取服务层对象
IAccountService as = ca.getBean("accountService", IAccountService.class);*/
//3.根据对象执行方法
as.saveAccount(account);
}
@Test
public void testUpdate(){
Account account = new Account();
account.setId(4);
account.setName("wf");
account.setMoney(1234.0f);
/* //1.加载配置文件
AnnotationConfigApplicationContext ca = new AnnotationConfigApplicationContext(SpringCinfiguration.class);
//2.获取服务层对象
IAccountService as = ca.getBean("accountService", IAccountService.class);*/
//3.根据对象执行方法
as.updateAccount(account);
}
@Test
public void testDelete(){
/* //1.加载配置文件
AnnotationConfigApplicationContext ca = new AnnotationConfigApplicationContext(SpringCinfiguration.class);
//2.获取服务层对象
IAccountService as = ca.getBean("accountService", IAccountService.class);*/
//3.根据对象执行方法
as.deleteAccount(8);
}
}
也可以在xml配置文件项目中使用此方法整合junit