第11章 综合实战：把十章拼成一个能跑的系统

┌───────────────────────────────────────────────────────────────┐
│ 浏览器                                                         │
│  login.jsp   register.jsp   brand.jsp   addBrand.jsp  updateBrand.jsp │
└──────────────────────────┬────────────────────────────────────┘
                           │ HTTP 请求（自动携带 Cookie: JSESSIONID）
┌──────────────────────────▼────────────────────────────────────┐
│ Filter 链（横切，不属于三层中的任何一层）                        │
│  EncodingFilter：统一 UTF-8   →   LoginFilter：登录校验         │
└──────────────────────────┬────────────────────────────────────┘
                           │ 放行
┌──────────────────────────▼────────────────────────────────────┐
│ 表现层 / Web 层    com.itheima.web                             │
│  BrandServlet  LoginServlet  RegisterServlet  CheckCodeServlet │
│  UserServlet                                                   │
│  职责：收参数、校验格式、调 Service、把结果放进 request 域、     │
│        转发到 JSP 或重定向到另一个 Servlet                      │
└──────────────────────────┬────────────────────────────────────┘
                           │ 普通 Java 方法调用（同一个 JVM、同一个线程）
┌──────────────────────────▼────────────────────────────────────┐
│ 业务逻辑层        com.itheima.service                          │
│  BrandService  UserService                                     │
│  职责：业务规则（品牌名不能重）、组合多次 DAO 调用、事务边界      │
└──────────────────────────┬────────────────────────────────────┘
                           │
┌──────────────────────────▼────────────────────────────────────┐
│ 数据访问层        com.itheima.dao                              │
│  BrandDao  UserDao                                             │
│  职责：一条方法一条 SQL，PreparedStatement 设参，结果集转实体     │
└──────────────────────────┬────────────────────────────────────┘
                           │ JDBC（Connection 来自 Druid 连接池）
┌──────────────────────────▼────────────────────────────────────┐
│ MySQL  db1：tb_brand、tb_user                                  │
└───────────────────────────────────────────────────────────────┘

另外两个"公共角色"，被所有层使用，自己不属于任何一层：
  com.itheima.pojo   Brand、User          —— 各层之间传递数据的载体
  com.itheima.utils  JdbcUtils            —— 连接池与连接获取

brand-demo
├── src/main/java/com/itheima
│   ├── pojo          Brand.java  User.java            实体类（只有字段 + getter/setter + toString）
│   ├── dao           BrandDao.java  UserDao.java      SQL 与结果集
│   ├── service       BrandService.java  UserService.java  业务规则与事务
│   ├── web           BrandServlet.java  LoginServlet.java
│   │                 RegisterServlet.java  CheckCodeServlet.java
│   │                 UserServlet.java
│   ├── web/filter    EncodingFilter.java  LoginFilter.java
│   └── utils         JdbcUtils.java
├── src/main/resources
│   └── druid.properties
└── src/main/webapp
    ├── WEB-INF/web.xml
    ├── css/  imgs/  js/
    ├── login.jsp  register.jsp
    ├── brand.jsp  addBrand.jsp  updateBrand.jsp
    └── index.jsp

-- 删除 tb_brand 表
drop table if exists tb_brand;
-- 创建 tb_brand 表
create table tb_brand
(
    -- id 主键
    id           int primary key auto_increment,
    -- 品牌名称
    brand_name   varchar(20),
    -- 企业名称
    company_name varchar(20),
    -- 排序字段
    ordered      int,
    -- 描述信息
    description  varchar(100),
    -- 状态：0：禁用 1：启用
    status       int
);

-- 添加数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
       ('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),
       ('小米', '小米科技有限公司', 50, 'are you ok', 1);

drop table if exists tb_user;
create table tb_user
(
    -- id 主键
    id       int primary key auto_increment,
    -- 用户名
    username varchar(20),
    -- 密码
    password varchar(32)
);

insert into tb_user (username, password) values ('zhangsan', '123');

 ①浏览器        ②Filter 链           ③Web 层            ④Service          ⑤DAO            ⑥MySQL
    |               |                    |                  |                 |                |
    |   GET /brand/selectAll?brandName=华                    |                 |                |
    |-------------->|                    |                  |                 |                |
    |               | EncodingFilter     |                  |                 |                |
    |               | setCharacterEncoding("UTF-8")          |                 |                |
    |               | LoginFilter        |                  |                 |                |
    |               | session 里有 user？  |                  |                 |                |
    |               | 有 → chain.doFilter |                  |                 |                |
    |               |------------------->|                  |                 |                |
    |               |                    | getPathInfo()    |                 |                |
    |               |                    | → "selectAll"    |                 |                |
    |               |                    | getParameter()   |                 |                |
    |               |                    |----------------->|                 |                |
    |               |                    |                  | 业务规则校验      |                |
    |               |                    |                  | trim、判空        |                |
    |               |                    |                  |---------------->|                |
    |               |                    |                  |                 | getConnection()|
    |               |                    |                  |                 |--------------->|
    |               |                    |                  |                 | PreparedStatement
    |               |                    |                  |                 | executeQuery() |
    |               |                    |                  |                 |--------------->|
    |               |                    |                  |                 |<-- ResultSet --|
    |               |                    |                  |                 | 逐行 → Brand    |
    |               |                    |                  |<-- List<Brand>--|                |
    |               |                    |<-- List<Brand>---|                 |                |
    |               |                    | request.setAttribute("brands", …)  |                |
    |               |                    | forward("/brand.jsp")              |                |
    |               |                    |  ┌── JSP 翻译成 Servlet 执行 ──┐    |                |
    |               |                    |  │ EL 从 request 域取 brands  │    |                |
    |               |                    |  │ c:forEach 循环输出 <tr>     │    |                |
    |               |                    |  └── 生成 HTML 字符串 ────────┘    |                |
    |<-- 200 text/html ------------------|                  |                 |                |
    |  浏览器渲染表格                     |                  |                 |                |

<?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>brand-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- mysql 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.34</version>
        </dependency>

        <!-- servlet：Tomcat 自带，绝不能打进 war -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- jsp：同样由 Tomcat 提供 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>

        <!-- jstl 与 standard：必须打进 war，Tomcat 不提供 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <!-- druid 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/brand-demo</path>
                    <uriEncoding>UTF-8</uriEncoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

<?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">

    <!-- 会话超时：30 分钟 -->
    <session-config>
        <session-timeout>30</session-timeout>
    </session-config>

</web-app>

    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>com.itheima.web.filter.EncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 写在后面 = 后执行 -->
    <filter>
        <filter-name>loginFilter</filter-name>
        <filter-class>com.itheima.web.filter.LoginFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>loginFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

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

package com.itheima.pojo;

/**
 * 品牌
 * 在实体类中，基本数据类型建议使用其对应的包装类型
 */
public class Brand {
    // id 主键
    private Integer id;
    // 品牌名称
    private String brandName;
    // 企业名称
    private String companyName;
    // 排序字段
    private Integer ordered;
    // 描述信息
    private String description;
    // 状态：0：禁用 1：启用
    private Integer status;

    public Brand() {
    }

    public Brand(Integer id, String brandName, String companyName, Integer ordered,
                 String description, Integer status) {
        this.id = id;
        this.brandName = brandName;
        this.companyName = companyName;
        this.ordered = ordered;
        this.description = description;
        this.status = status;
    }

    public Integer getId() {
        return id;
    }

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

    // …… 其余 getter / setter 与 toString 略，IDEA 中 Alt+Insert 一键生成

    @Override
    public String toString() {
        return "Brand{" +
                "id=" + id +
                ", brandName='" + brandName + '\'' +
                ", companyName='" + companyName + '\'' +
                ", ordered=" + ordered +
                ", description='" + description + '\'' +
                ", status=" + status +
                '}';
    }
}

package com.itheima.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

public class JdbcUtils {

    private static DataSource dataSource;

    static {
        // 静态代码块随着类的加载而自动执行，且只执行一次
        try {
            Properties prop = new Properties();
            // 用类加载器从 classpath 读，绝不能写死硬盘路径
            InputStream in = JdbcUtils.class.getClassLoader()
                    .getResourceAsStream("druid.properties");
            prop.load(in);
            dataSource = DruidDataSourceFactory.createDataSource(prop);
        } catch (Exception e) {
            // 初始化失败必须让程序立刻停下来，否则后面全是难查的 NPE
            throw new ExceptionInInitializerError(e);
        }
    }

    public static DataSource getDataSource() {
        return dataSource;
    }

    /**
     * 从连接池借一个连接。用完必须 close()，这里的 close 是"还回池子"，不是真的断开
     */
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true
username=root
password=1234
initialSize=5
maxActive=10
maxWait=3000

package com.itheima.dao;

import com.itheima.pojo.Brand;
import com.itheima.utils.JdbcUtils;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class BrandDao {

    /** 结果集的一行 → 一个 Brand 对象 */
    private Brand toBrand(ResultSet rs) throws SQLException {
        Brand brand = new Brand();
        brand.setId(rs.getInt("id"));
        brand.setBrandName(rs.getString("brand_name"));
        brand.setCompanyName(rs.getString("company_name"));
        brand.setOrdered(rs.getInt("ordered"));
        brand.setDescription(rs.getString("description"));
        brand.setStatus(rs.getInt("status"));
        return brand;
    }

    /**
     * 查询所有；brandName 为 null 或空串时查全部，否则按品牌名模糊查询
     */
    public List<Brand> selectAll(String brandName) {
        StringBuilder sql = new StringBuilder("select * from tb_brand where 1 = 1 ");
        List<Object> params = new ArrayList<>();

        if (brandName != null && !brandName.trim().isEmpty()) {
            sql.append("and brand_name like ? ");
            params.add("%" + brandName.trim() + "%");
        }
        sql.append("order by ordered desc");

        List<Brand> brands = new ArrayList<>();
        try (Connection conn = JdbcUtils.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql.toString())) {

            for (int i = 0; i < params.size(); i++) {
                pstmt.setObject(i + 1, params.get(i));
            }
            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    brands.add(toBrand(rs));
                }
            }
        } catch (SQLException e) {
            throw new RuntimeException("查询品牌列表失败", e);
        }
        return brands;
    }

    /**
     * 根据 id 查询
     */
    public Brand selectById(int id) {
        String sql = "select * from tb_brand where id = ?";
        try (Connection conn = JdbcUtils.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setInt(1, id);
            try (ResultSet rs = pstmt.executeQuery()) {
                // 主键查询最多一行，用 if 而不是 while
                return rs.next() ? toBrand(rs) : null;
            }
        } catch (SQLException e) {
            throw new RuntimeException("按 id 查询品牌失败", e);
        }
    }

    /**
     * 添加，返回受影响的行数
     */
    public int add(Brand brand) {
        String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) "
                + "values(?,?,?,?,?)";
        try (Connection conn = JdbcUtils.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, brand.getBrandName());
            pstmt.setString(2, brand.getCompanyName());
            pstmt.setInt(3, brand.getOrdered());
            pstmt.setString(4, brand.getDescription());
            pstmt.setInt(5, brand.getStatus());
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException("添加品牌失败", e);
        }
    }

    /**
     * 修改，返回受影响的行数
     */
    public int update(Brand brand) {
        String sql = "update tb_brand set brand_name = ?, company_name = ?, ordered = ?, "
                + "description = ?, status = ? where id = ?";
        try (Connection conn = JdbcUtils.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, brand.getBrandName());
            pstmt.setString(2, brand.getCompanyName());
            pstmt.setInt(3, brand.getOrdered());
            pstmt.setString(4, brand.getDescription());
            pstmt.setInt(5, brand.getStatus());
            pstmt.setInt(6, brand.getId());
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException("修改品牌失败", e);
        }
    }

    /**
     * 根据 id 删除，返回受影响的行数
     */
    public int deleteById(int id) {
        String sql = "delete from tb_brand where id = ?";
        try (Connection conn = JdbcUtils.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setInt(1, id);
            return pstmt.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException("删除品牌失败", e);
        }
    }

    /**
     * 根据品牌名精确查询，用于重名校验
     */
    public Brand selectByBrandName(String brandName) {
        String sql = "select * from tb_brand where brand_name = ?";
        try (Connection conn = JdbcUtils.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, brandName);
            try (ResultSet rs = pstmt.executeQuery()) {
                return rs.next() ? toBrand(rs) : null;
            }
        } catch (SQLException e) {
            throw new RuntimeException("按品牌名查询失败", e);
        }
    }
}

package com.itheima.service;

import com.itheima.dao.BrandDao;
import com.itheima.pojo.Brand;

import java.util.List;

public class BrandService {

    private BrandDao dao = new BrandDao();

    public List<Brand> selectAll(String brandName) {
        // 业务规则：不管调用方传什么，Service 保证交给 DAO 的是"干净"的参数
        if (brandName != null) {
            brandName = brandName.trim();
            if (brandName.isEmpty()) {
                brandName = null;
            }
        }
        return dao.selectAll(brandName);
    }

    public Brand selectById(int id) {
        if (id <= 0) {
            throw new IllegalArgumentException("品牌 id 不合法：" + id);
        }
        return dao.selectById(id);
    }

    /**
     * 新增。业务规则：品牌名不能为空、不能重名
     */
    public void add(Brand brand) {
        if (brand.getBrandName() == null || brand.getBrandName().trim().isEmpty()) {
            throw new IllegalArgumentException("品牌名称不能为空");
        }
        brand.setBrandName(brand.getBrandName().trim());

        // 组合两次 DAO 调用：先查重，再插入
        if (dao.selectByBrandName(brand.getBrandName()) != null) {
            throw new IllegalArgumentException("品牌名称已存在：" + brand.getBrandName());
        }
        dao.add(brand);
    }

    public void update(Brand brand) {
        if (brand.getId() == null) {
            throw new IllegalArgumentException("修改时必须携带 id");
        }
        dao.update(brand);
    }

    public void deleteById(int id) {
        if (id <= 0) {
            throw new IllegalArgumentException("品牌 id 不合法：" + id);
        }
        dao.deleteById(id);
    }
}

Connection conn = JdbcUtils.getConnection();
try {
    conn.setAutoCommit(false);      // 关闭自动提交，事务开始

    dao.addBrand(brand, conn);      // 两次操作必须用同一个 Connection
    dao.addLog("新增品牌", conn);

    conn.commit();                  // 一起成功
} catch (Exception e) {
    conn.rollback();                // 一起失败
    throw new RuntimeException("新增品牌失败", e);
} finally {
    conn.setAutoCommit(true);       // 恢复，再还给连接池
    conn.close();
}

package com.itheima.mapper;

import com.itheima.pojo.Brand;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface BrandMapper {

    @Select("select * from tb_brand")
    @ResultMap("brandResultMap")
    List<Brand> selectAll();

    @Select("select * from tb_brand where id = #{id}")
    @ResultMap("brandResultMap")
    Brand selectById(int id);

    @Insert("insert into tb_brand values(null,#{brandName},#{companyName},#{ordered},#{description},#{status})")
    void add(Brand brand);

    @Update("update tb_brand set brand_name = #{brandName}, company_name = #{companyName}, " +
            "ordered = #{ordered}, description = #{description}, status = #{status} where id = #{id}")
    void update(Brand brand);

    @Delete("delete from tb_brand where id = #{id}")
    void deleteById(int id);
}

public class BrandService {
    // 原来是 private BrandDao dao = new BrandDao();
    private SqlSessionFactory factory = SqlSessionFactoryUtils.getSqlSessionFactory();

    public List<Brand> selectAll() {
        SqlSession sqlSession = factory.openSession();
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        List<Brand> brands = mapper.selectAll();
        sqlSession.close();
        return brands;
    }

    public void add(Brand brand) {
        SqlSession sqlSession = factory.openSession();
        BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
        mapper.add(brand);
        sqlSession.commit();   // 忘了这一句，数据不会进库
        sqlSession.close();
    }
}

<!-- 片段：BrandMapper.xml -->
<mapper namespace="com.itheima.mapper.BrandMapper">
    <resultMap id="brandResultMap" type="brand">
        <result column="brand_name" property="brandName"></result>
        <result column="company_name" property="companyName"></result>
    </resultMap>
</mapper>

@WebServlet("/brand")
public class BrandServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        String method = request.getParameter("method");   // selectAll / add / update / delete
        switch (method) {
            case "selectAll": /* … */ break;
            // …
        }
    }
}

package com.itheima.web;

import com.itheima.pojo.Brand;
import com.itheima.service.BrandService;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
import java.io.IOException;
import java.util.List;

@WebServlet("/brand/*")
public class BrandServlet extends HttpServlet {

    private BrandService service = new BrandService();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // 1. 取出动作名：请求 /brand/selectAll 时 pathInfo 是 "/selectAll"
        String pathInfo = request.getPathInfo();
        String action = (pathInfo == null || "/".equals(pathInfo))
                ? "selectAll"                       // 直接访问 /brand 或 /brand/ 时默认查全部
                : pathInfo.substring(1);            // 去掉开头的 "/"

        // 2. 按动作名分发
        switch (action) {
            case "selectAll":
                selectAll(request, response);
                break;
            case "selectById":
                selectById(request, response);
                break;
            case "add":
                add(request, response);
                break;
            case "update":
                update(request, response);
                break;
            case "delete":
                delete(request, response);
                break;
            default:
                response.sendError(HttpServletResponse.SC_NOT_FOUND, "未知操作：" + action);
        }
    }

    /** 查询所有 / 模糊查询 */
    private void selectAll(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String brandName = request.getParameter("brandName");

        List<Brand> brands = service.selectAll(brandName);

        // 数据放 request 域，key 必须和 JSP 里 ${brands} 一致
        request.setAttribute("brands", brands);
        // 把关键词也回传，搜索框才能留住刚才输入的内容
        request.setAttribute("brandName", brandName);

        request.getRequestDispatcher("/brand.jsp").forward(request, response);
    }

    /** 按 id 查询，用于修改页回显 */
    private void selectById(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        int id = Integer.parseInt(request.getParameter("id"));

        Brand brand = service.selectById(id);
        if (brand == null) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND, "品牌不存在，id=" + id);
            return;
        }

        request.setAttribute("brand", brand);
        request.getRequestDispatcher("/updateBrand.jsp").forward(request, response);
    }

    /** 新增 */
    private void add(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        Brand brand = new Brand();
        brand.setBrandName(request.getParameter("brandName"));
        brand.setCompanyName(request.getParameter("companyName"));
        brand.setOrdered(Integer.parseInt(request.getParameter("ordered")));
        brand.setDescription(request.getParameter("description"));
        brand.setStatus(Integer.parseInt(request.getParameter("status")));

        service.add(brand);

        // 重定向回列表：浏览器地址栏变成 /brand/selectAll，刷新不会重复提交
        response.sendRedirect(request.getContextPath() + "/brand/selectAll");
    }

    /** 修改保存 */
    private void update(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        Brand brand = new Brand();
        brand.setId(Integer.parseInt(request.getParameter("id")));   // 隐藏域提交上来的
        brand.setBrandName(request.getParameter("brandName"));
        brand.setCompanyName(request.getParameter("companyName"));
        brand.setOrdered(Integer.parseInt(request.getParameter("ordered")));
        brand.setDescription(request.getParameter("description"));
        brand.setStatus(Integer.parseInt(request.getParameter("status")));

        service.update(brand);
        response.sendRedirect(request.getContextPath() + "/brand/selectAll");
    }

    /** 删除 */
    private void delete(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        int id = Integer.parseInt(request.getParameter("id"));
        service.deleteById(id);
        response.sendRedirect(request.getContextPath() + "/brand/selectAll");
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.doGet(request, response);
    }
}

原文（转发）：  POST /brand/add  →  内部转发  →  200 列表页      地址栏仍是 /brand/add
PRG（本章）：   POST /brand/add  →  302 重定向  →  GET /brand/selectAll  →  200 列表页

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:set var="ctx" value="${pageContext.request.contextPath}"/>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>品牌管理</title>
</head>
<body>
<h3>品牌管理</h3>

<%-- 搜索区：用 GET，刷新页面只是重新查一次，不会重复提交 --%>
<form action="${ctx}/brand/selectAll" method="get">
    品牌名称：<input name="brandName" value="${brandName}">
    <input type="submit" value="查询">
    <input type="button" value="新增" id="add">
</form>
<hr>

<table border="1" cellspacing="0" width="90%">
    <tr>
        <th>序号</th>
        <th>品牌名称</th>
        <th>企业名称</th>
        <th>排序</th>
        <th>品牌介绍</th>
        <th>状态</th>
        <th>操作</th>
    </tr>

    <c:forEach items="${brands}" var="brand" varStatus="status">
        <tr align="center">
            <td>${status.count}</td>
            <td>${brand.brandName}</td>
            <td>${brand.companyName}</td>
            <td>${brand.ordered}</td>
            <td>${brand.description}</td>
            <td>
                <c:if test="${brand.status == 1}">启用</c:if>
                <c:if test="${brand.status != 1}">禁用</c:if>
            </td>
            <td>
                <a href="${ctx}/brand/selectById?id=${brand.id}">修改</a>
                <a href="${ctx}/brand/delete?id=${brand.id}"
                   onclick="return confirm('确定删除【${brand.brandName}】吗？')">删除</a>
            </td>
        </tr>
    </c:forEach>
</table>

<c:if test="${empty brands}">
    <p>没有查询到品牌数据。</p>
</c:if>

<script>
    document.getElementById("add").onclick = function () {
        location.href = "${ctx}/addBrand.jsp";
    };
</script>
</body>
</html>

<c:if test="${brand.status == 1}">
    <td>启用</td>
</c:if>
<c:if test="${brand.status != 1}">
    <td>禁用</td>
</c:if>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:set var="ctx" value="${pageContext.request.contextPath}"/>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>添加品牌</title>
</head>
<body>
<h3>添加品牌</h3>
<form action="${ctx}/brand/add" method="post">
    品牌名称：<input name="brandName" required><br>
    企业名称：<input name="companyName" required><br>
    排序：<input name="ordered" type="number" value="0"><br>
    描述信息：<textarea rows="5" cols="20" name="description"></textarea><br>
    状态：
    <input type="radio" name="status" value="0" checked>禁用
    <input type="radio" name="status" value="1">启用<br>

    <input type="submit" value="提交">
</form>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:set var="ctx" value="${pageContext.request.contextPath}"/>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>修改品牌</title>
</head>
<body>
<h3>修改品牌</h3>
<form action="${ctx}/brand/update" method="post">

    <%-- 隐藏域，提交 id。用户看不见，但表单会带上 --%>
    <input type="hidden" name="id" value="${brand.id}">

    品牌名称：<input name="brandName" value="${brand.brandName}"><br>
    企业名称：<input name="companyName" value="${brand.companyName}"><br>
    排序：<input name="ordered" value="${brand.ordered}"><br>
    描述信息：<textarea rows="5" cols="20" name="description">${brand.description}</textarea><br>
    状态：
    <c:if test="${brand.status == 0}">
        <input type="radio" name="status" value="0" checked>禁用
        <input type="radio" name="status" value="1">启用<br>
    </c:if>
    <c:if test="${brand.status == 1}">
        <input type="radio" name="status" value="0">禁用
        <input type="radio" name="status" value="1" checked>启用<br>
    </c:if>

    <input type="submit" value="提交">
</form>
</body>
</html>

<select name="status">
    <option value="0" ${brand.status == 0 ? "selected" : ""}>禁用</option>
    <option value="1" ${brand.status == 1 ? "selected" : ""}>启用</option>
</select>

package com.itheima.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter("/*")
public class EncodingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        // 必须在任何 getParameter() 之前执行
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        chain.doFilter(request, response);
    }
}

String[] urls = {"/login.jsp", "/imgs/", "/css/", "/loginServlet",
                 "/register.jsp", "/registerServlet", "/checkCodeServlet"};
String url = req.getRequestURL().toString();
for (String u : urls) {
    if (url.contains(u)) {
        chain.doFilter(request, response);
        return;
    }
}

package com.itheima.web.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.*;
import java.io.IOException;
import java.net.URLEncoder;

@WebFilter("/*")
public class LoginFilter implements Filter {

    /** 白名单：登录、注册、验证码、查重接口、静态资源 */
    private static final String[] WHITE_LIST = {
            "/login.jsp", "/login", "/register.jsp", "/register",
            "/checkCode", "/checkUsername",
            "/css/", "/imgs/", "/js/", "/favicon.ico"
    };

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws ServletException, IOException {

        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;

        // 1. 当前请求路径（不含协议、主机、端口），形如 /brand-demo/brand/selectAll
        String uri = req.getRequestURI();
        String ctx = req.getContextPath();            // "/brand-demo"

        // 2. 白名单直接放行
        for (String u : WHITE_LIST) {
            if (uri.startsWith(ctx + u)) {
                chain.doFilter(request, response);
                return;                               // 注意：放行后必须 return
            }
        }

        // 3. 已登录放行
        Object user = req.getSession().getAttribute("user");
        if (user != null) {
            chain.doFilter(request, response);
            return;
        }

        // 4. 未登录：Ajax 请求不能重定向到 HTML 登录页，要回 401
        if ("XMLHttpRequest".equals(req.getHeader("X-Requested-With"))) {
            resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);   // 401
            resp.setContentType("text/plain;charset=utf-8");
            resp.getWriter().write("NOT_LOGIN");
            return;
        }

        // 5. 未登录的普通请求：记住"原本想去哪儿"，跳登录页
        String target = uri.substring(ctx.length());  // /brand/selectAll
        String query = req.getQueryString();          // id=3
        if (query != null && !query.isEmpty()) {
            target = target + "?" + query;
        }
        resp.sendRedirect(ctx + "/login.jsp?returnUrl="
                + URLEncoder.encode(target, "UTF-8"));
    }
}

// 登录成功之后
session.setAttribute("user", user);

String returnUrl = request.getParameter("returnUrl");
// 只允许跳回本应用内的路径，防止"开放重定向"漏洞
if (returnUrl != null && returnUrl.startsWith("/") && !returnUrl.startsWith("//")) {
    response.sendRedirect(request.getContextPath() + returnUrl);
} else {
    response.sendRedirect(request.getContextPath() + "/brand/selectAll");
}

// CheckCodeServlet：生成并存入 Session
String checkCode = CheckCodeUtil.outputVerifyImage(100, 50, os, 4);
request.getSession().setAttribute("checkCodeGen", checkCode);

// RegisterServlet：取出并比对
HttpSession session = request.getSession();
String checkCodeGen = (String) session.getAttribute("checkCodeGen");
session.removeAttribute("checkCodeGen");      // 一次性，用完立即作废
if (checkCodeGen == null || !checkCodeGen.equalsIgnoreCase(checkCode)) {
    request.setAttribute("register_msg", "验证码错误");
    request.getRequestDispatcher("/register.jsp").forward(request, response);
    return;
}

@WebServlet("/checkUsername")
public class UserServlet extends HttpServlet {
    private UserService service = new UserService();

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String username = request.getParameter("username");

        // 这里是本章相对原文唯一的实质改动：
        // 原文此处为了演示"不写死数据库也能跑"，直接 boolean flag = true;
        // 本章接上真实的 Service，查得到才说明被占用
        boolean exist = service.selectByUsername(username) != null;

        response.setContentType("text/html;charset=utf-8");
        response.getWriter().write("" + exist);       // 输出 true / false
    }
}

document.getElementById("username").onblur = function () {
    var username = this.value;
    if (username.trim() === "") {
        return;
    }

    var xhttp = new XMLHttpRequest();
    xhttp.open("GET", "${ctx}/checkUsername?username=" + encodeURIComponent(username));
    xhttp.onreadystatechange = function () {
        if (this.readyState == 4 && this.status == 200) {
            if (this.responseText == "true") {
                document.getElementById("username_err").style.display = "";
            } else {
                document.getElementById("username_err").style.display = "none";
            }
        } else if (this.readyState == 4 && this.status == 401) {
            // 会话过期了，直接去登录页
            location.href = "${ctx}/login.jsp";
        }
    };
    xhttp.send();
};

com.alibaba.druid.pool.GetConnectionTimeoutException:
wait millis 3001, active 10, maxActive 10, creating 0

// 形态一：压根没写 close
Connection conn = JdbcUtils.getConnection();
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.executeUpdate();

// 形态二：只在成功路径关，抛异常就漏了
Connection conn = JdbcUtils.getConnection();
pstmt.executeUpdate();
conn.close();                  // 上面抛异常，这行永远不执行

// 形态三：关了 ResultSet，忘了关 Connection
rs.close();

try (Connection conn = JdbcUtils.getConnection();
     PreparedStatement pstmt = conn.prepareStatement(sql)) {
    // …
}   // 无论正常还是异常，conn 和 pstmt 都会被自动 close

response.setContentType("application/json;charset=utf-8");
response.getWriter().write("[{\"id\":1,\"brandName\":\"华为\"}]");

axios.get('${ctx}/brand/selectAll').then(resp => {
    // resp.data 已经是解析好的对象，不用 JSON.parse
    renderTable(resp.data);
});