思考：

1. 对象创建创建能否写死？

2. 对象创建细节

对象数量

action  多个   【维护成员变量】

service 一个   【不需要维护公共变量】

dao     一个   【不需要维护公共变量】

创建时间

action    访问时候创建

service   启动时候创建

dao       启动时候创建

3. 对象的依赖关系

action 依赖 service

service依赖 dao

=======================================================

总结：

spring就是解决上面的问题的！

简单来说，就是处理对象的创建的、以及对象的依赖关系！

2. Spring框架

2.1 专业术语了解

组件/框架设计

侵入式设计

引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。

例如：     Struts框架

非侵入式设计

引入了框架，对现有的类结构没有影响。

例如：Hibernate框架 / Spring框架

控制反转:

Inversion on Control , 控制反转 IOC

对象的创建交给外部容器完成，这个就做控制反转.

依赖注入，  dependency injection

处理对象的依赖关系

区别：

控制反转， 解决对象创建的问题 【对象创建交给别人】

依赖注入，

在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】

AOP

         面向切面编程。切面，简单来说来可以理解为一个类，由很多重复代码形成的类。

切面举例：事务、日志、权限;

2.2 Spring框架

a. 概述

Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。

且可以和其他框架一起使用；Spring与Struts,  Spring与hibernate

(起到整合（粘合）作用的一个框架)

Spring提供了一站式解决方案：

1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系

2） Spring Web  Spring对web模块的支持。

-à 可以与struts整合,让struts的action创建交给spring

-à spring mvc模式

3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】

4） Spring ORM  spring对orm的支持：

à 既可以与hibernate整合，【session】

à 也可以使用spring的对hibernate操作的封装

5）Spring AOP  切面编程

6）SpringEE   spring 对javaEE其他模块的支持

b. 开发步骤

spring各个版本中：

在3.0以下的版本，源码有spring中相关的所有包【spring功能 + 依赖包】，如2.5版本；

在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】，(如果要用依赖包，需要单独下载！)

1） 源码, jar文件：spring-framework-3.2.5.RELEASE

commons-logging-1.1.3.jar           日志

　　   spring-beans-3.2.5.RELEASE.jar        bean节点

　　　spring-context-3.2.5.RELEASE.jar       spring上下文节点

　　   spring-core-3.2.5.RELEASE.jar         spring核心功能

　　　spring-expression-3.2.5.RELEASE.jar    spring表达式相关表

以上是必须引入的5个jar文件，在项目中可以添加用户库管理！Add-Libray

2）  Spring配置文件：applicationContext.xml或者为 bean.xml

约束参考：

spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

     <!-- IOC容器的配置： 要创建的所有的对象都配置在这里-->
    <bean id="user" class="cn.itcast.a_hello.User"></bean>
</beans>   

3）Api

public class App {

    // 1.方式一： 通过工厂类得到IOC容器创建的对象
    @Test
    public void testIOC() throws Exception {
        // 创建对象
        // User user = new User();

        // 现在，把对象的创建交给spring的IOC容器
        Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");这个用路径，不是包名，是/ 不是.
        // 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
        BeanFactory factory = new XmlBeanFactory(resource);
        // 得到容器创建的对象
        User user = (User) factory.getBean("user");
        System.out.println(user.getId());
    }

    //2. 方式二：（方便）直接得到IOC容器对象 ，推荐使用这种方式
    @Test
    public void testAc() throws Exception {
        // 得到IOC容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
        // 从容器中获取bean
        User user = (User) ac.getBean("user");
        System.out.println(user);
    }
}

2.3. bean对象创建的细节

public class App2_bean {

    /**
     * 1) 对象创建： 单例/多例
     *    scope="singleton", 默认值， 即 默认是单例    【service/dao/工具类】
     *    scope="prototype", 多例；                  【Action对象】
     *
     * 2) 什么时候创建?
     *    scope="prototype"  在用到对象的时候，才创建对象。
     *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
     * 3)是否延迟创建
     *    lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象
     *    lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象 （只对单例有效）
     * 4) 创建对象之后，初始化/销毁
     *    init-method="init_user"        【对应对象的init_user方法，在对象创建爱之后执行 】
     *    destroy-method="destroy_user"  【在调用容器对象的destroy方法时候执行，(容器用实现类)】
     */
    @Test
    public void testIOC() throws Exception {
        // 得到IOC容器对象  【用实现类，因为要调用销毁的方法】
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
        System.out.println("-----容器创建-----");

        // 从容器中获取bean
        User user1 = (User) ac.getBean("user");
        User user2 = (User) ac.getBean("user");

        System.out.println(user1);
        System.out.println(user2);

        // 销毁容器对象 ,user对象的销毁destroy方法也会执行
        ac.destroy();
    }

    @Test
    public void test() throws Exception {
        // 容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
        System.out.println("-----容器创建完成-----");
        User user1 = (User) ac.getBean("user1");
    }
}

applicationContext.xml

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

    <!-- IOC容器的配置： 要创建的所有的对象都配置在这里-->
    <bean id="user" class="cn.itcast.a_hello.User" init-method="init_user" destroy-method="destroy_user" scope="singleton" lazy-init="false">    </bean>
</beans>  

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

    public User() {
        super();
        System.out.println("------User对象创建------");
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public void init_user() {
        System.out.println("创建对象之后，初始化");
    }
    public void destroy_user() {
        System.out.println("IOC容器销毁，user对象回收!");
    }
}

2.4. Spring  IOC容器

1） 创建对象

Spring IOC容器，是spring核心内容。

作用： 创建对象 & 处理对象的依赖关系

IOC容器创建对象：因为对象需要IOC容器来创建，所以创建对象的时候，要明确用哪种方式来创建，即通过配置文件来指定。

创建对象, 有几种方式：

1） 调用无参数构造器

2） 带参数构造器

3） 工厂创建对象

工厂类，静态方法创建对象

工厂类，非静态方法创建对象

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

    <!-- ###############对象创建############### -->

    <!-- 1. 默认无参数构造器 -->
    <bean id="user1" class="cn.itcast.b_create_obj.User"></bean>

    <!-- 2. 带参数构造器 -->
    <bean id="user2" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>第一个参数，类型，值 （基本类型直接写，引用类型写全名，如下面的string类型）
        <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>第二个参数，类型，值
    </bean>

注意，上面的构造函数的参数可能不是基本类型，有可能是一个其他类的对象，这时候该如何处理？？？？
    <!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jacks"></constructor-arg>
    </bean>
    <bean id="user3" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg> 在这里引用上面创建的对象，同理可以是其他的对象，如User类等
    </bean>

    <!-- 3. 工厂类创建对象 -->
    <!-- # 3.1 工厂类，实例方法 -->
    <!-- 先创建工厂 -->
    <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
    <!-- 在创建user对象，用factory方的实例方法 -->
    <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean> 实例方法创建一定要用工厂对象来创建，即factory-bean

    <!-- # 3.2 工厂类： 静态方法 -->
    <!--
        class 指定的就是工厂类型
        factory-method  一定是工厂里面的“静态方法”
     -->
    <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>    静态方法不需要实例对象，即不需要factory-bean

    <!-- 对象写法 -->
    <!--
    问题：spring配置文件中，bean节点的id与name属性的区别?
        id 不能有特殊符号, 且唯一，且不能以数字开始
        name 可以有特殊符号
     -->
    <bean id="test" name="1test"  class="cn.itcast.b_create_obj.User"></bean>
</beans>

// 工厂，创建对象   上面的配置文件中，配置如何用工厂模式创建对象
public class ObjectFactory {

    // 实例方法创建对象
    public User getInstance() {
        return new User(100,"工厂：调用实例方法");
    }

    // 静态方法创建对象
    public static User getStaticInstance() {
        return new User(101,"工厂：调用静态方法");
    }
}

2） 对象依赖关系

Spring中，如何给对象的属性赋值?  【DI, 依赖注入】

1) 通过构造函数

2) 通过set方法给属性注入值

3) p名称空间

4)自动装配(了解)

5) 注解

public class App {

    // 创建容器对象
    private ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/c_property/bean.xml");

    @Test
    public void testSet() {
        // 从容器中获取
        User user = (User) ac.getBean("user");

        System.out.println(user);
    }

    @Test
    public void testExecuteAction() {
        // 从容器中获取Action
        UserAction userAction = (UserAction) ac.getBean("userAction");
        userAction.execute();

    }
}

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

    <!-- ###############对象属性赋值############### -->
    <!--  1) 通过构造函数 -->
    <bean id="user1" class="cn.itcast.c_property.User" scope="prototype">
        <constructor-arg value="100"></constructor-arg>
        <constructor-arg value="Tom"></constructor-arg>
    </bean>

    <!-- 2) 通过set方法给属性注入值 -->
    <bean id="user" class="cn.itcast.c_property.User" scope="prototype">
        <property name="id" value="101"></property>
        <property name="name" value="Jack"></property>
    </bean>

    <!--
        案例：
            action/service/dao
     -->
    <!-- dao instance -->
    <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>

    <!-- service instance -->
    <bean id="userService" class="cn.itcast.c_property.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <!-- action instance -->
    <bean id="userAction1" class="cn.itcast.c_property.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>

    <!-- ##############内部bean############## -->
    <bean id="userAction2" class="cn.itcast.c_property.UserAction">
        <property name="userService">
            <bean class="cn.itcast.c_property.UserService">
                <property name="userDao">
                    <bean class="cn.itcast.c_property.UserDao"></bean>
                </property>
            </bean>
        </property>
    </bean>

    <!--
        给对象属性注入值：
            # p 名称空间给对象的属性注入值
             (spring3.0以上版本才支持)
     --> 

</beans>