BlogJava-藏经阁-文章分类-原创

Tomcat配置cgi运行python脚本

ZhouFeng — Sat, 20 Oct 2018 02:34:00 GMT

今天折腾一下如何在Tomcat环境下运行python脚本，查阅了一些文档，把实现的过程小结如下，当前实验环境，Tomcat8，Eclipse。python环境是Anaconda，因为之前有安装这个东东，也就没有重新安装python环境了。首先在Eclipse中创建新工程，并可以在Tomcat中运行起来，接下来才是配置cgi的步骤

1、在web工程WEB-INF目录下创建目录cgi，当然也可以是别的名字

2、修改web.xml，开启如下设置，默认情况是注释掉的

<servlet>
    <servlet-name>cgiservlet-name>
    <servlet-class>org.apache.catalina.servlets.CGIServletservlet-class>
    <init-param>
        <param-name>clientinputTimeoutparam-name>
        <param-value>100param-value>
    init-param>
    <init-param>
        <param-name>debugparam-name>
        <param-value>0param-value>
    init-param>
    <init-param>
        <param-name>passShellEnvironmentparam-name>
        <param-value>trueparam-value>
    init-param>
    <init-param>
        <param-name>cgiPathPrefixparam-name>
        <param-value>WEB-INF/cgiparam-value>
    init-param>
    <init-param>
        <param-name>executableparam-name>
        <param-value>D:/Anaconda3/python.exeparam-value>
    init-param>
    <load-on-startup>5load-on-startup>
servlet>

注意修改python的路径

cgiPathPrefix: 与Server能够访问的脚本目录有关，与之前创建的目录相对应

3、开启cgi的mapping映射，修改web.xml，开启如下设置

<servlet-mapping>
<servlet-name>cgiservlet-name>
<url-pattern>/cgi-bin/*url-pattern>
servlet-mapping>

访问路径可以修改为自定义字符

4、修改content.xml文件，在Context中添加privileged属性

5、在工程cgi目录写python文件，如hello.py

print('Content-type: text/plain\n\n')

print('Hello python')

输出text/plain说明这是一个普通文本，一定注意之后要有两个换行（小心坑啦）！！！

6、运行工程并测试

http://localhost:8080/prj/cgi-bin/hello.py

所见结果，通过这种方法可以在Tomcat环境下运行python脚本了，如果是已经用python脚本做好了服务的话，还是可以考虑通过服务调用的方式与Tomcat工程进行整合，在此记录一下

ZhouFeng 2018-10-20 10:34 发表评论

网页语音播报的实现

ZhouFeng — Tue, 25 Apr 2017 10:48:00 GMT

因为需要实现在页面中进行语音提示，有点像美团那个外卖的提示音“您有新的订单，请注意查收”，于是开始搜寻方法，最后发现一个开源项目，https://github.com/wenco/speech 用来实现语音播报，上面有文档说明。先clone下来试试

按照所给的代码，运行起来没有问题，需要在页面中放入一个标签，并写入要转换为语音的内容。为了后面为了调用方便，下面进行了一些调整。

把播放按钮隐藏起来，让事件触发播放。

修改jQuery.speech.min.js，因页面引用的文件是这个，也可以单独创建一个js在页面中引入，写入以下内容

//语音内容放在页面元素中，如果没有则创建

function say(arg) {

    //处理页面元素
    if($("#tts_content").length == 0){
        //存在元素
        $("

").appendTo("body");
    }

    //处理传入参数
    if(arg){
        $('#tts_content').text(arg);
    }else{
        $('#tts_content').text("您有新的消息，请注意查收");
    }

    //转化为语音
    $('#tts_content').speech({
        "speech": false,
        "speed": 16
    });
}

调整了播报速度，在程序中自动创建需要的标签，需要播报的内容根据参数传入，没有参数也可以播报默认的消息，经过这样简单的封装后，在调用时，就只需要调用say()方法即可，不需要在页面中放入标签，也方便放入其他事件中，然后页面就可以这样了

DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>语音播报title>
head>
<body>
<style type="text/css">
body{background-color:#fff;padding-top:50px;}
style>
<script src="js/jQuery/jQuery-2.1.4.min.js">script>
<script src="js/speech/jQuery.speech.min.js">script>

<button id="kk">说一个button>
<script>
$("#kk").click(function() {
say("您有新的订单，请注意查收");
//say();
});
script>
body>
html>

添加按钮只是为了演示事件触发，需要说什么内容就传入什么参数，如果不传入参数，则播报默认内容。这样的调用，甚是简单，终于完成了这样的功能，很帅，哈哈:D

致谢https://github.com/wenco/speech

ZhouFeng 2017-04-25 18:48 发表评论

在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 发表评论

Tomcat+Eclipse环境下使用Jenkins2.38搭建持续集成(CI)环境

ZhouFeng — Mon, 02 Jan 2017 03:51:00 GMT

在网上看到很多关于使用Jenkins构建持续集成环境的文章，在有空的时候也希望尝试一下，这样可以在测试服务器上看到提交的最新版本

1.下载安装Jenkins

可以在http://mirrors.jenkins-ci.org上下载安装包，也可以选择在官网（https://jenkins.io）上下载war包(http://mirrors.jenkins.io/war-stable/latest/jenkins.war)或是安装包(http://mirrors.jenkins-ci.org/windows/jenkins-2.38.zip)，写这篇文章时最新版本为2.38。如果选择安装包方式，下载后安装即可，安装完成后会自动启动浏览器向导，根据提示操作完成安装
本机下载安装包，安装到C:\Jenkins，如下配置也是基于此目录进行，下载及安装过程截图如下

选择Download Jenkins

下拉选择相应的操作系统版本，也可以直接下载war包，本文下载Windows版本的安装包，安装过程指定安装目录即可，安装完成后，会自动启动浏览器进行配置

根据页面提示，在文件中找到密码填入

选择插件，本例选择第二项，自己定义插件，打开第二项里的默认选择和推荐插件一样，如果不做修改，就相当于选择推荐插件安装

安装完成后，设置管理员账号

保存结束安装

点击开始进入Jenkins界面

2.启动Jenkins

Jenkins默认工作目录会在当前用户目录下创建.jenkins目录，也可以通过设置环境变量来修改，例如：

set JENKINS_HOME=C:\jenkins

然后重新启动jenkins，可以放在与安装目录不同的地方
进入安装目录C:\Jenkins，用命令行方式启动

java -jar jenkins.war

默认端口为8080，如果需要指定端口，可以使用如下参数指定，如指定端口为9000

java -jar jenkins.war --httpPort=9000

也可以修改目录下的jenkins.xml配置文件，将其中的httpPort修改即可

<arguments>-Xrs -Xmx256m -Dhudson.lifecycle=hudson.lifecycle.WindowsServiceLifecycle -jar "%BASE%\jenkins.war" --httpPort=8080 --webroot="%BASE%\war"arguments>

3.部署应用到Jenkins

之前的工程是基于Tomcat+Eclipse开发的，工程不是用Maven管理的，后面就对工程进行了改造，用Ant编译，添加了build.xml文件，在Ant中需要找到Tomcat目录，为了灵活一点，在系统里添加了Tomcat的环境变量CATALINA_HOME，以及Ant环境的安装，这是对原有工程的改造，如果新的工程采用Maven方式的话，应该会没有这么麻烦，附上build.xml

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

<project basedir="." default="build" name="xi">
    <property environment="env"/>
    <property name="tomcat.home" value="${env.CATALINA_HOME}" />
    <property name="tomcat.lib" value="${env.CATALINA_HOME}/lib" />
    <property name="web.root" value="${env.CATALINA_HOME}/webapps"/>
    <property name="ant.home" value="${env.ANT_HOME}" />
    <property name="debuglevel" value="source,lines,vars"/>
    <property name="target" value="1.7"/>
    <property name="source" value="1.7"/>
    <property name="webRoot.dir" value="${basedir}/WebContent" />
    <property name="src.dir" value="${basedir}/src" />
    <property name="lib.dir" value="${webRoot.dir}/WEB-INF/lib" />
    <property name="log.file" value="${tomcat.home}/webapps/log.info"/>

    <tstamp>
        <format property="build.time" pattern="yyyy-MM-dd HH:mm:ss" />
    tstamp>

    <path id="prj.classpath">
        <pathelement location="build/classes"/>
        <fileset dir="${tomcat.lib}">
            <include name="*.jar" />
        fileset>
        <fileset dir="${lib.dir}">
            <include name="*.jar" />
        fileset>
    path>
    <path id="tomcat.classpath">
        <fileset dir="${tomcat.lib}">
            <include name="*.jar" />
        fileset>
        <fileset dir="${tomcat.home}/bin">
            <include name="*.jar" />
        fileset>
    path>

    <target name="init">
        <echo message="---------- init ----------">echo>
        <mkdir dir="build/classes"/>
        <copy includeemptydirs="false" todir="build/classes">
            <fileset dir="src">
                <exclude name="**/*.java"/>
            fileset>
        copy>
    target>

    <target name="clean">
        <echo message="---------- clean ----------">echo>
        <delete dir="build/classes"/>
        <delete file="build/${ant.project.name}.war">delete>
    target>

    <target name="compile" depends="init">
        <echo message="${ant.project.name}: ${ant.file}"/>
        <javac debug="true" debuglevel="${debuglevel}" destdir="build/classes" includeantruntime="false"  encoding="UTF-8">
            <src path="src"/>
            <classpath refid="prj.classpath"/>
        javac>
        <delete file="build/classes/gen-conf.xml"/>
    target>

    <target name="build" depends="compile" description="make war">
        <war destfile="build/${ant.project.name}.war" basedir="WebContent" webxml="WebContent/WEB-INF/web.xml">

            <classes dir="${basedir}/build/classes">classes>
        war>
    target>

    <target name="deploy" depends="build" description="deploy to tomcat">
        <echo message="----------deploy to tomcat----------">echo>
        <delete file="${tomcat.home}/webapps/${ant.project.name}.war" />
        <delete dir="${tomcat.home}/webapps/${ant.project.name}" />
        <copy file="build/${ant.project.name}.war" todir="${tomcat.home}/webapps" />
    target>

    <target name="undeploy" description="deploy to tomcat">
        <echo message="---------- undeploy project ----------">echo>
        <delete file="${tomcat.home}/webapps/${ant.project.name}.war" />
        <delete dir="${tomcat.home}/webapps/${ant.project.name}" />
    target>


project>

这样写是为了在Jenkins里调用Ant完成编译和部署的工作。
在Jenkins里创建项目，当前选择的是自由项目，写好项目名称，后续就是对项目进行配置，如果不希望保留过多的旧构建，可以设置丢弃。另外还需要获取源码的服务器，默认支持CVS和Subversion，也可以通过插件支持Git，因当前项目托管于SVN，配置如下图

后面是如何触发的配置，如下设置为每天6:30进行构建，每一个小时检查一下源码，主要是获取到代码后的动作设置

在动作设置里用Windows的批处理方式进行，原本考虑在服务器上做一个批处理，由Jenkins调用，经测试需要用绝对路径，不知是不是某个地方没配置好，后来就改用这种方式，对服务进行启动停止控制，对工程进行部署
经测试，此方式可以用，当前用来解决Tomcat+Eclipse环境下的工程自动构建问题，写在这个地方做个记录，如果有机会，尝试一下Maven，看看是不是要简单点

ZhouFeng 2017-01-02 11:51 发表评论

将Tomcat8日志配置为log4j日志系统

ZhouFeng — Sat, 30 Apr 2016 11:48:00 GMT

Tomcat控制台启动日志是由java.util.logging.Logger实现的，我只是希望能自己定义输出格式，找了下文档，发现在%CATALINA_HOME%\conf目录下面有个logging.properties文件，里面有项内容为：

java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

这里的formatter需要通过类来实现，要是能在这里直接写formatter格式字串就好了，继续研究下吧。

电脑上安装的是Tomcat8，找了下官网上的文档，有关于使用Log4j作为日志的配置

http://tomcat.apache.org/tomcat-8.0-doc/logging.html#Using_Log4j

就试下了，下面是官网的实现步骤，文中描述的%CATALINA_HOME%是指Tomcat安装目录

1. 准备日志配置文件

官网上有一个配置文件，先拿来用下，后面根据自己的需要再慢慢作调整，保存到%CATALINA_HOME%\lib\log4j.properties

log4j.rootLogger=INFO, CATALINA

# Define all the appenders
log4j.appender.CATALINA=org.apache.log4j.DailyRollingFileAppender
log4j.appender.CATALINA.File=${catalina.base}/logs/catalina.
log4j.appender.CATALINA.Append=true
log4j.appender.CATALINA.Encoding=UTF-8
# Roll-over the log once per day
log4j.appender.CATALINA.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.CATALINA.layout = org.apache.log4j.PatternLayout
log4j.appender.CATALINA.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.LOCALHOST=org.apache.log4j.DailyRollingFileAppender
log4j.appender.LOCALHOST.File=${catalina.base}/logs/localhost.
log4j.appender.LOCALHOST.Append=true
log4j.appender.LOCALHOST.Encoding=UTF-8
log4j.appender.LOCALHOST.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.LOCALHOST.layout = org.apache.log4j.PatternLayout
log4j.appender.LOCALHOST.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.MANAGER=org.apache.log4j.DailyRollingFileAppender
log4j.appender.MANAGER.File=${catalina.base}/logs/manager.
log4j.appender.MANAGER.Append=true
log4j.appender.MANAGER.Encoding=UTF-8
log4j.appender.MANAGER.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.MANAGER.layout = org.apache.log4j.PatternLayout
log4j.appender.MANAGER.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.HOST-MANAGER=org.apache.log4j.DailyRollingFileAppender
log4j.appender.HOST-MANAGER.File=${catalina.base}/logs/host-manager.
log4j.appender.HOST-MANAGER.Append=true
log4j.appender.HOST-MANAGER.Encoding=UTF-8
log4j.appender.HOST-MANAGER.DatePattern='.'yyyy-MM-dd'.log'
log4j.appender.HOST-MANAGER.layout = org.apache.log4j.PatternLayout
log4j.appender.HOST-MANAGER.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Encoding=UTF-8
log4j.appender.CONSOLE.layout = org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern = %d [%t] %-5p %c- %m%n

# Configure which loggers log to which appenders
log4j.logger.org.apache.catalina.core.ContainerBase.[Catalina].[localhost]=INFO, LOCALHOST
log4j.logger.org.apache.catalina.core.ContainerBase.[Catalina].[localhost].[/manager]=INFO, MANAGER
log4j.logger.org.apache.catalina.core.ContainerBase.[Catalina].[localhost].[/host-manager]=INFO, HOST-MANAGER

2. 需要下载Log4j的jar包

1.2的版本下载如下

http://logging.apache.org/log4j/1.2/download.html

3. 下载Tomcat8的扩展组件

就是在下载Tomcat8的那个页面http://tomcat.apache.org/download-80.cgi，下面点有个Extras，里面有两项JULI adapters jar 和 JULI log4j jar的下载，下载后的两个文件为tomcat-juli.jar，tomcat-juli-adapters.jar

4. 准备和替换

把下载的log4j.jar和tomcat-juli-adapters.jar放到%CATALINA_HOME%\lib

把下载的tomcat-juli.jar替换掉%CATALINA_HOME%\bin\tomcat-juli.jar

5. 删除%CATALINA_HOME%\conf\logging.properties文件

6. 重新启动Tomcat

上面就是官网给出的操作步骤，结果可行，只是第一次运行时，控制台什么都没有，原来日志配置文件里的

log4j.rootLogger=INFO, CATALINA

就输出到文件里去了，把CONSOLE加上

log4j.rootLogger=INFO, CATALINA,CONSOLE

这里重新启动Tomcat，就可以看到原来的日志信息了。

到此，将Tomcat配置为log4j日志系统就改造结束了，要实现自己定义日志格式，那就折腾一下这个log4j.properties吧

ZhouFeng 2016-04-30 19:48 发表评论

GEF示例及Logic源代码

ZhouFeng — Tue, 04 Sep 2012 11:12:00 GMT

在参照网上的一些资料学习了一下GEF，算是有点眉目了，可总想看看示例的源代码，就是官方的一些示例。之前在网上找了很多，本以为是一个单独的工程，可总是没找到，很无语，在一些博客里也一两句话就带过去了，感觉很轻松似的。可是我却看得很模糊，在经过一番努力后，终于找到了在什么地方了
原来GEF的源代码是和插件一起发布的，安装好GEF插件后，在系统工程里就会有，大概步骤如下
在新建工程里选择New->Example

然后选择如上图所示的GEF(Graphical Editing Framework)Plug-ins下面的Logic，这就是我找寻很久的Logic示例工程，当然还有其它的几个工程也是这样的，然后下一步会生成一个系统默认的工程名：org.eclipse.gef.examples.logic 这是一个可以运行的工程，所有源代码就在其中，这下可以运行起来再看看代码啦，也可以试着改改看看效果。
在运行出来的一个Eclipse窗口里面，创建一个新的工程，具体是什么工程好像没有什么影响吧，我创建的是一个JAVA工程，然后创建一个文件，类型选择如上图所示的Logic Diagram文件，取好文件名后就可以确定了，这时就会看到一个打开的.logic的文件，里面什么都没有，刚开始，我到这里就迷惑了，这下怎么开始呢，怎么不像网上说的那样可以画点东西出来呢，原来这里的面板是浮动的，是靠编辑器的右侧浮动，把鼠标移动到靠近Outline面板的位置，浮动工具箱就会出来，然后，就可以开始拖点什么出来了。
接下来嘛，就可以好好学习，天天上网啦:D

ZhouFeng 2012-09-04 19:12 发表评论

学习一下GEF开发

ZhouFeng — Mon, 03 Sep 2012 03:22:00 GMT

最近接触了一下Eclipse的插件开发，需要学习GEF，据说有点难度，所以还是有心理准备的，在网上找了很多的资料，都没发现比较好容易入手的，看过《八进制》的BLOG，也找过PDF，Google,Baidu找出来的东东基本上都看过，都看得昏昏的，后来找到一个资料叫《GEF开发指南-插件开发.pdf》，下载好Eclipse和GEF插件后就可以开工了，至于GEF插件的安装，我就不在这里写出来的，网上很多的，开发环境配置好后，就可以开始入手了。
那文档有一百多页，分了几个部分，根着指导一步一步做下来，再加上学习和理解的过程，差不多花了一周时间，好漫长呀，不过做完之后，就可以对GEF的体系结构有个入门的了解了，接下来想看看带的一些官方示例，想从那里再学习一下，可总找不到，网上很多文档都写得很简单，一两句话就说过去了，也没看出来是怎么出来的。无奈，就只有自己慢慢的摸索了，看来GEF这样的东东确实不好对付，还得继续战斗

ZhouFeng 2012-09-03 11:22 发表评论

MyBatis代码生成工具mybatis-generator的使用

ZhouFeng — Sun, 22 Jul 2012 09:12:00 GMT

在用MyBatis的时候，会涉及到POJO类的编写，Mapper接口的编写，还有一些xml配置文件，数据库的创建也得自己完成，这样只是把数据库访问方式换成了ORM的方式进行，工作量并没有减少，在MyBatis主页里有看到提供的代码生成工具，便试了一下，写好配置文件后，执行一条命令便生成了之前我们手工完成的这些文件，很酷哇。
首先在网上下载mybatis-generator，此处下载的是3.1.1的版本的一个zip包，下载好后解压
解压后有个doc目录和一个lib目录，doc目录提供了一个使用说明文档，lib目录是我们需要的jar文件，当然还有提供源代码和文档jar，这些可以导入MyEclipse里用
进入到lib目录中（当然也可以在别处创建一个目录，只不过在使用时要指定jar文件路径，此处为了方便点，就把文件生成在这个目录里了），创建一个配置文件，如conf.xml，此处文件名自己命名，没有命名方面的特殊要求，我是参考doc文档里的配置文件写的，如下

xml version="1.0" encoding="UTF-8"?>
DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
  <classPathEntry location="mysql-connector-java-3.1.13-bin.jar" />

  <context id="mysqlTables" targetRuntime="MyBatis3">

    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost/bbs"
        userId="root"
        password="1233">
    jdbcConnection>

    <javaTypeResolver >
      <property name="forceBigDecimals" value="false" />
    javaTypeResolver>

    <javaModelGenerator targetPackage="test.model" targetProject="src">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    javaModelGenerator>

    <sqlMapGenerator targetPackage="test.xml"  targetProject="src">
      <property name="enableSubPackages" value="true" />
    sqlMapGenerator>


    <javaClientGenerator type="XMLMAPPER" targetPackage="test.dao"  targetProject="src">
      <property name="enableSubPackages" value="true" />
    javaClientGenerator>

    <table tableName="tb_users" >
table>

  context>
generatorConfiguration>

标签里指定要生成的相关数据表，如果有多个表的话，需要配置多个

数据库还是用之前创建好的数据库和表，并指定了要生成文件的相关表，因为要用到与数据库的连接，得加载数据库驱动，可以将mysql的驱动放在系统环境变量的classpath里，也可以在配置文件里指定路径，此处为了配置文件方便，把mysql的驱动jar包拷贝到lib目录下了，并创建一个用于存放生成文件的src文件夹
在命令窗口模式下，进入到lib目录，执行如下命令

java -jar mybatis-generator-core-1.3.1.jar -configfile conf.xml -overwrite

命令执行完成后，便可在src目录下看到生成的一些文件了，大概看了一下生成的代码，自己写的话，还是要花一点时间的，有好的工具，可真是方便呀，不过发现一个问题，生成的代码里的好多的注释，感觉注释比可用代码都多，我查了一下配置文件，找到了一个去掉生成注释的地方，把它加在了配置文件里，大概位置如下，我之前放错了地方，就没法运行

  <context id="mysqlTables" targetRuntime="MyBatis3">

    <commentGenerator>
      <property name="suppressAllComments" value="true" />
      <property name="suppressDate" value="true" />
    commentGenerator>

    <jdbcConnection driverClass="com.mysql.jdbc.Driver"

这样改了之后，生成的代码就没有注释了，这下清爽了许多，至于标签和里面的两个属性的含义，doc文档里有详细的说明，我就不贴在这里了，如果要把生成的文件放到工程应用里，注意改下相关的路径及包名，应该就可以了。
用了一下，感觉这个东东很不错，确实省事儿不少，不过我还没有在项目中尝试，写在这里了先:)

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

初试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 发表评论

SimpleDateFormat进行月分转换（MMM）异常的问题

ZhouFeng — Tue, 15 Nov 2011 02:10:00 GMT

在做一个任务时，需要对日期进行转换，源始字串格式为：Tue Nov 15 09:17:35 CST 2011
希望转换成日期类型，写了如下代码

Date pubd = (new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy")).parse("Tue Nov 15 09:17:35 CST 2011");

没想到出现了异常提示

java.text.ParseException: Unparseable date: "Tue Nov 15 09:17:35 CST 2011"

我逐步排查，最后发现是MMM的问题，因为最后将代码精简到只剩MMM时还是出现这样的问题

Date pubd = (new SimpleDateFormat("MMM")).parse("Nov");

在网上查了些文档，也多半是讲解怎样用SimpleDateFormat进行日期转换的，好像遇到这样异常的还不多，最后看到JAVA文档里还有一个构造函数

SimpleDateFormat(String pattern, Locale locale)

结合网上的一些提示，Nov是英文中的表示方法，就试着在构造函数里添加一个Locale.US，结果如下

Date pubd = (new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy",Locale.US)).parse("Tue Nov 15 09:17:35 CST 2011");

终于解决了这个问题，也许这对于有经验的老手来说，算不上什么。暂时记在这里先，如果有朋友再碰到这样的问题，希望能很快解决

ZhouFeng 2011-11-15 10:10 发表评论

浮动QQ客服的实现

ZhouFeng — Sat, 05 Nov 2011 02:01:00 GMT

这个功能是最近的一个东东需要，所以关注了一下，在网上找了一些，感觉都有点复杂，经过一段时间的学习后，终于实现了一个稍微简洁的版本
我是用的wp.qq.com官方网站上的提示完成了，在页面里定义一个DIV，里面的内容安排就自己确定了，我的代码如下

那部分...的代码是在wp.qq.com上拷贝的，网站上还有很多的样式供选择，为了适应本来的页面样式，还得定义该层的样式，确定显示位置等，使其更规范些，我的样式定义如下

/********************在线服务部分**********************/
#online_box{
    position: absolute;
    float: right;
    left: 5px;
    top: 200px;
    z-index: 10;
    border: 1px solid #0168b7;
    width: 170px;
    background-color: white;
    text-align: left;
}
#online_box #title{
    background-color: #0168b7;
    color: white;
    font-size: 12;
    font-weight: bold;
    padding: 10px;
}
#online_box #qqlist{
    font-size: 12;
    padding: 20px;
}
#online_box #qqlist img{
    vertical-align:middle;
}

接下来就是对页面滚动的处理，实现层的浮动，我借用了jQuery来完成的，库的引入就不必再写了，下面附上写的脚本

1 $(document).ready(function(){
2
3     var bodyTop = 0;
4     var selfHeight = $("#online_box").height();
5     if (typeof window.pageYOffset != 'undefined') {
6         bodyTop = window.pageYOffset;
7     } else if (typeof document.compatMode != 'undefined' && document.compatMode != 'BackCompat') {
8         bodyTop = document.documentElement.scrollTop;
9     }else if (typeof document.body != 'undefined') {
10         bodyTop = document.body.scrollTop;
11     }
12     $("#online_box").css("top", bodyTop+document.body.clientHeight-selfHeight-5);
13 });
14
15
16
17 $(window).scroll(function() {
18     var bodyTop = 0;
19     var selfHeight = $("#online_box").height();
20     if (typeof window.pageYOffset != 'undefined') {
21         bodyTop = window.pageYOffset;
22     } else if (typeof document.compatMode != 'undefined' && document.compatMode != 'BackCompat') {
23         bodyTop = document.documentElement.scrollTop;
24     }else if (typeof document.body != 'undefined') {
25         bodyTop = document.body.scrollTop;
26     }
27
28     //靠上端方式
29     //$("#online_box").css("top", 100 + bodyTop);
30
31     //靠下端方式
32     $("#online_box").css("top", bodyTop+document.body.clientHeight-selfHeight-5);
33 });

我采用靠左下的方式显示，直接在CSS中无法确定靠下显示的页面显示高度，所以在ready()里做了一次定位，如果是按上对齐方式，这部分可以不写，直接把TOP写在CSS里就行了，下面的滚动定位也会简单些
好啦，任务完成，收工，今天周六，把前几天完成的事情记录一下先:)

ZhouFeng 2011-11-05 10:01 发表评论

CKeditor3.3配置记录

ZhouFeng — Sun, 30 May 2010 16:30:00 GMT

摘要: 记录新的CKEditor3.3的一些配置,以及中文问题的处理阅读全文

ZhouFeng 2010-05-31 00:30 发表评论

在MyEclipse中使设置JSP页面编码及注释

ZhouFeng — Wed, 28 Apr 2010 07:26:00 GMT

在前面的一篇文章里有写到在MyEclipse中更改JSP的页面编码,那种方法在新版的MyEclipse中似乎不太有效,经查资料找到以下方法可以设置JSP页面的默认编码,windows->Preferences->MyEclipse->Files & Editors->JSP->encoding:设置为ISO10646/Unicode(UTF-8)

在MyEclipse中设置注释
MyEclipse有很多自动化的功能,可以方便我们开发,其中快速插入注释就很好用,减少了很多重复的劳动,MyEclipse中有很多已定义好的注释格式,如果我们觉得不够满意,可以自己修改或是重新定义,其操作步骤如下:windows ->Preferences -> Java ->Code Style ->Code Templates ->Comments ->Types ->edit(编辑)

在"Insert Variable..."里还可以添加时间等变量,修改为自己合适的方式
如果希望每次新建类或是方法时自动按照这种定义好的格式添加好注释的话,可以选中下面的复选框(Automatically add Comments for new Methods and types),点击Apply 确认即可

让MyEclipse显示行号
我刚安装好的MyEclipse 8.0M1默认是不显示行号的,但可以通过以下设置显示行号: windows ->Preferences ->General ->Editor ->Text Editors ->Show line numbers(勾选)

另外还有一个简单的方法,就是在编辑器的行号显示的位置点击鼠标右键,在菜单中选择"Show Line Numbers"即可

ZhouFeng 2010-04-28 15:26 发表评论

在MyEclipse中使用模板

ZhouFeng — Wed, 21 Apr 2010 14:21:00 GMT

在MyEclipse中使用模板可以大大提高我们的编程效率，在Eclipse或MyEclipse中默认使用的是Alt+/调出模板，如果调不出模板的话，可能是快捷键存在冲突，可以通过如下方法设置 Window->Preferences->General->Keys 打开如下界面（我用的版本是MyEclipse 8.0M1)

在界面中找到Content Assist,可以看到默认绑定到Alt+/，可以通过下面的Binding:重新设置绑定键，建议使用不常用的，可以在Binding里单击列排序，可看到设定的键有没有重复，当设定好后点击OK确定，这步就完成了
下面进行模板的定义
选择Window->Preferences->Java->Editor->Templates进入如下界面

在这里可以看到系统已定义好的模板，输入模板名后按Alt+/或是前面设定好的热键即可根据模板替换文本，如系统自带有sysout模板，如下

那么我们在写java文件时就可以输入sysout然后打入Alt+/或是前面设定好的热键，就可以替换成Pattern里的文本，另外界面里还有个设置Automatically insert的地方，如果选中将其设置为on，那么在使用模板替换时就不会出现提示对话框，直接替换，若该状态不是on，在执行模板替换时会出现询问的提示
如果觉得这些不够用，我们也可以自己定义模板，选择旁边的New...即可，如下图

建了一个mytmp的模板，定义了五行文本，这里通过“Insert Variable...”插入了几个变量，它们分别代表不同的含义
${enclosing_package} 表示当前文件的包名
${enclosing_type} 表示当前类名
${enclosing_method} 表示当前的方法名
${cursor} 表示光标的位置
另外，在“Insert Variable...”里还有很多可选择的东东，大家看下英文的变量名就能应该能理解的
此时，当我们在编写java文件时，输入mytmp后按Alt+/或是前面设定好的热键，就可以替换为上面定义的五行文本，这样的操作真是太帅了
其实它自带模板的已经很多了，定义好热键及个性化的模板，可以大大加快我们写代码的速度，高效哇！！！
MyEclipse真是个好东东，看来还有很多值得研究的东西，把这点东东记录在这里，供还在钻研的朋友们参考一下

ZhouFeng 2010-04-21 22:21 发表评论

将数据源的连接配置改为从配置文件读取

ZhouFeng — Thu, 22 Oct 2009 16:14:00 GMT

最近因一个项目需要迁移到另一个服务器上,而迁移的目标服务器是公用的服务器,需要将原有的数据源配置改为从自定义的配置文件读取,服务器都是用的Tomcat,以前的项目是在Tomcat里配置数据源,然后在程序中获取数据源里的连接,而新的服务器只提供了一个上传JSP文件的FTP方式,这种方式是没办法修改Tomcat配置文件配置数据源的,也就只好修改程序,将数据连接的部分改为读取自定义的配置文件

在此,考虑了几种方法
方法一:用Spring框架,将数据连接配置写在Spring的配置文件里,用Spring的注入方式生成对象,供程序调用
方法二:自定义一个xml文件,在数据连接写在xml中,写一个JavaBean读取xml
方法三:用Property方式定义配置配置文件,用JavaBean来读取设置
因为是一个很小的东东,为此一项而使用Spring框架,似乎有点浪费,用xml来作配置文件,自己写读取方法时也不算简单,最简单的还是第三种,也不想为这点改动用大刀,简单的就是最好的:)

首先新建一个读取配置文件的DBConfig.java(省略了包及getter,setter方法)

/**
* 这是一个获取数据库配置的类
* @author ZF
*/
public class DBConfig {
    private String url;
    private String driver;
    private String userName;
    private String password;

    /**
     * @param args
     */
    public static void main(String[] args) {
        DBConfig conf = new DBConfig();

    }

    /**
     * 在构造函数里读取配置文件
     */
    public DBConfig(){
        Properties prop= new Properties();
        try
        {
            //目录指到根目录的上级,是为了将配置文件放在WEB-INF目录下
            //如果直接放在根目录下,则需将配置文件放在classes目录下
            InputStream is = getClass().getResourceAsStream("/../dbconfig.property");
            prop.load(is);
            if(is!=null){
                is.close();
            }
        }
        catch(Exception e) {
            e.printStackTrace();
        }

        this.setDriver(prop.getProperty("Driver"));
        this.setUrl(prop.getProperty("URL"));
        this.setUserName(prop.getProperty("user"));
        this.setPassword(prop.getProperty("password"));
    }

    // getters()... and setters()...

}

然后在WEB-INF目录下新建配置文件dbconfig.property

Driver=com.mysql.jdbc.Driver
URL=jdbc:mysql://localhost/tsoa
user=mysqluser
password=mysqlpassword

修改获取数据连接的代码

//获取数据库连接配置
DBConfig dbconf = new DBConfig();

//根据连接配置获取数据库连接
Class.forName(dbconf.getDriver()).newInstance();
conn= DriverManager.getConnection(dbconf.getUrl(),dbconf.getUserName(),dbconf.getPassword());

测试通过,OK,在此记录一下

ZhouFeng 2009-10-23 00:14 发表评论

搞定SUSE下安装Mplayer

ZhouFeng — Thu, 30 Jul 2009 05:05:00 GMT

折腾了很久，终于还是安装上了MPlayer，试过通过源代码编译，用yast安装，用yum安装，都没有成功，最后还是用zypper装好的，下面把重要的步骤记录下来就是了，那些曲折的路线就不用写了

安装Mplayer需要另外有packman的源.安装源可以在 http://en.opensuse.org/Additional_YaST_Package_Repositories 找到
添加安装源在线安装方为妙策.
#zypper ar URL Packman
#zypper install mplayer
以上URL为Packman的源

现在还是觉得zypper是个好东东

安装好之后，播放avi没有问题，可让界面全屏时，窗口倒是全屏了，可播放的画面还是原始大小，修改~/.mplayer/config为以下状态

zoom="yes"
sub-fuzziness=1
subcp=cp936

第一行为解决缩放全屏的问题
第二行为解决自动加载字幕的问题
第三行为中文字幕指定一个字符集
这样设置后,播放有中文字幕的视频就没有问题了

ZhouFeng 2009-07-30 13:05 发表评论

搞定FCKeditor2.6.4上传中文图片的问题

ZhouFeng — Wed, 03 Jun 2009 06:41:00 GMT

昨天配置好了FCKeditor,可以上传图片和文件了,可有一个问题还没有解决,那就是上传中文图片的时候会出现乱码,我的工程里用的编码都是UTF-8的,在网上找了好些资料,都搞不定,最后下载了fckeditor-java-2.4.1-src.zip(在http://www.fckeditor.net/download上也有下载).解压缩之后,把源文件部署到工程里,可启动老是报错,不知道是啥回事儿,后来换成了手动的,操作如下
找到源文件中的 net.fckeditor.connector.ConnectorServlet.java,将其中的部分代码改掉,我们先搞定图片中文问题,需要做如下修改,大概在240多行的位置

String newFilename = null;
FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);

在其后添加一行,指定编码为UTF-8的格式,如下

String newFilename = null;
FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
upload.setHeaderEncoding("UTF-8");

代码是改掉了,可怎么部署到应用里面呢,前面有说到,直接将java源文件放在工程里编译启动里会报错,不知道是我哪里没弄好还是怎么回事,反正也没去折腾了,改用土办法
解压fckeditor-java-core-2.4.1.jar里面的class放在WEB-INF/classes下,然后手工将新生成的ConnectorServlet.class文件替换掉 WEB-INF/classes/net/fckeditor/connector/ConnectorServlet.class ,再启动服务器,如果没有报错的话,中文图片的上传问题就能搞定了

今天为了解决这个问题查了一天的资料,也顺便看了很多文档,好像是FCKeditor2.4之后可以配置上传文件自动重命名的地方,我只看到一篇文档上提到过一次,在官方网站上也没有找到相关的说明,也就不去找什么配置了,反正源代码已经改动过了,不如把重命名也一起改了,找到net.fckeditor.connector.ConnectorServlet.java大概250行左右

// We upload only one file at the same time
FileItem uplFile = items.get(0);
String rawName = UtilsFile.sanitizeFileName(uplFile.getName());
String filename = FilenameUtils.getName(rawName);
String baseName = FilenameUtils.removeExtension(filename);
String extension = FilenameUtils.getExtension(filename);

将上面的代码改为

// We upload only one file at the same time
FileItem uplFile = items.get(0);
String rawName = UtilsFile.sanitizeFileName(uplFile.getName());

String randTimer = String.valueOf(Calendar.getInstance().getTimeInMillis());
String randVal = String.valueOf(Math.abs((new Random()).nextInt()));

String filename = FilenameUtils.getName(rawName);
String baseName = randTimer + randVal;
String extension = FilenameUtils.getExtension(filename);
filename = baseName.concat(".").concat(extension);

即可,此处我是用时间的毫秒串再加上一个随机数串构成的新文件名,当然也可以改成你自己喜欢的格式,如将毫秒改成日期时间字串,则只需修改

String randTimer = (new SimpleDateFormat("yyyyMMddHHmmss")).format(new Date());

改好了之后,重新生成class文件,按照上面的做法部署到应用中去

为了方便使用,可以把修改后的class文件重新做成jar包,将WEB-INF/classes下的net和org目录拷贝到一个新的空目录中,然后在命令提示符下转到该目录,用如下命令可以生成新的jar包

jar -cvf fckeditor-java-2.4.1-rename.jar *.*

此处为生成一个fckeditor-java-2.4.1-rename.jar,当然,名字可以自己定义

上面的做法可能不是很先进,在Eclipse里也有打包jar的操作,也许更新一个java源文件不会是这么麻烦,但总算这样是搞定了,记录在这里先

ZhouFeng 2009-06-03 14:41 发表评论

解决从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 发表评论

取消Eclipse的自动代码格式化

ZhouFeng — Wed, 22 Apr 2009 02:13:00 GMT

前段时间在Eclipse里面设置了java文件保存时自动格式化,在java->Code Style->Formatter里设置了自定义的格式化的样式,这样每次保存后都会自动格式化代码,用了一段时间感觉还不错,高科技,自动化
后来小组开发使用了SVN后,困为格式化的样式不一致,所以每次比较文件时总会有很多不匹配的地方,想取消自动格式化的设置,找了很久,没找到在哪里设置,当时一个不小心设置好后就忘记地方了,今天把Preferences里的东东翻了个遍,终于找着了,修改
java->editor->Save Actions->Format Source Code
取消勾选,即取消了保存时自动格式化的功能,终于恢复正常了,在这里记录一下,怕哪天又给忘记了

ZhouFeng 2009-04-22 10:13 发表评论

为JBOSS的远程控制台加锁

ZhouFeng — Fri, 10 Apr 2009 09:01:00 GMT

下午看到一篇文章,说是JBOSS服务器可以通过远程的方式关闭服务,因为默认情况控制台的用户密码都为空,见前一篇文章,看到这个消息后,吃了一惊,因为我们有个东东正在用JBOSS做服务器,测试了一下,确实存在这样的问题,赶紧照着材料补了一下
我用的JBOSS版本是Version: 4.0.4CR2,操作如下
一、为jms-console加上认证
修改jboss4\server\default\deploy\jmx-console.war\WEB-INF下的web.xml和jboss-web.xml
在web.xml中把的注释去掉

   <security-constraint>
     <web-resource-collection>
       <web-resource-name>HtmlAdaptorweb-resource-name>
       <description>An example security config that only allows users with the
         role JBossAdmin to access the HTML JMX console web application
       description>
       <url-pattern>/*url-pattern>
       <http-method>GEThttp-method>
       <http-method>POSThttp-method>
     web-resource-collection>
     <auth-constraint>
       <role-name>JBossAdminrole-name>
     auth-constraint>
   security-constraint>

在jboss-web.xml中把注释去掉

<jboss-web>

<security-domain>java:/jaas/jmx-consolesecurity-domain>
jboss-web>

然后修改jboss4\server\default\conf\props下的两个配置文件jmx-console-roles.properties和jmx-console-users.properties,添加用户和密码,搞定上面的配置之后,访问jms-console就需要认证了,下面继续web-console的配置
二、为web-console加上认证
在deploy目录下面没有看到web-console,就通过查找,结果找到了两个地方,分别是

jboss4\server\default\deploy\management\console-mgr.sar\web-console.war\
jboss4\server\all\deploy\management\console-mgr.sar\web-console.war\

我也没搞清楚倒底是哪个起作用,我改了其中一个试试,没效果,干脆两个都改了,改的步骤都是相同的,下面就对其中一个的配置进行说明了
找到 WEB-INF\下面的jboss-web.xml和web.xml,修改的方法同上,去掉两个注释
认证的文件放在了 WEB-INF\classes\下面,分别是web-console-roles.properties和web-console-users.properties,把用户的认证信息添加到里面即可,重新启动JBOSS,此时登录控制台会要求输入密码,我测试后发现有效的密码是default下面的配置,也搞不懂为什么要两个都改了才会弹出要求身份认证的对话框
先暂时就记在这里吧,如果哪位有做深入的研究,希望可以多提意见完善这个文档

ZhouFeng 2009-04-10 17:01 发表评论

在TOMCAT下自定义404错误页面

ZhouFeng — Thu, 09 Apr 2009 06:46:00 GMT

在Tomcat安装目录下的conf/web.xml最后的之前增加如下代码

<error-page>
<error-code>404error-code>
<location>/web404.jsplocation>
error-page>

也可以在应用的WEB-INF/web.xml下加入上述代码
然后建立web404.jsp自定义的页面,在页面里显示提示信息3秒后转到起始页面,我写的页面代码如下

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <meta http-equiv="refresh" content="3;url=<%=basePath%>">
    <title>资源错误title>
head>
<body>
    <div align="center"><h1><font color="#800000">对不起,你所访问的页面不存在font>h1>div>
body>
html>

经测试,访问一个不存在的页面,则转到自定义的页面,3秒后转到起始页,只要自定义页面能够被访问,那么是否进行跳转或是要进行其它什么操作就由你自己决定了

ZhouFeng 2009-04-09 14:46 发表评论

将应用程序部署到Tomcat的根

ZhouFeng — Fri, 16 Jan 2009 16:05:00 GMT

在Tomcat下部署应用的时候,访问时会在地址栏加上应用名如:htt://host:8000/prj
有时我们希望通过如下方式访问http://host
为此,有两个地方需要进行修改,一是修改Tomcat服务端口,二是修改应用的访问路径
修改服务端口只需改到Tomcat\conf\server.xml

将port的值改为80即可,前提是80端口没有被使用,如果已被占用,启动Tomcat时会出现端口被占用的提示信息

下一步是修改应用程序访问路径
方法一:
在Tomcat\conf\Catalina\localhost\目录下找到对应工程的xml文件,如此处为Tomcat\conf\Catalina\localhost\prj.xml

xml version='1.0' encoding='utf-8'?>
<Context displayName="prj Name" docBase="prj" path="">
Context>

将其path的值改为空,另外还要将Tomcat\conf\Catalina\localhost\ROOT.xml 的path值改为另一个值,要不启动Tomcat时会有冲突,如改成以下的状态

xml version='1.0' encoding='utf-8'?>
<Context displayName="Welcome to Tomcat" docBase="ROOT" path="/ROOT">
Context>

在完成上述改动后,就可以通过主机地址的方式访问应用程序了,如http://host

方法二:
如果按上面的方法配置不成功,还可以试试修改server.xml,在...里加上如下信息

<Context displayName="prj Name" docBase="prj" path="">
Context>

这样就不用管Tomcat\conf\Catalina\localhos目录了
刚做完上面的测试,把过程做一个记录写在这里,以便以后查阅

ZhouFeng 2009-01-17 00:05 发表评论

UrlRewrite的使用记录

ZhouFeng — Fri, 16 Jan 2009 01:50:00 GMT

为了不在地址栏里暴露过多的信息,想到了做一个地址的隐藏,在网上找了一些资料,决定试试UrlRewriet
在网上下载了urlrewrite的包,我下载的是urlrewritefilter-2.6-src.zip
打开压缩包,将里面的urlrewrite-2.6.0.jar放在工程的/WEB-INF/lib/目录下
将里面的urlrewrite.xml放在工程的/WEB-INF/目录下
修改/WEB-INF/web.xml,加入过滤器

<filter>
    <filter-name>UrlRewriteFilterfilter-name>
    <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilterfilter-class>
    <init-param>
        <param-name>logLevelparam-name>
        <param-value>WARNparam-value>
    init-param>
filter>
<filter-mapping>
    <filter-name>UrlRewriteFilterfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>

在urlrewrite.xml里加入规则,如:

<rule>
    <note>
        The rule means that requests to /page/pagea.html will be redirected to /pagea.jsp
    note>
    <from>/html/([a-z]+).htmlfrom>
    <to>/$1.jspto>
rule>

此时在浏览器里访问/html/pagea.html会显示/pagea.jsp的内容,OK,搞定
如果这种地址隐藏可行,那么可以把jsp页面伪装成asp或是php页面,改写规则如下

<rule>
    <note>
        The rule means that requests to /html/pagea.html will be redirected to /pagea.jsp
    note>
    <from>/html/([a-z]+).htmlfrom>
    <to>/$1.jspto>
rule>

<rule>
    <note>
        The rule means that requests to /asp/pagea.asp will be redirected to /pagea.jsp
    note>
    <from>/asp/([a-z]+).aspfrom>
    <to>/$1.jspto>
rule>

<rule>
    <note>
        The rule means that requests to /php/pagea.php will be redirected to /pagea.jsp
    note>
    <from>/php/([a-z]+).phpfrom>
    <to>/$1.jspto>
rule>

此时,在浏览器里输入
/html/pagea.html
/asp/pagea.asp
/php/pagea.php
均可以访问页面pagea.jsp
几个月前我写了一篇笔记做地址伪装的,看来完全可以用这个东东代替了,上次写的那个还有一些问题没有完全解决,用urlrewrite做地址隐藏,真是感觉很专业,完美呀,初次使用,可能有些高级的功能还没有用到,不过通过这样的试验,已感觉出它的强大,这应该是一个很好的解决方案.

ZhouFeng 2009-01-16 09:50 发表评论

Tomcat 数据源

ZhouFeng — Thu, 15 Jan 2009 04:28:00 GMT

前面写了一段在Tomcat中配置数据连接池的操作,那是在网上找的一篇,在此把我的操作过程记录一下
将jdbc数据库驱动包放到%Tomcat_Home%\common\lib下面
打开%Tomcat_Home%\conf\server.xml,在前添加如下信息

<Context path="/lib" docBase="lib">
   <Resource name="jdbc/lib" scope="Shareable" type="javax.sql.DataSource"/>
   <ResourceParams name="jdbc/lib">
     <parameter>
       <name>factoryname>
       <value>org.apache.commons.dbcp.BasicDataSourceFactoryvalue>
     parameter>

     <parameter>
       <name>urlname>
       <value>jdbc:mysql://localhost/libvalue>
     parameter>
     <parameter>
       <name>driverClassNamename>
       <value>com.mysql.jdbc.Drivervalue>
     parameter>
     <parameter>
       <name>usernamename>
       <value>rootvalue>
     parameter>
     <parameter>
       <name>passwordname>
       <value>passwordvalue>
     parameter>

     <parameter>
       <name>maxWaitname>
       <value>3000value>
     parameter>
     <parameter>
       <name>maxIdlename>
       <value>100value>
     parameter>
     <parameter>
       <name>maxActivename>
       <value>10value>
     parameter>
   ResourceParams>
Context>

在其应用工程的WEB.XML中添加数据源的引用

<resource-ref>
   <res-ref-name>jdbc/libres-ref-name>
   <res-type>javax.sql.DataSourceres-type>
   <res-auth>Containerres-auth>
resource-ref>

然后写一个测试的页面
需要三个包

java.sql.*
javax.naming.*
javax.sql.DataSource

通过下面的方式获取连接

InitialContext ctx=new InitialContext();
DataSource ds=(DataSource)ctx.lookup("java:comp/env/jdbc/lib");
Connection conn=ds.getConnection();

测试通过,可以获取连接,配置完成!!!

ZhouFeng 2009-01-15 12:28 发表评论

Grails的Domain中的中文处理

ZhouFeng — Mon, 01 Dec 2008 02:02:00 GMT

我在Domain中做了一个inList的约束,不过却碰到了中文问题

inList:['学生','老师','管理员']

在网上找了解决办法,便转到这里来存着,方法如下:
将编辑器设置为支持UTF-8编码,并且保存文件也为UTF-8编码,如果使用UltraEdit，打开源代码后请选择“文件——转换——ASCII到UTF-8编辑”。然后正常输入汉字保存即可,照着这个办法试了一下,OK,搞定
在这里记录一下,就当做点笔记吧

ZhouFeng 2008-12-01 10:02 发表评论

初试Grails和Oracle的配置

ZhouFeng — Thu, 27 Nov 2008 09:45:00 GMT

在听说过Grails很久后,终于开始了自己的Grails之旅,下午弄了一下午的配置,碰到了很多的问题,终于把碰到的问题都搞定了
首先安装好Grails,还有Oracle,这里就不用多说了
Grails 1.0.2
Oracle 9i
JDK 1.5
Groovy 1.5.4
要使用Oracle数据库,则先把classes12.jar放在/grails/lib/目录下,修改配置文件/grails-app/conf/DataSource.groovy

dataSource {
    pooled = false
    driverClassName = "oracle.jdbc.driver.OracleDriver"
    username = "dev"
    password = "dev"
    dialect = org.hibernate.dialect.Oracle9Dialect
    //logSql = true
}

hibernate {
    cache.use_second_level_cache=true
    cache.use_query_cache=true
    cache.provider_class='org.hibernate.cache.EhCacheProvider'
}

注意加上方言:dialect = org.hibernate.dialect.Oracle9Dialect
如果要查看后如的SQL输出,则可以加上logSql = true

development {
        dataSource {
            dbCreate = "create-drop" // one of 'create', 'create-drop','update'
            url = "jdbc:oracle:thin:@localhost:1521:CS"
        }
    }

注意url最后的那个CS是我本机安装的数据库的SID,开始我写成ORCL怎么都连不上,改了之后就OK,在连接好数据库后,就可以把主要的力量放在程序上面了,数据库这部分可以不用操心了,真是帅呀,以前一边要设计数据库,还要修改程序,现在省事多了

grails:\>create-domain-class student
grails:\>create-controller student

修改域/grails-app/domain/Student.groovy为:

class Student {
    String name
    String password

    static constraints = {
        name(blank:false)
    }
}

定义了两个属性,并且name不允许为空
修改控制器/grails-app/controllers/StudentController.groovy为:

class StudentController {
def scaffold = Student
}

修改好了之后,启动服务

grails:\>run-app

OK,能过,太帅气了,省去了很多工作,就写了这么点代码,CRUD操作全都有了,真是个好东东,看来我得多多的学呀
争取:好好学习,天天上网

补充一点:因为本机的端口冲突,我把Grails的端口改了,修改文件%GRAILS_HOME%\grails\scripts\Init.groovy 大概是第(42)行

serverPort = System.getProperty('server.port') ? System.getProperty('server.port').toInteger() : 8000

此处我把服务端口改为8000

ZhouFeng 2008-11-27 17:45 发表评论

在SUSE10.3中使用Samba的一点记录

ZhouFeng — Sun, 02 Nov 2008 06:59:00 GMT

在Control Center中配置好Samba的服务器,在里面可以添加共享的目录和共享名,也可以禁止或允许系统里设置的共享项目
然后建立一个Samba的用户
#useradd suse
为新增的用户suse设置密码
#smbpasswd -a suse
password: ******

配置好了之后便可以在控制台里启动Samba的服务
#/etc/init.d/smb start

在Windows计算机上就可以通过刚设置好的用户名和密码访问了
如果要设置允许Windows用户可以上传文件的话,需要设置共享的目录对Samba用户有可写的权限

ZhouFeng 2008-11-02 14:59 发表评论