轻量级ORM框架DbUtils和OrmLite

  最近在树莓派上部署了一套数据抓取工具,需要将抓取的数据录入到MySQL,特意找了下一些轻量级的ORM框架,这里简单介绍下DbUtils和OrmLite的配置和使用。

1. DbUtils

  Apache旗下的,速度与稳定性不言而喻,但其配置还是有点啰嗦,依赖dbcp连接池。

  地址:http://commons.apache.org/proper/commons-dbutils/

添加pom依赖:

<dependency>
	<groupId>commons-dbutils</groupId>
	<artifactId>commons-dbutils</artifactId>
	<version>1.6</version>
</dependency>
<dependency>
	<groupId>commons-dbcp</groupId>
	<artifactId>commons-dbcp</artifactId>
	<version>1.4</version>
</dependency>

添加dbcp.properties配置文件,放在classpath中:

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://192.168.91.128:3306/db
username=steven
password=steven
initialSize=10
maxActive=50
maxIdle=20
minIdle=5
maxWait=60000
#附带连接属性
connectionProperties=useUnicode=true;characterEncoding=utf8
#自动提交(auto-commit)
defaultAutoCommit=true
#只读(read-only)
defaultReadOnly=
#事务级别(TransactionIsolation)
defaultTransactionIsolation=READ_COMMITTED

新增JdbcUtil.java来加载属性文件

package com.dorole.utils;

import java.io.InputStream;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

import com.mysql.jdbc.Connection;

public class JdbcUtil {
	private static DataSource ds;
	private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

	static {
		try {
			Properties prop = new Properties();
			InputStream in = JdbcUtil.class.getClassLoader()
					.getResourceAsStream("dbcp.properties");
			prop.load(in);
			ds = BasicDataSourceFactory.createDataSource(prop);
		} catch (Exception e) {
			throw new ExceptionInInitializerError(e);
		}
	}

	public static DataSource getDataSource() {
		return ds;
	}

	public static Connection getConnection() throws SQLException {
		try {
			Connection conn = tl.get();
			if (conn == null) {
				conn = (Connection) ds.getConnection();
				tl.set(conn);
			}
			return conn;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

插入数据:

QueryRunner runner = new QueryRunner(JdbcUtil.getDataSource());
String sql = "INSERT INTO `orders` (`storeName`, `telecomNumber`) VALUES (?, ?)";
Object params[] = { order.getStoreName(), order.getTelecomNumber(), };
try {
	runner.update(sql, params);
} catch (SQLException e) {
	e.printStackTrace();
}

2. OrmLite

  这个在Android上用的比较多,结合轻量级的数据库HSQLDB,非常适合嵌入式设备,但这里我们使用MySQL做演示,有意思的是连BaseDao都给封装好了,配置简单,易于使用。

  地址:http://ormlite.com/

添加pom依赖:

<dependency>
	<groupId>com.j256.ormlite</groupId>
	<artifactId>ormlite-jdbc</artifactId>
	<version>4.9</version>
</dependency>

新增OrderDao接口,默认的增删改查已经有了,故可以留空:

package com.dorole.dao;

import com.dorole.model.Order;
import com.j256.ormlite.dao.Dao;

public interface OrderDao extends Dao<Order, Integer> {

}

新增OrderDaoImpl实现类

package com.dorole.dao.impl;

import java.sql.SQLException;

import com.dorole.dao.OrderDao;
import com.dorole.model.Order;
import com.j256.ormlite.dao.BaseDaoImpl;
import com.j256.ormlite.support.ConnectionSource;

public class OrderDaoImpl extends BaseDaoImpl<Order, Integer> implements
		OrderDao {
	public OrderDaoImpl(ConnectionSource connectionSource,
			Class<Order> dataClass) throws SQLException {
		super(connectionSource, dataClass);
	}
}

初始化:

OrderDao orderDao = null;
ConnectionSource connectionSource;
try {
	connectionSource = new JdbcConnectionSource(
			"jdbc:mysql://192.168.91.128:3306/db");
	((JdbcConnectionSource) connectionSource).setUsername("steven");
	((JdbcConnectionSource) connectionSource).setPassword("steven");
	orderDao = new OrderDaoImpl(connectionSource, Order.class);
} catch (SQLException e) {
	e.printStackTrace();
}

插入数据:

try {
	Order order = new Order();
	orderDao.create(order);
} catch (SQLException e) {
	e.printStackTrace();
}

使用Java控制路由器获取公网IP

  不知道是公网IP不够用了,还是什么鬼原因,近期我这的联通ADSL拨号很大程度上获取的是一个10.开头的内网IP。虽说通常情况下无需关心,但跑PT,VPN等速度上大打折扣。投诉无果后只能自己写个脚本来自动更换IP。

  其原理很简单,模拟登录到路由器上检查WANIP是否是10.或0.开头,如是则断开重连,以此循环。代码是Java编写,无任何依赖,运行在树莓派上,24小时监视,在运营商完全分配内网IP之前还可以挣扎一阵子。有需要的朋友可以参考下。

  我这用的是TP-LINK WR720N路由器,设置了局域网IP为192.168.30.1 端口88,通过Chrome登录到路由器,可以在开发者工具中查看到Basic加密的Key,替换相应的位置即可。

查询IP的链接

http://192.168.30.1:88/userRpm/StatusRpm.htm

断开拨号的链接

http://192.168.30.1:88/userRpm/StatusRpm.htm?Disconnect=%B6%CF%20%CF%DF&wan=1

重新拨号的链接

http://192.168.30.1:88/userRpm/StatusRpm.htm?Connect=%C1%AC%20%BD%D3&wan=1

代码如下:

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CheckIP {
	private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
			"yyyy-MM-dd HH:mm:ss");

	public static void main(String[] args) throws Exception {
		do {
			String currentIP = getIP();
			if (currentIP.startsWith("10.") || currentIP.startsWith("0.")) {
				System.out.println(simpleDateFormat.format(new Date())
						+ " 检测到异常:" + currentIP);
				getHtml("http://192.168.30.1:88/userRpm/StatusRpm.htm?Disconnect=%B6%CF%20%CF%DF&wan=1");
				Thread.sleep(1000 * 1);
				getHtml("http://192.168.30.1:88/userRpm/StatusRpm.htm?Connect=%C1%AC%20%BD%D3&wan=1");
				Thread.sleep(1000 * 3);
			}
			Thread.sleep(1000 * 3);
		} while (true);
	}

	private static String getIP() throws Exception {
		String wanPara = getHtml("http://192.168.30.1:88/userRpm/StatusRpm.htm");
		if (null != wanPara) {
			wanPara = wanPara.substring(wanPara.indexOf("var wanPara"),
					wanPara.length());
			wanPara = wanPara.substring(0, wanPara.indexOf(");") + 2);
		}
		return getFirstIp(wanPara);
	}

	private static String getHtml(String address) throws Exception {
		URL url = new URL(address);
		URLConnection connection = url.openConnection();
		connection.setRequestProperty("Authorization", "Basic YWRtaW46d3Npa3Nr");
		connection.connect();
		InputStream inputStream = null;
		StringBuffer stringBuffer = new StringBuffer();
		inputStream = connection.getInputStream();
		BufferedReader bufferedReader = new BufferedReader(
				new InputStreamReader(inputStream));
		String line;
		while ((line = bufferedReader.readLine()) != null) {
			stringBuffer.append(line);
		}
		bufferedReader.close();
		inputStream.close();
		return stringBuffer.toString();
	}

	private static String getFirstIp(String packet) {
		Pattern p = Pattern.compile("\\d+\\.\\d+\\.\\d+\\.\\d+");
		Matcher m = p.matcher(packet);
		if (m.find()) {
			return m.group();
		} else {
			return null;
		}
	}
}

编译

pi@raspberrypi ~ $ javac CheckIP.java

后台运行

pi@raspberrypi ~ $ nohup java CheckIP &

日志

pi@raspberrypi ~ $ tail -f nohup.out 

Java 内存区域分析

  Java虚拟机在执行的过程中会将物理内存划分为几个区域来进行管理,这些区域都有特定用途和生命周期。Java虚拟机规范中提到,有以下6个部分组成:

1:寄存器(PC Register)

  Java虚拟机的多线程是通过轮流切换分配处理器执行时间来实现的,在任何一个时间点上,一个处理器只能执行一个线程中的指令,其余线程中断状态。因此为了记录每个线程当前所执行的指令,每个线程都会拥有一个独立的PC寄存器,用于保存线程执行状态。而且寄存器互不影响,类似这样的内存空间也叫做“线程私有”内存。

  特别的,如果执行的方法是native方法,寄存器是不确定的(undefined),如果是Java方法,寄存器保存的是当前字节码指令地址。PC寄存器的容量至少应当能保存一个 returnAddress 类型的数据或者一个与平台相关的本地指针的值。所以在计算内存使用的时候,这一部分可以忽略不计。

2:虚拟机栈(Java Virtual Machine Stacks)

  虚拟机栈也是线程私有的,与线程生命周期一致,创建的时候分配,终止的时候回收。在内存中以帧的形式存储,用于保存线程的局部变量表,局部计算结果,一个方法开始执行到返回结果,对于栈来说就是一个帧入栈和出栈的过程。其中局部变量表中包含了基本数据类型和引用对象(对象地址指针,字节码地址等等)

  在Java虚拟机规范第一版中,Java虚拟机栈也被直接称作Java栈,这个规范允许要么以固定尺寸来分配空间或者能动态扩展。如果栈大小是固定的,创建栈的时候,每一个Java虚拟机栈大小都可以独立选定。即通过参数决定栈大小或者最大最小值,内存可不要求连续。Java虚拟机的栈可以分配于更底层语言中的堆中。

  Java虚拟机栈上操作会有两个异常需要考虑,一是线程计算请求的栈深度(容量)超过虚拟机所允许的深度,将抛出StackOverflowError异常,如果虚拟机可以动态扩展,并试图扩展,但内存不足了,或者没有足够内存创建新线程的时候,将抛出OutOfMemoryError异常。

3:堆(Heap)

  堆是可供所有线程共享的区域,类实例和数组分配的区域。启动虚拟机的时候创建,堆中存储的对象受自动内存管理(GC),所以无需手动释放。空间分配也可以是固定大小或动态扩展,内存可不要求连续,这点和栈是一样的。如果需求的堆容量超过了自动内存管理能提供的最大容量,也会抛出OutOfMemoryError异常。

4:方法区(Method Area)

  方法区同样是线程共享的区域,有点类似于传统语言的“Text Segment”区。存储了类结构,例如:运行时常量池,字段和方法数据,以及构造函数和普通方法的字节码内容。还包括一些类,实例,接口初始化时用到的特殊方法。特殊方法例如init等等。

  方法区同样在虚拟机启动的时候创建,尽管方法区是堆的逻辑组成中的一部分,不过这个区可以实现垃圾回收,也可以不实现,规范不做强制要求,代码编译管理策略和物理内存分配都不做要求,具体得看虚拟机的实现了。

  当然,如果申请不到足够的内存,也会抛OutOfMemoryError。

5:运行时常量池(Run-Time Constant Pool)

  顾名思义,是每一个类或接口常量表现形式,包括若干种常量:从编译期可知的值到解析运行才知道的值。每一个常量池都保存在方法区中,在类被加载到虚拟机后创建出来。显然,构造常量池不能超过方法区大小,否则抛OutOfMemoryError。

6:本地方法栈(Native Method Stacks)

  这块区域是为Java调用非Java编写的代码而开辟的空间,实际上就是一块传统语言用到的栈。如果虚拟机不支持native方法,自身也不依赖传统栈,可以不分配本地方法栈空间,如果支持,一般都在线程创建的时候分配空间。本地方法栈的大小调整和前面几个一致。分配的栈容量不得超出本地方法栈最大容量,否则抛StackOverflowError异常,无法申请足够的内存扩展栈的话,将抛出OutOfMemoryError异常。

  官方参考:link

Java NIO 的一些细节

  最近项目中折腾到Java的新I/O接口,不得不说这个NIO的实现思路还是很不错的,相比传统的阻塞式I/O,NIO具有非阻塞,高效率。通过抽象出通道,缓冲器的概念来与数据打交道,减少了很多步骤,使用更为便捷。NIO支持文件I/O和网络I/O,高效性主要是设计结构更接近操作系统惯用模型。ByteBuffer作为最核心的东西,内容也十分的多,本文也主要问绕这个类来写。

  ByteBuffer继承自Buffer,Buffer中有四个比较关键的字段或者叫索引(mark, position, limit, capacity)。四个值有这样的关系:0 <= mark <= position <= limit <= capacity private int mark = -1;
  标记,设置一个标记位,调用mark()可以将mark的值设置为position。

private int position = 0;
  位置,当前数据起始位置,调用put()添加数据,position会自增。随时保持最新数据的最后一个字节位置。调用position()可以得到当前position值,position(int)可以设置position的值。

private int limit;
  界限,不能使用的数据位,即指向一段数据流末尾。调用get()方法返回的数据就是在position和limit之间的数据。调用limit()可以获取limit值,limit(int)设置limit值。

private int capacity;
  容量,即该Buffer的大小,分配空间时候决定的,一直指向最后一个数据地址。

字节缓冲区的几个重要方法:
allocate(int):新建一个Buffer,分配指定size的空间。此时position = 0,limit = capacity,mark = null,所有元素将初始化为0。

allocateDirect(int):这个功能如上,比较牛的是与系统耦合性较高,因此速度更快,但是分配开支也会增大,数据位于常规垃圾回收管理之外。

get()/get(int):get()获取当前position的值,并且对position做自增,表示移动到下个位置。get(int)只取出指定位置的数据,不移动指针。

put(byte)/put(int, byte):put(byte)在position位置存入byte,对position做自增,移动到下个位置。put(int, byte)替换int指定位置的值为byte,不移动指针。

flip():在准备取缓冲区内所有数据的时候必须调用一次,进行这些操作:limit = position,position = 0,mark = -1,意味着之前标记将丢失,从0到limit进行遍历即可得到所有数据,写入也时同样的道理。

mark():对缓冲区的位置做标记,进行这个操作:mark = position。一般会配合reset()来使用,前者将当前位置记住,后者将当前位置设置为记住的位置,这有点像录音机中的A-B复读的意思。对于需要取一段特殊数据是有用的。

reset():重置缓冲区的position为先前mark的位置,进行这个操作:position = mark。如果mark < 0会抛InvalidMarkException异常,也就是没有调用mark()之前,不可以reset。 clear():重置缓冲区指针,进行这些操作:position = 0,limit = capacity,mark = -1。这个操作并不会删除实际的数据,但是指针位置被重置了,和flip()接近。

limit()/limit(int):分别是获取limit和设置limit。需要注意的是设置的时候不能超过capacity,不能小于0,如果position > limit,会将position也设置为limit,相当于缩小了范围。如果mark > limit,则mark = -1,作废。

position()/position(int):分别是获取和设置position,设置的时候不得大于limit,不得小于0,如果mark > position,则mark = -1,作废。

rewind():重绕缓冲区,进行这些操作:position = 0,mark = -1。可见也是类似flip(),可以为存取数据做准备,并且使mark作废。

remaining()/hasRemaining():前者得到剩余数,即position – limit的值。后者是判断position是否小于limit,小于返回true,可以用在取数据时判断是否还有数据。

  等等,还有些就不一一介绍了。

struts中使用FormFile文件上传

用贯了spring mvc的注入式文件上传,回到struts中都忘了怎么写,翻了翻老项目,记录下。
struts config中,定义formBean,action中用name指定formBean。

<struts-config>
    <form-beans>
        <form-bean name="fileManagerForm" type="com.dorole.FileManagerForm" />
    </form-beans>
    <action path="..." type="..." parameter="method" name="fileManagerForm">
        <forward name="..." path="..."></forward>
    </action>
</struts-config>

FileManagerForm如下

public class FileManagerForm extends ActionForm {
    private FormFile file;
    public void setFile(FormFile file) {
        this.file = file;
    }
    public FormFile getFile() {
        return file;
    }
}

FileManagerAction如下

public ActionForward upload(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {
        FileManagerForm fmf = (FileManagerForm) form;
        FormFile formFile = fmf.getFile();
        if (formFile.getFileData().length != 0) {
            ...
        }
        return null;
}

jsp如下

<form action="..." method="post" enctype="multipart/form-data">
    <input type="file" name="file" />
    <input type="submit" value="upload" />
</form>