美文网首页
SSH入门---框架搭建（eclipse环境下）

SSH入门---框架搭建（eclipse环境下）

作者: 背对背拥抱 | 来源:发表于2017-07-26 13:44 被阅读0次

前情提要：本文是把Spring、Struts2、Hibernate三大框架整合到一起，搭建整合框架的教程，如需查看各个框架的单独搭建，请看我个人的相关文章。

一、新建动态web项目，导包：

我的项目名称是ssh_crmA
首先下载SSH框架搭建所需完整jar包
密码：ovl9

一共43个包，其中标签库的包是用eclipse这个IDE工具才需要的，如果用的是myeclipse开发，则不需要。

提示：
javassist-3.18.1-GA.jar包与hibernate中的重复，请删除低版本的。最终实际导入的是42个包。

将下载的所有包全部复制到WebContent / WEB-INF / lib下。

二、单独配置spring容器：

1）创建配置文件：

在src下创建名为applicationContext.xml的配置文件。
在配置文件中编写一个根元素<beans></beans>。
然后进行第二步。

2）导入约束（4个）：

首先下载相关约束文件
密码：fvxu

约束文件下载完后，
请参考spring环境搭建第四点，把四个约束文件全部导入进去。

导入约束文件的作用：让我们的电脑在没有网络的情况下编写配置文件有代码提示功能，能防止不必要的错误发生。

3）创建UserAction：

在src下创建一个包com.zl.web.action,在包下创建一个Action类，名为UserAction。

package com.zl.web.action;

import com.opensymphony.xwork2.ActionSupport;

public class UserAction extends ActionSupport {
    
}

然后在applicationContext.xml配置文件中把UserAction配置进去。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.springframework.org/schema/beans" 
        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-4.2.xsd 
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
        
    <bean name="userAction" class="com.zl.web.action.UserAction"></bean>                    
                            
</beans>
4）配置spring的监听器：

在WEB-INF下面的web.xml文件中插入以下代码：

<!-- 配置一个监听器，让spring随web启动而创建容器 -->
  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

三、单独配置struts2：

1）导入约束，编写主配置文件：

在src下创建名为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="crm" namespace="/" extends="struts-default">
        <action name="UserAction_*" class="com.zl.web.action.UserAction" method="{1}">
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

记得在WebContent根目录下编写一个success.jsp文件，内容随便写，这个文件只是暂时的。

2）配置struts2的核心过滤器：

到web.xml下书写以下代码：

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

四、整合struts2和spring：

1）导包：

这个步骤可以跳过，因为在最初的时候，我们已经把全部的包都导入进去了。这个地方要导入的包是struts2-spring-plugin-2.3.24.jar。

2）配置常量：

在com.zl.service包下编写UserService接口：

package com.zl.service;

import com.zl.domain.User;

public interface UserService {
    User getUserByCodePassword(User u);
}

然后在com.zl.service.impl包下创建UserServiceImpl实现类：

package com.zl.service.impl;
import com.zl.domain.User;
import com.zl.service.UserService;

public class UserServiceImpl implements UserService {

    @Override
    public User getUserByCodePassword(User u) {
        System.out.println("getUserByCodePassword");
        return null;
    }

}

注意：此时缺少实体User
在com.zl.domain包下创建User实体类。记得生成get/set方法。

此时，修改applicationContext.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.springframework.org/schema/beans" 
        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-4.2.xsd 
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
    
    
    <!-- 配置action -->
    <!-- Action作用范围一定是多例的，这样才符合struts2架构 -->
    <bean name="userAction" class="com.zl.web.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>         
    
    <!-- 配置service -->      
    <bean name="userService" class="com.zl.service.impl.UserServiceImpl"></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>
    
    <!-- # struts.objectFactory = spring    将action的创建交给spring
          struts.objectFactory.spring.autoWire = name  spring负责装配Action依赖，默认打开
          -->
    <constant name="struts.objectFactory" value="spring"></constant>
    
    <package name="crm" namespace="/" extends="struts-default">
    
        <!-- spring整合struts方案：class属性上填写spring的action对象的bean name -->
        <action name="UserAction_*" class="userAction" method="{1}">
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

五、单独配置hibernate：

1）导包：

此步骤在刚开始的时候已导入全部的包，跳过

2）为刚刚编写的User实体类编写实体映射文件。

在实体类User的同目录下，创建User.hbm.xml文件。

注意：其中Customer、LinkMan及其映射文件，这里不需要管，因为这是我做项目的时候所需要的，此处只是搭建ssh环境，只需要User实体类就够了

3）编写主配置文件：

记得先导入约束。
在src下创建hibernate.cfg.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
    
         <!-- 数据库驱动 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <!-- 数据库url -->
        <property name="hibernate.connection.url">jdbc:mysql:///hibernate1</property>
         <!-- 数据库连接用户名 -->
        <property name="hibernate.connection.username">root</property>
         <!-- 数据库连接密码 -->
        <property name="hibernate.connection.password">root</property>
        
        
        <!-- 数据库方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        
        
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        
        <!-- 自动建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
        
         
        <mapping resource="com/zl/domain/Customer.hbm.xml" />
        <mapping resource="com/zl/domain/LinkMan.hbm.xml" />
        <mapping resource="com/zl/domain/User.hbm.xml" />
        
    </session-factory>
</hibernate-configuration>
4）编写测试类：

测试hibernate是否配置成功。
新建com.zl.test包，在包中新建测试类HibernateTest

package com.zl.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import com.zl.domain.User;

public class HibernateTest {
    @Test
    public void test(){
        Configuration conf = new Configuration().configure();
        SessionFactory sf = conf.buildSessionFactory();
        Session session = sf.openSession();
        Transaction tx = session.beginTransaction();
        //--------------------------------------------------
        User u = new User();
        
        u.setUser_code("tom");
        u.setUser_name("汤姆");
        u.setUser_password("12345");
        u.setUser_state('2');
        
        session.save(u);
        //--------------------------------------------------
        tx.commit();
        session.close();
        sf.close();
    }
}

如果数据被写入数据库，则说明hibernate配置成功。

注意：只需要创建一个数据库，与hibernate主配置文件中的数据库名对应，不需要创建表，因为hibernate会帮我们创建表，创建的表与实体类对应。

六、整合Spring和Hibernate：

1）将sessionfactory配置到spring容器中：

在applicationContext.xml配置文件中加入以下代码：
方案一：不推荐使用

<!-- 将sessionfactory配置到spring容器中 -->
    <!-- 整合spring和hibernate的方案1：仍然使用外用的hibernate.cfg.xml -->
    <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>     
    </bean>

方案二：推荐使用

<!-- 整合spring和hibernate的方案2：在spring配置中放入hibernate配置 -->
    <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 配置hibernate基本信息 -->
        <property name="hibernateProperties">
            <props>
                <!--  必选配置 -->
                <prop key="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</prop>
                <prop key="hibernate.connection.url" >jdbc:mysql:///crm</prop>
                <prop key="hibernate.connection.username" >root</prop>
                <prop key="hibernate.connection.password" >root</prop>
                <prop key="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</prop>
                
                <!--  可选配置 -->
                <prop key="hibernate.show_sql" >true</prop>
                <prop key="hibernate.format_sql" >true</prop>
                <prop key="hibernate.hbm2ddl.auto" >update</prop>
            </props>
        </property>
        <!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
        <property name="mappingDirectoryLocations" value="classpath:com/zl/domain" ></property>
    </bean>

七、整合Spring和C3P0连接池：

首先在src根目录下创建db.properties文件。

jdbc.jdbcUrl=jdbc:mysql:///crm
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=root

然后在applicationContext.xml配置文件中加入以下代码：

<!-- 读取db.properties文件 -->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 配置c3p0连接池 -->
    <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
        <property name="driverClass" value="${jdbc.driverClass}" ></property>
        <property name="user" value="${jdbc.user}" ></property>
        <property name="password" value="${jdbc.password}" ></property>
    </bean>

然后修改第六点的方案二：修改后的代码如下：

<!-- 整合spring和hibernate的方案2：在spring配置中放入hibernate配置 -->
    <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 将连接池注入到sessionFactory, hibernate会通过连接池获得连接 -->
        <property name="dataSource" ref="dataSource" ></property>
        
        <!-- 配置hibernate基本信息 -->
        <property name="hibernateProperties">
            <props>
                <!--  必选配置 -->
                <!-- <prop key="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</prop>
                <prop key="hibernate.connection.url" >jdbc:mysql:///crm</prop>
                <prop key="hibernate.connection.username" >root</prop>
                <prop key="hibernate.connection.password" >root</prop> -->
                
                <prop key="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</prop>
                
                <!--  可选配置 -->
                <prop key="hibernate.show_sql" >true</prop>
                <prop key="hibernate.format_sql" >true</prop>
                <prop key="hibernate.hbm2ddl.auto" >update</prop>
            </props>
        </property>
        <!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
        <property name="mappingDirectoryLocations" value="classpath:com/zl/domain" ></property>
    </bean>

修改步骤：
1）把必选配置的关于连接数据库的<prop></prop>注释掉


2）然后加入一行代码：


八、整合Hibernate模板（Template）操作数据库：

1）创建UserDao接口：

在src下创建com.zl.dao包，在包中创建UserDao接口：

package com.zl.dao;

import com.zl.domain.User;

public interface UserDao {
    //根据登陆名称查询user对象
    User getByUserCode(String usercode);
}
2）创建UserDaoImpl实现类：

创建包com.zl.dao.impl，在包中创建UserDaoImpl，实现UserDao接口：

package com.zl.dao.impl;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate5.HibernateCallback;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;

import com.zl.dao.UserDao;
import com.zl.domain.User;

//HibernateDaoSupport  为dao注入sessionFactory
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
    
    private HibernateTemplate ht;

    @Override
    public User getByUserCode(final String usercode) {
        //HQL操作
        return getHibernateTemplate().execute(new HibernateCallback<User>() {
            @Override
            public User doInHibernate(Session session) throws HibernateException {
                String hql="from User where user_code=?";
                Query query = session.createQuery(hql);
                query.setParameter(0, usercode);
                User user = (User) query.uniqueResult();
                return user;
            }
        });
        
        //Criteria操作
        /*
         * DetachedCriteria dc = DetachedCriteria.forClass(User.class);
         * 
         * dc.add(Restrictions.eq("user_code", usercode));
         * 
         * List<User> list = (List<User>)
         * getHibernateTemplate().findByCriteria(dc);
         * 
         * if(list != null && list.size()>0){ 
         *      return list.get(0); 
         *  }else{ 
         *      return null; 
         *  }
         */
        
    }

}
3）在spring中配置dao：

在applicationContext.xml配置文件中加入以下代码：

<!-- 配置dao -->
    <bean name="userDao" class="com.zl.dao.impl.UserDaoImpl" >
        <!-- 注入sessionFactory -->
        <property name="sessionFactory" ref="sessionFactory" ></property>
    </bean>

九、整合Spring的aop事务：

方案一：通过xml配置aop事务：
1）配置核心事务管理器：

在applicationContext.xml配置文件中写入以下代码：

<!-- 核心事务管理器 -->
    <bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager" >
        <property name="sessionFactory" ref="sessionFactory" ></property>
    </bean>
2）配置通知：

在核心事务管理器下方写入以下代码：

<!-- 配置通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager" >
        <tx:attributes>
            <tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
            <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
        </tx:attributes>
    </tx:advice>
3）将通知织入目标对象：

在配置通知的下方写入以下代码：

    <!-- 配置将通知织入目标对象 -->
    <aop:config>
        <!-- 配置切点 -->
        <aop:pointcut expression="execution(* com.zl.service.impl.*ServiceImpl.*(..))" id="txPc"/>
        <!-- 配置切面 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
    </aop:config>
方案二：通过注解配置aop事务：

略

十、扩大Session的作用范围：

为了避免使用懒加载时出现no session问题。

1）配置filter：

在WEB-INF下的web.xml中配置filter：

<!-- 扩大session作用范围
    注意: 任何filter一定要在struts的filter之前调用
   -->
   <filter>
    <filter-name>openSessionInView</filter-name>
    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>openSessionInView</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

特别注意：因为一旦进入struts的流程，struts就不会放行，所以要把下面的代码放入到struts核心过滤器的前面：

<filter-mapping>
    <filter-name>openSessionInView</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

也就是说，最终的代码相对位置应该是下面的形式：

 <!-- 扩大session作用范围
    注意: 任何filter一定要在struts的filter之前调用
   -->
   <filter>
    <filter-name>openSessionInView</filter-name>
    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
  </filter>
  
  <!-- struts2核心过滤器 -->
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  
  <filter-mapping>
    <filter-name>openSessionInView</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

最终的web.xml文件代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>ssh_crmA</display-name>
  
  <!-- 配置一个监听器，让spring随web启动而创建容器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 配置spring配置文件位置参数 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  
  <!-- 扩大session作用范围
    注意: 任何filter一定要在struts的filter之前调用
   -->
   <filter>
    <filter-name>openSessionInView</filter-name>
    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
  </filter>
  
  <!-- struts2核心过滤器 -->
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  
  <filter-mapping>
    <filter-name>openSessionInView</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
</web-app>

最终的applicationContext.xml文件代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.springframework.org/schema/beans" 
        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-4.2.xsd 
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd 
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
    
    <!-- 读取db.properties文件 -->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 配置c3p0连接池 -->
    <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}" ></property>
        <property name="driverClass" value="${jdbc.driverClass}" ></property>
        <property name="user" value="${jdbc.user}" ></property>
        <property name="password" value="${jdbc.password}" ></property>
    </bean>
    
    <!-- 核心事务管理器 -->
    <bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager" >
        <property name="sessionFactory" ref="sessionFactory" ></property>
    </bean>
    
    <!-- 配置通知 -->
    <!-- <tx:advice id="txAdvice" transaction-manager="transactionManager" >
        <tx:attributes>
            <tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
            <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
            <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
        </tx:attributes>
    </tx:advice> -->
    
    <!-- 配置将通知织入目标对象 
    配置切点
    配置切面-->
    <!-- <aop:config>
        <aop:pointcut expression="execution(* com.zl.service.impl.*ServiceImpl.*(..))" id="txPc"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
    </aop:config> -->
    
    <!-- ========================================================================================= -->
    <!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" />
    
    
    <!-- 将sessionfactory配置到spring容器中 -->
    <!-- 整合spring和hibernate的方案1：仍然使用外用的hibernate.cfg.xml -->
    <!-- <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>     
    </bean> -->
    
    <!-- 整合spring和hibernate的方案2：在spring配置中放入hibernate配置 -->
    <bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 将连接池注入到sessionFactory, hibernate会通过连接池获得连接 -->
        <property name="dataSource" ref="dataSource" ></property>
        
        <!-- 配置hibernate基本信息 -->
        <property name="hibernateProperties">
            <props>
                <!--  必选配置 -->
                <!-- <prop key="hibernate.connection.driver_class" >com.mysql.jdbc.Driver</prop>
                <prop key="hibernate.connection.url" >jdbc:mysql:///crm</prop>
                <prop key="hibernate.connection.username" >root</prop>
                <prop key="hibernate.connection.password" >root</prop> -->
                
                <prop key="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</prop>
                
                <!--  可选配置 -->
                <prop key="hibernate.show_sql" >true</prop>
                <prop key="hibernate.format_sql" >true</prop>
                <prop key="hibernate.hbm2ddl.auto" >update</prop>
            </props>
        </property>
        <!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
        <property name="mappingDirectoryLocations" value="classpath:com/zl/domain" ></property>
    </bean>
    
    
    
    <!-- 配置action -->
    <!-- Action作用范围一定是多例的，这样才符合struts2架构 -->
    <bean name="userAction" class="com.zl.web.action.UserAction" scope="prototype">
        <property name="userService" ref="userService"></property>
    </bean>         
    
    <!-- 配置service -->      
    <bean name="userService" class="com.zl.service.impl.UserServiceImpl">
        <property name="ud" ref="userDao"></property>
    </bean>
    
    <!-- 配置dao -->
    <bean name="userDao" class="com.zl.dao.impl.UserDaoImpl" >
        <!-- 注入sessionFactory -->
        <property name="sessionFactory" ref="sessionFactory" ></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>
    
    <!-- # struts.objectFactory = spring    将action的创建交给spring
          struts.objectFactory.spring.autoWire = name  spring负责装配Action依赖，默认打开
          -->
    <constant name="struts.objectFactory" value="spring"></constant>
    
    <package name="crm" namespace="/" extends="struts-default">
    
        <!-- spring整合struts方案：class属性上填写spring的action对象的bean name -->
        <action name="UserAction_*" class="userAction" method="{1}">
            <result name="success">/success.jsp</result>
        </action>
    </package>
</struts>

至于为什么没有贴hibernate.cfg.xml的代码，因为hibernate的主配置文件已经注入在spring的主配置文件中，hibernate的主配置文件已经没有用了，相当于没有这个文件。

到此位置，SSH三大框架的整合框架的搭建已经全部完成。

本文仅供学习参考之用，转载请注明来源。

相关文章

网友评论

      本文标题：SSH入门---框架搭建（eclipse环境下）

      本文链接：https://www.haomeiwen.com/subject/tyonkxtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|SSH入门---框架搭建（eclipse环境下）|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！