美女与狗交叉动态图片_cptksu3gyzx+0aenirdhphfubaqax1nmrmhbfnwszud0eqhmsq8lgo80bcvm1zholgwhmd4oxwgywdb8bylpbw==_u2snan6de5zpl7ynk7dfqax9uldrwhmcy6fexultvxiafcxuwguuemzbrkm003dwuloxnboln6vvo5sku+ferw==怎么里面的影片放不了
当前位置：jpab217197是真货吗_百度知道
jpab217197是真货吗
我有更好的答案
紫金与黄金及白金不同的是，真品紫金首饰工艺精良,其余还有375，并清晰标有“585”字印和品牌标识,硬度高，同体积重量会轻些纯正的紫金首饰为标号585。消费者要到正规，要有权威部门出具的质量监督检验证书或报告,375的较之稍微逊色、有信誉的商场或专卖店购买。真品紫金首饰放在酸液中不会发生任何化学反应。真品紫金首饰同体积会比其他金属重些，有的品牌会用小小的铅封把标签拴在首饰上。从外观上看,色泽光亮,标号585的含金量为百分之五十八点五,相当于我们的18K,相当于我们所说的24K。赝品紫金首饰没有585和品牌字印等标记
其他类似问题
为您推荐：
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁JAVA实例　十四）泛型_java时间公用跟StringUnitl以及java调用存储过程_OpenJPA (三)__脚本百事通
稍等，加载中……
^_^请注意，有可能下面的2篇文章才是您想要的内容：
JAVA实例　十四）泛型
java时间公用跟StringUnitl以及java调用存储过程
OpenJPA (三)
JAVA实例　十四）泛型
JAVA范例　十四）泛型　　第14章 泛型
　　14.1 泛型基础
　　实例255 一个关于泛型的简单例子
import java.util.D
public class MyFirstGeneric&T& {
T //t的类型是T,现在不能具体确定它的类型，需要到创建对象时才能确定
MyFirstGeneric(T t) {// 创建该类的构造方法为T对象赋值
// 这个方法的返回类型也是T
T getT() {
// 显示T的类型
void printType() {
System.out.println("Type of T is:" + t.getClass().getName());
public static void main(String args[]) {
// 声明一个String类型的Generic变量
MyFirstGeneric&String&
// 创建一个String类型的Generic对象
str = new MyFirstGeneric&String&("这是一个简单的泛型实例");
// 输出它的一些信息
str.printType();
String string = str.getT();
System.out.println("\tstring=" + string);
// 声明一个Date类型的Generic变量
MyFirstGeneric&Date&
// 创建一个Date类型的Generic对象
sobj = new MyFirstGeneric&Date&(new Date());
// 输出它的一些信息
sobj.printType();
String time = sobj.getT().toGMTString();
System.out.println("\ttime=" + time);
　　实例256 带两个类型参数的泛型
public class MoreParameters&T, V& {
// 构造方法也可以使用这两个类型参数
MoreParameters(T t1, V v1) {
// 显示T和V的类型
void printTypes() {
System.out.println("参数T的对象类型为： " + t.getClass().getName());
System.out.println("参数V的对象类型为： " + v.getClass().getName());
T getT() {
V getV() {
public static void main(String args[]) {
MoreParameters&Integer, Double& // 指定类型参数的实际类型
// 构造方法中需要再次指定类型参数，同时还要传递实际参数
tv = new MoreParameters&Integer, Double&(100, 12.56);
tv.printTypes();
int num = tv.getT();
System.out.println("num变量中的值为: " + num);
double dou = tv.getV();
System.out.println("dou变量中的值为:" + dou);
　　实例257 有界类型程序示例
//有界类型程序示例
public class BoundedType {
public static void main(String args[]) {
System.out.println("有界类型程序示例如下：");
Integer inums[] = { 1, 2, 3, 4, 5 };//创建一个Integer类型的数组
MyTypes&Integer& iobj = new MyTypes&Integer&(inums);//使用泛型对象
System.out.println("\tint型数据的求和结果为：" + iobj.summation());
Double dnums[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
MyTypes&Double& dobj = new MyTypes&Double&(dnums);//创建一个Double类型的数
System.out.println("\n\tdouble型数据的求和结果为：" + dobj.summation());
class MyTypes&T extends Number& {
T[]//定义一个Number类的数组
MyTypes(T[] obj) {//为该数组赋值
double summation() {//对参数进行求和运算
double sum = 0.0;
for (int i = 0; i & nums. ++i)
sum += nums[i].doubleValue(); //将Number类数组中的对象转换成double类型并依次相加求和
　　实例258 通配符使用示例
import java.util.*;
//通配符参数使用示例
public class Wildcard {
public static void main(String args[]) {
Integer Ints[] = { 1, 2, 3, 4, 5 };// 定义Integer对象数组并初始化
Symbol&Integer& integer = new Symbol&Integer&(Ints);// 创建Integer泛型对象
Double Dous[] = { 1.1, 2.2, 3.3, 4.4, 5.5 };// 定义Double对象数组并初始化
Symbol&Double& douObject = new Symbol&Double&(Dous);// 创建Double泛型对象
douObject.printMessage(integer); // integer和douObject的类型不相同
List&String& list1 = new ArrayList&String&();// 定义一个List泛型对象，添加的元素是String类型的
// 向List对象中添加元素
list1.add("String");
list1.add("你好");
list1.add("世界真大啊");
List&?& list2 = list1;// 声明一个List列表中元素为任何类型的泛型对象，并将list1赋给list2
System.out.println("列表List对象list2中的元素如下：");
for (int i = 0; i & list2.size(); i++) {
System.out.println("\t" + list2.get(i));// 将list2中的元素输出
class Symbol&T extends Number& {
Symbol(T[] obj) {
void printMessage(Symbol&?& sb) { // 这里使用了类型通配符
System.out.println("对象型参数sb的参数类型是：" + sb.getClass().getName());
　　实例259 泛型方法使用示例
import java.util.D
//泛型方法的使用示例
public class GenericMethod {
// 定义泛型方法，有一个形式参数用类型参数T来定义
public static &T& void genericMethods(T t, char n) {
T t1 = // 局部变量也可以用类型参数T来定义
System.out.println("[1] " + n + "的对象类型为：" + t1.getClass().getName());
public static &T& void genericMethods(T t) {
System.out.println("\n[2] " + t + "的对象类型为：" + t.getClass().getName());
public static void main(String args[]) {
Date date = new Date();
Character k = new Character('A');
// 用两种不同的方法调用泛型方法
GenericMethod.&Character& genericMethods(k, 'B');
genericMethods(date);
　　实例260 泛型接口示例
//泛型接口的使用示例
public class GenericInterface {
public static void main(String args[]) {
Double doubleArrays[] = { 56.5, 58.127, 56.2, 5.569, 825.0, 12.36,
510.89 };// 创建一个Double类型的数组并初始化
Character charArrays[] = { 'A', 'w', 'z', 'Z', 'b', 'u', 'x' };// 创建一个Character类型的数组并初始化
ComparableElement&Double& iob = new ComparableElement&Double&(
doubleArrays);// 创建Double类型的泛型对象
ComparableElement&Character& cob = new ComparableElement&Character&(
charArrays);// 创建Character类型的泛型对象
// 调用MaxOrMin接口中的min()和max()
System.out.println("在Integer数组中，求元素最大值，max= " + iob.max());
System.out.println("在Integer数组中，求元素最小值为，min= " + iob.min());
System.out.println("在Character数组中，求元素最大值，max= " + cob.max());
System.out.println("在Character数组中，求元素最小值为，min=
" + cob.min());
interface MaxOrMin&T extends Comparable&T&& {// 创建一个泛型接口
// 定义两个泛型方法：min()和max()
// 声明一个ComparableElement类继承于Comparable类并实现MaxOrMin接口
class ComparableElement&T extends Comparable&T&& implements MaxOrMin&T& {
ComparableElement(T[] ob) {
public T min() {// 重写MaxOrMin接口中的min()方法，求出数组中的最小值
T t = mm[0];
for (int i = 1; i & mm. ++i)
if (mm[i].compareTo(t) & 0)
t = mm[i];
public T max() {// 重写MaxOrMin接口中的max()方法，求出数组中的最大值
T t = mm[0];
for (int i = 1; i & mm. ++i)
if (mm[i].compareTo(t) & 0)
t = mm[i];
　　实例261 泛型实现坐标打印
* Created by IntelliJ IDEA. User: leizhimin Date:
Time: 16:09:37
* 三种坐标，用泛型实现坐标打印
public class CoorGeneric {
static void showXY(GenericCoords&?& c) {// 定义泛型方法，利用通配符设置参数C的类型为XL并显示类XL中的变量X和Y的值
System.out.println("X Y 坐标轴:");
for (int i = 0; i & c.gcs. i++) {
System.out.println(c.gcs[i].x + "
" + c.gcs[i].y);
static void showXYZ(GenericCoords&? extends XYZ& c) {
System.out.println("X Y Z 坐标轴:");
// 定义泛型方法，利用通配符设置参数C的类型为XYZ并显示类XYZ中的变量X、Y和Z的值
for (int i = 0; i & c.gcs. i++) {
System.out.println(c.gcs[i].x + "
" + c.gcs[i].y + "
+ c.gcs[i].z);
static void showAll(GenericCoords&? extends XYZT& c) {
System.out.println("X Y Z T 坐标轴:");
// 定义泛型方法，利用通配符设置参数C的类型为XYZT并显示类XYZT中的变量X、Y、Z和T的值
for (int i = 0; i & c.gcs. i++) {
System.out.println(c.gcs[i].x + "
" + c.gcs[i].y + "
+ c.gcs[i].z + "
" + c.gcs[i].t);
public static void main(String args[]) {
XY td[] = { new XY(0, 0), new XY(7, 9), new XY(18, 4), new XY(-1, -23) };
GenericCoords&XY& gcd1 = new GenericCoords&XY&(td);
System.out.println("GenericCoords类对象gcd2中的内容：");
showXY(gcd1);
XYZT fd[] = { new XYZT(1, 2, 3, 4), new XYZT(6, 8, 14, 8),
new XYZT(22, 9, 4, 9), new XYZT(3, -2, -23, 17) };
GenericCoords&XYZT& gcd2 = new GenericCoords&XYZT&(fd);
System.out.println("GenericCoords类对象gcd2中的内容：");
showXY(gcd2);
showXYZ(gcd2);
showAll(gcd2);
class XY {// 表示只有XY坐标的类
public XY(int x, int y) {// 为变量X、Y赋值
class XYZ extends XY {// 表示只有XYZ坐标的类
public XYZ(int x, int y, int z) {
super(x, y);// 调用父类的构造方法
class XYZT extends XYZ {// 表示只有XYZT坐标的类，其中X：横坐标，Y：纵坐标 Z：垂直坐标，T：空间
public XYZT(int x, int y, int z, int t) {
super(x, y, z);// 调用父类的构造方法
* 存放泛型坐标的（数据结构）类
class GenericCoords&T extends XY& {// 定义泛型类，设置其参数类型为XY
public GenericCoords(T[] gcs) {
this.gcs =
　　14.2 泛型类的继承
　　实例262 继承泛型类示例
import java.util.D
//继承泛型类
public class GenericClass {
public static void main(String args[]) {
System.out.println("以泛型类为父类的实现方法如下：");
// 创建子类的对象，它需要传递两个参数，Date类型给父类，自己使用String类型
Child&Date, String& cd = new Child&Date, String&(new Date(),
"当前系统的时间为: ");
System.out.print("\t" + cd.getDob());
System.out.println(cd.getOb());
class Child&T, U& extends Father&T& {
public Child(T t1, U u1) {
super(t1); // 传递参数给父类
u = u1; // 为自己的成员赋值
public U getDob() {
class Father&T& { // 定义一个泛型类
public Father(T t) {
public Father() {
public T getOb() {
　　实例263 继承非泛型类示例
//继承非泛型类示例
public class NonGenericcClass {
public static void main(String args[]) {
System.out.println("继承非泛型类的实现方法如下：");
doNonGeneric&String& oa = new doNonGeneric&String&(
"doNonGeneric类的值为: ", 125);
System.out.print("\t" + oa.getOb());
System.out.println(oa.getNum());
class NonGeneric {// 创建父类对象，此类并不是泛型类
public NonGeneric(double n) {// 设置变量num的值等于传入的参数值
public NonGeneric() {// 设置变量num的默认值为0.0
num = 0.0;
public double getNum() {// 返回变量num的当前值
class doNonGeneric&T& extends NonGeneric {// 定义一个继承于NonGeneric的子类。该类被声明为泛型类
public doNonGeneric(T ob, double n) {
super(n);// 将传入的参数值赋给父类
this.ob =// 将对数类型给自己的变量赋值
public T getOb() {
　　实例264 泛型类的类型识别示例
//泛型运行时类型识别 1
public class GenericRTTI {
public static void main(String args[]) {
MyFirstGeneric&Double& dou = new MyFirstGeneric&Double&(100.0);
MyFirstGeneric&String& str = new MyFirstGeneric&String&("hellow");
if (dou instanceof MyFirstGeneric)//判断dou是否是MyFirstGeneric类的实例
System.out
.println("MyFirstGeneric&Integer& object is instance of MyFirstGeneric");
if (dou instanceof MyFirstGeneric&?&)//判断dou是否是MyFirstGeneric&?&泛型类的实例
System.out
.println("MyFirstGeneric&Integer& object is instance of MyFirstGeneric&?&");
if (dou.getClass() == str.getClass())//判断这两个对象运行时的类是否相等
System.out
.println("MyFirstGeneric&Integer& class equals MyFirstGeneric&String& class");
　　实例265 强制类型转换示例
//强制类型转换
public class CastType {
public static void main(String args[]) {
Father&Double& father = new Father&Double&(1.0);
Child&Double, String& child = new Child&Double, String&(200.0, "中国您好");
// 试图将子类对象转换成父类，正确
if ((Father&Double&) child instanceof Father)
System.out.println("子类对象转换成父亲对象.");
// 试图将父类对象转换成子类，错误
if ((Child&Double, String&) father instanceof Child)
System.out.println("父类对象转换成子亲对象.");
} catch (Exception e) {
System.out.println(e);
System.out.println("发生异常的原因：父类对象不能强制转换成子亲对象.");
　　14.3 擦拭
　　实例266 无限界的擦拭
import java.util.D
//有限界的擦拭
public class BorderWipe&T extends Date& {
// 下面所有的T将被String所代替
BorderWipe(T date) {
this.date =
T getOb() {
　　实例267 有限界的擦拭
//无限界的擦拭
public class UnBorderWipe&T& {
// 下面所有的T将被Object所代替
UnBorderWipe(T ob) {
T getOb() {
　　14.4 集合泛型类
　　实例268 Hashtable的泛型化
import java.util.H
//Hashtable的泛型化
public class HashtableGeneric&K, V& {
// 创建Hashtable的泛型类对象
public Hashtable&K, V& hashTable = new Hashtable&K, V&();
// 创建put方法为key和value赋值
public void put(K k, V v) {
hashTable.put(k, v);
// 创建get方法可以根据key值获取value的值
public V get(K k) {
return hashTable.get(k);
public static void main(String args[]) {
HashtableGeneric&String, String& t = new HashtableGeneric&String, String&();
t.put("key", "Java语言");
String s = t.get("key");
System.out.println("根据key值获取的value的内容：\n\t" + s);
　　实例269 多功能画笔
import java.awt.*;
import java.awt.event.*;
import java.util.*;
//多功能画笔
public class Paintbrush extends Frame{
private final static int POINT = 0;
private final static int LINE = 1;
private final static int RECTANGLE = 2;
private final static int OVAL = 3;
// 画笔类型
ArrayList&Point& points = new ArrayList&Point&();
ArrayList&DrawPoint& area = new ArrayList&DrawPoint&();
public Paintbrush(String s) {
public void mainFrame() {
MenuBar menuBar = new MenuBar();
Menu menu = new Menu("菜单");
MenuItem fmi4 = new MenuItem("Exit");
fmi4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
menu.addSeparator();
menu.add(fmi4);
Menu mtype = new Menu("画笔种类");
MenuItem menuItem = new MenuItem("点状");
menuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
type = Paintbrush.POINT;
MenuItem menuItem2 = new MenuItem("线状");
menuItem2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
type = Paintbrush.LINE;
MenuItem dmi3 = new MenuItem("矩形");
dmi3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
type = Paintbrush.RECTANGLE;
MenuItem dmi4 = new MenuItem("圆形");
dmi4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
type = Paintbrush.OVAL;
mtype.add(menuItem);
mtype.add(menuItem2);
mtype.add(dmi3);
mtype.add(dmi4);
menuBar.add(menu);
menuBar.add(mtype);
setMenuBar(menuBar);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent e) {
p1 = new Point(e.getX(), e.getY());
if (type == Paintbrush.POINT) {
points.add(p1);
repaint();
public void mouseReleased(MouseEvent e) {
if (type != Paintbrush.POINT) {
p2 = new Point(e.getX(), e.getY());
area.add(new DrawPoint(p1, p2, type));
repaint();
setBounds(50, 50, 640, 480);
setBackground(Color.WHITE);
setVisible(true);
public void paint(Graphics g) {
Iterator&Point& ip = points.iterator(); // 使用泛型
g.setColor(Color.black);
while (ip.hasNext()) {
Point p = ip.next(); // 使用泛型
g.fillOval(p.x, p.y, 10, 10);
// 起始点坐标
int x1, y1, x2, y2;
for (Iterator&DrawPoint& ipp = area.iterator(); ipp.hasNext();) {
DrawPoint pp = ipp.next();
x1 = (int) pp.startPoint.getX();
y1 = (int) pp.startPoint.getY();
x2 = (int) pp.endPoint.getX();
y2 = (int) pp.endPoint.getY();
switch (pp.type) {
case LINE:
g.setColor(Color.green);
g.drawLine(x1, y1, x2, y2);
case RECTANGLE:
g.setColor(Color.red);
g.drawRect(x1, y1, x2 - x1, y2 - y1);
// 鼠标从右向左或从下往上拖动，不能绘制出图像:负值无意义
case OVAL:
g.setColor(Color.blue);
g.drawOval(x1, y1, x2 - x1, y2 - y1);
public static void main(String[] args) {
Paintbrush drawApp = new Paintbrush("多功能彩色画笔");
drawApp.mainFrame();
class DrawPoint {
public Point startP
public Point endP
public DrawPoint(Point sPoint, Point ePoint, int drawType) {
startPoint = sP
endPoint = eP
type = drawT
java时间公用跟StringUnitl以及java调用存储过程
java时间公用和StringUnitl以及java调用存储过程
构建存储过程的语句信息/**
* 从Function名称和参数信息拼接数据库存储过程访问SQL语句
* {?= call f_conf_qr_queryallconfig(?, ?, ?, ?, ?, ?, ?, ?)}
* @param funcName Function名称
* @param params 参数信息
* @return 数据库存储过程访问SQL语句
String buildRunSql(final String funcName, final Object[][] params)
final StringBuffer buffer = new StringBuffer();
buffer.append(WorkerKeys.LEFT_BRACKET);
//拼接Oracle的function返回值处理
buffer.append(WorkerKeys.WENHAO).append(WorkerKeys.EQUAL_MARK);
buffer.append(WorkerKeys.DB_CALL_MARK).append(funcName);
if (null != params)
//参数部分字符串 (?, ?, ?)
buffer.append(WorkerKeys.LEFT_GUAHAO);
for (int i = 0; i & params. i++)
buffer.append(0 == i ? DaoKeys.EMPTY : MA_BLANK);
buffer.append(WorkerKeys.WENHAO_STR);
buffer.append(WorkerKeys.RIGHT_GUAHAO);
buffer.append(WorkerKeys.RIGHT_BRACKET);
return buffer.toString();
2 调用存储过程信息
String[][] params = new String[][] {
{DaoKeys.IN_STR, DaoKeys.VARCHAR, phoneNumber}, //电话号码
{DaoKeys.IN_STR, DaoKeys.VARCHAR, toneInfo.getTonecode()}, //铃音编码
{DaoKeys.IN_STR, DaoKeys.VARCHAR, toneInfo.getPurchase()}, //订购时间
{DaoKeys.OUT_STR, DaoKeys.INTEGER, DaoKeys.EMPTY}}; //返回码
String runSql = buildRunSql("",params);
CallableStatement callableStatement = Connection.prepareCall(runSql);
callableStatement.execute();
==================================================================
/* * 文 件 名:
TimeUtils.java * 版
Huawei Technologies Co., Ltd. Copyright YYYY-YYYY,
All rights reserved * 描
时间工具类 * 修 改 人:
w * 修改时间:
* 修改版本: COMMON V1.0 * 修改内容: 新增 *
* 修改人：王顺 * 修改内容：新增getDBTimeOnceADay方法 * 修改时间：
*/package mon.import java.text.DateFimport java.text.ParseEimport java.text.ParsePimport java.text.SimpleDateFimport java.util.Cimport java.util.Dimport java.util.Limport mon.constants.TimeKimport mon.system.action.SystemApublic final class TimeUtils{
* 时间正则表达式与格式对应关系
private static final String[][] COM_PATTERNS = new String[][]{
new String[]{TimeKeys.REGEX_YYYY_MM_DD, TimeKeys.YYYY_MM_DD},
new String[]{TimeKeys.REGEX_YYYY_MM_DD_HH_MM_SS, TimeKeys.YYYY_MM_DD_HH_MM_SS},
new String[]{TimeKeys.REGEX_YYYYMMDD, TimeKeys.YYYYMMDD},
new String[]{TimeKeys.REGEX_YYYYMMDDHHMMSS, TimeKeys.YYYYMMDDHHMMSS},
new String[]{TimeKeys.REGEX_HH_MM_SS, TimeKeys.HH_MM_SS}
* 特殊时间正则表达式与格式对应关系
private static final String[][] SPECIAL_PATTERNS = new String[][]{
//调用中音的qryUserTone的时候有些局点返回的时间格式是yyyy.MM.dd
new String[]{TimeKeys.REGEX_YYYY_MM_DD_EX1, TimeKeys.YYYY_MM_DD_EX1}
* 数据库时间获取器
private static final DBTimeGetter DAILY_GETTER = new DBTimeGetter(TimeKeys.DAY_MILLIS);
* 工具类，私有化构造方法
private TimeUtils()
* 对输入时间进行加法操作（因子可以为负数，此时表减法）
* @param inputTime 输入时间
* @param field 加法类型
* 1、Calendar.MONTH 按月份
* 2、Calendar.DATE
* 3、Calendar.MINUTE
* @param amount 增加幅度 负数则为减法
* @return 加法后的时间
public static long addTime(long inputTime, int field, int amount)
//日期方法
final Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date(inputTime));
calendar.add(field, amount);
return calendar.getTimeInMillis();
* 在原有日期上加上指定天数
* @param inputTimeStr 原来日期String型
* @param timePattern 时间格式
* @param field 加法类型
* 1、Calendar.MONTH 按月份
* 2、Calendar.DATE
* 3、Calendar.MINUTE
* @param amount 增加幅度 负数则为减法
* @return date
public static String addTime(String inputTimeStr, String timePattern, int field, int amount)
//获取输入时间的长整型值
long inputT
inputTime = parseTimeInMillis(inputTimeStr, timePattern);
catch (ParseException e1)
//获取时间加减后的值
long addedInputTime = addTime(inputTime, field, amount);
//对时间进行字符串格式化
return formatTime(addedInputTime, timePattern);
* 获取当前时间是否在约定的开始结束时间之间
* @param beginTime 开始时间
* @param endTime 结束时间
* @return 是否在约定时间内
* @throws ParseException 解析异常信息
public static boolean isThisTimeBetween(String beginTime, String endTime) throws ParseException
//时间格式器
final SimpleDateFormat format = new SimpleDateFormat(TimeKeys.HH_MM_SS);
//解析开始结束时间并获取当前时间
final long beginTimeL = format.parse(beginTime).getTime();
final long endTimeL = format.parse(endTime).getTime();
final long thisTimeL = format.parse(format.format(new Date())).getTime();
//返回当前时间是否在两者之间
return (thisTimeL &= beginTimeL) && (thisTimeL &= endTimeL);
* 数据库时间格式转换
* @param inputTime 字符串时间
* @return long型时间
* @throws ParseException 解析异常
public static long parseTimeInMillis(String inputTime) throws ParseException
//默认不支持特殊格式的时间格式
return parseTimeInMillis(inputTime, false);
* 数据库时间格式转换
* @param inputTime 字符串时间
* @param specialPattern 特殊格式
* @return long型时间
* @throws ParseException 解析异常
public static long parseTimeInMillis(String inputTime, boolean specialPattern) throws ParseException
//判断输入时间是否为空，为空直接返回码
if (StringUtils.isBlank(inputTime))
throw new ParseException("Empty param value input!", 0);
//根据输入时间获取格式
String pattern = getTimePattern(inputTime, TimeKeys.HH_MM_SS, specialPattern);
return parseTimeInMillis(inputTime, pattern);
* 格式化字符串时间
* @param inputTime 字符串时间
* @param pattern 格式类型
* @return 格式化后的时间（long型）
* @throws ParseException 格式化异常
public static long parseTimeInMillis(String inputTime, String pattern) throws ParseException
//初始化格式初始工具
final DateFormat dateFormat = new SimpleDateFormat(pattern);
//格式化字符串
final Date inputDate = dateFormat.parse(inputTime);
//格式化字符串
return inputDate.getTime();
* 根据时间值获取时间格式
* @param inputTime 时间的值
* @param defPattern 默认格式
* @param specialPattern 特殊格式
* @return 时间格式
private static String getTimePattern(String inputTime, String defPattern, boolean specialPattern)
//循环列表进行判断处理
int length = COM_PATTERNS.
for (int i = 0; i & i++)
//判断是否匹配正则表达式
if (inputTime.matches(COM_PATTERNS[i][0]))
return COM_PATTERNS[i][1];
//不包括特殊格式则直接返回
if (!specialPattern)
return defP
//循环遍历特殊格式列表
length = SPECIAL_PATTERNS.
for (int i = 0; i & i++)
//判断是否匹配正则表达式
if (inputTime.matches(SPECIAL_PATTERNS[i][0]))
return SPECIAL_PATTERNS[i][1];
//其他情况返回默认值
return defP
* 将Long型时间转换为字符串
* @param inputTime long型时间
* @param pattern 类型
* @return 返回字符串时间
public static String formatTime(long inputTime, String pattern)
//返回格式化后的字符串时间
return new SimpleDateFormat(pattern).format(new Date(inputTime));
* 将某格式字符串类型时间转换为另一个格式字符串
* @param inputTime 字符串型时间
* @param inputPattern 输入时间的格式
* @param outputPattern 输出时间的格式
* @return 返回字符串时间
public static String formatTime(String inputTime, String inputPattern, String outputPattern)
Date date = parseTime0(inputTime, inputPattern);
//返回格式化后的字符串时间
return new SimpleDateFormat(outputPattern).format(date);
* 将日期型时间转换为字符串
* @param date 日期型时间
* @param pattern 类型
* @return 返回字符串时间
public static String formatTime(Date date, String pattern)
//返回格式化后的字符串时间
return new SimpleDateFormat(pattern).format(date);
* 得到当前日期和时间
* @param pattern 格式类型
* @return 当前日期和时间
public static String getJavaThisTime(String pattern)
return new SimpleDateFormat(pattern).format(new Date());
* 获取今天开始时间的毫秒值
* @return 今天开始时间的毫秒值
public static long getJavaTodayStartTime()
//获取JAVA系统当前时间
final Calendar calendar = Calendar.getInstance();
//使用内部方法获取今天的开始时间
return getCalendarDayTopTime(calendar, false).getTimeInMillis();
* 获取今天结束时间的毫秒值
* @return 今天结束时间的毫秒值
public static long getJavaTodayEndTime()
//获取JAVA系统当前时间
final Calendar calendar = Calendar.getInstance();
//使用内部方法获取今天的开始时间
return getCalendarDayTopTime(calendar, true).getTimeInMillis();
* 获取今天开始时间的毫秒值
* @param calendar0 日历对象
* @param isEndDay 是否获取天的结束时间
* @return 返回日历对象一天的开始或结束时间
public static Calendar getCalendarDayTopTime(Calendar calendar0, boolean isEndDay)
//检查日历对象
final Calendar calendar = null == calendar0 ? Calendar.getInstance(Locale.ENGLISH) : calendar0;
//清除当前的小时、分钟、秒 和 毫秒
calendar.set(Calendar.MILLISECOND, 0);//清除毫秒位数字
calendar.set(Calendar.SECOND, 0);//清除秒钟位数字
calendar.set(Calendar.MINUTE, 0);//清除分钟位数字
calendar.set(Calendar.HOUR_OF_DAY, 0);//清除小时位数字
//判断是否为结束时间
if (isEndDay)
//时间向后增加一天
calendar.add(Calendar.DATE, 1);
//退后一天的当天开始时间再减去一毫秒，则为当天的最后时间
calendar.add(Calendar.MILLISECOND, -1);
//返回日历对象
* 得到昨天当前日期和时间
* @param pattern 格式类型
* @return 当前日期和时间
public static String getJavaYesterdayThisTime(String pattern)
//获取系统当前时间
long thisTime = System.currentTimeMillis();
//获取昨天的当前时间
long yesterdayThisTime = addTime(thisTime, Calendar.DATE, -1);
//长整型时间转字符串
return formatTime(yesterdayThisTime, pattern);
* 获取DB时间一天到数据库查询一次
* 时间格式为：yyyyMMddHHmmss
* @return 数据库系统时间
public static String getGoodishDBTimeDaily()
//获取指定格式的数据库时间
return DAILY_GETTER.getFormatedGoodishDBThisTime(TimeKeys.YYYYMMDDHHMMSS);
* 获取DB时间一天到数据库查询一次
* 时间格式为：yyyyMMddHHmmss
* @return 数据库系统时间
public static long getGoodishDBTimeDailyInMillis()
//获取指定格式的数据库时间
return DAILY_GETTER.getGoodishDBThisTime();
* 转换时间格式
* @param inputTime 时间参数
* @param toFormat 目标格式
* @return 目标格式的时间
public static String switchTimeFormat(String inputTime, String toFormat)
//默认不支持特殊格式的时间格式进行检查跳转
return switchTimeFormat(inputTime, toFormat, false);
* 转换时间格式
* @param inputTime 时间参数
* @param toFormat 目标格式
* @param specialPattern 特殊格式
* @return 目标格式的时间
public static String switchTimeFormat(String inputTime, String toFormat, boolean specialPattern)
//判断时间是否为空，为空直接返回
if (StringUtils.isBlank(inputTime) || StringUtils.isBlank(toFormat))
return inputT
//根据输入时间获取格式
String fromFormat = getTimePattern(inputTime, toFormat, specialPattern);
//判断目标格式与当前格式是否一致,则直接返回
if (toFormat.equals(fromFormat))
return inputT
//进行时间格式转换
return switchTimeFormat(inputTime, fromFormat, Locale.getDefault(), toFormat, Locale.getDefault());
* 从一个时间格式转换到另一个时间格式
* @param dateTime
需要改变的时间
* @param fromFormat 原来的时间格式
* @param toFormat 目标时间格式
* @return 将原来的时间格式转换成需要的时间格式字符串
public static String switchTimeFormat(String dateTime, String fromFormat, String toFormat)
//使用默认语言类型进行转换
return switchTimeFormat(dateTime, fromFormat, Locale.getDefault(), toFormat, Locale.getDefault());
* 从一个时间格式转换到另一个时间格式
* @param dateTime
需要改变的时间
* @param fromFormat 原来的时间格式
* @param fromLocale 语言类型
* @param toFormat 目标时间格式
* @param toLocale
* @return 将原来的时间格式转换成需要的时间格式字符串
public static String switchTimeFormat(String dateTime, String fromFormat,
Locale fromLocale, String toFormat, Locale toLocale)
//判断时间参数是否为空，为空直接返回
if (StringUtils.isBlank(dateTime))
return dateT
final DateFormat from = new SimpleDateFormat(fromFormat, fromLocale);
//目的格式
final DateFormat to = new SimpleDateFormat(toFormat, toLocale);
final Date date = from.parse(dateTime);
return to.format(date);
catch (ParseException e)
return dateT
* 检查字符串时间是为指定格式
* @param inputTime 字符串格式的时间
* @param pattern 类型
* @return 是否指定格式的时间
public static boolean validateTimePattern(String inputTime, String pattern)
//初始化格式初始工具
final DateFormat dateFormat = new SimpleDateFormat(pattern);
//设置为强校验
dateFormat.setLenient(false);
//解析字符串时间
dateFormat.parse(inputTime);
catch (ParseException e)
//返回成功
* 检查字符串时间是为指定格式
* @param inputTime 字符串格式的时间
* @param pattern 类型
* @return 是否指定格式的时间
public static boolean validateForceTimePattern(String inputTime, String pattern)
//判断时间内容是否为空
if (StringUtils.isBlank(inputTime) || null == pattern)
//判断字符串长度是否一致
if (inputTime.length() != pattern.length())
//格式校验
return validateTimePattern(inputTime, pattern);
* UTC日期对象与Local日历对象进行跳转
* @param calendar 日历对象
* @param localToUTC 是否本地转UTC
* @return 新的日历对象
private static Calendar switchUTCAndLocal(Calendar calendar, boolean localToUTC)
//获取时区域
int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
int destOffset = calendar.get(Calendar.DST_OFFSET);
//获取偏移量值(小时值)
int hourOffset = (int)((zoneOffset + destOffset) / TimeKeys.HOUR_MILLIS);
//获取现有的小时数值
int curHours = calendar.get(Calendar.HOUR_OF_DAY);
//获取系统新的小时值
int newCurHours = localToUTC ? curHours - hourOffset : curHours + hourO
//更改时间为标准时间
calendar.set(Calendar.HOUR_OF_DAY, newCurHours);
//返回当前日历对象
* 转换UTC至本地日历
* @param utcCalendar UTC日历对象
* @return 本地日历对象
public static Calendar changeUTCToLocal(Calendar utcCalendar)
return null == utcCalendar ? null : switchUTCAndLocal(utcCalendar, false);
* 转换本地至UTC日历
* @param localCalendar 本地 日历对象
* @return UTC日历对象
public static Calendar changeLocalToUTC(Calendar localCalendar)
return null == localCalendar ? null : switchUTCAndLocal(localCalendar, true);
* 获取系统当前UTC日历对象
* @return 系统当前UTC日历对象
public static Calendar getThisUTCCalendar()
//获取本地系统日历对象
Calendar calendar = Calendar.getInstance();
//日历对象转换为UTC
return switchUTCAndLocal(calendar, true);
* 获取格式为yyyy-MM-dd HH:mm:ssUTC当前时间
* @return UTC当前时间
public static String getUTCThisTime()
return getUTCThisTime(TimeKeys.YYYY_MM_DD_HH_MM_SS);
* 获取系统当前时间
* @param pattern 指定格式
* @return 系统当前时间
public static String getUTCThisTime(String pattern)
//日历对象转换为UTC
Calendar calendarUTC = getThisUTCCalendar();
//日历信息转字符串
return formatTime(calendarUTC.getTime(), pattern);
* 将格林威治时间转化成本地时间,返回格式为String
* 格林威治时间+8小时=北京时间
* @param utcTime 传入的格林威治
* @param pattern 输入输出时间格式
* @return 本地时间
public static String changeUTCToLocalString(String utcTime, String pattern)
return changeUTCToLocalString(utcTime, pattern, pattern);
* 将格林威治时间转化成本地时间,返回格式为String
* 格林威治时间+8小时=北京时间
* @param utcTime 传入的格林威治
* @param inputPattern 输入时间格式
* @param outputPattern 输出时间格式
* @return 本地时间
public static String changeUTCToLocalString(String utcTime, String inputPattern, String outputPattern)
//判断输入的UTC字符串是否为空
if (StringUtils.isBlank(utcTime))
//日期显示格式
SimpleDateFormat format = new SimpleDateFormat(inputPattern);
Date utcDate = format.parse(utcTime, new ParsePosition(utcTime.indexOf("")));
//获取日历对象
Calendar utcCalendar = Calendar.getInstance();
utcCalendar.setTime(utcDate);
//获取本地日历对象
Calendar localCalendar = switchUTCAndLocal(utcCalendar, false);
//转换时间为指定格式
return new SimpleDateFormat(outputPattern).format(localCalendar.getTime());
* 将本地时间转化为UTC（格林威治）时间,返回格式为Calendar
* 格林时间+8小时=北京时间
* 说明：该方法不能自行删除，soap接口测试页面再使用
* @param localTime 传入的本地时间
* @param pattern 格式类型
时间 格式yyyy-MM-dd HH:mm:ss
* @return UTC（格林威治）时间
public static Calendar changeToUTCCalendar(String localTime, String pattern)
//判断输入的UTC字符串是否为空
if (StringUtils.isBlank(localTime))
//获取系统当前日历对象
Calendar localCalendar = Calendar.getInstance();
// 日期显示格式
SimpleDateFormat format = new SimpleDateFormat(pattern);
Date localDate = format.parse(localTime, new ParsePosition(localTime.indexOf("")));
//把时间放到日历表中
localCalendar.setTime(localDate);
// 返回UTC时间格式
return switchUTCAndLocal(localCalendar, true);
* 将本地时间转化为UTC（格林威治）时间
* 格林时间+8小时=北京时间
* @param localTime 传入的本地时间 格式yyyy-MM-dd HH:mm:ss
* @param pattern 输入输出时间格式
* @return UTC（格林威治）时间 格式yyyy-MM-dd HH:mm:ss
public static String changeLocalToUTCString(String localTime, String pattern)
return changeLocalToUTCString(localTime, pattern, pattern);
* 将本地时间转化为UTC（格林威治）时间
* 格林时间+8小时=北京时间
* @param localTime 传入的本地时间 格式yyyy-MM-dd HH:mm:ss
* @param inputPattern 输入时间格式
* @param outputPattern 输出时间格式
* @return UTC（格林威治）时间 格式yyyy-MM-dd HH:mm:ss
public static String changeLocalToUTCString(String localTime, String inputPattern, String outputPattern)
Calendar calendar = changeToUTCCalendar(localTime, inputPattern);
//返回UTC时间格式
return new SimpleDateFormat(outputPattern).format(calendar.getTime());
* 将Long型时间转换为字符串
* @param inputTime long型时间
* @param pattern 类型
* @return 返回字符串时间
public static String parseTimeToStr(final long inputTime, final String pattern)
//初始化格式初始工具
final DateFormat dateFormat = new SimpleDateFormat(pattern);
//获取时间对象
final Date date = new Date(inputTime);
//返回格式化后的字符串时间
return dateFormat.format(date);
* 解析事件内部方法
* @param inputTime 输入时间
* @param pattern 格式信息
* @return 返回码对象
private static Date parseTime0(String inputTime, String pattern)
//判断输入时间是否为空
if (StringUtils.isBlank(inputTime))
//初始化指定格式的初始工具
DateFormat dateFormat = new SimpleDateFormat(pattern);
return dateFormat.parse(inputTime);
catch (Exception e)
* 事件比较方法
* @param leftTime 左时间
* @param rightTime 右事件
* @param pattern 时间格式
* @return 整型 -1：（leftTime & rightTime）,0:相等； 1：（leftTime & rightTime）
public static int compareTime(String leftTime, String rightTime, String pattern)
//格式化字符串
Date leftDate = parseTime0(leftTime, pattern);
Date rightDate = parseTime0(rightTime, pattern);
//判断时间对象是否为空
if (null == leftDate || null == rightDate)
return null == leftDate ? ((null == rightDate) ? 0 : -1) : 1;
//使用时间比较方法
pareTo(rightDate);
* 获取本月第一天
* @param pattern 时间格式
* @return 当月第一天
public static String getFirstDayThisMonth(String pattern)
//若格式为空时，赋默认值
if (StringUtils.isBlank(pattern))
pattern = TimeKeys.YYYY_MM_DD;
Calendar calendar = Calendar.getInstance();
//设置当前日期
calendar.setTime(new Date());
//取得当前月的最小日期(天)
int firstDay = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
calendar.set(Calendar.DAY_OF_MONTH, firstDay);
//格式化成字符串
return new SimpleDateFormat(pattern).format(calendar.getTime());
* 获取本月最后一天
* @param pattern 时间格式
* @return 本月最后一天
public static String getLastDayThisMonth(String pattern)
//若格式为空时，赋默认值
if (StringUtils.isBlank(pattern))
pattern = TimeKeys.YYYY_MM_DD;
Calendar calendar = Calendar.getInstance();
//设置当前日期
calendar.setTime(new Date());
//取得当前月的最大日期(天)
int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
calendar.set(Calendar.DAY_OF_MONTH, lastDay);
// 格式化成字符串
return new SimpleDateFormat(pattern).format(calendar.getTime());
* 数据库时间协助类
* @version
[COMMON, ]
public static class DBTimeGetter
* 访问的间隔时间
private final long accessI
* 最近一次访问数据库时间
private long lastAccessT
* JAVA与数据库时间偏差
* &默认构造函数&
* @param accessInterval 访问的间隔时间
public DBTimeGetter(long accessInterval)
this.accessInterval = accessI
this.lastAccessTime = 0;
this.offset = 0;
* 获取数据库时间
* @return 数据库时间
public static long queryDBThisTime()
//定义数据库配置信息
String[] dbSystemP
//定义数据库当前时间对象
long dbThisTime = -1;
//访问数据库获取系统信息
dbSystemParams = SystemActions.queryDBSystemInfo();
//获取时间字符串字段信息
if (null != dbSystemParams && dbSystemParams.length & 0)
//解析时间至长整型
dbThisTime = parseTimeInMillis(dbSystemParams[0], TimeKeys.YYYY_MM_DD_HH_MM_SS);
catch (Exception e)
dbThisTime = -1;
//返回数据库当前时间
return dbThisT
* 获取格式化后的数据库时间
* @param pattern 时间格式
* @return 格式化后的数据库时间
public static String getFormatedDBThisTime(String pattern)
//获取数据库当前时间
long dbThisTime = queryDBThisTime();
if (dbThisTime & 0)
dbThisTime = System.currentTimeMillis();
//格式化时间
return formatTime(dbThisTime, null == pattern ? TimeKeys.YYYY_MM_DD_HH_MM_SS : pattern);
* 获取存在误差的数据库时间
* @return 数据库时间
public long getGoodishDBThisTime()
//获取JAVA当前时间
long javaThisTime = System.currentTimeMillis();
//定义数据库当前时间
long dbThisT
//仅当间隔时间大于0，则进行误差时间获取
if (this.accessInterval &= 0)
dbThisTime = queryDBThisTime();
return dbThisTime & 0 ? javaThisTime : dbThisT
//判断当前时间是否满足更新条件
if (lastAccessTime + accessInterval &= javaThisTime)
//获取数据库时间
synchronized (this)
if (lastAccessTime + accessInterval &= javaThisTime)
this.lastAccessTime = javaThisT
//获取数据库时间
dbThisTime = queryDBThisTime();
if (dbThisTime & 0)
dbThisTime = javaThisT
//获取时间误差值
this.offset = dbThisTime - javaThisT
//获取数据库当前时间
return javaThisTime + this.
* 获取带误差数据库时间的格式化字符串
* @param pattern 格式字符串
* @return 格式化后的字符串
public String getFormatedGoodishDBThisTime(String pattern)
//获取带误差的数据库时间
long goodishDBThisTime = getGoodishDBThisTime();
//格式化时间至字符串
return formatTime(goodishDBThisTime, null == pattern ? TimeKeys.YYYY_MM_DD_HH_MM_SS : pattern);
* 获取以毫秒的形式获取UTC当前时间
* @return 以毫秒的形式的UTC当前时间
public static long getUTCTimeInMillis()
//1、取得本地时间
Calendar calendar = Calendar.getInstance();
//2、取得时间偏移量
int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
//3、取得夏令时差
int dstOffset = calendar.get(Calendar.DST_OFFSET);
//4、从本地时间里扣除这些差量，即可以取得UTC时间
calendar.add(Calendar.MILLISECOND, -(zoneOffset + dstOffset));
return calendar.getTimeInMillis();
}}=====================================================================================================public final class TimeKeys{
//**************************************************************************************/
* 一秒钟大小
public static final long SECOND_MILLIS = 1000;
* 一分钟大小
public static final long MINUTE_MILLIS = 60 * SECOND_MILLIS;
* 一小时大小
public static final long HOUR_MILLIS = 60 * MINUTE_MILLIS;
* 一天大小
public static final long DAY_MILLIS = 24 * HOUR_MILLIS;
* 半小时大小
public static final long HALF_HOUR_MILLIS = 30 * MINUTE_MILLIS;
//**************************************************************************************/
//**************************************************************************************/
* 时间格式1：yyyy-MM-dd HH:mm:ss.SSS
public static final String YYYY_MM_DD_HH_MM_SS_SSS = "yyyy-MM-dd HH:mm:ss.SSS";
* 时间格式2： yyyy-MM-dd HH:mm:ss
public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
* 时间格式3： yyyyMMddHHmmss
public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
* 时间格式4： yyyy-MM-dd
public static final String YYYY_MM_DD = "yyyy-MM-dd";
* 时间格式5： yyyyMMdd
public static final String YYYYMMDD = "yyyyMMdd";
* 时间格式6： HH:mm:ss
public static final String HH_MM_SS = "HH:mm:ss";
* 时间格式7：MMddHHmm
public static final String MMDDHHMM = "MMddHHmm";
* 时间格式8： HHmmss
public static final String HHMMSS = "HHmmss";
* 时间格式：HHmmssSSS
public static final String HHMMSSSSS = "HHmmssSSS";
* 时间格式9：yyMMddHHmmssSSS
public static final String YYYYMMDDHHMMSSSSS = "yyyyMMddHHmmssSSS";
* 全时间格式10： yyyy-MM-dd HH:mm:ss.SSS a Z E D w
public static final String YYYY_MM_DD_HH_MM_SS_FULL = "yyyy-MM-dd HH:mm:ss.SSS a Z E D w";
* 时间格式11： yyyy.MM.dd
public static final String YYYY_MM_DD_EX1 = "yyyy.MM.dd";
* JSON时间格式
public static final String YYYY_MM_DD_T_HH_MM_SS = "yyyy-MM-dd'T'HH:mm:ss";
public static final String YYYY = "yyyy";
public static final String MM = "MM";
public static final String DD = "dd";
public static final String HH = "HH";
public static final String MM_S = "mm";
public static final String SS = "ss";
public static final String YYYYW = "yyyyw";
public static final String YYYY_W = "yyyy w";
//**************************************************************************************/
//**************************************************************************************/
* 日期时间
public static final String REGEX_YYYY_MM_DD = "\\d{4}-\\d{1,2}-\\d{1,2}";
* 日期时间
public static final String REGEX_YYYY_MM_DD_HH_MM_SS =
"\\d{4}-\\d{1,2}-\\d{1,2} ([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]";
* 日期时间
public static final String REGEX_YYYYMMDD = "\\d{4}\\d{1,2}\\d{1,2}";
* 日期时间
public static final String REGEX_YYYYMMDDHHMMSS = "\\d{4}\\d{1,2}\\d{1,2}([01][0-9]|2[0-3])[0-5][0-9][0-5][0-9]";
* 时间格式
public static final String REGEX_HH_MM_SS = "([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]";
* 时间格式
public static final String REGEX_YYYY_MM_DD_EX1 = "\\d{4}\\.\\d{1,2}\\.\\d{1,2}";
* 常理类，私有化构造方法
private TimeKeys()
}}======================================================================================public final class StringUtils{
* 空字符串
public static final String EMPTY = "";
* 私有构造方法
private StringUtils()
* 是否为空串(判断是否为null 或 "")
* isEmpty(null)
* isEmpty("")
* isEmpty("
* @param value 输入的字符串
* @return 是否为空串
public static boolean isEmpty(String value)
return null == value || 0 == value.length();
* 是否为空格串(判断是否为null 、"" 或 "
* isBlank(null)
* isBlank("")
* isBlank("
* @param value 输入的字符串
* @return 是否为空格串
public static boolean isBlank(String value)
//是否为空串，如果为空串直接返回
return null == value || 0 == value.length() || EMPTY.equals(value.trim());
* 字符串是否为非空
* @param value 输入的字符串
* @return 是否为非空格串
public static boolean isNoBlank(String value)
return !isBlank(value);
* trim字符串操作（如果字符串为空，则返回传入的默认值）
* @param value 需要处理的字符串
* @param defValue 默认值字符串
* @return 处理后的字符串
public static String defaultIfBlank(String value, String defValue)
//是否为空格字符串
if (isBlank(value))
return defV
//将结果进行trim操作
return value.trim();
* 字符串为空则使用默认字符串
* @param value 需要处理的字符串
* @param defValue 默认值字符串
* @return 处理后的字符串
public static String defaultIfNull(String value, String defValue)
//是否为空格字符串
return null == value ? defValue : value.trim();
* 字符串清理
* @param value 需要处理的字符串
* @return 清理后的字符串
public static String emptyIfBlank(String value)
return null == value ? EMPTY : value.trim();
* 正则匹配字符串
* @param value 待处理的字符串
* @param regex 正则表达式
* @return 是否不匹配
public static boolean noMatches(String value, String regex)
return !matches(value, regex);
* 正则匹配字符串
* @param value 待处理的字符串
* @param regex 正则表达式
* @return 是否匹配
public static boolean matches(String value, String regex)
//如果校验字符为空
if ((null == value) || (null == regex))
//非空的话进行匹配
return value.matches(regex);
* 先对输入字符串进行trim操作再进行正则匹配字符串
* @param value 待处理的字符串
* @param regex 正则表达式
* @return 是否匹配
public static boolean trimAndmatches(String value, String regex)
//如果校验字符为空
if ((null == value) || (null == regex))
//非空的话进行匹配
return value.trim().matches(regex);
* 字符串trim并转小写
* @param value 待处理的字符串
* @return 转小写后字符串
public static String trimAndLowerCase(String value)
return emptyIfBlank(value).toLowerCase(Locale.getDefault());
* 字符串trim并转大写
* @param value 待处理的字符串
* @return 转大写后字符串
public static String trimAndUpperCase(String value)
return emptyIfBlank(value).toUpperCase(Locale.getDefault());
* ToString方法
* @param object 对象
* @return 描述信息
public static String trimAndToString(Object object)
return null == object ? EMPTY : object.toString().trim();
* 构建固定长度的字符串
* @param input 输入字符串
* @param length 长度
* @param filledChar 前补充字符
* @param fillHead 是头填充还是尾填充
* @return 固定长度后的字符串
public static String buildFixedLength(String input, int length, char filledChar, boolean fillHead)
//获取格式化后的字符串
String inputTrimed = emptyIfBlank(input);
//判断字符串位数与固定长度数目关系，如果字符串位数大于要求固定长度，则直接返回
if (inputTrimed.length() &= length)
return inputT
//获取需要拼接的字节数组信息
int filledLength = length - inputTrimed.length();
char[] chars = new char[filledLength];
//使用待填充字符对填充字符数组进行填充
for (int i = 0; i & filledL i++)
chars[i] = filledC
//根据头填充还是尾填充返回结果
return fillHead ? new String(chars) + inputTrimed : inputTrimed + new String(chars);
* 构建固定长度的字符串
* @param sequenceValue 序列值
* @param pattern 字符串格式
* @return 固定长度的序列字符串
public static String buildFixedLength(long sequenceValue, String pattern)
//获取格式化的格式字符串信息
String newPattern = StringUtils.emptyIfBlank(pattern);
//使用字符串格式化进行格式化
DecimalFormat decimalFormat = new DecimalFormat(newPattern);
//返回格式化字符串
return decimalFormat.format(sequenceValue);
* 判断是否为中文字符
* @param charValue 字符值
* @return 是否为中文字符
public static boolean isChineseChar(char charValue)
//获取字符对象
Character.UnicodeBlock unicodeBlock = Character.UnicodeBlock.of(charValue);
//返回中文字符
return unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
|| unicodeBlock == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| unicodeBlock == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
|| unicodeBlock == Character.UnicodeBlock.GENERAL_PUNCTUATION
|| unicodeBlock == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
|| unicodeBlock == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS;
* 获取字符串的字节长度
* @param value 字符串
* @return 字符串的字节长度：一个汉字的字节长度为2
public static int getStringByteLength(String value)
//判断取值是否为空
return null == value ? 0 : value.getBytes().
* 字符串剔除特殊字符
* @param input 输入字符串
* @param rejectChar 剔除字符
* @return 剔除后的字符串
public static String rejectHeadSpecialChar(String input, char rejectChar)
//判断输入字符串是否为空，为空则直接返回空
if (StringUtils.isBlank(input))
return StringUtils.EMPTY;
//获取前后trim的字符串
String inputTrim = input.trim();
//获取输入字符串长度信息
int inputTrimLength = inputTrim.length();
//初始化特殊字符串标记位
int index = 0;
//循环检查字符
for (; index & inputTrimL index++)
//判断是否不等于特殊字符串，如果是则推出
if (rejectChar != inputTrim.charAt(index))
//截取配置固定长度信息
return inputTrim.substring(index, inputTrimLength);
OpenJPA (三)
OpenJPA (3)4 EntityManagerFactory
4．1 Overview
EntityManagerFactory可以被注入到应用中，也可以通过以下方式创建：
EntityManagerFactory emf = Persistence.createEntityManagerFactory("openjpa");
Persistence.createEntityManagerFactory方法通过在类路径上查找META-INF目录中的persistence.xml文件来获得EntityManagerFactory的配置，persistence.xml文件中可以定义多个persistence-unit。其name属性值可以作为Persistence.createEntityManagerFactory方法的参数，transaction-type用来指定是使用JTA，还是使用局部事务。以下是个persistence.xml文件的例子：
&?xml version="1.0"?&
&persistence&
&persistence-unit name="openjpa" transaction-type="RESOURCE_LOCAL" &
&provider&org.apache.openjpa.persistence.PersistenceProviderImpl&/provider&
&class&tutorial.Animal&/class&
&class&tutorial.Dog&/class&
&class&tutorial.Rabbit&/class&
&class&tutorial.Snake&/class&
&properties&
&property name="openjpa.ConnectionURL" value="jdbc:hsqldb:tutorial_database"/&
&property name="openjpa.ConnectionDriverName" value="org.hsqldb.jdbcDriver"/&
&property name="openjpa.ConnectionUserName" value="sa"/&
&property name="openjpa.ConnectionPassword" value=""/&
&property name="openjpa.Log" value="DefaultLevel=WARN, Tool=INFO"/&
&/properties&
&/persistence-unit&
&/persistence&
EntityManagerFactory 实例是重量级对象。每个EntityManagerFactory 实例可能要维护metadata cache、object state cache、EntityManager pool、connection pool等等资源。如果应用程序不再使用EntityManagerFactory，那么应该及时关闭它以便释放资源。如果在一个或多个EntityManager处于活跃状态时试图关闭EntityManagerFactory，那么会导致一个IllegalStateException。
4．2 Persistence Context
Persistence context包含一组entities，这些entities都有唯一的persistent identity。在persistence context中，EntityManager管理entities的生命周期，entities可以访问datastore来获取persistent state。当persistence context结束的时候，被EntityManager管理的所有entities都变成detached状态。Detached entities不再被EntityManager管理，也不能访问datastore。有两种类型的persistent context：transaction persistence context和extended persistence context。
4．2．1 Transaction Persistence Context
在transaction persistence context模型中，EntityManager为每一个事务开始一个新的persistence context。当事务被提交或者回滚后，persistence context也就自动结束，被EntityManager管理的所有entity都变成detached状态。此时如果访问entity上尚未被加载的字段（例如lazy fetch字段）会导致没有定义的结果。
如果不在事务中通过EntityManager访问datastore，那么EntityManager会对每一次方法调用都创建一个新的persistence context。当方法调用结束时，persistence context也自动结束。例如当在事务之外调用EntityManager.find方法，EntityManager会创建一个临时的persistence context，并在这个临时的persistence context中访问datastore。当EntityManager.find方法结束时，临时的persistence context自动结束，并且EntityManager.find方法会返回一个detached entity。如果用相同的identity object再次调用EntityManager.find方法，那么会得到一个新的detached entity。以下是个描述transaction persistence context模型的行为的例子：
EntityM // injected
// outside a transaction:
// each operation occurs in a separate persistence context, and returns
// a new detached instance
Magazine mag1 = em.find(Magazine.class, magId);
Magazine mag2 = em.find(Magazine.class, magId);
assertTrue(mag2 != mag1);
// transaction begins:
// within a transaction, a subsequent lookup doesn't return any of the
// detached objects.
however, two lookups within the same transaction
// return the same instance, because the persistence context spans the
// transaction
Magazine mag3 = em.find(Magazine.class, magId);
assertTrue(mag3 != mag1 && mag3 != mag2);
Magazine mag4 = em.find(Magazine.class (magId);
assertTrue(mag4 == mag3);
// transaction commits:
// once again, each operation returns a new instance
Magazine mag5 = em.find(Magazine.class, magId);
assertTrue(mag5 != mag3);
4．2．2 Extended Persistence Context
在extended persistence context模型中，不论是否在事务内，EntityManager在其整个生命周期内维护相同一个persistence context。所有通过EntityManager得到的entities都被EntityManager管理，只有在EntityManager被关闭，或者entity被序列化的时候，entity才变成detached状态。
以下是个描述extended persistence context模型的行为的例子：
EntityManagerFactory emf = ...
EntityManager em = emf.createEntityManager();
// persistence context active for entire life of EM, so only one entity
// for a given persistent identity
Magazine mag1 = em.find(Magazine.class, magId);
Magazine mag2 = em.find(Magazine.class, magId);
assertTrue(mag2 == mag1);
em.getTransaction().begin();
// same persistence context active within the transaction
Magazine mag3 = em.find(Magazine.class, magId);
assertTrue(mag3 == mag1);
Magazine mag4 = em.find(Magazine.class (magId);
assertTrue(mag4 == mag1);
// when the transaction commits, instance still managed
Magazine mag5 = em.find(Magazine.class, magId);
assertTrue(mag5 == mag1);
// instance finally becomes detached when EM closes
em.close();
5 EntityManager
EntityManager接口的方法可以大致分为以下几类。
5．1 Transaction Association
public EntityTransaction getTransaction ();
EntityManager实例和EntityTransaction实例之间是一对一的关系。 通过getTransaction方法可以得到与EntityManager关联的EntityTransaction实例。
5．2 Entity Identity Management
EntityManager负责管理entities，以下的这些方法的行为会因persistence context（transaction persistence context或者extended persistence context）的不同而有差异。
public &T& T find(Class&T& cls, Object oid);
find方法返回persistent identity指定的entity。 如果这个entity存在于当前的persistence context中，那么返回值是被缓存的对象；否则会创建一个新的entity，并从datastore中加载相关的persistent state。如果datastore不存在持有指定persistent identity的记录，那么这个方法返回null。
public &T& T getReference(Class&T& cls, Object oid);
getReference方法与find相似。不同的是：如果缓存中没有指定的entity，EntityManager会创建一个新的entity，不是立即访问datastore（不加载persistent state），而是在第一次访问某个持久字段的时候才加载相应的persistent state。此外，getReference 方法不返回null，如果在datastore中找不到相应的entity，这个方法会抛出EntityNotFoundException。
public boolean contains(Object entity);
如果当前的persistence context 包含指定的entity，那么返回true；否则返回false。
5．3 Cache Management
public void flush();
Flush方法把当前事务中所有的修改写入到datastore中。如果EntityManager没有连接到datastore，那么EntityManager首先会获取一个连接并一直持有到事务结束。Flush方法抛出的任何异常都会导致事务回滚。如果调用flush方法时没有一个活跃的事务，那么flush方法会抛出TransactionRequiredException。
public FlushModeType getFlushMode();
public void setFlushMode(FlushModeType flushMode);
EntityManager的FlushMode 属性用来指定是否在执行query之前进行flush。这可以确保当前事务中的任何修改会体现在query的结果中。此外也可以在query实例上设置FlushMode。它有以下两个可选值：
COMMIT: 只是在事务提交的时候flush。当前事务中的修改可能不会体现在query的结果中。
AUTO: 在需要的时候进行flush以确保当前事务中的任何修改都会体现在query的结果中。
OpenJPA 只在当前事务的任何修改可能会影响到将要执行的query的结果时才进行flush。
public void clear();
Clear方法会结束当前的persistence context，被EntityManager管理的所有entities变成detached状态。
5．4 Query Factory
public Query createQuery(String query);
createQuery方法根据提供的Java Persistence Query Language (JPQL) string来创建一个query。
public Query createNamedQuery(String name);
createNamedQuery方法用来得到通过metadata定义的命名query。
public Query createNativeQuery(String sql);
public Query createNativeQuery(String sql, Class resultCls);
public Query createNativeQuery(String sql, String resultMapping);
以上方法用来创建datastore特有的native queries。例如在关系型数据库中使用的Structured Query Language (SQL)。
5．5 Closing
public boolean isOpen();
public void close();
当不再使用EntityManager 的时候，需要及时关闭它以便释放资源。如果EntityManager 已经关闭，那么除了调用isOpen 方法外，调用EntityManager上的其它方法会导致IllegalStateException。不能在一个事务正在进行中的时候关闭EntityManager。
5．6 Entity Lifecycle Management
5．6．1 public void persist(Object entity);
persist方法用于将新创建的entity纳入EntityManager的管理，在下一次的flush或者commit时，这个entity会被插入到datastore中。这个方法只能在一个活跃的事务环境中调用。它的行为如下：
如果是新entity，那么它会被EntityManager管理。
如果这个entity已经被EntityManager管理，那么会被忽略。
如果这个entity之前被remove，那么它会重新被管理。
如果这个entity的状态是detached，那么会导致IllegalArgumentException。
以下是个简单的例子：
import java.util.I
import java.util.L
import javax.persistence.B
import javax.persistence.CascadeT
import javax.persistence.E
import javax.persistence.FetchT
import javax.persistence.Id;
import javax.persistence.OneToM
import org.apache.openjpa.persistence.FetchA
import org.apache.openjpa.persistence.FetchG
import org.apache.openjpa.persistence.FetchG
@FetchGroups({
@FetchGroup(name="detail", attributes={
@FetchAttribute(name="grade"),
@FetchAttribute(name="magazines")
public class Publisher {
private List&Magazine&
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("id: " + getId());
sb.append(", name: " + getName());
sb.append(", grade: " + getGrade());
sb.append(", magazines[");
if(getMagazines() != null) {
for(Iterator&Magazine& iter = getMagazines().iterator(); iter.hasNext(); )
sb.append(iter.next().toString());
if(iter.hasNext()) {
sb.append("; ");
sb.append("]");
return sb.toString();
public int getId() {
public void setId(int id) {
public String getName() {
public void setName(String name) {
this.name =
@Basic(fetch=FetchType.LAZY)
public String getGrade() {
public void setGrade(String grade) {
this.grade =
@OneToMany(mappedBy="publisher", cascade=CascadeType.ALL, fetch=FetchType.LAZY)
public List&Magazine& getMagazines() {
public void setMagazines(List&Magazine& magazines) {
this.magazines =
import javax.persistence.CascadeT
import javax.persistence.E
import javax.persistence.Id;
import javax.persistence.IdC
import javax.persistence.JoinC
import javax.persistence.ManyToO
@IdClass(Magazine.MagazineId.class)
public class Magazine {
@ManyToOne(cascade=CascadeType.ALL)
@JoinColumn(name = "publisherId", referencedColumnName = "id")
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("isbn: " + isbn);
sb.append(", title: " + title);
return sb.toString();
public String getIsbn() {
public void setIsbn(String isbn) {
this.isbn =
public String getTitle() {
public void setTitle(String title) {
this.title =
public Publisher getPublisher() {
public void setPublisher(Publisher publisher) {
this.publisher =
public static class MagazineId {
public MagazineId() {
public MagazineId(String isbn, String title) {
this.isbn =
this.title =
public boolean equals(Object obj) {
if(this == obj) {
if(!(obj instanceof MagazineId)) {
MagazineId rhs = (MagazineId)
boolean b1 = (isbn == rhs.isbn || (isbn != null && isbn.equals(rhs.isbn)));
boolean b2 = (title == rhs.title || (title != null && title.equals(rhs.title)));
return b1 && b2;
public int hashCode(){
int h1 = (isbn == null ? 0 : isbn.hashCode());
int h2 = (title == null ? 0 : title.hashCode());
return h1 ^ h2;
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("isbn: " + isbn);
sb.append(", title: " + title);
return sb.toString();
Publisher p1 = new Publisher();
p1.setId(id);
p1.setName("publisher1");
p1.setGrade("excellent");
p1.setMagazines(new ArrayList&Magazine&());
Magazine m1 = new Magazine();
m1.setIsbn("isbn1");
m1.setTitle("title1");
m1.setPublisher(p1);
p1.getMagazines().add(m1);
Magazine m2 = new Magazine();
m2.setIsbn("isbn2");
m2.setTitle("title2");
m2.setPublisher(p1);
p1.getMagazines().add(m2);
EntityManagerem = entityManagerFactory.createEntityManager();
em.getTransaction().begin();
em.persist(p1);
em.getTransaction().commit();
5．6．2 public void remove(Object entity);
remove方法用于删除被管理的entity。在下一次的flush或者commit时，这个entity会从datastore中删除。这个方法只能在一个活跃的事务环境中调用。它的行为如下：
如果是新entity，那么会被忽略。
如果是已经被管理的entity，那么它会被删除。
如果这个entity之前被remove，那么会被忽略。
如果这个entity的状态是detached，那么会导致IllegalArgumentException。
5．6．3 public void refresh(Object entity);
refresh方法用于确保entity的persistent state和datastore中的persistent state同步。它的行为如下：
如果是新entity，那么会被忽略。
如果是已经被管理的entity，那么刷新它的persistent state。
如果这个entity之前被remove，那么会被忽略。
如果这个entity的状态是detached，那么会导致IllegalArgumentException。
5．6．4 public Object merge(Object entity);
有些情况下，你需要编辑一个处于detached状态的entity，然后重新将这个entity纳入到EntityManager的管理中，并将对其persistent state的修改更新到datastore中。Merge方法返回该entity受管理的一份拷贝。这个方法只能在一个活跃的事务环境中调用。它的行为如下：
如果是新entity，那么会创建该entity的一份拷贝，并将这份拷贝纳入EntityManager的管理。
如果是已经被管理的entity，那么会被忽略。
如果这个entity之前被remove，那么会导致IllegalArgumentException。
如果这个entity的状态是detached，如果EntityManager中已经管理了具有相同的identity的entity B，那么会将原始entity的persistent state拷贝到entity B中；否则会创建该entity的一份拷贝，并将这份拷贝纳入EntityManager的管理。
以下是个简单的例子：
p1.setName("publisher2");
EntityManager em = entityManagerFactory.createEntityManager();
em.getTransaction().begin();
em.merge(obj);
em.getTransaction().commit();
5．6．5 public void lock (Object entity, LockModeType mode);
lock方法通过指定的LockModeType 来对entity加锁。LockModeType 有以下两个可选值：
READ: 在其它事务中可以读取，但是不能更新。
WRITE: 在其它事务中不可以读取或更新。在当前事务提交后，无论被WRITE lock锁定的entities是否改变，其version将会自动增加。
5．6．6 Detach and Attach
除了JPA定义的detach和attach API之外，OpenJPA还支持更多的特性。例如OpenJPAEntityManager提供以下方法：
public Object detach(Object pc);
public Object[] detachAll(Object... pcs);
public Collection detachAll(Collection pcs);
以上的detach方法返回给定entity的detached状态的拷贝。在detach在当前事务中被修改过的entity之前，flush方法会被调用，以便将这些修改保存到datastore中。由于detached entity不能访问datastore，因此有时候需要在detach之前加载一些persistent state（例如某些lazy fetch字段）。尽管可以通过手工编码完成，OpenJPA也提供了一些特性来自动完成类似的工作。例如DetachState，它有以下可选值：
loaded: 保持已经加载的字段，对于没有加载的字段则保持不变。这是缺省值。
fetch-groups: 根据fetch group来决定需要加载的字段。
all: 加载所有的字段。
继续5．6．1中的例子：
EntityManager em = entityManagerFactory.createEntityManager();
Publisher p2 = (Publisher)em.find(Publisher.class, id);
em.close();
System.out.println(p2.toString());
以上例子中p2在em.close()之后变成detached状态。由于采用了缺省的DetachState，因此没有加载lazy fetch字段grade和magazines。输出如下：
id: 1, name: publisher1, grade: null, magazines[]
em = entityManagerFactory.createEntityManager();
Publisher p4 = (Publisher)em.find(Publisher.class, id);
p4.getGrade();
p4.getMagazines();
em.close();
System.out.println(p4.toString());
以上例子中p4在em.close()之后变成detached状态。虽然采用了缺省的DetachState，但是由于程序中显式访问了lazy fetch字段，所以grade和magazines被加载，并且在detach之后仍然可以访问。输出如下：
id: 1, name: publisher1, grade: excellent, magazines[isbn: isbn1, title: title1; isbn: isbn2, title: title2]
em = entityManagerFactory.createEntityManager();
((OpenJPAEntityManager)em).setDetachState(DetachStateType.ALL);
Publisher p5 = (Publisher)em.find(Publisher.class, id);
em.close();
System.out.println(p5.toString());
以上例子中p5在em.close()之后变成detached状态。由于采用了 DetachStateType.ALL，因此所有的lazy fetch字段在detach之前都自动被加载，并且在detach之后仍然可以访问。输出如下：
id: 1, name: publisher1, grade: excellent, magazines[isbn: isbn1, title: title1; isbn: isbn2, title: title2]
em = entityManagerFactory.createEntityManager();
((OpenJPAEntityManager)em).setDetachState(DetachStateType.FETCH_GROUPS);
((OpenJPAEntityManager)em).getFetchPlan().addFetchGroup("detail");
Publisher p6 = (Publisher)em.find(Publisher.class, id);
em.close();
System.out.println(p6.toString());
以上例子中p6在em.close()之后变成detached状态。由于采用了 DetachStateType. FETCH_GROUPS，而Publisher中名为"detail"的fetch group定义了要额外加载grade和magazines，因此grade和magazines被加载，并且在detach之后仍然可以访问。输出如下：
id: 1, name: publisher1, grade: excellent, magazines[isbn: isbn1, title: title1; isbn: isbn2, title: title2]
如果您想提高自己的技术水平，欢迎加入本站官方1号QQ群：&&，&&2号QQ群：，在群里结识技术精英和交流技术^_^
本站联系邮箱：}