SSH搭建流程以及实现增删查改（整合）

最新推荐文章于 2024-04-30 19:21:07 发布

tian_xin_ke

最新推荐文章于 2024-04-30 19:21:07 发布

阅读量6.7k

点赞数 3

分类专栏： ssh框架搭建 mysql myeclipse jsp

本文链接：https://blog.csdn.net/tian_xin_ke/article/details/62057006

版权

ssh框架搭建同时被 3 个专栏收录

5 篇文章 0 订阅

订阅专栏

mysql

3 篇文章 0 订阅

订阅专栏

myeclipse

1 篇文章 0 订阅

订阅专栏

这篇博客是看了百度传课上面的ssh框架视频所记下的笔记。网址为：https://www.chuanke.com/v1982732-196856-1122330.html

首先说一下编程环境，我使用的工具如下：MyEclipse2013编程软件，开源免费的MySQL-5.0.22-win32数据库，服务器为Apache-Tomcat-7.0.57，以及数据库界面管理软件SQLyog10。
MyEclipse工程上传到服务器中：window->preferences->MyEclipse->Servers->Tomcat->Tomcat 7.x->浏览安装服务器Tomcat 7.x文件夹
数据库连接：将数据库连接驱动jar包：mysql-connector-java-5.1.6-bin.jar 放到WebRoot\WEB-INF\lib文件夹下，SQLyog10安装后，配置数据库相关参数，如下图：
注意几个参数
配置完这些，使用MyEclipse启动servers，可以在自己的电脑上登录http://localhost:8080/，验证服务器是否已启动

下面为整个搭建流程的文字版

1.加入Spring

1).加入jar包
2).配置web.xml
3).加入Spring的配置文件

2.加入Hibernate

1).同时建立持久化类，和其对应的，hbm.xml文件，生成对应的数据库
2).Spring整合Hibernate
3).步驟：

①.加入jar包
②.在类路径下加入hibernate.cfg.xml文件，在其中配置hibernate的基本属性
③.建立持久化类，和其对应的.hbm.xml文件
④.和Spring进行整合

i.加入c3p0和MySQL的驱动
ii.在Spring的配置文件中配置：数据源，SessionFactory，声明式事务

⑤.启动项目，会看到生成对应的数据表
3.加入Struts2

1).加入jar包：若有重复的jar包，则需要删除版本较低的
2).在web.xml文件中配置Struts2的Filter
3).加入Struts2的配置文件
4).整合Spring
①.加入Struts2的Spring插件的jar包
②.在Spring的配置文件中正常配置Action，注意Action的scope为prototype
③.在Struts2的配置文件中配置Action时，class属性指向该Action在IOC中的id


4.完成功能

1).获取所有的员工信息：若在Dao中只查询Employee的信息，而且Employee和Department还是使用的懒加载，页面上还需要显示
员工信息，此时会出现懒加载异常，代理对象不能被初始化
解决：
①.打开懒加载（不推荐使用）
②.获取Employee时使用迫切左外连接同时初始化其关联的Department对象
③.使用OpenSessionInviewFilter:直到页面加载完关闭Session，这样Session中存的数据表数据一直可以获取

2).删除员工信息
①.正常删除，返回值需要是redirect类型，而且重定向到emp-list
②.确定要删除吗？的提示使用jQuery完成
③.Ajax的使用参见struts-2.3.15.3-all/struts-2.3.15.3/docs/ww/docs/ajax.html

3).添加员工：
①.显示表单页面：需要先查询所有的部门信息
②.使用Struts2的ModelDriven和Preparable拦截器
③.时间是一个字符串，需要转为一个Date类型的对象

接下来一步步实现

第一步加入Spring

1.加入Spring

1).加入jar包
2).配置web.xml
3).加入Spring的配置文件

首先加入jar包，jar包放在WebRoot\WEB-INF\lib文件夹下
spring-jar包

配置web.xml代码如下

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_2_4.xsd"
  id="WebApp_ID"   version="2.4">
  <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:applicationContext*.xml</param-value>
  <!-- 多配置文件 applicationContext.xml 和applicationContext-beans.xml-->
  </context-param>

  <!-- 配置spring的listenner-->
  <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- 配置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>

这里要注意web-app_2_4.xsd id=”WebApp_ID” version=”2.4”，注意版本号，不能看别人项目里写的多少就是多少

加入Spring的配置文件：applicationContext.xml 和applicationContext-beans.xml
applicationContext.xml 导入资源文件db.properties，这里资源文件为数据库的参数信息，接下来配置数据源，则一一对应；配置SessionFactory，添加hibernate.cfg.xml文件路径，以及与数据库表对应的xx.hbm.xml文件；然后就是配置Spring的声明式事务，比较固定。 * com.atguigu.ssh.service..(..)是Service类路径下的方法
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:context="http://www.springframework.org/schema/context" 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.0.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 导入资源文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 配置C3P0数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        <property name="initialPoolSize" value="${jdbc.initialPoolSize}"></property>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
    </bean>

    <!-- 配置SessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configLocation" value="classpath:hibernate.cfg.xml" />
        <property name="mappingLocations" value="classpath:com/atguigu/ssh/entities/*.hbm.xml"></property>
    </bean>

    <!-- 配置Spring的声明式事务 -->
    <!-- 1.配置hibernate的事务管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    <!-- 2.配置事务属性 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="true" />
            <tx:method name="*" />
        </tx:attributes>
    </tx:advice>

    <!-- 3.配置事务切入点，再把事务属性和事务切入点关联起来 -->
    <aop:config>
        <aop:pointcut expression="execution(* com.atguigu.ssh.service.*.*(..))"
            id="txPointcut" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
    </aop:config>

</beans>

注意Spring版本为4，hibernate版本为4，以及beans标签中的属性tx,aop,context

其中加载的db.properties文件代码如下：

jdbc.user=root
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssh_2
jdbc.initialPoolSize=5
jdbc.maxPoolSize=10

这里注意数据库名为ssh_2

pplicationContext-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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <!-- Employee beans -->
    <bean id="employeeDao" class="com.atguigu.ssh.dao.EmployeeDao">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <bean id="employeeService" class="com.atguigu.ssh.service.EmployeeService">
        <property name="employeeDao" ref="employeeDao"></property>
    </bean>

    <!-- Department beans -->
    <bean id="departmentDao" class="com.atguigu.ssh.dao.DepartmentDao">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <bean id="departmentService" class="com.atguigu.ssh.service.DepartmentService">
        <property name="departmentDao" ref="departmentDao"></property>
    </bean>

    <!-- action -->
    <bean id="employeeAction" class="com.atguigu.ssh.actions.EmployeeAction"
    scope="prototype">
        <property name="employeeService" ref="employeeService"></property>
        <property name="departmentService" ref="departmentService"></property>

    </bean>

</beans>

一环扣一环，首先bean标签id=employeeAction响应Struts.xml中的action标签，其属性两个Service，由两个bean标签id=xxService响应，其各自属性即两个Dao，由两个bean标签id=xxDao响应，各自属性都为SessionFactory，用于传递数据库表数据

第二步加入Hibernate

1).同时建立持久化类，和其对应的，hbm.xml文件，生成对应的数据库
2).Spring整合Hibernate
3).步驟：

①.加入jar包
②.在类路径下加入hibernate.cfg.xml文件，在其中配置hibernate的基本属性
③.建立持久化类，和其对应的.hbm.xml文件
④.和Spring进行整合

i.加入c3p0和MySQL的驱动
ii.在Spring的配置文件中配置：数据源，SessionFactory，声明式事务

⑤.启动项目，会看到生成对应的数据表

加入jar包：
hibernate jar包

在类路径下加入hibernate.cfg.xml文件，在其中配置hibernate的基本属性
hibernate.cfg.xml文件代码如下：

<?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">
<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

    <session-factory>
    <!-- 配置hibernate的基本属性 -->

    <!-- 方言 -->
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

    <!-- 是否显示及格式化SQL -->
    <property name="hibernate.show_sql">true</property>
    <property name="hibernate.format_sql">true</property>

    <!-- 生成数据表的策略 -->
    <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>

</hibernate-configuration>

注意hibernate-configuration-3.0.dtd，其他版本会报错

建立持久化类，和其对应的.hbm.xml文件
两个表两个持久化类，两个.hbm.xml
Department.java，成员对应表中的两个属性

package com.atguigu.ssh.entities;

public class Department {

    private Integer id;
    private String departmentName;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getDepartmentName() {
        return departmentName;
    }
    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

}

Employee.java，成员对应表中的六个属性

package com.atguigu.ssh.entities;

import java.util.Date;

public class Employee {

    private Integer id;
    // 不能被修改
    private String lastName;
    private String email;
    // 从前端传入的是String类型，所以需要注意转换
    private Date birth;

    // 不能被修改
    private Date createTime;
    // 单向n-1的关联关系
    private Department department;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", lastName=" + lastName + ", email="
                + email + ", birth=" + birth + ", createTime=" + createTime
                + ", department.id=" + department.getId() + "]";
    }

}

Department.hbm.xml，table指数据库中的表SSH_DEPARTMENT，注意hibernate-mapping-3.0.dtd版本号

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping package="com.atguigu.ssh.entities">
    <class name="com.atguigu.ssh.entities.Department" table="SSH_DEPARTMENT">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="departmentName" type="java.lang.String">
            <column name="DEPARTMENT_NAME" />
        </property>
    </class>
</hibernate-mapping>

Employee.hbm.xml，table指数据库中的表SSH_EMPLOYEE，注意hibernate-mapping-3.0.dtd版本号，以及两个表关联键，左外键连接

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>
    <class name="com.atguigu.ssh.entities.Employee" table="SSH_EMPLOYEE">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="LastName" type="java.lang.String">
            <column name="LAST_NAME" />
        </property>
        <property name="email" type="java.lang.String">
            <column name="EMAIL" />
        </property>
        <property name="birth" type="java.util.Date">
            <column name="BIRTH" />
        </property>
        <property name="createTime" type="java.util.Date">
            <column name="CREATE_TIME" />
        </property>
        <!-- 映射单向n-1的关联关系 -->
        <many-to-one name="department" class="com.atguigu.ssh.entities.Department" >
        <!--  many-to-one name="department" class="com.atguigu.ssh.entities.Department" lazy="false"-->
        <!-- 关掉懒加载，查询语句可以为hql="FROM Employee，见EmployeeDao" -->
            <column name="DEPARTMENT_ID" />
        </many-to-one>
    </class>
</hibernate-mapping>

和Spring进行整合

i.加入c3p0和MySQL的驱动
ii.在Spring的配置文件中配置：数据源，SessionFactory，声明式事务

这在前面已经说过，c3p0-0.9.1.jar和mysql-connector-java-5.1.6-bin.jar

启动项目，会看到生成对应的数据表
这里是说启动服务器后，两个持久化类和对应的.hbm.xml会实现，数据库中会新建两个表

第三步加入Struts2

1).加入jar包：若有重复的jar包，则需要删除版本较低的
2).在web.xml文件中配置Struts2的Filter
3).加入Struts2的配置文件
4).整合Spring

加入jar包：若有重复的jar包，则需要删除版本较低的
Struts2_jar包
与之前要求导入的jar包如果名字相同，则会发生冲突，需要删除版本低的

在web.xml文件中配置Struts2的Filter
前面已经说过，固定声明

加入Struts2的配置文件
主要使用action标签响应网页来的超链接，并且与Spring配置文件联系，执行Action
Struts.xml代码如下：

<?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>
    <constant name="struts.devMode" value="false"></constant>

    <package name="default" namespace="/" extends="struts-default">
        <!-- 定义新的拦截器栈，配置prepare拦截器栈的alwaysInvokePrepare参数值为false -->
        <interceptors>
            <interceptor-stack name="sshStack">
                <!-- 不调用action中的prepare()方法 -->
                <interceptor-ref name="paramsPrepareParamsStack">
                    <param name="prepare.alwaysInvokePrepare">false</param>
                </interceptor-ref>
            </interceptor-stack>
        </interceptors>

        <!-- 使用新的拦截器栈 -->
        <default-interceptor-ref name="sshStack"></default-interceptor-ref>

        <action name="emp-*" class="employeeAction" method="{1}">
            <!-- emp-对应emp-list.jsp -->
            <result name="list">/WEB-INF/views/emp-list.jsp</result><!-- 显示全部员工信息 -->
            <!-- "list"对应EmployeeAction中的函数list()的返回值"list" -->
            <result name="delete" type="redirect">/emp-list</result>
            <result name="input">/WEB-INF/views/emp-input.jsp</result>
            <result name="success" type="redirect">/emp-list</result>
        </action>


    </package>
</struts>

注意struts-2.3.dtd版本号，result name=”*”和xxAction.java中的list(),delete(),input(),save()的返回值一一对应，一定要注意

整合Spring

①.加入Struts2的Spring插件的jar包
②.在Spring的配置文件中正常配置Action，注意Action的scope为prototype
③.在Struts2的配置文件中配置Action时，class属性指向该Action在IOC中的id

①Struts2的Spring插件的jar包为struts2-spring-plugin-2.2.1.jar
②③前面已说过，即web服务器运行时jsp从Struts经过Spring到JavaBean，JavaBean又经过Struts回到jsp

第四步完成功能

获取所有的员工信息：若在Dao中只查询Employee的信息，而且Employee和Department还是使用的懒加载，页面上还需要显示员工信息，此时会出现懒加载异常，代理对象不能被初始化

解决：
①.打开懒加载（不推荐使用）
②.获取Employee时使用迫切左外连接同时初始化其关联的Department对象
③.使用OpenSessionInviewFilter:直到页面加载完关闭Session，这样Session中存的数据表数据一直可以获取

①EmployeeDao.java中，

String hql = "FROM Employee";

Employee.hbm.xml中设置lazy=”false”

<many-to-one name="department" class="com.atguigu.ssh.entities.Department" lazy="false">

这样做会对表Department也调用了查询语句，不必要的操作

②①EmployeeDao.java中，

String hql = "FROM Employee e LEFT OUTER JOIN FETCH e.department";

Employee.hbm.xml中去掉lazy=”false”

<many-to-one name="department" class="com.atguigu.ssh.entities.Department">

这个明显比第一个方法好

③没有讲。。。

删除员工信息

①.正常删除，返回值需要是redirect类型，而且重定向到emp-list
②.确定要删除吗？的提示使用jQuery完成
③.Ajax的使用参见struts-2.3.15.3-all/struts-2.3.15.3/docs/ww/docs/ajax.html

①在Struts.xml中添加代码

<result name="delete" type="redirect">/emp-list</result><!-- 删除员工 -->

②使用onClick

<!-- 先执行onClick属性，若判断为yes，执行href跳转，否则什么都不做 -->
<a href="emp-delete?id=${id }" onClick='if (!confirm("请确认?")==1){return false;}'>Delete</a>

③没有讲。。。

添加员工：

①.显示表单页面：需要先查询所有的部门信息
②.使用Struts2的ModelDriven和Preparable拦截器
③.时间是一个字符串，需要转为一个Date类型的对象

①使用

<%@ page language="java" import="java.util.*" contentType="text/html;charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %><!-- 导入struts2的标签 -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
    <title>Insert title here</title>
  </head>

  <body>
    <h4>Employee input Page</h4>

    <s:form action="emp-save" method="post">
        <s:textfield name="lastName" label="LastName"></s:textfield>
        <s:textfield name="email" label="Email"></s:textfield>
        <s:textfield name="birth" label="Birth"></s:textfield>

        <s:select list="#request.departments"
            listKey="id" listValue="departmentName" name="department.id"
            label="Department"></s:select>
        <s:submit></s:submit>
    </s:form>
  </body>
</html>

②这里没有使用action实现的prepare()方法，所有需要重新设置拦截器，见Struts.xml
③使用DateFormat，添加xwork-convertion.properties文件和SSHDateConverter.java转换文件
xwork-convertion.properties代码如下：

java.util.Date=com.atguigu.ssh.converters.SSHDateConverter

SSHDateConverter.java代码如下：

package com.atguigu.ssh.converters;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;

import org.apache.struts2.util.StrutsTypeConverter;

public class SSHDateConverter extends StrutsTypeConverter {

    private DateFormat dateFormat;

    {
        dateFormat = new SimpleDateFormat("yyyy-MM-dd");//Date格式
    }

    @Override
    public Object convertFromString(Map arg0, String[] arg1, Class arg2) {
        // TODO Auto-generated method stub
        if(arg2 == Date.class){
            try {
                return dateFormat.parse(arg1[0]);//将字符串变为Date类型
            } catch (ParseException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public String convertToString(Map arg0, Object arg1) {
        // TODO Auto-generated method stub
        if(arg1 instanceof Date){
            return dateFormat.format((Date)arg1);//将Date类型变为字符串，以便输出
        }
        return null;
    }

}

其余文件代码如下：

首页文件index.jsp代码如下：

<%@ page language="java" import="java.util.*" contentType="text/html;charset=UTF-8" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
    <title>Insert title here</title>
  </head>

  <body>
    <a href="emp-list">list all Employees</a>

    <br><br>

    <a href="emp-input">add new Employee</a>

  </body>
</html>

查询信息jsp文件emp-list.jsp代码如下：

<%@ page language="java" import="java.util.*" contentType="text/html;charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %><!-- 导入struts2的标签 -->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
    <title>Insert title here</title>
  </head>

  <body>
    <h4>Employee List Page</h4>
    <s:if test="#request.employees.size()==0">
    没有任何员工信息
    </s:if>
    <s:elseif test="#request.employees.size()>0">
    <table border="1" cellpadding="10" cellspacing="0">
        <tr>
        <td>ID</td>
        <td>LASTNAME</td>
        <td>EMAIL</td>
        <td>BIRTH</td>
        <td>CREATETIME</td>
        <td>DEPT</td>
        <td>DELETE</td>
        </tr>
        <s:iterator value="#request.employees">
        <!-- 对应EmployeeAction中的Map<"employees",List<Employee>>request -->
        <tr><!-- 对应Employee类的6个成员变量 -->
        <td>${id }</td><!-- el表达式，在 JSP 中简化表达式的方法，让Jsp的代码更加简化。 -->
        <td>${lastName }</td>
        <td>${email }</td>
        <!--  <td>${birth }</td>-->
        <td>
            <s:date name="birth" format="yyyy-MM-dd"/>
        </td>
        <td>${createTime }</td>
        <td>${department.departmentName }</td>
        <td> 
        <!-- 先执行onClick属性，若判断为yes，执行href跳转，否则什么都不做 -->
        <a href="emp-delete?id=${id }" onClick='if (!confirm("请确认?")==1){return false;}'>Delete</a>
        </td>
        </tr>
        </s:iterator>
    </table>
    </s:elseif>
  </body>
</html>

Service文件代码如下：
EmployeeService.java代码如下：

package com.atguigu.ssh.service;

import java.util.List;

import com.atguigu.ssh.dao.EmployeeDao;
import com.atguigu.ssh.entities.Employee;

public class EmployeeService {

    private EmployeeDao employeeDao;

    public void setEmployeeDao(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }

    public void delete(Integer id){
        this.employeeDao.delete(id);
    }

    public List<Employee> getAll(){
        //List<Employee> products= employeeDao.getAll();

        //return products;
        List<Employee> employees= employeeDao.getAll();
        //如果员工信息为空会怎么样？
        //employees.clear();
        int size=employees.size();
        System.out.println(size);
        return employees;
        //return employeeDao.getAll();
    }

    public void saveOrUpdate(Employee employee){
        employeeDao.saveOrUpdate(employee);
    }

}

DepartmentService.java代码如下：

package com.atguigu.ssh.service;

import java.util.List;

import com.atguigu.ssh.dao.DepartmentDao;
import com.atguigu.ssh.entities.Department;

public class DepartmentService {

    private DepartmentDao departmentDao;

    public void setDepartmentDao(DepartmentDao departmentDao) {
        this.departmentDao = departmentDao;
    }

    public List<Department> getAll(){
        return departmentDao.getAll();
    }

}

Dao文件代码如下：
BaseDao.java如下：

package com.atguigu.ssh.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class BaseDao {

private SessionFactory sessionFactory;

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    public Session getSession() {
        return this.sessionFactory.getCurrentSession();
    }

}

DepartmentDao.java代码如下：

package com.atguigu.ssh.dao;

import java.util.List;

import com.atguigu.ssh.entities.Department;

public class DepartmentDao extends BaseDao{

    public List<Department> getAll(){
        String hql= "FROM Department";
        return getSession().createQuery(hql).list();
    }

}

EmployeeDao.java代码如下：

package com.atguigu.ssh.dao;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.atguigu.ssh.entities.Employee;

//public class EmployeeDao extends HibernateTemplate{//Spring3
public class EmployeeDao extends BaseDao{

    public void delete(Integer id){
        String hql="DELETE FROM Employee e WHERE e.id=?";
        getSession().createQuery(hql).setInteger(0, id).executeUpdate();
    }

    public  List<Employee> getAll(){

        //第一种方法，HQL的左外键连接抓取，对其进行重载，如果不加的话会丢失数据
        String hql = "FROM Employee e LEFT OUTER JOIN FETCH e.department";
        //String hql = "FROM Employee";
        //return  (List<Employee>) find("FROM Employee");
        List<Employee> le =getSession().createQuery(hql).list();
        int size=le.size();
        for(int i=0; i<size;i++){
            System.out.println(le.get(i).getLastName());

        }

        /*
        //第二种方法，打开懒加载，见Employee.hbm.xml文件，这个时候对表Department也调用了查询语句
        String hql = "FROM Employee";
        */
        return getSession().createQuery(hql).list();
    }

    public void saveOrUpdate(Employee employee){
        getSession().saveOrUpdate(employee);
    }

}

EmployeeAction.java代码如下：

package com.atguigu.ssh.actions;

import java.util.Date;
import java.util.Map;

import org.apache.struts2.interceptor.RequestAware;

import com.atguigu.ssh.entities.Employee;
import com.atguigu.ssh.service.DepartmentService;
import com.atguigu.ssh.service.EmployeeService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import com.opensymphony.xwork2.Preparable;

public class EmployeeAction extends ActionSupport implements RequestAware,
ModelDriven<Employee>,Preparable{

    private static final long serialVersionUID = 1L;

    private EmployeeService employeeService;
    //List<Employee> employees;

    public void setEmployeeService(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    private DepartmentService departmentService;

    public void setDepartmentService(DepartmentService departmentService) {
        this.departmentService = departmentService;
    }

    private Map<String, Object> request;

    public void setRequest(Map<String, Object> arg0) {
        this.request = arg0;
    }

    public String list(){
        //employees = employeeService.getAll();
        request.put("employees", employeeService.getAll());
        return "list";//对应Struts.xml配置文件中action标签中result name="list"
    }

    private Integer id;

    public void setId(Integer id) {
        this.id = id;
    }
    public String delete(){
        employeeService.delete(id);
        return "delete";//对应Struts.xml配置文件中action标签中result name="success"
    }

    public String input(){
        request.put("departments", departmentService.getAll());
        return "input";
    }

    public void prepare() throws Exception{}

    private Employee model;

    public Employee getModel(){
        return model;
    }

    public String save(){
        //System.out.println(model);
        model.setCreateTime(new Date());//获取当前时间作为添加的新员工时间
        employeeService.saveOrUpdate(model);
        return "success";
    }

    public void prepareSave(){
        model = new Employee();
    }
}

tian_xin_ke

关注

3
点赞
踩
22

收藏

觉得还不错? 一键收藏
1
评论
SSH搭建流程以及实现增删查改（整合）

这篇博客是看了百度传课上面的ssh框架视频所记下的笔记。网址为：https://www.chuanke.com/v1982732-196856-1122330.html首先说一下编程环境，我使用的工具如下：MyEclipse2013编程软件，开源免费的MySQL-5.0.22-win32数据库，服务器为Apache-Tomcat-7.0.57，以及数据库界面管理软件SQLyog10。
复制链接

扫一扫