图片自动加水印

package cn.tfri.filter.watermark;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class WaterMarkFilter implements Filter{
    
    private boolean enabled;
    private String waterMarkFile;
    
    public boolean isEnabled() {
        return enabled;
    }
    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }
    public String getWaterMarkFile() {
        return waterMarkFile;
    }
    public void setWaterMarkFile(String waterMarkFile) {
        this.waterMarkFile = waterMarkFile;
    }

    public void destroy() {}

    public void doFilter(ServletRequest req, ServletResponse resp,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest)req;
        HttpServletResponse response = (HttpServletResponse)resp;
        if(this.isEnabled()){
            WaterMarkResponseWrapper waterMarkRes = new WaterMarkResponseWrapper(response,this.getWaterMarkFile());
            chain.doFilter(request, waterMarkRes);
            waterMarkRes.finishResponse();
        }
        chain.doFilter(request, response);
    }

    public void init(FilterConfig filterConfig) throws ServletException {
        this.setEnabled("true".equalsIgnoreCase(filterConfig.getInitParameter("enabled").trim()));
        String file = filterConfig.getInitParameter("waterMarkFile");
        this.setWaterMarkFile(filterConfig.getServletContext().getRealPath(file));
    }
    
}

package cn.tfri.filter.watermark;

import java.io.IOException;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

import cn.tfri.hibernate.utils.ImageUtil;

public class WaterMarkResponseWrapper extends HttpServletResponseWrapper{
    private String waterMarkFile;
    private HttpServletResponse response;
    private WaterMarkOutputStream waterMarkOutputStream = new WaterMarkOutputStream();
    
    public String getWaterMarkFile() {
        return waterMarkFile;
    }
    public void setWaterMarkFile(String waterMarkFile) {
        this.waterMarkFile = waterMarkFile;
    }
    public HttpServletResponse getResponse() {
        return response;
    }
    public void setResponse(HttpServletResponse response) {
        this.response = response;
    }
    public WaterMarkOutputStream getWaterMarkOutputStream() {
        return waterMarkOutputStream;
    }
    public void setWaterMarkOutputStream(WaterMarkOutputStream waterMarkOutputStream) {
        this.waterMarkOutputStream = waterMarkOutputStream;
    }
    
    public WaterMarkResponseWrapper(HttpServletResponse response,String waterMarkFile){
        super(response);
        this.setResponse(response);
        this.setWaterMarkFile(waterMarkFile);
    }
    
    public ServletOutputStream getOutputStream(){
        return this.getWaterMarkOutputStream();
    }
    @Override
    public void flushBuffer() throws IOException {
        this.getWaterMarkOutputStream().flush();
    }
    
    public void finishResponse() throws IOException{
        byte[] imageData = this.getWaterMarkOutputStream().getByteArrayOutputStream().toByteArray();
        byte[] image = ImageUtil.waterMark(imageData, this.getWaterMarkFile());
        response.setContentLength(image.length);
        response.getOutputStream().write(image);
        this.getWaterMarkOutputStream().close();
    }
}

package cn.tfri.filter.watermark;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

import javax.servlet.ServletOutputStream;

public class WaterMarkOutputStream extends ServletOutputStream{
    private ByteArrayOutputStream byteArrayOutputStream;
    
    public ByteArrayOutputStream getByteArrayOutputStream() {
        return byteArrayOutputStream;
    }
    public void setByteArrayOutputStream(ByteArrayOutputStream byteArrayOutputStream) {
        this.byteArrayOutputStream = byteArrayOutputStream;
    }
    
    public WaterMarkOutputStream(){
        this.setByteArrayOutputStream(new ByteArrayOutputStream());
    }
    
    @Override
    public void write(int b) throws IOException {
        this.getByteArrayOutputStream().write(b);
    }
    @Override
    public void close() throws IOException {
        this.getByteArrayOutputStream().close();
    }
    @Override
    public void flush() throws IOException {
        this.getByteArrayOutputStream().flush();
    }
    @Override
    public void write(byte[] b, int off, int len) throws IOException {
        this.getByteArrayOutputStream().write(b, off, len);
    }
    @Override
    public void write(byte[] b) throws IOException {
        this.getByteArrayOutputStream().write(b);
    }
}

package cn.tfri.hibernate.utils;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

public class ImageUtil {
    public static byte[] waterMark(byte[] imageData,String waterMarkFiler) throws IOException{
        int paddingRight = 10;
        int paddingBottom = 10;
        
        Image image = new ImageIcon(imageData).getImage();
        int imageWidth = image.getWidth(null);
        int imageHeight = image.getHeight(null);
        
        Image waterMark = ImageIO.read(new File(waterMarkFiler));
        int waterMarkWidth = waterMark.getWidth(null);
        int waterMarkHeight = waterMark.getHeight(null);
        
        if(imageWidth < waterMarkWidth + 2*paddingRight || imageHeight < waterMarkHeight + 2*paddingBottom){
            return imageData;
        }
        
        BufferedImage bufferedImage = new BufferedImage(imageWidth,imageHeight,BufferedImage.TYPE_INT_RGB);
        Graphics g = bufferedImage.createGraphics();
        g.drawImage(image, 0, 0, imageWidth, imageHeight, null);
        g.drawImage(waterMark,imageWidth - waterMarkWidth - paddingRight,imageHeight - waterMarkHeight - paddingBottom,waterMarkWidth,waterMarkHeight,null);
        //设置图形上下文的当前颜色为红色
        g.setColor(Color.red);
        //创建新的字体
        Font font = new Font("华文行楷",Font.BOLD,12);
        //设置图形上下文的字体为指定字体
        g.setFont(font);
        //在图片上绘制文字，文字的颜色为图形上下文的当前颜色，即红色
        g.drawString("上海烛龙-古剑奇谭", imageWidth - 200, imageHeight - 200);
        g.dispose();
        
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
        encoder.encode(bufferedImage);
                
        byte[] data = out.toByteArray();
        out.close();
        return data;
    }
}