geotools ​

package tech.webgis.controller;


import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.geotools.data.FileDataStore;
import org.geotools.data.FileDataStoreFinder;
import org.geotools.data.simple.SimpleFeatureSource;
import org.geotools.factory.CommonFactoryFinder;
import org.geotools.filter.text.cql2.CQL;
import org.geotools.filter.text.cql2.CQLException;
import org.geotools.filter.text.ecql.ECQL;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.map.FeatureLayer;
import org.geotools.map.Layer;
import org.geotools.map.MapContent;
import org.geotools.referencing.CRS;
import org.geotools.renderer.lite.StreamingRenderer;
import org.geotools.styling.*;
import org.geotools.styling.Stroke;
import org.opengis.filter.FilterFactory;
import org.opengis.filter.FilterFactory2;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.HashMap;
import java.util.Map;

@Api(tags = "wms服务")
@RestController
@RequestMapping("services")
public class WmsController {
    @Autowired
    private HttpServletRequest request;
    @Autowired
    private HttpServletResponse response;

    private static StyleFactory styleFactory = CommonFactoryFinder.getStyleFactory();
    private static FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory();
    private static FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    private MapContent map = null;
    private SimpleFeatureSource featureSource = null;
    private Layer layer = null;
    public WmsController() {
        super();
        try {
            map = new MapContent();
            // 1. 添加图层
            this.addLayer();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    @ApiOperation("wms")
    @GetMapping("wms")
    public void wms() {
        response.setContentType("image/png");
        response.setHeader("Cache-Control", "max-age=2500, must-revalidate");

        String WIDTH = request.getParameter("WIDTH"),
                HEIGHT = request.getParameter("HEIGHT"),
                BBOX = request.getParameter("BBOX");

        String[] BBOXS = BBOX.split(",");
        double[] _bbox = new double[]{
                Double.parseDouble(BBOXS[0]),
                Double.parseDouble(BBOXS[1]),
                Double.parseDouble(BBOXS[2]),
                Double.parseDouble(BBOXS[3])
        };

        int width = Integer.parseInt(WIDTH), height = Integer.parseInt(HEIGHT);

        Map paras = new HashMap();
        paras.put("bbox", _bbox);
        paras.put("width", width);
        paras.put("height", height);

        try {
            // 2. 输出图片
            this.getMapContent(paras);
        } catch (Exception e) {

        }
    }

    private void addLayer() throws Exception{
        if(layer != null) map.removeLayer(layer);
        Style style = this.createPolygonStyle();
        File file = new File("D:\\test\\county.shp");
        FileDataStore store = FileDataStoreFinder.getDataStore(file);
        featureSource = store.getFeatureSource();
        layer = new FeatureLayer(featureSource, style);
        map.addLayer(layer);
    }

    private void getMapContent(Map params){
        try{
            double[] bbox = (double[]) params.get("bbox");
            double x1 = bbox[0], y1 = bbox[1],
                    x2 = bbox[2], y2 = bbox[3];
            int width = (Integer) params.get("width"),
                    height=(Integer) params.get("height");

            // 设置输出范围
            CoordinateReferenceSystem crs = CRS.decode("EPSG:3857");
            ReferencedEnvelope mapArea = new ReferencedEnvelope(x1, x2, y1, y2, crs);

            // 初始化渲染器
            StreamingRenderer sr = new StreamingRenderer();
            sr.setMapContent(map);

            // 初始化输出图像
            BufferedImage bi = new BufferedImage(width, height,
                    BufferedImage.TYPE_INT_ARGB);
            Graphics g = bi.getGraphics();
            ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                    RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            Rectangle rect = new Rectangle(0, 0, width, height);
            // 绘制地图
            sr.paint((Graphics2D) g, rect, mapArea);
            //将BufferedImage变量写入文件中。
            ImageIO.write(bi,"png",response.getOutputStream());
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }

    private Style createPolygonStyle() throws CQLException {
        Rule rule1 = createRule(new Color(0,255, 255));
        rule1.setFilter(ff.equal(
                ff.property("code"),
                ff.literal("632803"),
                true));

        Rule rule2 = createRule(new Color(0,0, 255));
        rule2.setFilter(ff.equal(
                ff.property("code"),
                ff.literal("652824"),
                true));

        Rule rule3 = createRule(new Color(0,255, 0));
        rule3.setFilter(ff.equal(
                ff.property("code"),
                ff.literal("652825"),
                true));
//        rule3.setFilter(CQL.toFilter("DZM = '150000'"));

        Rule commonRule = createRule(new Color(255,0, 0));
        commonRule.setFilter(ECQL.toFilter("code NOT IN ('150000', '540000', '230000')"));

        FeatureTypeStyle fts = styleFactory.createFeatureTypeStyle();
        fts.rules().add(rule1);
        fts.rules().add(rule2);
        fts.rules().add(rule3);
        fts.rules().add(commonRule);
        Style style = styleFactory.createStyle();
        style.featureTypeStyles().add(fts);

        return style;
    }

    private Rule createRule(Color color) {
        Stroke stroke =
                styleFactory.createStroke(
                        filterFactory.literal(color),
                        filterFactory.literal(1),
                        filterFactory.literal(1)
                );
        Fill fill =
                styleFactory.createFill(
                        filterFactory.literal(color),
                        filterFactory.literal(0.2)
                );
        PolygonSymbolizer sym = styleFactory.createPolygonSymbolizer(stroke, fill, null);
        Rule rule = styleFactory.createRule();
        rule.symbolizers().add(sym);
        return rule;
    }
}