书城项目-使用Filter过滤器实现后台的权限管理、书城项目-ThreadLocal使用介绍、书城项目-使用ThreadLocal确保所有操作都使用同一个Connection来实现事务管理、书城项目-使用Filter统一给所有Service方法都加上try-catch来管理事务、书城项目-使用Tomcat统一管理异常，展示友好的错误页面

书城第八阶段：

1、使用 Filter 过滤器拦截/pages/manager/所有内容，实
现权限检查

Filter 代码：

package top.qaqaq.filter;

import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;

import java.io.IOException;

/**
 * @author RichieZhang
 * @create 2022-12-19 10:43
 */
public class ManagerFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;

        Object user = httpServletRequest.getSession().getAttribute("user");

        if (user == null) {
            httpServletRequest.getRequestDispatcher("/pages/user/login.jsp").forward(servletRequest,servletResponse);
        } else {
            filterChain.doFilter(servletRequest,servletResponse);
        }

    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

    <filter>
        <filter-name>ManagerFilter</filter-name>
        <filter-class>top.qaqaq.filter.ManagerFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>ManagerFilter</filter-name>
        <url-pattern>/pages/manager/*</url-pattern>
        <url-pattern>/manager/bookServlet</url-pattern>
        <url-pattern>/manager/orderServlet</url-pattern>
    </filter-mapping>

2、ThreadLocal 的使用

ThreadLocal 的作用，它可以解决多线程的数据安全问题。

ThreadLocal 它可以给当前线程关联一个数据（可以是普通变量，可以是对象，也可以是数组，集合）

ThreadLocal 的特点：
1、ThreadLocal 可以为当前线程关联一个数据。（它可以像 Map 一样存取数据，key 为当前线程）
2、每一个 ThreadLocal 对象，只能为当前线程关联一个数据，如果要为当前线程关联多个数据，就需要使用多个
ThreadLocal 对象实例。
3、每个 ThreadLocal 对象实例定义的时候，一般都是 static 类型
4、ThreadLocal 中保存数据，在线程销毁后。会由 JVM 虚拟自动释放。

测试类：

package top.qaqaq.threadlocal;

import java.util.Map;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author RichieZhang
 * @create 2022-12-19 11:17
 */
public class ThreadLocalTest {

    // 线程安全的Map
    public static Map<String,Object> data = new ConcurrentHashMap<>();
//    public static Map<String,Object> data = new Hashtable<String,Object>();

    public static ThreadLocal<Object> threadLocal = new ThreadLocal<Object>();
    public static ThreadLocal<Object> threadLocal2 = new ThreadLocal<Object>();

    private static Random random = new Random();

    public static class Task implements Runnable {
        @Override
        public void run() {

            /*threadLocal.set("abc");
            threadLocal2.set("bbj");

            System.out.println(threadLocal.get());
            System.out.println(threadLocal2.get());*/



            // 在 Run 方法中，随机生成一个变量（线程要关联的数据），然后以当前线程名为 key 保存到 map 中
            Integer i = random.nextInt(1000);//0-999
            // 获取当前线程名
            String name = Thread.currentThread().getName();
            System.out.println("线程["+name+"]生成的随机数是：" + i);
//            data.put(name,i);
            threadLocal.set(i);

            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            new OrderService().createOrder();

            // 在 Run 方法结束之前，以当前线程名获取出数据并打印。查看是否可以取出操作
//            Object o = data.get(name);
            Object o = threadLocal.get();
            System.out.println("在线程["+name+"]快结束时取出关联的数据是：" + o);

        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(new Task()).start();
        }
    }
}

package top.qaqaq.threadlocal;

/**
 * @author RichieZhang
 * @create 2022-12-19 11:31
 */
public class OrderService {

    public void createOrder(){
        String name = Thread.currentThread().getName();
        System.out.println("OrderService 当前线程[" + name + "]中保存的数据是：" + ThreadLocalTest.threadLocal.get());
        new OrderDao().saveOrder();
    }
}

package top.qaqaq.threadlocal;

/**
 * @author RichieZhang
 * @create 2022-12-19 11:31
 */
public class OrderDao {

    public void saveOrder(){
        String name = Thread.currentThread().getName();
        System.out.println("OrderDao 当前线程[" + name + "]中保存的数据是：" + ThreadLocalTest.threadLocal.get());
    }
}

3、使用 Filter 和 ThreadLocal 组合管理事务

3.1、使用 ThreadLocal 来确保所有 dao 操作都在同一个 Connection 连接对象中完成

原理分析图：

JdbcUtils 工具类的修改：

package top.qaqaq.utils;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

/**
 * @author RichieZhang
 * @create 2022-12-06 下午 1:36
 */
public class JdbcUtils {

    private static DruidDataSource dataSource;

    private static ThreadLocal<Connection> conns = new ThreadLocal<Connection>();

    static {
        try {
            Properties properties = new Properties();
            // 读取 jdbc.properties属性配置文件
            // 注意 较新的idea需要把jdbc.properties放入resources文件夹中
            InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
            // 从流中加载数据
            properties.load(inputStream);
            // 创建 数据库连接 池
            dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取数据库连接池中的连接
     *
     * @return 如果返回null,说明获取连接失败 有值就是获取连接成功
     */
    public static Connection getConnection() {

        Connection conn = conns.get();

        if (conn == null) {
            try {
                conn = dataSource.getConnection(); //从数据库连接池中获取连接

                conns.set(conn); //保存到ThreadLocal对象中，供后面的jdbc操作使用

                conn.setAutoCommit(false); //设置为手动管理事务

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

        return conn;
    }

    /**
     * 提交事务，并关闭释放连接
     */
    public static void commitAndClose(){
        Connection connection = conns.get();
        if (connection != null) { // 如果不等于null，说明 之前使用过连接，操作过数据库

            try {
                connection.commit(); // 提交 事务
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    connection.close(); // 关闭连接，释放资源
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 一定要执行remove操作，否则就会出错。(因为Tomcat服务器底层使用了线程池技术)
        conns.remove();
    }

    /**
     * 回滚事务，并关闭释放连接
     */
    public static void rollbackAndClose(){
        Connection connection = conns.get();
        if (connection != null) { // 如果不等于null，说明 之前使用过连接，操作过数据库

            try {
                connection.rollback(); // 回滚 事务
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                try {
                    connection.close(); // 关闭连接，释放资源
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        // 一定要执行remove操作，否则就会出错。(因为Tomcat服务器底层使用了线程池技术)
        conns.remove();
    }

    /**
     * 关闭连接，放回数据库连接池
     *
     * @param conn
     */
/*    public static void close(Connection conn) {
        if (conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }*/

}

修改 BaseDao

package top.qaqaq.dao.impl;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import top.qaqaq.utils.JdbcUtils;

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

/**
 * @author RichieZhang
 * @create 2022-12-06 下午 2:22
 */
public abstract class BaseDao {

    //使用DbUtils操作数据库
    private QueryRunner queryRunner = new QueryRunner();

    /**
     * update() 方法用来执行：Insert\Update\Delete语句
     * @return 如果返回-1，说明执行失败 返回其他表示影响的行数
     */
    public int update(String sql, Object ...args){

        System.out.println("BaseDao 程序在[" + Thread.currentThread().getName() + "]中");

        Connection connection = JdbcUtils.getConnection();
        try {
            return queryRunner.update(connection,sql,args);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 查询返回一个javaBean的sql语句
     * @param type  返回的对象类型
     * @param sql   执行的sql语句
     * @param args  sql对应的参数值
     * @param <T>   返回的类型的泛型
     * @return
     */
    public <T> T queryForOne(Class<T> type,String sql,Object ...args){
        Connection con = JdbcUtils.getConnection();
        try {
            return queryRunner.query(con,sql,new BeanHandler<T>(type),args);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 查询返回多个javaBean的sql语句
     * @param type  返回的对象类型
     * @param sql   执行的sql语句
     * @param args  sql对应的参数值
     * @param <T>   返回的类型的泛型
     * @return
     */
    public <T> List<T> queryForList(Class<T> type, String sql, Object ...args){
        Connection con = JdbcUtils.getConnection();
        try {
            return queryRunner.query(con,sql,new BeanListHandler<T>(type),args);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 执行返回一行一列的sql语句
     * @param sql   执行的sql语句
     * @param args  sql对应的参数值
     * @return
     */
    public Object queryForSingleValue(String sql, Object ...args){
        Connection conn = JdbcUtils.getConnection();

        try {
            return queryRunner.query(conn,sql, new ScalarHandler(),args);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

3.2、使用 Filter 过滤器统一给所有的 Service 方法都加上 try-catch。来进行实现的管理。

原理分析图：

Filter 类代码：

package top.qaqaq.filter;

import jakarta.servlet.*;
import top.qaqaq.utils.JdbcUtils;

import java.io.IOException;

/**
 * @author RichieZhang
 * @create 2022-12-19 17:15
 */
public class TransactionFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        try {
            filterChain.doFilter(servletRequest,servletResponse);

            JdbcUtils.commitAndClose(); // 提交事务

        } catch (Exception e) {

            JdbcUtils.rollbackAndClose(); // 回滚事务

            e.printStackTrace();
            throw new RuntimeException(e); // 把异常抛给Tomcat管理展示友好的错误页面
        }
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

在 web.xml 中的配置：

    <filter>
        <filter-name>TransactionFilter</filter-name>
        <filter-class>top.qaqaq.filter.TransactionFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>TransactionFilter</filter-name>
        <!-- /* 表示当前工程下所有请求 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

一定要记得把 BaseServlet 中的异常往外抛给 Filter 过滤器

package top.qaqaq.web;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.lang.reflect.Method;

/**
 * @author RichieZhang
 * @create 2022-12-10 下午 12:28
 */
public abstract class BaseServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doGet(req, resp);

        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doPost(req, resp);

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

//        System.out.println(acction);

        //方法一：写一个方法判断一次
//        if ("login".equals(action)) {
//            //System.out.println("处理登录的需求");
//            login(req,resp);
//        } else if ("regist".equals(action)) {
//            //System.out.println("处理注册的需求");
//            regist(req,resp);
//        }

        //方法二：通过反射动态获取
        try {
            // 通过action业务鉴别字符串，获取相应的业务 方法反射对象
            Method method = this.getClass().getDeclaredMethod(action, HttpServletRequest.class, HttpServletResponse.class);

//            System.out.println(method);

            // 调用目标业务 方法
            method.invoke(this,req,resp);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e); // 把异常抛给Filter过滤器
        }
    }
}

3.3、将所有异常都统一交给 Tomcat，让 Tomcat 展示友好的错误信息

页面。

在 web.xml 中我们可以通过错误页面配置来进行管理。

    <!-- error-page标签配置，服务器出错之后，自动跳转的页面 -->
    <error-page>
        <!-- error-code是错误类型 -->
        <error-code>500</error-code>
        <!-- location标签表示。要跳转去的页面路径 -->
        <location>/pages/error/error500.jsp</location>
    </error-page>

    <!-- error-page标签配置，服务器出错之后，自动跳转的页面 -->
    <error-page>
        <!-- error-code是错误类型 -->
        <error-code>404</error-code>
        <!-- location标签表示。要跳转去的页面路径 -->
        <location>/pages/error/error404.jsp</location>
    </error-page>

error500.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>电子产品</title>

	<%-- 静态包含 base标签，css样式，jQuery文件 --%>
	<%@ include file="/pages/common/head.jsp"%>

</head>
<body>
	很抱歉，您访问的后台程序出现了错误，程序猿小哥，正在努力的为您抢修！！！<br/>
	<a href="index.jsp">返回首页</a>
</body>
</html>

error404.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>电子产品</title>

	<%-- 静态包含 base标签，css样式，jQuery文件 --%>
	<%@ include file="/pages/common/head.jsp"%>

</head>
<body>
	很抱歉。您访问的页面不存在，或已经被删除！！！<br/>
	<a href="index.jsp">返回首页</a>
</body>
</html>