Spring Bean标签内容讲解（依赖注入实现方式讲解等）

3.1 Spring Bean标签的基本配置

• id：Bean实例在Spring容器中的唯一标识
• class：Bean的全限定名称
• 实例化方法：

 ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

<bean id="UserDao" class="Impl.UserDaoImpl"></bean>

3.2 Bean标签范围配置

- 1 当scope的取值为singleton（默认）时

Bean的实例化个数： 1个  

Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例  

Bean的生命周期：
•对象创建：当应用加载，创建容器时，对象就被创建了
·一对象运行：只要容器在，对象一直活着
一对象销毁：当应用卸载，销毁蓉器时，对象就被销毁了

- 2 当scope的取值为prototype时

Bean的实例化个数：多个  

Bean的实例化时机：当调用getBeanQ方法时实例化Bean  

•对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被 Java的垃圾回收器回收了

3.3 Bean生命周期配置

1. init-method：指定类中的初始化方法名称
2. destroy-method：指定类中销毁方法名称

<bean id="UserDao" class="Impl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="destroy"></bean>

public void init(){
        System.out.println("初始化");
    }

    public void destroy(){
        System.out.println("对象销毁");
    }

3.4 Bean实例化三种方式

无参构造方法实例化

public class UserDaoImpl implements UserDao {
    public UserDaoImpl(){
        System.out.println("对象创建了一次");
    }

工厂静态方法实例化

import Dao.UserDao;
import Impl.UserDaoImpl;

public class StaticFactory {
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

工厂实例方法实例化

import Dao.UserDao;
import Impl.UserDaoImpl;

public class DynamicFactory {
    public  UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

3.5 ？？？

3.6 Bean的依赖注入分析

目前UserSenvice实例和UserDao实例都存在与Spving容器中。当前的做法是在容器外部获得UserService
实例和UserDao实例，然后在程序中进行结合。

因为UserSenvice和UserDao都在Spring容案中，而最终程序直接使用的是UserSenvice，所以可以在
Spring容器中，将UserDao设置到UserService內部。

3.7 Bean的依赖注入概念

依赖注入（Dependency Injection）：它是Spring 框架核心IOC的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。

IOC解耦只是降低他们的依赖关系，但不会消除。

例如：业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让Spring 来维护了。
简单的说，就是坐等框架把持久层对象传人业务层，而不用我们自己去获取

怎么将UserDao怎样注入到UserService内部呢?

• 构造方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    private UserServiceImpl(UserDao userDao){
        this.userDao = userDao;
    }
    private UserServiceImpl(){

    }

 <bean id="UserService" class="service.Impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="UserDao"></constructor-arg>
        注入的属性和变量名
    </bean>

• set方法

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

    @Override
    public void save() {
//        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//        UserDao userDao = (UserDao) app.getBean("UserDao");
        userDao.save();
    }

	<bean id="UserDao" class="Impl.UserDaoImpl">	</bean>
    <bean id="UserService" class="service.Impl.UserServiceImpl">
        <property name="UserDao" ref="UserDao"></property>
        <!--ref路径在这一步在spring内部注入了UserDao-->
    </bean>

p命名空间注入
支持了p命名空间，那么随后就可以使用“p：属性”，或者“p：属性-ref”来进行操作的定义。

引入：
xmlns:p="http://www.springframework.org/schema/p"


   <bean id="UserDao" class="Impl.UserDaoImpl"></bean>
    <bean id="UserService" class="service.Impl.UserServiceImpl" p:userDao-ref="UserDao"/>

3.8 Bean的依赖注入的数据类型

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

1. 普通数据类型

 private String name;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }

    <bean id="UserDao" class="Impl.UserDaoImpl">
       <property name="name" value="bob"></property>
       <property name="age" value="13"></property>
       
 </bean>

1. 引用数据类型

2. 集合数据类型

public class UserDaoImpl implements UserDao {
	 private List<String> strList;
    private Map<String, User> userMap;
    private Properties properties;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

public class  User {
    private String name;
    private String addr;

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

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", addr='" + addr + '\'' +
                '}';
    }
    }

 <bean id="UserDao" class="Impl.UserDaoImpl">
        <property name="name" value="bob"></property>
        <property name="age" value="13"></property>
        <property name="strList">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </list>
        </property>
        <property name="userMap">
            <map><entry key="u1" value-ref="user1"></entry>
                <entry key="u2" value-ref="user2"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="p1">pp1</prop>
                <prop key="p2">pp2</prop>
                <prop key="p3">pp3</prop>
            </props>
        </property>
    </bean>
    <bean name="user1" class="domin.User">
        <property name="name" value="tom"></property>
        <property name="addr" value="shanghai"></property>
    </bean>
    <bean name="user2" class="domin.User">
        <property name="name" value="lucy"></property>
        <property name="addr" value="shenzhen"></property>
    </bean>

3.9 引入其他配置文件（分模块开发）

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

Spring的重点配置
标签
ia属性:在容器中Bean实例的唯一标识，不允许重复
class属性:要实例化的Bean的全限定名
scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
标签：属性注入
name属性：属性名称
value属性：注入的普通属性值
zef属性：注入的对象引用值
标签