SSH(Struts、Spring、Hibernate)三大框架整合

1. 新建数据库ssh_db -> 新建表user_tb（id为主键，自动递增)

2. 导入jar包（struts、hibernate 和 spring）

3. 注册页面reg.jsp，将表单的 action 属性设置为 handleAction，input 元素的 name 属性值加上前缀“user.”，如user.username

<%@ 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>账号注册</title>
</head>
<body>
     <form action="handleAction" method="post">
          账&nbsp;&nbsp;&nbsp;&nbsp;号:<input name="user.username"/><br/> <br/>
          密&nbsp;&nbsp;&nbsp;&nbsp;码:<input type="password" name="user.password"/><br/> <br/>
      <input type="submit" value="注册"/> <input type="submit" value="登录">
     </form>
</body>
</html>

4.数据处理及输出页面handledata.jsp，当Action中返回的user对象为空时，页面输出“注册失败”，不为空时输出注册信息

<%@page import="java.sql.*"%>
<%@page import="indi.wt.ssh.pojo.*"%>
<%@page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8" import="java.sql.*"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>数据处理</title>
</head>
<%@ taglib prefix="s" uri="/struts-tags" %>
<body>
    <%
         User user = (User) request.getAttribute("user");
         if (user != null) {
             out.print("<p>恭喜你，注册成功！以下是你的注册信息：</>");
             out.print("<p>账号：" + user.getUsername() + "</>");
             out.print("<p>密码：" + user.getPassword() + "</>");
         } else {
             out.print("<p>注册失败！</>");
         }
     %>
</body>
</html>

5.实体层:根据数据库表结构生成 User 类，并生成对应字段的 set 和 get 方法（id为主键，生成策略为自动增长，username和password为属性）-> 加hibernate注解如下

package indi.wt.ssh.pojo;

import javax.persistence.*;
import org.hibernate.annotations.Where;

@Entity
@Table(name="user_tb")
@Where(clause = "")
public class User {
    @Column(name="username")
    private String username;
    @Column(name="password")
    private String password;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) //主键生成策略
    private int 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;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
}

6. 数据访问层，加入insertUser和getUser方法

package indi.wt.ssh.dao;

import indi.wt.ssh.pojo.User;

import org.hibernate.*;
import org.hibernate.cfg.*; 

public class UserDao {
    public int insertUser(User user) {
        //System.out.println("insertUser");
        Configuration config = new Configuration().configure();
        SessionFactory sf = config.buildSessionFactory();
        Session session = sf.openSession();
        Transaction tx = session.beginTransaction();
        session.save(user);
        tx.commit();
        session.close();
        sf.close();
        return user.getId();
    }

    public User getUser(int id) {

        User user = null;
        Configuration config = new Configuration().configure();
        SessionFactory sf = config.buildSessionFactory();
        Session session = sf.openSession();
        Transaction tx = session.beginTransaction();

        Object obj = session.createQuery("from User u where u.id=" + id).uniqueResult();
        tx.commit();
        user = (User) obj;

        session.close();
        sf.close();
        return user;
    }
}

7. Action层：注入User和UserDao对象 -> 生成相应地get和set方法 -> 重写execute方法

package indi.wt.ssh.action;

import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionSupport;

import indi.wt.ssh.dao.UserDao;
import indi.wt.ssh.pojo.User;

public class HandleDataAction extends ActionSupport {

    User user = null;
    UserDao userDao = null;

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public String execute() {
        if(userDao == null) System.out.println("userdao = null");
        int id = userDao.insertUser(user);
        System.out.println("id = "+id);
        if (id > 0) {
            ServletActionContext.getRequest().setAttribute("user",user);
            return SUCCESS;
        } else {
            return "error";
        }

    }

}

8. 配置web.xml，加入Spring监听器和Struts过滤器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>SSHIntegrationPrj</display-name>
  <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>
  <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>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

9. 配置struts文件struts.xml，放在src目录下

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

    <constant name="struts.enable.DynamicMethodInvocation" value="false" />
    <constant name="struts.devMode" value="true" />

    <package name="default" namespace="/" extends="struts-default">

        <default-action-ref name="index" />

        <global-results>
            <result name="error">/WEB-INF/jsp/error.jsp</result>
        </global-results>

        <global-exception-mappings>
            <exception-mapping exception="java.lang.Exception" result="error"/>
        </global-exception-mappings>

        <action name="RegAction" >
            <result>/reg.jsp</result>
        </action>

        <action name="handleAction" class="indi.wt.ssh.action.HandleDataAction">
            <result name="success">/handledata.jsp</result>
        </action> 

    </package>

</struts>

10. 配置hibernate文件hibernate.cfg.xml，放在src目录下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 数据库JDBC驱动类名 -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://127.0.0.1:3306/ssh_db</property>
        <property name="connection.username">wt</property>
        <property name="connection.password">123456</property>

        <!-- 数据库方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <!-- ddl语句自动建表 -->
        <property name="hbm2ddl.auto">none</property>
<!--输出sql语句 -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <!-- 连接池配置 -->
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <property name="hibernate.c3p0.max_size">20</property>
        <property name="hibernate.c3p0.min_size">5</property>
        <property name="hibernate.c3p0.timeout">120</property>
        <property name="automaticTestTable">Test</property>
        <property name="hibernate.c3p0.max_statements">100</property>
        <property name="hibernate.c3p0.idle_test_period">120</property>
        <property name="hibernate.c3p0.acquire_increment">1</property>
        <property name="c3p0.testConnectionOnCheckout">true</property>
        <property name="c3p0.idleConnectionTestPeriod">18000</property>
        <property name="c3p0.maxIdleTime">25000</property>
        <property name="c3p0.idle_test_period">120</property>

        <!-- 注册ORM映射文件 -->
        <mapping class="indi.wt.ssh.pojo.User"/>
    </session-factory>
</hibernate-configuration>

11. 配置spring文件applicationContext.xml，放在web-inf目录下 （因UserDao和HandleDataAction之间存在依赖关系，故将到 dao 对象的配置放在前面。特别要注意的是，系统默认采用的自动装配策略是 byName 方式，所以此处 dao 的 id 值必须和 action 中的属性名一致，action 的 id 值要和 Struts.xml 文件中配置的 action 名一致）

<?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:util="http://www.springframework.org/schema/util"
 xmlns:p="http://www.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-4.0.xsd">
 <!-- 配置一个 bean -->
<bean id="userDao" class="indi.wt.ssh.dao.UserDao"></bean>
<bean id="handleAction" class="indi.wt.ssh.action.HandleDataAction"></bean>
</beans>

原文地址：https://www.cnblogs.com/unknownname/p/10742641.html

时间： 2024-10-10 01:07:41

SSH(Struts、Spring、Hibernate)三大框架整合的相关文章

浅谈ssh(struts,spring,hibernate三大框架)整合的意义及其精髓

hibernate工作原理 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现.他很大程度的简化DAO层的编码工作 3. hib

[转] 浅谈ssh(struts,spring,hibernate三大框架)整合的意义及其精髓

hibernate工作原理 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Sesssion 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现.他很大程度的简化DAO层的编码工作 3. hib

SSH(struts2+spring+hibernate)三大框架整合

SSH框架整合理论: 在SSH框架的JAVAweb项目的开发过程中,WEB层通常使用的是Struts2+jsp,service层使用的是javaBean,DAO层使用的是hibernate,而spring的使用覆盖三层. 使用了spring框架之后,我们可以把对象交给spring来管理.在WEB层中,所有action对象的创建和管理都可以交给spring来完成,这样Struts2就不用自己来new一个action,这一切都可以交给spring,直接向spring来要action对象. 在DAO层

Struts,spring,hibernate三大框架的面试

Struts,spring,hibernate三大框架的面试 1.Hibernate工作原理及为什么要用? 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory  为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久

Struts,Spring,Hibernate三大框架 面试题

Struts,Spring,Hibernate三大框架 1.Hibernate工作原理及为什么要用? 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于JDBC的主流持久化框架,

struts2,spring,hibernate三大框架整合

本文利用mvc三层架构来讲述S2SH三大框架整合的步骤: 1.建立好包结构,建立好的包结构如下: 2.导入相应的jar包 (1)struts2用到的jar包 (2)spring用到的jar包 (3)hibernate用到的jar包 (4)mysql驱动包,junit和struts2插件 (5)公共包,例如日志 commons-logging-1.1.3.jar log4j-1.2.17.jar slf4j-log4j12-1.5.0.jar 最后经过整理的jar包清单如下: antlr-2.7.

Struts,Spring,Hibernate三大框架问题阐述

 有时候心里面知道,但未必能组织好语言来表述,累积一下如何来回答问题. 1.Hibernate工作原理及为什么要用? 工作原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory 为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码. 2. Hibernate是一个基于J

struts spring hibernate 三大框架实现基本的增删改查技术

/*struts.xml配置*/ 1 <?xml version="1.0" encoding="UTF-8" ?> 2 <!DOCTYPE struts PUBLIC 3 "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" 4 "http://struts.apache.org/dtds/struts-2.3.dtd">

Struts2+Spring+Hibernate 三大框架的合并集成

这次来看看Struts2+Spring+Hibernate三大框架的整合应用,主要是Spring和Hibernate框架的整合,因为前边已经将Strtus2+Spring整合过了基本一样.  首先看一下分工吧: Struts2做的MVC的流程框架,主要完成从客户端访问到选择action的过程,其中过滤器起到了Controller的作用,action属于model,而jsp则是view页面的展示. Spring主要利用Ioc的特长来管理各种对象:action,service,dao,数据访问源,H

用eclipse搭建SSH（struts+spring+hibernate）框架

Struts + Spring + Hibernate三者各自的特点都是什么? Struts 的MVC设计模式可以使我们的逻辑变得很清晰,主要负责表示层的显示. Spring 的IOC和AOP可以使我们的项目在最大限度上解藕. hibernate的就是实体对象的持久化了, 数据库的封装. 表现层.中间层(业务逻辑层)和数据服务层.三层体系将业务规则.数据访问及合法性校验等工作放在中间层处理.客户端不直接与数据库交互,而是通过组件与中间层建立连接,再由中间层与数据库交互. 表现层是传统的JSP技术