SSH框架整合
源代码下载:https://download.csdn.net/download/qq_31059985/10390008
jar包下载地址:https://download.csdn.net/download/qq_31059985/10390042
原帖地址:https://blog.csdn.net/qq_31059985/article/details/80167712
一、SSH框架整合原理
1、Spring和Struts2整合就是将Action对象交给Spring容器进行创建
2、Spring和Hibernate整合就是将sessionFactory交给Spring来负责维护(session维护以及aop事物)
二、导包
先创建一个空的javaweb项目然后进行导包操作。
Hibernate
-hibernate-release-5.0.7.Final\lib\required
-hibernate-release-5.0.7.Final\lib\jpa(java persist api java的持久化规范-接口)
-数据库驱动包
Struts2
-struts-2.3.24\apps\struts2-blank\WEB-INF\lib
-struts-2.3.24\lib\struts2-spring-plugin-2.3.24.jar (struts整合spring插件包)注意:如果单用Struts2不使用Spring不要导入这个包,一旦导入那么Struts2在启动时就会寻找spring容器,找不到就会抛出异常。
Spring
1、基本包:4+2:core|beans|context|expression|logging|log4j
-spring-framework-4.2.4.RELEASE\libs (四个基本包)
-spring-framework-3.0.2.RELEASE-dependencies\org.apache.commons\com.springsource.org.apache.commons.logging\1.1.1
-spring-framework-3.0.2.RELEASE-dependencies\org.apache.log4j\com.springsource.org.apache.log4j\1.2.15
2、web包
-spring-framework-4.2.4.RELEASE\libs\
3、AOP包4个:spring-aop|spring-aspect|aop联盟|aopweaving
-spring-framework-4.2.4.RELEASE\libs
-spring-framework-3.0.2.RELEASE-dependencies\org.aopalliance\com.springsource.org.aopalliance\1.0.0
-spring-framework-3.0.2.RELEASE-dependencies\org.aspectj\com.springsource.org.aspectj.weaver\1.6.8.RELEASE
4、Hibernate和事务包4个:spring-jdbc|spring-tx|c3p0|spring-orm
-spring-framework-4.2.4.RELEASE\libs
-spring-framework-3.0.2.RELEASE-dependencies\com.mchange.c3p0\com.springsource.com.mchange.v2.c3p0\0.9.1.2
5、正junit4测试:test包
-spring-framework-4.2.4.RELEASE\libs
6、标签库
-jstl
三、配置Spring容器
1、创建配置文件,并导入约束(4个)beans|context|aop|tx
<?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 ">
</beans>
2、配置spring随项目启动
<?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_integrate</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>
<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>
阶段测试:启动项目确认sping整合是否成功。如果正常启动(控制台没有报错误信息)继续下面操作,如果不能正常启动重新执行以上步骤或排查问题。
四、配置Struts2
1、准备工作
-创建一个service接口
package com.ssh.service;
public interface UserService {
}
-创建一个实现类
package com.ssh.service.impl;
import com.ssh.service.UserService;public class UserServiceImpl implements UserService{
}
-创建欢迎页
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
success
</body>
</html>
-创建Action,生成service的set方法
import com.opensymphony.xwork2.ActionSupport;
import com.ssh.service.UserService;
public class UserAction extends ActionSupport {
UserService userService;
public String login(){
System.out.println(userService);
return SUCCESS;
}
public UserService getUserService() {
return userService;
}
public void setUserService(UserService userService) {
this.userService = userService;
}
}
2、配置struts2主配置文件
-创建struts2配置文件
<?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="ssh" namespace="/" extends="struts-default">
<action name="UserAction_*" class="com.ssh.action.UserAction" method="{1}">
<result name="success">/</result>
</action>
</package>
</struts>
-配置struts2核心过滤器到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_integrate</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>
<!-- 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>
<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>
阶段测试:启动项目确认struts2整合是否成功。如果正常启动(控制台没有报错误信息)继续下面操作,如果不能正常启动重新执行以上步骤或排查问题。
五、struts2与spring整合
-导包(之前已经导入过了)
-配置整合方案:spring负责创建action以及组装.
<?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架构 scope="prototype" -->
<bean name="userAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!-- service -->
<bean name="userService" class="com.ssh.service.impl.UserServiceImpl"></bean>
</beans>
-配置常量
<?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>
<!--
//将action的创建交给spring容器管理
struts.objectFactory = spring
//(默认打开 不需要配置)设置spring负责装配action的依赖 即:自动装配action需要的service
struts.objectFactory.spring.autoWire = name
-->
<constant name="struts.objectFactory" value="spring"></constant>
<!-- 设置action生命周期完全由spring管理,修改class属性为spring中action对象的beanName -->
<package name="ssh" namespace="/" extends="struts-default">
<action name="UserAction_*" class="userAction" method="{1}">
<result name="success">/success.jsp</result>
</action>
</package>
</struts>
阶段测试:启动项目测试spring和struts2整合是否成功。如果正常启动,访问http://localhost:8080/ssh_integrate/UserAction_login能显示页面,且控制台打印service地址则整合成功,继续下面操作,否则重新执行以上步骤或排查问题。
六、单独配置hibernate
-创建数据库和表
CREATE TABLE `user` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`username` varchar(255) DEFAULT NULL,
`password` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-创建实体类
package com.ssh.bean;
public class User {
/*
*
CREATE TABLE `user` (
`id` int(10) NOT NULL AUTO_INCREMENT,
`username` varchar(255) DEFAULT NULL,
`password` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
*/
private Integer id;
private String username;
private String password;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
-创建ORM元数据
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.ssh.bean" >
<class name="User" table="user" >
<id name="id" >
<generator class="native"></generator>
</id>
<property name="username" ></property>
<property name="password" ></property>
</class>
</hibernate-mapping>
-配置hibernate主配置文件
<?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:///ssh</property>
<!-- 数据库连接用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库连接密码 -->
<property name="hibernate.connection.password">mysql</property>
<!-- 数据库方言
不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
sql99标准: DDL 定义语言 库表的增删改查
DCL 控制语言 事务 权限
DML 操纵语言 增删改查
注意: MYSQL在选择方言时,请选择最短的方言.
-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 将hibernate生成的sql语句打印到控制台 -->
<property name="hibernate.show_sql">true</property>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<property name="hibernate.format_sql">true</property>
<!--
## auto schema export 自动导出表结构. 自动建表
#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
-->
<property name="hibernate.hbm2ddl.auto">update</property>
<mapping resource="com/ssh/bean/User.hbm.xml" />
</session-factory>
</hibernate-configuration>
阶段测试:
编写hibernate测试类
package com.ssh.test;
import org.hibernate.Session;
import org.hibernate.SessionFactory;import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import com.ssh.bean.User;
//测试hibernate框架
public class HibernateTest {
@Test
public void fun1() {
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();
//========================================================
User user = new User();
user.setUsername("username");
user.setPassword("password");
session.save(user);
transaction.commit();
session.close();
sessionFactory.close();
}
}
执行成功且数据库保存数据成功则表示成功
七、spring整合hibernate
1、整合原理
将sessionFactory对象交给spring容器管理
2、在spring中配置sessionFactory
<?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 ">
<!-- 在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>
<!-- 数据库url -->
<prop key="hibernate.connection.url">jdbc:mysql:///ssh</prop>
<!-- 数据库连接用户名 -->
<prop key="hibernate.connection.username">root</prop>
<!-- 数据库连接密码 -->
<prop key="hibernate.connection.password">mysql</prop>
<!-- 数据库方言
不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
sql99标准: DDL 定义语言 库表的增删改查
DCL 控制语言 事务 权限
DML 操纵语言 增删改查
注意: MYSQL在选择方言时,请选择最短的方言.
-->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!-- 可选参数 -->
<!-- 将hibernate生成的sql语句打印到控制台 -->
<prop key="hibernate.show_sql">true</prop>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<prop key="hibernate.format_sql">true</prop>
<!--
## auto schema export 自动导出表结构. 自动建表
#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
-->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
<property name="mappingDirectoryLocations" value="classpath:com/ssh/bean" ></property>
</bean>
<!-- action -->
<!-- 注意:Action对象的作用范围一定是多例,这样才符合struts2架构 scope="protptype" -->
<bean name="userAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!-- service -->
<bean name="userService" class="com.ssh.service.impl.UserServiceImpl"></bean>
</beans>
阶段测试:执行以下测试方法测试保存数据是否成功
package com.ssh.test;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.ssh.bean.User;
//测试hibernate框架
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class HibernateTest {
@Resource(name="sessionFactory")
private SessionFactory sessionFactory ;
// @Test
// public void fun1() {
// Configuration configuration = new Configuration().configure();
//
// SessionFactory sessionFactory = configuration.buildSessionFactory();
//
// Session session = sessionFactory.openSession();
//
// Transaction transaction = session.beginTransaction();
//
// //========================================================
// User user = new User();
// user.setUsername("username");
// user.setPassword("password");
// session.save(user);
// transaction.commit();
// session.close();
//
// sessionFactory.close();
// }
@Test
//测试spring管理sessionFactory
public void fun2(){
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
//-------------------------------------------------
User user = new User();
user.setPassword("22");
user.setUsername("11");
session.save(user);
//-------------------------------------------------
tx.commit();
session.close();
}
}
八、spring整合c3p0连接池
1、配置db.properties
jdbc.jdbcUrl=jdbc:mysql:///ssh
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.password=mysql
2、引入连接池到spring中并将连接池注入给SessionFactory
<?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>
<!-- 在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>
-->
<!-- 数据库url
<prop key="hibernate.connection.url">jdbc:mysql:///ssh</prop>
-->
<!-- 数据库连接用户名
<prop key="hibernate.connection.username">root</prop>
-->
<!-- 数据库连接密码
<prop key="hibernate.connection.password">mysql</prop>
-->
<!-- 数据库方言
不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
sql99标准: DDL 定义语言 库表的增删改查
DCL 控制语言 事务 权限
DML 操纵语言 增删改查
注意: MYSQL在选择方言时,请选择最短的方言.
-->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!-- 可选参数 -->
<!-- 将hibernate生成的sql语句打印到控制台 -->
<prop key="hibernate.show_sql">true</prop>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<prop key="hibernate.format_sql">true</prop>
<!--
## auto schema export 自动导出表结构. 自动建表
#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
-->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
<property name="mappingDirectoryLocations" value="classpath:com/ssh/bean" ></property>
</bean>
<!-- action -->
<!-- 注意:Action对象的作用范围一定是多例,这样才符合struts2架构 scope="protptype" -->
<bean name="userAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!-- service -->
<bean name="userService" class="com.ssh.service.impl.UserServiceImpl"></bean>
</beans>
阶段测试:再次执行上一步的测试方法测试保存数据是否成功
九、spring整合hibernate环境操作数据库
1、类创建Dao接口和实现类(实现类需要继承HibernateDaoSupport)
-创建Dao接口
package com.ssh.dao;
public interface UserDao {
public User getByUserName(String username);
}
-创建Dao实现类
package com.ssh.dao.impl;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.ssh.bean.User;
import com.ssh.dao.UserDao;
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
@Override
public User getByUserName(final String username) {
//HQL
/*return getHibernateTemplate().execute(new HibernateCallback<User>() {
@Override
public User doInHibernate(Session session) throws HibernateException {
String hql = "from User where username = ? ";
Query query = session.createQuery(hql);
query.setParameter(0, username);
User user = (User) query.uniqueResult();
return user;
}
});*/
//Criteria
DetachedCriteria dc = DetachedCriteria.forClass(User.class);
dc.add(Restrictions.eq("username", username));
List<User> list = (List<User>) getHibernateTemplate().findByCriteria(dc);
if(list != null && list.size()>0){
return list.get(0);
}else{
return null;
}
}
}
2、spring中配置dao
<?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>
<!-- 在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>
-->
<!-- 数据库url
<prop key="hibernate.connection.url">jdbc:mysql:///ssh</prop>
-->
<!-- 数据库连接用户名
<prop key="hibernate.connection.username">root</prop>
-->
<!-- 数据库连接密码
<prop key="hibernate.connection.password">mysql</prop>
-->
<!-- 数据库方言
不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
sql99标准: DDL 定义语言 库表的增删改查
DCL 控制语言 事务 权限
DML 操纵语言 增删改查
注意: MYSQL在选择方言时,请选择最短的方言.
-->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!-- 可选参数 -->
<!-- 将hibernate生成的sql语句打印到控制台 -->
<prop key="hibernate.show_sql">true</prop>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<prop key="hibernate.format_sql">true</prop>
<!--
## auto schema export 自动导出表结构. 自动建表
#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
-->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
<property name="mappingDirectoryLocations" value="classpath:com/ssh/bean" ></property>
</bean>
<!-- action -->
<!-- 注意:Action对象的作用范围一定是多例,这样才符合struts2架构 scope="protptype" -->
<bean name="userAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!-- service -->
<bean name="userService" class="com.ssh.service.impl.UserServiceImpl"></bean>
<!-- dao -->
<bean name="userDao" class="com.ssh.dao.impl.UserDaoImpl">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory" ></property>
</bean>
</beans>
阶段测试:执行测试方法,如果能查询到数据表示成功
package com.ssh.test;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.ssh.bean.User;
import com.ssh.dao.UserDao;
//测试hibernate框架
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class HibernateTest {
@Resource(name="sessionFactory")
private SessionFactory sessionFactory ;
// @Test
// public void fun1() {
// Configuration configuration = new Configuration().configure();
//
// SessionFactory sessionFactory = configuration.buildSessionFactory();
//
// Session session = sessionFactory.openSession();
//
// Transaction transaction = session.beginTransaction();
//
// //========================================================
// User user = new User();
// user.setUsername("username");
// user.setPassword("password");
// session.save(user);
// transaction.commit();
// session.close();
//
// sessionFactory.close();
// }
//
// @Test
// //测试spring管理sessionFactory
// public void fun2(){
// Session session = sessionFactory.openSession();
// Transaction tx = session.beginTransaction();
// //-------------------------------------------------
// User user = new User();
// user.setPassword("55");
// user.setUsername("66");
// session.save(user);
//
// //-------------------------------------------------
// tx.commit();
//
// session.close();
//
// }
@Resource(name="userDao")
private UserDao ud;
@Test
//测试Dao Hibernate模板
public void fun3(){
User u = ud.getByUserName("username");
System.out.println(u);
}
}
十、spring的AOP事务
<?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.ssh.service.impl.*ServiceImpl.*(..))" id="txPc"/>
<!-- 配置切面 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPc" />
</aop:config>
<!-- 在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>
-->
<!-- 数据库url
<prop key="hibernate.connection.url">jdbc:mysql:///ssh</prop>
-->
<!-- 数据库连接用户名
<prop key="hibernate.connection.username">root</prop>
-->
<!-- 数据库连接密码
<prop key="hibernate.connection.password">mysql</prop>
-->
<!-- 数据库方言
不同的数据库中,sql语法略有区别. 指定方言可以让hibernate框架在生成sql语句时.针对数据库的方言生成.
sql99标准: DDL 定义语言 库表的增删改查
DCL 控制语言 事务 权限
DML 操纵语言 增删改查
注意: MYSQL在选择方言时,请选择最短的方言.
-->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!-- 可选参数 -->
<!-- 将hibernate生成的sql语句打印到控制台 -->
<prop key="hibernate.show_sql">true</prop>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<prop key="hibernate.format_sql">true</prop>
<!--
## auto schema export 自动导出表结构. 自动建表
#hibernate.hbm2ddl.auto create 自动建表.每次框架运行都会创建新的表.以前表将会被覆盖,表数据会丢失.(开发环境中测试使用)
#hibernate.hbm2ddl.auto create-drop 自动建表.每次框架运行结束都会将所有表删除.(开发环境中测试使用)
#hibernate.hbm2ddl.auto update(推荐使用) 自动生成表.如果已经存在不会再生成.如果表有变动.自动更新表(不会删除任何数据).
#hibernate.hbm2ddl.auto validate 校验.不自动生成表.每次启动会校验数据库中表是否正确.校验失败.
-->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 引入orm元数据,指定orm元数据所在的包路径,spring会自动读取包中的所有配置 -->
<property name="mappingDirectoryLocations" value="classpath:com/ssh/bean" ></property>
</bean>
<!-- action -->
<!-- 注意:Action对象的作用范围一定是多例,这样才符合struts2架构 scope="protptype" -->
<bean name="userAction" class="com.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!-- service -->
<bean name="userService" class="com.ssh.service.impl.UserServiceImpl"></bean>
<!-- dao -->
<bean name="userDao" class="com.ssh.dao.impl.UserDaoImpl">
<!-- 注入sessionFactory -->
<property name="sessionFactory" ref="sessionFactory" ></property>
</bean>
</beans>
测试:
1、service层增加saveUser方法
-service
-serviceImpl
-dao接口
-dao实现类
-在spring中注入userDao到userService中
-编写测试方法执行测试
十一、扩大session作用范围
1、意义:为了避免使用懒加载时出现no-session问题.需要扩大session的作用范围
2、在web.xml中配置filter
<?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_integrate</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之前调用,因为一旦进入struts的filter就不会再执行其他filterl
-->
<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>
到此SSH框架搭建完成
编写个小功能测试SSH框架。
根据用户名查询user表中数据返回给前台页面