最开始的时候，是在做非强检器具的编辑功能。添加了一个非强检器具，然后点击编辑，获取对应的对象，然后绑定在表单上，附加参量没有出现。

图中红框的位置应该有一个附加参量的编辑部分，但现在没有出现。然后从次开始问题的查找。

问题定位

1.检查前台问题

首先是先检查一下是否是前台出错了，因为这是个动态的表单，所以存在ng-show，检查无误。附加参量的位置使用了ng-repeat，也就是说，只要获取到了数据，附加参量就会显示。

2.检查jsonview

调用的是get方法，所以可能是相应的实体上没有添加jsonview，所以在前台没有获取到对应的数据。将所有的关联实体都添加上jsonview后，依然不好使。也不是这个问题。

3.打印获取的对象

获取的附加参量是一个空数组。到这里可以知道，get方法没有出错。那么既然获取没有问题，那么就只能是保存的时候出现了问题。

4.查找save的错误

这个保存的问题还是花了挺长时间才找到的。最后还是因为巧合才发现问题的原因。

最开始，我的更新方法update在保存的时候使用的是jpa自带的保存方法。

1
2
3
4
5
6

@Override
public void update(Long id, NonMandatoryInstrument nonMandatoryInstrument) {
    ...   
    logger.debug("持久化更新内容");
    nonMandatoryInstrumentRepository.save(oldNonMandatoryInstrument);
}

这里直接使用repository的save方法，然后我先点击了一下编辑，然后保存。在点击编辑，发现原来的参量也不见了。

然后我将update的保存方法也换成M层的保存方法。就和最上面的问题一样了：参量能存上，但是附加参量存不上。

所以我就去看了一下M层的save是怎么写的：

1
2
3
4
5
6
7

public void save(NonMandatoryInstrument nonMandatoryInstrument) {
    logger.debug("为参数添加非强检器具");
    for(Parameter parameter: nonMandatoryInstrument.getParameterSet()) {
        parameter.setNonMandatoryInstrument(nonMandatoryInstrument);
    }
    nonMandatoryInstrumentRepository.save(nonMandatoryInstrument);
}

发现在保存之前先为每个参量添加了非强检器具这个属性。看到这里我就知道问题所在了：保存的时候没有设置附加参量的参量属性。

原因猜测

首先我们知道非强检器具和参量是一对多的关系。参量和附加参量是一对多的关系。我们在建实体的时候，避免生成中间表，使用了mappedBy这个属性，交由一的一方来维护表。这样就会在参量的表中生成一个非强检器具的外键，所以如果在保存的时候不为参量添加非强检器具，这个外键就是空的。所以在查询的时候就不能关联查询出参量。参量和附加参量也是这个道理。

问题解决

解决办法很简单，在保存之前，为附加参量设置参量这个属性。

1
2
3
4
5
6
7
8
9
10
11

public void save(NonMandatoryInstrument nonMandatoryInstrument) {
    logger.debug("为参数添加非强检器具");
    for(Parameter parameter: nonMandatoryInstrument.getParameterSet()) {
        parameter.setNonMandatoryInstrument(nonMandatoryInstrument);
        logger.debug("为附加参量添加参量");
        for (AdditionalParameter additionalParameter: parameter.getAdditionalParameterSet()) {
            additionalParameter.setParameter(parameter);
        }
    }
    nonMandatoryInstrumentRepository.save(nonMandatoryInstrument);
}

总结

这次的问题解决时间还是比较长的，虽然最终问题是解决了，但是还是暴露出比较多的问题。一个就是对已知的知识掌握的不够灵活，另一个就是debug能力比较弱。

我们在做前台的时候，会遇到动态表单的问题，就是只有在我们输入或者点击了某些按钮后才会显示新的页面，而当新显示的页面会有多组的时候，验证就成了我们的问题。

例如上图，当我们点击新增参量的时候，会生成下方的参量，而参量1和参量2是相同的表单结构。这时我们要进行表单的验证就会显得有些难度了。

解决方法

在解决这个问题之前，我们需要清楚这组动态表单是怎么生成的。

动态表单的生成

相同的表单结构，又是动态生成的，所以我们肯定要使用ng-repeat来帮助实现。

1
2
3

<div class="p-m" ng-repeat="parameterCategory in data.parameterCategorySet">
...
</div>

但我们点击新增参量的时候，会新生成一个参量，然后添加进parameterCategorySet中。

原来验证方法的问题

上面的代码结构，如果我们还是按照原来的验证方法添加表单校验，就会出现问题。

按照我们原来的方法，以提示信息的验证为例验证如下：

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

<div class="p-m" ng-repeat="parameterCategory in data.parameterCategorySet">
    <div class="row">
        <div class="col-md-8">
            <div class="form-group">
                <label class="col-sm-4 control-label">提示信息:</label>
                <div class="col-sm-5">
                    <input type="text" ng-model="parameterCategory.tips" class="form-control" name="paramTip" required="true" />
                    <div class="m-t-xs" ng-show="nonMandatoryInstrumentCategoryAddForm.paramTip.$touched && nonMandatoryInstrumentCategoryAddForm.paramTip.$invalid">
                        <span class="text-danger" ng-show="nonMandatoryInstrumentCategoryAddForm.paramTip.$error.required"><i class="fa fa-exclamation-triangle"></i> 提示信息不能为空 </span>
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>

我们给input输入框一个name属性,然后在表单的数据不合法并且被点击过的时候显示验证信息。这时会出现下面的问题。

当存在两个参量的时候，我使其中一个出现验证信息，对另一个不做任何操作，但是同样的，另一个也出现了验证信息。类似的，当我们将其中一个的提示信息填写后，两个的验证信息都不出现了。

问题原因

出现这个问题的原因是因为本应该不同的两部分表单，使用了相同的name作为标志。就是说我要给小明一个苹果，但是有两个人都叫小明，所以我就给两个小明一人一个苹果了。

最终解决

知道原因后，解决的办法就有了。既然不能使用相同的name属性，那我们使用不同的属性不就行了。

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

<div class="p-m" ng-repeat="parameterCategory in data.parameterCategorySet">
    <div class="row">
        <div class="col-md-8">
            <div class="form-group">
                <label class="col-sm-4 control-label">提示信息:</label>
                <div class="col-sm-5">
                    <input type="text" ng-model="parameterCategory.tips" class="form-control" name="{{parameterCategory.name}}ParamTip" required="true" />
                    <div class="m-t-xs" ng-show="nonMandatoryInstrumentCategoryAddForm[parameterCategory.name + 'ParamTip'].$touched && nonMandatoryInstrumentCategoryAddForm[parameterCategory.name + 'ParamTip'].$invalid">
                        <span class="text-danger" ng-show="nonMandatoryInstrumentCategoryAddForm[parameterCategory.name + 'ParamTip'].$error.required"><i class="fa fa-exclamation-triangle"></i> 提示信息不能为空 </span>
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>

这里我将input的name属性设置为一个变量，这是根据parameterCategory对象的名字的不同来进行命名的。这样标志就不同了。然后在引用上，使用类似数组的表示方法。

1

nonMandatoryInstrumentCategoryAddForm[parameterCategory.name + 'ParamTip']

这就对应了提示信息的这个input输入框。

总结

这次的解决办法并没有找很久，主要就是问题定位比较快。

很多时候，当我们知道了问题所在，并知道是什么原因引起的这个问题，解决问题的办法也就自然而然的出来了。

问题描述

两个实体，教师和课程，关系多对多。要实现在新建教师的时候能为教师添加多个课程，可编辑，删除时删除相应的关系。

问题解决

关联定义

首先，我们肯定要先定义教师和课程的多对多。在教师的模型定义如下：

1
2
3
4
5

class User extends Model {
    public function courses() {
        return $this->belongsToMany('Course');
    }
}

这样就定义了多对多关系，但是还没有结束，还需要去数据库中建立一张中间表teacher_course，然后定义表中字段。到此，关系维护结束。

关联添加

因为我们在添加关系的时候，课程和教师都已经存好了，所以这时候我们只用操作中间表。

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

$post = Request::instance()->post();
// 获取要保存的关联课程
$courseIds = $post['course_id'];
$Teacher = new Teacher();
$Teacher->name        = $post['name'];
$Teacher->sex         = $post['sex'];
$Teacher->work_number = $post['work_number'];
$Teacher->password    = $post['password'];
if ($Teacher->save()) {
    // 在教师添加成功后修改中间表
    $Teacher->courses()->attach($courseIds);
    return $this->success('保存成功！', 'index');
} else {
    return $this->error('保存失败！');
}

获取从V层传过来的数据，包括要保存的所有课程id，然后当教师保存成功后再修改中间表，将教师和课程的id对应的存入中间表中。(attach()这个函数只会操作中间表，另外两个数据表不会被改变。)

关联删除

同样的关联删除只能操作中间表。

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

...
if ($Teacher->delete()) {
    // 获取所有的关联课程，依次删除
    $courses = $Teacher->courses;
    foreach ($courses as $course) {
        $Teacher->courses()->detach($course->id);
    }
    return $this->success('删除成功！', url('index'));
} else {
    return $this->error('删除失败！');
}
...

遍历获取所有的与删除的教师关联的课程，然后遍历删除。(同样，detach()函数也只会操作中间表)

关联编辑

编辑稍微复杂一点，需要先将原来的关联关系删除，然后再保存新的关系。也就是将上面的添加和删除合在一起了。这样一分析就简单了。

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

$post = Request::instance()->post();
$courseIds = $post['course_id'];
...
if ($Teacher->save()) {
    // 删除原来的关系
    $courses = $Teacher->courses;
    foreach ($courses as $course) {
        $Teacher->courses()->detach($course->id);
    }
    // 加入新的关系
    $Teacher->courses()->attach($courseIds);
    return $this->success('保存成功！', url('index'));
} else {
    return $this->error('保存失败！');
}

与添加一样，先获取V层传过来的id数组。然后在教师对象修改完后，去除原来的教师课程关系，然后将新的id存进去。

总结

最近用惯了java，在维护实体关系的时候都是由hibernate替我们自动维护的，只需要写几个注解和配置项。一方面我们感叹hibernate的强大；但是另一方面，我们有了实现功能的思想，发现自己去实现的时候也并不困难。

官方参考：
https://www.kancloud.cn/manual/thinkphp5/142359

安装nginx

直接使用命令：

1

sudo apt-get install nginx

这时候，如果没有出现问题的话，nginx就已经安装完成了。

但是在我安装的时候出现了如下问题：

解决办法

这个问题出现的原因是post-installation重复安装。

解决办法：

1.将文件备份：

1

sudo /var/lib/dpkg/info /var/lib/dpkg/info_old

2.新建info文件

1

sudo /var/lib/dpkg/info

3.重新生成文件内容

1
2

sudo apt-get update
sudo apt-get -f install

4.将info中的文件复制到info_old中

1

sudo mv /var/lib/dpkg/info/* /var/lib/dpkg/info_old

5.删除info，将info_old再改回info

1
2

sudo rm -rf /var/lib/dpkg/info
sudo mv /var/lib/dpkg/info_old /var/lib/dpkg/info

这样之后，再重新安装nginx，安装成功了。

启动nginx

成功安装nginx后，启动文件安装在/etc/init.d/下，创建启动脚本nginx。

启动nginx:

1

/etc/init.d/nginx start

安装成功了。

问题描述

整个系统的界面是采用继承的方式实现的，页面的菜单部分都使用同样的代码。菜单上有一个功能是用户信息。效果是点击它，就可以修改当前登录用户的信息。

实现思路

应为在登录的时候，通过使用session将当前登录的用户id存了起来。所以直接获取当前登录的id，然后点击按钮的时候将id传入，编辑这个人信息。

实现过程

控制器中获取登录用户的id，传入V层：

1
2
3
4
5

use think\Session;
...
$teacherId = Session::get('teacherId');
$this->assign('teacherId', $teacherId);
...

v层直接添加跳转，跳转到编辑的界面：

1
2
3

...
<li><a href="{:url('teacher/edit?id='.$teacherId)}"><i class="fa fa-user fa-fw"></i> 用户信息</a>
...

这时候报了这么一个错：

$teacherId没有定义，首先就去检查了一下我有没有拼写出错，发现没有后，检查这个变量是否传过来了，将变量换一个位置，变量存在。这时候陷入了僵局，完全不知道问题所在。又仔细看一一下报错，这时候文件名引起了我的注意，这是一个编译后的文件，将html中的tp代码都进行了转义。

这里突然发现这并不是我以为的文件，报错的位置是另一个文件。看到这里就知道问题的原因了。因为我的菜单使用了继承，所以没有重写的位置，完全使用原来的代码，但是这个时候，这个文件的控制器并没有定义$teacherId这个变量。

原因找到了，解决起来就简单了。

控制器使用了继承，有一个基本控制器，在这个基本控制器中定义一个构造函数，通过构造函数获取当前登录的用户id。相当在所有的控制器中都定义了$teacherId了。

总结

1.通过解决这个问题，又一次发现了快速找到问题原因的重要性。

2.不要想当然的定位错误。

问题描述

原来在进行更新操作的时候，都是使用put方法来进行请求的，但是这次在写更新的时候，只需要更新一个字段，所以使用了patch方法，那么，patch和put这两者有什么区别呢？

局部与整体

最基本的，patch是对put的一个补充。举个例子：

一个计量单位实体MeasurementUnit，他有name，weight，measurementUnitCategory等多个字段，在这里，我们要只修改weight这个字段，这时应该如何选择呢？

通常，我们为了省事，就会直接将修改了weight的完整的MeasurementUnit对象直接传给后台。但是这种做法实际上并不明智，这会浪费大量的网络带宽。

但是patch呢，他会只将weight传到制定资源去，表示这是一个局部更新，后端只更新收到的字段。

幂等性

另一个方面的区别：put是幂等的，而patch是非幂等的。

这里有一个比较有意思的概念，叫做幂等性。什么是幂等性呢，就是在请求某一资源的时候，多次操作与一次操作对被操作的对象达到的效果是一样的。简单举个例子：

用上面的更新来举例子，将权重weight更新为1，这种操作应该是执行多次都是达到同一个效果。

另一个操作，将weight更新为+1，这种操作显然多次操作就和一次操作不同了。

友情链接：

https://segmentfault.com/q/1010000011686226

https://segmentfault.com/q/1010000005685904

问题描述

有一个路由是这么定义的：

1

@PostMapping("/")

没有实际的路由，只有一个”/“，这时候，我们可以使用@PostMapping的默认值来代替上面的写法：

1

@PostMapping

然后我们在访问的时候，什么也不用做修改，和上面那种写法的访问路由完全相同。

默认值

发现这个现象的时候，首先就去看了一下这个注解的默认值。

默认值是"",所以什么都不写就相当于@PostMapping("").这时我们访问这个方法的时候路由应该这么写：/XXX。

多余的”/“

在将路由修改后，本应该将单元测试的访问路由一起修改的，但是我在第一遍进行单元测试的时候，并没有修改原来的路由：/XXX/。而单元测试依然通过。

所以在处理最后一个”/“的时候，在没有匹配的情况下，他会自动的将斜杠去掉。这就好像我们在浏览器中输入www.baidu.com/，这时候我们依然能访问的是www.baidu.com。Spring为我们将多余的斜杠去除了。

什么是AOP

相信大家对于AOP这个词都不陌生：面向切面编程。在解释这个概念的时候就不得不说一下他的适用情况了。在实际项目中，有一部分是主要的业务逻辑，而还有一部分很重要的就是非功能性需求，比如权限判断，事务控制，异常处理等等。这些功能有个共同的特点就是他们会贯穿项目，我们可能在很多的地方都需要做一些为了系统安全的操作，而这些操作又不能将他们放到业务逻辑中去，那样就会使我们的业务逻辑实现变得复杂。这时候就需要AOP这一利器。它会在某一个层面上统一执行一些操作，而这些操作我们在实现业务逻辑的时候就完全不用去考虑了。

简言之，AOP就是从复杂的业务逻辑中将非功能性需求抽离出来的办法。

Spring是如何实现AOP的

Spring在为我们实现AOP的时候提供了很好的支持。https://docs.spring.io/spring/docs/4.3.18.BUILD-SNAPSHOT/spring-framework-reference/htmlsingle/#aop

Aspect类

首先我们需要建立一个Aspect类，用来定义切面和执行切面的操作。在这个切面类中，首选需要定义一个切点：@Pointcut，它会告诉我们在哪里执行切的操作。然后就是定义advice函数，这些函数主要是告诉我们在切的时候执行什么操作。

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

@Aspect // 声明这个是一个切面
@Component  // 声明这个是一个组件。由于切面中，并没有包含Component，所以如果想让spring扫描到，必须那入@Component注解
public class InstrumentOwnerCheckAspect {
...
    @Pointcut("@annotation(com.mengyunzhi.measurement.annotation.InstrumentOwnerCheckAnnotation) && args(id,..)")
    public void doAccessCheck(Long id) {}
    @Before("doAccessCheck(id)")
    public void before(Long id) throws ObjectNotFoundException, AccessDeniedException {
        ...
    }
}

值得注意的是，在定义Aspect这个类的时候，我们需要使用@Component这个注解，以使它在项目启动的时候能够被Spring扫描到。

匹配注解

这个概念是对如何实现切的操作而说的。

这是说通过某一个注解就可以实现切的操作。

在这几个中，比较常用的是@annotation：在方法上使用注解。参数是告诉我们使用哪个注解，比如上面使用的就是AdminOnly注解。

有一个比较特殊的，是匹配方法：execution，它只能在某个方法的地方切。

1
2

// 在所有的public方法上切
@Pointcut("execution(public * *(..))")

他的用法在https://docs.spring.io/spring/docs/4.3.14.RELEASE/spring-framework-reference/html/aop.html#aop-pointcuts-examples上还要很多，这里就不一一介绍了。

匹配参数

匹配参数是同样也是在告诉我们在什么地方执行切的操作，不同的是，它只能告诉我们切点的参数是什么样子。所以匹配参数都是在切方法的时候用的。

参数匹配主要有两种execution和args：

这里推荐使用args。

五大Advice

advice是告诉我们在执行切的时候应该做什么的，而五大advice是根据在切点不同位置执行操作而区分的。

示例代码解读

1
2
3
4
5
6
7
8
9

...
@Pointcut("@annotation(com.mengyunzhi.measurement.annotation.InstrumentOwnerCheckAnnotation) && args(id,..)")
public void doAccessCheck(Long id) {}
@Before("doAccessCheck(id)")
public void before(Long id) throws ObjectNotFoundException, AccessDeniedException {
    ...
}
...

切点：InstrumentOwnerCheckAnnotation注解。参数：第一个参数是id的方法。

@Before在切之前执行操作。

所以上面的意思就是，在所有使用@InstrumentOwnerCheckAnnotation注解，并且第一个参数是id的方法处切，然后在切之前执行before方法。

总结

Spring的AOP帮助我们能够更加专注于实现某一部分的业务逻辑，而忽视夹杂其间的非功能性需求，在最大的可能上降低了我们的项目的整体耦合性，从而更好的实现面向对象的思想。

友情链接：

https://docs.spring.io/spring/docs/4.3.14.RELEASE/spring-framework-reference/html/aop.html

https://www.imooc.com/learn/869

问题描述

查询的实现使用了过滤器，然后还要实现分页。这个过滤器如果还是像以前一样在V层使用过滤器，那么就会先实现分页，然后再去查询的时候，分页的数据不会改变。比如查询出10条数据，那么分页获取的数据总数就是10条，然后过滤掉3条，这时页面上就会显示7条数据，但是分页获取的数据总数还是10条，这样就出现了数据的不同步。

解决办法

1.如何在controller使用过滤器?

首先先介绍一下过滤器在controller中的使用。

1
2
3
4

angular.module('myApp')
.controller('myController', function($filter) {
...
});

首先在开始的时候将$filter注入进来

1
2
3
4

angular.module('myApp')
.controller('myController', function($filter) {
$filter('myFilter')(param1, param2...);
});

然后使用$filter来注入你自己定义的过滤器，第一个括号中是个自己的过滤器的名子，后面的过滤器的参数。值得注意的是，这里我们要将过滤的对象放在第一个参数的位置。

2.解决问题

1

<tbody ng-repeat="person in persons | yunzhiPersonnel: filterParams.qualifierCertificateType: filterParams.validityDate | yunzhiQualifierNumber: filterParams.number">

原来的过滤器我是这么使用的。现在将过滤器放到controller中。

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

...
// 提交查询
self.submit = function() {
    $scope.filterParams = self.getFilterParams(); // 设置过滤条件
    PersonnelPersonnelsupervisefileService.getAllBySpecification(self.getQueryParams(), function(data) {
        $scope.persons = data; // 传入v层
        // 在这里调用过滤器，原因是为了适应分页的使用，需要在分页之前执行完查询，否则会出现少数据的现象。
        $scope.persons = $filter('yunzhiPersonnel')($scope.persons, $scope.filterParams.qualifierCertificateType, $scope.filterParams.validityDate);
        $scope.persons = $filter('yunzhiQualifierNumber')($scope.persons, $scope.filterParams.number);
        self.reload(); // 重新加载，显示分页
    });
};
...

这样在每次查询的时候，都先将查询的结果过滤一下，然后再对过滤的结果进行分页，就不会在出现数据对不上的现象了。

官方参考：https://docs.angularjs.org/api/ng/filter/filter

问题描述

在实现一个人员的查询功能的时候，有两个查询条件：人员资质和有效期至，人员和人员资质的关系是1：n，有效期至是人员资质的一个字段。在实现这个查寻的时候，而在后台通过n的一方来查询1的一方是很不好实现的。

解决办法

这个问题最后考虑在前台使用过滤器来实现，首先将满足其他查询条件的查询出来，然后将没有相应人员资质的人员过滤掉，这样就实现了。

解决过程

1.引入过滤器

首先我们知道，过滤器是通过管道符来使用的：

1

objects | filter

然后就是过滤器参数的问题，在管道符前面的objects就是第一个参数，过滤器至少有一个参数。现在有人员资质和有效期至，这两个是过滤的条件，必然也要作为参数。那么过滤器是如何传参的呢？

1

objects | filter: param

在过滤器后面写一个冒号:，然后冒号后面的就是参数。那两个参数呢？

1

objects | filter: param1: param2

连续使用冒号:就可以传多个参数了。好了，下面来解决我们的问题。

1

<tbody ng-repeat="person in persons | yunzhiPersonnel: params.qualifierCertificateType: params.validityDate">

然后实现过滤器的基本思想就是首先遍历人员，再遍历人员中的人员资质，当人员资质和查询的人员资质相同的时候，就将这个人员放到返回列表中，最后统一返回。

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

...
self.getQualifierWithQualifierCertificate = function(personnels, qualifierCertificateType, validityDate) {
    var persons = []; // 初始化符合条件的人员
    // 遍历人员
    angular.forEach(personnels, function(personnel) {
        var qualifierCertificates = personnel.qualifier.qualifierCertificate; // 获取人员资质
        // 如果输入了两个查询条件
        if (qualifierCertificateType.id && validityDate) {
            // 遍历人员资质
            angular.forEach(qualifierCertificates, function(qualifierCertificates) {
                // 当资格证类别与查询的资格证类别相同，并且有效期至也相同时，将人员放入返回人员数组中
                if (qualifierCertificates.qualifierCertificateType.name === qualifierCertificateType.name && qualifierCertificates.validityDate === validityDate) {
                    persons.push(personnel);
                }
            });
            // 如果输入资格证类别    
        } else if (qualifierCertificateType.id) {
            // 遍历人员资质
            angular.forEach(qualifierCertificates, function(qualifierCertificates) {
                // 资格证类别与查询的资格证类别相同
                if (qualifierCertificates.qualifierCertificateType.name === qualifierCertificateType.name) {
                    persons.push(personnel);
                }
            });
            // 输入有效期至   
        } else {
            // 遍历人员资质
            angular.forEach(qualifierCertificates, function(qualifierCertificates) {
                // 有效期至与查询的有效期至相同
                if (qualifierCertificates.validityDate === validityDate) {
                    persons.push(personnel);
                }
            });
        }
    });
    return persons;
};
...

2.过滤器及时生效

上面我在设置参数的时候，直接将查询的参数当做过滤参数，所以一旦输入了查询条件，就会直接过滤。而我们要的效果是，在用户点击查询后在显示过滤后的数据。

首先想到的是，在给这个过滤器一个参数：是否点击了查询。只有当用户点击了查询，这个参数为true，然后执行过滤，没有点击，这个参数为false，不执行过滤。

1

<tbody ng-repeat="person in persons | yunzhiPersonnel: params.qualifierCertificateType: params.validityDate：touched">

1
2
3
4
5
6
7

...
if(touched) {
return self.getQualifierWithQualifierCertificate(personnels, qualifierCertificateType, validityDate);
} else {
return personnels;
}
...

但是这种解决方法并不好。一个问题是，这种解决方法会带来一些其他的问题，比如说先查询了一次，再查询一次就又会出现上面直接出结果的问题；另一个问题，也是主要的问题，这种方法不符合规范，过滤器的职能就是过滤，不应该在过滤器中判断什么时候开始过滤，什么时候不过滤，而应该是我在需要过滤的时候，再给他过滤条件，不需要过滤的时候，就不给他过滤条件。

所以，在控制器中重新定义一个函数，用来获取过滤条件，这个方法在点击查询的时候调用。

1

<tbody ng-repeat="person in persons | yunzhiPersonnel: filterParams.qualifierCertificateType: filterParams.validityDate">

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

// 获取过滤参数
self.getFilterParams = function() {
    return {
        qualifierCertificateType: $scope.params.qualifierCertificateType, // 资格证类别
        validityDate: $scope.params.validityDate, // 有效期至
        // 这里还可以添加其他过滤条件
    };
};
// 提交查询
self.submit = function() {
    ...
    $scope.filterParams = self.getFilterParams(); // 设置过滤条件
    ...
};

总结

我们这种mvc的开发思想，在实现每一部分的时候，都要尽可能的使每一部分都只做自己的功能，这样不仅能增加代码的可读性，同时也增加了可维护性，在后面进行改写的时候也会减小压力。

在angular项目中，点击编辑人员操作，会在表单中默认显示选择的人员的信息，信息以下拉选框的形式展现，每个下拉选框都是一个指令。这时，技术机构指令和管理部门指令均以同一个字段：department作为他们的选项。他们两个都是部门，只是类型不同。对于同一个人员，只能有一个部门，所以要默认显示技术机构或管理部门。

排查原因

首先看一下我们的两个指令：

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

...
<div class="form-group" ng-show="showInstrumentUser">
    <label class="col-sm-4 control-label">技术机构</label>
    <div class="col-sm-8">
        <yunzhi-instrument-user ng-model="data.department" data-district="params.district" data-config="{departmentType: '技术机构'}"></yunzhi-instrument-user>
    </div>
</div>
<div class="form-group" ng-show="showManagementDepartment">
    <label class="col-sm-4 control-label">管理部门</label>
    <div class="col-sm-8">
        <yunzhi-management-department data-district="params.district" ng-model="data.department"></yunzhi-management-department>
    </div>
</div>
...

上面是我点击编辑后，根据id获取的人员有一个部门字段，内容为管理部门，这时应该默认选中管理部门。但是并没有选择上。所以让我们删除一下技术机构再看一下效果。

1
2
3
4
5
6
7
8

...
<div class="form-group" ng-show="showManagementDepartment">
    <label class="col-sm-4 control-label">管理部门</label>
    <div class="col-sm-8">
        <yunzhi-management-department data-district="params.district" ng-model="data.department"></yunzhi-management-department>
    </div>
</div>
...

这回默认选中了管理部门。这里不妨大胆的猜测一下原因：

由于技术机构的存在，我们将部门传进指令中，没有对应的技术机构，所以部门就成了空。

让我们将技术机构再放回来，然后调换一下两个指令的位置。

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

...
<div class="form-group" ng-show="showManagementDepartment">
    <label class="col-sm-4 control-label">管理部门</label>
    <div class="col-sm-8">
        <yunzhi-management-department data-district="params.district" ng-model="data.department"></yunzhi-management-department>
    </div>
</div>
<div class="form-group" ng-show="showInstrumentUser">
    <label class="col-sm-4 control-label">技术机构</label>
    <div class="col-sm-8">
        <yunzhi-instrument-user ng-model="data.department" data-district="params.district" data-config="{departmentType: '技术机构'}"></yunzhi-instrument-user>
    </div>
</div>
...

可以看到管理部门同样被默认选择上了，说明我们上面的猜测正确。

由于ng-model在angularjs中会使数据双向绑定，当前面的技术机构没有对应的对象存在时，它就会选中空值，这时又将这个空值绑定在ng-model上。两个指令的ng-model都绑定的是统一数据，所以后面的管理部门在取选中的时候，就是根据空值来选择的，当然选择不上了。

解决办法

我们最开始在controller中通过id获取对象时，直接将返回的对象中的属性给ng-model了，导致两个指令对应同一参数。

1
2
3
4
5
6
7

...
self.getOneById = function(id) {
    PersonnelPersonnelsupervisefileService.getOneById(id, function(data) {
        $scope.data = data;
    };
};
...

既然两个指令绑定同一变量会混乱，那我让他们绑定不同的变量是不是就可以了呢？

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

...
$scope.instrumentUser = undefined;// 初始化技术机构
$scope.managementDepartment = undefined;// 初始化管理部门
self.getOneById = function(id) {
    PersonnelPersonnelsupervisefileService.getOneById(id, function(data) {
        $scope.data = data; // 赋值
        $scope.params.district = data.department.district; // 为区域赋值
        // 如果数据的部门是管理部门,为管理部门赋值
        if (data.department.departmentType.pinyin === "guanlibumen") {
            $scope.managementDepartment = data.department;
            // 如果数据的部门是技术机构，为技术机构赋值
        } else if (data.department.departmentType.pinyin === "jishujigou") {
            $scope.instrumentUser = data.department;
        }
    });
};
...

首先定义两个变量，用来绑定不同的指令，当我们编辑的人员的部门的类型是技术机构，就为技术机构这个对象赋值；如果为部门类型是管理部门，就为管理部门赋值；否则均不赋值。然后再让两个指令绑定不同的变量。

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

<div class="form-group" ng-show="showInstrumentUser">
    <label class="col-sm-4 control-label">技术机构</label>
    <div class="col-sm-8">
        <yunzhi-instrument-user ng-model="instrumentUser" data-district="params.district" data-config="{departmentType: '技术机构'}"></yunzhi-instrument-user>
    </div>
</div>
<div class="form-group" ng-show="showManagementDepartment">
    <label class="col-sm-4 control-label">管理部门</label>
    <div class="col-sm-8">
        <yunzhi-management-department data-district="params.district" ng-model="managementDepartment"></yunzhi-management-department>
    </div>
</div>

到此，问题解决。但是肯定有细心的小朋友发现了，你在这里将部门用两个变量来表示，但对于人员来说这两个都不是我们要的字段，那保存的时候怎么绑定部门呢？

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

$scope.$watch('[instrumentUser, managementDepartment]', 
function(newValue) {
    var instrumentUser = newValue[0]; // 技术机构
    var managementDepartment = newValue[1]; // 管理部门
    // 当选择了技术机构，为监督抽查人员的部门字段赋值
    if (instrumentUser && instrumentUser.id) {
        $scope.data.department = instrumentUser;
        // 当选择了管理部门，为监督抽查人员的部门字段赋值
    } else if (managementDepartment && managementDepartment.id) {
        $scope.data.department = managementDepartment;
        // 当什么都没选时，为监督抽查人员的部门字段赋空值
    } else {
        if ($scope.data) {
            $scope.data.department = instrumentUser = managementDepartment;
        }
    }, true);

在这里我们监听一下技术机构和管理部门，当他们选择的时候，将他们选择的值赋给人员的部门。

总结

这次的问题中，显然我们的解决办法显得并不是多么高深的方法，很简单。所以解决问题的关键在快速的定位问题产生的原因，当原因找到后，问题也就迎刃而解了。

$watch监听函数

将监听的参数部分换为函数。虽然监听的是函数，但实际上监听的是函数的返回值。

1
2
3
4
5
6
7
8
9
10
11

$scope.food = 1;
$scope.foodCounter = 0;
$scope.$watch(
    function() { return $scope.food; },
    function(newValue, oldValue) {
        if (newValue !== oldValue) {
        console.log(newValue);
            $scope.foodCounter = $scope.foodCounter + 1;
        }
    }
);

然后让我们看一下我们监听的部分，看看是不是我们的返回值：

$watchGroup(watchExpressions, listener)

$watchGroup是scope上的另一个函数，他是$watch的功能扩展。他可以监听一个数组中的多个元素，当其中的人一个发生改变时，都会被监听到。

1
2
3
4
5

$scope.v1 = 'a';
$scope.v2 = 'a';
$scope.$watchGroup(['v1', 'v2'], function(newValues, oldValues) {
    console.log(newValues, oldValues);
});

$watchCollection(obj, listener)

$watchCollection也是scope上的一个函数，同样为$watch的扩展。他可以监听一个对象，当对象中的任一个属性发生改变额时候，都会被监听到。

obj 部分同样可以是String或是function。

1
2
3
4
5
6
7
8
9

$scope.people = {
    name: 'zhangsan',
    sex: '男'
};
$scope.dataCount = 0;
$scope.$watchCollection('people', function(newValue) {
    $scope.dataCount = $scope.dataCount + 1;
});

这个方法的功能跟使用$watch的第三个参数是一样的效果：当$watch的第三个参数为true的时候，就会实现这样的效果。

1

$scope.$watch('people', function(newValue) {}, true);

上一次我们已经提到过了，在这里使用true，表示新旧值将使用angular.equals来进行判等。在官方文档中有这么一句话：

Both objects or values are of the same type and all of their properties are equal by comparing them with angular.equals.

可以看到，这里的判等需要每个属性都相等。

总结

灵活的使用$watch以及相关的方法，会使你的展现的功能富有趣味，富有灵活性。

官方参考：https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$watch

监听一个对象

先来看一下他的基本用法：

1

$watch(string, function(), [optional]);

可以看到上面有三个参数，第一个是我们要监听的对象，他以字符串的方式呈现；

第二个参数是一个回调函数，他是我们在监听到变化是做的动作。他有三个参数：newValue，oldValue，scope。看名字就能知道这三个参数的含义：新值，旧值，当前作用域。

第三个参数是一个可选项，他是一个布尔值，使用angular.equals来比较对象，默认是false。

示例代码：

html部分：

1
2
3
4
5
6

...
<div ng-repeat='item in items'>  
    <span>{{item.title}}</span>  
    <input ng-model='item.quantity'>    
</div>
...

js部分：

1
2
3
4
5
6
7
8
9
10

$scope.items = [
{ title: '西瓜', quantity: 8, price: 3.95 }, 
{ title: '西红柿', quantity: 17, price: 12.95 }, 
{ title: '苹果', quantity: 5, price: 6.95 }];
$scope.$watch('items', function(newValue) {
if (newValue) {
console.log("这是一个新值！");
 }
}, true);

当我们改变输入框中的数字时，在控制台中就会出现这是一个新值！的字样。

监视多个对象

$watch 在监视两个对象的时候，后面的参数都和上面的相同，只有第一个是不一样的，变成了一个数组。

1

$watch('[object1, object2]', function(newValue), [optional]);

在监听两个变量的时候，我们看一下newValue是怎么个样子的：

下面的部分以项目中的指令为例：

1
2
3

scope.$watch('[instrumentType, discipline]', function(newValue) {
    console.log(newValue);
}, true);

监听了两个对象，反回来的当然也是两个对象了。那么我们就可在分别对这两个对象做一些事情，在第一个对象变化的时候和第二个对象变化的时候做不同的事情。

比如第一个变化的时候打印1，第二个变化的时候打印2：

1
2
3
4
5
6
7
8

scope.$watch('[instrumentType, discipline]', function(newValue) {
    if (newValue[0].selected && newValue[0].selected.id) {
    console.log("1");
}
if (newValue[1].selected && newValue[1].selected.id) {
console.log("2");
}
}, true);

这里就有人要问了，为什么我第一张打印的是2，而第二张打印的是1呢？原因是我们数组中对象的顺序与我们监听时设立的顺序是一样的：[instrumentType, discipline]。

我的应用

两个指令相互关联，但是又允许单独使用，所以就使用了上面的监听两个对象的做法。

效果展示：

总结

$watch是一个有趣且灵活的函数，当然$watch的用法还不止我所说的这几种，还有很多其他的用法。 参考网址

问题描述

添加新的菜单，存在老版本，需要照顾老版本。

解决过程

1.直接添加菜单

最开始没有考虑到版本的问题，所以直接添加了一个菜单。

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

// 人员资质
protected void addWebAppMenusPersonnel() {
...
 WebAppMenu personnelSuperviseFileMenu = new WebAppMenu();
    personnelSuperviseFileMenu.setRouteName("personnelSuperviseFile");
    personnelSuperviseFileMenu.setParentRouteWebAppMenu(personnelMenu);
    personnelSuperviseFileMenu.setParentWebAppMenu(personnelMenu);
    personnelSuperviseFileMenu.setName("监督抽查人员档案");
    personnelSuperviseFileMenu.setWeight(300);
    personnelSuperviseFileMenu.setDescription("人员资质管理监督抽查人员档案");
    webAppMenus.add(personnelSuperviseFileMenu);
}

但是，很明显这种方法有问题。

2.使用版本号进行控制

参考了一下以前的解决办法，生成一个随机的版本号，然后在执行初始化的时候判断一下有没有这个版本，如果没有，将版本号存进数据库，然后添加新的菜单；如果有，直接跳过。

上面的代码没有变，在开始的时候添加一个版本判断：

1
2
3
4
5
6
7
8
9
10

String batch3 = "M0xOM80H0UWKVvE5GpVUiAg1b1cnAw5j";
if (null == migrationService.findByBatch(batch3)) {
isAdd = true;   // 有新数据需要添加
    logger.info("维护版本信息");
    migrationService.saveByBatch(batch3);
    logger.info("人员资质功能新增");
    this.addWebAppMenusPersonnel();
}

这样会出现问题，在进行测试的时候，本应该出现一百多条的数据，只出现了几十条。原因是什么呢？

因为我们在这里使用的还是addWebAppMenusPersonnel()这个方法，但是这个方法中的菜单我们已经在前面统一添加的时候添加过了一次，现在再添加一次，那么就会产生重复。初始化执行到这里发现有问题，就停止执行了，所以测试就会出现问题。

3.最终解决

既然不能重复添加，那我们就要将新添加的菜单放在另一个函数中来单独添加。

首先将定义一个全局变量：personnelMenu。这是由于这是个父类的菜单，他会在两个函数中被调用。

1

private WebAppMenu personnelMenu;

然后定义一个函数，用来单独添加新的菜单，同时要删除原来人员资质中的相应菜单部分：

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

// 人员资质功能新增
private void addPersonnelFunction() {
    logger.info("为原有人员资质管理添加监督抽查人员档案");
    WebAppMenu personnelSuperviseFileMenu = new WebAppMenu();
    personnelSuperviseFileMenu.setRouteName("personnelSuperviseFile");
    personnelSuperviseFileMenu.setParentRouteWebAppMenu(personnelMenu);
    personnelSuperviseFileMenu.setParentWebAppMenu(personnelMenu);
    personnelSuperviseFileMenu.setName("监督抽查人员档案");
    personnelSuperviseFileMenu.setWeight(300);
    personnelSuperviseFileMenu.setDescription("人员资质管理监督抽查人员档案(适用于管理部门)");
    webAppMenus.add(personnelSuperviseFileMenu);
}

最后调用新建的函数：

1
2
3
4
5
6
7
8
9
10

String batch3 = "M0xOM80H0UWKVvE5GpVUiAg1b1cnAw5j";
if (null == migrationService.findByBatch(batch3)) {
    isAdd = true;   // 有新数据需要添加
    logger.info("维护版本信息");
    migrationService.saveByBatch(batch3);
    logger.info("人员资质功能新增");
    this.addPersonnelFunction();
}

这样问题就解决了。

总结

随着系统的完善，我们肯定会对系统升级多次，对数据的维护就显得至关重要。很多时候我们不能手动取操作数据表来维护数据，所以维护数据的代码就少不了了。这就是我们要实现的自动维护：程序一启动，完全不用考虑数据的问题。这才是我们想要的效果。

场景描述

两个实体，角色和菜单，关系多对多。使用：Jpa的@ManyToMany注解。

一：简单实现

第一种的实现方法就是在字段上简单使用多对多注解。

1
2
3
4
5
6
7

@Entity
public class Role implements Serializable{
    ...
    @ManyToMany
    private Set<WebAppMenu> webAppMenus = new HashSet<WebAppMenu>();
    ...
}

1
2
3
4
5
6
7

@Entity
public class WebAppMenu extends BaseWebAppMenu {
...
    @ManyToMany
    private Set<Role> roles = new HashSet<>();
    ...
}

但是在使用这种方法的时候，还需要使用@ManyToMany注解的一个属性mappedBy，来声明维护中间表的一方。如果在这个时候不使用这个属性，就会出现生成两张中间表的现象。

1
2
3
4
5
6
7

@Entity
public class WebAppMenu {
...
    @ManyToMany(mappedBy = "webAppMenus")
    private Set<Role> roles = new HashSet<>();
    ...
}

这次我们在role这个字段上的@ManyTomany注解上使用mappedBy，将维护权交给对方，也就是说roles不能维护双方的关系，关系由WebAppMenus来维护。这样就只会生成一张中间表。

二：中间表类

这种方法我们会直接定义一个中间表实体，然后将多对多的双方都映射到这个表中，这样一来就不用关维护方到底是谁了。

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

@Entity
@Table(name = "web_app_menu_role")
public class WebAppMenuRole implements Serializable{
...
    @ManyToOne
    @JoinColumn(name = "role_id", insertable = false, updatable = false)
    protected Role role;
    @ManyToOne
    @JoinColumn(name = "web_app_menu_id", insertable = false, updatable = false)
    protected WebAppMenu webAppMenu;
    ...
}

这是我们定义的中间表类，在这里，中间表和另外的两个实体关系都是多对一的，然后在实体上声明一下表名（也就是我们的中间表）：

1

@Table(name = "web_app_menu_role")

然后声明一下中间表中的字段名：

1
2

@JoinColumn(name = "role_id", insertable = false, updatable = false)
@JoinColumn(name = "web_app_menu_id", insertable = false, updatable = false)

在我们的两个实体中，实现如下：

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

@Entity
public class WebAppMenu {
...
    @ManyToMany
    @JoinTable(
            name = "web_app_menu_role",
            joinColumns = @JoinColumn(name = "web_app_menu_id"),
            inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles = new HashSet<>();
    ...
}

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

@Entity
public class Role implements Serializable{
    ...
    @ManyToMany
    @JoinTable(
            name = "web_app_menu_role",
            joinColumns = @JoinColumn(name = "role_id"),
            inverseJoinColumns = @JoinColumn(name = "web_app_menu_id")
    )
    private Set<WebAppMenu> webAppMenus = new HashSet<WebAppMenu>();
    ...
}

关联的实体中依然使用@ManyToMany注解，然后再使用@JoinTable注解，声明将这两个字段映射到中间表里，并对应上面的字段名。

友情参考：https://en.wikibooks.org/wiki/Java_Persistence/ManyToMany

问题描述

两个实体：角色和菜单，多对多关联，由一张中间表来维护。现在要修改其中其中菜单的关联，将菜单换成他的基类菜单。出现问题的位置：通过角色获取所有的菜单。

解决过程

修改实体对应的关系这个比较简单，但在进行查询操作的时候就出现了问题。我们都知道，在通过角色获取所有菜单的时候，必然要通过中间表来找到对应的菜单。这时候报错出现了：

可以看到，报错中说不能从元组中实例化BaseWebAppMenu这个类从。原因是什么呢?

中间Google了好多办法，但是都不行。最终找到了问题的原因：BaseWebAppMenu这个父类是一个抽象类，不能进行实例化。

1
2

@Query(value = "SELECT new BaseWebAppMenu(w.baseWebAppMenu.id) FROM UserRole u, WebAppMenuRole w where w.role.id = u.role.id and u.user.id=?1")
List<BaseWebAppMenu> findAllByUserId(Long userId);

这里简单看了一下什么是元组：一个容器对象，包含了多个对象，允许从容器中读取，不允许向里添加。

在repository中，我们需要通过角色获取所有的菜单，这时候我们使用了@Query这个注解，它在执行查询的时候会返回一个元组，元组中的对象就是实例化的基本菜单，但是基本菜单又不能实例化，所以就报出了上面的错误。

解决办法

解决的办法很简单，既然抽象类不能实例化，那么我们就不让他是抽象类不就行了。

总结

在这里我们虽然是成功的解决了问题，但是我们又不得不思考后面的问题：我们的历史数据怎么实现保存。所以，还是要权衡一下能不能使用这个办法。

遇到的问题

解决这个问题的时候，google了不少的办法，但是没有成功。无论是使用if条件判断，还是使用exist函数的时候都会报错。

1
2
3
4

if Not exists(select * from sysobjects where id=object_id('tableName') and name='columnName' ) then
begin 
alert table tableName add columnName
end;

这个时候会报出字段不存在的错，在执行select这条命令的时候，由于数据表中还没有columnName这个字段，也就不认识columnName，所以报错。

类似的，中间还出过几个错，在这里就不一一列举了。

最终的解决办法

最后的解决办法是在一个mysql的官方讨论区里找到的。在这里先给出解法。

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

SET @dbname = DATABASE ( );
SET @tablename = "tableName";
SET @columnname = "columnName";
SET @preparedStatement = (
SELECT
IF (
(
SELECT
COUNT( * ) 
FROM
INFORMATION_SCHEMA.COLUMNS 
WHERE
( table_name = @tablename ) 
AND ( table_schema = @dbname ) 
AND ( column_name = @columnname ) 
) > 0,
"SELECT 1",
CONCAT( "ALTER TABLE ", @tablename, " ADD ", @columnname, " VARCHAR(31) not null;" ) 
) 
);
PREPARE alterIfNotExists 
FROM
@preparedStatement;
EXECUTE alterIfNotExists;
DEALLOCATE PREPARE alterIfNotExists;

下面我做下简单解释。

1.首先，定义了三个变量，分别为数据库名，表名，字段名，这是后面会重复用到的，所以在这里进行定义。
2.然后定义了另一个变量，这个变量主要执行查找select，查找是否存在我们要添加的字段的相关记录。
3.最后是这个解法的最特别之处：定义一个预处理变量，这个变量就是处理上面我们的查找的那个变量，然后执行预处理。最后Deallocate一下，释放所使用的数据库资源

预处理语句

好了，问题解决了，但是肯定还是有疑惑的：什么是预处理语句呢？

MySQL官方将prepare、execute、deallocate统称为PREPARE STATEMENT。我们称之为【预处理语句】

预处理，顾名思义，预先处理。他会在sql执行之前进行语句解析，然后统一执行一次或多次。通过上面的例子我们可以看到，预处理其实非常简单。

笔者对sql研究较少，理解有限，所以在这里给出预处理的官方参考。

总结

通过这次编写sql语句，感受到了sql的博大，从最开始比较水比较基础的sql语句，到后面使用预处理，语句质量提升了一大步，对sql又产生了兴趣。

问题描述

两个系统，他们公用同一个后台。每个系统都有一个菜单类，现在两个菜单类实体的属性基本相同，需要用实体继承来实现。

策略一：单表映射（single）

描述

单表映射，顾名思义，只有一张表。它表示父类和继承它的子类共同使用一张数据表，然后另设一个字段，用来区分不同的实体。

用法演示

父类：

在父类中使用注解@Inheritance来声明这是继承的父类，然后在参数中定义继承的策略：单表继承SINGLE_TABLE。

使用注解@DiscriminatorColumn来生成一个新的字段，用来区别两个不同的子类。参数为字段的名字。

1
2
3
4
5
6
7

@Entity
@Table(name = "web_app_menu")       
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)   
@DiscriminatorColumn(name = "DB_TYPE")      
public abstract class BaseWebAppMenu {
    // 省略具体内容
}

子类：

在子类中，只需要通过注解@DiscriminatorValue来设置自己对应的用来区分的字段的名字。然后继承父类就行了。

1
2
3
4

@Entity
@DiscriminatorValue("web_app_menu")    
public class WebAppMenu extends BaseWebAppMenu {
}

1
2
3
4

@Entity
@DiscriminatorValue("automation")   
public class AutomationWebAppMenu extends BaseWebAppMenu {
}

最后会生成类似下面的表结构：

策略二：Joined策略

描述

这种策略从字面上来看：加入，加盟。它的意思就是父类和子类都各自生成数据表，但是，父类的数据表中只有公共的字段，子类的数据表中只有扩展的字段。你生成你的字段，我生成我的字段，然后我们合起来就是完整的表了。

用法演示

父类：

父类中只需要通过@Inheritance注解来声明这是父类，然后策略为：JOINED。

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

@Entity
@Inheritance(strategy = InheritanceType.JOINED)   
public abstract class BaseWebAppMenu {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private String pinyin;
    private String description;
    private boolean isAbstract = false;
    private Boolean status = true;
    private String remark;
    private Boolean isShow = true;
    // 省略相关函数
}

子类：

由于需要对应不同的数据表，而又没有重新定义主键，所以需要使用@PrimaryKeyJoinColumn注解来声明一下主键。

1
2
3
4
5

@Entity
@PrimaryKeyJoinColumn(name = "web_app_menu_id")    
public class WebAppMenu extends BaseWebAppMenu {
public String head;
}

1
2
3
4
5

@Entity
@PrimaryKeyJoinColumn("automation_id")   
public class AutomationWebAppMenu extends BaseWebAppMenu {
public String foot;
}

策略三：Table per Class策略

描述

这个策略也很好理解：一个类一张表嘛。而这个策略的特点是，每个子类单独创建数据表，并且拥有父类中的所有属性，数据也不会共享。

用法演示

父类：

父类的改动很小，只需要将上面的策略换成：TABLE_PER_CLASS就行了。

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

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)   
public abstract class BaseWebAppMenu {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private String pinyin;
    private String description;
    private boolean isAbstract = false;
    private Boolean status = true;
    private String remark;
    private Boolean isShow = true;
    // 省略相关函数
}

子类：

由于子类生成的表中会包含所有字段，所以子类什么也不需要做。

1
2
3
4

@Entity
public class WebAppMenu extends BaseWebAppMenu {
public String head;
}

1
2
3
4

@Entity
public class AutomationWebAppMenu extends BaseWebAppMenu {
public String foot;
}

总结

Hibernate为我们解决了实体继承的问题，让我们不必再纠结实体与数据表的关系。但是这三种映射策略并不是什么时候都能使用的，还是需要看实际的项目中是什么样的情况，针对不同的情况使用不同的策略，才能发挥他最强大的功能。

什么是Docker？

Docker 在维基百科上的解释是：

Docker是一个开放原始码软体专案，让应用程式布署在软体容器下的工作可以自动化进行，借此在Linux作业系统上，提供一个额外的软体抽象层，以及作业系统层虚拟化的自动管理机制.

emmmmm，很抽象。简单来说，Docker就是一个容器，就是一个小型的虚拟机，而他要比虚拟机更有优势，他体积更小，开启关闭更快。

Docker有什么优势？

docker将同一类的项目都放到了一个容器中，那么我们就不需要为分类而苦恼了，每个不同的容器，都装了不同类的东西。在我们的项目中，不同的项目可能需要不同的环境，那么我们用docker将每一个项目所需的环境都放到不同的容器中，一来我们不用担心大家的环境不统一；二来一个人配置好环境，大家的环境就都配置好了，节省了时间。

Docker安装

Windows和mac上的安装都比较简单，可以直接到Docker官网上下载，然后直接安装就行。下面我介绍一下在Ubuntu上的安装。

准备工作

1.首先要检查一下你的Linux内核版本，需要大于3.10，当然，大部分都是满足的。

1

uname -r

2.更新源文件。

1

sudo apt-get update

3.安装https传输和CA证书

1

sudo apt-get install apt-transport-https ca-certificates

4.添加新的GPG

1

sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

5.编辑source.list

在/etc/apt/source.list中添加新的仓库：

1

deb https://apt.dockerproject.org/repo ubuntu-xenial main #docker repository

6.重新更新

1

sudo apt-get update

安装

源文件添加完了，安装就简单了：

1

sudo apt-get install docker-engine

验证是否安装成功

1

docker -v

配置用户组

这里需要将自己添加到docker的用户组中，这样以后我们执行docker的命令时就不用输入sudo了。

1

sudo gpasswd a+x ${USER} docker

重启docker服务

1

sudo service docker restart

如果看到类似的版本信息，就说明你安装成功了。

运行Docker服务

在这里给大家介绍几个常用的docker命令。

1.docker images

这个命令会列出所有的镜像：

1

docker images

2.docker rmi + repository/image id

这个命令会删除存在的镜像，后面用镜像的名字或是对应的id都可以：

1

docker rmi nginx

3.docker run

运行镜像：

1

docker run nginx

4.docker ps [-a]

列出所有的正在运行的容器，加上-a会将运行过的容器都显示出来：

1

docker ps

1

docker ps -a

5.docker rm

删除容器

1
2
3
4
5
6
7
8
9

docker rm 16f1af7c5b65
``` 
### 6.docker stop
停止正在运行的容器
```bash
docker stop nginx

7.docker pull

从远程仓库拉取镜像

8.docker build

创建自己的镜像

9.docker commit

保存更改过的新镜像

总结

相信docker这门技术以后会是团队合作的必备，也会成为我们这个大数据，云服务崛起的时代的一项必不可少的技术。

相关参考：https://www.imooc.com/learn/867

为什么要使用异步

简单来说,使用异步出于无奈.在同一个线程中,一个函数执行的时间过长,那么后面的函数就只能等着,那么我们就需要另外使用一个线程,将运行时间长的函数放到这个单独的线程中去执行.

java 异步编程

下面介绍两种 java 中的异步编程方式.

Future方式的异步编程

Future 表示未来的某个异步计算的结果, 当我们向线程池提交任务的时候,就会获得这个对象. 然后可以使用 get 方法来获取计算完成的结果,并且只有在计算完成时才能使用.

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

interface ArchiveSearcher { String search(String target); }
class App {
    ExecutorService executor = ...        // 执行者,用来执行函数
    ArchiveSearcher searcher = ...
    void showSearch(final String target) throws InterruptedException {
        Future<String> future = executor.submit(new Callable<String>() {
            public String call() {
                return searcher.search(target);
        }});
        displayOtherThings();           // 在这里可以做一些其他的事情
        try {
            displayText(future.get());  // 使用 future, 获取结果
        } catch (ExecutionException ex) { 
            cleanup(); 
            return; 
        }
    }
}

可以看到,在这段代码中,我们先定义了一个执行者,他会执行未来的某个函数.然后我们定义了一个Future对象,他的值就是上面的执行者 executor 执行了 call 函数后的返回值.这个call函数中就是我们要执行的运行时间很长的函数.在他之后,这个函数或交给另一个线程去执行,而我们也不用等待这个函数执行完,可以去做一些其他的事情.最后,使用 Future 对象中的get方法,获取函数执行后的返回值.

注意: 这里有可能会抛出一个执行异常,所以我们需要在这里使用try catch来处理一下异常.

CompletableFuture方式的异步编程

首先肯定就有人会问,有了Future,那为什么还要选择CompletableFuture这种异步编程的方式呢?

答案显而易见:Future存在缺陷.

Future虽然实现了异步,但是他缺少通知机制,所以我们并不能知道函数什么时候执行结束.

使用阻塞,在future.get()的地方等待函数返回结果,但是这样就又成了同步的方式了.

使用isDone来进行轮询判断Future是否执行结束,但这样又会显得很多余,浪费很多的CPU.

有问题必然就要解决,所以就有了我们的 CompletableFuture 的编程方式.

CompletableFuture 这种异步编程的方式是在java8才出现的新的异步编程方式.他解决了一些在Future上存在的问题.使得java完整的实现了非阻塞方式的异步编程.

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

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("Hello");
});
try {
    future.get();
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}
System.out.println("CompletableFuture");

这里我们可以看到,我们调用了CompletableFuture中的一个静态方法runAsync()来执行异步代码(这里会默认分配给他一个线程池), 他会返回一个没有返回值的CompletableFuture.

当然, CompletableFuture 当中还有很多的静态方法,可以获取没有返回值的,同样也可以获取有返回值的.这里就不一一介绍了.在最后我会给出链接,读者可自行学习.

总结

虽然我们有异步编程的方式去解决函数执行时间长的问题,但是却不要首先想到这个执行办法,首先还是要看我们的函数时候能够减少数据库的IO操作,然后再去想是否应该使用异步编程.

官方参考:

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html