Spring框架入门（一）

　　Spring 框架概述

　　1.1. 什么是Spring

　　Spring是分层的JavaSE/EE full-stack(一站式) 轻量级开源框架

　　分层： 来自JavaEE体系结构 (客户端层、 web层、业务层、持久层 )

　　服务器端三层结构 (web层、业务层、持久层)

　　Servlet + JSP —- web层技术 —- Struts2框架

　　JDBC 接口 —- 持久化技术 —- Hibernate框架

　　EJB 框架(复杂) —- 业务层技术 —- Spring 框架 (取代EJB出现 )

　　Spring 出现，就是为了解决常见JavaEE 企业开发问题 !

　　一站式： Spring框架提供了 web层(表现层) SpringMVC、 业务层 IoC、AOP和事务管理、 持久层JdbcTemplate 各层javaEE软件开发解决方案

　　轻量级：相对于EJB框架而言

　　Spring核心

　　IoC： 控制反转

　　AOP： 面向切面编程

　　官网：http://www.springsource.org/

　　Spring 给软件开发带来了什么

　　方便解耦，简化开发 (Spring IoC特性)

　　AOP编程的支持

　　声明式事务的支持

　　方便程序的测试

　　方便集成各种优秀框架 (整合Struts2 、 Hibernate 、MyBatis 、Struts1 )

　　降低JavaEE API的使用难度 (Spring 提供大量工具类， 简化代码编写 )

　　Spring 体系结构

　　Spring框架IoC和DI

　　下载开发包

　　http://projects.spring.io/spring-framework/ 网址下载开发包

　　最新版本4.1 课程 3.2

　　开发包3.2

　　../201510/GridViewLiveTiles.html

　　依赖吧 3.0 (常见开源技术jar包)

　　../201510/GridViewLiveTiles.html

　　Spring目录结构

　　Docs 文档目录(API 和 规范)

　　Libs 开发需要jar包(包含javadoc和source)

　　Schema 所有约束文档

　　导入jar包到项目

　　进行Ioc和DI的开发，只需要导入最核心spring的jar包

　　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容器获得对象
        // 1、 获取Ioc容器工厂对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2、 从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;
    }

配置

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

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

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

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

应用场景： 大多数情况，可以通过构造器直接实例化， 只有在对象构造过程非常复杂的情况下，才会采用工厂实例化的方式

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

单例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...");
    }
}

配置

在对象构造后，立即执行初始化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 属性进行构造参数注入

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属性注入

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

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

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

【知识点】 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;
    }
}

集合元素类型属性注入

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

public class CollectionBean {
    private List list;
    private Set set;
    private Map map;
    private Properties properties;

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

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

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

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

    
        
        
            
                
                 aaa
                 bbb
                 ccc
            
        
        
            
                10
                10
                20
            
        
        
        
        
            
                asd456
                hjk789