Hice 2 arreglos en sandro.
Etiquetas:
d3,
d3js,
java,
javascript,
sandro
Hace un tiempito que estoy jugando con el API de blogger para hacer posts automaticamente. Lo que me parece más complicado es autenticarse vía oauth2 desde una aplicación de línea de comando. Por eso hice un módulo de sandro que lo hace por mi, pidiendo el código de autorización solo cuando es necesario
Se puede usar como módulo de sandro así:
define({
accessToken: './accessToken'
},
function(m) {
var accessToken = m.accessToken(
'refresh_token_fname.txt',
{
clientId: 'CLIENT ID HERE',
clientSecret: 'CLIENT SECRET HERE'
}
)
// Use accessToken here!
})
Abajo les dejo accessToken.js completo (cuidado, son 134 líneas de código):
define({
javaPackages: "javaPackages",
ary: "sandro/nadaMas/array",
json: "sandro/nadaMas/json",
object: "sandro/nadaMas/object"
}, function(m) {
var URL = m.javaPackages.java.net.URL
var String = m.javaPackages.java.lang.String
var URLEncoder = m.javaPackages.java.net.URLEncoder
var StandardCharsets = m.javaPackages.java.nio.charset.StandardCharsets
var InputStreamReader = m.javaPackages.java.io.InputStreamReader
var BufferedReader = m.javaPackages.java.io.BufferedReader
var Scanner = m.javaPackages.java.util.Scanner
var System = m.javaPackages.java.lang.System
var File = java.io.File
var FileOutputStream = java.io.FileOutputStream
var OutputStreamWriter = java.io.OutputStreamWriter
var out = System.out
var in_ = new Scanner(System["in"])
var paramBytes = function(p) {
var s = new String( Object.keys(p).map(function(k) {
return "" + URLEncoder.encode(k, "UTF-8") + "=" + URLEncoder.encode(p[k])
}).join("&") )
return s.getBytes(StandardCharsets.UTF_8)
}
var postJsonResult = function(url, params) {
var parameters = paramBytes(params)
var c = new URL(url).openConnection()
try {
c.requestMethod = "POST"
c.doOutput = true
c.fixedLengthStreamingMode = parameters.length
c.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
c.connect()
c.outputStream.write(parameters)
if (200 != c.responseCode) {
return null
}
var response = ""
var reader = new BufferedReader( new InputStreamReader( c.inputStream ) )
while( true ) {
var buff = reader.readLine()
if (buff == null) {
break
}
response += buff
}
return m.json.parse( "" + response )
} finally {
c.disconnect()
}
}
var authCode2refreshToken = function(authCode, credentials) {
var rv = postJsonResult(
"https://www.googleapis.com/oauth2/v4/token", {
code: authCode,
redirect_uri: "urn:ietf:wg:oauth:2.0:oob",
client_id: credentials.clientId,
client_secret: credentials.clientSecret,
grant_type: "authorization_code"
}
)
return rv ? rv["refresh_token"] : null
}
var refreshAccessToken = function(refreshToken, credentials) {
var rv = postJsonResult(
"https://www.googleapis.com/oauth2/v4/token", {
refresh_token: refreshToken,
client_id: credentials.clientId,
client_secret: credentials.clientSecret,
grant_type: "refresh_token"
}
)
return rv ? rv["access_token"] : null
}
var readFileLine = function(fname) {
var sc = new Scanner(new File(fname))
try {
return sc.nextLine()
} finally {
sc.close()
}
}
var writeFileLine = function(fname, line) {
try {
var w = new OutputStreamWriter( new FileOutputStream(fname) )
line = "" + line
w.write(line, 0, line.length)
} finally {
w.close()
}
}
var obtainAccessToken = function(refreshTokenFname, credentials) {
var accessToken = null
var refreshToken = null
try {
refreshToken = readFileLine(refreshTokenFname)
} catch (e) {
// ignore
}
while (true) {
if (refreshToken) {
accessToken = refreshAccessToken(refreshToken, credentials)
}
if (accessToken) {
return accessToken
}
var authorizationUrl =
"https://accounts.google.com/o/oauth2/auth?scope=https://www.googleapis.com/auth/blogger&redirect_uri=urn:ietf:wg:oauth:2.0:oob&response_type=code&client_id=" +
credentials.clientId
out.println("Anda a este URL, completa la autorizacion y pega el codigo de autorizacion aca. Despues presiona ENTER")
out.println(authorizationUrl)
var authCode = in_.nextLine()
refreshToken = authCode2refreshToken(authCode, credentials)
writeFileLine(refreshTokenFname, refreshToken)
}
}
return obtainAccessToken
})
Si quieren, es bastante fácil transliterarlo a código Java.
Espero que les sirva,
Aureliano.
Sigo en mi cruzada para hacer cosas automáticamente en blogger usando sandro. En este caso, hice el código para obtener un access token a partir de un authorization code. Para eso, primero necesitás registrar una aplicación de línea de comando. Una vez que lo hayas hecho, vas a tener el client id y el client secret. Pero eso no alcanza, para obtener el access token, como el que usamos en el post anterior, hace falta un authorization code. Para obtenerlo, conectate a este URL:
https://accounts.google.com/o/oauth2/auth?scope=https://www.googleapis.com/auth/blogger&redirect_uri=urn:ietf:wg:oauth:2.0:oob&response_type=code&client_id=ACA_VA_TU_CLIENT_ID
Y te va a mostrar el authorization code después de loguearte a google y autorizar a tu aplicación a hacer cosas de blogger en tu nombre.
Una vez que obtuviste tu authorization code, hay que obtener un access token. El access token te sirve para manipular blogger con tu usuario por la próxima hora. Para renovarlo, hay que usar un refresh token, que también obtendremos, pero voy a mostrar cómo usarlo en otro post.
Acá abajo dejo el código de ejemplo para obtener estos tokens.
define({
javaPackages: "javaPackages",
ary: "sandro/nadaMas/array",
json: "sandro/nadaMas/json",
object: "sandro/nadaMas/object"
}, function(m) {
var URL = m.javaPackages.java.net.URL
var out = m.javaPackages.java.lang.System.out
var String = m.javaPackages.java.lang.String
var URLEncoder = m.javaPackages.java.net.URLEncoder
var StandardCharsets = m.javaPackages.java.nio.charset.StandardCharsets
var InputStreamReader = m.javaPackages.java.io.InputStreamReader
var BufferedReader = m.javaPackages.java.io.BufferedReader
var tokenUrl = new URL("https://www.googleapis.com/oauth2/v3/token")
var paramBytes = function(p) {
var s = Object.keys(p).map(function(k) {
return "" + URLEncoder.encode(k, "UTF-8") + "=" + URLEncoder.encode(p[k])
}).join("&")
out.println(s)
s = new String(s)
return s.getBytes(StandardCharsets.UTF_8)
}
return function(code, client_id, client_secret) {
var parameters = paramBytes({
code: code,
redirect_uri: "urn:ietf:wg:oauth:2.0:oob",
client_id: client_id,
client_secret: client_secret,
grant_type: "authorization_code"
})
var c = tokenUrl.openConnection()
c.requestMethod = "POST"
c.doOutput = true
c.fixedLengthStreamingMode = parameters.length
c.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
c.connect()
c.outputStream.write(parameters)
var response = ""
var reader = new BufferedReader( new InputStreamReader( c.inputStream ) )
while( true ) {
var buff = reader.readLine()
if (buff == null) {
break
}
response += buff
}
var jsonResponse = m.json.parse( "" + response )
out.println("Tokens: " + m.json.stringify(jsonResponse))
}
})
No uso la google-client-api de java porque es un quilombo y no entendí cómo usarla, así que me conecto a los webservices de google directamente.
Etiquetas:
blogger,
google client api,
java,
javascript,
oauth2,
sandro
Hoy estuve jugando con el API de blogger desde un script que hice usando sandro. Como puedo usar las APIs de java desde el código JavaScript que implementa los módulos de Sandro, decidí usar la biblioteca que google provee para Java.
Lo que más me costó fue toda la parte de oauth2. Como estoy solo probando, no quise armar todo un webserver para hacer todo el camino de oauth. En vez de eso, usé el oauth playground para obtener un access-token y programé desde ahí.
Con todo esto, y afanando bastante de acá hice un scriptcito que obtiene algunos datos de este blog.
define({
javaPackages : "javaPackages",
ary : "sandro/nadaMas/array"
}, function(m) {
var Blogger = m.javaPackages.com.google.api.services.blogger.Blogger
var NetHttpTransport = m.javaPackages.com.google.api.client.http.javanet.NetHttpTransport
var JacksonFactory = com.google.api.client.json.jackson2.JacksonFactory
var GoogleCredential = com.google.api.client.googleapis.auth.oauth2.GoogleCredential
var HTTP_TRANSPORT = new NetHttpTransport();
var JSON_FACTORY = new JacksonFactory();
var CREDENTIAL = GoogleCredential().setAccessToken("HERE GOES THE ACCESS TOKEN")
var buildBlogger = function() {
var bb = new Blogger.Builder(HTTP_TRANSPORT, JSON_FACTORY, CREDENTIAL)
bb.applicationName = "Testing blogger"
return bb.build()
}
return function() {
var out = m.javaPackages.java.lang.System.out
var blogger = buildBlogger()
var action = blogger.blogs().getByUrl("http://aurelianito.blogspot.com")
action.fields = "description,name,posts/totalItems,updated"
var blog = action.execute();
// Now we can navigate the response.
out.println("Name: " + blog.name)
out.println("Description: " + blog.description)
out.println("Post Count: " + blog.posts.totalItems)
out.println("Last Updated: " + blog.updated)
}
})
Si lo corren debería mostrarles algo muy parecido a:
Name: aurelianito
Description: Blog de Aureliano Calvo.
Aureliano Calvo's blog.
Post Count: 318
Last Updated: 2016-01-20T19:49:14.000-03:00
Después tengo que ver cómo hacer para hacer que el flujo del oauth ande bien.
Happy hacking,
Aureliano
Etiquetas:
blogger,
google client api,
java,
javascript,
oauth2,
sandro
Update 2: Ahora la página web de webex anda en Firefox en Ubuntu. Creo ques esa es la mejor opción.
Update: Lo probé y no anda :(. Estoy usando el app de Webex para Android para tener audio en las conferencias.
Webex anda con un applet que corre usando el JDK de Oracle. Para que arranque hay que instalarle ese JDK:
$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java8-installer
$ sudo apt-get install oracle-java8-set-default
y arranca, pero el audio no anda. La primera vez, para zafar, hice que me llame al celu (anda en Argentina!!!!).
Parece que webex está linkeado contra cosas de 32 bits, por eso con las libs de 64 bits no anda el audio :/. Para instalar las libs, seguí las intrucciones de este post.
Los puntos relevantes son:
En los últimos días implementé el módulo sandro/tengo. Lo que hice fue una forma "objetosa" de contruir queries de SQL y procesar los resultados, usando como base JDBC. La idea es evitar los problemas de seguridad por inyección que plagan los usos de las bases de datos sin restringir la funcionalidad. El código que hice lo probé con sqlite3, y debería andar con cualquier base de datos que sea ANSI-SQL y tenga driver de JDBC.
Acá les dejo un ejemplo de cómo hacer un query usando tengo. Asumiendo que connection es una conexión a la base de datos y hay una tabla person (id integer, name string, rank integer), así hago un query:
define(
{
tengo: "sandro/tengo"
},
function(m) {
// Some code before, constructing the JDBC connection
var _ = m.tengo.ansiBuilder
// SELECT * FROM person ORDER BY id DESC;
var results = _.select({
from: "person",
order_by: _.desc("id")
}).map(connection, function(rs) {
return {
name: "" + rs.getString("name"),
id: rs.getInt("id")
}
})
// SELECT count(1) as c, rank FROM person GROUP BY rank HAVING c > 1
var results2 = _.select({
columns: [ _.alias("c",_.invoke("count", _.int(1))), "rank" ],
from: "person",
group_by: "rank",
having: _.gt("c", _.int(1))
}).map(connection, function(rs) {
return {
c: rs.getInt("c"),
rank:rs.getInt("rank")
}
})
// You can process the results here
}
)
En la implementación actual podés hacer SELECTs con un montón de opciones (TODO: documentar todo). La idea subyacente es que las queries se arman haciendo árboles de objetos que generan los queries con objetos inmutables siguiendo la sintaxis de SQL (para que puedan usar los conocimientos de SQL que ya tienen), y estos objetos se encargan de escapar el SQL. Para que sea menos verbose, los strings son transformados en símbolos de SQL (como columnas o tablas), los números en expresiones que representan el número en punto flotante y los arrays en expresiones separadas por comas, que está buenísimo para hacer queries con varias tablas, requerir varias columnas o hacer ORDER BY con varios criterios.
Lo siguiente que toca es hacer que se pueda hacer UPDATE, DELETE, INSERT. Y después toca CREATE TABLE y DROP TABLE.
¿Qué frameworks conocen que les dejen hacer queries tan fácilmente? Lo más parecido que se me ocurre es el API de bajo nivel de SQLAlchemy, pero como los elementos de las queries son stateful, es mucho más quilombo.
Sandro tiene soporte para basic authentication. Para usarlo hay que importar el módulo sandro/alFinal. Se usa así:
alFinal.basicAuth( my_handler, function(user, pass) { return user === pass }, "sample realm")
Los tres parámetros que recibe son:
Etiquetas:
basic authentication,
java,
javascript,
sandro
En los últimos días hice que sea posible correr la biblioteca de sandro de línea de comando y tenga una consola. Para correr la consola, usando todos los módulos de sandro, ponelo en el classpath (con sus dependencias) y corré:
$ java sandro.RhinoConsole
Eso abre una consola donde podés correr código, que es una consola como la de rhino pero customizada para poder importar los módulos de sandro usando penumbras.
js> var funMod = penumbras.loadModule("sandro/nadaMas/function")
js> funMod.isFun(5)
false
js> funMod.isFun(function(a) {} )
true
Pero esto no es todo, ¡también se pueden correr módulos de sandro desde la línea de comandos! Para eso, hay que poner los módulos en el classpath (en un jar o un directorio), aparte de sandro y sus dependencias, y correr:
$ java sandro.RhinoRunner my/custom/module param1 param2
Para que corran, el módulo tiene que exportar una función, que es la que llama el runner. Pueden mirar el módulo helloWorld (está en el proyecto de la biblioteca por ahora) para ver un ejemplo tonto:
define({
javaPackages : "javaPackages",
ary : "sandro/nadaMas/array"
}, function(m) {
return function() {
var out = m.javaPackages.java.lang.System.out
out.println("Hello!")
out.println(m.ary.fromArgs(arguments).join())
}
})
Y si lo invocan de línea de comando, pasa esto:
$ java sandro.RhinoRunner helloWorld Hola Manola
Hello!
Hola,Manola
Usando esto, hice que los tests de la biblioteca corran de línea de comando así:
$ java sandro.RhinoRunner sandro/testRunner
Por último, saqué la dependencia de servlets del cargador de módulos, así que ahora no hace falta tener el API de servlets en el classpath para usar todas las cosas que no tienen que ver con la web.
Happy hacking,
Aureliano.
Etiquetas:
consola,
java,
javascript,
sandro
Hice varias mejoras en sandro. Ahora se puede definir módulos que son endpoints y se cargan dinámicamente, definir rutas estáticas y ¡debuggear desde eclipse! Estos features llevaron sorprendentemente poco código.
Y ¡sigue pudiéndose compartir fácilmente código entre cliente y server! Ya está tomando forma y tiene cosas que no tienen la mayoría de los frameworks para hacer páginas web.
¿Cuándo hacés tu proyecto en sandro?,
Aureliano.
Etiquetas:
java,
javascript,
sandro,
web
Pydev me colgaba el eclipse cuando abría un archivo con muchos errores. Para que no se cuelgue más tuve que editar el eclipse.ini y agregarle al final
-Djava.net.preferIPv4Stack=true
Más detalles en http://stackoverflow.com/questions/7463691/eclipse-pydev-completion-hangs-yet-again.
Si tratan de correr cgoban con Java Web Start, como dice en gokgs.com, puede ser que les de un error en la firma del jnlp (como a mi). Para workaroundear el problema, lo que yo hice es bajarme el .jar de http://files.gokgs.com/javaBin/cgoban.jar y correrlo localmente.
Espero que les sirva, y si quieren jugarse una partidita de go conmigo pueden buscarme en Dragon Go Server, mi usuario es aurelianito y, al momento de escribir este post, soy 11k.
Hace ya casi 4 años empecé un proyecto para hacer más fácil hacer páginas web seguras al que llamé sandro. Ahora estoy empezando el mismo proyecto de nuevo, siguiendo con mismas ideas rectoras:
Esto es lo que tuve que hacer para que la webapp en java que estoy desarrollando con eclipse 3.5 y web tools platform ande en el context-path root:
Ayer me di cuenta que no necesito rehacer los classloaders de java para cargar scripts de JavaScript, ya que puedo usarlos y son todo lo flexibles que necesito (y más). Inclusive, si por una de esas casualidades llegara a hace falta, creo que puedo hacer uno en rhino y todo. Por lo tanto decidí que mi lógica para cargar módulos tenía una indirección de más (la lista de loaders) y lo cambié para que use el classloader y listo. Fíjense en la nueva implementación de loadMod y como se simplificó el uso de los loaders.
En la versión del código que estoy usando ahora, también hice que los módulos se carguen un toque distintos para que haya mejores stack-traces (ese cambio está en la función require). Bueno, abajo pongo el código:
/*
* Does not support relative paths (yet?).
* Can be invoked by several threads.
*
* Uses the classloader to fetch js modules.
*/
var require = function (id) {
try {
require.lock.lock() // Avoid threading issues while loading modules.
if (!require.modules[id]) {
var modCode = require.loadMod(id)
var exports = {}
require.modules[id] = exports
var module = {
id : id
}
var context = {
exports: exports,
module: module,
}
if(!modCode) {
throw new require.RequireError(id, "module not found")
}
org.mozilla.javascript.Context.getCurrentContext().evaluateString(
context,
modCode,
id,
1,
null
)
/*
Old style invocation, should work in the browser but has worst error messages.
var f = new Function("require", "exports", "module", modCode)
f.call(context, require, exports, module) */
}
return require.modules[id]
} catch (x) {
if (x instanceof require.RequireError) {
throw x
} else {
throw new require.RequireError(id, x)
}
} finally {
require.lock.unlock()
}
}
require.loaders = []
require.modules = {}
require.lock = new java.util.concurrent.locks.ReentrantLock()
var RequireErrorProto = {}
require.RequireError = function(moduleId, cause) {
this.moduleId = moduleId
this.cause = cause
}
require.RequireError.prototype = RequireErrorProto
require.RequireError.prototype.toString = function() {
return "Error loading " + this.moduleId + ( this.cause ? ". Cause: " + this.cause : "" )
}
require.RequireError.prototype.name = "RequireError"
require.load = function(path) {
return java.lang.Class.forName("java.lang.String").getResourceAsStream(path)
}
require.loadMod = function(id) {
function path(id) {
return "/" + id + ".js"
}
function readFromStream(stream) {
var io = java.io
var reader = new io.BufferedReader( new io.InputStreamReader(stream) )
try {
var stringBuffer = new java.lang.StringBuffer()
var line = ""
while( line = reader.readLine()) {
stringBuffer.append(line)
stringBuffer.append("\n")
}
return stringBuffer.toString()
} finally {
reader.close()
}
}
var stream = require.load(path(id))
if (!stream) { return null }
return readFromStream(stream)
}
/**
* Resets the module cache.
*
* It will reload all the modules. Old modules referenced will still be working.
*/
require.reset = function() {
try {
require.lock.lock()
require.modules = {}
} finally {
require.lock.unlock()
}
}
Etiquetas:
java,
javascript,
rhino
Hoy estuve hackeando un toque y modifiqué el RhinoServlet que les mostré en este post para poder tener módulos en Javascript. El API que hice es un subset de lo definido en CommonJS. En particular, soporta require pero no los paths relativos de módulos (o sea, los que empiezan con . o ..). También le puse a todo un lock para que pueda usarse en un entorno concurrente, pero si un módulo tarda mucho en cargarse puede llegar a ser un problema.
Lo que me parece más interesante de mi prototipo es que se pueden agregar fácilmente nuevos loaders de módulos de JavasScript. Ya vienen por defecto loaders para cargar desde el classpath y desde la webapp, pero si quieren poder poner sus módulos en /WEB-INF/example, alcanza con agregar una línea en init.js:
require.loaders.push( require.stdLoader(servlet.servletContext, "/WEB-INF/example/"))
package aure.jslib;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;
public class RhinoServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private Scriptable initialScope = null;
public void runJs(Context cx, String scriptLocation, Scriptable scope) throws IOException {
InputStream is = this.getClass().getResourceAsStream(scriptLocation);
if( is == null) {
is = this.getServletContext().getResourceAsStream("/WEB-INF/js/" + scriptLocation);
}
Reader jsReader = new InputStreamReader(is);
cx.evaluateReader(scope, jsReader, scriptLocation, 1, null);
}
public static void addJavaObjectToScope(Scriptable scope, String name, Object obj) {
ScriptableObject.putProperty(scope, name, Context.javaToJS(obj, scope) );
}
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
Context cx = Context.enter();
try {
Scriptable scope = cx.initStandardObjects();
addJavaObjectToScope(scope, "servlet", this);
addJavaObjectToScope(scope, "config", config);
this.runJs(cx, "initRequire.js", scope);
this.runJs(cx, "init.js", scope);
this.initialScope = scope;
} catch (IOException e) {
throw new ServletException(e);
} finally {
Context.exit();
}
}
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Context cx = Context.enter();
try {
Scriptable scope = cx.initStandardObjects();
scope.setParentScope(this.initialScope);
addJavaObjectToScope(scope, "request", request);
addJavaObjectToScope(scope, "response", response);
this.runJs(cx, "start.js", scope);
} finally {
Context.exit();
}
}
}
/* Based on http://www.davidflanagan.com/demos/require.js
* but heavily modified.
*
* Does not support relative paths (yet?).
* Can be invoked by several threads.
*
* Uses the servletContext and the classloader to fetch js modules.
*/
var logger = java.util.logging.Logger.getLogger("sarasa")
var require = function (id) {
try {
require.lock.lock() // Avoid threading issues while loading modules.
if (!require.modules[id]) {
var modText = require.loadMod(id)
var context = {}
var exports = {}
require.modules[id] = exports
var module = {
id : id
}
var f = new Function("require", "exports", "module", modText)
f.call(context, require, exports, module)
}
return require.modules[id]
} catch (x) {
throw new Error("Can't load module: " + id + ": " + x)
} finally {
require.lock.unlock()
}
}
require.loaders = []
require.modules = {}
require.lock = new java.util.concurrent.locks.ReentrantLock()
require.loadMod = function(id) {
var modText = null
var i = 0
while (modText == null && i < require.loaders.length) {
modText = require.loaders[i](id)
i++
}
return modText
}
// Setup loaders for files in the classpath, files in WEB-INF and files in the
// web-app (usually served to the client)
require.stdLoader = function(source, prepend) {
// Support functions
function readFromStream(stream) {
var io = java.io
var reader = new io.BufferedReader( new io.InputStreamReader(stream) )
var stringBuffer = new java.lang.StringBuffer()
var line = ""
while( line = reader.readLine()) {
stringBuffer.append(line)
stringBuffer.append("\n")
}
return stringBuffer.toString()
}
function path(id) {
return prepend + id + ".js"
}
var f = function(id) {
var stream = source.getResourceAsStream(path(id))
return stream ? readFromStream(stream) : null
}
return f
}
require.initStdLoaders = function() {
// classpath loader
require.loaders.push( this.stdLoader(servlet["class"], "/") )
// web-app context loader
require.loaders.push( this.stdLoader(servlet.servletContext, "/") )
}
require.initStdLoaders()
var f = new Function("require", "exports", "module", modText)
f.call(context, require, exports, module)¿Por qué te negás a usar dependencias de otros proyectos de eclipse?
¿Por qué no recompilás bien cuando está corriendo el web-server en modo debug y uso resources de adentro del classpath?
Bueno, por ahora son 2 problemas que creo poder "workarroundear".
Happy hacking,
Aureliano.
Estuve con algo de tiempo y me puse a probar como hacer para ejecutar JavaScript en el server. E hice 2 implementaciones (o sea, 2 servlets programados en Java). La primera que hice usa javax.script (que viene por defecto en Java 6) y me parece que el API es más cómoda pero tiene 2 limitaciones que no me gustaron, no se puede heredar de clases Java en JavaScript y no encontré cómo hacer para bindear un método de Java a JavaScript. Este es el código:
package aure;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import javax.script.Bindings;
import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class JsServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private ScriptEngine jsEng = new ScriptEngineManager()
.getEngineByName("js");
private Bindings initBindings = this.jsEng
.getBindings(ScriptContext.ENGINE_SCOPE);
public JsServlet() {
super();
}
@Override
public void init(ServletConfig config) throws ServletException {
try {
super.init(config);
this.initBindings.put("config", config);
this.initBindings.put("servlet", this);
this.runJs("init.js", this.initBindings);
} catch (ScriptException e) {
throw new ServletException("Error running init.js", e);
}
}
public void runJs(String scriptLocation, Bindings bindings)
throws ScriptException {
Reader jsReader = new InputStreamReader(this.getServletContext()
.getResourceAsStream(scriptLocation));
this.jsEng.eval(jsReader, bindings);
}
protected void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
try {
Bindings bindings = jsEng.createBindings();
bindings.putAll(this.initBindings);
bindings.put("request", request);
bindings.put("response", response);
this.runJs("start.js", bindings);
} catch (ScriptException e) {
throw new ServletException("Error running javascript", e);
}
}
}
package aure;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;
public class RhinoServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private Scriptable initialScope = null;
public void runJs(Context cx, String scriptLocation, Scriptable scope) throws IOException {
Reader jsReader = new InputStreamReader(this.getServletContext()
.getResourceAsStream("/WEB-INF/js" + scriptLocation));
cx.evaluateReader(scope, jsReader, scriptLocation, 1, null);
}
public static void addJavaObjectToScope(Scriptable scope, String name, Object obj) {
ScriptableObject.putProperty(scope, name, Context.javaToJS(obj, scope) );
}
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
Context cx = Context.enter();
try {
Scriptable scope = cx.initStandardObjects();
addJavaObjectToScope(scope, "servlet", this);
addJavaObjectToScope(scope, "config", config);
this.runJs(cx, "/init.js", scope);
this.initialScope = scope;
} catch (IOException e) {
throw new ServletException(e);
} finally {
Context.exit();
}
}
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Context cx = Context.enter();
try {
Scriptable scope = cx.initStandardObjects();
scope.setParentScope(this.initialScope);
addJavaObjectToScope(scope, "request", request);
addJavaObjectToScope(scope, "response", response);
this.runJs(cx, "/start.js", scope);
} finally {
Context.exit();
}
}
}
Etiquetas:
java,
javascript,
rhino,
servlet
Hoy estuve mirando un toque como hacer una aplicación en Android. Después de hacer el HelloWorld correspondiente, seguir parte del tutorial sobre como hacer una aplicación que sirva para guardar notas y leer bastante de la documentación, hice correr el Lunar Lander. El Lunar Lander es un port del archi-conocido juego al android.
Pensé que iba a salir de toque, pero no :(. Así que puse manos a la obra, toque las 2 tonteras que tenía mal y lo hice andar. Para que no tengan que hacer lo mismo que yo, les dejo mi proyecto de eclipse armado. Es igual al de los ejemplos de Google salvo porque como package uso aure en vez de com.android.examples.
Acá está el tar.gz.
Happy hacking,
Aureliano.