spring之IOC容器创建对象

1.术语了解

1.1组件/框架设计
 侵入式设计
引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。
例如： Struts框架
非侵入式设计
引入了框架，对现有的类结构没有影响。
例如：Hibernate框架 / Spring框架
控制反转:
Inversion on Control , 控制反转 IOC
对象的创建交给外部容器完成，这个就做控制反转.

依赖注入：

        dependency injection

处理对象的依赖关系

区别：
         控制反转， 解决对象创建的问题 【对象创建交给别人】
依赖注入，在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】
AOP
面向切面编程。切面，简单来说来可以理解为一个类，由很多重复代码形成的类。

切面举例：事务、日志、权限;

1.2 Spring框架

Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。
且可以和其他框架一起使用；Spring与Struts,  Spring与hibernate
(起到整合（粘合）作用的一个框架)
Spring提供了一站式解决方案：（Spring六大模块）
1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系
2） Spring Web  Spring对web模块的支持。
- 可以与struts整合,让struts的action创建交给spring
    - spring mvc模式
3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】
4） Spring ORM  spring对orm（对象关系映射）的支持： 
 既可以与hibernate整合，【session】
 也可以使用spring的对hibernate操作的封装
5）Spring AOP  切面编程
6）SpringEE   spring 对javaEE其他模块的支持
spring各个版本中：
在3.0以下的版本，源码有spring中相关的所有包【spring功能 + 依赖包】
如2.5版本；
在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】
(如果要用依赖包，需要单独下载！)

1） 源码, jar文件：spring-framework-3.2.5.RELEASE
commons-logging-1.1.3.jar           日志
spring-beans-3.2.5.RELEASE.jar        bean节点
spring-context-3.2.5.RELEASE.jar       spring上下文节点
spring-core-3.2.5.RELEASE.jar         spring核心功能
spring-expression-3.2.5.RELEASE.jar    spring表达式相关表

以上是必须引入的5个jar文件，在项目中可以用户库管理！

2） 核心配置文件: applicationContext.xml

Spring配置文件：applicationContext.xml / bean.xml

2.开发步骤

首先新建项目，引入spring的架包，
项目包下新建xml文件，一般命名为applicationContext.xml或者bean.xml，这里以bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

Spring的一个特点就是将对象的创建写在配置文件中（即bean.xml中），在创建对象时只需要引用即可，这样的
好处就是增加了开发的灵活性

例子1： 使用配置文件的方法创建对象

实体类User

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

	/////////通过容器注入属性值
	public void setId(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}

	/////////
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}

	public User() {
		System.out.println("无参构造器");
	}

	public User(int id, String name) {
		super();
		System.out.println("有参构造器");
		this.id = id;
		this.name = name;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}

	public void init_user() {
		System.out.println("init");
	}
	public void destroy_user() {
		System.out.println("destroy");
	}

}

bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

	<!--
	各属性对应的含义  可以使用不同的属性实验效果
	 * (1)对象创建：单例/多例
	 * scope="singleton",默认值，默认单例  【service/dao】
	 * scope="prototype" 多例  用于action
	 *
	 * (2)什么时候创建？
	 * scope="singleton"单例 在启动（容器初始化前）就创建对象,只创建这一次
	 * scope="prototype" 多例 在容器创建完后在使用到对象时才创建对象
	 *
	 * (3)是否延迟创建（只对单例模式有效）
	 *  lazy-init="false" 默认为false，不延迟创建，即在启动时就创建对象
	 *  lazy-init="true" 延迟初始化，在用到对象时才创建对象
	 *
	 *  (4)创建对象后，初始化/销毁
	 *  init-method="init_user"      【对应对象的init_user方法，在对象创建之后执行】
	 *  destroy-method="destroy_user"  【在调用容器对象的destroy后执行】
	 *
	 */

	-->
    <bean id = "user" class="com.th.test1.User" scope="singleton"
    lazy-init="true" init-method="init_user" destroy-method="destroy_user"></bean>

</beans>

调用实例化实体类

public class App2Bean {

//得到IOC容器对象
	private ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/th/test1/bean.xml");

	@Test
	public void testIOC() throws Exception {
		System.out.println("容器创建");
 		//从容器中获取bean
		User user1 = (User) ac.getBean("user"); //此处user就是在bean.xml中配置的id为user的对象
		User user2 = (User) ac.getBean("user");

		System.out.println(user1);
		System.out.println(user2);

		//销毁容器
		ac.destroy();
	}
}

例子2：创建对象的几种方式
   1.调用无参构造器
   2.带参构造器
   3.工厂创建对象
         工厂类，静态方法创建对象
         工厂类，非静态方法创建对象

工厂类：

public class ObjectFactory {
	//实例方法创建对象
	public User getInstance(){
		return new User(100,"调用实例方法");
	}

	//静态方法创建对象
	public static User getStaticInstance(){
		return new User(100,"调用静态实例方法");
	}
}

bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 1.默认无参构造器-->
    <bean id = "user1" class="com.th.create_obj.User" ></bean>

    <!-- 2.带参构造起  type 基本类型直接写，引用类型写全路径-->
    <bean id = "user2" class="com.th.create_obj.User" >
    	<constructor-arg value="100" index="0" type="int"></constructor-arg>
    	<constructor-arg value="jack" index="1" type="java.lang.String"></constructor-arg>
    </bean>

    <!-- 3.定义一个字符串，值是jack String s = new String("jack") -->
    <bean id="str" class="java.lang.String">
    	<constructor-arg value="jacks"></constructor-arg>
    </bean>
    <bean id = "user3" class="com.th.create_obj.User" >
    	<constructor-arg value="100" index="0" type="int"></constructor-arg>
    	<constructor-arg ref="str" index="1" type="java.lang.String"></constructor-arg>
    </bean>

        <!-- 4.工厂类创建对象 -->
        <!-- 先创建工厂 -->
        <bean id="factory" class="com.th.create_obj.ObjectFactory"></bean>
        <!-- 在创建user对象，用factory方的实例方法 -->
        <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>

		<!-- 5.工厂类：静态方法 -->
		<bean id="user5" class="com.th.create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
</beans>

对象依赖关系
Spring中，如何给对象的属性赋值
1.通过构造函数
2.通过set方法给属性注入值
3.p名称空间
三层构造Dao-->Service-->Action

UserDao代码：

public class UserDao {
	public void save() {
		System.out.println("DB:保存用户");
	}
}

UserService代码：

public class UserService {
	private UserDao userDao;
	//IOC:对象的创建交给Spring的外部容器完成
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void save() {
		userDao.save();
	}
}

UserAction代码

public class UserAction {

	private UserService userService;
	public void setUserService(UserService userService) {
		this.userService = userService;
	}

	public String execute() {
		userService.save();
		return null;
	}
}

bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

        <!-- 对象属性赋值-->
   		<!-- (1)通过构造函数 -->
   		<bean id="user" class="com.th.c_property.User">
   			<constructor-arg value="100"></constructor-arg>
   			<constructor-arg value="Tom"></constructor-arg>
   		</bean>

   		<!-- 通过set方法给属性注入值 -->
   		<bean id="user1" class="com.th.c_property.User">
   			<property name="id" value="101"></property>
   			<property name="name" value="jack"></property>
   		</bean>

   		<!-- 案例 action/service/dao -->
   		<!-- dao instance实例化 -->
   		<bean id="userDao" class="com.th.c_property.UserDao"></bean>
   		<!-- service instance实例化  依赖dao层-->
   		<bean id="userService" class="com.th.c_property.UserService">
   			<property name="userDao" ref="userDao"></property>
   		</bean>

   		<!--action instance  依赖service层-->
   		<bean id="userAction" class="com.th.c_property.UserAction">
   			<property name="userService" ref="userService"></property>
   		</bean>

</beans>

P名称空间实现对象依赖

bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

   		<!-- 给对象属性注入值
   			P名称空间给属性注入值，在3.0以上版本才能使用
   			p:userDao-ref="userDao" 引用userDao
   		 -->
   		 <bean id="userDao" class="com.th.c_property.UserDao"></bean>
		<bean id="userService" class="com.th.c_property.UserService" p:userDao-ref="userDao"></bean>
		<bean id="userAction" class="com.th.c_property.UserAction" p:userService-ref="userService"></bean>

	<!-- set注入改为p名称注入
	<bean id="user1" class="com.th.c_property.User">
   			<property name="id" value="101"></property>
   			<property name="name" value="jack"></property>
   		</bean>
	-->
	<bean id="user" class="com.th.c_property.User" p:name="jack"></bean>

</beans>

自动装配：
bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context

	<!-- 自动装配也可以定义到全局，    此处添加default-autowire="byName"   则下边bean节点中配置的autowire="byName可省去-->
        http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byName">
        <!--
        	自动装配其是指还是调用UserDao和UserService中的set方法进行设置值，不过不需要我们手动配置
        	autowire="byName"  根据名字自动装配，自动在ioc容器中寻找名字
        	autowire="byType" 根据类型自动装配：必须确保容器中只有一个该类型的对象，否则报错

         -->
        <!-- 自动装配 -->
        <bean id="userDao" class="com.th.d_auto.UserDao"></bean>
        <bean id="userService" class="com.th.d_auto.UserService" autowire="byName"></bean>

       <!-- 根据名称自动装配：userAction注入的属性 ，会去IOC容器中自动查找与属性同名的对象-->
        <bean id="userAction" class="com.th.d_auto.UserAction" autowire="byName"></bean>

</beans>

注解： 
注解方式可以简化spring的IOC容器的配置!
使用注解步骤：
1）先在bean.xml中引入context名称空间
xmlns:context="http://www.springframework.org/schema/context"
2）开启注解扫描
<context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>
3）使用注解
通过注解的方式，把对象加入ioc容器。
   创建对象以及处理对象依赖关系，相关的注解：
@Component   指定把一个对象加入IOC容器
@Repository   作用同@Component； 在持久层使用
@Service      作用同@Component； 在业务逻辑层使用
@Controller    作用同@Component； 在控制层使用 
@Resource     属性注入
总结：
1） 使用注解，可以简化配置，且可以把对象加入IOC容器,及处理依赖关系(DI)
2） 注解可以和XML配置一起使用。