Spring---bean的创建，赋值，获取

获取对象和赋值

（一）通过IOC容器根据id获取对象★

1. 导入.jar包

2. 建bean类，里面提供具体的set/get方法。

3. 配置.xml 文件，注册组件

4. 创建IOC对象，并且启动容器。

5. 使用的时候，就直接从容器中获取bean对象，但前提是，这个对象必须在配置文件中注册过，如：

<!-- 注册一个person对象，Spring 会自动创建这个对象 -->
	<!-- 一个bean标签可以注册一个组件 -->
	<bean id="person01" class="com.daq.bean.Person">
		<property name="age" value="18"></property>
		<property name="email" value="2829025551@qq.com"></property>
		<property name="gender" value="男"></property>
		<property name="name" value="代澳旗"></property>
	</bean>
	
	<bean id="person02" class="com.daq.bean.Person">
		<property name="age" value="20"></property>
		<property name="email" value="2829025551@qq.com"></property>
		<property name="gender" value="女"></property>
		<property name="name" value="梧桐"></property>
	</bean>

//容器帮我们创建好了对象
Person bean1=(Person) ioc.getBean("person01");
Person bean2=(Person) ioc.getBean("person02");
		
System.out.println(bean1);
System.out.println(bean2);

（二）根据bean的类型从容器中获取对象★

/*
 * 方法二---通过对象类型，从容器中获取这个对象]
 * 但是如果ioc容器中这个类型的对象有多个，查找就会失败，报错。
 * 这种类型的对象，只能有一个
 */
	@Test
	public void test02() {
		Person bean = ioc.getBean(Person.class);
		System.out.println(bean)
	}

（三）调用有参构造器给对象赋值

1. 在bean类中，创建有参构造方法。
   

2. 在配置文件中，使用constructor标签给对象赋值。有几个参数，就用几次标签

3. 在容器中通过id的方式获取对象。

（四）通过P名称空间为bean赋值

（五）正确的为各种属性赋值

1. 测试使用null值 。
2. 引用类型赋值（引用其他bean、引用内部bean）

<bean id="person01" class="com.atguigu.bean.Person">
		
		<!-- lastName="null" -->
		<property name="lastName">
			<!-- 进行复杂的赋值 -->
			<null />
		</property>
		
		<!-- ref：代表引用外面的一个值 ;引用其他bean car = ioc.getBean("car01") -->
		<!-- <property name="car" ref="car01"></property> -->
		<property name="car">
<!--对象我们可以使用bean标签创建 car = new Car(); 引用内部bean；不能被获取到，只能内部使用 -->
			<bean class="com.atguigu.bean.Car">
				<property name="carName" value="自行车"></property>
			</bean>
		</property>
	</bean>

3. 集合类型赋值（List、Map、Properties）

<bean id="person02" class="com.atguigu.bean.Person">
		<!-- 如何为list类型赋值 -->
		<property name="books">
			<!-- books = new ArrayList<Book>(); -->
			<list>
				<!-- list标签体中添加每一个元素 -->
				<bean class="com.atguigu.bean.Book" p:bookName="西游记"></bean>
				<!-- 引用外部一个元素 -->
				<ref bean="book01" />
			</list>
		</property>

		<!-- Map<String, Object> maps; -->
		<property name="maps">
			<!-- maps = new LinkedHashMap<>(); -->
			<map>
				<!-- 一个entry代表一个键值对 -->
				<entry key="key01" value="张三"></entry>
				<entry key="key02" value="18"></entry>
				<entry key="key03" value-ref="book01"></entry>
				<entry key="key04">
					<bean class="com.atguigu.bean.Car">
						<property name="carName" value="宝马"></property>
					</bean>
				</entry>
				<entry key="key05">
					<value>李四</value>
				</entry>
				<!-- <entry key="key05"> <map></map> </entry> -->
			</map>
		</property>

		<!-- private Properties properties; -->
		<property name="properties">
			<!-- properties = new Properties();所有的k=v都是string -->
			<props>
				<!-- k=v都是string；值直接写在标签体中 -->
				<prop key="username">root</prop>
				<prop key="password">123456</prop>
			</props>
		</property>
	</bean>

4. util名称空间创建集合类型的bean 级联属性赋值

<!-- 级联属性赋值：   级联属性:属性的属性-->
	<bean id="person04" class="com.atguigu.bean.Person">
		<!--为car赋值的时候。改变car的价格  -->
		<property name="car" ref="car01"></property>
		<!--  -->
		<property name="car.price" value="900000"></property>
	</bean>

工厂方式创建bean

（六）通过继承实现bean配置信息的重用

• 不修改的信息就继承别人的，自己独有的信息，就修改。

<!--parent：指定当前bean的配置信息继承于哪个  -->
	<bean id="person06" class="com.atguigu.bean.Person" parent="person05">
		<property name="lastName" value="李四"></property>
	</bean>

（七）通过abstract属性创建一个模板bean

• 抽象Bean只能用来被别人继承。

<!-- abstract="true"：这个bean的配置是一个抽象的，不能获取他的实例，只能被别人用来继承 -->
	<bean id="person05" class="com.atguigu.bean.Person" abstract="true">
		<property name="lastName" value="张三"></property>
		<property name="age" value="18"></property>
		<property name="gender" value="男"></property>
		<property name="email" value="zhangsan@atguigu.com"></property>
	</bean>

（八）bean的作用域，分别创建单实例和多实例的bean★

<!-- 测试bean的作用域，分别创建单实例和多实例的bean
	bean的作用域:指定bean是否单实例，xxx；默认：单实例
	
	prototype:多实例
		1）、容器启动默认不会去创建多实例bean。
		2）、获取的时候创建这个bean。
		3）、每次获取都会创建一个新的对象
	singleton:单实例的；默认情况下是单实例。
		1）、在容器启动完成之前就已经创建好对象，保存在容器中了。
		2）、任何获取都是获取之前创建好的那个对象。
	
	request:在web环境下，同一次请求创建一个Bean实例（没卵用）
	session:在web环境下，同一次会话创建一个Bean实例（没卵用）
	 -->

（九）静态/实例工厂方法创建bean，FactoryBean★

• 有些简单的对象还好，因为属性少，但是有的对象属性很多，总不可能写一个抽象bean，让其他来继承吧，这个时候，就要用到工厂方法来创建了，
• 工厂模式

<!-- bean的创建默认就是框架利用反射new出来的bean实例 -->
	<!-- 工厂模式：工厂帮我们创建对象，有一个专门帮我们创建对象的类，这个类就是工厂
    	如下面的：AirPlaneFactory 
		AirPlane ap = AirPlaneFactory.getAirPlane(String jzName);
		
	静态工厂：工厂本身不用创建对象；通过静态方法调用，对象 = 工厂类.工厂方法名()；
	实例工厂：工厂本身需要创建对象；
			工厂类 工厂对象 = new 工厂类();
			工厂对象.getAirPlane("张三");
	-->	

• 静态工厂

/**
 * 静态工厂
 * @author lfy
 */
public class AirPlaneStaticFactory {
	
	//AirPlaneStaticFactory.getAirPlane()
	public static AirPlane getAirPlane(String jzName){
		System.out.println("AirPlaneStaticFactory...正在为你造飞机");
		AirPlane airPlane = new AirPlane();
		airPlane.setFdj("太行");
		airPlane.setFjsName("lfy");
		airPlane.setJzName(jzName);
		airPlane.setPersonNum(300);
		airPlane.setYc("198.98m");
		return airPlane;
	}
}

	<!-- 1、静态工厂(不需要创建工厂本身)
		class：指定静态工厂全类名
		factory-method:指定哪个方法是工厂方法
		constructor-arg：可以为方法传参
	 -->
	<bean id="airPlane01" class="com.atguigu.factory.AirPlaneStaticFactory"
		factory-method="getAirPlane">
		<!-- 可以为方法指定参数 -->
		<constructor-arg value="李四"></constructor-arg>
	</bean>

• 实例工厂

/**
 * 实例工厂
 * @author lfy
 */
public class AirPlaneInstanceFactory {
	// new AirPlaneInstanceFactory().getAirPlane();
	public  AirPlane getAirPlane(String jzName){
		System.out.println("AirPlaneInstanceFactory...正在造飞机");
		AirPlane airPlane = new AirPlane();
		airPlane.setFdj("太行");
		airPlane.setFjsName("lfy");
		airPlane.setJzName(jzName);
		airPlane.setPersonNum(300);
		airPlane.setYc("198.98m");
		return airPlane;
	}
}

<!--2、实例工厂使用 
		factory-method;指定这个实例工厂中哪个方法是工厂方法；	
	-->
	<bean id="airPlaneInstanceFactory" 
		class="com.atguigu.factory.AirPlaneInstanceFactory">
	</bean>
		
	<!-- factory-bean：指定当前对象创建使用哪个工厂
		1、先配置出实例工厂对象
		2、配置我们要创建的AirPlane使用哪个工厂创建
			1）、factory-bean：指定使用哪个工厂实例
			2）、factory-method：使用哪个工厂方法
	 -->
	<bean id="airPlane02" class="com.atguigu.bean.AirPlane"
		factory-bean="airPlaneInstanceFactory" 
		factory-method="getAirPlane">
		<constructor-arg value="王五"></constructor-arg>
	</bean>

• FactoryBean

/**
 * 实现了FactoryBean接口的类是Spring可以认识的工厂类；
 * Spring会自动的调用工厂方法创建实例
 * @author lfy
 *1、编写一个FactoryBean的实现类
 *2、在spring配置文件中进行注册
 */
public class MyFactoryBeanImple implements FactoryBean<Book>{
	/**
	 * getObject：工厂方法；
	 * 		返回创建的对象
	 */
	@Override
	public Book getObject() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("MyFactoryBeanImple。。帮你创建对象...");
		Book book = new Book();
		book.setBookName(UUID.randomUUID().toString());
		return book;
	}
	/**
	 * 返回创建的对象的类型；
	 * Spring会自动调用这个方法来确认创建的对象是什么类型
	 */
	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Book.class;
	}
	/**
	 * isSingleton：是单例？
	 * false：不是单例
	 * true：是单例
	 */
	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	}
}

<!-- FactoryBean★(是Spring规定的一个接口);
			只要是这个接口的实现类，Spring都认为是一个工厂；
		1、ioc容器启动的时候不会创建实例 
		2、FactoryBean；获取的时候的才创建对象
		-->
	<bean id="myFactoryBeanImple" 
		class="com.atguigu.factory.MyFactoryBeanImple"></bean>

引用外部属性文件★

- 外部文件：dbconfig.properties

jdbc.username=root
jdbc.password=***
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/user
jdbc.driverClass=com.mysql.jdbc.Driver

<!--引用外部属性文件★依赖context名称空间  -->
	<!-- 数据库连接池作为单实例是最好的；一个项目就一个连接池，连接池里面管理很多连接。连接是直接从连接池中拿 -->
	<!-- 可以让Spring帮我们创建连接池对象，（管理连接池） -->
	<!-- 加载外部配置文件    固定写法  classpath:，表示引用类路径下的一个资源-->
	<context:property-placeholder location="classpath:dbconfig.properties"/>
	
	<!-- username是Spring的key中的一个关键字；
	为了防止配置文件中的key和spring自己的关键字冲突。我们可以给配置文件中的key加上一个前缀 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.username}"></property>
		<!-- ${key}动态取出配置文件中某个key对应的值 -->
		<property name="password" value="${jdbc.password}"></property>
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
		<property name="driverClass" value="${jdbc.driverClass}"></property>
	</bean>

@Test
	public void test02() throws SQLException{
		//1、从容器中拿到连接池
		//DataSource bean = (DataSource) ioc.getBean("dataSource");
		
		//2、按照类型获取组件，可以获取到这个类型下的所有实现类子类等等...
		DataSource bean = ioc.getBean(DataSource.class);	
		System.out.println(bean.getConnection());
	}