SSH框架的基础使用

最新推荐文章于 2022-04-20 21:27:10 发布
最新推荐文章于 2022-04-20 21:27:10 发布
阅读量373 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36833590/article/details/78088930
版权

1.首先创建一个web项目,导入jar包。这里没使用maven,所有的jar包都是自己添加的,有点多,当时后续的项目都会用到的。下面是资源地址,大家可下载.

http://download.csdn.net/download/qq_36833590/9994890

2.配置web.xml

<?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>OnlineMealSys</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.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>Struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
</web-app>

3.配置spring的配置文件application.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/demo"></property>
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="username" value="root"></property>
		<property name="password" value="a"></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/yc/bean/Users.hbm.xml</value>
			</list>
		</property>
	</bean>

	<!-- 开启注解扫描 -->
	<context:component-scan base-package="com.yc"></context:component-scan>
</beans>
4.然后就是写数据库脚本(mySql) 

create database demo;

use dome;

create table users(
    uid  int primary key auto_increment,
    username varchar(20),
    password varchar(20)
)
5.创建一个package(com.yc.bean)和与之对应的实体类(Users.java) 
package com.yc.bean;

import java.io.Serializable;

/**
 * 用户实体类
 * @author 梁祥
 *
 */
public class Users implements Serializable{
	
	private static final long serialVersionUID = 1L;
	
	private Integer uid;	//用户id
	private String username;	//用户名
	private String password;	//密码
	
	public Users(Integer uid, String username, String password) {
		super();
		this.uid = uid;
		this.username = username;
		this.password = password;
	}

	public Users() {
		super();
	}

	public Integer getUid() {
		return uid;
	}

	public void setUid(Integer uid) {
		this.uid = uid;
	}

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

	@Override
	public String toString() {
		return "Users [uid=" + uid + ", username=" + username + ", password=" + password + "]";
	}
	
}

6.配置实体类的hibernate映射文件(Users.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.yc.bean.Users" table="users" dynamic-update="true" catalog="demo">
		<id name="uid" type="java.lang.Integer" column="uid">
			<generator class="identity"></generator>
		</id>
		<property name="username" type="string" column="username"></property>
		<property name="password" type="string" column="password"></property>
	</class>
</hibernate-mapping>

7.为了方便使用,编写一个Session的工具类(SessionUtil.java)

package com.yc.utils;

import javax.annotation.Resource;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Service;

/**
 * 获取session工具类
 * @author 梁祥
 *
 */
@Service
public class SessionUtil {
	private SessionFactory sessionFactory;

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	/**
	 * 注入sessionFactory
	 * 
	 * @param sessionFactory
	 */
	@Resource
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	/**
	 * 获取session
	 * 
	 * @return
	 */
	public Session getSession() {
		return sessionFactory.getCurrentSession();
	}
}


8.Dao持久层接口 

package com.yc.dao;

import org.springframework.stereotype.Controller;

import com.yc.bean.Users;

/**
 * 用户操作接口
 * @author 梁祥
 *
 */
@Controller
public interface UsersDao {
	
	/**
	 * 注册操作
	 * @param user
	 * @return
	 */
	boolean reg(Users user);

	/**
	 * 登录操作
	 * @param user
	 * @return
	 */
	Users login(Users user);
	
	/**
	 * 修改该密码
	 * @param user
	 * @param newPwd
	 * @return
	 */
	boolean updatePwd(Users user,String newPwd);
	
	/**
	 * 用户销毁
	 * @param user
	 * @return
	 */
	boolean deleteUser(Users user);
}

9.接口实现 

package com.yc.dao.impl;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;

import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.stereotype.Repository;

import com.yc.bean.Users;
import com.yc.dao.UsersDao;
import com.yc.utils.SessionUtil;

@Repository
public class UserDaoImpl implements UsersDao {

	@Resource
	private SessionUtil sessionUtil;

	@Override
	public boolean reg(Users user) {
		if (user != null) {
			try {
				Session session = sessionUtil.getSession();
				// 判断用户名是否存在
				Query query = session.createQuery("select username from Users where username = ?").setString(0,
						user.getUsername());
				query.setCacheable(true);
				if (query.uniqueResult() != null) {
					return false;
				}
				session.beginTransaction();
				session.save(user);
				session.getTransaction().commit();
				return true;
			} catch (Exception e) {
				e.printStackTrace();
				return false;
			}
		}
		return false;
	}

	@Override
	public Users login(Users user) {
		if (user != null) {
			try {
				Session session = sessionUtil.getSession();
				// 查询用户
				Query query = session.createQuery("from Users where username = ? and password = ?");
				query.setCacheable(true);
				query.setString(0, user.getUsername());
				query.setString(1, user.getPassword());
				return (Users) query.list().get(0);
			} catch (Exception e) {
				e.printStackTrace();
				return null;
			}
		}
		return null;
	}

	@Override
	public boolean updatePwd(Users user, String newPwd) {
		if (null != user && !"".equals(newPwd) && null != newPwd) {
			Session session = sessionUtil.getSession();
			try {
				Query query = session.createQuery("update Users set password = ? where uid = ? and password = ?");
				query.setString(0, newPwd);
				query.setInteger(1, user.getUid());
				query.setString(2, user.getPassword());
				query.executeUpdate();
				return true;
			} catch (Exception e) {
				e.printStackTrace();
				return false;
			} finally {
				session.close();
			}
		}
		return false;
	}

	@Override
	public boolean deleteUser(Users user) {
		if(null != user){
			Session session = sessionUtil.getSession();
			try {
				Query query = session.createQuery("delete from Users where uid = ?");
				query.setInteger(0, user.getUid());
				query.executeUpdate();
				return true;
			} catch (Exception e) {
				e.printStackTrace();
				return false;
			} finally {
				session.close();
			}
		}
		return false;
	}

}

10.控制器action 

package com.yc.action;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.springframework.web.context.ServletContextAware;

import com.opensymphony.xwork2.ActionSupport;

/**
 * 基础action
 * @author xiang
 *
 */
public class BaseAction extends ActionSupport implements ServletContextAware,
ServletRequestAware, ServletResponseAware {

private static final long serialVersionUID = -2778286744226080905L;

protected HttpServletRequest request;
protected HttpServletResponse response;
protected HttpSession session;
protected ServletContext application;

@Override
public void setServletResponse(HttpServletResponse response) {
    this.response = response;
}

@Override
public void setServletRequest(HttpServletRequest request) {
    this.request = request;
    this.session = this.request.getSession();
    
}

@Override
public void setServletContext(ServletContext application) {
    this.application = application;
}

}


package com.yc.action;


import javax.annotation.Resource;
import javax.servlet.http.HttpSession;


import org.springframework.stereotype.Controller;


import com.yc.bean.Users;
import com.yc.dao.UsersDao;


/**
 * 用户操作控制器
 * @author 梁祥
 *
 */
@Controller
public class UsersAction extends BaseAction{
	
	@Resource
	private UsersDao usersDao;
	
	private String username;
	private String password;
	private String newPwd;


	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 String getNewPwd() {
		return newPwd;
	}


	public void setNewPwd(String newPwd) {
		this.newPwd = newPwd;
	}


	/**
	 * 注册控制
	 * @return
	 */
	public String reg(){
		Users user = new Users();
		user.setUsername(username);
		user.setPassword(password);
		if(usersDao.reg(user)){
			return "success";
		}
		return "error";
	}
	
	/**
	 * 登录控制
	 * @return
	 */
	public String login(){
		Users user = new Users();
		user.setUsername(username);
		user.setPassword(password);
		user = usersDao.login(user);
		if(null != user){
			session.setAttribute("user", user);
			return "success";
		}
		return "error";
	}
	
	/**
	 * 修改密码控制
	 * @param session
	 * @return
	 */
	public String updatePwd(){
		Users user = (Users) session.getAttribute("user");
		if( null != user){
			if(usersDao.updatePwd(user, newPwd)){
				return "success";
			}else{
				return "error";
			}
		}
		return "error";
	}
	
	/**
	 * 用户删除
	 * @return
	 */
	public String deleteUser(){
		Users user = (Users) session.getAttribute("user");
		if( null != user){
			if(usersDao.deleteUser(user)){
				return "success";
			}else{
				return "error";
			}
		}
		return "error";
	}
}

11.配置struts.xml

<?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编码配置 -->
<constant name="struts.i18n.encoding" value="utf-8"></constant>

<!-- 页面跳转控制 -->
<package name="page" extends="struts-default" namespace="/">
<action name="toReg" class="com.yc.action.PageAction" method="toReg">
<result name="success">page/reg.jsp</result>
</action>
</package>

<!-- 用户操作 -->
<package name="user" extends="struts-default" namespace="/">

<!-- 登录 -->
<action name="login" class="com.yc.action.UsersAction" method="login">
<result name="success">page/info.jsp</result>
<result name="error">page/login.jsp</result>
</action> 

<!-- 注册 -->
<action name="reg" class="com.yc.action.UsersAction" method="reg">
<result name="success">page/login.jsp</result>
<result name="error">page/reg.jsp</result>
</action>

<!-- 修改密码 -->
<action name="updatePwd" class="com.yc.action.UsersAction" method="updatePwd">
<result name="success">page/login.jsp</result>
<result name="error">page/info.jsp</result>
</action>

<!-- 修改密码 -->
<action name="deleteUser" class="com.yc.action.UsersAction" method="deleteUser">
<result name="success">page/reg.jsp</result>
<result name="error">page/info.jsp</result>
</action>
</package>
</struts>


12.剩下的就是前端页面的代码了,大家自行完成吧,form表单的action要和struts.xml中的<action>标签的name属性值一一对应(a标签的href也是)

Little Xcum
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【Linux系统基础快速入门详解】SSH远程连接必备网络基础知识详解
走向CTO的路上...
06-02 660
TCP/IP协议是一种可靠的通信协议，它将数据分成小块进行传输，并在传输过程中进行错误检测和校正，保证数据的完整性和可靠性。在SSH远程连接中，需要知道目标计算机的IP地址，才能进行远程连接。SSH远程连接需要了解一些必备的网络基础知识，包括IP地址、端口号、网络协议、网络拓扑、防火墙和SSH密钥认证等。掌握这些知识可以帮助你更好地理解SSH远程连接的原理和使用方法，提高SSH远程连接的安全性和效率。在SSH远程连接中，需要知道目标计算机所在的网络拓扑，以便确定网络连接方式和网络延迟。
SSH框架基础版本
08-13
在SSH框架基础上进行开发，通常需要以下步骤： 1. **环境配置**：首先确保开发环境正确，包括安装Eclipse集成开发环境，设置JDK1.8及以上版本，以及配置Tomcat7.0服务器和MySql5.0数据库。 2. **项目创建**：在...
SSH框架基础
weixin_30262255的博客
06-23 143
首先，SSH不是一个框架，而是多个框架（struts+spring+hibernate）的集成，是目前较流行的一种Web应用程序开源集成框架，用于构建灵活、易于扩展的多层Web应用程序。 集成SSH框架的系统从职责上分为四层：表示层、业务逻辑层、数据持久层和域模块层（实体层）。 Struts作为系统的整体基础架构，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用H...
使用SSH框架的步骤
u013602859的博客
01-11 1320
1.创建Maven项目 2. 在pom.xml文件中写入spring，struts，hibernate的依赖 org.apache.struts struts2-core 2.3.14 javassist javassist
使用ssh框架写一个基本的登录注册页面
热门推荐
lylyyg的专栏
07-17 4万+
基于ssh框架的一个简单的登录注册页面，注册页面使用Ajax和jQuery检测用户名与注册邮箱。
SSH框架入门知识总结
weixin_33845881的博客
12-17 125
chap01 领略清晰的MVC流程----Struts讲解技术资料.pdf 提取码：wwi5 chap02 体验控制反转的理念----Spring介绍技术文档.pdf 提取码：0mp3 chap03 感悟Hibernate操作数据的方便技术资料.pdf 提取码：10fb chap04 SSH互整合技术资料.pdf 提取码：ulie 转载于:https://www.cnblo...
ssh框架基础jar
09-21
SSH框架是Java Web开发中广泛使用的三大开源框架的组合，分别是Struts2、Spring和Hibernate。这些框架分别负责表现层、业务逻辑层和服务层的管理，极大地提高了开发效率和代码的可维护性。 Struts2作为MVC（Model-...
SSH框架搭建源码
10-19
SSH框架，全称为Struts2、Spring和Hibernate的组合，是Java Web开发中常见的三大开源框架集成。这个压缩包文件"SSHdemo"提供了一个SSH框架搭建登录功能的示例，帮助开发者了解并实践如何整合这三个框架来构建一个...
ssh框架搭建基础项目
08-04
hibernate整合的一个基础项目，在eclipse中将此项目导入，并打开项目中的applicationContext.xml文件，根据自己的数据库(Mysql)来进行相关修改，保存后在tomcat8中运行即可，进入...
ssh基础框架
06-10
总结，SSH框架的使用大大提高了Java Web开发的效率和可维护性。通过理解并掌握SSH，开发者可以更好地组织项目结构，实现松耦合的代码设计，同时享受到各框架带来的便捷性。在实际项目中，可以根据需求选择Spring ...
简单ssh框架（适合开发及初学者了解ssh框架）
11-09
struts2 + hibernate + spring 简单的SSH2框架实现代码,供初学者学习，了解ssh2框架及搭建流程。
SSH原理，strusts,hebernate,Spring等相关知识
06-21
SSH框架知识-原理。其中包括strusts原理,hebernate原理,Spring的原理，以及为什么要用他们，AOP和IOC。getAttribute 和 getParameter 的区别
SSH框架知识总结
05-21
文档详细介绍了SSH框架技术的应用，本人会每天更新技术知识。
SSH基础知识
学习印记 Learning imprint
08-12 1734
从逻辑角度，系统可以分成客户端，web服务器，应用服务器，数据库服务器四层。 应用服务器可以扩充       Servlet技术（执行过程）：1.客户想web容器（如tomcat）发送HTTP请求 2.容器装入Servlet，Servlet一直保留在内存中，只到容器卸载它（tomcat停止运行） 3.web容器吧HTTP请求信息发送给Servlet，给每个用户请求创建一个新的线程。4.Servl
SSH三大框架搭建（非常之基础）
Xgx120413的专栏
10-02 6453
这是一个简单的SSH完整的配置流程，希望大家能耐心看下去并操作，个人觉得非常之详细了！
SSH框架总结
咕咕怪的博客
09-02 5131
传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的 JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用符号嵌入很多的 Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密...
Java 三大框架——SSH框架应用简介
jianyi7659的专栏
07-01 3万+
JAVA三大框架用来做WEN应用。struts主要负责表示层的显示 spring利用它的IOC和AOP来处理控制业务（负责对数据库的操作） hibernate主要是数据的持久化到数据库  在用jsp的servlet做网页开发的时候有个web.xml的映射文件，里面有个mapping的标签就是用来做文件映射的。 当你在浏览器上输入URL地址的时候，文件就会根据你写的名称对应到
Linux入门学习——ssh基础操作
ZJJ_5346的博客
10-23 1162
接下来的学习中我们就会需要用到两个虚拟机互相的互动，如果想让两个不同的主机能相互连接互动的话，首先就需要调整两个主机的ip地址，那什么是ip呢，ip也叫网络之间互联的协议。也就是为计算机网络相互连接进行通信而设计的协议。在因特网中，它是能使连接到网上的所有计算机网络实现相互通信的一套规则，规定了计算机在因特网上进行通信时应当遵守的规则。任何厂家生产的计算机系统，只要遵守IP协议就可以与因特网互连互
SSH框架的搭建及应用
qq_45429856的博客
04-20 1574
SSH框架的搭建及应用 一、创建maven程序，引入依赖 struts-core、apache-commons-fileupload，struts-convention.plugin poi、poi-ooxml spring-context、sprng-jdbc、spring-tx、spring-context-suport、aspectjweaver spring-web、struts2-spring-plugin hibernate-core、mysql、 spring-orm druid <?x
ssh框架搭建教程.doc
最新发布
12-01
ssh框架搭建教程.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值