<![CDATA[Zhang Teng'Blog]]> 2015-05-31T06:32:06.132Z // Hexo <![CDATA[gitlab只使用https协议]]> /2015/05/30/gitlab只使用https协议/ 2015-05-30T14:25:04.000Z 2015-05-31T06:26:20.000Z 主要修改两个地方

1 修改app/views/shared/_clone_panel.html.haml

删掉下面这段代码

1
2
3
4
5
6
7

%button{ |
      class: "btn #{ 'active' if default_clone_protocol == 'ssh' }#{ ' has_tooltip' if current_user && current_user.require_ssh_key? }", |
      :"data-clone" => project.ssh_url_to_repo, |
      :"data-title" => "Add an SSH key to your profile<br> to pull or push via SSH",
      :"data-html" => "true",
      :"data-container" => "body"}
      SSH

2 修改./app/helpers/projects_helper.rb

1
2
3
4
5
6
7
8

def default_url_to_repo(project = nil)
    project = project || @project
    current_user ? project.http_url_to_repo : project.url_to_repo
  end

  def default_clone_protocol
    current_user ? "http" : "ssh"
  end
]]> 主要修改两个地方

]]> <![CDATA[基于Docker的Hadoop完全分布式环境搭建]]> /2015/05/19/基于Docker的Hadoop完全分布式环境搭建/ 2015-05-19T15:55:37.000Z 2015-05-31T06:18:35.000Z 1 配置docker环境

创建一个带有ssh的centos的docker images，命名为centos6-ssh（建议采用centos6）并且ssh能在容器启动是自启动，不是本部分的重点，不详细描述。

2 启动docker，配置java

2.1 启动第1步中创建的容器。

docker run -it centos6-ssh /bin/bash

2.2 安装Java

不是本文重点，不具体描述。Java的安装目录是/opt/java8

3 安装Hadoop

3.1 下载Hadoop

1
2
3
4
5
6

shell>> cd /opt

shell>> wget http://mirrors.cnnic.cn/apache/hadoop/common/hadoop-2.6.0/hadoop-2.6.0.tar.gz

shell>> tar -zxvf hadoop-2.6.0.tar.gz

3.2 配置环境变量

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

shell>> vim /etc/profile

# 输入一下内容

export HADOOP_HOME=/opt/hadoop-2.6.0/

export HADOOP_CONFIG_HOME=$HADOOP_HOME/etc/hadoop

export PATH=$PATH:$HADOOP_HOME/bin

export PATH=$PATH:$HADOOP_HOME/sbin

3.3 配置Hadoop

下面，我们开始修改Hadoop的配置文件。主要配置core-site.xml、hdfs-site.xml、mapred-site.xml这三个文件。

1
2
3
4
5
6
7
8

shell>> cd $HADOOP_HOME/

shell>> mkdir tmp

shell>> mkdir namenode

shell>> mkdir datanode

这里创建了三个目录，后续配置的时候会用到：

1. tmp：作为Hadoop的临时目录

2. namenode：作为NameNode的存放目录

3. datanode：作为DataNode的存放目录

接下来进入配置文件夹，开始配置

1
2

shell>> cd $HADOOP_CONFIG_HOME/
3.3.1 core-site.xml配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

<?xml version="1.0" encoding="UTF-8"?>

<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>

<!--

  Licensed under the Apache License, Version 2.0 (the "License");

  you may not use this file except in compliance with the License.

  You may obtain a copy of the License at



    http://www.apache.org/licenses/LICENSE-2.0



  Unless required by applicable law or agreed to in writing, software

  distributed under the License is distributed on an "AS IS" BASIS,

  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  See the License for the specific language governing permissions and

  limitations under the License. See accompanying LICENSE file.

-->



<!-- Put site-specific property overrides in this file. -->



<configuration>

    <property>

            <name>hadoop.tmp.dir</name>

            <value>/opt/hadoop-2.6.0/tmp</value>

            <description>A base for other temporary directories.</description>

    </property>



    <property>

            <name>fs.default.name</name>

            <value>hdfs://master.hadoop.com:9000</value>

            <final>true</final>

            <description>The name of the default file system.  A URI whose

            scheme and authority determine the FileSystem implementation.  The

            uri's scheme determines the config property (fs.SCHEME.impl) naming

            the FileSystem implementation class.  The uri's authority is used to

            determine the host, port, etc. for a filesystem.</description>

    </property>

</configuration>

注意：

* hadoop.tmp.dir配置项值即为此前命令中创建的临时目录路径。

* fs.default.name配置为hdfs://master:9000，指向的是一个Master节点的主机（后续我们做集群配置的时候，自然会配置这个节点，先写在这里）
3.3.2 hdfs-site.xml配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

<?xml version="1.0" encoding="UTF-8"?>

<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>

<!--

  Licensed under the Apache License, Version 2.0 (the "License");

  you may not use this file except in compliance with the License.

  You may obtain a copy of the License at



    http://www.apache.org/licenses/LICENSE-2.0



  Unless required by applicable law or agreed to in writing, software

  distributed under the License is distributed on an "AS IS" BASIS,

  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  See the License for the specific language governing permissions and

  limitations under the License. See accompanying LICENSE file.

-->



<!-- Put site-specific property overrides in this file. -->



<configuration>

    <property>

        <name>dfs.replication</name>

        <value>2</value>

        <final>true</final>

        <description>Default block replication.

        The actual number of replications can be specified when the file is created.

        The default is used if replication is not specified in create time.

        </description>

    </property>



    <property>

        <name>dfs.namenode.name.dir</name>

        <value>/opt/hadoop-2.6.0/namenode</value>

        <final>true</final>

    </property>



    <property>

        <name>dfs.datanode.data.dir</name>

        <value>/opt/hadoop-2.6.0/datanode</value>

        <final>true</final>

    </property>

</configuration>

注意：

  • 我们后续搭建集群环境时，将配置一个Master节点和两个Slave节点。所以dfs.replication配置为2。

  • dfs.namenode.name.dir和dfs.datanode.data.dir分别配置为之前创建的NameNode和DataNode的目录路径

3.3.3 mapred-site.xml配置
1
2

shell>> cp mapred-site.xml.template mapred-site.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

<?xml version="1.0"?>

<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>

<!--

  Licensed under the Apache License, Version 2.0 (the "License");

  you may not use this file except in compliance with the License.

  You may obtain a copy of the License at



    http://www.apache.org/licenses/LICENSE-2.0



  Unless required by applicable law or agreed to in writing, software

  distributed under the License is distributed on an "AS IS" BASIS,

  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  See the License for the specific language governing permissions and

  limitations under the License. See accompanying LICENSE file.

-->



<!-- Put site-specific property overrides in this file. -->



<configuration>

    <property>

        <name>mapred.job.tracker</name>

        <value>master.hadoop.com:9001</value>

        <description>The host and port that the MapReduce job tracker runs

        at.  If "local", then jobs are run in-process as a single map

        and reduce task.

        </description>

    </property>

</configuration>

这里只有一个配置项mapred.job.tracker，我们指向master节点机器。

3.3.3.4 修改JAVA_HOME环境变量

使用命令vim hadoop-env.sh打开配置文件，修改配置如下：

1
2
3
4

# The java implementation to use.

export JAVA_HOME=/opt/java8

4 格式化namenode

这是很重要的一步，执行命令hadoop namenode -format

5 配置SSH，生成访问秘钥

1
2
3
4
5
6
7
8

shell>> cd ~/

shell>> ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa

shell>> cd .ssh

shell>> cat id_rsa.pub >> authorized_keys

注意： 这里，我的思路是直接将密钥生成后写入镜像，免得在买个容器里面再单独生成一次，还要相互拷贝公钥，比较麻烦。当然这只是学习使用，实际操作时，应该不会这么搞，因为这样所有容器的密钥都是一样的！

6 创建Hadoop images

1
2
3
4
5
6
7
8
9
10

# 退出docker容器

shell>> exit

# commit容器

shell>> docker commit -a "zhangteng" -m "add hadoop" b7227b0d59fe02d22ad823a5c4a478ec8de3e7882488259191984995791da953 tcheung/hadoop

得到# 容器的id需要替换，可以通过docker ps -a

3 Hadoop分布式集群搭建

重点来了！

按照 hadoop 集群的基本要求,其 中一个是 master 结点,主要是用于运行 hadoop 程序中的 namenode、secondorynamenode 和 jobtracker（新版本名字变了） 任务。用外两个结点均为 slave 结点,其中一个是用于冗余目的,如果没有冗 余,就不能称之为 hadoop 了,所以模拟 hadoop 集群至少要有 3 个结点。

我们搭建集群环境的时候，需要指定节点的hostname，以及配置hosts。hostname可以使用docker run命令的h参数直接指定，但hosts解析有点麻烦，需要每次重启之后重新配置

启动master容器
1
2

shell>> docker run -d -h master.hadoop.com  --net=none --name=master.hadoop.com tcheung/hadoop
启动slave1容器
1
2

shell>> docker run -d -h slave1.hadoop.com  --net=none --name=slave1.hadoop.com tcheung/hadoop
启动slave2容器
1
2

shell>> docker run -d -h slave2.hadoop.com  --net=none --name=slave2.hadoop.com tcheung/hadoop

给3个容器配置ip

配置ip的方式有很多，如pipework（我使用的是这个），具体可以百度。

master 192.168.5.10

slave1 192.168.5.20

slave2 192.168.5.30

修改3个容器的hosts

通过ssh分别进入3个容器，使用vim /etc/hosts修改各自的hosts，添加内容如下：

1
2
3
4
5
6

192.168.5.10    master.hadoop.com

192.168.5.20    slave1.hadoop.com

192.168.5.30    slave2.hadoop.com

配置slaves

下面我们来配置哪些节点是slave。在较老的Hadoop版本中有一个masters文件和一个slaves文件，但新版本中只有slaves文件了。

在master节点容器中执行如下命令：

1
2
3
4

shell>> cd $HADOOP_CONFIG_HOME/

shell>> vim slaves

将如下slave节点的hostname信息写入该文件： 

1
2
3
4

slave1.hadoop.com

slave2.hadoop.com

启动Hadoop

在master节点上执行start-all.sh命令，启动Hadoop。

如果没有报错，就代表启动成功，如果有错，那就慢慢调吧。

在3个节点上执行jps命令，会得到类似的结果：

master节点

1
2
3
4
5
6
7
8

516 ResourceManager

358 SecondaryNameNode

775 Jps

169 NameNode

slave1节点

1
2
3
4
5
6

292 Jps

52 DataNode

153 NodeManager

slave1节点

1
2
3
4
5
6

465 Jps

52 DataNode

153 NodeManager

在master节点上通过命令hdfs dfsadmin -report查看DataNode是否正常启动。

也可以通过在浏览器中输入http://master.hadoop.com:50070查看Hadoop的运行状态。

]]> 1 配置docker环境

创建一个带有ssh的centos的docker images，命名为centos6-ssh（建议采用centos6）并且ssh能在容器启动是自启动，不是本部分的重点，不详细描述。

2 启动docker，配置java

]]> <![CDATA[基于Docker的Hadoop完全分布式环境搭建]]> /2015/05/18/HBase环境搭建/ 2015-05-18T15:55:37.000Z 2015-05-31T06:17:38.000Z HBase需要在Hadoop的基础上运行，使用了Hadoop的HDFS，所有在搭建HBase之前，需要先搭建Hadoop的环境。
Habse的运行模式主要有两种：

  1. 单机模式
  2. 分布式模式
    2.1. 伪分布式
    2.2. 完全分布式
    主要介绍单击模式和完全分布式。

1 单机模式

单机模式的HBase使用的是本地文件系统，并没有使用HDFS，这种方式可以用于实验，官方并不建议将这种方式用到生产环境中。
我选择的版本是：hbase-1.0.1（此版本是一个稳定版本）。
下载地址：http://mirrors.cnnic.cn/apache/hbase/stable/
现面开始安装说明：

1.1 安装Java

不是本文重点，不做叙述。最好选择Java7或者Java8，我选择的是Java8。

1.2 下载HBase并解压

1
2
3
4
5
6

# 进入安装文件夹
shell>> cd /opt
# 下载
shell>> wget http://mirrors.cnnic.cn/apache/hbase/stable/hbase-1.0.1-bin.tar.gz
# 解压
shell>> tar -xzvf hbase-1.0.1-bin.tar.gz

#### 1.3 配置HBase
配置hbase-site.xml
hbase-site.xml在conf文件夹下。
1
2
3
4
5
6
7
8
9
10

<configuration>
  <property>
    <name>hbase.rootdir</name>
    <value>file:///data/hbase</value>
  </property>
  <property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/data/zookeeper</value>
  </property>
</configuration>

HBase的数据目录不需要我们去手动创建，当启HBase时，HBase会自动去创建。
#### 1.4 启动HBase
通过运行bin/start-hbase.sh，HBase就能启动起来。在单机模式下，HBase的所有守护进程都只运行在一个JVM下。

### 2 完全分布式模式
使用Docker来搭建分布式环境。
Docker是一种虚拟化技术，可以为我们提供虚拟化环境，启动多个Docker容器，相当于启动了多个虚拟机，各容器间是相互隔离的，基本上通过网络进行通信。
启动了3个Centos6的Docker容器来搭建HBase环境，3个容器情况如下：
|节点 |hostname |ip |域名 |
|—————-|———————————————-|———————————|———————————————|
|master|master.hadoop.com|192.168.5.10|master.hadoop.com|
|slave1|slave1.hadoop.com|192.168.5.20|slave1.hadoop.com|
|slave2|slave2.hadoop.com|192.168.5.30|slave1.hadoop.com|
#### 2.1 配置各Docker容器环境
##### 2.1.1 安装Java
##### 2.1.2 安装、配置SSH
在各容器中安装SSH，并生成相应的无密码登录的公钥与私钥，并叫公钥拷贝到其他容器中，确保各容器间能通过ssh无密码登录（使用公钥登录）。
1
2

shell>> ssh-keygen -t rsa
shell>> cat id_rsa.pub >> ~/.ssh/authorized_keys

##### 2.1.3 修改host
通过vim /etc/hosts修改各容器的host，在文件中添加如下内容：
1
2
3

192.168.5.10    master.hadoop.com
192.168.5.20    slave1.hadoop.com
192.168.5.30    slave2.hadoop.com

#### 2.2 配置master节点
##### 2.2.1 进入master节点
1

ssh root@192.168.5.10

##### 2.2.2 下载HBase并解压
1
2
3
4
5
6

# 进入安装文件夹
shell>> cd /opt
# 下载
shell>> wget http://mirrors.cnnic.cn/apache/hbase/stable/hbase-1.0.1-bin.tar.gz
# 解压
shell>> tar -xzvf hbase-1.0.1-bin.tar.gz

##### 2.2.3 配置hbase-site.xml
hbase-site.xml在conf文件夹下。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<configuration>
    <property>
      <name>hbase.cluster.distributed</name>
      <value>true</value>
    </property>
    <property>
      <name>hbase.rootdir</name>
      <value>hdfs://master.hadoop/hbase</value>
    </property>


    <property>
      <name>hbase.zookeeper.quorum</name>
      <value>master.hadoop.com,slave1.hadoop.com,slave2.hadoop.com</value>
    </property>
    <property>
      <name>hbase.zookeeper.property.dataDir</name>
      <value>/opt/zookeeper</value>
    </property>
</configuration>

#### 2.3 配置slave1和slave2
在master中已经将HBase配置好了，HBase要求所有节点的安装目录和配置完全一致，所以，最简单的方式就是将master节点中的HBase复制到slave1和slave2
中。
可以通过scp达到这一目的。
在master节点中执行如下命令：
1
2

scp /opt/hbase-1.0.1 root@192.168.5.20:/opt
scp /opt/hbase-1.0.1 root@192.168.5.30:/opt

#### 2.4 启动集群
在master节点中，执行bin/start-hbase.sh就可以启动集群。如果看到类似于下面的这些信息，就表示启动成功。
1
2
3
4
5
6
7

slave1.hadoop.com: starting zookeeper, logging to /opt/hbase-1.0.1/bin/../logs/hbase-root-zookeeper-slave1.hadoop.com.out
slave2.hadoop.com: starting zookeeper, logging to /opt/hbase-1.0.1/bin/../logs/hbase-root-zookeeper-slave2.hadoop.com.out
master.hadoop.com: starting zookeeper, logging to /opt/hbase-1.0.1/bin/../logs/hbase-root-zookeeper-master.hadoop.com.out
starting master, logging to /opt/hbase-1.0.1/bin/../logs/hbase-root-master-master.hadoop.com.out
slave2.hadoop.com: starting regionserver, logging to /opt/hbase-1.0.1/bin/../logs/hbase-root-regionserver-slave2.hadoop.com.out
slave1.hadoop.com: starting regionserver, logging to /opt/hbase-1.0.1/bin/../logs/hbase-root-regionserver-slave1.hadoop.com.out
slave1.hadoop.com: starting master, logging to /opt/hbase-1.0.1/bin/../logs/hbase-root-master-slave1.hadoop.com.out

#### 2.5 查看各节点的进程信息
通过jps查看各节点运行的Java进程，如果看到如下的进程，表示HBase启动成功。
master节点
1
2
3
4

shell>> jps
20355 Jps
20071 HQuorumPeer
20137 HMaster

slave1节点
1
2
3
4

shell>> jps
15930 HRegionServer
16194 Jps
15838 HQuorumPeer

slave2节点
1
2
3
4

shell>> jps
13901 Jps
13639 HQuorumPeer
13737 HRegionServer

#### 2.6 在浏览器中查看运行状态
在浏览器中输入：http://master.hadoop.com:16010，可查看HBase运行状态。
#### 2.7 例子演示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

建立一个表scores具有两个列族grad 和courese      
create 'scores','grade', 'course' 
查看当前HBase中具有哪些表      
list 
查看表的构造      
describe 'scores' 
加入一行数据,行名称为zkb 列族grad的列名为”” 值位5      
put 'scores','zkb','grade:','5'

给zkb这一行的数据的列族course添加一列<math,97>      
put 'scores','zkb','course:math','97'  
给zkb这一行的数据的列族course添加一列<art,87>      
put 'scores','zkb','course:art','87'  
加入一行数据,行名称为baoniu列族grad的列名为”” 值为4      
put 'scores','baoniu','grade:','4' 
给baoniu这一行的数据的列族course添加一列<math,89>     
put 'scores','baoniu','course:math','89'

给baoniu这一行的数据的列族course添加一列<art,80>      
put 'scores','baoniu','course:art','80'  
查看scores表中zkb的相关数据      
get 'scores','zkb'  
查看scores表中所有数据      
scan 'scores'  
注意：scan命令可以指定startrow,stoprow来scan多个row，例如：scan 'user_test', {COLUMNS =>'info:username',LIMIT =>10, STARTROW => 'test',STOPROW=>'test2'}

查看scores表中所有数据courses列族的所有数据      
scan 'scores',{COLUMNS => 'course'}  
删除scores表      
disable 'scores'       
drop 'scores'      
注意：先要屏蔽该表，才能对该表进行删除
]]> HBase需要在Hadoop的基础上运行，使用了Hadoop的HDFS，所有在搭建HBase之前，需要先搭建Hadoop的环境。
Habse的运行模式主要有两种：

  1. 单机模式
  2. 分布式模式
    2.1. 伪分布式
    2.2. 完全分布式
    主要介绍单击模式和完全分布式。
]]> <![CDATA[基于docker的gitlab搭建]]> /2015/05/03/基于docker的gitlab搭建/ 2015-05-03T06:21:48.000Z 2015-05-31T06:23:44.000Z ### 一、准备docker容器环境

1. 下载docker ubuntu镜像

1

shell>> docker pull ubuntu

#### 2. 启动ubuntu镜像并更新

1
2
3

shell>> docker run -it docker.io/ubuntu
# 更新操作在ubuntu容器中进行
shell>> apt-get -y update

3. 安装ssh

1
2
3
4
5
6
7

shell>> apt-get install openssh-server vim
# 配置ssh
shell>> vim /etc/ssh/sshd_config
# 启动ssh
shell>> service ssh start
# 退出容器
shell>> exit

#### 4. commit docker容器

1
2

shell>> docker commit -a "zhangteng" -m "add ssh" 876f90b7a5769c04f3d9975369b3a1148e6c951d1f4f4217728b072b6ae6a50b ubuntu-ssh
ps: "876f90b7a5769c04f3d9975369b3a1148e6c951d1f4f4217728b072b6ae6a50b"为刚刚安装了ssh的ubuntu容器的id，需要替换，id可通过ps -a查到

#### 5. build docker容器
1
2
3

shell>> mkdir ubuntu_ssh
shell>> cd ubuntu_ssh
shell>> vim Dockerfile

在Dockerfile文件中输入如下内容:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# Add ssh to ubuntu
# author: zhangteng
# VERSION 1.0

FROM ubuntu-ssh:latest
MAINTAINER zhangteng
 
# change root passwd
RUN echo 'root:123456' | chpasswd
 
# expose ssh port
EXPOSE 22
 
RUN mkdir /var/run/sshd                                                                                                                  
 
# add run.sh
ADD run.sh /run.sh
RUN chmod 755 /run.sh

CMD ["/run.sh"]


1

shell>> vim run.sh

在run.sh文件中输入如下内容：
1
2
3
4

#!/bin/bash
 
# start sshd, let this at last
/usr/sbin/sshd -D

build容器
1

docker build -t ubuntu-ssh:v1 .

#### 6. 启动容器并进入容器
1
2

shell>> docker run -d -p 49170:22 --name=ubuntu-ssh ubuntu-ssh:v1
shell>> ssh root@127.0.0.1 -p 49170

### 二、安装gtilab
在完成上一步，进入docker容器之后就可以开始安装gitlab了。
注意：以下操作都必须在docker容器中进行，不在容器中的操作会有说明，没有说明的都在容器中操作。
以下内容参考gitlab官方安装说明，根据我们这边要求进行了一些说明。
#### 1. Packages/Dependencies
1.1 安装需要的依赖（用于编译Ruby和一些Ruby gems需要的原生依赖）
1

shell>> sudo apt-get install -y build-essential zlib1g-dev libyaml-dev libssl-dev libgdbm-dev libreadline-dev libncurses5-dev libffi-dev curl openssh-server redis-server checkinstall libxml2-dev libxslt-dev libcurl4-openssl-dev libicu-dev logrotate python-docutils pkg-config cmake libkrb5-dev nodejs

1.2 检查git的版本是否正确
1
2
3
4
5

# 安装Git
shell>> sudo apt-get install -y git-core

# 确保Git的版本是1.7.10或者更高
shell>> git --version

如果git的版本太久，可以移除它并用源码安装的方式安装一个高版本。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 移除旧版本的Git
shell>> sudo apt-get remove git-core

# 安装依赖
shell>> sudo apt-get install -y libcurl4-openssl-dev libexpat1-dev gettext libz-dev libssl-dev build-essential

# 下载源码、编译
shell>> cd /tmp
shell>> curl -L --progress https://www.kernel.org/pub/software/scm/git/git-2.1.2.tar.gz | tar xz
shell>> cd git-2.1.2/
shell>> ./configure
shell>> make prefix=/usr/local all

# 安装到/usr/local/bin
shell>> sudo make prefix=/usr/local install

# When editing config/gitlab.yml (Step 5), change the git -> bin_path to /usr/local/bin/git
# 当在第6步编辑config/gitlab.yml的时候，需要编辑bin_path=/usr/local/bin/git

1.3 安装postfix
做邮件服务器用，但是现在没有调通
1

shell>> sudo apt-get install -y postfix

#### 2. 安装Ruby
2.1 移除旧版本的Ruby
1

shell>> sudo apt-get remove ruby1.8

2.2 下载Ruby源码，编译并安装
1
2
3
4
5
6

shell>> mkdir /tmp/ruby && cd /tmp/ruby
shell>> curl -L --progress http://cache.ruby-lang.org/pub/ruby/2.1/ruby-2.1.6.tar.gz | tar xz
shell>> cd ruby-2.1.6
shell>> ./configure --disable-install-rdoc
shell>> make
shell>> sudo make install

2.3 更改Gem源
由于国内网络原因（你懂的），导致 rubygems.org 存放在 Amazon S3 上面的资源文件间歇性连接失败。所以你会与遇到 gem install rack 或 bundle install 的时候半天没有响应，具体可以用 gem install rails -V 来查看执行过程。
详见http://ruby.taobao.org/。
1
2
3
4
5
6
7

shell>> gem sources --remove https://rubygems.org/
shell>> gem sources -a https://ruby.taobao.org/
shell>> gem sources -l
*** CURRENT SOURCES ***

https://ruby.taobao.org
# 请确保只有 ruby.taobao.org

2.4 安装Bundler Gem
1

shell>> sudo gem install bundler --no-ri --no-rdoc

#### 3. 添加系统用户
1

shell>> sudo adduser --disabled-login --gecos 'GitLab' git

#### 4. 安装数据库(MySql)
我们使用的数据库是宿主主机的数据库，这里安装只是为了用于后面安装Gem，不需要启动这个数据库。
数据库可以选择Mysql或者PostgreSQL，我们使用的是Mysql。
1
2
3
4
5
6
7
8

# 安装Mysql
sudo apt-get install -y mysql-client libmysqlclient-dev

# Ensure you have MySQL version 5.5.14 or later
mysql --version

# 输入mysql的密码
# 再次输入mysql的密码

安装完数据库之后，还需要在宿主主机的Mysql中创建gitlab需要用的账户和数据库。
以下操作在宿主主机中执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 登录Mysql
shell>> mysql -h127.0.0.1 -uroot -p

# 输入mysql密码

# 创建git账户
mysql> CREATE USER 'git'@'localhost' IDENTIFIED BY 'gitlab';

# 创建Gitlab生产环境数据库
mysql> CREATE DATABASE IF NOT EXISTS `gitlabhq_production` DEFAULT CHARACTER SET `utf8` COLLATE `utf8_unicode_ci`;

mysql> GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, INDEX, ALTER, LOCK TABLES ON `gitlabhq_production`.* TO 'git'@'localhost';

# 为git添加远程访问能力
mysql> GRANT ALL PRIVILEGES ON *.* TO git@"192.168.5.%" IDENTIFIED BY "git"; 
mysql> GRANT ALL PRIVILEGES ON *.* TO git@"172.%.%.%" IDENTIFIED BY "git"; 
# 更改git只能在192.168.5.*这个ip段访问
mysql> use mysql;
mysql> update user set Host="192.168.5.%" where user="git" and Host="%";
mysql> flush privileges;
mysql> \q;

#### 5. 安装Redis
以下操作在docker容器中进行。
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

shell>> sudo apt-get install redis-server

# 配置redis使用socket访问
shell>> sudo cp /etc/redis/redis.conf /etc/redis/redis.conf.orig

# 将redis监听端口设为0，取消其对TCP请求的监听
shell>> sed 's/^port .*/port 0/' /etc/redis/redis.conf.orig | sudo tee /etc/redis/redis.conf
echo 'unixsocket /var/run/redis/redis.sock' | sudo tee -a /etc/redis/redis.conf
echo 'unixsocketperm 770' | sudo tee -a /etc/redis/redis.conf


# 创建socket需要使用的目录
shell>> mkdir /var/run/redis
shell>> chown redis:redis /var/run/redis
shell>> chmod 755 /var/run/redis
# Persist the directory which contains the socket, if applicable
if [ -d /etc/tmpfiles.d ]; then
  echo 'd  /var/run/redis  0755  redis  redis  10d  -' | sudo tee -a /etc/tmpfiles.d/redis.conf
fi

# 重启以激活修改
shell>> sudo service redis-server restart

# 将git用户添加到redis组
shell>> sudo usermod -aG redis git

#### 6. 安装Gitlab
6.1 克隆Gitlab源码
1
2
3

shell>> cd /home/git
shell>> sudo -u git -H git clone https://gitlab.com/gitlab-org/gitlab-ce.git -b 7-10-stable gitlab
ps: 我有下载好的，如果下载速度太慢，可以找我要，我也会传到gitlab上

6.2 配置Gitlab
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

shell>> cd /home/git/gitlab

# 复制一份gitlab的配置文件
shell>> sudo -u git -H cp config/gitlab.yml.example config/gitlab.yml

# 根据配置文件头部的说明进行修改，可以参考我修改之后的文件，在gitlab中
shell>> sudo -u git -H vim config/gitlab.yml
# 这需要修改production这一块就可以了，列出几个需要修改的关键地方
host: gitlab.b-m.net
port: 443
https: true
email_from: gitlab@boman.net
repos_path: /data/gitlab-data/repositories/

# 确保Gitlab对log/和tmp/这两个目录有写的权限
shell>> sudo chown -R git log/
shell>> sudo chown -R git tmp/
shell>> sudo chmod -R u+rwX,go-w log/
shell>> sudo chmod -R u+rwX tmp/

# 创建satellites文件夹
shell>> sudo -u git -H mkdir /home/git/gitlab-satellites
shell>> sudo chmod u+rwx,g=rx,o-rwx /home/git/gitlab-satellites

# 确保Gitlab对tmp/pids/和tmp/sockets/两个目录有写权限
shell>> sudo chmod -R u+rwX tmp/pids/
shell>> sudo chmod -R u+rwX tmp/sockets/

# 确保Gitlab对public/uploads/目录有写权限
shell>> sudo chmod -R u+rwX  public/uploads

# 复制一份Unicorn配置文件
shell>> sudo -u git -H cp config/unicorn.rb.example config/unicorn.rb

# 查找cpu的核数
nproc

# 如果你希望有一个高负荷的实例，可以开启集群模式
# 例如. 如果内存为2GB，设置workers为3
# workers的值至少是cpu的核数
shell>> sudo -u git -H vim config/unicorn.rb
列出需要修改的关键地方
worker_processes 4
listen "/home/git/gitlab/tmp/sockets/gitlab.socket", :backlog => 1024
listen "8080", :tcp_nopush => true

# Copy the example Rack attack config
shell>> sudo -u git -H cp config/initializers/rack_attack.rb.example config/initializers/rack_attack.rb

# Configure Git global settings for git user, useful when editing via web
# Edit user.email according to what is set in gitlab.yml
shell>> sudo -u git -H git config --global user.name "GitLab"
shell>> sudo -u git -H git config --global user.email "gitlab@b-m.net"
shell>> sudo -u git -H git config --global core.autocrlf input

# 配置Redis连接设置
shell>> sudo -u git -H cp config/resque.yml.example config/resque.yml

# 如果没有使用默认方式安装Redis，需要修改Redis的socket path
shell>> sudo -u git -H editor config/resque.yml

6.3 配置Gitlab的数据库设置
1
2
3
4
5
6
7
8
9
10
11
12
13
14

shell>> sudo -u git cp config/database.yml.mysql config/database.yml
shell>> sudo -u git -H vim config/database.yml
只需要修改production部分即可
production:
  adapter: mysql2
  encoding: utf8
  collation: utf8_general_ci
  reconnect: false
  database: gitlabhq_production
  pool: 10
  username: git
  password: "gitlab"
  host: 192.168.5.1
  socket: /alidata1/data/db3306/mysql.sock

6.4 安装Gems
6.4.1 修改Gem源
1
2
3
4

shell>> sudo -u git -H vim Gemfile
修改第一行
# source "https://rubygems.org"
source 'https://ruby.taobao.org/'

6.4.2 安装
1

shell>> sudo -u git -H bundle install --deployment --without development test postgres aws

6.5 安装Gitlab Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

shell>> mkdir -p /data/gitlab-data/repositories/
shell>> chown -R git:git /data/gitlab-data/
shell>> sudo -u git -H bundle exec rake gitlab:shell:install[v2.6.2] REDIS_URL=unix:/var/run/redis/redis.sock RAILS_ENV=production
# 修改配置
shell>> sudo -u git -H vim /home/git/gitlab-shell/config.yml
# 修改后的内容如下，也可参考我上传的文件
user: git
gitlab_url: https://gitlab.b-m.net/
http_settings:
  self_signed_cert: true
repos_path: "/data/gitlab-data/repositories/"
auth_file: "/data/gitlab-data/.ssh/authorized_keys"
redis:
  bin: "/usr/bin/redis-cli"
  namespace: resque:gitlab
  socket: "/var/run/redis/redis.sock"
log_level: INFO
audit_usernames: false

6.6 初始化数据库
1
2
3

shell>> sudo -u git -H bundle exec rake gitlab:setup RAILS_ENV=production
# 输入"yes"去创建数据库表
# 初始化完成之后可以看见"Administrator account created:"

可以使用下面的语句设置管理员的密码，如果不设置将使用默认密码。
1

shell>> sudo -u git -H bundle exec rake gitlab:setup RAILS_ENV=production GITLAB_ROOT_PASSWORD=yourpassword

6.7 安装服务脚本
1
2
3

sudo cp lib/support/init.d/gitlab /etc/init.d/gitlab
# 设置开机自启动
sudo update-rc.d gitlab defaults 21

6.8 安装日志管理工具
1

shell>> sudo cp lib/support/logrotate/gitlab /etc/logrotate.d/gitlab

6.9 检查程序状态
1

sudo -u git -H bundle exec rake gitlab:env:info RAILS_ENV=production

6.10 预编译
1

sudo -u git -H bundle exec rake assets:precompile RAILS_ENV=production

6.11 启动Gitlab
1

sudo service gitlab start

7. 退出docker容器
1

shell>> exit;

到这里，gitlab已经可以投入使用了，后面的操作只是对docker进行一些更多的操作，保存镜像，配置静态ip。
### 三、将Gitlab容器做成docker镜像，配置静态ip
#### 1. commit docker容器
这里commit的是刚刚安装了Gitlab的容器。
1
2

docker commit -a "zhangteng" -m"add gitlab" 26d8f1393450e6743e2f6becfb2ca4574e04cbb101234bb95f04d157fa9af6c2 ubuntu-gitlab
ps: "26d8f1393450e6743e2f6becfb2ca4574e04cbb101234bb95f04d157fa9af6c2"为刚刚安装了Gitlab的ubuntu-ssh容器的id，需要替换，id可通过ps -a查到

#### 2. build docker容器
1
2
3

shell>> mkdir ubuntu_gitlab
shell>> cd ubuntu_gitlab
shell>> vim Dockerfile

在Dockerfile文件中输入如下内容:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# Add gitlab to ubuntu
# author: zhangteng
# VERSION 1.0

FROM ubuntu-gitlab:latest
MAINTAINER zhangteng

# expose port 80
EXPOSE 80

# expose port 443
EXPOSE 443

# add run.sh
ADD run.sh /run.sh
RUN chmod 755 /run.sh

CMD ["/run.sh"]


1

shell>> vim run.sh

在run.sh文件中输入如下内容：
1
2
3
4
5
6
7
8
9
10
11

#!/bin/bash

# start redis
/etc/init.d/redis-server stop >/dev/null 2>&1
/etc/init.d/redis-server start >/dev/null 2>&1
# start gitlab
/etc/init.d/gitlab stop >/dev/null 2>&1 
/etc/init.d/gitlab start >/dev/null 2>&1

# start sshd, let this at last
/usr/sbin/sshd -D >/dev/null 2>&1

最后，build容器
1

docker build -t ubuntu-gitlab:v1 .

#### 3. 启动docker容器
1
2
3

docker run -d -v /alidata1/docker-gitlab:/data/gitlab-data --net=none --name=gitlabv1 ubuntu-gitlab:v1
-v参数需要根据实际情况修改
/alidata1/docker-gitlab文件夹需要先创建好

#### 4. 为docker容器配置静态ip
可以使用我提供的脚本docker_static_ip.sh为docker设置静态ip
使用方法如下为：sh docker_static_ip.sh 容器id/容器name ip
容器id可以通过docker ps得到
1

sh docker_static_ip.sh 69ead0a0e1ba266f97232f4f51940e9dd2da21952ce8517b99c699b66ad10a24 192.168.5.5

#### 5. 进入docker容器
由于第3步启动docker容器的时候，docker容器还没有ip，在第4步的时候才设置，Gitlab在启动的时候会去连接Mysql，这个时候是连不上的，所以启动不起来，需要进入手动启动
1
2
3
4
5

shell>> ssh root@192.168.5.5
# 输入docker容器的root密码
shell>> service gitlab restart
shell>> chown -R git:git /data/gitlab-data
shell>> exit

#### 6. 在宿主主机中配置反向代理
配置反向代理到docker容器中，具体配置参考gitlab.b-m.net.conf文件。
我们使用的是https，但是没有证书，所以需要自己生成一个，可以用下面的命令：
1

shell>> openssl req -newkey rsa:2048 -x509 -nodes -days 3560 -out gitlab.crt -keyout gitlab.key

#### 7. 访问
在浏览器中输入地址访问即可
### 四、使用中的一些问题
#### 1. 设置git忽略对https的检测
由于我们使用的是自签名证书，git会对https进行检测，所以需要设置git对它忽略
1

shell>> git config --global http.sslVerify "false"

#### 2. 让git记住用户名和密码
编辑工程目录下的.git/config，在最后增加
1
2

[credential]
helper = store
]]> ### 一、准备docker容器环境

1. 下载docker ubuntu镜像

1

shell>> docker pull ubuntu

#### 2. 启动ubuntu镜像并更新

1
2
3

shell>> docker run -it docker.io/ubuntu
# 更新操作在ubuntu容器中进行
shell>> apt-get -y update
]]> <![CDATA[docker使用自定义网桥]]> /2015/04/24/docker使用自定义网桥/ 2015-04-24T06:19:26.000Z 2015-05-31T06:22:34.000Z 参考网址：https://docs.docker.com/articles/networking/

1
2
3
4

$ sudo service docker stop
$ sudo ip link set dev docker0 down
$ sudo brctl delbr docker0
$ sudo iptables -t nat -F POSTROUTING

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

# Create our own bridge

$ sudo brctl addbr docker-bridge
$ sudo ip addr add 192.168.5.1/24 dev docker-bridge
$ sudo ip link set dev docker-bridge up

# Confirming that our bridge is up and running

$ ip addr show docker-bridge
4: docker-bridge: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state UP group default
    link/ether 66:38:d0:0d:76:18 brd ff:ff:ff:ff:ff:ff
    inet 192.168.5.1/24 scope global docker-bridge
       valid_lft forever preferred_lft forever

# Tell Docker about it and restart (on Ubuntu)

$ echo 'DOCKER_OPTS="-b=docker-bridge"' >> /etc/default/docker
$ sudo service docker start

# Confirming new outgoing NAT masquerade is set up

$ sudo iptables -t nat -L -n
]]> 参考网址：https://docs.docker.com/articles/networking/

1
2
3
4

$ sudo service docker stop
$ sudo ip link set dev docker0 down
$ sudo brctl delbr docker0
$ sudo iptables -t nat -F POSTROUTING
]]> <![CDATA[常见的负载均衡的方式]]> /2015/04/10/常见的负载均衡的方式/ 2015-04-10T06:29:55.000Z 2015-05-31T06:31:34.000Z 1 负载均衡

1.1 场景引入

Tomcat最大能承受的访问量是300，现在需要处理同时并发1000的访问量，应该怎么做？

1.2 负载均衡的概念

百度百科的解释。
负载均衡 建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。
负载均衡，英文名称为Load Balance，其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。

2 常见的负载均衡的方式

2.1 基于DNS

在DNS上做负载均衡。

2.2 基于反向代理服务器（Apache、Nginx）

正向代理和反向代理的区别。
Nginx的配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

upstream pandawork {
    server 192.168.1.25;
    server 192.168.1.30;
}
server {
    listen       80;
    server_name  www.pandawork.net;

    location / {
        proxy_set_header   Host             $host;
        proxy_set_header   X-Real-IP        $remote_addr;
        proxy_set_header  X-Forwarded-For  $proxy_add_x_forwarded_for;
        client_max_body_size       12m;
        client_body_buffer_size    128k;
        client_body_temp_path      data/client_body_temp;
        proxy_connect_timeout      90;
        proxy_send_timeout         90;
        proxy_read_timeout         90;
        proxy_buffer_size          4k;
        proxy_buffers              4 32k;
        proxy_busy_buffers_size    64k;
        proxy_temp_file_write_size 64k;
        proxy_temp_path            data/proxy_temp;

        proxy_pass http://pandawork;
    }
}
5种方式的分配:
1、轮询（默认）
每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。
upstream pandawork {
    server 192.168.1.25;
    server 192.168.1.30;
}

2、weight
指定轮询几率，weight和访问比率成正比，用于后端服务器性能不均的情况。
upstream pandawork {
    server 192.168.1.25 weight=10;
    server 192.168.1.30 weight=10;
}

3、ip_hash
每个请求按访问ip的hash结果分配，这样每个访客固定访问一个后端服务器，可以解决session的问题。
upstream pandawork {
    ip_hash;
    server 192.168.1.25
    server 192.168.1.30;
}

4、fair（第三方）
按后端服务器的响应时间来分配请求，响应时间短的优先分配。
upstream pandawork {
    server 192.168.1.25;
    server 192.168.1.30;
    fair;
}

5、url_hash（第三方）
按访问url的hash结果来分配请求，使每个url定向到同一个后端服务器，后端服务器为缓存时比较有效。
upstream pandawork {
    server 192.168.1.25;
    server 192.168.1.30;
    hash $request_uri;
    hash_method crc32;
}

2.3 基于NAT

NAT（Network Address Translation 网络地址转换）简单地说就是将一个IP地址转换为另一个IP地址，一般用于未经注册的内部地址与合法的、已获注册的Internet IP地址间进行转换。适用于解决Internet IP地址紧张、不想让网络外部知道内部网络结构等的场合下。每次NAT转换势必会增加NAT设备的开销，但这种额外的开销对于大多数网络来说都是微不足道的，除非在高带宽有大量NAT请求的网络上。 NAT负载均衡将一个外部IP地址映射为多个内部IP地址，对每次连接请求动态地转换为一个内部服务器的地址，将外部连接请求引到转换得到地址的那个服务器上，从而达到负载均衡的目的。
NAT负载均衡是一种比较完善的负载均衡技术，起着NAT负载均衡功能的设备一般处于内部服务器到外部网间的网关位置，如路由器、防火墙、四层交换机、专用负载均衡器等，均衡算法也较灵活，如随机选择、最少连接数及响应时间等来分配负载。
NAT负载均衡可以通过软硬件方式来实现。软件的方式如Linux的iptables就可以实现。硬件方式就是集成了NAT服务的硬件，通常这样的硬件设备是第四层交换机和专用负载均衡器，第四层交换机的一项重要功能就是NAT负载均衡。
由于NAT是在第四层上做负载均衡，因此可用于出web外的多种服务，如ftp。

2.4 基于LVS

LVS是Linux Virtual Server的简写，意即Linux虚拟服务器，是一个虚拟的服务器集群系统。本项目在1998年5月由章文嵩博士成立，是中国国内最早出现的自由软件项目之一。
三种转发机制：
1 Virtual Server via NAT
2 Virtual Server via IP Tunneling
Virtual Server和响应服务器间建立IP隧道，响应服务器可以在远端，响应直接由响应服务器返回给客户端。
3 Virtual Server via Direct Routing
Virtual Server直接将请求转发给响应服务器，响应服务器和Virtual Server必须在一个物理局域网内，响应直接由响应服务器返回给客户端。
参考：http://www.360doc.com/content/12/1117/19/820209_248441825.shtml

2.5 基于NLB

NLB(Network Load Balancing),网络负载平衡。
特点：
（1）NLB集群可以将两台或更多服务器结合起来使用
（2）一个NLB集群最多支持32台计算机
（3）NLB集群只能用于各节点的服务与数据完全相同的情况
（4）增强 Web、FTP、VPN等服务的可靠性和可伸缩性
NLB的工作原理
（1）集群中的每台服务器都有固定IP地址
（2）集群中的每台服务器还有一个共同的IP地址—NLB的集群IP地址
（3）NLB将客户端的访问信息发送给群集中的所有节点
（4）NLB算法决定提供服务的节点—其他不提供服务的节点丢弃访问请求
（4）NLB通过单播或多播来确保算法的特点

2.6 基于硬件

比较流行的是F5，价格相当高，最便宜的也要10几万。
http://network.51cto.com/art/201004/196752.htm
http://network.51cto.com/art/201004/196752.htm

]]> 1 负载均衡

1.1 场景引入

Tomcat最大能承受的访问量是300，现在需要处理同时并发1000的访问量，应该怎么做？

1.2 负载均衡的概念

百度百科的解释。
负载均衡 建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的灵活性和可用性。
负载均衡，英文名称为Load Balance，其意思就是分摊到多个操作单元上进行执行，例如Web服务器、FTP服务器、企业关键应用服务器和其它关键任务服务器等，从而共同完成工作任务。

]]> <![CDATA[Leetcode-MinStack]]> /2014/11/14/2014-11-13-MinStack/ 2014-11-14T15:55:37.000Z 2014-11-15T03:32:56.000Z 先给出题目的地址吧:https://oj.leetcode.com/problems/min-stack/

昨天一个同学问了我这道题，回去就做了一下。
初看这道题，好像并不难，push、pop、top都是栈的基本操作，getMin好像不太好搞。
首先想到的是用一个变量min记录一下栈的最小值，每次压栈的时候比较压栈元素和min的大小，更新min值。
这个想法好像还不错，于是搞之，一交WA了。
仔细一想，如果当前的min值是栈顶的值，把栈顶的值pop之后，这个min值就不再是栈中最小的值了，此时最小值变成了栈中的次小值了。
自然就想到，能不能再记住次小值呢？当然是可以的。可是这样问题又来了，如果次小值再被弹出呢？那就不行了。
最后，想到的做法是，每次压栈的时候都去记住当前栈的最小值，把它记在栈顶上，这样栈顶就始终保存这当前栈的最小值。
于是，开开心心的去写代码，交之，TMD，居然告诉我MLE。
你大爷啊，这让我如何是好？
看了半天代码，实在没有内存需要优化的地方了。最后在内部类前面加了个static，然后就过了。
他就这么过了，加了个static为啥就过了呢？有点疑惑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package com.tcheung;

import java.util.Stack;

/**
 * MinStack
 *
 * @author: zhangteng
 * @time: 2014/11/14 21:12
 */
class MinStack {

    static class Element {
        int val, min;
        public Element(int val, int min) {
            this.val = val;
            this.min = min;
        }
    }

    private int min;

    private Stack<Element> stack = new Stack<Element>();

    public void push(int x) {
        if (stack.isEmpty()) {
            min = x;
        } else {
            min = Math.min(stack.peek().min, x);
        }
        stack.push(new Element(x, min));
    }

    public void pop() {
        stack.pop();
    }

    public int top() {
        return stack.peek().val;
    }

    public int getMin() {
        return stack.peek().min;
    }
}
]]> 先给出题目的地址吧:https://oj.leetcode.com/problems/min-stack/

]]> <![CDATA[CentOS安装多个Mysql]]> /2014/11/07/2014-11-07-cetos-install-muti-mysql/ 2014-11-07T12:57:05.000Z 2014-11-15T05:39:19.000Z 安装的mysql占用端口分别为3306和3307

下载mysql-5.6.20-linux-glibc2.5-x86_64.tar.gz，这个是编译完的二进制包

可阅读文件夹下的INSTALL-BINARY进行安装

两个mysql都安装在opt下面

3306安装命令如下

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

shell> groupadd mysql

shell> useradd -r -g mysql mysql

shell> cd /opt

shell> tar zxvf mysql-5.6.20-linux-glibc2.5-x86_64.tar.gz

shell> mv mysql-5.6.20-linux-glibc2.5-x86_64 mysql3306

shell> cd mysql3306

shell> mkdir log

shell> mkdir tmp

shell> chown -R mysql .

shell> chgrp -R mysql .

shell> scripts/mysql_install_db --user=mysql

shell> chown -R root .

shell> chown -R mysql data

shell> cp support-files/my-default.cnf my.cnf

shell> cp support-files/mysql.server /etc/init.d/mysqld3306

修改my.cnf,内容如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/5.6/en/server-configuration-defaults.html
# *** DO NOT EDIT THIS FILE. It's a template which will be copied to the
# *** default location during install, and will be replaced if you
# *** upgrade to a newer version of MySQL.

[mysqld]

# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M

# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin

# These are commonly set, remove the # and set as required.
 basedir = /opt/mysql3306 
 datadir = /opt/mysql3306/data 
 port = 3306 
# server_id = 
 socket = /tmp/mysql3306.sock
 pid-file=/opt/mysql3306/tmp/mysql.pid

# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M 

sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES 

#log
log-error=/opt/mysql3306/log/error.log
general_log=ON
general_log_file=/opt/mysql3306/log/mysql.log
long_query_time=2
#log-show-queries=/opt/mysql3306/log/showquery.log
log-bin=/opt/mysql3306/log/bin.log
expire_logs_days=15
sync_binlog=1
#max_binlog_cache_size = 4294967295
local-infile=0
[mysqld_safe]
log-error=/opt/mysql3306/mysqld3306.log
pid-file=/opt/mysql3306/mysqld.pid

修改/etc/init.d/mysqld3306
主要修改如下
1
2
3
4
5
6
7
8

basedir=/opt/mysql3306
datadir=/opt/mysql3306/data
conf=/opt/mysql3306/my.cnf

...

$bindir/mysqld_safe --defaults-file=$conf --datadir="$datadir" --pid-file="$mysqld_pid_file_path" $other_args >/dev/null 2>&1 &
      wait_for_pid created "$!" "$mysqld_pid_file_path"; return_value=$?

3307安装步骤如下

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

shell> tar zxvf mysql-5.6.20-linux-glibc2.5-x86_64.tar.gz

shell> mv mysql-5.6.20-linux-glibc2.5-x86_64 mysql3307

shell> cd mysql3307

shell> mkdir log

shell> mkdir tmp

shell> chown -R mysql .

shell> chgrp -R mysql .

shell> scripts/mysql_install_db --basedir=/opt/mysql2012 --datadur=/opt/mysql2012 --user=mysql

shell> chown -R root .

shell> chown -R mysql data

shell> cp support-files/my-default.cnf my.cnf

shell> cp support-files/mysql.server /etc/init.d/mysqld3307

修改my.cnf和/etc/init.d/mysqld3307,修改方式与3306的一样,只是将其中的3306改成3307即可。

最后，启动mysql
1
2
3

shell> service mysqld3306 start
shell> service mysqld3307 start
看见SUCCESS就成功了

开机自启动

1
2

shell> chkconfig --add mysqld3306
shell> chkconfig --add mysqld3307
]]> 安装的mysql占用端口分别为3306和3307

下载mysql-5.6.20-linux-glibc2.5-x86_64.tar.gz，这个是编译完的二进制包

可阅读文件夹下的INSTALL-BINARY进行安装

]]> <![CDATA[Windows下安装Redmine]]> /2014/09/09/2014-09-09-windows-install-redmine/ 2014-09-09T06:39:16.000Z 2014-11-15T05:36:27.000Z 准备工作

Redmine官网:http://www.redmine.org/
Ruby官网:http://rubyforge.org/

  1. 下载railsinstaller-2.2.3.exe
    这是Ruby环境的一键安装包，安装上它就可以安装上全部的Ruby环境。
    官网:http://railsinstaller.org/en
    此安装包包含如下内容：
    Ruby 1.9.3
    Rails 3.2
    Bundler
    Git
    Sqlite
    TinyTDS
    SQL Server Support
    DevKit

  1. 下载ImageMagick，这个是图型生成工具，redmine用于生成pdf等内容，也可以不安装。安装说明在这里
    我下载的是ImageMagick-6.8.4-0-Q16-x86-dll.exe
    下载地址:http://download.csdn.net/detail/lqt0307/5184966
    ps:我只找到了这个下载地址，需要1分，没有分的可以找我要。

  2. redmine
    这个就不用说了，上官网下就行，我用的版本是2.5.2。

  3. mysql
    redmine使用的数据库是mysql，所以需要安装mysql。

安装

  1. 安装railsinstaller
    如果不选择安装目录什么的，直接下一步就可以了。

  2. 解压redmine-2.5.2.zip

  3. 安装mysql
    这个就不多说了。

  4. 安装mysql2插件
    进入Railsinstaller安装目录下的DevKit，运行DevKit目录下的msys.bat
    输入:

    1

    gem install mysql2 -v=0.3.16 -- --with-mysql-dir="mysql安装目录"

    命令中的”mysql安装目录”要替换掉，要不要引号都可以

  5. 安装rmagick
    window下安装rmagick，需要手动安装，不能通过：gem install rmagick 进行安装。
    首先需要安装ImageMagick。安装方式可以参考http://www.redmine.org/projects/redmine/wiki/HowTo_install_rmagick_gem_on_Windows，上面讲得很详细。
    主要也是下一步、下一步就可以了，需要注意一下的是安装目录中最好不要有空格，我在这个地方被坑了好几次。

    安装完ImageMagick之后，就可以安装rmagick了。进入Railsinstaller安装目录下的DevKit，运行DevKit目录下的msys.bat。
    输入:

    1
2

    gem install -- --with-opt-lib="ImageMagick安装目录/lib"  --with-opt-include="
ImageMagick安装目录/include"

    命令中的”ImageMagick安装目录”要替换掉，要不要引号都可以。

  6. 数据库准备
    6.1. 把libmysql.dll复制到“RailsInstaller安装目录\Ruby1.9.3\bin”下面。
    6.2. 创建数据库

    1

    CREATE DATABASE db_redmine CHARACTER SET utf8;

    6.3. 修改redmine连接数据库文件
    redmine目录下的config/database.yml.example 改为config/database.yml
    第6行开始

    1
2
3
4
5
6

    production:
adapter: mysql2
database: redmine
host: localhost
username: root
password: my_password

  7. 目录下执行:

    1

    bundle install

  8. 初始化Redmine数据库环境

    1

    bundle exec rake db:migrate RAILS_ENV=production

  9. 生成session存储密钥

    1

    bundle exec rake generate_secret_token

  10. 启动Redmine

    1

    ruby script/rails server webrick -e production

将Redmine安装为Windows服务，开机自动运行

每次都用命令去启动Redmine还是很麻烦的，把Redmine安装成windows服务，让它能够开机自启动，还是很方便的。
Ruby提供一个安装Ruby程序为服务的包：mongrel_service。安装其实很简单，只要命令行下运行gem：

1

gem install mongrel_service

过程中安装一些必须的其他包。
然后将RedMine使用mongrel_service安装成Windows服务：
1

mongrel_rails service::install -N Redmine -c D:\WebRoot -p 3000 -e production

这里，我指定服务名为RedMine，我的Redmine在D:\WebRoot，你的要修改，注意指向Redmine的根目录。监听3000端口。
然后修改启动方式为自动启动，并添加MySQL服务为其依赖服务（如果你的MySQL服务器不是本机就不用麻烦了）：
1

sc config Redmine start= auto depend= MySQL

注意，执行sc config系列指令，服务必须是未启动的才行，否则会出错。
将来如果想去掉这个服务，只要执行：
1

mongrel_rails service::remove -N Redmine

也可以使用：sc delete Redmine 删除服务。

以上方式只适用于xp及xp以上系统，如果你的系统是server 2003，需要用下面这种方式：http://www.redmine.org/boards/1/topics/4123。
上面说得很详细了，我就不在累述。
1

rake redmine:plugins:migrate RAILS_ENV=production
]]> 准备工作

Redmine官网:http://www.redmine.org/
Ruby官网:http://rubyforge.org/

  1. 下载railsinstaller-2.2.3.exe
    这是Ruby环境的一键安装包，安装上它就可以安装上全部的Ruby环境。
    官网:http://railsinstaller.org/en
    此安装包包含如下内容：
    Ruby 1.9.3
    Rails 3.2
    Bundler
    Git
    Sqlite
    TinyTDS
    SQL Server Support
    DevKit
]]> <![CDATA[CentOS下安装Redmine]]> /2014/09/09/2014-09-09-centos-install-redmine/ 2014-09-09T06:37:15.000Z 2014-11-15T05:36:37.000Z Redmine的安装主要分为两部分：

  1. Ruby+Rails的安装
  2. Redmine的安装
    先说一下系统环境，我安装的系统是CentOS 5，选择的Redmine版本是2.5.2，Ruby的版本是1.9.3，Rails的版本是3.2.19。
    下面从以上两部分进行说明。

Ruby+Rails的安装

Ruby的安装有3中方式：

  1. 直接yum install ruby
  2. 源码编译安装
  3. 采用RVM安装
    以上3种方式我都尝试了，最后采用了RVM安装这种方式，这种方式也是最简单的。

  1. 下载RVM并且安装

    1

    curl -L https://get.rvm.io | bash -s stable

  2. 安装一些依赖库，编译安装其它软件或者库的时候会用到

    1
2

    yum install zlib zlib-devel sqlite-devel
yum install -y gcc-c++ patch readline readline-devel zlib zlib-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison iconv-devel

  3. 安装openssl，安装ruby的时候会使用到

    1

    rvm pkg install openssl

  4. 指定openssl的位置来安装ruby

    1

    rvm install 1.9.3 --with-openssl-dir=/usr/local/rvm/usr

  5. 指定使用Ruby版本

    1

    rvm use 1.9.2

  6. 安装Rails

    1

    gem install rails

经过以上步骤，Ruby和Rails就安装完毕了。
安装完Ruby之后，建议更改一下gem的镜像地址，原因你懂的。可以改到淘宝的gem镜像，参考一下网址：http://ruby.taobao.org/。上面有更改gem镜像的详细方法。

Redmine的安装

最推荐的做法是参考官方wiki（http://www.redmine.org/projects/redmine/wiki/RedmineInstall）

  1. 准备Redmine需要用到的数据库环境
    1.1. 修改Redmine数据库配置文件
    进入Redmine目录

    1
2

    cp config/database.yml.example config/database.yml  
vi database.yml

    按照下面的内容进行修改
    1
2
3
4
5
6
7

    production:  
adapter: mysql2  
database: db_redmine  
host: localhost  
username: root  
password: <你的mysql密码>  
ps: 其中的一些值需要根据实际情况

    1.2. 进入Mysql创建数据库

    1

    create database redmine character set utf8;

  2. 初始化Redmine数据库环境

    1

    rake db:migrate RAILS_ENV=production

    执行此命令的时候会出现以下错误：
    1
2

    Could not find gem 'mocha (~> 1.0.0) ruby' in the gems available on this machine.
Run `bundle install` to install missing gems.

    报这个错误的原因是因为缺少mocha这个gem，类似的还有很多gem都缺失。解决方法就是根据提示一个一个安装（类似于gem install mocha -v=1.0.0这样的命令），另一种解决办法是使用bundle install自动安装所缺少的gem，推荐使用这种方式，这种方式会自动帮你下载所依赖的gem，并且还能解决它们之间的版本冲突问题。
    通过bundle install命令基本可以安装上所有依赖的gem，除了一个，rmagick，这个gem还需要依赖ImageMagick，他是用于处理一些图片转换之类的工作的。由于rmagick需要依赖ImageMagick，所以使用bundle install会安装失败，需要现在系统中安装ImageMagick。
    解决方法如下：
    2.1. 如果你的CentOS版本比较新，可直接采用yum安装
    1

    	yum install ImageMagick-devel

    2.2. 源码编译安装
    去官网下载源码(http://www.imagemagick.org/script/install-source.php#unix)
    上面有安装教程，建议安装上面的步骤进行安装。
    下面列出我安装时执行的命令：

    1
2
3
4
5

    	tar xvzf ImageMagick.tar.gz
    cd ImageMagick-6.8.9
    ./configure
    make
    make install

    经过上面的步骤将gem都安装完之后，还需要再次执行rake db:migrate RAILS_ENV=production，这一步的主要作用是在数据库中生成Redmine需要的数据库表。

  3. 生成Redmine的Session存储

    1

    rake generate_secret_token

  4. 启动Redmine

    1

    ruby script/rails server webrick -e production

    这条命令不是后台运行，建议使用如下命令，让redmie在后台运行
    1

    ruby script/rails server -e production -d > /dev/null 2>&1 &

    可将上述命令加入/etc/local中，使得Redmine可以在系统启动时就启动。

在使用过程中可能会遇到如下错误：

1

ActionView::Template::Error (incompatible character encodings: UTF-8 and ASCII-8BIT)

解决方法如下：
1
2

rake assets:precompile
然后重启rails server。

插件安装

Redmine还可以安装一些插件，来帮助我们进行项目管理。
我们现在安装的插件有crumpm、code review、scrum、Aginle。
code review下载地址:http://www.redmine.org/plugins/codereview
scrum下载地址:https://redmine.ociotec.com/projects/redmine-plugin-scrum
Aginle下载地址:http://www.redmine.org/plugins/redmine_agile

插件安装步骤:

  1. 下载插件，解压到Redmine安装目录下的plugins文件夹下
  2. 在Redmine安装目录下执行:
    1

    rake redmine:plugins:migrate RAILS_ENV=production
  3. 重启Redmine

安装过程的参考资料如下：

  1. http://lxiaodao.iteye.com/blog/1579992
  2. http://note.youdao.com/share/?id=610d4aea90c5d7281b61dfcb1cd41906&type=note
  3. http://blog.sina.com.cn/s/blog_8254427901016z1l.html
]]> Redmine的安装主要分为两部分：

  1. Ruby+Rails的安装
  2. Redmine的安装
    先说一下系统环境，我安装的系统是CentOS 5，选择的Redmine版本是2.5.2，Ruby的版本是1.9.3，Rails的版本是3.2.19。
    下面从以上两部分进行说明。

Ruby+Rails的安装

Ruby的安装有3中方式：

  1. 直接yum install ruby
  2. 源码编译安装
  3. 采用RVM安装
    以上3种方式我都尝试了，最后采用了RVM安装这种方式，这种方式也是最简单的。
]]> <![CDATA[code-standards]]> /2014/07/19/code-standards/ 2014-07-19T14:42:52.000Z 2014-11-14T15:35:47.000Z 后端

工程结构

分为service和web

注释

  1. 类头要写明该类的职责是什么。
    for example:

    1
2
3
4
5
6
7
8

    /**
 * 职责
 * @Description
 *
 * @author zhangteng
 * @email zhangt@pandawork.net
 * @time: 2014/7/9 14:25
 */

  2. 方法要写明该方法的功能是什么。

    1
2
3
4
5
6
7
8
9
10

    /**
 * 获取分页列表
 *
 * @param curPage
 * @param code
 * @param name
 * @param startTime
 * @param endTime
 * @return
 */
  3. 方法里面要有适当的注释。不能写了一个方法100行，一个注释都没有。
  4. 数据库表要有一个总的声明，每个字段有相关说明。
  5. 实体或者业务修改，也要修改相关数据表中表对应的字段说明。保持一致。

后端规范

类名称

  1. 以大写字母开头。
  2. 以驼峰方式命名。

属性名、方法名

  1. 以小写字母开头。
  2. 以驼峰方式命名。

常量命名规范

  1. 所有字母大写
  2. 单词之间用’_’分隔

service,mapper方法名

方法名，根据不同的功能，按照不同的前缀进行设计。如下表：

功能说明 前缀
计算数量 count
获取列表 list
查询功能 query
创建 add
删除 del
修改 update

controller命名规范

功能说明 前缀
计算数量 count
获取列表 list
查询功能 query
创建 add
删除 del
修改 update

如果是ajax，则需要在此前加上ajax。例如：
要通过ajax按照ID删除一个产品，方法名为ajaxDelProductById

URL规范

URL结构

下面，我们以用户为例。

  • CREATE
    /user/new GET 这个Url负责跳转到提交表单的页面，用Get方法
    /user POST 负责接收表单提交的数据，用POST方法
  • DELETE
    /user/{id}/del GET 跳转到提交删除请求的页面，用GET方法（可选）
    /user/{id} DELETE 负责接收要删除的用户的数据，用DELETE方法
  • UPDATE
    /user/{id}/update GET 跳转到用户修改的页面，用GET方法
    /user/{id} PUT 负责接收表单提交的数据，修改用户，用PUT方法
  • READ
    /user GET 跳转到查看用户列表的页面，用GET方法
    /user/{id} GET 跳转到查看某个用户的页面，用GET方法
  • OTHER
    /user/{id}/lock PUT 有些时候，为了表示某一动作对用户产生的变化，我们这样命名，比如用户的锁定
  • 分页
    /user/{curPage} GET 大家可以用这个来进行获取分页列表

mapper层SQL语句书写规范

书写SQL语句时，SQL中的关键字全部采用大写，如下所示

1

SELECT * FROM `t_quality_check_item`

SELECT、FROM、INSERT INTO、UPDATE、DELETE、AND、OR、LIKE、LIMIT、ORDER等关键字，在mapper中书写SQL语句时均采用大写。

### 后端开发注意事项
1. 职责单一化
要确保所写的程序职责单一，例如，有ProductService，和一个DiscountService，两者的区别在于一个是对产品的操作，另外一个是折扣的业务，在ProductService中，出现直接调去DiscountMapper的方法。
如上例，一个方法可以，多了，整个工程会出现轮乱局面，正确做法是走discountService进行相关的折扣计算。
2. 重复方法
此类问题最为严重，禁止在同一个Service中，或在mapper中出现多个名称不一样，但功能一样的方法。

## 数据库
### 数据库表名命名规则
1. 表名由前缀和实际名字组成，前缀和实际名字之间使用“”连接。前缀使用“t”，实际名字都使用小写单词，多个单词之间使用“”连接。例如：tstudent_info
2. 如果要进行分表时，表的命名直接在表名的后面加上分表的标志。例如，t_user001,t_user002,t_user003
3. 表名的构成有t模块名称自己的表名。

### 字段命名规则
1. 每一个表都将有一个自动id作为主健,逻辑上的主健作为第一组候选主健来定义,如果是数据库自动生成的编码，统一命名为：id;如果是自定义的逻辑上的编码则用缩写 加“id”的方法命名。
2. 采用前缀命名。给每个表的列名都采用统一的前缀，后面的单词或则缩写都以大写字母开头

### 数据表的存储引擎和索引约定规则
1. 现在所有表的存储引擎都要选择InnoDB，如果需要设为其他存储引擎的时，要特别说明。
2. 在建立查询时候，务必要建立好数据库的索引，在确保查询语句使用正确高效可靠以后，养成马上建立对于索引的习惯。
3. 索引名称格式如下：
* index\索引类型_表名_按照索引顺序编写字段名，以_为分隔符。
index_t_books_isbn（普通索引） index_unique_t_books_isbn(构建唯一索引)

索引的类型一般有三种类型，分别是普通索引（数据库中的index）, 唯一索引（数据库中的index unique),全文索引，这个基本上我们不会使用。

1
2
3
4
5
6
7

url:{
    index:{
        login:{
            check: '${website}index/login/check'
        }
    }
}
]]> 后端

工程结构

分为service和web

注释

  1. 类头要写明该类的职责是什么。
    for example:

    1
2
3
4
5
6
7
8

    /**
 * 职责
 * @Description
 *
 * @author zhangteng
 * @email zhangt@pandawork.net
 * @time: 2014/7/9 14:25
 */

    ]]>
 <![CDATA[grub2修复windows引导]]> /2014/07/12/grub2-repair-windows/ 2014-07-12T04:39:43.000Z 2014-11-14T15:35:55.000Z 可参考网址http://blog.csdn.net/hengyunabc/article/details/6071683

今天装了个centos 7，进去之后发现没有windows引导了，centos 7开始用grub 2引导了。
首先可以试试:

1

$ gurb2-mkconfig -o /boot/grub/grub.cfg

它非常智能，能自动检测电脑上安装的操作系统，将它们加入到引导中去。
不过，有时候它也不好使，就像我今天这样。

可以采用第二种方式，手动修改/boot/grub/grub.cfg

首先查看分区的UUID

1

$ blkid

找到windows所在分区的UUID。一定要记住UUID，不要记住分区号，因为分区号有可能改变，但是UUID一定不会变。
然后修改grub.cfg

1

$ vim /boot/grub/grub.cfg

在该文件中加入如下内容:

1
2
3
4
5
6

menuentry "windows 8" {
    insmod chain
    insmod ntfs
    search --fs-uuid --set 10ac99d8ac99b8a4
    chainloader +1
}

其中的“10ac99d8ac99b8a4”要替换为上一步记住的UUID。

最后，重启电脑就可以看到windows 8的引导了，选择就可以进入系统了。

]]> 可参考网址http://blog.csdn.net/hengyunabc/article/details/6071683

今天装了个centos 7，进去之后发现没有windows引导了，centos 7开始用grub 2引导了。
首先可以试试:

1

$ gurb2-mkconfig -o /boot/grub/grub.cfg

它非常智能，能自动检测电脑上安装的操作系统，将它们加入到引导中去。
不过，有时候它也不好使，就像我今天这样。

]]> <![CDATA[markdown语法简介]]> /2014/07/07/markdown-grammar/ 2014-07-07T12:41:20.000Z 2014-11-14T15:36:17.000Z 本文摘抄自http://wowubuntu.com/markdown/，旨在联系一下markdown的语法，同时也向大家介绍一下markdown的语法，方便大家和自己查阅。

Markdown 语法说明（简体中文版）

概述

宗旨

Markdown的目标是实现「易读易写」。

可读性，无论如何，都是最重要的。一份使用Markdown格式撰写的文件应该可以直接以纯文本发布，并且看起来不会像是由许多标签或是格式指令所构成。Markdown语法受到一些既有text-to-HTML格式的影响，包括Setext、atx、Textile、reStructuredText、Grutatext和EtText，而最大灵感来源其实是纯文本电子邮件的格式。

总之，Markdown的语法全由一些符号所组成，这些符号经过精挑细选，其作用一目了然。比如：在文字两旁加上星号，看起来就像*强调*。Markdown的列表看起来，嗯，就是列表。Markdown的区块引用看起来就真的像是引用一段文字，就像你曾在电子邮件中见过的那样。

兼容 HTML

Markdown语法的目标是：成为一种适用于网络的书写语言。

Markdown不是想要取代HTML，甚至也没有要和它相近，他的语法种类很少，只对应HTML标记的一小部分。Markdown的构想不是要使得HTML文档更容易书写。在我看来，HTML已经很容易书写了。Markdown的理念是，能让文档更容易读、写和随意改。HTML是一种发布的格式，Markdown是一种书写的格式。就这样，Markdown的格式语法只涵盖纯文本可以涵盖的范围。

不在Markdown涵盖范围之内的标签，都可以直接在文档里面用HTMl撰写。不需要额外标注这是HTML或是Markdown；只要直接加标签就可以了。

要制约的只有一些HTML区块元素—比如<div>、<table>、<pre>、<p>等标签，必须在前后加上空行与其它内容区隔开，还要求它们的开始标签与结尾标签不能用制表符或空格来缩进。Markdown的生成器有足够只能，不会在HTML区块标签外加上不必要的<p>标签。

例子如下，在 Markdown 文件里加上一段 HTML 表格：

这是一个普通段落。

<table>
    <tr>
        <td>Foo</td>
    </tr>
</table>

这是另一个普通段落。

请注意，在 HTML 区块标签间的 Markdown 格式语法将不会被处理。比如，你在 HTML 区块内使用 Markdown 样式的*强调*会没有效果。

HTML的区段（行内）标签如<span>、<cite>、<del>可以在Markdown的段落、列表或是标题里随意使用。依照个人习惯，甚至可以不用Markdown格式，而直接此阿勇HTML标签来格式化。举例说明：如果比较喜欢HTML的<a>或<img>标签，可以直接使用这些标签，而不用Markdown提供的链接或是图像标签语法。

和处在HTML区块标签件不同，Markdown语法在HTML区段标签间是有效的。

]]> 本文摘抄自http://wowubuntu.com/markdown/，旨在联系一下markdown的语法，同时也向大家介绍一下markdown的语法，方便大家和自己查阅。

Markdown 语法说明（简体中文版）

]]> <![CDATA[新博客的第一篇博文]]> /2014/07/06/new-blog-first-post/ 2014-07-06T12:59:23.000Z 2014-07-06T13:08:55.000Z 以前在github上用octopress挂了一个博客，但是用它还得装ruby，感觉比较麻烦（主要还是不懂ruby）。
前段时间，看到有人用hexo搭建博客，我也试了试。hexo是基于node，比octopress方便多了，就转了过来。
这是他的官网http://hexo.io/，关于具体怎么搭建，我就不多说了，官网写得和详细，直接上官方文档的链接http://hexo.io/docs/index.html。
说说我遇到的问题吧，按照官网说的做了，我用hexo deploy，一直deploy上去，也不知道为啥，可能主要还是我对node和git都不熟悉吧。
最后我是手动deploy的。具体命令如下：

1
2
3
4

$ hexo clean
$ hexo deploy --generate
$ cd .deploy
$ git push -u origin master

命令都是在hexo博客的目录下执行的。
另外奉上我使用的主题地址:http://yangjian.me/pacman/hello/introducing-pacman-theme/

]]> <![CDATA[jquery使用笔记]]> /2013/11/01/2013-11-01-jquery-study/ 2013-11-01T02:43:00.000Z 2014-11-15T05:39:07.000Z
  • ajax请求，注意最后一个值的地方没有逗号
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    $.ajax({  
    type: "POST",
    url: "mystructs/hello_jsonTest.action",
    data: {
        number: $("#number").val(),
        userId: $('#userId').val() 
    },
    dataType: "text",  //ajax返回值设置为text（json格式也可用它返回，可打印出结果，也可设置成json）
    success: function(json) {
        var res = $.parseJSON(json);
        alert(res.result);
    },
    error: function(json) {
        alert(json);
    }
});
    1. jquery改变值
      1
2

      $('#id').val('value');
$('#id').html('value');
    2. jquery获取radio中被选中的那个元素
      1
2
3
4
5
6

      var val = $('input:radio[name="ra"]:checked').val();
if(val != null) {
    alert(val);
} else {        
    ...
}

      判读radio是否被选中
      1
2
3
4
5
6

      $('input:radio[name="ra"]').each(function() {
    //alert($(this).val());
    if($(this).attr("checked") == "checked") {
        alert($(this).val());
    }
});
    3. 获取选中的checkbox
      1
2
3

      $('input[name="chk"]:checked').each(function(){
    alert($(this).val());
});

      判读checkbox是否被选中
      1
2
3
4
5

      $('input:checkbox[name="chk"]').each(function() {
    if($(this).attr("checked") == "checked") {
        alert($(this).val());
    }
});
    ]]>
  • ajax请求，注意最后一个值的地方没有逗号
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    $.ajax({  
    type: "POST",
    url: "mystructs/hello_jsonTest.action",
    data: {
        number: $("#number").val(),
        userId: $('#userId').val() 
    },
    dataType: "text",  //ajax返回值设置为text（json格式也可用它返回，可打印出结果，也可设置成json）
    success: function(json) {
        var res = $.parseJSON(json);
        alert(res.result);
    },
    error: function(json) {
        alert(json);
    }
});
    • ]]>         <![CDATA[structs2返回json]]> /2013/10/30/2013-10-30-struts2-json/ 2013-10-30T01:28:00.000Z 2014-11-15T05:38:58.000Z structs2返回本身支持返回json，只需要配置即可，我们也可以自己把json串写入servlet输出流中。

    1.structs2本身对json的支持
    在action中对需要返回的值进行设置，实体、java自带类型都可以。
    如：

    1
2
3
4
5
6
7
8
9

    private User user;
private result result;

/*   setter and getter   */
public String json() {
    user.setUserName("iris");
    result = "success";
    return SUCCESS;
}

    在配置文件中配置result的type为json

    1
2
3
4
5
6
7

    <result-types>
    <result-type name="json" class="org.apache.struts2.json.JSONResult"/>
</result-types>

<action name="hello_*" class="action.FirstAction" method="{1}">
    <result name="success" type="json"></result>
</action>

    注意result-types那段一定要加上，不加那个的就必须让action所在的package继承json-default
    2.把json数据写入servlet输出流中
    在action中讲json数据直接写入servlet输出流中，action中的方法返回void
    如：

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

    public void newjsontest() {
    HttpServletResponse response = ServletActionContext.getResponse();
    PrintWriter out = null;
    try {
        out = response.getWriter();
    User user = new User();
    user.setUsername("iris");
    user.setPassword("iris");
    JSONObject jsonObject = JSONObject.fromObject(user);
    out.print(jsonObject.toString());
    out.flush();
    } catch (IOException e) {
    e.printStackTrace();
    } finally {
    if(out != null) {
        try {
    	        out.close();
    	    } catch (Exception e) {
            e.printStackTrace();
        }
        }
    }
}

    这里用到了net.sf.json.JSONObject这个包，将实体直接转换成json，也可以不用这个包，直接手动拼json串，然后out.write(jsonStr)。

    ]]>     structs2返回本身支持返回json，只需要配置即可，我们也可以自己把json串写入servlet输出流中。

    ]]>         <![CDATA[sublime利用snippet生成代码模版]]> /2013/10/23/2013-10-23-sublime-snippet/ 2013-10-23T06:20:00.000Z 2014-11-15T05:38:50.000Z tools->New Snippet新建一个snippet，保存为**.sublime-snippet。
    内容如下： 

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

    <snippet>
    <content>
    <![CDATA[
<!DOCTYPE HTML> 
<html> 
<head> 
    <meta charset="utf-8"> 
    <title>${1}</title> 
</head>
<body>
    ${1}
</body>
</html>
    ]]>
    </content>
    <!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
    <tabTrigger>myhtml</tabTrigger>
    <!-- Optional: Set a scope to limit where the snippet will trigger -->
    <!-- <scope>source.python</scope> -->
</snippet>sublime-snippet

    重启sublime，新建文件输入myhtml，然后按tab。

    ]]>     tools->New Snippet新建一个snippet，保存为**.sublime-snippet。
    内容如下：

    ]]>         <![CDATA[struts2文件上传]]> /2013/10/23/2013-10-23-struts-uploadfile/ 2013-10-23T01:02:00.000Z 2014-11-15T05:38:38.000Z 注意保持action中File的变量和jsp中input的name名相同。
    action中定义变量：

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

    package action;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import com.opensymphony.xwork2.ActionSupport;
public class UploadFileAction extends ActionSupport {
    
    // 上传的文件
    private File upload;
    
    // 上传的文件名
    private String uploadFileName;
    
    // 上传的文件类型
    private String uploadContentType;
    
    public String execute() throws Exception {
        FileInputStream fis = new FileInputStream(upload);
        File file = new File("E:/dsideal/upload/" +  uploadFileName);
        FileOutputStream fos = new FileOutputStream(file);
        byte[] buffer = new byte[8912];
        int count = 0;
        while((count = fis.read(buffer)) != -1) {
            fos.write(buffer, 0, count);
        }
        fos.close();
        fis.close();
        return SUCCESS;
    }
    
    /* set、get method */
}

    jsp页面:

    1
2
3
4
5

    <s:form action="mystruts/uploadFile.action" enctype="multipart/form-data">
    <s:file name="upload" label="输入要上传的文件名字" />
    <s:submit value="上传" />
    </s:form>
</body>

    使用了struts标签，也可以直接使用html表单标签form、input

    ]]>     注意保持action中File的变量和jsp中input的name名相同。
    action中定义变量：

    ]]>         <![CDATA[JSON和bean互转]]> /2013/10/21/2013-10-21-json-to-bean/ 2013-10-21T01:32:00.000Z 2014-11-15T05:38:32.000Z 需要用到的类：

    net.sf.json.JSONObject

    在包json-lib-2.3-jdk15中

    maven依赖：

    1
2
3
4
5
6

    <dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>
</dependency>

    将bean转换成JSONObject，调用JSONObject.fromObject(object)
    如：

    JSONObject jsonObject = JSONObject.fromObject(user);

    将JSONObject转换成bean，调用JSONObject.toBean(jsonObject, beanClass)
    如：

    User user = (User) JSONObject.toBean(jsonObject, User.class);
    ]]>     需要用到的类：

    net.sf.json.JSONObject

    在包json-lib-2.3-jdk15中

    ]]>         <![CDATA[删除Java集合中元素]]> /2013/10/13/2013-10-13-remove-elemetns/ 2013-10-13T13:42:00.000Z 2014-11-15T05:38:24.000Z 有时候我们需要删除list中的某个元素，最开始我会这样写：

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

    public class ListTest {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList();
        for(int i = 1;i <= 10; ++i) {
            numbers.add(i);
        }

        for(int i = 0;i < 10; ++i) {
            if(numbers.get(i) == 5) {
                numbers.remove(i);
            }
        }

        System.out.println(numbers);
    }
}

    这样写之后，会报错。因为list在循环中的时候是不可以删除它的元素的。
    对上面的代码进行一点下改进就可以删除list中的元素了，就是在remove之后加个break就可以了。

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

    public class ListTest {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList();
        for(int i = 1;i <= 10; ++i) {
            numbers.add(i);
        }

        for(int i = 0;i < 10; ++i) {
            if(numbers.get(i) == 5) {
                numbers.remove(i);
                break;
            }
        }

        System.out.println(numbers);
    }
}

    上面的方法适用于只删除一个元素，可有的时候我们需要删除多个元素，上面的方法虽可行，但需要为每个需要删除的元素写个for循环，这样效率太低了。
    使用Iterator可以完成上面的操作。

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

    public class ListTest {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList();
        for(int i = 1;i <= 10; ++i) {
            numbers.add(i);
        }

        for(Iterator it=numbers.iterator() ;it.hasNext(); ) {
            Integer tmp = (Integer) it.next();
            if(tmp == 5) {
                it.remove();
            }
            if(tmp == 7) {
                it.remove();
            }
        }

        System.out.println(numbers);
    }
}

    上面的方法虽都可以删除元素，但都需要for循环，效率不高，但没有找到更好的方法。感觉java的Iterator没有c++的那么只能，用起来没有c++顺手。

    对Java的基础知识了解越多，代码就会写得越简洁

    ]]>     有时候我们需要删除list中的某个元素，最开始我会这样写：

    ]]>