Spring-创建bean和装配bean

1、创建bean的三种方式

beans：
    bean1：构造方法实例化
    bean2：

static_factory：静态工厂实例化
    如果返回值是接口类型、没有实现类，只能使用静态工厂实例化
    例如Mybatis中Mapper接口，没有实现类

fac_factory：实例工厂实例化
    工厂里面方法没有被static修饰，需要先获取工厂对象再获取工厂方法

1. 通过构造器方式创建bean

   1. 需要有一个无参构造器，如果有参数可以通过setter方法或者构造方法注入参数

2. 通过静态工厂方法创建bean

   1. 就是在创建bean的时候，将创建bean的任务交给了静态工厂，不再是使用构造方法，而这个静态工厂就是一个java类，所以我们在配置bean的时候，bean里面添加class属性，class指定的就是该静态工厂的实现类，而不是bean的实现类，告诉bean交由哪个静态工厂创建，还需要添加一个factory-method属性来指定由工厂的哪个方法来创建bean的实例。如果静态工厂方法需要参数，使用构造方法方式注入参数

   2. 代码实现

      1. 创建一个接口类及实现类

         public interface UserDao
         {  
             public void hello();  
         }
         
         public class UserDaoImpl implements UserDao{
             private String name;
             public void setName(){
                 this.name = name;
             }
             
             @Override
             pulbic void hello(){
                 System.out.println(name+"Hello StaticFactory---");
             }
         }
         

      2. 创建静态工厂

         public void MyStaticFactory{
             public static UserDaoImpl getName(String name){
                 System.out.println("此人叫"+name);
                 return new UserDaoImpl();
             }
         }
         

      3. 配置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"
                xsi:schemaLocation="http://www.springframework.org/schema/beans
                 http://www.springframework.org/schema/beans/spring-beans.xsd">
             
             <bean id="userdao" class="com.k2.MyStaticFactory" factory-method="getName">
             	<!--为静态工厂的getName()方法传参-->
                 <constructor-arg value="张三"></constructor-arg>
                 <!--通过setter方法来注入参数-->
                 <property name="name" value="李四"></property>
             </bean>
             
         </beans>    
         

      4. 测试

         public class StaticFactoryTest{
             @Test
             public void test(){
                 ApplicationContext context =  new ClassPathXmlApplicationContext("aplication.xml");
                 // 获取到的是UserDaoImpl@64729b1e的实例，并不是获取到工厂（MyStaticFactory）的实例
                 UserDao userDao = context.getBean("userdao");
                 userDao.hello();
             }
         }
         

3. 通过实例工厂方法创建bean

   1. 回顾一下：静态工厂是通过class属性指定静态工厂实现类然后通过相应的方法创建的

   2. 工厂里面方法没有被static修饰，实例工厂就不能直接通过class属性指定动态工厂了，需要先创建该工厂的bean实例，然后再引用实例工厂的Bean的id创建其它bean，在实例工厂中通过factory-bean指定工厂bean的实例，在调用实例化工厂方法中，不是再用class属性指定，工厂对象已经创建，通过调用实例工厂的方法，创建bean实例即可，

   3. 代码实现一

      1. 创建一个bean

         public class BeanFac {
             public void beanFac(){
                 System.out.println("beanFac say ...");
             }
         }
         

      2. 创建实例工厂

          */
         public class MyBeanFacFactory {
         
             public MyBeanFacFactory() {
                 System.out.println();
                 System.out.println("BeanFac实例工厂实例化-----");
             }
         
             // 没有被static修饰的情况下
             public BeanFac createBean(){
                 return new BeanFac();
             }
         
         }
         

      3. 配置xml文件

         <!-- 实例工厂实例化	就是先创建类对象，如何通过对象来调用创建实例对象的方法 -->
         <!-- 配置工厂 -->
         <bean id="myBeanFacFactory" class="com.k2.bean的管理.bean的配置.fac_factory.MyBeanFacFactory"></bean>
             <!-- 使用factory-bean属性指向配置的实例工厂，		相当于new MyBeanFacFactory，然后调用方法
             使用factory-method属性确定使用工厂中哪个方法
             先获取工厂对象(myBeanFacFactory)，再获取工厂方法(createBean)
             -->
             <bean id="beanFac" factory-bean="myBeanFacFactory" factory-method="createBean"></bean>
         

      4. 测试

         @Test
         public void test(){
             ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContextBean.xml");
             BeanFac beanFac = (BeanFac) ac.getBean("beanFac");
             beanFac.beanFac();
         }
         

   4. 代码实现二

      1. 实现FactoryBean接口

      2. 代码实现

         1. 编写bean

            public class Bean {
                public Bean() {
                    System.out.println("使用实现接口-----");
                }
            }
            

         2. 编写实例工厂，实现FactoryBean接口

            public class MyBeanFactory implements FactoryBean<Bean> {
            
                @Override
                public Bean getObject() throws Exception {
                    System.out.println();
                    System.out.println("FactoryBean接口的getObject方法------");
                    return new Bean();
                }
            
                @Override
                public Class<?> getObjectType() {
                    return Bean.class;
                }
            
                @Override
                public boolean isSingleton() {
                    return false;
                }
            }
            

         3. 配置xml文件

            <!--看似没有创建MyBeanFactory对象，实则实现接口，已经创建对象-->
                <bean id="bean" class="com.k2.bean的管理.bean的配置.fac_factory.MyBeanFactory"/>
            

         4. 测试

            @Test
            public void test2(){
                ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContextBean.xml");
                Bean bean = (Bean) ac.getBean("bean");
                System.out.println(bean);
            }
            

2、装配bean的三种方式

1. 基于注解装配与自动装配
2. 基于xml的装配
3. 使用JavaConfig代码实现配置类