语源科技BlogJava-藏经阁

使用Maven创建项目模板

ZhouFeng — Mon, 24 Jun 2019 02:55:00 GMT

在开发项目的时候，有许多项目结构都是差不多的，使用的框架也一样，spring配置文件也一样的，只是每个项目的名称，包名等不同，如果按照之前的方法，可以拷贝一个项目，然后再做一些修改就好了。这也不是不可以，只是我觉得，应该还有更帅的招，Maven可以使用archetype创建项目，那是否也可以创建自定义结构的项目了，所以就了解了一下通过Maven使用现有项目创建项目模板。尝试了一下，很不错，可以自动处理包名等转换，几个命令就可以生成雷同结构的项目，在此记录一下过程

1 准备好一个现有的项目

既然做为模板项目，里面的配置都是做好了的，是一个可以用的项目，加入了Eclipse支持，项目中包含一些Eclipse配置文件，本例中项目目录为

D:\workspace\myprj

2 创建模板工程

进入项目目录后，运行生成archetype命令

D:\workspace\myprj>mvn archetype:create-from-project

会在myprj目录下生成target目录，其下生成如下目录

classes
generated-sources
generated-test-sources
m2e-wtp
maven-status
surefire-reports
test-classes

模板代码主要位于generated-sources目录中

3 修改模板代码

项目中的所有代码都会自动替换为占位符，除了Eclipse配置文件之外，接下来修改模板，进入target\generated-sources\archetype\src\main\resources\archetype-resources\目录，将Eclipse配置文件也加入占位符，以方便新项目的生成，比如修改下面两个文件，加入占位符artifactId

文件1：.project

#set( $symbol_pound = '#' )
#set( $symbol_dollar = '$' )
#set( $symbol_escape = '\' )
xml version="1.0" encoding="UTF-8"?>
<projectDescription>
        <name>${artifactId}name>
        <comment>comment>
        <projects>
        projects>
        <buildSpec>
                <buildCommand>
                        <name>org.eclipse.jdt.core.javabuildername>
                        <arguments>
                        arguments>
                buildCommand>
                <buildCommand>
                        <name>org.eclipse.wst.common.project.facet.core.buildername>
                        <arguments>
                        arguments>
                buildCommand>
                <buildCommand>
                        <name>org.eclipse.wst.validation.validationbuildername>
                        <arguments>
                        arguments>
                buildCommand>
                <buildCommand>
                        <name>org.eclipse.m2e.core.maven2Buildername>
                        <arguments>
                        arguments>
                buildCommand>
        buildSpec>
        <natures>
                <nature>org.eclipse.jem.workbench.JavaEMFNaturenature>
                <nature>org.eclipse.wst.common.modulecore.ModuleCoreNaturenature>
                <nature>org.eclipse.jdt.core.javanaturenature>
                <nature>org.eclipse.m2e.core.maven2Naturenature>
                <nature>org.eclipse.wst.common.project.facet.core.naturenature>
                <nature>org.eclipse.wst.jsdt.core.jsNaturenature>
        natures>
projectDescription>

文件2：.settings\org.eclipse.wst.common.component

xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
    <wb-module deploy-name="${artifactId}">
        <wb-resource deploy-path="/" source-path="/target/m2e-wtp/web-resources"/>
        <wb-resource deploy-path="/" source-path="/src/main/webapp" tag="defaultRootSource"/>
        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/java"/>
        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/resources"/>
        <property name="context-root" value="${artifactId}"/>
        <property name="java-output-path" value="/${artifactId}/target/classes"/>
    wb-module>
project-modules>

4 修改项目文件列表

配置完成后，通过mvn生成新的项目时，上面的Eclipse配置文件也不会被放入新的工程里，需要在配置文件中加入这些文件的信息，以及标记哪些文件是需要使用占位符替换的，修改target\generated-sources\archetype\src\main\resources\META-INF\maven\archetype-metadata.xml文件，在现有文件中可以看到如下信息

<fileSet filtered="true" encoding="UTF-8">
    <directory>.settingsdirectory>
    <includes>
        <include>**/*.xmlinclude>
    includes>
fileSet>

也就是说，默认情况下，mvn只将.settings目录下的*.xml文件生成到项目中，其中filtered="true"表示需要进行内容过滤替换占位符，我们把需要添加的文件放入此配置，修改后结果如下

<fileSet filtered="true" encoding="UTF-8">
    <directory>.settingsdirectory>
    <includes>
        <include>**/*.xmlinclude>
        <include>**/*.containerinclude>
        <include>**/*.componentinclude>
        <include>**/*.nameinclude>
        <include>**/*.jsdtscopeinclude>
        <include>**/*.prefsinclude>
    includes>
fileSet>
<fileSet filtered="true" encoding="UTF-8">
    <directory>directory>
    <includes>
        <include>.classpathinclude>
        <include>.projectinclude>
    includes>
fileSet>

如果需要过滤掉一些不需要的文件，也可以在此配置。准备好后，就可以安装了

5 将模板项目安装到本地仓库

进入/target/generated-sources/archetype/目录，执行安装

D:\workspace\myprj\target\generated-sources\archetype>mvn install

此命令会在maven仓库中生成archetype-catalog.xml文件，仓库位置取决于maven配置文件settings.xml中的设置，内容如下，可以修改描述信息，方便在创建项目时进行提示

xml version="1.0" encoding="UTF-8"?>
<archetype-catalog xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-catalog/1.0.0 http://maven.apache.org/xsd/archetype-catalog-1.0.0.xsd"
    xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-catalog/1.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <archetypes>
    <archetype>
      <groupId>com.zhoufgroupId>
      <artifactId>myprj-archetypeartifactId>
      <version>0.0.1-SNAPSHOTversion>
      <description>simple project with springmvc and jettydescription>
    archetype>
  archetypes>
archetype-catalog>

6 创建项目测试

执行生成命令

D:\workspace>mvn archetype:generate -DarchetypeCatalog=local

此命令可以在任何目录下执行，会在当前目录生成项目

Choose archetype:
1: local -> com.zhouf:myprj-archetype (simple project with springmvc and jetty)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): : 1
Define value for property 'groupId': com.zhouf
Define value for property 'artifactId': demoprj1
Define value for property 'version' 1.0-SNAPSHOT: :
Define value for property 'package' com.zhouf: :
Confirm properties configuration:
groupId: com.zhouf
artifactId: demoprj1
version: 1.0-SNAPSHOT
package: com.zhouf
Y: :

生成项目demoprj1

7 导入Eclipse运行

将生成的项目导入到Eclipse环境中，直接部署到服务器上跑一个，测试通过，不需要修改配置，帅

如果项目是通过mvn jetty:run运行的，也可以省略中间加入Eclipse配置文件的操作

转自我的简书：https://www.jianshu.com/p/fb5c0e39692f

ZhouFeng 2019-06-24 10:55 发表评论

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

jQuery打印插件printPage

ZhouFeng — Tue, 29 Nov 2016 03:53:00 GMT

摘要: 因最近项目中要用到打印，研究了一些打印方案，考虑过生成PDF再打印的方案，只是客户端需要安装程序，内容输出的控制不太方便，在网上找了一些稍微轻量级的插件来做，项目中有用到jQuery，便尝试了一下printPage打印插件，其它的没有花时间去对比，这个插件能满足需要，对输出内容控制也方便，就是一个HTML页面，也就确定用这个插件了，用法也不是很复杂，在此记录一下需要引入jquery插件，我之前用的... 阅读全文

ZhouFeng 2016-11-29 11:53 发表评论

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

在Tomcat7中添加外部Context

ZhouFeng — Tue, 27 May 2014 02:59:00 GMT

在网上找了两种方法，分别试了一下
其一是修改server.xml，在标签中添加context配置，如下

另一种是在conf\Catalina\localhost目录下添加配置文件，如prj.xml，内容如下

xml version='1.0' encoding='utf-8'?>
<Context
    crossContext="true"
    docBase="D:\eclipse\workspace\prj\WebRoot"
    path="/prj">
Context>

搞定，第二种的话如果不需要了，直接删除文件就是了，不用修改server.xml配置文件，这个我喜欢。
在官网的文档上没找到，还是在网上找的，在些记录一下，以备查

ZhouFeng 2014-05-27 10:59 发表评论