一般情况下，spring-boot服务停机时先关闭application context然后关闭jetty，两者关闭的时间差期间jetty依然再接收新的请求，而此时能够处理请求的相关资源已经在逐步关闭，导致抛出大量异常，直至jetty完全关闭。

2. 优雅的步骤

spring-boot收到服务停机请求时：
(1) jetty停止接收新的请求
(2) jetty处理收到停机请求之前的请求并返回
(3) 关闭application context

3. 具体实现

在application context关机事件发生时关闭jetty，server.stop()会实现以上(1)(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
27
28
29
30

@Slf4j
public class GracefulShutdownBean implements ApplicationListener<ContextClosedEvent> {
 
    private static Server server;
 
    @Override
    public void onApplicationEvent(ContextClosedEvent event) {
        if (server == null) {
            log.error("Jetty server variable is null, this should not happen!");
            return;
        }
        log.info("Entering shutdown for Jetty.");
        if (!(server.getHandler() instanceof StatisticsHandler)) {
            log.error("Root handler is not StatisticsHandler, graceful shutdown may not work at all!");
        } else {
            log.info("Active requests: " + ((StatisticsHandler) server.getHandler()).getRequestsActive());
        }
        try {
            long begin = System.currentTimeMillis();
            server.stop();
            log.info("Shutdown took " + (System.currentTimeMillis() - begin) + " ms.");
        } catch (Exception e) {
            log.error("Fail to shutdown gracefully.", e);
        }
    }
 
    public static void setServer(Server server) {
        GracefulShutdownBean.server = server;
    }
}

将GracefulShutdownBean声明为单例bean，交给spring管理:

1
2
3
4

@Bean
public GracefulShutdownBean initGracefulShutdownBean() {
    return new GracefulShutdownBean();
}

将jetty的server交给GracefulShutdownBean管理：

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

@Bean
JettyServletWebServerFactory embeddedServletContainerFactory(@Value("${server.port}") int port,
                                                             @Value("${server.jetty.threadPool.maxThreads}") int maxThreads,
                                                             @Value("${server.jetty.threadPool.minThreads}") int minThreads,
                                                             @Value("${server.jetty.threadPool.idleTimeout}") int idleTimeout,
                                                             @Value("${server.jetty.shutdown.waitTime}") int shutdownWaitTime) {

    JettyServletWebServerFactory factory = new JettyServletWebServerFactory(port);

    factory.addServerCustomizers(server -> {

        QueuedThreadPool threadPool = server.getBean(QueuedThreadPool.class);
        threadPool.setMaxThreads(maxThreads);
        threadPool.setMinThreads(minThreads);
        threadPool.setIdleTimeout(idleTimeout);

        GracefulShutdownBean.setServer(server);

        if (shutdownWaitTime > 0) {
            StatisticsHandler handler = new StatisticsHandler();
            handler.setHandler(server.getHandler());
            server.setHandler(handler);
            log.info("Shutdown wait time: " + shutdownWaitTime + "ms");
            server.setStopTimeout(shutdownWaitTime);
            // We will stop it through GracefulShutdownBean class.
            server.setStopAtShutdown(false);
        }
    });

    return factory;
}

参考文献：

1. https://github.com/spring-projects/spring-boot/issues/4657

RESTful，即Representational State Transfer的缩写，字面含义是表现层状态转化。是某歪果仁博士提出的一种网络应用软件架构风格。
根据理解RESTful架构的分析，RESTful的关键因素主要有三个：资源、表现层、状态转化。
(1) 资源
表现层依赖的实体，在网络中一般使用URI指定。可以是一张图片，也可以是一段文本。
(2) 表现层
资源的表现形式，是图片还是文本还是视频，应使用HTTP协议头部的Accept和Content-Type字段指定。
(3) 状态转化
client通过HTTP协议的GET、POST、PUT、DELETE等操作获取、创建、修改、删除服务器端的资源，并反映在client的展示中。

2. 优势

RESTful的优势主要体现在与传统C/S架构应用软件的对比上：
浏览器即客户端，客户端的开发难度和成本降低
仅在服务器端存在状态转化，有利于系统结构的拆分和扩展，有利于合理配置服务器资源
系统更新升级方便，向后兼容性好

1
2
3
4
5
6
7
8
9

{
  "data": {
    "1": "观景",
    "2": "小资",
    "3": "院落"
  },
  "ret": true,
  "errcode": 0
}

然后使用如下代码对其进行反序列化：

1
2
3
4

String retStr = "{\"data\":{\"1\":\"观景\",\"2\":\"小资\",\"3\":\"院落\"},\"ret\":true,\"errcode\":0}";
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> retMap = objectMapper.readValue(retStr, new TypeReference<Map<String, Object>>(){});
Map<Integer, String> dataMap = (Map<Integer, String>) retMap.get("data");

之后针对一些数字，需要判断dataMap中是否存在这个key，这里调用的是Map的containsKey()方法：

1

boolean existing = dataMap.containsKey(1);

明明dataMap中存在key=1的键值对，但是得到的结果却是false。
此时debug查看dataMap的内容(如下)，发现dataMap中是存在key=1的键值对的。但是查看key的类型，并不是int而是char，而上边调用constainsKey()方法传入的参数是int，因此返回false。

深扒了一下jackson的底层代码，发现它在反序列化map的key的时候，如果没有明确指定key的类型，将默认按照String类型处理，最终调用的是StringKD的_parse方法，直接将json中的数字以字符串的形式返回了。

1
2
3
4
5
6
7

final static class StringKD extends StdKeyDeserializer
{
    @Override
    public String _parse(String key, DeserializationContext ctxt) throws JsonMappingException {
        return key;
    }
}

修改代码如下，显式地将key转化为Integer类型，我们得到了想要的结果。

1
2
3
4
5
6
7
8
9

String retStr = "{\"data\":{\"1\":\"观景\",\"2\":\"小资\",\"3\":\"院落\"},\"ret\":true,\"errcode\":0}";
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> retMap = objectMapper.readValue(retStr, new TypeReference<Map<String, Object>>(){});
Map<String, String> dataMap = (Map<String, String>) retMap.get("data");
Map<Integer, String> tempMap = Maps.newHashMapWithExpectedSize(dataMap.size());
for (Map.Entry<String, String> entry : dataMap.entrySet()) {
    tempMap.put(Integer.valueOf(entry.getKey()), entry.getValue());
}
boolean existing = tempMap.containsKey(1);

当然还有另外一种解决方案，就是用明确了数据类型的类(即下面的AjaxResult)去接收反序列化的结果，代码如下，这个时候jackson知道了map key的类型，直接调用了IntKD的_parse，将字符串转化为Integer之后返回。

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

public class AjaxResult {
    private boolean ret;
    private int errcode;
    private Map<Integer, String> data;

    public boolean isRet() {
        return ret;
    }

    public AjaxResult setRet(boolean ret) {
        this.ret = ret;
        return this;
    }

    public int getErrcode() {
        return errcode;
    }

    public AjaxResult setErrcode(int errcode) {
        this.errcode = errcode;
        return this;
    }

    public Map<Integer, String> getData() {
        return data;
    }

    public AjaxResult setData(Map<Integer, String> data) {
        this.data = data;
        return this;
    }
}

1
2
3

AjaxResult ajaxResult = objectMapper.readValue(retStr, new TypeReference<AjaxResult>() {});
Map<Integer, String> ajaxDataMap = ajaxResult.getData();
dataNodeMap.containsKey(1);

第一步，grub rescue的处理

先在win7中压缩了20G出来，然后重启机器准备进入linux加载新分区，此时出现了问题，grub无法正常启动，进入了rescue界面。
解决办法是：

1. 列出所有分区

   1	grub rescue> ls

2. 依次ls每个分区直到找到不报’unknown filesystem’的分区，比如n=5

   1	grub rescue> ls (hd0,msdos5)/boot/grub

3. 依次执行以下命令，可进入正常的系统引导界面

   1 2 3 4

   grub rescue> set root=(hd0,msdos5)/boot/grub grub rescue> set prefix=(hd0,msdos5)/boot/grub grub rescue> insmod normal grub rescue> normal

4. 进入linux操作系统，执行以下命令修复grub，重启后grub可恢复正常

   1	$ sudo grub-install /dev/sda

第二步，archlinux挂载分区

配置新分区在linux启动的时候自动挂载，并映射到某一个文件路径，比如/extend

1. 找到要挂载的新分区硬盘号码，比如/dev/sda5

   1	$ sudo fdisk -l

2. 格式化/dev/sda5为linux系统的文件格式(也可使用其它稳定的文件格式)

   1	$ sudo mkfs.ext4 /dev/sda5

3. 配置新分区在系统启动的时候挂载，并映射为/extend
   修改/etc/fstab文件，在最后添加一行，注意使用对应的UUID并修改加载顺序

   1	UUID=59f8ba70-62d4-4d1d-982e-a33166d59394 /extend ext4 rw,relatime,data=ordered 0 3

防止csrf攻击的常用方法

1. HTTP Reference

原理：检查HTTP Reference的地址，判定请求的来源。
缺点：低版本浏览器（IE6等）可以篡改HTTP Reference，达不到防御效果；较新的浏览器允许用户关闭HTTP Reference的使用，致使用户的正常请求也不能通过。

2. url中添加token参数

原理：检查请求url中的token值是否是合法的。
缺点：所有请求地址中添加token字段，实现起来较复杂；url中的token很容易被攻击者获取到。

3. HTTP协议头部添加自定义属性

原理：检查HTTP头部的csrfToken字段值是否合法。
缺点：要使用XMLHttpRequest一次性给该类的所有请求添加csrfToken字段，而XMLHttpRequest的使用局限性很大，并非所有的请求都适合由XMLHttpRequest发起，使用XMLHttpRequest请求到的页面不能被浏览器记录，给用户带来不便。

推荐的防御方式

2+3, 对于安全性要求没那么高的请求，可以采用在url中添加token参数的方法防御csrf，对于安全性要求比较高的请求，则使用在HTTP协议头部添加csrfToken的方式。

1
2
3
4
5
6
7
8
9
10

@Service
public class ChildClass extends ParentClass {

    @Resource
    private TestService testService;

    public String play() {
        return testService.getParent().play();
    }
}

ParentClass:

1
2
3
4
5
6
7
8
9
10
11
12

public class ParentClass {

    private String value = "I am parent class";

    public String play() {
        return value;
    }

    public void setValue(String str) {
        this.value = str;
    }
}

TestService:

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

@Service
public class TestService {
    private ParentClass parent;

    @PostConstruct
    public void init() {
        parent = create();
    }

    public ParentClass getParent() {
        return this.parent;
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public ParentClass create() {
        try {
            Class classDefinition = Class.forName("com.springapp.mvc.inherited.ChildClass");
            ParentClass parent = (ParentClass) classDefinition.getConstructor(new Class[0]).newInstance(new Object[0]);
            parent.setValue("I was processed by test service");
            return parent;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

ResultController:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Controller
@RequestMapping("/inherited")
public class ResultController {

    @Resource
    private ChildClass childClass;

    @RequestMapping(method = RequestMethod.GET)
    public ModelAndView printWelcome() {
        ModelAndView modelAndView = new ModelAndView("hello");
        modelAndView.addObject("message", childClass.play());
        return modelAndView;
    }
}

我们注意到，ChildClass重写了ParentClass的play方法。由于在TestService中使用反射方式生成了ChildClass的实例，并赋值给了ParentClass的实例，此时ParentClass实例并不能访问到ChildClass实例的成员变量testService，且ParentClass实例的play方法已经被ChildClass实例的play方法隐藏，也就是说testService.getParent().play()实际调用的是ChildClass的play()方法，显而易见，此处出现了循环调用。但是由于ParentClass的实例中testService == null，因此程序在进入这一层时会抛出NPE。

之后我们使用注解在TestService中实现成员变量parent的初始化，代码如下：
ParentClass:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@Service
public class TestService {
    
    @Resource
    private ParentClass parent;

    @PostConstruct
    public void init() {
        parent.setValue("I was processed by test service");
    }

    public ParentClass getParent() {
        return this.parent;
    }
}

此时运行程序，NPE消失了，但是出现栈溢出问题。从＠Resource的注解来看，注解的继承关系是向上的，所有使用注解注入的实例共用资源，即以依赖注入形式实现的ChildClass和ParentClass的实例共享资源。因此，TestService中的成员变量parent可以访问到子类ChildClass实例的成员变量testService，进而形成循环依赖并最终导致栈溢出。
＠Resource部分注解：

1
2
3
4
5
6
7

* Even though this annotation is not marked Inherited, deployment
* tools are required to examine all superclasses of any component
* class to discover all uses of this annotation in all superclasses.
* All such annotation instances specify resources that are needed
* by the application component.  Note that this annotation may
* appear on private fields and methods of superclasses; the container
* is required to perform injection in these cases as well.

1
2
3

$ mkdir test
$ cd test
$ git init

config

1
2

$ git config --global user.name username
$ git config --global user.email useremail.chn@gmail.com

文件修改 、查看状态、文件添加以及修改提交

1
2
3
4
5
6
7
8
9
10

$ echo "hello world">>new.txt
$ git status
$ git add new.txt
$ git status
$ git commit -m "first" //提交第一个版本
$ echo "hello new world">>new.txt
$ git status
$ git add new.txt
$ git status
$ git commit -m "second" //提交第二个版本

版本切换

查看更新记录

1

$ git log

使用能够区别版本的前几位即可

1

$ git checkout commit-id

远程提交

添加远程仓库

1

$ git remote add origin https://github.com/windpuller/test.git

将修改提交到服务器端

1

$ git push -u origin master

检出仓库

创建本地仓库的克隆版本

1

$ git clone /path/to/repository

创建远端服务器的克隆版本

1

$ git clone uxername@host:/past/to/repository

分支

创建分支

1

$ git branch branch1

切换分支

1

$ git checkout branch1

删除本地分支

1

$ git branch -d branch1

删除远程分支(慎重使用)

1
2

$ git branch -r -d origin/branch1
$ git push origin :branch1

将分支推送到远端仓库，不推送的话分支是不为他人所见的

1

$ git push origin branch1

更新与合并

更新本地仓库至最新改动，完成了获取fetch并合并merge改动的功能

1

$ git pull

合并其他分支到当前分支

1

$ git merge branch

在以上两种情况下，git都会尝试自动合并改动。但是不是每次合并都能成功，可能出现冲突。这时候就需要修改文件来手动合并这些冲突。改完文件之后，需要重新commit。
在合并改动之前，可以使用如下命令预览差异：

1

$git diff source_branch target_branch

标签

为某个版本创建标签

1

$ git tag tag-name commit-ID

替换本地改动

如果操作失误，可以使用HEAD中的最新内容替换掉工作目录中的文件，已添加到缓存区的改动和新文件都不会受到影响

1

$ git checkout -- filename

如果想要放弃本地的所有改动和提交，可以到服务器上获取最新的版本历史，并将本地主分支指向它：

1
2

$ git fetch origin
$ git reset --hard origin/master

实用小贴士

内建的图形化git

1

$ gitk

彩色的git输出

1

$ git config color.ui true

显示历史记录时，每个提交的信息只显示一行

1

$ git config format.pretty oneline

交互式添加文件到暂存区

1

$ git add -i

参考文献：

1. http://rogerdudler.github.io/git-guide/index.zh.html