JavaWeb学习

1. Servlet

1.1 Servlet简介

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

1.2 HelloServlet

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

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

关于Maven父子工程的理解：

父项目中会有：

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

子项目中会有：

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

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

Maven环境优化：

修改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>

将Maven的结构搭建完整

编写一个Servlet程序

编写一个普通类

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

编写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>

配置Tomcat
测试运行

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.下载文件

要获取下载文件的路径
下载的文件名是啥？
设置想办法让浏览器能够支持下载我们需要的东西
获取下载文件的输入流
创建缓冲区
获取OutputStream对象
将FileOutputStream流写入到buffer缓冲区
使用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.获取前端传递的参数

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就存在；
用户登录之后，整个网站它都可以访问 --> 保存用户的信息，保存购物车的信息......

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 模型视图控制器

5. 过滤器 Filter（重点⭐）

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

处理中文乱码
登录验证等

Filter开发步骤：

导包

编写过滤器

导包不要错

//初始化，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("过滤器销毁");
}

在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>

过滤器的应用：

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

用户登录之后，向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");
    }
}

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

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项目（超市订单管理系统）

数据库：

6.1 项目搭建准备工作

搭建一个Maven web项目

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>

配置Tomcat
测试项目是否能运行

导入项目会用到的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>

创建项目包结构
创建实体类，属性私有化，以及对应的get/set方法，ORM映射

编写基础公共类

数据库配置文件

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>

导入静态资源

6.2 登录功能实现

编写前端页面

设置首页

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

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

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

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

service业务层接口

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

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

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

注册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>

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

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 密码修改

导入静态资源

编写UserDao接口

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

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

编写UserService业务层接口

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

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

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

配置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>

实现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 密码修改优化

导入阿里巴巴的json工具类

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

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

    });

后台代码

//验证旧密码
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 用户管理功能实现

思路

导入分页的工具类
导入用户列表页面

userlist.jsp rollpage.jsp

6.6.1 获取用户数量

UserDao

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

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

UserService

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

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 获取用户列表

UserDao

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

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

UserService

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

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 获取角色列表

RoleDao

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

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

RoleService

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

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方法

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

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方法的具体实现

获取前端返回的参数

//搜索框功能，按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;

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

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

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

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

//获取前端需要的用户信息列表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);

6.6.5 增加用户功能

UserDao

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

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

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

UserService

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

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

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

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 删除用户功能

UserDao

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

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

UserService

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

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

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 查看用户功能

UserDao

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

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

UserService

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

UserServiceImpl

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

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 修改用户功能

UserDao

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

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

UserService

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

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

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 订单管理

未完待续

posted @ 2022-11-11 14:29 CV攻城狮~ 阅读(18) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Loading

CV攻城狮的学习历程

JavaWeb学习

JavaWeb学习

1. Servlet

1.1 Servlet简介

1.2 HelloServlet

1.3 ServletContext

1.共享数据

2.获取初始化参数

3.请求转发

4.读取资源文件

1.4 HttpServletResponse

1.常见应用

1.向浏览器输出消息

2.下载文件

3.验证码功能

4.实现重定向⭐

1.5 HttpServletRequest

1.获取前端传递的参数

2.请求转发

2. Cookie、Session

2.1 会话

2.2 保存会话的两种技术

2.3 Cookie

2.4 Session（重点⭐）

3. JavaBean

4. MVC 三层架构

5. 过滤器 Filter（重点⭐）

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

6.1 项目搭建准备工作

6.2 登录功能实现

6.3 登录功能优化

6.4 密码修改

6.5 密码修改优化

6.6 用户管理功能实现

6.6.1 获取用户数量

6.6.2 获取用户列表

6.6.3 获取角色列表

6.6.4 编写UserServlet的query方法

6.6.5 增加用户功能

6.6.6 删除用户功能

6.6.7 查看用户功能

6.6.8 修改用户功能

6.7 供应商管理

6.8 订单管理

公告