精华内容
下载资源
问答
  • 基于SSH框架的完整项目排班系统

    热门讨论 2010-09-07 11:44:57
    SSH完整项目排班系统源码带注释SSH完整项目排班系统源码带注释SSH完整项目排班系统源码带注释SSH完整项目排班系统源码带注释SSH完整项目排班系统源码带注释SSH完整项目排班系统源码带注释SSH完整项目排班系统源码带...
  • 这是在大学毕业时候做的毕业设计,是基于ssh框架的javaweb项目。是基于jsp的网上调查问卷生成系统。使用的是bs架构。里面包含数据库表与项目的源码。还有自己当时写的毕业论文。可以用于大四学生的计算机毕设参考。...
  • 基于SSH框架的在线考试系统

    万次阅读 2019-05-25 00:37:12
    基于SSH框架的在线考试系统 ,使用bootstrap作为前端框架 项目描述 基于SSH框架的在线考试系统 ,使用bootstrap作为前端框架,分页是自己分装的bean. 有以下功能 学生登录和教师登录 学生端: 学生在线考试 成绩查询 ...

    基于SSH框架的在线考试系统 ,使用bootstrap作为前端框架

    项目描述
    基于SSH框架的在线考试系统 ,使用bootstrap作为前端框架,分页是自己分装的bean. 有以下功能 学生登录和教师登录

    学生端: 学生在线考试 成绩查询 修改密码 退出系统
    教师端:考生信息管理 考生成绩管理 试卷管理 题目管理 退出系统

    运行环境
    jdk7+tomcat7/8+mysql+eclipse

    项目技术
    spring+Struts2+Hibernate+bootstrap+jquery

    请添加图片描述

    请添加图片描述
    请添加图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    链接:http://www.xuluowuhen.com/article/1574931692

    展开全文
  • java基于ssh框架实现旅游系统项目 使用技术:struts2,spring,hibrnate、mysql、jq、js、css,百度编译器,jqueryUI等 功能:旅游路线展示和查询、酒店入住、酒店管理、人文管理、发布驴友活动等 部分截图如下: ...

    java基于ssh框架实现的旅游系统项目
    使用技术:struts2,spring,hibrnate、mysql、jq、js、css,百度编译器,jqueryUI等

    功能:旅游路线展示和查询、酒店入住、酒店管理、人文管理、发布驴友活动等

    部分截图如下:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    有想学习参考的可以私我

    展开全文
  • 本资源为基于ssh框架的"网上订餐系统",内涵项目源码,数据库表文件,所需各种jar包以及项目部署说明.
  • 基于ssh框架+MySQL图书管理系统 包含项目的数据库sql文件
  • 本资源为基于ssh框架的"网上银行系统",内涵项目源码,数据库表文件,所需各种jar包以及项目部署说明.
  • 本资源为基于ssh框架的"新闻发布系统",内涵项目源码,数据库表文件,所需各种jar包以及项目部署说明.
  • 项目介绍:基于ssh框架的网上书店的设计与实现 项目功能:购书者能随时掌握书籍的最新动向,从而在第一时间了解新书的信息,完成购物车和订单管理功能。 源代码+数据库Mysql
  • 基于SSH框架微博系统毕业项目 论文12000 前台页面很漂亮 有说明文档 有录屏和PPT mysql数据库
  • 项目基于ssh三大主流框架技术实现对用户信息管理与维护。
  • 系统基于spring,springmvc和hibernate框架的考勤管理系统,开发软件用的是eclipse,数据库用的是mysql,压缩包里包含项目源码和数据库,需要的可以下载下来。
  • 基于SSH框架微博系统毕业项目 论文12000 前台页面很漂亮 有说明文档 有录屏和PPT mysql数据库
  • 基于ssh的项目系统

    2012-10-29 19:00:04
    基于SSH框架完整项目代码,可以很好学习SSH
  • 项目使用struts2、hibernate和spring实现对员工信息管理web开发增删改查操作
  • 基于 SSH 框架的学生选课系统

    千次阅读 热门讨论 2018-07-11 12:02:09
    个人博客地址:稍后更新 github 地址:稍后更新 项目开发环境 Spring 5.0.6.RELEASE Struts 2.5.16 Hibernate 5.3.0.Final ...项目概述 ... 该项目采用前后端分离技术,前端使用 ... 后端使用 SSH 框架开发,返回 ...
    
    
    
    
    

    项目开发环境

    • Spring 5.0.6.RELEASE
    • Struts 2.5.16
    • Hibernate 5.3.0.Final
    • LayUI
    • jQuery 3.3.1

    项目概述

    该项目采用前后端分离技术,前端使用 LayUI 以及 JQuery,跨域请求后端 Rest API;
    后端使用 SSH 框架开发,返回 JSON 数据给请求。
    项目主要实现 1. 学生选课退课、查询本学期课表;2. 教师查询本学期课程、本学期课表;3. 管理员添加学生和教师信息、添加本学期排课情况、关闭|开放选课系统
    项目核心考虑业务包括:1. 学生选课:该课程是否被选过、该门课程是否已选、该时间段是否有课;2. 管理员添加课程:选择课程授课老师后,仅显示该教师的空余时间供管理员进行选择

    功能模块描述

    管理员

    教职工管理

    • 教职工信息查询与管理:允许管理员进行教职工信息的查询与删除
      教职工信息查询与管理

    • 添加教职工:添加教职工信息
      添加教职工

    学生管理

    • 学生信息查询与管理:允许管理员进行学生信息的查询与删除
    • 添加学生:添加学生信息

    班级管理

    • 班级信息查询与管理:允许管理员进行班级信息的查询与删除
    • 添加班级:添加班级信息

    课程管理

    • 课程信息查询与管理:允许管理员进行课程信息的查询与删除
    • 添加课程:添加课程信息

    系统设置

    • 允许管理员对选课中心进行开放和关闭
      系统设置

    学生

    课程中心

    选课中心:在选课系统开放期间,允许学生进行选课;

    系统会对该学生的已选课程进行判断,将会隐藏某门已选课程,并禁选时间冲突的课程

    选课中心

    已选课程:允许学生查看已选课程,并进行退选操作
    已选课程

    课表查询:允许学生查看本学期课表
    课表查询

    修改密码

    • 学生可以对自己的密码进行修改

    教师

    教师功能同学生类似

    展开全文
  • 1,该系统使用SSH三大框架实现,Struts2主要用于流程控制、Spring控制反转能起到解耦合作用、Hibernate是一个优秀ORM框架主要用于数据持久化 2,登录模块分为三种角色业务员、研究员、管理员 业务员:主要负责...
  • Eclipse搭建SSH框架搭建教程  注意:本项目为博主初学Web开发时所写,所使用方法都比较笨,不符合主流开发方法。例如,包管理应该使用Maven进行管理而不是手动导入,对前端后端代码架构也并不是很清晰。大家...

    Eclipse搭建SSH框架搭建教程

     注意:本项目为博主初学Web开发时所写,所使用的方法都比较笨,不符合主流开发方法。例如,包管理应该使用Maven进行管理而不是手动导入,对前端后端代码的架构也并不是很清晰。大家学习思想即可,可以不用浪费时间在将这个项目跑起来。目前主流的技术应当是Spring+SpringMVC+Mybatis的SSM框架,配合Shiro做权限控制,Redis做缓存,也可以学习SpringBoot开发微服务。由于本博主已经保研,较少接触开发,故此项目也不再进行维护。

    前期环境准备:

    ①   Java环镜

    ②   Eclipse4.6.2

    ③   Tomcat8.5

    ④   Struts2.3.41

    ⑤   Spring4.2.4

    ⑥   Hibernate4.3.11

    ⑦   mysql-5.6.35-winx64

    ⑧   Mysql-connector-java-5.1.26

    ⑨   Navicat for MySQL

    其中①②③可以参照http://www.cnblogs.com/oucbl/p/5928511.html。

    对于SSH框架的搭建,本人主要是参照http://blog.csdn.net/eson_15/article/details/51277324这篇博客来搭建的框架,其中的④⑤⑥⑦可以在里面下载到。

     

     

    SSH框架各自的作用:

    在开始搭建框架之前,先整体讲一下SSH框架各自的用途。首先是Struts框架,众所周知,一个网页有着各种各样的请求,比如注册账号,登录账号等请求,通过配置Struts框架,这些请求都会被拦截,由我们分配的Action进行处理,然后再根据我们的配置文件来进行转发。其次是Hibernate框架,它实现了数据库表与javabean的一一对应,使我们能够通过操纵类来操纵数据库。最后是Spring框架,它实现了SSH框架之间的解耦,通过配置文件,我们可以实现依赖注入。比如我有一个类A,其中有一个成员是类B,那么使用之前我们都需要先得到这个类的一个实例,正常情况下我们是通过new来实现。但是,使用了Spring框架之后,我们就可以通过配置文件将B依赖注入进A,在使用时不用管这个类的创建,只负责使用,大大方便了开发。可以说Spring框架就是SSH框架中的粘合剂,掌管着里面各个类。

     

    开始搭建

     

    首先附上项目目录结构图

     

     

    第一步:新建项目

    新建一个Dynamic Web Project项目。然后右键点击项目-Properties-Java Build Path,将默认输出路径调整到项目目录下的WEB-INF/classes。(之后会解释)

     

     

    第二步:搭建Struts框架

    ①   进入WEB-INF中的lib,把struts所需jar包复制进来,之后右键项目刷新。(之后每次在eclipse之外的操作都要刷新项目,不再重复)

    ②   修改WEB-INF目录下的web.xml如下:

     

    <?xml version="1.0"encoding="UTF-8"?>
       <web-appxmlns: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>S2SH</display-name>
     
       <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.jsp</welcome-file>
       </welcome-file-list>
       <listener> 
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
        </listener>
    </web-app>

     

     

     

     

     

    ③   新建一个TestAction类进行Struts框架的测试

     

    package com.blog.action;
    importcom.opensymphony.xwork2.ActionSupport;
     
    public class TestAction extendsActionSupport{
           publicString execute() throws Exception{
                  System.out.println("Struts2测试成功!!");
                  return"success";
           }
    }

     

     

     

    ④   在src目录下,新建struts.xml,内容如下:

     

    <?xml version="1.0"encoding="UTF-8" ?>
       <!DOCTYPE struts PUBLIC
               "-//Apache Software Foundation//DTD Struts Configuration2.0//EN"
               "http://struts.apache.org/dtds/struts-2.0.dtd">
     
       <struts>
           <package name="default"extends="struts-default">
               <action name="login" class="com.blog.action.TestAction">//类的目录
                      <resultname="success">/index.jsp</result>
                  </action>
           </package>
       </struts>
     

     

     

     

     

     

    ⑤   在WebContent下新建index.jsp,之后都利用这个页面来检测。

     

    <%@ page language="java"contentType="text/html; charset=UTF-8"
       pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTDHTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <metahttp-equiv="Content-Type" content="text/html; UTF-8">
    <title>Insert titlehere</title>
    </head>
    <body>
           <ahref="login.action">访问save</a>
    </body>
    </html>

     

     

     

     

     

    总结:

    解释一下在这里struts框架的作用。在Web.xml配置了之后,所有符合/*的链接都会被Struts框架中的org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter拦截链接,根据struts.xml的配置来进行转发,这里我们是转发到com.blog.action.TestAction这个类的public String execute()来处理,根据返回的String来转发网页。在struts中的配置有一个<resultname="success">/index.jsp</result>,即如果返回了success,就跳到/index.jsp这个网页。这是struts的一个用途。

     

     

     

    第三步:搭建Spring框架并且组合Struts框架

    ①   将Spring所需jar包拉进lib中。

    ②   在web.xml添加如下内容:

     

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

     

    ③   在src目录下新建一个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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx-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" >
           <bean id="date" class="java.util.Date" />
           <bean id="TestAction"class="com.blog.action.TestAction"scope="prototype"> 
           <property name="date" ref="date" />
           </bean>
    </beans> 

     

     

     

    ④   将struts中对应的class交给spring来管理,class后面的内容改为applicationContext.xml对应bean的id。

     

    <action name="login"class="TestAction">
            <result name="success">/index.jsp</result>
     </action>

    ⑤   将TestAction改为

     

    package com.blog.action;
    import java.util.Date;
    import org.hibernate.HibernateException;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    importorg.hibernate.boot.registry.StandardServiceRegistryBuilder;
    importorg.hibernate.boot.registry.internal.StandardServiceRegistryImpl;
    import org.hibernate.cfg.Configuration;
    importorg.hibernate.service.ServiceRegistry;
    importcom.opensymphony.xwork2.ActionSupport;
    public class TestAction extendsActionSupport{
           privateDate date;
           publicvoid setDate(Date date){
                  this.date=date;
           }
           publicDate getDate(){
                  returndate;
           }
           publicString execute() throws Exception{
                  System.out.println("Struts2测试成功!!");
                  System.out.println("Spring测试:目前时间是:"+date);
                  return"success";
           }
    }

     

     

     

    总结:

    解释一下Spring框架在这里的作用。Spring框架利用IOC的思想,减少了框架之间的耦合程度。比如,在TestAction中,我并没有对date进行new操作就直接使用,而是利用配置文件,在“无形之中”完成了date的创建。首先我们在web.xml配置spring框架的监听器,并且让程序一开始就读取spirng框架的配置文件。

     

    <context-param> 
       <param-name>contextConfigLocation</param-name> 
       <param-value>classpath:applicationContext.xml</param-value> 
    </context-param> 

     

    这一段中的classpath:指的就是WEB-INF-classes这个路径。它会到这个路径下寻找applicationContext.xml并读取。在配置文件中

     

    <bean id="date"class="java.util.Date" />
    <bean id="TestAction"class="com.blog.action.TestAction"scope="prototype"> 
    <property name="date"ref="date" />
    </bean>

    其实就完成了对date的创建,这个仔细琢磨一下应该能看懂。

    由于我们使用spring来管理类的创建,所以struts 中action的class也改为ApplicationContext.xml中对应bean的id。

     

    第四步,搭建Hibernate环境

    ①   将hibernate框架及数据库连接所需要用的jar包拉进lib中。

    ②   这里我们先使用到Navicat来完成对数据库的创建。

     

    ③   接下来创建Dao层,DaoImpl层,以及bean层。

     

    package com.blog.dao;
    import org.hibernate.HibernateException;
    import org.hibernate.Session;
    public interface BaseDao { 
       public void saveObject(Object obj) throws HibernateException; 
       public Session getSession(); 
       public void setSession(Session session); 
    } 
     
    package com.blog.daoImpl;
    import org.hibernate.HibernateException;
    import org.hibernate.Session;
    import com.blog.dao.BaseDao;
    public class UserDao implements BaseDao{ 
       private Session session; 
       @Override 
       public Session getSession() { 
            return session; 
       } 
       @Override 
       public void setSession(Session session) { 
           this.session = session; 
       } 
       @Override 
       public void saveObject(Object obj) throws HibernateException { 
           session.save(obj); 
        } 
    } 
    public class User {
           privateString username;
           privateString password;
           privateInteger id;
           publicString getUsername() {
                  returnusername;
           }
           publicvoid setUsername(String username) {
                  this.username= username;
           }
     
           publicString getPassword() {
                  returnpassword;
           }
     
           publicvoid setPassword(String password) {
                  this.password= password;
           }
           publicvoid setId(Integer id){
                  this.id=id;
           }
           publicInteger getId(){
                  returnid;
           }
    }

     

     

     

    ③   在src目录下新建hibernate.cfg.xml和User.hbm.xml。

    Hibernate.cfg.xml内容如下:

     

    <?xml version="1.0"encoding="UTF-8"?>
    <!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate ConfigurationDTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
       <session-factory>
            <!-- 各属性的配置-->
           <!-- 为true表示将Hibernate发送给数据库的sql显示出来 -->
           <property name="show_sql">true</property>
           <!-- SQL方言,这边设定的是MySQL -->
           <propertyname="dialect">org.hibernate.dialect.MySQLDialect</property>
           
           <!-- 一次读的数据库记录数 -->
           <property name="jdbc.fetch_size">50</property>
           
           <!-- 设定对数据库进行批量删除 -->
           <property name="jdbc.batch_size">23</property>
           
           <!--驱动程序-->
           <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
           
           <!-- JDBC URL -->
           <propertyname="connection.url">jdbc:mysql://localhost/mankind</property>
           
           <!-- 数据库用户名-->
           <propertyname="connection.username">root</property>
           
           <!-- 数据库密码-->
           <propertyname="connection.password">123456</property>
            <!--数据库连接池的大小-->  
           <property name="hibernate.connection.pool.size">20</property> 
           <!--是否在后台显示Hibernate用到的SQL语句,开发时设置为true,便于差错,程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false,提高运行效率-->  
           <property name="hibernate.show_sql">true</property>  
           <!--jdbc.use_scrollable_resultset是否允许Hibernate用JDBC的可滚动的结果集。对分页的结果集。对分页时的设置非常有帮助-->  
           <property name="jdbc.use_scrollable_resultset">false</property>  
           <!--connection.useUnicode连接数据库时是否使用Unicode编码-->  
           <property name="Connection.useUnicode">true</property> 
           <!--connection.characterEncoding连接数据库时数据的传输字符集编码方式,最好设置为gbk,用gb2312有的字符不全-->
           <property name="connection.characterEncoding">gbk</property> 
           <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->  
           <propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  
           <!--指定映射文件为“hibernate/ch1/UserInfo.hbm.xml”-->         
           <mapping resource="User.hbm.xml"/>  
       </session-factory>
    </hibernate-configuration>

    User.hbm.xml内容如下:

     

    <?xml version="1.0"encoding='UTF-8'?> 
    <!DOCTYPE hibernate-mapping PUBLIC 
                                "-//Hibernate/HibernateMapping DTD 3.0//EN" 
                               "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
     
    <hibernate-mappingpackage="com.blog.beans"> 
       <class name="User" table="user"> 
           <id name="id" column="id"> 
                <generatorclass="native"></generator> 
           </id> 
           <property name="username" column="username"type="java.lang.String"  />
           <property name="password" column="password"type="java.lang.String"  />
       </class> 
    </hibernate-mapping> 
     

     

     

     

    ④   TestAction内容更改如下:

     

    package com.blog.action;
    import java.util.Date;
    import org.hibernate.HibernateException;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.Transaction;
    import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
    importorg.hibernate.boot.registry.internal.StandardServiceRegistryImpl;
    import org.hibernate.cfg.Configuration;
    importorg.hibernate.service.ServiceRegistry;
    import com.blog.beans.User;
    import com.blog.dao.BaseDao;
    import com.blog.daoImpl.UserDao;
    importcom.opensymphony.xwork2.ActionSupport;
    import sun.security.timestamp.TSRequest;
    public class TestAction extendsActionSupport{
           privateDate date;
           privatestatic Configuration configuration = null;
           privatestatic SessionFactory sessionFactory = null;
           privatestatic ServiceRegistry serviceRegistry = null;
           publicvoid setDate(Date date){
                  this.date=date;
           }
           publicDate getDate(){
                  returndate;
           }
           publicString execute() throws Exception{
                  System.out.println("Struts2测试成功!!");
                  System.out.println("Spring测试:目前时间是:"+date);
                   try {
                          Configuration configuration = newConfiguration().configure();
                         //以下这两句是4.3的新用法
                         StandardServiceRegistryBuilderbuilder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());
                         StandardServiceRegistryImplregistry = (StandardServiceRegistryImpl) builder.build();
                         SessionFactorysessionFactory = configuration.buildSessionFactory(registry);
                         Sessionsession = sessionFactory.openSession();
                         Transactiontx = session.beginTransaction();
                         Useruser=new User();
                         //user.setId(1);
                         user.setUsername("MK");
                         user.setPassword("123456");
                         BaseDaodao=new UserDao();
                         dao.setSession(session);
                         dao.saveObject(user);
                         tx.commit();
                         session.close();
                          } catch (HibernateException e) {
                           e.printStackTrace();
                          }
                  return"success";
           }
    }

     

    总结:

    到这里已经完成了Hibernate框架的搭建。Hibernate的思路如下,使用一个bean类,将java的基本数据与数据库中表的数据一一对应起来,比如这里的User类,属性中有id,username,password,分别对应数据表中的id,username和password,他们是一一对应的关系。并且在这里所有的属性都要设置set和get方法。那么hibernate框架通过什么来完成这种转换呢?在这里便是通过user.hbm.xml来实现。

     

       <class name="User" table="user"> 
           <id name="id" column="id"> 
                <generatorclass="native"></generator> 
           </id> 
           <property name="username" column="username"type="java.lang.String"  />
           <property name="password" column="password"type="java.lang.String"  />
       </class> 

    name对应java中的字段,column对应数据库中的字段,通过这样的配置。Hibernate配置文件hibernate.cfg.xml中配置了账号,密码,数据库方言之类的数据库基本信息,同时通过<mapping resource="User.hbm.xml"/>来指定映射文件,即我们前面说的user与数据库中user表之间的映射关系通过User.hbm.xml就可以找到。

     

     

    第五步:完成Hibernate与Spring框架的整合。

    ①   在applicationContext.xml中配置dataSource、sessionFactory、transactionManager。

     

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
               <property name="driverClass" value="com.mysql.jdbc.Driver"/> 
               <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mankind"/> 
               <property name="user" value="root"/> 
               <property name="password" value="123456"/> 
                  </bean> 
                  <beanid="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> 
                       <property name="dataSource" ref="dataSource"/> 
                       <property name="configLocation"value="classpath:hibernate.cfg.xml" /> <!-- 加载hibernate配置文件 --> 
                  </bean> 
            <bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager"> 
                     <property name="sessionFactory"ref="sessionFactory" /> 
                  </bean> 
                  <tx:adviceid="advice" transaction-manager="transactionManager"> 
                      <tx:attributes> 
                          <tx:method name="save*" propagation="REQUIRED"/> 
                          <tx:method name="update*" propagation="REQUIRED"/> 
                          <tx:method name="delete*" propagation="REQUIRED"/> 
                          <tx:method name="*" propagation="SUPPORTS"/> 
                      </tx:attributes> 
                  </tx:advice> 
                  <aop:config> 
               <!-- 配置哪些包的类要切入事务 --> 
               <aop:pointcut id="pointcut" expression="execution(*com.blog.daoImpl.*.*(..))" /> 
               <aop:advisor advice-ref="advice"pointcut-ref="pointcut"/><!-- 连接了上面的advice和上面的pointcut --> 
               <!-- aop:pointcut要写在aop:advisor上面,否则会报错 --> 
            </aop:config>

     

     

     

    ②   由于在applicationContext.xml中配置了DataSource,可以删除hibernate.cfg.xml中相对应的四项(driverClass,jdbcURL,user,password)。其余的不用删,因为我们在spring中引用了hibernate.cfg.xml。

    ③   修改BaseDao

     

    public interface BaseDao { 
        publicvoid saveObject(Object obj) throws HibernateException; 
    } 

    ④   修改UserDao

     

    public class UserDao implements BaseDao {
           privateSessionFactory sessionFactory;
            //当需要使用sessoinFactory的时候,Spring会将sessionFactory注入进来 
        publicvoid setSessionFactory(SessionFactory sessionFactory) { 
           this.sessionFactory = sessionFactory; 
        }   
        protectedSession getSession() { 
           //从当前线程获取session,如果没有则创建一个新的session 
           return sessionFactory.getCurrentSession(); 
        } 
        publicvoid saveObject(Object obj) throws HibernateException { 
           getSession().save(obj);
        }
    }

     

     

     

    ⑤   修改TestAction

     

    public class TestAction extends ActionSupport{
           privateDate date;
           privateBaseDao userDao;
           publicvoid setDate(Date date){
                  this.date=date;
           }
           publicDate getDate(){
                  returndate;
           }
           publicvoid setUserDao(BaseDao userDao){
                  this.userDao=userDao;
           }
           publicBaseDao getUserDao(){
                  returnuserDao;
           }
           publicString execute() throws Exception{
                  System.out.println("Struts2测试成功!!");
                  System.out.println("Spring测试:目前时间是:"+date);
                   try {
                         Useruser=new User();
                         user.setUsername("MK");
                         user.setPassword("123456");
                         userDao.saveObject(user);
                          } catch (HibernateException e) {
                           e.printStackTrace();
                          }
                  return"success";
           }

     

    ⑥   修改applicationContext.xml,依赖注入TestAction和UserDao

     

    <bean id="userDao" class="com.blog.daoImpl.UserDao"> 
               <property name="sessionFactory"ref="sessionFactory" /> 
    </bean> 
    <bean id="date" class="java.util.Date"/>
    <bean id="TestAction" class="com.blog.action.TestAction"scope="prototype"> 
             <property name="date" ref="date"/>
             <property name="userDao" ref="userDao"/>
    </bean>

     

     

     

    总结:

    很明显,在Hibernate和Spring整合之前,我们在TestAction中需要写很长很长的代码来获得Session,整合之后,代码量大大减少。需要注意的地方是,Spring是针对接口来编程的,在TestAactoin中,userDao不能声明为userDao类型,而是应该声明为它的接口BaseDao,否则会报错。这个坑了我几个小时的时间..

    框架到这里就差不多都打通了,剩下的地方再根据需要改一改就可以开始开发了。

     

     

    ----------------------------------------------------------------------------

    本项目下载地址:

    github:https://github.com/SCAUMankind/SSHBlogSystem

    展开全文
  • 本资源为基于ssh框架的"网上订餐系统",内涵项目源码,数据库表文件,所需各种jar包以及项目部署说明.
  • 基于SSH框架的在线考试系统 ,使用bootstrap作为前端框架,分页是自己分装的bean. 有以下功能 学生登录和教师登录 学生端: 学生在线考试 成绩查询 修改密码 退出系统 教师端:考生信息管理 考生成绩管理 试卷管理 ...
  • 如何实现基于ssh框架的投票系统的的质量属性: 项目 :网上考试系统 我做的是网上考试系统,因为标准化的考试越来越重要,而通过计算机进行标准化判卷,系统会自动判卷出成绩,组织考试的人不用组织人员打印试卷了...
  • 使用MyEclipse+MySql开发,系统包括首页,首页中显示当前商品,系统具有用户登录、用户注册功能,对于管理员可以发布商品,修改、...系统采用javaweb语言jsp为开发制作而成,基于B/S模式,以Myeclipse为开发平台,my
  • 提出了一种简单易行的基于数据表元数据的代码自动生成方法,可以在MIS系统开发之初,自动生成所有数据库实体对象的增、删、改、查功能的实现代码,给用户构造一个基于SSH框架的可运行原型.基于代码生成系统,设计人员可...
  • 针对于中小型商贸企业资源管理系统,是企业内部使用综合信息管理服务平台。企业数据以WEB形式采集录入系统,经过收集汇总后,为各级终端用户提供日常业务信息管理、业务流程执行等日常办公服务...
  • 项目是作者当时花费了3个多月时间完成.在此拿出来给大家分享,请珍惜作者劳动成果,用心研读! JEEBBS最新版本采用hibernate3+spring mvc+spring3+freemarker技术架构,重新设计了jeebbs,重新架构后JEEBBS...
  • 基于ssh框架的员工管理系统

    千次阅读 2019-04-14 23:57:16
    前台页面及功能: 1.注册员工,管理员(默认为未审核状态,由后台管理员审核后则成为真正员工和管理员) 2.员工登录(登录后进入...项目结构: 导包: 主要代码: web.xml <?xml version="1....
  • Flex+Java 基于SSH框架 用户管理系统 java作为后台提供服务 Flex作为表示层实现增删改查,登陆,模糊查询,分页等基本功能 采用注解注解方式配置Java flex项目位置\Page\src\flex_app 请将服务器配置修改为自己...
  • 最近一个实验课程,需要做一个基于SSH框架的学生成绩管理系统。就简简单单做了一下…… 文章目录1. 要求原文1.1 实验要求:1.2 实验目的:1.3 实验思路:1.4 实验步骤:2. 项目实现2.1 技术栈与开发环境2.2 项目...
  • 使用myeclipse来开发的项目,压缩包中包括了,数据库,设计文档以及项目源代码。。作品十分简陋 简陋 简陋 重要事情说三遍,初学作品,仅作参考。有任何问题欢迎提出,我会热心帮忙

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 419
精华内容 167
关键字:

基于ssh框架的系统项目