发表于   |   更新于 | 分类于 >
字数统计: 5.4k字 | 阅读时长 ≈ 23分钟

Lambda表达式

为什么使用Lambda表达式

  • Lambda是一个匿名函数，相当于匿名内部类
  • 只有函数式接口(可以用@FunctionalInterface注解修饰) 可以使用Lambda表达式
  • 使用 Lambda省略了写实现类的繁琐步骤，可以写出更简洁、更灵活的代码，使Java的语言表达能力得到了提升。

Lambda表达式语法

Lambda 表达式在Java 语言中引入了一个新的操作符, “->”， 它将 Lambda 分为两个部分：
左侧：指定了 Lambda表达式的参数列表
右侧：指定了 Lambda体，即 Lambda表达式要执行的功能。

语法格式一：无参数，无返回值

1
() -> System.out.println("Hello Lambda!");

语法格式二：有一个参数，并且无返回值

1
(x) -> System.out.println(x);

语法格式三：若只有一个参数，小括号可以省略不写

1
x -> System.out.println(x)

语法格式四：有两个以上的参数，有返回值，并且 Lambda体中有多条语句

1
2
3
4
Comparator<Integer> com = (x, y) -> {
	System.out.println("函数式接口");
	return Integer.compare(x, y);
};

语法格式五：若 Lambda体中只有一条语句， return和大括号都可以省略不写

1
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

语法格式六：参数列表的数据类型可以省略不写

JVM编译器可以通过上下文推断出参数列表对应的数据类型，Lambda 表达式中无需指定类型，程序依然可以编译，即**“类型推断”**。

1
2
// Integer推荐省略
(Integer x, Integer y) -> Integer.compare(x, y);

语法速记口诀：
上联：左右遇一括号省
下联：左侧推断类型省
横批：能省则省

函数式接口

什么是函数式接口

  • 只包含一个抽象方法的接口，称为函数式接口。
  • 可以通过 Lambda 表达式来创建该接口的实现类。

函数式接口只会有一个抽象方法，default方法不属于抽象方法，接口重写了Object的公共方法也不算入内，所以Comparator是函数式接口。

Java内置函数式接口

四大核心接口

接口名 参数类型 返回类型 用途
Consumer<T> 消费型接口 T void void accept(T t);
适合“传递参数没有返回值”的场景
Supplier<T> 供给型接口 无 T T get();
适合“没有参数有返回值”的场景
Function<T,R> 函数型接口 T R R apply(T t);
适合“传递参数有返回值”的场景
Predicate<T> 断定型接口 T boolean boolean test(T t);
适合“传递参数返回boolean值”的场景

其他接口

接口名 参数类型 返回类型 用途
BiFunction<T, U, R> T, U R R apply(T t, U u);
适合“传递两个参数有返回值”的场景
UnaryOperator<T> (Function子接口) T T T apply(T t);
进行一元运算，适合“传递一个参数有返回值”的场景
BinaryOperator<T>(BiFunction 子接口) T, T T T apply(T t1, T t2);
进行二元运算，适合“传递两个参数有返回值”的场景
BiConsumer<T, U> T void void accept(T t, U u);
适合“传递两个参数没有返回值”的场景

方法引用、构造器引用、数组引用

方法引用

若Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用。
可以将方法引用理解 Lambda 表达式的另外一种表现形式。
使用操作符 “::” 将方法名和对象或类的名字分隔开来。
主要有下面三种使用情况：

  • 对象::实例方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 示例1
PrintStream ps = System.out;
Consumer<String> con = (str) -> ps.println(str);
con.accept("Hello World！");

Consumer<String> con2 = ps::println;
con2.accept("Hello Java8！");
// 示例2
Employee emp = new Employee(101, "张三", 18, 9999.99);
Supplier<String> sup = () -> emp.getName();
System.out.println(sup.get());

Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());
  • 类::静态方法
1
2
3
4
5
6
7
8
// 示例1
BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);
System.out.println(fun.apply(1.5, 22.2));
BiFunction<Double, Double, Double> fun2 = Math::max;
System.out.println(fun2.apply(1.2, 1.5));
// 示例2
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
Comparator<Integer> com2 = Integer::compare;
  • 类::实例方法
1
2
3
4
5
6
7
8
9
10
// 示例1
BiPredicate<String, String> bp = (x, y) -> x.equals(y);
System.out.println(bp.test("abcde", "abcde"));
BiPredicate<String, String> bp2 = String::equals;
System.out.println(bp2.test("abc", "abc"));
// 示例2
Function<Employee, String> fun = (e) -> e.show();
System.out.println(fun.apply(new Employee()));
Function<Employee, String> fun2 = Employee::show;
System.out.println(fun2.apply(new Employee()));

注意：

  • 方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致。
  • 若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

构造器引用

构造器的参数列表，需要与函数式接口中参数列表保持一致。
语法格式：
类名 :: new
示例：

1
Function<String, Employee> fun = Employee::new;

数组引用

语法格式：
类型[] :: new
示例：

1
2
3
4
5
6
Function<Integer, String[]> fun = (length) -> new String[length];
String[] strs = fun.apply(10);
System.out.println(strs.length);
Function<Integer, String[]> fun2 = String[]::new;
String[] strs2 = fun2.apply(15);
System.out.println(strs2.length);

强大的Stream API

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

什么是Stream

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
集合讲的是数据，流讲的是计算！

注意：

  • Stream 自己不会存储元素。
  • Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
  • Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream操作的三个步骤

在这里插入图片描述
Stream操作的三个步骤如下：

  • 创建 Stream
    一个数据源（如：集合、数组），获取一个流
  • 中间操作
    一个中间操作链，对数据源的数据进行处理
  • 终止操作(终端操作)
    一个终止操作，执行中间操作链，并产生结果

示例如下：

1
2
3
4
5
6
7
8
//所有的中间操作不会做任何的处理
Stream<Employee> stream = emps.stream()
	.filter((e) -> {
		System.out.println("测试中间操作");
		return e.getAge() <= 35;
	});
//只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
stream.forEach(System.out::println);

创建Stream

一、Java8 中的Collection接口被扩展，提供了两个获取流的方法：

  • default Stream stream() : 返回一个顺序流
  • default Stream parallelStream() : 返回一个并行流

示例代码如下：

1
2
3
4
//1、 Collection提供了两个方法  stream() 与 parallelStream()
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

二、由数组创建流
Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
static Stream stream(T[] array): 返回一个流。

示例代码如下：

1
2
3
//2、 通过 Arrays 中的 stream() 获取一个数组流
Integer[] nums = new Integer[10];
Stream<Integer> stream1 = Arrays.stream(nums);

三、用静态方法Stream.of()
可以使用静态方法 Stream.of(), 创建一个流。它可以接收任意数量的参数。
public static Stream of(T… values) : 返回一个流。
示例代码如下：

1
2
//3、通过 Stream 类中静态方法 of()
Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);

四、创建无限流
示例代码：

1
2
3
4
5
6
//迭代
Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
stream3.forEach(System.out::println);
//生成
Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
stream4.forEach(System.out::println);

中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为**“惰性求值”**。

筛选与切片

常用方法如下：

方法 描述
filter(Predicate p) 过滤： 接收 Lambda ， 从流中排除某些元素。
limit(long maxSize) 截断流： 使其元素不超过给定数量。
skip(long n) 跳过元素： 返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。
与 limit(n) 互补
distinct() 去重： 通过流所生成元素的hashCode()和equals()去除重复元素

示例代码如下：

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
// 1、filter过滤
//所有的中间操作不会做任何的处理
Stream<Employee> stream = emps.stream()
	.filter((e) -> {
		System.out.println("测试中间操作");
		return e.getAge() <= 35;
	});
//只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
stream.forEach(System.out::println);
// 2、limit截断流
emps.stream()
	.filter((e) -> {
		System.out.println("短路！"); // &&  ||
		return e.getSalary() >= 5000;
	})
	.limit(3)
	.forEach(System.out::println);
// 3、skip跳过元素
emps.parallelStream()
	.filter((e) -> e.getSalary() >= 5000)
	.skip(2)
	.forEach(System.out::println);
// 4、distinct去重
emps.stream()
	.distinct()
	.forEach(System.out::println);

映射

常用方法如下：

方法 描述
map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。
mapToInt(ToIntFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。
mapToLong(ToLongFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStream。
flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

示例代码如下：

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
public static void main(String[] args) {
     List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
     // 1、map简单使用
     Stream<String> stream = strList.stream()
             .map(String::toUpperCase);
     stream.forEach(System.out::println);

     Stream<Stream<Character>> stream2 = strList.stream()
             .map(Test::filterCharacter);
     // 输出aaabbbcccdddeeeaaabbbcccdddeee
     stream2.forEach((sm) -> {
         sm.forEach(System.out::print);
     });

     // 2、flatMap使用：相当于List的addAll()
     Stream<Character> stream3 = strList.stream()
             .flatMap(Test::filterCharacter);
     // 输出aaabbbcccdddeeeaaabbbcccdddeee
     stream3.forEach(System.out::print);
 }

// 把字符串中的每一个字符加入到list，返回流
 public static Stream<Character> filterCharacter(String str){
     List<Character> list = new ArrayList<>();
     for (Character ch : str.toCharArray()) {
         list.add(ch);
     }
     return list.stream();
 }

排序

常用方法如下：

方法 描述
sorted() 产生一个新流，按自然顺序排序。
sorted(Comparator comp) 产生一个新流，按比较器顺序排序。

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 自然排序
emps.stream()
	.map(Employee::getName)
	.sorted()
	.forEach(System.out::println);
// 定制排序
emps.stream()
	.sorted((x, y) -> {
		if(x.getAge() == y.getAge()){
			return x.getName().compareTo(y.getName());
		}else{
			return Integer.compare(x.getAge(), y.getAge());
		}
	}).forEach(System.out::println);

终止操作(终端操作)

注意：
流进行了终止操作后，不能再次使用。

查找与匹配

常用方法如下：

方法 描述
allMatch(Predicate p) 检查是否匹配所有元素
anyMatch(Predicate p) 检查是否至少匹配一个元素
noneMatch(Predicate p) 检查是否没有匹配所有元素
findFirst() 返回第一个元素
findAny() 返回当前流中的任意元素

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
boolean bl = emps.stream()
	.allMatch((e) -> e.getStatus().equals(Status.BUSY));

boolean bl1 = emps.stream()
	.anyMatch((e) -> e.getStatus().equals(Status.BUSY));

boolean bl2 = emps.stream()
	.noneMatch((e) -> e.getStatus().equals(Status.BUSY));

Optional<Employee> op = emps.stream()
	.sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
	.findFirst();
System.out.println(op.get());

Optional<Employee> op2 = emps.parallelStream()
	.filter((e) -> e.getStatus().equals(Status.FREE))
	.findAny();
System.out.println(op2.get());

内部迭代

方法 描述
forEach(Consumer c) 内部迭代

最值、数量

方法 描述
count() 返回流中元素总数
max(Comparator c) 返回流中最大值
min(Comparator c) 返回流中最小值

示例代码如下：

1
2
3
4
5
6
7
8
9
10
long count = emps.stream()
				 .filter((e) -> e.getStatus().equals(Status.FREE))
				 .count();

Optional<Double> op = emps.stream()
	.map(Employee::getSalary)
	.max(Double::compare);

Optional<Employee> op2 = emps.stream()
	.min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));

归约

方法 描述
reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。
返回 T。
reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。
返回Optional

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer sum = list.stream()
	.reduce(0, (x, y) -> x + y);
System.out.println(sum);

Optional<Double> op = emps.stream()
	.map(Employee::getSalary)
	.reduce(Double::sum);
System.out.println(op.get());

// 搜索名字中 “六” 出现的次数
Optional<Integer> sum = emps.stream()
	.map(Employee::getName)
	.flatMap(Test::filterCharacter)
	.map((ch) -> {
		if(ch.equals('六'))
			return 1;
		else 
			return 0;
	}).reduce(Integer::sum);
System.out.println(sum.get());

收集

方法 描述
collect(Collector c) 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
在这里插入图片描述
在这里插入图片描述

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
List<DeptInfoVo> deptInfoVoList = getDeptInfoVoData();
Set<String> set = deptInfoVoList.stream()
        .map(DeptInfoVo::getDeptName)
        .collect(Collectors.toSet());

HashSet<String> hashSet = deptInfoVoList.stream()
        .map(DeptInfoVo::getDeptName)
        .collect(Collectors.toCollection(HashSet::new));

// 分组
Map<Status, List<Employee>> map = emps.stream()
.collect(Collectors.groupingBy(Employee::getStatus));

// 多级分组
Map<Status, Map<String, List<Employee>>> map = emps.stream()
			.collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
				if(e.getAge() >= 60)
					return "老年";
				else if(e.getAge() >= 35)
					return "中年";
				else
					return "成年";
			})));

接口中的默认方法与静态方法

默认方法

Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default关键字修饰。

接口默认方法的类优先原则：
一个子类继承了一个父类，同时实现了一个接口。这个父类和接口有同名(默认)的方法，则字类调用方法会优先调用父类的方法。
示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ParentClass {
    public String getName(){
        return "嘿嘿嘿";
    }
}

public interface MyInterface {
    default String getName(){
        return "哈哈哈哈";
    }
}

public class SubClass extends ParentClass  {
    
}

public class Test {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        // 输出：嘿嘿嘿
        System.out.println(subClass.getName());
    }
 }

当然，如果子类再重写方法的话，以子类的为准。

接口默认方法冲突的解决方法：
如果一个父接口提供一个方法，而另一个父接口接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须重写该方法来解决冲突。
示例代码如下：

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
public interface MyInterface {
    default String getName(){
        return "嘿嘿嘿嘿";
    }
}
public interface MyInterfaceTwo {
    default String getName(){
        return "哈哈哈哈";
    }
}
public class SubClass implements MyInterface,MyInterfaceTwo {
    // 必须重写该方法
    @Override
    public String getName() {
        // return MyInterface.super.getName();
        return "我是子类重写的方法";
    }
}
public class Test {
    public static void main(String[] args) {
        SubClass subClass = new SubClass();
        // 输出：我是子类重写的方法
        System.out.println(subClass.getName());
    }
 }

Java中Super的用法

静态方法

Java8接口中允许添加静态方法。
示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
public interface MyInterface {
    static String getName(){
        return "我是静态方法";
    }
}
public class Test {
    public static void main(String[] args) {
    	//输出：我是静态方法
        System.out.println(MyInterface.getName());
    }
  }

新时间日期API

简介

SimpleDateFormat有线程安全问题,且Date类不好用。
Java8提供了LocalDate、LocalTime和LocalDateTime 类，它们的实例是不可变的对象，做任何操作都会新生成一个对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

注：ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法
相关方法如下：
在这里插入图片描述
示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
System.out.println(ldt.getYear());
System.out.println(ldt.getMonthValue());
System.out.println(ldt.getDayOfMonth());
System.out.println(ldt.getHour());
System.out.println(ldt.getMinute());
System.out.println(ldt.getSecond());

LocalDateTime ld2 = LocalDateTime.of(2016, 11, 21, 10, 10, 10);
System.out.println(ld2);

LocalDateTime ldt3 = ld2.plusYears(20);
System.out.println(ldt3);

LocalDateTime ldt4 = ld2.minusMonths(2);
System.out.println(ldt4);

Instant时间戳

Instant用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的毫秒数进行运算。
示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 默认使用 UTC 时区
Instant ins = Instant.now();
System.out.println(ins);

// 使用东8区
OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));
System.out.println(odt);
// 获取毫秒数
System.out.println(ins.toEpochMilli());

// 1970元年之后5秒
Instant ins2 = Instant.ofEpochSecond(5);
System.out.println(ins2);

Duration和Period

1、Duration: 用于计算两个“时间”间隔
2、Period:用于计算两个“日期”间隔

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Instant ins1 = Instant.now();
try {
	Thread.sleep(1000);
} catch (InterruptedException e) {
}
Instant ins2 = Instant.now();
System.out.println("所耗费时间为：" + Duration.between(ins1, ins2));

LocalDate ld1 = LocalDate.now();
LocalDate ld2 = LocalDate.of(2011, 1, 1);
Period pe = Period.between(ld2, ld1);
System.out.println(pe.getYears());
System.out.println(pe.getMonths());
System.out.println(pe.getDays());

时间校正器

  • TemporalAdjuster : 时间校正器。有时我们可能需要获
    取例如：将日期调整到“下个周日”等操作。
  • TemporalAdjusters: 该类通过静态方法提供了大量的常
    用 TemporalAdjuster 的实现。

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);
// 获取下一个星期天
LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
System.out.println(ldt3);

//自定义：下一个工作日
LocalDateTime ldt5 = ldt.with((l) -> {
	LocalDateTime ldt4 = (LocalDateTime) l;
	DayOfWeek dow = ldt4.getDayOfWeek();
	if(dow.equals(DayOfWeek.FRIDAY)){
		return ldt4.plusDays(3);
	}else if(dow.equals(DayOfWeek.SATURDAY)){
		return ldt4.plusDays(2);
	}else{
		return ldt4.plusDays(1);
	}
});
System.out.println(ldt5);

解析和格式化日期或时间

示例代码如下：

1
2
3
4
5
6
7
//DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");
LocalDateTime ldt = LocalDateTime.now();
String strDate = ldt.format(dtf);
System.out.println(strDate);
LocalDateTime newLdt = ldt.parse(strDate, dtf);
System.out.println(newLdt);

带时区的时间或日期

Java8 中加入了对时区的支持，带时区的时间为分别为：ZonedDate、ZonedTime、ZonedDateTime。其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式，
例如 ：Asia/Shanghai。

示例代码如下：

1
2
3
4
5
LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
System.out.println(ldt);

ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));
System.out.println(zdt);

与传统日期处理的转换

相关方法如下：
在这里插入图片描述

Optional类

Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
常用方法如下：

方法 描述
Optional.of(T t) 创建一个 Optional实例
Optional.empty() 创建一个空的 Optional实例
Optional.ofNullable(T t) 若 t 不为 null,创建 Optional 实例,否则创建空实例。相当于Optional.of(T t)+Optional.empty()
isPresent() 判断是否包含值
orElse(T t) 如果调用对象包含值，返回该值，否则返回t
orElseGet(Supplier s) 如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f) 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
flatMap(Function mapper) 与 map 类似，要求返回值必须是Optional

JVM的新特性

使用元空间Metaspace代替持久代PermGen space。
在JVM参数方面，使用-XX:MetaSpaceSize和-XX:MaxMetaspaceSize代替原来的-XX:PermSize和-XX:MaxPermSize。

优化HashMap

从 “数组+链表” 数据结构改为了 “数组+（链表/红黑树）”。
当链表长度大于8，且HashMap总容量大于64，会将链表自动转为红黑树。
添加元素比链表慢，其他的都比链表更快速。

重复注解

Java8允许在同一声明类型（类，属性，或方法）的多次使用同一个注解,这就是重复注解。Java8开始注解可以应用在任何地方。
Java8之前对重复注解的支持
示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
public @interface Authority {
     String role();
}
public @interface Authorities {
    Authority[] value();
}

public class RepeatAnnotationUseOldVersion {

    @Authorities({@Authority(role="Admin"),@Authority(role="Manager")})
    public void doSomeThing(){
    }
}

Java8之前，重复注解实现是由另一个注解来存储重复注解。
在使用时候，用存储注解Authorities来扩展重复注解。
很明显，这种方式可读性不是很好。

Java8对重复注解的支持
示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Repeatable(Authorities.class)
public @interface Authority {
    String role();
}
public @interface Authorities {
   Authority[] value();
}

public class RepeatAnnotationUseNewVersion {
   @Authority(role="Admin")
   @Authority(role="Manager")
   public void doSomeThing(){ }
}

不同的地方是，创建重复注解Authority时，加上@Repeatable,指向存储注解Authorities。
在使用时候，直接可以重复使用Authority注解。
从上面例子看出，java 8里面做法更适合常规的思维，可读性强一点。

说明：本笔记整理自尚硅谷Java8新特性课程以及互联网，仅供学习使用。

发表于   |   更新于 | 分类于 >
字数统计: 2.2k字 | 阅读时长 ≈ 8分钟

入门

开始和结束

正则表达式中 ^ 指定的是一个字符串的开始，$ 指定的是一个字符串的结束。
例如，
匹配以p开头的python字符串:
在这里插入图片描述
匹配以n结尾的python字符串:
在这里插入图片描述

阅读全文 »

发表于 | 分类于 >
字数统计: 2.2k字 | 阅读时长 ≈ 9分钟

作为码农平时搜集一些小知识点个人认为是个不错的习惯，书上说

好记性不如烂笔头

我想即使是以前忽略或者新get的很简单的东西，自己动手记下来不管如何印象也会更深刻。

synchronized锁定的对象

synchronized修饰的作用：
让多个线程排队依次获取某个资源，保证数据不会出错(原子性)。
synchronized锁定的元素:

  • 修饰方法
    • 静态方法，锁定的是类
    • 普通方法，锁定的时方法的调用者
  • 修饰代码块，锁定的时传入的对象

Java线程内存模型(JMM)定义的8中原子操作

  • read(读取)：从主内存中读取数据
  • load(载入)：将主内存读取到的数据写入工作内存
  • use(使用)：从工作内存读取数据来计算
  • assgin(赋值)：将计算好的值重新赋值到工作内存中
  • store(存储)：将工作内存数据写入主内存，会经过总线，到总线后就开始广播其他线程
  • write(写入)：将store过去的变量值赋值给主内存中的变量
  • lock(锁定)：将主内存变量加锁，标识为线程独占状态
  • unlock(解锁)：将主内存变量解锁，解锁后其他线程可以锁定该变量
    MESI缓存一致性协议：
    多个cpu从主内存读取同一个数据到各自的高速缓存，当其中某个cpu修改了缓存里的数据，该数据会马上同步回主内存，其他cpu通过总线嗅探机制可以感知到数据的变化从而将自己缓存里的数据失效。
    一般lock锁加在线程的赋值之后，存储之前，这样的锁的粒度不大。volatile保证数据可见性、synchronized保证原子性。

MySQL分区学习

参考链接、参考链接、参考链接

根据hash中的键模糊删除

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
/**
 * 根据hash中的键模糊删除
 * @param key key redis的key
 * @param item item hash的键
 */
public  void removeHashItem(String key, String item){

	ArrayList<String> items = new ArrayList<>();
	// 模糊查询出准确的item
	redisTemplate.execute(new RedisCallback() {
		@Override
		public Object doInRedis(RedisConnection connection) throws DataAccessException {
			Cursor<Map.Entry<byte[], byte[]>> entryCursor = connection.hScan(key.getBytes(), ScanOptions.scanOptions().match("*" + item + "*").count(1800).build());
			while(entryCursor.hasNext()){
				Map.Entry<byte[], byte[]> next = entryCursor.next();
				String key = new String(next.getKey());
				// 将查询出的item放入list
				items.add(key);
			}
			connection.close();
			return null;
		}
	});
	// 批量删除对应key中的item
	for (String str: items){
		redisTemplate.opsForHash().delete(key, str);
	}
}

union和ordery by一起使用报"Incorrect usage of UNION and ORDER BY"错误的解决方法

原因

每条字句都使用order by会报错。

解决方法

方法一：只在最后一条字句使用order by，意思是对整个结果集进行order by
参考代码如下：

1
2
3
4
select * from t1 where username like 'l%'
union
select * from t1 where username like '%m%'
order by score asc

方法二：union后整体改为临时表
参考代码如下：

1
2
3
4
5
select * from 
(select * from t1 where username like 'l%'
union
select * from t1 where username like '%m%')tmp
order by tmp.score asc

方法三：每一层都改为临时表再union

1
2
3
4
select * from (select * from t1 where username like 'l%') t1
union
select * from (select * from t1 where username like '%m%') t2
order by score asc

参考链接

Spring Cloud Config多服务共享公共配置

参考代码：

1
2
3
4
5
6
7
8
9
10
11
spring:
  application:
    name: innovation
  cloud:
    config:
      name: reward-innovation-v1,common
      profile: test
      uri: http://10.12.7.124:8888
      failFast: true
      enabled: true
  main.allow-bean-definition-overriding: true

该代码读取配置中心的common-test.yml和reward-innovation-v1-test.yml文件

参考链接

解决SpringBoot启动报错：NoClassDefFoundError: org/springframework/data/redis/connection/RedisStreamCommands

查重管理的时候，在测试环境碰到一模一样的问题。

参考链接

查看Java进程当前使用的JVM参数

1、jps命令查看当前进程id

1
2
3
4
[award_dev@localhost reward_taskjob]$ jps -l
32496 reward-taskjob-202209151113-SNAPSHOT.jar
4931 award-webbas-config-2022-08-29-122959.jar
3187 reward-innovation-202209172040-SNAPSHOT.jar

2、jinfo -flags 进程id 命令查看当前进程使用的JVM参数

1
2
3
4
5
6
7
[award_dev@localhost reward_taskjob]$ jinfo -flags 32496
Attaching to process ID 32496, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.121-b13
Non-default VM flags: -XX:CICompilerCount=12 -XX:ConcGCThreads=3 -XX:G1HeapRegionSize=1048576 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=null -XX:InitialHeapSize=1289748480 -XX:MarkStackSize=4194304 -XX:MaxHeapSize=2147483648 -XX:MaxNewSize=1287651328 -XX:MinHeapDeltaBytes=1048576 -XX:+PrintGC -XX:+PrintGCDateStamps -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintHeapAtGC -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:+UseFastUnorderedTimeStamps -XX:+UseG1GC
Command line:  -Dlog4j2.formatMsgNoLookups=true -DENV_CONFIG_IP=10.12.7.181 -DENV_CONFIG_PORT=9888 -DENV_TYPE=dev -Dname=reward-taskjob-202209151113-SNAPSHOT.jar -Djava.awt.headless=true -Djava.net.preferIPv4Stack=true -Duser.timezone=Asia/Shanghai -Djava.io.tmpdir=/opt/aspire/product/award_dev/reward_taskjob/data/tmp -Xms1230m -Xmx2g -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=./logs/java_heapdump.hprof -XX:+PrintGCDateStamps -Xloggc:/opt/aspire/product/award_dev/reward_taskjob/logs/gclog/gc-reward-taskjob-202209151113-SNAPSHOT.jar-20220919102315.log -XX:+PrintGCDetails -XX:+PrintHeapAtGC -XX:+UseG1GC

RestTemplate使用Ribbon实现负载均衡的调用

1
2
3
4
5
@Bean
@LoadBalanced
RestTemplate restTemplate(){
	return new RestTemplate();
}

直接通过服务名调用，Eureka会去找。

1
restTemplate.postForObject("http://webbas32-manage-v1/web/login/findemployeebyphone", formEntity, String.class);

其中webbas32-manage-v1为接口提供方的服务名
调用方的Eureka配置需要添加，fetchRegistry: true //表示可以从Eureka Server获取注册的服务信息

RestTemplate.postForObject泛型丢失(返回LinkedHashMap)的问题解决方法

问题：
在这里插入图片描述
如上图所示，data类型本应该为MemberInfoVo，但是泛型丢失变为LinkedHashMap。

解决方法：
参考代码如下：

1
2
3
ParameterizedTypeReference<ResponseMsg<MemberInfoVo>> typeRef = new ParameterizedTypeReference<ResponseMsg<MemberInfoVo>>() {};
ResponseEntity<ResponseMsg<MemberInfoVo>> result = restTemplate.exchange(findEmployeeUrl, HttpMethod.POST, formEntity, typeRef);
ResponseMsg<MemberInfoVo> responseMsg = result.getBody();

成功效果：
在这里插入图片描述
参考链接

MyBatis批量更新

参考链接

Spring Cloud Eureka自我保护机制

参考链接

Spring Cloud Eureka控制台相关配置参数学习

参考链接

SpringBoot配置默认sql级别info、sql打印级别为debug

SpringBoot的默认使用的日志框架为logback，且默认的日志级别均为INFO。
为了打印sql日志信息，我们只需把对应dao层包下的日志级别改为DEBUG。

示例代码如下：

1
2
3
4
5
6
7
8
9
10
# log  
logging:
  config: classpath:log4j2-dev.xml
  level:
    root: info
	# dao层包下的日志级别修改
    com:
      aspirecn:
        rewardmanagement:
          mapper: debug

参考链接

IDEA解决完所有冲突但是分支还是在Merging状态的解决方法

1、通过git status命令查看信息(关键)：
All conflicts fixed but you are still merging(use “git commit” to conclude merge)
2、根据第一步的信息提示做操作
示例操作如下：

1
2
git add -A
git commit -m '合并master'

参考链接

SpringBoot中使用@Value读取配置文件中的list、map

配置文件代码：

1
2
myList: item1,item2,item3
myMap: "{key1: 'value1', key2: 'value2'}"

Java代码：

1
2
3
4
5
@Value("#{'${myList}'.split(',')}")
private List<String> myList;
 
@Value("#{${myMap}}")  
private Map<String,String> myMap;

注意：
上面的list配置中，一定不要用""把list所有的成员value包起来，要不然解析报错。
上面的map配置中，一定要用"" 把map所对应的value包起来，要不然解析解析报错。

参考链接

SpringBoot中多个@ControllerAdvice全局异常处理

多个ControllerAdvice，优先级由@Order决定，order的数值越小 则优先级越高。

1
2
3
4
5
6
7
8
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;

@ControllerAdvice
@Order(Ordered.HIGHEST_PRECEDENCE)
public class MsControllerAdvice {

}

注意：@ControllerAdvice只能对controller抛出的异常处理

多个@ControllerAdvice全局异常处理(含多个实用场景)、
@ControllerAdvice优先级设定

SpringCloud zuul路由手动配置

示例代码：

1
2
3
4
5
6
7
8
zuul:
  routes:
    api-a:
      path: /api-a/**
      serviceId: service-ribbon
    api-b:
      path: /api-b/**
      serviceId: service-feign

zuul路由配置说明：api-a、api-b是路由名称可以随便取，serviceId是服务的id(对应spring.application.name)。
上面配置表示，以/api-a/ 开头的请求都转发给service-ribbon服务；以/api-b/开头的请求都转发给service-feign服务。

SpringCloud zuul的路由默认自动配置

zuul可以自动根据Eureka服务器中所注册的服务自动完成路由映射、负载均衡。
在Eureka上注册了两个服务：
1、服务名management，端口18081
2、服务名gateway，端口7001
请求路径，127.0.0.1:7001/management/addressBook/getList，网关zuul会把请求转发给management服务，
实际请求路径127.0.0.1:18081/addressBook/getList

参考链接

dependencyManagement标签的作用

在Maven中dependencyManagement的作用其实相当于一个对所依赖jar包进行版本管理的管理器。
jar的版本判断的两种途径：

  • 如果dependencies里的dependency自己没有声明version元素，那么maven就会到dependencyManagement里面去找有没有对该artifactId和groupId进行过版本声明。如果有，就继承它，如果没有就会报错，告诉你必须为dependency声明一个version。
  • 如果dependencies中的dependency声明了version，那么无论dependencyManagement中有无对该jar的version声明，都以dependency里的version为准。

示例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!--只是对版本进行管理，不会实际引入jar  -->
<dependencyManagement>  
      <dependencies>  
            <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-core</artifactId>  
                <version>3.2.7</version>  
            </dependency>  
    </dependencies>  
</dependencyManagement>  
  
<!--会实际下载jar包  --> 
<dependencies>  
       <dependency>  
                <groupId>org.springframework</groupId>  
                <artifactId>spring-core</artifactId>  
       </dependency>  
</dependencies>

参考链接

发表于 | 分类于 >
字数统计: 1.7k字 | 阅读时长 ≈ 6分钟

VirtualBox的7种网络接入模式详解

参考链接、参考链接

各网络模式的默认情况下，网络连接情况

NAT模式 桥接模式 Host-Only模式
虚拟机 -> 宿主机 √ √ 默认不能，需要设置
宿主机 ——> 虚拟机 x √ 默认不能，需要设置
虚拟机 ——> 虚拟机 x √ √
虚拟机 ——> 同局域网下其他主机 √ √ 默认不能，需要设置
同局域网下其他主机 ——> 虚拟机 x √ 默认不能，需要设置

参考链接

配置网络地址转换(NAT)模式

NAT模式下，宿主机访问虚拟机，虚拟机可以访问宿主机，虚拟机可以访问互联网。

访问外网

选择对应虚拟机 -> 设置 -> 网络 -> 选择连接方式为NAT -> 选择控制芯片
在这里插入图片描述
这样配置以后，启动虚拟机，执行ping www.baidu.com有响应说明配置成功。如果没有响应换一个控制芯片试试，上图框红的两个控制芯片是可以的。

宿主机访问虚拟机

配置步骤如下：
选择对应虚拟机 -> 设置 -> 网络 -> 端口转发(主机为222,子系统为22,其他不用填)
在这里插入图片描述
配置完重启虚拟机后，宿主机访问虚拟机连接如下：
在这里插入图片描述
注意，这种模式文件传输非常慢，本地上传一个10多KB的文件到虚拟机花费差不多2分钟。

配置桥接模式

桥接模式下，虚拟机和宿主机在同一网段，虚拟机可以访问外网，宿主机可以访问虚拟机，虚拟机可以访问宿主机同一局域网的其他机器。具体配置步骤如下所示：

网络连接方式设置

在这里插入图片描述
这里的MAC地址和网卡配置文件的HWADDR一致，否则会重启网络服务失败。
确定界面名称是网络的适配器，一般默认的没问题。
在这里插入图片描述
配置完桥接模式，启动虚拟机，网络就是通的，只是IP不固定。

修改网卡配置文件

这一步的目的是固定虚拟机的IP地址。
先查看宿主机的网络信息：
在这里插入图片描述
修改虚拟机的网卡配置文件：

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
TYPE=Ethernet
PROXY_METHOD=none
BROWSER_ONLY=no
# 改为静态
BOOTPROTO=static
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=no
IPV6_ADDR_GEN_MODE=stable-privacy
# 和ifcfg-enpXXX名一致
NAME=enp0s3
# 可以不写，但是写了就不能和其他网卡相同。可以用uuidgen命令生成。
UUID=40263cbd-6ed4-497c-9321-7326e27d4a29
# 和ifcfg-enpXXX名一致
DEVICE=enp0s3
# 改为yes，即开机
ONBOOT=yes
# 和宿主机在同一网段不同ip
IPADDR=10.1.18.156
# 和宿主机保持一致，否则会重启失败
NETMASK=255.255.255.0
# 和宿主机保持一致，否则会重启失败
GATEWAY=10.1.18.1
# 可以注销，不然得写正确，否则会重启失败
HWADDR=08:00:27:CB:CB:8E
# 不要写宿主机的字符串！可以网上查一个服务器，下面用的Google的DNS服务器
DNS1=8.8.8.8

测试网络

配置正常后，直接ping www.baidu.com就可以联通了。宿主机访问虚拟机，连接方式如下：
在这里插入图片描述

参考链接、参考链接

NAT+HostOnly模式组合

设置主机网络管理器

在这里插入图片描述
在这里插入图片描述
这个是VirtualBox的默认设置，不是这个可以改为这个，后续配置文件就不需要改了。

网络连接方式设置

在这里插入图片描述
在这里插入图片描述
设置好后，启动虚拟机。

虚拟机网卡配置文件修改

Nat模式启动虚拟机就可以访问外网，直接ping www.baidu.com是可以连通的。

修改默认网卡配置文件(NAT)

先用ip route命令查看网卡配置文件，如下可以看到默认配置文件是/etc/sysconfig/network-scripts/ifcfg-enp0s17,如果该配置文件命名不一致需要修改，并修改里面内容的名称。

1
2
3
4
[root@localhost ~]# ip route
default via 10.0.2.2 dev enp0s17 proto dhcp metric 101
10.0.2.0/24 dev enp0s17 proto kernel scope link src 10.0.2.15 metric 101
192.168.56.0/24 dev enp0s8 proto kernel scope link src 192.168.56.102 metric 100

然后修改"ONBOOT=yes",修改后配置文件如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
TYPE=Ethernet
PROXY_METHOD=none
BROWSER_ONLY=no
BOOTPROTO=dhcp
DEFROUTE=yes
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=no
IPV6_ADDR_GEN_MODE=stable-privacy
NAME=enp0s17
UUID=2f3b7238-96e2-4aa2-9a78-17270e4b8f5d
DEVICE=enp0s17
# 设置为yes
ONBOOT=yes

修改网卡2配置文件(HostOnly)

网卡2为HostOnly网络连接模式的配置文件，需要设置为静态ip，修改后的配置文件如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
TYPE="Ethernet"
PROXY_METHOD="none"
BROWSER_ONLY="no"
# BOOTPROTO改为static，意为静态模式
BOOTPROTO="static"
DEFROUTE="yes"
IPV4_FAILURE_FATAL="no"
IPV6INIT="yes"
IPV6_AUTOCONF="yes"
IPV6_DEFROUTE="yes"
IPV6_FAILURE_FATAL="no"
IPV6_ADDR_GEN_MODE="stable-privacy"
# NAME改为enp0s8，和文件名称后缀ifcfg-xxx保持一致。和ip route中的网卡2后缀一致。
NAME="enp0s8"
# 可以不写，但是写了就不能和其他网卡相同。可以用uuidgen命令生成。
UUID="87a8c150-3d1a-4111-97aa-816692dcf504"
# DEVICE改为enp0s8，和文件名称后缀ifcfg-xxx保持一致。和ip route中的网卡2后缀一致。
DEVICE="enp0s8"
ONBOOT="yes"
# IPADDR需要在指定的IP范围内（可以在VirtualBox主机网络配置管理器DHCP服务器中查看）
IPADDR=192.168.56.102
# NETMASK也和指定的服务器子网掩码一致（可以在VirtualBox主机网络配置管理器DHCP服务器中查看）
NETMASK=255.255.255.0

宿主机通过静态ip(HostOnly方式)访问虚拟机

在这里插入图片描述
经测试，这种模式文件传输非常快。

NAT+HostOnly模式与桥接模式不同的是，IPADDR、网关的配置。

  • NAT+HostOnly模式不用配置网关，IPADDR参考的是VirtualBox主机网络配置
  • 桥接模式要配置网关，IPADDR参考的是config/all命令返回的配置

参考链接

碰到问题

使用service network restart命令失败，要么配置文件问题(确定配置文件名和路由一致)，要么网卡没选对。

1
2
3
4
[root@localhost ~]# ip route
default via 10.0.2.2 dev enp0s17 proto dhcp metric 101
10.0.2.0/24 dev enp0s17 proto kernel scope link src 10.0.2.15 metric 101
192.168.56.0/24 dev enp0s8 proto kernel scope link src 192.168.56.101 metric 100

ip route命令输出enp0s17 ，即网卡配置文件为/etc/sysconfig/network-scripts/ifcfg-enp0s17。如果该配置文件命名不一致需要修改，并修改里面内容的名称。

注意enp0s9不等于enp0s09,配置文件名多个0也会启动失败！

Job for network.service failed. See ‘systemctl status network.service’ and 'journalctl -xn’问题的解决方法(含重启网络管理相关命令)

参考链接、参考链接

ip route没有显示路由信息，检查下网络管理有没有开启

执行下面两个命令如下：

1
2
chkconfig NetworkManager on
service NetworkManager start

桥接模式下，无法访问外网

防火墙开启是不影响的，检查下DNS服务器。

发表于 | 分类于 >
字数统计: 591字 | 阅读时长 ≈ 2分钟

Jenkins构建项目的几种方式

参考简书很有用的一篇文章

Jenkins简单的PipeLine流水线脚本

Windows：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
pipeline {
	agent any
	stages {
		stage('Pull code') {
			steps {
				checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: '4f77bfb0-49cc-4359-9b4a-99b190e5c92b', url: 'https://gitee.com/chuenhung/export-java-bean.git']]])
			}
		}
		stage('Build project') {
			steps {
				bat "mvn clean package"
				archiveArtifacts '**/target/*.jar'
			}
		}
	}
}

Linux：

1
把bat改为sh

注意：pipeline、stages、stage、steps、checkout…这些词不能改

构建遇到问题：java.lang.NoSuchMethodError: No such DSL method ‘pipeline’ found among steps [bat, build, checkout, container, containerLog, input, junit, library, libraryResource, load, milestone, node, parallel, podTemplate, powershell, properties
解决方法：成功安装PipeLine插件。

Jenkins项目构建细节(定时构建、参数化构建等)

参考链接

Jenkins远程部署Jar包(非流水线方式)

安装Publish Over SSH 插件

在这里插入图片描述

配置Publish Over SSH

点击Manage Jenkins->Configure System
在这里插入图片描述
找到Publish over SSH->修改用户密码
在这里插入图片描述
在这里插入图片描述

填写服务名、服务器ip、用户名、服务器文件夹等信息
!
填写完成后，点击Test Configuration 返回Success说明配置没问题。

项目构建配置

在对应构建的项目配置中(非PipeLine)，Post Steps选择Send files or execute commands over SSH
在这里插入图片描述
填写下面的配置：
其中，Remote directory是在之前的 Publish over SSH配置追加。比如之前配置了/usr/local/testJenkins/，这里填写/test/upload，最终上传的路径就会变成/usr/local/testJenkins/test/upload
在这里插入图片描述
最后，重新构建，看日志等着构建成功就好。这里传输如果文件过大速度会比较慢。
参考链接1、参考链接2

Jenkins远程部署Jar包(流水线方式)

测试通过的脚本如下：

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
def CONFIG_NAME = "LocalCentos" // SSH Server配置的名字
def SOURCE_FILES = "**/target/*.jar"
def REMOTE_DIRECTORY = "" //追加SSH Server配置的目录
def REMOVE_PREFIX = "/target"

pipeline {
	agent any
	stages {
		stage('Pull code') {
			steps {
				checkout([$class: 'GitSCM', branches: [[name: '*/master']], extensions: [], userRemoteConfigs: [[credentialsId: '4f77bfb0-49cc-4359-9b4a-99b190e5c92b', url: 'https://gitee.com/chuenhung/export-java-bean.git']]])
			}
		}
		stage('Build project') {
			steps {
				bat "mvn clean package"
				archiveArtifacts '**/target/*.jar'
			}
		}
		stage('Deploy project') {
			steps {
				sshPublisher(
					failOnError: false,
					publishers: [
						sshPublisherDesc(
							configName: "${CONFIG_NAME}",
							transfers: [
								sshTransfer(
									sourceFiles: "${SOURCE_FILES}",
									remoteDirectory: "${REMOTE_DIRECTORY}",
									removePrefix: "",
									flatten: true,
									execCommand: "",//上传后执行的脚本
									execTimeout: 1800000//执行脚本超时时间
								)
							],
							sshRetry: [
								retries: 0  //重试次数
							]
						   )
						]
					)
			}
		}
	}
}

参考链接