• 电商后台项目 + 源码

    项目总体样式如下：

     重点功能：模糊条件分页查询功能：

     

     一、前期准备

    PageBean实体类：

    1. package com.itheima.pojo;
    2.  
    3. import java.util.List;
    4.  
    5. /**
    6.  *  PageBean： 分页查询功能用来封装数据传递给前端的
    7.  */
    8. public class PageBean<T> {  // 这里自定义一个泛型
    9.  
    10.     // 总商品数
    11.     private int totalCount;
    12.  
    13.     // 当前页数据 ( 把当前页查询出来的数据以List集合的形式封装到属性当中传递给前端 )
    14.     private List<T> rows;
    15.     /**
    16.      *  这里用自定义的泛型T ： 因为以后开发项目的时候 我们有可能有Brand实体类，也有可能有User实体类等。
    17.      *      我们自定义好泛型之后，以后谁new 这个PageBean类 这个泛型里面就是谁
    18.      */
    19.  
    20.  
    21.     // getter and setter
    22.  
    23.     public int getTotalCount() {
    24.         return totalCount;
    25.     }
    26.  
    27.     public void setTotalCount(int totalCount) {
    28.         this.totalCount = totalCount;
    29.     }
    30.  
    31.     public List<T> getRows() {
    32.         return rows;
    33.     }
    34.  
    35.     public void setRows(List<T> rows) {
    36.         this.rows = rows;
    37.     }
    38. }

    二、代码如下

    2.1、mapper层 （BrandMapper）

    1. package com.itheima.mapper;
    2. import com.itheima.pojo.Brand;
    3. import org.apache.ibatis.annotations.*;
    4.  
    5. import java.util.List;
    6.  
    7. public interface BrandMapper {
    8.  
    9.     /**
    10.      * 1、查询所有商品功能
    11.      *
    12.      */
    13.  
    14.     @Select("select * from tb_brand")
    15.     @ResultMap("brandResultMap")
    16.     List<Brand> selectAll();
    17.  
    18.     /**
    19.      *  2、添加商品功能
    20.      */
    21.     @Insert("insert into tb_brand values (null,#{brandName},#{companyName},#{ordered},#{description},#{status})")
    22.     void add(Brand brand);
    23.  
    24.     /**
    25.      *  3、批量删除功能
    26.      *
    27.      *  批量删除：因为我们不知道客户端会传过来几个删除id，因此这里我们要用动态sql 并且不能用注解的形式了
    28.      */
    29.  
    30.     void deleteByIds(int[] ids);
    31.  
    32.     /**
    33.      * 4、 查询当前页的数据功能
    34.      *  思路： 拿到客户端请求的 ”第几页页数“ 和 “每页展示数据数”，我们拿到之后，再把这页的数据全部查询出来展示给客户端
    35.      */
    36.     @Select("select * from tb_brand limit #{begin},#{size}")
    37.     @ResultMap("brandResultMap")
    38.     List<Brand> selectByPage(@Param("begin") int begin, @Param("size") int size);
    39.  
    40.     /**
    41.      * 5、查询数据库商品总数功能
    42.      *      把数据库商品的总个数查询出来响应给前端
    43.      */
    44.     @Select("select count(*) from tb_brand")
    45.     int selectTotalCount();
    46.  
    47.  
    48.     /**
    49.      * 6、分页模糊条件查询功能
    50.      *
    51.      * 接收前端请求的“页码数”和“每页展示数据数”和“模糊查询的数据请求”（在前端页面看：客户端模糊查询请求的数据只有三个：当前状态、企业名称、品牌名称）
    52.      *
    53.          * （因为模糊条件查询：比如说客户端就请求了一个企业名称：“阿里巴巴”，但是我们数据库当中会有什么不同的关于“阿里巴巴”的数据，
    54.          * 因为是模糊查询所以会查出来很多的数据，前端呢因为怕查询出来的数据太多了所以想分页，所以我们后端接收到前端请求的 “当前页码”，
    55.          * “每页展示数据个数” 和“模糊查询的数据” 进行模糊分页查询就可以了
    56.          * 就是按一页几条数据来进行查询响应给前端即可了 ）
    57.      *
    58.      *
    59.      * begin： 当前页码
    60.      * size： 每页展示数据个数
    61.      * brand对象： 模糊查询的前端数据请求
    62.      *
    63.      * 注意：@Param("") 里面的数据对应的是SQL语句的参数占位符 也就是SQL语句中 #{} 内的数据
    64.      *
    65.      * @return
    66.      */
    67.  
    68.     List<Brand> selectByPageAndCondition(@Param("begin") int begin, @Param("size") int size, @Param("brand") Brand brand);
    69.  
    70.     /**
    71.      *  7、查询模糊查询出来的总商品数量功能
    72.      *      因为这里面就一个brand对象 所以对象的属性名就相对应着SQL语句的 #{"参数占位数"}
    73.      */
    74.  
    75.     int selectTotalCountByCondition(Brand brand);
    76.  
    77.  
    78. }

    BrandMapper.xml：

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.itheima.mapper.BrandMapper">
    6.  
    7.     <resultMap id="brandResultMap" type="brand">
    8.         <result property="brandName" column="brand_name" />
    9.         <result property="companyName" column="company_name" />
    10.     </resultMap>
    11.  
    12.  
    13.  
    14.     <delete id="deleteByIds">
    15.         delete from tb_brand where id in
    16.         <foreach collection="ids" item="id" separator="," open="(" close=")">
    17.             #{id}
    18.         </foreach>
    19.  
    20.  
    21.     </delete>
    22.     <!-- where brand_name = #{brand.brandName}-->
    23.     <select id="selectByPageAndCondition" resultMap="brandResultMap">
    24.         select *
    25.         from tb_brand
    26.         <where>
    27.             <if test="brand.brandName != null and brand.brandName != '' ">
    28.                 and  brand_name like #{brand.brandName}
    29.             </if>
    30.  
    31.             <if test="brand.companyName != null and brand.companyName != '' ">
    32.                 and  company_name like #{brand.companyName}
    33.             </if>
    34.  
    35.             <if test="brand.status != null">
    36.                 and  status = #{brand.status}
    37.             </if>
    38.  
    39.         </where>
    40.  
    41.         limit #{begin} , #{size}
    42.  
    43.     </select>
    44.     <select id="selectTotalCountByCondition" resultType="java.lang.Integer">
    45.  
    46.         select count(*)
    47.         from tb_brand
    48.         <where>
    49.             <if test="brandName != null and brandName != '' ">
    50.                 and  brand_name like #{brandName}
    51.             </if>
    52.  
    53.             <if test="companyName != null and companyName != '' ">
    54.                 and  company_name like #{companyName}
    55.             </if>
    56.  
    57.             <if test="status != null">
    58.                 and  status = #{status}
    59.             </if>
    60.  
    61.         </where>
    62.  
    63.     </select>
    64.  
    65. </mapper>

     

    2.2、service业务逻辑层

    BrandService接口：（基本上和代理接口代码是一样的）

    1. package com.itheima.service;
    2. import com.itheima.pojo.Brand;
    3. import com.itheima.pojo.PageBean;
    4. import org.apache.ibatis.annotations.Param;
    5. import org.apache.ibatis.annotations.ResultMap;
    6. import org.apache.ibatis.annotations.Select;
    7.  
    8. import java.util.List;
    9. public interface BrandService {
    10.  
    11.     /**
    12.      * 1、查询所有商品
    13.      *
    14.      * @return
    15.      */
    16.     List<Brand> selectAll();
    17.  
    18.     /**
    19.      *  2、添加商品
    20.      *
    21.      *  @param brand
    22.      */
    23.     void add(Brand brand);
    24.  
    25.     /**
    26.      * 3、批量删除
    27.      */
    28.  
    29.     void deleteByIds(int[] ids);
    30.  
    31.     /**
    32.      *  4、查询当前页数据功能 & 查询数据库商品的总个数
    33.      *
    34.      * @param begin ： 当前页数
    35.      * @param size  ： 每一页的展示数据个数
    36.      * @return
    37.      */
    38.  
    39.     PageBean<Brand> selectByPage(int begin, int size);
    40.  
    41.  
    42.  
    43.     /**
    44.      * 6、分页模糊条件查询功能 & 模糊查询出总商品数功能
    46.      * @return
    47.      */
    48.  
    49.     PageBean<Brand> selectByPageAndCondition( int begin, int size,  Brand brand);
    50.  
    51.  
    52.  
    53.  
    54. }

    BrandServiceImpl：（实现BrandService接口）【该BrandServiceImpl实现了BrandService接口中的所有方法，因为BrandService接口中写的代码逻辑基本上和mapper层的代理接口一样，所以我们在BrandServiceImpl类中做业务逻辑同样相当于以前单独的一个BrandService类中的形式是一样的。】

    细节1：使用BrandServiceImpl类实现BrandService接口做业务逻辑作用：降低了service层和web层的耦合度

    细节2：所有的逻辑基本上就在业务逻辑层做处理，比如模糊查询需要用到%%，把查询的数据封装到对象属性中等、

    1. package com.itheima.service.impl;
    2. import com.itheima.mapper.BrandMapper;
    3. import com.itheima.pojo.Brand;
    4. import com.itheima.pojo.PageBean;
    5. import com.itheima.service.BrandService;
    6. import com.itheima.util.SqlSessionFactoryUtils;
    7. import org.apache.ibatis.session.SqlSession;
    8. import org.apache.ibatis.session.SqlSessionFactory;
    9.  
    10. import java.util.List;
    11.  
    12. /**
    13.  *  用这个类实现接口（BrandService）的最终目的：
    14.  *      降低service业务逻辑层和web层的servlet之间的耦合度
    15.  *
    16.  *  原因： 以前的BrandService类（业务逻辑层）里面是用的方法，把增删改查等全部写成了方法返回到servlet层的
    17.  *  现在是把这些增删改查的方法单独写到了实现BrandService接口的这个类当中了，降低了耦合度
    18.  */
    19.  
    20. public class BrandServiceImpl implements BrandService {
    21.     // 1. 创建工厂对象
    22.     SqlSessionFactory factory = SqlSessionFactoryUtils.getSqlSessionFactory();
    23.  
    24.     /**
    25.      * 1、查询所有商品
    26.      *
    27.      * @return
    28.      */
    29.     @Override
    30.     public List<Brand> selectAll() {
    31.         // 2. 获取Session
    32.         SqlSession sqlSession = factory.openSession();
    33.         // 3. 映射出BrandMapper接口
    34.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
    35.  
    36.         // 4. 调用BrandMapper接口中的查询所有的方法
    37.         List<Brand> brands = brandMapper.selectAll();
    38.  
    39.         // 释放资源
    40.         sqlSession.close();
    41.         return brands;
    42.     }
    43.  
    44.  
    45.     /**
    46.      * 2、添加商品
    47.      *
    48.      * @param brand
    49.      */
    50.     @Override
    51.     public void add(Brand brand) {
    52.         // 2. 获取Session
    53.         SqlSession sqlSession = factory.openSession();
    54.         // 3. 映射出BrandMapper接口
    55.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
    56.  
    57.         // 4. 调用BrandMapper接口中的查询所有的方法
    58.         brandMapper.add(brand);
    59.  
    60.         // 5. 提交事务
    61.         sqlSession.commit();
    62.         // 6. 释放资源
    63.         sqlSession.close();
    64.  
    65.     }
    66.  
    67.  
    68.     /**
    69.      * 3、批量删除
    70.      */
    71.     @Override
    72.     public void deleteByIds(int[] ids) {
    73.  
    74.         // 2. 获取Session
    75.         SqlSession sqlSession = factory.openSession();
    76.         // 3. 映射出BrandMapper接口
    77.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
    78.  
    79.         // 4. 调用BrandMapper接口中的批量删除的方法
    80.         brandMapper.deleteByIds(ids);
    81.  
    82.         // 5. 提交事务
    83.         sqlSession.commit();
    84.         // 6. 释放资源
    85.         sqlSession.close();
    86.  
    87.     }
    88.  
    89.  
    90.     /**
    91.      * 4、查询当前页数据功能 & 查询数据库商品的总个数
    92.      *
    93.      *      思路： 把查询出来的当前页数据和数据库商品的总个数 封装到PageBean对象的属性当中，然后把PageBean对象返回给前端
    94.      *
    95.      *  @param begin ： 当前页数
    96.      *  @param size  ： 每一页的展示数据个数
    97.      */
    98.     @Override
    99.     public PageBean<Brand> selectByPage(int begin,int size) {
    100.         // 4.2. 获取Session
    101.         SqlSession sqlSession = factory.openSession();
    102.         // 4.3. 映射出BrandMapper接口
    103.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
    104.  
    105.         /**
    106.          * 重点： 在这里进行一下SQL语句分页查询的计算
    107.          *    如： select * from emp limit 0,8;    # 计算公式：起始索引(页数)从0开始   起始索引 =(当前查询的页数-1)*每页展示数据数
    108.          *    我们拿到的客户端请求的页数是第begin页，那么我们的SQL查询起始索引就是（begin-1）* size
    109.          */
    110.  
    111.         // 4.4、计算起始索引
    112.         int begin1 =(begin-1)*size;
    113.  
    114.         // 4.5、计算每页展示的数据个数
    115.         int size1 =size;
    116.  
    117.         /**
    118.          *  4.6、调用BrandMapper接口的查询当前页数据的功能
    119.          */
    120.         List<Brand> brands =brandMapper.selectByPage(begin1,size1);
    121.  
    122.         /**
    123.          * 4.7、调用BrandMapper接口的查询数据库商品总数的功能
    124.          */
    125.         int totalCount =brandMapper.selectTotalCount();
    126.  
    127.         /**
    128.          *  4.8、
    129.          *      把 6、7 查询出来的数据封装到PageBean对象的属性当中 返回给前端
    130.          */
    131.         PageBean<Brand> pageBean =new PageBean<>();
    132.         // 把数据封装到PageBean对象属性当中
    133.         pageBean.setRows(brands);
    134.         pageBean.setTotalCount(totalCount);
    135.  
    136.         /**
    137.          * 4.9、把pageBean对象返回给前端（属性中已经封装好查询出来的数据咯）
    138.          */
    139.         sqlSession.close();
    140.         return pageBean;
    141.  
    142.     }
    143.  
    144.     /**
    145.      *   5、   分页模糊条件查询功能 & 模糊查询出总商品数功能
    147.      * @param begin ：当前页数
    148.      * @param size ： 每页中展示的数据数
    149.      * @param brand ： 模糊条件查询的数据
    150.      * @return
    151.      */
    152.  
    153.     @Override
    154.     public PageBean<Brand> selectByPageAndCondition(int begin, int size, Brand brand) {
    155.         // 5.2. 获取Session
    156.         SqlSession sqlSession = factory.openSession();
    157.         // 5.3. 映射出BrandMapper接口
    158.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
    159.  
    160.  
    161.         /**
    162.          * 5.4、 调用BrandMapper接口中的 "分页模糊条件查询功能" （ 把模糊查询的结果按分页的形式查询出来，等会响应给前端 ）
    163.          *
    164.          *          注意：这里传参之前要把brand对象当中各属性加上 ”%属性名%“  （因为brand对象属性当中封装了前端模糊查询的请求数据，
    165.          *                                                              又因为模糊查询SQL语句是： like %数据%  所以要处理属性）
    166.          *
    167.          * // !!!! 1、这里要进行一下判断 不判断的话 如果有为null的 那下面模糊处理 就成了 %null%  就会使SQL语句错误了
    168.          * // !!!! 2、还要进行分页查询的计算
    169.          */
    170.         // 处理模糊表达式
    171.         String brandName =brand.getBrandName();
    172.         if (brandName!=null && brandName.length() >0){   // 这里要进行一下判断 不判断的话 如果有为null的 那下面模糊处理 就成了 %null%  就会使SQL语句错误了
    173.  
    174.             brand.setBrandName("%" +brandName+ "%");  // 再把客户端请求的数据做一下模糊表达式处理（如："%华为%")），然后再封装到属性当中 传给代理接口进行SQL语句查询
    175.             System.out.println(brand.getBrandName());
    176.         }
    177.  
    178.         String companyName =brand.getCompanyName();
    179.         if (companyName!=null && companyName.length() >0){   // 不为null 说明前端请求的有值
    180.             brand.setCompanyName("%" +companyName+ "%");  // 再把客户端请求的数据做一下模糊表达式处理（如："%华为%")），然后再封装到属性当中 传给代理接口进行SQL语句查询
    181.         }
    182.  
    183.         // 分页计算
    184.         int begin1 =(begin-1)*size;
    185.         int size1 =size;
    186.  
    187.  
    188.         List<Brand> brands =brandMapper.selectByPageAndCondition(begin1,size1,brand); // 这里再传的对象属性就是进行过模糊处理的属性数据
    189.  
    190.         /**
    191.          *  5.5、 调用BrandMapper接口中的查询 "模糊查询出来的总商品数量" 功能方法 （ 把模糊查询查询出来的总商品数量查询出来，等会响应给前端 ）
    192.          */
    193.         int counts =brandMapper.selectTotalCountByCondition(brand);
    194.  
    195.         /**
    196.          *  5.6、 把 5.4、5.5 查询出来的结果 封装到PageBean对象属性当中，传递响应给前端
    197.          */
    198.  
    199.         PageBean<Brand> pageBean =new PageBean<>();
    200.         // 封装数据到属性当中
    201.         pageBean.setTotalCount(counts);
    202.         pageBean.setRows(brands);
    203.  
    204.  
    205.         //  释放资源，返回PageBean对象
    206.         sqlSession.close();
    207.         return pageBean;
    208.  
    209.     }
    210. }
    211.  
    212.

    2.3、web层 

    （使用优化后的servlet。 作用：减少了servlet的个数，以前我们做增删改查的时候就要写增删改查的servlet，需要写4个，太繁琐 ，优化后把每个servlet写成对象方法了 直接调用即可）

    可以说因为BsaeServlet继承了HttpServlet，又BrandServlet继承了BsaeServlet，BrandServlet头上又写了访问的路径，所以可以说BrandServlet继承了HttpServlet并自带访问路径地址，可以说和以前的doGet、doPost使用方法又一样了

    BsaeServlet：

    这个类继承了HttpServlet，能继承service（）方法 【可以理解为该方法是doPost，doGet他爹】

    1. package com.itheima.web.servlet;
    2. import javax.servlet.ServletException;
    3. import javax.servlet.http.HttpServlet;
    4. import javax.servlet.http.HttpServletRequest;
    5. import javax.servlet.http.HttpServletResponse;
    6. import java.io.IOException;
    7. import java.lang.reflect.InvocationTargetException;
    8. import java.lang.reflect.Method;
    9.  
    10. public class BaseServlet extends HttpServlet {
    11.     @Override
    12.     protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    13.         // 1. 获取请求路径
    14.         String url =req.getRequestURI();
    15.  
    16.         //  获取最后一段路径（方法名）
    17.         int index =url.lastIndexOf("/");    // 从路径后面数 第一次出现“/”的位置
    18.         String methodName =url.substring(index+1);   // 获取到从“/”开始截取的后面的路径 （这里我们不要/ 所以+1）
    19.         // System.out.println(methodName);
    20.  
    21.         // 2. 执行BrandServlet对象中的selectAll方法
    22.  
    23.         // 2.1 获取BrandServlet 字节码对象 Class （映射）
    24.         Class<? extends BaseServlet> cls =this.getClass();
    25.         /**
    26.          *  注意：这个 this代表的是谁？
    27.          *      因为BrandServlet继承了该BaseServlet，所以可以说BrandServlet类当中也有BaseServlet类当中的
    28.          *      service（）方法，当客户端请求路径 @WebServlet("/brand/*") 格式的时候，会进入到BaseServlet资源
    29.          *      路径下，会自动调用该service（）方法，所以谁调用该方法，this就代表哪个对象
    30.          *      因为实际上是BrandServlet类中调用的service（）方法 所以this代表BrandServlet对象
    31.          */
    32.  
    33.         // 2.2 获取方法 Method对象（映射）
    34.         try {
    35.  
    36.             Method method =cls.getDeclaredMethod(methodName, HttpServletRequest.class, HttpServletResponse.class);
    37.  
    38.  
    39.             // 2.3 调用该方法 （映射）
    40.             method.invoke(this,req,resp); // 把客户端的请求数据传到service方法参数中
    41.  
    42.         } catch (NoSuchMethodException e) {
    43.             e.printStackTrace();
    44.         } catch (InvocationTargetException e) {
    45.             e.printStackTrace();
    46.         } catch (IllegalAccessException e) {
    47.             e.printStackTrace();
    48.         }
    49.  
    50.  
    51.     }
    52. }

    BrandServlet： （继承了BsaeServlet类）：

    1. package com.itheima.web.servlet;
    2. import com.alibaba.fastjson.JSON;
    3. import com.alibaba.fastjson.JSONObject;
    4. import com.itheima.pojo.Brand;
    5. import com.itheima.pojo.PageBean;
    6. import com.itheima.service.BrandService;
    7. import com.itheima.service.impl.BrandServiceImpl;
    8. import javax.servlet.ServletException;
    9. import javax.servlet.annotation.WebServlet;
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import java.io.BufferedReader;
    13. import java.io.IOException;
    14. import java.util.List;
    15.  
    16. /**
    17.  *  BrandServlet 继承父类BaseServlet
    18.  *  父类中继承了HttpServlet 所以还是相当于BrandServlet继承了HttpServlet
    19.  *
    20.  *  父类BaseServlet中有service方法 （该方法当客户端访问相对应路径时自动调用该方法中）
    21.  *  子类继承了父类 也就是说：这个BrandServlet中实际上也有个service方法 当访问该 @WebServlet("/brand/*")路径时
    22.  *  其实调用的是BrandServlet类当中的service（）方法
    23.  *
    24.  */
    25.  
    26. @WebServlet("/brand/*")
    27. public class BrandServlet extends BaseServlet{
    28.  
    29.     // 获取业务逻辑层对象
    30.     private BrandService brandService =new BrandServiceImpl();
    31.  
    32.     /**
    33.      *  1、 查询所有商品功能
    34.      */
    35.     public void selectAll(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
    36.  
    37.         // 1. 调用BrandServiceImpl完成查询所有功能
    38.         List<Brand> brands =brandService.selectAll();
    39.  
    40.         // 2. 将Java对象数据转换成JSON格式数据，响应给前端
    41.         response.setContentType("text/json;charset=utf-8"); // 中文乱码问题
    42.         String toString = JSON.toJSONString(brands);
    43.  
    44.         // 3. 响应给前端数据
    45.         response.getWriter().write(toString);
    46.     }
    47.  
    48.     /**
    49.      *  2、 添加商品功能
    50.      */
    51.     public void add(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
    52.  
    53.         // 1. 通过抓包拿到前端请求过来的数据（演示的是前端的数据为JSON格式）
    54.         BufferedReader bufferedReader =request.getReader();
    55.         String rl =bufferedReader.readLine();   // 拿到前端请求的JSON数据
    56.  
    57.         // 2. 将JSON数据转换成Java数据 （也就是说将JSON数据转换成Brand对象类型，将数据封装到对象属性中了）
    58.         Brand brand =JSON.parseObject(rl,Brand.class);
    59.  
    60.         // 3. 调用BrandService接口中的添加商品方法
    61.         brandService.add(brand);
    62.  
    63.         // 4. 响应给前端success的标识信号
    64.         response.getWriter().write("success");
    65.     }
    66.  
    67.     /**
    68.      * 3、批量删除商品功能
    69.      *      思路：把客户端请求的删除id 封装到int数组里面 然后传递给代理接口 供SQL语句使用 （SQL语句要用增强for 遍历该数组删除数据即可）
    70.      */
    71.  
    72.     public void deleteByIds(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
    73.  
    74.         // 1、抓包 （ 前端是以JSON数据格式请求数据的，所以需要先抓包 ）
    75.         BufferedReader bufferedReader =request.getReader();
    76.         String params =bufferedReader.readLine();
    77.         // System.out.println(params);   // 拿到前端请求的JSON数据格式： [1,2,3,4,5]
    78.  
    79.         // 2、把JSON数据转换成Java的数组格式
    80.         int[] ids =JSON.parseObject(params,int[].class);
    81.  
    82.         // 3、调用业务逻辑层的批量删除方法 （将数组传到sql语句当中去）
    83.         brandService.deleteByIds(ids);
    84.  
    85.         // 4、删除完成后，响应给前端成功的标识
    86.         response.getWriter().write("success");
    87.  
    88.  
    89.     }
    90.  
    91.     /**
    92.      *  4、查询当前页码数据功能 & 查询数据库商品的总个数
    93.      */
    94.     public void selectByPage(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
    95.  
    96.  
    97.         // 1、接收前端请求过来的 ”当前页码数“ 和 “每页展示的数据个数”
    98.  
    99.         // 假设：前端的访问类型：url?currentPage=1&pageSize=5  （表示：第一页，每一页有五条数据）
    100.         // 因为前端不是以JSON格式数据请求的，所以用request域当中的方法就可以获取前端的请求（和doPost doGet方法一样）
    101.         String _currentPage =request.getParameter("currentPage");
    102.         String _pageSize =request.getParameter("pageSize");
    103.  
    104.         // 2、把String字符串类型转换成int类型
    105.         int currentPage =Integer.parseInt(_currentPage);
    106.         int pageSize =Integer.parseInt(_pageSize);
    107.  
    108.         // 3、调用查询方法 （把 ”当前页码“ 和 “每页展示的数据个数” 传递过去）
    109.         PageBean<Brand> o =brandService.selectByPage(currentPage,pageSize);
    110.  
    111.         // 4. 将Java对象数据转换成JSON格式数据，响应给前端
    112.         response.setContentType("text/json;charset=utf-8"); // 中文乱码问题
    113.         String toString = JSON.toJSONString(o);
    114.  
    115.         // 5. 响应给前端数据
    116.         response.getWriter().write(toString);
    117.     }
    118.  
    119.  
    120.     /**
    121.      *  4、分页模糊条件查询功能 & 模糊查询出总商品数功能
    122.      */
    123.     public void selectByPageAndCondition(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
    124.         // 解决POST乱码问题
    125.         request.setCharacterEncoding("UTF-8");
    126.  
    127.         // 1、接收前端请求过来的 ”当前页码数“ 和 “每页展示的数据个数” 和”模糊条件查询请求的数据参数“  （模糊条件查询请求的数据参数：前端是以JSON数据请求过来的）
    128.  
    129.         String _currentPage =request.getParameter("currentPage");
    130.         String _pageSize =request.getParameter("pageSize");
    131.  
    132.         // 2、把String字符串类型转换成int类型
    133.         int currentPage =Integer.parseInt(_currentPage);
    134.         int pageSize =Integer.parseInt(_pageSize);
    135.  
    136.         // 3、获取前端模糊条件查询的请求参数
    137.         // 3.1、先抓包
    138.         BufferedReader bufferedReader =request.getReader();
    139.         // 3.2、读一行
    140.         String params =bufferedReader.readLine(); // 拿到前端模糊查询请求参数的JSON数据格式
    141.  
    142.         // 3.3、将JSON数据 转换成 Java对象形式
    143.         Brand brand =JSON.parseObject(params,Brand.class);  // brand对象属性中封装好了前端模糊请求的数据
    144.  
    145.         // 4、 调用 分页模糊条件查询功能
    146.         PageBean<Brand> o =brandService.selectByPageAndCondition(currentPage,pageSize,brand);
    147.  
    148.         String jsonString = JSON.toJSONString(o);
    149.         // 5、 将查询出来的Java对象数据转换成JSON格式数据，响应给前端
    150.         response.setContentType("text/json;charset=utf-8"); // 中文乱码问题
    151.        // 6、 响应给前端数据
    152.         response.getWriter().write(jsonString);
    153.  
    154.     }
    155. }

    其他代码找我要即可~

  • 相关阅读:
    有什么自定义表单工具功能较好？
    Linux shell编程学习笔记27：tputs
    03.爬楼梯 04.使用最小花费爬楼梯
    为什么选择clickhouse?
    抠图专题1：抠出白色陶瓷杯（每天一个PS小项目）
    渐进式JavaScript框架---Vue.js
    超长表单分页校验,下一页和上一页功能
    数字化工厂建设方案探讨
    shell语法（一）
    【故障公告】龙卷风来袭：突增的并发请求，撑不住的CPU
  • 原文地址：https://blog.csdn.net/lwj_07/article/details/125632828