一、架构

软件架构是系统的一个草图，阐述了各个组件之间的通信，层次划分，一旦系统开始详细设计，架构蓝图就很难甚至无法改变。

• 传统分层架构
• 前后端分离架构
• 微服务架构

分层架构

分层架构是一种设计软件架构的思想。

• 开放API层：可直接封装Service接口暴露成RPC接口；通过Web封装成http接口；网关控制层等。
• 终端显示层：各个端的模板渲染并执行显示的层。当前主要是Velocity 渲染，JS渲染，JSP渲染，移动端展示等。
• Web 层：主要是对访问控制进行转发，各类基本参数校验，或者不复用的业务简单处理等。
• Service 层：相对具体的业务逻辑服务层。
• Manager 层：通用业务处理层，它有如下特征：对第三方平台封装的层，预处理返回结果及转化异常信息，适配上层接口。对 Service 层通用能力的下沉，如缓存方案、中间件通用处理。 与 DAO 层交互，对多个 DAO 的组合复用。
• DAO 层：数据访问层，与底层 MySQL、Oracle、Hbase、OB 等进行数据交互。
• 第三方服务：包括其它部门 RPC 服务接口，基础平台，其它公司的 HTTP 接口，如淘宝开放平台、支付宝付款服务、高德地图服务等。
• 外部数据接口：外部（应用）数据存储服务提供的接口，多见于数据迁移场景中。

通常意义上的三层架构就是将整个业务应用划分为展现层（表示层）（User Interface Layer）、业务逻辑层（Buesiness Logic Layer）、数据访问层（Data Access Layer）。区分层次的目的是为了体现“高内聚，低耦合”的思想。

分层领域模型规约

• DO（Data Object），此对象与数据库表结构一一对应，通过 DAO 层向上传输数据源对象。
• DTO（Data Transfer Object），数据传输对象，Service或Manager向外传输的对象。
• BO（Business Object），业务对象，可以由Service层输出的封装业务逻辑的对象。
• VO（View Object），显示层对象，通常是Web向模板渲染引擎层传输的对象。
• Query，数据查询对象，各层接收上层的查询请求。注意超过2个参数的查询封装，禁止使用Map类来传输。

二、微服务架构

Martin Fowler于2014年提出的Micro Service概念，谈论多年的SOA（Service-Oriented Architecture，面向服务的架构）终于有了新的解决方案，不再需要ESB（Enterprise Service Bus，企业服务总线），并随着Docker的普及，一个轻量级SOA架构MSA诞生。

单体应用架构

若干业务模块打包封装到一个war包。单块架构/单体应用架构

单体应用架构：尽管已经进行了模块化，但UI和若干业务都被打包在一个war包中，该war包包含了整个系统所有的业务功能。

缺点在于：

• 复杂性高。模块多、边界模糊、依赖不清晰、代码质量参差不齐。
• 技术债务。随着时间推移、需求变更、人员更迭，导致不坏不修，且代码难以被修改。
• 部署频率低。构建和部署时间增加，全量部署耗时长、风险高。
• 可靠性差。某个应用bug，如死循环、OOM等导致整个应用崩溃。
• 拓展能力受限。有些模块计算密集，有些IO密集，导致在cpu、内存等硬件选择上无法兼顾。
• 阻碍技术创新。

一、核心功能

核心功能（优点）

1、快速构建项目（提供starter简化配置）
2、主流开发框架的无配置集成（自动配置Spring）
3、可以jar包方式独立运行，无须依赖Servlet容器，内嵌Servlet容器（Tomcat、Jetty、Undertow）
4、提供运行时的应用监控
5、极大提高了开发和部署效率（无代码生成和xml配置，通过注解配置和java配置，自动化配置）
6、与云计算的天然集成，提供生产级特性actuator

快速集成

1、可到https://start.spring.io 快速配置下载demo
2、idea自带的Spring Initializr或eclipse的Spring Tool Suite
3、Spring Boot CLI命令行生成
4、Maven手工创建

• 添加Spring Boot的父级依赖
• 添加web支持的starter pom（spring-boot-starter-web）
• 添加编译插件

二、基本配置

入口类和@SpringBootApplication

有名为*Application的入口类，包含一个main方法，用来启动SpringBoot应用项目。

banner默认启动图案

可通过在src/main/resources新建banner.txt覆盖。也可在main里禁用。

配置文件

SpringBoot使用资源目录下的全局的配置文件application.properties（常规properties配置文件）或application.yml（yaml语言）。

SpringBoot提倡零xml配置，如特殊情况需要使用，可使用@ImportResource来加载。

如tomcat端口和访问路径：

1
2
3
4
5
6
7
8

#properties版本
server.port=9090
server.servlet.context-path=/iherr

#yml版本
server:
	port: 9090
	server.servlet.context-path: /iherr

starter pom

提供了大多数场景的starter pom，包括官方和第三方，列举部分：

一、Spring MVC原理

Servlet–>EJB–>Struts–>SpringMVC–>SpringBoot

Servlet

Servlet的本质：

• Servlet就是一个Java接口，这个接口定义了一套处理网络请求的规范，包含了init、destroy这两个生命周期的方法，和一个处理请求的service方法。
• 所有实现servlet接口的类，或者说，所有想要处理网络请求的类，都需要回答这三个问题：你初始化时要做什么？你销毁时要做什么？你接受到请求时要做什么？
• 实现Servlet类并不能直接处理请求，servlet不会和客户端打交道，需要servlet容器来实现。常见的如tomcat，里面包含servlet接口和实现。tomcat监听客户端端口，根据请求信息，将请求交给对应的servlet处理，调用servlet的service方法，返回response对象，再返回给客户端。

Servlet和JSP的区别：

• JSP就是在html里面写Java代码，Servlet就是在Java里面写html代码。其实JSP会转换为servlet代码，然后编译成类文件，供JVM运行。
• Servlet能够很好地组织业务逻辑代码，但是在Java源文件中通过字符串拼接的方式生成动态HTML内容会导致代码维护困难、可读性差。
• JSP虽然规避了Servlet在生成HTML内容方面的劣势，但是在HTML中混入大量、复杂的业务逻辑同样也是不可取的。

因此通过MVC模型，Controller层负责servlet，View层负责JSP，提高代码可读性和可维护性。

DispatcherServlet（前端控制器）

DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

DispatcherServlet继承自Servlet。HttpServletBean抽象类仍然是spring提供，而HttpServlet抽象类、Servlet接口都是servlet容器（如tomcat）等提供。

HandlerMapping（处理器映射器）

HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等，推荐使用注解开发。

Handler（处理器）

Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

HandlerAdapter（处理器适配器）

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

ViewResolver（视图解析器）

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。

二、Spring MVC核心源码

1、所有的源头从Servlet接口的service方法开始。

1
2
3

public interface Servlet {
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
}

2、FrameworkServlet类有service的方法的实现

1
2
3
4
5
6
7
8
9
10
11

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        if (httpMethod != HttpMethod.PATCH && httpMethod != null) {
            super.service(request, response); // 关键代码，调用父类service方法
        } else {
            this.processRequest(request, response);
        }

    }
}

3、父类HttpServlet的service方法

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

public abstract class HttpServlet extends GenericServlet {
	protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		String method = req.getMethod();
		long lastModified;
		if (method.equals("GET")) {
			lastModified = this.getLastModified(req);
			if (lastModified == -1L) {
				this.doGet(req, resp); //关键代码，是get方法调用doGet
			} 
			...
		} 
	}
}

4、回到FrameworkServlet的doGet和processRequest方法

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

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
    protected final void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.processRequest(request, response);
    }

	protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		...
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor());
        this.initContextHolders(request, localeContext, requestAttributes);
        try {
            this.doService(request, response); //关键代码，调用doService
        }
    }

	protected abstract void doService(HttpServletRequest var1, HttpServletResponse var2) throws Exception; //doService是个抽象方法，被子类DispatcherServlet重写
}

5、DispatcherServlet的最核心SpringMVC源码

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

public class DispatcherServlet extends FrameworkServlet {
	@Nullable
    private List<HandlerMapping> handlerMappings;
    @Nullable
    private List<HandlerAdapter> handlerAdapters;

	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		...
        try {
            this.doDispatch(request, response); //关键代码，调用doDispatch，进入mvc核心源码
        }
    }

	//SpringMVC核心源码
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            try {
                ModelAndView mv = null;
                Object dispatchException = null;

                try {
                    processedRequest = this.checkMultipart(request); //检查是否是multipart请求
                    multipartRequestParsed = processedRequest != request; 
                    mappedHandler = this.getHandler(processedRequest); //图上的2、3步，调用处理器映射器HandlerMapper
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
					
                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());//获取处理器适配器
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    if (isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }
					//执行拦截器
                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }
					//返回处理器对象后，会走图上第4、5、6步，通过处理器适配器HandlerAdapter调用controller的方法
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
					//图上8、9、10步骤，渲染ModelAndView
                    this.applyDefaultViewName(processedRequest, mv);
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } catch (Exception var20) {
                    dispatchException = var20;
                } catch (Throwable var21) {
                    dispatchException = new NestedServletException("Handler dispatch failed", var21);
                }

                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
            } catch (Exception var22) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
            } catch (Throwable var23) {
                this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
            }

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }

	//获取处理器映射器HandlerMapping，相关配置在spring-webmvc-x.x.x.RELEASE.jar!\org\springframework\web\servlet\DispatcherServlet.properties
	@Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) { 
			// handlerMappings是个数组，是spring启动时已初始化
			// {RequestMappingHandlerMapping@6887}匹配Controller中@Requestmapping注解指定的URL。
			// {BeanNameUrlHandlerMapping@7378}匹配beanID作为url，必须以/开头，由继承AbstractController的Controller来处理该url。 
			// {RouterFunctionMapping@7379}
			// {SimpleUrlHandlerMapping@7380}根据url进行统一映射管理，比如会映射到ResourceHttpRequestHandler来处理静态资源映射。
			// {WelcomePageHandlerMapping@7381}欢迎页面/或/index的映射 
            Iterator var2 = this.handlerMappings.iterator();

            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next(); //如是controller自定义路径，会定位到RequestMappingHandlerMapping
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) { //handler会返回处理器对象。com.herr.springboot.base.Controller.HelloController#index()
                    return handler;
                }
            }
        }

        return null;
    }
	//获取处理器适配器HandlerAdapter
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
			// handlerAdapters同样是个数组，在spring启动时已初始化。根据映射器的不同，会有不同的适配器
			// {RequestMappingHandlerAdapter@7109} 
			// {HandlerFunctionAdapter@7469} 
			// {HttpRequestHandlerAdapter@7470} 
			// {SimpleControllerHandlerAdapter@7471} 
            Iterator var2 = this.handlerAdapters.iterator();

            while(var2.hasNext()) {
                HandlerAdapter adapter = (HandlerAdapter)var2.next();
                if (adapter.supports(handler)) {
                    return adapter;
                }
            }
        }
    }
}

一、Spring相关概念

框架设计原则

• 使用POJO（Plain Old Java Object，普通Java对象）取代EJB（Enterprise Java bean，企业级Java Bean），进行轻量级（1MB的jar包）和最小侵入式开发。
• 通过IoC（Inversion of Control，控制反转）的DI（Dependency Injection，依赖注入），配合基于接口编程实现松耦合。
• 通过AOP（Aspect Oriented Programming，面向切面编程），和默认习惯进行声明式编程。配合模板（template）减少模块化代码，用于事务管理、权限控制、日志记录、性能统计等。

常用jar包

• org.springframework.aop，Spring的面向切面编程，提供AOP（面向切面编程）的实现
• org.springframework.beans，所有应用都用到，包含访问配置文件，创建和管理bean等，是Spring IOC的基础实现。
• org.springframework.context，提供在基础IOC功能上的扩展服务，此外还提供许多企业级服务的支持，有邮件服务、任务调度、JNDI定位，EJB集成、远程访问、缓存以及多种视图层框架的支持。
• org.springframework.core，Spring的核心工具包，其他包依赖此包
• org.springframework.expression，Spring表达式语言
• org.springframework.jcl，日志框架
• org.springframework.test，对JUNIT等测试框架的简单封装
• org.springframework.web，包含Web应用开发时，用到Spring框架时所需的核心类。
• org.springframework.webmvc，基于web框架，提供MVC模式支持。

控制反转（IoC，Inversion of Control）

• 控制反转，不是什么技术，而是一种设计思想。它能指导我们如何设计出松耦合、更优良的程序。
• 传统Java程序设计，直接在“对象”内部通过new创建了“依赖对象”，是“对象”主动去创建“依赖对象”，由“对象”直接控制“依赖对象”。
• 在IoC中，有专门容器来协助“对象”创建并注入“依赖对象”，即由专有容器来控制“依赖对象”的创建。“对象”只是被动的接受“依赖对象”，而不是像传统方式一样直接控制“依赖对象”，因此被称为控制反转。

依赖注入（DI，Dependency Injection）

• 和IoC的关系：IoC和依赖注入本质上描述的是同一种概念，但如非要区分，可以认为IoC是一种思想，依赖注入是一种实现方式，即控制反转通过依赖注入来实现。
• 依赖注入指的是容器负责创建对象和维护对象间的依赖关系，而不是通过对象本身负责自己的创建和解决自己的依赖。
• 依赖注入是注入某个对象所需要的属性（包括对象、资源、常量数据）。主要为了解耦，体现了一种“组合”的理念，组合则使耦合度大大降低。如果需要某个类具备某项功能的时候，也可以使用继承，但继承一个具有此功能的父类，子类将和父类耦合。

Spring中的IoC

• 对于Spring框架来说，就是由Spring的IoC容器（ApplicationContext）来负责控制对象的生命周期和对象间的关系。
• IoC容器用来帮“对象”查找“依赖对象”、创建“依赖对象”、把“依赖对象”交给“对象”。即IoC容器负责创建Bean，并将功能类Bean注入到你需要的Bean中。
• Spring提供3种元数据配置方式，基于xml配置、基于注解配置和基于Java类配置，来实现Bean的创建和注入。推荐使用Java配置和注解混合配置。全局配置使用Java类配置，业务Bean的配置使用注解配置。
• IoC容器通过解析配置的元数据（如dom4j解析xml，扫描注解），进行Bean初始化、配置和管理依赖，底层原理是利用java的反射来实现。
• 创建对象时，向类里面的属性设置值，可以称为属性注入。方式有三种：有参构造器注入、set方法(包括P名称空间注入)、接口方法注入。Spring支持前两种注入，还可以支持静态工厂和实例工厂的注入。
• 手动装配需要使用property进行设置。针对自动装配，xml使用autowire属性，注解使用@Autowired，xml中autowire属性可设置为no、byName、byType、constructor和Autodetect。

接口多态、工厂模式、spring依赖注入区别

• 接口多态，耦合，更换时需要所有对象创建的地方修改。
• 工厂模式，解耦，只需要修改工厂方法，直接去工厂获取对象。
• spring依赖注入，不需要写工厂方法，由spring自动扫描、获取，实现动态的拆装组建和组件重用。

二、Spring IoC代码实践

实体类，UserDao.java和UserService.java

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

public class UserDao {
    private String age;

    public UserDao() {
    }

    public void printName(){
        System.out.println("herr");
    }

    public UserDao(String age) {
        this.age = age;
    }

    public void printAge(){
        System.out.println(age);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class UserService {

    private UserDao userDao;
    private String stringValue;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setStringValue(String stringValue) {
        this.stringValue = stringValue;
    }

    public void printName(){
        userDao.printName();
    }

    public void printString(){
        System.out.println(stringValue);
    }
}

传统实现

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

public class NormalTest {

    @Test
    //传统方式创建对象，使用new
    public void testNormalCreate(){
        UserDao userDao =new UserDao();
        userDao.printName();
    }

    @Test
    //传统方式创建对象，使用静态工厂模式
    public void testFactoryCreate(){
        UserDao userDao = StaticBeanFactory.getUserDao();
        userDao.printName();
    }

    @Test
    //传统方式创建对象，使用java反射
    public void testReflectionCreate() throws Exception {
        Class clazz= Class.forName("com.herr.xml.UserDao");
        UserDao userDao =(UserDao) clazz.newInstance();
        userDao.printName();
    }
    
    @Test
    //传统方式属性注入，通过有参构造器
    public void testeNormalConstuctorCreate(){
        UserDao userDao = new UserDao("18");
        userDao.printAge();
    }

    @Test
    //传统方式属性注入，通过setter
    public void testNormalSetter(){
        UserService userService =new UserService();
        userService.setStringValue("normal setter://");
        userService.printString();
    }
}

Spring基于xml的配置

xml-bean.xml文件

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

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 没有autowire属性的都是手动装配 -->
    <!-- 默认，需要类中有"无参构造方法"，bean有scope属性，默认为singleton（单例），还有prototype（多例） -->
    <bean id="userDao" class="com.herr.xml.UserDao" scope="singleton"/>

    <!-- 静态工厂创建 -->
    <bean id="userDao2" class="com.herr.xml.StaticBeanFactory" factory-method="getUserDao"/>

    <!-- 实例工厂创建 -->
    <bean id="beanFactory" class="com.herr.xml.BeanFactory"/>
    <bean id="userDao3" factory-bean="beanFactory" factory-method="getUserDao"/>

    <!-- 有参构造属性注入，需要类中有"有参构造方法" -->
    <bean id="userConstructor" class="com.herr.xml.UserDao">
        <!-- 有参构造使用constructor-arg标签 -->
        <constructor-arg name="age" value="18"/>
    </bean>

    <!-- setter属性注入，需要类中有"setter方法" -->
    <bean id="userService" class="com.herr.xml.UserService">
        <!-- 注入dao对象，name为service类里面的属性，ref为dao配置bean中的id值 -->
        <property name="userDao" ref="userDao"></property>
        <!-- 注入value、list、map等复杂类型都可，value为字符串的值。-->
        <property name="stringValue" value="setter://"></property>
    </bean>

    <!-- P标签注入，需要类中有"setter方法"，用来简化property -->
    <bean id="userServiceP" class="com.herr.xml.UserService" p:stringValue="p://"/>

    <!-- autowire默认为no，即不自动注入。如注入需要使用property属性设置 -->
    <bean id="userServiceNotAuto" class="com.herr.xml.UserService" autowire="no"></bean>

    <!-- 根据名字自动注入，会找UserService类属性userDao同名的Bean，即xml中第1个配置的bean -->
    <bean id="userServiceAuto" class="com.herr.xml.UserService" autowire="byName"></bean>
    <!-- 由于有多个定义的bean是UserDao类型的，会报错 -->
    <!-- <bean id="userServiceAuto" class="com.herr.xml.UserService" autowire="byType"></bean> -->

</beans>

使用Spring的xml配置方式，可以对比上方的传统方式，便于理解IoC。

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//com.herr.xml为使用xml配置方式，由XMLTest.java进行测试。  
public class XMLTest {

    @Test
    //Spring的xml配置创建对象，使用类的默认的无参构造器
    public void testSpringCreate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userDao");
        userDao.printName();
    }

    @Test
    //Spring的xml配置创建对象。使用静态工厂创建，创建静态方法，返回类的对象
    public void testSpringStaticFactoryCreate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userDao2");
        userDao.printName();
    }

    @Test
    //Spring的xml配置创建对象。使用实例工厂创建，创建实例方法，返回类的对象
    public void testSpringFactoryCreate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userDao3");
        userDao.printName();
    }

    @Test
    //Spring的xml配置，通过有参构造注入属性
    public void testSpringConstructor(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userConstructor");
        userDao.printAge();
    }

    @Test
    //Spring的xml配置，通过setter注入属性
    public void testSpringSetter(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userService");
        userService.printName();
        userService.printString();
    }

    @Test
    //Spring的xml配置，通过P标签注入属性
    public void testSpringForPLabel(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userServiceP");
        userService.printString();
    }

    @Test
    //Spring的xml配置，自动根据name注入属性
    public void testSpringForAutowire(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userServiceAuto");
        userService.getUserDao().printName();
    }

    @Test
    //Spring的xml配置，不自动或手动注入属性，userDao会报空指针异常，因为没有进行属性装配。
    public void testSpringForNotAutowire(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userServiceNotAuto");
        userService.getUserDao().printName();
    }
}

class BeanFactory {
    //使用实例方法返回UserDao对象
    public UserDao getUserDao(){
        return new UserDao();
    }
}

class StaticBeanFactory {
    //使用静态方法返回UserDao对象
    public static UserDao getUserDao(){
        return new UserDao();
    }
}

一、Nginx安装部署

docker安装

docker的nginx镜像： https://hub.docker.com/_/nginx

1
2
3
4
5
6
7
8
9

# docker安装nginx，本地新建nginx/conf/nginx.conf文件，文件参考下方第3小结-基础配置
$ docker run --name nginx -d -p 8070:80 -v ~/docker/nginx/html:/usr/share/nginx/html -v ~/docker/nginx/conf/nginx.conf:/etc/nginx/nginx.conf nginx
# 默认编译参数
$ nginx -V
nginx version: nginx/1.21.6
built by gcc 10.2.1 20210110 (Debian 10.2.1-6)
built with OpenSSL 1.1.1k  25 Mar 2021 (running with OpenSSL 1.1.1n  15 Mar 2022)
TLS SNI support enabled
configure arguments: --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module

mac安装

1
2
3
4
5
6
7

$ brew install nginx
# 配置文件/opt/homebrew/etc/nginx/nginx.conf
# 静态资源/opt/homebrew/var/www
$ brew services start nginx
$ brew services stop nginx
$ nginx -v
$ nginx -s reload

linux编译安装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# rewrite模块，http模块的正则解析，需要pcre库
# gzip模块的压缩和解压缩，需要zlib库
# ssl功能需要openssl库
$ yum -y install gcc pcre pcre-devel zlib zlib-devel openssl openssl-devel

# 获取源码
$ cd usr/local/src/
$ wget http://nginx.org/download/nginx-1.16.1.tar.gz
$ tar -xvf nginx-1.16.1.tar.gz 
$ git clone https://github.com/arut/nginx-rtmp-module.git

#编译
$ ./configure --help #帮助
# 标准http模块默认编译到nginx中，除非使用--without-XXX参数。可选http模块默认不编译，除非使用--with-XXX参数。
$ ./configure --prefix=/usr/local/nginx
# 生成的nginx二进制文件在/objs目录

# 编译安装
$ make && make install

一、OpenResty基础

简介

『OpenResty』是一个基于 Nginx 与 Lua 的高性能 Web 平台，其内部集成了大量精良的 Lua 库、第三方模块以及大多数的依赖项。用于方便地搭建能够处理超高并发、扩展性极高的动态 Web 应用、Web 服务和动态网关。

OpenResty通过汇聚各种设计精良的Nginx模块，从而将Nginx有效地变成一个强大的通用Web应用平台。这样，Web开发人员和系统工程师可以使用Lua脚本语言调动Nginx支持的各种C以及Lua模块，快速构造出足以胜任10K乃至1000K以上单机并发连接的高性能Web应用系统。

OpenResty的目标是让你的Web服务直接跑在Nginx服务内部，充分利用Nginx的非阻塞I/O模型，不仅仅对HTTP客户端请求，甚至于对远程后端诸如MySQL、PostgreSQL、Memcached以及Redis等都进行一致的高性能响应。

OpenResty基于Nginx和Lua/LuaJIT，充分利用了两者的优势，能够无阻塞地处理海量并发连接，任意操纵HTTP/TCP/UDP数据流，而且功能代码不需要编译，可以就地修改脚本并运行，简化了开发流程，加快了开发和调试的速度，同时也缩短了开发周期。

应用场景

由于OpenResty具有优秀的反向代理功能，以及负载均衡、内容缓冲、安全防护等高级特性，所以最常见的用法是部署在网站架构的最前端，作为流量的总入口，提高系统的整体稳定性和可靠性。

OpenResty内嵌方便快捷的Lua脚本，完全能够取代PHP、Python、Ruby来编写应用服务，把业务逻辑跑在高性能的Nginx里，去掉不必要的中间环节直接操作Redis、MySQL等数据库，减少内部的网络消耗，节约系统资源。

OpenResty也可以充当API Gateway，以RESTful接口为基础聚合整理各种后端服务，并增加监控、缓存、权限控制等功能，改善系统的运行效率。

OpenResty使用四位数字作为版本号，形式是：a.b.c.x，其中前三位数字是内部Nginx的版本，作为大版本号，第四位数字是OpenResty自己的发布版本号，也就是小版本号。

Mac安装

1

$ brew install openresty/brew/openresty

Windows安装

去官网下载安装包。

1
2
3
4
5
6
7

$ start nginx
$ tasklist /fi "imagename eq nginx.exe"

映像名称                       PID 会话名              会话#       内存使用
========================= ======== ================ =========== ============
nginx.exe                    11468 Console                   18     10,548 K
nginx.exe                    19632 Console                   18     11,160 K

另外，如果windows环境没有安装perl，可去『strawberryperl』 下载安装。

docker安装

1
2
3
4
5
6

$ docker run -d --name openresty1 -p 8090:8090 -v ~/docker/openresty/conf/nginx.conf:/usr/local/openresty/nginx/conf/nginx.conf -v ~/docker/openresty/logs:/usr/local/openresty/nginx/logs openresty/openresty:alpine

#创建logs、conf目录
$ mkdir ~/docker/openresty
$ cd ~/docker/openresty
$ mkdir logs/ conf/

conf/nginx.conf文件

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

worker_processes  1; #设置worker进程数为1
error_log logs/error.log;
events {  #设置并发连接需要在events块里
    worker_connections 1024; #单个worker的最大链接数
}
http { #定义http服务
    server { #server块，定义Web服务
        listen 8080; #监听端口
        location / { #location块，匹配任意URI
            # default_type text/html;
            content_by_lua_block {
                ngx.say("HelloWorld")
            }
        }
    }
}

linux安装

1
2
3
4
5
6
7
8

#可参考nginx安装
$ tar -xzvf openresty-VERSION.tar.gz
$ ./configure --prefix=/opt/openresty \
            --with-luajit \
            --without-http_redis2_module \
            --with-http_iconv_module \
            --with-http_postgres_module
$ make && make install

openresty常用命令

1
2
3
4
5
6
7
8
9

# cd到~/docker/openresty后执行
# -c参数为运行时指定配置文件
$ /usr/local/opt/openresty/nginx/sbin/nginx -p `pwd`/ -c conf/nginx.conf
# -p是-c的增强版，设置工作目录，则运行时会使用这个目录下的conf文件来运行，日志文件存放在logs目录。
$ /usr/local/opt/openresty/nginx/sbin/nginx -p ~/docker/openresty/ -c conf/nginx.conf
# -s signal可以快速停止和重启openresty，signal可以是stop（立即停止）、quit（请求处理完后停止）、reload（重启服务，重新加载配置文件和lua代码，服务不会中断），reopen（重新打开日志文件，服务不中断，用于切分日志）
# -t，测试配置文件是否正确
# -v或-V，显示openresty版本信息
$ .\resty -e "print('hello herr')"

包管理工具

开发语言/环境都会提供配套的包管理工具，例如npm/Node.js、cpan/Perl、gem/Ruby等，OpenResty可使用opm。

opm的用法很简单，常用的命令有：

• search ：以关键字检索相关的组件；
• get ：安装功能组件（注意不是install）；
• info ：显示已安装组件的详细信息；
• list ：列出所有本地已经安装的组件；
• upgrade：更新某个已安装组件；
• update ：更新所有已安装组件；
• remove ：移除某个已安装组件。

二、OpenResty核心组件

OpenResty的核心组成部分有四个，分别是：

• Nginx：高性能的Web服务器；
• LuaJIT：高效的Lua语言解释器/编译器；
• ngx_lua（http_lua）：处理HTTP协议，让Lua程序嵌入在Nginx里运行；
• stream_lua：与ngx_lua类似，但处理的是TCP/UDP协议。

还包含许多nginx组件，以C模块的方式提供，集成在Nginx内部。

• ngx_iconv：转换不同的字符集编码；
• ngx_encrypted：使用AES-256算法执行简单的加密运算；
• ngx_echo：提供一系列“echo”风格的指令和变量；
• ngx_set_misc：增强的“set_xxx”指令，用来操作变量；
• ngx_headers_more：更方便地处理HTTP请求头和响应头的指令；
• ngx_memc：支持各种memcached操作；
• ngx_redis2：支持各种Redis操作；
• ngx_dizzle：支持各种MySQL操作；
• ngx_postgres：支持各种PostgreSQL操作。

OpenResty里的Lua组件通常以Lua源码的方式提供(*.lua)，但个别组件为追求效率会以C语言实现，是动态链接库的形式（ *.so）。

• lua_core：OpenResty的核心功能库；
• lua_cjson：处理JSON格式的数据，速度很快（使用C语言实现）；
• lua_string：hex/md5/sha1/sha256等字符串功能；
• lua_upload：流式读取HTTP的上行数据；
• lua_healthcheck：后端集群健康检查；
• lua_limit_traffic：定制流量控制策略；
• lua_lock：基于共享内存的非阻塞锁；
• lua_lrucache：高效的LRU缓存功能；
• lua_dns：高效、非阻塞的DNS解析功能；
• lua_websocket：高效、非阻塞的WebSocket功能；
• lua_redis：Redis客户端，用起来比ngx_redis2更灵活；
• lua_memcached：Memcached客户端，用起来比ngx_memc更灵活；
• lua_mysql:MySQL客户端，用起来比ngx_dizzle更灵活。

OpenResty目前提供的辅助工具有：

• opm ：类似rpm、npm的管理工具，用来安装各种功能组件；
• resty-cli ：以命令行的形式直接执行OpenResty/Lua程序；
• restydoc ：类似man的参考手册，非常详细。

三、Lua语言

Lua是OpenResty的工作语言，是一种动态脚本语言。开发工具可以是IDEA + EmmyLua插件。windows平台推荐使用luaDist。

基本语法

• 单行注释使用–。多行注释使用–[[ … ]]–
• 有六种基本数据类型，nil，boolean，number，string，function，table。使用函数type()测试数据类型。
• string，字符串不可变，单引号或双引号都可以。\代表转义字符。使用[[ … ]]可避免转义。
• 变量，区分大小写，局部变量使用local关键字声明，没有使用local的都是全局变量，且不需要声明就可以直接使用。没有常量说法。
• 逻辑运算使用and、or和not。nil和false为假，其他都是真，包括0
• 字符串运算有个..，用于连接多个字符串。
• 语句块使用do…end形式声明，赋值使用=号。
• 分支语句 if condition1 then … elseif condition2 then … else … end。
• 循环语句有while、repeat-until和for三种。while condition do … end。repeat … until condition。for var=m,n,step do … end。
• 支持使用break和return跳出循环，但不支持continue。
• 模块通过require关键字来引用。自行编写Lua模块时，创建一个表，将函数作为表的元素，用return返回这个表即可。

函数

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

local function f1(a)
    a='1' --lua的参数都是传值（表除外），修改形参不会影响外部变量
    print("var is ",a);
end
f1{1,2,3} --参数是表，调用时省略了括号。
local x= '2'
f1(x,'3') -- 多传入的参数被忽略

local function f2(a,b,c)
    print (a .. (b or '').. (c or ''))
end
f2('1','2')  --调用函数，少的参数默认为nil

local function f3(a,b)
    return a+b,a*b --返回多个结果
end
local x,y=f3(2,3) --接收多个返回值
local z =(f3(2,3)) -- 使用圆括号调用，只返回第1个值

表

表（table）是Lua里唯一的数据结构。类似于字典、数组等，能模拟出array、list、dict、set、map等常见数据结构。

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

local a ={1,2,3} --声明数组形式的表
a[1]=100 --作为数组来使用时下标索引从1开始计数
print(a[1],a[2],a[3]) -- 100 2 3
print(assert(#a ==3)) --运算符#可以计算表里的数组元素数量

local d ={one =1,['two']=2} --声明字典形式的表
d['three']=3 --添加一个新元素
d.four=5; --可使用.key或者[key]来访问表里的元素
assert(#d == 0) --运算符#无法计算字典元素的数量，会返回0

local x ={}
x.mission =function(dest) --为表添加一个函数变量，相当于成员函数
    print('move to ',dest)
end
x.mission('home') --执行成员函数

for i = 1, #a do --使用for循环遍历数组
    print(a[i],', ')
end

for i,v in ipairs(a) do --ipairs只能遍历数组形式的表，遇到nil值就结束。
    print(a[i],', ')
end

for k,v in pairs(d) do --pairs可以遍历所有元素，但速度没有ipairs快。
    print(k,'=>',v)
end

local function f(v)
    v.one=v.one.. ' add'
end

f(d) --当表作为函数的参数时，不是传值，直接传递表的引用
print(d.one) -- 1 add，可以看到已经被修改

面向对象

• 面向对象的设计原则并不完全适用Lua。字典形式的表本身就是对象，可以存储任意变量和函数。
• 封装，但不提供private、public等关键字，所有成员都是公开的。如需要实现私有成员，则在模块文件里用local修饰变量。
• 多态，表是动态的，成员在运行时可以随意替换，没有编译型语言静态绑定的烦恼。
• 继承，在Lua里不提倡，替代方案是使用“原型”模块，克隆出一个新对象，然后在动态变更其属性，达到继承类似的效果。
• 原型模式，需要使用Lua的高级特性，元表metatable和函数setmetatable()。
• 元表需要在表里使用”__index”元方法，重载Lua里查找key的操作。
• 函数setmetatable(t,meta)是把表t的元表设置为meta并返回t。如果meta里设置了__index方法，那么对t的操作t.key会作用在meta上，即meta.key。这样表t就克隆了表meta的所有成员，表meta就成了表t的原型。
• self关键字代表对象自身，调用函数时可以使用”:”替代”.”，这样会隐含传入一个self参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

local proto = {} --首先声明一个原型对象 ，暂时是空表
function proto.go() --为表添加一个方法，即成员函数
    print ("go proto")
end

local mt = { __index = proto } --定义元表 注意重载了 “＿index"
local obj = setmetatable ( {} , mt) --调用 setmetatable 设置元表，返回新表
-- local obj = setmetatable ({ }, { _index = proto } ) --等同于上面2行
obj.go() --新对象是原型的克隆

function proto.new() --new 对象，也就是克隆出新对象
    return setmetatable( --调用setetatable设置元表
    {name="test"} , mt)  --克隆时为对象添加新的name属性
end

function proto:hello() -- 使用":"，隐含传入 self 参数
    print ("hello", self.name) --可以直接使用 self 参数，无须声明
end
local obj = proto:new() --使用":"的方式调用函数
obj:hello() --使用":"的方式调用函数，打印结果hello	test

1

道理都懂，可依然过不好这一生。

写在前面，其实并不是道理有错，而是你害怕拿自己的人生去检验。

一、成长篇

1

从前有个少年，后来他长大了。

小时候觉得悲伤很酷，听悲泪的情歌，写决绝的字句，生怕自己看起来没情绪。现在想来，当时真是多虑了，人生的疾苦都会在未来的路上埋伏好等你出现，一样也不会少你，一样你都躲不掉。

人们通常不会为做过什么而后悔，只会为没做过什么而后悔。

总有一句话，让我们瞬间长大。

您能谈谈人类的奇怪之处吗？他们急于成长，然后又哀叹失去的童年；他们以健康换取金钱，不久后又想用金钱恢复健康。他们对未来焦虑不已，却又无视现在的幸福。因此，他们既不活在当下，也不活在未来。他们活着，仿佛从来不会死亡；临死前，又仿佛从未活过。

我已经过了餐桌上有只鸡就一定能吃到鸡腿的年纪了。

优于别人，并不高贵，真正的高贵应该是优于过去的自己。

人世间，但凡真正的悲伤，往往都与时光有关。

时间是个自称包治百病的庸医。

它揭发了我不愿承认的懦弱，或提醒了我从不自知的坚强。只是我当时不知道，这两者对我都是好的。

如今我们深夜饮酒，杯子碰到一起，都是梦破碎的声音。

攻人短者，其自修必疏。

要学会避开弱者思维，抱怨，运气，爹妈。

有一些路，只有你走过了、走错了、走进死胡同了，你才知道这条路是不能走的，但这样并不影响你的速度，因为，生活和速度无关，和终点无关，和路程上的风景、和陪你的人、和走路的心情息息相关。

明明世界上两点之间直线最短，上帝为什么让你绕着走？后来随着成长，我开始明白，两点之间的线段虽然最短，但是那条曲线是最美的。

很多时候，道理虽是对的，但时代错了。

人生有三次成长，第一次是在发现自己不是世界中心的时候，第二次是在发现即使再怎么努力，终究还是有些事令人无能为力的时候，第三次是在明知道有些事情可能会无能为力，但还是会努力争取的时候。

别指望所有的人都能懂你，因为萝卜白菜，各有所爱。你做了萝卜，自然就做不成白菜。

什么是成熟？小时候我认为成熟是像大人一样做什么事都很稳妥，叛逆期我又认为成熟不过是苟且的另一种说法，现在呢我认为成熟是一种释怀，是一种对生命的释然。

那个喝冰镇汽水的少年，终将拿起保温杯。

像我们这样的人，再不努力和坚持就什么也不是了。努力了不见得会成功，不见得一定会得到自己想要的。很有可能我们努力奋斗一生的，却是别人一出生就拥有的。但是努力一定会有回报，也许是美好的生活，也许只是给自己一个交代。

我未曾见过一个早起、勤奋、谨慎、诚实的人，抱怨命运不好。良好的品格，优良的习惯，坚强的意志，是不会被假设所谓的命运击败的。

人生苦难重重。这是个伟大的真理，它的伟大之处在于，只要我们真正理解并接受这一点，那么我们就再也不会对人生的苦难耿耿于怀了。

世界其实无比简单，所有的复杂都是感官上的迷惑、大脑的想象和对未来的恐惧。

小时候听故事，总是急着问：“后来呢？”后来，原来并非全然美好。人生是一场盛筵，初见总是琳琅满目热气腾腾，之后酒冷茶凉。悲伤的，不是这残羹冷炙，是这似水流年。

这辈子什么最好？没钱的时候，钱最好；没房的时候，房最好；生病的时候，健康最好；离别的时候，相聚最好。但是，钱也有买不到的东西啊，房也有带不走的一天啊。真正永远好的东西都是无价的，珍贵的。这辈子呀，健康最好，真心的感情最好，活着的每一天最好，年轻人加油！

马有千里之程，无骑不能自往；人有冲天之志，非运不能自通。人道我贵，非我之能也，此乃时也、运也、命也。嗟呼！人生在世，富贵不可尽用，贫贱不可自欺，听由天地循环，周而复始焉。

知者不惑，仁者不忧，勇者不惧。

我这一生的种种，都是万事之来，往往顺其自然，当不得已处，实不愿拂逆旁人之意，宁可舍己从人。

选择你能承担的，承担你所选择的。

年纪大了才发现，不是自己选的路有多英明，而是时代洪流下的侥幸。我们其实都是一类人，好的不彻底，坏的不纯粹，周密的计划往往抵不过谋生的随机。

做成一件事情，有很多因素。坚持，是成本最低的一种。

我们终其一生都在寻找两个东西。一个是价值感，一个是归属感。价值来源于被肯定，归属感来源于被爱。

见识是对世道人心的领悟，是对社会运转的明晰，是对人性法则的洞察。

二、家人篇

每个人都有跟不上这个社会的时候，你是在长牙前，他们是在掉牙后。

字典里有几个词，我一直认为解释得不够好，比如爱情，比如责任，比如成熟。

中年以后的男人，时常会觉得孤独，因为，他一睁开眼睛，周围都是要依靠他的人，却没有他可以依靠的人。

生活就是生活，柴米油盐、酸甜苦辣，平淡、寻常。不必每个场景都要灌入深沉情感，每件小事都要赋予宏大意义，不必每个细节都上升到“花枝春满、悲欣交集”的境界。

当我无牵无挂的时候，贫穷对我来说只是晚上吃馒头和吃牛排的区别，无损我的快乐。

幼时依赖，少年叛逆，成年嫌弃，直到中年或自己成为父亲时，才明白父亲的不易。自己不是个好儿子，但一直努力做个好父亲。我们想要一个孩子，教养一个孩子，并不是孩子需要我们，而是我们自己，需要孩子。这一代的父亲是不容易做的。他们要适应年轻的子女的需求，做“现代的父亲”；还要适应年迈的父母的要求，做“传统的儿子”。沉默的、看着“没出息”的儿子只能摇头叹息的父亲，和沉默的、在父亲面前永远无话可说的儿子。

我相信每一个赤诚忠厚的孩子，都曾在心里向父母许下“孝”的宏愿，相信来日方长，相信水到渠成，相信自己必有成功就衣锦还乡的那一天，可以从容尽孝。可惜人们忘了，忘了时间的残酷，忘了人生的短暂，忘了世上有永远无法报答的恩情，忘了生命本身有不堪一击的脆弱。

哪有什么岁月静好，不过是有人替你负重前行。众生皆苦，没有人会被命运额外眷顾。如果你活得格外轻松顺遂，一定是有人替你承担了你该承担的重量。那个替你负重前行的人，就是这个世界上最爱你的人，他（她）总是怕你太累，而把最多的重量放在自己肩上。如果一个人对你好，绝对是命运的恩赐，而不是理所应当。哪怕是夫妻，哪怕是父母。

我意识到，与家人共享的时间不在于长短，而在于这段时间是否真正美好。质量，信赖，承诺，似乎才是你们三个最珍视的品质。

经常有人聊起：要孩子是为了什么？传宗接代还是养儿防老？今天，终于看到一个很令人感动的答案：为了参与一个生命的成长。参与：意味着付出与欣赏。不求孩子完美，不用替我争脸，不用为我传宗接代，更不用帮我养老。只要这个生命健康存在，在这个美丽的世界上走一遍，让我有机会与他同行一段。

时间无情第一，它才不在乎你是否还是一个孩子，你只要稍一耽搁、稍一犹豫，它立马帮你决定故事的结局。它会把你欠下的对不起，变得还不起。又会把很多对不起，变成来不及。

人情世故的阻路栅栏无外乎这两个词：回头、改天。一回头就是杳无音信，一改天就没了下文。

放假的意义就在于，一个说不起就不起的早晨、一个说不睡就不睡的深夜和一个说不出门就不出门的白天。只有虚度的时光才是最好的时光，最值得做的事就是取悦自己和家人，静享岁月的美好丰盛。

夫妻吵架，就事论事。

有句话说，天下无不是的父母。我觉得恰恰相反。为人父母，天天那么多鸡毛蒜皮，谁能做到完美无缺万无一失？宽容父母的小过错，原谅他们的不完美，是人最基本的德行。

人这辈子千万不要马虎两件事：一是找对爱的人，二是找对事业，在太阳升起时要投身事业，太阳落山时要与爱人相拥。

三、理想篇

学医三年，自谓天下无不治之症。行医三年，始信世间无可用之方。

健硕的身体和丰沛的心灵才是储存财富的粮仓，没有一个人可以无视这两样上苍最宝贵的赠予。感受微风的轻拂，体味秋叶的飘零，对生命细微的触觉与感动才是无与伦比的存在之美。

人总得有个面子吧，你往办公室一摊，什么也不做，那不是个事。

人可以变老，但要老得体面一点。

驾一叶扁舟，看湖水悠悠，赏红叶听鸟鸣，于天地间肆意遨游。

我谈不上有高尚的追求，没有特别多的理想，大部分时间是不得不做。

想认真地跟大家说：那些有工作、有钱人的生活，不要羡慕，因为随着年龄的增长，你迟早会有。但是，那些你有而他们没有的东西——时间、青春，其实格外重要。

就像一个天天在家睡觉的人，永远不知道在跑步机上的人有另一种幸福。

记得，优秀还不够，一定要卓越，要无可替代，这才是最重要的。

愿风指引你的道路，愿星辰照亮你前进的方向，愿圣光与你同在，愿艾露恩保佑你，愿大地母亲永远守护你，愿阳光永远照耀你。

在很久很久以前，谎言和真实在河边洗澡。谎言先洗好，穿了真实的衣服离开，真实却不肯穿谎言的衣服。后来，在人们眼里，只有穿着真实衣服的谎言，却很难接受赤裸裸的真实。

君子贤而能容罢，知而能容愚，博而能容浅，粹而能容杂。

隐忍的意志、感恩的心和谦卑的灵魂，是我一直崇尚的品质。

人生不应是一条由窄变宽、由急变缓的河流，更应该像一条在崇山峻岭间奔腾的小溪，时而近乎枯竭，时而一泻千里，总之你不会知道在下一个弯口会出现怎样的景致和故事，人生本该立体而多彩。

一门心思地朝九晚五去上班，买了车买了房又如何？一门心思地辞职退学去流浪，到了南极北极又如何？真正牛B的人生，应该是:既可以朝九晚五，又能够浪迹天涯。

身空心静，云淡风来。

当我年轻的时候，我的想象力从没有受过限制，我梦想改变这个世界。
当我成熟以后，我发现我不能够改变这个世界，我将目光缩短了些，决定只改变我的国家。
当我进入暮年以后，我发现我不能够改变我的国家，我的最后愿望仅仅是改变一下我的家庭。但是，这也不可能。
当我现在躺在床上，行将就木时，我突然意识到：如果一开始我仅仅去改变自己，然后作为一个榜样，我可能改变我的家庭；在家人的帮助和鼓励下，我可能为国家做一些事情。
然而，谁知道呢？我甚至可能改变这个世界！

在我有生之年，在你退隐之前，若我有福，能在台下听一遍你的随便哪首歌。不需狂热，不要荧光棒，不会追逐你索要签名合照，我在每首歌的结尾、串场词的间隙，随人群一起鼓掌。你嘻嘻哈哈地唱，我安安静静地听，完场谢幕的时候，我想我会感到人生一件大事终于圆满的满足。

每个圣人都有过去，每个罪人也有未来。

脾气不好，其实是你的修养不够。

绝大多数的人生痛苦，都是因为我们太在乎即时满足。一点付出，没有立马回报，就会觉得痛苦。你的延迟满足感程度更高，你就会耐心更好，标准更高，目标更大，做事更从容专注，不计较眼前的利益，不在意一城一池的得失，对一时的成功看得淡，对短暂的失败不恐惧。

但行好事，莫问前程。前路有光，初心莫忘。

四、爱情篇

冰心赠葛洛的一首诗中说，爱在左，情在右，在生命的两旁，随时撒种，随时开花，将这一径长途点缀得花香弥漫，使得穿花拂叶的行人，踏着荆棘，不觉痛苦，有泪可挥，不觉悲凉。

来路或许不易，命运或许不公，人生或许悲苦，但是请你足够相信。无论是生活困顿，抑或身体抱恙，都会有“爱”与“情”相伴。

有多少人，以朋友的名义，默默爱着，有多少人，以夫妻的名义，凑合过着。

对我来说，“你好”这两个字不是打招呼，而是字面意思。千好万好，还是你好。

一、App后台入门

App后台作用

• 远程存储数据
• 消息中转

App后台架构

业务–>问题–>解决方案–>架构

App和后台通信

• http协议or私有协议
• 长连接or短连接
• API定义and通信格式
• 接口风格：REST or SOAP
• App后端differ Web后端

编程语言

• 开发效率
• 擅长业务场景
• 根据业务逻辑来拆分语言

开发周期

需求-原型-UI-交互-研发-测试-上线-迭代

开发模式

Scrum敏捷开发框架（适用场景）

术语中英文对照：

开发流程

一、算法基础

前言

• 时间有限，做个算法的入门。
• 对于算法而言，语言只是工具，重要的是思想（道）。
• 器术道用：易者，以用为妙。
• 建议循序渐进，《算法图解》/《labuladong的算法小抄》==>红宝书《算法》第4版（Robert Sedgewick）==>《数据结构与算法分析》（Mark Allen Weiss）==>《算法导论》（Thomas H.Cormen）。而不是刚学会了1+1=2，就直接上微积分。
• 算法的基础是数学。要学好数学，学好数学，学好数学。

算法

1、算法是什么？

• 是任何良定义的计算过程，根据输入产生输出。
• 万物皆算法，算法在慢慢统治世界。

2、为什么需要算法？

计算机也许是快的，但它们不是无限快。存储器也许是廉价的，但不是免费的。因此算法帮助我们有效的使用时间或空间等资源。

3、大部分算法是现成的，直接拿来用就好，为啥还要学习已有的算法？

数据结构、算法、编译原理、计算机体系结构等基础课程是“内功”，新的语言、技术、标准是“外功”。整天赶时髦的人最后只懂得招式，没有功力，是不可能成为高手的。

真正学懂计算机的人都对数学有相当的造诣，既能用科学家的严谨思维来求证，也能用工程师的务实手段来解决问题——而这种思维和手段的最佳演绎就是“算法”。

时间复杂度

我们以插入排序的算法为例，解释时间复杂度计算。

一、安全基础

互联网上进行信息传输的问题和解决方案：

二、加密概况

加密技术通常分为两大类:”对称式”和”非对称式”。

对称性加密算法

对称式加密就是加密和解密使用同一个密钥。信息接收双方都需事先知道密匙和加解密算法且其密匙是相同的，之后便是对数据进行加解密了。对称加密算法用来对敏感数据等信息进行加密。

• 优点：对称加密算法的优点是算法公开、计算量小、加密速度快、加密效率高。
• 缺点：1、密钥传输问题（密钥还需要非对称加密后传输）2、密钥管理问题（每个用户都需要单独生成一个密钥）
• 使用场景：本地数据加密、https通信、网络传输等

非对称加密算法

1976年由美国Whitfield Diffie和Martin Hellman提出“迪菲-赫尔曼密钥交换”。使得人们认识到，加密和解密可以使用不同的规则，来避免直接传递密钥。

公钥私钥：

• 加密和解密所使用的不是同一个密钥，通常有两个密钥，称为”公钥”和”私钥”，两个必须配对使用。

• 使用私钥加密的内容，只能通过公钥来解密。使用公钥加密的内容，只能通过私钥来解密。

• 公钥，可以对外给任何人的加密和解密密码，公开的，可以任何人访问

• 私钥，私钥是一定要严格保护的，通过私钥可以生成公钥，但是从公钥可以认为是永远无法推导出私钥的。

• 优点：非对称加密与对称加密相比其安全性更好

• 缺点：加密和解密花费时间长、速度慢，只适合对少量数据进行加密。

• 使用场景：https会话前期、CA数字证书、信息加密、登录认证等

信息加密流程：

B需要接收消息，则B生成一对密钥，然后B将公钥公开。A如果想给B发送消息，需要先获取B的公钥进行消息加密后，发送给B，B再用自己的私钥进行消息解密。

身份认证流程：

身份认证和加密不同，主要用户鉴别用户的真伪。这里我们只要能够鉴别一个用户的私钥是正确的，就可以鉴别这个用户的真伪。因此A如果想在B站做身份认证，则A在B站生成一对密钥后，A将私钥保存好，B站将公钥保存好。A做验证时，通过私钥进行加密后传给B站，B站如果能用A用户对应的公钥进行解密，则完成了A的身份认证。

散列算法

散列算法，又称哈希函数，是一种单向加密算法。在信息安全技术中，经常需要验证消息的完整性，散列(Hash)函数提供了这一服务，它对不同长度的输入消息，产生固定长度的输出。这个固定长度的输出称为原输入消息的”散列”或”消息摘要”(Message digest)。散列算法不算加密算法，因为其结果是不可逆的，既然是不可逆的，那么当然不是用来加密的，而是签名。

• 优点：不可逆、易计算、特征化
• 缺点：可能存在散列冲突
• 使用场景：文件或字符串一致性校验、数字签名、鉴权协议

三、对称性加密

对称性加密算法有：DES、3DES、AES
用途：对称加密算法用来对敏感数据等信息进行加密

DES（Data Encryption Standard）

由IBM设计，数据加密标准，速度较快，适用于加密大量数据的场合。

3DES（Triple DES）

是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高。相对DES更安全，但效率不高。

AES（Advanced Encryption Standard）

• 高级加密标准，是下一代的加密算法标准，速度快，安全级别高；
• AES是一个使用128为分组块的分组加密算法，分组块和128、192或256位的密钥一起作为输入，对4×4的字节数组上进行操作。
• AES是种十分高效的算法，尤其在8位架构中，这源于它面向字节的设计。AES适用于8位的小型单片机或者普通的32位微处理器,并且适合用专门的硬件实现，硬件实现能够使其吞吐量（每秒可以到达的加密/解密bit数）达到十亿量级。同样，其也适用于RFID系统。

关键术语：

• 分组密码体制，即AES加密会首先把明文切成一段一段的，而且每段数据的长度要求必须是128位16个字节，如果最后一段不够16个字节了，就需要用Padding来填满。
• Padding，就是用来把不满16个字节的分组数据填满16个字节用的，它有三种模式PKCS5、PKCS7和NOPADDING。PKCS5是指分组数据缺少几个字节，就在数据的末尾填充几个字节的几。PKCS7是指分组数据缺少几个字节，就在数据的末尾填充几个字节的0。NoPadding是指不需要填充，必须保证数据有16字节。
• 密钥，AES要求密钥的长度可以是128位16个字节、192位或者256位。
• 初始向量IV，作用是使加密更加安全可靠，我们使用AES加密时需要主动提供初始向量，而且只需要提供一个初始向量就够了，后面每段数据的加密向量都是前面一段的密文。初始向量IV的长度规定为128位16个字节，初始向量的来源为随机生成。
• 四种加密模式，共有四种加密模式，分别是ECB（电子密码本模式）、CBC（密码分组链接模式）、CFB、OFB，我们一般使用的是CBC模式

四、非对称性加密

非对称性加密算法有：RSA、DSA、ECC

RSA

由麻省理工学院的Ron Rivest、Adi Shamir、Leonard Adleman提出，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的。

对于RSA的原理理解，需要的数学知识包含互质、欧拉函数、欧拉定理、模反元素。参见“数学基础”章节。

RSA密钥生成步骤：

1、求N

使用伪随机数生成器生成p和q，p和q都是质数，N=p * q

2、求φ(N)（欧拉函数）

φ(N) = φ(p * q) = φ(p)φ(q)=(p-1)(q-1)

3、求E

要求1<E<φ(N)，且E和φ(N)互质。实际应用中，常常选择65537。

4、求E对于φ(N)的模反元素D

要求1<D<φ(N)，且E * D mod φ(N)=1

5、公钥和私钥

将N和E放入公钥，将N和D放入私钥。

6、可靠性验证

回顾我们一共生成了六个数字：p、q、N、φ(N)、E、D，这六个数字之中，公钥用到了两个（N和E），其余四个数字都是不公开的。其中最关键的是D，因为N和D组成了私钥，一旦D泄漏，就等于私钥泄漏。那么，有无可能在已知N和E的情况下，推导出D？

• E * D mod φ(N)=1。只有知道E和φ(N)，才能算出D
• φ(N)=(p-1)(q-1)。只有知道p和q，才能算出φ(N)
• N=pq。只有将N因数分解，才能算出p和q

结论：如果n可以被因数分解，d就可以算出，也就意味着私钥被破解。但是如果N很大，即以现有计算能力，还无法被因数分解。正是基于这个数学上的难题，因此可以公开密钥算法。

目前针对RSA流行的攻击一般都是基于大数因式分解。目前编号为RSA-768的数被成功分解，威胁到现通行的1024-bit密钥的安全性，普遍认为用户应尽快升级到2048-bit或以上。

此外量子计算的秀尔算法能使穷举的效率大大的提高。一个拥有N量子比特的量子计算机，每次可进行2^N次运算，理论上讲，密钥为1024位长的RSA算法，用一台512量子比特位的量子计算机在1秒内即可破解。