Wetts's blog

Stay Hungry, Stay Foolish.

0%

发表于 分类于

打开 SQL*Plus 控制台。用 sys 或者 system 登陆。然后运行： 

1
2
3
begin
  dbms_xdb.sethttpport('8088');
end;

这样就把端口设置为 8088 了。 

发表于 分类于

  • git config --global user.name "Your Name"

  • git config --global user.email "email@example.com"

  • git reflog : 查看命令历史，以便确定要回到未来的哪个版本

  • git --version: 查看Git版本

  • git config -l: 查看git所有配置项

start a working area

  • git init: 初始化一个Git仓库（Create an empty Git repository or reinitialize an existing one）
  • git clone: Clone a repository into a new directory

work on the current change

  • git add <files>: Add file contents to the index
  • git reset: 跳转版本（Reset current HEAD to the specified state）

    用HEAD表示当前版本，上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100
    用命令 git reset HEAD file 可以把暂存区的修改撤销掉（unstage），重新放回工作区

  • git rm <file>: Remove files from the working tree and from the index（用于删除一个文件）

grow, mark and tweak your common history

  • git commit: Record changes to the repository
  • git diff <file>: 查看difference，显示的格式正是Unix通用的diff格式（Show changes between commits, commit and working tree, etc）
  • git checkout: Switch branches or restore working tree files

    命令git checkout -- readme.txt意思就是，把readme.txt文件在工作区的修改全部撤销，这里有两种情况：
    一种是readme.txt自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；
    一种是readme.txt已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。
    总之，就是让这个文件回到最近一次git commit或git add时的状态。

  • git branch: List, create, or delete branches

examine the history and state

  • git status: 可以让我们时刻掌握仓库当前的状态（Show the working tree status）
  • git log: 显示从最近到最远的提交日志（Show commit logs）

    git log --pretty=oneline: 一行输出

git 结构

工作区 add 暂存区 commit 本地版本库 push 远程库

创建版本库

1
2
3
git init
git add readme.txt
git commit -m "wrote a readme file"

查看状态

1
2
git status
git diff readme.txt

回退

1
2
3
4
git log
git log --pretty=oneline #查看git版本记录
git reset --hard HEAD^
git reflog #查看git操作日志

撤销修改

1
git checkout -- readme.txt

命令git checkout -- readme.txt意思就是，把readme.txt文件在工作区的修改全部撤销，这里有两种情况：

  1. readme.txt自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；
  2. readme.txt已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。

总之，就是让这个文件回到最近一次git commit或git add时的状态。
checkout是将暂存库还原到工作区

1
git reset HEAD readme.txt

git reset命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用HEAD时，表示最新的版本。

reset是将版本库还原到暂存区

场景1：当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令 git checkout -- file。

场景2：当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令 git reset HEAD file，就回到了场景1，第二步按场景1操作。

场景3：已经提交了不合适的修改到版本库时，想要撤销本次提交，参考版本回退一节，不过前提是没有推送到远程库。

git checkout 其实是用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”。

删除

1
git rm test.txt

命令git rm用于删除一个文件。如果一个文件已经被提交到版本库，那么你永远不用担心误删，但是要小心，你只能恢复文件到最新版本，你会丢失最近一次提交后你修改的内容。

修改

每次修改，如果不add到暂存区，那就不会加入到commit中。

创建远程库

1
ssh-keygen -t rsa -C "youremail@example.com"

如果一切顺利的话，可以在用户主目录里找到.ssh目录，里面有id_rsa和id_rsa.pub两个文件，这两个就是SSH Key的秘钥对，id_rsa是私钥，不能泄露出去，id_rsa.pub是公钥，可以放心地告诉任何人

1
git remote add origin git@github.com:michaelliao/learngit.git

把上面的 michaelliao 替换成你自己的 GitHub 账户名，否则，你在本地关联的就是我的远程库，关联没有问题，但是你以后推送是推不上去的，因为你的 SSH Key 公钥不在我的账户列表中。
添加后，远程库的名字就是 origin，这是 Git 默认的叫法，也可以改成别的，但是 origin 这个名字一看就知道是远程库。

1
git push -u origin master

把本地库的内容推送到远程，用 git push 命令，实际上是把当前分支 master 推送到远程。
由于远程库是空的，我们第一次推送 master 分支时，加上了 -u 参数，Git 不但会把本地的 master 分支内容推送的远程新的 master 分支，还会把本地的 master 分支和远程的 master 分支关联起来，在以后的推送或者拉取时就可以简化命令。

1
git push origin master

场景

克隆远程库

1
git clone git@github.com:michaelliao/gitskills.git

可以加参数 --depth=1，depth 用于指定克隆深度，为 1 即表示只克隆最近一次 commit。

当add错误的时候

1
git rm -r --cached

该方法为递归删除

“add”有个“-n”，可以预览会加进哪些文件

分支

1
git branch <branch名称> <commit版本>

根据一个特定的提交创建新分支

1
git checkout -b dev

git checkout命令加上-b参数表示创建并切换，相当于以下两条命令：

  • git branch dev
  • git checkout dev
1
git branch

git branch命令会列出所有分支，当前分支前面会标一个*号

1
2
git add readme.txt
git commit -m "branch test"
1
git checkout master

切换回master分支

1
git merge dev

git merge命令用于合并指定分支到当前分支

1
git branch -d dev

删除dev分支

解决冲突

1
2
3
4
5
6
7
git checkout -b feature1
git add readme.txt
git commit -m "AND simple"
git checkout master
git add readme.txt
git commit -m "& simple"
git merge feature1

Git用<<<<<<<，=======，>>>>>>>标记出不同分支的内容，我们修改如下后保存

1
git log --graph --pretty=oneline --abbrev-commit

用带参数的 git log 也可以看到分支的合并情况

删除git远程分支

1
git push origin :test

git push [远程名] :[分支名]

git push [远程名] [本地分支]:[远程分支] 语法，如
果省略 [本地分支]，那就等于是在说“在这里提取空白然后把它变成 [远程分支]”。

删除代码库中文件

1
git rm --cached "文件路径"

不删除物理文件，仅将该文件从缓存中删除

1
git rm --f "文件路径"

将该文件从缓存中删除，还会将物理文件删除

更新代码

1
git pull origin master
1
git pull <远程主机名> <远程分支名>:<本地分支名>

比如，取回origin主机的next分支，与本地的master分支合并，需要写成下面这样。

1
git pull origin next:master

或者

1
2
git fetch origin master
git merge origin/master
  1. 从远程的origin仓库的master主分支更新最新的版本到origin/master分支上
  2. 合并内容到本地master分支

更新代码，保留生产服务器上所做的改动

1
2
3
git stash
git pull
git stash pop

将缓存区内容释放恢复

git stash apply

将当前分支的最后一次缓存的内容释放出来，但是刚才的记录还存在list中

git stash pop

将当前分支的最后一次缓存的内容释放出来，但是刚才的记录不存在list中

撤销“本地的”修改（修改了文件，没有add）

  • 场景: 一只猫从键盘上走过，无意中保存了修改，然后破坏了编辑器。不过，你还没有 commit 这些修改。你想要恢复被修改文件里的所有内容 — 就像上次 commit 的时候一模一样。

  • 方法: git checkout -- <bad filename>

  • 原理: git checkout 会把工作目录里的文件修改到 Git 之前记录的某个状态。你可以提供一个你想返回的分支名或特定 SHA ，或者在缺省情况下，Git 会认为你希望 checkout 的是 HEAD，当前 checkout 分支的最后一次 commit。

  • 记住：你用这种方法“撤销”的任何修改真的会完全消失。因为它们从来没有被提交过，所以之后 Git 也无法帮助我们恢复它们。你要确保自己了解你在这个操作里扔掉的东西是什么！（也许可以先利用 git diff 确认一下）

重置“本地的”修改（修改了文件，已经add）

  • 场景: 你在本地提交了一些东西（还没有 push），但是所有这些东西都很糟糕，你希望撤销前面的三次提交 — 就像它们从来没有发生过一样。

  • 方法: git reset <last good SHA> 或 git reset --hard <last good SHA>

  • 原理: git reset 会把你的代码库历史返回到指定的 SHA 状态。 这样就像是这些提交从来没有发生过。缺省情况下， git reset 会保留工作目录。这样，提交是没有了，但是修改内容还在磁盘上。这是一种安全的选择，但通常我们会希望一步就“撤销”提交以及修改内容 — 这就是 –hard 选项的功能。

删除本地untracked文件

1
2
3
4
5
6
7
8
9
10
11
12
13
# 删除 untracked files
git clean -f

# 连 untracked 的目录也一起删掉
git clean -fd

# 连 gitignore 的untrack 文件/目录也一起删掉 （慎用，一般这个是用来删掉编译出来的 .o之类的文件用的）
git clean -xfd

# 在用上述 git clean 前，墙裂建议加上 -n 参数来先看看会删掉哪些文件，防止重要文件被误删
git clean -nxfd
git clean -nf
git clean -nfd

在撤销“本地修改”之后再恢复

  • 场景: 你提交了几个 commit，然后用 git reset –hard 撤销了这些修改（见上一段），接着你又意识到：你希望还原这些修改！

  • 方法: git reflog 和 git reset 或 git checkout

  • 原理: git reflog 对于恢复项目历史是一个超棒的资源。你可以恢复几乎 任何东西 — 任何你 commit 过的东西 — 只要通过 reflog。

撤销一个“已push”的改变

  • 场景: 你已经执行了 git push, 把你的修改发送到了 GitHub，现在你意识到这些 commit 的其中一个是有问题的，你需要撤销那一个 commit.

  • 方法: git revert <SHA>;

  • 原理: git revert 会产生一个新的 commit，它和指定 SHA 对应的 commit 是相反的（或者说是反转的）。如果原先的 commit 是“物质”，新的 commit 就是“反物质” — 任何从原先的 commit 里删除的内容会在新的 commit 里被加回去，任何在原先的 commit 里加入的内容会在新的 commit 里被删除。

向 GitHub 上贡献代码

  1. 先fork下别人的代码，于是你的github上就出现了同名的项目
  2. 把这个自己的项目git clone到本地，修修改改，然后push到你自己的项目里
  3. 在github上你的项目页面有个按钮，叫Pull request，对 你点它就会把你的修改发到对方的项目里

在你fork他的项目之后，如果他又更新了代码，你自己fork的项目怎么做到和原项目同步呢？

  1. 先git clone我的代码到本地，然后修修改改
  2. 然后你不是不能push到我的项目里么，你可以先在github页面上fork我的项目
  3. 有了你自己的项目地址（url）之后呢，你在本地操作git remote add [sort name] [your url]，意思就是添加第二个远程仓库地址，这个仓库的“昵称”就是你刚指定的[sort name]
  4. 之后push文件呢 就通过指定这个［sort name］来push到这个你自己的仓库里

查看每一行代码的作者和创建时间

1
git blame <文件名>

针对某一时间的版本做上标记

添加tag

1
git tag -a <版本> -m '<注释>'

查看所有tag

1
git tag -l

切换到对应的标签

1
git checkout <tag的版本>

切换到对应的标签（如果有个同名的分枝名）

1
git checkout tags/<tag的版本>

删除tag

1
git tag -d <tag的版本>

提交某一版本tag

1
git push origin <tag的版本>

提交所有tag

1
git push origin --tag

发表于 分类于
  • Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序；
  • Union All：对两个结果集进行并集操作，包括重复行，不进行排序；
  • Intersect：对两个结果集进行交集操作，不包括重复行，同时进行默认规则的排序；
  • Minus：对两个结果集进行差操作，不包括重复行，同时进行默认规则的排序。

发表于 分类于

普通索引

普通索引（由关键字 KEY 或 INDEX 定义的索引）的唯一任务是加快对数据的访问速度。因此，应该只为那些最经常出现在查询条件（WHERE column = …）或排序条件（ORDER BY column）中的数据列创建索引。只要有可能，就应该选择一个数据最整齐、最紧凑的数据列（如一个整数类型的数据列）来创建索引。

唯一索引

普通索引允许被索引的数据列包含重复的值。比如说，因为人有可能同名，所以同一个姓名在同一个”员工个人资料”数据表里可能出现两次或更多次。

如果能确定某个数据列将只包含彼此各不相同的值，在为这个数据列创建索引的时候就应该用关键字 UNIQUE 把它定义为一个唯一索引。这么做的好处：一是简化了 MySQL 对这个索引的管理工作，这个索引也因此而变得更有效率；二是 MySQL 会在有新记录插入数据表时，自动检查新记录的这个字段的值是否已经在某个记录的这个字段里出现过了；如果是， MySQL 将拒绝插入那条新记录。也就是说，唯一索引可以保证数据记录的唯一性。事实上，在许多场合，人们创建唯一索引的目的往往不是为了提高访问速度，而只是为了避免数据出现重复。

主索引

在前面已经反复多次强调过：必须为主键字段创建一个索引，这个索引就是所谓的”主索引”。主索引与唯一索引的唯一区别是：前者在定义时使用的关键字是 PRIMARY 而不是 UNIQUE。

外键索引

如果为某个外键字段定义了一个外键约束条件，MySQL 就会定义一个内部索引来帮助自己以最有效率的方式去管理和使用外键约束条件。

复合索引

索引可以覆盖多个数据列，如像 INDEX(columnA, columnB) 索引。这种索引的特点是 MySQL 可以有选择地使用一个这样的索引。如果查询操作只需要用到 columnA 数据列上的一个索引，就可以使用复合索引 INDEX(columnA, columnB)。不过，这种用法仅适用于在复合索引中排列在前的数据列组合。比如说，INDEX(A, B, C) 可以当做 A 或 (A, B) 的索引来使用，但不能当做 B、C 或 (B, C) 的索引来使用。

索引的长度

在为 CHAR 和 VARCHAR 类型的数据列定义索引时，可以把索引的长度限制为一个给定的字符个数（这个数字必须小于这个字段所允许的最大字符个数）。这么做的好处是可以生成一个尺寸比较小、检索速度却比较快的索引文件。在绝大多数应用里，数据库中的字符串数据大都以各种各样的名字为主，把索引的长度设置为 10~15 个字符已经足以把搜索范围缩小到很少的几条数据记录了。

在为 BLOB 和 TEXT 类型的数据列创建索引时，必须对索引的长度做出限制；MySQL 所允许的最大索引长度是 255 个字符。

全文索引

文本字段上的普通索引只能加快对出现在字段内容最前面的字符串（也就是字段内容开头的字符）进行检索操作。如果字段里存放的是由几个、甚至是多个单词构成的较大段文字，普通索引就没什么作用了。这种检索往往以 LIKE %word% 的形式出现，这对 MySQL 来说很复杂，如果需要处理的数据量很大，响应时间就会很长。

这类场合正是全文索引（full-text index）可以大显身手的地方。在生成这种类型的索引时，MySQL 将把在文本中出现的所有单词创建为一份清单，查询操作将根据这份清单去检索有关的数据记录。全文索引即可以随数据表一同创建，也可以等日后有必要时再使用下面这条命令添加：

1
ALTER TABLE tablename ADD FULLTEXT(column1, column2)

有了全文索引，就可以用SELECT查询命令去检索那些包含着一个或多个给定单词的数据记录了。下面是这类查询命令的基本语法：

1
SELECT * FROM tablename WHERE MATCH(column1, column2) AGAINST('word1', 'word2', 'word3')

上面这条命令将把 column1 和 column2 字段里有 word1、word2 和 word3 的数据记录全部查询出来。

注解：InnoDB 数据表不支持全文索引。

发表于 分类于

转自：http://www.cnblogs.com/yuyue2014/p/4339090.html

myisam 存储引擎

数据库版本：阿里云 RDS MySQL5.1

1
2
3
4
5
6
7
mysql> select @@version;
+-------------------------------+
| @@version |
+-------------------------------+
| 5.1.61-Alibaba-rds-201404-log |
+-------------------------------+
1 row in set (0.00 sec)

测试的表结构信息

1
2
3
4
5
6
7
8
9
10
mysql> show create table tb2\G
*************************** 1. row ***************************
Table: tb2
Create Table: CREATE TABLE `tb2` (
`a` varchar(255) DEFAULT NULL,
`b` varchar(255) DEFAULT NULL,
`c` varchar(255) DEFAULT NULL,
`d` varchar(1000) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

添加单列索引，能够添加成功（报出warning），但实际添加的是前缀索引。

1
2
3
4
5
6
7
8
9
10
11
12
mysql> alter table tb2 add index idx1 (d);
Query OK, 0 rows affected, 2 warnings (0.00 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> show warnings;
+---------+------+----------------------------------------------------------+
| Level | Code | Message |
+---------+------+----------------------------------------------------------+
| Warning | 1071 | Specified key was too long; max key length is 1000 bytes |
| Warning | 1071 | Specified key was too long; max key length is 1000 bytes |
+---------+------+----------------------------------------------------------+
2 rows in set (0.00 sec)

表结构信息：

1
2
3
4
5
6
7
8
9
10
11
mysql> show create table tb2\G
*************************** 1. row ***************************
Table: tb2
Create Table: CREATE TABLE `tb2` (
`a` varchar(255) DEFAULT NULL,
`b` varchar(255) DEFAULT NULL,
`c` varchar(255) DEFAULT NULL,
`d` varchar(1000) DEFAULT NULL,
KEY `idx1` (`d`(333))
) ENGINE=MyISAM DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

添加组合索引，会执行失败。

1
2
mysql> alter table tb2 add index idx1 (a,b);
ERROR 1071 (42000): Specified key was too long; max key length is 1000 bytes

分析

myisam 存储引擎在创建索引的时候，索引键长度是有一个较为严格的长度限制的，所有索引键最大长度总和不能超过 1000，而且不是实际数据长度的总和，而是索引键字段定义长度的总和。

主要字符集的计算方式：

  • latin1 = 1 byte = 1 character
  • uft8 = 3 byte = 1 character
  • gbk = 2 byte = 1 character

innodb 存储引擎

表结构信息：

1
2
mysql> create table tb1 (a varchar(255), b varchar(255), c varchar(255), d varchar(1000));
Query OK, 0 rows affected (0.01 sec)

添加组合索引，报出waring，实际在某个单列上添加的是前缀索引

1
2
3
4
5
6
7
8
9
10
11
12
13
mysql> alter table tb1 add index idx1(a,b,c,d);

Query OK, 0 rows affected, 2 warnings (0.01 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> show warnings;
+---------+------+---------------------------------------------------------+
| Level | Code | Message |
+---------+------+---------------------------------------------------------+
| Warning | 1071 | Specified key was too long; max key length is 767 bytes |
| Warning | 1071 | Specified key was too long; max key length is 767 bytes |
+---------+------+---------------------------------------------------------+
2 rows in set (0.00 sec)

添加单列索引，报出 waring，实际添加的是前缀索引

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
mysql> alter table tb1 add index idx2(d);
Query OK, 0 rows affected, 2 warnings (0.02 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> show warnings;
+---------+------+---------------------------------------------------------+
| Level | Code | Message |
+---------+------+---------------------------------------------------------+
| Warning | 1071 | Specified key was too long; max key length is 767 bytes |
| Warning | 1071 | Specified key was too long; max key length is 767 bytes |
+---------+------+---------------------------------------------------------+
2 rows in set (0.00 sec)

mysql> show create table tb1\G
*************************** 1. row ***************************
Table: tb1
Create Table: CREATE TABLE `tb1` (
`a` varchar(255) DEFAULT NULL,
`b` varchar(255) DEFAULT NULL,
`c` varchar(255) DEFAULT NULL,
`d` varchar(1000) DEFAULT NULL,
KEY `idx1` (`a`,`b`,`c`,`d`(255)),
KEY `idx2` (`d`(255))
) ENGINE=InnoDB DEFAULT CHARSET=utf8
1 row in set (0.00 sec)

分析：

默认情况下，InnoDB 引擎单一字段索引的长度最大为 767 字节，同样的，前缀索引也有同样的限制。当使用 UTF-8 字符集，每一个字符使用 3 字节来存储，在 TEXT 或者 VARCHAR 类型的字段上建立一个超过 255 字符数的前缀索引时就会遇到问题。可以启用服务器选项 innodb_large_prefix 使得这个限制增加到 3072 字节，而且表的 row_format 需要使用 compressed 或者 dynamic。

使用前缀索引带来的风险：

INNODB的索引会限制单独Key的最大长度为767字节，超过这个长度必须建立小于等于767字节的前缀索引。

此外，BLOB和TEXT类型的列只能创建前缀索引。

前缀索引能提高索引建立速度和检索速度，但是下面情况是无法使用前缀索引的：

  • 索引覆盖扫描
  • 通过索引的排序（order by, group by）

还是在上面的测试表上：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
mysql> explain select * from tb1 order by d;
+----+-------------+-------+------+---------------+------+---------+------+------+----------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+------+------+----------------+
| 1 | SIMPLE | tb1 | ALL | NULL | NULL | NULL | NULL | 5 | Using filesort |
+----+-------------+-------+------+---------------+------+---------+------+------+----------------+
1 row in set (0.00 sec)

mysql> explain select * from tb1 group by d;
+----+-------------+-------+------+---------------+------+---------+------+------+---------------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+------+------+---------------------------------+
| 1 | SIMPLE | tb1 | ALL | NULL | NULL | NULL | NULL | 5 | Using temporary; Using filesort |
+----+-------------+-------+------+---------------+------+---------+------+------+---------------------------------+
1 row in set (0.00 sec)

发表于 分类于

先按某字段分组再取每组中前 N 条记录

1
2
3
4
5
6
7
8
9
10
SELECT show_date,photo_url,video_url FROM tb_grouth_album a
    WHERE
        baby_uuid = '69182ed4acf9491cb5b6767e157626fa' AND
        (
            SELECT COUNT(id)
                FROM tb_grouth_album b
            WHERE
                baby_uuid = '69182ed4acf9491cb5b6767e157626fa' AND b.show_date = a.show_date AND a.id<=b.id
         ) <= 9
    ORDER BY show_date DESC

取日期字段的年月日

SELECT DATE_FORMAT(crt_time,'%Y-%m-%d') FROM ad_n_advertise_t

订单按照月份分类统计总数

SELECT count(1),DATE_FORMAT(create_time,"%Y-%m") month FROM integral_charge_order GROUP BY month;

发表于 分类于

转自：http://blog.csdn.net/lonelyroamer/article/details/7868820

一、Java泛型的实现方法：类型擦除

前面已经说了，Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出（type erasure）。

阅读全文 »

发表于 分类于

转自：http://blog.csdn.net/lonelyroamer/article/details/7864531

一、泛型的基本概念

泛型的定义：泛型是JDK 1.5的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

阅读全文 »

发表于 分类于
  • OracleDBConsoleorcl：Oracle 数据库控制台服务，orcl 是 Oracle 的实例标识，默认的实例为 orcl。在运行Enterprise Manager（企业管理器 OEM）的时候，需要启动这个服务。（非必须启动）
  • OracleJobSchedulerORCL：Oracle 作业调度（定时器）服务，ORCL 是 Oracle 实例标识。（非必须启动）
  • OracleOraDb11g_home1TNSListener：监听器服务，服务只有在数据库需要远程访问的时候才需要。（非必须启动）
  • OracleServiceORCL：数据库服务（数据库实例），是 Oracle 核心服务该服务，是数据库启动的基础，只有该服务启动，Oracle 数据库才能正常启动。（必须启动）

通过上面介绍我们可以看出，如果是只用 Oracle 自带的 sql*plus 的话，只要启动 OracleServiceORCL 即可，要是使用 PL/SQL Developer 等第三方工具的话，OracleOraDb11g_home1TNSListener 服务也要开启。OracleDBConsoleorcl 是进入基于 web 的 EM 必须开启的，其余服务很少用。

平时我们只需要启动 OracleServiceORCL、OracleOraDb11g_home1TNSListener 这两个服务就可以了。