Spring（二）bean，DI

bean标签

1 bean的三种创建方式

1.构造器实例化： 用默认构造函数创建。
在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数（无参构造），则对象无法创建，当有其他带参的构造函数时，需要声明无参构造函数，当没有其他构造函数则不用（默认是有无参构造的）

	 //id为标识符，class为要通过getBean()创建的类
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

2.实例工厂实例化： 使用普通工厂中的方法创建对象（使用某个类中非静态方法创建对象，并存入spring容器）

	/**
	 * 第二种方式
     * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）
     */
    public class InstanceFactory {

        public IAccountService getAccountService(){
            return new AccountServiceImpl();
        }
    }  

目的：先创建实例工厂instanceFactory，然后调用==getAccountService()==方法创建对象。

	// 			标识符                      指定类
    <bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
    //          标识符					指定实例工厂的id				指定实例工厂中生产对象的方法
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean> 

3.静态工厂实例化： 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
PS:类的构造函数也是静态方法,因此默认无参构造函数也可以看作一种静态工厂方法

	/**
	 * 第三种方式
     * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）
     */
    public class StaticFactory {

        public static IAccountService getAccountService(){
            return new AccountServiceImpl();
        }
    }

   	//            标识符                      指定类                                     直接指定类中的静态方法           
    <bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>    

2 bean的作用范围

bean标签的scope属性：
作用：指定bean的作用范围
取值：常用的就是单例和多例

singleton：单例（默认）
prototype：多例
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时它就是session

global-session图解：

3 bean对象的生命周期

单例对象

出生：当容器创建时对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象死亡
总结：单例对象的生命周期和容器相同

//配置：
<bean id="accountService" class="com.java.service.impl.AccountServiceImpl"
          scope="singleton" init-method="init" destroy-method="destroy"></bean>
//实现类          
 public class AccountServiceImpl implements IAccountService {
    public AccountServiceImpl(){ System.out.println("对象创建了"); }
    @Override
    public void saveAccount(){ System.out.println("service中的saveAccount执行了。。。"); }
    public void init(){ System.out.println("对象初始化了。。。"); }
    public void destroy(){ System.out.println("对象被销毁了。。。"); }
}     
//测试：
public class Client {
    public static void main(String[] args) {
        //获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as = (IAccountService) ac.getBean("accountService");
        as.saveAccount();
    }
}
//输出：
对象创建了
对象初始化了。。。
service中的saveAccount执行了。。。

为什么没有销毁？？
当main方法执行完，内存就已经被释放了（容器也销毁了），destroy方法还没来得及执行，所以要手动调用销毁容器的方法。
destroy方法是在容器销毁之前执行。

public class Client {

    public static void main(String[] args) {
        //获取核心容器对象
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as = (IAccountService) ac.getBean("accountService");
        as.saveAccount();
        ac.close();
    }
}
//输出：
对象创建了
对象初始化了。。。
service中的saveAccount执行了。。。
对象被销毁了。。。

多例对象

出生：当我们使用对象时spring框架为我们创建
活着：对象只要在使用过程中就是一直活着
死亡：当对象长时间不用且没有别的对象引用时，由Java的垃圾回收器回收

public class Client {

    public static void main(String[] args) {
        //获取核心容器对象
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as = (IAccountService) ac.getBean("accountService");
        as.saveAccount();
        ac.close();
    }
}
//输出：
对象创建了
对象初始化了。。。
service中的saveAccount执行了。。。

依赖注入

IOC的作用：
降低程序间的耦合（依赖关系）
依赖关系的管理：
以后都交给spring来维护，在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明
依赖关系的维护：
就称之为依赖注入。
能注入的数据：有三类
基本类型和String
其他bean类型（在配置文件中或者注解配置过的bean）
复杂类型/集合类型

1. 三种注入方式

注入的方式：有三种
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供

1.1 第一种使用构造函数（一般不采用）

需要注入的对象

public class AccountServiceImpl implements IAccountService {
	//随便取的几种类型
    private String name;
    private Integer age;
    private Date birthday;

    public AccountServiceImpl(String name, Integer age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    @Override
    public  void saveAccount(){
        System.out.println("service中的saveAccount执行了。。。"+name+","+age+","+birthday);
    }
}

xml文件bean配置

	<bean id="accountService" class="com.java.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

    <!-- 配置一个日期对象 -->
    <bean id="now" class="java.util.Date"></bean>

使用的标签:constructor-arg
标签出现的位置：bean标签的内部
标签中的属性
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
name：用于指定给构造函数中指定名称的参数赋值 （常用的）
=============以上三个用于指定给构造函数中哪个参数赋值===============================
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

    优势：
        在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
    弊端：
        改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。（每个属性必须注值）

1.2 第二种使用set注入（更常用）

需要注入的对象

public class AccountServiceImpl2 implements IAccountService {

    private String name;
    private Integer age;
    private Date birthday;

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

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

    public void setBirthday(Date birthday) { this.birthday = birthday; }

    @Override
    public  void saveAccount(){
        System.out.println("service中的saveAccount执行了。。。"+name+","+age+","+birthday);
    }
}

xml文件bean配置

	<bean id="accountService2" class="com.java.service.impl.AccountServiceImpl2">
            <property name="name" value="Test"></property>
            <property name="age" value="18"></property>
            <property name="birthday" ref="now"></property>
    </bean>

涉及的标签：property
出现的位置：bean标签的内部
标签的属性
name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

    优势：<br>
        创建对象时没有明确的限制，可以直接使用默认构造函数（属性可以按需注值，不用打的可不注值）<br>
    弊端：<br>
        如果有某个成员必须有值，则获取对象时有可能set方法还没有执行注值。（用默认构造函数（无参构造）创建完bean对象后就被拿去用完了，还没来得及注值）

1.3 第三种注解注入

Autowired

2. 复杂类型的注入/集合类型的注入

用于给List结构集合注入的标签：
list array set
用于个Map结构集合注入的标签:
map props
结构相同，标签可以互换

需要注入的对象

public class AccountServiceImpl3 implements IAccountService {

    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myPproperties;

    public void setMyStrs(String[] myStrs) { this.myStrs = myStrs; }

    public void setMyList(List<String> myList) { this.myList = myList; }

    public void setMySet(Set<String> mySet) { this.mySet = mySet; }

    public void setMyMap(Map<String, String> myMap) { this.myMap = myMap;}

    public void setMyPproperties(Properties myPproperties) { this.myPproperties = myPproperties; }

    @Override
    public  void saveAccount(){
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myPproperties);
    }

xml文件bean配置

	<bean id="accountService3" class="com.java.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>
        <property name="myList">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>
        <property name="myMap">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB" value="bbb"></entry>
            </map>
        </property>
        <property name="myPproperties">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>
    </bean>

按作用分类常用IOC注解

  //曾经XML的配置：
  <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"
        scope=""  init-method="" destroy-method="">
     <property name=""  value="" | ref=""></property>
  </bean>

1. 用于创建对象的注解

他们的作用就和在XML配置文件中编写一个标签实现的功能是一样的
Component：

• 作用：用于把当前类对象存入spring容器中
• 属性：
  value： 用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。

Controller： 一般用在表现层
Service： 一般用在业务层
Repository： 一般用在持久层

以上三个注解他们的作用和属性与Component是一模一样。
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰

bean.xml配置文件开启扫描包的注解

//需要注入容器的对象
 @Component
public class AccountServiceImpl implements IAccountService {

//测试
public class Client {
    public static void main(String[] args) {
        //获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as = (IAccountService) ac.getBean("accountServiceImpl");
        System.out.println(as);
    }
}
//注入成功
com.java.service.impl.AccountServiceImpl@aecb35a

2. 用于注入数据的注解

他们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一样的
Autowired：

• 作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功
  
  如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。
  如果Ioc容器中有多个类型匹配时：先根据数据类型圈定匹配的对象，再使用变量名称作为Id继续查找，如果有一样的就成功，反之失败。
  

• 出现位置：
  可以是变量上，也可以是方法上

• 细节：
  在使用注解注入时，set方法就不是必须的了。

Qualifier：

• 作用：在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用（须和Autowired一起用）。但是在给方法参数注入时可以（后面有提到）
• 属性：
  value：用于指定注入bean的id。

//Dao实现类1
@Repository("accountDao1")
public class AccountDaoImpl1 implements IAccountDao {
    @Override
    public void saveAccount() {System.out.println("账户保存成功1111111111");}
}
//Dao实现类2
@Repository("accountDao2")
public class AccountDaoImpl2 implements IAccountDao {
    @Override
    public void saveAccount() {System.out.println("账户保存成功2222222222");}
}
//service实现类
@Service
public class AccountServiceImpl implements IAccountService {
    @Autowired
    @Qualifier("accountDao2")
    private IAccountDao accountDao = null;
   
    @Override
    public  void saveAccount(){accountDao.saveAccount();}
}
//测试
public class Client {
    public static void main(String[] args) {
        //获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as = (IAccountService) ac.getBean("accountServiceImpl");
//        System.out.println(as);
        as.saveAccount();
    }
}
//输出：
账户保存成功1111111111

Resource：

• 作用：直接按照bean的id注入。它可以独立使用
• 属性：
  name：用于指定bean的id。

	@Resource(name = "accountDao2")
    private IAccountDao accountDao = null;

以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。
另外，集合类型的注入只能通过XML来实现。

Value：

• 作用：用于注入基本类型和String类型的数据
• 属性：
  value：用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式）
  SpEL的写法：${表达式}（EL表达式出现在什么地方在就在哪取值—mybatis，spring，jsp中）

3. 用于改变作用范围的

他们的作用就和在bean标签中使用scope属性实现的功能是一样的
Scope：

• 作用：用于指定bean的作用范围
• 属性：
  value：指定范围的取值。常用取值：singleton prototype

4. 和生命周期相关（了解）

他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的
PreDestroy：

• 作用：用于指定销毁方法

PostConstruct：

• 作用：用于指定初始化方法

@Service
public class AccountServiceImpl implements IAccountService {
    @Resource(name = "accountDao1")
    private IAccountDao accountDao = null;

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

    @Override
    public  void saveAccount(){accountDao.saveAccount();}
}
//测试
public class Client {
    public static void main(String[] args) {
        //获取核心容器对象
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as1 = (IAccountService) ac.getBean("accountServiceImpl");
        as1.saveAccount();
        ac.close();
    }
}
//输出：
初始化方法执行了。。。
账户保存成功1111111111
销毁方法执行了。。。