思考:

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模块的支持。

a. 可以与struts整合,让struts的action创建交给spring

b. spring mvc模式

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

4) Spring ORM  spring对orm的支持:

a.  既可以与hibernate整合,【session】

b.  也可以使用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>

</beans>      

案例:

MVC模式下的处理方式转变:

Dao层:模拟操作数据库

public class UserDao {
    public void save() {
        System.out.println("DB:保存用户");
    }
}

service层:

public class UserService {

    private UserDao userDao; // = new UserDao();
    // IOC:对象的创建交给spring的外部容器完成
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save() {
        userDao.save();
    }
}

action类:

public class UserAction {
    // Service: springIOC容器注入
    private UserService userService;
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public String execute() {
        userService.save();
        return null;
    }
}
public class App {  在一个类中调用一个action????????

   // 创建容器对象
    private ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/c_property/bean.xml");
    @Test
    public void testExecuteAction() {
        // 从容器中获取Action
        UserAction userAction = (UserAction) ac.getBean("userAction");
        userAction.execute();

    }
}

配置文件bean.xml

(常用)Set方法注入值

    <!-- dao instance -->一般项目中所有的dao的instance写在一起
    <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>

    <!-- service instance -->创建service对象时候,一定要注入它的依赖对象userDao,依赖的是一个对象,需要用引用
    <bean id="userService" class="cn.itcast.c_property.UserService">
        <property name="userDao" ref="userDao"></property> 上面的userdao配置放在下面也没关系,跟顺序无关
    </bean>

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

上面的方式userDao,servicedao实例都加入到spring的IOC容器,其他对象都可以使用该实例。

内部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>
    

功能一样,都可以创建action对象,并处理了action对象的依赖关系。

内部bean的方法创建的userdao是内部的,只能供useraction2使用,其他对象用不到,一般不用这种方式,当只使用一次的时候可以这么用,但不推荐。

# p 名称空间注入属性值 (优化)

<?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"  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">

    <!-- ###############对象属性赋值############### -->

    <!--
        给对象属性注入值:
            # p 名称空间给对象的属性注入值
             (spring3.0以上版本才支持)
     -->
     <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>
     <bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>
     <bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></bean>

    <!-- 传统的注入:
     <bean id="user" class="cn.itcast.c_property.User" >
         <property name="name" value="xxx"></property>
     </bean>
    -->
    <!-- p名称空间优化后 -->   p:name=是直接给属性赋值,p:name-ref是对象的引用
    <bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>
</beans>        

# 自动装配(了解)

根据名称自动装配:autowire="byName"

         自动去IOC容器中找与属性名同名的引用的对象,并自动注入

<!-- ###############自动装配############### -->
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
    <bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>
    <!-- 根据“名称”自动装配: userAction注入的属性,会去ioc容器中自动查找与属性同名的对象 -->
    <bean id="userAction"
class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>

也可以定义到全局, 这样就不用每个bean节点都去写autowire=”byName”

<?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" default-autowire="byName">   根据名称自动装配(全局)

    <!-- ###############自动装配############### -->
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
</beans>   

根据类型自动装配:autowire="byType"

必须确保改类型在IOC容器中只有一个对象;否则报错。

<?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" default-autowire="byType">

    <!-- ###############自动装配############### -->
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean>
    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>

    <!-- 如果根据类型自动装配: 必须确保IOC容器中只有一个该类型的对象 -->
    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>

    <!--   报错: 因为上面已经有一个该类型的对象,且使用了根据类型自动装配
    <bean id="userService_test" class="cn.itcast.d_auto.UserService" autowire="byType"></bean>
     -->
</beans>  

总结: Spring提供的自动装配主要是为了简化配置; 但是不利于后期的维护。 (一般不推荐使用)

# 注解

注解方式可以简化spring的IOC容器的配置! 缺点是不利于维护。

使用注解步骤:

1)先引入context名称空间

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

2)开启注解扫描,扫描指定包及子包下所有的类

<context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>

3)使用注解

通过注解的方式,把对象加入ioc容器。

创建对象以及处理对象依赖关系,相关的注解:

@Component   指定把一个对象加入IOC容器

        @Repository   作用同@Component; 在持久层使用

        @Service      作用同@Component; 在业务逻辑层使用

        @Controller    作用同@Component; 在控制层使用

        @Resource     属性注入

bean.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">

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="cn.itcast.e_anno"></context:component-scan>会扫描当前包及子包中所有的类
</beans> 

userdao:

// 把当前对象加入ioc容器
@Component("userDao")   //  相当于bean.xml 【<bean id=userDao class=".." />】
public class UserDao {

    public void save() {
        System.out.println("DB:保存用户!!!");
    }
}

userservice:

@Component("userService")  // userService加入ioc容器
public class UserService {

    // 会从IOC容器中找userDao对象,注入到当前字段
    /*
     * <bean id="" class="">
     *      <property name="userDao" ref="userDao" />    @Resource相当于这里的配置
     * </bean>
     */

    @Resource(name = "userDao")  这里相对于是用名字在IOC容器中查找,可以有多个该类的实例
   @Resource 这是简化注解,是用类型去IOC容器中取查找,但是要求在IOC容器中,必须只有该类的一个实例,否则报错,因为他不知道要用哪个实例对象注入 private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void save() { userDao.save(); } }

UserAction :
import org.springframework.stereotype.Component;

@Component("userAction")  // 加入IOC容器
public class UserAction {

    @Resource(name = "userService")
    private UserService userService;

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

    public String execute() {
        userService.save();
        return null;
    }
}
public class App {

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

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

总结:

1) 使用注解,可以简化配置,且可以把对象加入IOC容器,及处理依赖关系(DI)

         2) 注解可以和XML配置一起使用。

3. Spring与Struts框架整合

Spring,负责对象对象创建

Struts, 用Action处理请求

Spring与Struts框架整合,

关键点:让struts框架action对象的创建,交给spring完成!

Spring与Hibernate整合:

【SSH整合:

Spring与Struts

关键点: action交给spring创建!

Spring与Hibernate

关键点: sessionFactory对象交给spring创建!

步骤:

引入jar文件

1)引入struts .jar相关文件

2)spring-core  相关jar文件

3)spring-web 支持jar包

spring-web-3.2.5.RELEASE.jar                            【Spring源码】

        struts2-spring-plugin-2.3.4.1.jar      【Struts源码】

配置:

4)配置XML

      struts.xml    【struts路径与action映射配置】

      bean.xml      【spring ioc容器配置】

      web.xml

        【核心过滤器: 引入struts功能】

【初始化spring的ioc容器】

【初始化spring的ioc容器】

查看api。

4) 代码以及配置

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <!-- 1. struts配置 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 2. spring 配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/classes/bean-*.xml</param-value>  src下的文件会自动部署到WEB-INF/classes目录下
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

bean-dao.xml      项目中所有的dao的bean都配置在这里

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd">

    <bean id="userDao" class="cn.itcast.dao.UserDao" scope="singleton" lazy-init="false"></bean>

</beans> 

bean-service.xml          项目中所有的service都配置在这里

<?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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd">

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

</beans>  

bean-action.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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 指定action多例 -->
    <bean id="userAction" class="cn.itcast.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>

</beans>     

struts.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>

    <package name="user" extends="struts-default">

        <action name="user" class="userAction" method="execute">
            <result name="success">/index.jsp</result>
        </action>

    </package>

</struts>