修改不成功，麻烦帮忙看一下

相关代码：

package com.imooc.mgallery.controller;

import com.imooc.mgallery.entity.Painting;
import com.imooc.mgallery.service.PaintingService;
import com.imooc.mgallery.utils.PageModel;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.UUID;

@WebServlet("/management")
public class ManagementController extends HttpServlet {
    private PaintingService paintingService = new PaintingService();
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //因为是doPost调用所以要添加字符集
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        String method = request.getParameter("method");
        //显示分页的数据,创建list方法
        if(method.equals("list")){//分页查询列表 方法在下面已经创建
            this.list(request, response);
        }else if(method.equals("show_create")){//显示新增页面  方法在下面已经创建
            this.showCreatePage(request, response);
        }else if(method.equals("create")){//新增油画  方法在下面已经创建
            this.create(request, response);
        }else if(method.equals("show_update")){//修改查询油画  方法在下面已经创建
            this.showUpdatePage(request, response);
        }else if(method.equals("update")){//更新油画 方法在下面已经创建
            this.update(request, response);
        }

    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }
    protected void list(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //从前端接受数据
        String p = request.getParameter("p");
        String r = request.getParameter("r");
        //为空时赋默认值
        if(p == null){
            p = "1";
        }if(r == null){
            r = "6";
        }
        PageModel pageModel = paintingService.pagination(Integer.parseInt(p),Integer.parseInt(r));
        //将得到的内容放入请求属性中
        request.setAttribute("pageModel", pageModel);
        //转发到指定路径，进行数据展现
        request.getRequestDispatcher("/WEB-INF/jsp/list.jsp").forward(request, response);
    }

    //显示新增页面
    protected void showCreatePage(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.getRequestDispatcher("/WEB-INF/jsp/create.jsp").forward(request, response);
    }
    //新增油画的方法
    protected void create(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
       /* 文件上传时的数据处理和标准表单不同，文件上传需要二进制，在此无法获取信息
        需要借助第三方组件进行文件上传*/
        /*String pname = request.getParameter("pname");
        System.out.println(pname);在此不起作用*/

        //1.初始化FileUpload
        /**
         * FileItemFactory用于将前端表单数据转换成叫做FileItem的对象
         * ServletFileUpload是为FileUpload组件提供java web的HTTP请求解析、
         * 次两者联合使用
         */
        FileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload sf = new ServletFileUpload(factory);
        //2.遍历所有FileItem
        try {
            //将请求来的表单数据转换成FileItem对象
            List<FileItem> formData = sf.parseRequest(request);
            Painting painting = new Painting();
            for(FileItem fi : formData){
                //普通输入项为true；文件上传框就为false
                if(fi.isFormField() == true){
                    System.out.println("普通输入项："+fi.getFieldName()+":"+fi.getString("UTF-8"));
                    switch (fi.getFieldName()){
                        case "pname" :
                            painting.setPname(fi.getString("UTF-8"));
                            break;
                        case "category" :
                            painting.setCategroy(Integer.parseInt(fi.getString("UTF-8")));
                            break;
                        case "price" :
                            painting.setPrice(Integer.parseInt(fi.getString("UTF-8")));
                            break;
                        case "description" :
                            painting.setDescription(fi.getString("UTF-8"));
                            break;
                    }
                }else{
                    System.out.println("文件上传项："+fi.getFieldName());
                    //3.将上传的文件保存到服务器的upload目录中
                    //此方法可以获取到运行时upload所在的物理路径
                    String path = request.getServletContext().getRealPath("/upload");
                    System.out.println("上传文件的目录"+path);
                    //String fileName = "test.jpg";
                    //为上传的文件随机取名  UUID是java内置对象，用于随机取名
                    String fileName = UUID.randomUUID().toString();
                    //文件扩展名，提取原文件扩展名，添加到随机名字的文件上
                    //做法是获取文件名，截取从最后一次出现.开始后面的内容
                    String suffix = fi.getName().substring(fi.getName().lastIndexOf("."));
                    fi.write(new File(path, fileName + suffix));
                    painting.setPreview("/upload/" + fileName + suffix);
                }
            }
            paintingService.create(painting);//新增功能
            response.sendRedirect("/management?method=list");//返回列表页
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 修改查询油画
     * @param request
     * @param response
     * @throws ServletException
     * @throws IOException
     */
    protected void showUpdatePage(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //接受前端传来的id
        String id = request.getParameter("id");
        Painting painting = paintingService.findById(Integer.parseInt(id));
        //把得到的对象放入请求属性，再转发到指定修改的jsp
        request.setAttribute("painting", painting);
        request.getRequestDispatcher("//WEB-INF/jsp/update.jsp").forward(request, response);
    }

    protected void update(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.初始化FileUpload
        /**
         * FileItemFactory用于将前端表单数据转换成叫做FileItem的对象
         * ServletFileUpload是为FileUpload组件提供java web的HTTP请求解析、
         * 次两者联合使用
         */
        FileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload sf = new ServletFileUpload(factory);
        //String isPreviewModified = request.getParameter("isPreviewModified");
        Integer isPreviewModified = 0;
        //2.遍历所有FileItem
        //将请求来的表单数据转换成FileItem对象
        try {
            List<FileItem> formData = sf.parseRequest(request);
            Painting painting = new Painting();
            for(FileItem f : formData){
                //普通输入项为true；文件上传框就为false
                if(f.isFormField() == true){
                    switch (f.getFieldName()){
                        case "id":
                            painting.setId(Integer.parseInt(f.getString("UTF-8")));
                            break;
                        case "pname":
                            painting.setPname(f.getString("UTF-8"));
                            break;
                        case "category":
                            painting.setCategroy(Integer.parseInt(f.getString("UTF-8")));
                            break;
                        case "price" :
                            painting.setPrice(Integer.parseInt(f.getString("UTF-8")));
                            break;
                        case "description" :
                            painting.setDescription(f.getString("UTF-8"));
                            break;
                    }
                    }else{
                    if(isPreviewModified == 1) {
                        System.out.println("文件上传项：" + f.getFieldName());
                        //3.将上传的文件保存到服务器的upload目录中
                        //此方法可以获取到运行时upload所在的物理路径
                        String path = request.getServletContext().getRealPath("/upload");
                        System.out.println("上传文件的目录" + path);
                        //String fileName = "test.jpg";
                        //为上传的文件随机取名  UUID是java内置对象，用于随机取名
                        String fileName = UUID.randomUUID().toString();
                        //文件扩展名，提取原文件扩展名，添加到随机名字的文件上
                        //做法是获取文件名，截取从最后一次出现.开始后面的内容
                        String suffix = f.getName().substring(f.getName().lastIndexOf("."));
                        f.write(new File(path, fileName + suffix));
                        painting.setPreview("/upload/" + fileName + suffix);
                    }
                }
            }
            paintingService.update(painting,isPreviewModified);//更新功能
            response.sendRedirect("/management?method=list");//返回列表页
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


}

相关代码：

package com.imooc.mgallery.dao;

import com.imooc.mgallery.entity.Painting;
import com.imooc.mgallery.utils.PageModel;
import com.imooc.mgallery.utils.XmlDataSource;

import java.util.ArrayList;
import java.util.List;

public class PaintingDao {
    /**
     * 分页查询油画数据
     *
     * @param page 页号
     * @param rows 当前页面对应的数据数量
     * @return PageModel分页对象
     */
    //把PageModel类当做返回值
    public PageModel pagination(int page, int rows) {
        //获取油画数据
        List<Painting> list = XmlDataSource.getRawData();
        //将数据放入PageModel类中
        PageModel pageModel = new PageModel(list, page, rows);
        return pageModel;
    }
    //对pagination方法重载

    /**
     * 按照类别进行查询
     *
     * @param categroy 分类编号
     * @param page     页号
     * @param rows     内容
     * @return 分类后的对象
     */
    public PageModel pagination(int categroy, int page, int rows) {
        //获取油画数据
        List<Painting> list = XmlDataSource.getRawData();
        //创建一个需要得到的categroy集合
        List<Painting> categroyList = new ArrayList<>();
        //对原始的数据进行遍历拿取
        //如果原始数据中的getCategroy和传入的categroy相等，那么就进行拿取
        for (Painting pa : list) {
            if (pa.getCategroy() == categroy) {
                categroyList.add(pa);
            }
        }
        PageModel pageModel = new PageModel(categroyList, page, rows);
        return pageModel;
    }

    /**
     * 新增数据
     */
    public void create(Painting painting) {
        XmlDataSource.append(painting);
    }

    /**
     * 修改查询数据
     */
    public Painting findById(Integer id) {
        //从数据中遍历取出需要的id
        List<Painting> data = XmlDataSource.getRawData();
        //创建一个Painting对象用来保存拿到id的对象
        Painting painting = null;
        for (Painting p : data) {
            if (p.getId() == id) {
                painting = p;
                break;
            }
        }
        //返回得到的数据，如果没有就会返回null
        return painting;
    }

    /**
     * 更新数据
     */
    public void update(Painting painting){
        XmlDataSource.update(painting);
    }



}

相关代码：

package com.imooc.mgallery.service;
/**
 * 油画服务类
 */

import com.imooc.mgallery.dao.PaintingDao;
import com.imooc.mgallery.entity.Painting;
import com.imooc.mgallery.utils.PageModel;
import com.imooc.mgallery.utils.XmlDataSource;

import java.awt.*;
import java.util.List;

public class PaintingService {
    private PaintingDao paintingDao = new PaintingDao();

    /**
     * pagination数据分页查询
     * @param page 页号
     * @param rows 当前页面对应的数据数量
     * @param categroy 可选参数，代表它可以有，也可以没有，还有可能是多个
     *                 可变参数的书写形式是（参数类型 ...  参数名）。
     *                 这里的String是参数类型，可以换成其他的。比如，int类型的可变参数（int ...  args）。
     * @return PageModel分页对象
     */
    public PageModel pagination(int page, int rows, String... categroy){
        if(rows == 0){
            throw new RuntimeException("无效的rows参数");
        }
        //当传入的categroy长度是0或者第一个元素是空，证明没有从前端传过来任何与分类有关的信息
        if(categroy.length == 0 || categroy[0] == null) {
            //返回所有数据信息
            return paintingDao.pagination(page, rows);
            //有信息的时候
        }else{
            //因为从前端过来的是一个string，所以需要转换,拿到第一个值
            //返回的是Dao中的三参方法，筛选后的categroy集合
            return paintingDao.pagination(Integer.parseInt(categroy[0]),page, rows);
        }
    }

    /**
     * 新增数据
     */
    public void create(Painting painting){
        paintingDao.create(painting);
    }

    /**
     * 修改查询数据
     * @return painting对象
     */
    public Painting findById(Integer id){
        Painting p =  paintingDao.findById(id);
        //处理为空的情况
        if(p == null){
            throw new RuntimeException("[id=" + id + "]油画不存在");
        }
        return p;
    }

    public void update(Painting newPainting,int isPreviewModified){
        Painting painting = paintingDao.findById(newPainting.getId());
        if(isPreviewModified == 1){
            painting.setPreview(newPainting.getPreview());
        }
        paintingDao.update(painting);
    }




//    public static void main(String[] args) {
//        PaintingService paintingService = new PaintingService();
//        PageModel pageModel = paintingService.pagination(2, 6);
//        List<Painting> paintingList = pageModel.getPageData();
//        for(Painting pa : paintingList){
//            System.out.println(pa.getPname());
//        }
//        System.out.println(pageModel.getPageStartRow() + ":" + pageModel.getPageEndRow());
//    }
}

相关代码：

package com.imooc.mgallery.utils;

import java.util.ArrayList;
import java.util.List;

/**
 * 分页模型对象
 */
public class PageModel {
    private int page;//页号
    private int totalPages;//总页数
    private int rows;//页面对应的数据数量
    private int totalRows;//原始数据总量
    private int pageStartRow;//当前页数据从第几行开始
    private int pageEndRow;//当前页数据到第几行结束
    private boolean hasNextPage;//是否存在下一页
    private boolean hasPreviousPage;//是否存在上一页
    private List pageData;//当前页面的数据

    public PageModel() {

    }

    /**
     * 初始化PageModel属性，计算分页属性
     *
     * @param data 原始数据集合
     * @param page 页号
     * @param rows 页面对应的数据数量
     */
    public PageModel(List data, int page, int rows) {
        this.page = page;
        this.rows = rows;
        totalRows = data.size();
        //Math.ceil是浮点数向上取整，Math.floor就是浮点数向下取整，返回值都是double

        //总页数计算规则：总行数/每页记录数，能整除，页数取整，不能整除向上取整
        /*此处注意！因为totalRows和rows都是整数类型，那么相除得到的结果只会保留整数，就会舍弃小数。
        所以把其中任何一个乘以一个浮点型或者double型那么结果就会变成一个浮点数*/
        totalPages = new Double(Math.ceil(totalRows / (rows * 1f))).intValue();
        //当前页开始行号
        pageStartRow = (page - 1) * rows;
        //当前页结束行号
        pageEndRow = page * rows;
        //为避免下标越界的问题
        if (pageEndRow > totalRows) {
            pageEndRow = totalRows;
        }

        pageData = data.subList(pageStartRow, pageEndRow);
        //判断是否存在上一页
        if(page > 1){
            hasPreviousPage = true;
        }else{
            hasPreviousPage = false;
        }
        //判断是否存在下一页
        if(page < totalPages){
            hasNextPage = true;
        }else{
            hasNextPage = false;
        }
    }

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }

    public int getTotalPages() {
        return totalPages;
    }

    public void setTotalPages(int totalPages) {
        this.totalPages = totalPages;
    }

    public int getRows() {
        return rows;
    }

    public void setRows(int rows) {
        this.rows = rows;
    }

    public int getTotalRows() {
        return totalRows;
    }

    public void setTotalRows(int totalRows) {
        this.totalRows = totalRows;
    }

    public int getPageStartRow() {
        return pageStartRow;
    }

    public void setPageStartRow(int pageStartRow) {
        this.pageStartRow = pageStartRow;
    }

    public int getPageEndRow() {
        return pageEndRow;
    }

    public void setPageEndRow(int pageEndRow) {
        this.pageEndRow = pageEndRow;
    }

    public boolean isHasNextPage() {
        return hasNextPage;
    }

    public void setHasNextPage(boolean hasNextPage) {
        this.hasNextPage = hasNextPage;
    }

    public boolean isHasPreviousPage() {
        return hasPreviousPage;
    }

    public void setHasPreviousPage(boolean hasPreviousPage) {
        this.hasPreviousPage = hasPreviousPage;
    }

    public List getPageData() {
        return pageData;
    }

    public void setPageData(List pageData) {
        this.pageData = pageData;
    }

    public static void main(String[] args) {
        List sample = new ArrayList();
        for (int i = 1; i <= 100; i++) {
            sample.add(i);

        }
        PageModel pageModel = new PageModel(sample,6,8);
        System.out.println(pageModel.getPageData());
        System.out.println(pageModel.getTotalPages());
        System.out.println(pageModel.getPageStartRow()+":"+ pageModel.getPageEndRow());
    }
}

相关代码：

package com.imooc.mgallery.utils;

import com.imooc.mgallery.entity.Painting;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;

import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.List;

/**
 * 数据源类，用于将xml解析成java对象
 */
public class XmlDataSource {
    //通过static关键字保证数据全局唯一,即所有的dao类只能访问这个一个地址
    //使用list集合保存xml的油画数据
    private static List<Painting> data = new ArrayList();
    //保存xml文件的地址
    private static String dataFile;

    //需要在静态代码块中实现
    static {
        //得到这个类的根路径，找到painting.xml文件，再得到文件的物理磁盘路径地址
        dataFile = XmlDataSource.class.getResource("/painting.xml").getPath();
        reload();//更新数据
    }

    private static void reload() {
        //如果文件路径有空格等不确定字符，可以使用该类进行转换
        URLDecoder decoder = new URLDecoder();
        try {
            dataFile = decoder.decode(dataFile, "UTF-8");
            System.out.println(dataFile);
            //利用dome4j对xml进行解析
            SAXReader reader = new SAXReader();
            //读取xml路径,获取DOcument文档对象
            Document document = reader.read(dataFile);
            //使用X-path得到xml的节点集合
            List<Node> nodes = document.selectNodes("/root/painting");
            //得到painting节点后，把节点内容赋值给实体类Painting
            //将data数据首先清空，然后进行重新读取以做更新
            data.clear();
            for (Node node : nodes) {
                //需要把node类型转换成Element类型
                Element element = (Element) node;
                String id = element.attributeValue("id");
                String pname = element.elementText("pname");
                System.out.println(id + ":" + pname);

                //实例化实体类Painting进行赋值
                Painting painting = new Painting();
                //编号
                painting.setId((Integer.parseInt(id)));
                //合在一起的写法painting.setId(Integer.parseInt(element.attributeValue("id")));
                //名称
                painting.setPname(pname);
                //合在一起的写法painting.setPname(element.elementText("pname"));
                //下面就是将上面的拆分写到一起

                //分类
                painting.setCategroy(Integer.parseInt(element.elementText("category")));
                //售价
                painting.setPrice(Integer.parseInt(element.elementText("price")));
                //地址
                painting.setPreview(element.elementText("preview"));
                //描述
                painting.setDescription(element.elementText("description"));
                //将油画实体对象加入最初的静态集合中
                data.add(painting);
            }

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

    /**
     * 获取所有的油画对象
     *
     * @return Painting List集合
     */
    public static List<Painting> getRawData() {
        return data;
    }

    public static void append(Painting painting) {
        //1.读取XML文档，得到document对象
        SAXReader reader = new SAXReader();
        //向文件写入字符流
        Writer writer = null;
        try {
            Document document = reader.read(dataFile);
            //2.创建新的painting节点

            //首页得到XML中的根节点
            Element root = document.getRootElement();
            Element p = root.addElement("painting");
            //3.创建painting节点的各个子节点

            //在原始最后一个油画id上加一就是新的id，String.valueOf是转换成字符串类型
            p.addAttribute("id", String.valueOf(data.size() + 1));
            //创建新子节点，设置文本值为painting.getPname，toString和是为了转换成字符串，以下同此
            p.addElement("pname").setText(painting.getPname());
            p.addElement("category").setText(painting.getCategroy().toString());
            p.addElement("price").setText(painting.getPrice().toString());
            p.addElement("preview").setText(painting.getPreview());
            p.addElement("description").setText(painting.getDescription());

            //4.写入XML完成追加操作

            writer = new OutputStreamWriter(new FileOutputStream(dataFile), "UTF-8");
            document.write(writer);
            System.out.println(dataFile);
            //写入完成后，需要确保上面dataFile的数据也得到更新
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            reload();//更新数据
        }


    }

    /**
     * 更新对应id的油画数据
     *
     * @param painting 要更新的油画数据
     */
    public static void update(Painting painting) {
        SAXReader reader = new SAXReader();
        Writer writer = null;
        try {
            Document document = reader.read(dataFile);
            //对指定属性的筛选  节点路径[@属性名=属性值]
            List<Node> nodes =  document.selectNodes("/root/painting[@id=" + painting.getId() + "]");
            //如果不存在要抛出异常
            if(nodes.size() == 0){
                throw new RuntimeException("id:" + painting.getId() + "不存在");
            }else{
                //id存在
                Element p = (Element) nodes.get(0);
                //得到指定标签名的唯一节点   对指定名称内容进行更新
                //因为是对xml进行更新，所以都有转换成为字符串类型
                p.selectSingleNode("pname").setText(painting.getPname());
                p.selectSingleNode("category").setText(painting.getCategroy().toString());
                p.selectSingleNode("price").setText(painting.getPrice().toString());
                p.selectSingleNode("preview").setText(painting.getPreview());
                p.selectSingleNode("description").setText(painting.getDescription());
                writer = new OutputStreamWriter(new FileOutputStream(dataFile), "UTF-8");
                //将新内容写入xml
                document.write(writer);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            reload();
        }

    }


    public static void main(String[] args) {
        /*new XmlDataSource();*/
       /* List<Painting> ps = XmlDataSource.getRawData();
        System.out.println(ps);*/
        Painting pa = new Painting();
        pa.setPname("测试油画");
        pa.setCategroy(1);
        pa.setPrice(6000);
        pa.setPreview("/upload/10.jpg");
        pa.setDescription("可以不");
        XmlDataSource.append(pa);
    }
}

修改任何数据都不成功