使用七牛上传图片的demo

七牛是一个很好的第三方的图片服务器,下面介绍一下使用七牛上传图片的demo.
1、直接上代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
UploadDemo.java
----------
package com.qiniu.up;
import java.io.IOException;
import com.qiniu.common.QiniuException;
import com.qiniu.common.Zone;
import com.qiniu.http.Response;
import com.qiniu.storage.UploadManager;
import com.qiniu.util.Auth;
public class UploadDemo {
	// 设置好账号的ACCESS_KEY和SECRET_KEY
	String ACCESS_KEY = "lEZ6Ht3bp××××××b1Hn-aNpwH"; // 这两个登录七牛
																	// 账号里面可以找到
	String SECRET_KEY = "DKJKiwHNy××××××nTTl6D89is_gNSEzohpDYOKk";
	// 要上传的空间
	String bucketname = "storage××××××4zj"; // 填写新建的那个存储空间对象的名称
	// 上传到七牛后保存的文件名
	String key = "00002.jpg";
	// 上传文件的路径
	String FilePath = "d:\\01.jpg"; // 本地要上传文件路径
	// 密钥配置
	Auth auth = Auth.create(ACCESS_KEY, SECRET_KEY);
	// 创建上传对象
	UploadManager uploadManager = new UploadManager();
	// 简单上传，使用默认策略，只需要设置上传的空间名就可以了
	public String getUpToken() {
		return auth.uploadToken(bucketname);
	}
	// 普通上传
	public void upload() throws IOException {
		try {
			// 调用put方法上传
			Response res = uploadManager.put(FilePath, key, getUpToken());
			// 打印返回的信息
			System.out.println(res.isOK());
			System.out.println(res.bodyString());
		} catch (QiniuException e) {
			Response r = e.response;
			// 请求失败时打印的异常的信息
			System.out.println(r.toString());
			try {
				// 响应的文本信息
				System.out.println(r.bodyString());
			} catch (QiniuException e1) {
				// ignore
			}
		}
	}
	public static void main(String args[]) throws IOException {
		new UploadDemo().upload();
	}
}

2、相关的依赖
Demo依赖的jar包
3、引用文章
Java SDK

展开全文 >>

Java8之lambda表达式略解

一、什么是lambda表达式？

Lambda 表达式，其实就是匿名函数。而函数其实就是功能（function），匿名函数，就是匿名的功能代码了，我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使 Java的语言表达能力得到了提升。Lambda就是为了替换匿名函数而存在的【本人的理解】;

二、lambda的使用场景。

1
Lambda表达式是用于替代匿名函数，写出更简洁的代码的，因此，所有期待匿名函数、或者函数式接口类型参数出现的地方都可以使用Lambda替换。

三、什么是函数式接口。

1
2
3
4
函数式接口：Functional Interface. 
定义的一个接口，接口里面必须 有且只有一个抽象方法 ，这样的接口就成为函数式接口。 
在可以使用lambda表达式的地方，方法声明时必须包含一个函数式的接口，匿名内部类其实是函数式接口的实现类。 
（JAVA8的接口可以有多个default方法）

四、写法、规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
基本语法: 
(parameters) -> expression 或 (parameters) ->{ statements; } 
即: 参数 -> 带返回值的表达式/无返回值的陈述
----------
//1. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y;
//2. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s);
----------
lambda表达式的结构
参数可以是零个或多个
参数类型可指定，可省略（根据表达式上下文推断）
参数包含在圆括号中，用逗号分隔
表达式主体可以是零条或多条语句,包含在花括号中
表达式主体只有一条语句时,花括号可省略
表达式主体有一条以上语句时，表达式的返回类型与代码块的返回类型一致
表达式只有一条语句时，表达式的返回类型与该语句的返回类型一致
//零个
 ()-> System.out.println("no argument");
//一个
  x->x+1
//两个
  (x,y)->x+y
//省略参数类型
 View.OnClickListener oneArgument = view->Log.d(TAG,"one argument");
 //指定参数类型
 View.OnClickListener oneArgument = (View view)->Log.d(TAG,"one argument");
//多行语句
//返回类型是代码块返回的void
View.OnClickListener multiLine = (View view)->{
      Log.d(TAG,"multi statements");
      Log.d(TAG,"second line");
}
//返回类型是表达式主体语句的返回类型int
(int x)->x+1

五.几个特性

1
2
3
1. 类型推导 
编译器负责推导lambda表达式的类型。它利用lambda表达式所在上下文所期待的类型进行推导， 
这个被期待的类型被称为目标类型。就是说我们传入的参数可以无需写类型了！

六、demo
1.使用lambda表达式实现Runnable

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.lz.test;
/**
 * 使用lambda表达式替换Runnable匿名内部类
 * @author MingChenchen
 *
 */
public class RunableTest {
    /**
     * 普通的Runnable
     */
    public static void runSomeThing(){
        //new Runnable()实际上实现的接口的匿名子类;
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("I am running");
            }
        };
        new Thread(runnable).start();
    }
    /**
     * 使用lambda后的
     */
    public static void runSomeThingByLambda(){
    	//此处期待的是一个函数式类型的参数，因此可以使用lambda表达式进行替换;
        new Thread(() -> System.out.println("I am running")).start();
    }
    public static void main(String[] args) {
        //runSomeThing();
     runSomeThingByLambda();
    }
}

上述代码中：
() -> System.out.println(“I am running”)就是一个lambda表达式，
可以看出，它是替代了new Runnable(){}这个匿名内部类。

2.使用lambda表达式实现Comparator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
Students.java
----------
package com.lz.test;
/**
 * Lambda表达式测试实体;
 * @author JunZhou
 * @Time 2018年1月29日下午10:44:56
 */
public class Students {
	private int age;
	private int score;
	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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package com.lz.test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class LambdaTestDemo {
	public static void main(String[] args) {
		List<Students> students = new ArrayList<Students>();
		students.add(new Students(23, 100));
		students.add(new Students(27, 98));
		students.add(new Students(29, 99));
		students.add(new Students(29, 98));
		students.add(new Students(22, 89));
		// 未使用lambda表达式之前的代码;
		/*
		 * Collections.sort(students, new Comparator<Students>() {
		 * 
		 * @Override public int compare(Students o1, Students o2) { int i =
		 * o1.getScore() - o2.getScore(); if(i == 0){ return o1.getAge() -
		 * o2.getAge(); } return i; } });
		 */
		// 使用lambda表达式替换之后的代码;
		Collections.sort(students, (Students o1, Students o2) -> {
			int i = o1.getScore() - o2.getScore();
			if (i == 0) {
				return o1.getAge() - o2.getAge();
			}
			return i;
		});
		for (Students stu : students) {
			System.out.println("score:" + stu.getScore() + ":age" + stu.getAge());
		}
	}
}

7、参考文章
JAVA8之lambda表达式详解，及stream中的lambda使用

30 分钟入门 Java8 之 lambda 表达式

展开全文 >>

Java中对List中的存储对象根据属性进行排序的办法

有时候需要对集合中的元素按照一定的规则进行排序，对于比较简单单一的数据可以用Java中提供的对集合进行操作的工具类Collections中的sort方法,对于对象，如果要一依据属性进行排序，就需要参与比较的对象实现ComparableT接口，或者使用匿名比较器的方式实现比较。
先看一个简单的例子：
1、简单数据

1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {  
    List<Integer> nums = new ArrayList<Integer>();  
        nums.add(3);  
        nums.add(5);  
        nums.add(1);  
        nums.add(0);  
        System.out.println(nums);  
        Collections.sort(nums);  
        System.out.println(nums);  
}

输出结果：
[3, 5, 1, 0]
[0, 1, 3, 5]
稍微复杂的List里面放一个复杂的对象

2、复杂数据
(1、)通过实现接口进行比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package core.java.collection.collections;  
  
public class User implements Comparable<User>{  
      
    private int score;  
      
    private int age;  
      
    public User(int score, int age){  
        super();  
        this.score = score;  
        this.age = age;  
    }  
  
    public int getScore() {  
        return score;  
    }  
  
    public void setScore(int score) {  
        this.score = score;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    @Override  
    public int compareTo(User o) {  
        int i = this.getAge() - o.getAge();//先按照年龄排序  
        if(i == 0){  
            return this.score - o.getScore();//如果年龄相等了再用分数进行排序  
        }  
        return i;  
    }  
      
}  
  
public static void main(String[] args) {  
        List<User> users = new ArrayList<User>();  
        users.add(new User(78, 26));  
        users.add(new User(67, 23));  
        users.add(new User(34, 56));  
        users.add(new User(55, 23));  
        Collections.sort(users);  
        for(User user : users){  
            System.out.println(user.getScore() + "," + user.getAge());  
        }  
}

输出结果：
55,23
67,23
78,26
34,56
我们会发现sort(List)方法中List中的T必须实现Comparable接口，然后实现
compareTo（）方法，该方法的返回值0代表相等，1表示大于，-1表示小于；为什么
在简单例子中没有看到实现Comparable接口呢？是因为Integer类其实自己已经实现
了Comparable接口，Java已经给我们做好了。

(2、)通过匿名比较器实现比较
Collections提供的第二种排序方法sort(List list, Comparator<? super T> c)
先看例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package core.java.collection.collections;  
  
public class Students {  
      
    private int age;  
    private int score;  
      
    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 static void main(String[] args) {  
        List<Students> students = new ArrayList<Students>();  
        students.add(new Students(23, 100));  
        students.add(new Students(27, 98));  
        students.add(new Students(29, 99));  
        students.add(new Students(29, 98));  
        students.add(new Students(22, 89));  
        Collections.sort(students, new Comparator<Students>() {  
  
            @Override  
            public int compare(Students o1, Students o2) {  
                int i = o1.getScore() - o2.getScore();  
                if(i == 0){  
                    return o1.getAge() - o2.getAge();  
                }  
                return i;  
            }  
        });  
        for(Students stu : students){  
            System.out.println("score:" + stu.getScore() + ":age" + stu.getAge());  
        }  
}

输出结果：
score:89:age22
score:98:age27
score:98:age29
score:99:age29
score:100:age23

3、总结
两种方式都可以实现数据的比较，从上面的例子我们可以看出Students类没有实现Comparable接口，只是在sort()方法中多传入一个参数，只不过该参数是一个接口我们需要实现其compare方法，但是通过实现接口的方式代码结构将更加清晰。

展开全文 >>

SpringBoot中的拦截器的使用和配置

SpringBoot中的拦截器是常用的技能，接下来将参照一个小小的demo讲解SpringBoot中拦截器的配置和使用.
1、SpringBoot中拦截器的使用场景.
日志、登陆验证、权限等都会用到拦截器.
2、demo源码.
在SpringBoot中使用拦截器非常的简单，相关的依赖SpringBoot已经自动为我们导入了，因此不必进行额外的导入，相关的参考代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package com.spring.boot.gp4zj.webconfig;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
/**
 * 添加了一个拦截器，用于登陆验证和数据加密;
 * 
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月19日@下午2:24:42
 */
public class SessionInterceptor implements HandlerInterceptor {
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
		// 登录不做拦截
		if (request.getRequestURI().equals("/mongo/attencedetail/selectAll")
				|| request.getRequestURI().equals("/user/login_view")) {
			System.out.println("You get a http request");
		}
		return true;
	}
  
   /**
     * 该方法将在Controller执行之后，返回视图之前执行，modelAndView表示请求Controller处理之后返回的Model和View对象，所以可以在
     * 这个方法中修改modelAndView的属性，从而达到改变返回的模型和视图的效果。
     */
	@Override
	public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o,
			ModelAndView modelAndView) throws Exception {
	}
   
	@Override
	public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
			Object o, Exception e) throws Exception {
	}
	public String getRemortIP(HttpServletRequest request) {
		if (request.getHeader("x-forwarded-for") == null) {
			return request.getRemoteAddr();
		}
		return request.getHeader("x-forwarded-for");
	}
}

3、参考文章

如何在SpringBoot项目中使用拦截器[登陆拦截器]

SpringMVC拦截器

SpringMVC学习记录–拦截器的使用

SpringMvc4.x基本配置:拦截器配置

Spring Boot核心:日志配置

springboot整合shiro-登录认证和权限管理

展开全文 >>

Springboot中定时任务的实现

1、定时任务在J2EE项目中经常会被用到，如自动取消订单、在指定的时间清空缓存等需求就需要定时任务来实现。定时任务的完成是靠轮询来实现的，所以存在一定的延时误差是合理的。springboot在实现定时任务的过程中相关的依赖已经在父依赖中被导入了，所以不需要导入额外的依赖。
2、SpringBoot中定时任务的实现分两步：（1、）定时任务的的实现;
(2、)创建调度表达式;
3、具体实现.
(1、)定时任务的的实现，其实就是你要通过定时器完成的业务逻辑:

1
2
3
4
5
6
7
@Scheduled(cron = "*/2 * * * * ?")
	public void serviceOrderTask() {
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("YY:MM:DD hh:mm:ss");
        String formatDataStr = sdf.format(date);
        System.out.println("|_"+formatDataStr);
	}

(2、)配置调度表达式:
调度表达式的声明参考文章1.
调度表达式的声明参考文章2.

1
2
3
4
5
6
7
@Scheduled(cron = "*/2 * * * * ?")
	public void serviceOrderTask() {
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("YY:MM:DD hh:mm:ss");
        String formatDataStr = sdf.format(date);
        System.out.println("|_"+formatDataStr);
	}

通过@Scheduled注解添加调度表达式.
4、需要注意的地方
在使用SpringBoot任务调度的时候，需要在启动类上添加注解@EnableScheduling。

1
2
3
4
5
6
7
8
9
10
11
12
package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableScheduling
public class DemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
}

展开全文 >>

Jrebel热部署插件的安装、破解和使用

1、什么是jrebel？
Jrebel是一款热部署插件，用于提高开发效率。一般我们在开发j2ee项目的时候，每次代码跟新就得重启服务，这样效率很低，尤其是对于大项目的，启动很慢，白白浪费了很多时间。使用jrebel插件后可以在java【配置文件更新后还是得重启服务】代码更新后自动编译更新而不用重启项目。但是jrebel的破解码很难搞，下面介绍jrebel的安装、破解和使用.。

2、jrebel的安装、破解和使用.
(1、)安装
可以直接去eclipse的应用商店中下载，如图:
这里写图片描述
(2、)破解
jrebel理论上是收费的，但是我们可以破解，不是通过破解码和破解工具破解，因为这些方大都是无效的，老旧的。幸好，jrebel爱好者【可能是jrebe官方】搭建了一个网站，专门用于破解激活jrebel.
破解网站:MyJrebel
登录这个网站，使用facebook 或者推特登录（需要翻墙），然后输入邮箱，会要求验证（登录邮箱验证，点击验证链接），在输入手机号，不需要验证手机号。之后会进入破解网站:MyJrebel,登录后按照如下步骤操作即可获取激活码：
A、这里写图片描述
B、这里写图片描述
C、这里写图片描述
(3、)使用
3.1、将jrebel插件作用于选中的项目;

这里写图片描述
3.2、更新代码，jrebel自动重新编译，无需重新启动。
这里写图片描述

展开全文 >>

java中枚举类略解

为什么在java中要用枚举类呢?
我的理解：如果不用枚举类，而用传统的方法，那么如果要定义三个常量:

1
[{0,"服务订单"},{1,"商品订单"},{2,"会员卡订单"}]

而且在引用的时候做到见名知意,那么就得这么些：
OrderType.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.lz.orign.enums;
/**
 * 模拟枚举类中元素的底层实现;
 * 
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月20日@下午12:32:22
 */
public class OrderType {
	private String type;
	private int typeCode;
	public OrderType(int typeCode,String type) {
		super();
		this.type = type;
		this.typeCode = typeCode;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public int getTypeCode() {
		return typeCode;
	}
	public void setTypeCode(int typeCode) {
		this.typeCode = typeCode;
	}
}

SumuOrderEnum.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.lz.orign.enums;
/**
 * 模拟枚举类中元素的声明;
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月20日@下午2:08:12
 */
public class SumuOrderEnum {
	public static OrderType orderType1 = new OrderType(0,"服务订单");
	public static OrderType orderType2 = new OrderType(1,"商品订单");
	public static OrderType orderType3 = new OrderType(2,"会员卡订单");
	
}

EnumTest .java

1
2
3
4
5
6
7
8
9
10
11
12
package com.lz.orign.enums;
public class EnumTest {
/**
 * 模拟枚举类的调用;
 * @param args
 */
public static void main(String[] args) {
	SumuOrderEnum sumuOrderEnum = new SumuOrderEnum();
	System.out.println(sumuOrderEnum.orderType1.getTypeCode()+"-"+sumuOrderEnum.orderType1.getType());
}
}

但是用枚举类就方便许多了:
OrderTypeEnum.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
/**
 *
 * @(#) OrderTypeEnum.java
 * @Package cn.lz.life.enums
 * 
 * Copyright  Icerno Corporation. All rights reserved.
 *
 */
package com.lz.enums;
/**
 * 定义枚举类;
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月20日@下午2:11:26
 */
public enum OrderTypeEnum {
    
	//声明枚举类的元素;
	ORDER_TYPE_IS_ZERO(0,"服务订单"),
	ORDER_TYPE_IS_ONE(1,"商品订单"),
	ORDER_TYPE_IS_TWO(2,"会员卡订单"),
	;
	//声明枚举类的属性，实际上是
    private int orderType;
	
	private String msg;
	public int getOrderType() {
		return orderType;
	}
	public void setOrderType(int orderType) {
		this.orderType = orderType;
	}
	public String getMsg() {
		return msg;
	}
	public void setMsg(String msg) {
		this.msg = msg;
	}
	private OrderTypeEnum(int orderType, String msg) {
		this.orderType = orderType;
		this.msg = msg;
	}
	
	
}

EnumTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.lz.enums;
/**
 * 枚举类的调用;
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月20日@下午2:12:01
 */
public class EnumTest {
public static void main(String[] args) {
	System.out.println(OrderTypeEnum.ORDER_TYPE_IS_ONE.getOrderType());
	System.out.println(OrderTypeEnum.ORDER_TYPE_IS_ONE.getMsg());
}
}

枚举类使用过程中因该注意的地方:
一：枚举类中必须定义构造方法;
二:枚举类中元素声明的类型必须和构造函数匹配,可以理解为元素的声明就是调用构造方法实例化了一个元素实例;
三:枚举类中属性可以没有，如果属性存在的话，枚举类中属性的名称可以随意，最好做到见名知意,但是其类型必须匹配构造函数中的类型;
四:元素的声明必须放在枚举类的首部;
五:枚举类的存在是为了简化常量的定义和使用;

展开全文 >>

SpringBoot+React前后端分离项目中跨域问题的完美解决方案

springboot+react前后端分离项目中，跨域问题必然存在，解决方案有三种类型:
1、前端解决：
在package.json中添加如下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{
  "name": "myproject1",
  "version": "0.1.0",
  "private": true,
  **"proxy": "http://localhost:9090",**
  "dependencies": {
    "antd": "^3.0.3",
    "fetch": "^1.1.0",
    "flux": "^3.1.3",
    "react": "^15.4.1",
    "react-addons-css-transition-group": "^15.6.2",
    "react-dom": "^15.4.1",
    "react-router": "^3.0.0",
    "react-scripts": "1.0.17"
  },
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test --env=jsdom",
    "eject": "react-scripts eject"
  },
  "devDependencies": {
    "reqwest": "^2.0.5"
  }
}

缺点：由于域名部分是固定的，无法解决跨多个网站请求资源的跨域;
2.后端解决方案:
2.1、参考文章；
2.2、原理:添加SpringMVC底层实现的Web配置适配器,增加CORS相关的配置信息;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.spring.boot.gp4zj.webconfig;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration
public class CORSConfiguration extends WebMvcConfigurerAdapter
{
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry
                .addMapping("/**")
                .allowedMethods("*")
                .allowedOrigins("*")
                .allowedHeaders("*");
    }
}

3.3、添加代理服务器,如nginx配置,前面讲过;

展开全文 >>

Des加密中错误Input length not multiple of 8 bytes的解决办法

1、最近在使用des加密的过程中出现了如下错误：
这里写图片描述
错误提示的意思是：输入的加密源数据不足8个字节,推测是加密的填充模式不对；
2、错误原因:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
DES、AES 或者 3DES 属于块加密算法，一般来说原文必须是 8 的整数倍，所以块加密算法除子加密模式之外，还涉及到一个填充模式。
如果一定要用 NoPadding 的话，那么必须保证原文字节是 8 的倍数，否则的话需要使用其他的填充模式。
在 Sun JCE 中默认的填充模式除了 NoPadding 之外，还有：
PKCS5Padding 和 ISO10126Padding
PKCS5Padding 的填充规则是：
填充至符合块大小的整数倍，填充值为填充数量数。例如：
原始：FF FF FF FF FF FF FF FF FF
填充：FF FF FF FF FF FF FF FF FF 07 07 07 07 07 07 07
ISO10126Padding 的填充规则是：
填充至符合块大小的整数倍，填充值最后一个字节为填充的数量数，其他字节随机处理。例如：
原始：FF FF FF FF FF FF FF FF FF
填充：FF FF FF FF FF FF FF FF FF 3F 7A B4 09 14 36 07
使用填充模式后原文字节并不需要是 8 的整数倍，采用填充模式之后，块加密的密文长度为：
(N / 8 * 8) + 8
如上，假如原文长度为 15 个字节，密文长度就是 16 个字节。假如原文长度为 16 个字节，密文长度就为 24 个字节。也就是说，采用填充模式后必须进行填充，哪怕是 8 的整数倍。

注意点:2.1使用哪一种填充模式加密的，也必须采用哪种填充模式解密;
2.2CBC 加密模式需要有一个 IV 参数（也就是初始化向量），这个值在加 密时会随机生成，但必须保存下来，否则无法完成解密工作。
2.3建议采用 ECB 模式，或者在使用 CBC 时将初始化向量保存，在解密时使用。

3、解决方案:

1
2
3
4
5
6
7
//算法名称/加密模式/填充方式 
    //DES共有四种工作模式-->>ECB：电子密码本模式、CBC：加密分组链接模式、CFB：加密反馈模式、OFB：输出反馈模式
    //此处应该注意加密模式的取值,建议使用ebc模式下的PKCS5Padding自动填充形式;
    [修改前的模式]
    //public static final String CIPHER_ALGORITHM = "DES/ECB/NoPadding";
    [修改后的模式]
    public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5Padding ";

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

最痛苦的事，<br><br>不是失败，<br><br>而是,我本可以!