SSH(Struts2+Spring+Hibernate)框架搭建流程

2021-09-23 06:45:36

添加支持

我先介绍的是MyEclipse9的自带框架支持搭建过程：（完全的步骤　　傻瓜式的学习。。~）

首先我们来搭建一个Web项目：

一、Hibernate(数据层)的搭建：

相关描述

Ⅰ.每一层的代码之间的耦合改为模块(分离/解耦),代码之间互不影响

Ⅱ.不再关注具体的实现类的实例

Ⅲ.更换不同的技术(模块),不需要改动代码，只需要修改applicationContext.xml的相关配置信息

Ⅳ.主要功能IOC(控制反转)松耦合、AOP (面向切面)内聚性

实现流程

编辑web.xml文件：

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="3.0" 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_3_0.xsd">

    <display-name></display-name>

    <!-- 这是一只拦路虎 -->

    <welcome-file-list>

        <welcome-file>index.jsp</welcome-file>

    </welcome-file-list>

    <!-- 读取applicationContext.xml文件 不写默认Spring需要读取 WebContent\WEB-INF\applicationContext.xml -->

    <context-param>

        <param-name>contextConfigLocation</param-name>

        <!-- 改变默认读取路径为src目录下的 applicationContext.xml 在改变的路径下还是没找到，便自动到默认路径查找 -->

        <param-value>classpath:applicationContext.xml</param-value>

    </context-param>

    <!-- 定义Spring监听器 class: spring 3.0 Web Libraries 下可以找到。 -->

    <listener>

        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

    </listener>

    <!-- Struts2过滤器 -->

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

</web-app>

DB Browser中反转实体类：

数据访问层dao接口

package com.dao;

import com.entity.Users;

/**

 * 用户接口

 * @author asus

 *

 */

public interface UsersDao {

    /** 登陆验证 */

    Users loginCheck(Users user);

}

数据访问层dao.impl实现类

　　1）继承HibernateDaoSupport类实现增删改查

package com.dao.impl;

import java.util.List;

import org.springframework.orm.hibernate3.HibernateTemplate;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.dao.UsersDao;

import com.entity.Users;

/**

 * 用户接口实现类

 * @author asus

 *HibernateTemplate、HibernateDaoSupport两种方法实现增删改查

 *一种方法：

        Dao实现类继承HibernateDaoSupport类，该类是抽象类，

        该类中有一个HibernateTemplate的属性，通过this.getHibernateTemplate()可获得一个HibernateTemplate类的模板对象。

 */

public class UsersDaoImpl extends HibernateDaoSupport implements UsersDao {

    @Override

    public Users loginCheck(Users user) {

        //得到此类提供的模板实现增删改查

        HibernateTemplate ht = this.getHibernateTemplate();

        //得到一个集合

        List<Users> list = ht.find("from Users where name=? and password=? ",user.getName(),user.getPassword());

        //使用三元运算符，防止list.get(0)时报空指针。

        return (Users) (list.size()>0?list.get(0):null);

    }

}

　2）定义HibernateTemplate模板对象属性

package com.dao.impl;

import java.util.List;

import org.springframework.orm.hibernate3.HibernateTemplate;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.dao.UsersDao;

import com.entity.Users;

/**

 * 用户接口实现类

 * @author asus

 *HibernateTemplate、HibernateDaoSupport两种方法实现增删改查

 *第二种方法：

    在dao类中定义一个HibernateTemplate类的对象，用该对象调用HibernateTemplate模板封装好的方法，如下：

 */

public class UsersDaoImpl implements UsersDao {

    //定义一个模板对象

    HibernateTemplate hibernateTemplate;

    @Override

    public Users loginCheck(Users user) {

        //得到一个集合

        List<Users> list = hibernateTemplate.find("from Users where name=? and password=? ",user.getName(),user.getPassword());

        //使用三元运算符，防止list.get(0)时报空指针。

        return (Users) (list.size()>0?list.get(0):null);

    }

    //生成Get'Set方法

    public HibernateTemplate getHibernateTemplate() {

        return hibernateTemplate;

    }

    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

        this.hibernateTemplate = hibernateTemplate;

    }

}

业务逻辑层接口service

package com.service;

import com.entity.Users;

/**

 * 用户业务逻辑层

 * @author asus

 *

 */

public interface UsersService {

    /** 登陆验证 */

    Users loginCheck(Users user);

}

业务逻辑层接口实现类service.impl

package com.service.impl;

import com.dao.UsersDao;

import com.entity.Users;

import com.service.UsersService;

/**

 * 用户业务逻辑层实现类

 * @author asus

 *

 */

public class UsersServiceImpl implements UsersService {

    //这里以前是new的，现在不需要了，交给Spring来实例

    private UsersDao udd;

    @Override

    public Users loginCheck(Users user) {

        return udd.loginCheck(user);

    }

    //生成Get'Set

    public UsersDao getUdd() {

        return udd;

    }

    public void setUdd(UsersDao udd) {

        this.udd = udd;

    }

}

控制器类Action

package com.action;

import com.entity.Users;

import com.opensymphony.xwork2.ActionSupport;

import com.service.UsersService;

/**

 * 用户控制器类

 * @author asus

 *

 */

public class UsersAction extends ActionSupport {

    //接收页面的值

    private Users user;

    //一样交给Spring实例

    private UsersService uss;

    public String execute(){

        return SUCCESS;

    }

    /** 判断用户输入的账号密码 */

    public String login(){

        if(user!=null){

            Users checkResult = uss.loginCheck(user);

            if(checkResult!=null){

                return SUCCESS;

            }

        }

        return LOGIN;

    }

    //生成Get'Set

    public Users getUser() {

        return user;

    }

    public void setUser(Users user) {

        this.user = user;

    }

    public UsersService getUss() {

        return uss;

    }

    public void setUss(UsersService uss) {

        this.uss = uss;

    }

}

登陆页面

  <body>

        <form action="loginUser.action" method="post" >

            用户名：<input type="text" name="user.name" />

            密码：   <input type="password" name="user.password" />

            <input type="submit" value="登录按钮" >

        </form>

  </body>

成功页面

  <body>

        登录成功！

  </body>

配置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"

    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <bean id="sessionFactory"

        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

        <property name="configLocation" value="classpath:hibernate.cfg.xml">

        </property>

    </bean>

    <!-- UsersBean配置 -->

    <!-- 第一种方法：Dao实现类继承HibernateDaoSupport类的配置 -->

    <bean id="userDaoImpl" class="com.dao.impl.UsersDaoImpl">

        <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    <!-- 第二种方法：在dao类中定义一个模板对象

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate" >

        <property name="sessionFactory" ref="sessionFactory" ></property>

    </bean>

    <bean id="userDaoImpl" class="com.dao.impl.UsersDaoImpl">

        <property name="hibernateTemplate" ref="hibernateTemplate"></property>

    </bean> -->

    <bean id="userServiceImpl" class="com.service.impl.UsersServiceImpl">

        <property name="udd" ref="userDaoImpl" />

    </bean>

    <bean id="userSturts" class="com.action.UsersAction">

        <property name="uss" ref="userServiceImpl" />

    </bean>

</beans>

配置Struts.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">

<struts>

   <package name="struts2" namespace="/" extends="struts-default">

      <action name="*User" class="userSturts" method="{1}" >

         <result name="success">/success.jsp</result>

         <result name="login">/login.jsp</result>

      </action>

   </package>

</struts>

end:基本的登陆现在已经做好，现在我们开始做添加事务。

添加事务

数据访问层dao接口

package com.dao;

import com.entity.District;

/**

 * 区域接口

 * @author asus

 *

 */

public interface DistrictDao {

    /** 添加区域  */

    int addReg (District district);

}

数据访问层dao.impl实现类

　　定义HibernateTemplate模板对象属性

package com.dao.impl;

import org.springframework.dao.DataAccessException;

import org.springframework.orm.hibernate3.HibernateTemplate;

import com.dao.DistrictDao;

import com.entity.District;

/**

 * 区域接口实现类

 * @author asus

 *HibernateTemplate、HibernateDaoSupport两种方法实现增删改查

 *第二种方法：

    在dao类中定义一个HibernateTemplate类的对象，用该对象调用HibernateTemplate模板封装好的方法，如下：

 */

public class DistrictDaoImpl implements DistrictDao {

    //定义一个模板对象

    private HibernateTemplate hibernateTemplate;

    @Override

    public int addReg(District district) {

        try {

            hibernateTemplate.save(district);

            return 1;

        } catch (DataAccessException e) {

            e.printStackTrace();

        }

        return 0;

    }

    //生成Get'Set方法

    public HibernateTemplate getHibernateTemplate() {

        return hibernateTemplate;

    }

    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {

        this.hibernateTemplate = hibernateTemplate;

    }

}

业务逻辑层接口service

package com.service;

import com.entity.District;

/**

 * 地区业务逻辑类接口

 * @author asus

 *

 */

public interface DistrictService {

    /**

     *  配置事务的话注意方法的命名规范以什么开头。

     * @param district

     */

    int addReg(District district);

}

业务逻辑层接口实现类service.impl

package com.service.impl;

import com.dao.DistrictDao;

import com.entity.District;

import com.service.DistrictService;

/**

 * 区域业务逻辑层接口实现类

 *

 * @author asus

 *

 */

public class DistrictServiceImpl implements DistrictService {

    //声明接口由Spring来实例

    private DistrictDao ddd;

    @Override

    public int addReg(District district) {

        return ddd.addReg(district);

    }

    //声明Get'Set方法

    public DistrictDao getDdd() {

        return ddd;

    }

    public void setDdd(DistrictDao ddd) {

        this.ddd = ddd;

    }

}

控制器类Action

package com.action;

import com.entity.District;

import com.opensymphony.xwork2.ActionSupport;

import com.service.DistrictService;

/**

 * 控制器类

 * 作用：添加区域

 * @author asus

 *

 */

public class DistrictAction extends ActionSupport {

    //属性

    private District district;

    private DistrictService dss;

    //处理添加请求

    public String add(){

        int addReg = dss.addReg(district);

        if(addReg>0){

            return SUCCESS;

        }

        return "index";

    }

    //生成Get'Set方法

    public DistrictService getDss() {

        return dss;

    }

    public void setDss(DistrictService dss) {

        this.dss = dss;

    }

    public District getDistrict() {

        return district;

    }

    public void setDistrict(District district) {

        this.district = district;

    }

}

添加页面

  <body>

        <form action="addReg" method="post" >

            <input type="text" name="district.name" >

            <input type="submit" value="提交" >

        </form>

  </body>

成功页面

  <body>

        登录成功！

  </body>

配置applicationContext.xml（这里还是比较重要的，其中夹杂前面Users的Bean）

<?xml version="1.0" encoding="UTF-8"?>

<!-- 配置事务第一步：需要导入的命名空间

        命名规范：

            xsi:架构实例

            beans:根节点

            aop:事务

            context：注解

            tx:事务管理

            xsi:schemaLocation

    协议（一个命名规范对应一个协议） 注：若不知道自己使用的框架版本，可以把协议后的版本号去掉，此处已经去掉。 -->

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"

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

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <bean id="sessionFactory"

        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

        <property name="configLocation" value="classpath:hibernate.cfg.xml">

        </property>

    </bean>

    <!-- 配置事务第二步：配置事务管理器，将SessionFactory注入 -->

    <bean id="txManager"

        class="org.springframework.orm.hibernate3.HibernateTransactionManager">

        <property name="sessionFactory" ref="sessionFactory" />

    </bean>

    <!-- 配置事务第三步：事务通知

            tx:method： 管理事务的方法

            name:方法的名字是已什么开头的

            no-rollback-for="true":回滚

            read-only="true"：只读（默认false,是已非事务的方式来操作你的数据，比如查询）

            propagation:事务是以哪种方式来操作    REQUIRED：必填

            （事务解释：比如一个方法中执行添加两张表的信息，第一个添加，没有事务开启一个事务，第二个添加加入第一个事务中，两个方法都成功则成功，一个失败全部回滚）

            name="*" :不在以上方法名开头之内的，是以非事务的方式来操作

     -->

    <tx:advice id="txAdvice" transaction-manager="txManager">

        <tx:attributes>

            <tx:method name="get*" propagation="SUPPORTS" read-only="true" />

            <tx:method name="add*" propagation="REQUIRED" />

            <tx:method name="del*"  propagation="REQUIRED"/>

            <tx:method name="update*" propagation="REQUIRED"/>

            <tx:method name="*" propagation="SUPPORTS" read-only="true" />

        </tx:attributes>

    </tx:advice>

    <!-- 配置事务第四步：织入（以面相切面的方式编程） -->

    <aop:config>

        <!-- 切面

            expression：表达式\

                * com.service.impl.*.*(..):（星    空格    包名    点星(代表所有此包下所有的类)    点星(代表类下所有的方法)       括号点点(代表方法中不管带有几个参数，只要符合命名规范都纳入事务管理)）

         -->

        <aop:pointcut id="serviceMethod" expression="execution(* com.service.impl.*.*(..))" />

        <!-- 通知者

                   由切面和事务通知组成的通知者

        -->

        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>

    </aop:config>

    <!-- UsersBean配置 -->

    <!-- 第一种方法：Dao实现类继承HibernateDaoSupport类的配置 -->

    <bean id="userDaoImpl" class="com.dao.impl.UsersDaoImpl">

        <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    <!-- 第二种方法：在dao类中定义一个模板对象 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"

        > <property name="sessionFactory" ref="sessionFactory" ></property> </bean>

        <bean id="userDaoImpl" class="com.dao.impl.UsersDaoImpl"> <property name="hibernateTemplate"

        ref="hibernateTemplate"></property> </bean> -->

    <bean id="userServiceImpl" class="com.service.impl.UsersServiceImpl">

        <property name="udd" ref="userDaoImpl" />

    </bean>

    <bean id="userSturts" class="com.action.UsersAction">

        <property name="uss" ref="userServiceImpl" />

    </bean>

    <!-- DistrictBean配置 -->

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">

        <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    <bean id="DistrictDaoImpl" class="com.dao.impl.DistrictDaoImpl">

        <property name="hibernateTemplate" ref="hibernateTemplate"></property>

    </bean>

    <bean id="DistrictServiceImpl" class="com.service.impl.DistrictServiceImpl">

        <property name="ddd" ref="DistrictDaoImpl"></property>

    </bean>

    <bean id="DistrictAction" class="com.action.DistrictAction">

        <property name="dss" ref="DistrictServiceImpl"></property>

    </bean>

</beans>

优化SessionFacatory,使用Spring创建最原始的JDBC数据源

优化JDBC为C3P0数据源连接池

（注：代码确与上面有重复，我走的是步骤路线虽然代码重复太多，只为更容易理解）

配置applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

<!-- 配置事务第一步：需要导入的命名空间

        命名规范：

            xsi:架构实例

            beans:根节点

            aop:事务

            context：注解

            tx:事务管理

            xsi:schemaLocation

    协议（一个命名规范对应一个协议） 注：若不知道自己使用的框架版本，可以把协议后的版本号去掉，此处已经去掉。 -->

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"

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

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 倒数第二步：这个sessionFactory使用的还是最原始的，可以优化，真正实际开发不会去用，测试可用。

    <bean id="sessionFactory"

        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

        <property name="configLocation" value="classpath:hibernate.cfg.xml">

        </property>

    </bean>-->

    <!-- 最后一步：优化sessionFactory:

            hibernate.cfg.xml中数据库连接方式可以由Spring来创建与管理

         操作步骤：使用Spring创建数据源:

             右键Spring——>New DataSource and SessionFactory（有图解）

             (Spring提供的是最原始的JDBC数据源连接池的写法，当然可以再成优化C3P0,DBCP数据源连接池)

             -->

    <!-- dataSource创建的：

            JDBC数据源写法（将C3P0数据源连接池写法注释掉就可用此数据源，它的HTML注释太多就先注释此..）

    <bean id="dataSource"

        class="org.apache.commons.dbcp.BasicDataSource">

        <property name="driverClassName"

            value="oracle.jdbc.driver.OracleDriver">

        </property>

        <property name="url"

            value="jdbc:oracle:thin:@localhost:1521:orcl">

        </property>

        <property name="username" value="root"></property>

        <property name="password" value="admin"></property>

    </bean> -->

    <!-- C3P0数据源连接池写法 -->

     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

        <property name="driverClass" value="oracle.jdbc.driver.OracleDriver"></property>

        <property name="jdbcUrl" value="jdbc:oracle:thin:@localhost:1521:orcl"></property>

        <property name="user" value="root" />

        <property name="password" value="admin" />

        <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->

        <property name="initialPoolSize" value="1" />

        <!--连接池中保留的最小连接数。 -->

        <property name="minPoolSize" value="1" />

        <!--连接池中保留的最大连接数。Default: 15 -->

        <property name="maxPoolSize" value="300" />

        <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->

        <property name="maxIdleTime" value="60" />

        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->

        <property name="acquireIncrement" value="5" />

        <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->

        <property name="idleConnectionTestPeriod" value="60" />

    </bean>

    <!-- session的创建方式 -->

    <bean id="sessionFactory"

        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

        <property name="dataSource">

            <ref bean="dataSource" />

        </property>

        <property name="hibernateProperties">

            <props>

                <prop key="hibernate.dialect">

                    org.hibernate.dialect.Oracle9Dialect

                </prop>

                <prop key="hibernate.show_sql">true</prop>

                <prop key="hiberenate.format_sql">true</prop>

            </props>

        </property>

        <property name="mappingResources">

            <list>

                <value>com/entity/District.hbm.xml</value>

                <value>com/entity/House.hbm.xml</value>

                <value>com/entity/Street.hbm.xml</value>

                <value>com/entity/Type2.hbm.xml</value>

                <value>com/entity/Users.hbm.xml</value>

            </list>

        </property>

    </bean>

    <!-- 配置事务第二步：配置事务管理器，将SessionFactory注入 -->

    <bean id="txManager"

        class="org.springframework.orm.hibernate3.HibernateTransactionManager">

        <property name="sessionFactory" ref="sessionFactory" />

    </bean>

    <!-- 配置事务第三步：事务通知

            tx:method： 管理事务的方法

            name:方法的名字是已什么开头的

            no-rollback-for="true":回滚

            read-only="true"：只读（默认false,是已非事务的方式来操作你的数据，比如查询）

            propagation:事务是以哪种方式来操作    REQUIRED：必填

            （事务解释：比如一个方法中执行添加两张表的信息，第一个添加，没有事务开启一个事务，第二个添加加入第一个事务中，两个方法都成功则成功，一个失败全部回滚）

            name="*" :不在以上方法名开头之内的，是以非事务的方式来操作

     -->

    <tx:advice id="txAdvice" transaction-manager="txManager">

        <tx:attributes>

            <tx:method name="get*" propagation="SUPPORTS" read-only="true" />

            <tx:method name="add*" propagation="REQUIRED" />

            <tx:method name="del*"  propagation="REQUIRED"/>

            <tx:method name="update*" propagation="REQUIRED"/>

            <tx:method name="*" propagation="SUPPORTS" read-only="true" />

        </tx:attributes>

    </tx:advice>

    <!-- 配置事务第四步：织入（以面相切面的方式编程） -->

    <aop:config>

        <!-- 切面

            expression：表达式\

                * com.service.impl.*.*(..):（星    空格    包名    点星(代表所有此包下所有的类)    点星(代表类下所有的方法)       括号点点(代表方法中不管带有几个参数，只要符合命名规范都纳入事务管理)）

         -->

        <aop:pointcut id="serviceMethod" expression="execution(* com.service.impl.*.*(..))" />

        <!-- 通知者

                   由切面和事务通知组成的通知者

        -->

        <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice"/>

    </aop:config>

    <!-- UsersBean配置 -->

    <!-- 第一种方法：Dao实现类继承HibernateDaoSupport类的配置 -->

    <bean id="userDaoImpl" class="com.dao.impl.UsersDaoImpl">

        <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    <!-- 第二种方法：在dao类中定义一个模板对象 <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate"

        > <property name="sessionFactory" ref="sessionFactory" ></property> </bean>

        <bean id="userDaoImpl" class="com.dao.impl.UsersDaoImpl"> <property name="hibernateTemplate"

        ref="hibernateTemplate"></property> </bean> -->

    <bean id="userServiceImpl" class="com.service.impl.UsersServiceImpl">

        <property name="udd" ref="userDaoImpl" />

    </bean>

    <bean id="userSturts" class="com.action.UsersAction">

        <property name="uss" ref="userServiceImpl" />

    </bean>

    <!-- DistrictBean配置 -->

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">

        <property name="sessionFactory" ref="sessionFactory"></property>

    </bean>

    <bean id="DistrictDaoImpl" class="com.dao.impl.DistrictDaoImpl">

        <property name="hibernateTemplate" ref="hibernateTemplate"></property>

    </bean>

    <bean id="DistrictServiceImpl" class="com.service.impl.DistrictServiceImpl">

        <property name="ddd" ref="DistrictDaoImpl"></property>

    </bean>

    <bean id="DistrictAction" class="com.action.DistrictAction">

        <property name="dss" ref="DistrictServiceImpl"></property>

    </bean>

</beans>

附Spring创建JDBC数据源图：

码农公寓

相关文章