javaweb-SMBMS

最新推荐文章于 2024-06-21 15:14:18 发布
最新推荐文章于 2024-06-21 15:14:18 发布
阅读量147 收藏
点赞数
分类专栏： 学习笔记 文章标签： java 数据库 mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43427354/article/details/125934439
版权

SMBMS超市订单管理系统

javaweb基础学习总结，模拟简单的超市订单管理系统

文章目录

一、SMBMS架构、数据库表

在这里插入图片描述

数据库表
在这里插入图片描述

二、项目准备

1、搭建一个maven web项目
在这里插入图片描述
2、配置tomcat
3、测试启动项目
4、导入项目中会遇到的jar包依赖
5、创建项目包结构
在这里插入图片描述

6、编写实体类
ORM映射：表——类映射
7.编写基础公共类

  • 数据库配置文件（properties）

    driver=com.mysql.cj.jdbc.Driver
url =jdbc:mysql://localhost:3306/jdbcstudy?useUnicode=true&charaterEncoding=ut8&useSSL=true
username=root
password=1234qwer

  • 编写数据库的公共类

    package com.jjl.dao;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class BaseDao {
    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    //静态代码块，类加载时就初始化
    static {
        Properties properties = new Properties();
        //通过类加载器读取对应的资源
        InputStream is = BaseDao.class.getClassLoader().getResourceAsStream("db.properties");

        try {
            properties.load(is);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        driver = properties.getProperty("driver");
        url = properties.getProperty("url");
        username = properties.getProperty("username");
        password = properties.getProperty("password");
    }
    //获取数据库的连接
    public static Connection getConnection() {
        Connection connection = null;
        try {
            Class.forName(driver);
            connection = DriverManager.getConnection(url, username, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }

    //编写查询公共类
    public static ResultSet execute(Connection connection,String sql,Object[] params,ResultSet resultSet,PreparedStatement preparedStatement) throws SQLException {
        preparedStatement = connection.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            //Object[] params 这个参数是从1开始的，而数组是从0开始的
            preparedStatement.setObject(i+1,params[i]);
        }
        resultSet = preparedStatement.executeQuery();
        return resultSet;
    }
    //编写增删改公共方法
    public static int execute(Connection connection,String sql,Object[] params,PreparedStatement preparedStatement) throws SQLException {
        preparedStatement = connection.prepareStatement(sql);
        for (int i = 0; i < params.length; i++) {
            //Object[] params 这个参数是从1开始的，而数组是从0开始的
            preparedStatement.setObject(i+1,params[i]);
        }
        int updateRows = preparedStatement.executeUpdate();
        return updateRows;
    }

    //关闭连接，释放资源
    public static boolean closeResource(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet){
        boolean flag = true;
        if (resultSet!=null){
            try {
                resultSet.close();
                //GC回收
                resultSet=null;
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        if (preparedStatement!=null){
            try {
                preparedStatement.close();
                //GC回收
                preparedStatement=null;
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        if (connection!=null){
            try {
                connection.close();
                //GC回收
                connection=null;
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        return flag;
    }
}

  • 编写字符编码过滤器

    package com.jjl.filter;
import javax.servlet.*;
import java.io.IOException;
public class CharacterEncodingFilter implements Filter {

    public void init(FilterConfig filterConfig) throws ServletException {}
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        request.setCharacterEncoding("utf-8");
        chain.doFilter(request,response);
    }
    public void destroy() {}
}

        <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.jjl.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

  • 导入静态资源
    在这里插入图片描述

三、用户登录

在这里插入图片描述

1、编写前端页面（login.jsp）

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title>系统登录 - 超市订单管理系统</title>
    <link type="text/css" rel="stylesheet" href="${pageContext.request.contextPath }/css/style.css" />
    <script type="text/javascript">
	/* if(top.location!=self.location){
	      top.location=self.location;
	 } */
    </script>
</head>
<body class="login_bg">
    <section class="loginBox">
        <header class="loginHeader">
            <h1>超市订单管理系统</h1>
        </header>
        <section class="loginCont">
	        <form class="loginForm" action="${pageContext.request.contextPath }/user/login.do"  name="actionForm" id="actionForm"  method="post" >
				<div class="info">${error }</div>
				<div class="inputbox">
                    <label for="userCode">用户名：</label>
					<input type="text" class="input-text" id="userCode" name="userCode" placeholder="请输入用户名" required/>
				</div>	
				<div class="inputbox">
                    <label for="userPassword">密码：</label>
                    <input type="password" id="userPassword" name="userPassword" placeholder="请输入密码" required/>
                </div>	
				<div class="subBtn">
					
                    <input type="submit" value="登录"/>
                    <input type="reset" value="重置"/>
                </div>	
			</form>
        </section>
    </section>
</body>
</html>

2、设置欢迎页（web.xml)

<welcome-file-list>
    <welcome-file>login.jsp</welcome-file>
</welcome-file-list>

在这里插入图片描述

3、编写dao层登录用户的接口

package com.jjl.dao.user;

import com.jjl.pojo.User;

import java.sql.Connection;
import java.sql.SQLException;

public interface UserDao {
    //得到要登录的用户
    public User getLoginUser(Connection connection, String userCode) throws SQLException;
}

4、编写dao接口的实现类

package com.jjl.dao.user;

import com.jjl.dao.BaseDao;
import com.jjl.pojo.User;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class UserDaoImpl implements UserDao{
    public User getLoginUser(Connection connection, String userCode) throws SQLException {

        PreparedStatement pstm = null;
        ResultSet rs= null;
        User user = null;

        //如果数据库连接成功，则就执行sql
        if(connection!=null) {
            String sql = "select * from smbms_user where userCode=?";
            Object[] params = {userCode};

            rs = BaseDao.execute(connection, sql, params, rs, pstm);
            if (rs.next()) {
                user = new User();
                user.setId(rs.getInt("id"));
                user.setUserCode(rs.getString("userCode"));
                user.setUserName(rs.getString("userName"));
                user.setUserPassword(rs.getString("userPassword"));
                user.setGender(rs.getInt("gender"));
                user.setBirthday(rs.getDate("birthday"));
                user.setPhone(rs.getString("phone"));
                user.setAddress(rs.getString("address"));
                user.setUserRole(rs.getInt("userRole"));
                user.setCreatedBy(rs.getInt("createdBy"));
                user.setCreationDate(rs.getTimestamp("creationDate"));
                user.setModifyBy(rs.getInt("modifyBy"));
                user.setModifyDate(rs.getTimestamp("modifyDate"));
            }
            BaseDao.closeResource(null,pstm,rs);
        }
        return user;
    }
}

5、业务层接口

package com.jjl.service.user;

import com.jjl.pojo.User;

import java.sql.SQLException;

public interface UserService {
    //用户登录
    public User login(String userCode, String password) throws SQLException;
}

6、业务层实现类

package com.jjl.service.user;

import com.jjl.dao.BaseDao;
import com.jjl.dao.user.UserDao;
import com.jjl.dao.user.UserDaoImpl;
import com.jjl.pojo.User;

import java.sql.Connection;
import java.sql.SQLException;

public class UserServiceImpl implements UserService{
    //业务层都会调用dao层，所以要引入dao层
    private UserDao userDao;
    public UserServiceImpl(){
        userDao = new UserDaoImpl();
    }
    public User login(String userCode, String password) {
        Connection connection =null;
        User user = null;
        connection = BaseDao.getConnection();
        //通过业务层调用嘴硬的数据库操作
        try {
            user = userDao.getLoginUser(connection,userCode);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return user;
    }
}

7、编写servlet

设置存放用户session的常量

package com.jjl.util;

public class Constants {
    public final static String USER_SESSION = "userSession";
}

编写servlet

package com.jjl.servlet.user;
import com.jjl.pojo.User;
import com.jjl.service.user.UserServiceImpl;
import com.jjl.util.Constants;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class LoginServlet extends HttpServlet {

    //Servlet:控制层调用业务层代码
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入LoginServlet...start....");

        //获取前端传递的用户名和密码
        String userCode = req.getParameter("userCode");
        String userPassword = req.getParameter("userPassword");

        //和数据库中的密码进行对比，调用业务层
        UserServiceImpl userService = new UserServiceImpl();
        User user = userService.login(userCode, userPassword);//这里就把登录的人查出来了

        if(user!=null){//如果查到的用户不等于空，则查有此人可以登录
            //将用户的信息放入session中
            req.getSession().setAttribute(Constants.USER_SESSION,user);
            //跳转到主页
            resp.sendRedirect("jsp/frame.jsp");

        }else {//如果用户名为空，无法登录
            //转发回登录页面，顺待提示它，用户名或密码错误；
            req.setAttribute("error","用户名或者密码不正确");
            req.getRequestDispatcher("login.jsp").forward(req,resp);
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

8、注册servlet

<servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>com.jjl.servlet.user.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login.do</url-pattern>
    </servlet-mapping>

9、测试访问

特别注意，遇到了如下报错：

java.lang.ClassNotFoundException: com.mysql.cj.jdbc.Driver 	
at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1364) 	
at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1187)

是由于tomcat的lib中没有连接mysql的驱动（mysql-connector-java-8.0.28.jar），只需要将项目中的驱动复制到tomcat的lib中即可
测试访问：
在这里插入图片描述

10、优化登录功能（注销、权限过滤）

1、注销

思路:

  • 移除session
  • 返回登录页面
package com.jjl.servlet.user;
import com.jjl.util.Constants;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class LogoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.getSession().removeAttribute(Constants.USER_SESSION);
        resp.sendRedirect(req.getContextPath()+"/login.jsp");//返回登录页面
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

注册：

<servlet>
    <servlet-name>LogoutServlet</servlet-name>
    <servlet-class>com.jjl.servlet.user.LogoutServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>LogoutServlet</servlet-name>
    <url-pattern>/user/logout</url-pattern>
</servlet-mapping>

2、登录拦截（权限控制）

四、修改密码

1、导入前端页面

2、思路

在这里插入图片描述

3、编写UserDao接口

package com.jjl.dao.user;
import com.jjl.pojo.User;
import java.sql.Connection;
import java.sql.SQLException;
public interface UserDao {
    //得到要登录的用户
    public User getLoginUser(Connection connection, String userCode, String userPassword) throws SQLException;

    //新增接口：获取当前用户密码
    public int updatePwd (Connection connection, int id, String userPassword)throws SQLException;

}

4、UserDao类中新增修改密码的实现接口

package com.jjl.dao.user;
import com.jjl.dao.BaseDao;
import com.jjl.pojo.User;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class UserDaoImpl implements UserDao{
    //获取要登录的用户
    略：
    //修改当前用户密码
    public int updatePwd(Connection connection, int id, String userPassword) throws SQLException {
        PreparedStatement pstm = null;
        int execute = 0;
        if (connection!=null) {
            String sql = "update smbms_user set userPassword=? where id=?";
            Object params[] = {userPassword, id};
            execute = BaseDao.execute(connection, sql, params, pstm);
            BaseDao.closeResource(null, pstm, null);
        }
        return execute;
    }
}

5、编写service层接口（UserService）

package com.jjl.service.user;
import com.jjl.pojo.User;
import java.sql.Connection;
import java.sql.SQLException;

public interface UserService {
    //用户登录
    public User login(String userCode, String userPassword) throws SQLException;
    
    //根据用户id，修改密码
    public boolean updatePwd (int id, String userPassword);
}

6、UserServiceImpl实现类，传递参数返回业务处理结果

package com.jjl.service.user;
import com.jjl.dao.BaseDao;
import com.jjl.dao.user.UserDao;
import com.jjl.dao.user.UserDaoImpl;
import com.jjl.pojo.User;
import java.sql.Connection;
import java.sql.SQLException;

public class UserServiceImpl implements UserService{
    //用户登录
    略
	//业务层实现类，修改密码
    public boolean updatePwd(int id, String userPassword) {
        Connection connection =null;
        boolean flag = false;
        connection = BaseDao.getConnection();
        try {
            if(userDao.updatePwd(connection,id,userPassword)>0){
                flag=true;
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return flag;
    }
}

7、编写servlet

package com.jjl.servlet.user;
import com.jjl.pojo.User;
import com.jjl.service.user.UserService;
import com.jjl.service.user.UserServiceImpl;
import com.jjl.util.Constants;
import com.mysql.cj.util.StringUtils;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

//实现servlet复用
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //从session里面拿id；
        Object attribute = req.getSession().getAttribute(Constants.USER_SESSION);
        String newpassword = req.getParameter("newpassword");
        System.out.println("UserServlet" +newpassword );
        boolean flag = false;
        //!StringUtils.isNullOrEmpty(newpassword)
        if (attribute!= null && newpassword!=null){
            UserServiceImpl userService = new UserServiceImpl();
            flag = userService.updatePwd(((User) attribute).getId(), newpassword);
            if (flag){
                req.setAttribute("message","修改密码成功，请退出使用新密码登录");
                //密码修改成功移除当前用户session
                req.getSession().removeAttribute(Constants.USER_SESSION);
            }else {
                req.setAttribute("message","修改密码失败");
            }

        }else {
            req.setAttribute("message","新密码有误");
        }
        req.getRequestDispatcher("pwdmodify.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

注册web.xml

    <servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.jjl.servlet.user.UserServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/jsp/user.do</url-pattern>
    </servlet-mapping>

8、实现复用，提取方法

package com.jjl.servlet.user;
import com.jjl.pojo.User;
import com.jjl.service.user.UserService;
import com.jjl.service.user.UserServiceImpl;
import com.jjl.util.Constants;
import com.mysql.cj.util.StringUtils;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

//实现servlet复用
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if (method.equals("savepwd")&&method!=null){
            this.updatePwd(req,resp);
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
    public void updatePwd(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //从session里面拿id；
        Object attribute = req.getSession().getAttribute(Constants.USER_SESSION);
        String newpassword = req.getParameter("newpassword");
        System.out.println("UserServlet" +newpassword );
        boolean flag = false;
        //!StringUtils.isNullOrEmpty(newpassword)
        if (attribute!= null && newpassword!=null){
            UserServiceImpl userService = new UserServiceImpl();
            flag = userService.updatePwd(((User) attribute).getId(), newpassword);
            if (flag){
                req.setAttribute("message","修改密码成功，请退出使用新密码登录");
                //密码修改成功移除当前用户session
                req.getSession().removeAttribute(Constants.USER_SESSION);
            }else {
                req.setAttribute("message","修改密码失败");
            }

        }else {
            req.setAttribute("message","新密码有误");
        }
        req.getRequestDispatcher("pwdmodify.jsp").forward(req,resp);
    }
}

9、优化密码修改时，旧密码验证，使用Ajax

1、导入阿里巴巴的fastjson.jar包，并且将jar复制到tomcat的lib中

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.10</version>
</dependency>

2、设置session的默认过期时间

<!--    默认session过期时间,30分钟-->
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>

3、编写验证密码的方法

package com.jjl.servlet.user;
import com.alibaba.fastjson.JSONArray;
import com.jjl.pojo.User;
import com.jjl.service.user.UserServiceImpl;
import com.jjl.util.Constants;
import com.mysql.cj.util.StringUtils;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

//实现servlet复用
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if (method.equals("savepwd")&&method!=null){
            this.updatePwd(req,resp);
        }else if (method.equals("pwdmodify")&&method!=null){
            this.pwdModify(req, resp);
        }
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
    //修改密码
    public void updatePwd(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        略·····
    }

    //验证旧密码
    public void pwdModify(HttpServletRequest req, HttpServletResponse resp){
        Object attribute = req.getSession().getAttribute(Constants.USER_SESSION);
        String oldpassword = req.getParameter("oldpassword");

        //万能的Map: 结果集
        Map<String, String> resultMap = new HashMap<String, String>();
        if (attribute==null){//如果session失效获取过期了，
            resultMap.put("result","sessionerror");
        }else if(StringUtils.isNullOrEmpty(oldpassword)){//如果密码为空
            resultMap.put("result","error");
        }else {
            String userPassword = ((User) attribute).getUserPassword();//session中用户的密码
            if(oldpassword.equals(userPassword)){
                resultMap.put("result","true");
            }else {
                resultMap.put("result","false");
            }
        }

        try {
            resp.setContentType("application/json");
            PrintWriter writer = resp.getWriter();
            //JSONArray 阿里巴巴的json工具类,转换格式
            /*
            将Map的格式
            resultMap={"result","error"，"result","sessionerror"}
            转化成json的格式
            Json格式 = {key: value}
             */
            writer.write(JSONArray.toJSONString(resultMap));
            writer.flush();//刷新
            writer.close();//关闭
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

五、用户管理、分页展示

思路图
在这里插入图片描述
1、导入分页的工具类
2、用户列表页面导入

1、获取用户数量

1、UserDao

package com.jjl.dao.user;

import com.jjl.pojo.User;

import java.sql.Connection;
import java.sql.SQLException;

public interface UserDao {
    //得到要登录的用户
    略
    //获取当前用户密码
    略
    //查询用户总数
    public int getUserCount(Connection connection, String userName,int userRole) throws SQLException;
}

2、UserDaolmpl

package com.jjl.dao.user;

import com.jjl.dao.BaseDao;
import com.jjl.pojo.User;
import com.mysql.cj.util.StringUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

public class UserDaoImpl implements UserDao{
    //获取要登录的用户
   	略：
    //修改当前用户密码
    略：

    //根据用户名或者用户角色查询用户总数
    public int getUserCount(Connection connection, String userName, int userRole) throws SQLException {
        PreparedStatement pstm=null;
        ResultSet rs =null;
        int count = 0;
        if (connection!=null){
            StringBuilder sql = new StringBuilder();//可变字符串
            sql.append("select count(1) as count from smbms_user u, smbms_role r where u.userRole=r.id");
            ArrayList<Object> list = new ArrayList<Object>();//存放我们的参数
            if (!StringUtils.isNullOrEmpty(userName)){
                sql.append(" and userName like ?");
                list.add("%"+userName+"%");
            }
            if (userRole>0){
                sql.append(" and u.userRole = ?;");
                list.add(userRole);
            }
            //把list转换为数组
            Object[] params = list.toArray();
            System.out.println("UserDaoImpl->getUserCount："+sql.toString());

            rs = BaseDao.execute(connection,sql.toString(),params,rs,pstm);
            if (rs.next()){
                count = rs.getInt("count");//从结果集中获取最终的数量
            }
            BaseDao.closeResource(null,pstm,rs);

        }
        return count;
    }
}

3、UserService

package com.jjl.service.user;
import com.jjl.pojo.User;
import java.sql.Connection;
import java.sql.SQLException;
public interface UserService {
    //用户登录
    略
    //根据用户id，修改密码
    略
    //查询记录数
    public int getUserCount(String username,int userRole);
}

4、UserServicelmpl

package com.jjl.service.user;

import com.jjl.dao.BaseDao;
import com.jjl.dao.user.UserDao;
import com.jjl.dao.user.UserDaoImpl;
import com.jjl.pojo.User;
import org.junit.Test;

import java.sql.Connection;
import java.sql.SQLException;

public class UserServiceImpl implements UserService{
    //业务层都会调用dao层，所以要引入dao层
    略
    //业务层实现类，修改密码
    略
    //查询记录
    public int getUserCount(String username, int userRole) {
        Connection connection = null;
        int count=0;
        try {
            connection = BaseDao.getConnection();
            count = userDao.getUserCount(connection,username,userRole);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return count;
    }
}

2、获取用户列表

1、UserDao

//用户列表
    public List<User> getUserList(Connection connection,String userName, int userRole,int currentPageNo, int pageSize)throws Exception;

2、UserDaoImpl

//根据条件查询用户列表
    public List<User> getUserList(Connection connection, String userName, int userRole, int currentPageNo, int pageSize) throws Exception {
        PreparedStatement pstm = null;
        ResultSet rs = null;
        List<User> userList=new ArrayList<User>();
        if (connection!=null){
            StringBuilder sql = new StringBuilder();
            sql.append("select u.*,r.roleName as userRoleName from smbms_user u,smbms_role r where u.userRole=r.id;");
            ArrayList<Object> list = new ArrayList<Object>();
            if (!StringUtils.isNullOrEmpty(userName)){
                sql.append(" and u.userName like ?");
                list.add("%"+userName+"%");
            }
            if (userRole>0){
                sql.append(" and u.userRole = ?");
                list.add(userRole);
            }

            //limit在sql中用于指定显示数据的条数，它有两个参数，分别是（从第几条（0开始），到第几条）
            sql.append(" order by creationDate DESC limit ?,?");
            currentPageNo = (currentPageNo-1)*pageSize;
            list.add(currentPageNo);
            list.add(pageSize);

            Object[] params = list.toArray();
            System.out.println("sql-----"+sql.toString());
            rs=BaseDao.execute(connection,sql.toString(),params,rs,pstm);
            while (rs.next()){
                User _user =new User();
                _user.setId(rs.getInt("id"));
                _user.setUserCode(rs.getString("userCode"));
                _user.setUserName(rs.getString("userName"));
                _user.setGender(rs.getInt("gender"));
                _user.setBirthday(rs.getDate("birthday"));
                _user.setPhone(rs.getString("phone"));
                _user.setUserRole(rs.getInt("userRole"));
                _user.setUserRoleName(rs.getString("userRoleName"));
                userList.add(_user);
            }
            BaseDao.closeResource(null,pstm,rs);
        }
        return userList;
    }

3、UserService

//根据条件查询用户列表
    public List<User> getUserList(String qureyUserName,int queryUserRole,int currentPageNo,int pageSize);

4、UserServiceImpl

    //根据条件查询用户列表
    public List<User> getUserList(String qureyUserName, int queryUserRole, int currentPageNo, int pageSize) {
        Connection connection=null;
        List<User> userList = null;
        System.out.println(queryUserRole);
        System.out.println(qureyUserName);
        System.out.println(currentPageNo);
        System.out.println(pageSize);
        try {
            connection = BaseDao.getConnection();
            userList = userDao.getUserList(connection,qureyUserName,queryUserRole,currentPageNo,pageSize);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return userList;
    }

3、获取角色列表

把角色的操作放在另一个包中
1、RoleDao

package com.jjl.dao.role;

import com.jjl.pojo.Role;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

public interface RoleDao {
    //获取角色列表
    public List<Role> getRoleList(Connection connection)throws SQLException;
}

2、RoleDaoImpl

package com.jjl.dao.role;

import com.jjl.dao.BaseDao;
import com.jjl.pojo.Role;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class RoleDaoImpl implements RoleDao {
    //获取角色列表
    public List<Role> getRoleList(Connection connection) throws SQLException {
        PreparedStatement pstm =null;
        ResultSet rs=null;
        ArrayList<Role> rolesList = new ArrayList<Role>();
        if (connection!=null){
            String sql = "select * from smbms_role";
            Object[] params = {};
            rs= BaseDao.execute(connection,sql,params,rs,pstm);
            while (rs.next()){
                Role role = new Role();
                role.setId(rs.getInt("id"));
                role.setRoleCode(rs.getString("roleCode"));
                role.setRoleName(rs.getString("roleName"));
                rolesList.add(role);
            }
            BaseDao.closeResource(null,pstm,rs);
        }
        return rolesList;
    }
}

3、RoleService

package com.jjl.service.role;

import com.jjl.pojo.Role;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

public interface RoleService {
    //获取角色列表
    public List<Role> getRoleList()throws SQLException;
}

4、RoleServiceImpl

package com.jjl.service.role;

import com.jjl.dao.BaseDao;
import com.jjl.dao.role.RoleDao;
import com.jjl.dao.role.RoleDaoImpl;
import com.jjl.pojo.Role;
import org.junit.Test;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

public class RoleServiceImpl implements RoleService{
    //引入Dao
    private RoleDao roleDao;

    public RoleServiceImpl(){
        roleDao= new RoleDaoImpl();
    }
    public List<Role> getRoleList() throws SQLException {
        Connection connection = null;
        List<Role> roleList=null;
        connection = BaseDao.getConnection();
        roleList = roleDao.getRoleList(connection);
        BaseDao.closeResource(connection,null,null);
        return roleList;
    }
}

4、Servlet层

package com.jjl.servlet.user;
import com.alibaba.fastjson.JSONArray;
import com.jjl.pojo.Role;
import com.jjl.pojo.User;
import com.jjl.service.role.RoleServiceImpl;
import com.jjl.service.user.UserServiceImpl;
import com.jjl.util.Constants;
import com.jjl.util.PageSupport;
import com.mysql.cj.util.StringUtils;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//实现servlet复用
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if (method.equals("savepwd")&&method!=null){
            this.updatePwd(req,resp);
        }else if (method.equals("pwdmodify")&&method!=null){
            this.pwdModify(req, resp);
        } else if (method.equals("query")&&method!=null) {
            try {
                this.query(req, resp);
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }

        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
    //修改密码
略

    //验证旧密码
 略

    //用户管理
    public void query(HttpServletRequest req, HttpServletResponse resp) throws IOException, SQLException, ServletException {
        //查询用户列表
        //从前端获取数据
        String queryUserName = req.getParameter("queryname");
        String queryUserRole = req.getParameter("queryUserRole");
        String pageIndex = req.getParameter("pageIndex");
        int queryuserrole =0;
        List<User> userList=null;

        //获取用户列表
        UserServiceImpl userService = new UserServiceImpl();
        //第一次走这个请求，一定是第一页，页面大小固定的
        int pageSize = 3;
        int currentPageNo = 1;

        if (queryUserName==null){
            queryUserName="";
        }
        if (queryUserRole!=null&&!queryUserRole.equals("")){
            queryuserrole=Integer.parseInt(queryUserRole);
        }
        if (pageIndex!=null){
            try {
                currentPageNo = Integer.parseInt(pageIndex);
            }catch (Exception e){
                resp.sendRedirect("error.jsp");
            }

        }
        //获取用户总数(分页，上一页，下一页）
        int totalCount = userService.getUserCount(queryUserName, queryuserrole);
        PageSupport pageSupport = new PageSupport();
        //用户输入的当前页数
        pageSupport.setCurrentPageNo(currentPageNo);
        //页面容量
        pageSupport.setPageSize(pageSize);
        //总页数
        pageSupport.setTotalCount(totalCount);

        int totalPageCount = pageSupport.getTotalPageCount();
        //控制首页和尾页
        if (currentPageNo<1){//如果当前页数小于1了，则就强制显示第一页内容
            currentPageNo=1;
        } else if (currentPageNo>totalPageCount) {//如果当前页面大于了最后一页，则就当前页面就等于最后一页
            currentPageNo=totalPageCount;
        }

        //获取用户列表展示
        userList = userService.getUserList(queryUserName, queryuserrole, currentPageNo, pageSize);
        req.setAttribute("userList",userList);
        req.setAttribute("queryUserName",queryUserName);
        req.setAttribute("queryUserRole",queryuserrole);

        //获取角色列表
        RoleServiceImpl roleService = new RoleServiceImpl();
        List<Role> roleList = roleService.getRoleList();
        req.setAttribute("roleList",roleList);

        //把总页数、总数、当前页数返回前端
        req.setAttribute("totalPageCount",totalPageCount);
        req.setAttribute("totalCount",totalCount);
        req.setAttribute("currentPageNo",currentPageNo);


        req.getRequestDispatcher("userlist.jsp").forward(req,resp);

        ArrayList<User> arrayList = new ArrayList<User>(userList);
        for (User user : arrayList) {
            System.out.println(user.getAge().toString());
        }
    }
}

5、添加用户

1、dao

public int add(Connection connection, User user) throws SQLException {
        PreparedStatement pstm=null;
        int updateRows = 0;
        if (connection!=null){
            String sql = "insert into smbms_user (userCode, userName, userPassword, " +
                    "gender, birthday, phone, address, userRole, createdBy, creationDate) " +
                    "VALUES (?,?,?,?,?,?,?,?,?,?)";
            Object [] params = {user.getUserCode(),user.getUserName(),user.getUserPassword(), user.getGender(),
                    user.getBirthday(),user.getPhone(),user.getAddress(),user.getUserRole(),user.getCreatedBy(),user.getCreationDate()};
            updateRows = BaseDao.execute(connection,sql,params,pstm);
            BaseDao.closeResource(null,pstm,null);
        }
        return updateRows;
    }

2、service层

//添加用户
    public boolean add(User user) {
        boolean flag = false;
        Connection connection= null;

        try {
            connection = BaseDao.getConnection();
            connection.setAutoCommit(false);//打开jdbc事务管理
            int updateRows = userDao.add(connection,user);
            connection.commit();
            if (updateRows>0){
                flag=true;
                System.out.println("add success!");
            }else {
                System.out.println("add failed!");
            }
        } catch (SQLException e) {
            e.printStackTrace();
            try {
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return flag;
    }
    
    //验证用户编码
    public boolean getUserCode(String userCode) {
        boolean flag = false;
        Connection connection=null;
        connection = BaseDao.getConnection();
        try {
            if (userDao.userCode(connection,userCode)>0){
                flag = true;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }finally {
            BaseDao.closeResource(connection,null,null);
        }
        return flag;
    }

3、srivlet层

//增加用户
    public void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException, SQLException {
        req.getRequestDispatcher("useradd.jsp").forward(req,resp);
        System.out.println("add()============");
        String userCode = req.getParameter("userCode");
        String userName = req.getParameter("userName");
        String password = req.getParameter("userPassword");
        String gender = req.getParameter("gender");
        String birthday = req.getParameter("birthday");
        String phone = req.getParameter("phone");
        String address = req.getParameter("address");
        String userRole = req.getParameter("userRole");

        User user = new User();
        user.setUserCode(userCode);
        user.setUserName(userName);
        user.setUserPassword(password);
        user.setGender(Integer.valueOf(gender));
        try {
            user.setBirthday(new SimpleDateFormat("yyyyy-MM-dd").parse(birthday));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        user.setPhone(phone);
        user.setAddress(address);
        user.setUserRole(Integer.valueOf(userRole));
        user.setCreationDate(new Date());
        user.setCreatedBy(((User)req.getSession().getAttribute(Constants.USER_SESSION)).getId());

        UserServiceImpl userService = new UserServiceImpl();
        if (userService.add(user)){
            resp.sendRedirect(req.getContextPath()+"/jsp/user.do?method=query");
            System.out.println("用户添加成功");
//            req.getRequestDispatcher("userlist.jsp").forward(req,resp);
        }else {
            req.getRequestDispatcher("useradd.jsp").forward(req,resp);
        }
    }

    //获取角色列表
    public void rolelist(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException, SQLException {
        RoleServiceImpl roleService = new RoleServiceImpl();
        List<Role> roleList = roleService.getRoleList();
        req.setAttribute("RoleList",roleList);

        Map<String, String> roleMap = new HashMap<String, String>();
        for (Role role : roleList) {
            roleMap.put(String.valueOf(role.getId()),role.getRoleName());
        }

        resp.setContentType("application/json");
        resp.setCharacterEncoding("utf-8");
        PrintWriter writer = resp.getWriter();
        writer.write(JSONArray.toJSONString(roleMap));
        writer.flush();//刷新
        writer.close();//关闭
    }


    //验证用户名
    public void ucexist(HttpServletRequest req, HttpServletResponse resp){
        UserServiceImpl userService = new UserServiceImpl();
        //万能的Map: 结果集
        Map<String, String> userCodeMap = new HashMap<String, String>();
        reqUserCode = req.getParameter("userCode");
        boolean userCode = userService.getUserCode(reqUserCode);
        System.out.println(userCode);
        if (reqUserCode==null || reqUserCode==""){
            userCodeMap.put("userCode","existnull");
        }else if(userCode){
            userCodeMap.put("userCode","exist");
            System.out.println("ucexist=====>"+userCode);
        }else {
            System.out.println("可以新添加用户");
        }
        try {
            resp.setContentType("application/json");
            PrintWriter writer = resp.getWriter();
            writer.write(JSONArray.toJSONString(userCodeMap));
            writer.flush();//刷新
            writer.close();//关闭
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
XL's妃妃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaWeb-smbms项目
qq_41355222的博客
04-02 199
项目如何搭建？ 考虑使用不使用Maven？依赖，jar 项目搭建 搭建Maven的Web项目 配置tomcat 测试项目能否跑起来 导依赖jar包 <dependencies> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version&..
JavaWeb入门-SMBMS
weixin_43763889的博客
07-20 1356
SMBMS 这个小项目主要是javaWeb的一个回顾，项目只实现了部分功能(主要是用户管理模块），因为其他功能都是大同小异，加上本人比较懒，都是一些sql语句的不同，就没有写。 主要参考狂神javaWeb最后的视频讲解，边写边回顾javaWeb的一些知识点 还有这个项目的前端是直接拿过来用的，不是自己写的… 项目简介： 文章目录SMBMS1.环境搭建1.1 数据库的创建和连接1.2 导入相关依赖1.3 基本框架搭建1.4 编写数据库连接资源文件2. 基础类编写2.1 pojo层2.2 操作数据库
javaweb-smbms
weixin_43921407的博客
05-17 36
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、登录二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、登
【狂神说笔记—— Java基础18-JavaWeb-SMBMS项目】
weixin_46055348的博客
08-07 889
【狂神说笔记—— Java基础18-JavaWeb-SMBMS项目】
javaweb-SMBMS项目
wmy01234的博客
12-07 674
1、项目搭建准备 1、搭建一个maven web项目 2、配置Tomcat 3、测试项目能否成功运行 4、导入项目中需要使用的jar包 <dependencies> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version.
狂神-javaweb项目-smbms笔记代码
兔子的博客
08-05 1384
smbms 1、项目准备工作 1、搭建一个maven项目 2、配置tomcat 3、测试项目 4、导入依赖jar包 5、创建包结构 dao filter pojo service servlet util 6、编写实体类 ORM映射：表–类映射 7、编写基础公共类 ​ 1、数据库配置文件 db.properties driver = com.mysql.jdbc.Driver url = jdbc:mysql://localhost:3306?userUnicode=true&ch
JavaWeb-SMBMS 登录流程解析
m0_53509974的博客
03-14 197
JavaWeb-SMBMS 登录流程解析 结构 ## 数据库访问
【狂神说】JavaWeb项目-SMBMS
qq_44430911的博客
10-11 2205
JavaWeb项目—SMBMS(超市管理项目) 本文绝大部分基于狂神说B站视频进行总结。 本人基于狂神老师的笔记，边学习边添加了自己的注解，特此发文便于保存。 项目初始框架图： 数据库： 项目如何搭建？ 考虑是不是用maven？ jar包，依赖 搭建项目准备工作 搭建一个maven web 项目 配置Tomcat 测试项目是否能够跑起来 导入项目中需要的jar包; jsp，Servlet，mysql驱动jstl，stand… 构建项目包结构 编写实体类 ORM映射:表-
狂神说-SMBMS项目
03-24
狂神说-SMBMS项目
SSM-smbms.zip
10-17
超市订单管理系统含有5个功能，订单管理，供应商管理，用户管理，角色管理，密码修改。包括spring注解技术，具有非常好的学习价值。亲测无bug!
smbms(JAVAWeb实现-超市订单管理系统)
08-26
(JAVAWeb实现-超市订单管理系统）
工一说javaweb之smbms实战静态资源.zip
10-24
工一说javaweb之smbms实战静态资源
毕设&课设&项目&实训-smbms超市订单管理系统 本项目基于javaWeb+jsp+Mysql+Tomcat+前端。.zip
01-26
所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通，第一时间进行解答！该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！...
JavaWeb-03 SMBMS
qq_40781378的博客
03-15 98
SMBMS 超市订单管理系统 数据库配置文件 driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://localhost:3306?useUnicode=true&characterEncoding=utf-8 username=root password=123 编写数据库的公共类 package com.kang.dao; import java.io.IOException; import java.io.InputStream; import
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 935
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
日常工作记录目录
最新发布
与海
06-21 330
EasyExcel实现二维码下载与展示
Day43
m0_67496588的博客
06-20 1152
JSON，Ajax
JavaWeb-SSM-超市管理系统.docx
07-01
本文是关于JavaWeb-SSM-超市管理系统的项目文档，该项目是南阳理工学院软件学院移动1班2018年12月完成的一个实验，旨在实现浏览器和服务器的交互，实现对超市管理系统的基本功能，包括浏览商品信息、购物车管理、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XL's妃妃

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值