struts+spring+hibernate登录功能包括简单增删改查

于 2017-09-24 13:32:01 发布
阅读量181 收藏
点赞数
文章标签： java 数据库 开发工具
原文链接：https://yq.aliyun.com/articles/552601
版权

初识struts和hibernate很多东西都不是很懂呀，跟着网上的资源实现就简单的增删改查，其中hibernate的hql不是很会用，之前是在学习mybatis，现在一和hibernate对比，让我深深感觉mybatis的好呀！嘻嘻，其实都差不多，好了，直接正文吧！

整体功能：学生注册，登录，修改密码，注销。包揽了增删改查。
项目使用maven创建，不用麻烦在WEB-INF的lib目录下手动放那么多jar包…

如果你的eclipse没有maven插件，请先安装以及一系列的配置，不要嫌麻烦！程序员嘛！不折腾会死的！！

1. 创建maven工程
maven创建

创建好maven工程后如果报错（提示缺失文件夹）这个时候按照此方法解决。
错误解决
选择项目，单机右键最后一个功能为Properties 重新选择JRE即可。

创建好后目录结构是这样的，请忽略我的那个红xx，项目没问题，应该是eclipse的某个设置导致提示错误，晚点解决
目录结构

2. pom.xml 加入依赖我们所需要的jar包！

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.wy</groupId>
  <artifactId>Struct</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>Struct Maven Webapp</name>
  <url>http://maven.apache.org</url>

    <!-- Spring版本控制 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.3.11.RELEASE</spring.version>
    </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-core</artifactId>
        <version>2.5.2</version>
    </dependency>
    <!-- 数据库 https://mvnrepository.com/artifact/commons-dbcp/commons-dbcp -->
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.2.2</version>
    </dependency>
    <!-- spring  https://mvnrepository.com/artifact/org.springframework/spring-orm -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>4.3.11.RELEASE</version>
    </dependency>

    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.3.11.RELEASE</version>
    </dependency>
    <dependency>
            <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
            <version>4.3.11.RELEASE</version>
     </dependency>
    <!-- mysql数据库的驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.38</version>
    </dependency>
    <!-- spring对jdbc的支持包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!--  hibernate  https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.2.10.Final</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.2.10.Final</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.hibernate.common/hibernate-commons-annotations -->
    <dependency>
        <groupId>org.hibernate.common</groupId>
        <artifactId>hibernate-commons-annotations</artifactId>
        <version>5.0.1.Final</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.struts/struts2-spring-plugin -->
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-spring-plugin</artifactId>
        <version>2.5.12</version>
    </dependency>
    <!-- servlet 包，上线后不要，因为 tomcat的lib中自带有, 所以要配置 scope为provided -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
        <!-- spring容器 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

  </dependencies>
  <build>
    <finalName>Struct</finalName>
  </build>
</project>

3.配置web.xml文件
需要配置Struts前端控制器 ，这样才能被struts拦截，由struts处理一系列请求。
加上使用了spring，配置tomcat开启时,加载Spring配置文件，还有一个延迟加载的过滤
这个不清楚具体做什么的网上说能保持对象在使用前session为打开状态 具体请搜索吧。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns: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_3_0.xsd"
    version="3.0">
  <display-name>Archetype Created Web Application</display-name>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <!-- tomcat开启时,加载Spring配置文件 -->
    <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>

    <!-- 延迟加载的过滤 ,必须设置在前端控制器之前 -->
    <!-- 能保持对象在使用前session为打开状态 -->
    <filter>
        <filter-name>OpenSessionView</filter-name>
        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
        <init-param>
            <param-name>flushMode</param-name>
            <param-value>AUTO</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>OpenSessionView</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


    <!-- 配置Struts前端控制器 -->
    <filter>
        <filter-name>Struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>Struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

4. 配置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:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"
    default-lazy-init="true">

    <!-- 数据源的配置 -->
    <bean id="ds" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/struts"></property>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- sessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="ds">
        </property>
        <!-- hibernate配置信息 -->
        <property name="hibernateProperties">
            <props>

                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.formate_sql">false</prop>

            </props>
        </property>
        <property name="mappingResources">
            <list>
                <value>com/struts/bean/Student.hbm.xml</value>
            </list>
        </property>
    </bean>

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com"></context:component-scan>

    <!-- 声明式事务管理,采用AOP切入 -->
    <bean id="txManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <!-- 定义事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

</beans>

5. 数据库设计
使用的mysql。一个简单的登录功能，只需要简单的表设计就OK

create table student(
    id int primary key auto_increment,
    name varchar(10),
    pwd varchar(10)
)

6. 实体类的编写

package com.struts.bean;

import java.io.Serializable;
import com.opensymphony.xwork2.ActionSupport;

public class Student implements Serializable {  //这个实现Serializable 接口可以不用，但是大型上线    项目应该都会有
    private static final long serialVersionUID = 3449928115491130878L;

    private Integer id;
    private String name;
    private String pwd;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

}

实体类对应的hbm.xml配置文件Student.hbm.xml 

<?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">
<!-- Generated 2016-11-26 16:32:02 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
        <!-- 配置实体类和表的关系-->
    <class name="com.struts.bean.Student" table="student">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" /> 
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="pwd" type="java.lang.String">
            <column name="PWD" />
        </property>
    </class>
</hibernate-mapping>

7.dao层的编写

package com.struts.dao;

import com.struts.bean.Student;
public interface StudentDao {
    //用户登录
    public Student login(Student student);
    //注册
    public boolean register(Student student);
    //判断用户是否存在
    public boolean isExist(Student student);
    //根据用户名修改密码
    public void updatePwdByName(Student student);
    //根据用户名删除用户
    public void delStudentByName(Student student);
}

dao层的实现 daoImpl

package com.struts.dao.impl;

import java.util.List;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.query.Query;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import com.struts.bean.Student;
import com.struts.dao.StudentDao;
import com.struts.utils.SessionUtil;

@Repository
public class StudentDaoImpl implements StudentDao {

    @Resource(name="sessionUtil")
    private SessionUtil sessionUtil;

    //登录
    @Override
    public Student login(Student student) {
        if(student==null) {
            return null;
        }
        try{
            //创建session对象
            Session session = sessionUtil.getSession();
            Query query = session.createQuery("from Student where name = ? and pwd = ?");
            query.setCacheable(true);
            query.setString(0,student.getName());
            query.setString(1,student.getPwd());
            List list = query.list();
            return  (Student) (list!=null&&list.size()>0?list.get(0):null); 
            /**
             *TODO:直接使用这句，当用户名密码不正确的时候回报错
             * //(Student) query.list().get(0);
             */
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;

    }

    //判断用户是否存在
    @Override
    public boolean isExist(Student student) {
        if(student==null) {
            return false;
        }
        try{
            //创建session对象
            Session session = sessionUtil.getSession();
            //首先判断用户是否存在
            Query query = session.createQuery("from Student where name = ?");
            query.setCacheable(true);
            query.setString(0,student.getName());
            List list = query.list();
            if(  (list!=null&&list.size()>0)) {
                return true;
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return false;
    }

    //注册
    @Override
    public boolean register(Student student) {
        if(student==null) {
            return false;
        }
        try{
            //创建session对象
            Session session = sessionUtil.getSession();
            Query query = session.createSQLQuery("insert into student(name,pwd) values(?,?)").addEntity(Student.class);       //createQuery("from Student where name = ? and pwd = ?");
            query.setCacheable(true);
            query.setString(0,student.getName());
            query.setString(1,student.getPwd());
            session.save(student);
            return true;
        }catch(Exception e){
            e.printStackTrace();
        }
        return false;
    }

    //根据用户名修改密码
    @Override
    public void updatePwdByName(Student student) {
        try{
            //创建session对象
            Session session = sessionUtil.getSession();
            //事物处理
            Transaction tran = session.beginTransaction();
//          session.beginTransaction().commit(); 如果直接用这句但是不用下面这句
//          session.beginTransaction(); //   则报 Transaction not successfully started  使用这两句没用...
            Query query = session.createSQLQuery("update Student set pwd=? where name=? ").addEntity(Student.class); 
            query.setCacheable(true);
            query.setString(0,student.getPwd());
            query.setString(1,student.getName());
            query.executeUpdate();
            tran.commit();

            session.close();
        }catch(Exception e){
            e.printStackTrace();
        }

    }

    //根据用户名删除该用户
    @Override
    @Transactional
    public void delStudentByName(Student student) {
        try{
            //创建session对象
            Session session = sessionUtil.getSession();
            //事物处理
            Transaction tran = session.beginTransaction();
            //查询
            Query query = session.createSQLQuery("delete from student where name=? ").addEntity(Student.class);
            query.setCacheable(true);
            query.setString(0,student.getName());
            query.executeUpdate();
            tran.commit();
            session.close();
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("删除失败！请检查代码！");
        }

    }

}

8.业务层action只说一个例子，登录 具体请看GitHub上的代码

package com.struts.action;

import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import org.apache.struts2.interceptor.RequestAware;
import org.apache.struts2.interceptor.SessionAware;
import org.springframework.stereotype.Controller;
import com.opensymphony.xwork2.ActionSupport;
import com.struts.bean.Student;
import com.struts.dao.StudentDao;
import com.struts.dao.impl.StudentDaoImpl;
import freemarker.template.utility.Execute;

@Controller
public class LoginAction extends ActionSupport   {  // extends ActionSupport  区别 implements RequestAware  SessionAware

    private static final long serialVersionUID = -531893540665347994L;
    @Resource
    private StudentDao sdDao = new StudentDaoImpl();
    private Student student;
    private String name;
    private String pwd;

    public String Login() {
        //先判断该用户名是否存在
        Student stu = new Student();
        stu.setName(name);
        stu.setPwd(pwd);
        Student s = sdDao.login(stu);
        if(s!=null) {
            return "success";
        }
        return "error";

    }


    public Student getStudent() {
        return student;
    }
    public void setStudent(Student student) {
        this.student = student;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

}

9.获取session的工具类

package com.struts.utils;

import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Service;

@Service
public class SessionUtil {
    private SessionFactory sessionFactory;
    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    @Resource
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    public Session getSession() {
        return sessionFactory.getCurrentSession();
    }
}

10.配置strutsxml就可以搞事情啦

<?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>
    <!--  
          在struts.xml文件中可以使用<constant>标记来对default.properties中的常量属性做覆盖性配置，最常更改的几个常量属性是：  
        1.struts.i18n.encoding=UTF-8：请求消息的编码方式  
        2.struts.action.extension=action：指定被struts2处理的请求后缀类型。多个用逗号隔开。如：action,do,go  
        3.struts.configuration.xml.reload=false：当struts.xml改动后，是否重新加载。默认值为false(生产环境下使用),开发阶段最好打开  
        4.struts.devMode=false：是否使用struts的开发模式。开发模式会有更多的调试信息。默认值为false(生产环境下使用),开发阶段最好打开  
        5.struts.serve.static.browserCache=true：设置浏览器是否缓存静态内容。默认值为true(生产环境下使用),开发阶段最好关闭。  
        6.struts.objectFactory=spring：指定由spring负责action对象的创建  
        7.struts.enable.SlashesInActionNames=false：启用Action的name是否支持斜线(/)  
        8.struts.enable.DynamicMethodInvocation=false：启用动态方法调用  
        9.struts.ui.theme=simple：UI主题类型  
    -->  
    <constant name="struts.devMode" value="true"></constant>  
    <constant name="struts.i18n.encoding" value="UTF-8"></constant> 
    <constant name="struts.locale" value="zh_CN"></constant> 

    <!-- Struts2以package形式管理Action的配置 -->  
    <!--  
        package常用的属性：  
        1.name：包名，作为被其它包引用的标识。必须的。实际应用中，应该把一组业务功能相关的Action放在同一个包下。  
        2.extends：指定要扩展的包名。一般会继承自struts-default包。struts-default包是struts2内置的，它定义了struts2内部的众多拦截器和Result类型。  
        3.namespace：指定名称空间。Struts2中Action的请求URI映射由namespace和action名称两部分组成。如果不指定该属性，默认的命名空间为""（空字符串）。  
        4.abstract：声明包为抽象的。抽象包中不能配置action。  
    -->  
    <package name="mytest" extends="struts-default"  namespace="/">
        <action name="loginAction" class="com.struts.action.LoginAction" method="Login"> 
             <result name="success">/success.jsp</result>  
             <result name="error" >/index.jsp</result>  <!-- 重定向type="redirectAction"如果加上这句则会调跳转到index.jsp.action -->
        </action>

        <action name="registerAction" class="com.struts.action.RegisterAction" method="Register"> 
             <result name="success">/index.jsp</result>  
             <result name="error" >/register.jsp</result>  <!-- 重定向type="redirectAction"如果加上这句则会调跳转到index.jsp.action -->
        </action>

        <action name="updatePwdByNameAction" class="com.struts.action.UpdatePwdByNameAction" method="UpdatePwdByName"> 
             <result name="success">/index.jsp</result>  
        </action>

        <action name="destroyAction" class="com.struts.action.DestroyAction" method="Destroy"> 
             <result name="success">/index.jsp</result>  
        </action>

        <action name="isExistAction" class="com.struts.action.IsExistAction" method="isExist"> 
        </action>

        <action name="loginIsExistAction" class="com.struts.action.IsExistAction" method="LoginIsExist"> 
        </action>

    </package>

</struts>

在登录和注册时使用了ajax判断用户是否存在，提高用户体验，这就是这几条折腾出来的东西…
GitHub地址：https://github.com/Danielpengsh/struts

weixin_34198881
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值