Spring介绍

Spring是一个开源框架，是一个分层的一站式轻量级开源框架

• Javaee开发分成三层结构
  • WEB层：Spring MVC
  • 业务层：Bean管理

  • 持久层：Spring的JDBC模板。ORM模板用于整合其他的持久层框架
    Spring 负责在项目中管理所有对象

    
    介绍

一站式框架

• 正是因为spring框架性质是属于容器性质的.
• 容器中装什么对象就有什么功能.所以可以一站式.
• 不仅不排斥其他框架,还能帮其他框架管理对象.
• aop支持
• ioc思想'
• spring jdbc
• aop 事务
• junit 测试支持

Spring搭建

导包

Spring 导包
Spring核心包
日志包 apache

com.springsource.org.apache.log4j-1.2.15.jar可选

创建一个对象

public class User {
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

书写配置注册对象到容器

• 配置文件名任意

导入约束

spring的约束在schema/beans/spring-bean-4.2.xsd

<?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">
    <!--将user对象交给Spring容器管理
        name:指定一个名称
        class:指定管理的对象的完整类名
    -->
    <bean name="user" class="cn.probuing.bean.User"></bean>
</beans>

注意 此处容易报 ‘找不到元素 'beans' 的声明。‘ SAX解析错误，这种错误一般都是由于声明约束不足而导致的错误

代码测试

   @Test
    public void fun1() {
        //创建容器对象 传入配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //向容器要User对象 填写配置中对象的名字
        User user = (User) ac.getBean("user");
        //操作User对象
        System.out.println(user.toString());


    }

Spring概念

• IOC：控制反转
  将创建对象的方式反转了，在以前对象的创建是由开发人员自己维护，包括依赖关系也是自己注入。
  使用了Spring之后，对象的创建以及对象依赖关系可以由Spring完成创建以及注入
  反转控制就是反转了对象的创建方式，从我们自己创建反转给了Spring

• DI:依赖注入
  实现IOC思想需要DI做支持
  注入方式：
  * set方法注入
  * 构造方法注入
  * 字段注入
  注入类型：
  * 值类型注入
  * 引用类型注入

applicationContext&BeanFactory

BeanFactory接口

• Spring原始的接口，针对原始接口的实现类功能较为单一
• BeanFactory接口实现类的容器：特点是每次在获得对象时才会创建对象

applicationContext Spring中的容器

ApplicationContext接口有两个实现类

• 每次容器启动时就会创建容器中配置的所有对象.并提供更多功能
• 丛类路径下加载配置文件:ClassPathXmlApplicationContext
• 从硬盘绝对路径下加载配置文件:FileSystemXmlApplicationContext("d:/xxx/yyy/xxx")
  结论:web开发中,使用applicationContext. 在资源匮乏的环境可以使用BeanFactory.

Spring配置详解

Bean元素

Spring配置

id:Bean起个名字，在约束中采用ID的约束：唯一，必须以字母开始，可以使用字母、数字、连字符、下划线、句号、冒号 不能出现特殊字符
name:Bean起个名字，name可以使用特殊字符。没有id的属性name可以当做id使用

Bean元素进阶

Scope属性

• singleton:配置的默认值，被标识为单例的对象在Spring中只会存在一个实例

    <bean name="user" class="cn.probuing.bean.User" scope="singleton"></bean>

• prototype:多例原型：被标识为多例的对象，每次 再获得时才会创建，每次创建都是新的对象

    <bean name="user" class="cn.probuing.bean.User" scope="prototype"></bean>

• request:web环境下与request生命周期一致
• session:在web环境下，被标识为session的对象与session的生命周期一致

生命周期属性

• 配置一个方法作为生命周期初始化方法，spring会在对象创建之后立即调用
  • initmethod
• 也可配置一个方法作为生命周期的销毁方法，spring容器在关闭并销毁所有容器中的对象之前调用
  • destroymethod

    <bean name="user" class="cn.probuing.bean.User" init-method="init" destroy-method="destroy"></bean>

Spring创建对象的方式

空参构造

空参构造

静态工厂

public class UserFactory {
    public static User createUser() {
        System.out.println("静态工厂创建User");
        return new User();
    }
}

创建对象
   @Test
    public void fun2() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/probuing/createobj/applicationContext.xml");
        User user2 = (User) ac.getBean("user2");
        System.out.println(user2.toString());
    }

• 配置

<!--静态工厂创建
        调用UserFactory的createUser方法创建名为user2的对象，放入容器
    -->
    <bean name="user2" class="cn.probuing.createobj.UserFactory" factory-method="createUser">

实例工厂

<!--实例工厂配置-->
    <bean name="userfactory" class="cn.probuing.createobj.UserFactory"></bean>
    <bean name="user3" factory-bean="userfactory" factory-method="createUser2"></bean>
</beans>

Spring分模块配置

Spring可以在一个主配置文件中引入其他的配置文件

    <!--导入其他的配置文件-->
    <import resource="cn/probuing/createobj/applicationContext.xml"/>

Spring属性注入

set方法注入

 <!--set方式注入-->
    <bean name="user" class="cn.probuing.bean.User">
        <!--
        为user对象中 名为name的属性 注入tom作为值
        -->
        <property name="name" value="tom"/>
        <!--
        为user对象中，名为age的属性 注入值18
        -->
        <property name="age" value="18"/>
    </bean>

• 注入对象属性

 <!--set方式注入-->
    <bean name="user" class="cn.probuing.bean.User">
        <!--
        为user对象中 名为name的属性 注入tom作为值
        -->
        <property name="name" value="tom"/>
        <!--
        为user对象中，名为age的属性 注入值18
        -->
        <property name="age" value="18"/>
        <!--
        为user对象注入对象属性
        ref:引用配置的对象
        -->
        <property name="car" ref="car"/>
    </bean>

    <!--配置对象到容器-->
    <bean name="car" class="cn.probuing.bean.Car">
        <property name="name" value="benz"></property>
        <property name="color" value="red"></property>
    </bean>

构造函数注入

 <bean name="user2" class="cn.probuing.bean.User">
        <!--构造函数参数，这里的构造函数是
         User(String name, Car car)
         所以在使用constructor-arg标签中指定参数的值
        -->
        <constructor-arg name="name" value="jerry"></constructor-arg>
        <!--指定引用上面配置的对象-->
        <constructor-arg name="car" ref="car"></constructor-arg>
    </bean>

• 多个构造函数
  有多个构造函数时，按照参数的索引注入index，从而通过不同的构造函数，类型不同时通过type来指定

   <!--构造函数注入-->
    <bean name="user2" class="cn.probuing.bean.User">
        <!--构造函数参数，这里的构造函数是
         User(String name, Car car)
         所以在使用constructor-arg标签中指定参数的值
         index:指定属性对应的索引位置
         type:指定类型的构造函数注入
        -->
        <constructor-arg name="name" value="1" index="0" type="java.lang.Integer"></constructor-arg>
        <!--指定引用上面配置的对象-->
        <constructor-arg name="car" ref="car" index="1"></constructor-arg>


    </bean>

p名称空间注入

• 导入p名称空间

xmlns:p="http://www.springframework.org/schema/p"

• p名称空间不需要多余的标签，直接属性完成注入

 <!--p名称空间注入-->
    <bean name="user3" class="cn.probuing.bean.User"
          p:name="jack" p:age="20" p:car-ref="car"
    ></bean>

p名称注入本质还是set注入，省略了很多标签

spel注入

  <!--spel注入 spring Expressin Language spring表达式语言-->
    <bean name="user4" class="cn.probuing.bean.User">
        <!--
        #{}:代表spel表达式的书写位置 user3.name代表找到name为user3的对象name作为user4的name的值

        -->
        <property name="name" value="#{user3.name}"></property>
        <property name="age" value="#{user2.age}"></property>
        <!--
        引用类型不支持spel
        -->
        <property name="car" ref="car"></property>
    </bean>

复杂类型注入

数组属性注入

  <!--array注入-->
    <bean name="cb" class="cn.probuing.injection.CollectionBean">
        <!--
        如果数组中只准备注入一个值，可以使用value 或者ref
        -->
        <property name="arr">
            <!--为数组注入值-->
            <array>
                <value>hello</value>
                <value>how</value>
                <value>are</value>
                <value>you</value>
                <!--数组中的引用元素-->
                <ref bean="car"></ref>

            </array>
        </property>

list属性注入

<!--
        list注入
        -->
        <property name="list">
            <list>
                <value>i</value>
                <value>am</value>
                <value>list</value>
                <ref bean="user2"/>
            </list>
        </property>

map属性注入

  <!--map注入-->
        <property name="map">
            <map>
                <entry key="a" value="avalue"/>
                <entry key="driverName" value="Mysql"/>
                <entry key="car" value-ref="car"/>
            </map>
        </property>

property

<!--配置文件注入-->
        <property name="properties">
            <props>
                <prop key="driveClass">com.apple.applescript.apple.applescript</prop>
                <prop key="userName">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>