一、 Jar包
1. Mysql数据库驱动包
2. struts2.2.1
注意:与hibernate集成时去掉javassist-3.7
与spring集成时加上struts2-spring-plugin-2.2.1.jar
3. Hibernate3.6.4
4. Spring3.1
Spring AOP需要jar包
Spring整合Hibernate需要jar包
二、 框架集成所需配置文件
1. web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<welcome-file-list>
<welcome-file>register.jsp</welcome-file>
</welcome-file-list>
<!-- 集成spring所需配置 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:beans.xml</param-value>
</context-param>
<!-- spring解决hibernate的session关闭问题:是session在jsp访问完成后由该filter关闭,注意此filter必须在struts2的filter前面
配置该filter后要进行事务的配置,否则产生read-only
OpenSessionInViewFilter默认事务均为只读事务,且事务边界为Dao层
-->
<filter>
<filter-name>OpenSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
<!-- 注意:beans.xml中SessionFactory的id如果不是sessionFactory则需配置此项
<init-param>
<param-name>sessionFactoryBeanName</param-name>
<param-value>mySessionFactory</param-value>
</init-param>
-->
</filter>
<filter-mapping>
<filter-name>OpenSessionInViewFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- struts2的filter -->
<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>
2. 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>
<!-- 设置模式为开发模式,项目部署完成后注意设置为false(默认) -->
<constant name="struts.devMode" value="true" />
<!-- 解决中文问题 -->
<constant name="struts.i18n.encoding" value="GBK"></constant>
<package name="user" extends="struts-default" namespace="/user">
<action name="user" class="userAction">
<result name="registersuccess">/register_success.jsp</result>
<result name="getUserById">/show_user.jsp</result>
</action>
</package>
</struts>
3. beans.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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<context:annotation-config/>
<context:component-scan base-package="com.mj.register"/>
<!-- xml的配置方式
<bean id="userDao" class="com.mj.register.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.mj.register.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
-->
<!-- beans.xml中配置数据库连接参数
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/ssh_register"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>
-->
<!-- jdbc.properties中配置数据库连接参数 -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:jdbc.properties</value>
</property>
</bean>
<!-- 配置DataSource数据源 -->
<bean id="myDataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName"
value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- spring中配置SessionFactory bean 注意用annotation方式时class配置-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="myDataSource"/>
<!--
<property name="annotatedClasses">
<list>
<value>com.bjsxt.model.User</value>
<value>com.bjsxt.model.Log</value>
</list>
</property>
-->
<property name="packagesToScan">
<list>
<value>com.mj.register.model</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<!-- spring集成hibernate时的HibernateTemplate bean配置 -->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- spring关于事务TransactionManager的配置 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- spring关于AOP面向切面编程的配置 -->
<aop:config>
<aop:pointcut id="bussinessService"
expression="execution(public * com.mj.register.service.impl.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="bussinessService"/>
</aop:config>
<!-- spring对具体方法的事务配置 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!-- <tx:method name="exists" read-only="true" /> -->
<tx:method name="add*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
</beans>
4. jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssh_register
jdbc.username=root
jdbc.password=123
5. log4j.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration PUBLIC "-//log4j/log4j Configuration//EN" "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%d %-5p %c.%M:%L - %m%n"/>
</layout>
</appender>
<!-- specify the logging level for loggers from other libraries -->
<!--
<logger name="com.opensymphony">
<level value="DEBUG" />
</logger>
-->
<!--
<logger name="org.apache.struts2">
<level value="DEBUG" />
</logger>
-->
<logger name="log4j.logger.org.hibernate.tool.hbm2ddl">
<level value="DEBUG" />
</logger>
<!-- for all other loggers log only debug and above log messages -->
<root>
<priority value="warn"/>
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>
三、 用户注册模块(MVC)
1. 控制层Controller
(1). UserAction
package com.mj.register.action;
import javax.annotation.Resource;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import com.mj.register.model.Log;
import com.mj.register.model.User;
import com.mj.register.service.UserService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
//将UserAction以组件的形式放入spring的容器中,注意spring bean默认是单例,此处要修改为prototype类型
@Component("userAction")
@Scope("prototype")
public class UserAction extends ActionSupport implements ModelDriven{
// private UserService userService=null;
private UserService userService;
private User user=new User();//struts2用ModelDriven自动装配实体时需要new实体对象
// public UserAction() {
// userService=new UserServiceImpl();
// }
public String register(){
// System.out.println("userName="+user.getName());
Log log=new Log();
log.setInfo("a user add!");
userService.add(user,log);
return "registersuccess";
}
public String getUserById(){
user=userService.getUserById(user.getId());
// System.out.println(user.getName());
return "getUserById";
}
@Override
public Object getModel() {
return user;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public UserService getUserService() {
return userService;
}
//spring注入UserService
@Resource(name="userService")
public void setUserService(UserService userService) {
this.userService = userService;
}
}
2. 展示层Viewer
(2). register.jsp
<%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>用户注册</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
</head>
<body>
<form action="user/user!register" method="post">
用户名:<input type="text" id="name" name="name">
密码:<input type="password" id="password" name="password">
确认密码:<input type="password" id="passwordconfirm" name="passwordconfirm">
<input type="submit" value="注册"/>
</form>
</body>
</html>
(3). register_success.jsp
<%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>用户注册成功</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
</head>
<body>
User Register Success!
</body>
</html>
(4). show_user.jsp
<%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>用户注册成功</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
</head>
<body>
<c:out value="${user.name}"></c:out>
</body>
</html>
3. 业务逻辑层Model
(1). 数据库实体模型model
a. User
package com.mj.register.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class User {
private int id;
private String name;
private String password;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
b. Log
package com.mj.register.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="t_log")
public class Log {
private int id;
private String info;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
(2). 数据库访问层Dao接口
a. UserDao
package com.mj.register.dao;
import com.mj.register.model.User;
public interface UserDao {
public void save(User user);
public User getUserById(int id);
// public void save(User user,Connection conn) throws SQLException;
}
b. LogDao
package com.mj.register.dao;
import com.mj.register.model.Log;
public interface LogDao {
public void log(Log log);
}
(3). Spring集成hibernate SuperDao
package com.mj.register.dao;
import javax.annotation.Resource;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Component;
//spring集成hibernate的辅助,帮助注入HibernateTemplate
@Component("superDao")
public class SuperDao extends HibernateDaoSupport{
@Resource(name="hibernateTemplate")
public void setSuperHibernateTemplate(HibernateTemplate hibernateTemplate){
super.setHibernateTemplate(hibernateTemplate);
}
}
(4). 数据库访问层Dao实现
a. UserDaoImpl
package com.mj.register.dao.impl;
//import org.hibernate.Session;
import javax.annotation.Resource;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Component;
import com.mj.register.dao.SuperDao;
import com.mj.register.dao.UserDao;
import com.mj.register.model.User;
@Component("userDao")
public class UserDaoImpl extends SuperDao implements UserDao {
// private SessionFactory sf=null;
// private HibernateTemplate hibernateTemplate;
// public UserDaoImpl(){
// sf=HibernateUtil.getSessionFactory();
// }
@Override
public void save(User user) {
// Session session=sf.openSession();
// Session session=sf.getCurrentSession();
// session.beginTransaction();
// session.save(user);
// session.getTransaction().commit();
// session.close();
// HibernateUtil.Close(sf);
// hibernateTemplate.save(user);
this.getHibernateTemplate().save(user);
}
/*
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
@Resource(name="hibernateTemplate")
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
*/
@Override
public User getUserById(int id) {
// return hibernateTemplate.load(User.class, id);
return this.getHibernateTemplate().load(User.class, id);
}
// public void save(User user, Connection conn) throws SQLException{
// PreparedStatement pstmt=null;
// String sql="insert into user(name,password) values(?,?)";
// try {
// pstmt=conn.prepareStatement(sql);
// pstmt.setString(1, user.getName());
// pstmt.setString(2, user.getPassword());
// pstmt.executeUpdate();
//
// } finally{
// DBUtil.close(pstmt);
// }
// }
// public void save(User user) {
// Connection conn=null;
// PreparedStatement pstmt=null;
// String url="jdbc:mysql://localhost:3306/ssh_register";
// String userName="root";
// String password="123";
// String sql="insert into user(name,password) values(?,?)";
// try {
// Class.forName("com.mysql.jdbc.Driver");
// conn=DriverManager.getConnection(url, userName, password);
// conn.setAutoCommit(false);
// pstmt=conn.prepareStatement(sql);
// pstmt.setString(1, user.getName());
// pstmt.setString(2, user.getPassword());
// pstmt.executeUpdate();
// conn.commit();
throw new SQLException();
//
// } catch (SQLException e) {
// e.printStackTrace();
// try {
// conn.rollback();
// } catch (SQLException e1) {
// e1.printStackTrace();
// }
// } catch (ClassNotFoundException e){
// e.printStackTrace();
// } finally{
//
// //关闭stmt
// if(pstmt!=null){
// try {
// pstmt.close();
// pstmt=null;
// } catch (SQLException e) {
// e.printStackTrace();
// }
// }
// //关闭conn 恢复conn为自动提交事务
// if(conn!=null){
//
// try {
// if(conn.getAutoCommit()){
// conn.setAutoCommit(true);
// }
// } catch (SQLException e1) {
// e1.printStackTrace();
// }
//
// try {
// conn.close();
// conn=null;
// } catch (SQLException e) {
// e.printStackTrace();
// }
// }
// }
//
// }
}
b. LogDaoImpl
package com.mj.register.dao.impl;
import javax.annotation.Resource;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Component;
import com.mj.register.dao.LogDao;
import com.mj.register.dao.SuperDao;
import com.mj.register.model.Log;
@Component("logDao")
public class LogDaoImpl extends SuperDao implements LogDao{
// private HibernateTemplate hibernateTemplate;
@Override
public void log(Log log){
// hibernateTemplate.save(log);
this.getHibernateTemplate().save(log);
}
/*
public HibernateTemplate getHibernateTemplate() {
return hibernateTemplate;
}
@Resource(name="hibernateTemplate")
public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
this.hibernateTemplate = hibernateTemplate;
}
*/
}
(5). 业务逻辑Service接口
a. UserService
package com.mj.register.service;
import com.mj.register.model.Log;
import com.mj.register.model.User;
public interface UserService {
public void add(User user,Log log);
public User getUserById(int id);
}
(6). 业务逻辑Service实现(事务边界)
a. UserServiceImpl
package com.mj.register.service.impl;
//import java.sql.Connection;
//import java.sql.SQLException;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import com.mj.register.dao.LogDao;
import com.mj.register.dao.UserDao;
import com.mj.register.model.Log;
import com.mj.register.model.User;
import com.mj.register.service.UserService;
@Component("userService")
public class UserServiceImpl implements UserService {
// private Connection conn=null;
// private UserDao userDao=null;
private UserDao userDao;
private LogDao logDao;
// public UserServiceImpl() {
conn=DBUtil.getConnection();
// userDao=new UserDaoImpl();
// }
@Override
public void add(User user,Log log) {
userDao.save(user);
logDao.log(log);
}
@Override
public User getUserById(int id) {
return userDao.getUserById(id);
}
public UserDao getUserDao() {
return userDao;
}
@Resource(name="userDao")
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public LogDao getLogDao() {
return logDao;
}
@Resource(name="logDao")
public void setLogDao(LogDao logDao) {
this.logDao = logDao;
}
// public void add(User user) {
// try {
// DBUtil.beginTransaction(conn);
// userDao.save(user, conn);
// DBUtil.commitTransaction(conn);
// } catch (Exception e) {
// e.printStackTrace();
// DBUtil.rollbackTransaction(conn);
// } finally{
// DBUtil.recoverConnection(conn);
// DBUtil.close(conn);
// }
// }
}