MySQL资源设置

max_connections=500
wait_timeout=10
max_connect_errors = 100

连接最大个数是在第一行中进行管理的。与 Apache 中的 MaxClients 类似,其想法是确保只建立服务允许数目的连接。要确定服务器上目前建立过的最大连接数,请执行

SHOW STATUS LIKE ‘max_used_connections’。

第 2 行告诉 mysqld 终止所有空闲时间超过 10 秒的连接。在 LAMP 应用程序中,连接数据库的时间通常就是 Web 服务器处理请求所花费的时间。有时候,如果负载过重,

连接会挂起,并且会占用连接表空间。如果有多个交互用户或使用了到数据库的持久连接,那么将这个值设低一点并不可取!

最后一行是一个安全的方法。如果一个主机在连接到服务器时有问题,并重试很多次后放弃,那么这个主机就会被锁定,直到 FLUSH HOSTS 之后才能运行。默认情况下,

10 次失败就足以导致锁定了。将这个值修改为 100 会给服务器足够的时间来从问题中恢复。如果重试 100 次都无法建立连接,那么使用再高的值也不会有太多帮助,

可能它根本就无法连接。

开发网站使用MySQL的GPL协议问题

今天有花了很长时间看GPL协议的问题,终于有眉目了。我关心的不是分发或者卖我的软件该怎么绕开GPL协议,只是想知道我要开发一个网站,数据库用到了GPL的MySQL,那我也要遵守GPL协议,但是我该不该公布我的源代码?该不该开放整个网站的源代码?

网上的讨论很激烈,但是能解决问题的很少,很多是集中在我想用人家GPL的源代码在自己的程序里,或者用GPL的library,等等,其实,要想真的搞懂GPL,最好是乖乖地去看GPL的官方网站,这是我的最终感受。

http://www.gnu.org/licenses/gpl.html

这里有两个误区:

1. GPL与免费

很多人在网上搜索时包括我在内都在用类似的关键词查找“xxx GPL 免费” “XXX GPL free license”。其实GPL强调的是权利,具有GPL授权的软件的权利,“你可以自由使用;你可以获得源代码;你可以修改;你需要公布自己的源代码(在某种条件下)…” 听起来都很美,但是,它没有提到钱的问题,实际上它只关心你的权利和义务(right, not price),才不管你收不收费呢。假如你遵守GPL并且发布软件及源码,你硬要收费,那也行。只要有人肯付钱就行。所以很多GPL软件收费最多的其实是服务,而不是GPL软件本身。

2. 遵守GPL,就要开源 (至少是我的误区)

这里最最最关键的一点就是你有没有分发(distribute),传播(propagate),发布(convey)你的软件?如果没有,就不需要开源。有,就要开源。以我的例子:

我为公司开发网站用到GPL的MySQL,要开源我的网站系统吗?不用。因为我没有分发。作为GPL软件的使用者,我有权利运行使用它,覆盖它(cover),修改它,只要我不传播出去。

以下是我在官方网站上找到的证明:

引用
http://www.gnu.org/licenses/gpl-faq.html

A company is running a modified version of a GPL’ed program on a web site. Does the GPL say they must release their modified sources 

The GPL permits anyone to make a modified version and use it without ever distributing it to others. What this company is doing is a special case of that. Therefore, the company does not have to release the modified sources.

It is essential for people to have the freedom to make modifications and use them privately, without ever publishing those modifications. However, putting the program on a server machine for the public to talk to is hardly “private” use, so it would be legitimate to require release of the source code in that special case. Developers who wish to address this might want to use the GNU Affero GPL for programs designed for network server use.

Is making and using multiple copies within one organization or company “distribution” 

No, in that case the organization is just making the copies for itself. As a consequence, a company or other organization can develop a modified version and install that version through its own facilities, without giving the staff permission to release that modified version to outsiders.

However, when the organization transfers copies to other organizations or individuals,  that is distribution. In particular, providing copies to contractors for use off-site is distribution.

If I only make copies of a GPL-covered program and run them, without distributing or conveying them to others, what does the license require of me 

Nothing. The GPL does not place any conditions on this activity.

thiswebapplicationinstancehasbeenstoppedalready

信息: Illegal access: this web application instance has been stopped already.  Could not load com.mysql.jdbc.Util.  The eventual following stack trace is caused by an error thrown for debugging purposes as well as to attempt to terminate the thread which caused the illegal access, and has no functional impact.
java.lang.IllegalStateException
    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1246)
    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1206)
    at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
    at com.mysql.jdbc.CommunicationsException.<init>(CommunicationsException.java:180)
    at com.mysql.jdbc.MysqlIO.send(MysqlIO.java:2710)
    at com.mysql.jdbc.MysqlIO.send(MysqlIO.java:2621)
    at com.mysql.jdbc.MysqlIO.quit(MysqlIO.java:1338)
    at com.mysql.jdbc.Connection.realClose(Connection.java:4429)
    at com.mysql.jdbc.Connection.cleanup(Connection.java:1973)
    at com.mysql.jdbc.Connection.finalize(Connection.java:3114)
    at java.lang.ref.Finalizer.invokeFinalizeMethod(Native Method)
    at java.lang.ref.Finalizer.runFinalizer(Finalizer.java:83)
    at java.lang.ref.Finalizer.access$100(Finalizer.java:14)
    at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:160)

排错:删除掉asm-2-2-3.jar包

【转】MySQL存储引擎及各引擎特性比较

MySQL
5.1中,MySQL AB引入了新的插件式存储引擎体系结构,允许将存储引擎加载到正在运新的MySQL服务器中。

MySQL插件式存储引擎的体系结构


下载



(93.24 KB)
MySQL存储引擎
结构

昨天 17:41

与MySQL一起提供的各种存储引擎在设计时考虑了不同的使用情况。为了更有效地使用插件式存储体系结构,最好了解各种存储引擎的优点和缺点。

在下面的表格中,概要介绍了与MySQL一起提供的存储引擎:

存储引擎比较



下载



(97.53 KB)
存储引擎比较

昨天 17:41

下述存储引擎是最常用的:

·         MyISAM:默认的MySQL插件式存储引擎,它是在Web、数据仓储和其他应用环境下最常使用的存储引擎之一。注意,通过更改STORAGE_ENGINE配置变量,能够方便地更改MySQL服务器的默认存储引擎。

·         InnoDB:用于事务处理应用程序,具有众多特性
,包括ACID事务支持。

·         BDB:可替代InnoDB的事务引擎,支持COMMIT、ROLLBACK和其他事务特性。

·         Memory:将所有数据保存在RAM中,在需要快速查找引用和其他类似数据的环境下,可提供极快的访问。

·         Merge:允许MySQL DBA或开发人员将一系列等同的MyISAM表以逻辑方式组合在一起,并作为1个对象引用它们。对于诸如数据仓储等VLDB环境十分适合。

·         Archive:为大量很少引用的历史、归档、或安全审计信息的存储和检索提供了完美的解决方案。

·         Federated:能够将多个分离的MySQL服务器链接起来,从多个物理服务器创建一个逻辑数据库。十分适合于分布式环境或数据集市环境。

·         Cluster/NDB:MySQL的簇式数据库引擎,尤其适合于具有高性能查找要求的应用程序,这类查找需求还要求具有最高的正常工作时间和可用性。

·         Other:其他存储引擎包括CSV(引用由逗号隔开的用作数据库表的文件),Blackhole(用于临时禁止对数据库的应用程序输入),以及Example引擎(可为快速创建定制的插件式存储引擎提供帮助)。

请记住,对于整个服务器或方案,你并不一定要使用相同的存储引擎,你可以为方案中的每个表使用不同的存储引擎,这点很重要。

使用SpringSide3.1.4.3开发Web项目的全过程(上)

http://www.blogjava.net/youxia/archive/2009/07/19/287366.html

 

SpringSide 3.1.4.3是目前SpringSide的最新版本,也是完成度比较高的一个版本,用来做实际项目的开发应该丝毫不成问题。这里写一下使用该版本开发一个简单Web项目的全过程,当然,最重要的是我自己的一些心得体会。我的文章很长,只有耐下性子细看,才能体会个中三味。

第一步、下载SpringSide 3.1.4.3 all-in-one版。这个过程太简单了,SpringSide的官方网站是www.springside.org.cn,去那里就可以下载了,all-in-one版当然是懒人们的不二选择。这里有一点很搞笑,该版本标的是SpringSide 3.1.4.3,但是下载后解压缩,解压缩出来的文件是springside-3.1.4.2,这可能是江南白衣的一点小小的失误,据我猜测,3.1.4.3较3.1.4.1的进步应该是加入了jsp-api.jar这一个库,希望白衣这次不要为了更改这个版本号上的失误而再推出一个新版本,如果真要推出新版本,怎么样也应该把我最近研究出来的多数据库的配置加进去。

第二步、安装SpringSide。如果安装过SpringSide以前的版本,最好把用户目录下的.m2文件夹删掉,这个文件夹是Maven的本地仓库所在地,虽说Maven可以有效保证库文件不会发生版本冲突,但是删除这个文件夹会使安装过程加快,否则,SpringSide的安装过程会不停询问你是否覆盖某某文件。删除.m2文件夹后,运行springside-3.1.4.2目录下的bin目录中的quickstart.bat即可(前提条件是已经安装好了JDK5或以上版本,如果你的电脑中连JDK都没有,就别来趟SpringSide的浑水了)。 等待这个文件运行完,就可以看到SpringSide 3提供的三个示例项目mini-web、mini-service、showcase都运行起来了,这时你可以细细体会一下SpringSide实现的各种特性。

仔细察看SpringSide的bin目录,发现该版本提供的脚本更加明确和有用,如start-db.bat可以用来启动Derby数据库,start-selenium.bat用来启动selenium server,而start-tomcat.bat那就别说了,地球人都知道。

如果要想使用SpringSide来生成项目,还有一点点小工作要做,就是把Maven的bin目录加入到PATH环境变量中,如下图:

第三步,使用SpringSide生成项目。运行bin目录下的new-project.bat即可,如下图:

在创建项目的过程中,该脚本会提出一些问题,其中groupId指的是你的组织的名称,由于该项目由我私人贡献,纯属示范用,所以我填了youxia.personal,因此,在第5个问题上,我选择了personal.you作为我项目中的package的名字,这也是符合国际惯例的;artifactId指的是项目的名字,这里为MultiDatasourceExample,名字有点长,从名字就可以看出来我要示范多个数据源的配置。

第四步、启动Eclipse,导入项目。 生成的项目位于SpringSide目录下的tools\generator\generated-project目录下,下面是Eclipse的截图:

项目导入成功后,Eclispe资源管理器的截图:

 可以看到,该项目一经导入,立即可用,一个烦人的红叉都没有,这也正说明了该版本是SpringSide 3的一个革命性版本,从该版本开始,SpringSide 3的易用性提高了不止一个档次。

Eclipse推荐使用3.4及以上版本,因为在该版本中,对Tomcat服务器的管理更加方便,只需要在项目的快捷菜单中选择Run On Server,即可自动打开Tomcat服务器并部署项目,如下图:

这里有一点一定要注意,由于SpringSide生成的项目默认使用的是Derby数据库,所以要想成功运行项目,必须先启动Derby数据库,还记得前面提到的start-db.bat吗?运行它!然后运行该项目的bin目录下的init-db.jar,在数据库中放入该项目的初始化数据。

然后就可以点Run On Server来启动项目了,让大家见识一下Eclipse的嵌入式浏览器、Tomcat服务器视图、Console视图。真的是太方便了:

第五步、将数据库迁移到MySQL中。在项目中,创建数据库和初始化数据库的语句都是以SQL文件存在的,如下图:

但是该语句都是针对Derby的,如果要应用于MySQL,还必须得要做一些修改才行,先修改schema.sql,如下:

drop table if exists RESOURCES_AUTHORITIES;
drop table if exists ROLES_AUTHORITIES;
drop table if exists USERS_ROLES;
drop table if exists RESOURCES;
drop table if exists AUTHORITIES;
drop table if exists USERS;
drop table if exists ROLES;

create table USERS (
ID 
integer primary key auto_increment,
LOGIN_NAME 
varchar(20not null unique,
PASSWORD 
varchar(20),
NAME 
varchar(20),
EMAIL 
varchar(30)
);

create unique index USERS_LOGIN_NAME_INDEX on USERS(LOGIN_NAME);

create table ROLES (
ID 
integer primary key auto_increment,
NAME 
varchar(20not null unique
);

create table USERS_ROLES (
USER_ID integer not null,
ROLE_ID 
integer not null,
FOREIGN KEY (ROLE_ID) references ROLES(ID),
FOREIGN KEY (USER_IDreferences USERS(ID)
);

CREATE TABLE AUTHORITIES (
ID 
integer primary key auto_increment,
NAME 
varchar(20not null,
DISPLAY_NAME 
varchar(20not null
);

create table ROLES_AUTHORITIES (
ROLE_ID 
integer not null,
AUTHORITY_ID 
integer not null,
FOREIGN KEY (ROLE_ID) references ROLES(ID),
FOREIGN KEY (AUTHORITY_ID) references AUTHORITIES(ID)
);

CREATE TABLE RESOURCES (
ID 
integer primary key auto_increment,
RESOURCE_TYPE 
varchar(20not null,
VALUE 
varchar(255not null,
ORDER_NUM 
float not null
);

create table RESOURCES_AUTHORITIES (
AUTHORITY_ID 
integer not null,
RESOURCE_ID 
integer not null,
FOREIGN KEY (AUTHORITY_ID) references AUTHORITIES(ID),
FOREIGN KEY (RESOURCE_ID) references RESOURCES(ID)
);

该修改主要包含两个地方,一个是在drop table后面加上了if exists,一个是把GENERATED ALWAYS as IDENTITY修改为auto_increment。而load-data.sql不需要修改。

然后,启动MySQL,在MySQL中使用上面的两个sql文件创建数据库和添加初始化数据,如下图:

然后更改数据库连接,修改项目的application.properties文件,如下:

#jdbc settings
jdbc.url
=jdbc:mysql://localhost:3306/MultiDatasourceExample useUnicode=true&characterEncoding=utf8
jdbc.username
=youxia
jdbc.password
=******

#hibernate settings
hibernate.show_sql
=false
hibernate.format_sql
=false
hibernate.ehcache_config_file
=/ehcache/ehcache-hibernate-local.xml

修改项目的applicationContext.xml文件,这里要修改两个地方,一个为DriverClassName,一个为hibernate.dilect,如下:

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:jee
=”http://www.springframework.org/schema/jee” xmlns:tx=”http://www.springframework.org/schema/tx”
    xmlns:context
=”http://www.springframework.org/schema/context”
    xsi:schemaLocation
=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd”
    default-lazy-init
=”true”>

    
<description>Spring公共配置文件 </description>

    
<!– 定义受环境影响易变的变量 –>
    
<bean class=”org.springframework.beans.factory.config.PropertyPlaceholderConfigurer”>
        
<property name=”systemPropertiesModeName” value=”SYSTEM_PROPERTIES_MODE_OVERRIDE” />
        
<property name=”ignoreResourceNotFound” value=”true” />
        
<property name=”locations”>
            
<list>
                
<!– 标准配置 –>
                
<value>classpath*:/application.properties</value>
                
<!– 本地开发环境配置 –>
                
<value>classpath*:/application.local.properties</value>
                
<!– 服务器生产环境配置 –>
                
<!– <value>file:/var/myapp/application.server.properties</value> –>
            
</list>
        
</property>
    
</bean>

    
<!– 使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入 –>
    
<context:component-scan base-package=”personal.youxia” />

    
<!– 数据源配置,使用应用内的DBCP数据库连接池 –>
    
<bean id=”dataSource” class=”org.apache.commons.dbcp.BasicDataSource” destroy-method=”close”>
        
<!– Connection Info –>
        
<property name=”driverClassName” value=”com.mysql.jdbc.Driver” />
        
<property name=”url” value=”${jdbc.url}” />
        
<property name=”username” value=”${jdbc.username}” />
        
<property name=”password” value=”${jdbc.password}” />

        
<!– Connection Pooling Info –>
        
<property name=”initialSize” value=”5″ />
        
<property name=”maxActive” value=”100″ />
        
<property name=”maxIdle” value=”30″ />
        
<property name=”maxWait” value=”1000″ />
        
<property name=”poolPreparedStatements” value=”true” />
        
<property name=”defaultAutoCommit” value=”false” />
    
</bean>

    
<!– 数据源配置,使用应用服务器的数据库连接池 –>
    
<!–<jee:jndi-lookup id=”dataSource” jndi-name=”java:comp/env/jdbc/ExampleDB” />–>

    
<!– Hibernate配置 –>
    
<bean id=”sessionFactory” class=”org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean”>
        
<property name=”dataSource” ref=”dataSource” />
        
<property name=”namingStrategy”>
            
<bean class=”org.hibernate.cfg.ImprovedNamingStrategy” />
        
</property>
        
<property name=”hibernateProperties”>
            
<props>
                
<prop key=”hibernate.dialect”>org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                
<prop key=”hibernate.show_sql”>${hibernate.show_sql}</prop>
                
<prop key=”hibernate.format_sql”>${hibernate.format_sql}</prop>
                
<prop key=”hibernate.cache.provider_class”>org.hibernate.cache.EhCacheProvider
                
</prop>
                
<prop key=”hibernate.cache.provider_configuration_file_resource_path”>${hibernate.ehcache_config_file}</prop>
            
</props>
        
</property>
        
<property name=”packagesToScan” value=”personal.youxia.entity.*” />
    
</bean>

    
<!– 事务管理器配置,单数据源事务 –>
    
<bean id=”transactionManager” class=”org.springframework.orm.hibernate3.HibernateTransactionManager”>
        
<property name=”sessionFactory” ref=”sessionFactory” />
    
</bean>

    
<!– 事务管理器配置,多数据源JTA事务–>
    
<!–
        <bean id=”transactionManager” class=”org.springframework.transaction.jta.JtaTransactionManager or
        WebLogicJtaTransactionManager” />
    
–>

    
<!– 使用annotation定义事务 –>
    
<tx:annotation-driven transaction-manager=”transactionManager” />
</beans>

由于SpringSide不提供Mysql的jdbc驱动,所以需要自己去MySQL的官方网站下载,将下载到的mysql-connector-5.*.jar复制到项目的WEB-INF中的lib目录中。然后运行项目,成功。至此,成功将项目迁移到MySQL中。

第六步、添加数据表、编写Entity类、编写Dao类、Manager类,并进行单元测试。还是以前几篇文章中提到的文章发布系统为例,每一篇文章对应多篇评论,所以说据库中需创建articles和comments两个数据表,如下:

create   table  articles(
id  
int   primary   key  auto_increment,
subject  
varchar ( 20 )  not   null ,
content  
text );

create   table  comments(
id  
int   primary   key  auto_increment,
content  
varchar ( 255 ),
article_id  
int   not   null ,
foreign   key  (article_id)  references  articles(id)
);

在编写Java代码之前,我还要做一点小工作,什么工作呢?那就是要为我自己的项目创建一个单独的源文件夹,因为src\main\java这个文件夹已经被江南白衣放入了太多的package,而且因为涉及到security,所以层次也不明显,操作起来不方便,找起代码来也不够快。下面是我创建了自己的源文件夹后的截图:

在我自己的源文件夹中,只创建了四个package,刚好代表从底到上的四个层次,这样,找起代码来要方便得多。

先来Entity层,Article.java的代码如下:

package personal.youxia.entity;

import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.Table;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode;

@Entity
// 表名与类名不相同时重新定义表名.
@Table(name = articles)
// 默认的缓存策略.
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Article extends IdEntity {
    
private String subject;
    
private String content;
    
private Set<Comment> comments = new LinkedHashSet<Comment>();

    
public String getSubject() {
        
return subject;
    }


    
public void setSubject(String subject) {
        
this.subject = subject;
    }


    
public String getContent() {
        
return content;
    }


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

webwinform导入excel支持20032007

      private void btnImportExcel_Click(object sender, EventArgs e)

        {
          
            SqlConnection conn = new SqlConnection();

            try
            {
                OpenFileDialog openFile = new OpenFileDialog();//打开文件对话框。

                if (openFile.ShowDialog() == DialogResult.OK)
                {

                    string connStr = null;
                    string filename = openFile.FileName;
                    int index = filename.LastIndexOf(“\\”);//截取文件的名字
                    filename = filename.Substring(index + 1);
                    int suffix_index = filename.LastIndexOf(“.”);
                    string suffixName = filename.Substring(suffix_index + 1);
                    //hdr=no(第一行是不是标题,作为数据来使用,这样excel可以读取汉字或者格式混乱的内容)
                    if (suffixName == “xls”)
                    {
                        connStr = “Provider=Microsoft.Jet.OLEDB.4.0;”
                            //+ “Extended Properties=Excel 8.0;”
                            + “Extended Properties=\”Excel 8.0;HDR=NO;IMEX=1;\”;”
                            + “Data Source=” + filename;
                    }
                    else if (suffixName == “xlsx”)
                    {
                        connStr = “Provider=Microsoft.ACE.OLEDB.12.0;”
                           + “Extended Properties=\”Excel 12.0;HDR=NO;IMEX=1;\”;”
                           + “Data Source=” + filename;
                    }
                    else
                    {
                        MessageBox.Show(“格式错误”);
                        return;
                    }

                    OleDbConnection objConn = null;
                    objConn = new OleDbConnection(connStr);
                    objConn.Open();

                    // Get the first sheet name.
                    DataTable dt = objConn.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);

                    string sheetName = “”;
                    if (dt != null && dt.Rows.Count > 0)
                    {
                        sheetName = dt.Rows[0][“TABLE_NAME”].ToString();
                    }
                    else
                    {
                        MessageBox.Show(“数据为空”);
                        return;
                    }

                    // Get the data from the first sheet.
                    string sql = string.Format(“SELECT * FROM [{0}]”, sheetName);

                    DataSet ds = new DataSet();
                    OleDbDataAdapter da = new OleDbDataAdapter(sql, objConn);
                    da.Fill(ds);
                    DataTable dataTable = ds.Tables[0];
                    int coluNum = dataTable.Columns.Count;
                    int rowNum = dataTable.Rows.Count;
                    bool firstrow_flag = true;

                    string mysql = null;

                    foreach (DataRow row in dataTable.Rows)
                    {

                        bool insertbuilding_flag = true;
                        if (firstrow_flag)
                        {
                            firstrow_flag = false;
                            continue;
                        }

                        Guid gid = Guid.NewGuid();

                        string buildingname = row[6].ToString() + “栋” + row[7].ToString() + “单元”;

                        for (int i = 9; i < coluNum; i++)
                        {
                            conn = DBConnection.DBOpen();
                            SqlTransaction tran = conn.BeginTransaction();

                            try
                            {
                                if (insertbuilding_flag)
                                {
                                    insertbuilding_flag = false;
                                    if (!string.IsNullOrEmpty(buildingname))
                                    {
                                        string sql_insertBuilding = “insert into dbo.building(buildingID,building_name) values(‘” + gid + “‘,'” + buildingname + “‘);”;
                                        mysql += sql_insertBuilding;
                                    }
                                    if (!string.IsNullOrEmpty(row[i].ToString()))
                                    {
                                        string sql_insertRoom = “insert into dbo.Room(roomID,buildingID,room_name) values(‘” + Guid.NewGuid() + “‘,'” + gid + “‘,'” + row[i].ToString() + “‘);”;
                                        mysql += sql_insertRoom;
                                    }

                                }
                                else
                                {
                                    if (!string.IsNullOrEmpty(row[i].ToString()))
                                    {
                                        string sql_insertRoom = “insert into dbo.Room(roomID,buildingID,room_name) values(‘” + Guid.NewGuid() + “‘,'” + gid + “‘,'” + row[i].ToString() + “‘);”;
                                        mysql = sql_insertRoom;
                                    }

 

                                }

                                if (!string.IsNullOrEmpty(mysql))
                                {

                                    SqlCommand cmd = new SqlCommand(mysql, conn);
                                    cmd.Transaction = tran;
                                    cmd.ExecuteNonQuery();
                                    tran.Commit();
                                    mysql = null;
                                }

                            }
                            catch
                            {
                                tran.Rollback();

                            }
                            finally
                            {
                                conn.Close();
                            }
                        }

                    }

 

                    MessageBox.Show(“操作成功”);
                    openFileDialog1.Dispose();

                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());

            }
            finally
            {
                if (conn.State == ConnectionState.Open)
                {
                    conn.Close();
                }
            }

        }

mysql创建用户方法(转)

mysql 创建用户方法

sOso 发表于 2006-10-13 12:40:49

命令方式的.注意每行后边都跟个 ; 表示一个命令语句结束.<BR>格式:grant select on 数据库.* to 用户名@登录主机 identified by “密码”

<P><BR>例1、增加一个用户test1密码为abc,让他可以在任何主机上登录,并对所有数据库有查询、插入、修改、删除的权限。首先用以root用户连入MYSQL,然后键入以下命令:<BR>grant select,insert,update,delete on *.* to test1@”%” Identified by “abc”;</P>

<P><BR>但例1增加的用户是十分危险的,你想如某个人知道test1的密码,那么他就可以在internet上的任何一台电脑上登录你的mysql数据库并对你的数据可以为所欲为了,解决办法见例2。</P>

<P><BR>例2、增加一个用户test2密码为abc,让他只可以在localhost上登录,并可以对数据库mydb进行查询、插入、修改、删除的操作(localhost指本地主机,即MYSQL数据库所在的那台主机),这样用户即使用知道test2的密码,他也无法从internet上直接访问数据库,只能通过MYSQL主机上的web页来访问了。</P>

<P><BR>grant select,insert,update,delete on mydb.* to test2@localhost identified by “abc”;<BR>如果你不想test2有密码,可以再打一个命令将密码消掉。<BR>grant select,insert,update,delete on mydb.* to test2@localhost identified by “”;</P>

连接池proxool配置

首先, 你要把下载 proxool 的 lib 下面所有的 jar 文件, 放到 WEB-INF/lib 下面,

另外, 把你的 jdbc driver 也放到相同的 lib, 这里使用的是 proxool-0.9.1.jar

接着就是配置 /WEB-INF/web.xml 

web.xml 配置如下

  <!– proxool –>

  <servlet>

     <servlet-name>proxoolInitialServlet</servlet-name>

<servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class>

     <init-param>

       <param-name>xmlFile</param-name>

       <param-value>WEB-INF/proxool.xml</param-value>

  </init-param>

     <load-on-startup>1</load-on-startup>

   </servlet>

    

   <servlet>

    <servlet-name>dbpoolAdmin</servlet-name>

    <servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>

   </servlet>

    

  <servlet-mapping>

    <servlet-name>dbpoolAdmin</servlet-name>

    <url-pattern>/dbpool</url-pattern>

  </servlet-mapping> 

然后在 WEB-INF 下面新建 proxool.xml

proxool.xml 配置如下

< xml version=”1.0″ encoding=”UTF-8″ >

<xml-body>

<something-else-entirely>    

    <proxool>    

        <!–连接池的别名–>    

        <alias>dbpool</alias>    

        <!–proxool只能管理由自己产生的连接–>    

        <driver-url>jdbc:mysql://localhost:3306/smeonline</driver-url>    

        <!–JDBC驱动程序–>    

        <driver-class>com.mysql.jdbc.Driver</driver-class>    

        <driver-properties>    

            <property name=”user” value=”root”/>    

            <property name=”password” value=”root”/>

            <property name=”useUnicode” value=”true”/>                                  

            <property name=”characterEncoding” value=”utf-8″/>

        </driver-properties>    

        <!– proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁–>    

        <house-keeping-sleep-time>90000</house-keeping-sleep-time>    

        <!– 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受–>      

        <maximum-new-connections>150</maximum-new-connections>    

        <!– 最少保持的空闲连接数–>      

        <prototype-count>3</prototype-count>    

        <!– 允许最大连接数,超过了这个连接,再有请求时,就排在队列中等候,最大的等待请求数由maximum-new-connections决定–>      

        <maximum-connection-count>100</maximum-connection-count>    

        <!– 最小连接数–>    

        <minimum-connection-count>3</minimum-connection-count>    

    </proxool>    

</something-else-entirely>

</xml-body>

proxool.xml 具体配置可网上可查这里就不多说了,

部署到服务器后用 http://localhost:8080/oa/dbpoll 就可在线监控连接池状态了

记住一定要在 web 环境里面测试连接

Hibernate 里面配置 proxool.xml

<session-factory>

<!– proxool 连接池加载类 –>

<property name=”hibernate.connection.provider_class”>org.hibernate.connection.ProxoolConnectionProvider</property>

<!–连接池的别名,即配置连接池时起的别名–>

<property name=”hibernate.proxool.pool_alias”>dbpool</property>

<!–连接池文件的地址–>

<property name=”hibernate.proxool.xml”>zn/oa/pojo/proxool.xml</property>

<property name=”hibernate.proxool.existing_pool”>false</property><!– 此值设为 false,当 hibernate 开始被调用时,就会初始化 proxool –>

<mapping resource=”zn/oa/pojo/ODepartment.hbm.xml” />

<mapping resource=”zn/oa/pojo/OProvience.hbm.xml” />

<mapping resource=”zn/oa/pojo/OCity.hbm.xml” />

<mapping resource=”zn/oa/pojo/OEmployee.hbm.xml” />

<mapping resource=”zn/oa/pojo/OCalendar.hbm.xml” />

</session-factory>

Web2.0动态网站开发-PHP技术与应用(PDF电子书)

Web2.0动态网站开发PHP技术应用(PDF电子书)
电子书相关:
本书以Web 2.0网站开发的5种需求和28个重要元素为线索,从PHP开发Web 2.0网站的三个理由出发,全面讲解PHP的Web开发技术,并按行业流行的开发模式创建10大Web 2.0应用系统,帮助读者真正实现从新手高手的跨越。
  全书分3部分共21章,第1部分(第1~3章)介绍Web 2.0的概念、应用、重要元素及开发技术;第2部分(第4~11章)结合92个范例讲解PHP的Web开发技术,内容包括PHP开发入门、PHP基本语法、PHP流程控制、PHP函数和类、MySQL、PHP+MySQL数据库开发、PHP动态网站构建全过程、PHP开发中的常用技巧等;第3部分(第12~21章)为实例篇,介绍博客网站系统、基于~ax的留言板、新闻发布系统、为网站添加RSS功能、Wiki网站系统、网络论坛系统、网络邮件系统、网络校友录系统、网络聊天室、网站访问统计等10个系统的设计与实现。
电子书目录
第1部分 Web 2.0大航海时代
——第1章 Web 2.0概念与图谱
——第2章 Web 2.0元素详解
——第3章 Web 2.0开发技术PHP
第2部分 PHP技术之旅
——第4章 PHP开发入门
——第5章 PHP基本语法
——第6章 PHP流程控制
——第7章 PHP函数和类
——第8章 PHP最佳搭档MySQL
——第9章 PHP+MySQL数据库系统开发
——第10章 PHP动态网站构建全程实录
——第11章 PHP开发中的常用技巧
第3部分 Web 2.0大航海之旅
——第12章 博客网站系统
——第13章 基于Ajax的留言板
——第14章 新闻发布系统
——第15章 RSS生成与阅读器制作
——第16章 Wiki网站系统
——第17章 网络论坛系统
——第18章 网络邮件系统
——第19章 网络校友录系统
——第20章 网络聊天室
——第21章 网站访问统计
附录A Ajax框架汇总
附录B 中国互联网Web 2.0百强企业
PS:本贴提供随书光盘下载,包含10大web2.0应用系统的源代码,可以直接部署。

电子书下载:
==============================
[url=Web.2.0动态网站开发——PHP技术与应用.pdf (243.34 MB)]Web2.0动态网站开发-PHP技术与应用(PDF电子书)[/url]
[url=Web.2.0动态网站开发——PHP技术与应用-随书光盘.iso (6.08 MB)]Web2.0动态网站开发-PHP技术与应用(随书光盘)
[/url]
(右键迅雷或电驴下载)

==============================
原帖地址http://www.phpjava.org/thread-409-1-1.html
本文来自: PJDN–php&Java论坛|技术交流社区,打造中国php&java开发者社区[www.phpjava.org]

MySQL引擎简介

MySQL引擎简介

  MySQL是我们比较常用的一种数据库软件。它有着诸多的优点,如开源的,免费的等等。其实它还有一个很好的特点,那就是有多种引擎可以供你选择。如果赛车手能根据不同的路况,地形随手更换与之最适宜的引擎,那么他们将创造奇迹。然而目前他们还做不到那样便捷的更换引擎,但是我们却可以!

     所谓知己知彼方可百战不殆,要想将它们发挥到极致,首先我们应该来认识一下MySQL提供给我们的这几种引擎。

     一般来说,MySQL有以下几种引擎:ISAM、MyISAM、HEAP、InnoDB和Berkley(BDB)。注意:不同的版本支持的引擎是有差异的。当然啦,如果你感觉自己的确技术高超,你还能够使用MySQL++来创建自己的数据库引擎,这个已经out of my knowledge,牛人可以参照MySQL++ API帮助来实现。下面逐一叙述这5种引擎各自的特性:

ISAM

ISAM是一个定义明确且历经时间考验的数据表格管理方法,它在设计之时就考虑到数据库被查询的次数要远大于更新的次数。因此,ISAM执行读取操作的速度很快,而且不占用大量的内存和存储资源。ISAM的两个主要不足之处在于,它不支持事务处理,也不能够容错:如果你的硬盘崩溃了,那么数据文件就无法恢复了。如果你正在把ISAM用在关键任务应用程序里,那就必须经常备份你所有的实时数据,通过其复制特性,MySQL能够支持这样的备份应用程序。

MyISAM

MyISAM是MySQL的ISAM扩展格式和缺省的数据库引擎。除了提供ISAM里所没有的索引和字段管理的大量功能,MyISAM还使用一种表格锁定的机制,来优化多个并发的读写操作。其代价是你需要经常运行OPTIMIZE TABLE命令,来恢复被更新机制所浪费的空间。MyISAM还有一些有用的扩展,例如用来修复数据库文件的MyISAMChk工具和用来恢复浪费空间的 MyISAMPack工具。

MyISAM强调了快速读取操作,这可能就是为什么MySQL受到了Web开发如此青睐的主要原因:在Web开发中你所进行的大量数据操作都是读取操作。所以,大多数虚拟主机提供商和Internet平台提供商(Internet Presence Provider,IPP)只允许使用MyISAM格式。

HEAP

HEAP允许只驻留在内存里的临时表格。驻留在内存里让HEAP要比ISAM和MyISAM 都快,但是它所管理的数据是不稳定的,而且如果在关机之前没有进行保存,那么所有的数据都会丢失。在数据行被删除的时候,HEAP也不会浪费大量的空间。 HEAP表格在你需要使用SELECT表达式来选择和操控数据的时候非常有用。要记住,在用完表格之后就删除表格。让我再重复一遍:在你用完表格之后,不要忘记删除表格。

InnoDB和Berkley DB

InnoDB和Berkley DB(BDB)数据库引擎都是造就MySQL灵活性的技术的直接产品,这项技术就是MySQL++ API。在使用MySQL的时候,你所面对的每一个挑战几乎都源于ISAM和MyISAM数据库引擎不支持事务处理也不支持外来键。尽管要比ISAM和 MyISAM引擎慢很多,但是InnoDB和BDB包括了对事务处理和外来键的支持,这两点都是前两个引擎所没有的。如前所述,如果你的设计需要这些特性中的一者或者两者,那你就要被迫使用后两个引擎中的一个了。

认识完了这么多的引擎,我们也知道了它们应该在什么情况下拿来应急,那么接着我们就要学会如何来更换这些引擎了。

Globle:一种最简单的方法就是更改服务器配置,直接将其设置成你所需要的引擎。这个在 win下通过更改服务器安装目录下的mysql.ini中的default-storage-engine项即可,也可以通过运行MySQL Server Instance Configuration Wizard做简单的设置。

Per Table:除了全局的方法外,还有一种更灵活的配置方法,那就是按表来设置引擎,这样我们就可以把那些需要用到事务处理的表设置成InnoDB,其他设置成MyISAM,将性能提升到极致,这是不是很令人兴奋呢?设置方法也比较简单:

1、你可以在Create Table语句的最后添加扩展语句,如TYPE=MyISAM(或者ENGINE = INNODB)来指定当前标的引擎类型。也可以用Alter语句在建立表个后进行更改。当你不清楚当前数据库中各表的引擎时可以使用SHOW TABLE STATUS FROM DBname来查看。

2、使用随MySQL服务器发布同时提供的MySQL客户端来创建表,在创建时可以选择使用的存储引擎。

不同的引擎选择在不同的业务处理上,性能将有天壤之别!!

题外话:

要想服务器性能达到最佳,在配置服务器时也需要好好考虑。如果是在Win下那么可以通过运行MySQL Server Instance Configuration Wizard来设置,它将引导你设置当前服务器的类型等等信息。

还有再有大量数据需要插入的时候可以考虑使用INSERT DELAYED语句(具体语法参考MySQL手册)。当一个客户端使用INSERT DELAYED时,会立刻从服务器处得到一个确定。并且行被排入队列,当表没有被其它线程使用时,此行被插入。使用INSERT DELAYED的另一个重要的好处是,来自许多客户端的插入被集中在一起,并被编写入一个块。这比执行许多独立的插入要快很多。当然它也有其适用范围,具体参考手册,我就不再赘述了。