UML

不想多讨论 UML 相关的知识，但是我觉得你如果真的会写 Java，请先学会表达自己，UML 就是你说话的语言，做一名优秀的 Java 程序员，请至少学会这两种 UML 图：

1. 类图
2. 时序图

clean code

我认为保持代码的简洁和可读性是代码的最基本保证，如果有一天为了程序的效率而降低了这两点，我认为是可以谅解的，除此之外，没有任何理由可以让你任意挥霍你的代码。

1. 读者可以看一下 Robert C. Martin 出版的《Clean Code》（代码整洁之道） 这本书
2. 可以参考美团文章聊聊 clean code（http://tech.meituan.com/clean-code.html）；
3. 也可以看一下阿里的 Java 编码规范

无论如何，请保持你的代码的整洁。

Linux 基础命令

这点其实和会写 Java 没有关系，但是 Linux 很多时候确实承载运行 Java 的容器，请学好 Linux 的基础命令。

1. 参考鸟哥的《Linux私房菜》

PO：persistent object 持久对象

1 ．有时也被称为Data对象，对应数据库中的entity，可以简单认为一个PO对应数据库中的一条记录。

2 ．在hibernate持久化框架中与insert/delet操作密切相关。

3 ．PO中不应该包含任何对数据库的操作。

POJO ：plain ordinary java object 无规则简单java对象

一个中间对象，可以转化为PO、DTO、VO。

1 ．POJO持久化之后==〉PO

（在运行期，由Hibernate中的cglib动态把POJO转换为PO，PO相对于POJO会增加一些用来管理数据库entity状态的属性和方法。PO对于programmer来说完全透明，由于是运行期生成PO，所以可以支持增量编译，增量调试。）

2 ．POJO传输过程中==〉DTO

3 ．POJO用作表示层==〉VO

PO 和VO都应该属于它。

BO：business object 业务对象

业务对象主要作用是把业务逻辑封装为一个对象。这个对象可以包括一个或多个其它的对象。

比如一个简历，有教育经历、工作经历、社会关系等等。我们可以把教育经历对应一个PO，工作经历对应一个PO，社会关系对应一个PO。

建立一个对应简历的BO对象处理简历，每个BO包含这些PO。

这样处理业务逻辑时，我们就可以针对BO去处理。

封装业务逻辑为一个对象（可以包括多个PO，通常需要将BO转化成PO，才能进行数据的持久化，反之，从DB中得到的PO，需要转化成BO才能在业务层使用）。

关于BO主要有三种概念

1 、只包含业务对象的属性；

2 、只包含业务方法；

3 、两者都包含。

在实际使用中，认为哪一种概念正确并不重要，关键是实际应用中适合自己项目的需要。

VO：value object 值对象 / view object 表现层对象

1 ．主要对应页面显示（web页面/swt、swing界面）的数据对象。

2 ．可以和表对应，也可以不，这根据业务的需要。

DTO（TO）：Data Transfer Object 数据传输对象

1 ．用在需要跨进程或远程传输时，它不应该包含业务逻辑。

2 ．比如一张表有100个字段，那么对应的PO就有100个属性（大多数情况下，DTO内的数据来自多个表）。但view层只需显示10个字段，没有必要把整个PO对象传递到client，这时我们就可以用只有这10个属性的DTO来传输数据到client，这样也不会暴露server端表结构。到达客户端以后，如果用这个对象来对应界面显示，那此时它的身份就转为VO。

DAO：data access object数据访问对象

1 ．主要用来封装对DB的访问（CRUD操作）。

2 ．通过接收Business层的数据，把POJO持久化为PO。

简易的关系图：

为什么偷来这么一篇文章：不同的对象需要用在不同的地方，之前全是POJO，现在传输用DTO，条件查询用BO，查询对象用POJO接收，显示对象用VO，虽然增加了一点代码量，但是代码结构更加清晰，也防止了表结构的暴露。

个人理解：

po，数据库表字段，一个字段对应一个po

dto，数据传输对象，是从数据库表中查询出来的自定义数据封装。

vo，表现层对象，前端页面显示时所需要的所有数据。由dto组装成vo

如果传输的dto刚好是前端表示所需要的值，此时dto也就是vo。

entity里的每一个字段，与数据库相对应，vo里的每一个字段，是和你前台页面相对应， 而dto，是用类做entity和dto之间转换的实体类。

说到代码结构问题，业务分层

所以一个好的应用分层需要具备以下几点：

• 方便后续代码进行维护扩展

• 分层的效果需要让整个团队都接受

• 各个层职责边界清晰

阿里规范

在阿里的编码规范中约束的分层如下图：

①开放接口层：可直接封装 Service 方法暴露成 RPC 接口；通过 Web 封装成 http 接口；进行网关安全控制、流量控制等。

②终端显示层：各个端的模板渲染并执行显示的层。当前主要是 velocity 渲染，JS 渲染，JSP 渲染，移动端展示等。

③Web 层：主要是对访问控制进行转发，各类基本参数校验，或者不复用的业务简单处理等。

④Service 层：相对具体的业务逻辑服务层。

⑤Manager 层：通用业务处理层。

它有如下特征:

对第三方平台封装的层，预处理返回结果及转化异常信息。

对 Service 层通用能力的下沉，如缓存方案、中间件通用处理。

与 DAO 层交互，对多个 DAO 的组合复用。

⑥DAO 层：数据访问层，与底层 MySQL、Oracle、Hbase 进行数据交互。

下面介绍一下具体业务中应该如何实现分层。

优化分层

从我们的业务开发中总结了一个较为的理想模型,这里要先说明一下由于我们的 RPC 框架选用的是 Thrift 可能会比其他的一些 RPC 框架例如 Dubbo 会多出一层，作用和 controller 层类似。

最上层 Controller 和 TService 是阿里分层规范里面的第一层：轻业务逻辑，参数校验，异常兜底。

通常这种接口可以轻易更换接口类型，所以业务逻辑必须要轻，甚至不做具体逻辑。

①Service：业务层，复用性较低，这里推荐每一个 Controller 方法都得对应一个 Service，不要把业务编排放在 Controller 中去做，为什么呢？

如果我们把业务编排放在 Controller 层去做的话，如果以后我们要接入 Thrift，我们这里又需要把业务编排在做一次，这样会导致我们每接入一个入口层这个代码都得重新复制一份。

如下图所示：

这样大量的重复工作必定会导致我们开发效率下降，所以我们需要把业务编排逻辑都得放进 Service 中去做：

Mannager：可复用逻辑层。这里的 Mannager 可以是单个服务的，比如我们的 Cache，MQ 等等，当然也可以是复合的。

当你需要调用多个 Mannager 的时候，这个可以合为一个 Mannager，比如逻辑上的连表查询等。如果是 httpMannager 或 rpcMannager 需要在这一层做一些数据转换。

③DAO：数据库访问层。主要负责“操作数据库的某张表，映射到某个 Java 对象”，DAO 应该只允许自己的 Service 访问，其他 Service 要访问我的数据必须通过对应的 Service。

分层领域模型的转换

在阿里巴巴编码规约中列举了下面几个领域模型规约：

DO（Data Object）：与数据库表结构一一对应，通过 DAO 层向上传输数据源对象。

DTO（Data Transfer Object）：数据传输对象，Service 或 Manager 向外传输的对象。

BO（Business Object）：业务对象。由 Service 层输出的封装业务逻辑的对象。

AO（Application Object）：应用对象。在 Web 层与 Service 层之间抽象的复用对象模型，极为贴近展示层，复用度不高。

VO（View Object）：显示层对象，通常是 Web 向模板渲染引擎层传输的对象。

Query：数据查询对象，各层接收上层的查询请求。注意超过2个参数的查询封装，禁止使用 Map 类来传输。

每一个层基本都自己对应的领域模型，这样就导致了有些人过于追求每一层都是用自己的领域模型。

这样就导致了一个对象可能会出现 3 次甚至 4 次转换在一次请求中，当返回的时候同样也会出现 3-4 次转换，这样有可能一次完整的请求-返回会出现很多次对象转换。

如果在开发中真的按照这么来，恐怕就别写其他的了，一天就光写这个重复无用的逻辑算了吧

所以我们得采取一个折中的方案：

允许 Service/Manager 可以操作数据领域模型，对于这个层级来说，本来自己做的工作也是做的是业务逻辑处理和数据组装。

Controller/TService 层的领域模型不允许传入 DAO 层，这样就不符合职责划分了。

同理，不允许 DAO 层的数据传入到 Controller/TService。

bean 使我们使用最多的模型之一

domain 包名

根据很多 Java 程序员的”经验”来看，一个数据库表则对应着一个 domain 对象，所以很多程序员在写代码时，包名则使用：com.xxx.domain ，这样写好像已经成为了行业的一种约束，数据库映射对象就应该是 domain。但是你错了，domain 是一个领域对象，往往我们再做传统 Java 软件 Web 开发中，这些 domain 都是贫血模型，是没有行为的，或是没有足够的领域模型的行为的，所以，以这个理论来讲，这些 domain 都应该是一个普通的 entity 对象，并非领域对象，所以请把包名改为:com.xxx.entity。

DTO

数据传输我们应该使用 DTO 对象作为传输对象，这是我们所约定的，因为很长时间我一直都在做移动端 API 设计的工作，有很多人告诉我，他们认为只有给手机端传输数据的时候(input or output)，这些对象成为 DTO 对象。

请注意！这种理解是错误的，只要是用于网络传输的对象，我们都认为他们可以当做是 DTO 对象，比如电商平台中，用户进行下单，下单后的数据，订单会发到 OMS 或者 ERP 系统，这些对接的返回值以及入参也叫 DTO 对象。

我们约定某对象如果是 DTO 对象，就将名称改为 XXDTO，比如订单下发OMS：OMSOrderInputDTO。

DTO 转化

正如我们所知，DTO 为系统与外界交互的模型对象，那么肯定会有一个步骤是将 DTO 对象转化为 BO 对象或者是普通的 entity 对象，让 service 层去处理。

场景

比如添加会员操作，由于用于演示，我只考虑用户的一些简单数据，当后台管理员点击添加用户时，只需要传过来用户的姓名和年龄就可以了，后端接受到数据后，将添加创建时间和更新时间和默认密码三个字段，然后保存数据库。

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

@RequestMapping("/v1/api/user")
@RestController
public class UserApi {

    @Autowired
    private UserService userService;

    @PostMapping
    public User addUser(UserInputDTO userInputDTO){
        User user = new User();
        user.setUsername(userInputDTO.getUsername());
        user.setAge(userInputDTO.getAge());

        return userService.addUser(user);
    }
}

我们只关注一下上述代码中的转化代码，其他内容请忽略：

1
2
3

User user = new User();
user.setUsername(userInputDTO.getUsername());
user.setAge(userInputDTO.getAge());

请使用工具

上边的代码，从逻辑上讲，是没有问题的，只是这种写法让我很厌烦，例子中只有两个字段，如果有 20 个字段，我们要如何做呢？ 一个一个进行 set 数据吗？当然，如果你这么做了，肯定不会有什么问题，但是，这肯定不是一个最优的做法。

网上有很多工具，支持浅拷贝或深拷贝的 Utils。举个例子，我们可以使用 org.springframework.beans.BeanUtils#copyProperties 对代码进行重构和优化：

1
2
3
4
5
6
7

@PostMapping
public User addUser(UserInputDTO userInputDTO){
    User user = new User();
    BeanUtils.copyProperties(userInputDTO,user);

    return userService.addUser(user);
}

BeanUtils.copyProperties 是一个浅拷贝方法，复制属性时，我们只需要把 DTO 对象和要转化的对象两个的属性值设置为一样的名称，并且保证一样的类型就可以了。如果你在做 DTO 转化的时候一直使用 set 进行属性赋值，那么请尝试这种方式简化代码，让代码更加清晰!

转化的语义

上边的转化过程，读者看后肯定觉得优雅很多，但是我们再写 Java 代码时，更多的需要考虑语义的操作，再看上边的代码：

1
2

User user = new User();
BeanUtils.copyProperties(userInputDTO,user);

虽然这段代码很好的简化和优化了代码，但是他的语义是有问题的，我们需要提现一个转化过程才好，所以代码改成如下：

1
2
3
4
5
6
7
8
9
10
11

@PostMapping
 public User addUser(UserInputDTO userInputDTO){
         User user = convertFor(userInputDTO);
         return userService.addUser(user);
 }

 private User convertFor(UserInputDTO userInputDTO){
         User user = new User();
         BeanUtils.copyProperties(userInputDTO,user);
         return user;
 }

这是一个更好的语义写法，虽然他麻烦了些，但是可读性大大增加了，在写代码时，我们应该尽量把语义层次差不多的放到一个方法中，比如：

1
2

User user = convertFor(userInputDTO);
return userService.addUser(user);

这两段代码都没有暴露实现，都是在讲如何在同一个方法中，做一组相同层次的语义操作，而不是暴露具体的实现。

抽象接口定义

当实际工作中，完成了几个 API 的 DTO 转化时，我们会发现，这样的操作有很多很多，那么应该定义好一个接口，让所有这样的操作都有规则的进行。

如果接口被定义以后，那么 convertFor 这个方法的语义将产生变化，它将是一个实现类。

看一下抽象后的接口：

1
2
3

public interface DTOConvert<S,T> {
    T convert(S s);
}

虽然这个接口很简单，但是这里告诉我们一个事情，要去使用泛型，如果你是一个优秀的 Java 程序员，请为你想做的抽象接口，做好泛型吧。

我们再来看接口实现：

1
2
3
4
5
6
7
8

public class UserInputDTOConvert implements DTOConvert {
@Override
public User convert(UserInputDTO userInputDTO) {
User user = new User();
BeanUtils.copyProperties(userInputDTO,user);
return user;
}
}

我们这样重构后，我们发现现在的代码是如此的简洁，并且那么的规范：

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

@RequestMapping("/v1/api/user")
@RestController
public class UserApi {

    @Autowired
    private UserService userService;

    @PostMapping
    public User addUser(UserInputDTO userInputDTO){
        User user = new UserInputDTOConvert().convert(userInputDTO);

        return userService.addUser(user);
    }
}

review code

如果你是一个优秀的 Java 程序员，我相信你应该和我一样，已经数次重复 review 过自己的代码很多次了。

我们再看这个保存用户的例子，你将发现，API 中返回值是有些问题的，问题就在于不应该直接返回 User 实体，因为如果这样的话，就暴露了太多实体相关的信息，这样的返回值是不安全的，所以我们更应该返回一个 DTO 对象，我们可称它为 UserOutputDTO：

1
2
3
4
5
6
7

@PostMapping
public UserOutputDTO addUser(UserInputDTO userInputDTO){
        User user = new UserInputDTOConvert().convert(userInputDTO);
        User saveUserResult = userService.addUser(user);
        UserOutputDTO result = new UserOutDTOConvert().convertToUser(saveUserResult);
        return result;
}

这样你的 API 才更健全。

不知道在看完这段代码之后，读者有是否发现还有其他问题的存在，作为一个优秀的 Java 程序员，请看一下这段我们刚刚抽象完的代码:

1

User user = new UserInputDTOConvert().convert(userInputDTO);

你会发现，new 这样一个 DTO 转化对象是没有必要的，而且每一个转化对象都是由在遇到 DTO 转化的时候才会出现，那我们应该考虑一下，是否可以将这个类和 DTO 进行聚合呢，看一下我的聚合结果:

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

public class UserInputDTO {
private String username;
private int age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    public User convertToUser(){
        UserInputDTOConvert userInputDTOConvert = new UserInputDTOConvert();
        User convert = userInputDTOConvert.convert(this);
        return convert;
    }

    private static class UserInputDTOConvert implements DTOConvert<UserInputDTO,User> {
        @Override
        public User convert(UserInputDTO userInputDTO) {
            User user = new User();
            BeanUtils.copyProperties(userInputDTO,user);
            return user;
        }
    }

}

然后 API 中的转化则由：

1
2

User user = new UserInputDTOConvert().convert(userInputDTO);
User saveUserResult = userService.addUser(user);

变成了：

1
2

User user = userInputDTO.convertToUser();
User saveUserResult = userService.addUser(user);

我们再 DTO 对象中添加了转化的行为，我相信这样的操作可以让代码的可读性变得更强，并且是符合语义的。

再查工具类

再来看 DTO 内部转化的代码，它实现了我们自己定义的 DTOConvert 接口，但是这样真的就没有问题，不需要再思考了吗？

我觉得并不是，对于 Convert 这种转化语义来讲，很多工具类中都有这样的定义，这中 Convert 并不是业务级别上的接口定义，它只是用于普通 bean 之间转化属性值的普通意义上的接口定义，所以我们应该更多的去读其他含有 Convert 转化语义的代码。

我仔细阅读了一下 GUAVA 的源码，发现了 com.google.common.base.Convert 这样的定义：

1
2
3
4
5

public abstract class Converter<A, B> implements Function<A, B> {
    protected abstract B doForward(A a);
    protected abstract A doBackward(B b);
    //其他略
}

从源码可以了解到，GUAVA 中的 Convert 可以完成正向转化和逆向转化，继续修改我们 DTO 中转化的这段代码：

1
2
3
4
5
6
7
8

private static class UserInputDTOConvert implements DTOConvert<UserInputDTO,User> {
        @Override
        public User convert(UserInputDTO userInputDTO) {
                User user = new User();
                BeanUtils.copyProperties(userInputDTO,user);
                return user;
        }
}

修改后：

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

private static class UserInputDTOConvert extends Converter<UserInputDTO, User> {
         @Override
         protected User doForward(UserInputDTO userInputDTO) {
                 User user = new User();
                 BeanUtils.copyProperties(userInputDTO,user);
                 return user;
         }

         @Override
         protected UserInputDTO doBackward(User user) {
                 UserInputDTO userInputDTO = new UserInputDTO();
                 BeanUtils.copyProperties(user,userInputDTO);
                 return userInputDTO;
         }
 }

看了这部分代码以后，你可能会问，那逆向转化会有什么用呢？其实我们有很多小的业务需求中，入参和出参是一样的，那么我们变可以轻松的进行转化，我将上边所提到的 UserInputDTO 和 UserOutputDTO 都转成 UserDTO 展示给大家。

DTO：

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

public class UserDTO {
    private String username;
    private int age;

    public String getUsername() {
            return username;
    }

    public void setUsername(String username) {
            this.username = username;
    }

    public int getAge() {
            return age;
    }

    public void setAge(int age) {
            this.age = age;
    }


    public User convertToUser(){
            UserDTOConvert userDTOConvert = new UserDTOConvert();
            User convert = userDTOConvert.convert(this);
            return convert;
    }

    public UserDTO convertFor(User user){
            UserDTOConvert userDTOConvert = new UserDTOConvert();
            UserDTO convert = userDTOConvert.reverse().convert(user);
            return convert;
    }

    private static class UserDTOConvert extends Converter<UserDTO, User> {
            @Override
            protected User doForward(UserDTO userDTO) {
                    User user = new User();
                    BeanUtils.copyProperties(userDTO,user);
                    return user;
            }

            @Override
            protected UserDTO doBackward(User user) {
                    UserDTO userDTO = new UserDTO();
                    BeanUtils.copyProperties(user,userDTO);
                    return userDTO;
            }
    }

}

API：

1
2
3
4
5
6
7

@PostMapping
 public UserDTO addUser(UserDTO userDTO){
         User user =  userDTO.convertToUser();
         User saveResultUser = userService.addUser(user);
         UserDTO result = userDTO.convertFor(saveResultUser);
         return result;
 }

当然，上述只是表明了转化方向的正向或逆向，很多业务需求的出参和入参的 DTO 对象是不同的，那么你需要更明显的告诉程序：逆向是无法调用的：

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

private static class UserDTOConvert extends Converter<UserDTO, User> {
         @Override
         protected User doForward(UserDTO userDTO) {
                 User user = new User();
                 BeanUtils.copyProperties(userDTO,user);
                 return user;
         }

         @Override
         protected UserDTO doBackward(User user) {
                 throw new AssertionError("不支持逆向转化方法!");
         }
 }

看一下 doBackward 方法，直接抛出了一个断言异常，而不是业务异常，这段代码告诉代码的调用者，这个方法不是准你调用的，如果你调用，我就”断言”你调用错误了。

关于异常处理的更详细介绍，可以参考我之前的文章：如何优雅的设计 Java 异常（http://lrwinx.github.io/2016/04/28/%E5%A6%82%E4%BD%95%E4%BC%98%E9%9B%85%E7%9A%84%E8%AE%BE%E8%AE%A1java%E5%BC%82%E5%B8%B8/） ，应该可以帮你更好的理解异常。

bean 的验证

如果你认为我上边写的那个添加用户 API 写的已经非常完美了，那只能说明你还不是一个优秀的程序员。我们应该保证任何数据的入参到方法体内都是合法的。

为什么要验证

很多人会告诉我，如果这些 API 是提供给前端进行调用的，前端都会进行验证啊，你为什还要验证？

其实答案是这样的，我从不相信任何调用我 API 或者方法的人，比如前端验证失败了，或者某些人通过一些特殊的渠道(比如 Charles 进行抓包)，直接将数据传入到我的 API，那我仍然进行正常的业务逻辑处理，那么就有可能产生脏数据！

“对于脏数据的产生一定是致命”，这句话希望大家牢记在心，再小的脏数据也有可能让你找几个通宵！

jsr 303验证

hibernate 提供的 jsr 303 实现，我觉得目前仍然是很优秀的，具体如何使用，我不想讲，因为谷歌上你可以搜索出很多答案!

再以上班的 API 实例进行说明，我们现在对 DTO 数据进行检查：

1
2
3
4
5
6
7

public class UserDTO {
    @NotNull
    private String username;
    @NotNull
    private int age;
        //其他代码略
}

API 验证：

1
2
3
4
5
6
7

@PostMapping
    public UserDTO addUser(@Valid UserDTO userDTO){
            User user =  userDTO.convertToUser();
            User saveResultUser = userService.addUser(user);
            UserDTO result = userDTO.convertFor(saveResultUser);
            return result;
    }

我们需要将验证结果传给前端，这种异常应该转化为一个 api 异常(带有错误码的异常)。

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

@PostMapping
public UserDTO addUser(@Valid UserDTO userDTO, BindingResult bindingResult){
     checkDTOParams(bindingResult);

     User user =  userDTO.convertToUser();
     User saveResultUser = userService.addUser(user);
     UserDTO result = userDTO.convertFor(saveResultUser);
     return result;
}
private void checkDTOParams(BindingResult bindingResult){
     if(bindingResult.hasErrors()){
             //throw new 带验证码的验证错误异常
     }
}

BindingResult 是 Spring MVC 验证 DTO 后的一个结果集，可以参考spring 官方文档（http://spring.io/）。

检查参数后，可以抛出一个“带验证码的验证错误异常”，具体异常设计可以参考如何优雅的设计 Java 异常（http://lrwinx.github.io/2016/04/28/%E5%A6%82%E4%BD%95%E4%BC%98%E9%9B%85%E7%9A%84%E8%AE%BE%E8%AE%A1java%E5%BC%82%E5%B8%B8/）。

拥抱 lombok

上边的 DTO 代码，已经让我看的很累了，我相信读者也是一样，看到那么多的 Getter 和 Setter 方法，太烦躁了，那时候有什么方法可以简化这些呢。

请拥抱 lombok,它会帮助我们解决一些让我们很烦躁的问题

去掉 Setter 和 Getter

其实这个标题，我不太想说，因为网上太多，但是因为很多人告诉我，他们根本就不知道 lombok 的存在，所以为了让读者更好的学习，我愿意写这样一个例子：

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

@Setter
@Getter
public class UserDTO {
    @NotNull
    private String username;
    @NotNull
    private int age;

    public User convertToUser(){
        UserDTOConvert userDTOConvert = new UserDTOConvert();
        User convert = userDTOConvert.convert(this);
        return convert;
    }

    public UserDTO convertFor(User user){
        UserDTOConvert userDTOConvert = new UserDTOConvert();
        UserDTO convert = userDTOConvert.reverse().convert(user);
        return convert;
    }

    private static class UserDTOConvert extends Converter<UserDTO, User> {
        @Override
        protected User doForward(UserDTO userDTO) {
            User user = new User();
            BeanUtils.copyProperties(userDTO,user);
            return user;
        }

        @Override
        protected UserDTO doBackward(User user) {
            throw new AssertionError("不支持逆向转化方法!");
        }
    }

}

看到了吧，烦人的 Getter 和 Setter 方法已经去掉了。

但是上边的例子根本不足以体现 lombok 的强大。我希望写一些网上很难查到，或者很少人进行说明的 lombok 的使用以及在使用时程序语义上的说明。

比如:@Data,@AllArgsConstructor,@NoArgsConstructor..这些我就不进行一一说明了，请大家自行查询资料。

bean 中的链式风格

什么是链式风格？我来举个例子，看下面这个 Student 的 bean：

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

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public int getAge() {
        return age;
    }

    public Student setAge(int age) {
        return this;
    }
}

仔细看一下 set 方法，这样的设置便是 chain 的 style，调用的时候，可以这样使用：

1
2
3

Student student = new Student()
        .setAge(24)
        .setName("zs");

相信合理使用这样的链式代码，会更多的程序带来很好的可读性，那看一下如果使用 lombok 进行改善呢，请使用 @Accessors(chain = true)，看如下代码：

1
2
3
4
5
6
7

@Accessors(chain = true)
@Setter
@Getter
public class Student {
    private String name;
    private int age;
}

这样就完成了一个对于 bean 来讲很友好的链式操作。

静态构造方法

静态构造方法的语义和简化程度真的高于直接去 new 一个对象。比如 new 一个 List 对象，过去的使用是这样的：

1

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

看一下 guava 中的创建方式：

1

List<String> list = Lists.newArrayList();

Lists 命名是一种约定(俗话说：约定优于配置)，它是指 Lists 是 List 这个类的一个工具类，那么使用 List 的工具类去产生 List，这样的语义是不是要比直接 new 一个子类来的更直接一些呢，答案是肯定的，再比如如果有一个工具类叫做 Maps，那你是否想到了创建 Map 的方法呢：

1

HashMap<String, String> objectObjectHashMap = Maps.newHashMap();

好了，如果你理解了我说的语义，那么，你已经向成为 Java 程序员更近了一步了。

再回过头来看刚刚的 Student，很多时候，我们去写 Student 这个 bean 的时候，他会有一些必输字段，比如 Student 中的 name 字段，一般处理的方式是将 name 字段包装成一个构造方法，只有传入 name 这样的构造方法，才能创建一个 Student 对象。

接上上边的静态构造方法和必传参数的构造方法，使用 lombok 将更改成如下写法（@RequiredArgsConstructor 和 @NonNull）:

1
2
3
4
5
6
7
8

@Accessors(chain = true)
@Setter
@Getter
@RequiredArgsConstructor(staticName = "ofName")
public class Student {
    @NonNull private String name;
    private int age;
}

测试代码：

1

Student student = Student.ofName("zs");

这样构建出的 bean 语义是否要比直接 new 一个含参的构造方法(包含 name 的构造方法)要好很多。

当然，看过很多源码以后，我想相信将静态构造方法 ofName 换成 of 会先的更加简洁：

1
2
3
4
5
6
7
8

@Accessors(chain = true)
@Setter
@Getter
@RequiredArgsConstructor(staticName = "of")
public class Student {
        @NonNull private String name;
        private int age;
}

测试代码：

1

Student student = Student.of("zs");

当然他仍然是支持链式调用的：

1

Student student = Student.of("zs").setAge(24);

这样来写代码，真的很简洁，并且可读性很强。

使用 builder

Builder 模式我不想再多解释了，读者可以看一下《Head First》(设计模式) 的建造者模式。

今天其实要说的是一种变种的 builder 模式，那就是构建 bean 的 builder 模式，其实主要的思想是带着大家一起看一下 lombok 给我们带来了什么。

看一下 Student 这个类的原始 builder 状态:

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

public class Student {
    private String name;
    private int age;

    public String getName() {
            return name;
    }

    public void setName(String name) {
            this.name = name;
    }

    public int getAge() {
            return age;
    }

    public void setAge(int age) {
            this.age = age;
    }

    public static Builder builder(){
            return new Builder();
    }
    public static class Builder{
            private String name;
            private int age;
            public Builder name(String name){
                    this.name = name;
                    return this;
            }

            public Builder age(int age){
                    this.age = age;
                    return this;
            }

            public Student build(){
                    Student student = new Student();
                    student.setAge(age);
                    student.setName(name);
                    return student;
            }
    }

}

调用方式：

1

Student student = Student.builder().name("zs").age(24).build();

这样的 builder 代码，让我是在恶心难受，于是我打算用 lombok 重构这段代码：

1
2
3
4
5

@Builder
public class Student {
    private String name;
    private int age;
}

调用方式：

1

Student student = Student.builder().name("zs").age(24).build();

代理模式

正如我们所知的，在程序中调用 rest 接口是一个常见的行为动作，如果你和我一样使用过 spring 的 RestTemplate，我相信你会我和一样，对他抛出的非 http 状态码异常深恶痛绝。详解 Java 中的三种代理模式。

所以我们考虑将 RestTemplate 最为底层包装器进行包装器模式的设计：

1
2
3
4
5
6
7
8
9

public abstract class FilterRestTemplate implements RestOperations {
        protected volatile RestTemplate restTemplate;

        protected FilterRestTemplate(RestTemplate restTemplate){
                this.restTemplate = restTemplate;
        }

        //实现RestOperations所有的接口
}

然后再由扩展类对 FilterRestTemplate 进行包装扩展：

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

public class ExtractRestTemplate extends FilterRestTemplate {
    private RestTemplate restTemplate;
    public ExtractRestTemplate(RestTemplate restTemplate) {
            super(restTemplate);
            this.restTemplate = restTemplate;
    }

    public <T> RestResponseDTO<T> postForEntityWithNoException(String url, Object request, Class<T> responseType, Object... uriVariables)
                    throws RestClientException {
            RestResponseDTO<T> restResponseDTO = new RestResponseDTO<T>();
            ResponseEntity<T> tResponseEntity;
            try {
                    tResponseEntity = restTemplate.postForEntity(url, request, responseType, uriVariables);
                    restResponseDTO.setData(tResponseEntity.getBody());
                    restResponseDTO.setMessage(tResponseEntity.getStatusCode().name());
                    restResponseDTO.setStatusCode(tResponseEntity.getStatusCodeValue());
            }catch (Exception e){
                    restResponseDTO.setStatusCode(RestResponseDTO.UNKNOWN_ERROR);
                    restResponseDTO.setMessage(e.getMessage());
                    restResponseDTO.setData(null);
            }
            return restResponseDTO;
    }
}

包装器 ExtractRestTemplate 很完美的更改了异常抛出的行为，让程序更具有容错性。在这里我们不考虑 ExtractRestTemplate 完成的功能，让我们把焦点放在 FilterRestTemplate 上，“实现 RestOperations 所有的接口”,这个操作绝对不是一时半会可以写完的，当时在重构之前我几乎写了半个小时,如下：

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

public abstract class FilterRestTemplate implements RestOperations {

    protected volatile RestTemplate restTemplate;

    protected FilterRestTemplate(RestTemplate restTemplate) {
            this.restTemplate = restTemplate;
    }

    @Override
    public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
            return restTemplate.getForObject(url,responseType,uriVariables);
    }

    @Override
    public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
            return restTemplate.getForObject(url,responseType,uriVariables);
    }

    @Override
    public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {
            return restTemplate.getForObject(url,responseType);
    }

    @Override
    public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
            return restTemplate.getForEntity(url,responseType,uriVariables);
    }
    //其他实现代码略。。。
}

我相信你看了以上代码，你会和我一样觉得恶心反胃，后来我用 lombok 提供的代理注解优化了我的代码(@Delegate)：

1
2
3
4
5

@AllArgsConstructor
public abstract class FilterRestTemplate implements RestOperations {
    @Delegate
    protected volatile RestTemplate restTemplate;
}

这几行代码完全替代上述那些冗长的代码。

是不是很简洁，做一个拥抱 lombok 的程序员吧。

工具类的设计

工具类：存放了某一类事物存放工具方法的类。封装了一些常用Java操作方法,便于重复开发利用

　　命名：XxxUtil，XxxUtils，XxxTool，XxxHelper，XxxHelpers等　　比如：JdbcUtil

工具类存放的包：存放工具类

　　命名：util，utils，tool，helper，helpers等

工具类如何设计？

工具在开发中只需要存在一份即可

　　1）如果工具类没有使用static修饰，说明工具方法要用工具类的对象来调用。

　　　　此时把工具类设计成单例模式。

　　2）如果工具类使用static修饰，说明工具方法只需要用工具类的类名来调用即可。

　　　　此时必须把工具类的构造方法私有化（防止工具类的对象来调用静态方法）。

一般首选第二种，简单，在JDK中提供的工具类都是第二种。如java.Util.Arrays类。

1.如果工具类中的方法全部是静态方法，那么可以将工具类作为一个 abstract 抽象类。Spring 框架中存在大量的这样的使用。

2.如果工具类中有异常，请抛出，不要自己去 try-catch。更不要 try 了之后 e.printStackTrace() 。

3.工具类中要不要打印日志问题，尽量不要打印，像 log4j 这样的一些第三方日志框架也不要用。降低于第三方类库的依赖。

4.工具类中的方法非 static 的。那你可以将工具类定义为 final class，考虑到工具类应该不能被继承。在私有化它的构造函数，提供一个单例。

5.工具类的命名应该用 Util 结尾，例如 LogUtil。

工具类中的方法应该设计为静态的还是非静态的，这个没有统一的标准。各有各的好，参加大多数开源框架，static 的多一些。

工具类的设计，推荐大家多看看 Guava、Apache Commons。

像大名鼎鼎的 Hutool，它提到了工具类的 6 大设计思想：

​ 方法优先于对象、自动识别优于用户定义、便捷性与灵活性并存、适配与兼容、可选依赖原则、无侵入原则。

Hutool 中的工具类，既没有采用抽象类 abstract class 有没有采用 final class。所以我更喜欢 Spring、Guava、Apache Commons等框架的源码。

权限的设计

权限控制主要分为两块，认证（Authentication）与授权（Authorization）。认证之后确认了身份正确，业务系统就会进行授权，现在业界比较流行的模型就是RBAC（Role-Based Access Control）。

RBAC包含为下面四个要素：用户、角色、权限、资源。用户是源头，资源是目标，用户绑定至角色，资源与权限关联，最终将角色与权限关联，就形成了比较完整灵活的权限控制模型。
资源是最终需要控制的标的物，但是我们在一个业务系统中要将哪些元素作为待控制的资源呢？我将系统中待控制的资源分为三类：

1. URL访问资源（接口以及网页）
2. 界面元素资源（增删改查导入导出的按钮，重要的业务数据展示与否等）
3. 数据资源

用户对应角色，（用户多的时候可以用用户组扩展），角色对应多个权限，权限对应多个资源（每个资源都有各自的表和其维护表），权限操作需要有记录表

现在业内普遍的实现方案实际上很粗放，就是单纯的“菜单控制”，通过菜单显示与否来达到控制权限的目的。
我仔细分析过，现在大家做的平台分为To C和To B两种：

1. To C一般不会有太多的复杂权限控制，甚至大部分连菜单控制都不用，全部都可以访问。
2. To B一般都不是开放的，只要做好认证关口，能够进入系统的只有内部员工。大部分企业内部的员工互联网知识有限，而且作为内部员工不敢对系统进行破坏性的尝试。

所以针对现在的情况，考虑成本与产出，大部分设计者也不愿意在权限上进行太多的研发力量。
菜单和界面元素一般都是由前端编码配合存储数据实现，URL访问资源的控制也有一些框架比如SpringSecurity，Shiro。
目前我还没有找到过数据权限控制的框架或者方法，所以自己整理了一份。

数据权限控制原理

数据权限控制最终的效果是会要求在同一个数据请求方法中，根据不同的权限返回不同的数据集，而且无需并且不能由研发编码控制。这样大家的第一想法应该就是AOP，拦截所有的底层方法，加入过滤条件。这样的方式兼容性较强，但是复杂程度也会更高。我们这套系统中，采用的是利用Mybatis的plugin机制，在底层SQL解析时替换增加过滤条件。
这样一套控制机制存在很明显的优缺点，首先缺点：

1. 适用性有限，基于底层的Mybatis。
2. 方言有限，针对了某种数据库（我们使用Mysql），而且由于需要在底层解析处理条件所以有可能造成不同的数据库不能兼容。当然Redis和NoSQL也无法限制。

当然，假如你现在就用Mybatis，而且数据库使用的是Mysql，这方面就没有太大影响了。

接下来说说优点：

1. 减少了接口数量及接口复杂度。原本针对不同的角色，可能会区分不同的接口或者在接口实现时利用流程控制逻辑来区分不同的条件。有了数据权限控制，代码中只用写基本逻辑，权限过滤由底层机制自动处理。
2. 提高了数据权限控制的灵活性。例如原本只有主管能查本部门下组织架构/订单数据，现在新增助理角色，能够查询本部门下组织架构，不能查询订单。这样的话普通的写法就需要调整逻辑控制，使用数据权限控制的话，直接修改配置就好。

数据权限实现

上一节就提及了实现原理，是基于Mybatis的plugins（查看官方文档）实现。

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：
Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)

Mybatis的插件机制目前比较出名的实现应该就是PageHelper项目了，在做这个实现的时候也参考了PageHelper项目的实现方式。所以权限控制插件的类命名为PermissionHelper。
机制是依托于Mybatis的plugins机制，实际SQL处理的时候基于jsqlparser这个包。
设计中包含两个类，一个是保存角色与权限的实体类命名为PermissionRule，一个是根据实体变更底层SQL语句的主体方法类PermissionHelper。

首先来看下PermissionRule的结构：

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

public class PermissionRule {

    private static final Log log = LogFactory.getLog(PermissionRule.class);
    /**
     * codeName<br>
     * 适用角色列表<br>
     * 格式如: ,RoleA,RoleB,
     */
    private String roles;
    /**
     * codeValue<br>
     * 主实体，多表联合
     * 格式如: ,SystemCode,User,
     */
    private String fromEntity;
    /**
     * codeDesc<br>
     * 过滤表达式字段, <br>
     * <code>{uid}</code>会自动替换为当前用户的userId<br>
     * <code>{me}</code> main entity 主实体名称
     * <code>{me.a}</code> main entity alias 主实体别名
     * 格式如：
     * <ul>
     * <li>userId = {uid}</li>
     * <li>(userId = {uid} AND authType > 3)</li>
     * <li>((userId = {uid} AND authType) > 3 OR (dept in (select dept from depts where manager.id = {uid})))</li>
     * </ul>
     */
    private String exps;

    /**
     * codeShowName<br>
     * 规则说明
     */
    private String ruleComment;

}

看完这个结构，基本能够理解设计的思路了。数据结构中保存如下几个字段：

• 角色列表：需要使用此规则的角色，可以多个，使用英文逗号隔开。
• 实体列表：对应的规则应用的实体（这里指的是表结构中的表名，可能你的实体是驼峰而数据库是蛇形，所以这里要放蛇形那个），可以多个，使用英文逗号隔开。
• 表达式：表达式就是数据权限控制的核心了。简单的说这里的表达式就是一段SQL语句，其中设置了一些可替换值，底层会用对应运行时的变量替换对应内容，从而达到增加条件的效果。
• 规则说明：单纯的一个说明字段。

核心流程
系统启动时，首先从数据库加载出所有的规则。底层利用插件机制来拦截所有的查询语句，进入查询拦截方法后，首先根据当前用户的权限列表筛选出PermissionRule列表，然后循环列表中的规则，对语句中符合实体列表的表进行条件增加，最终生成处理后的SQL语句，退出拦截器，Mybatis执行处理后SQL并返回结果。

讲完PermissionRule，再来看看PermissionHelper，首先是头：

1
2
3
4

@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class PermissionHelper implements Interceptor {
}

头部只是标准的Mybatis拦截器写法，注解中的Signature决定了你的代码对哪些方法拦截，update实际上针对修改（Update）、删除（Delete）生效，query是对查询（Select）生效。

下面给出针对Select注入查询条件限制的完整代码：

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

private String processSelectSql(String sql, List<PermissionRule> rules, UserDefaultZimpl principal) {
    try {
        String replaceSql = null;
        Select select = (Select) CCJSqlParserUtil.parse(sql);
        PlainSelect selectBody = (PlainSelect) select.getSelectBody();
        String mainTable = null;
        if (selectBody.getFromItem() instanceof Table) {
            mainTable = ((Table) selectBody.getFromItem()).getName().replace("`", "");
        } else if (selectBody.getFromItem() instanceof SubSelect) {
            replaceSql = processSelectSql(((SubSelect) selectBody.getFromItem()).getSelectBody().toString(), rules, principal);
        }
        if (!ValidUtil.isEmpty(replaceSql)) {
            sql = sql.replace(((SubSelect) selectBody.getFromItem()).getSelectBody().toString(), replaceSql);
        }
        String mainTableAlias = mainTable;
        try {
            mainTableAlias = selectBody.getFromItem().getAlias().getName();
        } catch (Exception e) {
            log.debug("当前sql中， " + mainTable + " 没有设置别名");
        }


        String condExpr = null;
        PermissionRule realRuls = null;
        for (PermissionRule rule :
                rules) {
            for (Object roleStr :
                    principal.getRoles()) {
                if (rule.getRoles().indexOf("," + roleStr + ",") != -1) {
                    if (rule.getFromEntity().indexOf("," + mainTable + ",") != -1) {
                        // 若主表匹配规则主体，则直接使用本规则
                        realRuls = rule;

                        condExpr = rule.getExps().replace("{uid}", UserDefaultUtil.getUserId().toString()).replace("{bid}", UserDefaultUtil.getBusinessId().toString()).replace("{me}", mainTable).replace("{me.a}", mainTableAlias);
                        if (selectBody.getWhere() == null) {
                            selectBody.setWhere(CCJSqlParserUtil.parseCondExpression(condExpr));
                        } else {
                            AndExpression and = new AndExpression(selectBody.getWhere(), CCJSqlParserUtil.parseCondExpression(condExpr));
                            selectBody.setWhere(and);
                        }
                    }

                    try {
                        String joinTable = null;
                        String joinTableAlias = null;
                        for (Join j :
                                selectBody.getJoins()) {
                            if (rule.getFromEntity().indexOf("," + ((Table) j.getRightItem()).getName() + ",") != -1) {
                                // 当主表不能匹配时，匹配所有join，使用符合条件的第一个表的规则。
                                realRuls = rule;
                                joinTable = ((Table) j.getRightItem()).getName();
                                joinTableAlias = j.getRightItem().getAlias().getName();

                                condExpr = rule.getExps().replace("{uid}", UserDefaultUtil.getUserId().toString()).replace("{bid}", UserDefaultUtil.getBusinessId().toString()).replace("{me}", joinTable).replace("{me.a}", joinTableAlias);
                                if (j.getOnExpression() == null) {
                                    j.setOnExpression(CCJSqlParserUtil.parseCondExpression(condExpr));
                                } else {
                                    AndExpression and = new AndExpression(j.getOnExpression(), CCJSqlParserUtil.parseCondExpression(condExpr));
                                    j.setOnExpression(and);
                                }
                            }
                        }
                    } catch (Exception e) {
                        log.debug("当前sql没有join的部分！");
                    }
                }
            }
        }
        if (realRuls == null) return sql; // 没有合适规则直接退出。

        if (sql.indexOf("limit ?,?") != -1 && select.toString().indexOf("LIMIT ? OFFSET ?") != -1) {
            sql = select.toString().replace("LIMIT ? OFFSET ?", "limit ?,?");
        } else {
            sql = select.toString();
        }

    } catch (JSQLParserException e) {
        log.error("change sql error .", e);
    }
    return sql;
}

重点思路
重点其实就在于Sql的解析和条件注入，使用开源项目JSqlParser。

• 解析出MainTable和JoinTable。from之后跟着的称为MainTable，join之后跟着的称为JoinTable。这两个就是我们PermissionRule需要匹配的表名，PermissionRule::fromEntity字段。
• 解析出MainTable的where和JoinTable的on后面的条件。使用and连接原本的条件和待注入的条件，PermissionRule::exps字段。
• 使用当前登录的用户信息（放在缓存中），替换条件表达式中的值。
• 某些情况需要忽略权限，可以考虑使用ThreadLocal（单机）/Redis（集群）来控制。

想要达到无感知的数据权限控制，只有机制控制这么一条路。本文选择的是通过底层拦截Sql语句，并且针对对应表注入条件语句这么一种做法。应该是非常经济的做法，只是基于文本处理，不会给系统带来太大的负担，而且能够达到理想中的效果。大家也可以提出其他的见解和思路

电商项目

SPU表

标题（商品名称），副标题（商品描述），几个ID（所属的目录），是否上架，是否有效，添加时间，删除时间。

SKU表

spu_id，商品标题，图片（多个以，分开），销售价格，参数，是否有效，创建时间和修改时间。

kind表

商品的种类，上级菜单分类

订单号的生成

常见的订单基本都14-20位，(年月日时分秒和随机数)基本上就有14位

要求：

1.全局唯一性：不能出现重复的ID号，既然是唯一标识，这是最基本的要求。
2.趋势递增：在MySQL InnoDB引擎中使用的是聚集索引，由于多数RDBMS使用B-tree的数据结构来存储索引数据，在主键的选择上面我们应该尽量使用有序的主键保证写入性能。
3.单调递增：保证下一个ID一定大于上一个ID，例如事务版本号、IM增量消息、排序等特殊需求。
4.信息安全：如果ID是连续的，恶意用户的扒取工作就非常容易做了，直接按照顺序下载指定URL即可；如果是订单号就更危险了，竞对可以直接知道我们一天的单量。所以在一些应用场景下，会需要ID无规则、不规则。

123对应三类不同的场景，3和4需求还是互斥的，无法使用同一个方案满足

所以ID生产系统：

1.平均延迟和TP999延迟都要尽可能低；
2.可用性5个9；
3.高QPS。

考虑客户体验：

1.订单号无重复性；
2.如果方便客服的话，最好是“日期+自增数”样式的订单号，客服一看便知道订单是否在退货保障期限内容；
3.订单号长度尽量保持短（10位以内），方便用户，尤其电话投诉时，长的号码报错几率高，影响客服效率；
4.订单号尽量保持数字型(纯整数)，在数据库订单索引查询中，长整数字型的数据索引与检索效率，远远高于文本型，因此尽量避免“字母+数字字符串式”！

在复杂的分布式系统中，很多场景需要的都是全局唯一ID的场景，一般为了防止冲突可以考虑的有36位的UUID,twitter的snowflake（雪花算法）等。

1. UUID, 组成：当前日期+时间+时钟序列+机器识别号（Mac地址或其他）没有mac网卡的话会有别的东西识别。在分布式系统中，所有元素（WEB服务器）都不需要通过中央控制端来判断数据唯一性。几十年之内可以达到全球唯一性。
2. Mysql通过AUTO_INCREMENT实现、Oracle通过Sequence序列实现。在数据库集群环境下，不同数据库节点可设置不同起步值、相同步长来实现集群下生产全局唯一、递增ID
3. Snowflake算法 雪花算法。41位时间戳+10位机器ID+12位序列号（自增） 转化长度为18位的长整型。Twitter为满足美秒上万条消息的创建，且ID需要趋势递增，方便客户端排序。Snowflake虽然有同步锁，但是比uuid效率高。
4. Redis自增ID。实现了incr(key)用于将key的值递增1，并返回结果。如果key不存在，创建默认并赋值为0。 具有原子性，保证在并发的时候。
5. 拼接应用所在的网络ip。或者应用所在的端口号。或者进程ID。或者以上的组合保证唯一。

例：

0/1:0为游客下单，1为公司下单

• 商户ID的传入(传入商户ID是为了防止重复订单的，但是不起作用)
• 毫秒仅保留三位(缩减长度同时保证应用切换不存在重复的可能)
• 使用线程安全的计数器做数字递增(三位数最低保证并发800不重复,代码中我给了4位)
• 更换日期转换为java8的日期类以格式化(线程安全及代码简洁性考量)

1
2
3
4
5
6
7
8
9
10
11

/** 订单号生成(NEW) **/
private static final AtomicInteger SEQ = new AtomicInteger(1000);
private static final DateTimeFormatter DF_FMT_PREFIX = DateTimeFormatter.ofPattern("yyMMddHHmmssSS");
private static ZoneId ZONE_ID = ZoneId.of("Asia/Shanghai");
public static String generateOrderNo(){
    LocalDateTime dataTime = LocalDateTime.now(ZONE_ID);
    if(SEQ.intValue()>9990){
        SEQ.getAndSet(1000);
    }
    return  dataTime.format(DF_FMT_PREFIX)+SEQ.getAndIncrement();
}

雪花算法：100万个ID 耗时２秒

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
123
124
125
126

public class IdWorker {

    /**
     * 起始的时间戳
     */
    private final static long START_STMP = 1530795377086L;

    /**
     * 每一部分占用的位数
     */

    /**
     * 序列号占用的位数
     */
    private final static long SEQUENCE_BIT = 12;

    /**
     * 机器标识占用的位数
     */
    private final static long MACHINE_BIT = 5;

    /**
     * 数据中心占用的位数
     */
    private final static long DATACENTER_BIT = 5;

    /**
     * 每一部分的最大值
     */
    private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);
    private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
    private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);

    /**
     * 每一部分向左的位移
     */
    private final static long MACHINE_LEFT = SEQUENCE_BIT;
    private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
    private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;

    /**
     * 数据中心
     */
    private long datacenterId;

    /**
     * 机器标识
     */
    private long machineId;
    /**
     * 序列号
     */
    private long sequence = 0L;

    /**
     * 上一次时间戳
     */
    private long lastStmp = -1L;

    public IdWorker(long datacenterId, long machineId) {
        if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {
            throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");
        }
        if (machineId > MAX_MACHINE_NUM || machineId < 0) {
            throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");
        }
        this.datacenterId = datacenterId;
        this.machineId = machineId;
    }

    /**
     * 产生下一个ID
     * @return
     */
    public synchronized long nextId() {
        long currStmp = getNewstmp();
        if (currStmp < lastStmp) {
            throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
        }

        if (currStmp == lastStmp) {
            //相同毫秒内，序列号自增
            sequence = (sequence + 1) & MAX_SEQUENCE;
            //同一毫秒的序列数已经达到最大
            if (sequence == 0L) {
                currStmp = getNextMill();
            }
        } else {
            //不同毫秒内，序列号置为0
            sequence = 0L;
        }

        lastStmp = currStmp;

        return (
                //时间戳部分
                currStmp - START_STMP) << TIMESTMP_LEFT
                //数据中心部分
                | datacenterId << DATACENTER_LEFT
                //机器标识部分
                | machineId << MACHINE_LEFT
                //序列号部分
                | sequence;
    }

    private long getNextMill() {
        long mill = getNewstmp();
        while (mill <= lastStmp) {
            mill = getNewstmp();
        }
        return mill;
    }

    private long getNewstmp() {
        return System.currentTimeMillis();
    }

    public static void main(String[] args) {
        IdWorker snowFlake = new IdWorker(2, 3);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            System.out.println(snowFlake.nextId());
        }
        System.out.println(System.currentTimeMillis() - start);
    }
}

一致性和性能的思考

1、性能和一致性不能同时满足，为了性能考虑，通常会采用「最终一致性」的方案

2、掌握缓存和数据库一致性问题，核心问题有 3 点：缓存利用率、并发、缓存 + 数据库一起成功问题

3、失败场景下要保证一致性，常见手段就是「重试」，同步重试会影响吞吐量，所以通常会采用异步重试的方案

4、订阅变更日志的思想，本质是把权威数据源（例如 MySQL）当做 leader 副本，让其它异质系统（例如 Redis / Elasticsearch）成为它的 follower 副本，通过同步变更日志的方式，保证 leader 和 follower 之间保持一致

项目的思考

1.如果前端需要多个DTO，而不同业务的DTO有99%可以复用，我是需要根据业务生成多个DTO（一个接口一个DTO）传还是都复用一个DTO（多个接口公用一个DTO，虽然很多属性没有用到）？

答：

2.向项目里使用新技术时，我在加的时候是否需要重写之前的方法以适用新技术？这是否违反了开闭原则？

答：

3.如果业务里只有一个方法需要处理，需要等待这个方法的结果再返回给前端，还是异步这个方法，交给其他线程去处理？哪种客户体验更好？

答：

4.web端项目后端怎么主动发消息给前端？前端可能关闭了网页则连接就断了

答：

5.延时处理：过期自动收货，到期自动删除？

答：

6.springboot项目的DTO和VO的分类？Controller层、Service层代码应该放什么？Service层的接口是否真的有必要？

7.业务代码里重复的方法太多，不知道怎么提取公共部分，如果提取了公共部分，一些切面就无法执行，如果为了执行再加切面，是否会影响性能？如果存在两个方法的大致逻辑都一样，只是一些不一样，我该怎么抽取公共？比如说一个方法A，参数是1，业务里根据参数1查对应的表得出11，在根据11继续逻辑；方法B，参数是2，业务里根据参数2查对应的表得出22，在根据22继续逻辑。11和22是不同的表，我该怎么抽取公共代码？

8.功能重要还是性能重要？比如加一个新东西可以实现某项功能，但是会严重消耗性能，我该怎么取舍？（这个功能可能有用可能鸡肋，这个功能和性能的平衡点在哪）

9.对于一个新功能或者新技术的引用，可能会耗费大量时间，在这期间产品不会更新或者进度很慢，是否值得？（怎么向老板解释长时间不出活是为了后期更高的性能）

项目

​ 程序员与代码密不可分，而代码又是为了项目服务的，项目又可以集合成一个产品，而产品最终是要为我们服务的。为什么会有计算机的存在，是因为人类想要一种机器帮助我们简化计算，为什么会有代码的存在，是因为人类想要计算机更易懂我们的想法，为什么会有项目的存在，是因为我们需要计算机可以将我们的想法完整表达出来，为什么会有产品存在，说到底，是人类的进化使我们想要更高效的生活。所以说，如何做一个产品？产品是我们最终想要的结果，项目明确了我们的需求，代码只是底层实现，计算机，执行者罢了。所以这篇文章，写一写怎样开始着手于写一个项目。

项目前的准备

​ 写项目之前，首先要明确，你的需求是什么，你想要一个什么样的产品。明确需求很重要，否则你写出来的东西很有可能不是你或者别人想要的东西。一千个哈姆雷特，每个人都有自己的想法，而完成一个别人的项目，需要完成的，就是实现别人的想法。所以大方向很重要。

​ 明确真实需求后，怎么样实现需求呢？要做到心中有数，需要我们在自己心中建立起一个框架。要明确分为几个模块，每个模块会用到什么东西,具体的流程是什么样的，做到心中有数，自可万法归一，行云流水。

​ 工欲善其事必先利其器，为了更高效简洁的开发，我们需要准备好我们的工具。首先就是自己常用且顺手的各种工具，然后是可能已有的框架，一个逻辑的既定代码，造轮子固然可以提高自己的技术，但是重复造轮子就属实没有必要了。

需求文档，定义功能，界面，原型图，数据库设计，接口设计

具体流程

1.明确需求

2.搭建环境

3.找轮子

4.建数据库，建表

5.建类

6.思考设计模式

7.梳理接口，确定开发排期

8.写代码，写单测

9.前后端对接

10.产品验收，上线

项目构思框架

​ 一个完整的项目，必定会有前后端。前端负责展示效果，后端负责处理逻辑。

前端

1.router.js

路由页面。负责网页地址的跳转

2.main.js

导入资源页面。负责导入用到的相关框架或者包。

3.view

vue的前端显示的页面。

包括三部分：

- html元素
- js代码
- css样式

components：部件。可以在这里设定上端、下端的固定样式，可以用到每个页面。

4.utils

工具类。

5.assets/static/public

存放静态资源。

6.request

跨域请求

后端

1.pom.xml

maven的配置文件。

2.controller层

控制层，一般在src下的java下。

3.service层

逻辑层，一般在src下的java下。

4.Mapper层

数据库层，src下的resources下的是数据库表字段的配置文件，src下的java下的是sql语句。

5.entity，pojo

实体类，一般在src下的java下。

6.exception

异常

7.utils

工具

8.filter

过滤，拦截器

9.config

配置

10.dto

自定义数据结构

用到的相关依赖

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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
        <mybatis-plus-boot-starter.version>3.4.0</mybatis-plus-boot-starter.version>
        <mysql.version>5.1.40</mysql.version>
        <commons-lang3.version>3.6</commons-lang3.version>
        <hutool-all.version>4.6.2</hutool-all.version>
        <springfox.version>2.9.1</springfox.version>
        <fastjson.version>1.2.13</fastjson.version>
    </properties>
    <distributionManagement>
        <snapshotRepository>
            <id>sonatype-nexus-snapshots</id>
            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
        </snapshotRepository>
        <repository>
            <id>sonatype-nexus-staging</id>
            <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
        </repository>
    </distributionManagement>
    <scm>
        <connection></connection>
        <developerConnection></developerConnection>
        <url></url>
    </scm>
    <dependencies>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-core</artifactId>
            <version>4.0.6</version> <!-- 注：如提示报错，先升级基础包版，无法解决可联系技术支持 -->
        </dependency>

        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>aliyun-java-sdk-dysmsapi</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- mybatis-plus begin =================================== -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus-boot-starter.version}</version>
        </dependency>
        <!-- mybatis-plus end -->


        <!-- ========================= 数据库相关 ========================== -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>druid</artifactId>
             <version>1.1.22</version>
         </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>

        <!-- ========================= 常用库依赖 ========================== -->

        <!-- lombok插件 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- Hutool工具类 -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool-all.version}</version>
        </dependency>

        <!-- StringUtils工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>

        <!-- 阿里FastJson转换工具依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>

        <!-- AOP依赖 【注：系统日记需要此依赖】 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!--httpclient-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.10</version>
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.10</version>
        </dependency>

        <!-- swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${springfox.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.mapstruct</groupId>
                    <artifactId>mapstruct</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${springfox.version}</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-bean-validators</artifactId>
            <version>${springfox.version}</version>
        </dependency>
        <!--poi相关-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.9</version>
        </dependency>

    </dependencies>

    <build>

        <!-- 注：maven默认是不编译，因此加上如下resources才会生产对应的xml文件 目的：解决mybatis映射关系不对应问题  start =============== -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
                <!--是否替换资源中的属性-->
                <filtering>false</filtering>
            </resource>
        </resources>
        <testResources>
            <testResource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </testResource>
        </testResources>
        <!-- 注：maven默认是不编译，因此加上如下resources才会生产对应的xml文件 目的：解决mybatis映射关系不对应问题  end =============== -->

        <plugins>
            <plugin>
                <groupId>org.sonatype.plugins</groupId>
                <artifactId>nexus-staging-maven-plugin</artifactId>
                <version>1.6.3</version>
                <extensions>true</extensions>
                <configuration>
                    <serverId>sonatype-nexus-staging</serverId>
                    <nexusUrl>https://oss.sonatype.org/</nexusUrl>
                    <autoReleaseAfterClose>true</autoReleaseAfterClose>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

前后端的对接规范

1.使用MybatisPlus的R返回值。

R是com.baomidou.mybatisplus.extension.api中写好的一个统一结果返回集。主要包含code，data，msg

**R(IErrorCode errorCode)**： {data:null,code:errorCode.getCode(),msg:errorCode.getMsg()}

R.ok(T data): 默认情况下：{data:data,code:0,msg:执行成功} 如果data为Boolean类型且就是false:{data:false,code:-1,msg:操作失败}

R.failed(String msg): {data:null,code:-1,msg:msg}

R.failed(IErrorCode errorCode) : {data:null,code:errorCode.getCode(),msg:errorCode.getMsg()}

R.restResult(T data, IErrorCode errorCode) : {data:data,code:errorCode.getCode(),msg:errorCode.getMsg()}

R.restResult(T data, long code, String msg): {data:data,code:code,msg:msg}

可以自己定义枚举类实现IErrorCode接口,例如自定义一个IErrorCode

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

public enum ResApiFailCode implements IErrorCode {
    FAILED(-1L, "出错了"),
    INVALID_PARAM(-2L, "参数异常");
    
    private final long code;
    private final String msg;

    ResApiFailCode(final long code, final String msg) {
        this.code = code;
        this.msg = msg;
    }

    @Override
    public long getCode() {
        return this.code;
    }

    @Override
    public String getMsg() {
        return this.msg;
    }

    @Override
    public String toString() {
        return String.format(" ErrorCode:{code=%s, msg=%s} ", this.code, this.msg);
}

    使用时使用：return R.restResult(null, ResApiFailCode.FAILED);

对于异常也需要做处理：

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

@Slf4j
@ControllerAdvice
@Component("myGlobalExceptionHandler")
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public R<?> defaultExceptionHandler(Exception e) {
        log.info("这里处理错误，错误信息是：{}", e.toString());
        //常见异常返回
        if (e instanceof CommonException) {
            String message = e.getMessage();
            return R.failed(message);
        } else if (e instanceof UserNotExistException) {
            return R.failed(ResApiFailCode.NO_PERMISSION);
        } else if (e instanceof ClientException) {
            return R.failed(ResApiFailCode.WRONG_SERVER);
        }
        //运行时异常返回
        return R.restResult(null, ResApiFailCode.FAILED);
    }
}

2.使用SpringBoot提供的ResponseBodyAdvice

ResponseBodyAdvice的作用：拦截Controller方法的返回值，统一处理返回值/响应体，一般用来统一返回格式，加解密，签名等等

首先需要定义返回格式

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

@Data
public class ResultData<T> {
  /** 结果状态 ,具体状态码参见ResultData.java*/
  private int status;
  private String message;
  private T data;
  private long timestamp ;


  public ResultData (){
    this.timestamp = System.currentTimeMillis();
  }


  public static <T> ResultData<T> success(T data) {
    ResultData<T> resultData = new ResultData<>();
    resultData.setStatus(ReturnCode.RC100.getCode());
    resultData.setMessage(ReturnCode.RC100.getMessage());
    resultData.setData(data);
    return resultData;
  }

  public static <T> ResultData<T> fail(int code, String message) {
    ResultData<T> resultData = new ResultData<>();
    resultData.setStatus(code);
    resultData.setMessage(message);
    return resultData;
  }

}

再定义状态码

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

public enum ReturnCode {
    /**操作成功**/
    RC100(100,"操作成功"),
    /**操作失败**/
    RC999(999,"操作失败"),
    /**服务限流**/
    RC200(200,"服务开启限流保护,请稍后再试!"),
    /**服务降级**/
    RC201(201,"服务开启降级保护,请稍后再试!"),
    /**热点参数限流**/
    RC202(202,"热点参数限流,请稍后再试!"),
    /**系统规则不满足**/
    RC203(203,"系统规则不满足要求,请稍后再试!"),
    /**授权规则不通过**/
    RC204(204,"授权规则不通过,请稍后再试!"),
    /**access_denied**/
    RC403(403,"无访问权限,请联系管理员授予权限"),
    /**access_denied**/
    RC401(401,"匿名用户访问无权限资源时的异常"),
    /**服务异常**/
    RC500(500,"系统异常，请稍后重试"),

    INVALID_TOKEN(2001,"访问令牌不合法"),
    ACCESS_DENIED(2003,"没有权限访问该资源"),
    CLIENT_AUTHENTICATION_FAILED(1001,"客户端认证失败"),
    USERNAME_OR_PASSWORD_ERROR(1002,"用户名或密码错误"),
    UNSUPPORTED_GRANT_TYPE(1003, "不支持的认证模式");



    /**自定义状态码**/
    private final int code;
    /**自定义描述**/
    private final String message;

    ReturnCode(int code, String message){
        this.code = code;
        this.message = message;
    }


    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

再需要编写一个具体实现类：

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

@RestControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice<Object> {
    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }

    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        if(o instanceof String){
            //如果Controller直接返回String的话，SpringBoot是直接返回，故我们需要手动转换成json
            return objectMapper.writeValueAsString(ResultData.success(o));
        }      
        if(o instanceof ResultData){
   			return o;
  		}
        return ResultData.success(o);
    }
}

注：@RestControllerAdvice注解@RestControllerAdvice是@RestController注解的增强，可以实现三个方面的功能：

1.全局异常处理

2.全局数据绑定

3.全局数据预处理

对于异常，也需要统一返回格式：

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

@Slf4j
@RestControllerAdvice
public class RestExceptionHandler {
    /**
     * 默认全局异常处理。
     * @param e the e
     * @return ResultData
     */
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ResultData<String> exception(Exception e) {
        log.error("全局异常信息 ex={}", e.getMessage(), e);
        return ResultData.fail(ReturnCode.RC500.getCode(),e.getMessage());
    }

}

注：

1.@RestControllerAdvice，RestController的增强类，可用于实现全局异常处理器

2.@ExceptionHandler,统一处理某一类异常，从而减少代码重复率和复杂度，比如要获取自定义异常可以@ExceptionHandler(BusinessException.class)

3.@ResponseStatus指定客户端收到的http状态码

数据库

参考文章：https://www.cnblogs.com/macoffee/p/13475320.html

单表行数超过 500 万行或者单表容量超过 2GB，推荐进行分库分表。预计三年后的数据量根本达不到这个级别，不要在创建表时就分库分表

• 1.数据库设计和表创建时就要考虑性能
• 2.sql的编写需要注意优化
• 4.分区
• 4.分表
• 5.分库

设计表时要注意：

表字段避免null值出现，null值很难查询优化且占用额外的索引空间，推荐默认数字0代替null。
尽量使用INT而非BIGINT，如果非负则加上UNSIGNED（这样数值容量会扩大一倍），当然能使用TINYINT、SMALLINT、MEDIUM_INT更好。

数据库表的id的类型：最好int，数据量大的用bigint
使用枚举或整数代替字符串类型
尽量使用TIMESTAMP而非DATETIME
单表不要有太多字段，建议在20以内
用整型来存IP
索引

索引并不是越多越好，要根据查询有针对性的创建，考虑在WHERE和ORDER BY命令上涉及的列建立索引，可根据EXPLAIN来查看是否用了索引还是全表扫描
应尽量避免在WHERE子句中对字段进行NULL值判断，否则将导致引擎放弃使用索引而进行全表扫描
值分布很稀少的字段不适合建索引，例如”性别”这种只有两三个值的字段
字符字段只建前缀索引
字符字段最好不要做主键
不用外键，由程序保证约束
尽量不用UNIQUE，由程序保证约束
使用多列索引时主意顺序和查询条件保持一致，同时删除不必要的单列索引
简言之就是使用合适的数据类型，选择合适的索引

选择合适的数据类型

（1）使用可存下数据的最小的数据类型，整型 < date,time < char,varchar < blob
（2）使用简单的数据类型，整型比字符处理开销更小，因为字符串的比较更复杂。如，int类型存储时间类型，bigint类型转ip函数
（3）使用合理的字段属性长度，固定长度的表会更快。使用enum、char而不是varchar
（4）尽可能使用not null定义字段
（5）尽量少用text，非用不可最好分表

选择合适的索引列

（1）查询频繁的列，在where，group by，order by，on从句中出现的列
（2）where条件中<，<=，=，>，>=，between，in，以及like 字符串+通配符（%）出现的列
（3）长度小的列，索引字段越小越好，因为数据库的存储单位是页，一页中能存下的数据越多越好
（4）离散度大（不同的值多）的列，放在联合索引前面。查看离散度，通过统计不同的列值来实现，count越大，离散程度越高：

2.sql的编写需要注意优化

使用limit对查询结果的记录进行限定
避免select *，将需要查找的字段列出来
使用连接（join）来代替子查询
拆分大的delete或insert语句
可通过开启慢查询日志来找出较慢的SQL
不做列运算：SELECT id WHERE age + 1 = 10，任何对列的操作都将导致表扫描，它包括数据库教程函数、计算表达式等等，查询时要尽可能将操作移至等号右边
sql语句尽可能简单：一条sql只能在一个cpu运算；大语句拆小语句，减少锁时间；一条大sql可以堵死整个库
OR改写成IN：OR的效率是n级别，IN的效率是log(n)级别，in的个数建议控制在200以内
不用函数和触发器，在应用程序实现
避免%xxx式查询
少用JOIN
使用同类型进行比较，比如用’123’和’123’比，123和123比
尽量避免在WHERE子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描
对于连续数值，使用BETWEEN不用IN：SELECT id FROM t WHERE num BETWEEN 1 AND 5
列表数据不要拿全表，要使用LIMIT来分页，每页数量也不要太大

引擎

目前广泛使用的是MyISAM和InnoDB两种引擎：

1. MyISAM
2. MyISAM引擎是MySQL 5.1及之前版本的默认引擎，它的特点是：

• 不支持行锁，读取时对需要读到的所有表加锁，写入时则对表加排它锁
• 不支持事务
• 不支持外键
• 不支持崩溃后的安全恢复
• 在表有读取查询的同时，支持往表中插入新纪录
• 支持BLOB和TEXT的前500个字符索引，支持全文索引
• 支持延迟更新索引，极大提升写入性能
• 对于不会进行修改的表，支持压缩表，极大减少磁盘空间占用

1. InnoDB
2. InnoDB在MySQL 5.5后成为默认索引，它的特点是：

• 支持行锁，采用MVCC来支持高并发
• 支持事务
• 支持外键
• 支持崩溃后的安全恢复
• 不支持全文索引

总体来讲，MyISAM适合SELECT密集型的表，而InnoDB适合INSERT和UPDATE密集型的表

MyISAM速度可能超快，占用存储空间也小，但是程序要求事务支持，故InnoDB是必须的，故该方案无法执行，放弃！

3.分区

MySQL在5.1版引入的分区是一种简单的水平拆分，用户需要在建表的时候加上分区参数，对应用是透明的无需修改代码

对用户来说，分区表是一个独立的逻辑表，但是底层由多个物理子表组成，实现分区的代码实际上是通过对一组底层表的对象封装，但对SQL层来说是一个完全封装底层的黑盒子。MySQL实现分区的方式也意味着索引也是按照分区的子表定义，没有全局索引

用户的SQL语句是需要针对分区表做优化，SQL条件中要带上分区条件的列，从而使查询定位到少量的分区上，否则就会扫描全部分区，可以通过EXPLAIN PARTITIONS来查看某条SQL语句会落在那些分区上，从而进行SQL优化，我测试，查询时不带分区条件的列，也会提高速度，故该措施值得一试。

分区的好处是：

• 可以让单表存储更多的数据
• 分区表的数据更容易维护，可以通过清楚整个分区批量删除大量数据，也可以增加新的分区来支持新插入的数据。另外，还可以对一个独立分区进行优化、检查、修复等操作
• 部分查询能够从查询条件确定只落在少数分区上，速度会很快
• 分区表的数据还可以分布在不同的物理设备上，从而搞笑利用多个硬件设备
• 可以使用分区表赖避免某些特殊瓶颈，例如InnoDB单个索引的互斥访问、ext3文件系统的inode锁竞争
• 可以备份和恢复单个分区

分区的限制和缺点：

• 一个表最多只能有1024个分区
• 如果分区字段中有主键或者唯一索引的列，那么所有主键列和唯一索引列都必须包含进来
• 分区表无法使用外键约束
• NULL值会使分区过滤无效
• 所有分区必须使用相同的存储引擎

分区的类型：

• RANGE分区：基于属于一个给定连续区间的列值，把多行分配给分区
• LIST分区：类似于按RANGE分区，区别在于LIST分区是基于列值匹配一个离散值集合中的某个值来进行选择
• HASH分区：基于用户定义的表达式的返回值来进行选择的分区，该表达式使用将要插入到表中的这些行的列值进行计算。这个函数可以包含MySQL中有效的、产生非负整数值的任何表达式
• KEY分区：类似于按HASH分区，区别在于KEY分区只支持计算一列或多列，且MySQL服务器提供其自身的哈希函数。必须有一列或多列包含整数值
• 具体关于mysql分区的概念请自行google或查询官方文档，我这里只是抛砖引玉了。

我首先根据月份把上网记录表RANGE分区了12份，查询效率提高6倍左右，效果不明显，故：换id为HASH分区，分了64个分区，查询速度提升显著。问题解决！

结果如下：PARTITION BY HASH (id)PARTITIONS 64

select count() from readroom_website; –11901336行记录

/ 受影响行数: 0 已找到记录: 1 警告: 0 持续时间 1 查询: 5.734 sec. /

select * from readroom_website where month(accesstime) =11 limit 10;

/ 受影响行数: 0 已找到记录: 10 警告: 0 持续时间 1 查询: 0.719 sec. */

4.分表

分表就是把一张大表，按照如上过程都优化了，还是查询卡死，那就把这个表分成多张表，把一次查询分成多次查询，然后把结果组合返回给用户。

分表分为垂直拆分和水平拆分，通常以某个字段做拆分项。比如以id字段拆分为100张表： 表名为 tableName_id%100

但：分表需要修改源程序代码，会给开发带来大量工作，极大的增加了开发成本，故：只适合在开发初期就考虑到了大量数据存在，做好了分表处理，不适合应用上线了再做修改，成本太高！！！而且选择这个方案，都不如选择我提供的第二第三个方案的成本低！故不建议采用。

5.分库

把一个数据库分成多个，建议做个读写分离就行了，真正的做分库也会带来大量的开发成本，得不偿失！不推荐使用

搜索的正确顺序

google

stackoverflow

csdn/知乎/博客园等论坛网站

gitee/github查源码或者类似配置

搜索结果的显示

可以使用浏览器的脚本，将搜索结果的广告进行屏蔽，将结果更直观的展示出来。

谷歌浏览器需要先下载谷歌上网助手。

汇总了一些常用的浏览器插件：收藏猫插件：https://chrome.pictureknow.com/

脚本管理工具：油猴，暴力猴。

提供脚本的网站：https://greasyfork.org/zh-CN

搜索的格式

正常搜索

各个名词之间，加空格搜索。

手机 苹果

英文半角双引号搜索

是一种比较精确的搜索方法：最关键的是可以将推广页面剔除掉。双引号可以实现精确的查询，这种方法要求查询结果要精确匹配，不包括演变形式

"手机"

圆括号搜索

是完全部分匹配搜索：完全，是不会将搜索结果拆开去搜索；部分，是将搜索结果去匹配部分内容符合的内容。这种方法针对搜索结果有特殊要求的内容,有圆括号的搜索方式，搜索结果的数量变少且范围缩小了。

(苹果手机)

通配符搜索(建议在谷歌使用，百度不太适合)

*号不限制字符匹配数量，?号正好与其相反，限制字符匹配数量

computer*,可以找到“computer、computers、computerised、computerized”等单词，

comp?ter，只能找到“computer、compater、competer”等单词。

利用加号减号【+】、【-】搜索

在想要搜索的关键词前使用加号，也就等于告诉搜索引擎你搜索的这个词必须出现在搜索结果的网页中，如果只是网页标题中含这个关键词的就不出现。在想要搜索的关键词前使用减号，实质是与上面有些相反的意思，则在搜索结果中不能出现前面带减号的关键词，

我+要去+英国+留学,就表示要查找的网页内容中必须要同时包含“我、要去、英国、留学”这三个关键词

搜索范围限定在网页标题中

网页标题就是在打开网站的时候浏览器上显示的文字，但是网页标题中所包含的关键词有可能是不出现在网页中的，所以你只想搜索网页标题里面的关键词，就需要用到intitle：语法

intitle+标题

限定网站搜索方式

site:www.baidu.com 百度

“site:”后面跟的站点域名，不要带“//”;site:后面带不带www结果可能是不一样的，因为有些域名还包括二级域名，如：site:www.XX.com和site:XX.com，搜索结果就不一样。另外，site:和站点名之间，不要带空格。使用site:语法限定在某站上搜索特定关键词（只在当前网站进行搜索）

限定链接url搜索

inurl:douban 电影

与site的区别就是inurl中的所有网页URL中都包含了douban但是是不同的网站

inurl的作用是限定在url中搜索，利用这种相关性，来缩小范围，快速准确地找到所需信息

专业文档搜索

filetype:doc 电脑

搜索结果都是word格式并且包含了 电脑 这个关键词

以上也可以在百度的高级搜索中进行设置。

日常工作中的交流沟通合作技巧。

1.发送文件，带个说明，对方会回答收到与否。

2.聊天多带个表情。不要直接指出对方错误，应该说：这样会不会好一点。

3.多人合作项目，文件带个日期，尽量不要搞多个文件，会混淆。最好搞个在线文档，随时更新随时看。

4.不要推卸责任，要想办法弥补，即使那不是你的问题。你需要做的是表达清楚，而不是再去要求他重新干嘛。

5.描述问题的时候不要加语气词之类的东西，就只用客观描述问题就可以，加了语气词会让人感到你很不耐烦。

6.截图的时候不要截部分，可以截全部，然后将其中的部分圈起来。

7.不要说我以为，会被认为是在推卸责任。

8.讨论，需要的是互动，不然汇报一样会让人容易听不进去。

平常生活工作中遇到的感兴趣的名词和计算机方面的知识，专有名词，会收录在这个文档中。

一些名词

1.wiki:多人协作的写作系统，来源于夏威夷语，它最大的特点就是分享性，开放性以及互动性。wiki站点允许任何访问它的用户都可以修改、编辑以及创建上面的内容。

wiki软件，是一种运行在php+mysql运行环境的百科系统软件。用wiki软件可以迅速地搭建起一个wiki网站。

国内目前使用最普遍的wiki软件有HDwiki(互动中文wiki系统)以及mediawiki。两者各有特点：

HDwiki，是中国第一家拥有自主知识产权的中文wiki系统，适用于国内wiki爱好者；
mediawiki是世界上使用最多的wiki系统，在世界范围内使用比较广泛。

2.**.zip**是程序的压缩包 **.msi**是程序安装包

.msi文件是Windows Installer的数据包，它实际上是一个数据库，包含安装一种产品所需要的信息和在很多安装情形下安装（和卸载）程序所需的指令和数据，只要系统中包含windows installer支持就能够使用。

.msi是Windows installer开发出来的程序安装文件，它可以让你安装，修改，卸载你所安装的程序。说白了.msi就是Windows installer的数据包，把所有和安装文件相关的内容封装在一个包里。

3.备份（backup）文件的时候，可以加后缀名.bak，等到需要回退到这个版本的时候，放开.bak即可。

4..html转换为帮助文档就是**.chm**文档

5.坐标系：84坐标可以定位到国外，但是GCJ02和BD09只能在国内使用。（相当于是为了保密，在国内不使用gps坐标系，而是加密了一下，使用加密版的坐标系：GCJ02坐标系、BD09坐标系）

​ WGS84坐标系： 地球坐标系，国际通用坐标系
​ GCJ02坐标系：火星坐标系，WGS84坐标系加密后的坐标系；Google国内地图、高德、QQ地图 使用
​ BD09坐标系：百度坐标系，GCJ02坐标系加密后的坐标系

6.像素

像素即一个小方块，它具有特定的位置和颜色。图片、电子屏幕(手机、电脑)就是由无数个具有特定颜色和特定位置的小方块拼接而成。

像素可以作为图片或电子屏幕的最小组成单位。

分辨率

通常我们所说的分辨率有两种，屏幕分辨率和图像分辨率

屏幕分辨率指一个屏幕具体由多少个像素点组成。分辨率高不代表屏幕就清晰，屏幕的清晰程度还与尺寸有关

图片分辨率其实是指图片含有的像素数，比如一张图片的分辨率为800 x 400。这表示图片分别在垂直和水平上所具有的像素点数为800和400。同一尺寸的图片，分辨率越高，图片越清晰

PPI

PPI(Pixel Per Inch)：每英寸包括的像素数。

PPI可以用于描述屏幕的清晰度以及一张图片的质量。

使用PPI描述图片时，PPI越高，图片质量越高，使用PPI描述屏幕时，PPI越高，屏幕越清晰。

描述手机分辨率：iPhone XS Max 和 iPhone SE的PPI分别为458和326，说明前者的屏幕更清晰。

由于手机尺寸为手机对角线的长度，我们通常使用如下的方法计算PPI:

DPI

DPI(Dot Per Inch)：即每英寸包括的点数。

这里的点是一个抽象的单位，它可以是屏幕像素点、图片像素点也可以是打印机的墨点。

平时你可能会看到使用DPI来描述图片和屏幕，这时的DPI应该和PPI是等价的，DPI最常用的是用于描述打印机，表示打印机每英寸可以打印的点数。

一张图片在屏幕上显示时，它的像素点数是规则排列的，每个像素点都有特定的位置和颜色。

当使用打印机进行打印时，打印机可能不会规则的将这些点打印出来，而是使用一个个打印点来呈现这张图像，这些打印点之间会有一定的空隙，这就是DPI所描述的：打印点的密度。

在上面的图像中我们可以清晰的看到，打印机是如何使用墨点来打印一张图像。

所以，打印机的DPI越高，打印图像的精细程度就越高，同时这也会消耗更多的墨点和时间

DPR

设备像素比（dpr） = 设备像素（分辨率）/设备独立像素（屏幕尺寸）

布局视窗：屏幕大小

视觉视窗：为了解决PC端网站在移动端显示不佳，布局视窗比设备屏幕宽度宽，一般为980

1

<meta name="viewport" content="width:device-width, initial-scale=1.0, maximum=1.0, minimum=1.0, user-scalable=no">

这行代码把视觉视窗大小设置成和布局视窗大小相等，这样我们在代码设置css像素时，设置的跟渲染出来效果也是一样。

手机分辨率指的是屏幕能够达到的清晰度，液晶排列点阵数量，通常用乘号或者 * 表示，如320 * 240，480 * 800，1280 * 720 表示的是像素，越大屏幕分辨率越高，同等尺寸情况下越清晰，当然跟屏幕生产商，材质也有关系。

像素指的是相机，通常在摄像头后面有标记，如2M，8M等，指的是200万，800万像素

像素越高，最大输出的影像分辨率也越高；分辨率越大，图片的面积越大

手机尺寸 1英寸 = 2.54 厘米 手机屏幕的大小还和屏幕的长宽比有关，同样的对角线长度16:9的长宽比和4:3的长宽比，屏幕大小是不一样的

比如：苹果5的是4英寸：1136 * 640 像素密度330PPI （浏览器调试的时候就可以设置为：568 * 320）

7.robots.txt：Web机器人（爬虫）

8.ORM：Object Relational Mapping，对象关系映射。

9.Thrift 是一个软件框架（远程过程调用框架），用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引 擎，以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, and OCaml 这些编程语言间无缝结合的、高效的服务

10.百度指数：查看数据可以去百度指数，查看这个数据的搜索热度。

11.**.DS_Store**：是Mac OS保存文件夹的自定义属性的隐藏文件，如文件的图标位置或背景色，相当于Windows的desktop.ini

12.CDN：内容分发网络（Content Delivery Network），是建立并覆盖在承载网之上，由分布在不同区域的边缘节点服务器群组成的分布式网络。CDN应用广泛，支持多种行业、多种场景内容加速。例如：图片小文件、大文件下载、视音频点播、直播流媒体、全站加速、安全加速

CDN通过广泛的网络节点分布，提供快速、稳定、安全、可编程的全球内容分发加速服务，支持将网站、音视频、下载等内容分发至接近用户的节点，使用户可就近取得所需内容，提高用户访问的响应速度和成功率。

CND加速主要是加速静态资源，CND加速需要依靠各个网络节点，CND服务器通过缓存或者主动抓取主服务器的内容来实现资源储备

13.ERP系统：是企业资源计划（Enterprise Resource Planning）的简称，是指建立在信息技术基础上，集信息技术与先进管理思想于一身，以系统化的管理思想，为企业员工及决策层提供决策手段的管理平台。

14.Dashboard：仪表板，一般为后台管理系统的首页

15.**.sh**结尾的文件：脚本文件，被称为脚本Bash的应用程序和使用开发人员文件。可以使用sh命令运行“sh xxx.sh”，并且由于在linux中sh是链接到bash上的，所以sh与bash在功能上是没有区别的。

windows系统下可以通过git bash打开到这个.sh文件所在位置，然后运行sh xxx.sh

16.在xml中，被**<![CDATA[]]>这个标记所包含的内容将表示为纯文本**，比如<![CDATA[<]]>表示文本内容“<”

在xml中，”<”、”>”、”&”等字符是不能直接存入的，否则xml语法检查时会报错，如果想在xml中使用这些符号，必须将其转义为实体，如”<”、”>”、”&”，这样才能保存进xml文档。

　　(1)转义序列字符之间不能有空格；
　　(2) 转义序列必须以”;”结束；
　　(3) 单独出现的”&”不会被认为是转义的开始；
　　(4) 区分大小写。

　在XML中，需要转义的字符有：
　　(1)&　　　&
　　(2)<　　　<
　　(3)>　　　>
　　(4)＂　　　"
　　(5)＇　　　'

17.关于大于小于的简写：

EQ 就是 EQUAL等于

NE 就是 NOT EQUAL不等于

GT 就是 GREATER THAN大于　

LT 就是 LESS THAN小于

GE 就是 GREATER THAN OR EQUAL 大于等于

LE 就是 LESS THAN OR EQUAL 小于等于

18.psd文件是Photoshop图片软件保存的一种文件格式，保存这种格式后可以在下次打开这个文件的时候继续以前的操作而不会断掉。

19.  U+2006 ios手机输入法如果只输入拼音，但是未选择汉字时直接回车会在拼音的`之间插入这个字符。复制在idea里会显示，但是其他地方都只会显示一个空格。

20.进程：应用程序的启动实例。进程拥有代码和打开的文件资源、数据资源、独立的内存空间

线程：线程从属于进程，是程序的实际执行者。一个进程至少包含一个主线程，也可以有更多的子线程。线程拥有自己的栈空间。具有经典的五种状态：初始化，就绪，阻塞，运行，销毁

协程：一个线程可以拥有多个协程。在单线程下，由用户自己控制，一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率

管程：用来管理共享变量以及对共享变量操作的过程。MESA模型、Hasen模型、Hoare模型。解决了互斥与同步：管程保证了同时只允许一个线程进入。

线程是最小的执行单元，进程是最小的资源管理单元。无论进程还是线程，都是由操作系统所管理的。

协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）

微信

1.微信发送安卓相关的安装包会自动屏蔽。

2.微信的浏览器内核：

安卓（Android）手机：微信6.1版本以上的android用户，都是使用的QQ浏览器的X5内核。5.4-6.1之间的版本，若用户安装了QQ浏览器就是使用的X5内核，若用户未安装浏览器，使用的是系统内核。

苹果（IOS）手机：safari

WKWebview（此网页由）和UIWebview（网页由）

从ios8开始支持WKWebview

电脑知识

1.usb2.0和usb3.0：

颜色：USB2.0接口处为黑色或白色，USB3.0接口处为蓝色

标志符号：USB3.0接口比2.0多了个ss

兼容性：USB2.0：可以兼容USB1.0、USB2.0。

​ USB3.0：可以兼容USB1.0、USB2.0、USB3.0

传输速率：USB2.0的理论传输速率：480Mbps (60MB/s)

​ USB3.0的理论传输速率：5Gbps (500MB/s)

硬件结构：USB2.0：采用了半双工二线制总线，只能提供单向数据流传输；

​ USB3.0：采用了对偶单纯形四线制差分信号线，可以双向并发数据传输

2.下载好的软件，如果桌面没有快捷方式图标，需要重新在软件位置右击创建快捷方式到桌面，直接拉到桌面不能启动。

3.windows下打开到某个文件，在地址栏输入cmd，可以直接跳转到cmd命令行的这个文件目录。

4.windows系统下，windows键+上下左右箭头键可以进行分屏。

5.x64是64位系统。x86是32位系统。

x86指的是一种cpu的架构。因为intel的8086，286，386～586而得名，amd开发的大部分cpu也是基于x86架构的。x86架构的特点是cpu的寄存器是32位的，因此也叫32位cpu。

X86的32位体系结构通常称为IA－32，全称为“英特尔体系结构，32位”。它的64位体系结构最早由AMD推出，被称为“AMD64”。后来，它也被英特尔采用，被称为“英特尔64”。也称为“x86－64”、“x64”。

早期英特尔曾以80x86的数字格式命名处理器，包括8086、80186、80286、80386和80486。

因为它以“86”结尾，所以它的体系结构被称为“x86”。由于digital不是注册商标，英特尔及其竞争对手在新一代处理器中使用可注册名称，如奔腾、酷睿和ryzen（由AMD推出）

6.查看本机IP：cmd中输入 ipconfig

​ 查看网络连接状况：cmd中输入：ping baidu.com

​ 查看本机外网的ip：直接在百度输入ip第一条就是本机的ip信息

​ 查看本机有没有装好TCP/IP协议：ping 127.0.0.1 （本机无论在联网或是没有联网的状态下的地址.用这个都可以访问到自己的机子）

本地Socks Proxy的地址是localhost:1080或127.0.0.1:1080

7.打开文件之后，不要急着关闭，以防会再用到，再去打开找。浏览器不要打开多个窗口，否则会很卡，因为会占用内存。

8.硬编码

​ 硬编码是将数据直接嵌入到程序或其他可执行对象的源代码中的软件开发实践，与从外部获取数据或在运行时生成数据不同。

​ 硬编码数据通常只能通过编辑源代码和重新编译可执行文件来修改，尽管可以使用调试器或十六进制编辑器在内存或磁盘上进行更改。

​ 硬编码的数据通常表示不变的信息，例如物理常量，版本号和静态文本元素。 另一方面，软编码数据对用户输入，HTTP服务器响应或配置文件等任意信息进行编码，并在运行时确定。

它和普通编码的区别是：

• 编码方式不同：

普通编码：使用CPU进行编码。

硬编码：使用非CPU进行编码，如显卡GPU、专用的DSP、FPGA、ASIC芯片等。

• 使用方式不同：

普通编码：实现直接、简单，参数调整方便，升级易，但CPU负载重，性能较硬编码低，低码率下质量通常比硬编码要好一点

硬编码：性能高，低码率下通常质量低于软编码器，但部分产品在GPU硬件平台移植了优秀的软编码算法（如X264）的，质量基本等同于软编码

• 复杂程度不同：

普通编码比硬编码要复杂一些，对以后的考虑要周到一些。普通编码是一种设计，而硬编码不过是一种具体的实现。软件开发不只是需要一个软件的实现，更需要软件能够很好的修改，方便得扩展，所以需要一些设计技巧在里面。

9.注册表：注册表的作用是保存程序所需要的信息,当程序需要这些信息时,就从注册表里读出.因此,注册表最基本的功能就是保存信息

​ win+r，输入“regedit”。解决了谷歌浏览器下载的图片格式问题，右键git bash here命令消失的问题。

10.图片的格式类型：

图片格式是计算机存储图片的格式，常见的存储的格式有bmp，jpg，png，tif，gif，pcx，tga，exif，fpx，svg，psd，cdr，pcd，dxf，ufo，eps，ai，raw，WMF，webp，avif等

11.中文的：和英文的:

中文的”“和英文的””

中文的（）和英文的()

明显发现中文的格式都有一点空格，英文没有

12. 路径指示：

    ./表示当前目录

    ../表示父级目录

    /表示根目录

13. 转义字符

​ ‘/x’ x表示任意

​ ‘/t’ tab键

​ ‘/r’ 回车

​ ‘/n’ 换行

14.斜杠/和反斜杠\

• 反斜线“\”是电脑出现了之后为了表示程序设计里的特殊含义才发明的专用标点。就是说，除了程序设计领域外，任何地方都不应该有使用反斜杠的时候，请永远使用正斜线“/”
• Windows系统中用反斜线“\”来表示目录，但是Linux下用正斜线“/”来表示
• Windows：“/”是表示参数，“\”是表示本地路径。
  Linux和Unix：“/”表示路径，“\”表示转义，“-”和“–”表示参数。
  网络：由于网络使用Unix标准，所以网络路径用“/”。

例：

url地址：https://www.baidu.com
windows地址：C:\Program Files
linux地址：/home/nginx/logs
linux中的转义字符 find ./ -name *.c
其他常见转义字符 ： 如 \n \t
java中注释： / * 单行注释 * / //单行注释
所以谨记正则表达式、转义字符都是用反斜杠 \

15.查看win10系统的激活过期时间：windows键+r打开运行，再输入 slmgr.vbs -xpr

16.一级缓存、二级缓存和三级缓存

当cpu进行读取缓存数据的时候，是先从缓存的数据进行查找的，读取之后再输入到电脑cpu里面进行处理，如果没有对应的缓存文件给cpu进行处理的话，那电脑就会从内存中的数据进行处理并给cpu进行处理。这一段时间会相比找到缓存文件来要慢的多。cpu处理完数据之后，就会把处理完的的数据模块进行保存，这个就是缓存文件

电脑的缓存文件分为三个等级，分别是一二三级缓存。

一级缓存基本上都是内置在cpu的内部和cpu一个速度进行运行，能有效的提升cpu的工作效率。一级缓存越多，cpu的工作效率就会越来越高，是cpu的内部结构限制了一级缓存的容量大小，使一级缓存的容量都是很小的。

二级缓存，主要作用是协调一级缓存和内存之间的工作效率。cpu首先用的是一级内存，当cpu的速度慢慢提升之后，一级缓存就不够cpu的使用量了，这就需要用到二级内存。当然二级内存会比一级内存的缓存的效率要低很多，但是相比容量来说二级内存的容量要比一级的容量要大很多。一级内存和二级内存主要是为cpu的处理数据的时候临时进行数据交换的时候使用的。

三级缓存和一级缓存与二级缓存的关系差不多，是为了在读取二级缓存不够用的时候而设计的一种缓存手段，在有三级缓存cpu之中，只有大约百分之五的数据需要在内存中调取使用，这能提升cpu不少的效率，从而cpu能够高速的工作。

现在市场上主流的cpu有两种型号的cpu： amd 和intel。amd型号的cpu只用一级缓存和二级缓存，没有三级缓存。但是intel的cpu恰恰相反，有二级缓存和三级缓存，但是没有一级缓存。

浏览器

1.浏览器主要是看内核来分辨显示。有的浏览器会自动过滤掉一些资源（比如一个名为guanggao的图片）

Apple的Safari, Google的Chrome, Nokia S60平台的默认浏览器，Apple手机的默认浏览器，Android手机的默认浏览器均采用的Webkit作为器浏览器内核

Firefox使用Gecko 内核

微软的IE系列则使用的是Trident内核

2.网址后可以加**#+代码块的id**（这个id是唯一的），表示打开这个网站，可以直接定位到这个代码块对应的前端部分。如果没有跟任何东西，只有#，代表定位到上次访问的位置。

3.根据坐标查询地理位置，可以去某个地图网站的坐标拾取器进行搜索。

4.谷歌浏览器快捷键：ctrl+shift+t，打开刚刚关闭的网页。ctrl+w，关闭当前网页。

5.浏览器的储存：

• cookie空间太小，一旦大了，会消耗流量，只适合存一些登录会话信息

• sessionStorage的过期时间就是关闭浏览器，是个临时会话窗口；sessionStorage只能在同一标签下共享，假如你把网址复制粘贴到新打开的标签页里面，不共享数据

• localStorage存储空间大，长时间保存，同一浏览器，标签页全部共享，它是直接存到电脑硬盘上的，是永久有效的，除非手动清除

localStorage和sessionStorage的区别：两者都可用来存储数据，但是localStorage会保留原始数据，即使关闭浏览器，数据仍然存在。而sessionStorage不会保留，关闭浏览器后数据被销毁。由于要求用户在保持登录状态下重新打开浏览器可以不用登录直接进入主页面，所以要用localStorage

6.4g不能访问某个网站，换到了wifi就可以：（本地项目可以通过在同一个局域网下的设备通过内网ip访问来实现本地的现实机型调试）

服务器商那边对移动网络的问题。实际上跳转的时候的ip发生了变化，找服务商解决的。不是阿里云也不是腾讯云

7.SEO（Search Engine Optimization）：汉译为搜索引擎优化。是一种方式：利用搜索引擎的规则提高网站在有关搜索引擎内的自然排名。目的是让其在行业内占据领先地位，获得品牌收益。很大程度上是网站经营者的一种商业行为，将自己或自己公司的排名前移

搜索引擎优化的技术手段主要有黑帽（black hat）、白帽（white hat）两大类。

通过作弊手法欺骗搜索引擎和访问者，最终将遭到搜索引擎惩罚的手段被称为黑帽，比如隐藏关键字、制造大量的meta字、alt标签等。

而通过正规技术和方式，且被搜索引擎所接受的SEO技术，称为白帽

8.浏览器下的F12调试模式：

Network下的所有请求和回复：不止一个请求，会有多个。
Headers：
User-Agent：我们的浏览器信息：操作系统，位数，什么类型的浏览器等一些信息（没有这个无法返回消息）
Cookie：保存在本地的信息（往往是加密的）（没有这个可能会出现登录的问题，如果无法登录，自然无法爬取一些特定的内容）
…
Elements下点击某个标签后，最下面一行会显示这个标签的所有父模块，便于更快的定位html元素

9.ping 百度时候ping www.baidu.com 会出现www.a.shifen.com。这是百度以前的网址

10.localhost 是一个域名，在过去它指向 127.0.0.1 这个IP地址。在操作系统支持 ipv6 后，它同时还指向ipv6 的地址 [::1]

整个127.* 网段通常被用作 loopback 网络接口的默认地址，按惯例通常设置为 127.0.0.1。这个地址在其他计算机上不能访问，就算你想访问，访问的也是自己，因为每台带有TCP/IP协议栈的设备基本上都有 localhost/127.0.0.1

本机地址通常指的是绑定在物理或虚拟网络接口上的IP地址，可供其他设备访问到：IPv4地址：192.168.0.156

11.chromedriver是操作浏览器的一个exe应用程序。java，python都可以在程序里读到这个exe并对其进行操作。相当于就是在程序里对浏览器进行操作。

12.通过网站域名 +robots.txt 方式查看这个网站自己禁止爬取本站信息的爬虫名单

robots.txt（统一小写）是一种存放于网站根目录下的ASCII编码的文本文件，它通常告诉网络搜索引擎的漫游器（又称网络蜘蛛），此网站中的哪些内容是不应被搜索引擎的漫游器获取的，哪些是可以被漫游器获取的。因为一些系统中的URL是大小写敏感的，所以robots.txt的文件名应统一为小写。robots.txt应放置于网站的根目录下。如果想单独定义搜索引擎的漫游器访问子目录时的行为，那么可以将自定的设置合并到根目录下的robots.txt，或者使用robots元数据（Metadata，又称元数据）
robots.txt协议并不是一个规范，而只是约定俗成的，所以并不能保证网站的隐私。注意robots.txt是用字符串比较来确定是否获取URL，所以目录末尾有与没有斜杠“/”表示的是不同的URL。robots.txt允许使用类似”Disallow: *.gif”这样的通配符。

13.PhantomJS是一个Python包，他可以在没有图形界面的情况下，完全模拟一个”浏览器“，js脚本验证什么的再也不是问题了

项目

1.调试程序的时候，得到什么值输出一下，一步一步查看错误在哪，对于不懂得错误，学会用搜索引擎解决。

2.魔法数字

魔法数值，是指在代码中直接出现的数值，只有在这个数值记述的那部分代码中才能明确了解其含义

在Java语言中，对有名字的值的定义，可以使用用Static final或者enum来声明的值。

注意(命名方法)：在取名时一定要注意增加名字的信息量。

如果16表示的是价格表的一个元素，为16命名为SIXTEEN是没有意义的，应该命名为PRICE_TABLE_MAX

阿里：尽量不要在接口里定义变量，如果一定要定义变量，肯定是与接口方法相关。不要在程序中出现魔法数字

3.项目里报错，首先要注意排查格式错误，避免出现中文写的符号，避免多加空格之类的低级错误。

4.mock,是前端写好的json可以用来进行接口测试，使用mock data来模拟后台传数据。

6.正则表达式的反斜杠

1
2

String reg = "^\\{\"data_type\":\"[a-z]{3,8}(_[a-z]{3,6}){0,2}\",\"data\":\\[\\{\"[a-z]{3,7}(_[a-z]{2,4})?\":\"[0-9A-Z]{2,8}\""+"(,\"[a-z]{3,7}(_[a-z]{2,4})?\":\"[0-9A-Z]{2,8}\"){0,5}\\}\\]\\}$"
^表示正则开头 第一个\表示java的字符串里需要加\转义，第二个\表示正则的{}需要\转义 {后的\表示java的字符串的下个“需要\转义

7.idea查看jar包源码

将jar包放到项目里，右击选择add as Library 就可以正常查看了

8.replace(/-/g, “/“)

一般用于格式化日期，如2019-1-1 格式化为2019/1/1，然后js 可以直接操作这个时间。 /g 代表全局，所有的- 都替换

9.-n=~n+1 对十进制的n取反 ~n 其实等于 -n-1
10.java存储文件到mysql数据库的操作：

• 将它们另存为blob/图像/无论您选择的DB调用什么字节流：Blob是一个可以存储二进制文件的容器，最大容量只有64kb。
• 存储文件的路径，并将文件存储在文件系统中(服务器上)

java类型与mysql类型的对应表

数据库

1.数据库增加一个字段，对增删改查业务没有影响。

其他

1.政府，标准文件格式：

标题 宋体/黑体 2号 小标题可以自己定 正文 仿宋 4号

起点

​ 好记性始终不如烂笔头，一个人的记忆力是有限的，而写出来以后再看的时候就会很快想起来。所以从今天开始在hexo上写点东西来记录自己的转行学习java的经历。

​ 曾经我认为世界上最神奇的两件事：基因和计算机。基因这种东西，每个人都不同，像世界上没有两片相同的叶子，只是因为基因不同，就能决定一个人的性格，长相，体质等因素，像一个人怎么吃都不会长胖，像一个人天生就很善于交际，像一个人从小就天赋异禀……生命本身就是神奇的东西，大学有幸学到一点相关知识，却也没有深究，最后不了了之，也许到以后也没有机会去了解了，也会是一个遗憾吧。说回计算机，在刚接触的时候还是被震惊了，就像只需要动动鼠标和键盘，就会点击互动产生一些神奇的效果，在当时对于我还是很神奇的，以致于有了以后的沉迷网络游戏，却还是自以为自己很擅长，甚至妄图平衡游戏和学习，最后还是后悔莫及，但也奠定了自己的兴趣方向，为自己的爱好而努力应该也是一件幸事吧。正如我无法逃离网络游戏的诱惑，也是因为个人不自制且莫名自信，自学起来断断续续，没有目标，三天打鱼两天晒网，也相当于是什么也没有。

​ 最早接触计算机还不知道里面的门路有这么多，甚至不知道都有些什么语言，底层原理，甚至高级算法。回顾我的历程，还要从大二自学C语言开始。当初有个贴吧的帖子是教C语言的，还画了很多漫画，当时作为一个外行人看感觉还是很神奇的，从网上找了一个比自己还小的高中生的一个教C语言的视频看起来，在笔记本上做了很多基础知识的记录，也从未下载过相关软件，甚至一行代码都没有亲手敲过，后来荒废了。大学毕业后，受到java语言的铺天广告，于是正式决定投入java的行业。

​ 再决定学习java后，从网上找了相关视频，当时没有想到B站甚至可以用来学习，所以去百度云存了一个很老的视频：尚学堂的300集java基础视频。当时也是跟着敲了很多demo，只记得当时的老师一直用马士兵、高琪举例（现在朋友圈的公众号一直被马士兵刷屏，这也是个大佬吧），以至于为什么这样敲，对一些底层的语法都没有细思，学的云里雾里。

​ 再然后看完视频又荒废了一段日子，买了本《java从入门到精通》（现在经常有人调侃，从入门到放弃，哈哈哈），看着是清华大学出版社，然后就开始eng看，一天看几页，最后看完也不知道讲了啥，也有很多忘了，就相当于没看。

​ 时间就这样荒废了一天又一天。中间穿插着各种微信公众号的小文章推送，知乎的相关经历介绍，被各种难懂烦躁，洗脑劝退。后来又看了黑马程序员的java教学，因为视频源比较老，当时还没有java8，边做笔记边敲代码，慢慢懂了点基础原理。后来也慢慢了解到java的体系结构。但是学习的路还是很长。

​ 现在入职了一家公司，与一个软件专业的同学交流后，发现自己差的还很多。了解到一些博客，想写点自己的东西，一来是记录自己的学习过程，二也是为了以后自己找轮子更方便一些。

​ just for it！只要开始了，什么时候都不算晚。