nodejs npm install -g 全局安装和非全局安装的区别

2018-07-04

2018-07-02

工作中遇到一个问题,redis中存储了大量的key,而且没有设置时效,其中很大一部分后来都没用了,导致redis体积庞大,查询缓慢。服务器版本为windows,网上搜索到很多批量删除的方法都是Linux下的,几番寻找,终于找到了在windows下批量删除超大量key的方法。
首先贴一下Linux下的方法:

1	redis-cli keys"*" \|xargs redis-cli del

//如果redis-cli没有设置成系统变量,需要指定redis-cli的完整路径,加入redis-cli的安装路径如下：
这里写图片描述
那么在gitbash上模拟的linux命令则如下:

1	./redis-cli keys "lz"\|xargs ./redis-cli del

原理就是通过xargs工具将前半部分的查询结果借助管道传递给后面的删除命令，进而实现循环删除，达到批量删除的结果。
But,测试的时候趣发现这条命令不好使,测试结果如下图所示，具体的原因不明:
这里写图片描述

作为替代方案，我找到了windows、Linux下均试用的方法:
使用lua脚本:

1	redis-cli eval "redis.call('del', unpack(redis.call('keys','*')))" 0

但这种处理方式,量大的情况下,lua函数unpack会出现问题,会报错误

(error) ERR Error running script (call to f_e177a091510d969af3b388ee986dbe6658df6b57): user_script:1: too many results to unpack

解决方法:
一次性unpack太多会出问题,那就干脆一次5000吧,这样就不会有问题了,实测速度非常快哦。

1	redis-cli eval "local keys = redis.call('keys', ARGV[1]) for i=1,#keys,5000 do redis.call('del', unpack(keys, i, math.min(i+4999, #keys))) end return #keys" 0 'value*'

所以最终实现我的需求的代码就是：

1
2
3

redis-cli eval "redis.call('del', unpack(redis.call('keys','*lz*')))" 0
redis-cli eval "local keys = redis.call('keys', ARGV[1]) for i=1,#keys,5000 do redis.call('del', unpack(keys, i, math.min(i+4999, #keys))) end return #keys" 0 '*lz*'

上述语句的执行原理其实是递归调用，通过递归最终实现了批量删除。

在redis集群中可以借助脚本实现集群上的批量删除，这个还没测试过。参考文章如下:
redis集群批量删除指定的key

本文参考文章:
redis批量删除key （windows适用）

展开全文 >>

JAVA实现对包含数字、字母、中文的字符串按首字母排序

2018-06-28

最近项目中有新的需求，需要对包含数字、字母、中文的字符串按首字母排序。看似简单，但是实现起来却很难。因为这里面包含了中文，不能单纯的取首字母的ASSIC值进行比较。考虑到最终是根据英文字母进行比较的，索性将字符串统统转化成拼音字符串进行处理。具体的代码如下。

PinyinUtils.java

package com.fangshuo;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
/**
 * 汉字转换为拼音
 * @author Red
 */
public class PinyinUtils {
    /**
     * 获取字符串拼音的第一个字母
     * @param chinese
     * @return
     */
    public static String ToFirstChar(String chinese){         
        String pinyinStr = "";  
        char[] newChar = chinese.toCharArray();  //转为单个字符
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat(); 
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);  
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  
        for (int i = 0; i < newChar.length; i++) {  
            if (newChar[i] > 128) {  
                try {  
                    pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0].charAt(0);  
                } catch (BadHanyuPinyinOutputFormatCombination e) {  
                    e.printStackTrace();  
                }  
            }else{  
                pinyinStr += newChar[i];  
            }  
        }  
        return pinyinStr;  
    }  
   
    /**
     * 汉字转为拼音
     * @param chinese
     * @return
     */
    public static String ToPinyin(String chinese){          
        String pinyinStr = "";  
        char[] newChar = chinese.toCharArray();  
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();  
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);  
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  
        for (int i = 0; i < newChar.length; i++) {  
            if (newChar[i] > 128) {  
                try {  
                    pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0];  
                } catch (BadHanyuPinyinOutputFormatCombination e) {  
                    e.printStackTrace();  
                }  
            }else{  
                pinyinStr += newChar[i];  
            }  
        }  
        return pinyinStr;  
    }
    
    /**
     * 汉字转为拼音并获取大写的首字母;
     * @param chinese
     * @return
     */
    public static String ToPinyinAndGetFirstChar(String chinese){          
        String pinyinStr = "";  
        char[] newChar = chinese.toCharArray();  
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();  
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);  
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  
        for (int i = 0; i < newChar.length; i++) {  
            if (newChar[i] > 128) {  
                try {  
                    pinyinStr += PinyinHelper.toHanyuPinyinStringArray(newChar[i], defaultFormat)[0];  
                } catch (BadHanyuPinyinOutputFormatCombination e) {  
                    e.printStackTrace();  
                }  
            }else{  
                pinyinStr += newChar[i];  
            }  
        }  
        return pinyinStr.toUpperCase();
    }  
}

测试载体Students.java

package com.fangshuo;
public class Students {  
	private int age;  
    private int score;
    private String name;
    
    public Students() {
		super();
	}
	public Students(int age, int score, String name) {
		super();
		this.age = age;
		this.score = score;
		this.name = name;
	}
	
    public Students(int age, int score){  
        super();  
        this.age = age;  
        this.score = score;  
    }  
      
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
    public int getScore() {  
        return score;  
    }  
    public void setScore(int score) {  
        this.score = score;  
    }
    public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}  
	
}

测试类：

package com.fangshuo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class SortTest {
    public static void main(String[] args) {
    	 List<Students> students = new ArrayList<Students>();  
         students.add(new Students(23, 100,"阿里azj001"));  
         students.add(new Students(27, 98,"腾讯bzj002"));  
         students.add(new Students(29, 99,"百度dzj003"));  
         students.add(new Students(29, 98,"华为czj004"));  
         students.add(new Students(22, 89,"择天ezj005"));  
         
         students.add(new Students(22, 89,"a择天ezj005"));  
         students.add(new Students(22, 89,"A择天ezj005"));  
         
         students.add(new Students(22, 89,"8择天ezj005"));  
         students.add(new Students(22, 89,"0择天ezj005"));  
         
         students.add(new Students(22, 89,"z择天ezj005"));  
         
         students.add(new Students(22, 89,"_z择天ezj005"));  
         Collections.sort(students, new Comparator<Students>() {  
             @Override  
             public int compare(Students o1, Students o2) {
             	Students newo1 = new Students();
             	newo1.setName(PinyinUtils.ToPinyinAndGetFirstChar(o1.getName()));
             	Students newo2 = new Students();
             	newo2.setName(PinyinUtils.ToPinyinAndGetFirstChar(o2.getName()));
             	int i = newo1.getName().substring(0, 1).compareTo(newo2.getName().substring(0, 1));
                 return i;
             }
         });  
         for(Students stu : students){  
             System.out.println("score:" + stu.getScore() + ":age" + stu.getAge()+":name:"+stu.getName());  
         }  
	}
}

执行结果如下：
这里写图片描述

知识点：
字符串比较大小，可以使用现有的工具类：int result = str1.compareTo(str2);该方法返回两者的ASSIC 码的差值;

展开全文 >>

SpringBoot中AOP的简单实现。

2018-06-25

在SpringBoot中实现AOP很简单。
1、添加依赖：

//注意依赖的版本

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2、定义切面：
WebLogAspect.java

package com.fangshuo.Aspect;
import java.util.Arrays;
import javax.servlet.http.HttpServletRequest;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
@Aspect  
@Component  
public class WebLogAspect {  
  
    private Logger logger = Logger.getLogger(getClass());  
    @Pointcut("execution(public * com.fangshuo.controller.*.*(..))")  
    public void webLog(){}  
  
    @Before("webLog()")  
    public void doBefore(JoinPoint joinPoint) throws Throwable {  
        // 接收到请求，记录请求内容  
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();  
        HttpServletRequest request = attributes.getRequest();  
  
        // 记录下请求内容  
        logger.info("URL : " + request.getRequestURL().toString());  
        logger.info("HTTP_METHOD : " + request.getMethod());  
        logger.info("IP : " + request.getRemoteAddr());  
        logger.info("CLASS_METHOD : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());  
        logger.info("ARGS : " + Arrays.toString(joinPoint.getArgs()));  
  
    }  
  
    @AfterReturning(returning = "ret", pointcut = "webLog()")  
    public void doAfterReturning(Object ret) throws Throwable {  
        // 处理完请求，返回内容  
        logger.info("RESPONSE : " + ret);
    }  
  
}

整个AOP的代码结构如下:
这里写图片描述

注意点：

在后置通知中returning = “ret”中定义的参数名必须和通知方法受那个的参数匹配，即returning = “ret”中定义的是ret,通知方法中也必须是”ret”,否则将抛出异常。

@AfterReturning(returning = "ret", pointcut = "webLog()")  
  public void doAfterReturning(Object ret) throws Throwable {  
      // 处理完请求，返回内容  
      logger.info("RESPONSE : " + ret);
  }

3、参考文章：
spring aop 面向切面编程初接触
 Spring AOP(二)之AfterReturning增强处理

展开全文 >>

SSO单点登录探究【基于cookie共享】

2018-06-25

最近看到公司的需求里面有单点登录，就去了解了一下。下面将从SSO单点登录的原理、实现步骤以及实现demo几个方面来讲述自己的理解。

1、SSO根本原理:
登录状态的共享;
1)、登录状态的共享有两种实现方式:
一：cookie共享【但是cookie原则上不能跨域，通过合理的配置在二级域名相同的情况下可以跨域共享】。
二：通过Session共享登录状态。【Spring Session共享方案，分布式系统中常用】
三：通过IP+Agent+User的方式实现状态共享，实际上是模仿了cookie合session机制。【我自己研究的，适合绝对跨域的分布式系统】因为通过IP+Agent+User的形式理论上可以模仿cookie合session识别一次会话。
这里写图片描述
2、实现的概要步骤【网络上的步骤乱七八糟各种不合理，自己整理了下】
1）、子系统一登陆，未登陆则进入SSO认证中心认证，成功则更新登陆状态【创建全局会话】，返回共享媒介；
2）、子系统二携带共享媒介，获取全局会话，读取登陆信息和登陆状态，实质是通过共享媒介保持了会话状态。
３）、退出时只需要注销全局会话状态即可。

【以上的概要步骤对SSO根本原理的一、二、三都适用】

３、SSＯ登陆的demo[通过cookie共享实现的]
SSOAuth：
这里写图片描述
SSOWebDemo1：

SSOWebDemo2：

SSO单点登录的源码。

四：参考文章:
单点登录原理与简单实现
 单点登录

展开全文 >>

API扫描工具类的实现

2018-06-07

公司的架构师开发了一套接口扫描工具类，我想着，如果自己以后开公司了可能也用得着，所以研究了下，整理出了下面的开发思路和相关技术代码。
API扫描工具类的主要开发思路如下：
1、定义接口上的注解；
2、引用注解
3、扫描注解
首先定义注解：

定义接口上的注解

package com.fs.comment;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.FIELD,ElementType.LOCAL_VARIABLE,ElementType.PARAMETER})
public @interface PersistenceContext {
	String unitName();
}

关于注解：请参照下面的文章：
Java注解详解
 Java注解之Retention、Documented、Target介绍
 实用的java注解工具类
如果想要动态的修改注解的值【如动态切换数据源】，一般看来注解的值是不能动态修改的，但是借助特殊工具还是可以的，参照下面的文章：
JAVAssist—动态修改注解

引用注解

package com.fs.model.model2.model3.model4.model5;
import com.fs.comment.PersistenceContext;
import com.fs.model.EntityManager;
public class CollectionBase{  
    /** 
     * 注入实体单元 
     */  
    @PersistenceContext(unitName="collection-entity")  
    protected EntityManager em;  
    /**EntityManger 
     * 实例化 
     */
    @PersistenceContext(unitName="collection-entity-01-01-01-01-01-01")  
    public EntityManager getEntityManager() {          
        return this.em;  
    }  
    
    @PersistenceContext(unitName="collection-entity-01-02-02-01-01-01")
    public EntityManager getEntityManager2() {          
        return this.em;  
    }  
}

扫描注解
扫描注解的工具类是参考了别人的代码写出来的。

package com.fs.commentUtils;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import com.fs.comment.PersistenceContext;
/**
 * 
 * 注解扫描工具类;
 *
 */
public class CommentScanUtil {
	/**    
	   * getRequestMappingValue方法描述:  
	   * 作者:JunJun
	   * 日期:2018年6月7日 下午5:41:00         
	   * 异常对象:@param packageName
	   * 异常对象:@return 
	*/
	    public static List<String> getRequestMappingValue(String packageName) {
	   // GetAnnotationValueUtil getAnnotationValueUtil = new GetAnnotationValueUtil();
	         //第一个class类的集合  
	        List<Class<?>> classes = new ArrayList<Class<?>>();  
	        //是否循环迭代  
	        boolean recursive = true;  
	        //获取包的名字 并进行替换  
	        String packageDirName = packageName.replace('.', '/');  
	        //定义一个枚举的集合 并进行循环来处理这个目录下的文件 
	        Enumeration<URL> dirs;
	        try {  
	            //读取指定package下的所有class
	            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName); 
	            while (dirs.hasMoreElements()){  
	                URL url = dirs.nextElement();  
	                //得到协议的名称  
	                String protocol = url.getProtocol();
	                //判断是否以文件的形式保存在服务器上  
	                if ("file".equals(protocol)) {
	                    //获取包的物理路径  
	                     String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
	                     filePath = filePath.substring(1);
	                    //以文件的方式扫描整个包下的文件 并添加到集合中  
	                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
	                } 
	            }  
	        } catch (IOException e) {
	            e.printStackTrace();  
	        } 
	        List<String> stringList = new ArrayList<String>();
	        for (Class<?> clazz : classes) {
	            //循环获取所有的类
	            Class<?> c = clazz;
	            //获取类的所有方法
	            Method[] methods = c.getMethods();
	            for (Method method : methods) {
	                //获取RequestMapping注解
	            	PersistenceContext annotation = method.getAnnotation(PersistenceContext.class);
	                if (annotation != null) {
	                    //获取注解的value值
	                	String value = annotation.unitName();
	                    System.out.println("-------anoValue--------"+value);
	                }
	            }
	        }
	        return stringList;
	    }
	    
	    
	    /**    
	     * findAndAddClassesInPackageByFile方法描述:  
	     * 作者:JunJun
	     * 日期:2018年6月7日 下午5:41:12         
	     * 异常对象:@param packageName
	     * 异常对象:@param packagePath
	     * 异常对象:@param recursive
	     * 异常对象:@param classes 
	     */
	    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes){  
	    	//packagePath = packagePath.trim().substring(1);
	        //获取此包的目录 建立一个File  
	        File dir = new File(packagePath);
	        //如果不存在或者 也不是目录就直接返回  
	        if (!dir.exists() || !dir.isDirectory()) {
	            return;  
	        }  
	        //如果存在 就获取包下的所有文件 包括目录  
	        File[] dirfiles = dir.listFiles(new FileFilter() {  
	              //自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)  
	              public boolean accept(File file) { 
	                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));  
	              }
	        }); 
	        //循环所有文件 
	        for (File file : dirfiles) { 
	            //如果是目录 则继续扫描  
	            if (file.isDirectory()) {
	                findAndAddClassesInPackageByFile(packageName + "." + file.getName(),  
	                                      file.getAbsolutePath(),  
	                                      recursive,  
	                                      classes);
	            }  
	            else {  
	                //如果是java类文件 去掉后面的.class 只留下类名  
	                String className = file.getName().substring(0, file.getName().length() - 6); 
	                try {  
	                    //添加到集合中去  
	                    classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + "." + className));  
	                } catch (ClassNotFoundException e) {  
	                    e.printStackTrace();  
	                }  
	            }  
	        } 
	    }}

经过测试，证实这段代码对深层代码的递归扫描性能很高。测试的递归路径如下图所示：
这里写图片描述

另外在研究过程中尝试了自动解析API参数为JSON ，虽然最终以失败告终,失败的原因是写出来的代码无法适应参数中泛型以及泛型中属性名的动态匹配。下面是在尝试中总结出来的工具类：

扫描API中参数的类型工具类：

package com.fs;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import com.fs.comment.NoNull;
import com.fs.model.BlueChartProjectSearchFilter;
import com.fs.model.ReqObject;
import com.fs.model.ReqQuery;
import com.fs.model.Student;
import com.fs.model.Teacher;
/**
 * 通过反射获取泛型信息
 * 
 * @author Administrator
 *
 */
public class Generic {
	/**
	 * 方法一
	 * 
	 * @param map
	 * @param list
	 */
	public static void test01(@NoNull ReqObject<ReqQuery<BlueChartProjectSearchFilter>>  map, @NoNull List<Student> list,
			@NoNull Teacher<Student> a) {
		System.out.println("Generic.test01()");
	}
	
	public static void main(String[] args) {
		try {
			Method[] methods = Generic.class.getDeclaredMethods();
			Class<?>[] parameterTypes2 = methods[1].getParameterTypes();
			Method m = Generic.class.getMethod("test01", parameterTypes2);
			Class<?>[] parameterTypes = m.getParameterTypes();
			for (Class<?> class1 : parameterTypes) {
				System.out.println("---------><><><>" + class1);
			}
			Type[] t = m.getGenericParameterTypes();// 获取参数泛型
			for (Type paramType : t) {
				System.out.println("#" + paramType);
				if (paramType instanceof ParameterizedType) {
					Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();
					for (@SuppressWarnings("unused") Type genericType : genericTypes) {
						System.out.println("#"+paramType);
					}
				}
			}
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
	}
}

字符串转化为JAVA代码的工具类:

package com.fs.commentUtils;
import java.util.Map;
import org.apache.commons.jexl2.Expression;
import org.apache.commons.jexl2.JexlContext;
import org.apache.commons.jexl2.JexlEngine;
import org.apache.commons.jexl2.MapContext;
import com.fs.model.BlueChartProjectSearchFilter;
import com.fs.model.ReqObject;
import com.fs.model.ReqQuery;
import net.sf.json.JSONObject;
/**
 * 字符串转化为代码;
 * 
 * @author xdsm
 *
 */
public class StringToCode {
	/**
	 * 
	 * @author: Longjun
	 * @Description: 使用commons的jexl可实现将字符串变成可执行代码的功能
	 * @date:2016年3月21日 下午1:45:13
	 */
	public static Object convertToCode(String jexlExp, Map<String, Object> map) {
		JexlEngine jexl = new JexlEngine();
		Expression e = jexl.createExpression(jexlExp);
		JexlContext jc = new MapContext();
		for (String key : map.keySet()) {
			jc.set(key, map.get(key));
		}
		if (null == e.evaluate(jc)) {
			return "";
		}
		return e.evaluate(jc);
	}
	
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {  
		/*ReqObject req = (ReqObject) Class.forName("com.fs.model.ReqObject").newInstance();
		ReqQuery reqq = (ReqQuery) Class.forName("com.fs.model.ReqQuery").newInstance();
		BlueChartProjectSearchFilter bcsf = (BlueChartProjectSearchFilter) Class.forName("com.fs.model.BlueChartProjectSearchFilter").newInstance();
		reqq.setObj(bcsf);
		req.setObj(reqq);
		JSONObject json = JSONObject.fromObject(req);*/
		/*Object req = Class.forName("com.fs.model.ReqObject").cast(Class.forName("com.fs.model.ReqObject").newInstance());
		Object reqq = Class.forName("com.fs.model.ReqQuery").cast(Class.forName("com.fs.model.ReqQuery").newInstance());
		Object bcsf = Class.forName("com.fs.model.BlueChartProjectSearchFilter").cast(Class.forName("com.fs.model.BlueChartProjectSearchFilter").newInstance());
		Field[] fields = req.getClass().getDeclaredFields();
		for (Field field : fields) {
			String fieldStr = field.toString();
			String[] fieldPreStrArray = fieldStr.split(" ");
			String fieldType = fieldPreStrArray[1];
			String fieldName = fieldPreStrArray[2].substring(fieldPreStrArray[2].lastIndexOf(".") + 1);
			System.out.println("----fieldType----"+fieldType);
			System.out.println("//----fieldName----"+fieldName);
		}*/
		ReqObject<ReqQuery<BlueChartProjectSearchFilter>> req = new ReqObject<ReqQuery<BlueChartProjectSearchFilter>>();
		JSONObject json = JSONObject.fromObject(req);
		System.out.println(json);
		/*try {  
            Map<String,Object> map=new HashMap<String,Object>();   
            map.put("money",2100);    
            String expression="money>=2000&&money<=4000";
            Object code = convertToCode(expression,map);
            System.out.println(code);
        } catch (Exception e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  */
    }  
}

参考文章：java将字符串转换成可执行代码

展开全文 >>

梦想是一个天真的词，实现梦想是一个残酷的词

2018-05-08

梦想是一个天真的词，实现梦想是一个残酷的词。今天我要探索人工智能啦！
这里写图片描述

展开全文 >>

Request的包装类HttpServletRequestWrapper的使用

2018-04-19

在使用zuul进行鉴权的时候，我们希望从请求Request中获取输入流，解析里面的内容，奈何InputStream只能被读取一次。为啥呢？源码里是这样说的：

public int read(byte[] b,int off, int len)
　　　Reads up to len bytes of data into an array of bytes from this input stream. Ifpos equals count, then -1 is returned to indicate end of file. Otherwise, the number k of bytes read is equal to the smaller of len and count-pos.If k is positive, then bytes buf[pos] through buf[pos+k-1] are copied into b[off] through b[off+k-1] in the manner performed by System.arraycopy. The value k is added into pos and k is returned.
　　　
大致的意思是：在InputStream读取的时候，会有一个pos指针，它指示每次读取之后下一次要读取的起始位置。在每次读取后会更新pos的值，当你下次再来读取的时候是从pos的位置开始的，而不是从头开始，所以第二次获取String中的值的时候是不全的，API中提供了一个解决办法：reset()。但我发现在inputStream和servlet中根本不起作用。提示 mark/reset not supported 。意思是只有重写过markSupported()方法的IO流才可以用。所以一般我们使用inputStream，最好在一次内处理完所有逻辑。

那么就没法在中途获取请求流中的数据么？当然有办法了，我可是PPZ，只需要重写Request缓存一下流中的数据就好了，实现代码如下：

BodyReaderHttpServletRequestWrapper.java
package com.neo.authUtils;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Enumeration;
import java.util.NoSuchElementException;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;  
  
public class BodyReaderHttpServletRequestWrapper extends  
        HttpServletRequestWrapper {  
      
   // private final byte[] body;  
	 -----》private byte[] body;《------- 
  
    public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {  
        super(request);  
        System.out.println("-------------------打印请求的头信息------------------------------");    
        Enumeration<?> e = request.getHeaderNames()   ;    
         while(e.hasMoreElements()){    
             String name = (String) e.nextElement();    
             String value = request.getHeader(name);    
            // System.out.println(name+" = "+value);    
                 
         }
         -----》获取流中的数据缓存到字节数组中，以后要读数据就用这里的《------
        body = HttpHelper.getBodyString(request).getBytes(Charset.forName("UTF-8"));  
    }
    
    /**
     * 从请求的头部获取用户的身份识别id;
     * @param request
     * @return
     */
    public String getJsessionidFromHeader(HttpServletRequest request) {
    	String jsessionid = null;//识别用户身份的id;
    	Enumeration<?> e = request.getHeaderNames()   ;    
        while(e.hasMoreElements()){    
            String name = (String) e.nextElement();    
            String value = request.getHeader(name);
            //cookie = JSESSIONID=B926F6024438D4C693A5E5881595160C; SESSION=458e80dc-e354-4af3-a501-74504a873e70
            if("cookie".equals(name)) {
            	jsessionid = value.split(";")[0].split("=")[1];
            }
            System.out.println(name+"="+value);
        }
       // System.out.println("======jsessionid========>"+jsessionid);
		return jsessionid;
    }
  
    @Override  
    public BufferedReader getReader() throws IOException {  
        return new BufferedReader(new InputStreamReader(getInputStream()));  
    }  
  
    @Override  
    public ServletInputStream getInputStream() throws IOException {  
         ------》从缓存的数据中读取数据《------
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);  
  
        return new ServletInputStream() {  
            public int read() throws IOException {  
                return bais.read();  
            }
			@Override
			public boolean isFinished() {
				// TODO Auto-generated method stub
				return false;
			}
			@Override
			public boolean isReady() {
				// TODO Auto-generated method stub
				return false;
			}
			@Override
			public void setReadListener(ReadListener listener) {
				// TODO Auto-generated method stub
				
			}  
        };  
    }  
  
    @Override  
    public String getHeader(String name) {  
        return super.getHeader(name);  
    }  
  
    @Override  
    public Enumeration<String> getHeaderNames() {  
        return super.getHeaderNames();  
    }  
  
   /* @Override  
    public Enumeration<String> getHeaders(String name) {  
        return super.getHeaders(name);  
    }  */
    
    /**
     * content-type=text/plain;charset=UTF-8
     * 重写getHeaders方法，实现自定义Content-Type;
     */
    @Override  
    public Enumeration<String> getHeaders(String name) {  
        if ((null != name && name.equals("Content-Type"))||(null != name && name.equals("content-type"))) {  
            return new Enumeration<String>() {  
                private boolean hasGetted = false;  
  
                @Override  
                public String nextElement() {  
                    if (hasGetted) {  
                        throw new NoSuchElementException();  
                    } else {  
                        hasGetted = true;
                        return "application/json;charset=utf-8";  
                    }  
                }  
  
                @Override  
                public boolean hasMoreElements() {  
                    return !hasGetted;  
                }  
            };  
        }  
        return super.getHeaders(name);  
    }  
    
    /**
     * 添加自定义信息到请求体;
     * @param customMsg：自定义的添加到请求体中的信息;
     */
    public void appendCustomMsgToReqBody(String customMsg) {
    	String oldBodyString = HttpHelper.getBodyString(this);//oldBodyString一定是通过当前对象的输入流解析得来的，否则接收时会报EOFException；
    	String appendMsg = HttpHelper.appendCustomMsgToReqBody(customMsg);
    	String requestBodyAfterAppend = appendMsg + "," +oldBodyString;
    	//this.body = HttpHelper.appendCustomMsgToReqBody(HttpHelper.appendCustomMsgToReqBody(customMsg)+(HttpHelper.getBodyString(this))).getBytes(Charset.forName("UTF-8"));
    	//this.body = HttpHelper.appendCustomMsgToReqBody((HttpHelper.getBodyString(this))).getBytes(Charset.forName("UTF-8"));
    	this.body = HttpHelper.appendCustomMsgToReqBody(requestBodyAfterAppend).getBytes(Charset.forName("UTF-8"));
    } 
}  
HttpHelper.java
package com.neo.authUtils;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import javax.servlet.ServletRequest;
public class HttpHelper {
	/**
	 * 获取post请求中的Body
	 *
	 * @param request
	 * @return
	 */
	public static String getBodyString(ServletRequest request) {
		StringBuilder sb = new StringBuilder();
		InputStream inputStream = null;
		BufferedReader reader = null;
		try {
			inputStream = request.getInputStream();
			//读取流并将流写出去,避免数据流中断;
			reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
			String line = "";
			while ((line = reader.readLine()) != null) {
				sb.append(line);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return sb.toString();
	}
	
	//添加自定义的信息到请求体中;
	public static String appendCustomMsgToReqBody(String newReqBodyStr) {
		StringBuilder sb = new StringBuilder();
		InputStream inputStream = null;
		BufferedReader reader = null;
		String newReqBody = null;
		try {
			//通过字符串构造输入流;
			inputStream = String2InputStream(newReqBodyStr);
			reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
			String line = "";
			while ((line = reader.readLine()) != null) {
				sb.append(line);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		//返回字符串;
		newReqBody = sb.toString();
		return newReqBody;
		
	}
	
	//将字符串转化为输入流;
	public static InputStream String2InputStream(String str) {
	    ByteArrayInputStream stream = null;
	    try {
	        stream = new ByteArrayInputStream(str.getBytes("UTF-8"));
	    } catch (UnsupportedEncodingException e) {
	        e.printStackTrace();
	    }
	    return stream;
	}
}

上述方案解决了使用request.getInpuStream()方法读取流中的数据只能读取一次的问题，其实当我们在使用第三方接口时，如果请求头信息和我们的服务所需不一致，例如第三方接口中头部信息为：content-type=text/plain;charset=UTF-8
而我们需要的是：”application/json;charset=utf-8”时，我们也是可以通过重写对应的方法对请求的头部信息进行修改的，代码如下：

/**
     * content-type=text/plain;charset=UTF-8
     * 重写getHeaders方法，实现自定义Content-Type;
     */
    @Override  
    public Enumeration<String> getHeaders(String name) {  
        if ((null != name && name.equals("Content-Type"))||(null != name && name.equals("content-type"))) {  
            return new Enumeration<String>() {  
                private boolean hasGetted = false;  
  
                @Override  
                public String nextElement() {  
                    if (hasGetted) {  
                        throw new NoSuchElementException();  
                    } else {  
                        hasGetted = true;
                        return "application/json;charset=utf-8";  
                    }  
                }  
  
                @Override  
                public boolean hasMoreElements() {  
                    return !hasGetted;  
                }  
            };  
        }  
        return super.getHeaders(name);  
    }

当我们在后端设置了头部信息后，如果不出意外，前端发送的请求将变为简单请求，这样，服务器的处理机制将简单很多。

展开全文 >>

运行时异常-RunTimeExcepption

2018-04-19

前几天写代码的时候，遇到一个需求，保存的时候如果重名则不执行保存，并抛出异常。但是当我抛出的不是运行时异常的时候，这个异常就需要一层层的捕获。就像下面这样：

ExceptionTest .java
package com.lz.utils;
public class ExceptionTest {
   public static void testRunTimeException() throws Exception {
	  //throw new MyRunTimeException("运行时的异常！");
	   throw new Exception();
   }
}
Test.java
package com.lz;
import com.lz.utils.ExceptionTest;
import com.lz.utils.GetDBPhysicDesignTxt;
public class Test {
public static void main(String[] args) throws Exception {
	ExceptionTest.testRunTimeException();
}
}

或者这样

ExceptionTest.java
package com.lz.utils;
public class ExceptionTest {
   public static void testRunTimeException() {
	  //throw new MyRunTimeException("运行时的异常！");
	   try {
		throw new Exception();
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
   }
}

但是从一个程序员的角度，考虑，重名属于运行后进行操作才产生的异常，正常情况下应该抛出运行时异常，并且公司我最膜拜的架构师【据说是离神最近的男人】是已经封装好了异常，自定义运行时异常，因此就使用了运行时异常实现：
代码如下：

MyRunTimeException.java
自定义的运行时异常类：
package com.lz.utils;
public class MyRunTimeException extends RuntimeException {
	public MyRunTimeException(String info) {
		super(info);
	}
}
ExceptionTest.java
package com.lz.utils;
public class ExceptionTest {
   public static void testRunTimeException() {
	  throw new MyRunTimeException("运行时的异常！");
   }
}

使用自定义运行时异常后，发现省事好多，异常并不需要一级一级的向上抛出或者在当前类捕获。

借助这个案例分析了下运行时异常的特点：

A: 运行时期异常的概述:

RuntimeException和他的所有子类异常,都属于运行时期异常。
NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常.

B：运行时期异常的特点

a：方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常。

b：运行时期异常一旦发生,需要程序人员修改源代码。
设计原因:
运行异常,不能发生,但是如果发生了,程序人员停止程序修改源代码
运行异常: 一旦发生,不要处理,请你修改源代码,运行异常一旦发生,后面的代码没有执行的意义

这就是运行时异常的总结，就问还有谁。

展开全文 >>