JarCastingjavaz
Set of mini utils, classes, routines and other useful things, all buildable as JAR and available as maven artifacats.
Maven dependencies:
<dependency>
<groupId>org.javaz</groupId>
<artifactId>javaz-jdbc</artifactId>
<version>1.0</version>
<type>pom</type>
</dependency>
Available artifactIds:
javaz-cache, javaz-jdbc, javaz-queues, javaz-servlet, javaz-uml, javaz-util
Sub Projects:
-
cache - Simple and straightforward implementation of expirable Cache.
-
jdbc - Handy tool to access JDBC/JNDI databases, for replicating data between different DBs
-
queues - Helpers to make some batching/queues, both abstract and implementation part
-
servlet - Servlet, XMLRPC and SSL stuff
-
uml - tools to convert Violet UML editor class diagrams into objects, and render objects to any script files usung freemarker.
-
util - Small useful utils, not belong to any significant project
-
xml - Useful things for xml
Sub Projects cross-dependencies:
- jdbc/queues - Queues interface implemented using JDBC tools; Threaded generic mass-updater;
Usage examples
Cache
CacheImpl cache = new CacheImpl();
cache.setTimeToLive(3600*1000L);
cache.put("any key, String wold be fine", new Double(7.0));
Double seven = cache.get("any key, String wold be fine");
That's it. Cache auto cleared during active requests. If you want more aggressive purging - just call something like this in Thread: cache.clearExpired();
JDBC
String address = "jdbc:hsqldb:hsql://localhost:1600/mydb1;username=SA";
JdbcHelperI db = JdbcCachedHelper.getInstance(address);
// When you using pool, or your connections have to be created in some obscure way, you should
// implement own ConnectionProviderFactory and use it.
ConnectionProviderFactory ownFactory = ...
String address2 = "custom-address";
JdbcHelperI dbCustom = JdbcCachedHelper.getInstance(address2, ownFactory);
// simple query execution
db.runUpdate("create table test (id integer, name varchar(250))", null);
// simple query execution with parameter
HashMap map = new HashMap();
// SQL standards - parameters starts from 1
map.put(1, "No injections ' allowed \" at all'; " --");
db.runUpdate("insert into test (name) values (?)", map);
// no cache allowed in this query
List list = test.getRecordList("select * from test", null, false);
// cache is used here.
List list = test.getRecordList("select * from test", null);
// run mass update in single call - in single transaction/connection
ArrayList updates = new ArrayList();
updates.add(new Object[]{"insert into test values (101,'a')", null});
updates.add(new Object[]{"insert into test values (102,'b')", null});
updates.add(new Object[]{"insert into test values (103,'c')", null});
db.runMassUpdate(updates);
// Asynchronous queries
// For example, you in one thread very efficiently finding what should be updated.
// To make updates happen in separate Thread, is such simple as:
GenericDbUpdater dbUpdater =
GenericDbUpdater.getInstance("update test set name='x' where id", address);
dbUpdater.addToQueueAll(millionIdsCollection);
// And updates will go Batched by GenericDbUpdater.MAX_OBJECTS_PER_UPDATE and in separate Thread.
// POC util
ReplicateTables replicator = new ReplicateTables();
// initial values
replicator.dbFrom = address;
replicator.dbTo = address2;
replicator.dbToType = "hsqldb";
HashMap<String, String> tableInfo = new HashMap<String, String>();
tableInfo.put("name", "test5");
tableInfo.put("name2", "test6");
tableInfo.put("where1", " AND id > 0 ");
tableInfo.put("where2", " AND id > 0 ");
replicator.tables.add(tableInfo);
// Here will happen magic - all data from dbFrom.test5 table will go to dbTo.test6
// From and To any JDBC-compliant Database URLs.
// Conditions of success - meta data and sizes of columns should match (pretty obvious)
replicator.runReplicate();
- why caching some results? There happens heavy queries with relatively slow changing data;
When you read some rows into memory, objects will stay there until GC, right? So, storing them actually not bad idea, at least for some short time.
Queue
// You have very large table (~millions of records), or other datasource;
// and you need get records from there by some condition;
// For example to make update of expired data.
// Synchronous select is bad, since any significant client traffic will kill your DB
// To avoid this, there are RecordsRotaterI, which get records from underlying
// RecordsFetcherI in separate thread, by reasonable chunks.
SqlRecordsFetcher fetcher = new SqlRecordsFetcher(address,
"idx, name", // which columns are returned as DATA
"test4", // from clause, can contains tables, left joins, etc
"idx > 0"); // condition
//If your PK not called "id"
fetcher.setIdColumn("idx");
//How each records data will be returned, in Maps or ArrayList
fetcher.setSelectType(JdbcConstants.ACTION_MAP_RESULTS_SET);
//get and launch in background Thread rotator itself
RecordsRotatorI rotater = RotatorsHolder.getRotater(fetcher);
// if data is read, then here will be some results.
// No matter how many clients called this method, load will be low
// Since querying ready objects pool are separated from part which fills it from DB (Or any
// other source - RPC, WS)
Collection elements = rotater.getManyElements(1000);
// If you implementing accepter of data, it's nice to have it asynchronous too.
// For example, some clients are pushing to your server data, and load is different in time.
// That's simple:
// Create and launch Sender:
sender = new SimplePartialSender(yourFeederDataSaver);
//Any size
sender.setChunkSize(25);
//If your logic allows - wait some time to push more data
sender.setWaitDtelayForMinimalSize(1000);
// When data came, just puch it like this:
sender.addToQueueAll(manyObjects);
//That's it. When sender will be ready, it will call your implemented method in FeedI:
// yourFeederDataSaver.sendData(Collection nextChunkOfRecords) throws Exception;
Uml
// VioletParser used to parse beans from violet file or from json
HashMap fromViolet = new VioletParser().parseVioletClass("path");
// VioletParser used to parse beans from violet file or from json
HashMap fromJson = new VioletParser().parseFromJson("path");
// Can be used from commandline
java -cp ${jar} org.javaz.uml.VioletParser in.class.violet out-ver${ver}.json
// RenderFtl used to take beans (or each bean) and render some templates
RenderFtl renderFtl = new RenderFtl(oldModel, newModel);
renderFtl.setParseType(RENDER_DIFFERENCE);
renderFtl.setTemplate("update-db");
// This can be used from command-line
// This takes model from file model7.json and renders template create-mysql.ftl
java -cp ${jar} org.javaz.uml.RenderFtl model7.json create-mysql 1 -DtemplatePath=/path/tpl
Util
// return time in such format YYYYDDDPP
// where YYYY - year
// DDD - day in year
// PP - percents of time; e.g. 12:00 = 50; 18:00 = 75
Integer day = DayUtil.getIntegerTime();
// @return day from beginning of 2011 Year
// It's NOT the same as ((extract(year from NOW()) - 2011)*365 +
// extract(doy from NOW())) in database;
// As leap years and DST counting.
Integer daysFrom2011 = DayUtil.getDayShort();
String toBrowser = JsonUtil.convertToJS(anyHashMapOrArrayOrAnything);
filePropertyUtil = UpdateableFilePropertyUtil.getInstance(file);
//get property from file;
String original = filePropertyUtil.getProperty(key);
// imagine that file is somehow changed;
//get property from file;
String updated = filePropertyUtil.getProperty(key);
// Comparators - dynamic comparators, which can treat any Collections, elements can be any
// level of complexity and any level of nesting
// Create comparator which will sort Collection of Map, by getting from each map value
// by key "a", splitting this value by "\t" and comparing second part of split, treating
// it as Long.
GenericDeepComparator deepComparator = new GenericDeepComparator();
MapValueProducer producer1 = new MapValueProducer("a");
SplitStringProducer nested1 = new SplitStringProducer("\t", 1);
nested1.setNested(new LongFromStringProducer());
producer1.setNested(nested1);
deepComparator.setProducerI(producer1);
// Create comparator which will sort Collection of Map by getting from each map value
// by key "a"
GenericDeepComparator deepComparator = new GenericDeepComparator();
MapValueProducer producer1 = new MapValueProducer("a");
deepComparator.setProducerI(producer1);
// ObjectDifference used to find difference between objects.
// Mostly useful to make difference between Map(s)
HashMap inANotInB = ObjectDifference.getInANotInB(a, b);
HashMap inAAndInBEquals = ObjectDifference.getInAAndInBEquals(a, b);
HashMap inAAndInBNotEquals = ObjectDifference.getInAAndInBNotEquals(a, b);
XML
// If you are dealing with different XML and they are big to be processed via DOM,
// you end up with SAX.
// XpathSaxHandler could transform XML into set of HashMaps/ArrayLists/Strings the way you
// specify by simple rules.
XpathSaxHandler dh = new XpathSaxHandler();
// Specify what objects you want to treat as highest level objects
dh.addHashToHashFillingRule("tag1", XpathSaxHandler.RESULTS);
// Specify other objects you need to parse, and where this objects will be put,
// in this case all node2 objects will be put into their parent Map tag1, into
// property "key1", tag1.get("key1") == ArrayList
dh.addHashToHashFillingRule("node2", "tag1@key1,list");
// node3 which should be nested into Node2 structure put in both tag1 & tag2.
dh.addHashToHashFillingRule("node3", "tag2@n3,list");
dh.addHashToHashFillingRule("node3", "tag1@alln3,list");
// Okey, now let's tell parser where to create new Objects
dh.addNewObjectRule("/start", "tag1");
dh.addNewObjectRule("/start/some/node2", "node2");
dh.addNewObjectRule("/start/some/node2/deeper/deeper", "node3");
// And let's specify which attributes we actually need to be extracted:
// You see that we extract id for tag1 not from /start/, but from any child tree attribute
dh.addObjectFillingRule("/start/some@id", "tag1@id");
// Extract id for node2
dh.addObjectFillingRule("/start/some/node2@id", "node2@id");
// Extract all requred texts and put them into ArrayList into node2
dh.addObjectFillingRule("/start/some/node2/desc@text", "node2@alltextes,list");
// As for node3, we interested only in one attribute.
dh.addObjectFillingRule("/start/some/node2/deeper/deeper@refid", "node3@id");
// And, we need extract text content from tag 'text' into ArrayList of texts.
// Note that even empty Strings are proceeded.
dh.addObjectFillingRule("/start/some/node2/deeper/deeper/text", "node3@texts,list");
// Parse magic
parser.parse(inputStream, dh);
// And at last, get our data.
ArrayList objects = dh.getResults();