JUnit 5的@BeforeAll和@AfterAll注释分为两种情景使用：静态方法和实例方法。

静态方法

@BeforeAll和@AfterAll默认是添加到静态方法上，@BeforeAll注释的静态方法会在执行所有测试用例之前调用，@AfterAll注释的静态方法会在所有的测试用例完成后调用。它们是在应用级别，应用于所有实例对象。

示例：

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Junit5Test {

    private static final Logger LOGGER = LoggerFactory.getLogger(Junit5Test.class);

    @BeforeAll
    static void beforeAll() {
        LOGGER.info("beforeAll called");    
    }

    @Test
    public void aTest1() {
        LOGGER.info("aTest1 called");
        LOGGER.info(this.toString());        
    }

    @Test
    public void aTest2() {
        LOGGER.info("aTest2 called");
        LOGGER.info(this.toString());
    }

    @AfterAll
    static void afterAll() {
        LOGGER.info("afterAll called");        
    }
}

实例方法

@BeforeAll注释的实例方法会在实例所有的测试用例之前调用，@AfterAll注释的实例方法会在所有实例的测试用例之后调用。但如果@BeforeAll或@AfterAll要应用在实例方法上，需要在实例的类上添加注释@TestInstance。

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class Junit5Test {
....
}

Observer和Observable在Java 9标记为废弃。

废弃原因

Observer和Observable有几个原因：

1、不能序列化

Observable没有实现Serializable接口，它的内部成员变量都是私有的，子类不能通过继承它来对Observable的成员变量处理。所以子类也不能序列化。

参考：Why is java.util.Observable class not serializable.

2、不是线程安全

在 java.util.Observable文档里没有强制要求Observable是线程安全的，它允许子类覆盖重写Observable的方法，事件通知无序以及事件通知发生在不同的线程里，这些都是会影响线程安全的问题。

参考：Documentation of java.util.Observable

3、支持事件模型的功能简单

支持事件模型的功能很简单，例如，只是支持事情发生变化的概念，但是不能提供更多哪些内容发生了改变。

参考：deprecate Observer and Observable

解决方案

可以使用java.beans 里的PropertyChangeEvent 和 PropertyChangeListener 来代替目前Observer和Observable的功能。

示例

public class Demo {  
  
  private String name;  
  private PropertyChangeSupport listeners = new PropertyChangeSupport(this);  
    
  public Demo() {  
      this.name= "my name";  
  }  

  public String getName() {  
      return this.name;  
  }  
      
  public void setName(String name) {  
      String oldValue = this.name;  
      this.name= name;  
      //发布监听事件  
      firePropertyChange("name", oldValue, demoName);  
  }  
      
  public void addPropertyChangeListener(PropertyChangeListener listener) {  
      listeners.addPropertyChangeListener(listener);  
  }  
      
  public void removePropertyChangeListener(PropertyChangeListener listener){  
      listeners.removePropertyChangeListener(listener);  
  }  
      
  protected void firePropertyChange(String prop, Object oldValue, Object newValue) {  
      listeners.firePropertyChange(prop, oldValue, newValue);  
  }  
}

public class Main {  
  public static void main(String[] args) {  
    Demo demo= new Demo();  
     demo.addPropertyChangeListener(new PropertyChangeListener(){  
      public void propertyChange(PropertyChangeEvent evt) {  
         System.out.println("OldValue:"+evt.getOldValue());  
        System.out.println("NewValue:"+evt.getNewValue());  
        System.out.println("tPropertyName:"+evt.getPropertyName());  
    }});  
     demo.setName("new Name");  
  }  
}

用React Native写的项目，构建Android时报错：

Execution failed for task ':app:processDevelopmentDebugResources'.
> A failure occurred while executing com.android.build.gradle.internal.tasks.Workers$ActionFacade
> Android resource linking failed
.../app/build/intermediates/incremental/mergeDevelopmentDebugResources/merged.dir/values/values.xml:2682: AAPT: error: resource android:attr/lStar not found.

原因时androidx.core:core-ktx导致。解决方案就是把androidx.core:core-ktx指定版本为1.6.0

在应用的build.gradle配置：

configurations.all {
    resolutionStrategy {
        force 'androidx.core:core-ktx:1.6.0'
    }
}

或者在android/build.gradle

把

implementation 'androidx.core:core:1+

改为

implementation 'androidx.core:core:1.6.0

build.gradle文件示例：

repositories {
    mavenCentral()
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
apply plugin: 'java'
dependencies {
    compile('org.slf4j:slf4j-api')
    testCompile('junit:junit')
}

1、安装gradle的maven插件

此插件会帮助我们实现build.gradle转换为maven的pom文件。

a、在build.gradle添加如下：

apply plugin: 'maven'

b、执行安装

gradle install

执行完maven插件的安装后，在根目录下默认会生成三个子目录，如下：

• libs：包含了名为${artifactId}-${version}.jar的jar文件
• poms： 名为pom-default.xml的pom文件
• tmp/jar： 包含了manifest信息

其中pom文件内容类似于：

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>gradle-to-maven</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <dependencies>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

定制maven插件

除了使用默认生成的的jar包名，maven插件也允许对生成的jar名做定制，如

install {
    repositories {
        mavenInstaller {
            pom.version = '0.0.1-maven-SNAPSHOT'
            pom.groupId = 'com.example.sample'
            pom.artifactId = 'gradle-maven-converter'
        }
    }
}

生成的结果：

<groupId>com.example.sample</groupId>
<artifactId>gradle-maven-converter</artifactId>
<version>0.0.1-maven-SNAPSHOT</version>

Spring Security的AuthenticationManager用来处理验证的请求，处理的结果分两种：

• 验证成功：结果由AuthenticationSuccessHandler处理
• 验证失败：结果由交给AuthenticationFailureHandler处理。

在Spring Security内置了几种验证失败处理器：

• DelegatingAuthenticationFailureHandler将AuthenticationException子类委托给不同的AuthenticationFailureHandler，这意味着我们可以为AuthenticationException的不同实例创建不同的行为
• ExceptionMappingAuthenticationFailureHandler根据AuthenticationException的完整类名将用户重定向到特定的URL
• SimpleUrlAuthenticationFailureHandler是默认使用的组件，如果指定，它会将用户重定向到failureUrl;否则，它只会返回401响应

自定义AuthenticationFailureHandler

如果想自定义验证失败处理器，需要实现AuthenticationFailureHandler接口。AuthenticationFailureHandler接口源码如下：

package org.springframework.security.web.authentication;
public interface AuthenticationFailureHandler {
	/**
	 * 认证失败时会调用此方法
	 * @param request 出现认证失败时所处于的请求.
	 * @param response 对应上面请求的响应对象.
	 * @param exception 携带认证失败原因的认证失败异常对象
	 * request.
	 */
	void onAuthenticationFailure(HttpServletRequest request,
			HttpServletResponse response, AuthenticationException exception)
			throws IOException, ServletException;
}

实现一个简单的自定义AuthenticationFailureHandler，如下：

public class CustomAuthenticationFailureHandler 
  implements AuthenticationFailureHandler {
    private ObjectMapper objectMapper = new ObjectMapper();
    @Override
    public void onAuthenticationFailure(HttpServletRequest request,HttpServletResponse response,AuthenticationException exception) 
      throws IOException, ServletException {
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        Map<String, Object> data = new HashMap<>();
        data.put("exception", exception.getMessage());
        response.getOutputStream().println(objectMapper.writeValueAsString(data));
    }
}

这里只是简单的返回了一个验证失败的http状态码401，并把异常信息返回。

配置自定义AuthenticationFailureHandler

Spring Security默认是使用SimpleUrlAuthenticationFailureHandler，在配置中修改为自定义的AuthenticationFailureHandler。

@Configuration
@EnableWebSecurity
public class SecurityConfiguration 
  extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) 
      throws Exception {
        auth
          .inMemoryAuthentication()
          .withUser("test")
          .password("test")
          .roles("USER");
    }
    @Override
    protected void configure(HttpSecurity http) 
      throws Exception {
        http
          .authorizeRequests()
          .anyRequest()
          .authenticated()
          .and()
          .formLogin()
          .failureHandler(customAuthenticationFailureHandler());
    }
    @Bean
    public AuthenticationFailureHandler customAuthenticationFailureHandler() {
        return new CustomAuthenticationFailureHandler();
    }
}

可以注意到在HttpSecurity上调用了failureHandler来配置自定义的AuthenticationFailureHandler.

 Spring Security默认情况下是关闭了对方法级的安全控制。可以通过xml或者是在添加了@Configuration注解的bean上添加@EnableGlobalMethodSecurity来开启对方法级别的安全控制。Spring Security 支持三种方法级注解, 分别是 JSR-205/Secured 注解/prePostEnabled，可以在开启对方法级的安全控制时设置。

方法级的安全控制开启

通过xml开启对方法级的安全控制：

<global-method-security secured-annotations="enabled" />
<global-method-security jsr250-annotations="enabled" />
<global-method-security pre-post-annotations="enabled" />

通过注解的方式开启对方法级的安全控制：

//@Secured 注解
@EnableGlobalMethodSecurity(securedEnabled=true)
//JSR-205 注解
@EnableGlobalMethodSecurity(jsr250Enabled=true)
//@PreAuthorize 类型的注解(支持 Spring 表达式)
@EnableGlobalMethodSecurity(prePostEnabled=true)

prePostEnabled支持 Spring EL 表达式，而其他两种注解方式不支持。使用Spring EL表达式可以更灵活地定制一些权限规则。

@Secured注解的使用

只有满足角色的用户才能访问被注解的方法, 否则将会抛出 AccessDenied 异常.

@Secured("ROLE_TELLER","ROLE_ADMIN"), 该方法只允许 ROLE_TELLER 或 ROLE_ADMIN 角色的用户访问.
@Secured("IS_AUTHENTICATED_ANONYMOUSLY"), 该方法允许匿名用户访问.

JSR-205注解的使用

@DenyAll注解, 拒绝所有的访问
@PermitAll 注解, 运行所有访问
@RolesAllowed({"USER","ADMIN"}), 该方法只允许有 ROLE_USER 或 ROLE_ADMIN 角色的用户访问.

PreAuthorize的使用

@PreAuthorize 注解, 在方法调用之前, 基于表达式结果来限制方法的使用.
@PostAuthorize 注解, 允许方法调用, 但是如果表达式结果为 false, 将抛出一个安全性异常.
@PostFilter 注解, 允许方法调用, 但必要按照表达式来过滤方法的结果.
@PreFilter 注解, 允许方法调用, 但必须在进入方法之前过来输入值.

1、使用returnObject对返回值多检查

对于 @PostAuthorize 和 @PostFilter 注解, 可以在表达式中使用 returnObject 保留名, returnObject 代表着被注解方法的返回值, 我们可以使用 returnObject 保留名对注解方法的结果进行验证.

比如:

@PostAuthorize ("returnObject.owner == authentication.name")
public Book getBook();

2、使用#号引用方法参数

在表达式中, 可以使用 #arg 的形式来代表注解方法中的参数 arg.

比如:

@PreAuthorize ("#book.owner == authentication.name")
public void deleteBook(Book book);

使用@P注解或@Param注解给参数设置别名

@PreAuthorize("#c.name == authentication.name")
public void doSomething(@P("c") Contact contact);

3、内置的表达式列表

• hasRole([role]) ：如果有当前角色, 则返回 true(会自动加上 ROLE_ 前缀)
• hasAnyRole([role1, role2])： 如果有任一角色即可通过校验, 返回true,(会自动加上 ROLE_ 前缀)
• hasAuthority([authority]) ：如果有指定权限, 则返回 true
• hasAnyAuthority([authority1, authority2])： 如果有任一指定权限, 则返回true
• principal：获取当前用户的 principal 主体对象
• authentication：获取当前用户的 authentication 对象,
• permitAll：总是返回 true, 表示全部允许
• denyAll：总是返回 false, 代表全部拒绝
• isAnonymous()：如果是匿名访问, 返回true
• isRememberMe()： 如果是remember-me 自动认证, 则返回 true
• isAuthenticated()： 如果不是匿名访问, 则返回true
• isFullAuthenticated()： 如果不是匿名访问或remember-me认证登陆, 则返回true
• hasPermission(Object target, Object permission)
• hasPermission(Object target, String targetType, Object permission) 

在Spring MVC有两种方法可以用来获取请求头Header的值。

方法一、通过在方法的参数添加注解@RequestHeader

示例如下：

@Controller
public class RequestHeaderDemoController {
     @Autowired
     private HttpServletRequest request;
     @GetMapping("/printheader")
     public String printHeader(@RequestHeader HttpHeaders headers) {
          System.out.println("from parameter:" + headers.getFirst("myheader"));
          return "demo";
     }
}

或者在注解@RequestHeader指定获取的header：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
//..
@Controller
public class DemoController {
    @GetMapping(value = "/demo")
    public String hello(@RequestHeader(value="myheader") String myheader)
        //..
    }
}

方法二、从HttpServletRequest获取请求头信息

示例如下：

@Controller
public class RequestHeaderDemoController {
     @Autowired
     private HttpServletRequest request;
     @GetMapping("/printheader")
     public String printHeader(HttpServetRequest request) {
          System.out.println("from parameter:" + request.getHeader("myheader"));
          return "demo";
     }
}

Java版本JUnit5 @BeforeAll和@AfterAll的用法可以参考此文。

Kotlin的类是没有静态方法的，如果要提供类似于Java的静态方法，可以使用伴生对象（companion object）语法。

应用于所有实例的@BeforeAll和@AfterAll

把Java版静态方法的JUnit 5 @BeforeAll和@AfterAll使用Kotlin的伴生对象语法转换如下：

import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.Test
import org.slf4j.LoggerFactory

class Junit5KotlinTest {

    @Test
    fun aTest1() {
        LOGGER.info("aTest1 called")
        LOGGER.info(this.toString())
    }

    @Test
    fun aTest2() {
        LOGGER.info("aTest2 called")
        LOGGER.info(this.toString())
    }

    companion object {
        private val LOGGER = LoggerFactory.getLogger(Junit5KotlinTest::class.java)

        @BeforeAll
        @JvmStatic
        internal fun beforeAll() {
            LOGGER.info("beforeAll called")
        }

        @AfterAll
        @JvmStatic
        internal fun afterAll() {
            LOGGER.info("afterAll called")
        }
    }
}

这里使用了@JvmStatic注释用来标记@BeforeAll和@AfterAll注释的方法是等同于JVM的静态方法。@BeforeAll注释的方法会在所有实例的所有测试用例之前调用。@AfterAll注释的方法会在所有实例的所有测试用例之后调用。

应用于实例的@BeforeAll和@AfterAll

应用在实例方法上那就简单点了，Java版的转换如下：

import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.TestInstance
import org.slf4j.LoggerFactory

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class Junit5KotlinTest {

    private val LOGGER = LoggerFactory.getLogger(Junit5KotlinTest::class.java)

    @BeforeAll
    internal fun beforeAll() {
        LOGGER.info("beforeAll called")
    }

    @Test
    fun aTest1() {
        LOGGER.info("aTest1 called")
        LOGGER.info(this.toString())
    }

    @Test
    fun aTest2() {
        LOGGER.info("aTest2 called")
        LOGGER.info(this.toString())
    }


    @AfterAll
    internal fun afterAll() {
        LOGGER.info("afterAll called")
    }
}

使用Maven编译一个简单的java 10项目报错，报错的是maven-compiler-plugin:3.7.0插件。插件配置如下：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <configuration>
                <release>10</release>
            </configuration>
        </plugin>
    </plugins>
</build>

错误信息：

org.apache.maven.lifecycle.LifecycleExecutionException: Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0:testCompile (default-testCompile) on project example: Execution default-testCompile of goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0:testCompile failed.
        at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:213)
        at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:154)
        at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:146)
        at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:117)
        at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:81)
        at org.apache.maven.lifecycle.internal.builder.singlethreaded.SingleThreadedBuilder.build(SingleThreadedBuilder.java:51)
        at org.apache.maven.lifecycle.internal.LifecycleStarter.execute(LifecycleStarter.java:128)
        at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:309)
        at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:194)
        at org.apache.maven.DefaultMaven.execute(DefaultMaven.java:107)
        at org.apache.maven.cli.MavenCli.execute(MavenCli.java:993)
        at org.apache.maven.cli.MavenCli.doMain(MavenCli.java:345)
        at org.apache.maven.cli.MavenCli.main(MavenCli.java:191)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.base/java.lang.reflect.Method.invoke(Method.java:564)
        at org.codehaus.plexus.classworlds.launcher.Launcher.launchEnhanced(Launcher.java:289)
        at org.codehaus.plexus.classworlds.launcher.Launcher.launch(Launcher.java:229)
        at org.codehaus.plexus.classworlds.launcher.Launcher.mainWithExitCode(Launcher.java:415)
        at org.codehaus.plexus.classworlds.launcher.Launcher.main(Launcher.java:356)
Caused by: org.apache.maven.plugin.PluginExecutionException: Execution default-testCompile of goal org.apache.maven.plugins:maven-compiler-plugin:3.7.0:testCompile failed.
        at org.apache.maven.plugin.DefaultBuildPluginManager.executeMojo(DefaultBuildPluginManager.java:145)
        at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:208)
        ... 20 more
Caused by: java.lang.IllegalArgumentException
        at org.objectweb.asm.ClassReader.<init>(Unknown Source)
        at org.objectweb.asm.ClassReader.<init>(Unknown Source)
        at org.objectweb.asm.ClassReader.<init>(Unknown Source)
        at org.codehaus.plexus.languages.java.jpms.AsmModuleInfoParser.parse(AsmModuleInfoParser.java:80)
        at org.codehaus.plexus.languages.java.jpms.AsmModuleInfoParser.getModuleDescriptor(AsmModuleInfoParser.java:54)
        at org.codehaus.plexus.languages.java.jpms.LocationManager.resolvePaths(LocationManager.java:83)
        at org.apache.maven.plugin.compiler.TestCompilerMojo.preparePaths(TestCompilerMojo.java:281)
        at org.apache.maven.plugin.compiler.AbstractCompilerMojo.execute(AbstractCompilerMojo.java:762)
        at org.apache.maven.plugin.compiler.TestCompilerMojo.execute(TestCompilerMojo.java:176)
        at org.apache.maven.plugin.DefaultBuildPluginManager.executeMojo(DefaultBuildPluginManager.java:134)
        ... 21 more

原因及解决方法

在错误信息里 org.objectweb.asm.ClassReader.<init>(Unknown Source)的非法参数异常IllegalArgumentException。

原因是maven-compiler-plugin默认依赖了一个旧版本的asm包，它是不支持java 10的。把org.ow2.asm:asm配置最新版（6.1）可以解决，配置如下：

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.7.0</version>
    <configuration>
        <release>10</release>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm</artifactId>
            <version>6.1</version>
        </dependency>
    </dependencies>
</plugin>

判断LocalTime是否在午夜，可以判断时间是否在23:59和00:01之间。

代码如下：

private final LocalTime ONE_MINUTE_BEFORE_MIDNIGHT = LocalTime.of(23, 59, 0);
private final LocalTime ONE_MINUTE_AFTER_MIDNIGHT = LocalTime.of(0, 1, 0);

public boolean isAtMidnight(LocalTime time) {
    return time.isAfter(ONE_MINUTE_BEFORE_MIDNIGHT) || time.isBefore(ONE_MINUTE_AFTER_MIDNIGHT);
}

需要注意的是时间在23:59之后，但在00:01之前这两个条件是或逻辑“||”，而不是与逻辑“&&”。这是因为LocalTime.isAfter() 或者 LocalTime.isBefore()都是假设比较的时间是在同一天。

Java 10将新增特性：类型推断的局部变量声明var。

java9以及之前的版本，声明一个局部变量需要显式声明它的类型。Java 10引入了新的变量声明关键词var，使用它不需要我们显式声明局部变量的类型，它会自动推断出局部变量的类型。

Java 9示例:

import java.util.*;

public class Java9 {
  public static void main(String... args) {
    for (String arg : args) {
      System.out.println(arg);
    }

    for (int i = 0; i < args.length; i++) {
      String arg = args[i];
      System.out.println(arg);
    }

    List<String> strings = new ArrayList<>();
    strings.add("hello");
    for (String string : strings) {
    }

    List<String> explicit = new ArrayList<>();

    String name = "Hello";
    name += " World";
    System.out.println("name = " + name);

    int var = 42; // <-- hmmm, wonder what will happen?
  }
}

Java 10 var示例

import java.util.*;

public class Java10 {
  public static void main(String... args) {
    for (var arg : args) {
      System.out.println(arg);
    }

    for (var i = 0; i < args.length; i++) {
      var arg = args[i];
      System.out.println(arg);
    }

    var strings = new ArrayList<String>();
    strings.add("hello");
    for (String string : strings) {
    }

    List<String> explicit = new ArrayList<>();

    var name = "Hello";
    name += " World";
    System.out.println("name = " + name);

    var var = 42; // <-- this works
  }
}

var并不是保留字，在示例里，var var = 42是有效的，这种做法主要是为了兼容旧的版本。

Java 9给Process API引入了多种改进，其中新增了ProcessHandler类，它提供了进程相关的信息，如pid，父进程，子进程，进程开始时间以及累计cpu时间等。

这里使用Java 9的jshell简单演示下Process的使用：

jshell> Process p = new ProcessBuilder("stress", "--cpu", "4", "--timeout", "5").start();
p ==> Process[pid=5572, exitValue="not exited"]

jshell> p.pid()
$2 ==> 11542

jshell> p.info().user()
$3 ==> Optional[ccs]

jshell> p.info().command()
$4 ==> Optional[/usr/bin/stress]

jshell> p.info().commandLine()
$5 ==> Optional[/usr/bin/stress --cpu 4 --timeout 120]

jshell> Arrays.toString(p.info().arguments().get())
$6 ==> "[--cpu, 4, --timeout, 120]"

jshell> p.info().startInstant()
$7 ==> Optional[2018-02-26T10:31:53.642Z]

jshell> p.info().totalCpuDuration().get().toMillis()
$8 ==> 0

获取所有运行的进程

ProcessHandler提供了一个静态方法allProcesses()，它返回所有进程的一个Stream。输出所有进程示例：

ProcessHandle.allProcesses()
             .map(ProcessHandle::info)
             .map(ProcessHandle.Info::commandLine)
             .flatMap(Optional::stream)
             .forEach(System.out::println)

进程退出触发函数

Process的onExit()方法可以让我们在进程退出时执行一些函数处理：

Process proc = new ProcessBuilder("sleep", "10").start();
proc.onExit()
    .thenAccept(p -> System.out.println("Process " + p.pid() + " exited with " + p.exitValue()));

目前Java的String实现是把字符串存放在一个char类型的数组里，char占用两个字节（16位）。但是String作为很常用的类，在很多时候它只包含Latin-1里的字符，这些字符只需要一个字节（8位）存储，所以在这种情况下很容易造成空间的浪费。

Java 9引进紧凑字符串来解决这个问题。

1. 使用UTF-16字符数组，或者是1字节的数组加上一个编码标识符来存储字符串。如果字符串的内容都是ISO-8859-1/Latin-1字符，则使用ISO-8859-1/Latin-1编码存储字符串，否则使用UTF-16编码存储数组。
2. 这些只是实现的修改，String的接口没有任何修改。
3. 紧凑字符串集成在JDK 9里，默认启动。