第3章 IoC和DI（依赖注入）注解开发

第3章 IoC和DI（依赖注入）注解开发

3.1依赖

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。
IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
依赖注入（DI）的方式两种：①通过有参构造；②通过set方法

3.1.1 通过set方法实现依赖注入

步骤1: 在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void save() {
        userDao.save();
    }
}

步骤2：配置Spring容器调用set方法进行注入

<!--通过set方法实现依赖注入-->
<bean id="userDao" class="com.wx.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.wx.service.impl.UserServiceImpl">
    <!--
        name:setXxx方法中去掉set后首字母变小写
        ref:对象的引用，注入对象在spring容器中的唯一标识,就是bean的id
    -->
    <property name="userDao" ref="userDao"></property>
</bean>
//注入过程：把spring容器中的UserDao,通过UserService中的setUserDao方法，把UserDao注入给ServiceDao

测试

public void test(){
    ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = (UserService)app.getBean("userService");
    userService.save();
}

注意：通过set方式注入时配置文件有个简便的写法:通过P命名空间注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">

    <!--通过set方法实现依赖注入-->
    <bean id="userDao" class="com.wx.dao.impl.UserDaoImpl"/>
     <bean id="userService" class="com.wx.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>
</beans>

3.1.2 通过构造方法实现依赖注入

步骤1: 在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    public UserServiceImpl() {
    }
    public void save() {
        userDao.save();
    }
}

步骤2：配置Spring容器调用构造方法进行注入

  <bean id="userDao" class="com.wx.dao.impl.UserDaoImpl"/>
  <!--通过构造方法注入-->
  <bean id="userService" class="com.wx.service.impl.UserServiceImpl" >
      <constructor-arg name="userDao" ref="userDao"/>
  </bean>

步骤3：测试

public void test(){
    ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = (UserService)app.getBean("userService");
    userService.save();
}

3.1.3 依赖注入的数据类型

上面的操作，都是注入的引用Bean，除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。
注入数据的三种数据类型

• 普通数据类型
• 引用数据类型
• 集合数据类型

其中引用数据类型，上述已经操作过，这里就不操作了，下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。

普通数据类型

1：UserDaoImpl中添加普通类型数据

public class UserDaoImpl implements UserDao {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void save() {
        System.out.println("save running....");
        System.out.println(name+"------"+age);
    }
}

2:修改配置文件

<bean id="userDao" class="com.wx.dao.impl.UserDaoImpl">
    <property name="name" value="lisi"></property>
    <property name="age" value="18"></property>
</bean>
<!--通过构造方法注入-->
<bean id="userService" class="com.wx.service.impl.UserServiceImpl" >
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

3：测试

public void test(){
    ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = (UserService)app.getBean("userService");
    userService.save();
}

4：结果

集合数据类型

List 集合

** 1：在UserDaoImpl中添加List集合**

public class UserDaoImpl implements UserDao {
    //List集合
    private List<String> stringList;
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }  
    public void save() {
        System.out.println("List<String>"+stringList);
        System.out.println("save running....");
    }
}

2:编写配置文件

<bean id="userDao" class="com.wx.dao.impl.UserDaoImpl">
    <property name="stringList">
        <list>
            <value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </property>
</bean>
<bean id="userService" class="com.wx.service.impl.UserServiceImpl" >
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

3:测试代码

public void test(){
    ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = (UserService)app.getBean("userService");
    userService.save();
}

4：结果

Map集合

** 1：在UserDaoImpl中添加Map集合**

public class UserDaoImpl implements UserDao {
    private Map<String, User> userMap;
    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }
    public void save() {
        System.out.println("Map<String, User>"+ userMap);
    }
}

2:编写配置文件

  <bean id="userDao" class="com.wx.dao.impl.UserDaoImpl">
      <property name="userMap">
          <map>
              <entry key="u1" value-ref="user1"/>
              <entry key="u2" value-ref="user2"/>
          </map>
      </property>
  </bean>
  <bean id="user1" class="com.wx.domain.User">
      <property name="name" value="wangwu" />
      <property name="adr" value="北京" />
  </bean>
  <bean id="user2" class="com.wx.domain.User">
      <property name="name" value="lucy" />
      <property name="adr" value="上海" />
  </bean>
    <!--通过构造方法注入-->
  <bean id="userService" class="com.wx.service.impl.UserServiceImpl" >
      <constructor-arg name="userDao" ref="userDao"/>
  </bean>

3:测试

public void test7(){
    ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = (UserService)app.getBean("userService");
    userService.save();
}

4：结果

Properties集合

1：UserDaoImpl 注入Properties 集合

public class UserDaoImpl implements UserDao {
    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public void save() {
        System.out.println("Properties"+properties);
    }
}

2：配置文件

<bean id="userDao" class="com.wx.dao.impl.UserDaoImpl">
   <property name="properties">
        <props>
            <prop key="p1">ppp1</prop>
            <prop key="p2">ppp2</prop>
            <prop key="p3">ppp3</prop>
        </props>
    </property>
</bean>

3:测试

public void test(){
    ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userService = (UserService)app.getBean("userService");
    userService.save();
}

4：结果

最后补充一点：实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

 <import resource="applicationContext-xxx.xml"/>

3.2 IoC和DI原始注解开发

3.2.1 Spring原始注解

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。 另外Spring原始注解主要是替代的配置

注意：
使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是告诉spring容器在指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

<!--注解的组件扫描-->
<context:component-scan base-package="com.wx"></context:component-scan>
<!--component-scan base-package:是扫描基础包，扫描它本身及其子类-->

3.2.2 Spring注解开发入门

• 使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。
• 使用@Compont或@Service标识UserServiceImpl需要Spring进行实例化
• 使用@Autowired或者@Autowired+@Qulifier或者@Resource（name=””）进行userDao的注入

1：配置组件扫描

<context:component-scan base-package="com.wx"/>

2：编写 UserDaoImpl

//<bean id="userDao" class="com.wx.dao.impl.UserDaoImpl"></bean>
//@Component("userDao1")
@Repository("userDao1")
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("save running....");
    }
}

3：编写UserServiceImpl

//@Component("userService")
@Service("userService")
public class UserServiceImpl implements UserService {
    //<property name="userDao" ref="userDao"></property>
    @Autowired
    @Qualifier("userDao1")
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void save() {
        userDao.save();
    }
}

注意：使用@Autowired或者@Autowired+@Qulifier或者@Resource（name=””）进行userDao的注入时可以把关于UserDao的set方法注释掉

4：测试

    public void test1(){
        ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl userService = app.getBean(UserServiceImpl.class);
        userService.save();
    }

@Autowired或者@Autowired+@Qulifier或者@Resource（name=“xxx”）的使用

• @Autowired注解是按照数据类型匹配，仅适用于一个同类型的bean
• @Autowired+@Qualifier:按照名称匹配
• @Resource(name = “userDao1”)相当于@Autowired+@Qualifier

3.2.3 注入普通类型

使用@Value进行字符串的注入

@Value("注入基本类型")
private  String string;
@Value("${jdbc.driver}")
private String driver;

public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
public void save() {
    System.out.println(string);
    System.out.println(driver);
    userDao.save();
}

3.3 IoC和DI新注解开发

使用原始的注解还不能全部替代xml配置文件，所以我们需要新注解完整的代替xml配置文件。使用新注解替代的配置如下：

 1.非自定义的Bean的配置：<bean>
 2.加载properties文件的配置：<context:property-placeholder>
 3.组件扫描的配置：<context:component-scan>
 4.引入其他文件：<import>

接下来我们通过演示操作数据库来应用一下新注解，在这里有些模块的代码就不写了，写一些重要模块的代码

1：创建核心配置类

//标志当前类为spring的核心配置类
@Configuration

//组件扫描<context:component-scan base-package="com.wx"/>
@ComponentScan("com.wx")

//加载配置文件<context:property-placeholder  location="classpath:jdbc.properties"/>
@PropertySource("classpath:jdbc.properties")

//导入其他配置文件@Import({xxxx.class,xxx.class})
public class SpringConfiguration {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    //spring会将当前方法的返回值，以指定名称存储到spring中
    @Bean("dataSource")
    public DataSource getDataSourse() throws Exception {
        ComboPooledDataSource dataSource=new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

2：编写UserServiceImpl

@Service("userService")
public class UserServiceImpl implements UserService {
    @Resource(name = "userDao1")
    private UserDao userDao;
    @Resource(name = "dataSource")
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void save() {
        userDao.save();
        System.out.println("dataSource:"+dataSource);
    }
}

3：测试

 public void test(){
        ApplicationContext app=new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserServiceImpl userService = app.getBean(UserServiceImpl.class);
        userService.save();
 }

3.4 Spring整合Junit

3.4.1 原始Junit测试Spring的问题

在测试类中，每个测试方法都有以下两行代码：

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。
上述问题解决思路：
• 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它
• 将需要进行测试Bean直接在测试类中进行注入

3.4.2 Spring集成Junit步骤

1：导入spring集成Junit的坐标

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>

2:使用@Runwith注解替换原来的运行期

3:使用@ContextConfiguration指定配置文件或配置类

4:使用@Autowired注入需要测试的对象

5:创建测试方法进行测试

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")---这个代表是用配置文件开发的
@ContextConfiguration(classes = {SpringConfiguration.class})//这个表示用注解类开发的
public class SpringJunitTest {
    //测试谁注入谁
    @Autowired
    private UserService userService;
    @Test
    public void test1(){
        userService.save();
    }
}

敬请期待spring基础下一章节