1. Maven 概述

Maven 不仅内置了以来管理，更有一个拥有庞大 Java 开源软件包的中央仓库

• Maven 生命周期

  Maven 主要有三种内置的生命周期，每个生命周期，都有自己的一个或一系列的阶段

  • clean 用于清理 Maven 产生的文件和文件夹，包含一个 clean 阶段
  • site 用于处理项目文档的创建，包含一个 site 阶段，该阶段会生成项目的文档
  • default 用于处理项目的构建和部署。以下时 default 生命周期所包含的主要阶段
    • validate 该阶段用于验证所有项目的信息是否可用和正确
    • process-resources 该阶段复制项目到发布包的位置
    • compile 该阶段用于编译源码
    • test 该阶段结合框架执行特定的单元测试
    • package 该阶段按照特定发布包的格式来打包编译后的源码
    • integration-test 该阶段用于处理集成测试环境中的发布包
    • verify 该阶段运行校验发布包是否可用
    • install 该阶段安装发布包到本地库
    • deploy 该阶段安装最终的发布包到配置的库

  在实际使用中，开发人员无需明确指定生命周期。相反只需要指定一个阶段，Maven 会根据指定的阶段来推测生命周期。例如。当 Maven 以 package 为运行参数时，default 生命周期都会得到执行。Maven 会按顺序运行所有阶段

  每个阶段都由插件目标（goal）组成，插件目标是构建项目的特定任务

  一些目标旨在特定阶段才有意义。例如，在 Maven 的 compile 目标中，Maven Compiler 插件在 compile 阶段是有意义的，而 Maven Checkstyle 插件的 checkstyle 目标可以会在任何阶段运行

  Maven 的阶段、插件和目标的对应关系

  

2. 依赖管理

• 在 Java 中，可以用 groupId 、artifactId、version 组成的 Coordination（坐标）唯一表示一个依赖

• 任何基于 Maven 构建的项目本身也必须定义这 3 项，生成的包可以是 jar 包，也可以是 war 包或 ear 包

• 依赖管理中，一个非常重要的概念 scope (范围)。 Maven 有以下 6 种不同的 scope

  1. compile 默认就是 compile，它就表示被依赖项目需要参与当前项目的编译，后续的测试、运行周期也参与其中。打包时通常需要包含进去

  2. test 该类依赖项目仅参与测试相关的工作，包括测试代码的编译、执行。一般不需要这种类型的依赖

  3. runtime 表示被依赖项目无需参与项目的编译，不过后期的测试和运行周期需要其参与。典型实例为 logback，如果希望使用 Simple Logging Facade for Java (slf4j) 来记录日志，可以使用 logback 绑定

  4. provided 该类依赖只参与编译和运行，但并不需要在发布时打包进发布包。典型示例为 servlet-api，该类依赖通常由应用服务来提供

  5. system 从参与角度来说，与 provided 相同，不过被依赖项不会从 Maven 仓库获取，而是从本地文件系统获取，所以一定要配合 systemPath 属性使用

     1 2 3 4 5 6 7

     <dependency> <groupId>com.arcsoft.face</groupId> <artifactId>arcsoft-sdk-face</artifactId> <version>3.0.0.0</version> <scope>system</scope> <systemPath>${basedir}/lib/arcsoft-sdk-face-3.0.0.0.jar</systemPath> </dependency>

  6. import 仅用于依赖关系管理部分中 pom 类型的依赖。import 表示指定的 pom 应该被替换为该 pom 的 dependencyManagement 部分中的依赖关系。为了集中大型多模块项目的依赖关系

3. 多模块构建

Maven 支持多模块构建。将一个大型软件产品划分为多个模块来进行开发，从而实现软件项目的 “高内聚、低耦合”

Maven 的多模块构建是通过一个名称为项目继承（project inheritance）的功能来实现的，它允许将一些需要继承的元素，在父模块的 pom 文件中进行指定

多模块项目包含一个父模块及多个子模块

Gradle 概述

Gradle 是一个基于 Ant 和 Maven 概念的项目自动化构建工具

使用一种基于 Groovy 的特定领域语言（DSL）来声明项目设置，抛弃了传统的基于 XML 的各种繁琐配置

1. Gradle 生命周期

• Gradle 是基于编程语言的，开发人员可以自己定义任务（task）和任务之间的依赖，Gradle 会确保由顺序的去执行这些任务及依赖任务，并且每个任务只执行一次
• Gradle 构建主要有以下三个不同的阶段
  1. 初始化阶段（Initialization）
     • Gradle 支持单个和多个项目的构建。Gradle 在初始化阶段决定哪些项目（project）参与构建，并且为每个项目创建一个 Project 类的实体对象
  2. 配置阶段（Configuration）
     • 在这个阶段配置每个 Project 的实例对象，然后执行这些项目脚本中的一部分任务
  3. 执行阶段（Execution）
     • Gradle 确定任务的子集，在配置界面创建和配置这些任务，然后执行任务
     • 这些子集任务的名称被当作参数传递给 Gradle 命令和当前目录，然后，Gradle 执行每一个选择的任务

2. 依赖管理

一个项目的依赖会包含自己的依赖。例如，Spring 的核心需要几个其他包在类路径中存在才能运行

• Gradle 声明依赖的例子

  1 2 3 4 5 6 7 8

  apply plugin: 'java' repositores { mavenCentral() } dependencies { compole group: 'org.hebernate', name: 'hibernate-core', version: '3.6.7.Final' testCompile group: 'junit', name: 'junit', version:'4.+' }

  • 声明了使用了 Java 插件
  • Gradle 依赖要在 Maven 中央仓库找
  • 需要 Hibernate core 3.6.7.Final 版本来编译，Hibernate core 和它的依赖在运行时是需要的
  • 需要 junit >= 4.0版本，并在测试时编译

• Java 插件为 Gardle 添加的依赖关系和配置

  

• Gradle 依赖配置图

  

Redis基础数据结构

Redis 有 5 种基础数据结构，分别为：string (字符串)、list (列表)、set (集合)、hash (哈希) 和 zset (有序集合)

Redis 所有的数据结构都是以唯一的 key 字符串作为名称，然后通过这个唯一 key 值来获取相应的 value 数据

不同类型的数据结构的差异在于 value 的结构不一样

string (字符串)

字符串 string 是 Redis 最简单得数据结构

字符串结构使用非常广泛，一个常见的用途就是缓存用户信息

​ 将用户信息结构体使用 JSON 序列化成字符串，然后将序列化后的字符串塞进 Redis 来缓存

​ 取用户信息会经过一次反序列化的过程

Redis 的字符串是动态字符串，是可以修改的字符串，内部结构实现类似于 Java 的 ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配，当字符串长度小于 1M 时，扩容都是加倍现有的空间，如果超过 1M，扩容时一次只会多扩容 1M 的空间

字符串是由多个字节组成，每个字节又是由 8 个 bit 组成

字符串最大长度为 512M

键值对

1
2
3
4
5
6
7
8

> set name codehole ## 添加
ok
> get name ## 获取
"codehole"
> exists name ## 判断是否存在
(integer) 1
> del name ## 删除
(integer) 1

批量键值对

可以批量对多个字符串进行读写，节省网络耗时开销

1
2
3
4
5
6

> mset name1 boy name2 girl name3 unknown ## 批量添加
ok
> mget name1 name2 name3 ## 批量删除
1) "boy"
2) "girl"
3) "unknown"

过期时间和 set 命令扩展

可以对 key 设置过期时间，到点自动删除，这个功能常用来控制缓存的失效时间

1
2
3

> expire name 5 ## 设置 5s 后自动删除
> setex name 5 codehole ## 添加数据 并设置5s后自动删除，等价于 set+expire
> setnx name codehole # 如果 name 不存在就执行 set 创建

计数

如果 value 值是一个整数，还可以对它进行自增操作

自增范围 signed long 的最大最小值

1
2
3
4
5
6
7
8
9

> set age 30
ok
> incr age ## 自增 1
(integer) 31
> incrby age 5 ## 增加 5
(integer) 36
> incrby age -5 ## 减少 5
(integer) 31

List (列表)

Redis 的列表相当于 Java 语言里的 LinkedList，它是链表而不是数组。意味着 list 的插入和删除操作非常快，时间复杂度为 O(1)，但索引定位很慢，时间复杂度为 O(n)

当列表弹出了最后一个元素之后，该数据结构自动被删除，内存被回收

Redis 的列表结构常用来做异步队列使用；将需要延后处理的任务结构体序列化成字符串塞进 Redis 的列表，另一个线程从这个列表中轮训数据进行处理

右边进左边出：队列

1
2
3
4
5
6

> rpush books python java golang ## 添加至列表
(integer) 3
> llen books ## 查看列表长度
(integer) 3
> lpop books ## 弹出最先进入的那一个
"Python"

右边进右边出：栈

1
2
3
4

> rpush books python java golang ## 添加至列表
(integer) 3
> rpop books ## 弹出最后进入那一个
"golang"

慢操作

lindex 相当于 Java 链表中的 get(int index)方法，他需要对链表进行遍历，性能随着参数 index 增大而变差

ltrim 保留区间，它需要跟两个参数 start_index和end_index定义了一个区间，在这个区间的值保留，区间之外的统统砍掉。可以通过 itrim 来实现一个定长的链表

index 可以为负数，index=-1表示倒数第一个元素

1
2
3
4
5
6
7
8
9

> rpush books python java golang
> lindex books 1 ## 时间复杂度为 O(n) 慎用
"java"
> lrange books 0 -1 ## 获取所有的元素，时间复杂度为 O(n) 慎用
1) "Python"
2) "java"
3) "golang"
> ltrim books 1 -1  ## 时间复杂度为 O(n) 慎用 返回一个定长列表
> ltrim books 1 0 ## 清空整个列表，因为区间范围长度为负数

快速列表

Redis 的 List 底层是由快速链表quicklist 的结构实现的

在列表元素较小的时候会使用一块连续的内存存储，这个结构是压缩列表 ziplist 它将所有的元素紧挨着一起存储。

当数据量比较大的时候会改成quicklist，因为普通的链表需要附加指针空间太大，会比较浪费空间，而且会加重内存的碎片化。所以 Redis 将链表和ziplist结合起来组成了quicklist，将多个 ziplist 使用双指针串起来使用

hash(字典)

Redis 的字典相当于 Java 语言中的 HashMap，它是无序字典。内部实现结构与 Java 中的 HashMap 一样，都是使用 数组 + 链表二维结构。第一维 hash 的数组位置碰撞时，会讲碰撞的元素使用链表串接起来

不同的是 Redis 的字典的值只能是字符串，另外它们的 rehash 的方式不一样，Java 的 HashMap 在字典很大时，rehash 是个耗时的操作，需要一次性全部 rehash，而 Redis 采用了渐进式 rehash 策略

渐进式 rehash 会在 rehash 的同时，保留新旧两个 hash 结构，查询时会同时查询两个 hash 结构，然后在后续的定时任务中以及 hash 操作指令中，循序渐进地将旧 hash 的内容一点点迁移到新的 hash 结构中，当迁移完成后，就会使用新的 hash 结构取而代之

当 hash 移除了最后一个元素之后，改数据结构自动被删除，内存被回收

hash 结构的存储消耗要高于单个字符串

hash 结构中的单个子 key 也可以进行计数

1
2
3
4
5
6
7
8

> hset books java "think in java" ## 添加   命令行的字符串如果包含空格，要用引号扩起来
(integer) 1
> hgetaall books ## 获取 books 字典中的所有数据
> hlen books ## 获取 books 的长度
> hget books java ## 查询指定 field
> hset book java "effective java" ## 相同 field 会覆盖，所以是更新操作
> hmset books java "think in java" python "learning python" id 1 ## 批量添加操作
> hincrby books id 1 ## 计数

set (集合)

Redis 的集合相当于 Java 的 HashSet，它内部的键值对是无序的唯一的，它的内部实现相当于一个特殊的字典，字典中所有的 value 都是一个值 NULL

当集合中最后一个元素移除之后，数据结构自动删除，内存被回收

set 结构可以用来存储活动中将的用户 ID，因为有去重功能，可以保证同一用户不会中将两次

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

> sadd books python ## 添加
(integer) 1
> sadd books python ## 重复 会覆盖之前的数据
(integer) 0
> sadd books java golang ## 批量添加
(integer) 2
> sismember books java ## 查询某个 value 是否存在
(integer) 1
> scard books ## 查询集合的长度
(integer) 3
> spop books ## 弹出一个元素 随机弹出
"java" 

hset (有序集合)

hset 结构类似于 Java 的 SortedSet 和 HashMap 的结合体，一方面它是一个 set，保证了内部 value 的唯一性，另一方面它可以给每个 value 赋予一个 score，代表这个 value 的排序权重

hset 内部实现用的是一种叫做「跳跃列表」的数据结构

当有序集合最后一个 value 被移除后，数据结构自动删除，内存被回收

zset 可以用来存粉丝列表，value 值是粉丝的用户 ID，score 是关注时间。我们可以对粉丝列表按关注时间进行排序

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

> zadd books 9.0 "think in java" ## 添加
(integer) 1
> zadd books 8.9 "java concurrency"
(integer) 1
> zadd books 8.6 "java cookbook"
(integer) 1
> zrange books 0 -1 ## 按 score 顺序排序，参数区间为排列范围
1) "java cookbook"
2) "java concurrency"
3) "think in java"
> zrevrange books 0 -1 ## 按 score 倒序排列，参数区间为排列范围
1) "think in java"
2) "java concurrency"
3) "java cookbook"
> zcard books ## 获取 元素数量
(integer) 3
> zscore books "java cookbook" ## 获取指定 value 的 score
"8.9000000000000004"  ## 内部 score 使用 double 类型进行存储，所以存在小数点精度问题
> zrank books "java cookbook" ## 获取指定 value 的排名
> zrangebyscore books 0 8.91 ## 根据分值区间遍历 zset
> zrangebyscore books -inf 8.91 withscores # 根据分值区间 (-∞, 8.91] 遍历 zset，同时返回分值。inf 代表 infinite，无穷大的意思。
> zrem books "java concurrency"  # 删除 value

跳跃列表

zset 内部的排序功能是通过「跳跃列表」数据结构来实现的，它的结构非常特殊，也比较复杂

一个创业公司，刚开始只有几个人，团队成员之间人人平等，都是联合创始人。随着公司的成长，人数渐渐变多，团队沟通成本随之增加。这时候就会引入组长制，对团队进行划分。每个团队会有一个组长。开会的时候分团队进行，多个组长之间还会有自己的会议安排。公司规模进一步扩展，需要再增加一个层级 —— 部门，每个部门会从组长列表中推选出一个代表来作为部长。部长们之间还会有自己的高层会议安排。

跳跃列表类似于上面的层级制，最下面一层所有的元素都会串起来，然后每隔几个元素挑选出一个代表来，再将这几个代表使用另外一级指针串起来。然后在这些代表里再挑选出二级代表，再串起来。最终就形成了金字塔结构

跳跃列表之所以跳跃，是因为内部的元素可能身兼数职，比如上图中间的元素，同时处于 L0、L1 和 L2层，可以快速再不同层次之间进行跳跃

定位插入点时，现在顶层进行定位，然后下潜到下一层定位，一直下潜到最底层找到合适的位置，将新元素插进去

跳跃列表采取一个随机策略来决定新元素可以兼职到第几层

首先 L0 层兼职机率是 100%，L1 层只有 50% 的机率，L2 层只有 25% 的机率，L3 层只有 12.5% 机率，一直随机到最顶层 L31层

容器型数据结构的通用规则

list/set/hash/zset 这四种数据结构是容器型数据结构，它们共享下面两条通用规则：

1. create if not exists

   如果容器不存在，那就创建一个，再进行操作。

2. drop if no elements

   如果容器里元素没有了，那么立即删除元素，释放内存

过期时间

Redis 所有的数据结构都可以设置过期时间，时间到了，Redis 会自动删除相应的对象

过期是以对象为单位，比如一个 hash 结构的过期是整个 hash 对象的过期，而不是其中的某个子key

如果一个对象已经设置了过期时间，然后再次修改了它，那么它的过期时间会消失

高可用集群模式

• redis 集群时一个由多个主从节点群组组成的分布式服务器群，它具有复制、高可用和分片特性
• 该集群模式没有中心节点，可水平扩展，并且性能和高可用性都优于哨兵模式
• redis 3.2之后采用该模式

安装

官方下载地址：点击

1. 安装编译环境

   1	yum install gcc -y

2. 下载安装包，并复制到/usr/local/目录下

   1 2 3 4 5

   wget -p /usr/local/ http://download.redis.io/releases/redis-5.0.8.tar.gz #下载 cd /usr/local #切换至下载文件所在目录 tar -zxvf redis-5.0.8.tar.gz #解压 mv redis-5.0.8 redis cd redis #进入redis目录

3. 编译安装

   1	make & make install #编译并安装

4. 单机启动测试

   1 2 3 4 5 6 7

   src/redis-server redis.conf #启动 # 新启动一个窗口 src/redis-cli #连接redis set name testName > ok get name > testName

5. 结束redis服务

   1 2 3 4 5

   pkill redis-server kill -9 进程号 src/redis-cli shutdown

集群方式搭建

• redis 集群至少需要三个 master 节点，并且每个 master 节点需要至少一个 slave 节点，所以至少需要六个节点
• 以下方式是在一台服务器上搭建集群，也就是伪集群，实际环境大同小异

1. 创建六个节点需要的目录，用于存放数据和配置文件

   1	mkdir -p /usr/local/redis-cluster/{8001|8002|8003|8004|8005|8006}

2. 将 redis 主目录中的配置文件复制到 8001 目录下，并开始集群配置

   1 2 3

   cp /usr/local/redis/redis.conf /usr/local/redis-cluster/8001 cd /usr/local/redis-cluster/8001 vim redis.conf

   • daemonize yes 允许后台运行
   • port 8001 端口号，分别对应所在的目录
   • dir /usr/local/redis-cluster/8001 指定数据文件的存储位置，这里需要根据配置文件所在文字不同而不同
   • cluster-enabled yes 开启集群模式
   • cluster-config-file nodes-8001.conf 集群节点信息，800x部分最好于端口名相同，以便区分
   • cluster-node-timeout 5000 节点心跳超时时间 以毫秒为单位
   • # bind 127.0.0.1 注释掉IP绑定，这样所有的网卡都可以接收数据
   • protected-mode no 关闭保护模式
   • appendonly yes

   如果要设置密码需要增加以下配置

   • requirepass xxx 设置 redis 访问密码
   • masterauth xxx 设置集群节点间访问密码，建议与上面一致

3. 将修改好的 redis.conf 文件复制到 8002-8006 目录中，并修改包含8001的位置

   1 2 3 4

   cp /usr/local/redis-cluster/8001/redis.conf /usr/local/redis-cluster/8002/ #复制配置文件 ....... vim /usr/local/redis-cluster/8002/redis.conf #打开 8002-8006 目录下的配置文件 :%s/8001/8002/g #使用vim的替换功能将 8001 替换成 8002-8006 成功会显示替换的地方有三处

4. 启动所有的实例,并检查是否启动成功

   1 2 3 4 5

   /usr/local/redis/src/redis-server /usr/local/redis-cluster/8001/redis.conf /usr/local/redis/src/redis-server /usr/local/redis-cluster/8002/redis.conf ...... ps -ef | grep redis

   

5. 使用 redis-cli 创建 redis 集群

   1	/usr/local/redis/src/redis-cli -a xxx --cluster create --cluster-replicas 1 192.168.1.5:8001 192.168.1.5:8002 192.168.1.5:8003 192.168.1.5:8004 192.168.1.5:8005 192.168.1.5:8005

   • -a 参数是指上面配置的集群密码
   • --cluster create 表示创建集群
   • --cluster-replicas 表示每个 master 需要多少个 slave
   • 192.168.1.5 这里的IP地址最好指定对外可访问的地址，以便远程连接可自动切换

6. 验证集群

   1	/usr/local/redis/src/redis-cli -c -a xxx -h 192.168.1.5 -p 8001

   • -a 表示访问密码
   • -c 表示访问方式为集群

   1 2	cluster info #查看集群信息 cluster nodes #查看节点列表和状态

7. 关闭集群，关闭时需要一个一个的关闭

   1	/usr/local/redis/src/redis-cli -c -a xxx -h 192.168.1.5 -p 8001 shutdown

环境准备

• CentOS Linux release 7.3.1611 (Core)
• Oracle Database 12c Enterprise Edition Release 12.2.0.1.0 - 64bit Production

思路

• 三台安装 Oracle 的 CentOS 7.3 服务器，每台数据库服务器，存储着不同的数据库
• 利用 Oracle 的 Expdp 将数据导出来
• 利用 SCP 将导出来的数据库备份文件传送到其他两台服务器上，避免单点问题
• 将上面的步骤写成 Shell 脚本，利用 Crontab定时执行
• 为了避免备份文件撑爆硬盘，通过Shell 脚本定时删除备份文件
• 通过 impdp 恢复数据

备份策略

• 每周一凌晨三点执行全量备份任务
• 每月一号凌晨三点执行清理上上个月备份文件

开始部署

• 配置 Oracle 导入导出目录权限

  1 2 3 4 5 6

  su - oracle #切换Oracle账户 mkdir ~/backup_dir #创建导出文件存放目录 sqlplus / as sysdba #以DBA的身份登录Oracle create directory dir_dp as '/home/oracle/backup_dir'; #创建导入导出目录 create or replace directory dir_dp as '/home/oracle/backup_dir'; #修改导入导出目录 需要的话执行 grant read,write on directory dir_dp to chenlil; #授权 chenlil 用户对该目录

• 开始导出数据

  1	expdp chenlil/123456 schemas=chenlil DIRECTORY=dir_dp CONTENT=all compression=ALL DUMPFILE=chenlil.dmp logfile=chenlil.log

  • chenlil/123456 导出所需的用户名和密码 与上面授权的一致
  • schemas=chenlil 导出库的名称
  • DIRECTORY=dir_dp 导出的目录名 与上面配置的一致
  • DUMPFILE=chenlil.dmp 导出文件的名称
  • logfile=chenlil.log 导出日志的名称

• 生成导出脚本

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

  #!/bin/bash source ~/.bash_profile #刷新配置文件 scpip=(192.168.1.15 192.168.1.16) #备份的服务器IP tmp=/home/oracle/backup_dir/ #备份文件存放目录 dir=/home/oracle/global_back_dmp/ #全局同步文件存放目录 dmpfile=`date +_%Y%m%d`.dmp #根据当前年月日生成的备份文件名 dumplog=`date +_%Y%m%d`.log #根据当前年月日生成的备份日志文件名 username=chenlil #导出所需的用户名 password=123456 #导出所需的密码 schemas=(chenlil chenlil1 chenlil2 chenlil3) #需要导出的库 #清除之前的备份 rm -f ${tmp}* #备份过程 for s in ${schemas[@]} do expdp ${username}/${password} schemas=$s DIRECTORY=dir_dp CONTENT=all compression=ALL DUMPFILE=$s${dmpfile} logfile=$s${dumplog} done #同步本地 cp ${tmp}* ${dir} #远程传输 for ip in ${scpip[@]} do scp ${tmp}*${dmpfile} oracle@$ip:${dir} scp ${tmp}*${dumplog} oracle@$ip:${dir} done

• 添加定时任务—-每周一早上三点执行一下脚本

  1 2 3 4

  crontab -e #编辑定时任务 # 每周一早上三点 执行全量备份任务 SHELL=/bin/bash 0 3 * * 1 cd /home/oracle/cron/ && ./oracle_backup.sh

• 生成删除上上个月的备份文件脚本

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

  #!/bin/sh dir=/home/oracle/global_back_dmp/ nowdate=`date +%Y%m01` #本月第一天 startdate=`date -d"$nowdate last month last month" +%Y%m%d` #上上个月第一天 enddate=`date -d"$nowdate last month last day" +%Y%m%d` #上上个月最后一天 #遍历上上个月的每一天 while (( $startdate <= $enddate )) do #echo $startdate find $dir -type f -name "*${startdate}*" -ls >> ~/del_file_list.txt find $dir -type f -name "*${startdate}*" -exec rm -f {} \; startdate=`date -d "+1 day $startdate" +%Y%m%d` done

• 添加定时任务—-每月一号执行一下清理脚本

  1 2	# 每个月一号早上三点 执行清除上个月备份文件 0 3 1 * * cd /home/oracle/cron/ && ./del_backup.sh

数据恢复

• 准备工作

  • 同导出一样配置 Oracle 导入导出目录权限
  • 将备份文件拷被至导入导出文件夹

• 执行命令

  1	impdp chenlil/123456 schemas=chenlili dumpfile=chenlil_20200319.dmp logfile=impdp_chenlil_20200319.log directory=dir_dp

  • chenlil/123456 导入数据账号和密码
  • schemas=chenlili 导入的库名称
  • dumpfile=chenlil_20200319.dmp 导入的备份文件名称
  • logfile=impdp_chenlil_20200319.log 导入过程的日志文件名
  • directory=dir_dp 导入文件的文件名

crontab 是用来定期执行程序的命令

当系统安装完成之后，默认就会启动次任务调度命令

crond 服务会每分钟去检查是否有工作需要执行，如果有则会立即执行

语法

1

crontab [ -u user ] file

或

1

crontab [ -u user ] { -l | -r | -e}

说明

-u user 是指设定 user 用户的时程表，必须要有设置他人时程表的权限，比如 root 就能设置所有人的；如果不带此参数 则设置自己的时程表

参数说明

-e 执行文字编辑器来设定时程表，默认时vi

-r 删除目前所有的时程

-l 列出目前的时程

时间格式说明

1
2
3
4
5
6
7
8

*    *    *    *    *
-    -    -    -    -
|    |    |    |    |
|    |    |    |    +----- 星期中星期几 (0 - 7) (星期天 为0)
|    |    |    +---------- 月份 (1 - 12) 
|    |    +--------------- 一个月中的第几天 (1 - 31)
|    +-------------------- 小时 (0 - 23)
+------------------------- 分钟 (0 - 59)

实例

1
2

SHELL=/bin/bash
0 3 * * 1 cd /home/oracle/cron/ && ./oracle_backup.sh # 每周一早上三点 执行oracle_backup.sh这个脚本

注意

当程序在你所指定的时间执行后，系统会寄一封信给你，显示该程序执行的内容，若是你不希望收到这样的信，请在每一行空一格之后加上 > /dev/null 2>&1 即可

Docker 安装完成后配置镜像加速

• 创建配置文件

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

sudo tee /etc/docker/daemon.json <<-'EOF'
{
    "registry-mirrors": ["https://docker.011025.xyz"],
    "exec-opts": [
        "native.cgroupdriver=systemd"
    ],
    "log-driver": "json-file",
    "log-opts": {
        "max-size": "100m"
    },
    "storage-driver": "overlay2"
}
EOF

• 重载System配置

1

systemctl daemon-reload

• 重启docker服务

1

systemctl restart docker

• 配置docker开机启动

1

systemctl enable docker