少年阿宾

那些青春的岁月

:: 管理

500 Posts :: 0 Stories :: 135 Comments :: 0 Trackbacks

详细介绍 Hibernate 泛型 DAO 及其使用方法
编写Spring+Hibernate框架下的应用，总是离不了编写一个通用的泛型GenericHibernateDao。查阅了网上不少的GenericHibernateDao实现，归纳整理为如下实现，供后续编码参考。

首先定义接口泛型DAO接口 GenericDao

package com.th.huz;

import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;

public interface GenericDao<T extends Serializable, PK extends Serializable> {
// -------------------- 基本检索、增加、修改、删除操作 --------------------

// 根据主键获取实体。如果没有相应的实体，返回 null。
public T get(PK id);

// 根据主键获取实体并加锁。如果没有相应的实体，返回 null。
public T getWithLock(PK id, LockMode lock);

// 根据主键获取实体。如果没有相应的实体，抛出异常。
public T load(PK id);

// 根据主键获取实体并加锁。如果没有相应的实体，抛出异常。
public T loadWithLock(PK id, LockMode lock);

// 获取全部实体。
public List<T> loadAll();

// loadAllWithLock() ?

// 更新实体
public void update(T entity);

// 更新实体并加锁
public void updateWithLock(T entity, LockMode lock);

// 存储实体到数据库
public void save(T entity);

// saveWithLock()

// 增加或更新实体
public void saveOrUpdate(T entity);

// 增加或更新集合中的全部实体
public void saveOrUpdateAll(Collection<T> entities);

// 删除指定的实体
public void delete(T entity);

// 加锁并删除指定的实体
public void deleteWithLock(T entity, LockMode lock);

// 根据主键删除指定实体
public void deleteByKey(PK id);

// 根据主键加锁并删除指定的实体
public void deleteByKeyWithLock(PK id, LockMode lock);

// 删除集合中的全部实体
public void deleteAll(Collection<T> entities);

// -------------------- HSQL ----------------------------------------------

// 使用HSQL语句直接增加、更新、删除实体
public int bulkUpdate(String queryString);

// 使用带参数的HSQL语句增加、更新、删除实体
public int bulkUpdate(String queryString, Object[] values);

// 使用HSQL语句检索数据
public List find(String queryString);

// 使用带参数的HSQL语句检索数据
public List find(String queryString, Object[] values);

// 使用带命名的参数的HSQL语句检索数据
public List findByNamedParam(String queryString, String[] paramNames,
Object[] values);

// 使用命名的HSQL语句检索数据
public List findByNamedQuery(String queryName);

// 使用带参数的命名HSQL语句检索数据
public List findByNamedQuery(String queryName, Object[] values);

// 使用带命名参数的命名HSQL语句检索数据
public List findByNamedQueryAndNamedParam(String queryName,
String[] paramNames, Object[] values);

// 使用HSQL语句检索数据，返回 Iterator
public Iterator iterate(String queryString);

// 使用带参数HSQL语句检索数据，返回 Iterator
public Iterator iterate(String queryString, Object[] values);

// 关闭检索返回的 Iterator
public void closeIterator(Iterator it);

// -------------------------------- Criteria ------------------------------

// 创建与会话无关的检索标准对象
public DetachedCriteria createDetachedCriteria();

// 创建与会话绑定的检索标准对象
public Criteria createCriteria();

// 使用指定的检索标准检索数据
public List findByCriteria(DetachedCriteria criteria);

// 使用指定的检索标准检索数据，返回部分记录
public List findByCriteria(DetachedCriteria criteria, int firstResult,
int maxResults);

// 使用指定的实体及属性检索（满足除主键外属性＝实体值）数据
public List<T> findEqualByEntity(T entity, String[] propertyNames);

// 使用指定的实体及属性(非主键)检索（满足属性 like 串实体值）数据
public List<T> findLikeByEntity(T entity, String[] propertyNames);

// 使用指定的检索标准检索数据，返回指定范围的记录
public Integer getRowCount(DetachedCriteria criteria);

// 使用指定的检索标准检索数据，返回指定统计值
public Object getStatValue(DetachedCriteria criteria, String propertyName,
String StatName);

// -------------------------------- Others --------------------------------

// 加锁指定的实体
public void lock(T entity, LockMode lockMode);

// 强制初始化指定的实体
public void initialize(Object proxy);

// 强制立即更新缓冲数据到数据库（否则仅在事务提交时才更新）
public void flush();

}

实现GenericDao接口的Hibernate的实现类 GenericHibernateDao

package com.th.huz;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.PropertyUtils;
import org.hibernate.Criteria;
import org.hibernate.LockMode;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

@SuppressWarnings("unchecked")
public class GenericHibernateDao<T extends Serializable, PK extends Serializable>
extends HibernateDaoSupport implements GenericDao<T, PK> {
// 实体类类型(由构造方法自动赋值)
private Class<T> entityClass;

// 构造方法，根据实例类自动获取实体类类型
public GenericHibernateDao() {
this.entityClass = null;
Class c = getClass();
Type t = c.getGenericSuperclass();
if (t instanceof ParameterizedType) {
Type[] p = ((ParameterizedType) t).getActualTypeArguments();
this.entityClass = (Class<T>) p[0];
}
}

// -------------------- 基本检索、增加、修改、删除操作 --------------------

// 根据主键获取实体。如果没有相应的实体，返回 null。
public T get(PK id) {
return (T) getHibernateTemplate().get(entityClass, id);
}

// 根据主键获取实体并加锁。如果没有相应的实体，返回 null。
public T getWithLock(PK id, LockMode lock) {
T t = (T) getHibernateTemplate().get(entityClass, id, lock);
if (t != null) {
this.flush(); // 立即刷新，否则锁不会生效。
}
return t;
}

// 根据主键获取实体。如果没有相应的实体，抛出异常。
public T load(PK id) {
return (T) getHibernateTemplate().load(entityClass, id);
}

// 根据主键获取实体并加锁。如果没有相应的实体，抛出异常。
public T loadWithLock(PK id, LockMode lock) {
T t = (T) getHibernateTemplate().load(entityClass, id, lock);
if (t != null) {
this.flush(); // 立即刷新，否则锁不会生效。
}
return t;
}

// 获取全部实体。
public List<T> loadAll() {
return (List<T>) getHibernateTemplate().loadAll(entityClass);
}

// loadAllWithLock() ?

// 更新实体
public void update(T entity) {
getHibernateTemplate().update(entity);
}

// 更新实体并加锁
public void updateWithLock(T entity, LockMode lock) {
getHibernateTemplate().update(entity, lock);
this.flush(); // 立即刷新，否则锁不会生效。
}

// 存储实体到数据库
public void save(T entity) {
getHibernateTemplate().save(entity);
}

// saveWithLock()？

// 增加或更新实体
public void saveOrUpdate(T entity) {
getHibernateTemplate().saveOrUpdate(entity);
}

// 增加或更新集合中的全部实体
public void saveOrUpdateAll(Collection<T> entities) {
getHibernateTemplate().saveOrUpdateAll(entities);
}

// 删除指定的实体
public void delete(T entity) {
getHibernateTemplate().delete(entity);
}

// 加锁并删除指定的实体
public void deleteWithLock(T entity, LockMode lock) {
getHibernateTemplate().delete(entity, lock);
this.flush(); // 立即刷新，否则锁不会生效。
}

// 根据主键删除指定实体
public void deleteByKey(PK id) {
this.delete(this.load(id));
}

// 根据主键加锁并删除指定的实体
public void deleteByKeyWithLock(PK id, LockMode lock) {
this.deleteWithLock(this.load(id), lock);
}

// 删除集合中的全部实体
public void deleteAll(Collection<T> entities) {
getHibernateTemplate().deleteAll(entities);
}

// -------------------- HSQL ----------------------------------------------

// 使用HSQL语句直接增加、更新、删除实体
public int bulkUpdate(String queryString) {
return getHibernateTemplate().bulkUpdate(queryString);
}

// 使用带参数的HSQL语句增加、更新、删除实体
public int bulkUpdate(String queryString, Object[] values) {
return getHibernateTemplate().bulkUpdate(queryString, values);
}

// 使用HSQL语句检索数据
public List find(String queryString) {
return getHibernateTemplate().find(queryString);
}

// 使用带参数的HSQL语句检索数据
public List find(String queryString, Object[] values) {
return getHibernateTemplate().find(queryString, values);
}

// 使用带命名的参数的HSQL语句检索数据
public List findByNamedParam(String queryString, String[] paramNames,
Object[] values) {
return getHibernateTemplate().findByNamedParam(queryString, paramNames,
values);
}

// 使用命名的HSQL语句检索数据
public List findByNamedQuery(String queryName) {
return getHibernateTemplate().findByNamedQuery(queryName);
}

// 使用带参数的命名HSQL语句检索数据
public List findByNamedQuery(String queryName, Object[] values) {
return getHibernateTemplate().findByNamedQuery(queryName, values);
}

// 使用带命名参数的命名HSQL语句检索数据
public List findByNamedQueryAndNamedParam(String queryName,
String[] paramNames, Object[] values) {
return getHibernateTemplate().findByNamedQueryAndNamedParam(queryName,
paramNames, values);
}

// 使用HSQL语句检索数据，返回 Iterator
public Iterator iterate(String queryString) {
return getHibernateTemplate().iterate(queryString);
}

// 使用带参数HSQL语句检索数据，返回 Iterator
public Iterator iterate(String queryString, Object[] values) {
return getHibernateTemplate().iterate(queryString, values);
}

// 关闭检索返回的 Iterator
public void closeIterator(Iterator it) {
getHibernateTemplate().closeIterator(it);
}

// -------------------------------- Criteria ------------------------------

// 创建与会话无关的检索标准
public DetachedCriteria createDetachedCriteria() {
return DetachedCriteria.forClass(this.entityClass);
}

// 创建与会话绑定的检索标准
public Criteria createCriteria() {
return this.createDetachedCriteria().getExecutableCriteria(
this.getSession());
}

// 检索满足标准的数据
public List findByCriteria(DetachedCriteria criteria) {
return getHibernateTemplate().findByCriteria(criteria);
}

// 检索满足标准的数据，返回指定范围的记录
public List findByCriteria(DetachedCriteria criteria, int firstResult,
int maxResults) {
return getHibernateTemplate().findByCriteria(criteria, firstResult,
maxResults);
}

// 使用指定的实体及属性检索（满足除主键外属性＝实体值）数据
public List<T> findEqualByEntity(T entity, String[] propertyNames) {
Criteria criteria = this.createCriteria();
Example exam = Example.create(entity);
exam.excludeZeroes();
String[] defPropertys = getSessionFactory().getClassMetadata(
entityClass).getPropertyNames();
for (String defProperty : defPropertys) {
int ii = 0;
for (ii = 0; ii < propertyNames.length; ++ii) {
if (defProperty.equals(propertyNames[ii])) {
criteria.addOrder(Order.asc(defProperty));
break;
}
}
if (ii == propertyNames.length) {
exam.excludeProperty(defProperty);
}
}
criteria.add(exam);
return (List<T>) criteria.list();
}

// 使用指定的实体及属性检索（满足属性 like 串实体值）数据
public List<T> findLikeByEntity(T entity, String[] propertyNames) {
Criteria criteria = this.createCriteria();
for (String property : propertyNames) {
try {
Object value = PropertyUtils.getProperty(entity, property);
if (value instanceof String) {
criteria.add(Restrictions.like(property, (String) value,
MatchMode.ANYWHERE));
criteria.addOrder(Order.asc(property));
} else {
criteria.add(Restrictions.eq(property, value));
criteria.addOrder(Order.asc(property));
}
} catch (Exception ex) {
// 忽略无效的检索参考数据。
}
}
return (List<T>) criteria.list();
}

// 使用指定的检索标准获取满足标准的记录数
public Integer getRowCount(DetachedCriteria criteria) {
criteria.setProjection(Projections.rowCount());
List list = this.findByCriteria(criteria, 0, 1);
return (Integer) list.get(0);
}

// 使用指定的检索标准检索数据，返回指定统计值(max,min,avg,sum)
public Object getStatValue(DetachedCriteria criteria, String propertyName,
String StatName) {
if (StatName.toLowerCase().equals("max"))
criteria.setProjection(Projections.max(propertyName));
else if (StatName.toLowerCase().equals("min"))
criteria.setProjection(Projections.min(propertyName));
else if (StatName.toLowerCase().equals("avg"))
criteria.setProjection(Projections.avg(propertyName));
else if (StatName.toLowerCase().equals("sum"))
criteria.setProjection(Projections.sum(propertyName));
else
return null;
List list = this.findByCriteria(criteria, 0, 1);
return list.get(0);
}

// -------------------------------- Others --------------------------------

// 加锁指定的实体
public void lock(T entity, LockMode lock) {
getHibernateTemplate().lock(entity, lock);
}

// 强制初始化指定的实体
public void initialize(Object proxy) {
getHibernateTemplate().initialize(proxy);
}

// 强制立即更新缓冲数据到数据库（否则仅在事务提交时才更新）
public void flush() {
getHibernateTemplate().flush();
}
}
//以上代码来自网上收集

以上就实现了泛型的 Hibernate Dao 了，下面的例子就是业务对象对 GenericHibernateDao的使用

业务对象 Article 对应文章表的 aticle 表

package com.th.huz.model;

import java.io.Serializable;
import java.util.Date;

public class Article implements Serializable {

private static final long serialVersionUID = 1072812006693587010L;

private long id;
private String title;
private String author;
private Date pubDate;
private String content;

public long getId() {
return id;
}

public void setId(long id) {
this.id = id;
}

public String getTitle() {
return title;
}

public void setTitle(String title) {
this.title = title;
}

public String getAuthor() {
return author;
}

public void setAuthor(String author) {
this.author = author;
}

public Date getPubDate() {
return pubDate;
}

public void setPubDate(Date pubDate) {
this.pubDate = pubDate;
}

public String getContent() {
return content;
}

public void setContent(String content) {
this.content = content;
}
}

定义 Article 业务对象的Dao 接口 IArticleDao ，它继承自 GenericDao 接口，以获得其中的方法

你可以在 IArticleDao 中添加 Article 业务对象特有的方法，也可以直接使用 GenericDao 中提供的所有方法IArticleDao接口指定业务对象的类型和主键的类型 <Article,Long>

package com.th.huz.model;

import com.th.huz.dao.GenericDao;
import com.th.huz.model.Article;
public interface IArticleDAO extends GenericDao <Article,Long> {
// public void findById(Long id);
}
然后就可以定义 ArticleHibernateDao 类了，它只要实现 IArticleDao 接口并继承 GenericHibernateDao 类就可以使用所有的 Generic 接口和 IArticleDao 接口中的定义的方法。如果你在 IArticleDao 接口里指定了Article业务对象特有的方法，就在ArticleHibernateDao实现这些方法。而Generic 接口中的方法，在ArticleHibernateDao 的父类 GenericHibernateDao 中已经全部实现了，直接调用就可以方便的访问数据库。

package com.th.huz.model;

import com.th.huz.dao.GenericHibernateDao;

public class ArticleHibernateDao extends GenericHibernateDao<Article,Long> implements
IArticleDAO {

}
其他的业务对象也可以参照 Article 和 ArticleHibernateDao 类来定义， GenericDao 接口中有的通用方法就直接调用，不足的以后补充，其他业务对象特有的方法就在其他业务对象的 Dao接口(继承GenericDao接口) 中定义并通过 GenericHibernateDao 子类来实现。节省很多重复代码，简单几步就可以使用GenericDao接口的实现类 GenericHibernateDao 方便地访问数据库。

最后提供一个 Article 业务对象的 Hibernate 映射文件和建表SQL脚本和一个 ArticleHibernateDao 类的测试类

Article的映射文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="com.th.huz.model.Article" table="article">
<id name="id" type="java.lang.Long">
<column name="id" />
<generator class="native" />
</id>
<property name="title" type="java.lang.String">
<column name="title" length="100" />
</property>
<property name="author">
<column name="author" length="32" />
</property>
<property name="pubDate" type="java.util.Date">
<column name="pubDate" />
</property>
<property name="content" type="java.lang.String">
<column name="content" />
</property>
</class>
</hibernate-mapping>
Article对应的article表的建表脚本

if exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[article]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[article]
GO

CREATE TABLE [dbo].[article] (
[id] [int] IDENTITY (1, 1) NOT NULL ,
[title] [varchar] (100) COLLATE Chinese_PRC_CI_AS NOT NULL ,
[author] [varchar] (32) COLLATE Chinese_PRC_CI_AS NULL ,
[pubDate] [datetime] NULL ,
[content] [text] COLLATE Chinese_PRC_CI_AS NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
ArticleHibernateDao的测试类，只提供了seve(article) 方法的测试代码

package com.th.huz.test;

import junit.framework.TestCase;

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

import com.th.huz.model.Article;
import com.th.huz.model.ArticleHibernateDao;

public class ArticleHibernateDaoTest extends TestCase {

ApplicationContext ctx = new ClassPathXmlApplicationContext(
"applicationContext.xml");
ArticleHibernateDao adh = (ArticleHibernateDao) ctx
.getBean("articleHibernateDao");

public void testSave() {
Article art = (Article) ctx.getBean("article");
art.setId(1);
art.setTitle("标题1");
art.setAuthor("作者1");
adh.save(art);
}
}

posted @ 2012-03-20 22:20 abin 阅读(2039) | 评论 (0) | 编辑收藏

Spring 事务传播行为，隔离级别，代理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
   xmlns:tx="http://www.springframework.org/schema/tx"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
   http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

   
   <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
       destroy-method="close">
       <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
       <property name="url" value="jdbc:mysql://localhost:3306/abin"></property>
       <property name="username" value="root"></property>
       <property name="password" value="root"></property>
       <property name="maxActive" value="100"></property>
       <property name="maxIdle" value="30"></property>
       <property name="maxWait" value="500"></property>
       <property name="defaultAutoCommit" value="true"></property>
   </bean>

   
   <bean id="sessionFactory"
       class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
       <property name="dataSource" ref="dataSource"></property>
       <property name="hibernateProperties">
           <props>
               <prop key="hibernate.dialect">
                   org.hibernate.dialect.MySQLDialect
               </prop>
               <prop key="hibernate.show_sql">true</prop>
               <prop key="hibernate.format_sql">true</prop>
               <prop key="hibernate.hbm2ddl.auto">update</prop>
           </props>
       </property>
       <property name="mappingResources">
           <list>
               <value>com/abin/conference/hbm/ConferenceBean.hbm.xml</value>
           </list>
       </property>
   </bean>

   
   <bean id="transactionManager"
       class="org.springframework.orm.hibernate3.HibernateTransactionManager">
       <property name="sessionFactory">
           <ref local="sessionFactory" />
       </property>
   </bean>

   
   <bean id="transactionInterceptor"
       class="org.springframework.transaction.interceptor.TransactionInterceptor">
       <property name="transactionManager">
           <ref bean="transactionManager"></ref>
       </property>
       <property name="transactionAttributes">
           <props>
               <prop key="insert*">PROPAGATION_REQUIRED,ISOLATION_READ_COMMITTED,timeout_10,-EXCEPTION</prop>
               <prop key="del*">PROPAGATION_REQUIRED</prop>
               <prop key="update*">PROPAGATION_REQUIRED</prop>
               <prop key="find">PROPAGATION_REQUIRED</prop>
               <prop key="get">PROPAGATION_REQUIRED</prop>
           </props>
       </property>
   </bean>

   
   <bean id="userService" class="org.springframework.aop.framework.ProxyFactoryBean">
       <property name="target" ref="userServiceTarget"></property>
       <property name="interceptorNames">
           <value>transactionInterceptor</value>
       </property>
   </bean>

   
   
   
</beans>

posted @ 2012-03-19 23:53 abin 阅读(512) | 评论 (0) | 编辑收藏

wireshark的使用教程

摘要: wireshark是一款抓包软件，比较易用，在平常可以利用它抓包，分析协议或者监控网络，是一个比较好的工具，因为最近在研究这个，所以就写一下教程，方便大家学习。这里先说Wireshark的启动界面和抓包界面启... 阅读全文

posted @ 2012-03-19 17:21 abin 阅读(1033) | 评论 (0) | 编辑收藏

（转）数据库查询速度慢的原因

●查询速度慢的原因很多，常见如下几种：
1、没有索引或者没有用到索引(这是查询慢最常见的问题，是程序设计的缺陷)
2、I/O吞吐量小，形成了瓶颈效应。
3、没有创建计算列导致查询不优化。
4、内存不足
5、网络速度慢
6、查询出的数据量过大（可以采用多次查询，其他的方法降低数据量）
7、锁或者死锁(这也是查询慢最常见的问题，是程序设计的缺陷)
8、sp_lock,sp_who,活动的用户查看,原因是读写竞争资源。
9、返回了不必要的行和列
10、查询语句不好，没有优化 ●可以通过如下方法来优化查询 :
1、把数据、日志、索引放到不同的I/O设备上，增加读取速度，以前可以将Tempdb应放在RAID0上，SQL2000不在支持。数据量（尺寸）越大，提高I/O越重要.
2、纵向、横向分割表，减少表的尺寸(sp_spaceuse)
3、升级硬件
4、根据查询条件,建立索引,优化索引、优化访问方式，限制结果集的数据量。注意填充因子要适当（最好是使用默认值0）。索引应该尽量小，使用字节数小的列建索引好（参照索引的创建）,不要对有限的几个值的字段建单一索引如性别字段
5、提高网速;
6、扩大服务器的内存,Windows 2000和SQL server 2000能支持4-8G的内存。配置虚拟内存：虚拟内存大小应基于计算机上并发运行的服务进行配置。运行 Microsoft SQL Server? 2000 时，可考虑将虚拟内存大小设置为计算机中安装的物理内存的 1.5 倍。如果另外安装了全文检索功能，并打算运行 Microsoft 搜索服务以便执行全文索引和查询，可考虑：将虚拟内存大小配置为至少是计算机中安装的物理内存的 3 倍。将 SQL Servermax server memory 服务器配置选项配置为物理内存的 1.5 倍（虚拟内存大小设置的一半）。
7、增加服务器CPU个数;但是必须明白并行处理串行处理更需要资源例如内存。使用并行还是串行程是MsSQL自动评估选择的。单个任务分解成多个任务，就可以在处理器上运行。例如耽搁查询的排序、连接、扫描和GROUP BY字句同时执行，SQL SERVER根据系统的负载情况决定最优的并行等级，复杂的需要消耗大量的CPU的查询最适合并行处理。但是更新操作UPDATE,INSERT，DELETE还不能并行处理。
8、如果是使用like进行查询的话，简单的使用index是不行的，但是全文索引，耗空间。 like 'a%' 使用索引 like '%a' 不使用索引用 like '%a%' 查询时，查询耗时和字段值总长度成正比,所以不能用CHAR类型，而是VARCHAR。对于字段的值很长的建全文索引。
9、DB Server 和APPLication Server 分离；OLTP和OLAP分离
10、分布式分区视图可用于实现数据库服务器联合体。联合体是一组分开管理的服务器，但它们相互协作分担系统的处理负荷。这种通过分区数据形成数据库服务器联合体的机制能够扩大一组服务器，以支持大型的多层 Web 站点的处理需要。有关更多信息，参见设计联合数据库服务器。（参照SQL帮助文件'分区视图'）
a、在实现分区视图之前，必须先水平分区表
b、在创建成员表后，在每个成员服务器上定义一个分布式分区视图，并且每个视图具有相同的名称。这样，引用分布式分区视图名的查询可以在任何一个成员服务器上运行。系统操作如同每个成员服务器上都有一个原始表的复本一样，但其实每个服务器上只有一个成员表和一个分布式分区视图。数据的位置对应用程序是透明的。
11、重建索引 DBCC REINDEX ,DBCC INDEXDEFRAG,收缩数据和日志 DBCC SHRINKDB,DBCC SHRINKFILE. 设置自动收缩日志.对于大的数据库不要设置数据库自动增长，它会降低服务器的性能。在T-sql的写法上有很大的讲究，下面列出常见的要点：首先，DBMS处理查询计划的过程是这样的：
  1、查询语句的词法、语法检查
  2、将语句提交给DBMS的查询优化器
  3、优化器做代数优化和存取路径的优化
  4、由预编译模块生成查询规划
  5、然后在合适的时间提交给系统处理执行
  6、最后将执行结果返回给用户其次，看一下SQL SERVER的数据存放的结构：一个页面的大小为8K(8060)字节，8个页面为一个盘区，按照B树存放。
12、Commit和rollback的区别 Rollback:回滚所有的事物。 Commit:提交当前的事物. 没有必要在动态SQL里写事物，如果要写请写在外面如： begin tran exec(@s) commit trans 或者将动态SQL 写成函数或者存储过程。
13、在查询Select语句中用Where字句限制返回的行数,避免表扫描,如果返回不必要的数据，浪费了服务器的I/O资源，加重了网络的负担降低性能。如果表很大，在表扫描的期间将表锁住，禁止其他的联接访问表,后果严重。
14、SQL的注释申明对执行没有任何影响
15、尽可能不使用光标，它占用大量的资源。如果需要row-by-row地执行，尽量采用非光标技术,如：在客户端循环，用临时表，Table变量，用子查询，用Case语句等等。游标可以按照它所支持的提取选项进行分类：只进必须按照从第一行到最后一行的顺序提取行。FETCH NEXT 是唯一允许的提取操作,也是默认方式。可滚动性可以在游标中任何地方随机提取任意行。游标的技术在SQL2000下变得功能很强大，他的目的是支持循环。有四个并发选项 READ_ONLY：不允许通过游标定位更新(Update)，且在组成结果集的行中没有锁。 OPTIMISTIC WITH valueS:乐观并发控制是事务控制理论的一个标准部分。乐观并发控制用于这样的情形，即在打开游标及更新行的间隔中，只有很小的机会让第二个用户更新某一行。当某个游标以此选项打开时，没有锁控制其中的行，这将有助于最大化其处理能力。如果用户试图修改某一行，则此行的当前值会与最后一次提取此行时获取的值进行比较。如果任何值发生改变，则服务器就会知道其他人已更新了此行，并会返回一个错误。如果值是一样的，服务器就执行修改。选择这个并发选项OPTIMISTIC WITH ROW VERSIONING:此乐观并发控制选项基于行版本控制。使用行版本控制，其中的表必须具有某种版本标识符，服务器可用它来确定该行在读入游标后是否有所更改。在 SQL Server 中，这个性能由 timestamp 数据类型提供，它是一个二进制数字，表示数据库中更改的相对顺序。每个数据库都有一个全局当前时间戳值：@@DBTS。每次以任何方式更改带有 timestamp 列的行时，SQL Server 先在时间戳列中存储当前的 @@DBTS 值，然后增加 @@DBTS 的值。如果某个表具有 timestamp 列，则时间戳会被记到行级。服务器就可以比较某行的当前时间戳值和上次提取时所存储的时间戳值，从而确定该行是否已更新。服务器不必比较所有列的值，只需比较 timestamp 列即可。如果应用程序对没有 timestamp 列的表要求基于行版本控制的乐观并发，则游标默认为基于数值的乐观并发控制。 SCROLL LOCKS 这个选项实现悲观并发控制。在悲观并发控制中，在把数据库的行读入游标结果集时，应用程序将试图锁定数据库行。在使用服务器游标时，将行读入游标时会在其上放置一个更新锁。如果在事务内打开游标，则该事务更新锁将一直保持到事务被提交或回滚；当提取下一行时，将除去游标锁。如果在事务外打开游标，则提取下一行时，锁就被丢弃。因此，每当用户需要完全的悲观并发控制时，游标都应在事务内打开。更新锁将阻止任何其它任务获取更新锁或排它锁，从而阻止其它任务更新该行。然而，更新锁并不阻止共享锁，所以它不会阻止其它任务读取行，除非第二个任务也在要求带更新锁的读取。滚动锁根据在游标定义的 SELECT 语句中指定的锁提示，这些游标并发选项可以生成滚动锁。滚动锁在提取时在每行上获取，并保持到下次提取或者游标关闭，以先发生者为准。下次提取时，服务器为新提取中的行获取滚动锁，并释放上次提取中行的滚动锁。滚动锁独立于事务锁，并可以保持到一个提交或回滚操作之后。如果提交时关闭游标的选项为关，则 COMMIT 语句并不关闭任何打开的游标，而且滚动锁被保留到提交之后，以维护对所提取数据的隔离。所获取滚动锁的类型取决于游标并发选项和游标 SELECT 语句中的锁提示。锁提示只读乐观数值乐观行版本控制锁定无提示未锁定未锁定未锁定更新 NOLOCK 未锁定未锁定未锁定未锁定 HOLDLOCK 共享共享共享更新 UPDLOCK 错误更新更新更新 TABLOCKX 错误未锁定未锁定更新其它未锁定未锁定未锁定更新 *指定 NOLOCK 提示将使指定了该提示的表在游标内是只读的。
16、用Profiler来跟踪查询，得到查询所需的时间，找出SQL的问题所在;用索引优化器优化索引
17、注意UNion和UNion all 的区别。UNION all好
18、注意使用DISTINCT，在没有必要时不要用，它同UNION一样会使查询变慢。重复的记录在查询里是没有问题的
19、查询时不要返回不需要的行、列
20、用sp_configure 'query governor cost limit'或者SET QUERY_GOVERNOR_COST_LIMIT来限制查询消耗的资源。当评估查询消耗的资源超出限制时，服务器自动取消查询,在查询之前就扼杀掉。SET LOCKTIME设置锁的时间
21、用select top 100 / 10 Percent 来限制用户返回的行数或者SET ROWCOUNT来限制操作的行
22、在SQL2000以前，一般不要用如下的字句: "IS NULL", "<>", "!=", "!>", "!<", "NOT", "NOT EXISTS", "NOT IN", "NOT LIKE", and "LIKE '%500'"，因为他们不走索引全是表扫描。也不要在WHere字句中的列名加函数，如Convert，substring等,如果必须用函数的时候，创建计算列再创建索引来替代.还可以变通写法：WHERE SUBSTRING(firstname,1,1) = 'm'改为WHERE firstname like 'm%'（索引扫描），一定要将函数和列名分开。并且索引不能建得太多和太大。NOT IN会多次扫描表，使用EXISTS、NOT EXISTS ，IN , LEFT OUTER JOIN 来替代，特别是左连接,而Exists比IN更快，最慢的是NOT操作.如果列的值含有空，以前它的索引不起作用，现在2000的优化器能够处理了。相同的是IS NULL，“NOT", "NOT EXISTS", "NOT IN"能优化她，而”<>”等还是不能优化，用不到索引。
23、使用Query Analyzer，查看SQL语句的查询计划和评估分析是否是优化的SQL。一般的20%的代码占据了80%的资源，我们优化的重点是这些慢的地方。
24、如果使用了IN或者OR等时发现查询没有走索引，使用显示申明指定索引： SELECT * FROM PersonMember (INDEX = IX_Title) WHERE processid IN (‘男’，‘女’)
25、将需要查询的结果预先计算好放在表中，查询的时候再SELECT。这在SQL7.0以前是最重要的手段。例如医院的住院费计算。
26、MIN() 和 MAX()能使用到合适的索引。
27、数据库有一个原则是代码离数据越近越好，所以优先选择Default,依次为Rules,Triggers, Constraint（约束如外健主健CheckUNIQUE……,数据类型的最大长度等等都是约束）,Procedure.这样不仅维护工作小，编写程序质量高，并且执行的速度快。
28、如果要插入大的二进制值到Image列，使用存储过程，千万不要用内嵌INsert来插入(不知JAVA是否)。因为这样应用程序首先将二进制值转换成字符串（尺寸是它的两倍），服务器受到字符后又将他转换成二进制值.存储过程就没有这些动作: 方法：Create procedure p_insert as insert into table(Fimage) values (@image), 在前台调用这个存储过程传入二进制参数，这样处理速度明显改善。
29、Between在某些时候比IN速度更快,Between能够更快地根据索引找到范围。用查询优化器可见到差别。 select * from chineseresume where title in ('男','女') Select * from chineseresume where between '男' and '女' 是一样的。由于in会在比较多次，所以有时会慢些。
30、在必要是对全局或者局部临时表创建索引，有时能够提高速度，但不是一定会这样，因为索引也耗费大量的资源。他的创建同是实际表一样。
31、不要建没有作用的事物例如产生报表时，浪费资源。只有在必要使用事物时使用它。
32、用OR的字句可以分解成多个查询，并且通过UNION 连接多个查询。他们的速度只同是否使用索引有关,如果查询需要用到联合索引，用UNION all执行的效率更高.多个OR的字句没有用到索引，改写成UNION的形式再试图与索引匹配。一个关键的问题是否用到索引。
33、尽量少用视图，它的效率低。对视图操作比直接对表操作慢,可以用stored procedure来代替她。特别的是不要用视图嵌套,嵌套视图增加了寻找原始资料的难度。我们看视图的本质：它是存放在服务器上的被优化好了的已经产生了查询规划的SQL。对单个表检索数据时，不要使用指向多个表的视图，直接从表检索或者仅仅包含这个表的视图上读，否则增加了不必要的开销,查询受到干扰.为了加快视图的查询，MsSQL增加了视图索引的功能。
34、没有必要时不要用DISTINCT和ORDER BY，这些动作可以改在客户端执行。它们增加了额外的开销。这同UNION 和UNION ALL一样的道理。SELECT top 20 ad.companyname,comid,position,ad.referenceid,worklocation, convert(varchar(10),ad.postDate,120) as postDate1,workyear,degreedescription FROM jobcn_query.dbo.COMPANYAD_query ad where referenceID in('JCNAD00329667','JCNAD132168','JCNAD00337748','JCNAD00338345','JCNAD00333138','JCNAD00303570', 'JCNAD00303569','JCNAD00303568','JCNAD00306698','JCNAD00231935','JCNAD00231933','JCNAD00254567', 'JCNAD00254585','JCNAD00254608','JCNAD00254607','JCNAD00258524','JCNAD00332133','JCNAD00268618', 'JCNAD00279196','JCNAD00268613') order by postdate desc
35、在IN后面值的列表中，将出现最频繁的值放在最前面，出现得最少的放在最后面，减少判断的次数。
36、当用SELECT INTO时，它会锁住系统表(sysobjects，sysindexes等等)，阻塞其他的连接的存取。创建临时表时用显示申明语句，而不是select INTO. drop table t_lxh begin tran select * into t_lxh from chineseresume where name = 'XYZ' --commit 在另一个连接中SELECT * from sysobjects可以看到 SELECT INTO 会锁住系统表，Create table 也会锁系统表(不管是临时表还是系统表)。所以千万不要在事物内使用它！！！这样的话如果是经常要用的临时表请使用实表，或者临时表变量。
37、一般在GROUP BY 个HAVING字句之前就能剔除多余的行，所以尽量不要用它们来做剔除行的工作。他们的执行顺序应该如下最优：select 的Where字句选择所有合适的行，Group By用来分组个统计行，Having字句用来剔除多余的分组。这样Group By 个Having的开销小，查询快.对于大的数据行进行分组和Having十分消耗资源。如果Group BY的目的不包括计算，只是分组，那么用Distinct更快
38、一次更新多条记录比分多次更新每次一条快,就是说批处理好
39、少用临时表，尽量用结果集和Table类性的变量来代替它,Table 类型的变量比临时表好
40、在SQL2000下，计算字段是可以索引的，需要满足的条件如下：
a、计算字段的表达是确定的
b、不能用在TEXT,Ntext，Image数据类型
c、必须配制如下选项 ANSI_NULLS = ON, ANSI_PADDINGS = ON, …….
41、尽量将数据的处理工作放在服务器上，减少网络的开销，如使用存储过程。存储过程是编译好、优化过、并且被组织到一个执行规划里、且存储在数据库中的SQL语句，是控制流语言的集合，速度当然快。反复执行的动态SQL,可以使用临时存储过程，该过程（临时表）被放在Tempdb中。以前由于SQL SERVER对复杂的数学计算不支持，所以不得不将这个工作放在其他的层上而增加网络的开销。SQL2000支持UDFs,现在支持复杂的数学计算，函数的返回值不要太大，这样的开销很大。用户自定义函数象光标一样执行的消耗大量的资源，如果返回大的结果采用存储过程
42、不要在一句话里再三的使用相同的函数，浪费资源,将结果放在变量里再调用更快
43、SELECT COUNT(*)的效率教低，尽量变通他的写法，而EXISTS快.同时请注意区别： select count(Field of null) from Table 和 select count(Field of NOT null) from Table 的返回值是不同的！！！
44、当服务器的内存够多时，配制线程数量 = 最大连接数+5，这样能发挥最大的效率；否则使用配制线程数量<最大连接数启用SQL SERVER的线程池来解决,如果还是数量 = 最大连接数+5，严重的损害服务器的性能。
45、按照一定的次序来访问你的表。如果你先锁住表A，再锁住表B，那么在所有的存储过程中都要按照这个顺序来锁定它们。如果你（不经意的）某个存储过程中先锁定表B，再锁定表A，这可能就会导致一个死锁。如果锁定顺序没有被预先详细的设计好，死锁很难被发现
46、通过SQL Server Performance Monitor监视相应硬件的负载 Memory: Page Faults / sec计数器如果该值偶尔走高，表明当时有线程竞争内存。如果持续很高，则内存可能是瓶颈。 Process:
  1、% DPC Time 指在范例间隔期间处理器用在缓延程序调用(DPC)接收和提供服务的百分比。(DPC 正在运行的为比标准间隔优先权低的间隔)。由于 DPC 是以特权模式执行的，DPC 时间的百分比为特权时间百分比的一部分。这些时间单独计算并且不属于间隔计算总数的一部分。这个总数显示了作为实例时间百分比的平均忙时。
  2、%Processor Time计数器　如果该参数值持续超过95%，表明瓶颈是CPU。可以考虑增加一个处理器或换一个更快的处理器。
  3、% Privileged Time 指非闲置处理器时间用于特权模式的百分比。(特权模式是为操作系统组件和操纵硬件驱动程序而设计的一种处理模式。它允许直接访问硬件和所有内存。另一种模式为用户模式，它是一种为应用程序、环境分系统和整数分系统设计的一种有限处理模式。操作系统将应用程序线程转换成特权模式以访问操作系统服务)。特权时间的 % 包括为间断和 DPC 提供服务的时间。特权时间比率高可能是由于失败设备产生的大数量的间隔而引起的。这个计数器将平均忙时作为样本时间的一部分显示。　　
  4、% User Time表示耗费CPU的数据库操作，如排序，执行aggregate functions等。如果该值很高，可考虑增加索引，尽量使用简单的表联接，水平分割大表格等方法来降低该值。 Physical Disk: Curretn Disk Queue Length计数器该值应不超过磁盘数的1.5~2倍。要提高性能，可增加磁盘。 SQLServer:Cache Hit Ratio计数器该值越高越好。如果持续低于80%，应考虑增加内存。注意该参数值是从SQL Server启动后，就一直累加记数，所以运行经过一段时间后，该值将不能反映系统当前值。
47、分析select emp_name form employee where salary > 3000 在此语句中若salary是Float类型的，则优化器对其进行优化为Convert(float,3000)，因为3000是个整数，我们应在编程时使用3000.0而不要等运行时让DBMS进行转化。同样字符和整型数据的转换。
48、查询的关联同写的顺序 select a.personMemberID, * from chineseresume a,personmember b where personMemberID = b.referenceid and a.personMemberID = 'JCNPRH39681' （A = B ,B = ‘号码’） select a.personMemberID, * from chineseresume a,personmember b where a.personMemberID = b.referenceid and a.personMemberID = 'JCNPRH39681' and b.referenceid = 'JCNPRH39681' （A = B ,B = ‘号码’， A = ‘号码’） select a.personMemberID, * from chineseresume a,personmember b where b.referenceid = 'JCNPRH39681' and a.personMemberID = 'JCNPRH39681' （B = ‘号码’， A = ‘号码’）

posted @ 2012-03-17 01:33 abin 阅读(631) | 评论 (3) | 编辑收藏

深入Java集合学习系列：ArrayList的实现原理

1. ArrayList概述：

   ArrayList是List接口的可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。
   每个ArrayList实例都有一个容量，该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝，因此，如果可预知数据量的多少，可在构造ArrayList时指定其容量。在添加大量元素前，应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量，这可以减少递增式再分配的数量。
   注意，此实现不是同步的。如果多个线程同时访问一个ArrayList实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

2. ArrayList的实现：

对于ArrayList而言，它实现List接口、底层使用数组保存所有元素。其操作基本上是对数组的操作。下面我们来分析ArrayList的源代码：

1) 底层使用数组实现：

Java代码

private transient Object[] elementData;

2) 构造方法：
ArrayList提供了三种方式的构造器，可以构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列的。

Java代码

public ArrayList() {
this(10);
}
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
this.elementData = new Object[initialCapacity];
}
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}

3) 存储：
ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)这些添加元素的方法。下面我们一一讲解：

Java代码

// 用指定的元素替代此列表中指定位置上的元素，并返回以前位于该位置上的元素。
public E set(int index, E element) {
RangeCheck(index);
E oldValue = (E) elementData[index];
elementData[index] = element;
return oldValue;
}

Java代码

// 将指定的元素添加到此列表的尾部。
public boolean add(E e) {
ensureCapacity(size + 1);
elementData[size++] = e;
return true;
}

Java代码

// 将指定的元素插入此列表中的指定位置。
// 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）。
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
// 如果数组长度不足，将进行扩容。
ensureCapacity(size+1); // Increments modCount!!
// 将 elementData中从Index位置开始、长度为size-index的元素，
// 拷贝到从下标为index+1位置开始的新的elementData数组中。
// 即将当前位于该位置的元素以及所有后续元素右移一个位置。
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
size++;
}

Java代码

// 按照指定collection的迭代器所返回的元素顺序，将该collection中的所有元素添加到此列表的尾部。
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}

Java代码

// 从指定的位置开始，将指定collection中的所有元素插入到此列表中。
public boolean addAll(int index, Collection<? extends E> c) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(
"Index: " + index + ", Size: " + size);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacity(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}

4) 读取：

Java代码

// 返回此列表中指定位置上的元素。
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}

5) 删除：
ArrayList提供了根据下标或者指定对象两种方式的删除功能。如下：

Java代码

// 移除此列表中指定位置上的元素。
public E remove(int index) {
RangeCheck(index);
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; // Let gc do its work
return oldValue;
}

Java代码

// 移除此列表中首次出现的指定元素（如果存在）。这是应为ArrayList中允许存放重复的元素。
public boolean remove(Object o) {
// 由于ArrayList中允许存放null，因此下面通过两种情况来分别处理。
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
// 类似remove(int index)，移除列表中指定位置上的元素。
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}

    注意：从数组中移除元素的操作，也会导致被移除的元素以后的所有元素的向左移动一个位置。
   6) 调整数组容量：
   从上面介绍的向ArrayList中存储元素的代码中，我们看到，每当向数组中添加元素时，都要去检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容，以满足添加数据的需求。数组扩容通过一个公开的方法ensureCapacity(int minCapacity)来实现。在实际添加大量元素前，我也可以使用ensureCapacity来手动增加ArrayList实例的容量，以减少递增式再分配的数量。

Java代码

public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
}

从上述代码中可以看出，数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量的增长大约是其原容量的1.5倍。这种操作的代价是很高的，因此在实际使用时，我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时，要在构造ArrayList实例时，就指定其容量，以避免数组扩容的发生。或者根据实际需求，通过调用ensureCapacity方法来手动增加ArrayList实例的容量。
ArrayList还给我们提供了将底层数组的容量调整为当前列表保存的实际元素的大小的功能。它可以通过trimToSize方法来实现。代码如下：

Java代码

public void trimToSize() {
modCount++;
int oldCapacity = elementData.length;
if (size < oldCapacity) {
elementData = Arrays.copyOf(elementData, size);
}
}

7) Fail-Fast机制：
ArrayList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。具体介绍请参考我之前的文章深入Java集合学习系列：HashMap的实现原理中的Fail-Fast机制。
8) 关于其他的一些方法的实现都很简单易懂，读者可参照API文档和源代码，一看便知，这里就不再多说。

3. 相关阅读：
   本系列的文章之前还整理了以下几篇，有兴趣的可以参考，望与大家分享心得，共同进步：
   1) 深入Java集合学习系列：HashMap的实现原理。
   2) 深入Java集合学习系列：LinkedHashMap的实现原理。
   3) 深入Java集合学习系列：HashSet的实现原理。
   4) 深入Java集合学习系列：LinkedHashSet的实现原理。

转载自：http://www.cnblogs.com/batys/archive/2011/11/02/2233597.html

posted @ 2012-03-16 12:28 abin 阅读(604) | 评论 (0) | 编辑收藏

Java 单例模式

1、饿汉模式：

package com.abin.info.service;

public class Singleton {
private static Singleton singleton=new Singleton();

private Singleton(){

}

public static Singleton getInstance(){
return singleton;
}

}

private static LazyMode lazyMode=null;

public static synchronized LazyMode getInstance(){

if(null==lazyMode){

lazyMode=new LazyMode();

}

return lazyMode;

}

2、懒汉模式：

package com.abin.inter.she;

public class Singleton {
private static Singleton singleton=null;
private Singleton(){

}
public static Singleton getInstance(){
  if(null==singleton){
   return new Singleton();
  }
  return singleton;
}

}

懒汉模式的线程安全版本：

package com.abin.lee.template.pattern;

public class LazyMode {

private static LazyMode lazyMode=null;

public static synchronized LazyMode getInstance(){

if(null==lazyMode){

lazyMode=new LazyMode();

}

return lazyMode;

}

3、双重检测：

package com.east.abin.impl;

public class Singleton {
private static Singleton instance=null;
private Singleton(){

}

public static Singleton getInstance(){
  if(null==instance){
   synchronized(Singleton.class){
    if(null==instance){
     instance=new Singleton();
     return instance;
    }
   }
  }
  return instance;
}

}

4.静态内部类：

单例模式创新！google的ioc作者写的。只有在调用的时候才会初始化！而且线程安全

超级牛！

package com.east.abin.bin;

public class Singleton {
private Singleton(){

}

private static class SingletonHelp{
  private static Singleton instance=new Singleton();
}

public static Singleton getInstance(){
  return SingletonHelp.instance;
}

}

5、enum类型的(这个是针对jdk 1.5以及1.5版本以上的)

package com.abin.peng.service;

public enum Singleton {
Singleton;
private Singleton(){}
public static Singleton getInstance(){
return Singleton;
}
}

posted @ 2012-03-15 18:21 abin 阅读(510) | 评论 (0) | 编辑收藏

Java枚举类型enum使用详解

java的Enum枚举类型终于在j2se1.5出现了。之前觉得它只不过是鸡肋而已，可有可无。毕竟这么多年来，没有它，大家不都过得很好吗？今日看《Thinking in Java》4th edition，里面有一句话“有时恰恰因为它，你才能够"优雅而干净"地解决问题。优雅与清晰很重要，正式它们区别了成功的解决方案与失败的解决方案。而失败的解决方案就是因为其他人无法理他。"使用Enum枚举类型，可以将以前笨拙的代码变得优雅简单？但是，我同时也在思考另外一个问题，使用新的技术，会不会给技术人员带来更多的负担呢？

"学习新版语言的一个危险就是疯狂使用新的语法结构"

先学习一下enum的简单应用，以下简洁的代码已经包括enum所提供的绝大部分功能。

1.enum的应用，包括定义，遍历，switch，enumset，enummap等

Java代码

import java.util.EnumMap;
import java.util.EnumSet;
public class EnumTest {
// 定义一个enum枚举类型，包括两个实例ON，OFF
public enum State {
  ON, OFF
};
// 测试函数
public static void main(String[] args) {
  // 直接变量enum
  for (State s : State.values())
   System.out.println(s.name());
  // switch与enum的结合使用
  State switchState = State.OFF;
  switch (switchState) {
  case OFF:
   System.out.println("OFF");
   break;
  case ON:
   System.out.println("ON");
   break;
  }
  // EnumSet的使用
  EnumSet<State> stateSet = EnumSet.allOf(State.class);
  for (State s : stateSet) {
   System.out.println(s);
  }
  // EnumMap的使用
  EnumMap<State,String> stateMap = new EnumMap<State,String>(State.class);
  stateMap.put(State.ON, "is On");
  stateMap.put(State.OFF, "is off");
  for (State s : State.values()) {
   System.out.println(s.name() + ":" + stateMap.get(s));
  }
}
}

package com.aicent.test;
public enum TestEnumMathod {
// 为每个enum实例添加不同的实现方法
SAMPLE1 {
  String getInfo() {
   return "SAMPLE1";
  }
},
SAMPLE2 {
  String getInfo() {
   return "SAMPLE2";
  }
};
abstract String getInfo();
// 测试
public static void main(String args[]) {
  for (TestEnumMathod method : values()) {
   System.out.println(method.getInfo());
  }
}
}

以下内容可能有些无聊，但绝对值得一窥
1.代码：
public class State {
public static final int ON = 1;
public static final Int OFF= 0;
}

有什么不好了，大家都这样用了很长时间了，没什么问题啊。
首先，它不是类型安全的。你必须确保是int
其次，你还要确保它的范围是0和1
最后，很多时候你打印出来的时候，你只看到 1 和0 ，

但其没有看到代码的人并不知道你的企图，抛弃你所有旧的public static final常量吧

2.可以创建一个enum类，把它看做一个普通的类。除了它不能继承其他类了。(java是单继承，它已经继承了Enum),
可以添加其他方法，覆盖它本身的方法

3.switch()参数可以使用enum了

4.values()方法是编译器插入到enum定义中的static方法，所以，当你将enum实例向上转型为父类Enum是，values()就不可访问了。解决办法：在Class中有一个getEnumConstants()方法，所以即便Enum接口中没有values()方法，我们仍然可以通过Class对象取得所有的enum实例

5.无法从enum继承子类，如果需要扩展enum中的元素，在一个接口的内部，创建实现该接口的枚举，以此将元素进行分组。达到将枚举元素进行分组。

6.使用EnumSet代替标志。enum要求其成员都是唯一的，但是enum中不能删除添加元素。

7.EnumMap的key是enum，value是任何其他Object对象。

8.enum允许程序员为eunm实例编写方法。所以可以为每个enum实例赋予各自不同的行为。

9.使用enum的职责链(Chain of Responsibility) .这个关系到设计模式的职责链模式。以多种不同的方法来解决一个问题。然后将他们链接在一起。当一个请求到来时，遍历这个链，直到链中的某个解决方案能够处理该请求。

10.使用enum的状态机

11.使用enum多路分发

转载自：http://blog.csdn.net/mqboss/article/details/5647851

posted @ 2012-03-15 11:16 abin 阅读(452) | 评论 (0) | 编辑收藏

设计模式之六 --- 抽象工厂模式(Abstract Factory)

摘要: 每个模式都是针对一定问题的解决方案。抽象工厂模式面对的问题是多产品等级结构的系统设计。在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。 &nbs... 阅读全文

posted @ 2012-03-15 11:08 abin 阅读(855) | 评论 (0) | 编辑收藏