Uno de los motivos por las que casi no escribo en mi blog es porque estoy 100% sumergido en el proyecto open source Encuestame, hace unos dias creamos un nuevo portal y la verdad quedó bastante chulo, aqui les dejo un screenshot, estamos tambien trabajando en una version mobile.
También me gustaria destacar que estamos recibiendo ayuda para la traducción del sitio a varios idiomas como, Alemán, Italiano, Francés, Portugués, Inglés y Arabe. Gracias a los colaboradores 
The “Java Life”
SPOKEN:
In the cubicles representin’ for my JAVA homies…
In by nine, out when the deadlines are met, check it.
CHORUS:
We code hard in these cubicles
My style’s nerd-chic, I’m a programmin’ freak
We code hard in these cubicles
Only two hours to your deadline? Don’t sweat my technique.
Sippin’ morning coffee with that JAVA swirl.
Born to code; my first words were “Hello World”
Since 95, been JAVA codin’ stayin’ proud
Started on floppy disks, now we take it to the cloud.
On my desktop, JAVA’s what’s bobbin’ and weavin’
We got another winning app before I get to OddEven.
Blazin’ code like a forest fire, climbin’ a tree
Setting standards like I Triple E….
Boot it on up, I use the force like Luke,
Got so much love for my homeboy Duke.
GNU Public Licensed, it’s open source,
Stop by my desk when you need a crash course
Written once and my script runs anywhere,
Straight thuggin’, mean muggin’ in my Aeron chair.
All the best lines of code, you know I wrote ‘em
I’ll run you out of town on your dial-up modem.
CHORUS:
‘Cause…
We code hard in these cubicles
Me and my crew code hyphy hardcore
We code hard in these cubicles
It’s been more than 10 years since I’ve seen the 404.
Inheriting a project can make me go beeee-serk
Ain’t got four hours to transfer their Framework.
The cleaners killed the lights, Man, that ain’t nice,
Gonna knock this program out, just like Kimbo Slice
I program all night, just like a champ,
Look alive under this IKEA lamp.
I code HARDER in the midnight hour,
E7 on the vending machine fuels my power.
Ps3 to Smartphones, our code use never ends,
JAVA’s there when I beat you in “Words with Friends”.
My developing skills are so fresh please discuss,
You better step your game up on that C++.
We know better than to use Dot N-E-T,
Even Dan Brown can’t code as hard as me.
You know JAVA’s gettin’ bigger, that’s a promise not a threat,
Let me code it on your brain
WHISPERED:
so you’ll never forget.
CHORUS:
We code hard in these cubicles,
it’s the core component…of what we implement.
We code hard in these cubicles,
Straight to your JAVA Runtime Environment.
We code hard in these cubicles,
Keep the syntax light and the algorithm tight.
We code hard in these cubicles,
Gotta use JAVA if it’s gonna run right.
We code hard in these cubicles
JAVA keeps adapting, you know it’s built to last.
We code hard in these cubicles,
Robust and secure, so our swag’s on blast
CODE HARD
El dia de hoy revisando los proyectos de Spring Source, detecte dos interesantes proyectos que apenas tienen 1 mes desde el primer commit, los proyectos son, Spring Mobile y Spring Social.
Aún no están en la lista oficial de proyectos de Spring Source. Pero puedes descargar el código , estan en un repositorio GIT, así que tengras que instalar git o usar jGIT con eclipse.
Spring Mobile: https://jira.springframework.org/browse/MOBILE
Spring Social: https://jira.springframework.org/browse/SOCIAL
// Spring Social git clone git://git.springsource.org/spring-social/spring-social.git // Spring Mobile git clone git://git.springsource.org/spring-mobile/spring-mobile.git |
Brevemente, podemos describir que Spring Social esta orientado a crear un framework para la integracion de un sistema con Twitter, Facebook y otras comunidades sociales/, utilizando OAuth (con Spring Securitu OAuth) como metodo de autentificación y tratando de remplazar a Twitter4j.
Por el otro lado Spring Mobile por el poco código que veo en el repositorio, indica que será un una libreria para detectar dispositivos mobiles en las peticiones, un producto interesante ya con los SmartPhones en auge diariamente.
El 31 de Agosto de este año (2010) twitter dejo de proveer seguridad por medio de contraseña y usuario como venia siendo habitual en muchos clientes de Twitter.
Asi que nos hemos vistos muchos, como en mi caso, obligados a migrar OAuth, al principio cuesta un poco entender como funciona, pero es realmente muy sencillo y no comprometemos las contraseñas de nuestros usuarios.
Si quieres aprender algo mas sobre el protocolo de autorizacion OAuth, por aquí.. No quiero entrar a explicar como registrar una aplicacion en twitter, porque eso lo hacen muy bien en KodeGeek con Twitter4j.
En mi caso, no es una aplicación de escritorio, es web y con Java Server Faces, no usaré servlets porque mi intencion es almacenar la información en la base de datos, y no sera una sola cuenta, podran ser muchas cuentas. Dejo este tipico ejemplo que es el mas común de encontrar y con el que vamos a empezar a aclarar un poco lo que he leido en varios blogs.
Solo presentaré extractos de código, lo mas importante para entender como registrar las autentificaciones válidas con OAuth en Twitter y poder usarlas posteriormente.
//Creamos una instancia de Twitter, usemos el TwitterFactory , trabajamos con la version de Twitter4j 2.3.1 this.twitter = new TwitterFactory().getInstance(); // Las 2 llaves que nos da Twitter al registrar la aplicacion, estas son fundamentales las // usaremos mucho, se deben almacenar en la base de datos this.twitter.setOAuthConsumer("consumer_key", "consumer_secret"); //Solicitamos un REQUEST TOKEN, este objeto solo se debe crear una sola vez. this.requestToken = twitter.getOAuthRequestToken(); //Obtenemos el URL, este url lo podemos presentar en JSF con un link y nos enviara a la página // de twitter, daremos permiso a nuestra aplicacion // y obtendremos el pin que usaremos a continuacion. final String url = this.requestToken.getAuthorizationURL(); |
Hasta aquí todo bien, tenemos nuestro RequestToken, deberian usarlo en su clase como una propiedad de la clase, lo usaremos en otro metodo, tambien el objeto Twitter lo reutilizaremos, por eso los this.
//El objeto AccessToken, este objeto lo usaremos constantemente, cada vez que querramos //comunicarnos con Twitter, en este caso para validar nuestro // RequesToken y obtener 2 llaves mas, que son las definitivas y las que nos permitiran //publicar, hasta el momento no hemos terminado this.accessToken = this.twitter.getOAuthAccessToken(this.requestToken, "PIN"); //Si despues de esto todo sale bien (sin TwitterExceptions) tendremos ya acceso a los TOKENS, // son 2 cadenas que almacenaremos en nuestra base de datos // y usaremos posteriormente para publicar nuestros tweets o obtener algo de informacion de nuestra cuenta. //El token log.debug("New Token {"+this.accessToken.getToken()); //El Token Secret log.debug("New Secret Token {"+this.accessToken.getTokenSecret()); //Testing send twitter, WORKS !! //Si queremos probar que todo funciona, seteamos el ACCESS TOKEN que validamos anteriormente con el objeto Twitter. this.twitter.setOAuthAccessToken(accessToken); // Publicamos algo para comprobar. this.twitter.updateStatus("test accessToken"); //Guardamos los dos tokens en la base de datos. |
Ahora tenemos 4 codigos en nuestra tabla, los 2 codigos consumer y los 2 codigos Token, con estos 4 codigos podremos postear mientras no revoquemos nuestros permisos en nuestro perfil de Twitter.
//Para poder acceder a nuestra cuenta, postear o obtener algo de info, recuperamos nuestros // 4 datos principales, creamos un ACCESSTOKEN seteando en el // constructor el Token y el Secret Token validos final AccessToken accessToken = new AccessToken("Token", "Secret Token"); //Creamos una nueva instancia de Twitter y creamos una nueva instancia de autorizacion // con nuestras otras 2 llaves Consumer y el objeto creado // anteriormente ACCESS TOKEN Twitter twitter = new TwitterFactory().getOAuthAuthorizedInstance("Consumer Key", "Consumer Secret", accessToken); //Una vez echo esto, ya tenemos el objeto Twitter cargado y listo para ser usado, podemos probar las credenciales. twitter.verifyCredentials(); |
En otros blogs podrás encontrar muchas maneras de hacer esto, pero muchos se basan en aplicaciones de escritorio o basados en servlets, de esta forma podemos almacenar nuestras multiples cuentas de Twitter con OAuth y utilizarlas segun nuestras necesidades.
Hola Gente, regreso a las andadas varios meses después con una serie de artículos sobre Spring 3.0. El primero de ellos sera de unas clases nuevas que nos ofrece Spring MVC 3.0 para crear nuestros propios Feed con 2 formatos diferentes, RSS 2.0 o Atom.
Primero vamos a conocer las 2 clases abstractas disponibles desde Spring 3.0 que vamos a usar
AbstractFeedView es la clase para crear nuestra vista principal de RSS y esta a su vez se extiende de AbstractView nos ofrece metodos para crear los encabezados de nuestro RSS.
Esta clase abstracta extiende de AbstractAtomFeedView y esta tambien se extiende de AbstractView.
No es posible crear una sola clase para manejar los dos formatos, asi que trabajaremos solamente con RSS, el proceso para ATOM es practicamente el mismo.
Extendemos AbstractRssFeedView y creamos la siguiente vista. Se deben implementar 2 metodos obligatoriamente, el primero es para crear el encabezado del RSS (ojo, si no lo llenas bien recibiras una bonita excepcion) y el otro metodo es para setear todo el cuerpo del RSS.
public final class MyViewFeedRssView extends AbstractRssFeedView { /** * En el caso de los RSS debemos crear el Channel, parece la gente de Spring se olvido de hacerlo por nosotros, ojo * con llenar bien el Channel. */ @Override protected Channel newFeed() { final Channel channel = new Channel("rss_2.0"); channel.setPubDate(new Date()); channel.setDescription("RSS Description"); channel.setTitle("TITLE"); channel.setLink("link"); channel.setCopyright("2010"); channel.setPubDate(new Date()); return channel; } /** * Build Feed Entries. */ @SuppressWarnings("unchecked") @Override protected List buildFeedEntries(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception { // Obtenemos las entradas que vienen en el modelo desde el Controller List contentList = (List) model.get("entries"); // Creamos una lista de clase de Item, el objeto de ROME que refleja cada elemento del RSS List entries = new ArrayList(contentList.size()); // Iteramos nuestras entradas del blog for (EntriesBlog content : contentList) { final Item item = new Item(); String date = String.format("%1$tY-%1$tm-%1$td", content.getPublicationDateTweet()); item.setTitle(String.format("On %s, %s publish", date, content.getQuestionBean().getQuestionName())); item.setPubDate(content.getPublicationDateTweet()); item.setLink("http://www.encuestame.org"); entries.add(entry); } return entries; } } |
Para que esta vista pueda ser interpretada por el MVC de Spring, debemos definir un RESOLVER para que pueda encontrar nuestra vista de RSS, yo siempre le doy un orden prioritario, por si tuvieramos otros RESOLVERS definidos en nuestro MVC.
Tambien agregamos como un Bean nuestra nueva vista y recordemos el ID que pronto lo usaremos.
Ahora vamos con el Controller, que es el encargado de recibir la peticion del Dispacher Servlet , usaremos Anotaciones y mapeo con REST porque somos muuuuu modernos . Yo extendi de una clase abstracta, que no tiene nada pero no es necesario para nuestro ejemplo.
@Controller public class RSSFeedController extends AbstractFeedController { /** * Build Feed Body. */ private void buildTweetPollFeedBody(String username, Model model, HttpServletRequest request, User user){ model.addAttribute("username", username); model.addAttribute("feedTitle", String.format(TWEET_POLL_FEED_TITLE, username)); model.addAttribute("url", buildDomainWithRequest(request)); //buscamos nuestras entradas de nuestro blog, por poner un ejemplo final List entries = getEntries(user.getUsername()); // las guardamos en el modelo que pasaremos a la vista y usaremos mas adelante. model.addAttribute("entries", entries); } /** * Display RSS Feed. */ // Utilizar REST es sencillo, solo debemos definir la variable entre llaves y llamarla con la anotacion @PathVariable @RequestMapping(value = "/feed/{username}/entries.rss", method = RequestMethod.GET) public String tweetPollRss(@PathVariable String username, Model model, HttpServletRequest request) { // Como queremos utilizar el mismo RSS para diferentes usuarios, buscamos nuestro usuario. final User user = getByUsername(username); if(user == null){ //TODO: if null do something. } else{ // Como somos muy ordenados creamos otro metodo. this.buildTweetPollFeedBody(username, model, request, user); } // Aqui regresaremos una cadena, que no es mas que el ID de nuestra VISTA del Bean RSS. return "rssFeedView"; } } |
Una vez creada toda esta estructura, lo siguiente es pan comido, simplemente cargar en el url la direccion de la siguiente manera, sustituyendo la variable {username} por el usuario virtual para que nos regrese los RSS de ese usuario.
http://localhost/feed/bonachon/entries.rss
Preguntas?
Con un toque made in Hollywood, excelente trailer de una historia de amor por Java, no tiene desperdicio. Lo que mas me gusta es el reparto de actores y atrices. Scala Johansson 
Sonar es un proyecto OpenSource de codehaus.org para analizar la calidad tu código en Java con diferentes tipos de métricas, solo funciona con proyectos construidos con Maven2.
Para descargar el proyecto http://sonar.codehaus.org/downloads/
La Instalación es bien sencilla, primero debes descomprimir el ZIP que descargaste y modificar el archivo sonar.properties:
#--------------------------------------------------------- # WEB # THESE SETTINGS ARE USED ONLY IN STANDALONE MODE. IGNORED WHEN THE WAR IS DEPLOYED ON A JEE SERVER. #--------------------------------------------------------- # Listen host/port and context path (for example / or /sonar). Default values are 0.0.0.0:9000/ #sonar.web.host: 0.0.0.0 sonar.web.port: 8080 #sonar.web.context: / |
La primera propiedad se refiere al IP donde tienes instalado el sonar, el segundo el puerto y la tercera propiedad el contexto en tomcat o jboss, si estamos trabajando con virtualhost no creo que haga falta que pongas un contexto.
#----- MySQL 5.x/6.x # Comment the embedded database and uncomment the following lines to use MySQL sonar.jdbc.url: jdbc:mysql://localhost:3306/sonar?useUnicode=true&characterEncoding=utf8 sonar.jdbc.driverClassName: com.mysql.jdbc.Driver sonar.jdbc.validationQuery: select 1 #----- Global database settings sonar.jdbc.username: sonar sonar.jdbc.password: sonar sonar.jdbc.maxActive: 10 sonar.jdbc.maxIdle: 5 sonar.jdbc.minIdle: 2 sonar.jdbc.maxWait: 5000 sonar.jdbc.minEvictableIdleTimeMillis: 600000 sonar.jdbc.timeBetweenEvictionRunsMillis: 30000 |
En mi caso decidi conectarlo con MySQL aunque por defecto unsa una base de datos local en Derby, debes comentar las lineas de derby y descomentar la base de datos que tu eligas, hay buen menú donde elegir, y tal vez modificar datos como el usuario y la contraseña de conexión a la bd.
Llega la hora de crear el war, en la carpeta war, corres el comando build-war.sh y publicas en tu contenedor web para java el proyecto.
El tercer paso y mas importante es la configuracion en settings.xml en Maven2, en tu repositorio local.
<profile> <id>sonar</id> <activation> <activeByDefault>true</activeByDefault> </activation> <properties> <sonar.jdbc.url>jdbc:mysql://localhost:3306/sonar</sonar.jdbc.url> <sonar.jdbc.driver>com.mysql.jdbc.Driver</sonar.jdbc.driver> <sonar.jdbc.username>sonar</sonar.jdbc.username> <sonar.jdbc.password>password</sonar.jdbc.password> <sonar.host.url>http://tudominio:8080</sonar.host.url> </properties> </profile> </profiles> |
Esta sección se agrega en la parte de PROFILES en settings.xml en Maven2. Con esto lograremos que nuestro proyecto pueda publicarse en Sonar.
Ahora, la parte mas sencilla, navegas al path de tu proyecto y corres el comando siguiente,
mvn sonar:sonar |
y el resto es pan comido, en este proceso Sonar analizara tu código y creará las métricas en el portal. Algo como lo siguiente.
http://nemo.sonarsource.org/
Hace unos dias intentando integrar Spring Security 3.0 con Spring Web Flow en su última version 2.0.9 al día de hoy, como en el ejemplo siguiente.
<bean id="securityFlowExecutionListener" class="org.springframework.webflow.security.SecurityFlowExecutionListener" /> <webflow:flow-executor id="flowExecutor" flow-registry="flowRegistry"> <webflow:flow-execution-listeners> <webflow:listener ref="securityFlowExecutionListener" /> </webflow:flow-execution-listeners> </webflow:flow-executor> |
Esta configuracion en Web Flow basicamente lo que hace es que podamos restringir ciertas vistas o flujos enteros en base a Roles con Spring Security
<secured attributes="ROLE_USER"/> <view-state id="main"> <on-render> <render fragments="zona3"/> </on-render> <transition on="paso1" to="reviewHotels"> <secured attributes="ROLE_EDITOR"/> <evaluate expression="bean.metodo1()" /> <render fragments="zona1"/> </transition> <transition on="paso2" > <secured attributes="ROLE_ADMIN"/> <evaluate expression="bean.metodo2() /> <render fragments="zona1"/> </transition> </view-state> |
y obtenia este error al compilar.
Caused by: java.lang.ClassNotFoundException: org.springframework.security.vote.AffirmativeBased at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1387) at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1233) ... 65 more |
Pero parece no tener solución por ahora salvo que tu apliques el parche publicado en JIRA hace unos dias.
Aunque hoy mismo publicaron que el parche saldria hasta la versión Spring Web Flow 2.1 y no en la 2.0.9 como hace 48 horas estaba publicado.
https://jira.springsource.org/browse/SWF/fixforversion/11441
En pocas palabras, a esperar.
Vamos con algo sencillo el día de hoy. Ante la llegada hace unos meses ya de Spring Security 3.0 y con estupendas novedades y sus cambios.
Si ya has migrado te habrás dado cuenta que muchos de los nombres de los paquetes han cambiado.
import org.springframework.security.Authentication; import org.springframework.security.context.SecurityContext; import org.springframework.security.context.SecurityContextHolder; import org.springframework.security.context.SecurityContextImpl; import org.springframework.security.providers.openid.OpenIDAuthenticationStatus; import org.springframework.security.providers.openid.OpenIDAuthenticationToken; import org.springframework.security.userdetails.UserDetails; import org.springframework.security.userdetails.UserDetailsService; |
antes se llamaban
import org.springframework.security.core.Authentication; import org.springframework.security.core.context.SecurityContext; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.context.SecurityContextImpl; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.openid.OpenIDAuthenticationStatus; import org.springframework.security.openid.OpenIDAuthenticationToken; |
No solo estas clases han cambiado, en mi migración de hace unos dias me encontre que con el 70% de las clases que usaba habian sido cambiadas, fue todo un dolor de cabeza al principio.
Nota: no te olvides de agregar los filtros en el web.xml eso no ha cambiado para nada en la 3.0.
Yo ahora mismo estoy trabajando con la versión 3.0.2.RELEASE y es bastante estable aunque tiene un bug con la integración en Spring Web Flow.
El uso de propiedades en Maven es muy recomendable, si mañana quieres actualizar a otra versión es mucho mas comodo cambiar en un solo lugar, existen muchos otros JAR disponibles en Spring Security como (CAS, ASL o Spring Web) que tambien puedes agregar como dependencia, segun tus necesidades.
<properties> <spring.security.version>3.0.2.RELEASE</spring.security.version> </properties> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-config</artifactId> <version>${spring.security.version}</version> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-core</artifactId> <version>${spring.security.version}</version> <exclusions> <exclusion> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-ldap</artifactId> <version>${spring.security.version}</version> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-openid</artifactId> <version>${spring.security.version}</version> <scope>compile</scope> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-taglibs</artifactId> <version>${spring.security.version}</version> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-web</artifactId> <version>${spring.security.version}</version> </dependency> |
Otra cosa que debes modificar o agregar si es una nueva configuración es en los namespaces.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:security="http://www.springframework.org/schema/security" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd"> </beans> |
Spring Security 3.0 nos permite desde una configuración sencilla hasta las mas completas, según la documentacion esto es lo mínimo que necesitas.
En este caso se podria llamar una versión amateur de la configuración real con beans en Spring Security, ellos nos ofrecen este
<http auto-config='true'> <intercept-url pattern="/**" access="ROLE_USER" /> </http> |
Y pudiendose extender a algo mas complejo (complejo dentro de la sencille) como:
<security:http auto-config="false" entry-point-ref="authenticationEntryPoint" access-decision-manager-ref="voteAccessDecisionManager" > <security:intercept-url pattern="/**" access="ENCUESTAME_ANONYMOUS" /> <security:intercept-url pattern="/admon/**/*" access="ENCUESTAME_ADMIN" /> <security:intercept-url pattern="/tweet/" access="ENCUESTAME_ANONYMOUS" /> <security:intercept-url pattern="/" access="ENCUESTAME_ANONYMOUS" /> <security:intercept-url pattern="/**/*.xhtml" filters="none" /> <security:intercept-url pattern="/**/*.css" filters="none" /> <security:intercept-url pattern="/images/**" filters="none" /> <security:intercept-url pattern="/js/**" filters="none" /> <security:remember-me key="12345" services-alias="_rememberMeServices" /> <security:anonymous key="12345" /> <security:logout logout-success-url="/index.html" logout-url="/logout"/> <security:custom-filter position="FORM_LOGIN_FILTER" ref="authenticationFilter" /> <security:custom-filter position="ANONYMOUS_FILTER" ref="anonymousAuthFilter" /> </security:http> |
Para aprender algo más sobre los multiples filtros que ofrece Spring Security en versiones anteriores, en este mismo blog postee algunos artículos.
Git es un repositorio de datos que esta ganándole mucho terreno a SVN, existe una comunidad (GIT HUB) donde se podrán encontrar muchos proyectos en Git para practicar lo que vamos hablar a continuación.
Para descargar un proyecto solo debes clonarlo de la siguiente manera.
git clone git://github.com/jquery/jquery.git |
Gitstats es un proyecto de Heikki Hokkanen que podrás encontrar en http://gitstats.sourceforge.net/ , este proyecto esta desarrollado en Python y es muy sencillo de usar, necesitas tener instalado Git y Gnuplot para poder generar los gráficos como el de abajo.
Para generar las estadisticas solo debes ejecutar lo siguiente:
./gitstats /pathToGitRepo/ pathToGenerateHTMLStats/ |
Un proyecto parecido al anterior, pero en este caso es algo diferente, esta desarrollado en PHP y Perl y lo puedes encontrar en http://sourceforge.net/projects/gitstat/, solo debes crear una base de datos y preparar el archivo de configuracion config.pl que luego deberás poner en un Cron para que el actualice periódicamente las estadísticas, el almacena los cambios en la base de datos. Lo curioso de este proyectos es que esta alojado en un repositorio CVS, como dice el refran, en casa de herrero, cuchillo de palo.
