king_tt
- 浏览: 2233194 次
- 性别:
- 来自: 深圳
-
文章分类
最新评论
-
wahahachuang5：
web实时推送技术使用越来越广泛，但是自己开发又太麻烦了，我觉 ...
细说websocket - php篇 -
wahahachuang8：
挺好的，学习了
细说websocket - php篇 -
jacking124：
学习了！支持你，继续
初窥Linux 之 我最常用的20条命令 -
aliahhqcheng：
应该是可以实现的，没有看过源码。你可以参考下：http://w ...
Jackson 框架，轻易转换JSON
struts2+spring+hibernate集成(annotation版)
费话不多说......
（1）由于本人最常用的是Oracle，所以本例就采用Oracle为例，下面是建表语句：
--用户表 create table t_user ( user_id number primary key not null,--编号 user_name varchar2(24),--姓名 user_sex varchar2(4),--性别 user_class varchar2(24)--班级 ); create sequence user_seq start with 1 increment by 1; insert into t_user values(user_seq.nextval,'张一','男','大班'); insert into t_user values(user_seq.nextval,'张二','男','大班'); insert into t_user values(user_seq.nextval,'张三','男','大班'); insert into t_user values(user_seq.nextval,'张四','男','大班'); insert into t_user values(user_seq.nextval,'张五','男','大班'); insert into t_user values(user_seq.nextval,'李一','女','小班'); insert into t_user values(user_seq.nextval,'李二','女','小班'); insert into t_user values(user_seq.nextval,'李三','女','小班'); insert into t_user values(user_seq.nextval,'李四','女','小班'); insert into t_user values(user_seq.nextval,'李五','女','小班'); select * from t_user;
（2）spring配置文件，个人主要分成两个，便于管理，放到src目录下，
首先是数据源配置applicationContext-datasource.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<property name="driverClass"><value>oracle.jdbc.driver.OracleDriver</value></property>
<property name="jdbcUrl"><value>jdbc:oracle:thin:@localhost:1521:ORCL</value></property>
<property name="user"><value>scott</value></property>
<property name="password"><value>tiger</value></property>
<property name="minPoolSize"><value>5</value></property>
<property name="maxPoolSize"><value>50</value></property>
<property name="maxIdleTime"><value>1800</value></property>
<property name="acquireIncrement"><value>5</value></property>
<property name="maxStatements"><value>0</value></property>
<property name="maxStatementsPerConnection"><value>100</value></property>
<property name="initialPoolSize"><value>5</value></property>
<property name="acquireRetryAttempts"><value>30</value></property>
<property name="breakAfterAcquireFailure"><value>false</value></property>
<property name="testConnectionOnCheckout"><value>false</value></property>
<property name="idleConnectionTestPeriod"><value>1800</value></property>
</bean>
<!-- 注入jdbcTemplate,查询数据时使用 -->
<bean id="jdbcTemplete" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--
<context:annotation-config></context:annotation-config>
-->
<!-- 如果配置了自动扫描，则上面的可以注释掉 -->
<context:component-scan base-package="com.test"></context:component-scan>
</beans>
然后是sessionFactory以及事务相关配置 applicationContext-hibernate.xml，将实体bean以及事务交给spring来管理：
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9iDialect</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.format_sql">false</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.connection.release_mode">auto</prop>
</props>
</property>
<property name="mappingDirectoryLocations">
<list>
<value>classpath:com/test/model/</value>
</list>
</property>
</bean>
<bean name="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean name="baseTransaction" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">
<property name="transactionManager" ref="transactionManager"></property>
<property name="proxyTargetClass" value="true"></property>
<property name="transactionAttributes">
<props>
<prop key="create*">PROPAGATION_REQUIRED</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="edit*">PROPAGATION_REQUIRED</prop>
<prop key="del*">PROPAGATION_REQUIRED</prop>
<prop key="copy*">PROPAGATION_REQUIRED</prop>
<prop key="sync*">PROPAGATION_REQUIRED</prop>
<prop key="*">readOnly</prop>
</props>
</property>
</bean>
</beans>
（3）接下来就是struts的配置文件了，同样放到src目录下，struts.xml代码如下：
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd" > <struts> <constant name="struts.ui.theme" value="simple" /> <constant name="struts.ui.templateDir" value="template" /> <constant name="struts.ui.templateSuffix" value="ftl" /> <constant name="struts.devMode" value="true"></constant> <constant name="struts.configuration.xml.reload" value="true"></constant> <package name="default" extends="struts-default"> <action name="userAction" class="com.test.user.action.UserAction"> <result name="all">/all.jsp</result><!-- 此处代码配置forward跳转，可不必理会 --> <result name="all_group">/all_group.jsp</result> </action> </package> </struts>
（4）接下来就是最核心的web.xml配置了，代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<filter>
<filter-name>struts</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<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>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
相关配置做好了，接下来就开始以用户添加和查询为例......
（5）User.java，实体Bean
package com.test.model;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity
@Table(name="t_user",catalog="scott")
public class User implements Serializable{
private int user_id;
private String user_name;
private String user_sex;
private String user_class;
public User(){
}
public User(String user_name,String user_sex,String user_class){
this.user_name = user_name;
this.user_sex=user_sex;
this.user_class=user_class;
}
@Id
@Column(name="user_id")
@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="user_seq")
@SequenceGenerator(sequenceName="user_seq",name="user_seq")
public int getUser_id() {
return user_id;
}
public void setUser_id(int user_id) {
this.user_id = user_id;
}
@Column(name="user_name",length=24)
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
@Column(name="user_sex",length=4)
public String getUser_sex() {
return user_sex;
}
public void setUser_sex(String user_sex) {
this.user_sex = user_sex;
}
@Column(name="user_class",length=24)
public String getUser_class() {
return user_class;
}
public void setUser_class(String user_class) {
this.user_class = user_class;
}
}
（6）新建接口类：UserService.java
package com.test.user.service;
import java.util.List;
import org.springframework.stereotype.Service;
import com.test.model.User;
@Service
public interface UserService {
/*************
* 创建用户
*
* @param user
* @throws Exception
*/
public void createUser(User user) throws Exception;
/************
* 获取用户列表
*
* @return
* @throws Exception
*/
public List<User> getAllUser() throws Exception;
}
（6）新建UserDao，实现增加和查询的功能，继承HibernateDaoSupport ，代码如下：
package com.test.user.dao;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;
import com.test.model.User;
@Repository
public class UserDao extends HibernateDaoSupport {
private JdbcTemplate jdbcTemplate;
@Resource
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Resource
public void setSessionFactoryOverride(SessionFactory sessionFactory) {
super.setSessionFactory(sessionFactory);
}
public void createUser(User user) throws Exception {
this.getHibernateTemplate().save(user);
}
@SuppressWarnings("unchecked")
public List<User> getAllUser() throws Exception {
// return this.getHibernateTemplate().find("from User");
// 用jdbcTemplate查询
List<User> list = new ArrayList<User>();
SqlRowSet rs = this.jdbcTemplate
.queryForRowSet("select user_id,user_name,user_sex,user_class from t_user");
while (rs.next()) {
User user = new User();
user.setUser_id(rs.getInt("user_id"));
user.setUser_name(rs.getString("user_name"));
user.setUser_sex(rs.getString("user_sex"));
user.setUser_class(rs.getString("user_class"));
list.add(user);
}
return list;
}
}
（7）新建UserServiceImpl.java，注入UserDao，调用UserDao里的方法，实现UserServie接口，代码如下：
package com.test.user.service.impl;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Component;
import com.test.model.User;
import com.test.user.dao.UserDao;
import com.test.user.service.UserService;
@Component
public class UserServiceImpl implements UserService {
@Resource
private UserDao userDao;
@Override
public void createUser(User user) throws Exception {
this.userDao.createUser(user);
}
@Override
public List<User> getAllUser() throws Exception {
return this.userDao.getAllUser();
}
}
（8）接下来理所应当就是我们的控制器UserAction.java类了
package com.test.user.action;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import org.springframework.stereotype.Controller;
import com.opensymphony.xwork2.ActionSupport;
import com.test.model.User;
import com.test.user.service.UserService;
@Controller
public class UserAction extends ActionSupport {
@Resource
private UserService userService;
private List<User> userList = new ArrayList<User>();
public List<User> getUserList() {
return userList;
}
public void setUserList(List<User> userList) {
this.userList = userList;
}
public String getAllUser() {
try {
// this.userList = this.userService.getAllUser();//全查询
this.userList = new ArrayList<User>();
System.out.println(this.userList.size());
} catch (Exception e) {
e.printStackTrace();
}
return "all";
}
}
（10）为了避免麻烦就不用jsp页面进行演示，直接用Junit进行测试，添加jar包junit-4.8.2.jar，测试代码如下：
package com.test.test;
import java.util.List;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.test.user.service.UserService;
public class UserTest {
private static UserService userService;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
System.out.println("JUnit start......");
ApplicationContext app=new ClassPathXmlApplicationContext("applicationContext-*.xml");
userService=(UserService) app.getBean("userServiceImpl");
}
@AfterClass
public static void afterClass() throws Exception {
System.out.println("JUnit end......");
}
@Test
public void getAllUser(){
try {
System.out.println("用户数："+this.userService.getAllUser().size());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// @Test
// public void addUser(){
// System.out.println("添加用户......");
// User user=new User("刘星","男","小班");
// try {
// this.userService.createUser(user);
// } catch (Exception e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// }
}
(注：本例已测试通过)
分享到：
发表评论
相关推荐
Struts2、Spring和Hibernate是Java企业级开发中三大核心框架，它们的集成极大地提高了开发效率和代码质量。本文将详细解析"Struts2+Spring2+Hibernate3 Annotation的整合"这一主题，主要涵盖以下几个方面： 1. **...
### Struts2+Spring2+Hibernate3+Annotation所需JAR包详解 在Java Web开发领域，Struts2、Spring2和Hibernate3是三个非常重要的框架，它们分别负责Web层、业务逻辑层和服务持久化层的功能实现。为了更好地整合这三...
总结来说，"struts2.1 + spring 2.5 + hibernate 3.2 增删改查"的例子涵盖了Web应用开发中的核心部分：前端请求处理（Struts2）、业务逻辑管理（Spring）和数据库操作（Hibernate）。这个例子为初学者提供了一个很好...
【标题】：“jQuery EasyUI+Struts2+Spring+Hibernate基于注解实现的CRM系统” 在IT领域，CRM（Customer Relationship Management，客户关系管理）系统是企业用来优化与客户交互和管理的重要工具。本项目利用一系列...
### JavaEE多层架构Struts2+Spring3+Hibernate3+Ajax的整合 #### 概述 随着软件开发技术的不断进步，构建可复用、易于扩展并经过良好测试的软件组件变得尤为重要。在此背景下，Struts、Spring 和 Hibernate 这三大...
在这个“Struts2+Spring2.5+Hibernate3+annotation”整合程序中，我们将深入探讨这三大框架如何协同工作，以及注解在其中起到的关键作用。 首先，Struts2作为MVC（模型-视图-控制器）框架，负责处理HTTP请求，提供...
Struts2、Spring2.5和Hibernate3.2是经典的Java Web开发框架组合，它们各自在应用程序的不同层面提供了强大的功能。这个"sshTest"项目是一个使用这三个框架的注解配置的完整Eclipse工程，同时也包含了数据库脚本，...
### Java8 + Tomcat8 + Struts2.5 + Spring4.3 + Hibernate5.2 框架搭建详细过程 #### 一、环境配置与准备 在搭建一个基于Java8 + Tomcat8 + Struts2.5 + Spring4.3 + Hibernate5.2 的项目前，首先需要对开发环境...
Struts2.3.28、Spring4.1.6和Hibernate4.3.8是三个经典的Java EE框架，它们的整合是企业级应用开发中常见的技术栈，通常被称为S2SH。在这个版本的整合中，注解的使用极大地简化了配置过程，使得开发更加高效。以下是...
SSH三大框架，即Struts、Spring和Hibernate，是Java Web开发中的常用技术组合，它们各自负责不同的职责：Struts作为MVC模式中的Controller层，处理用户请求并转发到相应的业务逻辑；Spring则作为核心容器，负责依赖...
Struts1.3、Spring2.5 和 Hibernate3.3 是经典的 Java Web 开发框架组合，它们在企业级应用中广泛使用。这个组合被称为“SSH”（Struts-Spring-Hibernate），它允许开发者构建可扩展且松耦合的后端系统。在本项目中...
Struts2、Spring和Hibernate是Java Web开发中的三大框架，它们各自在应用程序的不同层面发挥着重要作用。Struts2是用于处理MVC（Model-View-Controller）架构的框架，Spring是一个全面的后端应用程序框架，而...
在Java Web开发领域，Struts2、Spring以及Hibernate是三个非常重要的开源框架，它们各自在不同的方面发挥着重要作用：Struts2用于构建MVC架构的Web应用；Spring作为依赖注入容器，简化了Java应用中的对象管理；...
【知识点详解】 ...这样的集成环境使得开发者可以方便地进行MVC架构的开发，同时利用Spring进行依赖注入和事务管理，以及Hibernate进行对象关系映射。这个过程对于理解Java Web应用的架构和开发流程至关重要。
JQuery1.4.2+Struts2.1.8+JSON0.34+Spring2.5.6+Hibernate3.5+XFire1.2.6整合实例(已上传) 1、JSON0.34使用的是struts2附带的struts2-json-plugin-2.1.8.1.jar 2、db是mysql，名字为test,用户名root,密码空 3、...
Spring还提供了对其他框架的集成，如Struts和Hibernate，形成了所谓的“Spring生态系统”。 在整合这三个框架时，通常步骤如下： 1. **配置Struts1.3**：首先需要在web.xml中配置Struts的前端控制器（Action...
Struts2、Hibernate和Spring是Java开发中三大主流框架，它们的整合应用通常被称为SSH（Struts2-Spring-Hibernate）集成。这个压缩包包含了这三个框架的特定版本：Struts2.18、Hibernate3.3.2和Spring2.5.6，以及可能...