spring ioc

spring ioc容器
（0）ioc(概念与原理)
1、什么是ioc
（1）控制反转，把对象创建和对象之间的调用过程，交给spring进行管理。
（2）使用ioc的目的：为了耦合度降低。
（1）ioc底层原理。
1、xml解析、工厂模式、反射。
2、反射。

public class UserFactory{
    public static UserDao getDao(){
        String classValue = class属性值; // xml解析
        Class clazz = Class.forName(classValue) // 通过反射创建对象  Class 反射 获取class文件
        return (UserDao)clazz.newInstance(); // newInstance 创建对象。scanbasescan
    }
}

（2）ioc接口(BeanFactory)。
1、ioc思想基于ioc容器完成，ioc容器底层就是对象工厂。
2、spring提供ioc容器实现两种方式：(两个接口)
（1）BeanFactory：ioc容器基本实现，是spring内部的使用接口，不提供开发人员使用。
1 、加载配置文件的时候不会创建对象，在获取对象(使用)才去创建对象。
（2） ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。
1、加载配置文件的时候会把配置文件中的对象进行创建。
（3）ApplicationContext接口有实现类
1、FileSystemXmlApplicationContext：配置全路径
2、ClassPathXmlApplicationContext：只配置类路径
（3）ioc操作bean管理(基本概念)。
1、什么是bean管理。
（0）bean管理指的是两个操作。
（1）spring创建对象。
（2）spring注入属性。
2、bean管理操作有两种方式
（1）基于xml配置文件方式实现。
（2）基于注解方式实现。
（4）ioc操作bean管理(基于xml)。
1、基于xml方式创建对象。

<!-- 基于xml方式创建对象，使用 bean进行配置
    	id：唯一标识
     	class：类路径
 -->
<bean id="user" class="com.xxx.User"></bean>

（1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
（2）在bean标签有很多属性，介绍常用的属性。
1、id属性：唯一标识。
2、class属性：类全路径(包类路径)。
（3）创建对象的时候，默认也是执行无参数构造方法。
2、基于xml方式注入属性。
（1）DI：依赖注入，就是注入属性。
3、第一种注入方式：使用set方法进行注入。
（1）使用set方法注入属性。

<bean id="book" class="com.xxx.Book">
    <!-- set方法注入属性，使用 property 进行配置
    	name：类里面属性名称
     	value：向属性注入的值
    -->
    <property name="bname" value="西游记"></property>
</bean>

4、第二种注入方式：使用有参数的构造方法进行注入。
（1）有参构造注入属性

<bean id="orders" class="com.xxx.Orders">
    <!-- 有参构造注入属性，使用 constructor-org 进行配置
    	name：类里面有参构造方法里的参数名称
     	value：向参数注入的值
    -->
    <constructor-arg name="oname" value="adb"></onstructor-arg>
    <constructor-arg name="address" value="China"></onstructor-arg>
</bean>

5、注入属性-外部bean
（1）在spring配置文件中进行配置。

<bean id="book" class="com.xxx.Book">
    <!--  注入外部bean 使用 ref 进行配置
    		ref：bean对象id 唯一标识
     -->
    <property name="bookDao" ref="bookDaoImpl"></property>
</bean>
<bean id="bookDaoImpl" class.com.xxx.dao.BookDaoImpl></bean>

6、注入属性-内部bean
（1）一对多关系：部门和员工
（2）spring进行配置-内部bean

<!-- 内部bean -->
<bean id="emp" class="com.xxx.Emp">
    <!-- 设置两个普通属性 -->
     <property name="ename" value="张三"></property>
     <property name="dept">
     <!-- 内部bean property 里 嵌套 bean -->
     	<bean id="dept" class="com.xxx.Dept">
      		<property name="dname" value="法外狂徒部"></property>
       </bean>
     </property>
</bean>

7、注入属性-级联赋值

<!-- 级联赋值 -->
<bean id="emp" class="com.xxx.Emp">
    <property name="ename" value="张三"></property>
    <!-- 第一种赋值方式 -->
    <property name="dept" ref="dept"></property>
    <!-- 第二种赋值方式 需要在 实体类 中 生成 get方法 -->
    <property name="dept.dname" value="法外狂徒部"></property>
</bean> 
<bean id="dept" class="com.xxx.Dept">
    <property name="dname" value="法外狂徒部"></property>
</bean>

（5）ioc操作bean管理(xml注入其他类型属性)
1、字面量。
（1）null值

<bean id="book" class="com.xxx.Book">
    <!-- 给属性设置 null 值 <null/> -->
    <property name="bname">
    	<null/>
    </property>
</bean>

（2）属性值包含特殊符号。

<bean id="book" class="com.xxx.Book">
    <!-- 属性值包含特殊符号
    	1.把 <> 进行转义 &it; &gt;
     	2.把带特殊符号内容写到 CDATA <![CDATA[ 内容 ]]>
     -->
    <property name="bname">
    	<value> <![CDATA[<<南京>>]]> </value>
    </property>
</bean>

（6）ioc操作bean管理(xml注入集合属性)。

<bean id="sut" class="com.xxx.Sut">
    <!-- 数组类型注入赋值，使用 array 标签 里 用 value 标签 赋值 -->
    <property name="courses">
    	<array>
     		<value>下标索引为0</value>
       	<value>下标索引为1</value>
     	</array>
    </property>
    <!-- List类型注入赋值，使用 list 标签 里 用 value 标签 赋值 -->
    <property name="list">
    	<list>
     		<value>张三</value>
       	<value>里斯</value>
       </list>
    </property>
    <!-- map类型注入赋值，使用 map 标签 里 用 entry 标签 赋值
    		entry： key 键  value 值
     -->
     <property name="maps">
     	<map>
      		<entry key="name" value="张三"></entry>
       </map>
     </propery> 
     <!-- set类型属性注入，使用 set 标签 里 用 value 标签 赋值 -->
     <property>
    	<set>
     		<value>张三</value>
       </set>
     </property>
     <!-- List类型属性注入对象，使用 list 标签 里 用 ref 标签 赋值 通过注入外部bean的方式 -->、
     <property name="cut">
     	<list>
      		<ref bean="cut1"></ref>
      	</list>
     </property>
</bean>
<bean id="cut1" class="com.xxx.Cut">
    <property name="cname" value = "法外狂徒班"></property>
</bean>
<!-- 把集合注入公共部分提取出来
    通过 引用命名空间 实现
  -->
  <util:list id="utilList">
  		<!-- 基本类型用 value 标签，对象 用 ref 标签 通过注入外部bean的方式 -->
  		<value>法外狂徒部</value>
  </util:list>
  <!- 通过 ref 引用 公共数据 使用 命名空间 的 id -->
  <bean id="book" class="com.xxx.Book">
  	<propery name="bookList" ref="utilList"></property>
  </bean>

（7）ioc操作bean管理(FactoryBean)。
1、spring有两种类型bean，一种普通bean，另外一种是工厂bean(FactoryBean).
2、普通bean：在配置文件中定义bean类型就是返回类型。
3、工厂bean：在配置文件中定义bean类型可以和返回类型不一样。
第一步 创建类，让这个类作为工厂bean，实现接口 FactoryBean。
第二步 实现接口里面的方法，在实现的方法中定义返回的bean类型。
（8）ioc操作bean管理(bean的作用域)。
1、在spring里面，可以设置创建bean实例是单实例还是多实例。
2、在spring里面，默认情况下，bean是单实例对象。
3、单例模式：每创建一个对象，就会引用第一个创建的对象，地址相同
多例模式：每创建一次对象，就会创建一个新的对象，地址就会不同。
4、如何设置单实例还是多实例。
（1）在spring配置文件bean标签里面有属性(scope)用于设置单实例还是多实例。
（2） scope属性值：
第一个值 默认值，singleton，表示是单实例对象。
第二个值 prototype，表示是多实例对象。

<!-- 属性 scope 设置 bean 是单例模式 还是 多例模式
    	scope：singleton 单例 prototype 多例
  -->
<bean id="book" class="com.xxx.Book" scope="prototype">
</bean>

（3）singleton和prototype区别。
第一 singleton是单实例，prototype是多实例。
第二 设置scope值是singleton的时候，加载spring配置文件的时候就会创建单实例对象。
设置scope值是prototype的时候，不是在加载pring配置文件的时候创建对象，而是在调用getBean方法的时候创建多实例对象。
（9）ioc操作bean管理(bean生命周期)。
1、生命周期。
（1）从对象创建到对象销毁的过程。
2、bean生命周期。
（1）通过构造器创建bean实例(无参数构造)。
（2）为bean的属性设置值和对其他bean的引用(调用set方法)。
（3）把bean实例传递bean后置处理器的方法。(初始化之前执行)
（4）调用bean的初始化的方法(需要进行配置)。
（5）把bean实例传递bean后置处理器的方法。(初始化之后执行)
（6）bean可以使用了(对象获取到了)。
（7）当容器关闭的时候，调用bean的销毁的方法(需要进行配置销毁的方法)。
3、bean后置处理器的创建。
（1）创建一个类，实现BeanPostProcessor接口。
（2）实现两个方法：
postProcessBeforeInittalization：初始化之前执行。
postProcessAfterInitialization：初始化之后执行。
（3）在spring配置文件中创建这个类的bean。
（4）这个后置处理器类 会给每一个bean进行配置。

 <!-- 初始化bean的时候 调用方法 用 init-method 属性
      销毁bean的时候 调用方法 用 destory-method 属性 
 -->
  <bean id="orders" class="com.xxx.Orders" 
  		 init-method="initMethod" destroy-method="destroyMethod">
 </bean>
 <!-- 创建后置处理器 -->
 <bean id="myBeanPost" class="com.xxx.MyBeanPost"></bean>

（10）ioc操作bean管理(自动装配)。
1、什么是自动装配。
（1）根据指定的装配规则(属性名称或者属性类型)，spring自动将匹配的属性值进行注入。
2、演示自动装配过程
（1）根据属性名称自动注入(byName)。
（2）根据属性类型自动注入(byType)。

<!-- 实现自动装配
    bean标签属性autowire，配置自动装配
    autowire属性常用两个值：
        	byNmae：根据属性名称注入，注入值bean的id值和类属性名称一样
           byType：根据属性类型注入
  -->
<bean id="emp" class="com.xxx.Emp" autowire="byName">
</bean>

（11）ioc操作bean管理(引用外部属性文件 )。
1、直接配置数据库信息。
（1）配置德鲁伊连接池。
（2）引入德鲁伊连接池的依赖或者jar包。

<!-- 连接数据库配置 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
    <property name="username" value="root"></property>
    <property name="password" value="123456"></property>
</bean>

2、引入外部属性文件配置数据库连接池。
（1）创建外部属性文件，properties格式文件，写数据库信息(键值对形式)
（2）把外部properties属性文件引入到spring配置文件中。
引入 context 名称空间 。
（3）在spring配置文件中使用一个标签引入外部属性文件。
<context:property-placeholder location=“classpath:jdbc.properties” />
（4） 在 value 属性里使用 ${xxx.xxx} 进行赋值。
（12）ioc操作bean管理(基于注解)。
1、什么是注解。
（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值…)。
（2）使用注解，注解作用在类上面，方法上面，属性上面。
（3）使用注解的目的：简化xml配置。
2、spring针对bean管理中创建对象提供注解。
（1）@Component：
（2）@Service：
（3）@Controller：
（4）@Repository：
上面四个注解功能是一样的，都可以用来创建bean实例。
3、基于注解方式实现创建对象。
（1）引入依赖 spring-aop.jar
（2）开启组件扫描。

<!-- 开启组件扫描
    1、如果扫描多个包，多个包使用逗号隔开。
    2、扫描包上层目录即可。
  -->
<context:component-scan base-package="com.xxx.xxx"></context:component-scan>

<!-- 组件扫描细节 -->
<!-- 示例1
    use-default-fukters="false" : 表示现在不使用默认filter(过滤器)，自己配置filter
    context:include-filter : 设置扫描哪些内容
-->
<context:component-scan base-package="com.xxx.xxx" use-default-fukters="false">
  	<context:include-filter type="annotation" expression="org.springFramework.stereotype.Controller" />  		  	
</context:component-scan>

<!-- 示例2
    下面配置扫描包所有内容
    context:exclude-filter : 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.xxx.xxx">
  	<context:exclude-filter type="annotation" expression="org.springFramework.stereotype.Controller" />  		  	
</context:component-scan>

（3）创建类，在类上面添加创建对象注解。
//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写 UserService -> userService
@Component(value = “userService”) //
pulic class UserService{ }
4、基于注解方式实现属性注入。
（1）@AutoWired：根据属性类型进行自动装配。
（2）@Qualifier：根据属性名称进行注入。
这个@Qualifier注解的使用要和@AutoWired一起使用。
（3）@Resource：可以根据类型注入，可以根据名称注入。
（4）@Value：注入普通类型属性。
5、完全注解开发。
（1）创建配置类，替代xml配置文件。
@Configuration // 作为配置类，替代xml配置文件
@ComponentScan(basePackages = {“com.xxx”}) // 包路径
public class SpringConfig{ }
（2）加载配置类。

public void test(){
    // 加载配置类
    //  AnnotationConfigApplicationContext 加载配置类
    //  ClassPathXmlApplicationContext 加载配置文件
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
}