SpringBoot 简单特性

2018-01-18

SpringBoot：1.5.10.RELEASE

定制SpringApplication

以关闭 Banner 为例：

import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {
	
	public static void main(String[] args) {
		SpringApplication application = new SpringApplication(MyApplication.class);
		application.setBannerMode(Banner.Mode.OFF);
		application.run(args);
	}
}

或者 application.yml 中

1
2
3

spring: 
	main:
		banner-mode: "off"

流式API

import org.springframework.boot.Banner;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;

@SpringBootApplication
public class MyApplication {
	
	public static void main(String[] args) {
		new SpringApplicationBuilder()
			.sources(MyApplication.class)
			.bannerMode(Banner.Mode.OFF)
			.run(args);
	}
}

展开全文 >>

SpringBoot 配置类和自动配置

2018-01-17

SpringBoot：1.5.10.RELEASE

SpringBoot 推荐基于 Java 维护元数据信息，但是也支持基于 XML 维护元数据信息。

配置类通过 @Configuration 注解可以进行自动扫描

SpringBoot 支持多个配置类单独配置，可通过 @Import 注解进行集中导入或者通过 @ComponentScan 自动扫描

如果想集成基于 XML 维护元数据，可通过 @ImportResource 注解进行集成

自动配置需要使用 @EnableAutoConfiguration 注解

@SpringBootApplication 注解组合了上述注解

package com.example.myproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication; 

@SpringBootApplication
public class Application {
	public static void main(String[] args) { 
		SpringApplication.run(Application.class, args);
	} 
}

@SpringBootApplication 组合了 @Configuration @EnableAutoCofiguration @ComponentScan 三个注解

可通过如下方式去除自动配置：

import org.springframework.boot.autoconfigure.*; 
import org.springframework.boot.autoconfigure.jdbc.*; import org.springframework.context.annotation.*;

@Configuration @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) 
public class MyConfiguration {
}

@EnableAutoConfiguration 可以通过 exclude 进行排除

展开全文 >>

SpringBoot 代码结构

2018-01-17

SpringBoot：1.5.10.RELEASE

不要使用默认包

default package 不能使用，SpringBoot 特性是自动扫描，自动装配，对代码结构有一定的约定，default package 结构可能影响自动扫描，自动装配

启动类的位置

官方推荐启动类位于根目录，因为 @EnableAutoConfiguration 注解是基于当前类所在包，扫描当前类所在包及子包

典型布局：

com
 +- example
     +- myproject
         +- Application.java
         |
         +- domain
         |   +- Customer.java
         |   +- CustomerRepository.java
         |
         +- service
         |   +- CustomerService.java
         |
         +- web
             +- CustomerController.java

package com.example.myproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration; 
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
	public static void main(String[] args) { 
		SpringApplication.run(Application.class, args);
	}
}

展开全文 >>

SpringBoot 使用

2018-01-17

SpringBoot：1.5.10.RELEASE

SpringBoot 引入有两种方式：

继承

 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.10.RELEASE</version>
</parent>

依赖管理

<dependencyManagement>
	<dependencies>
  		<!--spring-boot-->
  		<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-dependencies</artifactId>
    		<version>1.5.10.RELEASE</version>
    		<type>pom</type>
    		<scope>import</scope>
  		</dependency>
	</dependencies>
</dependencyManagement>

推荐使用依赖管理的方式，耦合性更低

展开全文 >>

Java 8 接口中的默认方法和静态方法

2018-01-15

展开全文 >>

Stream API

2018-01-12

Java 8 除 Lambda 表达式这一重大变化外，另一个就是 Stream API。

Stream API 是 Java 8 处理集合的关键抽象，希望对集合可以进行非常复杂的查找、过滤和映射数据等操作。

展开全文 >>

Spring Cloud Zuul 路径匹配

2018-01-12

Spring Boot: 1.5.10.RELEASE

Spring Cloud: Dalston.SR5

从之前可知路由配置规则：

properties 风格：

zuul.routes.<routh>.path = xxxx
zuul.routes.<routh>.serviceId = xxxxx
``` 
如：

``` 
zuul.routes.user-service.path = /user-service/**
zuul.routes.user-service.serviceId = user-service
``` 

yml 风格：

zuul:
routes:
:
path: xxxx
serviceId: xxxxx

1
2


如：

zuul:
routes:
user-service:
path: /user-service/**
serviceId: user-service
`

路径匹配主要是设置 path 参数，采用 Ant 风格定义， Ant 是根据通配符来进行匹配：

通配符	说明
?	匹配任意单个字符
*	匹配任意数量的字符
**	匹配任何数量的字符，支持多级

示例：

URL	说明
/user-service/?	可以匹配 /user-service/ 之后拼接一个任意字符的路径，如 /user-service/a，/user-service/b，/user-service/c
/user-service/*	可以匹配 /user-service/ 之后拼接的任意字符的路径，如 /user-service/a，/user-service/aa，/user-service/aaaaaa，但是不支持多级
/user-service/**	可以匹配 /user-service/ 之后拼接的任意字符的路径，且支持多级如 /user-service/a，/user-service/aa，/user-service/aaaaaa，/user-service/aa/bb，/user-service/aa/bb/cc 等等

路径匹配的顺序问题

默认路径匹配的顺序是根据配置文件中的配置顺序，而且因为 properties 文件无法保证有序，推荐使用 yml 格式

一个推荐的路径配置顺序是，层级越多的顺序优先

展开全文 >>

Spring Cloud Zuul 默认路由规则

2018-01-11

Spring Boot: 1.5.10.RELEASE

Spring Cloud: Dalston.SR5

路由管理端点

Zuul 会暴露一个路由管理端点 /routes，借助这个端点，可以方便、直观地查看以及管理 Zuul 的路由。

使用 GET 请求访问该路由管理端点即可获取 Zuul 当前映射的路由列表。

使用 POST 请求访问该路由管理端点即可强制刷新 Zuul 当前映射的路由列表。

默认 SpringCloud 因为安全机制是不允许访问，需设置 management.security.enabled=false

默认路由规则

在上一篇 SpringCloud Zuul 请求路由中有演示配置路由规则，那么如果不配置路径规则会怎么样？会通过服务提供者的请求路径直接访问吗？

还是使用上一篇的例子，只是修改配置文件 appliation.yml 如下：

spring: 
	application:
		name: zuul-server

server:
	port: 8888
	
management:
	security:
		enabled: false

eureka:
	instance:
		prefer-ip-address: false
	client:
		service-url:
			defaultZone: http://localhost:8761/eureka

POST 请求路由管理端点：

1	http://localhost:8888/routes

结果：

{
 "/hello-world-service-provide/**":"hello-world-service-provide",
 "/hello-world-service/**":"hello-world-service"
}

而实际路径如下：

hello-world-service:9001 的 /hello URL

hello-world-service-provide:9004 的 /hello URL

hello-world-service-provide:9005 的 /hello URL

可以发现 Zuul 默认会帮我们配置一个路由规则：默认以服务名称作为path的请求前缀

调用如下URL：

http://localhost:8888/hello-world-service/hello

http://localhost:8888/hello-world-service-provide/hello

屏蔽路由

因为 Zuul 的默认路由规则存在，那么等于默认是开放了所有的服务路径。故若想有选择的开放路由，则需要利用zuul.ignored-service= /* 进行路由屏蔽然后再通过开放指定路由的方式。

修改配置文件 appliation.yml 如下：

spring: 
	application:
		name: zuul-server

server:
	port: 8888
	
management:
	security:
		enabled: false

eureka:
	instance:
		prefer-ip-address: false
	client:
		service-url:
			defaultZone: http://localhost:8761/eureka
			
zuul: 
	ignored-services: '*'

POST 请求路由管理端点：

1	http://localhost:8888/routes

结果：

{}

修改配置文件 appliation.yml 如下：

spring: 
	application:
		name: zuul-server

server:
	port: 8888
	
management:
	security:
		enabled: false

eureka:
	instance:
		prefer-ip-address: false
	client:
		service-url:
			defaultZone: http://localhost:8761/eureka
			
zuul: 
	ignored-services: '*'
	routes:
		hello-world-service: /hello-world-service/**

POST 请求路由管理端点：

1	http://localhost:8888/routes

结果：

1
2
3

{
"/hello-world-service/**":"hello-world-service"
}

调用如下URL：

http://localhost:8888/hello-world-service/hello 可以正常访问

http://localhost:8888/hello-world-service-provide/hello 不可以正常访问

详细代码请参考 lxmuse-spring-cloud 下 example-zuul-02

展开全文 >>

Lambda 表达式方法引用

2018-01-11

Lambda 可以使用现成已经实现的方法。

要求被调用的方法的参数类型和返回值和 Lambda 表达式中函数接口中抽象方法的参数类型和返回值一致

对象::实例方法名

Consumer<String> consumer = x -> System.out.println(x);
		
PrintStream printStream = System.out;
Consumer<String> consumer1 = printStream::print;

1
2
3

Consumer<String> consumer = x -> System.out.println(x);
		
Consumer<String> consumer1 = System.out::print;

类::静态方法名

Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
comparator.compare(2,3);
	
Comparator<Integer> comparator1 = Integer::compare;
comparator1.compare(3,4);

类::实例方法名

要求第一个参数是实例方法的调用者，第二个参数是实例方法的参数

BiPredicate<String, String> biPredicate = (x, y) -> x.equals(y);
biPredicate.test("b", "b");
	
BiPredicate<String, String> biPredicate1 = String::equals;
biPredicate1.test("b", "b");

构造函数引用

可以自动匹配对应的构造函数

Supplier<String> supplier = () -> new String();
System.out.println(supplier);
	
Supplier<String> supplier1 = String::new;
System.out.println(supplier1.get());

Function<String, String> function = (x) -> new String(x);
System.out.println(function.apply("a"));
	
Function<String, String> function1 = String::new;
System.out.println(function1.apply("b"));

数组引用

Function<Integer, String[]> function = (x) -> new String[x];
System.out.println(function.apply(5).length);
	
Function<Integer, String[]> function1 = String[]::new;
System.out.println(function1.apply(6).length);

代码可参考lxmuse-jdk8-new-feature-lambda-04

展开全文 >>

Java 8 四大内置函数接口使用示例

2018-01-11

Consumer 接口

1
2
3

public interface Consumer<T> {
    void accept(T t);
}

1
2
3

public void happy(double money, Consumer<Double> consumer) {
		consumer.accept(money);
}

1	happy(1000, money -> System.out.println("吃喝玩乐"));

1	happy(10000, money -> System.out.println("旅游"));

Supplier 接口

1
2
3

public interface Supplier<T> {
    T get();
}

public List<Integer> getNumList(int num, Supplier<Integer> supplier) {
	List<Integer> list = new ArrayList<>();
	
	for(int i = 0; i < num; i++) {
		Integer n = supplier.get();
		list.add(n);
	}
	
	return list;
}

1	getNumList(10, () -> (int)(Math.random() * 100))

Function 接口

1
2
3

public interface Function<T, R> {
    R apply(T t);
}

1
2
3

public String strHandler(String str, Function<String, String> function) {
		return function.apply(str);
}

1	strHandler(" Lambda ", str -> str.trim().toUpperCase())

Predicate 接口

1
2
3

public interface Predicate<T> {
    boolean test(T t);
}

public List<String> filterStr(List<String> list, Predicate<String> predicate) {
	List<String> strList = new ArrayList<>();
	
	for(String str : list) {
		if(predicate.test(str)) {
			strList.add(str);
		}
	}
	
	return strList;
}

1 2	List<String> strings = Arrays.asList("Hello", "Lambda", "Function", "Java"); filterStr(strings, str -> str.length() > 5);

代码可参考lxmuse-jdk8-new-feature-lambda-03

展开全文 >>