在Mac OS或者Linux中比较有用，因为这些系统一般都同时安装了多个版本。尤其是Mac OS 10.5，目录结构太乱了

在python环境中：

1
2

from distutils.sysconfig import get_python_lib
print get_python_lib()

或者，直接命令行：

1

python -c "from distutils.sysconfig import get_python_lib; print get_python_lib()"

MySQL又可以使用InnoDB了

不过也有一些问题，比如没有MenuItem，没有快速搜索Component的功能，在Component列表中不支持滚动。

对于License，也可以通过blog推广的方式来获取，试一下

网站：http://wireframesketcher.com/index.html

Mockups For Desktop提供了很多“控件”进行选择，Button, Checkbox, Dialog Windows等等，直接拖到设计区域就可以，效果看起来像“手绘”的草图，感觉相当不错。

下面是偶画的一个程序界面：

程序没有右键菜单，感觉挺奇怪的，而且似乎不支持中文字符输入。
售价$79，不过可以通过Blog推广等方式来免费获取注册码。未注册版本还不能保存设计稿，这点相当不爽。

================
2月9日更新：
昨晚发布了日志后，马上给作者发了邮件，告知已经在Blog上进行推广，另外还有右键菜单建议和中文问题，今天就收到了作者的回复，他们会在以后的版本中增加右键功能菜单；如果需要输入中文，则可以在View菜单下，选中Use System Fonts，即可支持中文输入。

使用作者提供的注册码激活后，就可以保存文件了，格式为BMML，其实是一个XML格式的文件。

下载 Mockups For Desktop

JBoss Seam版本：2.1.0.SP1

Google Web Toolkit版本：1.5.3

1. gwt-servlet.jar版本问题：Seam中自带的gwt-servlet.jar版本可能和你使用的GWT版本不一致，如果你编译GWT程序的版本与Seam中gwt-servlet.jar版本不一致，可能会出现一些奇怪的问题，最好的办法是将Seam中的gwt-servlet.jar换成GWT中带的jar。
2. Seam Resource Servlet的配置和GWT程序中Service Entry Point的设置：Seam中的默认url pattern是/seam/resource/*，所以Seam会把对/seam/resource/gwt/*的请求发送给org.jboss.seam.remoting.gwt.GWT14Service处理，GWTService才会根据GWT客户端发送的请求类和方法来进行调用。需要注意的是，根据跟踪Seam的GWTService发现，客户端发送的请求类似于“5|0|6|http://127.0.0.1:8080/SeamGWT/|5BA8A5B3E35F40698BB0BF65F390BCF2|com.tiandinet.gwt.hello.client.HelloService|sayHello|java.lang.String|your name|1|2|3|4|1|5|6|”，而Seam的GWTService.getResource会根据com.tiandinet.gwt.hello.client.HelloService名称查找Seam组件，此组件即为GWT中的远程服务接口的Seam实现，所以在设置此实现类的@Name属性时，需要将其设置为GWT中远程服务接口的类名。
   所以，对于Service Entry Point的设置，只要URL能匹配到/seam/resource/gwt/即可，而Seam Reference示例中的String endpointURL = GWT.getModuleBaseURL() + “seam/resource/gwt”;可能不一定正确，因为根据GWT编译后页面路径在Seam应用中所处的位置不同，GWT.getModuleBaseURL()返回的路径可能就不能匹配到/seam/resource/gwt。
3. Seam Resource Servlet映射
   /web=org.jboss.seam.ui.resource.WebResource
   /captcha=org.jboss.seam.captcha.CaptchaImage
   /remoting=org.jboss.seam.remoting.Remoting
   /gwt=org.jboss.seam.remoting.gwt.GWT14Service
   /graphicImage=org.jboss.seam.ui.graphicImage.GraphicImageResource

静态初始化块：使用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

package com.tiandinet.studyjava;
 
public class TestInitiateBlock {
 
    {
        System.out.println("In non-static initialization block!");
    };
 
    static {
        System.out.println("In static initialization block!");
    };
 
    public TestInitiateBlock() {
        System.out.println("In Constructor1!");
    }
 
    public void show() {
        System.out.println("In show()!");
    }
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        TestInitiateBlock ti = new TestInitiateBlock();
        ti.show();
    }
 
}

运行结果：
In static initialization block!
In non-static initialization block!
In Constructor1!
In show()!

1. 安装memcached (服务器版本1.2.6)

服务器OS是RHEL5(Red Hat Linux Enterprise 5)，之前已经装好LAMP环境，这是我们的一台测试服务器，LAMP均位于/opt/lamp下。准备将memcached安装在/opt/cache/memcached目录下。

memcached需要libevent(http://monkey.org/~provos/libevent/)的支持，所以需要先安装libevent，安装目录位于/opt/cache/libevent，下载最新版本的libevent（此例中为1.4.8），解压后进入源代码目录，进行配置和安装。

./configure --prefix=/opt/cache/libevent
 
make
 
make install

接着安装memcached，使用的版本是1.2.6，进入解压后的源代码目录，

./configure --prefix=/opt/cache/memcached --with-libevent=/opt/cache/libevent

–with-libevent指令指定libevent的目录

make
 
make install

安装完成，试着使用

/opt/cache/memcached/bin/memcached -d -m 16 -p 33333 -u memcached -l 127.0.0.1

启动memcached服务器，但会报错，
error while loading shared libraries: libevent-1.4.so.2: cannot open shared object file: No such file or directory

意思是memcached无法找到libevent-1.4.so.2这个文件，但明明是指定了libevent的安装目录，为什么找不到呢？

memcached其实是到/usr/lib/目录下去找libevent的so文件，但我在安装时指定的libevent是位于/opt/cache/libevent，所以解决办法是在/usr/lib目录下创建一个文件链接（不知道算不算一个bug）

ln -s /opt/cache/libevent/lib/libevent-1.4.so.2 /usr/lib/libevent-1.4.so.2

再次启动memcached，一切正常。

2. 编译PHP的memcache扩展　(扩展版本2.2.4)
PHP的memcache是PECL下的一个包，下载地址位于http://pecl.php.net/package/memcache，因为这台服务器之前已经装好了PHP环境，所以我们直接将下载的tar包解压到PHP源代码目录下的ext目录中，进入memcache-2.2.4目录，使用phpize生成configure等配置文件

/opt/lamp/php/bin/phpize

配置

./configure --with-php-config=/opt/lamp/php/bin/php-config --enable-shared --enable-static

但此处会报错，提示找不到php_session.h头文件，该文件位于PHP源文件目录下的ext/session下，可以通过修改configure文件，设置正确的session_inc_path变量，指向PHP源文件目录/opt/lamp/php-5.2.5即可，重新configure即可通过。

接着调用make，会在module目录下生成memcache.so文件，将此文件拷贝到PHP的extension目录，再修改php.ini，重启httpd就完成了memcache扩展的配置。

值得注意的是，在编译扩展时，并不需要使用make install命令。

　　MultiPartFilter是一个定义在web.xml中的<filter>，原理是通过判断HttpServletRequest中的contentType是否包含”multipart/form-data”，若代码中包含此字符品，则表明是一个File Upload请求，就使用JakartaMultiPartRequest来对HttpServletRequest对其进行包装。

　　其代码如下：

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

public class MultiPartFilter extends GenericFilterBean {
 
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
            throws IOException, ServletException {
 
		HttpServletRequest request = (HttpServletRequest) servletRequest;
 
		String content_type = request.getContentType();
		if (content_type != null && content_type.indexOf("multipart/form-data") != -1) {
			JakartaMultiPartRequest jakartaMultiPartRequest = new JakartaMultiPartRequest(request,
					getFilterConfig().getInitParameter("saveDir"), Integer.valueOf(
							getFilterConfig().getInitParameter("maxUploadSize")).intValue());
 
			request = jakartaMultiPartRequest;
		}
 
		filterChain.doFilter(request, servletResponse);
    }
 
}

　　JakartaMultiPartRequest类继承自HttpServletRequestWrapper，在其构造方法中，我们对Request进行分析，并且保存用户上传的文件，将文件名等信息放到Request的attribute中，从而在后续的代码中可以对上传的文件进行处理。

　　但在后来客户进出的对产品图片处理的新需求中，因为JakartaMultiPartRequest的问题，没有办法满足我们的要求，所以考虑到使用Spring的MultipartResolver来进行上传处理，但之前的代码不能再进行改动，否则所有处理文件上传的Controller必须更改，代价很大。但如果在Spring中进行配置MultipartResolver的配置后，发现我们旧的文件上传代码都失效了，无法上传文件。

　　后来经过调试，发现在我们定义的MultiPartFilter中处理过上传的请求后，Spring的MultipartResolver又对其进行了上传处理，这样就导致我们之前设计在Request中的attribute全部丢失，所以我们得想办法让我们自定义的MultiPartFilter和Spring的MultipartResolver不要互相干扰。

我们需要经两步来解决此问题：

第一步：我们对自定义的MultiPartFilter进行改动，让其接受在web.xml中传入的配置参数“excludeURL”，此参数指定那些不需要JakartaMultiPartRequest类进行处理的页面URL。

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

boolean jump = false;
 
// 根据web.xml中的配置，判断当前url是否跳过此过滤器
String excludeURL = getFilterConfig().getInitParameter("excludeURL");
if (excludeURL != null && !"".equals(excludeURL)) {
	if (request.getRequestURI().indexOf(excludeURL) != -1) {
		jump = true;
	}
}
 
if (!jump) {
	String content_type = request.getContentType();
	if (content_type != null && content_type.indexOf("multipart/form-data") != -1) {
		JakartaMultiPartRequest jakartaMultiPartRequest = new JakartaMultiPartRequest(request,
				getFilterConfig().getInitParameter("saveDir"), Integer.valueOf(
						getFilterConfig().getInitParameter("maxUploadSize")).intValue());
 
		request = jakartaMultiPartRequest;
	}
}
 
filterChain.doFilter(request, servletResponse);

第二步：
　　经过查看org.springframework.web.multipart.commons.CommonsMultipartResolver的源代码我们发现（我们在spring中使用commons fileupload处理上传），其中有个public boolean isMultipart(HttpServletRequest request)方法，此方法控制着Spring是否对用户的Request进行文件上传处理，于是自定义一个我们自己的CommonsMultipartResolver，继承自org.springframework.web.multipart.commons.CommonsMultipartResolver，并重写其中的public boolean isMultipart(HttpServletRequest request)，在方法中对当前的request进行判断，如果是一个JakartaMultiPartRequest实例，则返回false，告知Spring不需要再对当前的request进行文件上传处理；如果不是，则直接调用父类的isMultipart方法。

代码如下：

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

public class CommonsMultipartResolver extends org.springframework.web.multipart.commons.CommonsMultipartResolver {
 
    /**
     * {@inheritDoc}
     * 
     * @see org.springframework.web.multipart.commons.CommonsMultipartResolver#isMultipart(javax.servlet.http.HttpServletRequest)
     */
    @Override
    public boolean isMultipart(HttpServletRequest request) {
        if (request instanceof JakartaMultiPartRequest) {
            return false;
        } else {
            return super.isMultipart(request);
        }
    }
 
}

　　当然，Spring中的配置也要使用自定义的CommonsMultipartResolver，

1
2
3
4
5

    <bean id="multipartResolver"
        class="net.ymeng.example.web.filter.CommonsMultipartResolver">
        <property name="maxUploadSize"
            value="20000000" />
    </bean>

　　这样，就可以让自定义的MultiPartFilter和Spring的MultipartResolver各司其职了。

在这个程序中，产品（Product）和分类（Category）是多对多的关系，关系维护方为产品，在创建产品时，允许选择多个分类，因为Product.categories是一个List属性，同时产品选择<select />标签也是由从Action中查询出来的所有Category的List，所以在页面上，需要在页面渲染、用户提交后的category进行转换。

显示时，我们以Category.id为<option />的value值，而Category.title为label。

Entity如下（省略setter和getter）：

Category.java

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

@Entity
@Table(name = "category")
public class Category extends BaseEntity {
 
	@Id
	@GeneratedValue
	@Column(name = "id", unique = true, nullable = false, length = 10)
	private Integer id;
 
	@Column(name = "title")
	@NotNull
	@Length(min = 4, max = 64, message = "{invalid.length}")
	private String title;
 
	@ManyToMany(mappedBy = "categories")
	private List<product> products = new ArrayList</product><product>();
}
</product>

Product.java

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

@Entity
@Table(name = "product")
public class Product extends BaseEntity {
 
	@Id
	@GeneratedValue
	@Column(name = "id", nullable = false, unique = true, length = 10)
	private Integer id;
 
	@Column(name = "title")
	@NotNull
	@Length(min = 4, max = 64)
	private String title;
 
	@Column(name = "price")
	@NotNull
	private Float price;
 
	@ManyToMany(cascade = { CascadeType.MERGE, CascadeType.REFRESH }, fetch = FetchType.LAZY)
	@JoinTable(name = "category_product", joinColumns = { @JoinColumn(name = "product_id", referencedColumnName = "id") }, inverseJoinColumns = { @JoinColumn(name = "category_id", referencedColumnName = "id") })
	private List<category> categories = new ArrayList</category><category>();
}
</category>

如果persistence.xml中，hibernate.hbm2ddl.auto的属性配置为create-drop，那么在JBoss启动时，这两个Entity会生成三张表，除了product和category外，还有一张关联表：category_product。

xhtml页面代码如下：

1
2
3
4

                <ui :define name="label">Category</ui>
                <h :selectManyListbox id="categories" value="#{productEditAction.product.categories}" converter="categoryConverter" >
                  <s :selectItems var="cat" value="#{productEditAction.categories}" label="#{cat.title}" />
                </h>

其中，#{productEditAction.categories}表示系统中所有的分类，是一个List<category>列表。

JSF Converter代码：

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

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.convert.ConverterException;
 
import net.ymeng.studyseam.entity.Category;
import net.ymeng.studyseam.service.InventoryService;
 
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.faces.Converter;
 
/**
 * @author yangtze
 * 
 */
@Name("categoryConverter")
@Converter(id = "categoryConverter")
public class CategoryConverter implements javax.faces.convert.Converter {
 
	@In(create = true, value = "inventoryServiceImpl")
	private InventoryService inventoryService;
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * javax.faces.convert.Converter#getAsObject(javax.faces.context.FacesContext
	 * , javax.faces.component.UIComponent, java.lang.String)
	 */
	public Object getAsObject(FacesContext context, UIComponent component,
			String value) {
		if (value != null && !"".equals(value)) {
			Integer catId = Integer.valueOf(value);
			Category cat = inventoryService.findCategoryById(catId);
			return cat;
		}
 
		return null;
	}
 
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * javax.faces.convert.Converter#getAsString(javax.faces.context.FacesContext
	 * , javax.faces.component.UIComponent, java.lang.Object)
	 */
	public String getAsString(FacesContext context, UIComponent component,
			Object value) {
		if (value instanceof Category) {
			return String.valueOf(((Category) value).getId());
		} else {
			throw new ConverterException("Unsupported valued! Value is: "
					+ value + "\tType is: " + value.getClass());
		}
	}
}

其中getAsString方法在页面显示时会自动调用，将传入的对象value转换为字符串输出，因为这里用作option值的是Category.id，所以我们在此方面中取出分类的id并返回。

而getAsObject方法是在用户提交时，将option的值转换为Integer，并从Service层中查找对应的Category实例、返回。

所以对于提交后的保存动作，我们就不需要再做任何处理，Product.categories中已经是转换好的List<Category>，直接persist/merge即可。

如果在转换类中使用@Converter注解，就不再需要在faces-config.xml中进行converter的配置了，Seam会自动帮你完成这个配置。

　　怎么使用？（以人力资源系统中的公司员工为例）：
　　一般来说，在需要对某个员工进行访问的时候，我们都会new一个员工类，如果两个客户代码同时访问同一个员工，则会产生两个相同（或部份相同）的同一员工实例，这样，对于一个员工来说，内存中就可能有该员工的多个实例存在，如果一个企业有10000个员工，那内存中实际的员工实例可能就不止10000个。在这种情况下，我们就可以用享元模式来解决这个问题。
（假设我们系统中原有的类如下图OldPerson所示）

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

public class OldPerson {
	private String id;
	private String name;
	private double basicSalary;
	private double variableSalary;
 
	/* 省略setter和getter */
 
	public OldPerson(String id, String name) {
		this.id = id;
		this.name = name;
	}
}

我们需要分两步来完成这个模式：

1、提取类中的不可变部份
仔细思考上面的OldPerson类，我们发现，在任何一种情况下，员工的id号和name都是不变的，不管是计算基础薪资的客户代码，还是计算绩效薪资的客户代码，id和name都具有不变性，所以我们可以将这两个属性列为员工类的不可变部份，利用这两个不变属性，创建一个接口NewPerson。

1
2
3
4
5

public interface NewPerson {
	public String getId();
	public String getName();
	public String toString();
}

2、创建享元工厂
在这一步，我们实例化享元并组织共享享元的客户代码，而且我们必须保证各个客户代码都使用享元工厂创建享元实例，而不能自己创建。下图是我们创建的享元工厂。

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

public class PersonFactory {
	private static Map<string , NewPerson> persons = new HashMap();
	static {
		persons.put("001", new NewPersonImpl("001", "Tom"));
		persons.put("002", new NewPersonImpl("002", "Jerry"));
	}
 
	public static NewPerson getPerson(String id) {
		return persons.get(id);
	}
 
	private static class NewPersonImpl implements NewPerson {
		private String id;
		private String name;
 
		public NewPersonImpl(String id, String name) {
			this.id = id;
			this.name = name;
		}
 
		public String getId() {return id;}
		public String getName() {return name;}
		public String toString() {
			return this.id + " ===> " + this.name;
		}
	}
}
</string>

在PersonFactory中，我们创建了它的一个私有内部类NewPersonImpl，并实现了NewPerson，这样即可禁止客户代码自己实例化NewPersonImple，这也是为什么我们需要创建NewPerson接口的原因了。

客户代码调用都需要使用PersonFactory.getPerson来获得某员工的唯一实例。比如：

1
2
3
4
5
6

public class TestNewPerson {
	public static void main(String[] args) {
		System.out.println(PersonFactory.getPerson("001"));
		System.out.println(PersonFactory.getPerson("002"));
	}
}

需要注意的是，享元对象中的属性必须是不可变的。

　　在编写一个方法的时候，考虑到算法的某些步骤可能会有不同的实现方式，我们可能会首先定出算法的框架。这样，在定义方法的时候，我们可以将某些步骤定义为抽象方法，或者是将它们定义为存根方法，也可以将它们定义为某个单独接口中的方法，这就是模板方法模式的实现。
　　模板方法的典型例子就是排序。java.util.Collections类将sort()方法定义为一个模板方法，而将其中的比较交给用户来实现，sort()方法所接受的List中的对象需要实现Comparator接口，这就是将实际算法推迟并交给其它类来实现的模板方法模式。

　　例：
　　我们有一个抽象类ShowSubClassName，有两个子类SubClassA和SubClassB继承了该抽象类，抽象类中定义的抽象方法showName()被推迟到了两个子类中实现（分别输出自己的class name）。

1
2
3
4
5
6
7
8
9
10

public abstract class ShowSubClassName {
	/**
	 * 这个方法的实现，我们交给子类完成
	 */
	public abstract void showName();
 
	public void show() {
		showName();
	}
}

1
2
3
4
5

public class SubClassA extends ShowSubClassName {
	public void showName() {
		System.out.println(this.getClass().getName());
	}
}

1
2
3
4
5
6
7

public class SubClassB extends ShowSubClassName {
 
	public void showName() {
		System.out.println(this.getClass().getName());
	}
 
}

1
2
3
4
5
6
7
8
9

public class Test {
	public static void main(String[] args) {
		ShowSubClassName classA = new SubClassA();
		classA.show();
 
		ShowSubClassName classB = new SubClassB();
		classB.show();
	}
}

　　比如我们要实现一个在线客户服务系统，若客服人员在线的时候，客户提交的问题将会直接传送给客服人员；若客服人员不在线，则将客户提交的问题发送至客服信箱。
　　类图：

工厂方法模式

　　　　
　　接口CustomerService中定义了一个抽象方法sendMessage()，类OnlineCustomerService和OffineCustomerService都实现了CustomerService接口，分别实现了客服人员在线和不在线时发送消息的方法。
　　CustomerServiceFactory中提供了一个createCustomerService()方法，用过返回CustomerService类型的对象，在返回此对象之类，它会通过isServiceOnline()来检查客服人员是否在线，以返回不同的对象。

　　下面是工厂类的代码：

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

public class CustomerServiceFacotry {
	private static boolean isServiceOnline() {
		// 检查客服人员状态
		// 若在线，返回true；不在线，返回false
		return false;
	}
 
	public static CustomerService createCustomerService() {
		if (isServiceOnline()) {
			return new OnlineCustomerService();
		} else {
			return new OfflineCustomerService();
		}
	}
}

　　　　为了支持观察者模式，Java类库中的java.util包中提供了Observable类和Observer接口。

　　　　我们现在举一个例子来说明观察者模式。
　　　　在网上商店的应用中，如果我们希望产品的名称被更改了后，系统会自动在控制台打印新名称，则就可以使用观察者模式。此时，产品类Product就需要继承Observable类，产品观察者类NameObserver则需要实现Observer接口。

　　　　先看类图：

观察者模式

代码实现：

1. Product.java

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

import java.util.Observable;
 
public class Product extends Observable {
	private String name;
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
 
		setChanged();
		notifyObservers(name);
	}
}

　　注意：在setName()方法中，调用了Observalbe类的setChanged()和notifyObservers()方法。
setChanged()方法将触发Observable代码将这次改变广播出去；而notifyObservers()方法调用所有注册的观察者对象的update()方法。（有点啰嗦）
　　Product类不需要维护所有监视它的对象的引用，这些监视的对象将在实际的代码中TestObserver.java被注册。

2. NameObserver.java

1
2
3
4
5
6
7
8
9
10
11

import java.util.Observable;
import java.util.Observer;
 
public class NameObserver implements Observer {
 
	public void update(Observable o, Object arg) {
		String name = (String)arg;
		System.out.println("Set Name: " + name);
	}
 
}

　　该类实现了Observer接口，当Product对象的setName()方法被调用后，该类的update方法会自动被调用，并在控制台输入新的产品名称。

3. TestObserver.java

1
2
3
4
5
6
7
8
9
10
11

public class TestObserver {
 
	public static void main(String[] args) {
		NameObserver nameObserver = new NameObserver();
		Product product = new Product();
		product.addObserver(nameObserver);
 
		product.setName("Cat1");
	}
 
}

　　该类是一个测试程序，实例化NameObserver和Product，并将NameObserver的实例注册给Product实例（通过调用Product.addObserver来注册），用以实现监听。当程序给Product的setName()方法被调用后，NameObserver实例的update()方法马上就会得到通知并输出新的产品名称。

1
2
3
4
5
6
7
8
9

private Factory factory = null;
 
public static Factory getFactory() {
  if (factory == null) {
    factory = new Facotry();
}
 
return factory;
}

　　上面的例子实现了单体模式，但如果在多线程环境中采用此方式，仍然可能产生多个实例，最好的办法，用synchronized来控制Factory实例的生成。

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

public class Factory {
	private static Factory factory;
 
	private Factory() {
	}
 
	public static Factory getFactory() {
		synchronized(Factory.class) {
			if (factory == null) {
				factory = new Factory();
			}
 
			return factory;
		}
	}
}

　　适配器模式的宗旨就是，保留现有的类所提供的服务，修改其接口，从而达到客户期望。

　　类适配器：

类适配器

　　对象适配器：

对象适配器

　　比如：

1
2
3

interface Login {
  boolean login(String name, String password);
}

需要注意的地方：
　1. 接口的方法总是抽象的，无论是否显式地声明。
　2. 接口的方法总是公共的，无论是否显式地声明。
　3. 接口的可见性受限于其所在的包，因为Login没有显式地声明为public，所以其在包内可见。
　4. 一个接口可以扩展另一个接口。比如List接口扩展了Collection。
　5. 接口可以不包含方法。不包含方法的接口称为“标记”接口。比如Cloneable接口。
　6. 接口不能声明实例域，不过可以通过声明static和final修饰的域来声明常量。

2. 选择索引
　　搜索的索引列，不一定是所要选择的列。出现在ON，WHERE和GROUP BY后的列适合作索引。
　　使用惟一索引
　　　　对于惟一值的列，索引的效果最好。例如：存放年龄的列具有不同值，所以很容易区分各行；而用来记录性别的列，只有’M'和’F'，不论搜索哪个值，都会得出大约一半的行，所以对其进行索引没有多大用途。
　　使用短索引
　　　　如果对字符串类型的列进行索引，应该指定一个前辍长度。比如一个varchar(200)的列，最好指定索引为前10个或20个字符内。（短的索引节省存储空间，并可能使查询更快）
　　利用最左前辍
　　　　在创建一个包含n列的索引时，实际上是创建了MySQL可以使用的n个索引。
多列索引可起几个索引的作用，因为可利用索引中最左边的列来匹配行。这样的列的集称为最左前辍。

　　比如在一个表中的state, city和zip三个列上创建索引，那么索引中的行是按state/city/zip的次序存放的。因此，索引中的行也会自动按state/city的顺序和state的顺序来存放。所以，该索引可以用来搜索下列的列的组合：
　　　　state/city/zip
　　　　state/city
　　　　state

　　不要过度索引
　　考虑在列上进行的比较类型
　　　　索引可用于< , <=, =, >=, >和BETWEEN运算，也可以用于LIKE运算。对于其他类型的计算（如STRCP()），则索引不起作用。

3. MySQL查询优化程序
　　EXPLAIN SELECT * FROM student WHERE 1=0;

　　3.1 优化程序怎样工作
　　　　MySQL查询优化程序有几个目标，但主要目标是尽量利用索引，而且尽量使用最具有限制性的索引以排除尽可能多的行。
　　　　比如：WHERE col1=’aaa’ AND col2=’bbb’，col1和col2都是索引。
　　　　假设整个表内，满足这col1=’aaa’的行有900行，满足col2=’bbb’的行有300行，两个条件都满足的行有30行。
　　　　那么，如果首先测试col1，必须检查900行以找到同时与col2值相符的30行，那么在测试col2时，有870行会失败。如果首先测试col2，要找到同时与col1相符的30行，只需要检测300行，这个过程中会有270行失败，这样所涉及的计算较少，磁盘I/O也较少，所以相对来说更快。

　　　　遵循下列准则，有助于优化程序利用索引：
　　　　　　a. 比较具有相同类型的列。
　　　　　　b. 比较中应尽量使用索引列独立。两个例子：
　　　　　　　　1. 比如WHERE col1 < 4 / 2的效果好于WHERE col1 * 2 < 4，后者不会使用索引，且会扫描表中所有行并进行计算。
　　　　　　　　2. 某表中的一个索引列date_col，日期类型
　　　　　　　　　　对于查询WHERE YEAR(date_col) < 1990，并不会使用索引与1990比较，而是将从列值计算出的值与1990比较，而且必须计算每一行。索引没有得到应用。
　　　　　　　　　　改进：WHERE date_col < ‘1990-01-01’

――――――――――――――――――――――――――――
但如果没有特定的日期值，比如要查询到今天为止100天内的记录，有3条语句可以完成这个任务
WHERE TO_DAYS(date_col) – TO_DAYS(CURRENT_DATE) < 100
WHERE TO_DAYS(date_col) < 100 + TO_DAYS(CURRENT_DATE)
WHERE date_col < DATE_ADD(CURRENT_DATE, INTERVAL 100 DAY)

第一条查询不能利用索引，因为必须检索每一行，以计算TO_DAYS(date_col)。
第二条查询要好一些，100和TO_DAYS(CURRENT_DATE)都是常量，因为表达式右边的值可以在查询处理前由优化程序一次计算出来，而不是每行计算一次，但date_col仍然在函数中，所以仍然没有使用索引。
第三条查询是最好的方法，表达式右边会在查询处理前一次性计算出来，其值是一个日期，可以直接和date_col比较，不需要再转换为天数，索引得到利用。

　　　　　　c. 在LIKE模式的起始处不要使用通配符。
　　　　　　　　查询WHERE name LIKE ‘%zhang%’的效率是很差的。
　　　　　　　　如果要查询以Mac开始的行，可以写成WHERE name LIKE ‘Mac%’，
　　　　　　　　但是WHERE name >= ‘Mac’ AND name < ‘Mad’的效率好于前者。

4. 列类型的选择与查询效率
　　a. 使用定长列，不使用可变长列。特别对于经常修改的表，变长列更容易产生碎片。
　　b. 在较短的列能够满足要求时不要使用较长的列
　　　　比如能使用CHAR(40)就不要使用CHAR(60)，好处：节省空间、节省I/O操作时间。
　　c. 将列定义为NOT NULL
　　　　这样处理速度更快，所需空间也更少。而且有时还能简化查询，因为不需要检查是否存在行例NULL。
　　d. 考虑使用ENUM列
　　　　如果某列的值的数量有限，应该考虑将其转换为ENUM类型。ENUM在内部使用数值表示，具有更快的处理速度。
　　e. 使用PROCEDURE ANALYSE()
　　　　比如SELECT * FROM commodity PROCEDURE ANALYSE();
　　　　会告诉你该列的最大值、最小值、平均值，以及推荐的列类型等等（主要是ENUM）。
　　f. 对容易产生碎片的表使用OPTIMIZE TABLE
　　　　以常进行修改的表、特别包含了变长列（特别是BLOB类型）的表，容易产生碎片。
　　g. 除非需要，应避免检索BLOB或TEXT值　――节省网络传输时间
　　h. 将BLOB或TEXT列分离到一个独立的表中
　　　　在某些情况下，将BLOB或TEXT列从表中移出可能具有一定意义，比如可将剩下的字段设置为定长格式，可以减少碎片，加快处理速度。

5. 有效地装载数据
　　基本理论：
　　a. 成批装载比单行装载更快，因为不需要在装载每个记录后就刷新索引。
　　b. 在表无索引的时候装载比有索引装载快，因为有索引的时候不仅需要写到数据文件，还需要写到索引文件。
　　c. 较短的语句比较长的语句快，因为服务器分析较少，网络传输量也较少。

　　实际结论：
　　a. LOAD DATA比INSERT效率高。
　　b. LOAD DATE比LOAD DATA LOCAL效率高。因为使用LOAD DATA，文件必须在服务器上（需要有FILE权限），节省了网络传输时间。
　　c. 如果必须使用INSERT，应该使用其多行插入形式。比如：
　　　　INSERT INTO student VALUES (1, ‘AAA’), (2, ‘BBB’), …
　　　　这样会减少索引创建的次数，也可以减少网络传送SQL语句的时间。

　　　　如果使用mysqldump来生成SQL备份文件，应该使用—extended-insert选项，使备份文件生成为多行插入形式。或者使用—opt参数。
　　d. 使用压缩参数。当需要在客户机/服务器间传输数据时，对于大多数客户机，可以使用—compress参数。但一般只用于较慢的网络，因为—compress参数需要占用更多的处理器时间。
　　e. 让MySQL来插入缺省值　――减少传输时间和服务器分析语句时间。
　　f. 在装载大量数据之前不要建立索引，待装载完成后再建立索引。或者在装载前删除索引，完成后再重建。

2. 当服务器接收到SQL命令时，它会将其转换成什么字符集？
character_set_connection and collation_connection
服务器将客户端发送的SQL命令从character_set_client转换到character_set_connection
在进行字符串比较时，collation_connection将起作用。
但是在进行column中字符串比较时，collation_connection将不起作用，因为column有自己的collation。

3. 服务器将以什么字符集发送 给果/错误信息 给客户端？
character_set_results

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
有两个语句可以改变connection character set：
1. SET NAMES ‘charset_name’;
2. SET CHARACTER SET charset_name;

SET NAMES告诉服务器客户端将使用什么样的字符集来发送SQL命令，也同时指定服务器返回给客户端所使用的字符集。

SET NAMES ‘x’ 等效于：
SET character_set_client = x;
SET character_set_results = x;
SET character_set_connection = x;
(注：SET character_set_connection = x; 语句同时也自动指定了字符集x的默认collation为 collation_connection的值，但也可以用 SET NAMES ‘charset_name’ COLLATE ‘collation_name’来提定你想使用的collation。)

SET CHARACTER SET和SET NAMES作用相似，但它将连接的字符集和collation设置为默认数据库的字符集和collation。

SET CHARACTER SET x 等效于：
SET character_set_client = x;
SET character_set_results = x;
SET collation_connection = @@collation_database;
(注：SET collation_connection同时也会自动设置character_set_connection。)

如果不希望MySQL在返回结果时进行转换，可以使用SET character_set_results = NULL;语句