spring 注入的方式（xml）

spring IOC 的本质：

    控制反转是一种通过描述（XML 或注解）并通过第三方去生产或者获取特定对象的方式。在spring 中实现控制反转的是IOC 容器，其实现方法是依赖注入（Dependency Injection ,DI）

    IOC(控制反转)，是一种设计思想，DI（依赖注入）是实现IOC 的一种方法，也有人认为DI只是IOC 的另一种说法。没有IOC 的程序中，我们使用面向对象编程，对象的创建和对象间的依赖关系完全编码这程序中，对象的创建由自己控制，实现控制反转后将对象的创建交给了第三方（创建完以后放在spring  容器），个人认为控制反转就是获得对象的方式反转了。

    采用XML 方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean 的定义信息直接以注解的形式定义在实现类中，从而达到零配置的目的。

    说完了概念，我们来创建spring项目实现控制反转并且用三种方式是实现注入。

    

    用xml的方式来注入：

　 第一步：新建项目，导入依赖（这个依赖导入，直接导入spring 的所有依赖）

 <dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.8.RELEASE</version>
    </dependency>

  </dependencies>

    第二步：新建一个pojo类

package pojo;

public class User {
    private Integer id;
    private String name;

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

    第三步：新建dao ，dao 实现类，service 和service 实现类

//userDao类
package dao;

public interface UserDao {
    public void printUser();
}

//userDao实现类
package dao.impl;
import dao.UserDao;

public class UserDaoImpl implements UserDao {


    public void printUser() {
        System.out.println("我就是用户1");
    }
}

//这是男用户的实现类
package dao.impl;

import dao.UserDao;

public class ManUserDaoImpl implements UserDao {

    public void printUser() {
        System.out.println("我是男用户1");
    }
}

//UserService 业务类接口 package service; public interface UserService { public void printUser(); } //UserServiceImp 实现类 package service.impl; import dao.UserDao; import service.UserService; public class UserServiceImp implements UserService { private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void printUser() { userDao.printUser(); } }

    第四步：编写配置文件，applicationContext.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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

    <!--id 是在spring 里的标识，class 里面必须写全限定类路径    -->
    <bean id="user" class="pojo.User" >
        <!--这里是为user的name属性注入值"xiaobin"        -->
        <property name="name" value="xiaobin"></property>
    </bean>
    
    <bean id="manUserDaoImpl" class="dao.impl.ManUserDaoImpl"></bean>

    <bean id="userServiceImp" class="service.impl.UserServiceImp">
        <!--ref 指的是注入bean        -->
        <property name="userDao" ref="manUserDaoImpl"></property>
    </bean>
    
</beans>

    第五步：新建一个测试类测试

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.User;
import service.impl.UserServiceImp;

public class mySpringTest {
    public static void main(String[] args) {
        //获取spring 的上下文对象
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        //我们的对象现在由spring 接管，我们要用就去容器里面去取就可以了,这里是去取id为user的bean
        User user= (User) applicationContext.getBean("user");
        System.out.println("我的名字是："+user.getName());
        //这是去取id为userServiceImp的bean 
        UserServiceImp userServiceImp = (UserServiceImp) applicationContext.getBean("userServiceImp");
        userServiceImp.printUser();
    }
}

输出的结果是： 

  我的名字是：xiaobin
  我是男用户1