既然我们需要的是图片，那么直接截图，真香

 
java导出带有水印的excel
 
起因
实现思路
代码实现
思考

 
起因
 
最近接到了一个比较恶心的需求，要求在导出的excel中增加水印，并且要求必须是要excel，因为他们要对excel中的数据做操作（既然要操作那水印同样可以删掉，完全是没有用的需求，但是无奈技术做不了主，只能硬着头皮干了）
 
实现思路
 
完全没有思路，根本没有相关api，于是百度、谷歌、github查个遍，最有定了方案。
 方案有两种：
 
先弄好有水印的空excel，然后再往这个excel中写入数据。但是业务要求每个人的水印不同，所以此方案不合适。
动态生成水印图片在画到生成的excel中。可以满足业务要求，最终决定用此方式。
 
代码实现
 
实现很简单，就是先通过createWaterMark方法生成水印图片，在将图片画到所有的sheet中，具体实现如下：
 
public class ExcelWaterRemarkUtil {

    public static void painWaterMark(Workbook wb,String content) throws IOException {
        String imgFileName = "waterMark_photo_"+content+".png";
        createWaterMark(content,imgFileName);

        int sheetSize = wb.getNumberOfSheets();
        for(int i=0;i<sheetSize;i++){
            Sheet sheet = wb.getSheetAt(i);
            //获取excel实际所占行
            int row = sheet.getFirstRowNum() + sheet.getLastRowNum();
            //获取excel实际所占列
            int cell = sheet.getRow(sheet.getFirstRowNum()).getLastCellNum() + 1;
            //根据行与列计算实际所需多少水印
            putWaterRemarkToExcelNew(wb, sheet, imgFileName, 0, 0, 5, 5, cell / 5 + 1, row / 5 + 1, 0, 0);
        }
    }

    /**
     * 创建水印图片
     * @param content
     * @param fileName
     * @return
     * @throws IOException
     */
    public static String createWaterMark(String content, String fileName) throws IOException {
        Integer width = 300;
        Integer height = 200;
        // 获取bufferedImage对象
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        String fontType = "宋体";
        Integer fontStyle = java.awt.Font.PLAIN;
        Integer fontSize = 50;
        java.awt.Font font = new java.awt.Font(fontType, fontStyle, fontSize);
        // 获取Graphics2d对象
        Graphics2D g2d = image.createGraphics();
        image = g2d.getDeviceConfiguration().createCompatibleImage(width, height, Transparency.TRANSLUCENT);
        g2d.dispose();
        g2d = image.createGraphics();
        g2d.setColor(new Color(0, 0, 0, 80)); //设置字体颜色和透明度
        // 设置字体
        g2d.setStroke(new BasicStroke(1));
        // 设置字体类型  加粗 大小
        g2d.setFont(font);
        //设置倾斜度
        g2d.rotate(Math.toRadians(-10), (double) image.getWidth() / 2, (double) image.getHeight() / 2);
        FontRenderContext context = g2d.getFontRenderContext();
        Rectangle2D bounds = font.getStringBounds(content, context);
        double x = (width - bounds.getWidth()) / 2;
        double y = (height - bounds.getHeight()) / 2;
        double ascent = -bounds.getY();
        double baseY = y + ascent;
        // 写入水印文字原定高度过小，所以累计写水印，增加高度
        g2d.drawString(content, (int) x, (int) baseY);
        // 设置透明度
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
        // 释放对象
        g2d.dispose();
        String targetImagePath = Thread.currentThread().getContextClassLoader().getResource("").getPath()+fileName;
        ImageIO.write(image, "png", new File(targetImagePath));
        return targetImagePath;
    }

    /**
     * 为Excel打上水印工具函数 请自行确保参数值，以保证水印图片之间不会覆盖。 在计算水印的位置的时候，并没有考虑到单元格合并的情况，请注意
     *
     * @param wb Excel Workbook
     * @param sheet 需要打水印的Excel
     * @param waterRemarkPath 水印地址，classPath，目前只支持png格式的图片，
     *                        因为非png格式的图片打到Excel上后可能会有图片变红的问题，且不容易做出透明效果。
     *                        同时请注意传入的地址格式，应该为类似："\\excelTemplate\\test.png"
     * @param startXCol 水印起始列
     * @param startYRow 水印起始行
     * @param betweenXCol 水印横向之间间隔多少列
     * @param betweenYRow 水印纵向之间间隔多少行
     * @param XCount 横向共有水印多少个
     * @param YCount 纵向共有水印多少个
     * @param waterRemarkWidth 水印图片宽度为多少列
     * @param waterRemarkHeight 水印图片高度为多少行
     * @throws IOException
     */
    public static void putWaterRemarkToExcel(Workbook wb, Sheet sheet, String waterRemarkPath, int startXCol,
                                                int startYRow, int betweenXCol, int betweenYRow, int XCount, int YCount, int waterRemarkWidth,
                                                int waterRemarkHeight) throws IOException {

        // 校验传入的水印图片格式
        if (!waterRemarkPath.endsWith("png") && !waterRemarkPath.endsWith("PNG")) {
            throw new RuntimeException("向Excel上面打印水印，目前支持png格式的图片。");
        }

        // 加载图片
        ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
//        InputStream imageIn = new FileInputStream(waterRemarkPath);
        InputStream imageIn = Thread.currentThread().getContextClassLoader().getResourceAsStream(waterRemarkPath);
        if (null == imageIn || imageIn.available() < 1) {
            throw new RuntimeException("向Excel上面打印水印，读取水印图片失败(1)。");
        }
        BufferedImage bufferImg = ImageIO.read(imageIn);
        if (null == bufferImg) {
            throw new RuntimeException("向Excel上面打印水印，读取水印图片失败(2)。");
        }
        ImageIO.write(bufferImg, "png", byteArrayOut);

        // 开始打水印
        Drawing drawing = sheet.createDrawingPatriarch();

        // 按照共需打印多少行水印进行循环
        for (int yCount = 0; yCount < YCount; yCount++) {
            // 按照每行需要打印多少个水印进行循环
            for (int xCount = 0; xCount < XCount; xCount++) {
                // 创建水印图片位置
                int xIndexInteger = startXCol + (xCount * waterRemarkWidth) + (xCount * betweenXCol);
                int yIndexInteger = startYRow + (yCount * waterRemarkHeight) + (yCount * betweenYRow);
                /*
                 * 参数定义： 第一个参数是（x轴的开始节点）； 第二个参数是（是y轴的开始节点）； 第三个参数是（是x轴的结束节点）；
                 * 第四个参数是（是y轴的结束节点）； 第五个参数是（是从Excel的第几列开始插入图片，从0开始计数）；
                 * 第六个参数是（是从excel的第几行开始插入图片，从0开始计数）； 第七个参数是（图片宽度，共多少列）；
                 * 第8个参数是（图片高度，共多少行）；
                 */
                ClientAnchor anchor = drawing.createAnchor(0, 0, 0, 0, xIndexInteger,
                        yIndexInteger, xIndexInteger + waterRemarkWidth, yIndexInteger + waterRemarkHeight);

                Picture pic = drawing.createPicture(anchor,
                        wb.addPicture(byteArrayOut.toByteArray(), Workbook.PICTURE_TYPE_PNG));
                pic.resize();
            }
        }
    }

}
 
思考
 
这个方法每次都会生成新的水印图片，其实每个人的水印图片是不会变的，所有可以将水印图片放到某个目录下，每次生成前看看以后没有对应人员的水印图片，有就拿来用，没有就重新生成（也可是其他维度不一定是人员维度，主要是找到不变的元素）。和我们的缓存的想法很像。

上代码跑一下即可
 pom
 
 	 <properties>
        <poi.ooxml.version>4.1.2</poi.ooxml.version>
        <ooxml.schemas.version>1.4</ooxml.schemas.version>
        <java.version>1.8</java.version>
    </properties>
        
 
   <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>${poi.ooxml.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>ooxml-schemas</artifactId>
            <version>${ooxml.schemas.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>${poi.ooxml.version}</version>
        </dependency>
 
utils
 
package com.liuhm.utils;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ooxml.POIXMLDocumentPart;
import org.apache.poi.openxml4j.opc.PackagePartName;
import org.apache.poi.openxml4j.opc.PackageRelationship;
import org.apache.poi.openxml4j.opc.TargetMode;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.*;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * excel操作类
 *
 * @author liuhaomin
 * @date 2020-8-8 11:36:09
 */
@Slf4j
public class ExcelUtils {
    /**
     * 字体图片
     * @author liuhaomin
     * @date 2020-8-8 11:36:09
     */
    static class FontImage {
        final static String[] TEXT = new String[]{"xxx系统"};
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
        static class Watermark {
            private Boolean enable;
            private String[] text;
            private String dateFormat;
            private String color;
        }
        public static BufferedImage createWatermarkImage(Watermark watermark) {
            if (watermark == null) {
                watermark = new Watermark();
                watermark.setEnable(true);
                watermark.setText(TEXT);
                watermark.setColor("#C5CBCF");
                watermark.setDateFormat("yyyy-MM-dd HH:mm");
            } else {
                if (StringUtils.isEmpty(watermark.getDateFormat())) {
                    watermark.setDateFormat("yyyy-MM-dd HH:mm");
                } else if (watermark.getDateFormat().length() == 16) {
                    watermark.setDateFormat("yyyy-MM-dd HH:mm");
                } else if (watermark.getDateFormat().length() == 10) {
                    watermark.setDateFormat("yyyy-MM-dd");
                }
                if (watermark.getText().length==0) {
                    watermark.setText(TEXT);
                }
                if (StringUtils.isEmpty(watermark.getColor())) {
                    watermark.setColor("#C5CBCF");
                }
            }
            Font font = new Font("微软雅黑", Font.BOLD, 12);
            Integer width = 300;
            Integer height = 70 * watermark.getText().length;

            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
            // 背景透明 开始
            Graphics2D g = image.createGraphics();
            image = g.getDeviceConfiguration().createCompatibleImage(width, height, Transparency.TRANSLUCENT);
            g.dispose();
            // 背景透明 结束
            g = image.createGraphics();
            // 设定画笔颜色
            g.setColor(new Color(Integer.parseInt(watermark.getColor().substring(1), 16)));
            // 设置画笔字体
            g.setFont(font);
            // 设定倾斜度
            g.shear(0.1, -0.26);
            // 消除文字锯齿
            g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            //设置字体平滑
            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

            int y =60;
            int x =0;
            for (int j=0;j<watermark.getText().length;j++){
                String[] textArray = watermark.getText()[j].split("\n");
                y+= 1*(j+1);
                // 计算文字长度，计算居中的x点坐标
                FontMetrics fm = g.getFontMetrics(font);
                int textWidth = fm.stringWidth(watermark.getText()[j]);
                x = (width - textWidth) / 2;

                for (int i = 0; i < textArray.length; i++) {
                    // 画出字符串
                    g.drawString(textArray[i], x, y);
                    y = y + font.getSize();
                }

            }
            g.dispose();// 释放画笔
            return image;
        }
    }

    /**
     * 添加水印
     * @param wb
     * @param sheet
     * @param waterMark
     */
    public static void addWaterMark(XSSFWorkbook wb, XSSFSheet sheet, String waterMark){
        //是否添加水印
        if(StringUtils.isNotBlank(waterMark)){
            FontImage.Watermark watermark = new FontImage.Watermark();
            watermark.setText(new String[]{waterMark});
            watermark.setEnable(true);
            BufferedImage image = FontImage.createWatermarkImage(watermark);
            // 导出到字节流B
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            try {
                ImageIO.write(image, "png", os);
            } catch (IOException e) {
                log.error("add watermark error: {}", e.getMessage());
            }

            int pictureIdx = wb.addPicture(os.toByteArray(), Workbook.PICTURE_TYPE_PNG);
            POIXMLDocumentPart poixmlDocumentPart = wb.getAllPictures().get(pictureIdx);

            PackagePartName ppn = poixmlDocumentPart.getPackagePart().getPartName();
            String relType = XSSFRelation.IMAGES.getRelation();
            //add relation from sheet to the picture data
            PackageRelationship pr = sheet.getPackagePart().addRelationship(ppn, TargetMode.INTERNAL, relType, null);
            //set background picture to sheet
            sheet.getCTWorksheet().addNewPicture().setId(pr.getId());
        }
    }

    /**
     * 添加水印
     * @param wb
     * @param sheet
     * @param waterMarks
     */
    public static void addWaterMark(XSSFWorkbook wb, XSSFSheet sheet, String[] waterMarks){
        //是否添加水印
        if(waterMarks!=null&&waterMarks.length>0){
            FontImage.Watermark watermark = new FontImage.Watermark();
            watermark.setText(waterMarks);
            watermark.setEnable(true);
            BufferedImage image = FontImage.createWatermarkImage(watermark);
            // 导出到字节流B
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            try {
                ImageIO.write(image, "png", os);
            } catch (IOException e) {
                log.error("add watermark error: {}", e.getMessage());
            }

            int pictureIdx = wb.addPicture(os.toByteArray(), Workbook.PICTURE_TYPE_PNG);
            POIXMLDocumentPart poixmlDocumentPart = wb.getAllPictures().get(pictureIdx);

            PackagePartName ppn = poixmlDocumentPart.getPackagePart().getPartName();
            String relType = XSSFRelation.IMAGES.getRelation();
            //add relation from sheet to the picture data
            PackageRelationship pr = sheet.getPackagePart().addRelationship(ppn, TargetMode.INTERNAL, relType, null);
            //set background picture to sheet
            sheet.getCTWorksheet().addNewPicture().setId(pr.getId());

        }
    }

    public static void main(String[] args) {
        // 指定创建的excel文件名称
        try {
            BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream("/data123.xlsx"));
            // 定义一个工作薄（所有要写入excel的数据，都将保存在workbook中）
            XSSFWorkbook workbook = new XSSFWorkbook();

            // 创建一个sheet
            XSSFSheet sheet = workbook.createSheet("my-sheet-1");
            XSSFSheet sheet2 = workbook.createSheet("my-sheet-2");

            // 开始写入数据流程，2大步：1、定位到单元格，2、写入数据；定位单元格，需要通过行、列配合指定。
            // step1: 先选择第几行（0表示第一行），下面表示在第6行
            XSSFRow row = sheet.createRow(5);
            // step2：选择第几列（0表示第一列），注意，这里的第几列，是在上面指定的row基础上，也就是第6行，第3列
            XSSFCell cell = row.createCell(2);
            // step3：设置单元格的数据（写入数据）
            cell.setCellValue("hello world");
            XSSFWorkbook xssfWorkbook = workbook;
            String strDateFormat = "yyyy-MM-dd HH:mm:ss";
            SimpleDateFormat sdf = new SimpleDateFormat(strDateFormat);
            String[] ss=new String[]{"xxxx系统","超级管理员", sdf.format(new Date())};
            for(int i=0;i<workbook.getNumberOfSheets();i++){
                ExcelUtils.addWaterMark(xssfWorkbook, xssfWorkbook.getSheetAt(i),ss);
            }
            // 执行写入操作
            workbook.write(outputStream);
            workbook.close();
            outputStream.flush();
            outputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
TestController
 
package com.liuhm.controller;

import com.liuhm.utils.ExcelUtils;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author liuhaomin
 * @date 2020/9/23
 */
@RestController
@RequestMapping("/")
public class TestController {
    @GetMapping
    public void test(HttpServletResponse response){
        // 指定创建的excel文件名称
        try {
            String path="/data123.xlsx";
            BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(path));
            // 定义一个工作薄（所有要写入excel的数据，都将保存在workbook中）
            XSSFWorkbook workbook = new XSSFWorkbook();

            // 创建一个sheet
            XSSFSheet sheet = workbook.createSheet("my-sheet-1");
            XSSFSheet sheet2 = workbook.createSheet("my-sheet-2");

            // 开始写入数据流程，2大步：1、定位到单元格，2、写入数据；定位单元格，需要通过行、列配合指定。
            // step1: 先选择第几行（0表示第一行），下面表示在第6行
            XSSFRow row = sheet.createRow(5);
            // step2：选择第几列（0表示第一列），注意，这里的第几列，是在上面指定的row基础上，也就是第6行，第3列
            XSSFCell cell = row.createCell(2);
            // step3：设置单元格的数据（写入数据）
            cell.setCellValue("hello world");
            XSSFWorkbook xssfWorkbook = workbook;
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String[] ss=new String[]{"开始xxxx系统xxxx系统xxxx系统xxxx系统xxxx系统结束","超级管理员", sdf.format(new Date())};
            for(int i=0;i<workbook.getNumberOfSheets();i++){
                ExcelUtils.addWaterMark(xssfWorkbook, xssfWorkbook.getSheetAt(i),ss);
            }
            // 执行写入操作
            workbook.write(outputStream);
            workbook.close();
            outputStream.flush();
            outputStream.close();

            download(path,response);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public HttpServletResponse download(String path, HttpServletResponse response) {
        try {
            // path是指欲下载的文件的路径。
            File file = new File(path);
            // 取得文件名。
            String filename = file.getName();
            // 取得文件的后缀名。
            String ext = filename.substring(filename.lastIndexOf(".") + 1).toUpperCase();

            // 以流的形式下载文件。
            InputStream fis = new BufferedInputStream(new FileInputStream(path));
            byte[] buffer = new byte[fis.available()];
            fis.read(buffer);
            fis.close();
            // 清空response
            response.reset();
            // 设置response的Header
            response.addHeader("Content-Disposition", "attachment;filename=" + new String(filename.getBytes()));
            response.addHeader("Content-Length", "" + file.length());
            OutputStream toClient = new BufferedOutputStream(response.getOutputStream());
            response.setContentType("application/octet-stream");
            toClient.write(buffer);
            toClient.flush();
            toClient.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return response;
    }
}
 
效果图如下
 
 
代码下载
 
代码中的这个module
 
excel-watermark
 
下载代码后，执行
 
localhost:9900
 
即可测试下载文件
 

 
 
MVC中的上传、导出、下载、水印图片



上传页面
<div> 
        <form action="@Url.Action("FileUpload")" method="post" enctype="multipart/form-data">
            Name:<input type="text" name="Name" /><br />
            AradeNo:<input type="text" name="AradeNo" /><br />
            ClassNo:<input type="text" name="ClassNo" /><br />
            Sex:<input type="text" name="Sex" /><br />
            Age:<input type="text" name="Age" /><br />
            FileName:<input id="File1" type="file" name="ExcFile"/><br />
            <input id="Submit1" type="submit" value="上传" />
        </form>      
    </div>




///上传（控制器方法）
    public ActionResult FileUpload(string Name,int AradeNo,int ClassNo,string Sex,int Age,HttpPostedFileBase ExcFile)
        {
            if (ExcFile == null)
            {
                return View();
            }
            var filename = Server.MapPath("/EXCEL/");
            if (!Directory.Exists(filename))
            {
                Directory.CreateDirectory(filename);
            }
            string scFileName = Path.GetFileName(ExcFile.FileName);
            string scNewFileName = string.Format("{0}.{1}", Guid.NewGuid().ToString(), scFileName.Split('.')[1]);
            ExcFile.SaveAs(filename + scNewFileName);

            StudentModel m = new StudentModel();
            m.Name = Name;
            m.AradeNo = AradeNo;
            m.ClassNo = ClassNo;
            m.Sex = Sex;
            m.Age = Age;
            m.FileName = scFileName;
            m.NewFileName = scNewFileName;

            var result = new BLL.StudentBLL().ShangChuan(m);
            if (result > 0)
            {
                return Content("<script>alert('上传成功！');location.href='/Home/ShowList'</script>");
            }
            else
            {
                return Content("<script>alert('上传失败！')</script>");
            }
        }




///导出（控制器方法）（记得引用NPOI插件）
        public FileResult DaoChu()
        {
            var result = new BLL.StudentBLL().Show();
            if (result != null || result.Count > 0)
            {
                HSSFWorkbook book = new HSSFWorkbook();
                ISheet sheet = book.CreateSheet("sheet1");
                IRow row = sheet.CreateRow(0);
                row.CreateCell(0).SetCellValue("Name");
                row.CreateCell(1).SetCellValue("AradeNo");
                row.CreateCell(2).SetCellValue("ClassNo");
                row.CreateCell(3).SetCellValue("Sex");
                row.CreateCell(4).SetCellValue("Age");
                row.CreateCell(5).SetCellValue("FileName");

                for (int i = 0; i < result.Count; i++)
                {
                    IRow rows = sheet.CreateRow(i + 1);
                    rows.CreateCell(0).SetCellValue(result[i].Name);
                    rows.CreateCell(1).SetCellValue(result[i].AradeNo);
                    rows.CreateCell(2).SetCellValue(result[i].ClassNo);
                    rows.CreateCell(3).SetCellValue(result[i].Sex);
                    rows.CreateCell(4).SetCellValue(result[i].Age);
                    rows.CreateCell(5).SetCellValue(result[i].FileName);
                }

                MemoryStream ms = new MemoryStream();
                book.Write(ms);
                ms.Seek(0, SeekOrigin.Begin);
                return File(ms, "application/ved-excel", "信息.xls");
            }
            else
            {
                MemoryStream ms = new MemoryStream();
                ms.Seek(0, SeekOrigin.Begin);
                return File(ms, "application/ved-excel", "信息.xls");
            }
        }




///下载（控制器方法）（使用id传值）
    public ActionResult XiaZai(int id)
        {
            List<InfoModel> m = new BLL.InfoBLL().showinfoID(id);
            InfoModel f = new InfoModel();
            f.SCNewName = m[0].SCNewName;
            string strfileName = Server.MapPath("/EXCEL/"); //上传的路径   strfileName路径名
            FileStream fs = new FileStream(string.Format("{0}{1}", strfileName, f.SCNewName), FileMode.Open);

            return File(fs, "application/vnd.ms-excel", f.SCName);
        }





//水印图片
    
    <div> 
        <form action="/Home/ShuiYing" method="post" enctype="multipart/form-data">
            <input name="File1" type="file" />
            <input id="Submit1" type="submit" value="提交" />
        </form>
    </div>（页面）

    public ActionResult ShuiYing(HttpPostedFileBase File1)
        {
            string warning = "";

            string files = Server.MapPath(File1.FileName);

            string filename = files.Remove(files.LastIndexOf("\\") - 4) + "img\\" + File1.FileName;

            string watchname = files.Remove(files.LastIndexOf("\\") - 4) + "img\\" + "1.jpg";

            File1.SaveAs(filename);

            string WarkUlr = WatherHelper.makewatermark(filename, watchname, WaterType.Center, files.Remove(files.LastIndexOf("\\") - 4) + "img\\", ImageType.JPEG, FileCache.Delete, out warning);

            return Content(WarkUlr);
        }

 
 
转载于:https://www.cnblogs.com/jpp666/p/7883089.html