Spring框架入门

时间 2019-11-18

标签 spring 框架入门栏目 Spring 繁體版

原文原文链接

Spring 框架概述
1.1. 什么是Spring
Spring是分层的JavaSE/EE full-stack(一站式) 轻量级开源框架
分层：来自JavaEE体系结构（客户端层、 web层、业务层、持久层）
服务器端三层结构（web层、业务层、持久层）
Servlet + JSP —- web层技术 —- Struts2框架
JDBC 接口 —- 持久化技术 —- Hibernate框架
EJB 框架（复杂） —- 业务层技术 —- Spring 框架（取代EJB出现）html

Spring 出现，就是为了解决常见JavaEE 企业开发问题！
一站式： Spring框架提供了 web层（表现层） SpringMVC、业务层 IoC、AOP和事务管理、持久层JdbcTemplate 各层javaEE软件开发解决方案
轻量级：相对于EJB框架而言 java

Spring核心
IoC：控制反转
AOP：面向切面编程
官网：http://www.springsource.org/web

Spring 给软件开发带来了什么
方便解耦，简化开发（Spring IoC特性）
AOP编程的支持
声明式事务的支持
方便程序的测试
方便集成各类优秀框架（整合Struts2 、 Hibernate 、MyBatis 、Struts1 ）
下降JavaEE API的使用难度（Spring 提供大量工具类，简化代码编写）spring

Spring 体系结构编程

Spring框架IoC和DI数组

下载开发包
http://projects.spring.io/spring-framework/ 网址下载开发包
最新版本4.1 课程 3.2 tomcat

开发包3.2
spring-framework-3.2.0.RELEASE-dist.zip
依赖吧 3.0 （常见开源技术jar包）
spring-framework-3.0.2.RELEASE-dependencies.zip服务器

Spring目录结构session

Docs 文档目录（API 和 规范）
Libs 开发须要jar包（包含javadoc和source）
Schema 全部约束文档

导入jar包到项目
进行Ioc和DI的开发，只须要导入最核心spring的jar包
app

Spring运行，使用commons-logging日志技术
（commons-logging 和 slf4j 都属于统一日志接口，整合log4j日志实现）
导入log4j jar

理解IoC和DI的概念
什么是IoC ？什么是DI ？区别是什么？
IoC：控制反转，解决程序对象紧密耦合问题（工厂+反射+ 配置文件），将程序中原来构造对象的权限，交给IoC容器来构造，当程序须要对象，找IoC容器获取。

DI ：依赖注入， IoC容器须要为程序提供依赖对象，返回对象所依赖对象一同能够提供（Servlet须要Service，找Ioc容器获取Service， Service由容器提供，Service依赖DAO ，IoC容器提供Service对象同时，将Service依赖DAO 注入到Service中）

编写IoC和DI入门案例

将全部对象，交给IoC容器（Spring）来管理

（spring配置文件一般能够在src 或者 WEB-INF目录下，一般名称 applicationContext.xml ）
参考文档： xsd-config.html
经过applicationContext.xml 配置Spring管理对象

在程序中经过ApplicationContext接口获取spring工厂对象
1.ClassPathXmlApplicationContext 读取 src下配置文件
2.FileSystemXmlApplicationContext 读取WEB-INF下配置文件
IoC 经过工厂，从Spring容器获取建立好对象

@Test
    public void testRegist2() {
        // 从Ioc容器得到对象
        // 一、 获取Ioc容器工厂对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 二、 从Ioc容器工厂 获取须要对象 (根据bean的id 获取)
        UserServlet userServlet = (UserServlet) applicationContext.getBean("userServlet");
        userServlet.regist();
    }

DI 在经过工厂获取，spring对象时，spring同时提供对象所依赖的对象

// 依赖注入 (Spring 在构造 UserServlet对象时，同时将构造好 UserService对象，注入到UserServlet对象中 )
    private UserService userService;

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

配置

<!-- 将对象的建立权，交给容器管理 -->
    <bean id="userServlet" class="cn.itcast.spring.a_quickstart.UserServlet" >
        <!-- 返回UserServlet时，同时提供 依赖的UserService对象 -->
        <!-- 
            name 属性 对应 对象中 setXXX 方法， 表明对象中含有某个属性
            ref 引用了另外一个Bean对象id 
         -->
        <property name="userService" ref="userService" />
    </bean>
    <bean id="userService" class="cn.itcast.spring.a_quickstart.UserServiceImpl"/>
    <bean id="userDAO" class="cn.itcast.spring.a_quickstart.UserDAOImpl" />

BeanFactory 和 ApplicationContext 接口
ApplicationContext 是 BeanFactory 子接口，BeanFactory 才是Spring框架最核心工厂接口。
ApplicationContext 是对BeanFactory 接口扩展，企业开发不多直接使用BeanFactory
ApplicationContext 会在容器初始化时，对其中管理Bean对象进行建立， BeanFactory 会在对象获取时才进行初始化。

IoC容器装配Bean（xml配置）
3.1.三种实例化Bean的方式
方式一：使用类构造器实例化对象

<!-- 方式一  使用构造器（无参数）实例化对象  -->
    <bean id="bean1" 
class="cn.itcast.spring.b_instance.Bean1" />

方式二：使用静态工厂静态方法，对对象实例化

<!-- 方式二 使用静态工厂实例化对象 -->
    <!-- 调用 工厂的 factory-method 返回对象 -->
    <bean id="bean2" 
class="cn.itcast.spring.b_instance.Bean2Factory" factory-method="getBean2" />

方式三：使用实例工厂实例方法对对象实例化

<!-- 方式三 使用实例工厂实例化对象 -->
    <!-- 先实例化工厂 -->
    <bean id="bean3Factory" class="cn.itcast.spring.b_instance.Bean3Factory" />
    <!-- 再经过工厂对象的实例方法，构造目标对象 -->
    <bean id="bean3" factory-bean="bean3Factory" 
factory-method="getBean3" />

应用场景：大多数状况，能够经过构造器直接实例化，只有在对象构造过程很是复杂的状况下，才会采用工厂实例化的方式

Bean的做用域
最经常使用 singleton 和 prototype 两种
Singleton （单例）: 在一个BeanFactory对象中，引用惟一的一个目标实例
Prototype （多例）: 每次经过工厂执行getBean时，返回不一样实例对象
Request （请求范围） : 建立对象保存在request范围，若是request销毁，对象销毁
Session （会话范围）：建立对象保存Session中，若是session销毁，对象销毁
* globalSession （全局会话）：分布式系统，全局会话的概念，一次登陆，应用多个系统

<!-- 第三部分 Bean的做用域 -->
    <!-- 经过scope属性，指定bean做用域 （默认做用域 singleton） -->
    <bean id="singletonBean" class="cn.itcast.spring.c_scope.SingletonBean" /><!-- 单例 -->
    <bean id="prototypeBean" class="cn.itcast.spring.c_scope.PrototypeBean" scope="prototype"/> <!-- 多例 -->

单例Bean 在容器初始化时，实例化（只实例化一次）
多例Bean 在工程执行getBean时才会实例化（每调用一次，返回不一样对象）

Bean的生命周期
能够经过 init-method属性配置 Bean对象初始化执行方法，destory-method属性配置Bean对象销毁的方法
（初始化方法和构造方法有区别？构造方法做用申请空间，为对象基本属性初始化，初始化方法对象复杂构造过程， java语言建议将对象复杂构造过程单独抽取初始化方法）

public class LifeCycleBean implements IHello {
    public LifeCycleBean() {
        System.out.println("LifeCycleBean 构造...");
    }

    public void setup() {
        System.out.println("LifeCycleBean 初始化...");
    }

    public void teardown() {
        System.out.println("LifeCycleBean 销毁...");
    }

    @Override
    public void sayHello() {
        System.out.println("hello ,itcast...");
    }
}

配置

<!-- 第四部分  bean的生命周期 -->
    <bean id="lifeCycleBean" class="cn.itcast.spring.d_lifecycle.LifeCycleBean" 
        init-method="setup" destroy-method="teardown" />

在对象构造后，当即执行初始化init ，默认没有执行destroy 销毁方法

public class LifeCycleTest {
    @Test
    public void testInitDestroy() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        IHello lifeCycleBean = (IHello) applicationContext.getBean("lifeCycleBean");
        System.out.println(lifeCycleBean);
        lifeCycleBean.sayHello();

        // 必须手动调用 容器销毁的方法 --- web服务器tomcat，自动调用容器销毁
        applicationContext.close();
    }
}

后处理器（后处理Bean）— 补充

在Spring构造Bean对象过程当中，有一个环节对Bean对象进行后处理操做（钩子函数） —– Spring 提供 BeanPostProcessor 接口
能够自定义类，实现 BeanPostProcessor 接口，配置到Spring容器中，在构造对象时，spring容器会调用接口中方法

后处理器，在对象构造过程当中，提供代理，是AOP自动代理核心！

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    /**
     * bean 表明Spring容器建立对象
     * beanName 表明配置对象对应 id属性
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            System.out.println("后处理器 初始化后执行...");
        }
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
        // 针对bean id 为 lifeCycleBean的对象 进行代理
        if (beanName.equals("lifeCycleBean")) {
            System.out.println("后处理器 初始化前执行...");
            return Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("执行代理.....");
                    return method.invoke(bean, args);
                }
            });
        }
        return bean;
    }
}

Bean的依赖注入

三种注入方式

构造参数的属性输入

public class Car {
    private String name;
    private double price;

    // 为Car类 提供构造方法
    public Car(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

经过constructor-arg 属性进行构造参数注入

<!-- 构造方法属性注入 -->
    <bean id="car" class="cn.itcast.spring.e_di.Car">
        <!-- 经过constructor-arg 注入构造函数的参数 -->
        <!-- index 表明参数顺序 ，第一个参数 0
             type 表明参数类型 
             name 表明参数的名称 
             value 注入参数的值
             ref  引用另外一个bean元素的id
         -->
        <constructor-arg index="0" type="java.lang.String" value="宝马"/>
        <constructor-arg index="1" type="double" value="1000000"/>
    </bean>

setter方法属性注入

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

    private Car car;// 复杂元素

    public void setId(int id) {
        this.id = id;
    }

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

    public void setCar(Car car) {
        this.car = car;
    }

在配置文件使用元素完成setter属性注入

<!-- setter方法属性注入 -->
    <bean id="employee" class="cn.itcast.spring.e_di.Employee" >
        <!-- 经过property 注入setter方法属性 (属性名称， 由setter方法推理得到)-->
        <!-- 
            name 属性名称 （由setter方法得到）
            value 注入参数的值
            ref 引用另外一个Bean元素的id
         -->
        <property name="id" value="100001" />
        <property name="name" value="张三" />
        <!-- 注入复杂对象 -->
        <property name="car" ref="car" />
    </bean>

属性注入深刻
【知识点】 p名称空间的使用
P名称空间，在spring2.5版本后引入，为了简化属性依赖注入（setter方法）
第一步：在配置文件，引入p名称空间

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

第二步：简化setter方法注入配置

<!-- 使用p命名空间注入 -->
    <bean id="employee2" class="cn.itcast.spring.e_di.Employee" 
        p:eid="100002" p:name="李四" p:car-ref="car"/>

【知识点】 spEL表达式的使用
在spring3.0以后，引入spEL 表达式语言，简化属性注入
参考 “Spring_表达式语言.pdf” 学习
语法： #{表达式}
用法一：直接经过value注入，引用一个Bean对象
用法二：引用一个Bean对象属性
用法三：直接调用对象的方法

public class ValueBean {
    private int id = 10003;
    private String name = "jor";

    public int getId() {
        return id;
    }

    public String pickName() {
        return name;
    }
}

<!-- spEL使用 -->
    <bean id="valueBean" class="cn.itcast.spring.e_di.ValueBean" />
    <bean id="employee3" class="cn.itcast.spring.e_di.Employee" >
        <!-- 调用valueBean的getId -->
        <property name="eid" value="#{valueBean.id}" />
        <!-- 直接调用对象的方法 -->
        <property name="name" value="#{valueBean.pickName().toUpperCase()}" />
        <!-- #{car} 效果相似 ref  -->
        <property name="car" value="#{car}" />
    </bean>

集合元素类型属性注入

Spring为每种集合都提供一个元素标签进行注入

public class CollectionBean {
    private List<String> list;
    private Set<Integer> set;
    private Map<String, Integer> map;
    private Properties properties;

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

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

    public void setMap(Map<String, Integer> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

<!-- 集合类型属性注入 -->
    <bean id="collectionBean" class="cn.itcast.spring.e_di.CollectionBean">
        <!-- 
            array 注入数组
            list 注入List集合
            set 注入Set集合
            map 注入Map集合
            props 注入 Properties 集合
         -->
        <property name="list">
            <list>
                <!-- 
                    value 注入基本数据类型， String 类型
                    ref 注入引用Bean的id
                 -->
                 <value>aaa</value>
                 <value>bbb</value>
                 <value>ccc</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>10</value>
                <value>10</value>
                <value>20</value>
            </set>
        </property>
        <property name="map">
            <map>
                <!-- map中每一个元素都是键值对 -->
                <entry key="abc" value="10"></entry>
                <entry key="def" value="20"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="qwe123">asd456</prop>
                <prop key="tyu567">hjk789</prop>
            </props>
        </property>
    </bean>