001/**
002 * Copyright (c) 2015-2022, Michael Yang 杨福海 (fuhai999@gmail.com).
003 * <p>
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 * <p>
008 * http://www.apache.org/licenses/LICENSE-2.0
009 * <p>
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package io.jboot.components.cache.interceptor;
017
018import com.jfinal.render.*;
019import io.jboot.web.render.JbootRender;
020import io.jboot.web.render.JbootTemplateRender;
021import io.jboot.web.render.JbootXmlRender;
022
023import java.io.Serializable;
024import java.util.HashMap;
025import java.util.HashSet;
026import java.util.Map;
027import java.util.Set;
028
029public class ActionCachedContent implements Serializable {
030
031    private static final int RENDER_DEFAULT = 0;
032    private static final int RENDER_TEMPLATE = 1;
033    private static final int RENDER_XML = 2;
034    private static final int RENDER_JSON = 3;
035    private static final int RENDER_TEXT = 4;
036
037    private static IRenderFactory renderFactory = RenderManager.me().getRenderFactory();
038    private static final Set<String> ignoreAttrs = new HashSet<>();
039
040
041    private Map<String, String> headers;
042    private Map<String, Object> attrs;
043
044    private String contentType;
045    private Integer renderType;
046    private String viewOrText;
047    private Map<String, Object> otherPara = null;
048
049    public static Set<String> getIgnoreAttrs() {
050        return ignoreAttrs;
051    }
052
053    public static void addIgnoreAttr(String attrName) {
054        ignoreAttrs.add(attrName);
055    }
056
057    public ActionCachedContent(Render render) {
058        if (render == null) {
059            throw new IllegalArgumentException("Render can not be null.");
060        }
061
062        // xml
063        if (render instanceof JbootXmlRender) {
064            renderType = RENDER_XML;
065            contentType = ((JbootXmlRender) render).getContentType();
066            viewOrText = render.getView();
067        }
068        // template
069        else if (render instanceof JbootTemplateRender) {
070            renderType = RENDER_TEMPLATE;
071            contentType = ((JbootTemplateRender) render).getContentType();
072            viewOrText = render.getView();
073        }
074        // default
075        else if (render instanceof JbootRender) {
076            renderType = RENDER_DEFAULT;
077            contentType = ((JbootRender) render).getContentType();
078            viewOrText = render.getView();
079        }
080        // text
081        else if (render instanceof TextRender) {
082            renderType = RENDER_TEXT;
083            contentType = ((TextRender) render).getContentType();
084            viewOrText = ((TextRender) render).getText();
085        }
086        // json
087        else if (render instanceof JsonRender) {
088            renderType = RENDER_JSON;
089            otherPara = new HashMap<>();
090
091            JsonRender jsonRender = (JsonRender) render;
092            otherPara.put("jsonText", jsonRender.getJsonText());
093            otherPara.put("attrs", jsonRender.getAttrs());
094            otherPara.put("forIE", jsonRender.getForIE());
095        } else {
096            throw new IllegalArgumentException("@Cacheable Can not support the render of the type: " + render.getClass().getName());
097        }
098    }
099
100    public String getContentType() {
101        return contentType;
102    }
103
104    public void setContentType(String contentType) {
105        this.contentType = contentType;
106    }
107
108    public Map<String, Object> getAttrs() {
109        return attrs;
110    }
111
112    public void setAttrs(Map<String, Object> attrs) {
113        this.attrs = attrs;
114        if (this.attrs != null) {
115            for (String ignoreAttr : ignoreAttrs) {
116                this.attrs.remove(ignoreAttr);
117            }
118        }
119    }
120
121    public void addAttr(String key, Object value) {
122        if (ignoreAttrs.contains(key)) {
123            return;
124        }
125        if (this.attrs == null) {
126            this.attrs = new HashMap<>();
127        }
128        this.attrs.put(key, value);
129    }
130
131    public String getViewOrText() {
132        return viewOrText;
133    }
134
135    public void setViewOrText(String viewOrText) {
136        this.viewOrText = viewOrText;
137    }
138
139    public Integer getRenderType() {
140        return renderType;
141    }
142
143    public void setRenderType(Integer renderType) {
144        this.renderType = renderType;
145    }
146
147    public Map<String, Object> getOtherPara() {
148        return otherPara;
149    }
150
151    public void setOtherPara(Map<String, Object> otherPara) {
152        this.otherPara = otherPara;
153    }
154
155    public Map<String, String> getHeaders() {
156        return headers;
157    }
158
159    public void setHeaders(Map<String, String> headers) {
160        this.headers = headers;
161    }
162
163    public void addHeader(String key, String value) {
164        if (this.headers == null) {
165            this.headers = new HashMap<>();
166        }
167        this.headers.put(key, value);
168    }
169
170
171    public Render createRender() {
172        switch (renderType) {
173            case RENDER_DEFAULT:
174                return renderFactory.getRender(viewOrText);
175            case RENDER_TEMPLATE:
176                return renderFactory.getTemplateRender(viewOrText);
177            case RENDER_JSON:
178                JsonRender jsonRender;
179                if (otherPara.get("jsonText") != null) {
180                    jsonRender = (JsonRender) renderFactory.getJsonRender((String) otherPara.get("jsonText"));
181                } else if (otherPara.get("attrs") != null) {
182                    jsonRender = (JsonRender) renderFactory.getJsonRender((String[]) otherPara.get("attrs"));
183                } else {
184                    jsonRender = (JsonRender) renderFactory.getJsonRender();
185                }
186                if (Boolean.TRUE.equals(otherPara.get("forIE"))) {
187                    jsonRender.forIE();
188                }
189                return jsonRender;
190            case RENDER_TEXT:
191                return renderFactory.getTextRender(viewOrText, contentType);
192            case RENDER_XML:
193                return renderFactory.getXmlRender(viewOrText);
194            default:
195                throw new IllegalStateException("@Cacheable can not support the renderType of the value: " + renderType);
196        }
197    }
198}