威联通自带 MySQL 当前我使用的版本是 MariaDB 5.5.57 ，威联通也可以看成是类 Unix 系统吧，但是他和 Linux 还是有很多不同，毕竟深度定制过。
MySQL 在威联通的配置路径在
/etc/config/my.cnf
找到该文件，其他配置就和 MySQL 一样了。
如果想要 MySQL 支持远程访问，在 “控制台” - “应用服务” - “MySQL 服务器” 中选择允许远程连接即可。此时设定一个比较强的密码。
收集了一些官方的非官方的学习资源。
主要讲了 Spring 发展的历史，和 struct 等的对比
以 Servlet 作为入口程序是绝大多数 MVC 框架都遵循的基本设计方案，这里的 DispatcherServlet 被称之为核心分发器。Spring MVC 的核心配置文件定义在 [servlet-name]-servlet.xml 文件中。控制层 Controller 是一个单独的 Java 文件，只是使用注解将其与 HTTP 请求关联。
- 入口程序 DispatcherServlet
- 核心配置 servlet.xml
- 控制逻辑 Controller
这三者构成 Spring MVC 的基础要素。
SpringMVC 在整个 Controller 改造中所涉及到的一些要点：
引入 Annotation 来完成请求 - 响应的映射关系
引入 Annotation 来完成请求 - 响应的映射关系，是 SpringMVC 的一个重大改造。在早期的 SpringMVC 以及其他的 MVC 框架中，通常都是使用 XML 作为基础配置的。而 Annotation 的引入将原本分散的关注点合并到了一起，为实现配置简化打下了坚实的基础。
泛化参数和返回值的含义
核心 Servlet 应该能够根据一定的规则对不同的 Http 请求分发到不同的 Servlet 对象上去进行处理。核心 Servlet 应该能够建立起一整套完整的对所有 Http 请求进行规范化处理的流程。
Servlet 模型中，请求 和 响应实现依赖，web.xml 中配置 <servlet> 和 <servlet-mapping> 的对应，将响应的 URL pattern 和其对应的实现类进行关联。针对这个问题，Spring MVC 提出的方案就是提炼一个核心的 Servlet 覆盖对所有 HTTP 请求的处理，这就是 org.springframework.web.servlet.DispatcherServlet 核心分发器。
因此 web.xml 中的配置就被固定
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/**</url-pattern>
</servlet-mapping>
Spring MVC 接下来要处理的内容就是根据一定的规则处理不同的 HTTP 请求，分发到响应的 Servlet 处理。
在 SpringMVC 的设计中，这两个方面的内容总是在一个不断交叉、互为补充的过程中逐步完善的。
处理流程规范化是目的，对于处理过程的步骤划分和流程定义则是手段。因而处理流程规范化的首要内容就是考虑一个通用的 Servlet 响应程序大致应该包含的逻辑步骤：
在 Java 语言中，最适合表达逻辑处理语义的语法结构是接口，因此上述的四个流程也就被定义为了四个不同接口，它们分别是：
核心配置文件在整个 SpringMVC 的构成要素中占有一席之地的重要原因就是在于：必须借助一个有效的手段对整个 SpringMVC 的组件进行定义，而这一点正是通过核心配置文件来完成的。
DispatcherServlet 与初始化主线，SpringMVC 的设计原则 Open for extension / closed for modification
Spring MVC 设计中的要点
根据 Servlet 规范的定义，Servlet 中的两大核心方法 init 方法和 service 方法，它们的运行时间和触发条件都截然不同：
init 方法
在整个系统启动时运行，且只运行一次。因此，在 init 方法中我们往往会对整个应用程序进行初始化操作。这些初始化操作可能包括对容器（WebApplicationContext）的初始化、组件和外部资源的初始化等等。
service 方法
在整个系统运行的过程中处于侦听模式，侦听并处理所有的 Web 请求。因此，在 service 及其相关方法中，我们看到的则是对 Http 请求的处理流程。
DispatcherServlet 的初始化主线
初始化主线的驱动要素，servlet 中的 init 方法；初始化主线的执行次序，HttpServletBean->FrameworkServlet->DispatcherServlet；初始化主线的操作对象，Spring 容器（WebApplicationContext）和组件。 一个组件的多种行为模式可以在容器中共存，容器将负责对这些实现类进行管理。DispatcherServlet 中对于组件的初始化过程实际上是应用程序在 WebApplicationContext 中选择和查找组件实现类的过程，也是指定组件在 SpringMVC 中的默认行为方式的过程。
SpringMVC 的核心配置文件在整个应用程序中所起到的作用也是举足轻重的。在 web.xml 中指定 SpringMVC 的入口程序 DispatcherServlet 时，实际上蕴含了一个对核心配置文件的指定过程（[servlet-name]-servlet.xml）
namespace element attributes
| | |
<mvc:annotation-driven ignore-default-model-on-redirect="true"/>
| | |
逻辑分类 过程语义 行为配置选项
Schema-based XML 中的配置节点拥有比较鲜明的功能特性，通过 namespace、element 和 attributes 这三大元素之间的配合，共同完成对一个动态过程的描述。
@Configuration 标注在类上，相当于把该类作为 spring 的 xml 配置文件中的 <beans>，作用为：配置 spring 容器（context）
package com.test.spring.support.configuration;
@Configuration
public class TestConfiguration {
public TestConfiguration(){
System.out.println("spring 容器启动初始化......");
}
}
相当于
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd" default-lazy-init="false">
</beans>
测试
package com.test.spring.support.configuration;
public class TestMain {
public static void main(String[] args) {
//@Configuration 注解的 spring 容器加载方式，用 AnnotationConfigApplicationContext 替换 ClassPathXmlApplicationContext
ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
// 如果加载 spring-context.xml 文件：
//ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
}
}
Class.isAssignableFrom() 是用来判断一个类 Class1 和另一个类 Class2 是否相同或是另一个类的超类 superclass 或接口 superinterface。
调用方式： X.class.isAssignableFrom(Y.class)
调用者和参数都是 java.lang.Class 类型。上面例子，如果返回为 true，则表示 X 是 Y 的超类或者接口，Y 可以是一个类也可以是一个接口。
instanceof 是用来判断一个对象实例是否是一个类或接口的或其子类子接口的实例。
调用方式：o instanceof TypeName
第一个参数是对象实例名，第二个参数是具体的类名或接口名
Class 中还有一个相关的方法 isInstance() ，这个方法用来检查实例
MyClass.class.isInstance(obj)
如果返回 true，则表示 obj 是类 MyClass 的实例或者子类实例。
public class NewMain
{
public static void main(String[] args)
{
NewMain nm = new NewMain();
nm.doit();
}
public void doit()
{
A myA = new A();
B myB = new B();
A[] aArr = new A[0];
B[] bArr = new B[0];
System.out.println("b instanceof a: " + (myB instanceof A));
System.out.println("b isInstance a: " + A.class.isInstance(myB));
System.out.println("a isInstance b: " + B.class.isInstance(myA));
System.out.println("b isAssignableFrom a: " + A.class.isAssignableFrom(B.class));
System.out.println("a isAssignableFrom b: " + B.class.isAssignableFrom(A.class));
System.out.println("bArr isInstance A: " + A.class.isInstance(bArr));
System.out.println("bArr isInstance aArr: " + aArr.getClass().isInstance(bArr));
System.out.println("bArr isAssignableFrom aArr: " + aArr.getClass().isAssignableFrom(bArr.getClass()));
}
class A
{
}
class B extends A
{
}
}
结果是：
b instanceof a: true
b isInstance a: true
a isInstance b: false
b isAssignableFrom a: true
a isAssignableFrom b: false
bArr isInstance A: false
bArr isInstance aArr: true
bArr isAssignableFrom aArr: true
Maven 本质上是一个插件框架，它的核心并不执行任何具体的构建任务，而是将所有任务都交给插件来完成，例如编译源代码是由 maven-compiler-plugin 完成的。进一步说，每个任务对应了一个插件目标（goal），每个插件会有一个或者多个目标，例如 maven-compiler-plugin 的 compile 目标用来编译位于 src/main/java/ 目录下的主源码，testCompile 目标用来编译位于 src/test/java/ 目录下的测试源码。
maven-source-plugin 打包插件，会根据当前的源码文件创建 jar 包。默认情况下 jar 文件会在项目 target 目录下。
如果没有进行特殊配置，maven 会按照标准接口查找和处理各种类型文件。一个标准的 maven 项目
├── project.iml
├── pom.xml
├── src
│ ├── main
│ │ ├── java
│ │ └── resources
│ └── test
│ ├── java
│ └── resources
└── target
├── classes
│ └── info
├── generated-sources
│ └── annotations
├── generated-test-sources
│ └── test-annotations
└── test-classes
src/main/java 和 src/test/java 中的所有 *.java 文件都会在 compile 和 test-compile 阶段被编译，结果会分别放到 target/classes 和 target/test-classes 目录中。
src/main/resources 和 src/test/resources 这两个目录的文件也会被复制到 target/classes 和 target/test-classes 目录中。打包插件默认会将 target/classes 中的所有内容打包到 jar 包或者 war 包中。
Archetype 插件允许用户从模板中创建 Maven 项目，该插件需要 Java 6 及以上版本。1
compiler 插件是最常用到的一个，定义 build 的 Java 版本，编译 Java 代码。
pom 文件定义，默认的 source 和 target 都是 1.5。
<project>
[...]
<build>
[...]
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<fork>true</fork>
<verbose>true</verbose>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
[...]
</build>
[...]
</project>
maven-dependency-plugin 是处理依赖相关的插件，该插件有很多 goal，常用的比如 mvn dependency:tree， mvn dependency:analyze 等等。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.8</version>
</plugin>
surefire 是 maven 的单元测试的插件，默认情况下 surefire 会执行文件名以 Test 开头或者结尾的测试用例，或者以 TestCase 结尾的用例。
pom 文件中定义，需要 Maven 2.2.1 or 3.x, and JDK 1.6 or higher
<project>
[...]
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.0</version>
</plugin>
</plugins>
</pluginManagement>
</build>
[...]
</project>
在 mvn 的生命周期中 ，mvn test 时会调用该插件。如果要在 build 时跳过 test 可以定义
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.0</version>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
排除某些类
<configuration>
<skip>true</skip>
<excludes>
<exclude>**/T</exclude>
</excludes>
</configuration>
另外如果要添加或者排除某些目录可以参考官网 的例子。
如果要在开发过程中执行 test，可以
mvn -Dtest=TestCircle test # test 表示当前测试方法所在的测试类，不需要扩展名
在一个稍大一点的组织或团队中，你无法保证所有成员都熟悉 Maven，那他们做一些比较愚蠢的事情就会变得很正常，例如给项目引入了外部的 SNAPSHOT 依赖而导致构建不稳定，使用了一个与大家不一致的 Maven 版本而经常抱怨构建出现诡异问题。maven-enforcer-plugin 能够帮助你避免之类问题，它允许你创建一系列规则强制大家遵守，包括设定 Java 版本、设定 Maven 版本、禁止某些依赖、禁止 SNAPSHOT 依赖。只要在一个父 POM 配置规则，然后让大家继承，当规则遭到破坏的时候，Maven 就会报错。除了标准的规则之外，你还可以扩展该插件，编写自己的规则。maven-enforcer-plugin 的 enforce 目标负责检查规则，它默认绑定到生命周期的 validate 阶段。
使用如下定义
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId>
<version>1.3.1</version>
</plugin>
enforcer 插件有两个 goal，第一个是 display-info， 使用 mvn enforcer:display-info 会显示当前环境信息
[INFO] Maven Version: 3.3.9
[INFO] JDK Version: 1.8.0_131 normalized as: 1.8.0-131
[INFO] OS Info: Arch: amd64 Family: unix Name: linux Version: 4.4.0-116-generic
[INFO]
第二个也是最主要的 goal，就是 mvn enforcer:enforce 用来检查依赖。enforce goal 和 maven 生命周期 validate 阶段绑定，也就意味着，如果要执行 enforcer:enforce 可以通过 mvn validate 来触发。
如果使用 Maven > 3.1.1 和 enforcer 1.4.1 可以使用 @ 语法来执行 特定 id 的 execution。
mvn enforcer:enforce@no-duplicate-declared-dependencies
插件的配置中能直接看到插件的 configuration 配置和 executions 中的 configuration 配置，这两个 configuration 配置有什么区别呢？在 executions 中的配置和 maven 的生命周期绑定，而外层插件的 configuration 是全局的配置。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId>
<version>1.0.1</version>
<executions>
<execution>
<id>convergence</id>
<goals>
<goal>enforce</goal>
</goals>
<configuration>
<rules>
<dependencyConvergence/>
</rules>
<fail>false</fail>
</configuration>
</execution>
</executions>
<configuration>
<rules>
<AlwaysPass />
</rules>
<fail>true</fail>
</configuration>
</plugin>
如果要执行 executions 中的规则，则需要运行 mvn validate 来触发，而在定义在外层 configuration 中的规则，通过 mvn enforcer:enforce 就能够执行。
enforcer 插件自带了很多规则 下面就列举比较常用的几个。
dependencyConvergence 规则 可以保证 maven 以来的包都使用同一个版本。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-enforcer-plugin</artifactId>
<version>3.0.0-M2</version>
<executions>
<execution>
<id>convergence</id>
<configuration>
<rules>
<dependencyConvergence/>
</rules>
</configuration>
<goals>
<goal>enforce</goal>
</goals>
</execution>
</executions>
</plugin>
单独执行该 goal 可以使用 mvn enforcer:enforce@convergence。
bannedDependencies 用来禁用某依赖，
<execution>
<!-- mvn enforcer:enforce@ban-dependencies -->
<id>ban-dependencies</id>
<goals>
<goal>enforce</goal>
</goals>
<configuration>
<rules>
<bannedDependencies>
<!-- 是否检查依赖传递 -->
<searchTransitive>false</searchTransitive>
<excludes>
<exclude>org.apache.maven</exclude>
<exclude>org.apache.maven:badArtifact</exclude>
<exclude>*:badArtifact</exclude>
<!--<exclude>com.google.code.gson</exclude>-->
</excludes>
<includes>
<!--only 1.0 of badArtifact is allowed-->
<include>org.apache.maven:badArtifact:1.0</include>
</includes>
<message>检查这些依赖</message>
</bannedDependencies>
</rules>
<fail>true</fail>
</configuration>
</execution>
excludes 中包含一些列禁止的 artifacts，格式是 groupId[:artifactId][:version][:type][:scope][:classifier] 除了 groupId 其他都是可选的，可以使用通配符
bannedPlugins 禁止使用某些插件。
更多的插件内置规则可以查看：http://maven.apache.org/enforcer/enforcer-rules/index.html
可用于构建 release 版本项目，实现自动打 tag、递增版本号、分发 release 版本 jar 包至仓库。
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-release-plugin</artifactId>
<version>2.5</version>
</plugin>
一般来说引入 maven release plugin 需要如下几步：
mvn release:prepare, 这时插件会扫描项目依赖查看是否有 SNAPSHOT, 是否存在未提交的文件，确定当前 release 的版本号和下一个迭代的版本号，插件会运行单元测试，并向 git 中提交两次 commit, 一次是 release 版本，一次是下一个迭代的版本。并将当前 release 版本打一个 tag 并提交到 git 上面去；mvn release:perform, 插件会执行 mvn deploy 操作，并 clean 掉生成的缓存文件。pom 设置
<distributionManagement>
<repository>
<id>releases</id>
<name>xxxx internal releases repository</name>
<url>http://xxx.com/nexus/content/repositories/releases</url>
</repository>
<snapshotRepository>
<id>snapshots</id>
<name>xxxx internal snapshots repository</name>
<url>http://xxx.com/nexus/content/repositories/snapshots</url>
</snapshotRepository>
</distributionManagement>
<scm>
<url>http://xxx.com/project</url>
<connection>scm:git:git@xxx.com/project.git</connection>
<developerConnection>scm:git:git@xxx.com/project.git</developerConnection>
<tag>HEAD</tag>
</scm>
引入 pom
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
<version>3.0.0</version>
<executions>
<execution>
<id>validate</id>
<phase>validate</phase>
<configuration>
<configLocation>checkStyle.xml</configLocation>
<encoding>UTF-8</encoding>
<consoleOutput>true</consoleOutput>
<failsOnError>true</failsOnError>
<includeTestSourceDirectory>true</includeTestSourceDirectory>
</configuration>
<goals>
<goal>check</goal>
</goals>
</execution>
</executions>
</plugin>
http://wiki.eclipse.org/Jetty/Feature/Jetty_Maven_Plugin
在进行 Web 开发的时候，打开浏览器对应用进行手动的测试几乎是无法避免的，这种测试方法通常就是将项目打包成 war 文件，然后部署到 Web 容器中，再启动容器进行验证，这显然十分耗时。为了帮助开发者节省时间，jetty-maven-plugin 应运而生，它完全兼容 Maven 项目的目录结构，能够周期性地检查源文件，一旦发现变更后自动更新到内置的 Jetty Web 容器中。做一些基本配置后（例如 Web 应用的 contextPath 和自动扫描变更的时间间隔），你只要执行 mvn jetty:run ，然后在 IDE 中修改代码，代码经 IDE 自动编译后产生变更，再由 jetty-maven-plugin 侦测到后更新至 Jetty 容器，这时你就可以直接测试 Web 页面了。需要注意的是，jetty-maven-plugin 并不是宿主于 Apache 或 Codehaus 的官方插件，因此使用的时候需要额外的配置 settings.xml 的 pluginGroups 元素，将 org.mortbay.jetty 这个 pluginGroup 加入。
更多的插件可以到这里查到：http://maven.apache.org/plugins/index.html
这不是一个官方的插件，实现的功能是能够在打包的二进制文件中关联 git 代码的版本。
地址：
maven 项目构建项目，打包成 jar 时，默认情况是 名字加上版本号，通过这个插件可以在命名的时候再增加一个 git 版本号，比如
com-einverne-api-1.0.0-SNAPSHOT-b31229dd.jar
<build>
<plugins>
<plugin>
<groupId>pl.project13.maven</groupId>
<artifactId>git-commit-id-plugin</artifactId>
<version>2.2.4</version>
<executions>
<execution>
<goals>
<goal>revision</goal>
</goals>
</execution>
</executions>
<configuration>
<verbose>true</verbose>
<generateGitPropertiesFile>true</generateGitPropertiesFile>
<injectAllReactorProjects>true</injectAllReactorProjects>
<!-- git 描述， JGIT 提供 -->
<gitDescribe>
<!-- 是否生成描述属性 -->
<skip>false</skip>
<!-- 提交操作未发现 tag 时，仅打印提交操作 ID,-->
<always>false</always>
<!-- 提交操作 ID 显式字符长度，最大值为：40; 默认值：7;
0 代表特殊意义；后面有解释；
-->
<abbrev>7</abbrev>
<!-- 构建触发时，代码有修改时（即"dirty state"), 添加指定后缀；默认值："";-->
<dirty>-dirty</dirty>
<!--always print using the "tag-commits_from_tag-g_commit_id-maybe_dirty" format, even if "on" a tag.
The distance will always be 0 if you're "on" the tag.
-->
<forceLongFormat>false</forceLongFormat>
</gitDescribe>
</configuration>
</plugin>
</plugins>
</build>
说明：
dotGitDirectory 默认值为 ${project.basedir}/.git，表示 .git 文件夹路径，可以自定义 ${project.basedir}/../.gitfailOnNoGitDirectory 默认值：true，.git 文件夹未找到时，构建是否失败；若设置 true, 则构建失败；若设置 false, 则跳过执行该目标更多详细的设置可以参考这里
Mojo Appassembler
主要作用是将 Java 程序打包成单一可执行程序，以往编写单一的可执行的 Java 程序可能非常复杂。The Application Assembler Plugin 是一个用来生成直接启动 Java 程序脚本的 Maven 插件。所有的依赖和构建都会被放到一个定义好的 assemble 目录中，所有的依赖都会在脚本中添加到 classpath 中。
如果直接使用 mvn 命令
mvn archetype:generate \
-DarchetypeGroupId=org.apache.maven.archetypes \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DgroupId=com.mycompany.app \
-DartifactId=my-app \
-Dversion=1.0-SNAPSHOT
或者定义到 pom 文件中
<project>
...
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>appassembler-maven-plugin</artifactId>
<version>1.10</version>
<configuration>
<programs>
<program>
<mainClass>com.mycompany.app.App</mainClass>
<id>app</id>
</program>
</programs>
</configuration>
</plugin>
</plugins>
</build>
</project>
然后使用生成的脚本
$ mvn package appassembler:assemble
...
$ sh target/appassembler/bin/app
Hello World!
其他更多的控制选项可以参考这里
Spring aims to make developer challenges easy, like creating web applications, working with databases, securing applications, and microservices.
Spring Boot builds on top of Spring to make Spring even easier with simplified dependency management, automatic configuration, and runtime insights.
笔记
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication() // 开启组件扫描和自动配置
public class Application {
public static void main(String[] args) {
try {
SpringApplication.run(Application.class, args); // 负责启动引导程序
} catch (Throwable ex) {
ex.printStackTrace();
}
}
}
@SpringBootApplication 将三个有用的注解组合在了一起
application.properties
只要它存 在就会被加载，Spring 和应用程序代码都能获取其中的属性
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<mainClass>com.einverne.api.Application</mainClass>
</configuration>
</plugin>
构建插件的主要功能是把项目打包成一个可执行的超级 JAR (uber-JAR), 包括把应用程序的所有依赖打入 JAR 文件内，并为 JAR 添加一个描述文件，其中的内容能让你用 java -jar target.jar 来运行应用程序。
今天遇到一个神奇的错误，登录 phpMyAdmin 无论如何都登录不进去，开始还以为密码记错了，但是再输入错误密码时，会显示错误的提示
#1045 - Access denied for user 'root'@'localhost' (using password: YES)
而在在我确认密码没有问题时，phpMyAdmin 的表现就像是登录成功过了，但是却没有跳转。
然后为了解决这个问题，修改过 php.ini 中的 session.save_path ，修改了 session 文件的 权限 chmod 777 /path/to/session ，重启了 apache，尝试了所有的可能，直到看到一个解决方法是，因为浏览器的问题，换别的浏览器就能登录，我果断用 Vivaldi 试了一下，果然可以。
于是这个奇怪的问题就解决了，然后我清理了一下 Chrome 的 Cookie ，Session 然后就好了。至于是 phpMyAdmin 的问题还是 Chrome 的问题我也就无从得知了。奇怪了。
方法 wait() 是让当前执行代码的线程等待，wait() 是 Object 类的方法。在调用 wait() 方法前，线程需要获得对象级别锁，只能在同步方法或者同步块中调用，执行 wait() 方法后，当前线程释放锁。如果调用时没有持有适当锁，会抛出 IllegalMonitorStateException 异常。
方法 notify() 也需要在同步方法或者同步块中调用，同样调用前也需要获取对象锁。如果调用没有持有适当的锁，也会抛出 IllegalMonitorStateException 异常。notify() 方法永安里通知可能处于等待该对象锁的其他线程，如果有多个线程等待，由线程规划器随机挑选一个呈现 wait 状态的线程，发出 notify 通知，并使它获得该对象的对象锁。notify() 方法执行后，当前线程不会马上释放该对象锁，wait 状态的线程也不能马上获取该对象锁，需要等执行 notify() 方法的线程将程序执行完，也就是退出 synchronized 代码块之后，当前线程才会被释放锁。
如果发出 notify() 操作时没有处于阻塞状态的线程，命令会被忽视。
wait() 方法使线程停止运行，而 notify() 使停止的线程继续运行。
如果主线程要等待子线程执行完成之后结束，可以使用 join() 方法。
join(long) 在内部使用 wait(long) 方法实现，所以会释放锁。而 Thread.sleep(long) 方法不会释放锁。
ThreadLocal 类主要解决的就是每个线程绑定自己的值，每个线程都有自己的私有数据。
公平锁线程在获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得 FIFO ，而非公平锁就是获取锁的抢占机制，随机获的锁。
类 ReentrantLock 是完全互斥排他，同一时间只有一个线程能够执行 ReentrantLock 后任务，这样的方式保证了实例变量的线程安全，但是效率低下。所以 JDK 中提供了另外一个读写锁 ReentrantReadWriteLock ，在某些不需要操作实例变量的方法中，可以使用读写锁 ReentrantReadWriteLock 来提升方法的效率。
读写锁表示有两个锁，一个读相关锁，也成为共享锁，另一个是写相关的锁，也叫排它锁。读锁之间不排斥，写锁与其他锁互相排斥。多个线程可以同时读操作，但是同一时刻只允许有一个线程写操作。
NextCloud 支持 WebDAV 协议，用户可以完全通过 WebDAV 来连接并同步文件。虽然官方还是推荐 使用客户端来同步文件，不过如果要临时访问 NextCloud 上的文件，使用 WebDAV 方式还是很便捷的。
假设 NextCloud 的地址是 example.com 这个，那么在 Linux 下，一般文件管理器中有连接到服务器的选项在其中，填入服务器 IP 地址，访问端口，然后访问地址填写 /remote.php/dav/files/[USERNAME] 输入该用户的用户名和密码即可访问该用户的所有文件列表。
如果要直接在文件管理器中访问，可以尝试使用如下的协议地址：
dav://[USERNAME]@[SERVER_IP]:[PORT]/remote.php/dav/files/[USERNAME]
在 Linux 下还能通过命令行访问，具体可参考下面的链接。
今天突然遇到一个问题，使用手机拍摄的照片 5+M 体积巨大，但是网易要求的图片大小需要小于 1M，所以就有了压缩图片的需求。记得很久以前使用过 TinyPNG 这个服务，但是唯一一点不好的就是无法脱离他在线的服务，需要把照片上传到他的网站上才能进行压缩。虽然有 tinypng-cli 这个命令行的工具，但其实也是依赖在线服务的。所以就找了一下，然后发现了 jpegoptim 和 optipng 这两个工具。
安装
apt-get install jpegoptim
使用
jpegoptim file.jpg
然后使用 du -h file.jpg 查看文件大小。使用这种方式 jpegoptim 会尽量使用无损失的压缩方式，所以几乎看不出区别。而如果想要指定大小，比如想要压缩到 500k 大小，可以
jpegoptim --size=500k file.jpg
而如果要批量压缩，在目录中 jpegoptim *.jpg 即可。
如果要将 EXIF 信息移走可以添加参数
jpegoptim --strip-exif file.jpg
结合 find
find images_folder/ *.{jpeg,jpg} -exec jpegoptim {} \;
安装
apt-get install optipng
使用
optipng file.png
结合 find
find images_folder/ *.png -exec optipng {} \;
优化 jpeg 压缩算法
命令行版本
安装方式：
npm install -g mozjpeg
mozjpeg --help