El IDE Netbeans puede ser bajado de forma gratuita de su página oficial http://www.netbeans.com/, en este tutorial suponemos un manejo básico de este IDE.
Para empezar a trabajar es necesario agregar un plugin al Netbeans, este proceso se describe claramente en el siguiente link:
Ahora se crea un nuevo proyecto web añadiendo los frameworsk de Vaadin, Spring e Hibernate.
Se modifican los diferentes archivos xml, como lo son el web.xml y los archivos de configuracion de spring applicationContext.xml y dispatcher-servlet.xml, ademas informacion de conexion con la base de datos para hibernate en un archivo properties.
web.xml (Descriptor comun que controla el comportamiento de la web)
applicationContext.xml (fichero de configuración básico de Spring)
Aca definimos los beans basicos y demas configuraciones necesarias para el proyecto.
application.propertiesAlmacena los parámetros configurables de una aplicación. También se puede utilizar para el almacenamiento de cadenas para la internacionalización y localización (i18n).
Se crea servlet para trabajar con Vaadin y con Spring convinados
web.xml (Descriptor comun que controla el comportamiento de la web)
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet>
<servlet-name>VaadinApplication</servlet-name>
<servlet-class>com.ejemplo.vaadin.util.AutowiringApplicationServlet</servlet-class>
<init-param>
<param-name>application</param-name>
<param-value>com.ejemplo.vaadin.MyApplication</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/vaadin/html/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>VaadinApplication</servlet-name>
<url-pattern>/vaadin/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>VaadinApplication</servlet-name>
<url-pattern>/VAADIN/*</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>
30
</session-timeout>
</session-config>
<welcome-file-list>
<welcome-file/>
</welcome-file-list>
</web-app>Aca definimos los beans basicos y demas configuraciones necesarias para el proyecto.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<context:property-placeholder location = "classpath:application.properties"/>
<!-- ############ Inicio Hibernate ############ -->
<!-- DATASOURCE DECLARATION -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- HIBERNATE SESSION FACTORY -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.generate_statistics">${hibernate.generate_statistics}</prop>
</props>
</property>
<property name="annotatedClasses">
<list>
<value>com.ejemplo.vaadin.entidades.Usuario</value>
</list>
</property>
<property name="eventListeners">
<map>
<entry key="merge">
<bean class="org.springframework.orm.hibernate3.support.IdTransferringMergeEventListener"/>
</entry>
</map>
</property>
</bean>
<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"
p:sessionFactory-ref="sessionFactory"/>
<!-- ############ Fin Hibernate ############ -->
<context:annotation-config />
<tx:annotation-driven/>
<aop:aspectj-autoproxy/>
<!-- Scan por los DAO -->
<context:component-scan base-package="com.ejemplo.vaadin.dao"/>
<!-- Declaramos los servicios explicitamente para poder referenciarlos-->
<bean class="com.ejemplo.vaadin.servicios.impl.ServicioUsuariosImpl" id="servicioUsuarios"/>
</beans> <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<context:annotation-config />
<context:component-scan base-package="com.ejemplo.vaadin.rest"/>
<bean id="contentNegotiatingViewResolver"
class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
<property name="favorPathExtension" value="true" />
<property name="favorParameter" value="true" />
<!--
default media format parameter name is 'format'
-->
<property name="ignoreAcceptHeader" value="false" />
<property name="order" value="1" />
<property name="mediaTypes">
<map>
<entry key="html" value="text/html"/>
<entry key="json" value="application/json" />
<entry key="xml" value="application/xml" />
</map>
</property>
<property name="viewResolvers">
<list>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
</bean>
</list>
</property>
<property name="defaultViews">
<list>
<bean class="org.springframework.web.servlet.view.json.MappingJacksonJsonView" />
<bean class="org.springframework.web.servlet.view.xml.MarshallingView">
<constructor-arg>
<bean class="org.springframework.oxm.xstream.XStreamMarshaller" />
</constructor-arg>
</bean>
</list>
</property>
</bean>
<!-- Configure the multipart resolver -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- the maximum file size in bytes -->
<property name="maxUploadSize" value="20000000"/>
</bean>
</beans>application.propertiesAlmacena los parámetros configurables de una aplicación. También se puede utilizar para el almacenamiento de cadenas para la internacionalización y localización (i18n).
################ BD ############################
## ESPECIFICOS DE LA BD
## BD DESARROLLO ###############################
jdbc.driverClassName=org.postgresql.Driver
## SERVIDOR BD
jdbc.url=jdbc:postgresql://localhost:5432/ejemplo
jdbc.username=usuario
jdbc.password=contrasena
#
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
############################################################
## FIN SERVIDOR BD
## HIBERNATE SETTINGS
hibernate.generate_statistics=true
hibernate.show_sql=false
hibernate.hbm2ddl.auto=false
########################################################Se crea servlet para trabajar con Vaadin y con Spring convinados
Servlet necesario para trabajar con Spring y Vaadin relacionados, se define en el web.xml, permite la inyeccion de los beans definidos en el applicationContext.
Si desean compilar el proyecto usando maven este seria el pom.xml:
Siguiente: Modelo
Volver al menú
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.ejemplo.vaadin.util;
import com.vaadin.Application;
import com.vaadin.terminal.gwt.server.ApplicationServlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
//import org.apache.log4j.Logger;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
/**
* {@link ApplicationServlet} that autowires and configures the {@link Application}
* objects it creates using the containing Spring {@link WebApplicationContext}.
*
* <p>
* When using this servlet, annotations such as
* <code>@{@link org.springframework.beans.factory.annotation.Autowired Autowired}</code>
* and <code>@{@link org.springframework.beans.factory.annotation.Required Required}</code>
* and interfaces such as {@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware},
* etc. will work on your {@link Application} instances.
* </p>
*
* <p>
* An example:
* <blockquote><pre>
* <bean id="applicationServlet" class="org.springframework.web.servlet.mvc.ServletWrappingController"
* p:servletClass="com.example.AutowiringApplicationServlet">
* <property name="initParameters">
* <props>
* <prop key="application">some.spring.configured.Application</prop>
* <prop key="productionMode">true</prop>
* </props>
* </property>
* </bean>
* </pre></blockquote>
*
* @see org.springframework.web.servlet.mvc.ServletWrappingController
* @see AutowireCapableBeanFactory
*/
public class AutowiringApplicationServlet extends ApplicationServlet {
// protected final Logger log = Logger.getLogger(getClass());
private WebApplicationContext webApplicationContext;
/**
* Initialize this servlet.
*
* @throws ServletException if there is no {@link WebApplicationContext} associated with this servlet's context
*/
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
// log.debug("finding containing WebApplicationContext");
System.out.println("finding containing WebApplicationContext");
try {
this.webApplicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(config.getServletContext());
} catch (IllegalStateException e) {
throw new ServletException("could not locate containing WebApplicationContext");
}
}
/**
* Get the containing Spring {@link WebApplicationContext}.
* This only works after the servlet has been initialized (via {@link #init init()}).
*
* @throws ServletException if the operation fails
*/
protected final WebApplicationContext getWebApplicationContext() throws ServletException {
if (this.webApplicationContext == null) {
throw new ServletException("can't retrieve WebApplicationContext before init() is invoked");
}
return this.webApplicationContext;
}
/**
* Get the {@link AutowireCapableBeanFactory} associated with the containing Spring {@link WebApplicationContext}.
* This only works after the servlet has been initialized (via {@link #init init()}).
*
* @throws ServletException if the operation fails
*/
protected final AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws ServletException {
try {
return getWebApplicationContext().getAutowireCapableBeanFactory();
} catch (IllegalStateException e) {
throw new ServletException("containing context " + getWebApplicationContext() + " is not autowire-capable", e);
}
}
/**
* Create and configure a new instance of the configured application class.
*
* <p>
* The implementation in {@link AutowiringApplicationServlet} delegates to
* {@link #getAutowireCapableBeanFactory getAutowireCapableBeanFactory()}, then invokes
* {@link AutowireCapableBeanFactory#createBean AutowireCapableBeanFactory.createBean()}
* using the configured {@link Application} class.
* </p>
*
* @param request the triggering {@link HttpServletRequest}
* @throws ServletException if creation or autowiring fails
*/
@Override
protected Application getNewApplication(HttpServletRequest request) throws ServletException {
Class<? extends Application> cl = null;
try {
cl = getApplicationClass();
} catch (ClassNotFoundException e) {
// log.error( "failed to find the application class" );
System.out.println("failed to find the application class");
}
// log.debug("creating new instance of " + cl);
System.out.println("creating new instance of " + cl);
AutowireCapableBeanFactory beanFactory = getAutowireCapableBeanFactory();
try {
return beanFactory.createBean(cl);
} catch (BeansException e) {
throw new ServletException("failed to create new instance of " + cl, e);
}
}
}Si desean compilar el proyecto usando maven este seria el pom.xml:
Siguiente: Modelo
Volver al menú
Link de ayuda para codigo
ResponderEliminarhttp://codeformatter.blogspot.com/2009/06/about-code-formatter.html
Pregunta...¿cómo me ayuda a desarrollar sitios de manera productiva, concisa y sin preocuparme en cómo funciona el framework, sino más bien cómo resolver problemas?
ResponderEliminarNo dudo que la aplicación quede bien, y sea algo genial, pero, los proyectos en base a configuración en mi experiencia son difíciles de llevar (sobretodo cuando los requerimientos cambian). Pero por ejemplo con jQueryUI y un framework cómo Play! (para Java) o uno cómo Lift (para Scala); creo que puedes hacer lo mismo.
El código es 100% Java. 100% comprobable en compile time, 100% testeable con JUnit. Con plugins como IcePush y algún event bus, podés hacer cosas con dos líneas de código que con otro framework requerirían muchas líneas en javascript/html/java. Reutilizar componentes con vaadin es tán fácil como instanciar un objeto.
EliminarExisten muchas soluciones informáticas para hacer estas cosas son tantas que no las conozco todas, en el caso de estos frameworks yo utilizo un aplicación base que tomo como referencia para construir cualquier otra aplicación construyendo la lógica del negocio según lo necesite. En este pos solo se muestra la configuración necesaria para empezar a trabajar, siendo así según lo que dije antes solo debo cuadrar la configuración de la base de datos y empezar a construir.
ResponderEliminarTambién hay soluciones estilo symphonyPHP que ejecutas un comando y te construye todo, pero no me gusta desconocer tanto lo que se crea.
ResponderEliminarhola, quisiera hacer esto mismo para aprender, pero utilizando eclipse en lugar de netbeams. se puede? no encuentro la forma de poder crear un proyecto y que me permita escoger los multiples frameworks con los que quiero trabajar como si te aparece con netbeams
ResponderEliminarNo he hecho mucho en eclipse pero en generar la única diferencia para construir el proyecto es como agrega el IDE las librerias, pero en esencia es se busca lo mismo, otro que puedes tratar es trabajar con maven y ahí no importaría si es netbeans o eclipse
ResponderEliminar