Spring Framework 依赖注入

Spring Framework：4.3.14.RELEASE

本文主要是论述 Spring Framework 依赖注入。

依赖注入主要可以分为两类：

  • 基于构造函数的依赖注入
  • 基于Setter方法的依赖注入

基于构造函数的依赖注入

在 bean 标签内通过使用 constructor-arg 子标签进行构造函数的依赖注入。

  • value 属性：构造函数参数的值
  • type 属性：构造函数参数的类型
  • index 属性：构造函数参数的索引

创建一个 Car 类，并重载构造函数：

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

public class Car {
	
	private String brand;
	private double price;
	private int maxSpeed;
	
	public Car(String brand, double price, int maxSpeed) {
		this.brand = brand;
		this.price = price;
		this.maxSpeed = maxSpeed;
	}
	
	public Car(String brand, double price) {
		this.brand = brand;
		this.price = price;
	}
	
	public Car(String brand, int maxSpeed) {
		this.brand = brand;
		this.maxSpeed = maxSpeed;
	}
	
	@Override
	public String toString() {
		return "Car{" +
			"brand='" + brand + '\'' +
			", price=" + price +
			", maxSpeed=" + maxSpeed +
			'}';
	}
}

使用如下构造函数注入：

1
2
3
4
5
public Car(String brand, double price, int maxSpeed) {
	this.brand = brand;
	this.price = price;
	this.maxSpeed = maxSpeed;
}
1
2
3
4
5
<bean id="smart" class="com.example.spring.Car">
    <constructor-arg value="Smart"></constructor-arg>
    <constructor-arg value="250000"></constructor-arg>
    <constructor-arg value="100"></constructor-arg>
</bean>

如果按如下方式注入：

1
2
3
4
<bean id="bmw" class="com.example.spring.Car">
    <constructor-arg value="BMW"></constructor-arg>
    <constructor-arg value="250000"></constructor-arg>
</bean>

会选择哪个构造函数：

1
2
3
4
5
6
7
8
9
public Car(String brand, double price) {
	this.brand = brand;
	this.price = price;
}
	
public Car(String brand, int maxSpeed) {
	this.brand = brand;
	this.maxSpeed = maxSpeed;
}

故此时可通过 type 属性进行明确指定：

1
2
3
4
5
6
7
8
9
<bean id="audi" class="com.example.spring.Car">
    <constructor-arg type="java.lang.String" value="Audi"></constructor-arg>
    <constructor-arg type="double" value="250000"></constructor-arg>
</bean>

<bean id="ferrari" class="com.example.spring.Car">
    <constructor-arg type="java.lang.String" value="Ferrari"></constructor-arg>
    <constructor-arg type="int" value="380"></constructor-arg>
</bean>

也可以通过 index 属性进行指定：

1
2
3
4
5
 <bean id="ford" class="com.example.spring.Car">
    <constructor-arg index="0" value="Ford"></constructor-arg>
    <constructor-arg index="1" value="150000"></constructor-arg>
    <constructor-arg index="2" value="180"></constructor-arg>
</bean>

官方推荐使用构造函数注入，可以确保依赖项不为空
但是构造函数参数过多时，不合适

基于Setter方法的依赖注入

在 bean 标签内通过使用 property 子标签进行 Setter 方法的依赖注入。

  • name 属性：Bean 中的属性名称
  • value 属性：Bean 中的属性的属性值
  • value 子标签：等同于 value 属性
  • ref 属性：Bean 中的引用属性
1
2
3
<bean id="user" class="com.example.spring.User">
    <property name="name" value="Spring Framework"></property>
</bean>

或

1
2
3
<bean id="user" class="com.example.spring.User">
    <property name="name"><value>Spring Framework</value></property>
</bean>

或 

1
2
3
<bean id="foo" class="com.example.spring.Foo">
    <property name="user" ref="user"></property>
</bean>

基于 Setter 方法的依赖注入可以在 Setter 方法上添加 @Required 注解标识该属性是必须注入的依赖项：

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
import org.springframework.beans.factory.annotation.Required;

public class RequiredFoo {
	
	private String name;
	
	private Boolean required;
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public Boolean getRequired() {
		return required;
	}
	
	@Required
	public void setRequired(Boolean required) {
		this.required = required;
	}
}

上述示例中，若进行 Setter 注入时，required 属性不注入则会提示错误

基于 Setter 方法的依赖注入是最常用的依赖注入方式
基于 Setter 方法的依赖注入可以让依赖项可控

并且基于基于构造函数的依赖注入和基于 Setter 方法的依赖注入可以同时使用

代码请参考example-04:
lxmuse-spring-example-04

展开全文 >>

Spring Framework Bean 实例化

Spring Framework：4.3.14.RELEASE

本文主要是论述 Spring Framework IOC 容器中 Bean 的实例化。

Bean 的实例化主要是两种方式：

  • 通过构造函数实例化
  • 通过静态方法实例化

通过构造函数实例化

通过构造函数实例化，前提条件是 Bean 含有一个无参构造器，可以是隐式无参构造器，也可以是显式无参构造器。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ExampleBeanOne {

	private String name;

	public void setName(String name) {
		this.name = name;
	}

	public String hello() {
		return "Hello " + name;
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ExampleBeanTwo {

	private String name;
	
	public ExampleBeanTwo() {
	}
	
	public ExampleBeanTwo(String name) {
		this.name = name;
	}
	
	public String hello() {
		return "Hello " + name;
	}

}
1
2
3
4
5
6
7
<bean id="exampleBeanOne" class="com.example.spring.ExampleBeanOne">
    <property name="name" value="ExampleBeanOne"></property>
</bean>

<bean id="exampleBeanTwo" class="com.example.spring.ExampleBeanTwo">
    <constructor-arg value="ExampleBeanTwo"></constructor-arg>
</bean>

通过静态方法实例化

通过静态方法实例化，前提条件是有一个静态方法可以实例化 Bean，可以是自身提供的静态方法，也可以是其他类提供的静态方法。

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

	private static ExampleBeanThree exampleBeanThree = new ExampleBeanThree("ExampleBeanThree");
	
	private String name;
	
	public static ExampleBeanThree createInstance() {
		return exampleBeanThree;
	}
	
	private ExampleBeanThree(String name) {
		this.name = name;
	}
	
	public String hello() {
		return "Hello " + name;
	}

}
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

public class ExampleBeanFive {
	private String name;
	
	public ExampleBeanFive() {
	}
	
	public ExampleBeanFive(String name) {
		this.name = name;
	}
	
	public String hello() {
		return "Hello " + name;
	}
}

public class ExampleBeanSix {
	
	private static ExampleBeanFive exampleBeanFive = new ExampleBeanFive("ExampleBeanFive");
	
	public ExampleBeanFive createClientInstance() {
		return exampleBeanFive;
	}
	
}
1
2
3
4
5
6
7
8
<bean id="exampleBeanThree" class="com.example.spring.ExampleBeanThree" factory-method="createInstance">
</bean>

<bean id="exampleBeanSix" class="com.example.spring.ExampleBeanSix">
</bean>

<bean id="exampleBeanFive" factory-bean="exampleBeanSix" factory-method="createClientInstance">
</bean>

通过静态方法实例化不常见，推荐使用构造函数实例化

代码请参考example-03:
lxmuse-spring-example-03

展开全文 >>

Spring Framework Bean 命名

Spring Framework：4.3.14.RELEASE

本文主要是论述 Spring Framework IOC 容器中 Bean 的命名。

  • 每个 Bean 在 IOC 容器内都需要有身份标识
  • 每个 Bean 可以拥有一个或多个身份标识
  • 任意一个身份标识需要在 IOC 容器内唯一

基于 XML 方式的元数据配置方式中：

  • Bean 的身份标识通过 id 或 name 属性标识。
  • id 只能声明一个身份标识
  • name 可以声明一个或一个以上的身份标识，多个身份标识之间通过逗号、分号、空格进行分隔

id 命名 Bean:

1
2
3
<bean id="helloWorld" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>

name 命名 Bean:

1
2
3
<bean name="helloWorld" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>
1
2
3
<bean name="helloWorld,helloWorld1" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>
1
2
3
<bean name="helloWorld;helloWorld1" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>
1
2
3
<bean name="helloWorld helloWorld1" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>

id 和 name 一起命名 Bean:

1
2
3
<bean id="helloWorld" name="helloWorld2,helloWorld3" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>

Bean 默认命名：

id 和 name 属性并不是必须的，若未进行声明，Spring Framework 将使用默认策略对 Bean 进行命名。
默认使用 类名的首字母小写名称作为 Bean 的身份标识。
但是推荐进行命名。

Bean 别名：

当 Bean 拥有多个身份标识时，他们等同于互为别名。但 Spring Framework 支持通过别名标签为 Bean 设置别名。

1
2
3
4
5
<bean id="helloWorld" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>

<alias name="helloWorld" alias="helloWorld2"></alias>
1
2
3
4
5
<bean name="helloWorld" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>

<alias name="helloWorld" alias="helloWorld2"></alias>
1
2
3
4
5
<bean id="helloWorld" name="helloWorld1" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>

<alias name="helloWorld1" alias="helloWorld2"></alias>
1
2
3
4
5
6
<bean id="helloWorld" name="helloWorld1" class="com.example.spring.HelloWorld">
	<property name="name" value="Example"></property>
</bean>

<alias name="helloWorld1" alias="helloWorld2"></alias> 
<alias name="helloWorld2" alias="helloWorld3"></alias>
  • alias 标签中 name 属性需是 Bean 的 id 或 name 属性值
  • alias 标签中 alias 属性是别名值
  • alias 标签可以对同一个 Bean 进行不同的别名设置
  • alias 标签可以嵌套循环进行别名设置
  • alias 标签的 alias 属性不能设置多个值

特别的别名设置：

1
2
3
4
5
6
<bean id="helloWorld" class="com.example.spring.HelloWorld">
    <property name="name" value="Example"></property>
</bean>
<bean id="helloWorld2" class="com.example.spring.HelloWorld">
    <property name="name" value="Example"></property>
</bean>

代码请参考example-02:
lxmuse-spring-example-02

展开全文 >>

Spring Framework HelloWorld

Spring Framework：4.3.14.RELEASE

Framework Modules

创建一个简单的JavaBean：HelloWorld

1
2
3
4
5
6
7
8
9
10
11
12
13
public class HelloWorld {

	private String name;

	public void setName(String name) {
		this.name = name;
	}

	public void hello() {
		System.out.println("Hello " + name);
	}

}

创建一个简单的 applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

  <!--配置 Bean-->
  <bean id="helloWord" class="com.example.spring.HelloWorld">
    <property name="name" value="Example"></property>
  </bean>

</beans>

创建一个简单的使用示例

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

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWordTest02 {

	public static void main(String[] args) {
		// 创建 Spring IOC 容器
		ApplicationContext applicationContext =
			new ClassPathXmlApplicationContext("applicationContext.xml");

		// 从 IOC 容器中获取 Bean 实例
		HelloWorld helloWorld = applicationContext.getBean("helloWorld", HelloWorld.class);

		// 调用 setName 方法
		helloWorld.setName("Example");

		// 调用 hello 方法
		helloWorld.hello();
	}
}

代码请参考example-01:
lxmuse-spring-example-01

展开全文 >>

为什么使用 Spring Framework

今天聊一个老生常谈的问题：为什么使用 Spring Framework？

以下仅仅是根据个人的经验来谈论这个问题，仅供参考。

首先，我们需要达成一个共识：类相互之间必须存在依赖关系，才能支持业务系统，才能让软件系统更健壮，更灵活，更有可扩展性。

其实，将所有的业务逻辑在一个类内全部实现并不是不可以，但是这样其实违背人类偷懒的本性（扯大旗），我们总是想可以重复使用东西，减少使用成本。而提取可重复使用的过程就是软件开发中的抽象，而抽象和复用也是软件开发中的基础思想。当然也是因为抽象和复用，类与类之间就必然出现了依赖关系。

所以，因为一个健壮的系统，类与类之间必然存在依赖关系，类和方法必然存在抽象和复用。

其次，在达成上述共识之后，我们需要向办法简化类与类之间的依赖关系管理。

那怎么简化？这就是设计模式出现的原因之一了。设计模式就是对前人经验的总结。在有设计模式之前，类与类之间通过 new 关键字建立相互之间的关系，意味着类与类之间的关系需要调用方来进行维护，而维护的前提就是需要知晓被调用方。

设计模式如工厂模式，就是引入了第三方角色，由第三方集中统管类与类之间的依赖关系，调用方此时可以不需要明确知道被调用方，将由之前的 1 X N 的关系变成和第三方角色的 1 X 1 的关系，简化了复杂度。

调用者获取被调用者将由 new 变成 get，由创建变成获取，但是创建和调用被调用者控制权还是由调用者掌握。

最后，调用者释放控制权

在上一步共识中，调用者释放了类与类之间依赖关系的维护，将依赖关系维护交于第三方角色（对象创建工厂）维护，但是调用者还掌握着创建和调用被调用者的控制权，此时调用者连个也想放弃，交与第三方角色控制。

要实现这一步，一般来说需要借助于配置文件和反射机制了（不解释具体原理了）。

通过配置文件和反射机制并结合工厂模式，类的创建工厂完全可以实现类与类依赖关系的维护，类的创建，类的实例化，给调用者直接赋予被调用者实例。

调用者获取被调用将由 get 变成 set，由自身主动获取，变成被动接受第三方的给予。

其实Spring Framework 实现的就是上述工作，只是由开源组织统一实现了，我们不需要自己做这方面的工作，直接拿来主义。

当然了 Spring Framework 不仅仅只有 IOC 容器 ，还有 AOP ，声明式事务，集成第三方优秀框架等等功能。

个人觉得可以换个角度思考这个问题，而不仅仅阐述一下IOC容器的实现原理等等，当然了通过上述的思考，也可以知道IOC容器就是反射机制+工厂模式，结合配置文件实现依赖注入，实现了控制反转，相关的概念也就有个比较清晰的理解，不会那么生硬。

展开全文 >>

CI 持续集成服务器搭建-准备篇

操作系统：CentOS 6.5 64bit
IP 地址：192.168.1.204
JDK 版本：JDK 1.7

更换 yum 镜像源

备份原文件，下载阿里 yum 镜像源文件，重命名下载的阿里 yum 镜像源文件

1
2
3
4
[root@localhost Desktop]# cd /etc/yum.repos.d/
[root@localhost yum.repos.d]# mv CentOS-Base.repo CentOS-Base.repo.backup
[root@localhost yum.repos.d]# wget http://mirrors.aliyun.com/repo/Centos-6.repo
[root@localhost yum.repos.d]# mv Centos-6.repo CentOS-Base.repo

更新系统

1
2
3
[root@localhost yum.repos.d]# yum update
[root@localhost yum.repos.d]# yum clean all
[root@localhost yum.repos.d]# yum makecache

设置静态 IP 地址

编辑网卡配置：

1
[root@localhost ~]# vi /etc/sysconfig/network-scripts/ifcfg-eth0

设置静态 IP 地址：

1
2
3
4
5
DR=192.168.1.204
NETMASK=255.255.255.0
GATEWAY=192.168.1.1
USERCTL=no
PEERDNS=yes

也可通过图形界面设置网络：

1
[root@localhost ~]# setup

重启网络服务

1
[root@localhost ~]# service network restart

安装 JDK

执行安装：

1
[root@localhost ~]# rpm –ivh jdk-7u60-linux-x64.rpm

默认安装目录：/usr/java/jdk1.7.0_60

配置环境变量：

1
[root@localhost ~]# vi /etc/profile

1
2
3
4
#set jdk environment
export JAVA_HOME=/usr/java/jdk1.7.0_60
export PATH=$PATH:$JAVA_HOME/bin
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

使配置立即生效：

1
[root@localhost ~]# vi /etc/profile

验证安装：

1
[root@localhost ~]# java -version

1
2
3
java version "1.7.0_60"
Java(TM) SE Runtime Environment (build 1.7.0_60-b19)
Java HotSpot(TM) 64-Bit_Server VM (build 24.60-b09, mixed mode)

展开全文 >>

Java Comparable VS Comparator

Comparable 和 Comparator 均是 Java Core API。

Comparable 和 Comparator 都是用于实现集合或数组中元素的排序的。

Comparable 在元素内部定义的方法实现的自身和其他元素的排序，其自然排序只可以选择升序或降序一种。
Comparator 在元素外部定义的类实现的两个元素之间的排序，单一比较器内部排序规则只可以选择升序或降序一种，但是可通过多个比较器实现不同的排序规则。

Comparable 接口
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
class User implements Comparable<User> {

	private String name;

	private String idCard;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getIdCard() {
		return idCard;
	}

	public void setIdCard(String idCard) {
		this.idCard = idCard;
	}

	public int compareTo(User o) {
		return getIdCard().compareTo(o.getIdCard());
	}

	@Override
	public String toString() {
		return "User{" +
			"name='" + name + '\'' +
			", idCard='" + idCard + '\'' +
			'}';
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
User userA = new User();
userA.setIdCard("1234567");
userA.setName("a");

User userB = new User();
userB.setIdCard("2234567");
userB.setName("b");

List<User> userList = new ArrayList<User>(8);
userList.add(userB);
userList.add(userA);

System.out.println(userList.toString());

Collections.sort(userList);

System.out.println(userList.toString());
1
2
[User{name='b', idCard='2234567'}, User{name='a', idCard='1234567'}]
[User{name='a', idCard='1234567'}, User{name='b', idCard='2234567'}]

如果想实现降序的自然排序，只能修改 User 类的 compareTo 方法：

1
2
3
public int compareTo(User o) {
    return o.getIdCard().compareTo(getIdCard());
}

若想实现多样性的比较和排序，需要依赖于 Comparator。

Comparator 接口

Comparator 使用策略模式，实现比较方式的多样性和排序的多样性。在使用时选择不同的 Comparator 比较器即可。

升序排序：

1
2
3
4
5
6
7

class UserAsoSortComparator implements Comparator<User> {

	public int compare(User o1, User o2) {
		return o1.getIdCard().compareTo(o2.getIdCard());
	}
}

降序序排序：

1
2
3
4
5
6
7

class UserDesoSortComparator implements Comparator<User> {

	public int compare(User o1, User o2) {
		return o2.getIdCard().compareTo(o1.getIdCard());
	}
}

使用时指定 Comparator：

1
Collections.sort(userList, new UserAsoSortComparator());

展开全文 >>

CentOS 6.5 64bit 安装 JDK 7

执行安装：

1
[root@localhost ~]# rpm -ivh jdk-7u60-linux-x64.rpm

配置环境变量：

1
[root@localhost ~]#vim /etc/profile

添加如下内容：

1
2
3
4
#set jdk environment
export JAVA_HOME=/usr/java/jdk1.7.0_60
export PATH=$PATH:$JAVA_HOME/bin
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

展开全文 >>

ZooKeeper Standalones 模式安装

ZooKeeper介绍

在单机中，系统协作大都是进程级的操作。分布式系统中，服务协作都是跨服务器才能完成的。在ZooKeeper之前，我们对于协作服务大都使用消息中间件，随着分布式系统的普及，用消息中间件完成协作，会有大量的程序开发。

Apache ZooKeeper 是由Apache Hadoop的子项目发展而来，于2010年11月正式成为了Apache的顶级项目。ZooKeeper是一个为分布式应用所设计的分布的、开源的协调服务，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，简化分布式应用协调及其管理的难度，提供高性能的分布式服务。ZooKeeper本身可以以Standalone模式安装运行，不过它的长处在于通过分布式ZooKeeper集群（一个Leader，多个Follower），基于一定的策略来保证ZooKeeper集群的稳定性和可用性，从而实现分布式应用的可靠性。

ZooKeeper作为分布式协调服务，是不需要依赖于Hadoop的环境，也可以为其他的分布式环境提供服务。

系统环境（本次环境）

准备一台Linux服务器，系统要求如下：

  • Linux: CentOS 6.5 64bit Server
  • Java: 1.7.0_60 64-Bit Server VM
  • zookeeper：zookeeper-3.4.5.tar.gz

ZooKeeper 使用Java语言编写，运行环境需要Java环境支持，建议使用JDK1.6以上版本

解压 ZooKeeper

安装目录：/usr/local/zookeeper-3.4.5
在 /usr/local/ 目录下解压 zookeeper-3.4.5.tar.gz ：

1
[root@localhost local]# tar zxvf zookeeper-3.4.5.tar.gz

配置 ZooKeeper
创建数据目录：
1
[root@localhost ~]# mkdir /var/zookeeperdata
准备配置文件：

因为ZooKeeper启动时默认加载名为zoo.cfg配置文件，所有需要将zoo_sample.cfg复制一份并命名为zoo.cfg。
配置文件目录 zookeeper-3.4.5/conf 。

1
[root@localhost conf]# cp zoo_sample.cfg zoo.cfg

编辑配置文件：
1
[root@localhost conf]# vim zoo.cfg

添加数据目录配置：

1
dataDir=/var/zookeeperdata

设置环境变量
1
[root@localhost ~]# vim /etc/profile

添加如下内容：

1
2
export ZOOKEEPER_HOME=/usr/local/zookeeper-3.4.5
export PATH=$PATH:$ZOOKEEPER_HOME/bin:$ZOOKEEPER_HOME/conf

启动 ZooKeeper

展开全文 >>

10 步让你成为更优秀的程序员

英文原文：10 steps to becoming a better programmer

永远不要复制代码

不惜任何代价避免重复的代码。如果一个常用的代码片段出现在了程序中的几个不同地方，重构它，把它放到一个自己的函数里。重复的代码会导致你的同事在读你的代码时产生困惑。而重复的代码如果在一个地方修改，在另外一个地方忘记修改，就会产生到处是bug，它还会使你的代码体积变得臃肿。现代的编程语言提供了很好的方法来解决这些问题，例如，下面这个问题在以前很难解决，而如今使用lambdas却很好实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/// <summary>
/// 一些函数含有部分重复代码
/// </summary>
void OriginalA()
{
	DoThingsA();

	// unique code

	DoThingsB();
}

/// <summary>
/// 另外一个含有部分重复代码的函数
/// </summary>
void OriginalB()
{
	DoThingsA();

	// 没有重复的代码

	DoThingsB();
}

现在我们重构含有部分相同代码的函数，用delegate模式重写它们：

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
/// <summary>
/// Encapsulate shared functionality
/// </summary>
/// <param name="action">User defined action</param>
void UniqueWrapper(Action action)
{
	DoThingsA();

	action();

	DoThingsB();
}

/// <summary>
/// New implmentation of A
/// </summary>
void NewA()
{
	UniqueWrapper(() =>
	{
		// unique code
	});
}

/// <summary>
/// New implementation of B
/// </summary>
void NewB()
{
	UniqueWrapper(() =>
	{
		// unique code
	});
}

留意你开始分心的时候

当你发现自己在浏览facebook或微博、而不是在解决问题，这通常是一种你需要短暂休息的信号。离开办公桌，去喝一杯咖啡，或去跟同事聊5分钟。尽管这样做看起来有点反直觉，但长久去看，它会提高你的工作效率。

不要匆忙赶任务而放弃原则

当带着压力去解决一个问题或修改一个bug，你很容易失去自制，发现自己匆匆忙忙，甚至完全忘了一直坚持的重要的测试过程。这通常会导致更多的问题，会让你在老板或同事眼里显得很不专业。

测试你完成的代码

你知道你的代码能做什么，而且试了一下，它确实好用，但你实际上需要充分的验证它。分析所有可能的边界情况，测试在所有可能的条件下它都能如期的工作。如果有参数，传递一些预期范围外的值。传递一个null值。如果可能，让同事看看你的代码，问他们能否弄坏它。单元测试是到达这种目的的常规方法。

代码审查

提交你的代码之前，找个同事一起坐下来，向他解释你做了哪些修改。通常，这样做的过程中你就能发现代码中的错误，而不需要同事说一句话。这比自己审查自己的代码要有效的多得多。

让代码更少

如果你发现写了大量的代码来解决一个简单的问题，你很可能做错了。下面的boolean用法是一个很好的例子：

1
2
3
4
5
if (numMines > 0){
   enabled=true;
} else {
   enabled=false;
}

这时你应该写成这样：

1
enabled = numMines > 0;

代码越少越好。这会使bug更少，重构可能性更小，出错的几率更小。要适度。可读性同等重要，你可不能这样做而使代码丧失可读性。

为优雅的代码而努力

优雅的代码非常的易读，只用手边很少的代码、让机器做很少的运算就能解决问题。在各种环境中都做到代码优雅是很难的，但经过一段时间的编程，你会对优雅的代码是个什么样子有个初步的感觉。优雅的代码不会通过重构来获得。当你看到优雅的代码是会很高兴。你会为它自豪。例如，下面就是一个我认为是优雅的方式来计算多边形面积的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
static public double GetConvexPolygonArea(Vector2[] vertices)
{
	double area = 0;
	for (int i = 0; i < vertices.Length; i++)
	{
		Vector2 P0 = vertices[i];
		Vector2 P1 = vertices[(i + 1) % vertices.Length];

		area += P0.Wedge(P1);
	}

	return area / 2;
}

编写不言自明的代码

勿庸置疑，注释是编程中很重要的一部分，但能够不言自明的代码跟胜一筹，因为它能让你在看代码时就能理解它。函数名变量名要慎重选择，好的变量/方法名字放到语言语义环境中时，不懂编程的人都能看懂。例如：

1
2
3
4
5
void DamagePlayer(Player player, int damageAmount){
	if (!player.m_IsInvincible && !player.m_IsDead){
		player.InflictDamage( damageAmount );
	}
}

能自我说明的代码不能代替注释。注释是用来解释“为什么”的，而自我说明的代码是来描述“是什么”的。

不要使用纯数字

直接把数字嵌入代码中是一种恶习，因为无法说明它们是代表什么的。当有重复时更糟糕——相同的数字在代码的多个地方出现。如果只修改了一个，而忘记了其它的。这就导致bug。一定要用一个命名常量来代表你要表达的数字，即使它在代码里只出现一次。

不要做手工劳动

当做一系列动作时，人类总是喜欢犯错误。如果你在做部署工作，并且不是一步能完成的，那你就是在做错事。尽量的让工作能自动化的完成，减少人为错误。当做工作量很大的任务时，这尤其重要。

避免过早优化

当你要去优化一个已经好用的功能代码时，你很有可能会改坏它。优化只能发生在有性能分析报告指示需要优化的时候，通常是在一个项目开发的最后阶段。性能分析之前的优化活动纯属浪费时间，并且会导致bug出现。

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家