BlogJava-自由飞翔-随笔分类-other

编码至高法则-高内聚低耦合

GavinMiao — Wed, 11 Sep 2019 07:59:00 GMT

摘要: 此法则适合所有语言，咱们以JavaScript和Java两个角度分析一下这个东东。一、javascript 有这样的一个页面，js、css代码都写在html页面中。例如：gnj.html v1版本Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-... 阅读全文

GavinMiao 2019-09-11 15:59 发表评论

公司口碑及待遇评价的网站

GavinMiao — Tue, 27 Mar 2012 15:13:00 GMT

1.公司速查手册：http://www.b1.tooyard.com/
2.分智网：http://www.fenzhi.com/
3.我评it：http://wopingit.com/
4.企业点评网：http://www.71dp.com/
5.中国企业评价网： http://www.ceea.net.cn/
6.公司点评网：http://www.gsdpw.com/
7.企业付费邀请面试：http://www.tradecv.com/

GavinMiao 2012-03-27 23:13 发表评论

window下dos窗口中文乱码解决办法

GavinMiao — Tue, 20 Mar 2012 03:16:00 GMT

进入注册表：
HKEY_CURRENT_USER\Console\%SystemRoot%_system32_cmd.exe
新建DWORD值，然后重命名为：CodePage，修改其值为十进制的936

GavinMiao 2012-03-20 11:16 发表评论

POI学习

GavinMiao — Wed, 22 Feb 2012 02:01:00 GMT

POI所有组件：

GavinMiao 2012-02-22 10:01 发表评论

MyEclipse修改项目名称

GavinMiao — Sat, 03 Dec 2011 15:37:00 GMT

项目上右击鼠标-->Properties-->MyEclipse-->Web-->Content Root-->Web content-root-->改成你想要的项目名即可

GavinMiao 2011-12-03 23:37 发表评论

转载：tomcat各种配置及编码设置

GavinMiao — Thu, 01 Dec 2011 02:49:00 GMT

只有注册用户登录后才能阅读该文。阅读全文

GavinMiao 2011-12-01 10:49 发表评论

XP 用命令查看和杀死进程

GavinMiao — Mon, 28 Nov 2011 07:28:00 GMT

1：查看8080端口占用情况：
C:\Documents and Settings\Administrator>netstat -aon | findstr "8080"
TCP 0.0.0.0:8080 0.0.0.0:0 LISTENING 3608

2：查看进程

C:\Documents and Settings\Administrator>tasklist | findstr "3608"
javaw.exe 3608 Console 0 69,484 K

3.杀进程：

tskill 3608

GavinMiao 2011-11-28 15:28 发表评论

MyEclipse + Tomcat项目重命名

GavinMiao — Tue, 15 Nov 2011 07:09:00 GMT

文章来源：
问题描述：
原来项目名称是shopping，部署到tomcat后直接输入地址端口后加项目名http://localhost:8080/shopping就可以浏览主页了，后来我把项目名改成shoppingCar，重新部署到tomcat后发现部署过去的项目还是shopping而不是shoppingCar
解决方案：
在MyEclipse里面只把项目重命名是不行的，还要修改以下内容：
项目→properties→MyEclipse→Web下修改Web Context-root的名字为重命名之后的名字即可。

GavinMiao 2011-11-15 15:09 发表评论

转载：在项目中使用多个数据源－多sessionFactory方案

GavinMiao — Mon, 14 Nov 2011 08:11:00 GMT

适用范围：适合SSH架构访问多个数据库，数据库的类型和表结构不必相同，且没有跨库事务的情况（跨库事务最好用分布式事务处理）。

文章来源：http://apps.hi.baidu.com/share/detail/15756344

实现方式：我们可以在spring的配置文件中配置多个sessionFactory,如：
   class="org.apache.commons.dbcp.BasicDataSource"
   destroy-method="close">

    ${adriver}


    ${aurl}


    ${ausername}


    ${apassword}


   class="org.apache.commons.dbcp.BasicDataSource"
   destroy-method="close">

    ${bdriver}


    ${burl}


    ${busername}


    ${bpassword}


   class="org.apache.commons.dbcp.BasicDataSource"
   destroy-method="close">

    ${cdriver}


    ${curl}


    ${cusername}


    ${cpassword}

   class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">






      .hbm.xml文件






      ${ahibernate.dialect}

     true
     true



   class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">






      .hbm.xml文件






      ${bhibernate.dialect}

     true
     true



   class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">






       .hbm.xml文件






      ${chibernate.dialect}

     true
     true





注意：最后一个com.cintel.dcp.datasource.MultiSessionFactory要自己实现，它实现了SessionFactory接口和ApplicationContext接口，如下：
package com.cintel.dcp.datasource;

import java.io.Serializable;
import java.sql.Connection;
import java.util.Map;
import java.util.Set;

import javax.naming.NamingException;
import javax.naming.Reference;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Interceptor;
import org.hibernate.SessionFactory;
import org.hibernate.StatelessSession;
import org.hibernate.classic.Session;
import org.hibernate.engine.FilterDefinition;
import org.hibernate.metadata.ClassMetadata;
import org.hibernate.metadata.CollectionMetadata;
import org.hibernate.stat.Statistics;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class MultiSessionFactory implements SessionFactory, ApplicationContextAware {
private static final long serialVersionUID = 2064557324203496378L;
private static final Log log = LogFactory.getLog(MultiSessionFactory.class);
private ApplicationContext applicationContext = null;
private SessionFactory sessionFactory = null;

public ApplicationContext getApplicationContext() {
   return applicationContext;
}

public void setApplicationContext(ApplicationContext applicationContext) {
   this.applicationContext = applicationContext;
}

public SessionFactory getSessionFactory(String sessionFactoryName) {
   log.debug("sessionFactoryName:"+sessionFactoryName);
   try{
    if(sessionFactoryName==null||sessionFactoryName.equals("")){
     return sessionFactory;
    }
    return (SessionFactory)this.getApplicationContext().getBean(sessionFactoryName);
   }catch(NoSuchBeanDefinitionException ex){
    throw new RuntimeException("There is not the sessionFactory in the applicationContext!");
   }
}

public SessionFactory getSessionFactory() {
   String sessionFactoryName = CustomerContextHolder.getCustomerType();
   return getSessionFactory(sessionFactoryName);
}

public void setSessionFactory(SessionFactory sessionFactory) {
   this.sessionFactory = sessionFactory;
}

/* (non-Javadoc)
* @see org.hibernate.SessionFactory#close()
*/
public void close() throws HibernateException {
   getSessionFactory().close();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evict(java.lang.Class)
*/
public void evict(Class persistentClass) throws HibernateException {
   getSessionFactory().evict(persistentClass);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evict(java.lang.Class, java.io.Serializable)
*/
public void evict(Class persistentClass, Serializable id) throws HibernateException {
   getSessionFactory().evict(persistentClass, id);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictCollection(java.lang.String)
*/
public void evictCollection(String roleName) throws HibernateException {
   getSessionFactory().evictCollection(roleName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictCollection(java.lang.String, java.io.Serializable)
*/
public void evictCollection(String roleName, Serializable id) throws HibernateException {
   getSessionFactory().evictCollection(roleName, id);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictEntity(java.lang.String)
*/
public void evictEntity(String entityName) throws HibernateException {
   getSessionFactory().evictEntity(entityName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictEntity(java.lang.String, java.io.Serializable)
*/
public void evictEntity(String entityName, Serializable id) throws HibernateException {
   getSessionFactory().evictEntity(entityName, id);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictQueries()
*/
public void evictQueries() throws HibernateException {
   getSessionFactory().evictQueries();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictQueries(java.lang.String)
*/
public void evictQueries(String cacheRegion) throws HibernateException {
   getSessionFactory().evictQueries(cacheRegion);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getAllClassMetadata()
*/
public Map getAllClassMetadata() throws HibernateException {
   return getSessionFactory().getAllClassMetadata();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getAllCollectionMetadata()
*/
public Map getAllCollectionMetadata() throws HibernateException {
   return getSessionFactory().getAllCollectionMetadata();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getClassMetadata(java.lang.Class)
*/
public ClassMetadata getClassMetadata(Class persistentClass) throws HibernateException {
   return getSessionFactory().getClassMetadata(persistentClass);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getClassMetadata(java.lang.String)
*/
public ClassMetadata getClassMetadata(String entityName) throws HibernateException {
   return getSessionFactory().getClassMetadata(entityName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getCollectionMetadata(java.lang.String)
*/
public CollectionMetadata getCollectionMetadata(String roleName) throws HibernateException {
   return getSessionFactory().getCollectionMetadata(roleName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getCurrentSession()
*/
public Session getCurrentSession() throws HibernateException {
   return getSessionFactory().getCurrentSession();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getDefinedFilterNames()
*/
public Set getDefinedFilterNames() {
   return getSessionFactory().getDefinedFilterNames();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getFilterDefinition(java.lang.String)
*/
public FilterDefinition getFilterDefinition(String filterName) throws HibernateException {
   return getSessionFactory().getFilterDefinition(filterName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getStatistics()
*/
public Statistics getStatistics() {
   return getSessionFactory().getStatistics();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#isClosed()
*/
public boolean isClosed() {
   return getSessionFactory().isClosed();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession()
*/
public Session openSession() throws HibernateException {
   return getSessionFactory().openSession();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession(java.sql.Connection)
*/
public Session openSession(Connection connection) {
   return getSessionFactory().openSession(connection);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession(org.hibernate.Interceptor)
*/
public Session openSession(Interceptor interceptor) throws HibernateException {
   return getSessionFactory().openSession(interceptor);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession(java.sql.Connection, org.hibernate.Interceptor)
*/
public Session openSession(Connection connection, Interceptor interceptor) {
   return getSessionFactory().openSession(connection, interceptor);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openStatelessSession()
*/
public StatelessSession openStatelessSession() {
   return getSessionFactory().openStatelessSession();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openStatelessSession(java.sql.Connection)
*/
public StatelessSession openStatelessSession(Connection connection) {
   return getSessionFactory().openStatelessSession(connection);
}
/* (non-Javadoc)
* @see javax.naming.Referenceable#getReference()
*/
public Reference getReference() throws NamingException {
   return getSessionFactory().getReference();
}
}

然后我用一个常量类来标识sessionFactory
public class DynamicDataSourceType {
public static final String A= "aSessionFactory";
public static final String B= "bSessionFactory";
public static final String C= "cSessionFactory";
}

最后一个关键类：用来存放当前正在使用的sessionFactory
public class CustomerContextHolder {

private static final ThreadLocal contextHolder = new ThreadLocal();

public static void setCustomerType(String customerType) {
Assert.notNull(customerType, "customerType cannot be null");
contextHolder.set(customerType);
}

public static String getCustomerType() {
return (String) contextHolder.get();
}

public static void clearCustomerType() {
contextHolder.remove();
}
}

可以在action、service、dao中进行数据库切换，切换方式：
CustomerContextHolder.setCustomerType(DynamicDataSourceType.A);

以上思路来自javaEye论坛的一个高手，在此标识感谢

GavinMiao 2011-11-14 16:11 发表评论

转载：动态切换数据源(spring+hibernate)

GavinMiao — Mon, 14 Nov 2011 07:37:00 GMT

文章来源：

http://www.th7.cn/Program/java/2011/10/23/44664.shtml

起因：在当前我手上的一个项目中需要多个数据源,并且来自于不同类型的数据库... 因为很多历史原因.这个项目的住数据源是MySQL,整个系统的CURD都是操作的这个数据库.

但是还有另外两个用于数据采集的数据库: MSSQL,ACCESS.还好只是用于数据采集，在事务上可以不要跨数据库了，这一点节省了好多的工作量.环境：我搭建的测试环境是 spring2.5.6+hibernate3.2
思路：动态切换数据源确切的来说是在同一类型数据库的情况下的。意思就是说 , 在系统中的使用的数据库分布在多台数据库服务器或者在同台服务器上的多个数据库. 在运行时期间根据某种标识符来动态的选择当前操作的数据库. 1.数据源是相同类型的数据库: 一个SessionFactory+动态数据源+一个事务管理器 2.数据源是不同类型的数据库: 根据类型配置多套SessionFactory模拟：两个mysql数据源+一个Access数据源
实现：
1.切换数据源需要标识符,标识符是Object类型

package lhp.example.context;
public enum DBType {
      dataSource1, dataSource2;
}

2.然后创建一个用于切换数据源(设置或者获得上下文)的工具类

package lhp.example.context;

public class ContextHolder {
    private static final ThreadLocal holder = new ThreadLocal();

    public static void setDbType(DBType dbType) {
        holder.set(dbType);
    }

    public static DBType getDbType() {
        return (DBType) holder.get();
    }

    public static void clearDbType() {
        holder.remove();
    }
}

3.创建动态数据源类,继承org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource这个类.

package lhp.example.context;

import java.util.logging.Logger;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {
    public static final Logger logger = Logger.getLogger(DynamicDataSource.class.toString());

    @Override
    protected Object determineCurrentLookupKey() {
        DBType key = ContextHolder.getDbType();//获得当前数据源标识符
        //logger.info("当前数据源 :" + key);
        return key;
    }

}

4.然后配置多个数据源


    <bean id="dataSource1" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/dec" />
        <property name="user" value="root" />
        <property name="password" value="" />
    bean>
    
    <bean id="dataSource2" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/lms" />
        <property name="user" value="root" />
        <property name="password" value="" />
    bean>

    
    <bean id="dataSource3" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="sun.jdbc.odbc.JdbcOdbcDriver" />
        <property name="jdbcUrl" value="jdbc:odbc:accessTest" />
        <property name="user" value="administrator" />
        <property name="password" value="XLZX0309" />
    bean>

    
    <bean id="mysqlDynamicDataSource" class="lhp.example.context.DynamicDataSource">
        <property name="targetDataSources">
            
            <map key-type="lhp.example.context.DBType">
                <entry key="dataSource1" value-ref="dataSource1" />
                <entry key="dataSource2" value-ref="dataSource2" />
            map>
        property>
        <property name="defaultTargetDataSource" ref="dataSource1" />
    bean>

5.配置sessionFactory


    <bean id="mysqlSessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="mysqlDynamicDataSource" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop>
                <prop key="hibernate.show_sql">trueprop>
                <prop key="hibernate.hbm2ddl.auto">updateprop>
                <prop key="hibernate.query.substitutions">true 1, false 0prop>
            props>
        property>
    bean>
    
    
    <bean id="aceessSessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource3" />
        <property name="hibernateProperties">
            <props>
                
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialectprop>
                <prop key="hibernate.jdbc.batch_size">30prop>
                <prop key="hibernate.jdbc.fetch_size">50prop>
                <prop key="hibernate.show_sql">trueprop>
                <prop key="hibernate.format_sql">falseprop>
                <prop key="hibernate.hbm2ddl.auto">updateprop>
                <prop key="hibernate.query.substitutions">true 1, false 0prop>
                <prop key="hibernate.cglib.use_reflection_optimizer">trueprop>
                
                
                
                
                
            props>
        property>
    bean>

6.测试用例

package lhp.example.junit;

import static org.junit.Assert.*;
import java.sql.DatabaseMetaData;
import lhp.example.context.ContextHolder;
import lhp.example.context.DBType;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ServiceTest {
    private ApplicationContext context;
    //三个数据源的URL
    private String dataSource1_URL = "jdbc:mysql://127.0.0.1:3306/dec";
    private String dataSource2_URL = "jdbc:mysql://127.0.0.1:3306/lms";
    private String dataSource3_URL = "jdbc:odbc:accessTest";
    private SessionFactory mysqlSessionFactory;
    private SessionFactory aceessSessionFactory;

    @Before
    public void setUp() throws Exception {
        // 选择数据源初始化spring
        ContextHolder.setDbType(DBType.dataSource1);
        //
        String[] xmlFiles = new String[] { 
                "applicationContext-dataSource.xml",
                "applicationContext-hibernate.xml",
                "applicationContext-spring.xml" };
        //
        context = new ClassPathXmlApplicationContext(xmlFiles);
        //
        mysqlSessionFactory = (SessionFactory) context.getBean("mysqlSessionFactory");
        aceessSessionFactory = (SessionFactory) context.getBean("aceessSessionFactory");
    }

    @SuppressWarnings("deprecation")
    @Test
    public void mysqlDataSourceTest() {
        try {

            Session mysqlSession = mysqlSessionFactory.openSession();
            // 获得数据库元数据
            DatabaseMetaData meatData = mysqlSession.connection().getMetaData();

            // 默认启动数据源 dataSource1
            //断言当前数据源URL是否是dataSource1的URL
            assertEquals(dataSource1_URL, meatData.getURL());

            // 切换到数据源 dataSource2
            ContextHolder.setDbType(DBType.dataSource2);
            mysqlSession = mysqlSessionFactory.openSession();
            meatData = mysqlSession.connection().getMetaData();
            //断言当前数据源URL是否是dataSource2的URL
            assertEquals(dataSource2_URL, meatData.getURL());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    @SuppressWarnings("deprecation")
    @Test
    public void accessDataSourceTest() {
        try {
            Session accessSession = aceessSessionFactory.openSession();
            // 获得数据库元数据
            DatabaseMetaData meatData = accessSession.connection().getMetaData();
            //断言当前数据源URL是否是dataSource3的URL
            assertEquals(dataSource3_URL, meatData.getURL());


        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

GavinMiao 2011-11-14 15:37 发表评论

tomcat 调内存

GavinMiao — Wed, 26 Oct 2011 01:51:00 GMT

一、java.lang.OutOfMemoryError: PermGen space 错误解决办法：

修改TOMCAT_HOME/bin/catalina.sh

在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行：

JAVA_OPTS="-server -XX:PermSize=64M -XX:MaxPermSize=128m
二、java.lang.OutOfMemoryError: Java heap space 错误解决办法：

解决方法：手动设置Heap size

修改TOMCAT_HOME/bin/catalina.sh

在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行：

JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m"

注意：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。

GavinMiao 2011-10-26 09:51 发表评论

用命令打开windows常用软件

GavinMiao — Wed, 28 Sep 2011 01:40:00 GMT

mspaint 画图板
mstsc 远程桌面连接
notepad 打开记事本
winmsd.exe 查看系统信息
Sndvol32 音量控制程序
diskmgmt.msc 磁盘管理器
cleanmgr 垃圾整理
conf 启动netmeeting聊天工具
cleanmgr.exe 磁盘清理
calc.exe 计算器
regedt32 注册表编辑器

GavinMiao 2011-09-28 09:40 发表评论

电脑使用技巧：windows自带定时关机

GavinMiao — Wed, 28 Sep 2011 01:16:00 GMT

转载：http://bbs.yhcgo.com/read.php?tid-77128.html

1.Windows XP的定时关机命令是由Shutdown.exe程序来控制的，位于Windows\System32文件夹中。
如果想让Windows 2000也实现同样的效果，可以把Shutdown.exe复制到系统目录下。
系统根目录：C:\windows\下；
2.winows+r打开“运行”输入框，然后输入以下命令：
at 22:00 Shutdown -s --->无倒计时框，到

22:00点提示关机

shutdown.exe -s -t 3600 -->60分钟后，以

倒计时的方式关机
Shutdown －s －t 1320 -->

指定系统在22分钟后自动关闭
3.

如果想取消的话，可以在运行中输入“shutdown -a”。另外输入“shutdown -i”，则可以打开设置自动关机对话框，对自动关机进行设置。
4.

Shutdown.exe的参数:
-r：关机并重启
-t 时间：设置关机倒计时
“-s”就表示关闭本地计算机
“-a”表示取消关机操作
-i：显示图形用户界面，但必须是Shutdown的第一个选项

GavinMiao 2011-09-28 09:16 发表评论

birt初认识

GavinMiao — Wed, 21 Sep 2011 16:01:00 GMT

官网：http://www.eclipse.org/birt/phoenix/
1.

BIRT是一个基于Eclipse的开源Web应用程序
2.主要用在基于Java和J2EE的web应用程序上；
3.使用birt可以实现：列表、图标、混合报表、交叉表（二维表）；
4.安装：

本人用的时MyEclipse6.6，对应的Eclipse3.3.；

如果使用的是eclipse3.3版本，你应该用birt-report-framework-2_2_0.zip，
地址：http://archive.eclipse.org/birt/downloads/build.php?build=R-R1-2_2_0-200706261010/birt-report-framework-2_2_0.zip

http://archive.eclipse.org/birt/downloads/build.php?build=R-R1-2_2_0-200706261010/birt-runtime-2_2_0.zip

如果使用的是eclipse3.4，你应该用birt-report-framework-2_3_0.zip。
5.参考文章地址：

http://www.docin.com/p-177563530.html

http://wenku.baidu.com/view/e9414713a216147917112885.html

http://wenku.baidu.com/view/8f996c553c1ec5da50e27093.html

http://www.blogjava.net/amigoxie/archive/2009/05/03/268684.html

GavinMiao 2011-09-22 00:01 发表评论

select count(*)时，报错java.lang.ClassCastException: java.lang.Long

GavinMiao — Thu, 15 Sep 2011 07:12:00 GMT

只有注册用户登录后才能阅读该文。阅读全文

GavinMiao 2011-09-15 15:12 发表评论

各数据库数据类型比较

GavinMiao — Tue, 06 Sep 2011 05:01:00 GMT

GavinMiao 2011-09-06 13:01 发表评论

UE设置java环境

GavinMiao — Mon, 05 Sep 2011 09:29:00 GMT

只有注册用户登录后才能阅读该文。阅读全文

GavinMiao 2011-09-05 17:29 发表评论

ssh与设计模式

GavinMiao — Mon, 29 Aug 2011 02:42:00 GMT

参考文章来源：

http://www.docin.com/p-87219490.html
http://kaixuan489577823.iteye.com/blog/662864

一、struts1主要用到的设计模式：
1.Straegy策略模式
2.singletom单例模式
3.command命令模式
4.Facade外观模式
5.composite view组成模式
6.decorator装饰模式
7.MVC模式
二、spring主要用到的设计模式：
1.简单工厂即静态工厂模式Static Factory Method
2.工厂模式Factory Method
3.单例模式Singleton
4.适配器Adapter
5.装饰器Decorator
6.代理Proxy
7.观察者Observer
8.策略Strategy
9.模板方法Template Method
三、struts2主要用到的模式：
1.MVC模式
2.command命令模式
3.代理Proxy
4.适配器Adapter
5.单例模式Singleton
6. 职责链模式 Chain of Responsibility

GoF设计模式的分类：
根据目的准则分类：
1．创建型：creational 与对象的创建有关。
2．结构型：Structural 处理类或对象之间的组合。
3．行为型：behavioral 描述类或对象如何交互及如何分配职责。

创建型模式

1.抽象工厂模式 AbstractFactory
2.建造者模式 Builder
3.工厂方法模式 Factory Method
4.原型模式 Prototype
5.单例模式 Singleton

结构型模式

1.适配器模式 Adapter
2.桥接模式 Bridge
3.组合模式 Composite
4.装饰模式 Decorator
5.外观模式 Facade
6.享元模式 Flyweight
7.代理模式 Proxy

行为模式

1.职责链模式 Chain of Responsibility
2.命令模式 Command
3.解释器模式 Interpreter
4.迭代器模式 Iterator
5.中介者模式 Mediator
6.备忘录模式 Memento
7.观察者模式 Observer
8.状态模式 State
9.策略模式 Strategy
10.模板方法模式 Template Method
11.访问者模式 Visitor

GavinMiao 2011-08-29 10:42 发表评论

瞎聊

GavinMiao — Tue, 23 Aug 2011 15:26:00 GMT

事务具有四个特征：原子性（ Atomicity ）、一致性（ Consistency ）、隔离性（ Isolation ）和持久性（ Durability ）。这四个特性简称为 ACID 特性
事务是一组原子操作单元
从数据库角度说，就是一组SQL指令，
要么全部执行成功，要么撤销不执行。

使用单态模式的目标是为了控制对象的创建，单态模式经常使用在控制资源的访问上。例如数据库连接或Socket连接等。单态模式可以控制在某个时刻只有一个线程访问资源。

GavinMiao 2011-08-23 23:26 发表评论