从0到1搭建一个SSH+mysql框架的用户管理系统（只有登录、用户增删改查功能）

最新推荐文章于 2023-08-17 11:42:52 发布

anmu4200

最新推荐文章于 2023-08-17 11:42:52 发布

阅读量860

点赞数 2

分类专栏： java系统文章标签： ssh java mysql

本文链接：https://blog.csdn.net/anmu4200/article/details/118712693

版权

java系统专栏收录该内容

78 篇文章 7 订阅

订阅专栏

博客目录

基于SSH框架的单模块用户管理系统

基于SSH框架的单模块用户管理系统

学习SSH框架有两个难点：
1、从0到1搭建SSH框架，各种配置比较头疼
2、好多同学为了学习框架，下载了好多SSH的系统，但是功能太复杂，难以看到框架的核心东西
基于上面两点，我将功能点简化，只留下登录、用户管理模块（增删改查），让大家可以将重点放在SSH框架本身上来，更容易去研究和学会SSH框架。

详细搭建流程（三大配置）

首先分析SSH框架的技术点：
我们知道SSH分别指的是：Structs2、Spring、Hibernate,所以我们搭建框架时候主要是写这三方面的配置文件。
那么这三个技术点的关系是什么呢，我们从MVC架构的角度来看：
在这里插入图片描述
structs2主要是位于控制器层，来处理前后端请求的交互
Hibernate位于数据持久化层，来处理数据库的连接和持久化操作
Spring位于最外部的一个管家的位置，它主要是来管理所有的javabeans，管理它们的生命周期整个过程

以上概念不理解也没关系，下面直接开始搭建框架。

1、（创建空白的项目，这一步就略过了）

2、Structs2配置文件：

在项目的src目录下创建一个structs.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="json-default">
           <action name="login" class="TestAction">
                  <result name="success">/index.jsp</result>
           </action>
           
           <action name="user_*" class="UserAction" method="{1}">
        		<result name="success">/main.jsp</result>
        		<result name="jsonMap" type="json">
				<param name="root">jsonMap</param>
				</result>
        	</action>
           
           <action name="check_*" class="CheckAction" method="{1}">
        		<result name="success">/userinfo.html</result>
        		<result name="jsonMap" type="json">
				<param name="root">jsonMap</param>
				</result>
        	</action>
       </package>
   </struts>

这个structs.xml配置文件中，主要是将controller层的action类注册在这里，并且将Action类返回结果与前端的jsp或者html绑定。（注意：我这里是用了json类型，所以多个了返回类型为jsonMap）

2、hibernate.cfg.xml配置文件（hibernate配置文件）

<?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 -->
       <property name="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 -->
       <!--<property name="connection.url">jdbc:mysql://localhost/test2</property>-->
       
       <!-- 数据库用户名-->
       <!--<property name="connection.username">root</property>-->
       
       <!-- 数据库密码-->
       <!--<property name="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">utf-8</property> 
       <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->  
       <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  
       <!--指定映射文件为“hibernate/ch1/UserInfo.hbm.xml”-->         
       <mapping resource="User.hbm.xml"/>
   </session-factory>
</hibernate-configuration>

hibernate…cfg.xml配置文件，它的后缀格式大家不用去纠结，因为从官网上下载hibernate的压缩包里，后缀就是.cfg.xml的。主要是分析这个框架相对于我们的jdbc有什么区别，hibernate告别了jdbc方式手动连接数据库，操作数据库语句的方式，通过配置数据的连接参数、数据库表的映射文件，可以实现全自动的数据库sql处理。（这个就是说我们不用自己写sql，增删改查直接调用hibernate框架给我们封装的方法既可）

下面我们看下，这个配置文件中引用的User表的映射文件：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-mapping package="com.code2life.ssh.entity"> 
   <class name="User" table="user"> 
       <id name="id" column="id">
            <generator class="native"></generator> 
       </id> 
       <property name="user_name" column="user_name" type="java.lang.String"  />
       <property name="pass_word" column="pass_word" type="java.lang.String"  />
       <property name="real_name" column="real_name" type="java.lang.String"  />
       <property name="age" column="age" type="java.lang.Integer"  />
       <property name="role" column="role" type="java.lang.Integer"  />
   </class> 
</hibernate-mapping>

没错，我们可以看到，user.hbm.xml（hbm其实全写是hibernate mapping, 即为hibernate映射）只是将数据库字段与我们的实体类进行了一个一对一的映射。

3、Spring配置文件：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.xsd" >


       <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/framedemo"/> 
           <property name="user" value="root"/> 
           <property name="password" value=""/>
       </bean>
       
       <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> 
           <property name="dataSource" ref="dataSource"/> 
           <property name="configLocation" value="classpath:hibernate.cfg.xml"/> <!-- 加载hibernate配置文件 --> 
       </bean>
       
       
       <bean id="userDao" class="com.code2life.ssh.dao.impl.UserDao"> 
           <property name="sessionFactory" ref="sessionFactory"/> 
       </bean> 
       
       <bean id="baseService" class="com.code2life.ssh.service.impl.BaseServiceImpl" lazy-init="true">  
     		<property name="sessionFactory" ref="sessionFactory" />  
		</bean> 
       
       <bean id="userService" class="com.code2life.ssh.service.impl.UserServiceImpl" parent="baseService">  
			<property name="userDao" ref="userDao" /> 
		</bean>
		
       <bean id="date" class="java.util.Date"/>
       
       <bean id="TestAction" class="com.code2life.ssh.action.TestAction" scope="prototype"> 
         <property name="date" ref="date"/>
         <property name="userDao" ref="userDao"/>
       </bean>
            
       <bean id="UserAction" class="com.code2life.ssh.action.UserAction" scope="prototype">  
	        <property name="userService" ref="userService" />
        </bean>
        
        <bean id="CheckAction" class="com.code2life.ssh.action.CheckAction" scope="prototype">  
	        <property name="userService" ref="userService" />
        </bean>
        
       <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> 
           <property name="sessionFactory" ref="sessionFactory" /> 
       </bean> 
         
       <tx:advice id="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="get*" propagation="REQUIRED"/> 
		        <tx:method name="load*" propagation="REQUIRED"/> 
		        <tx:method name="*" propagation="SUPPORTS"/>  
		   </tx:attributes>
	   </tx:advice>  
		<aop:config>  
	    <!-- 配置哪些包的类要切入事务 -->
	    <aop:pointcut id="pointcut" expression="execution(* com.code2life.ssh.service.impl.*.*(..))" />
	    <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/><!-- 连接了上面的advice和上面的pointcut -->  
	    <!-- aop:pointcut要写在aop:advisor上面，否则会报错 -->  
	   </aop:config>
</beans>

spring的这个配置文件中，即整合了hibernate，也将代码里的类进行了注册，同时有一些切面的配置（如：数据库的事务配置，当然这些如果不太理解，可以拿模板来直接用）

这些配置文件我是统一的放置在了src目录下：
在这里插入图片描述
一下子给大家解释清楚，估计这一篇博客根本不够，我想着是大家可以直接将配置拿过去自己用，出现了问题去查，然后才能理解，并且内化为自己的东西。

详细搭建流程（代码部分）

1、实体类User.java：

package com.code2life.ssh.entity;

public class User {

	private String user_name;
	private String pass_word;
	private Integer id;
	private String real_name;
	private Integer age;
	private Integer role;

	public String getUser_name() {
		return user_name;
	}

	public void setUser_name(String username) {
		this.user_name = username;
	}

	public String getPass_word() {
		return pass_word;
	}

	public void setPass_word(String password) {
		this.pass_word = password;
	}

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

	public Integer getId() {
		return id;
	}

	public String getReal_name() {
		return real_name;
	}

	public void setReal_name(String realname) {
		this.real_name = realname;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public Integer getRole() {
		return role;
	}

	public void setRole(Integer role) {
		this.role = role;
	}
	
}

2、service层：UserServiceImpl.java：

package com.code2life.ssh.service.impl;

import com.code2life.ssh.entity.User;

import java.util.List;

import com.code2life.ssh.dao.impl.UserDao;
import com.code2life.ssh.service.UserService;
import com.code2life.ssh.util.Constant;

public class UserServiceImpl extends BaseServiceImpl<User> implements UserService{
	private UserDao userDao;
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	public UserDao getUserDao(){
		return userDao;
	}
	@Override
	public Boolean loginCheck(String account,String password) {
		User user=userDao.loadByAccount(account);
		System.out.println(user.getPass_word());
		System.out.println(password);
		if(user!=null&&user.getPass_word().equals(password)){
			return true;
		}
		else{
			return false;
		}
	}

	@Override
	public Boolean accountCheck(String account,String password) {
		User user=userDao.loadByAccount(account);
		if(user==null){
			return true;
		}
		else 
			return false;
	}
	
	@Override
	public Integer loadUserId(String account) {
		User user=userDao.loadByAccount(account);
		return user.getId();
	}
	
	@Override
	public Boolean existCheck(String account) {
		User user=userDao.loadByAccount(account);
		if(user==null){
			return true;
		}
		return false;
	}
	
	@Override
	public Boolean loginCheck(String account) {
		User user=userDao.loadByAccount(account);
		if(user==null){
			return false;
		}
		return true;
	}
	
	@Override
	public User getUserByUserId(Integer userId){
		return userDao.loadUserByUserId(userId);
	}
	
	@Override
	public Integer getUserTotalPages(Integer userId) {
//		if(userDao.getTotalNum(userId)==0) return 0;
		return (userDao.getTotalNum(userId)-1)/Constant.USER_SIZE+1;
	}
	
	@Override
	public List<User> getUserList(Integer userId, Integer pageNum, Integer size) {
		return userDao.getUserList(userId, pageNum, size);
	}
	
	@Override
	public void saveUser(String username, String password, String realname, Integer age, Integer role) {
		User user=new User();
		user.setUser_name(username);
		user.setPass_word(password);
		user.setReal_name(realname);
		user.setAge(age);
		user.setRole(role);
		save(user);
	}
	
	@Override
	public void updateUser(Integer userId, String username, String password, String realname, Integer age, Integer role) {
		User user=new User();
		user.setId(userId);
		user.setUser_name(username);
		user.setPass_word(password);
		user.setReal_name(realname);
		user.setAge(age);
		user.setRole(role);
		update(user);
	}
	
	@Override
	public void deleteUser(Integer userId) {
		userDao.deleteByUserId(userId);
	}
	
}

3、action层：UserAction.java：

package com.code2life.ssh.action;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

import org.apache.struts2.ServletActionContext;

import com.code2life.ssh.entity.User;
import com.code2life.ssh.util.Constant;
import com.code2life.ssh.service.UserService;
import com.opensymphony.xwork2.ActionSupport;

public class UserAction extends ActionSupport{
	private UserService userService;
	private Map<String, Object> jsonMap=null;
	public void setJsonMap(Map<String, Object> jsonMap) {
		this.jsonMap = jsonMap;
	}
	public Map<String, Object> getJsonMap() {
		return jsonMap;
	}
	public void setUserService(UserService userService){
		this.userService=userService;
	}
	public UserService getUserService(){
		return userService;
	}
	
	/**
	 * 登录
	 * @return
	 */
	public String login() {
		System.out.println("inLogin!!!");
		HttpServletRequest request = ServletActionContext.getRequest(); 
		HttpSession session = request.getSession();
		String account = request.getParameter("account");  
        String password = request.getParameter("password"); 
		if(userService.loginCheck(account,password)==true){
			Integer userId=userService.loadUserId(account);
			session.setAttribute("userId", userId);
//			UserInfo userInfo=userInfoService.getUserInfoByUserId(userId);
//			userInfo.setUserRecentLoginTime(new Date());
//			userInfoService.update(userInfo);
			return Constant.SUCCESS;
		}else {
			return Constant.FAIL;
		}
	}
	
	/**
	 * 校验密码
	 * @return
	 */
	public String passwordCheck(){
		HttpServletRequest request = ServletActionContext.getRequest(); 
		jsonMap=new HashMap<String, Object>();
		String password=request.getParameter("password");
		String account=request.getParameter("account");
		Boolean match=userService.loginCheck(account,password);
		jsonMap.put("valid", match);
		return "jsonMap";
	}
	
	/**
	 * 新增用户
	 */
	public void createUser(){
		HttpServletRequest request = ServletActionContext.getRequest(); 
		HttpSession session = request.getSession();
		jsonMap=new HashMap<String,Object>();
		Integer userId=(Integer)session.getAttribute("userId");
		String username=request.getParameter("username");
		String password=request.getParameter("password");
		String realname=request.getParameter("realname");
		Integer age=Integer.valueOf(request.getParameter("age"));
		Integer role=Integer.valueOf(request.getParameter("role"));
		userService.saveUser(username, password, realname, age, role);
	}
	
	/**
	 * 获取总的分页数
	 * @return
	 */
	public String getUserTotalPages(){
		HttpServletRequest request = ServletActionContext.getRequest(); 
		HttpSession session = request.getSession();
		jsonMap=new HashMap<String,Object>();
		Integer userId=(Integer)session.getAttribute("userId");
		Integer totalPages=userService.getUserTotalPages(userId);
		System.out.println("userId:"+userId+"totalPages"+totalPages);
		jsonMap.put("totalPages", totalPages);
		return "jsonMap";
	}
	
	/**
	 * 获取用户信息
	 * @return
	 */
	public String getUser(){
		HttpServletRequest request = ServletActionContext.getRequest(); 
		HttpSession session = request.getSession();
		jsonMap=new HashMap<String,Object>();
		Integer pageNum=Integer.parseInt(request.getParameter("Page"));
		Integer userId=(Integer)session.getAttribute("userId");
		List<User> userList=userService.getUserList(userId, pageNum, Constant.USER_SIZE);
	    Integer showSize=userList.size();
	    jsonMap.put("showSize", showSize);	
	    jsonMap.put("userList", userList);
		return "jsonMap";
	}
	
	/**
	 * 编辑用户
	 */
	public String updateUser(){
		HttpServletRequest request = ServletActionContext.getRequest(); 
		Integer userId=Integer.valueOf(request.getParameter("edit_user_id"));
		String username=(String)request.getParameter("edit_user_name");
		String password=(String)request.getParameter("edit_pass_word");
		String realname=(String)request.getParameter("edit_real_name");
		Integer age=Integer.valueOf(request.getParameter("edit_age"));
		Integer role=Integer.valueOf(request.getParameter("edit_role"));
		
		System.out.println(userId+" "+username+" "+password);
		userService.updateUser(userId,username,password,realname,age,role);
		return Constant.SUCCESS;
	}
	
	public String getUserInfo(Integer userId){
		HttpServletRequest request = ServletActionContext.getRequest(); 
		HttpSession session = request.getSession();
		jsonMap = new HashMap<String, Object>();  
		System.out.println("!!!22222"+userId);
		User userInfo= userService.getUserByUserId(userId);
		jsonMap.put("userInfo", userInfo);
		return "jsonMap";
	}
	
	public String deleteUser(){
		HttpServletRequest request = ServletActionContext.getRequest(); 
		HttpSession session = request.getSession();
		Integer userId=(Integer)Integer.valueOf(request.getParameter("id"));
		System.out.println("!!!333333333"+userId);
		userService.deleteUser(userId);
		return Constant.SUCCESS;
	}
	
	public String execute(){
		System.out.println("111222333");
		return Constant.SUCCESS;
	}
}

到这里简单的一个SSH的用户管理系统就完成了，业务逻辑只有增删改查，自己运行起来后，还可以自己去拓展实现新的模块，这样也可以进一步消化框架的逻辑。

系统功能界面

在这里插入图片描述

总结

本次SSH+mysql用户管理框架我已经将代码整理好，并且写了详细的框架搭建流程的word文档以及前后端数据交互的流程，如果需要完整的demo，可以加博主V：（Code2Life2）

写博客不易，觉得写得不错，记得一键三连！

anmu4200

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
7
评论
从0到1搭建一个SSH+mysql框架的用户管理系统（只有登录、用户增删改查功能）

博客目录基于SSH框架的单模块用户管理系统详细搭建流程（三大配置）详细搭建流程（代码部分）总结基于SSH框架的单模块用户管理系统学习SSH框架有两个难点：1、从0到1搭建SSH框架，各种配置比较头疼2、好多同学为了学习框架，下载了好多SSH的系统，但是功能太复杂，难以看到框架的核心东西基于上面两点，我将功能点简化，只留下登录、用户管理模块（增删改查），让大家可以将重点放在SSH框架本身上来，更容易去研究和学会SSH框架。详细搭建流程（三大配置）首先分析SSH框架的技术点：我们知道SSH分别指
复制链接

扫一扫