Spring

applicationContext & BeanFactory区别

1、ApplicationContext接口★
    ① 每次容器启动时就会创建容器中配置的所有对象
    ② 提供了更多功能
    ③ 从类路径下加载配置文件: ClassPathXmlApplicationContext("applicationConfig.xml")
　     从硬盘的绝对路径下加载配置文件:FileSystemXmlApplication("D:/abc/ABC/applicationContext.xml");
2、BeanFactory接口
    ① spring的原始接口，针对原始接口的实现类功能较为单一
    ② BeanFactory接口实现类的容器，特点是每次在获得对象时才会创建对象

Spring配置详解

Spring基本包：beans、context、core、expression

XML配置方式：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">

    <!-- 
        name：是起一个名字,可以通过这个name来利用容器获取对象;
        id：与name作用基本相同,但不推荐使用 ,不支持特殊字符,不能重复; 
        class：被管理对象的全包名,spring会通过这个包名来创建对象 
        lazy-init：延迟加载,就是创建容器时不加载配置的bean对象,在获取的时候才创建
        scope： 有四个属性
            -singleton：单例,默认值,只会创建一个对象,一般项目中采用singleton 
            -prototype：多例,在获取的时候会创建新的对象,但特殊环境下需要改为prototype 
            -request：在web环境下,如果scope为request那么这个对象就会创建出来,它的生命周期与request请求一致 
            -session：同理,生命周期与session一致 -->
    <bean name="user" class="com.sikiedu.bean.User" lazy-init="true" scope="prototype">
        <property name="id" value="2" />
        <property name="username" value="巩耿" />
        <property name="userpassword" value="123456" />
        <!-- set注入 -->
        <property name="role" ref="role"></property>
    </bean>

    <bean name="user1" class="com.sikiedu.bean.User" init-method="initUser" destroy-method="destroyUser">
        <!-- 构造注入 -->
        <constructor-arg name="id" value="1"></constructor-arg>
        <constructor-arg name="username" value="KK"></constructor-arg>
        <constructor-arg name="userpassword" value="321"></constructor-arg>
        <constructor-arg name="role" ref="role"></constructor-arg>
    </bean>
    
    <bean name="role" class="com.sikiedu.bean.Role" lazy-init="true" scope="singleton">
        <property name="idrole" value="7" />
        <property name="name" value="老夫子" />
        <property name="level" value="1" />
        <property name="roletype" value="战士" />
    </bean>

    <!-- 复杂属性注入 -->
    <bean name="collection" class="com.sikiedu.bean.MyCollection">
        <!-- 数组 -->
        <property name="array">
            <array>
                <value>1111111</value>
                <value>AAAAAAA</value>
                <ref bean="user" />
            </array>
        </property>

        <!-- List -->
        <property name="list">
            <list>
                <value>3333333</value>
                <value>CCCCCCC</value>
                <ref bean="role" />
            </list>
        </property>

        <!-- Set -->
        <property name="set">
            <set>
                <value>^^^^^^^</value>
                <value>6666666</value>
                <ref bean="user1" />
            </set>
        </property>

        <!-- Map -->
        <property name="map">
            <map>
                <entry key="老张" value="42"></entry>
                <entry key="小王" value="26"></entry>
                <entry key-ref="user" value-ref="role"></entry>
            </map>
        </property>

        <!-- Properties -->
        <property name="prop">
            <props>
                <prop key="老王">66</prop>
                <prop key="小张">16</prop>
            </props>
        </property>
    </bean>

    <!-- 导入其他spring配置文件 - 引入applicationContext_3 -->
    <import resource="applicationContext_3.xml" />

</beans>

1 - bean标签：使用该标签描述需要spring容器管理的对象

<!-- bean标签属性 -->
● name：bean标识名字 - 可以重复、可以使用特殊字符；
● id：bean的唯一标识，不支持特殊符号；作用于name基本一致，不推荐使用，尽量使用name
● class：被管理对象的完整类名，spring会通过这个类来创建对象；
● scope：
　　① singleton：单例模式(默认值) - 被标识为单例的对象在spring容器中只会存在一个实例。单例模式下，创建的几个对象都只有一个；
　　② prototype：多例模式 - 被标识为多例的对象,每次在获得才会被创建,每次创建都是新的对象；【整合Struts2框架时使用】
　　③ request/session：表示与web环境中的request和session生命周期相同；
● lazy-init：懒加载，在初始化容器阶段不会对懒加载的bean初始化，只有在获取的时候才会初始化；只对scop属性为singleton的bean起作用
　　① true：懒加载 - Spring初始化阶段不会进行init并且依赖注入，当第一次进行getBean时候进行初始化并依赖注入。
　　② false：非懒加载 - 默认 - Spring初始化阶段时会立即进行init并且依赖注入。
● init-method：初始化方法 - spring会在对象创建之后立即调用该方法；
● destory-method：销毁方法 - spring容器在关闭并销毁所有容器中的对象之前调用；

name和id之间的一些注意点：
① 配置两个相同的 id 或者 name 都不能通过。
② 如果既配置了 id ，也配置了 name ，则两个都生效。如果id和name都没有指定，则用类全名作为name，
　　如<bean class="com.stamen.BeanLifeCycleImpl">,则你可以通过getBean("com.stamen.BeanLifeCycleImpl")返回该实例。
③ 如果配置基本类的时候，注解和配置文件都使用的时候，注解和配置文件中 name 相同的时候， 则两个冲突，配置文件生效。
　　如果配置基本类的时候，注解和配置文件都使用的时候，注解和配置文件中 name 不相同的时候， 则两个不冲突，都能够生效。

2 - spring三种对象的创建方式

① 空参构造（重要）

<bean name="user" class="com.sikiedu.bean.User"></bean>

② 静态工厂创建（调用静态方法创建）

<bean name="user" class="com.sikiedu.factoryBean.UserFactory" factory-method="createUser"></bean>

③ 实例工厂创建（调用非静态方法创建） - 需配置两个bean，因为无法通过类名调用非静态方法

<bean name="user" factory-bean="userFactory" factory-method="createUser"></bean>
<bean name="userFactory" class="com.sikiedu.factoryBean.UserFactory"></bean>

3 - 依赖注入：

● set注入(通常也叫属性注入)：重点

<property>
 - value：表示注入的值类型
 - ref：表示注入的是引用类型,引用其它bean的name属性

● 构造函数注入：

<constructor-arg>：如果有多个构造函数时 可以通过index、type属性来明确哪一个构造
 - name：构造函数的参数名
 - index：构造函数的参数索引
 - type：构造函数的参数类型
 - value：注入基本类型
 - ref：注入对象

● p命名空间注入：实际上set注入，spring特有，为了简化<property>写法

① 导入P名称空间：xmlns:p="http://www.springframework.org/schema/p"
② 使用p：属性完成注入
 - 基本类型：p:属性名="值"
 - 引用类型：p:属性名-ref="bean名称"

● SpEL注入：Spring Expression Language - spring表达式语言

特性：
 ① 使用Bean的ID来引用Bean；
 ② 调用方法和访问对象的属性；
 ③ 对值进行算术、关系和逻辑运算；
 ④ 正则表达式匹配；
 ⑤ 集合操作；

<bean name="role" class="com.sikiedu.bean.Role">
    <!-- 取bean标签中name为"user"中property为"name"中的value值 -->
    <property name="userid" value="#{user.id}"></property>
</bean>

● 复杂类型注入：array、list、set、map、properties

集合的注入都是给<property>添加子标签
 - 数组：<array>
 - List：<list>
 - Set：<set>
 - Map：<map> ，map存放k/v 键值对，使用<entry>描述
 - Properties：<props>  <prop key=""></prop>  
普通数据：<value>
引用数据：<ref>

package com.sikiedu.bean;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class MyCollection {

    private Object[] array;
    private List list;
    private Set set;
    private Map map;
    private Properties prop;

    public Object[] getArray() {
        return array;
    }

    public void setArray(Object[] array) {
        this.array = array;
    }

    public List getList() {
        return list;
    }

    public void setList(List list) {
        this.list = list;
    }

    public Set getSet() {
        return set;
    }

    public void setSet(Set set) {
        this.set = set;
    }

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public Properties getProp() {
        return prop;
    }

    public void setProp(Properties prop) {
        this.prop = prop;
    }

}

<bean name="collection" class="com.sikiedu.bean.MyCollection">
    <!-- 数组 -->
    <property name="array">
        <array>
            <value>1111111</value>
            <value>AAAAAAA</value>
            <ref bean="user" />
        </array>
    </property>

    <!-- List -->
    <property name="list">
        <list>
            <value>3333333</value>
            <value>CCCCCCC</value>
            <ref bean="role" />
        </list>
    </property>

    <!-- Set -->
    <property name="set">
        <set>
            <value>^^^^^^^</value>
            <value>6666666</value>
            <ref bean="user1" />
        </set>
    </property>

    <!-- Map -->
    <property name="map">
        <map>
            <entry key="老张" value="42"></entry>
            <entry key="小王" value="26"></entry>
            <entry key-ref="user" value-ref="role"></entry>
        </map>
    </property>

    <!-- Properties -->
    <property name="prop">
        <props>
            <prop key="老王">66</prop>
            <prop key="小张">16</prop>
        </props>
    </property>
</bean>

4 - 模块化配置：即分模块配置

<beans>
    <!-- 导入其他spring配置文件 -->
    <import resource="applicationContext_1.xml"/>
    <import resource="applicationContext_2.xml"/>
    <import resource="applicationContext_3.xml"/>
</beans>

注解配置方式：

XML 配置文件，非编程语言语法，无法调试，使用注解配置代码，更容易定位问题，所以注解可以替代 XML 配置文件

配置步骤：

1、导包和约束：aop包+context约束

2、在spring主配置文件中开启组件扫描

3、注解使用：

● web类注解
　@Controller("userAction")；
　@Scope(scopeName="prototype")；
● service类注解
　@Service("userService")；
● dao类注解
　@Repository("userDao")；
● 属性注解 - 一般使用Resource
　@Autowired() // 根据类自动装配; 问题：如果匹配到多个类型一致的对象，将无法注入；
　@Qualifier("userService") // 根据名字自动装配；
　@Resource(name = "userService") // 推荐使用，Autowired+Qualifier的结合体 ；

配置applicationContext.xml，spring会自动扫描com.xxx包下面有注解的类，完成Bean的装配。 

struts.xml

<!-- 告诉struts，不用创建Action，由Spring来创建 -->
<constant name="struts.objectFactory" value="spring"></constant>

Web创建唯一容器

防止创建多个applicationContext取值 / 并指定记载spring配置文件的位置——web.xml

1，导包：spring-web包

2，在web.xm配置监听器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
　　xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
　　xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
　　id="WebApp_ID" version="3.1">
  
  <!-- 让Spring随着项目的创建而创建 -->
  <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 读取Spring配置文件 -->
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  
</web-app>