BlogJava-藏经阁-文章分类-DataBase

在webapp中使用嵌入式数据库hsqldb

ZhouFeng — Mon, 24 Apr 2017 14:23:00 GMT

HSQLDB启动方便，不用安装，在之前的文档里已介绍过如何以服务器模式启动，并且通过JDBC连接，接下来介绍如何在webapp中嵌入hsqldb，让其可以随应用一起启动，比如和Tomcat服务器一起启动，不用单独启动数据库。这里有两种模式可以选择

一种是进程模式启动，按文件方式加载数据库，只有与Tomcat服务器在同一JVM中才能访问

另一种是用JAVA程序来启动服务器，以网络方式提供数据库服务，可以在Tomcat之外用hsqldb客户端来连接，方便调试

这两种数据文件都建议放在工程里，如下案例中是将数据库放在WEB-INF/db/目录下

1.加载hsqldb.jar

将hsqldb.jar文件加入到现有webapp工程中，拷贝hsqldb.jar至WEB-INF/lib/hsqldb.jar

2.创建WEB-INF/db/目录

在开发阶段，需要把数据文件放在工程中，而不是tomcat里，这样处理对打包，版本控制管理也方便

为了方便启动数据库，可以写一个批处理，如WEB-INF/startdb.bat，大家可根据自己的路径修改，内容如下

cd db
@java -classpath ../lib/hsqldb.jar org.hsqldb.server.Server --database.0 file:mycms --dbname.0 mycmsdb

文件名和数据库名可以不同，此处文件名为mycms，而数据库名为mycmsdb

3.使用Servlet启动数据库

可以创建一个自启动Servlet，用于启动数据库，这种方式可以使用客户端工具连接到应用数据库上，主要用于在线调试，或远程管理

package com.zhouf.mydb;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;

import org.hsqldb.server.Server;

@WebServlet(loadOnStartup=1)
public class HsqldbServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    private Server server = new Server();

    public HsqldbServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        String path=this.getServletContext().getRealPath("/WEB-INF/db/mycms");
        System.out.println("dbpath["+path+"]");

        server.setDatabaseName(0, "mycmsdb");
        server.setDatabasePath(0, path);
        server.setPort(9001);
        server.setSilent(true);
        Thread thread=new Thread(new Runnable(){
            public void run() {
                server.start();
            }
        });
        thread.start();
    }

    public void destroy() {
        super.destroy();
        server.shutdown();
    }

}

注意服务端口不要冲突

4.完成一个数据库连接类，用于处理数据库连接管理

public class DBManage {

    public static Connection getConnection() {
        Connection conn = null;
        try {

            //根据连接配置获取数据库连接
            Class.forName("org.hsqldb.jdbcDriver").newInstance();

            //*
            //连接Hsqldb Server
            conn= DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/mycmsdb;shutdown=true","SA","");
            /*/

            //直接获得In-process连接
            String path = DBManage.class.getResource("").toString();
            String dbpath = path.substring(0,path.indexOf("classes")) + "db/mycms";

            conn = DriverManager.getConnection("jdbc:hsqldb:"+dbpath,"SA","");
            //*/
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return conn;
    }
}

上面的连接管理两种方式都支持，可选用，这样应用可以发布到tomcat里独立运行，也可以打包成war发布，这样一个带war文件就可以演示，相当愉快:D

ZhouFeng 2017-04-24 22:23 发表评论

HSQLDB数据库使用介绍

ZhouFeng — Sun, 23 Apr 2017 08:41:00 GMT

用过HSQLDB一段时间，其作为一个小型数据库，很是小巧，jar包也就1M多，麻省虽小，五脏俱全。对于一此网站系统或是小型的应用系统，应该足够满足要求了，主要是绿色环保，不需要进行安装，这点我很喜欢，特别是直接打包到web应用里，可以直接使用，用不着更换运行环境后，重新配置数据库连接。下面就介绍一下hsqldb的一些简单的使用

下载HSQLDB
首先下载hsqldb，其官方网站为hsqldb.org，目前最新版本是2.4.0，最早用过1.9版本的，就觉得甚是喜欢，主页界面上有下载的链接，就一个压缩文件包，不需要区分操作系统。下载后解压即可

目录结构介绍
bin:存放运行的批处理，可以参照着放入自己的批处理用于启动或管理数据库
data:用于存放数据文件的地方，新解压时为空，后面自己用的时候，可能放在里面，也可以放在其他地方
doc:文档，与数据库操作的所有文档都在里面，很详细，有什么问题可以在里面找找
lib:jar文件，HSQLDB核心的jar包
sample:一些配置的模板

数据库启动
HSQLDB运行分为三种模式，分别为内存模式，进程模式，和服务器模式。
在内存模式下，所有的数据都将在内存中完成，如果程序退出，则相应的数据也将同时被销毁。连接JDBC的实例为：jdbc:hsqldb:mem:dbname
在进程模式下，是直接以文件方式进行操作，所有文件均写入文件，关闭数据库后数据可以保留，这种模式下不能接受其他程序访问
服务器模式，常用，又分为三种，即Servet,WebServer,Servlet，详见官方文档，服务器模式单独启动一个JVM用于提供数据库服务，并开放连接端口，其他程序可以通过jdbc或客户端连接，这也是在开发和调试中常用的一种方式，在上线运行后，可采用进程模式
以Server方式启动服务器
修改bin/runServer.bat，另存为myBookServer

cd ..\data
@java -classpath ../lib/hsqldb.jar org.hsqldb.server.Server --database.0 file:book --dbname.0 bookdb

即在data目录下创建数据文件，文件名为book，启动服务的数据库名为bookdb，如果需要修改监听端口，可以使用--poot 9002，如果不修改端口，可以不用添加这个参数，默认端口为9001，启动后的显示如下

D:\hsqldb-2.4.0\hsqldb\bin>myBookServer.bat

D:\hsqldb-2.4.0\hsqldb\bin>cd ..\data
[Server@4517d9a3]: Startup sequence initiated from main() method
[Server@4517d9a3]: Could not load properties from file
[Server@4517d9a3]: Using cli/default properties only
[Server@4517d9a3]: Initiating startup sequence
[Server@4517d9a3]: Server socket opened successfully in 6 ms.
[Server@4517d9a3]: Database [index=0, id=0, db=file:book, alias=bookdb] opened successfully in 354 ms.
[Server@4517d9a3]: Startup sequence completed in 362 ms.
[Server@4517d9a3]: 2017-04-23 15:22:33.599 HSQLDB server 2.4.0 is online on port 9001
[Server@4517d9a3]: To close normally, connect and execute SHUTDOWN SQL
[Server@4517d9a3]: From command line, use [Ctrl]+[C] to abort abruptly

看到这个提示，说明数据库已经启动好了，并开启了监听端口9001，现在可以通过客户端程序连接了
在bin目录下，有一个runManager.bat和一个runManagerSwing.bat，这两个批处理都可以打开自带的客户端程序，只是界面风格有所不同，runManager要简洁些，下面介绍一下runManagerSwing的使用，双击打开后，需要填写连接信息，当然也可以在命令行里通过参数的方式进行连接，在弹出对话框里输入连接信息

mybook是为当前配置取的名字，URL里添加上bookdb，如果不是9001端口的话，还需要添加端口，如//localhost:9001/bookdb，登录后，就可以进入到管理界面了

在这里操作HSQLDB，比如创建表，修改数据之类的，如果需要修改密码之类的操作，文档里有详解
创建表，插入数据，可以上图界面中运行如下命令

CREATE TABLE TB_BOOKS(BOOKID INTEGER GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY,BOOKNAME VARCHAR(30),AUTHOR VARCHAR(30));

创建一个book表，分别为bookid,bookname,author

JDBC访问
接下来用JAVA写入数据并测试

package com.zhouf.hsql;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class HsqlTest {

    public static void main(String[] args) throws SQLException {
        //initData();
        Connection conn = getConnection();
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("select * from tb_books");
        while(rs.next()){
            System.out.println(rs.getString("bookname") + "=>" + rs.getString("author"));
        }
        rs.close();
        stmt.close();
        conn.close();

    }

    public static Connection getConnection(){
        Connection conn = null;
        try {
            Class.forName("org.hsqldb.jdbcDriver");
            conn = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/bookdb", "SA", "");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    public static void initData() throws SQLException{

        Connection conn = getConnection();
        Statement stmt = conn.createStatement();
        for (int i = 10; i < 30; i++) {
            String sql = "insert into tb_books(bookname,author) values('BookName"+i+"','Author"+i+"')";
            System.out.println(sql);
            stmt.addBatch(sql);
        }

        stmt.executeBatch();
        stmt.close();
        conn.close();
    }

}

先调用initData()初始化数据，就可以在管理界面中看到数据了，再运行java可以读取数据，JDBC连接没有问题，记得一定要在工程里引用lib/hsqldb.jar库
此时在data目录下有很多book开头的文件，只是后缀有所不同，有临时文件，日志文件，属性文件以及脚本文件等，如果运行了shutdown命令，则其他文件会自动清理，仅保留properties和script文件，如果要带走数据库，把这两个文件带走就好了。
如果不希望每次打开管理界面都弹出对话框要求输入内容，可以在命令行里添加参数，拷贝一份bin/runManagerSwing.bat并修改为如下内容

cd ..\data
@java -classpath ..\lib\hsqldb.jar org.hsqldb.util.DatabaseManagerSwing --url jdbc:hsqldb:hsql://localhost/bookdb --user SA

另存为myBookManager.bat，下次直接运行这个批处理就可能直接连接到数据库服务器，不用再弹出连接对话框了，前提是服务器正在运行中，如果运行了shutdown关闭了服务器，则需要重新启动服务器进行连接。
至此，基本的hsqldb的使用就完成了，文档里还有其它更多的配置和连接方式，详细情况请参阅doc目录下的文档。
如果需要把hsqldb嵌入到webapp中运行，不用单独启动服务器，请关注后续文档，稍后整理好再发布。自己码了一下午才整理好这一篇，看来得提高效率了，如果这篇文档能对大家所有帮助，那就太好了。

ZhouFeng 2017-04-23 16:41 发表评论

JavaDB数据库使用笔记

ZhouFeng — Tue, 10 Jan 2017 02:48:00 GMT

在做一些小的应用系统时，用过嵌入式数据库，使用过HSQLDB，这个比较小巧，在做了几个应用之后觉得挺好用的，因为数据量不多，也能够满足要求，也就在嵌入式数据库这条路上越走越远了。

在JAVA里也有一个嵌入式数据库，也想尝试着用一下，便有了下面这篇日志。在安装jdk的时候会提示安装一个数据库，如果勾选的话，则会在安装Java嵌入式数据库JavaDB，在JAVA_HOME目录下多出一个db的目录（在jdk6版本里目录名为JavaDB），里面就是与数据库有关的文件了，如果安装jdk时没有选择安装，可以在官网http://db.apache.org/derby/derby_downloads.html上下载解压即可，经过了一段时间的摸索，现小结如下。

1.配置环境变量

在使用之前，需要配置环境变量DERBY_HOME指向db所在目录，本机JAVA_HOME为G:\Java\jdk1.8.0_73,则DERBY_HOME应该配置为G:\Java\jdk1.8.0_73\db，或%JAVA_HOME%\db，如果希望后面在命令行里用起来方便点，也可以将%DERBY_HOME%\db\bin添加到path里去

2.目录介绍

在DERBY_HOME目录下有两个目录bin和lib

bin:存放执行批处理文件，用于查看，启动和停止数据库的脚本

lib:存放所用到的jar包

bin目录下有几个主要的文件，有两个不同的方式，没有.bat后缀的文件为Linux平台下运行的脚本，bat文件为Windows平台使用的批处理

dblook:用于查看数据库的基本信息及DDL语句

ij:命令行客户端程序，提供与数据库的交互

NetworkServerControl:提供网络服务，主要被startNetworkServer和stopNetworkServer调用

startNetworkServer:启动网络数据库模式，开启监听

stopNetworkServer:关闭网络数据库模式，停止监听

sysinfo:查看当前系统信息，可用于检测数据库是否正确安装

几个以CP结束的批处理，主要用于在不同模式下设置CLASSPATH用的，如果把lib目录下的jar文件添加到CLASSPATH中，就可以不用通过执行批处理来设置CLASSPATH了

3.用命令行方式开启数据库

G:\Java\jdk1.8.0_73\db\bin>ij
ij 版本 10.11
ij> connect 'jdbc:derby:mydb;create=true';

加上create=true表明如果库mydb不存在，则创建，数据库文件存放位置为当前目录，接下来创建一个表，可以把三个字段定义信息写在一行里面，结束时要加分号

ij> create table stu(id int not null generated by default as identity,
> stuname varchar(20),
> email varchar(30));
已插入/更新/删除 0 行

向表中写入一条记录，并进行查询

ij> insert into stu(stuname,email) values('Tom','tom@test.com');
已插入/更新/删除 1 行
ij> select * from stu;
ID |STUNAME |EMAIL
---------------------------------------------------------------
1 |Tom |tom@test.com

已选择 1 行

退出命令行状态

ij> exit;

重新进入命令行方式，进行数据验证

G:\Java\jdk1.8.0_73\db\bin>ij
ij 版本 10.11
ij> connect 'jdbc:derby:mydb';
ij> select * from stu;
ID |STUNAME |EMAIL
---------------------------------------------------------------
1 |Tom |tom@test.com

已选择 1 行

查看当前表结构可以用describe <表名>

这是在命令行方式下的基本使用

4.在Java工程中使用JavaDB

在Eclipse中创建一个Java工程，导入derby.jar包，代码如下

package com.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class EmbedDB {

    private static String driver = "org.apache.derby.jdbc.EmbeddedDriver";
    private static String protocol = "jdbc:derby:db3;create=true"; // 在工程目录下创建数据库
    // private static String protocol = "jdbc:derby:db/db3;create=true";    //在工程目录下db目录中创建数据库
    // private static String protocol = "jdbc:derby:D:/mydbs/db3;create=true";    //在D:/mydbs/目录下创建数据库

    public static void main(String[] args) {
        try {
            Class.forName(driver).newInstance();
            System.out.println("Loaded the appropriate driver");
            Connection conn = DriverManager.getConnection(protocol);
            Statement stmt = conn.createStatement();
            stmt.executeUpdate("create table stu(id int not null generated by default as identity,stuname varchar(20),email varchar(30))");

            for (String str : "one,two,three,four,five".split(",")) {
                String sql = "insert into stu(stuname,email) values('" + str + "','" + str + "@test.com')";
                System.out.println(sql);
                stmt.addBatch(sql);
            }
            stmt.executeBatch();
            System.out.println("insert over");
            conn.commit();

            stmt.close();
            conn.close();

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

运行结果

Loaded the appropriate driver
insert into stu(stuname,email) values('one','one@test.com')
insert into stu(stuname,email) values('two','two@test.com')
insert into stu(stuname,email) values('three','three@test.com')
insert into stu(stuname,email) values('four','four@test.com')
insert into stu(stuname,email) values('five','five@test.com')
insert over

5.网络数据库模式

JavaDB是跑在JVM中的，如果此时再开启一个新的窗口，打开当前数据库，会报错，如果希望有多个客户端连接，如开发阶段，一边在Eclipse里运行程序，一边在命令行里查看数据记录，这种情况就可以使用JavaDB的网络启动模式

G:\Java\jdk1.8.0_73\db\bin>startNetworkServer
Tue Jan 10 09:10:54 CST 2017 : 已使用基本服务器安全策略安装了 Security Manager。
Tue Jan 10 09:11:04 CST 2017 : Apache Derby 网络服务器 - 10.11.1.2 - (1629631) 已启动并准备接受端口 1527 上的连接

表示当前窗口正在监听，即网络服务已开启

查看数据库的基本情况可以用dblook

G:\Java\jdk1.8.0_73\db\bin>dblook -d 'jdbc:derby://localhost:1527/mydb'
-- 时间戳记：2017-01-10 09:18:30.232
-- 源数据库为：mydb
-- 连接 URL 为：jdbc:derby://localhost:1527/mydb
-- appendLogs: false

-- ----------------------------------------------
-- 表的 DDL 语句
-- ----------------------------------------------

CREATE TABLE "APP"."STU" ("ID" INTEGER NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1, INCREMENT BY 1), "STUNAME" VARCHAR(20), "EMAIL" VARCHAR(30));

以命令行方式进行数据库连接并测试

此时也可以在Eclipse中使用Java程序进行数据库访问，需要加载derbyclient.jar包，代码如下

package com.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class ClientDB {

    private static String driver = "org.apache.derby.jdbc.ClientDriver";
    private static String protocol = "jdbc:derby://localhost:1527/mydb";

    public static void main(String[] args) {
        try {
            Class.forName(driver).newInstance();
            System.out.println("Loaded the appropriate driver");
            Connection conn = DriverManager.getConnection(protocol);
            Statement stmt = conn.createStatement();
            for (int i = 1; i < 10; i++) {
                String sql = "insert into stu(stuname,email) values('user" + i + "','user" + i + "@test.com')";
                System.out.println(sql);
                stmt.addBatch(sql);
            }
            stmt.executeBatch();
            System.out.println("insert over");
            conn.commit();

            stmt.close();
            conn.close();

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

控制以输出结果为

Loaded the appropriate driver
insert into stu(stuname,email) values('user1','user1@test.com')
insert into stu(stuname,email) values('user2','user2@test.com')
insert into stu(stuname,email) values('user3','user3@test.com')
insert into stu(stuname,email) values('user4','user4@test.com')
insert into stu(stuname,email) values('user5','user5@test.com')
insert into stu(stuname,email) values('user6','user6@test.com')
insert into stu(stuname,email) values('user7','user7@test.com')
insert into stu(stuname,email) values('user8','user8@test.com')
insert into stu(stuname,email) values('user9','user9@test.com')
insert over

此时查看数据库内容为

小结

终于学习了JavaDB，又尝试了一种嵌入式数据库，在做一些小项目或是应用演示时很方便。在了解过JavaDB后，觉得JavaDB也是个不错的选择，很多操作都做成了批处理方式，在HSQLDB中也可以自己构造批处理，在HSQLDB中有个图形界面可以用，相对直观一些，对于体积来说，HSQLDB好像更小巧点，他们都支持内存数据库，目前在数据库性能上没有做比较。总的来说，JavaDB是个不错的选择，使用起来比较方便。此文仅做简单介绍，如果希望了解得更多，可参考官方文档http://db.apache.org/derby/manuals/index.html#latest

有几个不同部分的文档，与SQL相关的部分如创建删除表的SQL怎么写，可以参考其中的《Derby Reference Manual》
另外在学习JavaDB里找了一些资料，下面这一篇我觉得还不错，一并附上
参考资料：http://www.codejava.net/java-se/jdbc/connect-to-apache-derby-java-db-via-jdbc

ZhouFeng 2017-01-10 10:48 发表评论

初试MyBatis

ZhouFeng — Sun, 22 Jul 2012 04:48:00 GMT

虽然MyBatis发布已经有一段时间了，一直想试试，可总是被中断，这次总算是跑了一下，对MyBatis有所了解。
在www.mybatis.org上可以找到下载链接，我下载的是mybatis-3.1.1这个版本，下载一个zip包，里面包含有主要的库文件mybatis-3.1.1.jar，还有一些引用的jar，一个PDF说明文档，这个说明文档提供的是E文版，可以在网上找到相应的中文版，下载完成后，就开始我的操作了。
在MyEclipse里创建了一个java工程，本来是打算在Web中使用的，没有创建Web工程，只是想试一下MyBatis这东东，java工程就可以了。
创建时引入MyBatis库和数据库驱动库，创建一个空的工程

准备好数据库，此处用MySQL做练习，创建一个bbs数据库，创建一个tb_users表，结构如下

+----------+----------+------+-----+---------+-------+

+----------+----------+------+-----+---------+-------+

| userid | int(11) | NO | PRI | | |

+----------+----------+------+-----+---------+-------+

创建一个User类，与数据表对应

package com.cuit.prj.domain;

public class User {
    private int userid;
    private String userName;

    public User() {
        super();
    }
    public User(int userid, String userName) {
        super();
        this.userid = userid;
        this.userName = userName;
    }
    public int getUserid() {
        return userid;
    }
    public void setUserid(int userid) {
        this.userid = userid;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
}

再创建一个UserMapper接口，里面提供了对User的相关操作

package com.cuit.prj.presistence;

import com.cuit.prj.domain.User;

public interface UserMapper {
    User selectUser(int userid);
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(int userid);
}

再创建一个UserMapper.xml，与UserMapper.java对应的一个配置文件，经本例测试，其中的id要和接口中的方法名一致

xml version="1.0" encoding="UTF-8" ?>
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cuit.prj.presistence.UserMapper">
    <select id="selectUser" parameterType="int" resultType="com.cuit.prj.domain.User">
        select *
        from tb_users where userid = #{userid}
    select>

    <insert id="insertUser" parameterType="com.cuit.prj.domain.User">
        insert into tb_users(userid,username) values (#{userid},#{userName})
    insert>

    <update id="updateUser" parameterType="com.cuit.prj.domain.User">
        update tb_users set username = #{userName} where userid = #{userid}
    update>

    <delete id="deleteUser" parameterType="int">
        delete from tb_users where userid = #{userid}
    delete>
mapper>

在src下面创建MyBatis配置文件mybatis-conf.xml，配置文件名没有特殊规定，因为在后面的代码里需要指定文件名

xml version="1.0" encoding="UTF-8" ?>
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost/bbs" />
                <property name="username" value="root" />
                <property name="password" value="1233" />
            dataSource>
        environment>
    environments>
    <mappers>
        <mapper resource="com/cuit/prj/presistence/UserMapper.xml" />
    mappers>
configuration>

创建一个获取连接的SessionFactory的类

package com.cuit.prj.sessionfactory;

import java.io.IOException;
import java.io.Reader;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class SessionFactory {
    public static SqlSession getSession(){
        SqlSession session = null;
        String resource = "mybatis-conf.xml";
        try {
            Reader reader = Resources.getResourceAsReader(resource);
            SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
            session = sqlMapper.openSession();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return session;
    }
}

做好上述准备后，写一个主方法调用测试，如下

package com.cuit.prj;

import org.apache.ibatis.session.SqlSession;
import com.cuit.prj.domain.User;
import com.cuit.prj.presistence.UserMapper;
import com.cuit.prj.sessionfactory.SessionFactory;

public class AppTest {
    public static void main(String[] args) {
        System.out.println("Hello");
        SqlSession session = SessionFactory.getSession();
        try {
            UserMapper mapper = session.getMapper(UserMapper.class);

            User user = mapper.selectUser(2);
            System.out.println(user.getUserName());
        } finally {
            session.close();
        }
    }
}

在数据库中添加两条记录，并提交

+--------+----------+

| userid | username |

+--------+----------+

| 1 | user1 |

| 2 | user2 |

+--------+----------+

接下来就可以运行看看结果了。输出如下：

Hello

user2

终于跑起来了，在处理了一系列的Exception之后看到的结果，上面的测试只是做了一个读取数据的操作，如果有新增或修改数据，需要调用session.commit()操作。
大概小结一下，用了MyBatis感觉还是很不错的，把SQL语句和JAVA代码分离开，喜欢自己掌控SQL语句的人们可能会喜欢MyBatis一些，不像Hibernate那样可以完全不用写SQL语句。只是配置文件和接口写起来还是有些麻烦，还有POJO类的生成，工作量还是不小哇，网上找到一个生成工具，下次研究一下再补充上来。

ZhouFeng 2012-07-22 12:48 发表评论

HSQLDB外键使用

ZhouFeng — Tue, 27 Dec 2011 09:59:00 GMT

前段时间用了HSQLDB，感觉这个东东还不错，这两天在把一个以前MYSQL上的东东转到HSQLDB上来，除了一些类型需要转换以外，还有就是外键的处理，着实让我折腾了一番。因为是系统改造，没有使用ORM映射，若是使用Hibernate或MyBatis之类的来做，应该会避免这个语句的问题
在此用三个表的创建为例记录一下外键的写法

create table notice(
    id integer generated by default as primary key,
    title varchar(30)
)

create table tbuser(
    userid varchar(20) primary key,
    username varchar(30)
)

create table noticecheck(
    id integer references notice(id) on delete cascade,
    userid varchar(20) references tbuser(userid) on delete cascade,
    checktime timestamp default current_timestamp,
    unique(id,userid)
)

另外noticecheck也可以使用如下的方式写语句

create table noticecheck(
    id integer,
    userid varchar(20),
    checktime timestamp default current_timestamp,
    unique(id,userid),
    constraint noticecheck_fk_1 foreign key(id) references notice(id) on delete cascade,
    constraint noticecheck_fk_2 foreign key(userid) references tbuser(userid) on delete cascade
)

好啦，就这样，官方所给的文档全E文的，费劲。网上也少有这方面的资料，看来使用HSQLDB的还不多，记在这里了先：）

ZhouFeng 2011-12-27 17:59 发表评论

Oracle10g数据库导入导出（跨字符集）

ZhouFeng — Sun, 25 Jul 2010 03:53:00 GMT

一导出：
#!/bin/bash
su - oracle -c "exp system/fakepass tables=$1 file=/data/$1.dmp"

[root@web oracle8i]# dmp album

Export: Release 10.1.0.3.0 - Production on 星期一 2月 5 01:56:55 2007

Copyright (c) 1982, 2004, Oracle. All rights reserved.

连接到: Oracle Database 10g Enterprise Edition Release 10.1.0.3.0 - Production
With the Partitioning, OLAP and Data Mining options
已导出 ZHS16CGB231280 字符集和 AL16UTF16 NCHAR 字符集
服务器使用 ZHS16GBK 字符集 (可能的字符集转换)

即将导出指定的表通过常规路径...
. . 正在导出表                           ALBUM导出了         590 行
EXP-00091: 正在导出有问题的统计信息。
EXP-00091: 正在导出有问题的统计信息。
EXP-00091: 正在导出有问题的统计信息。
导出成功终止, 但出现警告。
二导入
从 Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Production
With the Partitioning, OLAP and Data Mining options 断开
[oracle@dev ~]$ imp system/fit2007 file=blogcat.dmp tables=blogcat

Import: Release 10.2.0.1.0 - Production on 星期一 2月 5 01:44:39 2007

Copyright (c) 1982, 2005, Oracle. All rights reserved.

连接到: Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Production
With the Partitioning, OLAP and Data Mining options

经由常规路径由 EXPORT:V10.01.00 创建的导出文件
已经完成 ZHS16GBK 字符集和 AL16UTF16 NCHAR 字符集中的导入
导入服务器使用 AL32UTF8 字符集 (可能的字符集转换)
导出客户机使用 ZHS16CGB231280 字符集 (可能的字符集转换)
. 正在将 SYSTEM 的对象导入到 SYSTEM
. 正在将 SYSTEM 的对象导入到 SYSTEM
. . 正在导入表                       "BLOGCAT"导入了        1938 行
成功终止导入, 没有出现警告。
[oracle@dev ~]$ imp system/topsecret file=blogcat.dmp tables=blogcat
三总结
   2个oracle10g服务器，导出的在北京，版本10.1.0.3.0，使用 ZHS16GBK 字符集。
导入的在宝鸡，临时开发测试用，版本 10.2.0.1.0，AL32UTF8 字符集。
主要问题是2个服务器字符集不同，解决的关键是：在导入前，设置导入机器的NLS_LANG 与导出机器的NLS_LANG相同，为Simplified Chinese_china.ZHS16GBK
全部导出的dmp文件有1.8G，学校服务器带宽有限，所以采用了导出常用数据表的最新数据方法。

转:http://www.zhuoda.org/hofman/78332.html

ZhouFeng 2010-07-25 11:53 发表评论

解决从JBOSS迁移到TOMCAT下的MYSQL乱码问题

ZhouFeng — Tue, 26 May 2009 13:10:00 GMT

弄了老半天,终于是把这个问题给搞定了,一个在JOBSS下跑得很好的程序,因为某些原因需要迁移到TOMCAT下面,可老是出现乱码的问题,情况如下
数据库:MYSQL5.0
数据库编码:UTF-8
所有页面编码都统一用UTF-8
在JBOSS下配置数据源,即修改mysql-ds.xml

xml version="1.0" encoding="UTF-8"?>

<datasources>
  <local-tx-datasource>
    <jndi-name>appjndi-name>
    <connection-url>jdbc:mysql://localhost/appconnection-url>
    <driver-class>com.mysql.jdbc.Driverdriver-class>
    <user-name>useruser-name>
    <password>pwdpassword>

    <metadata>
       <type-mapping>mySQLtype-mapping>
    metadata>
  local-tx-datasource>
datasources>

当把应用迁移到TOMCAT6下时,配置好TOMCAT下的数据源(修改contex.xml文件)

xml version='1.0' encoding='utf-8'?>

<Context>

<Resource name="jdbc/app"
        auth="Container"
        type="javax.sql.DataSource"
        driverClassName="com.mysql.jdbc.Driver"
        url="jdbc:mysql://localhost/app"
        username="user"
        password="pwd"
        removeAbandoned="true"
        removeAbandonedTimeout="60"
        logAbandoned="true"
        maxActive="700"
        maxIdle="30"
        maxWait="10000" />


    <WatchedResource>WEB-INF/web.xmlWatchedResource>

Context>

因JBOSS和TOMCAT获取数据源连接的方式不同,又修改了获取连接的代码,启动之后是可以运行,页面读取数据正常,但写入数据库时,出现了乱码,我尝试着修改写入数据库的SQL语句的编码,但不管怎么修改都不能正常显示,后来试着通过URL直接修改连接的编码试试,于是把TOMCAT数据源配置里的URL指定为UTF-8的字符集

url="jdbc:mysql://localhost/app?useUnicode=true&characterEncoding=utf-8"

这里再重新启动TOMCAT,运行后,数据写入正常,这个困扰我多天的问题终于解决了,之前没有想到这样的问题,以为JBOSS里也是用的TOMCAT,在JBOSS里配置的数据源都没有在URL里指定编码,没想到单独使用TOMCAT时会出现这样的问题,把今天的处理在这里作个记录,以便以后备查

小结:
当用MYSQL作数据库时,将应用程序从JBOSS迁移到TOMCAT,如果存在乱码的问题,可以考虑修改URL指定字符集

ZhouFeng 2009-05-26 21:10 发表评论

MySQL优化经验

ZhouFeng — Tue, 10 Feb 2009 12:48:00 GMT

同时在线访问量继续增大对于1G内存的服务器明显感觉到吃力严重时甚至每天都会死机或者时不时的服务器卡一下这个问题曾经困扰了我半个多月MySQL使用是很具伸缩性的算法，因此你通常能用很少的内存运行或给MySQL更多的被存以得到更好的性能。

安装好mysql后，配制文件应该在/usr/local/mysql/share/mysql目录中，配制文件有几个，有my- huge.cnf my-medium.cnf my-large.cnf my-small.cnf,不同的流量的网站和不同配制的服务器环境，当然需要有不同的配制文件了。

一般的情况下，my-medium.cnf这个配制文件就能满足我们的大多需要；一般我们会把配置文件拷贝到/etc/my.cnf 只需要修改这个配置文件就可以了，使用mysqladmin variables extended-status –u root –p 可以看到目前的参数，有３个配置参数是最重要的，即key_buffer_size,query_cache_size,table_cache。

key_buffer_size只对MyISAM表起作用，

key_buffer_size指定索引缓冲区的大小，它决定索引处理的速度，尤其是索引读的速度。一般我们设为16M,实际上稍微大一点的站点　这个数字是远远不够的，通过检查状态值Key_read_requests和Key_reads,可以知道key_buffer_size设置是否合理。比例key_reads / key_read_requests应该尽可能的低，至少是1:100，1:1000更好（上述状态值可以使用SHOW STATUS LIKE ‘key_read%’获得）。或者如果你装了phpmyadmin 可以通过服务器运行状态看到,笔者推荐用phpmyadmin管理mysql，以下的状态值都是本人通过phpmyadmin获得的实例分析:

这个服务器已经运行了20天

key_buffer_size – 128M
key_read_requests – 650759289
key_reads - 79112

比例接近1:8000 健康状况非常好

另外一个估计key_buffer_size的办法　把你网站数据库的每个表的索引所占空间大小加起来看看以此服务器为例:比较大的几个表索引加起来大概125M 这个数字会随着表变大而变大。

从4.0.1开始，MySQL提供了查询缓冲机制。使用查询缓冲，MySQL将SELECT语句和查询结果存放在缓冲区中，今后对于同样的SELECT语句（区分大小写），将直接从缓冲区中读取结果。根据MySQL用户手册，使用查询缓冲最多可以达到238%的效率。

通过调节以下几个参数可以知道query_cache_size设置得是否合理

Qcache inserts
Qcache hits
Qcache lowmem prunes
Qcache free blocks
Qcache total blocks

Qcache_lowmem_prunes的值非常大，则表明经常出现缓冲不够的情况,同时Qcache_hits的值非常大，则表明查询缓冲使用非常频繁，此时需要增加缓冲大小Qcache_hits的值不大，则表明你的查询重复率很低，这种情况下使用查询缓冲反而会影响效率，那么可以考虑不用查询缓冲。此外，在SELECT语句中加入SQL_NO_CACHE可以明确表示不使用查询缓冲。

Qcache_free_blocks，如果该值非常大，则表明缓冲区中碎片很多query_cache_type指定是否使用查询缓冲

我设置:

query_cache_size = 32M
query_cache_type= 1

得到如下状态值:

Qcache queries in cache 12737 表明目前缓存的条数
Qcache inserts 20649006
Qcache hits 79060095 　看来重复查询率还挺高的
Qcache lowmem prunes 617913　有这么多次出现缓存过低的情况
Qcache not cached 189896 　　
Qcache free memory 18573912　　目前剩余缓存空间
Qcache free blocks 5328 这个数字似乎有点大　碎片不少
Qcache total blocks 30953

如果内存允许32M应该要往上加点

table_cache指定表高速缓存的大小。每当MySQL访问一个表时，如果在表缓冲区中还有空间，该表就被打开并放入其中，这样可以更快地访问表内容。通过检查峰值时间的状态值Open_tables和Opened_tables，可以决定是否需要增加table_cache的值。如果你发现open_tables等于table_cache，并且opened_tables在不断增长，那么你就需要增加table_cache的值了（上述状态值可以使用SHOW STATUS LIKE ‘Open%tables’获得）。注意，不能盲目地把table_cache设置成很大的值。如果设置得太高，可能会造成文件描述符不足，从而造成性能不稳定或者连接失败。

对于有1G内存的机器，推荐值是128－256。

笔者设置table_cache = 256

得到以下状态:

Open tables 256
Opened tables 9046

虽然open_tables已经等于table_cache，但是相对于服务器运行时间来说,已经运行了20天，opened_tables的值也非常低。因此，增加table_cache的值应该用处不大。如果运行了6个小时就出现上述值那就要考虑增大table_cache。

如果你不需要记录2进制log 就把这个功能关掉，注意关掉以后就不能恢复出问题前的数据了，需要您手动备份，二进制日志包含所有更新数据的语句，其目的是在恢复数据库时用它来把数据尽可能恢复到最后的状态。另外，如果做同步复制( Replication )的话，也需要使用二进制日志传送修改情况。

log_bin指定日志文件，如果不提供文件名，MySQL将自己产生缺省文件名。MySQL会在文件名后面自动添加数字引，每次启动服务时，都会重新生成一个新的二进制文件。此外，使用log-bin-index可以指定索引文件；使用binlog-do-db可以指定记录的数据库；使用binlog-ignore-db可以指定不记录的数据库。注意的是：binlog-do-db和binlog-ignore-db一次只指定一个数据库，指定多个数据库需要多个语句。而且，MySQL会将所有的数据库名称改成小写，在指定数据库时必须全部使用小写名字，否则不会起作用。

关掉这个功能只需要在他前面加上#号

#log-bin

开启慢查询日志( slow query log ) 慢查询日志对于跟踪有问题的查询非常有用。它记录所有查过long_query_time的查询，如果需要，还可以记录不使用索引的记录。下面是一个慢查询日志的例子：

开启慢查询日志，需要设置参数log_slow_queries、long_query_times、log-queries-not-using-indexes。

log_slow_queries指定日志文件，如果不提供文件名，MySQL将自己产生缺省文件名。long_query_times指定慢查询的阈值，缺省是10秒。log-queries-not-using-indexes是4.1.0以后引入的参数，它指示记录不使用索引的查询。笔者设置long_query_time=10

笔者设置:

sort_buffer_size = 1M
max_connections=120
wait_timeout =120
back_log=100
read_buffer_size = 1M
thread_cache=32
interactive_timeout=120
thread_concurrency = 4

参数说明:

back_log

要求MySQL能有的连接数量。当主要MySQL线程在一个很短时间内得到非常多的连接请求，这就起作用，然后主线程花些时间(尽管很短) 检查连接并且启动一个新线程。back_log值指出在MySQL暂时停止回答新请求之前的短时间内多少个请求可以被存在堆栈中。只有如果期望在一个短时间内有很多连接，你需要增加它，换句话说，这值对到来的TCP/IP连接的侦听队列的大小。你的操作系统在这个队列大小上有它自己的限制。 Unix listen(2)系统调用的手册页应该有更多的细节。检查你的OS文档找出这个变量的最大值。试图设定back_log高于你的操作系统的限制将是无效的。

max_connections

并发连接数目最大，120 超过这个值就会自动恢复，出了问题能自动解决

thread_cache

没找到具体说明，不过设置为32后 20天才创建了400多个线程而以前一天就创建了上千个线程所以还是有用的

thread_concurrency

#设置为你的cpu数目x2,例如，只有一个cpu,那么thread_concurrency=2
#有2个cpu,那么thread_concurrency=4
skip-innodb
#去掉innodb支持

代码:

# Example MySQL config file for medium systems.
#
# This is for a system with little memory (32M - 64M) where MySQL plays
# an important part, or systems up to 128M where MySQL is used together with
# other programs (such as a web server)
#
# You can copy this file to
# /etc/my.cnf to set global options,
# mysql-data-dir/my.cnf to set server-specific options (in this
# installation this directory is /var/lib/mysql) or
# ~/.my.cnf to set user-specific options.
#
# In this file, you can use all long options that a program supports.
# If you want to know which options a program supports, run the program
# with the "--help" option.

# The following options will be passed to all MySQL clients
[client]
#password = your_password
port = 3306
socket = /tmp/mysql.sock
#socket = /var/lib/mysql/mysql.sock
# Here follows entries for some specific programs

# The MySQL server
[mysqld]
port = 3306
socket = /tmp/mysql.sock
#socket = /var/lib/mysql/mysql.sock
skip-locking
key_buffer = 128M
max_allowed_packet = 1M
table_cache = 256
sort_buffer_size = 1M
net_buffer_length = 16K
myisam_sort_buffer_size = 1M
max_connections=120
#addnew config
wait_timeout =120
back_log=100
read_buffer_size = 1M
thread_cache=32
skip-innodb
skip-bdb
skip-name-resolve
join_buffer_size=512k
query_cache_size = 32M
interactive_timeout=120
long_query_time=10
log_slow_queries= /usr/local/mysql4/logs/slow_query.log
query_cache_type= 1
# Try number of CPU's*2 for thread_concurrency
thread_concurrency = 4

#end new config
# Don't listen on a TCP/IP port at all. This can be a security enhancement,
# if all processes that need to connect to mysqld run on the same host.
# All interaction with mysqld must be made via Unix sockets or named pipes.
# Note that using this option without enabling named pipes on Windows
# (via the "enable-named-pipe" option) will render mysqld useless!
#
#skip-networking

# Replication Master Server (default)
# binary logging is required for replication
#log-bin

# required unique id between 1 and 2^32 - 1
# defaults to 1 if master-host is not set
# but will not function as a master if omitted
server-id = 1

# Replication Slave (comment out master section to use this)
#
# To configure this host as a replication slave, you can choose between
# two methods :
#
# 1) Use the CHANGE MASTER TO command (fully described in our manual) -
# the syntax is:
#
# CHANGE MASTER TO MASTER_HOST=, MASTER_PORT=,
# MASTER_USER=, MASTER_PASSWORD= ;
#
# where you replace , , by quoted strings and
# by the master's port number (3306 by default).
#
# Example:
#
# CHANGE MASTER TO MASTER_HOST='125.564.12.1', MASTER_PORT=3306,
# MASTER_USER='joe', MASTER_PASSWORD='secret';
#
# OR
#
# 2) Set the variables below. However, in case you choose this method, then
# start replication for the first time (even unsuccessfully, for example
# if you mistyped the password in master-password and the slave fails to
# connect), the slave will create a master.info file, and any later
# change in this file to the variables' values below will be ignored and
# overridden by the content of the master.info file, unless you shutdown
# the slave server, delete master.info and restart the slaver server.
# For that reason, you may want to leave the lines below untouched
# (commented) and instead use CHANGE MASTER TO (see above)
#
# required unique id between 2 and 2^32 - 1
# (and different from the master)
# defaults to 2 if master-host is set
# but will not function as a slave if omitted
#server-id = 2
#
# The replication master for this slave - required
#master-host =
#
# The username the slave will use for authentication when connecting
# to the master - required
#master-user =
#
# The password the slave will authenticate with when connecting to
# the master - required
#master-password =
#
# The port the master is listening on.
# optional - defaults to 3306
#master-port =
#
# binary logging - not required for slaves, but recommended
#log-bin

# Point the following paths to different dedicated disks
#tmpdir = /tmp/
#log-update = /path-to-dedicated-directory/hostname

# Uncomment the following if you are using BDB tables
#bdb_cache_size = 4M
#bdb_max_lock = 10000

# Uncomment the following if you are using InnoDB tables
#innodb_data_home_dir = /var/lib/mysql/
#innodb_data_file_path = ibdata1:10M:autoextend
#innodb_log_group_home_dir = /var/lib/mysql/
#innodb_log_arch_dir = /var/lib/mysql/
# You can set .._buffer_pool_size up to 50 - 80 %
# of RAM but beware of setting memory usage too high
#innodb_buffer_pool_size = 16M
#innodb_additional_mem_pool_size = 2M
# Set .._log_file_size to 25 % of buffer pool size
#innodb_log_file_size = 5M
#innodb_log_buffer_size = 8M
#innodb_flush_log_at_trx_commit = 1
#innodb_lock_wait_timeout = 50

[mysqldump]
quick
max_allowed_packet = 16M

[mysql]
no-auto-rehash
# Remove the next comment character if you are not familiar with SQL
#safe-updates

[isamchk]
key_buffer = 20M
sort_buffer_size = 20M
read_buffer = 2M
write_buffer = 2M

[myisamchk]
key_buffer = 20M
sort_buffer_size = 20M
read_buffer = 2M
write_buffer = 2M

[mysqlhotcopy]
interactive-timeout

补充

优化table_cachetable_cache指定表高速缓存的大小。每当MySQL访问一个表时，如果在表缓冲区中还有空间，该表就被打开并放入其中，这样可以更快地访问表内容。通过检查峰值时间的状态值Open_tables和Opened_tables，可以决定是否需要增加 table_cache的值。如果你发现open_tables等于table_cache，并且opened_tables在不断增长，那么你就需要增加table_cache的值了（上述状态值可以使用SHOW STATUS LIKE ‘Open%tables’获得）。注意，不能盲目地把table_cache设置成很大的值。如果设置得太高，可能会造成文件描述符不足，从而造成性能不稳定或者连接失败。对于有1G内存的机器，推荐值是128－256。

案例1：该案例来自一个不是特别繁忙的服务器table_cache – 512open_tables – 103opened_tables – 1273uptime – 4021421 (measured in seconds)该案例中table_cache似乎设置得太高了。在峰值时间，打开表的数目比table_cache要少得多。

案例2：该案例来自一台开发服务器。table_cache – 64open_tables – 64opened-tables – 431uptime – 1662790 (measured in seconds)虽然open_tables已经等于table_cache，但是相对于服务器运行时间来说，opened_tables的值也非常低。因此，增加table_cache的值应该用处不大。案例3：该案例来自一个upderperforming的服务器table_cache – 64open_tables – 64opened_tables – 22423uptime – 19538该案例中table_cache设置得太低了。虽然运行时间不到6小时，open_tables达到了最大值，opened_tables的值也非常高。这样就需要增加table_cache的值。优化key_buffer_sizekey_buffer_size指定索引缓冲区的大小，它决定索引处理的速度，尤其是索引读的速度。通过检查状态值Key_read_requests和Key_reads，可以知道key_buffer_size 设置是否合理。比例key_reads / key_read_requests应该尽可能的低，至少是1:100，1:1000更好（上述状态值可以使用SHOW STATUS LIKE ‘key_read%’获得）。key_buffer_size只对MyISAM表起作用。即使你不使用MyISAM表，但是内部的临时磁盘表是 MyISAM表，也要使用该值。可以使用检查状态值created_tmp_disk_tables得知详情。对于1G内存的机器，如果不使用 MyISAM表，推荐值是16M（8-64M）。

案例1：健康状况key_buffer_size – 402649088 (384M)key_read_requests – 597579931key_reads - 56188案例2：警报状态key_buffer_size – 16777216 (16M)key_read_requests – 597579931key_reads - 53832731案例1中比例低于1:10000，是健康的情况；案例2中比例达到1:11，警报已经拉响。

本文出自:http://kb.discuz.net/index.php?title=MySQL优化经验

ZhouFeng 2009-02-10 20:48 发表评论