精华内容
下载资源
问答
  • 【知识图谱】知识图谱的基础概念与构建流程

    千次阅读 多人点赞 2019-11-09 18:46:49
    该该模块从文档中抽取的上下位关系信息,生成(下义,上义)数据对,例如(狗,动物)、(悉尼,城市)。提取上下位关系最简单的方法是解析百科类站点的分类信息(如维基百科的“分类”和百度百科的“开放分类...

    目录

    1、引言

    2、知识图谱的定义

    3、知识图谱的架构

    3.1 知识图谱的逻辑结构

    3.2 知识图谱的体系架构

    4、代表性知识图谱库

    5、知识图谱构建的关键技术

    5.1 知识提取

    5.2 知识表示

    5.3 知识融合


    【导读】知识图谱技术是人工智能技术的组成部分,其强大的语义处理和互联组织能力,为智能化信息应用提供了基础。我们专知的技术基石之一正是知识图谱-构建AI知识体系-专知主题知识树简介。下面我们特别整理了关于知识图谱的技术全面综述,涵盖基本定义与架构、代表性知识图谱库、构建技术、开源库和典型应用。

    1、引言

    随着互联网的发展,网络数据内容呈现爆炸式增长的态势。由于互联网内容的大规模、异质多元、组织结构松散的特点,给人们有效获取信息和知识提出了挑战。知识图谱(Knowledge Graph) 以其强大的语义处理能力和开放组织能力,为互联网时代的知识化组织和智能应用奠定了基础。最近,大规模知识图谱库的研究和应用在学术界和工业界引起了足够的注意力[1-5]。一个知识图谱旨在描述现实世界中存在的实体以及实体之间的关系。知识图谱于2012年5月17日由[Google]正式提出[6],其初衷是为了提高搜索引擎的能力,改善用户的搜索质量以及搜索体验。随着人工智能的技术发展和应用,知识图谱作为关键技术之一,已被广泛应用于智能搜索、智能问答、个性化推荐、内容分发等领域。

    2、知识图谱的定义

    在维基百科的官方词条中:知识图谱是Google用于增强其搜索引擎功能的知识库。本质上, 知识图谱旨在描述真实世界中存在的各种实体或概念及其关系,其构成一张巨大的语义网络图,节点表示实体或概念,边则由属性或关系构成。现在的知识图谱已被用来泛指各种大规模的知识库。 在具体介绍知识图谱的定义,我们先来看下知识类型的定义:

    知识图谱中包含三种节点:

    实体: 指的是具有可区别性且独立存在的某种事物。如某一个人、某一个城市、某一种植物等、某一种商品等等。世界万物有具体事物组成,此指实体。如图1的“中国”、“美国”、“日本”等。,实体是知识图谱中的最基本元素,不同的实体间存在不同的关系。

    语义类(概念):具有同种特性的实体构成的集合,如国家、民族、书籍、电脑等。 概念主要指集合、类别、对象类型、事物的种类,例如人物、地理等。

    内容: 通常作为实体和语义类的名字、描述、解释等,可以由文本、图像、音视频等来表达。

    属性(值): 从一个实体指向它的属性值。不同的属性类型对应于不同类型属性的边。属性值主要指对象指定属性的值。如图1所示的“面积”、“人口”、“首都”是几种不同的属性。属性值主要指对象指定属性的值,例如960万平方公里等。

    关系: 形式化为一个函数,它把kk个点映射到一个布尔值。在知识图谱上,关系则是一个把kk个图节点(实体、语义类、属性值)映射到布尔值的函数。

    基于上述定义。基于三元组是知识图谱的一种通用表示方式,即,其中,是知识库中的实体集合,共包含|E|种不同实体; 是知识库中的关系集合,共包含|R|种不同关系;代表知识库中的三元组集合。三元组的基本形式主要包括(实体1-关系-实体2)和(实体-属性-属性值)等。每个实体(概念的外延)可用一个全局唯一确定的ID来标识,每个属性-属性值对(attribute-value pair,AVP)可用来刻画实体的内在特性,而关系可用来连接两个实体,刻画它们之间的关联。如下图1的知识图谱例子所示,中国是一个实体,北京是一个实体,中国-首都-北京 是一个(实体-关系-实体)的三元组样例北京是一个实体 ,人口是一种属性2069.3万是属性值。北京-人口-2069.3万构成一个(实体-属性-属性值)的三元组样例。

    微信图片_20170930152906.jpg

    图1 知识图谱示例

    3、知识图谱的架构

    知识图谱的架构包括自身的逻辑结构以及构建知识图谱所采用的技术(体系)架构。

    3.1 知识图谱的逻辑结构

    知识图谱在逻辑上可分为模式层与数据层两个层次,数据层主要是由一系列的事实组成,而知识将以事实为单位进行存储。如果用(实体1,关系,实体2)、(实体、属性,属性值)这样的三元组来表达事实,可选择图数据库作为存储介质,例如开源的Neo4j[7]、Twitter的FlockDB[8]、sones的GraphDB[9]等。模式层构建在数据层之上,是知识图谱的核心,通常采用本体库来管理知识图谱的模式层。本体是结构化知识库的概念模板,通过本体库而形成的知识库不仅层次结构较强,并且冗余程度较小。

    3.2 知识图谱的体系架构

    图2 知识图谱的技术架构

    知识图谱的体系架构是其指构建模式结构,如图2所示。其中虚线框内的部分为知识图谱的构建过程,也包含知识图谱的更新过程。知识图谱构建从最原始的数据(包括结构化、半结构化、非结构化数据)出发,采用一系列自动或者半自动的技术手段,从原始数据库和第三方数据库中提取知识事实,并将其存入知识库的数据层和模式层,这一过程包含:信息抽取、知识表示、知识融合、知识推理四个过程,每一次更新迭代均包含这四个阶段。知识图谱主要有自顶向下(top-down)与自底向上(bottom-up)两种构建方式。自顶向下指的是先为知识图谱定义好本体与数据模式,再将实体加入到知识库。该构建方式需要利用一些现有的结构化知识库作为其基础知识库,例如Freebase项目就是采用这种方式,它的绝大部分数据是从维基百科中得到的。自底向上指的是从一些开放链接数据中提取出实体,选择其中置信度较高的加入到知识库,再构建顶层的本体模式[10]。目前,大多数知识图谱都采用自底向上的方式进行构建,其中最典型就是Google的Knowledge Vault[11]和微软的Satori知识库。现在也符合互联网数据内容知识产生的特点。

    4、代表性知识图谱库

    根据覆盖范围而言,知识图谱也可分为开放域通用知识图谱和垂直行业知识图谱[12]。开放通用知识图谱注重广度,强调融合更多的实体,较垂直行业知识图谱而言,其准确度不够高,并且受概念范围的影响,很难借助本体库对公理、规则以及约束条件的支持能力规范其实体、属性、实体间的关系等。通用知识图谱主要应用于智能搜索等领域。行业知识图谱通常需要依靠特定行业的数据来构建,具有特定的行业意义。行业知识图谱中,实体的属性与数据模式往往比较丰富,需要考虑到不同的业务场景与使用人员。下图展示了现在知名度较高的大规模知识库。

    微信图片_20170930153056.jpg

    图3 代表性知识图谱库概览

    5、知识图谱构建的关键技术

    大规模知识库的构建与应用需要多种技术的支持。通过知识提取技术,可以从一些公开的半结构化、非结构化和第三方结构化数据库的数据中提取出实体、关系、属性等知识要素。知识表示则通过一定有效手段对知识要素表示,便于进一步处理使用。然后通过知识融合,可消除实体、关系、属性等指称项与事实对象之间的歧义,形成高质量的知识库。知识推理则是在已有的知识库基础上进一步挖掘隐含的知识,从而丰富、扩展知识库。分布式的知识表示形成的综合向量对知识库的构建、推理、融合以及应用均具有重要的意义。接下来,本文将以知识抽取、知识表示、知识融合以及知识推理技术为重点,选取代表性的方法,说明其中的相关研究进展和实用技术手段 。

    5.1 知识提取

    知识抽取主要是面向开放的链接数据,通常典型的输入是自然语言文本或者多媒体内容文档(图像或者视频)等。然后通过自动化或者半自动化的技术抽取出可用的知识单元,知识单元主要包括实体(概念的外延)、关系以及属性3个知识要素,并以此为基础,形成一系列高质量的事实表达,为上层模式层的构建奠定基础。

    1.1 实体抽取

    实体抽取也称为命名实体学习(named entity learning) 或命名实体识别 (named entity recognition),指的是从原始数据语料中自动识别出命名实体。由于实体是知识图谱中的最基本元素,其抽取的完整性、准确率、召回率等将直接影响到知识图谱构建的质量。因此,实体抽取是知识抽取中最为基础与关键的一步。参照文献[13],我们可以将实体抽取的方法分为4种:基于百科站点或垂直站点提取、基于规则与词典的方法、基于统计机器学习的方法以及面向开放域的抽取方法。基于百科站点或垂直站点提取则是一种很常规基本的提取方法;基于规则的方法通常需要为目标实体编写模板,然后在原始语料中进行匹配;基于统计机器学习的方法主要是通过机器学习的方法对原始语料进行训练,然后再利用训练好的模型去识别实体;面向开放域的抽取将是面向海量的Web语料[14]。

    1) 基于百科或垂直站点提取

    基于百科站点或垂直站点提取这种方法是从百科类站点(如维基百科、百度百科、互动百科等)的标题和链接中提取实体名。这种方法的优点是可以得到开放互联网中最常见的实体名,其缺点是对于中低频的覆盖率低。与一般性通用的网站相比,垂直类站点的实体提取可以获取特定领域的实体。例如从豆瓣各频道(音乐、读书、电影等)获取各种实体列表。这种方法主要是基于爬取技术来实现和获取。基于百科类站点或垂直站点是一种最常规和基本的方法。

    2) 基于规则与词典的实体提取方法

    早期的实体抽取是在限定文本领域、限定语义单元类型的条件下进行的,主要采用的是基于规则与词典的方法,例如使用已定义的规则,抽取出文本中的人名、地名、组织机构名、特定时间等实体[15]。文献[16]首次实现了一套能够抽取公司名称的实体抽取系统,其中主要用到了启发式算法与规则模板相结合的方法。然而,基于规则模板的方法不仅需要依靠大量的专家来编写规则或模板,覆盖的领域范围有限,而且很难适应数据变化的新需求。

    3) 基于统计机器学习的实体抽取方法

    鉴于基于规则与词典实体的局限性,为具更有可扩展性,相关研究人员将机器学习中的监督学习算法用于命名实体的抽取问题上。例如文献[17]利用KNN算法与条件随机场模型,实现了对Twitter文本数据中实体的识别。单纯的监督学习算法在性能上不仅受到训练集合的限制,并且算法的准确率与召回率都不够理想。相关研究者认识到监督学习算法的制约性后,尝试将监督学习算法与规则相互结合,取得了一定的成果。例如文献[18]基于字典,使用最大熵算法在Medline论文摘要的GENIA数据集上进行了实体抽取实验,实验的准确率与召回率都在70%以上。近年来随着深度学习的兴起应用,基于深度学习的命名实体识别得到广泛应用。在文献[19],介绍了一种基于双向LSTM深度神经网络和条件随机场的识别方法,在测试数据上取得的最好的表现结果。

    微信图片_20170930153146.jpg

    图4 基于BI-LSTM和CRF的架构

    4) 面向开放域的实体抽取方法

    针对如何从少量实体实例中自动发现具有区分力的模式,进而扩展到海量文本去给实体做分类与聚类的问题,文献[20]提出了一种通过迭代方式扩展实体语料库的解决方案,其基本思想是通过少量的实体实例建立特征模型,再通过该模型应用于新的数据集得到新的命名实体。文献[21]提出了一种基于无监督学习的开放域聚类算法,其基本思想是基于已知实体的语义特征去搜索日志中识别出命名的实体,然后进行聚类。

    1.2 语义类抽取

    语义类抽取是指从文本中自动抽取信息来构造语义类并建立实体和语义类的关联, 作为实体层面上的规整和抽象。以下介绍一种行之有效的语义类抽取方法,包含三个模块:并列度相似计算、上下位关系提取以及语义类生成 [22]。

    1) 并列相似度计算

    并列相似度计算其结果是词和词之间的相似性信息,例如三元组(苹果,梨,s1)表示苹果和梨的相似度是s1。两个词有较高的并列相似度的条件是它们具有并列关系(即同属于一个语义类),并且有较大的关联度。按照这样的标准,北京和上海具有较高的并列相似度,而北京和汽车的并列相似度很低(因为它们不属于同一个语义类)。对于海淀、朝阳、闵行三个市辖区来说,海淀和朝阳的并列相似度大于海淀和闵行的并列相似度(因为前两者的关联度更高)。

    当前主流的并列相似度计算方法有分布相似度法(distributional similarity) 和模式匹配法(pattern Matching)。分布相似度方法[23-24]基于哈里斯(Harris)的分布假设(distributional hypothesis)[25],即经常出现在类似的上下文环境中的两个词具有语义上的相似性。分布相似度方法的实现分三个步骤:第一步,定义上下文;第二步,把每个词表示成一个特征向量,向量每一维代表一个不同的上下文,向量的值表示本词相对于上下文的权重;第三步,计算两个特征向量之间的相似度,将其作为它们所代表的词之间的相似度。 模式匹配法的基本思路是把一些模式作用于源数据,得到一些词和词之间共同出现的信息,然后把这些信息聚集起来生成单词之间的相似度。模式可以是手工定义的,也可以是根据一些种子数据而自动生成的。分布相似度法和模式匹配法都可以用来在数以百亿计的句子中或者数以十亿计的网页中抽取词的相似性信息。有关分布相似度法和模式匹配法所生成的相似度信息的质量比较参见文献。

    2) 上下位关系提取

    该该模块从文档中抽取词的上下位关系信息,生成(下义词,上义词)数据对,例如(狗,动物)、(悉尼,城市)。提取上下位关系最简单的方法是解析百科类站点的分类信息(如维基百科的“分类”和百度百科的“开放分类”)。这种方法的主要缺点包括:并不是所有的分类词条都代表上位词,例如百度百科中“狗”的开放分类“养殖”就不是其上位词;生成的关系图中没有权重信息,因此不能区分同一个实体所对应的不同上位词的重要性;覆盖率偏低,即很多上下位关系并没有包含在百科站点的分类信息中。

    在英文数据上用Hearst 模式和IsA 模式进行模式匹配被认为是比较有效的上下位关系抽取方法。下面是这些模式的中文版本(其中NPC 表示上位词,NP 表示下位词):

    NPC { 包括| 包含| 有} {NP、}* [ 等| 等等]
    NPC { 如| 比如| 像| 象} {NP、}*
    {NP、}* [{ 以及| 和| 与} NP] 等 NPC
    {NP、}* { 以及| 和| 与} { 其它| 其他} NPC
    NP 是 { 一个| 一种| 一类} NPC

    此外,一些网页表格中包含有上下位关系信息,例如在带有表头的表格中,表头行的文本是其它行的上位词。

    3) 语义类生成

    该模块包括聚类和语义类标定两个子模块。聚类的结果决定了要生成哪些语义类以及每个语义类包含哪些实体,而语义类标定的任务是给一个语义类附加一个或者多个上位词作为其成员的公共上位词。此模块依赖于并列相似性和上下位关系信息来进行聚类和标定。有些研究工作只根据上下位关系图来生成语义类,但经验表明并列相似性信息对于提高最终生成的语义类的精度和覆盖率都至关重要。

    1.3 属性和属性值抽取

    属性提取的任务是为每个本体语义类构造属性列表(如城市的属性包括面积、人口、所在国家、地理位置等),而属性值提取则为一个语义类的实体附加属性值。属性和属性值的抽取能够形成完整的实体概念的知识图谱维度。常见的属性和属性值抽取方法包括从百科类站点中提取,从垂直网站中进行包装器归纳,从网页表格中提取,以及利用手工定义或自动生成的模式从句子和查询日志中提取。

    常见的语义类/ 实体的常见属性/ 属性值可以通过解析百科类站点中的半结构化信息(如维基百科的信息盒和百度百科的属性表格)而获得。尽管通过这种简单手段能够得到高质量的属性,但同时需要采用其它方法来增加覆盖率(即为语义类增加更多属性以及为更多的实体添加属性值)。

    微信图片_20170930153321.jpg

    图5 爱因斯坦信息页

    由于垂直网站(如电子产品网站、图书网站、电影网站、音乐网站)包含有大量实体的属性信息。例如上图的网页中包含了图书的作者、出版社、出版时间、评分等信息。通过基于一定规则模板建立,便可以从垂直站点中生成包装器(或称为模版),并根据包装器来提取属性信息。从包装器生成的自动化程度来看,这些方法可以分为手工法(即手工编写包装器)、监督方法、半监督法以及无监督法。考虑到需要从大量不同的网站中提取信息,并且网站模版可能会更新等因素,无监督包装器归纳方法显得更加重要和现实。无监督包装器归纳的基本思路是利用对同一个网站下面多个网页的超文本标签树的对比来生成模版。简单来看,不同网页的公共部分往往对应于模版或者属性名,不同的部分则可能是属性值,而同一个网页中重复的标签块则预示着重复的记录。

    属性抽取的另一个信息源是网页表格。表格的内容对于人来说一目了然,而对于机器而言,情况则要复杂得多。由于表格类型千差万别,很多表格制作得不规则,加上机器缺乏人所具有的背景知识等原因,从网页表格中提取高质量的属性信息成为挑战。

    上述三种方法的共同点是通过挖掘原始数据中的半结构化信息来获取属性和属性值。与通过“阅读”句子来进行信息抽取的方法相比,这些方法绕开了自然语言理解这样一个“硬骨头”而试图达到以柔克刚的效果。在现阶段,计算机知识库中的大多数属性值确实是通过上述方法获得的。但现实情况是只有一部分的人类知识是以半结构化形式体现的,而更多的知识则隐藏在自然语言句子中,因此直接从句子中抽取信息成为进一步提高知识库覆盖率的关键。当前从句子和查询日志中提取属性和属性值的基本手段是模式匹配和对自然语言的浅层处理。图6 描绘了为语义类抽取属性名的主框架(同样的过程也适用于为实体抽取属性值)。图中虚线左边的部分是输入,它包括一些手工定义的模式和一个作为种子的(词,属性)列表。模式的例子参见表3,(词,属性)的例子如(北京,面积)。在只有语义类无关的模式作为输入的情况下,整个方法是一个在句子中进行模式匹配而生成(语义类,属性)关系图的无监督的知识提取过程。此过程分两个步骤,第一个步骤通过将输入的模式作用到句子上而生成一些(词,属性)元组,这些数据元组在第二个步骤中根据语义类进行合并而生成(语义类,属性)关系图。在输入中包含种子列表或者语义类相关模式的情况下,整个方法是一个半监督的自举过程,分三个步骤:

    模式生成:在句子中匹配种子列表中的词和属性从而生成模式。模式通常由词和属性的环境信息而生成。

    模式匹配。

    模式评价与选择:通过生成的(语义类,属性)关系图对自动生成的模式的质量进行自动评价并选择高分值的模式作为下一轮匹配的输入。

    1.3 关系抽取

    关系抽取的目标是解决实体语义链接的问题。关系的基本信息包括参数类型、满足此关系的元组模式等。例如关系BeCapitalOf(表示一个国家的首都)的基本信息如下:

    参数类型:(Capital, Country)
    模式:

    微信图片_20170930153412.jpg

    元组:(北京,中国);(华盛顿,美国);Capital 和 Country表示首都和国家两个语义类。

    早期的关系抽取主要是通过人工构造语义规则以及模板的方法识别实体关系。随后,实体间的关系模型逐渐替代了人工预定义的语法与规则。但是仍需要提前定义实体间的关系类型。 文献[26]提出了面向开放域的信息抽取框架 (open information extraction,OIE),这是抽取模式上的一个巨大进步。但OIE方法在对实体的隐含关系抽取方面性能低下,因此部分研究者提出了基于马尔可夫逻辑网、基于本体推理的深层隐含关系抽取方法[27]。

    开放式实体关系抽取

    开放式实体关系抽取可分为二元开放式关系抽取和n元开放式关系抽取。在二元开放式关系抽取中,早期的研究有KnowItAll[28]与TextRunner[27]系统,在准确率与召回率上表现一般。文献[29]提出了一种基于Wikipedia的OIE方法WOE,经自监督学习得到抽取器,准确率较TextRunner有明显的提高。针对WOE的缺点,文献[30]提出了第二代OIE ReVerb系统,以动词关系抽取为主。文献[31]提出了第三代OIE系统OLLIE(open language learning for information extraction),尝试弥补并扩展OIE的模型及相应的系统,抽取结果的准确度得到了增强。

    然而,基于语义角色标注的OIE分析显示:英文语句中40%的实体关系是n元的[32],如处理不当,可能会影响整体抽取的完整性。文献[33]提出了一种可抽取任意英文语句中n元实体关系的方法KPAKEN,弥补了ReVerb的不足。但是由于算法对语句深层语法特征的提取导致其效率显著下降,并不适用于大规模开放域语料的情况。

    基于联合推理的实体关系抽取

    联合推理的关系抽取中的典型方法是马尔可夫逻辑网MLN(Markov logic network)[34],它是一种将马尔可夫网络与一阶逻辑相结合的统计关系学习框架,同时也是在OIE中融入推理的一种重要实体关系抽取模型。基于该模型,文献[35]提出了一种无监督学习模型StatSnowball,不同于传统的OIE,该方法可自动产生或选择模板生成抽取器。在StatSnowball的基础上,文献[27,36]提出了一种实体识别与关系抽取相结合的模型EntSum,主要由扩展的CRF命名实体识别模块与基于StatSnowball的关系抽取模块组成,在保证准确率的同时也提高了召回率。文献[27,37]提出了一种简易的Markov逻辑TML(tractable Markov logic),TML将领域知识分解为若干部分,各部分主要来源于事物类的层次化结构,并依据此结构,将各大部分进一步分解为若干个子部分,以此类推。TML具有较强的表示能力,能够较为简洁地表示概念以及关系的本体结构。

    5.2 知识表示

    传统的知识表示方法主要是以RDF(Resource Description Framework资源描述框架)的三元组SPO(subject,property,object)来符号性描述实体之间的关系。这种表示方法通用简单,受到广泛认可,但是其在计算效率、数据稀疏性等方面面临诸多问题。近年来,以深度学习为代表的以深度学习为代表的表示学习技术取得了重要的进展,可以将实体的语义信息表示为稠密低维实值向量,进而在低维空间中高效计算实体、关系及其之间的复杂语义关联,对知识库的构建、推理、融合以及应用均具有重要的意义[38-40]。

    2.1 代表模型

    知识表示学习的代表模型有距离模型、单层神经网络模型、双线性模型、神经张量模型、矩阵分解模型、翻译模型等。详细可参见清华大学刘知远的知识表示学习研究进展。相关实现也可参见 [39]。

    1)距离模型

    距离模型在文献[41] 提出了知识库中实体以及关系的结构化表示方法(structured embedding,SE),其基本思想是:首先将实体用向量进行表示,然后通过关系矩阵将实体投影到与实体关系对的向量空间中,最后通过计算投影向量之间的距离来判断实体间已存在的关系的置信度。由于距离模型中的关系矩阵是两个不同的矩阵,使得协同性较差。

    2)单层神经网络模型

    文献[42]针对上述提到的距离模型中的缺陷,提出了采用单层神经网络的非线性模型(single layer model,SLM),模型为知识库中每个三元组(h,r,t) 定义了以下形式的评价函数:

    微信图片_20170930153950.png

    式中, ut的T次幂∈R的k次幂为关系 r 的向量化表示;g()为tanh函数; Mr,1×Mr,2∈R的k次幂是通过关系r定义的两个矩阵。单层神经网络模型的非线性操作虽然能够进一步刻画实体在关系下的语义相关性,但在计算开销上却大大增加。

    3)双线性模型

    双 线 性 模 型 又 叫 隐 变 量 模 型 (latent factor model,LFM),由文献[43-44]首先提出。模型为知识库中每个三元组 定义的评价函数具有如下形式:

    微信图片_20170930154623.png

    式中,Mr∈R的d×d次幂是通过关系r 定义的双线性变换矩阵;
    lh×lt∈R的d次幂是三元组中头实体与尾实体的向量化表示。双线性模型主要是通过基于实体间关系的双线性变换来刻画实体在关系下的语义相关性。模型不仅形式简单、易于计算,而且还能够有效刻画实体间的协同性。基于上述工作,文献[45]尝试将双线性变换矩阵r M 变换为对角矩阵, 提出了DISTMULT模型,不仅简化了计算的复杂度,并且实验效果得到了显著提升。

    4)神经张量模型

    文献[45]提出的神经张量模型,其基本思想是:在不同的维度下,将实体联系起来,表示实体间复杂的语义联系。模型为知识库中的每个三元组(h,r,t)定义了以下形式的评价函数:

    微信图片_20170930154916.png

    式中, ut的T次幂∈R的k次幂为关系 r 的向量化表示;g()为tanh函数; Mr∈d×k×k是一个三阶张量;Mr,1×Mr,2∈R的k次幂是通过关系r定义的两个矩阵。

    神经张量模型在构建实体的向量表示时,是将该实体中的所有单词的向量取平均值,这样一方面可以重复使用单词向量构建实体,另一方面将有利于增强低维向量的稠密程度以及实体与关系的语义计算。

    5)矩阵分解模型

    通过矩阵分解的方式可得到低维的向量表示,故不少研究者提出可采用该方式进行知识表示学习,其中的典型代表是文献[46]提出的RESACL模型。在RESCAL模型中,知识库中的三元组集合被表示为一个三阶张量,如果该三元组存在,张量中对应位置的元素被置1,否则置为0。通过张量分解算法,可将张量中每个三元组(h,r,t)对应的张量值解为双线性模型中的知识表示形式lh的T次幂×Mr×lt并使|Xhrt-lh的T次幂×Mr×l|尽量小。

    6)翻译模型

    文献[47]受到平移不变现象的启发,提出了TransE模型,即将知识库中实体之间的关系看成是从实体间的某种平移,并用向量表示。关系lr可以看作是从头实体向量到尾实体向量lt的翻译。对于知识库中的每个三元组(h,r,t),TransE都希望满足以下关系|lh+lt≈lt|:,其损失函数为:fr(h,t)=|lh+lr-lt|L1/L2, 该模型的参数较少,计算的复杂度显著降低。与此同时,TransE模型在大规模稀疏知识库上也同样具有较好的性能和可扩展性。

    2.2 复杂关系模型

    知识库中的实体关系类型也可分为1-to-1、1-to-N、N-to-1、N-to-N4种类型[47],而复杂关系主要指的是1-to-N、N-to-1、N-to-N的3种关系类型。由于TransE模型不能用在处理复杂关系上[39],一系列基于它的扩展模型纷纷被提出,下面将着重介绍其中的几项代表性工作。

    1)TransH模型

    文献[48]提出的TransH模型尝试通过不同的形式表示不同关系中的实体结构,对于同一个实体而言,它在不同的关系下也扮演着不同的角色。模型首先通过关系向量lr与其正交的法向量wr选取某一个超平面F, 然后将头实体向量lh和尾实体向量lt法向量wr的方向投影到F, 最后计算损失函数。TransH使不同的实体在不同的关系下拥有了不同的表示形式,但由于实体向量被投影到了关系的语义空间中,故它们具有相同的维度。

    2)TransR模型

    由于实体、关系是不同的对象,不同的关系所关注的实体的属性也不尽相同,将它们映射到同一个语义空间,在一定程度上就限制了模型的表达能力。所以,文献[49]提出了TransR模型。模型首先将知识库中的每个三元组(h, r,t)的头实体与尾实体向关系空间中投影,然后希望满足|lh+lt≈lt|的关系,最后计算损失函数。

    文献[49]提出的CTransR模型认为关系还可做更细致的划分,这将有利于提高实体与关系的语义联系。在CTransR模型中,通过对关系r 对应的头实体、尾实体向量的差值lh-lt进行聚类,可将r分为若干个子关系rc 。

    3)TransD模型

    考虑到在知识库的三元组中,头实体和尾实体表示的含义、类型以及属性可能有较大差异,之前的TransR模型使它们被同一个投影矩阵进行映射,在一定程度上就限制了模型的表达能力。除此之外,将实体映射到关系空间体现的是从实体到关系的语 义联系,而TransR模型中提出的投影矩阵仅考虑了不同的关系类型,而忽视了实体与关系之间的交互。因此,文献[50]提出了TransD模型,模型分别定义了头实体与尾实体在关系空间上的投影矩阵。

    4)TransG模型

    文献[51]提出的TransG模型认为一种关系可能会对应多种语义,而每一种语义都可以用一个高斯分布表示。TransG模型考虑到了关系r 的不同语义,使用高斯混合模型来描述知识库中每个三元组(h,r,t)头实体与尾实体之间的关系,具有较高的实体区分度。

    5)KG2E模型

    考虑到知识库中的实体以及关系的不确定性,文献[52]提出了KG2E模型,其中同样是用高斯分布来刻画实体与关系。模型使用高斯分布的均值表示实体或关系在语义空间中的中心位置,协方差则表示实体或关系的不确定度。

    知识库中,每个三元组(h,r,t)的头实体向量与尾实体向量间的

    微信图片_20170930160102.png

    关系r可表示为:

    微信图片_20170930160147.png

    5.3 知识融合

    通过知识提取,实现了从非结构化和半结构化数据中获取实体、关系以及实体属性信息的目标。但是由于知识来源广泛,存在知识质量良莠不齐、来自不同数据源的知识重复、层次结构缺失等问题,所以必须要进行知识的融合。知识融合是高层次的知识组织[53],使来自不同知识源的知识在同一框架规范下进行异构数据整合、消歧、加工、推理验证、更新等步骤[54],达到数据、信息、方法、经验以及人的思想的融合,形成高质量的知识库。

    3.1 实体对齐

    实体对齐 (entity alignment) 也称为实体匹配 (entity matching)或实体解析(entity resolution)或者实体链接(entity linking),主要是用于消除异构数据中实体冲突、指向不明等不一致性问题,可以从顶层创建一个大规模的统一知识库,从而帮助机器理解多源异质的数据,形成高质量的知识。

    在大数据的环境下,受知识库规模的影响,在进行知识库实体对齐时,主要会面临以下3个方面的挑战[55]:1) 计算复杂度。匹配算法的计算复杂度会随知识库的规模呈二次增长,难以接受;2) 数据质量。由于不同知识库的构建目的与方式有所不同,可能存在知识质量良莠不齐、相似重复数据、孤立数据、数据时间粒度不一致等问题[56];3) 先验训练数据。在大规模知识库中想要获得这种先验数据却非常困难。通常情况下,需要研究者手工构造先验训练数据。

    基于上述,知识库实体对齐的主要流程将包括[55]:1) 将待对齐数据进行分区索引,以降低计算的复杂度;2) 利用相似度函数或相似性算法查找匹配实例;3) 使用实体对齐算法进行实例融合;4) 将步骤2)与步骤3)的结果结合起来,形成最终的对齐结果。对齐算法可分为成对实体对齐与集体实体对齐两大类,而集体实体对齐又可分为局部集体实体对齐与全局集体实体对齐。

    1)成对实体对齐方法

    ① 基于传统概率模型的实体对齐方法

    基于传统概率模型的实体对齐方法主要就是考虑两个实体各自属性的相似性,而并不考虑实体间的关系。文献[57]将基于属性相似度评分来判断实体是否匹配的问题转化为一个分类问题,建立了该问题的概率模型,缺点是没有体现重要属性对于实体相似度的影响。文献[58]基于概率实体链接模型,为每个匹配的属性对分配了不同的权重,匹配准确度有所提高。文献[59]还结合贝叶斯网络对属性的相关性进行建模,并使用最大似然估计方法对模型中的参数进行估计。

    ② 基于机器学习的实体对齐方法

    基于机器学习的实体对齐方法主要是将实体对齐问题转化为二分类问题。根据是否使用标注数据可分为有监督学习与无监督学习两类,基于监督学习的实体对齐方法主要可分为成对实体对齐、基于聚类的对齐、主动学习。

    通过属性比较向量来判断实体对匹配与否可称为成对实体对齐。这类方法中的典型代表有决策树 [60]、支持向量机[61]、集成学习[62]等。文献[63]使用分类回归树、线性分析判别等方法完成了实体辨析。文献[64]基于二阶段实体链接分析模型,提出了一种新的SVM分类方法,匹配准确率远高于TAILOR中的混合算法。

    基于聚类的实体对齐算法,其主要思想是将相似的实体尽量聚集到一起,再进行实体对齐。文献[65]提出了一种扩展性较强的自适应实体名称匹配与聚类算法,可通过训练样本生成一个自适应的距离函数。文献[66]采用类似的方法,在条件随机场实体对齐模型中使用监督学习的方法训练产生距离函数,然后调整权重,使特征函数与学习参数的积最大。

    在主动学习中,可通过与人员的不断交互来解决很难获得足够的训练数据问题,文献[67]构建的ALIAS系统可通过人机交互的方式完成实体链接与去重的任务。文献[68]采用相似的方法构建了ActiveAtlas系统。

    2)局部集体实体对齐方法

    局部集体实体对齐方法为实体本身的属性以及与它有关联的实体的属性分别设置不同的权重,并通过加权求和计算总体的相似度,还可使用向量空间模型以及余弦相似性来判别大规模知识库中的实体的相似程度[69],算法为每个实体建立了名称向量与虚拟文档向量,名称向量用于标识实体的属性,虚拟文档向量则用于表示实体的属性值以及其邻居节点的属性值的加权和值[55]。为了评价向量中每个分量的重要性,算法主要使用TF-IDF为每个分量设置权重,并为分量向量建立倒排索引,最后选择余弦相似性函数计算它们的相似程度[55]。该算法的召回率较高,执行速度快,但准确率不足。其根本原因在于没有真正从语义方面进行考虑。

    3)全局集体实体对齐方法

    ① 基于相似性传播的集体实体对齐方法

    基于相似性传播的方法是一种典型的集体实体对齐方法,匹配的两个实体与它们产生直接关联的其他实体也会具有较高的相似性,而这种相似性又会影响关联的其他实体[55]。

    相似性传播集体实体对齐方法最早来源于文献[70-71]提出的集合关系聚类算法,该算法主要通过一种改进的层次凝聚算法迭代产生匹配对象。文献[72]在以上算法的基础上提出了适用于大规模知识库实体对齐的算法SiGMa,该算法将实体对齐问题看成是一个全局匹配评分目标函数的优化问题进行建模,属于二次分配问题,可通过贪婪优化算法求得其近似解。SiGMa方法[55]能够综合考虑实体对的属性与关系,通过集体实体的领域,不断迭代发现所有的匹配对。

    ② 基于概率模型的集体实体对齐方法基于概率模型的集体实体对齐方法主要采用统计关系学习进行计算与推理,常用的方法有LDA模型[73]、CRF模型[74]、Markov逻辑网[75]等。

    文献[73]将LDA模型应用于实体的解析过程中,通过其中的隐含变量获取实体之间的关系。但在大规模的数据集上效果一般。文献[74]提出了一种基于图划分技术的CRF实体辨析模型,该模型以观察值为条件产生实体判别的决策,有利于处理属性间具有依赖关系的数据。文献[66]在CRF实体辨析模型的基础上提出了一种基于条件随机场模型的多关系的实体链接算法,引入了基于canopy的索引,提高了大规模知识库环境下的集体实体对齐效率。文献[75]提出了一种基于Markov逻辑网的实体解析方法。通过Markov逻辑网,可构建一个Markov网,将概率图模型中的最大可能性计算问题转化为典型的最大化加权可满足性问题,但基于Markov网进行实体辨析时,需要定义一系列的等价谓词公理,通过它们完成知识库的集体实体对齐。

    3.2 知识加工

    通过实体对齐,可以得到一系列的基本事实表达或初步的本体雏形,然而事实并不等于知识,它只是知识的基本单位。要形成高质量的知识,还需要经过知识加工的过程,从层次上形成一个大规模的知识体系,统一对知识进行管理。知识加工主要包括本体构建与质量评估两方面的内容。

    1)本体构建

    本体是同一领域内不同主体之间进行交流、连通的语义基础,其主要呈现树状结构,相邻的层次节点或概念之间具有严格的“IsA”关系,有利于进行约束、推理等,却不利于表达概念的多样性。本体在知识图谱中的地位相当于知识库的模具,通过本体库而形成的知识库不仅层次结构较强,并且冗余程度较小。

    展开全文
  • ubuntu使用教程

    万次阅读 多人点赞 2020-01-15 17:53:05
    Ubuntu(乌班图)是一个基于Debian的以桌面应用为主的Linux操作系统,据说其名称来自非洲南部祖鲁语或科萨语的“ubuntu”一,意思是“人性”、“我的存在是因为大家的存在”,是非洲传统的一种价值观。 Ubuntu的...

    ubuntu使用教程

    一、 Ubuntu简介

    Ubuntu(乌班图)是一个基于Debian的以桌面应用为主的Linux操作系统,据说其名称来自非洲南部祖鲁语或科萨语的“ubuntu”一词,意思是“人性”、“我的存在是因为大家的存在”,是非洲传统的一种价值观。

    Ubuntu的目标在于为一般用户提供一个最新同时又相当稳定,主要以自由软件建构而成的操作系统。Ubuntu目前具有庞大的社区力量支持,用户可以方便地从社区获得帮助。

    二、下载及安装

    ubuntu官方网站: http://www.ubuntu.com
    中文地址为: http://www.ubuntu.org.cn/index_kylin
    桌面版下载地址: http://www.ubuntu.com/download/desktop

    三、 安装过程中的知识点:

    虚拟机的网络类型的简单理解:
      虚拟机是在我们的操作系统里使用软件模拟出来的,相当于虚拟机是寄宿在我们的真实的物理机的操作系统里的,虚拟机和物理机之间的关系是 寄宿与被寄宿的关系, 真实的物理机被称为宿主机。
    虚拟机3中模式:

    1. bridged(桥接模式)
        我们的电脑在上网的时候都需要有一个网络地址(IP地址),通过这个地址可以确定我们的电脑在网络上的位置,桥接模式就是将我们虚拟机中的网卡的网络地址 放在我们真实的物理机的网卡上。 这样的话,我们的虚拟机就好像跟我们的宿主机所在的局域网中的一台机器一样。 桥接模式适合有路由器的情况,和真实的物理环境一样。
    2. NAT(网络地址转换模式)
        在宿主机上制作一个虚拟网卡,通过这个网卡,给虚拟机分配IP。宿主机在这里的角色相当于局域网中的路由器。NAT模式适合于没有路由器的情况,虚拟机通过宿主机去上网。
    3. Host-Only(模式)
        和NAT模式很像,唯一的区别是,没有地址转换服务,所以该模式下虚拟机只能访问到主机。无法访问外网。
      在这里插入图片描述
      分区:

    文件系统类型: 默认为 ext4, 文件系统分很多种,ext2、ext3、ext4、fat、ntfs等等
      什么是文件系统: 文件系统是操作系统用于明确磁盘或分区上的文件的方法和数据结构; 即在磁盘上组织文件的方法。
      两种文件系统的对比:
    在这里插入图片描述
    在这里插入图片描述
    LInux目录结构:

    / : 所有目录都在
    /boot : boot 配置文件、内核和其它启动 时所需的文件
    /etc : 存放系统配置有关的文件
    /home : 存放普通用户目录
    /mnt : 硬盘上手动 挂载的文件系统
    /media : 自动挂载(加载)的硬盘分区以及类似CD、数码相机等可移动介质。
    /cdrom : 挂载光盘?
    /opt : 存放一些可选程序,如某个程序测试版本,安装到该目录的程序的所有数据,库文件都存在同个目录下
    /root : 系统管理员的目录,对于系统来说,系统管理员好比上帝,他可以对系统做任何操作,比如删除你的文件,一般情况下不要使用root用户。
    /bin : 存放常用的程序文件(命令文件)。
    /sbin : 系统管理命令,这里存放的是系统管理员使用的管理程序
    /tmp : 临时目录,存放临时文件,系统会定期清理该目录下的文件。
    /usr : 在这个目录下,你可以找到那些不适合放在/bin或/etc目录下的额外的工具。比如游戏、打印工具等。/usr目录包含了许多子目录: /usr/bin目录用于存放程序;/usr/share用于存放一些共享的数据,比如音乐文件或者图标等等;/usr/lib目录用于存放那些不能直接 运行的,但却是许多程序运行所必需的一些函数库文件。/usr/local : 这个目录一般是用来存放用户自编译安装软件的存放目录;一般是通过源码包安装的软件,如果没有特别指定安装目录的话,一般是安装在这个目录中。
        /usr/bin/ 非必要可执行文件 (在单用户模式中不需要);面向所有用户。
        /usr/include/ 标准包含文件。
        /usr/lib/ /usr/bin/和/usr/sbin/中二进制文件的库。
        /usr/sbin/ 非必要的系统二进制文件,例如:大量网络服务的守护进程。
        /usr/share/ 体系结构无关(共享)数据。
        /usr/src/ 源代码,例如:内核源代码及其头文件。
        /usr/X11R6/ X Window系统 版本 11, Release 6.
        /usr/local/ 本地数据的第三层次, 具体到本台主机。通常而言有进一步的子目录, 例如:bin/、lib/、share/.

    /var : 该目录存放那些经常被修改的文件,包括各种日志、数据文件;
    /var/cache/ 应用程序缓存数据。这些数据是在本地生成的一个耗时的I/O或计算结果。应用程序必须能够再生或恢复数据。缓存的文件可以被删除而不导致数据丢失。
    /var/lib/ 状态信息。 由程序在运行时维护的持久性数据。 例如:数据库、包装的系统元数据等。
    /var/lock/ 锁文件,一类跟踪当前使用中资源的文件。
    /var/log/ 日志文件,包含大量日志文件。
    /var/mail/ 用户的电子邮箱。
    /var/run/ 自最后一次启动以来运行中的系统的信息,例如:当前登录的用户和运行中的守护进程。现已经被/run代替[13]。
    /var/spool/ 等待处理的任务的脱机文件,例如:打印队列和未读的邮件。
    /var/spool/mail/ 用户的邮箱(不鼓励的存储位置)
    /var/tmp/ 在系统重启过程中可以保留的临时文件。
    /lib : 目录是根文件系统上的程序所需的共享库,存放了根文件系统程序运行所需的共享文件。这些文件包含了可被许多程序共享的代码,以避免每个程序都包含有相同的子程序的副本,故可以使得可执行文件变得更小,节省空间。
    /lib32 : 同上
    /lib64 : 同上
    /lost+found : 该目录在大多数情况下都是空的。但当突然停电、或者非正常关机后,有些文件就临时存放在;
    /dev : 存放设备文件
    /run : 代替/var/run目录,
    /proc : 虚拟文件系统,可以在该目录下获取系统信息,这些信息是在内存中由系统自己产生的,该目录的内容不在硬盘上而在内存里;
    /sys : 和proc一样,虚拟文件系统,可以在该目录下获取系统信息,这些信息是在内存中由系统自己产生的,该目录的内容不在硬盘上而在内存里;

    在这里插入图片描述
    SWAP分区的作用:

    当系统的物理内存不够用的时候,就需要将物理内存中的一部分空间释放出来,以供当前运行的程序使用。那些被释放的空间可能来自一些很长时间没有什么操作的程序,这些被释放的空间被临时保存到Swap空间中,等到那些程序要运行时,再从Swap中恢复保存的数据到内存中。这样,系统总是在物理内存不够时,才进行Swap交换。

    sudo cat /proc/sys/vm/swappiness
    该值默认值是60.

    swappiness=0的时候表示最大限度使用物理内存,然后才是 swap空间,

    swappiness=100的时候表示积极的使用swap分区,并且把内存上的数据及时的搬运到swap空间里面。

    –临时性修改:

    [root@rhce ~]# sysctl vm.swappiness=10

    vm.swappiness = 10

    [root@rhce ~]# cat /proc/sys/vm/swappiness

    10

    这里我们的修改已经生效,但是如果我们重启了系统,又会变成60.

    –永久修改:

    在/etc/sysctl.conf 文件里添加如下参数:

    vm.swappiness=10
    语言环境
    查看是否安装了中文支持:

    locale -a
    

    如果有 zh_CN.utf8 则表示系统已经安装了中文locale,如果没有则需要安装相应的软件包。安装方式如下:

    sudo apt-get install language-pack-zh-hans language-pack-zh-hans-base
    

    软件管理 apt ( Advanced Packaging Tool ) , 他可以自动下载、配置、安装软件包;简化了Linux系统上的。Debian及衍生版中都包含了apt , RedHat系列的linux的则使用yum来进行管理,其中Fedora22中Centos7中开始使用dnf 来替代yum。

    **apt-cache search package 搜索包**
    apt-cache show package 获取包的相关信息,如说明、大小、版本等
    **sudo apt-get install package 安装包**
    sudo apt-get install package –reinstall 重新安装包
    sudo apt-get -f install 强制安装
    **sudo apt-get remove package 删除包**
    **sudo apt-get remove package –purge 删除包,包括删除配置文件等**
    **sudo apt-get autoremove 自动删除不需要的包**
    **sudo apt-get update 更新源**
    **sudo apt-get upgrade 更新已安装的包**
    sudo apt-get dist-upgrade 升级系统
    sudo apt-get dselect-upgrade 使用 dselect 升级
    apt-cache depends package 了解使用依赖
    apt-cache rdepends package 了解某个具体的依赖
    sudo apt-get build-dep package 安装相关的编译环境
    apt-get source package 下载该包的源代码
    sudo apt-get clean && sudo apt-get autoclean 清理下载文件的存档
    sudo apt-get check 检查是否有损坏的依赖
    

    apt的配置文件

    /etc/apt/sources.list 设置软件包的获取来源
    /etc/apt/apt.conf apt配置文件
    /etc/apt/apt.conf.d apt的零碎配置文件
    /etc/apt/preferences 版本参数
    /var/cache/apt/archives/partial 存放正在下载的软件包
    /var/cache/apt/archives 存放已经下载的软件包
    /var/lib/apt/lists 存放已经下载的软件包详细信息
    /var/lib/apt/lists/partial 存放正在下载的软件包详细信息
    

    软件源配置文件格式:

    deb http://security.ubuntu.com/ubuntu xenial-security main restricted
    # deb-src http://security.ubuntu.com/ubuntu xenial-security main restricted
    deb http://security.ubuntu.com/ubuntu xenial-security universe
    # deb-src http://security.ubuntu.com/ubuntu xenial-security universe
    deb http://security.ubuntu.com/ubuntu xenial-security multiverse
    # deb-src http://security.ubuntu.com/ubuntu xenial-security multiverse
    

    Ubuntu 软件仓库被分为四个部分:main(主要的), restricted(受限的), universe(广泛的) , multiverse(多元的),这主要根据我们对软件的支持能力,以及软件的目的是否符合我们的 自由软件哲学。

    先看了一下配置文件的一段内容:

    第一个deb表示软件包的格式,可以是 deb 或 deb-src,前者表示所指向的存放 binary 格式(已编译),后者为 sources 格式(原代码)。
    第二个URI,即 Universal Resource Identifier,通用资源标识符,可以是以:file(系统) 、 cdrom(光驱) 、 http 、 ftp、copy 、rsh 、ssh 等几个参数开头的软件包所在位置。
    第三个Distribution 指发行版本号,可以是:stable,testing,unstable,sarge,etch,sid 等,具体可参考Debian文档。
    后面的几个component表示具体的软件包分类:

      main:完全遵循 Debian  自由软件准则 即DFSG的软件包;
      contrib:软件包均遵循DFSG自由使用原则,但是其使用了某些不符合DFSG的第三方库;
      non-free:不符合DFSG的软件包。     
    

    dpkg是Debian软件包管理器的基础,被用于安装、卸载和供给和.deb软件包相关的信息。dpkg本身是一个底层的工具,本身并不能从远程包仓库下载包以及处理包的依赖的关系,需要将包从远程下载后再安装。
    DPKG常用命令:

    dpkg -i package.deb 安装包
    dpkg -r package 删除包
    dpkg -P package 删除包(包括配置文件)
    dpkg -L package 列出与该包关联的文件
    dpkg -l package 显示该包的版本
    dpkg –unpack package.deb 解开 deb 包的内容
    dpkg -S keyword 搜索所属的包内容
    dpkg -l 列出当前已安装的包
    dpkg -c package.deb 列出 deb 包的内容
    dpkg –configure package 配置包
    

    四、常用命令

    4.1 date:用来显示或设定系统的日期和与时间

    date //显示当前日期
    # 日期格式化
    #       %Y     year
    #       %m     month (01..12)
    #       %d     day of month (e.g., 01)
    #       %H     hour (00..23)
    #       %I     hour (01..12)
    #       %M     minute (00..59)
    #       %S     second (00..60)
    date +"%Y%m%d %H%M%S"
        20160824 223856
    date +"%Y-%m-%d %H:%M:%S"
        2016-08-24 22:39:07
    
    date -s //设置当前时间,只有root权限才能设置,其他只能查看。
    date -s 20061010 //设置成20061010,这样会把具体时间设置成空00:00:00
    date -s 12:23:23 //设置具体时间,不会对日期做更改
    date -s “12:12:23 2006-10-10″ //这样可以设置全部时间
    
    # 注意: 重新设置时间后需要将时间捅不到硬件时钟。方式如下:
    hwclock -w    
    

    4.2 cal : 显示一个日历

    cal  #  现实当前月份的日历
    cal -y  # 显示当年的日历
    cal 2020 #  # 显示指定年份的日历
    

    4.3 设置时区

    tzselect
    
    # 或者
    cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime 
    

    4.4 修改密码

    # 修改密码的命令
    passwd # 默认修改当前用户的密码
    passwd username # 修改指定用户的密码,需要管理员权限
    

    4.5 忘记密码

    重启-->e-->F12-->rw init=/bin/bash-->F10-->passwd username-->密码-->密码
    

    4.6 注销/重启/关机

    logout  # 注销
    reboot  # 重启系统: 需要管理员全新啊
    shutdown # 关机: 需要管理员权限
    shutdown -r now # 现在立即重启
    shutdown -r +5  # 三分钟后重启
    shutdown -r 12:12    #在12:12时将重启计算机
    shutdown -h now # 现在立即关机
    shutdown -h +5  “The System will shutdown after 3 minutes”   # 提示使用者将在三分钟后关机
    shutdown -h +5   #  5分钟后关机
    shutdown -h 12:00  # 12点钟关机
    shutdown -c   # 取消关机操作
    

    4.7 cd切换目录

    cd  # 回到当前用户的家目录
    cd ~ # 可用于表示用户家目录
    cd  /etc # 切换到/etc目录
    cd -  # 切换到跳转之前的上一次的目录
    

    4.8 pwd 查看当前目录

    pwd :查看当前的工作路径
    

    4.9 pwd 创建目录

    # mkdir 目录名mkdir my_dir
    # - p 参数 : 递归创建目录,用于同时创建多级目录
    mkdir   a/b/c/d 
    

    4.10 获取帮助

     -h  --help  info  man 
    man man  # 查看man命令的手册  man  cd 
    man  pwd 
    man 5 passwd
    man -k passwd # 模糊查找
    man -f  passwd  # 精确查找 
    

    4.11 创建文件

    touch : 改变文件或目录的时间,文件不存在时会创建一个空文件。
    touch file1 # file1 不存在时被创建
    touch -c file1 # 不创建文件
    touch -r ref_file file1  更新file1.txt的时间戳和ref+file相同
    touch -t 201210120505.25 file1
    #  -t  time 使用指定的时间值 time 作为指定文件相应时间戳记的新值.此处的 # # time规定为如下形式的十进制数:      
    #  [[CC]YY]MMDDhhmm[.SS]     
    #   这里,CC为年数中的前两位,即”世纪数”;YY为年数的后两位,
    #   即某世纪中的年数.如果不给出CC的值,
    #   则 touch 将把年数CCYY限定在1969--2068之内.MM为月数,DD为天将把年数CCYY限定在1969--2068之内.
    #   MM为月数,DD为天数,hh 为小时数(几点),mm为分钟数,SS为秒数.此处秒的设定范围是0--61,
    #   这样可以处理闰秒.这些数字组成的时间是环境变量TZ指定的时区中的一个时间.
    #   由于系统的限制,早于1970年1月1日的时间是错误的。
    

    4.12 删除(rm:删除命令)

    rm -f  file1 # 强制删除文件
    rm -r  a/b/file1  # 删除指定目录及其下的所有文件和目录
    rm -rf  a/b/file1  #  强制删除指定目录及其下的所有文件和目录
    # rm 命令太危险,不建议使用
    

    4.13 mv:移动或重命令文件或目录

    mv SOURCE DEST  # 
    mv test.log test.txt  # 文件改名
    mv test1.txt dir1/      #移动文件
    mv test1.txt  test2.tx  test3.tx dir1/      #移动多个文件
    

    4.14 cp:复制

    cp SOURCE DEST # 复制文件
    cp -i  SOURCE DEST  #   如果遇到需要覆盖的情况,则提示
    cp -r  dir1  dir2  # 若给出的源文件是一目录文件,此时cp将递归复制该目录下所有的子目录和文件。此时目标文件必须为一个目录名
    cp -p  file1 file2  #  此时cp除复制源文件的内容外,还将把其修改时间和访问权限也复制到新文件中。
    cp -rp dir1  dir2
    

    4.15 stat : 查看文件相信信息

    stat filename 
    #  Access time(atime):是指取用文件的时间,所谓取用,常见的操作有:使用编辑器查看文件内容,使用cat命令显示文件内容,使用cp命令把该文件(即来源文件)复制成其他文件,或者在这个文件上运用grep sed more less tail head 等命令,凡是读取而不修改文件的操作,均衡改变文件的Access time.  
    #  Modify time(mtime):是指修改文件内容的时间,只要文件内容有改动(如使用转向输出或转向附加的方式)或存盘的操作,就会改变文件的Modify time,平常我们使用ls –l查看文件时,显示的时间就是Modify time  
    #  Change time(ctime):是指文件属性或文件位置改动的时间,如使用chmod,chown,mv指令集使用ln做文件的硬是连接,就会改变文件的Change time.
    

    4.16 cat

    链接文件后输出文件内容到屏幕上,其实就是查看文件内容
    

    4.17 tac : 反转行的输出

    cat file1  #显示 file1的文件内容
    cat file1 file2   # 显示file1和file2的文件内容 
    cat -n file1  #  由1开始对所有输出的行数编号
    cat -s file  # 当遇到连续2行以上的空白行,只保留一行空白行
    

    4.18 wc:统计指定文件中的字节数、字数、行数,并将统计结果显示输出

    -c 统计字节数。
    -l 统计行数。
    -m 统计字符数。这个标志不能与 -c 标志一起使用。
    -w 统计字数。一个字被定义为由空白、跳格或换行字符分隔的字符串
    

    4.19 sort:排序

    sort [-fbMnrtuk] [file or stdin]
    选项与参数:
    -f  :忽略大小写的差异,例如 A 与 a 视为编码相同;
    -b  :忽略最前面的空格符部分;
    -n  :使用『纯数字』进行排序(默认是以文字型态来排序的)-r  :反向排序;
    -u  :就是 uniq ,相同的数据中,仅出现一行代表;
    -t  :分隔符,默认是用 [tab] 键来分隔;
    -k  :以那个区间 (field) 来进行排序的意思
    

    4.20 uniq:忽略或报告重复行

    uniq [-icu]
    选项与参数:
    -i   :忽略大小写字符的不同;
    -c  :进行计数
    -u  :只显示唯一的行
    

    4.21 cut命令可以从一个文本文件或者文本流中提取文本列

    选项与参数:
    -d  :后面接分隔字符。与 -f 一起使用;
    -f  :依据 -d 的分隔字符将一段信息分割成为数段,用 -f 取出第几段的意思;
    -c  :以字符 (characters) 的单位取出固定字符区间;
    

    4.22 tee:读取标准输入的数据,并将其内容输出成文件。

    cat sec.log | tee file1  # 读取sec.log ,并生成file1文件
    cat sec.log | tee - a file1   # 读取sec.log ,并追加,
    cat sec.log  |tee  file1 file2 
    

    4.23 history:查看执行过的命令。

    history  # 显示最近1000条历史命令
    history 5   # 显示最后5条命令
    !number# number为history之后命令前的序号:执行该条命令
    !cat # 执行最后一条以cat开头的命令
    

    4.24 more:查看文件内容

    4.25 less:查看文件内容

    4.26 head : 输出文件的开始的部分, 可以指定行数 , 默认显示10行

    head -n 5 file 
    

    4.27 tail:查看文件尾部的内容。默认显示最后10行

    tail file1
    tail -n 5 file1
    tail -f file1  # 动态监控文件
    

    4.28 which # 查找其他命令的位置

     which ls
    

    4.29 ls:列出目标目录中所有的子目录和文件

    格式:ls [选项] [目录名] 
    -a 用于显示所有文件和子目录(保罗点文件)-l 除了文件名之外,还将文件的权限、所有者、文件大小等信息详细列出来。
    -r 将目录的内容清单以英文字母顺序的逆序显示。
    -t 按文件修改时间进行排序,而不是按文件名进行排序。
    -A 同-a,但不列出“.(表示当前目录)和“..(表示当前目录的父目录)-F 在列出的文件名和目录名后添加标志。例如,在可执行文件后添加“*”,在目录名后添加“/”以区分不同的类型。
    -R 如果目标目录及其子目录中有文件,就列出所有的文件。
    ... 
    . 表示当前目录
    .. 表示父目录
    文件类型
    ls  # 列出当前目录下的文件和目录
    ls  . # 列出当前目录下的文件和目录
    ls ..   # 列出当前目录的父目录下的文件和目录
    ls  /etc    # 列出/etc目录下的文件和目录
    ls -l  # 以长格式显示文件信息
    总用量 76
    -rwxrwxrwx 1 will will    78 513 18:11 ss_start.sh
    

    4.31 文件类型

    -  普通文件
    d  目录文件
    b 块设备文件
    c  字符设备文件
    l  链接文件
    p 管道文件
    s  socket文件
    ls -l  /dev  # 可以查看字符设备文件和块设备文件
    ls -l  /run  #  可以找到socket文件 
    ls -l  /run/systemd/inhibit/ # 可以查看到管道文件
    

    4.32 文件权限

    rwxrwxr-- : 三组rwx 分别表示 所有者、所有组、其他人 的权限。
    r : 表示可读, 可以用数字 4 来表示
    w : 标识可写 ,可以用数字 2 来表示
    x : 表示可执行 , 可以用数字 1 来表示
    - :表示没有相应权限  可以用数字 0 来表示
    

    4.32.1 修改权限的方法

    chmod o+w  file1
    chmod g-w file1
    chmod go-w file1
    chmod u=rwx file1
    
    chmod 755  file1  # -rwxr-xr-x (755) 只有所有者才有读,写,执行的权限,组群和其他人只有读和执行的权限
    chmod 644  #  -rw-r--r-- (644) 只有所有者才有读和写的权限,组群和其他人只有读的权限
    
    #  其中:
    #  u 代表所有者(user)
    #  g 代表所有者所在的组群(group)
    #  o 代表其他人,但不是u和g (other)
    #  a 代表全部的人,也就是包括u,g和o
    

    4.33 目录权限

    目录上的权限:
    r :  表示是否可以读取目录下的文件名
    w :  表示是否可以在目录下创建修改文件
    x  : 表示目录是否可以被搜索
    

    4.33.1 chown:更改文件的所有者和所有组

    chown root:root  file
    chown root   file  
    chown :root   file
    

    4.34 特殊权限

    SUID:让一般用户在执行某些程序的时候,能够暂时具有该程序拥有者的权限,SUID对目录是无效的
    SGID:文件:如果SGID设置在二进制文件上,则不论用户是谁,在执行该程序的时候,它的有效用户组(effective group)将会变成该程序的用户组所有者(group id); 目录:如果SGID是设置在某目录上,则在该目录内所建立的文件或目录的用户组,将会是该目录的用户组。 SGID多用在特定的多人团队的项目开发上,在系统中用得较少
    STICKY:只针对目录有效,在具有SBit的目录下,用户若在该目录下具有w及x权限,则当用户在该目录下建立文件或目录时,只有文件拥有者与root才有权力删除。

    rwsrw-r-- 表明有suid标识,
    rwxrws— 表明有sgid标识,
    rwxrw-rwt 表明有stick标识,
    当设置了特别权限位时,如果原来这个位上有x,那么这个特殊标示就显示为小写字母s,s,t ,否者就显示为大写S,S,T,此时他们不生效。

    4.35 用户和用户组

    linux使用文件保存用户信息 :
    文件
    #      /etc/passwd 用户账户信息。
    #       /etc/shadow 安全用户账户信息。
    #       /etc/group 组账户信息。
    #       /etc/gshadow 安全组账户信息。
    #       /etc/default/useradd 账户创建的默认值。
    #       /etc/skel/ 包含默认文件的目录。
    #       /etc/login.defs Shadow 密码套件配置。
    

    4.35.1 useradd: 添加用户

    # -c 备注 加上备注。并会将此备注文字加在/etc/passwd中的第5项字段中         
    #  -d 用户主文件夹。指定用户登录所进入的目录,并赋予用户对该目录的的完全控制权        
    #  -e 有效期限。指定帐号的有效期限。格式为YYYY-MM-DD,将存储在/etc/shadow         
    #  -f 缓冲天数。限定密码过期后多少天,将该用户帐号停用       
    #  -g 主要组。设置用户所属的主要组  www.cit.cn           
    #  -G 次要组。设置用户所属的次要组,可设置多组         
    # -M 强制不创建用户主文件夹         
    #  -m 强制建立用户主文件夹,并将/etc/skel/当中的文件复制到用户的根目录下         
    #  -p 密码。输入该帐号的密码         
    #  -s shell。用户登录所使用的shell         
    #  -u uid。指定帐号的标志符user id,简称uid
    useradd user1 # 添加用户 user1
    useradd  -d /home/userTT user2 
    

    4.35.2 userdel: 删除用户

    userdel  user1  #
    userdel -r user1
    #  -r, --remove   用户主目录中的文件将随用户主目录和用户邮箱一起删除。在其它文件系统中的文件必须手动搜索并删除。
    #    -f, --force    此选项强制删除用户账户,甚至用户仍然在登录状态。它也强制删除用户的主目录和邮箱,即使其它用户也使用同一个主目录或邮箱不属于指定的用户
    

    usermod : 修改用户信息

    # -c<备注>  修改用户帐号的备注文字。 
    # -d登入目录>  修改用户登入时的目录。 
    # -e<有效期限>  修改帐号的有效期限。 
    # -f<缓冲天数>  修改在密码过期后多少天即关闭该帐号。 
    # -g<群组>  修改用户所属的群组。 
    # -G<群组>  修改用户所属的附加群组。 
    # -l<帐号名称>  修改用户帐号名称。 
    # -L  锁定用户密码,使密码无效。 
    # -s<shell>  修改用户登入后所使用的shell。 
    # -u<uid>  修改用户ID。 
    
    
    # -U  解除密码锁定。
    usermod -G staff user2  # 将 newuser2 添加到组 staff 中 
    usermod -l newuser1 newuser  # 修改 newuser 的用户名为 newuser1 
    usermod -L newuser1  # 锁定账号 newuser1
    usermod -U newuser1  # 解除对 newuser1 的锁定
    

    groupadd : 添加组

    groupadd group1 
    groupadd -g  1000 group1  # 指定gid
    

    groupdel : 删除组

    groupdel group1 # 删除组
    

    4.36 su与 sudo

    4.36.1 su : 切换用户,没有参数时,默认切换为root用户;

    su   # 切换为root
    ## 推荐
    su -   # 切换为root 并加载user1的环境配置
    su -  user1 # 切换为user1 并加载user1的环境配置
    

    4.36.2 sudo:让当前用户暂时以管理员的身份root来执行命令。

    Ubuntu 默认没有启用root用户, 普通用户执行一些特殊的操作时,使用sudo就可以让普通用户以root用户的身份执行命令
     sudo有一个配置文件: /etc/sudoers  ;  通过修改配置文件可以让指定用户使用sudo命令
    man sudoers # 查看man手册看下面几行: # Host alias specification # 配置Host_Alias:就是主机的列表 
    Host_Alias      HOST_FLAG = hostname1, hostname2, hostname3# User alias specification # 配置User_Alias:就是具有sudo权限的用户的列表 
    User_Alias USER_FLAG = user1, user2, user3 
    # Cmnd alias specification # 配置Cmnd_Alias:就是允许执行的命令的列表,命令前加上!表示不能执行此命令.命令一定要使用绝对路径,避免其他目录的同名命令被执行,造成安全隐患 ,因此使用的时候也是使用绝对路径! 
    Cmnd_Alias      COMMAND_FLAG = command1, command2, command3 ,!command4
    # 配置Runas_Alias:就是用户以什么身份执行(例如root,或者oracle)的列表 
    Runas_Alias RUNAS_FLAG = operator1, operator2, operator3 
    
    # User privilege specification  
    # 配置权限的格式如下: 
    #  USER_FLAG HOST_FLAG=(RUNAS_FLAG) COMMAND_FLAG 
    root    ALL=(ALL:ALL) ALL
    如果不需要密码验证的话,则按照这样的格式来配置 
    USER_FLAG HOST_FLAG=(RUNAS_FLAG) NOPASSWD: COMMAND_FLAG 
    
    
    格式为:用户名(用户别名) 主机名(主机别名)=[(运行用户或是Runas_Alias)可选] [tag可选]  可以执行的命令(或Cmmd_Alias)  这样描述语法很生硬,不易理解,举例子
    user1  host1 = /bin/kill # user1 可以在host1上使用命令/bin/kill
    user1  host1 = NOPASSWD: /bin/kill # user1 可以在host1上使用命令/bin/kill 同时可以不必输入密码(这里就是使用了NOPASSWD # 这个tag,默认是PASSWD)
    user1  host1 = NOPASSWD: /bin/kill , PASSWORD: /bin/ls # user1 可以在host1上使用命令/bin/kill无需输入密码,但是使用/bin/ls则需要输入密码
    user1  host1 = (opterator) /bin/kill # user1 可以在host1上使用命令/bin/kill但是必须是以operator用户运行这个命令,等价于# su -u opertor /bin/kill
    user1  host1 = (:group_name) /bin/kill # user1 可以在host1上使用命令/bin/kill,且必须以group_name这个用户群组里面的用户来运行。
    %group_name host1 = /bin/kill # 所有group_name里面的用户都可以在host1上执行/bin/kill(Linux中一般代表整个用户群组用# %group_name)再举个实际例子,我之前对sudo su这个命令不理解,为什么我可以直接就su到root用户了呢,连密码都不需要?查看了一下sudoers文件才知道原来里面有这么一行:
    xxx     ALL=NOPASSWD: /bin/su
    

    4.37 alias : 给命令起别名

    alias ll='ls -alF'
    alias la='ls -A'
    alias l='ls -CF'
    如果需要别名永久生效,需要保存到 .bashrc 文件
    

    4.38 管道符

    管道符 就是 |  :他的作用是 将前一个命令的结果 交给后一个命令使用
     
    重定向  
    >   重定向,如果的文件存在,则覆盖文件内容,文件不存在时创建文件
    >> 重定向,如果的文件存在,则向文件追加内容,文件不存在时创建文件
    1>  标准正确输出,同上
    1>> 标准正确输出,同上  
    2> 标准错误输出,同上
    2>> 标准错误输出,同上
    &> 标准正确输出和标准错误输出,同上
    

    4.39 locate # 查找文件

    locate /etc/sh   # 搜索etc目录下所有以sh开头的文件。 
    locate ~/a   # 搜索用户主目录下,所有以a开头的文件。 
    locate -i ~/a   # 搜索用户主目录下,所有以a开头的文件,并且忽略大小写。
    

    4.40 find

    使用方法: 
    find   path   -option   [-print ]   [ -exec  -ok  command ]  {} \;
    ######  根据文件名查找 #######
    find / -name filename 再根目录里面搜索文件名为filename的文件
    find /home -name "*.txt"
    find /home -iname "*.txt"  # 忽略大小写
    
    ######  根据文件类型查找 #######
    find . -type 类型参数
    f 普通文件
    l 符号连接 
    d 目录 
    c 字符设备 
    b 块设备 
    s 套接字 
    p Fifo
    
    ######  根据目录深度查找 #######
    find . -maxdepth 3 -type f  # 最大深度为3
    find . -mindepth 2 -type f  # 最小深度为2
    #########   根据文件的权限或者大小名字类型进行查找 ###########
    find . -type f -size (+|-)文件大小 # +表示大于 -表示小于 b —— 块(512字节) 
    c —— 字节 
    w —— 字(2字节) 
    k —— 千字节 
    M —— 兆字节 
    G —— 吉字节
    
    #########   按照时间查找  ############
    
    -atime(+|-)n  # 此选项代表查找出n天以前被读取过的文件。
    -mtime(+|-)n  # 此选项代表查找出n天以前文件内容发生改变的文件。
    -ctime(+|-)n  # 此选项代表查找出n天以前的文件的属性发生改变的文件。
    -newer file  # 此选项代表查找出所有比file新的文件。
    -newer file1 ! –newer file2  # 此选项代表查找比file1文件时间新但是没有file2时间新的文件。
    # 注意:   
    #  n为数字,如果前面没有+或者-号,代表的是查找出n天以前的,但是只是一天之内的范围内发生变化的文件。
    #  如果n前面有+号,则代表查找距离n天之前的发生变化的文件。如果是减号,则代表查找距离n天之内的所有发生变化的文件。
    #  -newer file1 ! –newer file2中的!是逻辑非运算符
    #########   按照用户/权限查找  ############
    
    -user 用户名:根据文件的属主名查找文件。-group 组名:根据文件的属组名查找文件。-uid n:根据文件属主的UID进行查找文件。-gid n:根据文件属组的GID进行查找文件。-nouser:查询文件属主在/etc/passwd文件中不存在的文件。-nogroup:查询文件属组在/etc/group文件中不存在的文件-perm 777: 查询权限为777的文件
    
    来自: http://man.linuxde.net/find
    ########  查找时指定多个条件   ############
    
    -o:逻辑或,两个条件只要满足一个即可。-a:逻辑与,两个条件必须同时满足。
    
    find  /etc -size +2M -a -size -10M
    
    #########  对查找结果进行处理  #############
    -exec  shell命令  {}  \;-ok  shell命令  {}  \;
    其中-exec就是代表要执行shell命令,后面加的是shell指令,再后面的“{}”表示的是要对前面查询到的结果进行查询,最后的“\;”表示命令结束。需要注意的是“{}”和“\”之间是要有空格的。而-ok选项与-exec的唯一区别就是它在执行shell命令的时候会事先进行询问,-print选项是将结果显示在标准输入上
    
    find /home -name  “*.txt” -ok ls -l {} \;
    find /home -name  “*.txt” -ok rm {} \;
    

    4.41 df

    -T : 显示文件系统类型
    -h : 以能显示的最大单位显示
    df -Th
    

    4.42 du

    -s : 如果后面是目录,只显示一层-h : 以能显示的最大单位显示
    
    du dirname # 显示dirname下所有目录及其子目录的大小
    du -sh dirname  显示dirname的大小
    

    4.43 mount / umount 3 挂载和卸载设备

    mount # 查询挂在设备及属性
    
    # 挂载光盘
    mount -t iso9660 /dev/cerom /mnt
    mount /dev/sr0 /mnt  
    
    # 重新挂载设备
    mount -o remount,rw /mnt  # 重新挂载设备并设置rw属性
    # 挂载iso文件
    mount  a.iso -o loop /mnt 
    
    umount /mnt # 卸载设备
    umount -l /mnt # 强制卸载
    

    4.44 crontab

    * * * * * command to be executed- - - - - -
    | | | | | |
    | | | | | --- 预执行的命令
    | | | | ----- 表示星期07(其中星期天可以用07表示)
    | | | ------- 表示月份112
    | | --------- 表示日期131
    | ----------- 表示小时1230表示0点)----- 表示分钟159 每分钟用*或者 */1表示
    
    -u user:用来设定某个用户的crontab服务;
    -e:编辑某个用户的crontab文件内容。如果不指定用户,则表示编辑当前用户的crontab文件。-l:显示某个用户的crontab文件内容,如果不指定用户,则表示显示当前用户的crontab文件内容。
    -r:从/var/spool/cron目录中删除某个用户的crontab文件,如果不指定用户,则默认删除当前用户的crontab文件。
    -i:在删除用户的crontab文件时给确认提示
    

    4.45 tar

    -c :建立一个压缩文件的参数指令(create 的意思)-x :解开一个压缩文件的参数指令!
    -t :查看 tarfile 里面的文件!
    特别注意  c/x/t 同时仅能存在一个,因为不可能同时压缩与解压缩。
    -z :是否同时具有 gzip 的属性?亦即是否需要用 gzip 压缩?
    -j :是否同时具有 bzip2 的属性?亦即是否需要用 bzip2 压缩?
    -v :压缩的过程中显示文件!这个常用,但不建议用在背景执行过程!
    -f :使用档名,请留意,在 f 之后要立即接文件名-p :使用原文件的原来属性(属性不会依据使用者而变)
    -P :可以使用绝对路径来压缩!
    -N :比后面接的日期(yyyy/mm/dd)还要新的才会被打包进新建的文件中!
    
    # 将当前目录下所有.txt文件打包并压缩归档到文件this.tar.gz
    tar czvf this.tar.gz ./*.txt # 将当前目录下的this.tar.gz中的文件解压到当前目录
    tar xzvf this.tar.gz ./
    
    # 将整个 /etc 目录下的文件全部打包成为 /tmp/etc.tar
    tar -cvf /tmp/etc.tar /etc  # 仅打包,不压缩!
    tar -zcvf /tmp/etc.tar.gz /etc  # 打包后,以 gzip 压缩
    tar -jcvf /tmp/etc.tar.bz2 /etc  # 打包后,以 bzip2 压缩
    # 解压文件
    tar -xf  a.tar.gz   # 
    tar -xf  a.tar.gz  -C /tmp  # 指定解包路径
    

    4.46 grep

    格式:
    grep [OPTIONS] PATTERN [FILE...]
    grep [OPTIONS] [-e PATTERN]  [FILE...]
    参数:-c    --count   #计算符合样式的列数
    -l    --file-with-matches   #列出文件内容符合指定的样式的文件名称。 
    -v   --revert-match   #显示不包含匹配文本的所有行。
    -i    --ignore-case   #忽略字符大小写的差别。
    -o   # 只显示匹配到的关键字
    -n   # 显示行号,显示整行语句
    -on  # 显示行号,只显示要搜索的内容
    -E    使用正则表达式
    

    4.47 正则表达式

    ^ : 匹配开头
    $ : 匹配结尾
    [] : 范围匹配
    [a-z] : 匹配有小写字母
    [A-Z] : 匹配所有大写字母
    [0-9] : 匹配所有数字
    [^0-9]: 匹配非数字
    . : 匹配单个字符
    * : 表示*前面的内容出现0次或多次
    + : 表示+前面的内容出现1次或多次
    ? : 表示?前面的内容出现0次或1次
    cat a.txt |grep hat$ # 匹配以hat结尾的行
    cat a.txt |grep ^hat # 匹配以hat开头的行
    cat a.txt | grep -E "[0-9]*"   # 匹配有0到多个数字的行
    cat a.txt | grep -E "[0-9]+"   # 匹配有至少有1个数字的行
    cat a.txt | grep -E "[0-9]?"  # 匹配有0到1个数字的行
    

    4.48 sed : 流编辑器,一次处理一行内容

    sed [-nefr] [动作] [文件]
    选项与参数:
    -n :使用安静(silent)模式。在一般 sed 的用法中,所有来自 STDIN 的数据一般都会被列出到终端上。但如果加上 -n 参数后,则只有经过sed 特殊处理的那一行(或者动作)才会被列出来
    -e :直接在命令列模式上进行 sed 的动作编辑
    -f :直接将 sed 的动作写在一个文件内, -f filename 则可以运行 filename 内的 sed 动作
    -r :sed 的动作支持的是延伸型正规表示法的语法。(默认是基础正规表示法语法)
    -i :直接修改读取的文件内容,而不是输出到终端。
    
    动作说明: [n1[,n2]] 动作:
    n1, n2 :不一定存在,一般代表选择进行动作的行数,比如,如果我的动作是需要在 1020 行之间进行的,则10,20[动作行为]
    
    动作:
    #a :新增, a 的后面可以接字串,而这些字串会在新的一行出现(目前的下一行)
    #c :取代, c 的后面可以接字串,这些字串可以取代 n1,n2 之间的行!
    #d :删除,因为是删除啊,所以 d 后面通常不接任何咚咚;
        sed  "3d"  file  #  删除第三行
        sed  "1,3d"  # 删除前三行
        sed  "1d;3d;5d"  # 删除1、3、5行
        sed  "/^$/d" #删除空行   
        sed  "/abc/d" #删除所有含有abc的行
        sed  "/abc/,/def/d" #删除abc 和 def 之间的行,包括其自身
        sed  "1,/def/d" #删除第一行到 def 之间的行,包括其自身
        sed  "/abc/,+3d " # 删除含有abc的行之后,在删除3行
        sed  "/abc/,~3d" #从含有abc的行开始,共删除3行
        sed  "1~2d"  # 从第1行开始,每2行删除一行, 删除奇数行
        sed  "2~2d"  # 从第2行开始,每2行删除一行, 删除奇数行
        sed  "$d"  # 删除最后一行
        sed  "/dd\|cc/d"  删除有dd或者cc的行
    #i :插入, i 的后面可以接字串,而这些字串会在新的一行出现(目前的上一行);
    #p :列印,亦即将某个选择的数据印出。通常 p 会与参数 sed -n 一起运行
        sed -n  "3p"  file  #  显示第三行
        sed -n  "1,3p"  # 显示前三行
        sed -n  "2,+3p"  # 显示第二行,及后面的三行
        sed -n  "$p"  # 显示最后一行
        sed -n "1p;3p;5p"  # 只显示文件1、3、5行
        sed -n  "$="  # 显示文件行数
    #s :替换,可以直接进行取代的工作。通常这个 s 的动作可以搭配正规表示法,例如 1,20s/old/new/g
        's/old/new/g'  
        
        sed  "s/\(all\)/bb/"
        sed -r "s/(all)/bb/"
    

    4.49 awk : 一个强大的文本分析工具,相对于grep的查找,sed的编辑,awk在其对数据分析并生成报告时,显得尤为强大。简单来说awk就是把文件逐行的读入,以空格为默认分隔符将每行切片,切开的部分再进行各种分析处理。

    # 命令行调用方式
    awk [-F  field-separator]  'commands'  input-file(s)
    #  commands 是真正awk命令,[-F域分隔符]是可选的。 input-file(s) 是待处理的文件。    在awk中,文件的每一行中,由域分隔符分开的每一项称为一个域。通常,在不指名-F域分隔符的情况下,默认的域分隔符是空格。
    # awk工作流程:
    # 读入有'\n'换行符分割的一条记录,然后将记录按指定的域分隔符划分域,填充域,$0则表示所有域,$1表示第一个域,$n表示第n个域。默认域分隔符是"空白键" 或 "[tab]键",所以$1表示登录用户,$3表示登录用户ip,以此类推。
    cat /etc/passwd |awk  -F ':'  '{print $1}'  
    cat /etc/passwd |awk  -F ':'  '{print $1"\t"$7}'
    
    awk 常用内置变量
    ARGC               命令行参数个数
    ARGV               命令行参数排列, ARGV[0] ARGV[1]
    ENVIRON            支持队列中系统环境变量的使用
    FILENAME           awk浏览的文件名
    **FNR                浏览文件的记录数**
    **FS                 设置输入域分隔符,等价于命令行 -F选项**
    **NF                 浏览记录的域的个数**
    **NR                 已读的记录数**
    **OFS                输出域分隔符**
    **ORS                输出记录分隔符**
    RS                 控制记录分隔符
    # 统计/etc/passwd:文件名,每行的行号,每行的列数,对应的完整行内容:
    #awk  -F ':'  '{print "filename:" FILENAME ",linenumber:" NR ",columns:" NF ",linecontent:"$0}' /etc/passwd
    # 使用printf替代print,可以让代码更加简洁,易读
    awk  -F ':'  '{printf("filename:%10s,linenumber:%s,columns:%s,linecontent:%s\n",FILENAME,NR,NF,$0)}' /etc/passwd
    

    4.50 vi/vim : 强大的编辑器

    在这里插入图片描述
    在这里插入图片描述

    4.51 快捷键

    ctrl-a : 把光标移动到命令行最开始的地方。 
    ctrl-e : 把光标移动到命令行末尾。 
    ctrl-u : 清除命令行中光标所处位置之前的所有字符。 
    ctrl-k : 清除从提示符所在位置到行末尾之间的字符
    ctrl-w : 清除左边的字段 
    ctrl-y : 将会贴上被ctrl-u 或者 ctrl-k 或者 ctrl-w清除的部分。 
    ctrl-r : 将自动在命令历史缓存中增量搜索后面入的字符。 
    tab : 命令行自动补全-自动补全当前的命令行。如果启用自动补全脚本命令参数和选项也可以自动补齐。
    ctrl-l : 清屏
    
    展开全文
  • 人工智能时代,所需要了解人工智能的基本常识

    万次阅读 多人点赞 2018-12-10 22:49:44
    在句子“光阴似箭(Timeflieslikeanarrow)”中每一个单词的意义看起来都很清晰,直到系统遇到这样的句子“果蝇喜欢香蕉(Fruitflieslikeabanana)”,用“水果(fruit)”替代了“时间(time)”,并用“香蕉...

      国内对于人工智能的讨论大多是不成体系的碎片式,很难从中深入了解人工智能的发展脉络和技术体系,也很难有实际借鉴意义。人工智能的历史、核心技术和应用情况进行了详细说明,尤其是其中重要的认知技术。这份报告将有助于我们对人工智能和认知技术进行深入了解,也有助于各行业的公司考量人工智能应用的实际价值。

      一、概述

      近几年各界对人工智能的兴趣激增,自2011年以来,开发与人工智能相关的产品和技术并使之商业化的公司已获得超过总计20亿美元的风险投资,而科技巨头更是投资数十亿美元收购那些人工智能初创公司。相关报道铺天盖地,而巨额投资、计算机导致失业等问题也开始浮现,计算机比人更加聪明并有可能威胁到人类生存这类论断更是被媒体四处引用并引发广泛关注。

      IBM承诺拨出10亿美元来使他们的认知计算平台Watson商业化。

      谷歌在最近几年里的投资主要集中在人工智能领域,比如收购了8个机器人公司和1个机器学习公司。

      Facebook聘用了人工智能学界泰斗YannLeCun来创建自己的人工智能实验室,期望在该领域获得重大突破。

      牛津大学的研究人员发表了一篇报告表明,美国大约47%的工作因为机器认知技术自动化而变得岌岌可危。

      纽约时报畅销书《TheSecondMachineAge》论断,数字科技和人工智能带来巨大积极改变的时代已经到来,但是随之而来的也有引发大量失业等负面效应。

      硅谷创业家ElonMusk则通过不断投资的方式来保持对人工智能的关注。他甚至认为人工智能的危险性超过核武器。

      著名理论物理学家StephenHawking认为,如果成功创造出人工智能则意味着人类历史的终结,“除非我们知道如何规避风险。”

      即便有如此多炒作,但人工智能领域却也不乏显著的商业行为,这些活动已经或者即将对各个行业和组织产生影响。商业领袖需要透彻理解人工智能的含义以及发展趋势。

      二、人工智能与认知科技

      揭秘人工智能的首要步骤就是定义专业术语,勾勒历史,同时描述基础性的核心技术。

      1、人工智能的定义

      人工智能领域苦于存在多种概念和定义,有的太过有的则不够。作为该领域创始人之一的NilsNilsson先生写到:“人工智能缺乏通用的定义。”一本如今已经修订三版的权威性人工智能教科书给出了八项定义,但书中并没有透露其作者究竟倾向于哪种定义。对于我们来说,一种实用的定义即为——人工智能是对计算机系统如何能够履行那些只有依靠人类智慧才能完成的任务的理论研究。例如,视觉感知、语音识别、在不确定条件下做出决策、学习、还有语言翻译等。比起研究人类如何进行思维活动,从人类能够完成的任务角度对人工智能进行定义,而非人类如何思考,在当今时代能够让我们绕开神经机制层面对智慧进行确切定义从而直接探讨它的实际应用。值得一提的是,随着计算机为解决新任务挑战而升级换代并推而广之,人们对那些所谓需要依靠人类智慧才能解决的任务的定义门槛也越来越高。所以,人工智能的定义随着时间而演变,这一现象称之为“人工智能效应”,概括起来就是“人工智能就是要实现所有目前还无法不借助人类智慧才能实现的任务的集合。”

      2、人工智能的历史

      人工智能并不是一个新名词。实际上,这个领域在20世纪50年代就已经开始启动,这段探索的历史被称为“喧嚣与渴望、挫折与失望交替出现的时代”——最近给出的一个较为恰当的评价。

      20世纪50年代明确了人工智能要模拟人类智慧这一大胆目标,从此研究人员开展了一系列贯穿20世纪60年代并延续到70年代的研究项目,这些项目表明,计算机能够完成一系列所本只属于人类能力范畴之内的任务,例如证明定理、求解微积分、通过规划来响应命令、履行物理动作,甚至是模拟心理学家、谱曲这样的活动。

      但是,过分简单的算法、匮乏的难以应对不确定环境(这种情形在生活中无处不在)的理论,以及计算能力的限制严重阻碍了我们使用人工智能来解决更加困难和多样的问题。伴随着对缺乏继续努力的失望,人工智能于20世纪70年代中期逐渐淡出公众视野。

      20世纪80年代早期,日本发起了一个项目,旨在开发一种在人工智能领域处于领先的计算机结构。西方开始担心会在这个领域输给日本,这种焦虑促使他们决定重新开始对人工智能的投资。20世纪80年代已经出现了人工智能技术产品的商业供应商,其中一些已经上市,例如Intellicorp、Symbolics、和Teknowledge。

      20世纪80年代末,几乎一半的“财富500强”都在开发或使用“专家系统”,这是一项通过对人类专家的问题求解能力进行建模,来模拟人类专家解决该领域问题的人工智能技术。

      对于专家系统潜力的过高希望彻底掩盖了它本身的局限性,包括明显缺乏常识、难以捕捉专家的隐性知识、建造和维护大型系统这项工作的复杂性和成本,当这一点被越来越多的人所认识到时,人工智能研究再一次脱离轨道。

      20世纪90年代在人工智能领域的技术成果始终处于低潮,成果寥寥。反而是神经网络、遗传算法等科技得到了新的关注,这一方面是因为这些技术避免了专家系统的若干限制,另一方面是因为新算法让它们运行起来更加高效。

      神经网络的设计受到了大脑结构的启发。遗传算法的机制是,首先迭代生成备选解决方案,然后剔除最差方案,最后通过引入随机变量来产生新的解决方案,从而“进化”出解决问题的最佳方案。

      3、人工智能进步的催化剂

      截止到21世纪前10年的后期,出现了一系列复兴人工智能研究进程的要素,尤其是一些核心技术。下面将对这些重要的因素和技术进行详细说明。

      1)摩尔定律

      在价格、体积不变的条件下,计算机的计算能力可以不断增长。这就是被人们所熟知的摩尔定律,它以Intel共同创办人GordonMoore命名。GordonMoore从各种形式的计算中获利,包括人工智能研究人员使用的计算类型。数年以前,先进的系统设计只能在理论上成立但无法实现,因为它所需要的计算机资源过于昂贵或者计算机无法胜任。今天,我们已经拥有了实现这些设计所需要的计算资源。举个梦幻般的例子,现在最新一代微处理器的性能是1971年第一代单片机的400万倍。

      2)大数据

      得益于互联网、社交媒体、移动设备和廉价的传感器,这个世界产生的数据量急剧增加。随着对这些数据的价值的不断认识,用来管理和分析数据的新技术也得到了发展。大数据是人工智能发展的助推剂,这是因为有些人工智能技术使用统计模型来进行数据的概率推算,比如图像、文本或者语音,通过把这些模型暴露在数据的海洋中,使它们得到不断优化,或者称之为“训练”——现在这样的条件随处可得。

      3)互联网和云计算

      和大数据现象紧密相关,互联网和云计算可以被认为是人工智能基石有两个原因,第一,它们可以让所有联网的计算机设备都能获得海量数据。这些数据是人们推进人工智能研发所需要的,因此它可以促进人工智能的发展。第二,它们为人们提供了一种可行的合作方式——有时显式有时隐式——来帮助人工智能系统进行训练。比如,有些研究人员使用类似MechanicalTurk这样基于云计算的众包服务来雇佣成千上万的人来描绘数字图像。这就使得图像识别算法可以从这些描绘中进行学习。谷歌翻译通过分析用户的反馈以及使用者的无偿贡献来提高它自动翻译的质量。

      4)新算法

      算法是解决一个设计程序或完成任务的路径方法。最近几年,新算法的发展极大提高了机器学习的能力,这些算法本身很重要,同时也是其他技术的推动者,比如计算机视觉(这项科技将会在后文描述)。机器学习算法目前被开源使用,这种情形将促成更大进步,因为在开源环境下开发人员可以补足和增强彼此的工作。

      4、认知技术

      我们将区分人工智能领域和由此延伸的各项技术。大众媒体将人工智能刻画为跟人一样聪明的或比人更聪明的计算机的来临。而各项技术则在以往只有人能做到的特定任务上面表现得越来越好。我们称这些技术为认知技术(下图),认知技术是人工智能领域的产物,它们能完成以往只有人能够完成的任务。而它们正是商业和公共部门的领导者应该关注的。下面我们将介绍几个最重要的认知技术,它们正被广泛采纳并进展迅速,也获得大量投资。

      一文了解人工智能的基本常识

      1)计算机视觉

      是指计算机从图像中识别出物体、场景和活动的能力。计算机视觉技术运用由图像处理操作及其他技术所组成的序列来将图像分析任务分解为便于管理的小块任务。比如,一些技术能够从图像中检测到物体的边缘及纹理。分类技术可被用作确定识别到的特征是否能够代表系统已知的一类物体。

      计算机视觉有着广泛应用。其中包括,医疗成像分析被用来提高疾病的预测、诊断和治疗;人脸识别被Facebook用来自动识别照片里的人物;在安防及监控领域被用来指认嫌疑人;在购物方面,消费者现在可以用智能手机拍摄下产品以获得更多购买选择。

      机器视觉作为一个相关学科,泛指在工业自动化领域的视觉应用。在这些应用里,计算机在高度受限的工厂环境里识别诸如生产零件一类的物体,因此相对于寻求在非受限环境里操作的计算机视觉来说目标更为简单。计算机视觉是一个正在进行中的研究,而机器视觉则是“已经解决的问题”,是系统工程方面的课题而非研究层面的课题。因为应用范围的持续扩大,计算机视觉领域的初创公司自2011年起已经吸引了数亿美元的风投资本。

      2)机器学习

      指的是计算机系统无需遵照显式的程序指令而只是依靠暴露在数据中来提升自身性能的能力。其核心在于,机器学习是从数据中自动发现模式,模式一旦被发现便可用于做预测。比如,给予机器学习系统一个关于交易时间、商家、地点、价格及交易是否正当等信用卡交易信息的数据库,系统就会学习到可用来预测信用卡欺诈的模式。处理的交易数据越多,预测就会越好。

      机器学习的应用范围非常广泛,针对那些产生庞大数据的活动,它几乎拥有改进一切性能的潜力。除了欺诈甄别之外,这些活动还包括销售预测、库存管理、石油和天然气勘探、以及公共卫生。机器学习技术在其他的认知技术领域也扮演着重要角色,比如计算机视觉,它能在海量图像中通过不断训练和改进视觉模型来提高其识别对象的能力。现如今,机器学习已经成为认知技术中最炙手可热的研究领域之一,在2011-2014年中这段时间内就已吸引了近十亿美元的风险投资。谷歌也在2014年斥资4亿美金收购Deepmind这家研究机器学习技术的公司。

      3)自然语言处理

      是指计算机拥有的人类般文本处理的能力,比如,从文本中提取意义,甚至从那些可读的、风格自然、语法正确的文本中自主解读出含义。一个自然语言处理系统并不了解人类处理文本的方式,但是它却可以用非常复杂与成熟的手段巧妙处理文本,例如自动识别一份文档中所有被提及的人与地点;识别文档的核心议题;或者在一堆仅人类可读的合同中,将各种条款与条件提取出来并制作成表。以上这些任务通过传统的文本处理软件根本不可能完成,后者仅能针对简单的文本匹配与模式进行操作。请思考一个老生常谈的例子,它可以体现自然语言处理面临的一个挑战。在句子“光阴似箭(Timeflieslikeanarrow)”中每一个单词的意义看起来都很清晰,直到系统遇到这样的句子“果蝇喜欢香蕉(Fruitflieslikeabanana)”,用“水果(fruit)”替代了“时间(time)”,并用“香蕉(banana)”替代“箭(arrow)”,就改变了“飞逝/飞着的(like)”与“像/喜欢(like)”这两个单词的意思。

      自然语言处理,像计算机视觉技术一样,将各种有助于实现目标的多种技术进行了融合。建立语言模型来预测语言表达的概率分布,举例来说,就是某一串给定字符或单词表达某一特定语义的最大可能性。选定的特征可以和文中的某些元素结合来识别一段文字,通过识别这些元素可以把某类文字同其他文字区别开来,比如垃圾邮件同正常邮件。以机器学习为驱动的分类方法将成为筛选的标准,用来决定一封邮件是否属于垃圾邮件。

      因为语境对于理解“timeflies(时光飞逝)”和“fruitflies(果蝇)”的区别是如此重要,所以自然语言处理技术的实际应用领域相对较窄,这些领域包括分析顾客对某项特定产品和服务的反馈、自动发现民事诉讼或政府调查中的某些含义、以及自动书写诸如企业营收和体育运动的公式化范文等。

      4)机器人技术

      将机器视觉、自动规划等认知技术整合至极小却高性能的传感器、致动器、以及设计巧妙的硬件中,这就催生了新一代的机器人,它有能力与人类一起工作,能在各种未知环境中灵活处理不同的任务。例如无人机,还有可以在车间为人类分担工作的“cobots”,还包括那些从玩具到家务助手的消费类产品。

      5)语音识别技术

      主要是关注自动且准确的转录人类的语音。该技术必须面对一些与自然语言处理类似的问题,在不同口音的处理、背景噪音、区分同音异形异义词(“buy”和“by”听起来是一样的)方面存在一些困难,同时还需要具有跟上正常语速的工作速度。语音识别系统使用一些与自然语言处理系统相同的技术,再辅以其他技术,比如描述声音和其出现在特定序列和语言中概率的声学模型等。语音识别的主要应用包括医疗听写、语音书写、电脑系统声控、电话客服等。比如Domino’sPizza最近推出了一个允许用户通过语音下单的移动APP。

      上面提到的认知技术进步飞快并吸引了大量投资,其他相对成熟的认知技术仍然是企业软件系统的重要组成部分。这些日渐成熟的认知技术包括决策最优化——自动完成对复杂决策或者在资源有限的前提下做出最佳权衡;规划和调度——使设计一系列行动流程来满足目标和观察约束;规则导向系统——为专家系统提供基础的技术,使用知识和规则的数据库来自动完成从信息中进行推论的处理过程。

      三、认知技术的广泛使用

      各种经济部门已经把认知技术运用到了多种商业职能中。

      1)银行业

      自动欺诈探测系统使用机器学习可以识别出预示着欺诈性付款行动的行为模式;借助语音识别技术能够自动完成电话客服;声音识别可以核实来电者的身份

      2)医疗健康领域

      美国有一半的医院采用自动语音识别来帮助医生自动完成医嘱抄录,而且使用率还在迅速增长;机器视觉系统自动完成乳房X光检查和其他医学影响的分析;IBM的Watson借助自然语言处理技术来阅读和理解大量医学文献,通过假设自动生成来完成自动诊断,借助机器学习可以提高准确率。

      3)生命科学领域

      机器学习系统被用来预测生物数据和化合物活动的因果关系,从而帮助制药公司识别出最有前景的药物。

      4)媒体与娱乐行业

      许多公司正在使用数据分析和自然语言生成技术,自动起草基于数据的的公文材料,比如公司营收状况、体育赛事综述等。

      5)石油与天然气

      厂商将机器学习广泛运用在矿藏资源定位、钻井设备故障诊断等众多方面。

      6)公共部门

      出于监控、合规和欺诈检测等特定目的,公共部门也已经开始使用认知技术。比如,乔治亚州正在通过众包的形式来进行财政披露和竞选捐助表格的数字化,在这个过程中他们就采用了一套自动手写识别系统。

      7)零售商

      零售商利用机器学习来自动发现有吸引力的交叉销售定价和有效的促销活动。

      8)科技公司

      它们正利用机器视觉、机器学习等认知技术来改进产品或者开发全新产品,比如Roomba机器人吸尘器,Nest智能恒温器。

      上述例子表明,认识技术的潜在商业收益远大于自动化带来的成本节约,这主要体现在:

      更快的行动与决策(比如,自动欺诈检测,计划和调度)

      更好的结果(比如,医学诊断、石油探测、需求预测)

      更高的效率(亦即,更好的利用高技能人才和昂贵设备)

      更低的成本(比如,自动电话客服减少了劳动成本)

      更大的规模(亦即,开展人力无法执行的大规模任务)

      产品与服务创新(从增加新功能到创造新产品)

      四、认知技术影响力与日俱增的原因

      在未来五年,认知技术在商业领域的影响力将显著增长。原因有二,首先,近些年来,技术性能有了实质进步,并处于持续研发状态。其次,数亿美元已经投入到技术商业化中,许多公司正致力于为各商业部门的广泛需求提供定制化开发和打包方案,以使这些技术更易购买和配置。虽然并非所有的技术提供商都能幸存,但他们的努力将共同推动市场前进。技术性能的改善和商业化正在共同扩大着认知技术的应用范围,这种情况在未来几年都将持续下去。

      1、技术提升扩展了应用范围

      认知技术大踏步前进的例子非常多。比如Google的语音识别系统,一份报告显示,Google用了不到两年时间就将语音识别的精准度从2012年的84%提升到如今的98%。计算机视觉技术也取得了突飞猛进的发展。如果以计算机视觉技术研究者设置的技术标准来看,自2010年到2014年,图像分类识别的精准度提高了4倍。Facebook的DeepFace技术在同行评审报告(译者注:同行评审,是一种学术成果审查程序,即一位作者的学术著作或计划被同一领域的其他专家学者评审。)被高度肯定,其脸部识别率的准确度达到97%。2011年,IBM为了让Watson在智力节目《危险边缘》中获胜,曾对Watson进行优化,提升两倍的答案精确度。现在,IBM又宣称如今的Watson比当时“智能”了2400%。

      随着技术的改进和提高,技术应用的范围也在不断扩大。比如,在语音识别方面,机器曾经需要大量训练才能在有限词库里勉强识别出来,由语音识别技术延伸出的医疗应用程序也很难得到真正普及。而现在,每个月互联网上都会有数以百万次的语音搜索。另外,计算机视觉技术过去被狭隘的理解为部署在工业自动化方面,但现在,我们早已看到这一技术被广泛运用到监控、安全以及各种各样的消费应用里。IBM如今正拓展Watson在竞赛游戏之外的应用,从医疗诊断到医学研究再到财务建议以及自动化的呼叫中心。

      并不是所有的认知技术都有如此令人瞩目的发展。机器翻译有了一定发展,但幅度很小。一份调查发现,从2009年到2012年,将阿拉伯语翻译到英语的精确度仅仅提升了13%。尽管这些技术还不完美,但他们已经可以影响到专业机构的工作方式。很多专业翻译人员依靠机器翻译提升翻译精准度,并把一些常规翻译交给机器,自己专注在更具挑战性的任务上。

      很多公司正努力将认知技术做进一步研发,并逐步将其融入到更多产品尤其是企业级产品里,以方便企业用户购买和部署。

      2、对商业化进行的大规模投资

      从2011年到2014年5月,超过20亿美元的风险投资流入到基于认知技术研究的产品和服务里。与此同时,超过100家的相关公司被兼并或收购,其中一些被互联网巨头如亚马逊、苹果、Google、IBM或Facebook收购。所有这些投资都在培育一个多样化的公司图谱,这些公司正在加速认知技术的商业化进程。

      在这里,我们并不会提供关于某公司在认知技术商业化方面的细节,我们希望说明,认知技术产品拥有丰富的多样性。下面就是致力于认知技术商业化的公司名单,这个名单既不是完整无缺也非固定不变,而是一个动态的,用于推动和培育市场的指标。

      数据管理和分析工具主要使用自然语言处理、机器学习等认知技术。这些工具利用自然语言处理来从非结构化的文本中提取出意思,或者借助机器学习帮助分析人员从大规模数据集中发现深层含义。这个领域的公司包括ContextRelevant(译者注:美国的一家大数据挖掘和分析公司)、PalantirTechnologies(译者注:这家公司称要将数据、技术、人类和环境连接起来)、以及Skytree(译者注:一家借助机器学习进行市场分析并提供决策依据的大数据公司)。

      认知技术的各个部分可以被整合到各种应用和商业决策中,分别起到增加功能和提高效率的作用。例如,Wise.io公司提供一套模块来促进商业决策,比如客户支持、营销和销售,这里面会用到机器学习模型来预测哪些客户比较容易流失,以及哪些潜在客户更加容易转化。Nuance公司通过提供一种语音识别技术来帮助开发者进行需要语音控制的移动APP的开发。

      单点解决方案。众多认知技术成熟的标志是它们正在被不断的嵌入到特定商业问题的解决方案中。这些解决方案的设计初衷是要比公司原有的解决方案更加有效,并且几乎不需要认知技术方面的专业人员。普及度比较高的应用领域包括广告、营销和销售自动化、预测以及规划。

      技术平台。平台的目的是为建立高度定制化的商业解决方案提供基础。它们会提供一系列功能,包括数据管理、机器学习工具、自然语言处理、知识表示和推理、以及将这些定制化软件整合在一起的统一框架。

      3、新兴应用

      如果这些技术的表现和商业化趋势继续发展,我们就能够大胆预测认知技术的应用将更加广泛,被接受程度也会大大增加。数亿美金的投资涌入这些基于机器学习、自然语言处理、机器视觉或者机器人技术的公司,这预示着许多新应用即将投入市场。在商业机构依托认知技术构建自动化业务流程、增强产品和服务方面,我们也看到了巨大空间。

      五、认知技术在企业的应用路径

      认知技术将在接下来几年里变得流行。在未来2-5年,技术层面的进步和商业化将扩大认知技术对企业的影响。越来越多的企业会找到一些创新性应用来显著改善他们自身的表现或者创造新功能,以增强他们的竞争地位。企业的IT部门现在可以行动起来,增加对这些技术的了解,评估出适用这些技术的机会,将这些技术可能带来的价值向领导进行汇报。高级商务和公共部门的领导应该思考认知技术将对他们的部门以及整个公司产生何种影响,这些技术将如何激发创新并提升经营表现。


    1.人工智能大发展时代,如何利用大数据改变现有商业模式?

    http://www.duozhishidai.com/article-17554-1.html

    2.人工智能来势凶猛,人工智能最热门的技术趋势是什么

    http://www.duozhishidai.com/article-923-1.html

    3.今年人工智能领域,十项中外人工智能领域富有突破性的技术

    http://www.duozhishidai.com/article-17560-1.html

     

    展开全文
  • 但是,我们在实际应用中发现,SpringMVC可以完全替代Struts,配合注解的方式,编程非常快捷,而且通过restful风格定义url,让地址看起来非常优雅。 另外,MyBatis也可以替换Hibernate,正因为MyBatis的半自动特点,...

    本文发表于2016年6月,写于作者学生时期。文中使用到的技术和框架可能不是当下最佳实践,甚至很不“优雅”。但对于刚接触JavaEE和Spring的同学来说,还是能有很多收获的,大牛轻拍= =

    我们看招聘信息的时候,经常会看到这一点,需要具备SSH框架的技能;而且在大部分教学课堂中,也会把SSH作为最核心的教学内容。
    但是,我们在实际应用中发现,SpringMVC可以完全替代Struts,配合注解的方式,编程非常快捷,而且通过restful风格定义url,让地址看起来非常优雅。
    另外,MyBatis也可以替换Hibernate,正因为MyBatis的半自动特点,我们程序猿可以完全掌控SQL,这会让有数据库经验的程序猿能开发出高效率的SQL语句,而且XML配置管理起来也非常方便。
    好了,如果你也认同我的看法,那么下面我们一起来做整合吧!

    在写代码之前我们先了解一下这三个框架分别是干什么的?
    相信大以前也看过不少这些概念,我这就用大白话来讲,如果之前有了解过可以跳过这一大段,直接看代码!

    1. SpringMVC:它用于web层,相当于controller(等价于传统的servlet和struts的action),用来处理用户请求。举个例子,用户在地址栏输入http://网站域名/login,那么springmvc就会拦截到这个请求,并且调用controller层中相应的方法,(中间可能包含验证用户名和密码的业务逻辑,以及查询数据库操作,但这些都不是springmvc的职责),最终把结果返回给用户,并且返回相应的页面(当然也可以只返回json/xml等格式数据)。springmvc就是做前面和后面过程的活,与用户打交道!!

    2. Spring:太强大了,以至于我无法用一个词或一句话来概括它。但与我们平时开发接触最多的估计就是IOC容器,它可以装载bean(也就是我们java中的类,当然也包括service dao里面的),有了这个机制,我们就不用在每次使用这个类的时候为它初始化,很少看到关键字new。另外spring的aop,事务管理等等都是我们经常用到的。

    3. MyBatis:如果你问我它跟鼎鼎大名的Hibernate有什么区别?我只想说,他更符合我的需求。第一,它能自由控制sql,这会让有数据库经验的人(当然不是说我啦捂脸)编写的代码能搞提升数据库访问的效率。第二,它可以使用xml的方式来组织管理我们的sql,因为一般程序出错很多情况下是sql出错,别人接手代码后能快速找到出错地方,甚至可以优化原来写的sql。


    SSM框架整合配置

    好了,前面bb那么多,下面我们真正开始敲代码了~

    首先我们打开IED,我这里用的是eclipse(你们应该也是用的这个,对吗?),创建一个动态web项目,建立好相应的目录结构(重点!)

    项目结构图

    (打了马赛克是因为这里还用不到,你们不要那么污好不好?)

    我说一下每个目录都有什么用吧(第一次画表格,我发现markdown的表格语法很不友好呀~)
    这个目录结构同时也遵循maven的目录规范~

    文件名作用
    src根目录,没什么好说的,下面有main和test。
    - main主要目录,可以放java代码和一些资源文件。
    - - java存放我们的java代码,这个文件夹要使用Build Path -> Use as Source Folder,这样看包结构会方便很多,新建的包就相当于在这里新建文件夹咯。
    - - resources存放资源文件,譬如各种的spring,mybatis,log配置文件。
    - - - mapper存放dao中每个方法对应的sql,在这里配置,无需写daoImpl。
    - - - spring这里当然是存放spring相关的配置文件,有dao service web三层。
    - - - sql其实这个可以没有,但是为了项目完整性还是加上吧。
    - - - webapp这个貌似是最熟悉的目录了,用来存放我们前端的静态资源,如jsp js css。
    - - - - resources这里的资源是指项目的静态资源,如js css images等。
    - - - - WEB-INF很重要的一个目录,外部浏览器无法访问,只有羡慕内部才能访问,可以把jsp放在这里,另外就是web.xml了。你可能有疑问了,为什么上面java中的resources里面的配置文件不妨在这里,那么是不是会被外部窃取到?你想太多了,部署时候基本上只有webapp里的会直接输出到根目录,其他都会放入WEB-INF里面,项目内部依然可以使用classpath:XXX来访问,好像IDE里可以设置部署输出目录,这里扯远了~
    - test这里是测试分支。
    - - java测试java代码,应遵循包名相同的原则,这个文件夹同样要使用Build Path -> Use as Source Folder,这样看包结构会方便很多。
    - - resources没什么好说的,好像也很少用到,但这个是maven的规范。

    我先新建好几个必要的,并为大家讲解一下每个包的作用,顺便理清一下后台的思路~

    包结构图

    包名名称作用
    dao数据访问层(接口)与数据打交道,可以是数据库操作,也可以是文件读写操作,甚至是redis缓存操作,总之与数据操作有关的都放在这里,也有人叫做dal或者数据持久层都差不多意思。为什么没有daoImpl,因为我们用的是mybatis,所以可以直接在配置文件中实现接口的每个方法。
    entity实体类一般与数据库的表相对应,封装dao层取出来的数据为一个对象,也就是我们常说的pojo,一般只在dao层与service层之间传输。
    dto数据传输层刚学框架的人可能不明白这个有什么用,其实就是用于service层与web层之间传输,为什么不直接用entity(pojo)?其实在实际开发中发现,很多时间一个entity并不能满足我们的业务需求,可能呈现给用户的信息十分之多,这时候就有了dto,也相当于vo,记住一定不要把这个混杂在entity里面,答应我好吗?
    service业务逻辑(接口)写我们的业务逻辑,也有人叫bll,在设计业务接口时候应该站在“使用者”的角度。额,不要问我为什么这里没显示!IDE调皮我也拿它没办法~
    serviceImpl业务逻辑(实现)实现我们业务接口,一般事务控制是写在这里,没什么好说的。
    web控制器springmvc就是在这里发挥作用的,一般人叫做controller控制器,相当于struts中的action。

    还有最后一步基础工作,导入我们相应的jar包,我使用的是maven来管理我们的jar,所以只需要在pom.xml中加入相应的依赖就好了,如果不使用maven的可以自己去官网下载相应的jar,放到项目WEB-INF/lib目录下。关于maven的学习大家可以看慕课网的视频教程,这里就不展开了。我把项目用到的jar都写在下面,版本都不是最新的,大家有经验的话可以自己调整版本号。另外,所有jar都会与项目一起打包放到我的github上,喜欢的给个star吧~

    pom.xml

    <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 http://maven.apache.org/maven-v4_0_0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<groupId>com.soecode.ssm</groupId>
    	<artifactId>ssm</artifactId>
    	<packaging>war</packaging>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>ssm Maven Webapp</name>
    	<url>http://github.com/liyifeng1994/ssm</url>
    	<dependencies>
    		<!-- 单元测试 -->
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>4.11</version>
    		</dependency>
    
    		<!-- 1.日志 -->
    		<!-- 实现slf4j接口并整合 -->
    		<dependency>
    			<groupId>ch.qos.logback</groupId>
    			<artifactId>logback-classic</artifactId>
    			<version>1.1.1</version>
    		</dependency>
    
    		<!-- 2.数据库 -->
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>5.1.37</version>
    			<scope>runtime</scope>
    		</dependency>
    		<dependency>
    			<groupId>c3p0</groupId>
    			<artifactId>c3p0</artifactId>
    			<version>0.9.1.2</version>
    		</dependency>
    
    		<!-- DAO: MyBatis -->
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis</artifactId>
    			<version>3.3.0</version>
    		</dependency>
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis-spring</artifactId>
    			<version>1.2.3</version>
    		</dependency>
    
    		<!-- 3.Servlet web -->
    		<dependency>
    			<groupId>taglibs</groupId>
    			<artifactId>standard</artifactId>
    			<version>1.1.2</version>
    		</dependency>
    		<dependency>
    			<groupId>jstl</groupId>
    			<artifactId>jstl</artifactId>
    			<version>1.2</version>
    		</dependency>
    		<dependency>
    			<groupId>com.fasterxml.jackson.core</groupId>
    			<artifactId>jackson-databind</artifactId>
    			<version>2.5.4</version>
    		</dependency>
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>javax.servlet-api</artifactId>
    			<version>3.1.0</version>
    		</dependency>
    
    		<!-- 4.Spring -->
    		<!-- 1)Spring核心 -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-beans</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<!-- 2)Spring DAO层 -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-tx</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<!-- 3)Spring web -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    		<!-- 4)Spring test -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-test</artifactId>
    			<version>4.1.7.RELEASE</version>
    		</dependency>
    
    		<!-- redis客户端:Jedis -->
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>2.7.3</version>
    		</dependency>
    		<dependency>
    			<groupId>com.dyuproject.protostuff</groupId>
    			<artifactId>protostuff-core</artifactId>
    			<version>1.0.8</version>
    		</dependency>
    		<dependency>
    			<groupId>com.dyuproject.protostuff</groupId>
    			<artifactId>protostuff-runtime</artifactId>
    			<version>1.0.8</version>
    		</dependency>
    
    		<!-- Map工具类 -->
    		<dependency>
    			<groupId>commons-collections</groupId>
    			<artifactId>commons-collections</artifactId>
    			<version>3.2</version>
    		</dependency>
    	</dependencies>
    	<build>
    		<finalName>ssm</finalName>
    	</build>
    </project>
    
    

    下面真的要开始进行编码工作了,坚持到这里辛苦大家了~

    第一步:我们先在spring文件夹里新建spring-dao.xml文件,因为spring的配置太多,我们这里分三层,分别是dao service web。

    1. 读入数据库连接相关参数(可选)
    2. 配置数据连接池
    3. 配置连接属性,可以不读配置项文件直接在这里写死
    4. 配置c3p0,只配了几个常用的
    5. 配置SqlSessionFactory对象(mybatis)
    6. 扫描dao层接口,动态实现dao接口,也就是说不需要daoImpl,sql和参数都写在xml文件上

    spring-dao.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	http://www.springframework.org/schema/beans/spring-beans.xsd
    	http://www.springframework.org/schema/context
    	http://www.springframework.org/schema/context/spring-context.xsd">
    	<!-- 配置整合mybatis过程 -->
    	<!-- 1.配置数据库相关参数properties的属性:${url} -->
    	<context:property-placeholder location="classpath:jdbc.properties" />
    
    	<!-- 2.数据库连接池 -->
    	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    		<!-- 配置连接池属性 -->
    		<property name="driverClass" value="${jdbc.driver}" />
    		<property name="jdbcUrl" value="${jdbc.url}" />
    		<property name="user" value="${jdbc.username}" />
    		<property name="password" value="${jdbc.password}" />
    
    		<!-- c3p0连接池的私有属性 -->
    		<property name="maxPoolSize" value="30" />
    		<property name="minPoolSize" value="10" />
    		<!-- 关闭连接后不自动commit -->
    		<property name="autoCommitOnClose" value="false" />
    		<!-- 获取连接超时时间 -->
    		<property name="checkoutTimeout" value="10000" />
    		<!-- 当获取连接失败重试次数 -->
    		<property name="acquireRetryAttempts" value="2" />
    	</bean>
    
    	<!-- 3.配置SqlSessionFactory对象 -->
    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    		<!-- 注入数据库连接池 -->
    		<property name="dataSource" ref="dataSource" />
    		<!-- 配置MyBaties全局配置文件:mybatis-config.xml -->
    		<property name="configLocation" value="classpath:mybatis-config.xml" />
    		<!-- 扫描entity包 使用别名 -->
    		<property name="typeAliasesPackage" value="com.soecode.lyf.entity" />
    		<!-- 扫描sql配置文件:mapper需要的xml文件 -->
    		<property name="mapperLocations" value="classpath:mapper/*.xml" />
    	</bean>
    
    	<!-- 4.配置扫描Dao接口包,动态实现Dao接口,注入到spring容器中 -->
    	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    		<!-- 注入sqlSessionFactory -->
    		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    		<!-- 给出需要扫描Dao接口包 -->
    		<property name="basePackage" value="com.soecode.lyf.dao" />
    	</bean>
    </beans>
    

    因为数据库配置相关参数是读取配置文件,所以在resources文件夹里新建一个jdbc.properties文件,存放我们4个最常见的数据库连接属性,这是我本地的,大家记得修改呀~还有喜欢传到github上“大头虾们”记得删掉密码,不然别人就很容易得到你服务器的数据库配置信息,然后干一些羞羞的事情,你懂的!!

    jdbc.properties

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3307/ssm?useUnicode=true&characterEncoding=utf8
    jdbc.username=root
    jdbc.password=
    

    友情提示:配置文件中的jdbc.username,如果写成username,可能会与系统环境中的username变量冲突,所以到时候真正连接数据库的时候,用户名就被替换成系统中的用户名(有得可能是administrator),那肯定是连接不成功的,这里有个小坑,我被坑了一晚上!!

    因为这里用到了mybatis,所以需要配置mybatis核心文件,在recources文件夹里新建mybatis-config.xml文件。

    1. 使用自增主键
    2. 使用列别名
    3. 开启驼峰命名转换 create_time -> createTime

    mybatis-config.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    	<!-- 配置全局属性 -->
    	<settings>
    		<!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->
    		<setting name="useGeneratedKeys" value="true" />
    
    		<!-- 使用列别名替换列名 默认:true -->
    		<setting name="useColumnLabel" value="true" />
    
    		<!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->
    		<setting name="mapUnderscoreToCamelCase" value="true" />
    	</settings>
    </configuration>
    

    第二步:刚弄好dao层,接下来到service层了。在spring文件夹里新建spring-service.xml文件。

    1. 扫描service包所有注解 @Service
    2. 配置事务管理器,把事务管理交由spring来完成
    3. 配置基于注解的声明式事务,可以直接在方法上@Transaction

    spring-service.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:tx="http://www.springframework.org/schema/tx"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	http://www.springframework.org/schema/beans/spring-beans.xsd
    	http://www.springframework.org/schema/context
    	http://www.springframework.org/schema/context/spring-context.xsd
    	http://www.springframework.org/schema/tx
    	http://www.springframework.org/schema/tx/spring-tx.xsd">
    	<!-- 扫描service包下所有使用注解的类型 -->
    	<context:component-scan base-package="com.soecode.lyf.service" />
    
    	<!-- 配置事务管理器 -->
    	<bean id="transactionManager"
    		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    		<!-- 注入数据库连接池 -->
    		<property name="dataSource" ref="dataSource" />
    	</bean>
    
    	<!-- 配置基于注解的声明式事务 -->
    	<tx:annotation-driven transaction-manager="transactionManager" />
    </beans>
    

    第三步:配置web层,在spring文件夹里新建spring-web.xml文件。

    1. 开启SpringMVC注解模式,可以使用@RequestMapping,@PathVariable,@ResponseBody等
    2. 对静态资源处理,如js,css,jpg等
    3. 配置jsp 显示ViewResolver,例如在controller中某个方法返回一个string类型的"login",实际上会返回"/WEB-INF/login.jsp"
    4. 扫描web层 @Controller

    spring-web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:mvc="http://www.springframework.org/schema/mvc" 
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
    	http://www.springframework.org/schema/beans/spring-beans.xsd
    	http://www.springframework.org/schema/context
    	http://www.springframework.org/schema/context/spring-context.xsd
    	http://www.springframework.org/schema/mvc
    	http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
    	<!-- 配置SpringMVC -->
    	<!-- 1.开启SpringMVC注解模式 -->
    	<!-- 简化配置: 
    		(1)自动注册DefaultAnootationHandlerMapping,AnotationMethodHandlerAdapter 
    		(2)提供一些列:数据绑定,数字和日期的format @NumberFormat, @DateTimeFormat, xml,json默认读写支持 
    	-->
    	<mvc:annotation-driven />
    	
    	<!-- 2.静态资源默认servlet配置
    		(1)加入对静态资源的处理:js,gif,png
    		(2)允许使用"/"做整体映射
    	 -->
    	 <mvc:default-servlet-handler/>
    	 
    	 <!-- 3.配置jsp 显示ViewResolver -->
    	 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    	 	<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
    	 	<property name="prefix" value="/WEB-INF/jsp/" />
    	 	<property name="suffix" value=".jsp" />
    	 </bean>
    	 
    	 <!-- 4.扫描web相关的bean -->
    	 <context:component-scan base-package="com.soecode.lyf.web" />
    </beans>
    

    第四步:最后就是修改web.xml文件了,它在webappWEB-INF下。

    web.xml

    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                          http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    	version="3.1" metadata-complete="true">
    	<!-- 如果是用mvn命令生成的xml,需要修改servlet版本为3.1 -->
    	<!-- 配置DispatcherServlet -->
    	<servlet>
    		<servlet-name>seckill-dispatcher</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		<!-- 配置springMVC需要加载的配置文件
    			spring-dao.xml,spring-service.xml,spring-web.xml
    			Mybatis - > spring -> springmvc
    		 -->
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>classpath:spring/spring-*.xml</param-value>
    		</init-param>
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>seckill-dispatcher</servlet-name>
    		<!-- 默认匹配所有的请求 -->
    		<url-pattern>/</url-pattern>
    	</servlet-mapping>
    </web-app>
    
    

    我们在项目中经常会使用到日志,所以这里还有配置日志xml,在resources文件夹里新建logback.xml文件,所给出的日志输出格式也是最基本的控制台s呼出,大家有兴趣查看logback官方文档

    logback.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration debug="true">
    	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    		<!-- encoders are by default assigned the type ch.qos.logback.classic.encoder.PatternLayoutEncoder -->
    		<encoder>
    			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    		</encoder>
    	</appender>
    
    	<root level="debug">
    		<appender-ref ref="STDOUT" />
    	</root>
    </configuration>
    

    到目前为止,我们一共写了7个配置文件,我们一起来看下最终的配置文件结构图

    配置文件结构图


    SSM框架应用实例(图书管理系统)

    一开始想就这样结束教程,但是发现其实很多人都还不会把这个SSM框架用起来,特别是mybatis部分。那我现在就以最常见的“图书管理系统”中【查询图书】和【预约图书】业务来做一个demo吧!

    首先新建数据库名为ssm,再创建两张表:图书表book和预约图书表appointment,并且为book表初始化一些数据,sql如下。

    schema.sql

    -- 创建图书表
    CREATE TABLE `book` (
      `book_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '图书ID',
      `name` varchar(100) NOT NULL COMMENT '图书名称',
      `number` int(11) NOT NULL COMMENT '馆藏数量',
      PRIMARY KEY (`book_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8 COMMENT='图书表'
    
    -- 初始化图书数据
    INSERT INTO `book` (`book_id`, `name`, `number`)
    VALUES
    	(1000, 'Java程序设计', 10),
    	(1001, '数据结构', 10),
    	(1002, '设计模式', 10),
    	(1003, '编译原理', 10)
    
    -- 创建预约图书表
    CREATE TABLE `appointment` (
      `book_id` bigint(20) NOT NULL COMMENT '图书ID',
      `student_id` bigint(20) NOT NULL COMMENT '学号',
      `appoint_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '预约时间' ,
      PRIMARY KEY (`book_id`, `student_id`),
      INDEX `idx_appoint_time` (`appoint_time`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='预约图书表'
    

    entity包中添加两个对应的实体,图书实体Book.java和预约图书实体Appointment.java

    Book.java

    package com.soecode.lyf.entity;
    
    public class Book {
    
    	private long bookId;// 图书ID
    
    	private String name;// 图书名称
    
    	private int number;// 馆藏数量
    
    	// 省略构造方法,getter和setter方法,toString方法
    
    }
    

    Appointment.java

    package com.soecode.lyf.entity;
    
    import java.util.Date;
    
    /**
     * 预约图书实体
     */
    public class Appointment {
    
    	private long bookId;// 图书ID
    
    	private long studentId;// 学号
    
    	private Date appointTime;// 预约时间
    
    	// 多对一的复合属性
    	private Book book;// 图书实体
    	
    	// 省略构造方法,getter和setter方法,toString方法
    
    }
    

    dao包新建接口BookDao.javaAppointment.java

    BookDao.java

    package com.soecode.lyf.dao;
    
    import java.util.List;
    
    import com.soecode.lyf.entity.Book;
    
    public interface BookDao {
    
    	/**
    	 * 通过ID查询单本图书
    	 * 
    	 * @param id
    	 * @return
    	 */
    	Book queryById(long id);
    
    	/**
    	 * 查询所有图书
    	 * 
    	 * @param offset 查询起始位置
    	 * @param limit 查询条数
    	 * @return
    	 */
    	List<Book> queryAll(@Param("offset") int offset, @Param("limit") int limit);
    
    	/**
    	 * 减少馆藏数量
    	 * 
    	 * @param bookId
    	 * @return 如果影响行数等于>1,表示更新的记录行数
    	 */
    	int reduceNumber(long bookId);
    }
    
    

    AppointmentDao.java

    package com.soecode.lyf.dao;
    
    import org.apache.ibatis.annotations.Param;
    
    import com.soecode.lyf.entity.Appointment;
    
    public interface AppointmentDao {
    
    	/**
    	 * 插入预约图书记录
    	 * 
    	 * @param bookId
    	 * @param studentId
    	 * @return 插入的行数
    	 */
    	int insertAppointment(@Param("bookId") long bookId, @Param("studentId") long studentId);
    
    	/**
    	 * 通过主键查询预约图书记录,并且携带图书实体
    	 * 
    	 * @param bookId
    	 * @param studentId
    	 * @return
    	 */
    	Appointment queryByKeyWithBook(@Param("bookId") long bookId, @Param("studentId") long studentId);
    
    }
    

    提示:这里为什么要给方法的参数添加@Param注解呢?是因为该方法有两个或以上的参数,一定要加,不然mybatis识别不了。上面的BookDao接口的queryById方法和reduceNumber方法只有一个参数book_id,所以可以不用加 @Param注解,当然加了也无所谓~


    注意,这里不需要实现dao接口不用编写daoImpl, mybatis会给我们动态实现,但是我们需要编写相应的mapper。
    mapper目录里新建两个文件BookDao.xmlAppointmentDao.xml,分别对应上面两个dao接口,代码如下。

    BookDao.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.soecode.lyf.dao.BookDao">
    	<!-- 目的:为dao接口方法提供sql语句配置 -->
    	<select id="queryById" resultType="Book" parameterType="long">
    		<!-- 具体的sql -->
    		SELECT
    			book_id,
    			name,
    			number
    		FROM
    			book
    		WHERE
    			book_id = #{bookId}
    	</select>
    	
    	<select id="queryAll" resultType="Book">
    		SELECT
    			book_id,
    			name,
    			number
    		FROM
    			book
    		ORDER BY
    			book_id
    		LIMIT #{offset}, #{limit}
    	</select>
    	
    	<update id="reduceNumber">
    		UPDATE book
    		SET number = number - 1
    		WHERE
    			book_id = #{bookId}
    		AND number > 0
    	</update>
    </mapper>
    

    AppointmentDao.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.soecode.lyf.dao.AppointmentDao">
    	<insert id="insertAppointment">
    		<!-- ignore 主键冲突,报错 -->
    		INSERT ignore INTO appointment (book_id, student_id)
    		VALUES (#{bookId}, #{studentId})
    	</insert>
    	
    	<select id="queryByKeyWithBook" resultType="Appointment">
    		<!-- 如何告诉MyBatis把结果映射到Appointment同时映射book属性 -->
    		<!-- 可以自由控制SQL -->
    		SELECT
    			a.book_id,
    			a.student_id,
    			a.appoint_time,
    			b.book_id "book.book_id",
    			b.`name` "book.name",
    			b.number "book.number"
    		FROM
    			appointment a
    		INNER JOIN book b ON a.book_id = b.book_id
    		WHERE
    			a.book_id = #{bookId}
    		AND a.student_id = #{studentId}
    	</select>
    </mapper>
    

    mapper总结namespace是该xml对应的接口全名,selectupdate中的id对应方法名,resultType是返回值类型,parameterType是参数类型(这个其实可选),最后#{...}中填写的是方法的参数,看懂了是不是很简单!!我也这么觉得~ 还有一个小技巧要交给大家,就是在返回Appointment对象包含了一个属性名为book的Book对象,那么可以使用"book.属性名"的方式来取值,看上面queryByKeyWithBook方法的sql。


    dao层写完了,接下来test对应的package写我们测试方法吧。
    因为我们之后会写很多测试方法,在测试前需要让程序读入spring-dao和mybatis等配置文件,所以我这里就抽离出来一个BaseTest类,只要是测试方法就继承它,这样那些繁琐的重复的代码就不用写那么多了~

    BaseTest.java

    package com.soecode.lyf;
    
    import org.junit.runner.RunWith;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    /**
     * 配置spring和junit整合,junit启动时加载springIOC容器 spring-test,junit
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    // 告诉junit spring配置文件
    @ContextConfiguration({ "classpath:spring/spring-dao.xml", "classpath:spring/spring-service.xml" })
    public class BaseTest {
    
    }
    
    

    因为spring-serviceservice层的测试中会时候到,这里也一起引入算了!

    新建BookDaoTest.javaAppointmentDaoTest.java两个dao测试文件。

    BookDaoTest.java

    package com.soecode.lyf.dao;
    
    import java.util.List;
    
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.soecode.lyf.BaseTest;
    import com.soecode.lyf.entity.Book;
    
    public class BookDaoTest extends BaseTest {
    
    	@Autowired
    	private BookDao bookDao;
    
    	@Test
    	public void testQueryById() throws Exception {
    		long bookId = 1000;
    		Book book = bookDao.queryById(bookId);
    		System.out.println(book);
    	}
    
    	@Test
    	public void testQueryAll() throws Exception {
    		List<Book> books = bookDao.queryAll(0, 4);
    		for (Book book : books) {
    			System.out.println(book);
    		}
    	}
    
    	@Test
    	public void testReduceNumber() throws Exception {
    		long bookId = 1000;
    		int update = bookDao.reduceNumber(bookId);
    		System.out.println("update=" + update);
    	}
    
    }
    

    BookDaoTest测试结果

    testQueryById
    testQueryById

    testQueryAll
    testQueryAll

    testReduceNumber
    testReduceNumber

    AppointmentDaoTest.java

    package com.soecode.lyf.dao;
    
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.soecode.lyf.BaseTest;
    import com.soecode.lyf.entity.Appointment;
    
    public class AppointmentDaoTest extends BaseTest {
    
    	@Autowired
    	private AppointmentDao appointmentDao;
    
    	@Test
    	public void testInsertAppointment() throws Exception {
    		long bookId = 1000;
    		long studentId = 12345678910L;
    		int insert = appointmentDao.insertAppointment(bookId, studentId);
    		System.out.println("insert=" + insert);
    	}
    
    	@Test
    	public void testQueryByKeyWithBook() throws Exception {
    		long bookId = 1000;
    		long studentId = 12345678910L;
    		Appointment appointment = appointmentDao.queryByKeyWithBook(bookId, studentId);
    		System.out.println(appointment);
    		System.out.println(appointment.getBook());
    	}
    
    }
    

    AppointmentDaoTest测试结果

    testInsertAppointment
    testInsertAppointment

    testQueryByKeyWithBook
    testQueryByKeyWithBook


    嗯,到这里一切到很顺利那么我们继续service层的编码吧可能下面开始信息里比较大,大家要做好心理准备~

    首先,在写我们的控制器之前,我们先定义几个预约图书操作返回码的数据字典,也就是我们要返回给客户端的信息。我们这类使用枚举类,没听过的小伙伴要好好恶补一下了(我也是最近才学到的= =)

    预约业务操作返回码说明

    返回码说明
    1预约成功
    0库存不足
    -1重复预约
    -2系统异常

    新建一个包叫enums,在里面新建一个枚举类AppointStateEnum.java,用来定义预约业务的数据字典,没听懂没关系,我们直接看代码吧~是不是感觉有模有样了!

    AppointStateEnum.java

    package com.soecode.lyf.enums;
    
    /**
     * 使用枚举表述常量数据字典
     */
    public enum AppointStateEnum {
    
    	SUCCESS(1, "预约成功"), NO_NUMBER(0, "库存不足"), REPEAT_APPOINT(-1, "重复预约"), INNER_ERROR(-2, "系统异常");
    
    	private int state;
    
    	private String stateInfo;
    
    	private AppointStateEnum(int state, String stateInfo) {
    		this.state = state;
    		this.stateInfo = stateInfo;
    	}
    
    	public int getState() {
    		return state;
    	}
    
    	public String getStateInfo() {
    		return stateInfo;
    	}
    
    	public static AppointStateEnum stateOf(int index) {
    		for (AppointStateEnum state : values()) {
    			if (state.getState() == index) {
    				return state;
    			}
    		}
    		return null;
    	}
    
    }
    

    接下来,在dto包下新建AppointExecution.java用来存储我们执行预约操作的返回结果。

    AppointExecution.java

    package com.soecode.lyf.dto;
    
    import com.soecode.lyf.entity.Appointment;
    import com.soecode.lyf.enums.AppointStateEnum;
    
    /**
     * 封装预约执行后结果
     */
    public class AppointExecution {
    
    	// 图书ID
    	private long bookId;
    
    	// 秒杀预约结果状态
    	private int state;
    
    	// 状态标识
    	private String stateInfo;
    
    	// 预约成功对象
    	private Appointment appointment;
    
    	public AppointExecution() {
    	}
    
    	// 预约失败的构造器
    	public AppointExecution(long bookId, AppointStateEnum stateEnum) {
    		this.bookId = bookId;
    		this.state = stateEnum.getState();
    		this.stateInfo = stateEnum.getStateInfo();
    	}
    
    	// 预约成功的构造器
    	public AppointExecution(long bookId, AppointStateEnum stateEnum, Appointment appointment) {
    		this.bookId = bookId;
    		this.state = stateEnum.getState();
    		this.stateInfo = stateEnum.getStateInfo();
    		this.appointment = appointment;
    	}
    	
    	// 省略getter和setter方法,toString方法
    
    }
    
    

    接着,在exception包下新建三个文件
    NoNumberException.java
    RepeatAppointException.java
    AppointException.java
    预约业务异常类(都需要继承RuntimeException),分别是无库存异常、重复预约异常、预约未知错误异常,用于业务层非成功情况下的返回(即成功返回结果,失败抛出异常)。

    NoNumberException.java

    package com.soecode.lyf.exception;
    
    /**
     * 库存不足异常
     */
    public class NoNumberException extends RuntimeException {
    
    	public NoNumberException(String message) {
    		super(message);
    	}
    
    	public NoNumberException(String message, Throwable cause) {
    		super(message, cause);
    	}
    
    }
    
    

    RepeatAppointException.java

    package com.soecode.lyf.exception;
    
    /**
     * 重复预约异常
     */
    public class RepeatAppointException extends RuntimeException {
    
    	public RepeatAppointException(String message) {
    		super(message);
    	}
    
    	public RepeatAppointException(String message, Throwable cause) {
    		super(message, cause);
    	}
    
    }
    
    

    AppointException.java

    package com.soecode.lyf.exception;
    
    /**
     * 预约业务异常
     */
    public class AppointException extends RuntimeException {
    
    	public AppointException(String message) {
    		super(message);
    	}
    
    	public AppointException(String message, Throwable cause) {
    		super(message, cause);
    	}
    
    }
    
    

    咱们终于可以编写业务代码了,在service包下新建BookService.java图书业务接口。

    BookService.java

    package com.soecode.lyf.service;
    
    import java.util.List;
    
    import com.soecode.lyf.dto.AppointExecution;
    import com.soecode.lyf.entity.Book;
    
    /**
     * 业务接口:站在"使用者"角度设计接口 三个方面:方法定义粒度,参数,返回类型(return 类型/异常)
     */
    public interface BookService {
    
    	/**
    	 * 查询一本图书
    	 * 
    	 * @param bookId
    	 * @return
    	 */
    	Book getById(long bookId);
    
    	/**
    	 * 查询所有图书
    	 * 
    	 * @return
    	 */
    	List<Book> getList();
    
    	/**
    	 * 预约图书
    	 * 
    	 * @param bookId
    	 * @param studentId
    	 * @return
    	 */
    	AppointExecution appoint(long bookId, long studentId);
    
    }
    

    service.impl包下新建BookServiceImpl.java使用BookService接口,并实现里面的方法。

    BookServiceImpl

    package com.soecode.lyf.service.impl;
    
    import java.util.List;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import com.soecode.lyf.dao.AppointmentDao;
    import com.soecode.lyf.dao.BookDao;
    import com.soecode.lyf.dto.AppointExecution;
    import com.soecode.lyf.entity.Appointment;
    import com.soecode.lyf.entity.Book;
    import com.soecode.lyf.enums.AppointStateEnum;
    import com.soecode.lyf.exception.AppointException;
    import com.soecode.lyf.exception.NoNumberException;
    import com.soecode.lyf.exception.RepeatAppointException;
    import com.soecode.lyf.service.BookService;
    
    @Service
    public class BookServiceImpl implements BookService {
    
    	private Logger logger = LoggerFactory.getLogger(this.getClass());
    
    	// 注入Service依赖
    	@Autowired
    	private BookDao bookDao;
    
    	@Autowired
    	private AppointmentDao appointmentDao;
    
    
    	@Override
    	public Book getById(long bookId) {
    		return bookDao.queryById(bookId);
    	}
    
    	@Override
    	public List<Book> getList() {
    		return bookDao.queryAll(0, 1000);
    	}
    
    	@Override
    	@Transactional
    	/**
    	 * 使用注解控制事务方法的优点: 1.开发团队达成一致约定,明确标注事务方法的编程风格
    	 * 2.保证事务方法的执行时间尽可能短,不要穿插其他网络操作,RPC/HTTP请求或者剥离到事务方法外部
    	 * 3.不是所有的方法都需要事务,如只有一条修改操作,只读操作不需要事务控制
    	 */
    	public AppointExecution appoint(long bookId, long studentId) {
    		try {
    			// 减库存
    			int update = bookDao.reduceNumber(bookId);
    			if (update <= 0) {// 库存不足
    				//return new AppointExecution(bookId, AppointStateEnum.NO_NUMBER);//错误写法				
    				throw new NoNumberException("no number");
    			} else {
    				// 执行预约操作
    				int insert = appointmentDao.insertAppointment(bookId, studentId);
    				if (insert <= 0) {// 重复预约
    					//return new AppointExecution(bookId, AppointStateEnum.REPEAT_APPOINT);//错误写法
    					throw new RepeatAppointException("repeat appoint");
    				} else {// 预约成功
    					Appointment appointment = appointmentDao.queryByKeyWithBook(bookId, studentId);
    					return new AppointExecution(bookId, AppointStateEnum.SUCCESS, appointment);
    				}
    			}
    		// 要先于catch Exception异常前先catch住再抛出,不然自定义的异常也会被转换为AppointException,导致控制层无法具体识别是哪个异常
    		} catch (NoNumberException e1) {
    			throw e1;
    		} catch (RepeatAppointException e2) {
    			throw e2;
    		} catch (Exception e) {
    			logger.error(e.getMessage(), e);
    			// 所有编译期异常转换为运行期异常
    			//return new AppointExecution(bookId, AppointStateEnum.INNER_ERROR);//错误写法
    			throw new AppointException("appoint inner error:" + e.getMessage());
    		}
    	}
    
    }
    
    

    下面我们来测试一下我们的业务代码吧~因为查询图书的业务不复杂,所以这里只演示我们最重要的预约图书业务!!

    BookServiceImplTest.java

    package com.soecode.lyf.service.impl;
    
    import static org.junit.Assert.fail;
    
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.soecode.lyf.BaseTest;
    import com.soecode.lyf.dto.AppointExecution;
    import com.soecode.lyf.service.BookService;
    
    public class BookServiceImplTest extends BaseTest {
    
    	@Autowired
    	private BookService bookService;
    
    	@Test
    	public void testAppoint() throws Exception {
    		long bookId = 1001;
    		long studentId = 12345678910L;
    		AppointExecution execution = bookService.appoint(bookId, studentId);
    		System.out.println(execution);
    	}
    
    }
    
    

    BookServiceImplTest测试结果

    testAppointtestAppoint

    首次执行是“预约成功”,如果再次执行的话,应该会出现“重复预约”,哈哈,我们所有的后台代码都通过单元测试啦~~是不是很开心~


    咱们还需要在dto包里新建一个封装json返回结果的类Result.java,设计成泛型。

    Result.java

    package com.soecode.lyf.dto;
    
    /**
     * 封装json对象,所有返回结果都使用它
     */
    public class Result<T> {
    
    	private boolean success;// 是否成功标志
    
    	private T data;// 成功时返回的数据
    
    	private String error;// 错误信息
    
    	public Result() {
    	}
    
    	// 成功时的构造器
    	public Result(boolean success, T data) {
    		this.success = success;
    		this.data = data;
    	}
    
    	// 错误时的构造器
    	public Result(boolean success, String error) {
    		this.success = success;
    		this.error = error;
    	}
    
    	// 省略getter和setter方法
    }
    
    

    最后,我们写web层,也就是controller,我们在web包下新建BookController.java文件。

    BookController.java

    package com.soecode.lyf.web;
    
    import java.util.List;
    
    import org.apache.ibatis.annotations.Param;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import com.soecode.lyf.dto.AppointExecution;
    import com.soecode.lyf.dto.Result;
    import com.soecode.lyf.entity.Book;
    import com.soecode.lyf.enums.AppointStateEnum;
    import com.soecode.lyf.exception.NoNumberException;
    import com.soecode.lyf.exception.RepeatAppointException;
    import com.soecode.lyf.service.BookService;
    
    @Controller
    @RequestMapping("/book") // url:/模块/资源/{id}/细分 /seckill/list
    public class BookController {
    
    	private Logger logger = LoggerFactory.getLogger(this.getClass());
    
    	@Autowired
    	private BookService bookService;
    
    	@RequestMapping(value = "/list", method = RequestMethod.GET)
    	private String list(Model model) {
    		List<Book> list = bookService.getList();
    		model.addAttribute("list", list);
    		// list.jsp + model = ModelAndView
    		return "list";// WEB-INF/jsp/"list".jsp
    	}
    
    	@RequestMapping(value = "/{bookId}/detail", method = RequestMethod.GET)
    	private String detail(@PathVariable("bookId") Long bookId, Model model) {
    		if (bookId == null) {
    			return "redirect:/book/list";
    		}
    		Book book = bookService.getById(bookId);
    		if (book == null) {
    			return "forward:/book/list";
    		}
    		model.addAttribute("book", book);
    		return "detail";
    	}
    
    	//ajax json
    	@RequestMapping(value = "/{bookId}/appoint", method = RequestMethod.POST, produces = {
    			"application/json; charset=utf-8" })
    	@ResponseBody
    	private Result<AppointExecution> appoint(@PathVariable("bookId") Long bookId, @RequestParam("studentId") Long studentId) {
    		if (studentId == null || studentId.equals("")) {
    			return new Result<>(false, "学号不能为空");
    		}
    		//AppointExecution execution = bookService.appoint(bookId, studentId);//错误写法,不能统一返回,要处理异常(失败)情况
    		AppointExecution execution = null;
    		try {
    			execution = bookService.appoint(bookId, studentId);
    		} catch (NoNumberException e1) {
    			execution = new AppointExecution(bookId, AppointStateEnum.NO_NUMBER);
    		} catch (RepeatAppointException e2) {
    			execution = new AppointExecution(bookId, AppointStateEnum.REPEAT_APPOINT);
    		} catch (Exception e) {
    			execution = new AppointExecution(bookId, AppointStateEnum.INNER_ERROR);
    		}
    		return new Result<AppointExecution>(true, execution);
    	}
    
    }
    
    

    因为我比较懒,所以我们就不测试controller了,好讨厌写前端,呜呜呜~

    到此,我们的SSM框架整合配置,与应用实例部分已经结束了,我把所有源码和jar包一起打包放在了我的GitHub上,需要的可以去下载,喜欢就给个star吧,这篇东西写了两个晚上也不容易啊。

    完整代码下载地址:https://github.com/liyifeng1994/ssm


    2017-02-28更新(感谢网友EchoXml发现):
    修改预约业务代码,失败时抛异常,成功时才返回结果,控制层根据捕获的异常返回相应信息给客户端,而不是业务层直接返回错误结果。上面的代码已经作了修改,而且错误示范也注释保留着,之前误人子弟了,还好有位网友前几天提出质疑,我也及时做了修改。

    2017-03-30更新(感谢网友ergeerge1建议):
    修改BookController几处错误
    1.detail方法不是返回json的,故不用加@ResponseBody注解
    2.appoint方法应该加上@ResponseBody注解
    3.另外studentId参数注解应该是@RequestParam
    4.至于controller测试,测试appoint方法可不必写jsp,用curl就行,比如
    curl -H “Accept: application/json; charset=utf-8” -d “studentId=1234567890” localhost:8080/book/1003/appoint

    展开全文
  • 图像分割综述

    万次阅读 多人点赞 2019-07-09 22:03:48
    其中R代表整个正方形图像区域,P代表逻辑。 区域分裂合并算法优缺点: (1)对复杂图像分割效果好; (2)算法复杂,计算量大; (3)分裂有可能破怪区域的边界。 在实际应用当中通常将区域生长算法和区域...
  • 进场之后先去抽号,根据你抽到的题目内容进行一个两分钟的准备,我们组3个话题主要包括: (1)出国留学;(2)90后跳槽现象;(3)对企业加班的看法。 问了一下别的同学,好像还有一些话题包括: 1、沉迷网络...
  • 离散数学在计算机科学中的应用

    万次阅读 多人点赞 2018-02-03 11:56:44
    自从我们学院进行软件 工程认证后,期末考试的专业课全部是大题。这次离散数学的最后一题是:利用本...数据结构研究的主要内容是数据的逻辑结构,物理存储结构以及基本运算操作。其中逻辑结构和基本运算操作来源于离散
  • 软件测试面试题汇总

    万次阅读 多人点赞 2018-09-27 12:31:09
    33、集成测试也叫组装测试或者联合测试,请简述集成测试的主要内容? .............................................. 10 34、简述集成测试与系统测试关系? ....................................................
  • HTML学习

    千次阅读 多人点赞 2016-10-08 17:31:27
    元素的内容是开始标签与结束标签之间的内容 某些 HTML 元素具有空内容(empty content) 空元素在开始标签中进行关闭(以开始标签的结束而结束) 大多数 HTML 元素可拥有属性 嵌套的 HTML 元素 大多数 ...
  • 向量算法

    千次阅读 2019-06-05 22:31:07
    https://www.cnblogs.com/the-wolf-sky/articles/10192363.html...基于神经网络的表示一般称为向量、嵌入(word embdding)或分布式表示。 神经网络的向量和其他分布式类似,都基于分布式表达方式,核心依然是上...
  • 分布式服务框架

    千次阅读 2016-01-29 10:42:11
    memcache 存储支持的数据格式也是灵活多样的,通过对象的序列化机制,可以将更高层抽象的对象转换成为二进制数据,存储在缓存服务器中,当前端应用需要时,又可以通过二进制内容反序列化,将数据还原成原有对象。...
  • 常用Linux命令小结

    千次阅读 2013-06-01 15:47:32
    head file 显示文件头的内容,默认显示10行,加 -n 可以显示指定的行数;tailfile 显示文件尾的内容,默认显示10行,加 -n 可以显示指定的行数;如:tail -n 20 file 显示文件后20行。 4.3. more|less more ...
  • If 的替代词汇:unless、in case..._60

    千次阅读 2019-03-20 07:46:16
    想丰富、快捷的看到所有英语语法内容,使用 "微信扫一扫" 下面二维码 , “关注”  微信公众号 (e点小干货)。 每天推送 一文章,从 入门 -> 初级 -> 中级 -> 高级 -> 商务   的顺序,让你快乐、轻松、...
  • 【JAVA面试】java面试题整理(3)

    千次阅读 2018-10-28 12:50:13
    ♣ Class文件的常量池用于存放编译期生成的各种字面量和符号引用,这部分内容将在类加载后存放在运行时常量池中 ♣ 还把翻译出来的直接引用也放在运行时常量池中,运行时产生的常量也放在里面       ...
  • JSON文档存储(放入的内容就是取出的内容) 文件到期 派生的文本字段(从文字字段列表构建) 派生的布尔字段 Spredis不是什么Spredis不是关系/文档数据库,也不打算替代它。 当与您当前的数据库引擎(关系或文档...
  • 本文部分内容源自清华大学计算机系在读博士岂凡超在AI科技评论发布的:话到嘴边却忘了?这个模型能帮你 | AAAI 2020。会议之眼参考论文对模型框架、背景知识以及数据来源、评测部分进行了补充。 岂凡超 论文...
  • 一个平面进度条视图,作为 UIProgressView 的替代品。 目前支持: 所有四个方向 - 从左到右、从右到左、从上到下、从下到上。 (水平和垂直) 轨道颜色 进度颜色 可设计视图(Interface Builder 中的预览) 我 ...
  • 心理辅导平台设计

    千次阅读 2017-12-04 10:22:57
    |工具风险 |软件项目开发和实施过程,所必须用到的管理工具、开发工具、测试工具未能及时到位 |在项目的启动阶段就落实好各项工具的来源或可能的替代工具,在这些工具需要使用之前跟踪并落实工具的到位事宜。...
  • 替代废除iframe方案

    万次阅读 2016-03-13 15:33:31
    ),不不,不是这个,是另一个,以 sh 开头,以 y 结尾。(注:对英文语境不是太熟悉,评论中有人提到是  shy 。)对对,就是它!我可以继续说,但是请相信我对 SVG shadow DOM 的评价。或者你可以查看文档。...
  • 测试Node require方法的替代品,请参阅 小字 作者:Gleb Bahmutov:copyright:2014 许可证:麻省理工学院-对代码执行任何操作,但是如果不起作用,请不要怪我。 传播这个:tweet,在github上加星号,等等。 支持...
  • 屏蔽功能实现

    千次阅读 2013-11-20 23:27:26
    自己当时想过用字符串去替代的方式(replaceAll)去实现,但是这种效率又非常低,也不能保证最长匹配,这就是自己当时最初的想法。最近自己做的一个项目中,需要对一些内容做屏蔽,自己又对这个问题做了一次分析,...
  • 在近几年来,人工智能这个越来越火了,人工智能(Artificial Intelligence),英文缩写为AI。毕竟现在是数字化,信息化的时代,人工智能越来越流行,越来越先进也是无可厚非的,但是现阶段,人工智能的发展还是...
  •  将用“向量”的方式表示可谓是将 Deep Learning 算法引入 NLP 领域的一个核心技术。大多数宣称用了 Deep Learning 的论文,其中往往也用了向量。 本文目录: 0. 向量是什么 1. 向量的来历...
  • 古典密码的其他内容 多字母表替代和Vigenere密码 多字母表替代中,将密码分为t组,即每一组的长度为t,共使用t张表,那么相同的字母在不同位置的替换将会不同。凯撒密码相当于只使用了一张表。 Vigenere密码: 定义...
  • 目前,向量(又叫嵌入word embedding)已经成为NLP领域各种任务的必备一步,而且随着bert elmo,gpt等预训练模型的发展,向量演变为知识表示方法,但其本质思想不变。学习各种向量训练原理可以很好地掌握NLP...
  • 嵌入算法

    千次阅读 2018-08-27 01:06:42
    基于神经网络的表示一般称为向量、嵌入(word embdding)或分布式表示。 神经网络的向量和其他分布式类似,都基于分布式表达方式,核心依然是上下文的表示以及上下文与目标之间的关系映射。主要通过神经网络...
  •  也许百分之八九十的人没有接触过国产操作系统的人,脑海里都会不由自主浮现出“界面不友好”、“功能不完善”、“土土的“等形容。那你有没有想过,也许它是这样的:  或是这样的:  这个清爽、...
  • 此板条箱不对任何内容使用文字静态变量(但提供了多种将staticVec实例化为static或const的方法。变量(如果需要)。 通过为staticvec依赖项设置default-features = false,完全兼容#![no_std](几乎没有功能损失)
  • 用Transformer完全替代CNN?

    千次阅读 2020-10-24 14:03:00
    Transformer encoder Transformer Encoder结构和NLP中transformer结构基本上相同,所以这里只给出其结构图,和公式化的计算过程,也是顺便用公式表达了之前所说的几个部分内容。 Transformer Encoder的结构如下图所...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,084
精华内容 23,233
关键字:

内容的替代词