Posted by Nikolaus Gradwohl
Wed, 01 Sep 2010 17:35:00 GMT
I played around a bit with the new servlet-api 3.0 and tomcat7 and i really like it.
it has some nice features like servlet declaration using annotations or the support for
asynchornous requesthandling, but the feature that i really really love is the
support for file upload.
To handle a file upload form like this
<html>
<body>
<form action="upload" enctype="multipart/form-data" method="post">
<input type="file" name="filename"/>
<input type="submit" value="submit"/>
</form>
</body>
</html>
is to mark the servlet with an annotation and access the uploaded file using 'request.getPart("filename")' like this
package at.hpc.servlettest;
import java.io.*;
import javax.servlet.*;
import javax.servlet.annotation.*;
import javax.servlet.http.*;
@WebServlet(name="testUpload", urlPatterns={"/upload"})
@MultipartConfig
public class TestUpload extends HttpServlet {
protected void doPost( HttpServletRequest req, HttpServletResponse res )
throws ServletException, IOException {
Part part = req.getPart("filename");
res.setContentType( part.getContentType());
res.setHeader( "disposition", "inline" );
OutputStream out = res.getOutputStream();
InputStream in = part.getInputStream();
byte buffer[] = new byte[ 4048 ];
int n = 0;
while ((n = in.read( buffer )) > 0) {
out.write( buffer, 0, n );
}
out.close();
}
}
This is a really silly example that just copies the uploaded file back to the browser, but it shows how clean and simple
handling fileuploads gets with this api - this is the feature i have been waiting for years!
Tags api, j2ee, java, servlet | no comments
Tweet This!
Posted by Nikolaus Gradwohl
Tue, 22 Jun 2010 18:46:00 GMT
hmmmmmm - todays project for 30daysofcreativity is...
guru.OutOfIdeasException()
at guru.bodyparts.head.Brain.think()
at.guru.bodyparts.head.Head()
at.guru.body.Main().run()
Tags Creativity, fun, java | 1 comment
Tweet This!
Posted by Nikolaus Gradwohl
Mon, 11 Jan 2010 10:22:00 GMT
To deploy a processing sketch via java webstart export the sketch as an application (i used my randomlines sketch and exported it as a linux
application).
then i wrote a simple jnlp file and copied the files to my webserver. The only thing thats left is providing a
link to the jnlp file like this.
click here to dowload and launch the application
More info on jnlp and webstart can be found
here
test.jnlp
<?xml version="1.0" encoding="UTF-8"?>
<jnlp spec="1.0+" codebase="" href="">
<information>
<title>Processing Test</title>
<vendor>guru</vendor>
<icon href="http://www.local-guru.net/jnlp/randomlines/randomlines.png"/>
<desktop/>
<offline-allowed/>
<shortcut online="false">
<desktop/>
</shortcut>
</information>
<resources>
<j2se version="1.5+" href="http://java.sun.com/products/autodl/j2se"/>
<jar href="http://www.local-guru.net/jnlp/randomlines/lib/randomlines.jar" main="true" />
<jar href="http://www.local-guru.net/jnlp/randomlines/lib/core.jar" main="true" />
</resources>
<application-desc
name="ProcessinTestApp"
main-class="randomlines"
width="300"
height="300">
</application-desc>
<update check="background"/>
</jnlp>
Tags java, processing, webstart | no comments
Tweet This!
Posted by Nikolaus Gradwohl
Tue, 03 Mar 2009 03:25:00 GMT
motivated by my hand written x86 machinecode, i decided
that i had to take it to the next level.
i worte some handassembled java bytecode. run the file below as
./dump.sh > HelloAsm
and run the programm with
java HelloAsm
Read more...
Tags asm, helloworld, java, machinelanguage | no comments | no trackbacks
Tweet This!
Posted by Nikolaus Gradwohl
Fri, 23 Jan 2009 14:19:00 GMT
to switch between 2 installed versions of the jdk in ubuntu 2 commands are needed:
sudo update-alternatives --config java
is used to choose the java version
sudo update-alternatives --config javac
is used to change the javac version
Tags java, ubuntu | 1 comment
Tweet This!
Posted by Nikolaus Gradwohl
Fri, 20 Jun 2008 03:44:00 GMT
Yesterday i attended to the javadeus08, the first java-conference by sun
in austria.
Most of the sessions were really interesting, and i definitly have to give jmaki a try :-)
The only thing, that annoyed me, is that there was no free wlan and that even the speakers had a veeeeeeeeery slow
connection for their demos
Tags java, javadeus08, jmaki | no comments
Tweet This!
Posted by Nikolaus Gradwohl
Sun, 20 Apr 2008 05:55:00 GMT
When you need a array in java filled with some data, initializing it is easy
String[] bla = new String[] { "Foo", "Bar", "Bla" };
and done.
but when you need a Map or a Set prefilled with some data it starts getting complicated.
you can either use a static initializer block like
public class Bla {
static Set<String> dings;
static {
dings = new HashSet<String>();
dings.add("foo");
dings.add("bla");
}
}
or you fill your set or map in the contructor if it is still null (be carefull if you use this in a multithreaded application)
another way i have learnd at the last jax is using this code
public class Bla {
static Set<String> dings = new HashSet<String>() {{
add("Foo"); add("Bar"); add("Bla"); }};
}
neat isn't it?
this also works with a Map
public class Bla {
static Map<String,String> dings = new HashMap<String,String>() {{
put("k1", "Foo"); put("k2", "Bar"); put("k2", "Bla"); }};
}
Tags java | no comments
Tweet This!
Posted by Nikolaus Gradwohl
Wed, 26 Sep 2007 18:40:00 GMT
When I use jdbc to develop a small tool, where using a OR-Mapper
like Hibernate is overkill, I always dislike that i have to dublicate
all the "getStatement" "execQuery" "while (resultSet.next())" stuff.
i dont like to repeat stuff in my code. It would be very easy if
java had closures, but i dont want to wait until java7 to simplify
my code so I needet another idea.
java has no closures but it has something that can be used in a similar
manner - Anonymous inner classes.
so to simplify the following class
Connection con = getConnection()
Statement st = con.createStatement();
ResultSet rs = st.executeQuery( "sqlstring");
List<Foo> result = new ArrayList<Foo>();
while (rs.next()) {
Foo f = new Foo();
f.setProperty1( rs.getString( "property1" ));
f.setProperty2( rs.getString( "property2" ));
result.add( f );
}
// imagine catch/finaly block here
st.close();
con.close();
i define a interface called Function
interface Function<T> {
public T valueOf( ResultSet rs ) throws SQLException;
}
Then i define a QueryMapper like this
public class QueryMapper<T> {
private Database db;
public QueryMapper( Database db ) {
this.db = db;
}
List<T> listOf( Function<T> f, String query ) {
List<T> res = new ArrayList<T>();
Resultset rs = ... get resultset for query ..
while ( rs.next() ) {
res.add( f.valueOf( rs ));
}
// catch/finaly block here
return res;
}
}
So all i have to do in my code now is calling
Function<Foo> fn = new Function<Foo>() {
public Foo valueOf( ResultSet rs) throws SQLException {
Foo res = new Foo();
res.setPropery1( rs.getString( "property1" ));
res.setPropery2( rs.getString( "property2" ));
return res;
}
}
QueryMapper<Foo> qm = QueryMapper<Foo>( db );
List<Foo> res = qm.listOf( fn, "select * from foo");
I can even recycle the Function objects ( if i query different object of the same type but with different ids for example )
thats more how i like it
Tags java | 2 comments
Tweet This!
Posted by Nikolaus Gradwohl
Thu, 26 Apr 2007 09:25:00 GMT
Im currently sitting in Wiesbaden at the Jax2007 (missing a keynote from SAP :-) )
i've seen a lot of new interessting tools and techniques which will keep me busy some
times.
webtest from canoo, for example has evolved in a very interesting way since i gave it
the last try,
one thing that many of the speakers are showing ist the tendency to use more languages
on the JVM and choose the right tool for the problem. and not let the language shape the
solution.
there were some nice sessions showning how to generate textual DSL with ruby or
open architecture ware.
this time there were some netbeans sessions where new features from the upcoming
netbeans 6 release where shown - realy nice
and i heard abount ApacheDS a ldap server which is completely written in java
and can be embedded into other applications.
ok the sap keynote is comming to an end - i will go to the next session now ...
Tags java, jax2007 | no comments
Tweet This!
Posted by Nikolaus Gradwohl
Sun, 21 Jan 2007 10:09:00 GMT
Java 1.5 introduced a bunch of new classes for handling multithreaded programming.
The one I realy like the most is Future.
With future its possible to start the calculation of something you know you will need
at a later point in yout programm. When you reach that point you can call Future.get()
to fetch the result of the calculation. If it is already avaliable the result is returned
immediately, if the calculation is still running or has not started yet Future.get()
blocks until the results are here.
one gets a future by submitting an object implementing Runnable or Callable to an ExecutorService.
This is an interface that is implemented by ThreadPoolExecutor.
ExecutorService e = Executors.newSingleThreadExecutor();
Future<String> future = e.submit(callable);
...
String result = future.get();
This Class implements a queue and a threadpool. using ExecutorService.submit() you can put some
Workload in an queue, from where the threads of the pool will fetch and execute them. the submit method returns an Future which can be used to fetch the results of the workload.
There are various preconfigured Threadpools available from Executors Class. For example
ExecutorService e = Executors.newSingleThreadExecutor();
creates a degenerated Threadpool using just one thread. This is very usefull if one has to garantee
that no two instances of the submitted callable are executed at the same time. If you have to use an external service that is implemented by offering an api via webservice thats not threadsave beacause of a missing transaction handling, this SingleThreadExecutor can be used to serialize the requests comming from a webapplication.
All the clientrequests can be spooled in the executor service but all the calls to the service api are strictly searialized.
Another very usefull class is
ExecutorService e = Executors.newCachedThreadPool()
this is what most people think of when they refere to a threadpool. The class generatets new
threads if needed but reuses existing ones if they do idle. Threads that are not used for 60 seconds are removed from the pool.
ExecutorService e = Executors.newFixedThreadPool(n)
creates a Threadpool containing n threads. No new threads are generated an there also is no timeout.
SingleThreadExecutor is an fixedThreadPool with n = 1.
I think the java.util.concurrent package is the one of the best things that got introduced with java 1.5.
Tags java, threadpool | 1 comment
Tweet This!
