public abstract abstract class Operation<V> implements Callable<V> {
        /** 内部具体的执行操作  */
        protected abstract V run() throws HttpRequestException, IOException;

        /** 执行完成后的回调 **/
        protected abstract void done() throws IOException;

        /** 内部进行一列的异常捕获，确保 run 函数 和 done函数 正常执行 **/
        public V call() throws HttpRequestException {
            boolean thrown = false;
            try {
                return run();
            } catch (HttpRequestException e) {
                thrown = true;
                throw e;
            } catch (IOException e) {
                thrown = true;
                throw new HttpRequestException(e);
            } finally {
                try {
                    done();
                } catch (IOException e) {
                    if (!thrown) {
                        throw new HttpRequestException(e);
                    }
                }
            }
        }
    }

public abstract class CloseOperation<V> extends Operation<V> {

        private final Closeable closeable;
        private final boolean ignoreCloseExceptions;

        protected CloseOperation(final Closeable closeable, final boolean ignoreCloseExceptions) {
            this.closeable = closeable;
            this.ignoreCloseExceptions = ignoreCloseExceptions;
        }
        @Override
        protected void done() throws IOException {
            if (closeable instanceof Flushable) {
                ((Flushable) closeable).flush();
            }
            if (ignoreCloseExceptions) {
                try {
                    closeable.close();
                } catch (IOException e) {
                    // Ignored，如果发生异常了，程序继续执行，会忽略掉此异常
                }
            } else {
            	// 如果发生异常了，此时程序会退出
                closeable.close();
            }
        }
    }

public abstract class FlushOperation<V> extends Operation<V> {

        private final Flushable flushable;

        protected FlushOperation(final Flushable flushable) {
            this.flushable = flushable;
        }

        @Override
        protected void done() throws IOException {
            flushable.flush();
        }
    }

new CloseOperation<HttpRequest>(reader, ignoreCloseExceptions) {
   @Override
    public HttpRequest run() throws IOException {
        return copy(reader, writer);
    }
}.call();


new FlushOperation<HttpRequest>(writer) {
  @Override
    protected HttpRequest run() throws IOException {
        return copy(input, writer);
    }
}.call();

package com.pibigstar.utils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;

/**
 * 前后端数据传输加密工具类
 * @author pibigstar
 *
 */
public class AesEncryptUtils {
	//可配置到Constant中，并读取配置文件注入
	private static final String KEY = "abcdef0123456789";
	
	//参数分别代表 算法名称/加密模式/数据填充方式
	private static final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";

	/**
	 * 加密
	 * @param content 加密的字符串
	 * @param encryptKey key值
	 * @return
	 * @throws Exception
	 */
	public static String encrypt(String content, String encryptKey) throws Exception {
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(128);
		Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
		cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(encryptKey.getBytes(), "AES"));
		byte[] b = cipher.doFinal(content.getBytes("utf-8"));
		return Base64.encodeBase64String(b);
	}

	/**
	 * 解密
	 * @param encryptStr 解密的字符串
	 * @param decryptKey 解密的key值
	 * @return
	 * @throws Exception
	 */
	public static String decrypt(String encryptStr, String decryptKey) throws Exception {
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(128);
		Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
		cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(decryptKey.getBytes(), "AES"));
		byte[] encryptBytes = Base64.decodeBase64(encryptStr);
		byte[] decryptBytes = cipher.doFinal(encryptBytes);
		return new String(decryptBytes);
	}
	
	public static String encrypt(String content) throws Exception {
		return encrypt(content, KEY);
	}
	public static String decrypt(String encryptStr) throws Exception {
		return decrypt(encryptStr, KEY);
	}
	

	public static void main(String[] args) throws Exception {
		String content = "派大星";
		System.out.println("加密前：" + content);

		String encrypt = encrypt(content, KEY);
		System.out.println("加密后：" + encrypt);

		String decrypt = decrypt(encrypt, KEY);
		System.out.println("解密后：" + decrypt);
	}
}

@Autowired
private RedisService redisService;
	
@GetMapping("test")
public String test() {
	User user = new User();
	user.setId(1001);
	user.setName("pibigstar");
	user.setPassword("123456");
	//存数据
	redisService.setObject("my:user",JSON.toJSONString(user));
	//取数据
	String json = redisService.getObject("my:user");
	JSONObject parseObject = JSON.parseObject(json);
	User myUser = JSON.toJavaObject(parseObject, User.class);
	return myUser.toString();
}

package com.pibigstar.utils;

import java.util.List;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

/**
 * JSON工具类
 * @author pibigstar
 *
 */
public class JSONUtil {
	
	/**
	 * java对象转换为JSON字符串
	 * @param object
	 * @return
	 */
	public static String ObjectToJSON(Object object) {
		return JSON.toJSONString(object);
	}
	
	/**
	 * JSON字符串转换为Java对象
	 * @param json
	 * @param obj
	 * @return
	 */
	public static <T> T jSONToObject(String json, Class<T> obj) {
		JSONObject jsonObject = JSON.parseObject(json);
		return (T) JSON.toJavaObject(jsonObject, obj);
	}
	/**
	 * List集合转换为JSON字符串
	 * @param list
	 * @return
	 */
	public static <T> String listToJSON(List<T> list) {
		return JSONArray.toJSONString(list);
	}
	
	/**
	 * 将JSON字符串转换为List集合
	 * @param json
	 * @param obj
	 * @return
	 */
	public static <T> List<T> JSONToList(String json,Class<T> obj){
		return JSON.parseArray(json, obj);
	}

}

package com.pibigstar.springboot.service;

import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class RedisService {
	@Autowired
	private StringRedisTemplate stringRedisTemplate;
	@Autowired 
	private RedisTemplate<String, Object> redisTemplate; 

	/**
	 * 存储String类型数据
	 * @param key
	 * @param value
	 */
	public void set(String key,String value) {
		stringRedisTemplate.opsForValue().set(key, value);
	}
	/**
	 * 存储String类型数据
	 * @param key
	 * @param value
	 * @param timeout 过期时间，单位：秒
	 */
	public void set(String key,String value,long timeout) {
		stringRedisTemplate.opsForValue().set(key, value,timeout,TimeUnit.SECONDS);
	}
	/**
	 * 得到String类型数据
	 * @param key
	 * @return
	 */
	public String get(String key) {
		return stringRedisTemplate.opsForValue().get(key);
	}
	
	/**
	 * 存储object对象
	 * @param key
	 * @param value
	 */
	public void setObject(String key,Object value) {
		redisTemplate.opsForValue().set(key, value);
	}
	/**
	 * 存储object对象
	 * @param key
	 * @param value
	 * @param timeout 过期时间，单位：秒
	 */
	public void setObject(String key,Object value,long timeout) {
		redisTemplate.opsForValue().set(key, value,timeout,TimeUnit.SECONDS);
	}
	/**
	 * 得到Object对象
	 * @param key
	 * @return
	 */
	public Object getObject(String key) {
		return redisTemplate.boundValueOps(key).get();
	}

}

package com.pibgstar.demo.tags;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
import java.util.ArrayList;

/**
 * @author pibigstar
 * @create 2018-12-02 17:16
 * @desc 自定义radio组件
 **/
public class RadioTagSupport extends SimpleTagSupport{

    private String code;
    private String tip;
    private String key;
    private String value;
    private ArrayList<RadioVo> list;

    @Override
    public void doTag() throws JspException, IOException {
        getData();
        StringBuilder sp = new StringBuilder();
        sp.append("<div class='radio'>");
        sp.append("<span class='tip'>");
        sp.append(this.getTip());
        sp.append("</span>");
        for (RadioVo r: list) {
            sp.append("<input type='radio' ");
            sp.append("name='");
            sp.append(r.getName());
            sp.append("' value='");
            sp.append(r.getValue());
            if (r.getChecked()) {
                sp.append("' checked />");
            }else {
                sp.append("' />");
            }

            sp.append(r.getShowValue());
        }
        sp.append("</div>");

        JspWriter out = getJspContext().getOut();
        out.write(sp.toString());
        // 从body中获取值
        //StringWriter sw = new StringWriter();
        //getJspBody().invoke(sw);
        //getJspContext().getOut().write(sw.toString());

    }

    private void getData() {
        list = new ArrayList();
        // 这里可以通过code值，拿到数据库中自己配置的值，这里只是简单的封装几个固定的值
        RadioVo r1 = new RadioVo();
        r1.setName("sex");
        r1.setValue("1");
        r1.setShowValue("男");
        RadioVo r2= new RadioVo();
        r2.setName("sex");
        r2.setValue("2");
        r2.setShowValue("女");
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getTip() {
        return tip;
    }

    public void setTip(String tip) {
        this.tip = tip;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public ArrayList<RadioVo> getList() {
        return list;
    }

    public void setList(ArrayList<RadioVo> list) {
        this.list = list;
    }
}


class RadioVo {
    private String name;
    private String value;
    private String showValue;
    private Boolean checked;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getShowValue() {
        return showValue;
    }

    public void setShowValue(String showValue) {
        this.showValue = showValue;
    }

    public Boolean getChecked() {
        return checked;
    }

    public void setChecked(Boolean checked) {
        this.checked = checked;
    }
}