JavaWeb学习

JavaWeb学习

1. Servlet#

1.1 Servlet简介#

  • Servlet 是sun公司开发动态web的一门技术
  • Sun在这些API中提供一些接口叫做：Servlet，如果想开发一个Servlet程序，只需完成两个小步骤：
    • 编写一个类，实现Servlet接口
    • 把开发好的java类部署到web服务器中。

1.2 HelloServlet#

Servlet接口Sun公司有两个默认的实现类：HttpServlet，GenericServlet

  1. 构建一个普通Maven项目，删掉里面的src目录，以后的学习就是在这个项目里建立Module，这个空的工程就是Maven主工程；

  2. 关于Maven父子工程的理解：

    • 父项目中会有：

    • <modules>
    <module>servlet_01</module>
</modules>

    • 子项目中会有：

    • <parent>
    <artifactId>JavaWeb_Servlet</artifactId>
    <groupId>com.LEEZ</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>

    • 父项目中的jar包，子项目可以直接使用

  3. Maven环境优化：

    1. 修改web.xml为最新的

      <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">
</web-app>

    2. 将Maven的结构搭建完整

  4. 编写一个Servlet程序

    1. 编写一个普通类

    2. 实现Servlet接口，这里我们直接继承HttpServlet

      public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter printWriter = resp.getWriter();
        printWriter.write("hello,servlet");
    }

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

  5. 编写Servlet的映射

    • 为什么需要映射：我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的servlet，还需要给它一个浏览器能访问的路径

    •     <!--注册Servlet-->
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.LEEZ.Servlet.HelloServlet</servlet-class>
    </servlet>
    <!--Servlet的请求路径-->
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/HelloServlet</url-pattern>
    </servlet-mapping>

  6. 配置Tomcat

  7. 测试运行

1.3 ServletContext#

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用：

1.共享数据#

  • 我在这个Servlet中保存的数据，可以在另一个Servlet中获取

  •     //保存数据
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();

        String username = "立g";
        servletContext.setAttribute("username",username);
    }

  •     //获取数据
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        String username = (String) servletContext.getAttribute("username");

        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        PrintWriter writer = resp.getWriter();
        writer.write("名字：" + username);
    }

  • 	<!-- 保存数据的Servlet  -->    
	<servlet>
        <servlet-name>HelloServlet02</servlet-name>
        <servlet-class>com.LEEZ.Servlet.HelloServlet02</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet02</servlet-name>
        <url-pattern>/HelloServlet02</url-pattern>
    </servlet-mapping>

	<!-- 获取数据的Servlet  -->  
    <servlet>
        <servlet-name>GetServlet</servlet-name>
        <servlet-class>com.LEEZ.Servlet.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>GetServlet</servlet-name>
        <url-pattern>/GetServlet</url-pattern>
    </servlet-mapping>

2.获取初始化参数#

  •     <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
    </context-param>

  •     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        String url = servletContext.getInitParameter("url");

        resp.getWriter().print(url);
    }

3.请求转发#

  •     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();

        System.out.println("进入了ServletDemo04");
        servletContext.getRequestDispatcher("/ServletDemo03").forward(req,resp);
    }

4.读取资源文件#

Properites

  • 在java目录下新建properties

    • username = root
password = 654321

    •     <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

    •     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        InputStream is = servletContext.getResourceAsStream("/WEB-INF/classes/com/LEEZ/Servlet/test.properties");

        Properties prop = new Properties();
        prop.load(is);

        String username = prop.getProperty("username");
        String password = prop.getProperty("password");

        resp.getWriter().print(username + ":" + password);
    }

    •     <servlet>
        <servlet-name>Properties06</servlet-name>
        <servlet-class>com.LEEZ.Servlet.Properties06</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Properties06</servlet-name>
        <url-pattern>/Properties06</url-pattern>
    </servlet-mapping>

  • 在resources目录下新建properties

    •     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        InputStream is = servletContext.getResourceAsStream("/WEB-INF/classes/db.properties");

        Properties prop = new Properties();
        prop.load(is);

        String username = prop.getProperty("username");
        String password = prop.getProperty("password");

        resp.getWriter().print(username + ":" + password);
    }

    • username = root
password = 123456

    •     <servlet>
        <servlet-name>Properties05</servlet-name>
        <servlet-class>com.LEEZ.Servlet.Propertis05</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Properties05</servlet-name>
        <url-pattern>/Properties05</url-pattern>
    </servlet-mapping>

发现：都被打包到了同一个路径下：classes，我们俗称这个路径为classpath；

1.4 HttpServletResponse#

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequese对象，一个代表响应的HttpServletResponse对象；

  • 如果要获取客户端请求过来的参数：找HttpServletRequest
  • 如果要给客户端响应一些消息：找HttpServletResponse

1.常见应用#

1.向浏览器输出消息
2.下载文件
  1. 要获取下载文件的路径
  2. 下载的文件名是啥？
  3. 设置想办法让浏览器能够支持下载我们需要的东西
  4. 获取下载文件的输入流
  5. 创建缓冲区
  6. 获取OutputStream对象
  7. 将FileOutputStream流写入到buffer缓冲区
  8. 使用OutputStream将缓冲区中的数据输出到客户端
3.验证码功能

  • 前端实现

  • 后端实现，需要用到 java 图片类，生成一个图片

    • protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //如何让浏览器每3秒自动刷新
        resp.setHeader("refresh","3");

        //在内存中创建一个图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
        //得到图片
        Graphics2D g = (Graphics2D) image.getGraphics();
        //设置图片的背景颜色
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, 80, 20);
        //给图片写数据
        g.setColor(Color.blue);
        g.setFont(new Font(null, Font.BOLD, 20));
        g.drawString(makeNum(),0,20);

        //告诉浏览器，这个请求用图片的形式打开
        resp.setContentType("image/jpeg");
        //网站存在缓存，不让浏览器缓存
        resp.setDateHeader("expires", -1);
        resp.setHeader("Cache-Control", "no-cache");
        resp.setHeader("Pragma", "no-cache");

        //把图片写给浏览器
        ImageIO.write(image,"jpg", resp.getOutputStream());
    }

    //生成随机数
    public String makeNum() {
        Random random = new Random();
        String number = random.nextInt(9999999) + "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 7 - number.length(); i++) {
            sb.append(0);
        }
        number = sb.toString() + number;
        return number;
    }
4.实现重定向⭐

一个Web资源收到客户端请求后，它会通知客户端去访问另外一个Web资源，这个过程叫重定向

常见场景：

  • 用户登录
void sendRedirect(String var1) throws IOException;

测试

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/r1/image");
    }

1.5 HttpServletRequest#

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，Http请求中的所有信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息。

1.获取前端传递的参数

javaweb-1.jpg

2.请求转发
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbies = req.getParameterValues("hobby");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbies));

        //ServletContext
        //this.getServletContext().getRequestDispatcher("/success.jsp").forward(req,resp);//绝对路径
        //请求转发
        //req.getRequestDispatcher("/success.jsp").forward(req,resp);//绝对路径
    	//req.getRequestDispatcher("./success.jsp").forward(req,resp);//相对路径
        //重定向
        resp.sendRedirect("./success.jsp");//相对路径
    }

getRequestDispatcher(url)分为两种情况：

  • req.getRequestDispatche(url)，这里的url可以是相对路径，也可以是绝对路径
  • this.getServletContext().getRequestDispatcher(url)，这里的url只能是绝对路径

resp.sendRedirect(url)则是相对路径

2. Cookie、Session#

2.1 会话#

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话

有状态会话：当浏览某页面时，下次再来时，能知道你来过，称之为有状态会话

2.2 保存会话的两种技术#

  • cookie

    • 客户端技术（响应，请求）

  • session

    • 服务器技术，可以保存用户的会话信息，我们可以把信息和数据放在session中
Cookie[] cookies = req.getCookies();	//获取cookie
cookie.getName()	//获取cookie的键
cookie.getValue()	//获取cookie的值
Cookie cookie = new Cookie("LastTime", System.currentTimeMillis() + "");	//新建一个cookie
cookie.setMaxAge(24*60*60)	//设置cookie的有效期
resp.addCookie(cookie);		//服务端将cookie响应给客户端

删除cookie

  • 不设置有效期，关闭浏览器，自动生效
  • 设置有效期为0

编码解码

URLEncoder.encode("立g","utf-8")	//编码
URLDecoder.decode(cookie.getValue(),"utf-8")	//解码

2.4 Session（重点⭐）#

什么是Session：

  • 服务器会给每一个用户（浏览器）创建一个Session对象；
  • 一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
  • 用户登录之后，整个网站它都可以访问 --> 保存用户的信息，保存购物车的信息......

javaweb-2.jpg

Session和Cookie的区别：

  • Cookie是把用户的数据写给用户的浏览器，浏览器保存（可以保存多个）
  • Session把用户的数据写到用户独占Session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
  • Session对象由服务创建

使用场景：

  • 保存一个登录用户的信息；
  • 购物车信息；
  • 在整个网站中经常会使用的数据，我们将它保存在Session中；

使用Session：

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //修改乱码
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");

        //获取Session
        HttpSession session = req.getSession();
        //设置Session
        session.setAttribute("person", new Person("立g",22));

        //获取Session的id
        String id = session.getId();

        //判断Session是否是新创建的
        if (session.isNew()) {
            resp.getWriter().write("Session是新创建的，id为：" + id);
        } else {
            resp.getWriter().write("Session已经存在，id为：" + id);
        }
   }

        //获取Session
        HttpSession session = req.getSession();

        //获取demo01所存的数据
        Person person = (Person) session.getAttribute("person");

        System.out.println(person);

会话自动过期：web.xml中配置

<session-config>
    <!--15分钟后会话自动过期，以分钟为单位-->
    <session-timeout>15</session-timeout>
</session-config>

3. JavaBean#

实体类

JavaBean有特定的写法：

  • 必须要有一个无参构造
  • 属性必须私有化
  • 必须有对应的get/set方法

一般用来和数据库的字段做映射，ORM

ORM：对象关系映射

  • 表---->类
  • 字段---->属性
  • 行记录---->对象

4. MVC 三层架构#

什么是MVC：Model View Controller 模型视图控制器

javaweb-3.jpg

5. 过滤器 Filter（重点⭐）#

Filter：过滤器，用来过滤网站的数据：

  • 处理中文乱码
  • 登录验证等

javaweb-4.jpg

Filter开发步骤：

  • 导包

  • 编写过滤器

    1. 导包不要错

      javaweb-5.jpg

    2. //初始化，web服务器启动，就已经初始化了
@Override
public void init(FilterConfig filterConfig) throws ServletException {
    System.out.println("过滤器初始化");
}

/*
    * 1.过滤中的所有代码，在过滤特定请求的时候都会执行
    * 2.必须要让过滤器继续通行
    * filterChain.doFilter(servletRequest, servletResponse);
    * */
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    servletRequest.setCharacterEncoding("utf-8");
    servletResponse.setCharacterEncoding("utf-8");
    servletResponse.setContentType("text/html;charset=utf-8");

    System.out.println("过滤器过滤前=========");
    filterChain.doFilter(servletRequest, servletResponse);  //让我们的请求继续走，如果不写，程序到这里被拦截
    System.out.println("过滤器过滤后=========");
}

//销毁，web服务器关闭的时候，过滤器会销毁
@Override
public void destroy() {
    System.out.println("过滤器销毁");
}

    3. 在web.xml中配置 Filter

    <filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>com.LEEZ.Filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <!--只要是经过/servlet的任何请求，都会经过这个过滤器-->
    <url-pattern>/servlet/*</url-pattern>
</filter-mapping>

过滤器的应用：

用户登录之后才能进入主页，用户注销后不能进入主页

  1. 用户登录之后，向Session中放入用户的数据

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

    String username = req.getParameter("username");

    if (username.equals("admin")) {
        //登录成功后，会给用户一个USER_SESSION,用于判断是否已登录
        req.getSession().setAttribute(USER_SESSION,req.getSession().getId());
		//登陆成功，重定向至主页
        resp.sendRedirect("/sys/success.jsp");
    } else {
        //登录失败，重定向至错误页面
        resp.sendRedirect("/error.jsp");
    }
}

  2. 进入主页的时候，要判断用户是否已经登录，要求：在过滤器中实现

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    //ServletRequest和HttpServletRequest是父子关系，并不一样，需要强转
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    HttpServletResponse response = (HttpServletResponse) servletResponse;
	//获取用户的登录状态
    Object user_session = request.getSession().getAttribute(USER_SESSION);

    if (user_session == null) {
        //重定向回错误页面
        response.sendRedirect("/error.jsp");
    }

    filterChain.doFilter(request,response);
}

6. SMBMS项目（超市订单管理系统）#

javaweb-6.png

数据库：

javaweb-7.png

6.1 项目搭建准备工作#

  1. 搭建一个Maven web项目

    • 目录结构：

      javaweb-8.png

    • pom.xml删掉多余内容

      <?xml version="1.0" encoding="UTF-8"?>

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>JavaWeb_smbms</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
  
</project>

    • web.xml的内容更换为最新

      <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">
</web-app>

  2. 配置Tomcat

    • javaweb-9.png
    • javaweb-10.png

  3. 测试项目是否能运行

    • javaweb-11.png

  4. 导入项目会用到的jar包

    • <dependencies>
    <!--servlet-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
    </dependency>
    <!--jsp-->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.2.1</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <!--jstl-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!--standard-->
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>
</dependencies>

  5. 创建项目包结构

    • javaweb-12.png

  6. 创建实体类，属性私有化，以及对应的get/set方法，ORM映射

    • javaweb-13.png
    • javaweb-14.png
    • javaweb-15.png
    • javaweb-16.png
    • javaweb-17.png

  7. 编写基础公共类

    • 数据库配置文件

      driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimeZone=UTC
username=root
password=

    • 编写数据库公共类

      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) {
            e.printStackTrace();
        }

        driver = properties.getProperty("diver");
        url = properties.getProperty("url");
        username = properties.getProperty("username");
        password = properties.getProperty("password");
    }

    //获取数据库的连接
    public static Connection getConnection() throws Exception {
        Class.forName(driver);
        Connection connection = DriverManager.getConnection(url, username, password);
        return connection;
    }

    //编写查询公共类
    public static ResultSet excute(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet,String sql,Object[] param) throws SQLException {
        //预编译的sql，后面直接执行就行
        preparedStatement = connection.prepareStatement(sql);

        for (int i = 0; i < param.length; i++) {
            //占位符是从1开始，但是数组是从零开始
            preparedStatement.setObject(i + 1, param[i]);
        }

        resultSet = preparedStatement.executeQuery();
        return resultSet;
    }

    //编写增删改公共类
    public static int excute(Connection connection,PreparedStatement preparedStatement,String sql,Object[] param) throws SQLException {
        preparedStatement = connection.prepareStatement(sql);

        for (int i = 0; i < param.length; i++) {
            //占位符是从1开始，但是数组是从零开始
            preparedStatement.setObject(i + 1, param[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();
                //如果调用close()失败，设为null，gc回收
                resultSet = null;
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
                preparedStatement = null;
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        if (connection != null) {
            try {
                connection.close();
                connection = null;
            } catch (SQLException e) {
                e.printStackTrace();
                flag = false;
            }
        }
        return flag;
    }
}

    • 编写字符编码过滤器

      <!--字符编码过滤器-->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>com.LEEZ.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/smbms/*</url-pattern>
</filter-mapping>

  8. 导入静态资源

    • javaweb-18.png

6.2 登录功能实现#

javaweb-19.png

  1. 编写前端页面

  2. 设置首页

    • <!--设置欢迎页面-->
<welcome-file-list>
    <welcome-file>login.jsp</welcome-file>
</welcome-file-list>

  3. 编写dao层，得到用户登录的接口

    //得到要登陆的用户
public User getLoginUser(Connection connection, String userCode) throws Exception;

  4. 编写dao接口的实现类

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

        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        User user = null;

        if (connection != null) {
            String sql = "select * from smbms_user where userCode=?";
            Object[] params = {userCode};

            resultSet = BaseDao.excute(connection, preparedStatement, resultSet, sql, params);

            if (resultSet.next()) {
                user = new User();
                user.setId(resultSet.getInt("id"));
                user.setUserCode(resultSet.getString("userCode"));
                user.setUserName(resultSet.getString("userName"));
                user.setUserPassword(resultSet.getString("userPassword"));
                user.setGender(resultSet.getInt("gender"));
                user.setBirthday(resultSet.getDate("birthday"));
                user.setPhone(resultSet.getString("phone"));
                user.setAddress(resultSet.getString("address"));
                user.setUserRole(resultSet.getInt("userRole"));
                user.setCreatedBy(resultSet.getInt("createdBy"));
                //注意，这里不是用getDate(),而是用getTimestamp()获取时间戳
                user.setCreationDate(resultSet.getTimestamp("creationDate"));
                user.setModifyBy(resultSet.getInt("modifyBy"));
                //注意，这里不是用getDate(),而是用getTimestamp()获取时间戳
                user.setModifyDate(resultSet.getTimestamp("modifyDate"));
            }

            BaseDao.closeResource(null, preparedStatement, resultSet);
        }
        return user;
    }
}

  5. service业务层接口

    //用户登录
public User login(String userCode,String userPassword) throws Exception;

  6. service业务层接口的实现类

    public class UserServiceImpl implements UserService {
    //业务层都会调用dao层，所以要引入dao层
    private UserDao userDao;

    public UserServiceImpl() {
        userDao = new UserDaoImpl();
    }

    @Override
    public User login(String userCode, String userPassword) throws Exception {
        Connection connection = null;
        User user = null;

        connection = BaseDao.getConnection();
        //通过业务层调用具体的数据库操作
        user = userDao.getLoginUser(connection, userCode);
        
        //将从数据库获取的对象与前端输入的数据进行比对
        if (!userPassword.equals(user.getUserPassword())) {//如果密码不正确
            user = null;
        }

        BaseDao.closeResource(connection, null, null);
        
        return user;
    }
}

  7. 编写Servlet

    public class LoginServlet extends HttpServlet {

    //控制层Servlet：调用业务层Service代码

    @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");

        User user = null;

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

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

        if (user != null) {//查有此人，可以登录
            //将用户的信息放到Session
            req.getSession().setAttribute(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.LEEZ.servlet.user.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/login.do</url-pattern>
</servlet-mapping>

  9. 测试访问，确保以上功能成功

6.3 登录功能优化#

  • 注销功能

思路：移除Session，返回登录界面

public class LogoutServlet extends HttpServlet {
 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     req.getSession().removeAttribute(Constant.USER_SESSION);

     resp.sendRedirect(req.getContextPath() + "/login.jsp");
 }

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

注册xml

<!--注销登录-->
<servlet>
 <servlet-name>LogoutServlet</servlet-name>
 <servlet-class>com.LEEZ.servlet.user.LogoutServlet</servlet-class>
</servlet>
<servlet-mapping>
 <servlet-name>LogoutServlet</servlet-name>
 <url-pattern>/jsp/logout.do</url-pattern>
</servlet-mapping>
  • 登录拦截优化
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    HttpServletResponse response = (HttpServletResponse) servletResponse;

    User user = (User) request.getSession().getAttribute(Constant.USER_SESSION);

    //判断用户是否为登录状态
    if (user == null) {
        //重定向至登陆界面
        response.sendRedirect(request.getContextPath() + "/error.jsp");
    } else {
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

注册xml

<!--登录拦截过滤器-->
<filter>
    <filter-name>SysFilter</filter-name>
    <filter-class>com.LEEZ.filter.SysFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>SysFilter</filter-name>
    <url-pattern>/jsp/*</url-pattern>
</filter-mapping>

6.4 密码修改#

javaweb-20.png

  1. 导入静态资源

  2. 编写UserDao接口

    //修改当前用户密码
public int updatePwd(Connection connection, int id, String userPassword) throws Exception;

  3. 编写UserDao接口的实现类

    //修改当前用户密码
@Override
public int updatePwd(Connection connection, int id, String userPassword) throws Exception {
    PreparedStatement preparedStatement = null;
    int updateRows = 0;

    if (connection != null) {
        String sql = "update smbms_user set userPassword = ? where id = ?";
        Object[] params = {userPassword,id};

        updateRows = BaseDao.excute(connection, preparedStatement, sql, params);

        BaseDao.closeResource(null, preparedStatement, null);
    }

    return updateRows;
}

  4. 编写UserService业务层接口

    //用户修改当前密码
public boolean updatePwd(int id, String userPassword);

  5. 编写UserService业务层接口的实现类

    @Override
public boolean updatePwd(int id, String userPassword){
    //首先业务层要调用dao层，因此需要在业务层创建连接，然后传参给dao
    Connection connection = null;
    boolean flag = false;

    try {
        connection = BaseDao.getConnection();
        int updateRows = userDao.updatePwd(connection, id, userPassword);
        if (updateRows > 0) {//说明更新成功，可以提交事务
            flag = true;
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        BaseDao.closeResource(connection, null, null);
    }
    return flag;
}

  6. 编写Servlet

    public void updatePwd(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //首先要获取已登录的用户的信息
    Object o = req.getSession().getAttribute(Constant.USER_SESSION);
    //Integer id = ((User)o).getId();
    String userPassword = req.getParameter("newpassword");

    boolean flag = false;

    //首先判断session和输入的新密码是否为空
    if (o != null && !StringUtils.isNullOrEmpty(userPassword)) {
        //将前端信息传到service层得到返回结果
        UserService userService = new UserServiceImpl();
        flag = userService.updatePwd(((User)o).getId(), userPassword);
        if (flag) {//如果更新成功，返回成功信息，移除session，重定向回登陆页面
            req.setAttribute(Constant.MESSAGE, "修改密码成功，请使用新密码重新登录");//更新失败
            req.getSession().removeAttribute(Constant.USER_SESSION);
        } else {//如果更新失败，返回失败信息，转发回当前页
            req.setAttribute(Constant.MESSAGE, "修改密码失败，请重试");
        }
    } else {
        req.setAttribute(Constant.MESSAGE, "密码不能为空");
    }
    req.getRequestDispatcher("pwdmodify.jsp").forward(req, resp);
}

  7. 配置xml

    <!--修改密码-->
<servlet>
    <servlet-name>UserServlet</servlet-name>
    <servlet-class>com.LEEZ.servlet.user.UserServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>UserServlet</servlet-name>
    <url-pattern>/jsp/user.do</url-pattern>
</servlet-mapping>

  8. 实现Servlet复用

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

6.5 密码修改优化#

  1. 导入阿里巴巴的json工具类

    <!--json-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.12</version>
</dependency>

  2. ajax

    oldpassword.on("blur",function(){//JQuery失去焦点
    $.ajax({
        type:"GET",
        url:path+"/jsp/user.do",
        data:{method:"pwdmodify",oldpassword:oldpassword.val()},//data就是ajax传递的参数
        /*
			上面这句话等价于path+"/jsp/user.do？method="pwdmodify"&&oldpassword=oldpassword.val()
			*/
        dataType:"json",//主流开发都是用JSON实现前后端开发{}
        success:function(data){
            if(data.result == "true"){//旧密码正确
                validateTip(oldpassword.next(),{"color":"green"},imgYes,true);
            }else if(data.result == "false"){//旧密码输入不正确
                validateTip(oldpassword.next(),{"color":"red"},imgNo + " 原密码输入不正确",false);
            }else if(data.result == "sessionerror"){//当前用户session过期，请重新登录
                validateTip(oldpassword.next(),{"color":"red"},imgNo + " 当前用户session过期，请重新登录",false);
            }else if(data.result == "error"){//旧密码输入为空
                validateTip(oldpassword.next(),{"color":"red"},imgNo + " 请输入旧密码",false);
            }
        },
        error:function(data){
            //请求出错
            validateTip(oldpassword.next(),{"color":"red"},imgNo + " 请求错误",false);
        }
    });

    saveBtn.on("click",function(){
        oldpassword.blur();
        newpassword.blur();
        rnewpassword.blur();
        if(oldpassword.attr("validateStatus") == "true"&&
           newpassword.attr("validateStatus") == "true"
           && rnewpassword.attr("validateStatus") == "true"){
            if(confirm("确定要修改密码？")){
                $("#userForm").submit();
            }
        }

    });

  3. 后台代码

    //验证旧密码
public void pwdmodify(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    String oldpassword = req.getParameter("oldpassword");
    User user = (User) req.getSession().getAttribute(Constant.USER_SESSION);

    //万能的map
    Map<String, String> resultMap = new HashMap<>();

    if (user == null) {//session失效了，session过期了
        resultMap.put("result", "sessionerror");
    } else if (oldpassword == null) {
        resultMap.put("result", "error");
    } else {
        if (!oldpassword.equals(user.getUserPassword())) {
            resultMap.put("result", "false");
        } else {
            resultMap.put("result", "true");
        }
    }

    resp.setContentType("application/json");
    PrintWriter writer = resp.getWriter();
    //JSONArray是阿里巴巴的json工具类， 转换格式
    /*
        * resultMap = ["result","sessionerror","result","false"]
        * 转为Json格式 = {"result":"sessionerror"}
        * */
    writer.write(JSONArray.toJSONString(resultMap));
    writer.flush();
    writer.close();
}

6.6 用户管理功能实现#

思路

javaweb-21.png

  1. 导入分页的工具类

  2. 导入用户列表页面

    userlist.jsp rollpage.jsp

6.6.1 获取用户数量#

  1. UserDao

    //查询用户总数
public int getUserCount(Connection connection, String userName, int userRole)throws Exception;

  2. UserDaoImpl

    //根据用户名或者角色查询用户总数
@Override
public int getUserCount(Connection connection, String userName, int userRole) throws Exception {
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    int userCount = 0;

    if (connection != null) {
        StringBuffer sql = new StringBuffer();
        sql.append("select count(1) as count from smbms_user su , smbms_role sr where su.userRole = sr.id");
        //存放我们的参数
        ArrayList<Object> list = new ArrayList<>();

        if (userName != null) {
            sql.append(" and userName like ?");
            list.add("%" + userName + "%");
        }
        if (userRole > 0) {
            sql.append(" and sr.id = ?");
            list.add(userRole);
        }

        //把list转化为数组
        Object[] params = list.toArray();
        System.out.println("UserDaoImpl-->getUserCount:"+sql.toString());

        resultSet = BaseDao.excute(connection, preparedStatement, resultSet, sql.toString(), params);
        if (resultSet.next()) {
            userCount = resultSet.getInt("count");//上面sql语句"as count"
        }
        BaseDao.closeResource(null, preparedStatement, resultSet);
    }
    return userCount;
}

  3. UserService

    //查询用户总数
public int getUserCount(String userName, int userRole) throws Exception;

  4. UserServiceImpl

    //查询用户总数
@Override
public int getUserCount(String userName, int userRole) throws Exception {
    Connection connection = BaseDao.getConnection();

    int userCount = userDao.getUserCount(connection, userName, userRole);

    BaseDao.closeResource(connection, null, null);

    return userCount;
}

6.6.2 获取用户列表#

  1. UserDao

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

  2. UserDaoImpl

    //获取用户列表
@Override
public List<User> getUserList(Connection connection, String userName, int userRole, int currentPageNo, int pageSize) throws SQLException {
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    List<User> users = new ArrayList<User>();
    List<Object> list = new ArrayList<Object>();

    if (connection != null) {
        StringBuffer sql = new StringBuffer();
        sql.append("Select u.*,r.roleName from smbms_user u,smbms_role r where u.userRole = r.id");

        if (userName != null) {
            sql.append(" and u.userName like ?");
            list.add("%" + userName + "%");
        }
        if (userRole > 0) {
            sql.append(" and u.userRole = ?");
            list.add(userRole);
        }
        //起始索引 = （当前页 - 1）*页面大小
        int startNo = (currentPageNo - 1) * pageSize;
        sql.append(" limit ?,?");
        list.add(startNo);
        list.add(pageSize);

        System.out.println("UserDaoImpl-->getUserList:" + sql.toString());

        //将list转为数组
        Object[] params = list.toArray();

        resultSet = BaseDao.excute(connection, preparedStatement, resultSet, sql.toString(), params);

        //将得到的结果进行封装
        while (resultSet.next()) {
            User user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUserCode(resultSet.getString("userCode"));
            user.setUserName(resultSet.getString("userName"));
            user.setUserPassword(resultSet.getString("userPassword"));
            user.setGender(resultSet.getInt("gender"));
            user.setBirthday(resultSet.getDate("birthday"));
            user.setPhone(resultSet.getString("phone"));
            user.setAddress(resultSet.getString("address"));
            user.setUserRole(resultSet.getInt("userRole"));
            user.setCreatedBy(resultSet.getInt("createdBy"));
            //注意，这里不是用getDate(),而是用getTimestamp()获取时间戳
            user.setCreationDate(resultSet.getTimestamp("creationDate"));
            user.setModifyBy(resultSet.getInt("modifyBy"));
            //注意，这里不是用getDate(),而是用getTimestamp()获取时间戳
            user.setModifyDate(resultSet.getTimestamp("modifyDate"));
            users.add(user);
        }
        BaseDao.closeResource(null,preparedStatement,resultSet);
    }
    return users;
}

  3. UserService

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

  4. UserServiceImpl

    @Override
public List<User> getUserList(String userName, int userRole, int currentPageNo, int pageSize) throws Exception {
    Connection connection = BaseDao.getConnection();
    List<User> users = userDao.getUserList(connection, userName, userRole, currentPageNo, pageSize);
    BaseDao.closeResource(connection, null, null);
    return users;
}

6.6.3 获取角色列表#

  1. RoleDao

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

  2. RoleDaoImpl

    //获取角色列表
@Override
public List<Role> getRoleList(Connection connection) throws SQLException {
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    List<Role> roleList = new ArrayList<Role>();

    if (connection != null) {
        String sql = "select * from smbms_role";
        Object[] params = {};

        resultSet = BaseDao.excute(connection, preparedStatement, resultSet, sql, params);
        while (resultSet.next()) {
            Role role = new Role();
            role.setId(resultSet.getInt("id"));
            role.setRoleCode(resultSet.getString("roleCode"));
            role.setRoleName(resultSet.getString("roleName"));
            role.setCreatedBy(resultSet.getInt("createdBy"));
            role.setCreationDate(resultSet.getTimestamp("creationDate"));
            role.setModifyBy(resultSet.getInt("modifyBy"));
            role.setModifyDate(resultSet.getTimestamp("modifyDate"));
            roleList.add(role);
        }
        BaseDao.closeResource(null, preparedStatement, resultSet);
    }
    return roleList;
}

  3. RoleService

    //获取角色列表
public List<Role> getRoleList() throws Exception;

  4. RoleServiceImpl

    //获取角色列表
@Override
public List<Role> getRoleList() throws Exception {
    Connection connection = BaseDao.getConnection();
    List<Role> roleList = roleDao.getRoleList(connection);
    BaseDao.closeResource(connection, null, null);
    return roleList;
}

6.6.4 编写UserServlet的query方法#

  1. Page工具类

    public class Page {
	//当前页码-来自于用户输入
	private int currentPageNo;
	
	//总数量（表）
	private int totalCount;
	
	//页面容量
	private int pageSize;
	
	//总页数-totalCount/pageSize（+1）
	private int totalPageCount;

	public Page(int currentPageNo, int totalCount, int pageSize) {
		this.currentPageNo = currentPageNo;
		this.totalCount = totalCount;
		this.pageSize = pageSize;

		//初始化的时候就把totalPageCount给算了，然后直接获取
		this.setTotalPageCount(totalCount,pageSize);
	}

	public Page() {
	}

	public int getCurrentPageNo() {
		return currentPageNo;
	}
	public void setCurrentPageNo(int currentPageNo) {
		if(currentPageNo > 0){
			this.currentPageNo = currentPageNo;
		}
	}

	public int getTotalCount() {
		return totalCount;
	}
	public void setTotalCount(int totalCount) {
		if(totalCount > 0){
			this.totalCount = totalCount;
		}
	}

	public int getPageSize() { return pageSize;
	}
	public void setPageSize(int pageSize) {
		if(pageSize > 0){
			this.pageSize = pageSize;
		}
	}

	public int getTotalPageCount() {
		return totalPageCount;
	}
	public void setTotalPageCount(int totalCount,int pageSize) {
		if(totalCount % pageSize == 0){
			this.totalPageCount = totalCount / pageSize;
		}else if(totalCount % pageSize > 0){
			this.totalPageCount = totalCount / pageSize + 1;
		}else{
			this.totalPageCount = 0;
		}
	}
}

  2. UserServlet-->query

    //获取用户列表
public void query(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    System.out.println("UserServlet-->query===================================================================================");
    //搜索框功能，按userName或roleName搜索
    //首先从前端获取参数
    String queryname = req.getParameter("queryname");
    String tempQueryUserRole = req.getParameter("queryUserRole");
    String pageIndex = req.getParameter("pageIndex");
    //先设置一个默认的userRole，以防第一次获取tempQueryUserRole时为null
    int userRole = 0;
    int currentPageNo = 1;

    UserService userService = new UserServiceImpl();
    RoleService roleService = new RoleServiceImpl();
    List<User> userList = null;
    List<Role> roleList = null;

    System.out.println("UserServlet-->queryname = " + queryname);
    System.out.println("UserServlet-->queryUserRole = " + userRole);
    System.out.println("UserServlet-->pageIndex = " + pageIndex);

    if (queryname == null) {//这里为空，说明用户没有输入要查询的用户名，则sql语句传值为""，%%，会查询所有记录
        queryname = "";
    }
    //对tempQueryUserRole进行转变
    if (tempQueryUserRole != null && !tempQueryUserRole.equals("")) {
        userRole = Integer.parseInt(tempQueryUserRole);
    }
    //对pageIndex进行转变
    if (pageIndex != null) {
        currentPageNo = Integer.parseInt(pageIndex);
    }

    //底部分页功能
    //前端需要totalCount，currentPageNo，totalPageCount
    int totalCount = userService.getUserCount(queryname, userRole);
    Page page = new Page(currentPageNo,totalCount,Constant.PAGESIZE);
    int totalPageCount = page.getTotalPageCount();

    System.out.println("UserServlet-->totalCount = " + totalCount);
    System.out.println("UserServlet-->currentPageNo = " + currentPageNo);
    System.out.println("UserServlet-->pagesize = " + Constant.PAGESIZE);
    System.out.println("UserServlet-->totalPageCount = " + totalPageCount);

    if (currentPageNo < 1) {
        currentPageNo = 1;
    } else if (currentPageNo > totalPageCount) {
        currentPageNo = totalPageCount;
    }

    //获取前端需要的用户信息列表userList
    //需要userName,userRole,currentPageNo,pageSize这些参数
    userList = userService.getUserList(queryname, userRole, currentPageNo, Constant.PAGESIZE);

    //用户信息展示功能
    //获取前端需要的roleName列表
    roleList = roleService.getRoleList();

    //将获取到的userList返回给前端
    req.setAttribute("userList", userList);
    //获取到前端需要的参数，roleList,返回给前端
    req.setAttribute("roleList", roleList);

    req.setAttribute("queryUserName", queryname);
    req.setAttribute("queryUserRole", userRole);

    //req.setAttribute("totalPageCount", totalPageCount);
    req.setAttribute("totalPageCount", totalPageCount);
    req.setAttribute("totalCount", totalCount);
    req.setAttribute("currentPageNo", currentPageNo);

    //返回前端
    req.getRequestDispatcher("userlist.jsp").forward(req, resp);
    System.out.println("UserServlet-->query===================================================================================");
}

分析query方法的具体实现

  1. 获取前端返回的参数

    //搜索框功能，按userName或roleName搜索
//首先从前端获取参数
String queryname = req.getParameter("queryname");
String tempQueryUserRole = req.getParameter("queryUserRole");
String pageIndex = req.getParameter("pageIndex");
//先设置一个默认的userRole，以防第一次获取tempQueryUserRole时为null
int userRole = 0;
int currentPageNo = 1;

  2. 对获取的参数进行判断，判断是否需要修改

    if (queryname == null) {//这里为空，说明用户没有输入要查询的用户名，则sql语句传值为""，%%，会查询所有记录
    queryname = "";
}
//对tempQueryUserRole进行转变
if (tempQueryUserRole != null && !tempQueryUserRole.equals("")) {
    userRole = Integer.parseInt(tempQueryUserRole);
}
//对pageIndex进行转变
if (pageIndex != null) {
    currentPageNo = Integer.parseInt(pageIndex);
}

  3. 数据过多，需要分页，因此要先将分页的各个参数完成

    //底部分页功能
//前端需要totalCount，currentPageNo，totalPageCount
int totalCount = userService.getUserCount(queryname, userRole);
Page page = new Page(currentPageNo,totalCount,Constant.PAGESIZE);
int totalPageCount = page.getTotalPageCount();

if (currentPageNo < 1) {
    currentPageNo = 1;
} else if (currentPageNo > totalPageCount) {
    currentPageNo = totalPageCount;
}

  4. 将前端参数以及分页参数传给service层进行处理，得到返回数据

    //获取前端需要的用户信息列表userList
//需要userName,userRole,currentPageNo,pageSize这些参数
userList = userService.getUserList(queryname, userRole, currentPageNo, Constant.PAGESIZE);

//用户信息展示功能
//获取前端需要的roleName列表
roleList = roleService.getRoleList();

  5. 将前端需要的数据返回到前端

    //将获取到的userList返回给前端
req.setAttribute("userList", userList);
//获取到前端需要的参数，roleList,返回给前端
req.setAttribute("roleList", roleList);

req.setAttribute("queryUserName", queryname);
req.setAttribute("queryUserRole", userRole);

//req.setAttribute("totalPageCount", totalPageCount);
req.setAttribute("totalPageCount", totalPageCount);
req.setAttribute("totalCount", totalCount);
req.setAttribute("currentPageNo", currentPageNo);

//返回前端
req.getRequestDispatcher("userlist.jsp").forward(req, resp);

6.6.5 增加用户功能#

  1. UserDao

    //新增用户
public int addUser(Connection connection, User user) throws SQLException;

//查询用户编码是否已存在
public boolean ucexist(Connection connection, String userCode) throws SQLException;

  2. UserDaoImpl

    //新增用户
@Override
public int addUser(Connection connection, User user) throws SQLException {
    PreparedStatement preparedStatement = null;
    int resultRow = 0;

    if (connection != null) {
        String sql = "insert into smbms_user(userCode,userName,userPassword,gender,birthday,phone,address,userRole,createdBy,creationDate) values (?,?,?,?,?,?,?,?,?,?)";

        String userCode = user.getUserCode();
        String userName = user.getUserName();
        String userPassword = user.getUserPassword();
        int gender = user.getGender();
        Date birthday = user.getBirthday();
        String phone = user.getPhone();
        String address = user.getAddress();
        int userRole = user.getUserRole();
        int createBy = user.getCreatedBy();
        Date creationDate = user.getCreationDate();

        System.out.println("UserDaoImpl-->addUser:userCode: " + userCode);
        System.out.println("UserDaoImpl-->addUser:userName: " + userName);
        System.out.println("UserDaoImpl-->addUser:userPassword: " + userPassword);
        System.out.println("UserDaoImpl-->addUser:gender: " + gender);
        System.out.println("UserDaoImpl-->addUser:birthday: " + birthday);
        System.out.println("UserDaoImpl-->addUser:phone: " + phone);
        System.out.println("UserDaoImpl-->addUser:address: " + address);
        System.out.println("UserDaoImpl-->addUser:userRole: " + userRole);
        System.out.println("UserDaoImpl-->addUser:createBy: " + createBy);
        System.out.println("UserDaoImpl-->addUser:creationDate: " + creationDate);

        Object[] params = {userCode, userName, userPassword, gender, birthday, phone, address, userRole, createBy, creationDate};

        resultRow = BaseDao.excute(connection, preparedStatement, sql, params);

        BaseDao.closeResource(null, preparedStatement, null);
    }

    return resultRow;

}

//查询用户编码是否重复
@Override
public boolean ucexist(Connection connection, String userCode) throws SQLException {
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    boolean flag = false;

    if (connection != null) {
        String sql = "select * from smbms_user where userCode = ?";
        Object[] params = {userCode};
        resultSet = BaseDao.excute(connection, preparedStatement, resultSet, sql, params);
        if (resultSet.next()) {
            flag = true;
        }
        BaseDao.closeResource(null, preparedStatement, resultSet);
    }
    return flag;
}

  3. UserService

    //新增用户
public boolean addUser(User user) throws Exception;

//查询用户编码是否重复
public boolean ucexist(String userCode) throws Exception;

  4. UserServiceImpl

    //新增用户
@Override
public boolean addUser(User user) throws Exception {
    Connection connection = null;
    boolean flag = false;
    try {
        connection = BaseDao.getConnection();
        //涉及增删改需要增加事务
        connection.setAutoCommit(false);
        int resultRow = userDao.addUser(connection, user);
        connection.commit();

        if (resultRow > 0) {
            flag = true;
            System.out.println("UserServiceImpl-->addUser: add success");
        } else {
            System.out.println("UserServiceImpl-->addUser: add failed");
        }
    } catch (Exception e) {
        e.printStackTrace();
        connection.rollback();
        System.out.println("UserServiceImpl-->addUser: roll back!");
    } finally {
        BaseDao.closeResource(connection, null, null);
    }
    return flag;
}

//查询用户编码是否重复
@Override
public boolean ucexist(String userCode) throws Exception {
    Connection connection = BaseDao.getConnection();
    boolean flag = userDao.ucexist(connection, userCode);
    BaseDao.closeResource(connection, null, null);
    return flag;
}

  5. UserServlet-->add()、getrolelist()、ucexist()

    //新增用户
public void add(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    System.out.println("UserServlet-->add===================================================================================");
    //首先获取前端参数
    String userCode = req.getParameter("userCode");
    String userName = req.getParameter("userName");
    String userPassword = req.getParameter("userPassword");
    Integer gender =Integer.parseInt(req.getParameter("gender"));
    String tempBirthday = req.getParameter("birthday");
    String phone = req.getParameter("phone");
    String address = req.getParameter("address");
    Integer userRole = Integer.parseInt(req.getParameter("userRole"));

    //登录者即为新用户的创建者
    User loginer = (User) req.getSession().getAttribute(Constant.USER_SESSION);
    int createdBy = loginer.getUserRole();

    //对获取到的birthday转型为date
    Date birthday = new SimpleDateFormat("yyyy-MM-dd").parse(tempBirthday);
    Date date = new Date();
    java.sql.Date creationDate = new java.sql.Date(date.getTime());

    //新用户
    User user = new User(userCode, userName, userPassword, gender, birthday, phone, address, userRole, createdBy, creationDate);

    //封装好后传给service
    UserService userService = new UserServiceImpl();
    boolean flag = userService.addUser(user);

    if (flag) {
        System.out.println("UserServlet-->add: Success");
        //返回前端新增用户的结果
        req.setAttribute(Constant.MESSAGE,"添加用户成功！请返回主页");
    } else {
        System.out.println("UserServlet-->add: failed");
        req.setAttribute(Constant.MESSAGE,"添加用户失败！请重试！");
    }

    //添加完后转发回当前页
    req.getRequestDispatcher("useradd.jsp").forward(req, resp);

    System.out.println("UserServlet-->add===================================================================================");
}

//ajax获取roleList
public void getrolelist(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    System.out.println("UserServlet-->getrolelist===================================================================================");

    RoleService roleService = new RoleServiceImpl();
    List<Role> roleList = roleService.getRoleList();

    //ajax获取，需要转为json格式
    resp.setContentType("application/json");
    PrintWriter writer = resp.getWriter();
    writer.write(JSONArray.toJSONString(roleList));
    writer.flush();
    writer.close();

    System.out.println("UserServlet-->getrolelist===================================================================================");
}

//ajax判断用户编码是否已经存在
public void ucexist(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    System.out.println("UserServlet-->ucexist===================================================================================");
    //获取前端输入的用户编码
    String preUserCode = req.getParameter("userCode");

    //传入service进行判断
    UserService userService = new UserServiceImpl();
    boolean ifexist = userService.ucexist(preUserCode);

    Map<String, String> result = new HashMap<>();

    if (ifexist) {
        result.put("userCode", "exist");
    } else {
        result.put("userCode", "notExist");
    }

    resp.setContentType("application/json");
    PrintWriter writer = resp.getWriter();
    writer.write(JSONArray.toJSONString(result));
    writer.flush();
    writer.close();
}

6.6.6 删除用户功能#

  1. UserDao

    //删除用户
public boolean delUser(Connection connection, int uesrId) throws SQLException;

  2. UserDaoImpl

    //删除用户
@Override
public boolean delUser(Connection connection, int uesrId) throws SQLException {
    PreparedStatement preparedStatement = null;
    boolean flag = false;

    if (connection != null) {
        String sql = "delete from smbms_user where id = ?";
        Object[] params = {uesrId};
        int resultRow = BaseDao.excute(connection, preparedStatement, sql, params);
        if (resultRow > 0) {
            flag = true;
        }
        BaseDao.closeResource(null, preparedStatement, null);
    }
    return flag;
}

  3. UserService

    //删除用户
public boolean delUser(int userId) throws Exception;

  4. UserServiceImpl

    //删除用户
@Override
public boolean delUser(int userId) throws Exception {
    Connection connection = null;
    boolean flag = false;
    try {
        connection = BaseDao.getConnection();
        connection.setAutoCommit(false);
        flag = userDao.delUser(connection, userId);
        connection.commit();
    } catch (Exception e) {
        e.printStackTrace();
        connection.rollback();
    } finally {
        BaseDao.closeResource(connection, null, null);
    }
    return flag;
}

  5. UserServlet-->deluser

    //删除用户
public void deluser(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    System.out.println("UserServlet-->delUser===================================================================================");
    //获取前端参数
    String userid = req.getParameter("uid");

    Map<String, String> result = new HashMap<>();

    //需要对userid进行判断
    if (userid == null) {
        result.put("delResult", "notexist");
    } else {
        UserService userService = new UserServiceImpl();
        boolean flag = userService.delUser(Integer.parseInt(userid));
        if (flag) {
            result.put("delResult", "true");
        } else {
            result.put("delResult", "false");
        }
    }

    //需要将数据转为json格式
    resp.setContentType("application/json");
    PrintWriter writer = resp.getWriter();
    writer.write(JSONArray.toJSONString(result));
    writer.flush();
    writer.close();
}

6.6.7 查看用户功能#

  1. UserDao

    //查看用户详情
public User viewUser(Connection connection, int userId) throws SQLException;

  2. UserDaoImpl

    //查看用户详情
@Override
public User viewUser(Connection connection, int userId) throws SQLException {
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    User user = null;

    if (connection != null) {
        String sql = "select * from smbms_user u,smbms_role r where u.userRole = r.id and u.id = ?";
        Object[] params = {userId};
        resultSet = BaseDao.excute(connection, preparedStatement, resultSet, sql, params);
        if (resultSet.next()) {
            user = new User();
            user.setId(resultSet.getInt("id"));
            user.setUserCode(resultSet.getString("userCode"));
            user.setUserName(resultSet.getString("userName"));
            user.setUserPassword(resultSet.getString("userPassword"));
            user.setGender(resultSet.getInt("gender"));
            user.setBirthday(resultSet.getDate("birthday"));
            user.setPhone(resultSet.getString("phone"));
            user.setAddress(resultSet.getString("address"));
            user.setUserRole(resultSet.getInt("userRole"));
            user.setUserRoleName(resultSet.getString("roleName"));
            user.setCreatedBy(resultSet.getInt("createdBy"));
            //注意，这里不是用getDate(),而是用getTimestamp()获取时间戳
            user.setCreationDate(resultSet.getTimestamp("creationDate"));
            user.setModifyBy(resultSet.getInt("modifyBy"));
            //注意，这里不是用getDate(),而是用getTimestamp()获取时间戳
            user.setModifyDate(resultSet.getTimestamp("modifyDate"));
            user.setAge();
        }
        BaseDao.closeResource(null, preparedStatement, resultSet);
    }
    return user;
}

  3. UserService

    //查看用户详情
public User viewUser(int userId) throws Exception;

  4. UserServiceImpl

    //查看用户详情
@Override
public User viewUser(int userId) throws Exception {
    Connection connection = BaseDao.getConnection();
    User user = userDao.viewUser(connection, userId);
    return user;
}

  5. UserServlet-->deluser

    //查看用户详情
public void view(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    System.out.println("UserServlet-->view===================================================================================");
    //获取前端传递的参数
    String id = req.getParameter("uid");
    System.out.println("UserServlet-->view--> userid:"+id);

    //对参数进行判断
    if (id != null) {
        int userid = Integer.parseInt(id);
        //将参数传递给service层
        UserService userService = new UserServiceImpl();
        User user = userService.viewUser(userid);

        System.out.println("UserServlet-->view--> user:"+user);

        //对得到的user对象进行判断
        if (user != null) {
            req.setAttribute("user",user);
            //不能用重定向，重定向后两次请求的数据不共享
            req.getRequestDispatcher("userview.jsp").forward(req,resp);
        } else {//失败则转发回用户列表
            req.getRequestDispatcher("userlist.jsp").forward(req,resp);
        }
    }
}

6.6.8 修改用户功能#

  1. UserDao

    //修改用户信息
public int updateUser(Connection connection, User user) throws SQLException;

  2. UserDaoImpl

    //修改用户信息
@Override
public int updateUser(Connection connection, User user) throws SQLException {
    PreparedStatement preparedStatement = null;
    User updatedUser = null;
    int resultRow = 0;

    if (connection != null) {
        String sql = "update smbms_user set userName = ?, gender = ?, birthday = ?, phone = ?, address = ?, userRole = ?, modifyBy = ?, modifyDate = ? where id = ?";
        Object[] params = {user.getUserName(), user.getGender(), user.getBirthday(), user.getPhone(), user.getAddress(), user.getUserRole(),user.getModifyBy(), user.getModifyDate(),user.getId()};
        resultRow = BaseDao.excute(connection, preparedStatement, sql, params);
        BaseDao.closeResource(null, preparedStatement, null);
    }
    return resultRow;
}

  3. UserService

    //修改用户信息
public boolean updateUser(User user) throws Exception;

  4. UserServiceImpl

    //修改用户信息
@Override
public boolean updateUser(User user) throws Exception {
    Connection connection = null;
    boolean flag = false;
    try {
        connection = BaseDao.getConnection();
        connection.setAutoCommit(false);
        int resultRow = userDao.updateUser(connection, user);
        connection.commit();
        if (resultRow > 0) {
            flag = true;
        }
    } catch (Exception e) {
        e.printStackTrace();
        connection.rollback();
    } finally {
        BaseDao.closeResource(connection, null, null);
    }
    return flag;
}

  5. UserServlet-->modifyexe

    //修改用户信息2，获取要修改的字段
public void modifyexe(HttpServletRequest req, HttpServletResponse resp) throws Exception {
    System.out.println("UserServlet-->modifyexe===================================================================================");
    //获取前端拿到的参数,被修改者
    Integer userid =Integer.parseInt(req.getParameter("uid"));
    String userName = req.getParameter("userName");
    Integer gender = Integer.parseInt(req.getParameter("gender"));
    String tempbirthday = req.getParameter("birthday");
    Date birthday = new SimpleDateFormat("yyyy-MM-dd").parse(tempbirthday);
    String phone = req.getParameter("phone");
    String address = req.getParameter("address");
    Integer userRole = Integer.parseInt(req.getParameter("userRole"));
    //修改者，也就是正在登录的人
    User login = (User) req.getSession().getAttribute(Constant.USER_SESSION);
    Integer modifyBy = login.getId();
    Date modifyDate = new SimpleDateFormat("yyyy-MM-dd").parse(new Date().toLocaleString());

    //对参数进行封装
    User user = new User(userid, userName, gender, birthday, phone, address, userRole, modifyBy, modifyDate);
    //传给service层进行处理
    UserService userService = new UserServiceImpl();
    boolean flag = userService.updateUser(user);
    if (flag) {
        //更改成功，返回成功信息
        req.setAttribute(Constant.MESSAGE, "修改信息成功，请返回用户列表");
    } else {
        //更改失败，重试
        req.setAttribute(Constant.MESSAGE, "修改信息失败，请重试");
    }
    req.getRequestDispatcher("usermodify.jsp").forward(req, resp);
}

6.7 供应商管理#

未完待续

6.8 订单管理#

未完待续

作者：LEEZ

出处：https://www.cnblogs.com/leezStudy/p/16880382.html

版权：本作品采用「署名-非商业性使用-相同方式共享 4.0 国际」许可协议进行许可。

声明：转载请注明出处！

posted @   CV攻城狮~  阅读(24)  评论(0)  编辑  收藏  举报
相关博文：
·  Mybatis学习
·  SpringMVC学习
·  JavaWeb基础01
·  JavaWeb实现smbms项目核心功能
·  JavaWeb学习6：Servlet
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· winform 绘制太阳，地球，月球 运作规律
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
more_horiz
keyboard_arrow_up dark_mode palette
选择主题
menu
点击右上角即可分享
微信分享提示
AI IDE Trae