Spring+Hibernate+Struts(SSH)框架整合實戰(zhàn)
更新時間：2018年04月07日 15:32:17 作者：佳先森
SSH是 struts+spring+hibernate的一個集成框架，是目前比較流行的一種Web應(yīng)用程序開源框架。本篇文章主要介紹了Spring+Hibernate+Struts(SSH)框架整合實戰(zhàn)，非常具有實用價值，需要的朋友可以參考下
SSH框架整合
前言：有人說，現(xiàn)在還是流行主流框架，SSM都出來很久了，更不要說SSH。我不以為然?，F(xiàn)在許多公司所用的老項目還是ssh，如果改成主流框架，需要成本。再說比如金融IT這一塊，數(shù)據(jù)庫dao層還是推薦使用的是hibernate，因為能夠快速開發(fā)上手，除非是互聯(lián)網(wǎng)，因涉及到高并發(fā)，dao層用的是mybatis，數(shù)據(jù)交互效率較快。所以，SSH不容忽略。
一、什么是SSH
SSH是 struts+spring+hibernate的一個集成框架，是目前比較流行的一種Web應(yīng)用程序開源框架。
集成SSH框架的系統(tǒng)從職責(zé)上分為四層：表示層、業(yè)務(wù)邏輯層、數(shù)據(jù)持久層和域模塊層，以幫助開發(fā)人員在短期內(nèi)搭建結(jié)構(gòu)清晰、可復(fù)用性好、維護方便的Web應(yīng)用程序。其中使用Struts作為系統(tǒng)的整體基礎(chǔ)架構(gòu)，負責(zé)MVC的分離，在Struts框架的模型部分，控制業(yè)務(wù)跳轉(zhuǎn)，利用Hibernate框架對持久層提供支持，Spring做管理，管理struts和hibernate。具體做法是：用面向?qū)ο蟮姆治龇椒ǜ鶕?jù)需求提出一些模型，將這些模型實現(xiàn)為基本的Java對象，然后編寫基本的DAO(Data Access Objects)接口，并給出Hibernate的DAO實現(xiàn)，采用Hibernate架構(gòu)實現(xiàn)的DAO類來實現(xiàn)Java類與數(shù)據(jù)庫之間的轉(zhuǎn)換和訪問，最后由Spring做管理，管理struts和hibernate。
---------百度百科
二、SSH所涉及的部分
三、快速部署環(huán)境
這里利用保存客戶的小Demo來演示整合SSH
1.導(dǎo)入所需jar包
1）. Struts2框架
* struts-2.3.24\apps\struts2-blank\WEB-INF\lib\*.jar -- Struts2需要的所有jar包
* struts2-spring-plugin-2.3.24.jar ---Struts2整合Spring的插件包
2）. Hibernate框架
* hibernate-release-5.0.7.Final\lib\required\*.jar -- Hibernate框架需要的jar包
* slf4j-api-1.6.1.jar -- 日志接口
* slf4j-log4j12-1.7.2.jar -- 日志實現(xiàn)
* mysql-connector-java-5.1.7-bin.jar -- MySQL的驅(qū)動包
3）. Spring框架
* IOC核心包
* AOP核心包
* JDBC模板和事務(wù)核心包
* Spring整合JUnit測試包
* Spring整合Hibernate核心包
* Spring整合Struts2核心包
2、在web.xml中配置spring與struts的相關(guān)代碼
1）配置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>
2）配置spring的監(jiān)聽器
當服務(wù)啟動時，就會先加載spring的配置文件
<!-- 配置Spring框架整合WEB的監(jiān)聽器 --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>
3）配置默認加載路徑
<!-- 監(jiān)聽器默認加載Web-INF文件下，需要配置參數(shù)來加載指定文件 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param>
總結(jié)：web.xml全部代碼為
<!-- 配置Spring框架整合WEB的監(jiān)聽器 --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!-- 監(jiān)聽器默認加載Web-INF文件下，需要配置參數(shù)來加載指定文件 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param> <!-- 配置核心過濾器 --> <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、src下編寫相關(guān)配置文件
1)spring:applicationContext.xml
導(dǎo)入相關(guān)約束
<?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: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"> </beans>
2）hibernate:hibernate.cfg.xml
導(dǎo)入相關(guān)約束，并配置數(shù)據(jù)庫
<?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> <property name="hibernate.connection.url">jdbc:mysql://192.168.174.130:3306/SSH</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> <!-- 配置C3P0的連接池 --> <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property> <!-- 不能配置綁定當前的線程的操作 --> <!-- 映射配置文件 --> <mapping resource="com/clj/domain/Customer.hbm.xml"/> </session-factory> </hibernate-configuration>
3）配置log4j.properties
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=info, stdout
4)struts2:struts.xml
導(dǎo)入相關(guān)約束
<?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.3.dtd"> <struts> </struts>
總結(jié)：src所需配置文件如圖
3、配置dao層
定義一個接口和其實現(xiàn)類
public interface CustomerDao {
public void save(Customer customer);
}
public class CustomerDaoImpl implements CustomerDao {
public void save(Customer customer) {
}
}
4、定義業(yè)務(wù)層接口和實現(xiàn)類
package com.clj.service;
import com.clj.domain.Customer;
public interface CustomerService {
public void save(Customer customer);
}
package com.clj.service;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客戶的業(yè)務(wù)層
* @author Administrator
*
*/
public class CustomerServiceImpl implements CustomerService{//用來保存客戶
public void save(Customer customer) {
}
}
5、定義pojo類
hibernate通過操作pojo類來操作數(shù)據(jù)庫表，做到對象關(guān)系映射
package com.clj.domain;
public class Customer {
private Long cust_id;
private String cust_name;
private Long cust_user_id;
private Long cust_create_id;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;
public Long getCust_id() {
return cust_id;
}
public void setCust_id(Long cust_id) {
this.cust_id = cust_id;
}
public String getCust_name() {
return cust_name;
}
public void setCust_name(String cust_name) {
this.cust_name = cust_name;
}
public Long getCust_user_id() {
return cust_user_id;
}
public void setCust_user_id(Long cust_user_id) {
this.cust_user_id = cust_user_id;
}
public Long getCust_create_id() {
return cust_create_id;
}
public void setCust_create_id(Long cust_create_id) {
this.cust_create_id = cust_create_id;
}
public String getCust_source() {
return cust_source;
}
public void setCust_source(String cust_source) {
this.cust_source = cust_source;
}
public String getCust_industry() {
return cust_industry;
}
public void setCust_industry(String cust_industry) {
this.cust_industry = cust_industry;
}
public String getCust_level() {
return cust_level;
}
public void setCust_level(String cust_level) {
this.cust_level = cust_level;
}
public String getCust_linkman() {
return cust_linkman;
}
public void setCust_linkman(String cust_linkman) {
this.cust_linkman = cust_linkman;
}
public String getCust_phone() {
return cust_phone;
}
public void setCust_phone(String cust_phone) {
this.cust_phone = cust_phone;
}
public String getCust_mobile() {
return cust_mobile;
}
public void setCust_mobile(String cust_mobile) {
this.cust_mobile = cust_mobile;
}
@Override
public String toString() {
return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name
+ ", cust_user_id=" + cust_user_id + ", cust_create_id="
+ cust_create_id + ", cust_source=" + cust_source
+ ", cust_industry=" + cust_industry + ", cust_level="
+ cust_level + ", cust_linkman=" + cust_linkman
+ ", cust_phone=" + cust_phone + ", cust_mobile=" + cust_mobile
+ "]";
}
}
6、定義Customer.hbm.xml
此配置文件關(guān)乎Customer這個pojo類，此文件需放在Customer pojo類同個包下
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.clj.domain.Customer" table="cst_customer"> <id name="cust_id" column="cust_id"> <generator class="native"/> </id> <property name="cust_name" column="cust_name"/> <property name="cust_user_id" column="cust_user_id"/> <property name="cust_create_id" column="cust_create_id"/> <property name="cust_source" column="cust_source"/> <property name="cust_industry" column="cust_industry"/> <property name="cust_level" column="cust_level"/> <property name="cust_linkman" column="cust_linkman"/> <property name="cust_phone" column="cust_phone"/> <property name="cust_mobile" column="cust_mobile"/> </class> </hibernate-mapping>
項目構(gòu)建大致圖
四、demo之保存客戶初步演示
這里先初略的定義持久層交給heibernate，業(yè)務(wù)層交個struts2，創(chuàng)建實例交給spring
1、定義一個保存客戶的界面，利用form表單進行數(shù)據(jù)的提交
根據(jù)域名可知，這里利用的是struts2的通配符方式進行訪問
<FORM id=form1 name=form1
action="${pageContext.request.contextPath }/customer_add.action"
method=post>
<!--table部分省略-->
</FORM>
2、在struts.xml中配置接受請求，根據(jù)action名和方法跳轉(zhuǎn)指定的action，執(zhí)行指定的方法
spring整合struts2方式一：action由struts2框架管理
* 因為導(dǎo)入的struts2-spring-plugin-2.3.24.jar 包自帶一個配置文件 struts-plugin.xml ，該配置文件中有如下代碼
* <constant name="struts.objectFactory" value="spring" /> 開啟一個常量，如果該常量開啟，那么下面的常量就可以使用
* struts.objectFactory.spring.autoWire = name，該常量是可以讓Action的類來自動裝配Bean對象！
<?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.3.dtd">
<struts>
<!-- 配置包結(jié)構(gòu) -->
<package name="crm" extends="struts-default" namespace="/">
<!-- 配置客戶的Action -->
<!-- 方式一：aciton由struts2框架管理-->
<action name="customer_*" class="com.clj.web.action.CustomerAction" method="{1}"/>
</package>
</struts>
3、在spring的applicationContext.xml中配置相對應(yīng)的bean以及事務(wù)
這里利用spring中IOC(控制反轉(zhuǎn))的特性，將創(chuàng)建實例的任務(wù)交給spring框架管理
<bean id="customerService" class="com.clj.service.CustomerServiceImpl"> <property name="customerDao" ref="customerDao"></property> </bean> <bean id="customerDao" class="com.clj.dao.CustomerDaoImpl"> <property name="hibernateTemplate" ref="hibernateTemplate"/> </bean> <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate"> <!-- 注入sessionFactory --> <property name="sessionFactory"/> </bean> </beans>
4、編寫持久層實現(xiàn)類相關(guān)代碼
這里利用hibernate提供的模板類，內(nèi)部封轉(zhuǎn)了session，從而可以調(diào)用session中的方法
/**
* 持久層
*
* @author Administrator
*
*/
public class CustomerDaoImpl implements CustomerDao {
//將數(shù)據(jù)保存到數(shù)據(jù)庫中(調(diào)用模板類(hibernate提供，內(nèi)部封裝了session))
private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
/**
* 保存客戶
*/
public void save(Customer customer) {
System.out.println("持久層：保存客戶");
hibernateTemplate().save(customer);
}
}
5、編寫業(yè)務(wù)層實現(xiàn)類相關(guān)代碼
package com.clj.service;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客戶的業(yè)務(wù)層
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
//用來保存客戶
public void save(Customer customer) {
System.out.println("業(yè)務(wù)層，保存客戶");
customerDao.save(customer);
}
}
6、編寫action相關(guān)代碼
這里通過struts2的模板類
package com.clj.web.action;
import org.apache.struts2.ServletActionContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
/**
* 客戶的控制層
* @author Administrator
*
*/
public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
//不要忘記手動new
private Customer customer=new Customer();
public Customer getModel() {
return customer;
}
//提供service成員屬性，提供set方法
private CustomerService customerService;
public void setCustomerService(CustomerService customerService) {
this.customerService = customerService;
}
/**
* 保存客戶
* @return
*/
public String add(){
System.out.println("WEB層，保存客戶");
//方式一：創(chuàng)建web的工廠（action由struts2創(chuàng)建）
WebApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
CustomerService cs=(CustomerService) context.getBean("customerService");
//調(diào)用方法
cs.save(customer);return NONE;
}
}
五、項目優(yōu)化之整合
1、 spring整合struts2方式二：action由spring框架管理
把具體的 Action類配置文件applicatonContext.xml的配置文件中，但是注意：struts.xml需要做修改
<struts>
<!-- 配置包結(jié)構(gòu) -->
<package name="crm" extends="struts-default" namespace="/">
<!-- 配置客戶的Action -->
<!-- 方式一：aciton由struts2框架管理
<action name="customer_*" class="com.clj.web.action.CustomerAction" method="{1}"/>-->
<!-- 方式二：action由spring管理，class標簽上只需要編寫srping配置bean的ID值既可以-->
<action name="customer_*" class="customerAction" method="{1}"></action>
</package>
</struts>
2、在applicationContext.xml中配置Action類
注意：1）Spring框架默認生成CustomerAction是單例的，而Struts2框架是多例的。所以需要配置 scope="prototype"
2）此時沒有struts2的自動裝配，在action需要手動配置customerService屬性，并在action類中生成set方法
<!-- 配置客戶模塊 --> <!-- 強調(diào)：配置的Aciton,必須是多列的 --> <bean id="customerAction" class="com.clj.web.action.CustomerAction" scope="prototype"> <!--注意：struts管理action時，基于其中有個struts-plugin的jar包，其中更改了一個 常量struts.objectFactory.spring.autoWire = name將其打開了，可以自動裝配，只需要提供set方法 但是此時action由spring管理，自動裝配失效，所以需要手動進行配置注入 --> <property name="customerService" ref="customerService"></property> </bean>
3、.配置事務(wù)
spring整合hibernate方式一： （帶有 hibernate.cfg.xml的配置文件。強調(diào)：不能加綁定當前線程的配置）
以前玩hibernate時，hibernate.cfg.xml都是由hibernate框架管理，其配置文件能生成sessionFactory,持久層加載此配置文件獲取sessionFactory，從而創(chuàng)建工廠生成session，進行數(shù)據(jù)的增刪改成，此時其配置文件應(yīng)該交給spring管理，充分利用spring的IOC特性
Spring框架提供了一個HibernateDaoSupport的工具類，以后DAO都可以繼承該類??！在引入hibernate核心配置文件之前，得讓dao層繼承一個父類HibernateDaoSupport，此父類內(nèi)部封裝了事務(wù)模板
看源碼：
1）修改相對應(yīng)的持久層實現(xiàn)類，讓他繼承HibernateDaoSupport
package com.clj.dao;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.clj.domain.Customer;
/**
* 持久層
* 繼承HibernateDaoSupport，內(nèi)部封裝了HibernateTemplate
* @author Administrator
*
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
//將數(shù)據(jù)保存到數(shù)據(jù)庫中(調(diào)用模板類(hibernate提供，內(nèi)部封裝了session))
/*private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}*/
/**
* 保存客戶
*/
public void save(Customer customer) {
System.out.println("持久層：保存客戶");
this.getHibernateTemplate().save(customer);
}
}
2）修改業(yè)務(wù)層讓，開啟事務(wù)注解
package com.clj.service;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客戶的業(yè)務(wù)層
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
//用來保存客戶
public void save(Customer customer) {
System.out.println("業(yè)務(wù)層，保存客戶");
customerDao.save(customer);
}
}
3）修改applicationContext.xml文件
先引入hibernate配置文件
<!-- 編寫bean,名稱都是固定的，由spring提供，用來加載hibernate.cfg.xml的配置文件--> <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"> <!-- 配置路徑：當啟動服務(wù)器時 ，該對象就會被創(chuàng)建，從而加載hibernate.cfg.xml文件，從而生成sessionFactory對象--> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> </bean>
配置平臺事務(wù)管理：用來管理事務(wù)， 注意現(xiàn)在使用的是 Hibernate框架，所以需要使用Hibernate框架的事務(wù)管理器
<!-- 先配置平臺事務(wù)管理器 --> <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager"> <!-- 注入事務(wù)，session能夠管理事務(wù)，工廠能夠創(chuàng)建session --> <property name="sessionFactory" ref="sessionFactory"/> </bean>
開啟事務(wù)注解
<!-- 開啟事務(wù)的注解 --> <tx:annotation-driven transaction-manager="transactionManager"/>
去除模板類配置，并為持久層配置sessionFactory
<!-- 以后，Dao都需要繼承HibernateDaoSupport，注入sessionFactory --> <bean id="customerDao" class="com.clj.dao.CustomerDaoImpl"> <!--<property name="hibernateTemplate" ref="hibernateTemplate"/>--> <!-- 這里不注入模板類，而是注入sessionFactory,因為模板需要session(封裝了session)--> <property name="sessionFactory" ref="sessionFactory"/> </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: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,名稱都是固定的，有spring提供，用來加載hibernate.cfg.xml的配置文件--> <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"> <!-- 配置路徑：當啟動服務(wù)器時 ，該對象就會被創(chuàng)建，從而加載hibernate.cfg.xml文件，從而生成sessionFactory對象--> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> </bean> <!-- 先配置平臺事務(wù)管理器 --> <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager"> <!-- 注入事務(wù)，session能夠管理事務(wù)，工廠能夠創(chuàng)建session --> <property name="sessionFactory" ref="sessionFactory"/> </bean> <!-- 開啟事務(wù)的注解 --> <tx:annotation-driven transaction-manager="transactionManager"/> <!-- 配置客戶模塊 --> <!-- 強調(diào)：配置的Aciton,必須是多列的 --> <bean id="customerAction" class="com.clj.web.action.CustomerAction" scope="prototype"> <!--注意：struts管理action時，基于其中有個struts-plugin的jar包，其中更改了一個 常量struts.objectFactory.spring.autoWire = name將其打開了，可以自動裝配，只需要提供set方法 但是此時action由spring管理，自動裝配失效，所以需要手動進行配置注入 --> <property name="customerService" ref="customerService"></property> </bean> <bean id="customerService" class="com.clj.service.CustomerServiceImpl"> <property name="customerDao" ref="customerDao"></property> </bean> <bean id="customerDao" class="com.clj.dao.CustomerDaoImpl"> <!--<property name="hibernateTemplate" ref="hibernateTemplate"/>--> <!-- 這里不注入模板類，而是注入sessionFactory,因為模板需要session(封裝了session)--> <property name="sessionFactory" ref="sessionFactory"/> </bean> <!-- 配置模板類(hibernate框架提供的，內(nèi)部封裝了session)，此時交給spring管理,如果持久層繼承了HibernateDaoSupport，則無需配置--> <!-- <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate"> 注入sessionFactory <property name="sessionFactory"/> </bean>--> </beans>
4）修改action類
因為注入了業(yè)務(wù)層實現(xiàn)類，所以此時可以直接調(diào)用業(yè)務(wù)層方法，無須加載bean
package com.clj.web.action;
import org.apache.struts2.ServletActionContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
/**
* 客戶的控制層
* @author Administrator
*
*/
public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
//不要忘記手動new
private Customer customer=new Customer();
public Customer getModel() {
return customer;
}
//提供service成員屬性，提供set方法
private CustomerService customerService;
public void setCustomerService(CustomerService customerService) {
this.customerService = customerService;
}
/**
* 保存客戶
* @return
*/
public String add(){
System.out.println("WEB層，保存客戶");
//方式一：創(chuàng)建web的工廠（action由struts2創(chuàng)建）
/*WebApplicationContext context=WebApplicationContextUtils.getWebApplicationContext(ServletActionContext.getServletContext());
CustomerService cs=(CustomerService) context.getBean("customerService");
//調(diào)用方法
cs.save(customer);*/
customerService.save(customer);
return NONE;
}
}
spring整合hibernate方式二： （不帶有 hibernate.cfg.xml的配置文件）
這里準備刪除hibernate的核心配置文件，在刪除之前，需要將其配置文件中的相關(guān)內(nèi)容配置到spring的applicatioinContext.xml文件中取
1、查看hibernate.cfg.xml文件中的相關(guān)內(nèi)容
* 數(shù)據(jù)庫連接基本參數(shù)（4大參數(shù)）
* Hibernate相關(guān)的屬性
* 連接池
* 映射文件
2、引入配置
引入連接池
<!-- 先配置C3p0的連接池 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"/> <property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/> <property name="user" value="root"/> <property name="password" value="root"/> </bean>
修改對應(yīng)的sessionFactory: 因為已經(jīng)沒有了 hibernate.cfg.xml的配置文件，所以需要修改該配置，注入連接池
引入對象映射文件：因為已經(jīng)沒有了hibernate.cfg.xml的配置文件，不會掃描到該配置文件，需要注入
<!-- 編寫bean,名稱都是固定的，有spring提供，用來加載hibernate.cfg.xml的配置文件-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!--先加載連接池 -->
<property name="dataSource" ref="dataSource"/>
<!-- 加載方言，加載可選項 -->
<property name="hibernateProperties">
<props>
<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>
<!-- 引入映射的配置文件 -->
<property name="mappingResources">
<list>
<value>com/clj/domain/Customer.hbm.xml</value>
</list>
</property>
</bean>
現(xiàn)在：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: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">
<!-- 先配置C3p0的連接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://192.168.174.130:3306/SSH"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- 編寫bean,名稱都是固定的，有spring提供，用來加載hibernate.cfg.xml的配置文件-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!--先加載連接池 -->
<property name="dataSource" ref="dataSource"/>
<!-- 加載方言，加載可選項 -->
<property name="hibernateProperties">
<props>
<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>
<!-- 引入映射的配置文件 -->
<property name="mappingResources">
<list>
<value>com/clj/domain/Customer.hbm.xml</value>
</list>
</property>
</bean>
<!-- 先配置平臺事務(wù)管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<!-- 注入事務(wù)，session能夠管理事務(wù)，工廠能夠創(chuàng)建session -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 開啟事務(wù)的注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!-- 配置客戶模塊 -->
<!-- 強調(diào)：配置的Aciton,必須是多列的 -->
<bean id="customerAction" class="com.clj.web.action.CustomerAction" scope="prototype">
<!--注意：struts管理action時，基于其中有個struts-plugin的jar包，其中更改了一個
常量struts.objectFactory.spring.autoWire = name將其打開了，可以自動裝配，只需要提供set方法
但是此時action由spring管理，自動裝配失效，所以需要手動進行配置注入
-->
<property name="customerService" ref="customerService"></property>
</bean>
<bean id="customerService" class="com.clj.service.CustomerServiceImpl">
<property name="customerDao" ref="customerDao"></property>
</bean>
<!-- 以后，Dao都需要繼承HibernateDaoSupport，注入sessionFactory -->
<bean id="customerDao" class="com.clj.dao.CustomerDaoImpl">
<!--<property name="hibernateTemplate" ref="hibernateTemplate"/>-->
<!-- 這里不注入模板類，而是注入sessionFactory,因為模板需要session(封裝了session)-->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 配置模板類(hibernate框架提供的，內(nèi)部封裝了session)，此時交給spring管理,如果持久層繼承了HibernateDaoSupport，則無需配置-->
<!-- <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
注入sessionFactory
<property name="sessionFactory"/>
</bean>-->
</beans>
此時可以安心的刪除hibernate.cfg.xml文件了
這樣SSH整合完畢
六、Hibernate模板常用方法
注意：以下代碼省略了接口中的演示(偷了個懶，相信初學(xué)者不會看不懂)
1）插入：
持久層
package com.clj.dao;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.clj.domain.Customer;
/**
* 持久層
* 繼承HibernateDaoSupport，內(nèi)部封裝了HibernateTemplate
* @author Administrator
*
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
this.getHibernateTemplate().update(customer);
}
}
業(yè)務(wù)層
package com.clj.service;
import java.util.List;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客戶的業(yè)務(wù)層
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
customerDao.update(customer);
}
}
測試類
package com.clj.test;
import java.util.List;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
/**
* 測試Hiberante模板類的簡單方法
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
@Resource(name="customerService")
private CustomerService customerService;
/**
* 測試插入
*/
@Test
public void run1(){
Customer customer=new Customer();
customer.setCust_id(1L);
customer.setCust_name("測試");
customerService.update(customer);
}
}
2）以下為指定查詢、查詢所有、離線查詢代碼
持久層
package com.clj.dao;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.clj.domain.Customer;
/**
* 持久層
* 繼承HibernateDaoSupport，內(nèi)部封裝了HibernateTemplate
* @author Administrator
*
*/
public class CustomerDaoImpl extends HibernateDaoSupport implements CustomerDao {
//將數(shù)據(jù)保存到數(shù)據(jù)庫中(調(diào)用模板類(hibernate提供，內(nèi)部封裝了session))
/*private HibernateTemplate hibernateTemplate;
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}*/
/**
* 保存客戶
*/
public void save(Customer customer) {
System.out.println("持久層：保存客戶");
this.getHibernateTemplate().save(customer);
}
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
this.getHibernateTemplate().update(customer);
}
/**
* 通過主鍵查詢
*/
public Customer getById(Long id) {
return this.getHibernateTemplate().get(Customer.class, id);
}
/**
* 查詢所有
*/
@Override
public List<Customer> findAll() {
String sql="from Customer";
List<Customer> list=(List<Customer>) this.getHibernateTemplate().find(sql);
return list;
}
/**
* QBC離線查詢
*/
@Override
public List<Customer> findAllByQBC() {
DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class);
List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria);
return list;
}
}
業(yè)務(wù)層
package com.clj.service;
import java.util.List;
import org.springframework.transaction.annotation.Transactional;
import com.clj.dao.CustomerDao;
import com.clj.domain.Customer;
/**
* 客戶的業(yè)務(wù)層
* @author Administrator
*
*/
@Transactional
public class CustomerServiceImpl implements CustomerService{
private CustomerDao customerDao;
public void setCustomerDao(CustomerDao customerDao) {
this.customerDao = customerDao;
}
//用來保存客戶
public void save(Customer customer) {
System.out.println("業(yè)務(wù)層，保存客戶");
customerDao.save(customer);
}
@Override
public void update(Customer customer) {
// TODO Auto-generated method stub
customerDao.update(customer);
}
@Override
public Customer getById(Long id) {
// TODO Auto-generated method stub
return customerDao.getById(id);
}
@Override
public List<Customer> findAll() {
return customerDao.findAll();
}
@Override
public List<Customer> findAllByQBC() {
// TODO Auto-generated method stub
return customerDao.findAllByQBC();
}
}
測試類
package com.clj.test;
import java.util.List;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.clj.domain.Customer;
import com.clj.service.CustomerService;
/**
* 測試Hiberante模板類的簡單方法
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
@Resource(name="customerService")
private CustomerService customerService;
/**
* 測試插入
*/
@Test
public void run1(){
Customer customer=new Customer();
customer.setCust_id(1L);
customer.setCust_name("測試");
customerService.update(customer);
}
/**
* 測試查詢指定的客戶
*/
@Test
public void run2(){
Customer customer=customerService.getById(2L);
System.out.println(customer);
}
/**
* 查詢所有的客戶
*/
@Test
public void run3(){
List<Customer> list=customerService.findAll();
System.out.println(list);
}
/**
* QBC(離線查詢)
*/
@Test
public void run4(){
List<Customer> list=customerService.findAllByQBC();
System.out.println(list);
}
}
七、關(guān)于SSH延遲加載問題
1. 使用延遲加載的時候，再WEB層查詢對象的時候程序會拋出異常！
* 原因是延遲加載還沒有發(fā)生SQL語句，在業(yè)務(wù)層session對象就已經(jīng)銷毀了，所以查詢到的JavaBean對象已經(jīng)變成了托管態(tài)對象！
* 注意：一定要先刪除javassist-3.11.0.GA.jar包（jar包沖突了）
2. 解決辦法
Spring框架提供了一個過濾器，讓session對象在WEB層就創(chuàng)建，在WEB層銷毀。只需要配置該過濾器即可
* 但是：要注意需要在struts2的核心過濾器之前進行，spring監(jiān)聽器之后配置
<!-- 解決延遲加載的問題 --> <filter> <filter-name>OpenSessionInViewFilter</filter-name> <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class> </filter> <filter-mapping> <filter-name>OpenSessionInViewFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
3、演示延遲加載
持久層：調(diào)用load方法，此方法時延遲加載的
/**
* 延遲加載
*/
@Override
public Customer loadById(long id) {
// TODO Auto-generated method stub
return this.getHibernateTemplate().load(Customer.class, id);
}
業(yè)務(wù)層
@Override
public Customer loadById(long id) {
// TODO Auto-generated method stub
return customerDao.loadById(id);
}
測試類
@Test
public void run5(){
Customer customer=customerService.loadById(2L);
System.out.println(customer);
}
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
您可能感興趣的文章:
- Spring5+SpringMvc+Hibernate5整合的實現(xiàn)
- Spring+SpringMVC+Hibernate整合實例講解
- Spring+SpringMVC+Hibernate項目環(huán)境搭建的步驟(圖文)
- SpringBoot 使用hibernate validator校驗
- Springboot+hibernate實現(xiàn)簡單的增刪改查示例
- Spring MVC+FastJson+hibernate-validator整合的完整實例教程
- springboot使用hibernate validator校驗方式
- Springboot hibernate envers使用過程詳解
相關(guān)文章
手把手帶你掌握SpringBoot RabbitMQ延遲隊列
RabbitMQ 是一個由Erlang語言開發(fā)的AMQP的開源實現(xiàn)，支持多種客戶端。用于在分布式系統(tǒng)中存儲轉(zhuǎn)發(fā)消息，在易用性、擴展性、高可用性等方面表現(xiàn)不俗，下文將帶你深入了解 RabbitMQ 延遲隊列2021-09-09
這篇文章主要介紹了@Scheduled在springboot中的使用方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-08-08
SpringBoot + FFmpeg實現(xiàn)一個簡單的M3U8切片轉(zhuǎn)碼系統(tǒng)
使用大名鼎鼎的ffmpeg，把視頻文件切片成m3u8，并且通過springboot，可以實現(xiàn)在線的點播。2021-05-05
這篇文章主要給大家介紹了關(guān)于如何在Java中使用Arrays.toString()對類進行排序的相關(guān)資料,文中通過代碼示例介紹的非常詳細,需要的朋友可以參考下2023-08-08
這篇文章主要為大家介紹了grpc-java?k8s下的負載均衡的處理方法，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-02-02
MapStruct處理Java中實體與模型間不匹配屬性轉(zhuǎn)換的方法
今天小編就為大家分享一篇關(guān)于MapStruct處理Java中實體與模型間不匹配屬性轉(zhuǎn)換的方法，小編覺得內(nèi)容挺不錯的，現(xiàn)在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧2019-03-03
本篇文章主要介紹了詳解Spring框架注解掃描開啟之配置細節(jié)，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-08-08
這篇文章主要介紹了javaSE基礎(chǔ)對java自定義注解原理分析，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多度進步，早日升職加薪2021-10-10
SpringBoot+Vue實現(xiàn)EasyPOI導(dǎo)入導(dǎo)出的方法詳解
項目開發(fā)過程中，很大的需求都有 導(dǎo)入導(dǎo)出功能。本文將利用SpringBoot+Vue實現(xiàn)EasyPOI導(dǎo)入導(dǎo)出功能，感興趣的可以了解一下2022-08-08
學(xué)習(xí)Java之Java中的異常處理機制詳解
在本文中,小編將帶領(lǐng)大家來學(xué)習(xí)Java的異常處理機制,包括異常機制、異常類型、如何捕獲異常、如何拋出異常以及如何創(chuàng)建自定義異常等核心內(nèi)容,感興趣的同學(xué)跟著小編一起來看看吧2023-08-08