Skip to main content

Home/ Java Development/ Group items tagged IDE

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
Hendy Irawan

Querydsl - 0 views

www.querydsl.com

java querydsl query data repository database JPA DB

shared by Hendy Irawan on 26 Apr 11 - No Cached
  • Hendy Irawan on 26 Apr 11
     
    Querydsl is a framework which enables the construction of type-safe SQL-like queries for multiple backends including JPA, JDO and SQL in Java. Instead of writing queries as inline strings or externalizing them into XML files they are constructed via a fluent API. Code completion in IDE (all properties, methods and operations can be expanded in your favorite Java IDE) Almost no syntactically invalid queries allowed (type-safe on all levels) Domain types and properties can be referenced safely (no Strings involved!) Adopts better to refactoring changes in domain types Incremental query definition is easier Querydsl is licensed under the LGPL 2.1 license.
Hendy Irawan

Eclipse Java development tools (JDT) - 0 views

www.eclipse.org/jdt

jdt java eclipse plugin ide development tools javaEE programming

shared by Hendy Irawan on 03 Dec 10 - Cached
  • Hendy Irawan on 03 Dec 10
     
    The JDT project provides the tool plug-ins that implement a Java IDE supporting the development of any Java application, including Eclipse plug-ins. It adds a Java project nature and Java perspective to the Eclipse Workbench as well as a number of views, editors, wizards, builders, and code merging and refactoring tools. The JDT project allows Eclipse to be a development environment for itself.
Hendy Irawan

eik - Eclipse Integration for Apache Karaf runtimes - Google Project Hosting - 0 views

code.google.com/...eik

eclipse integration apache eik Karaf OSGi launcher plugin IDE

shared by Hendy Irawan on 05 May 11 - No Cached
  • Hendy Irawan on 05 May 11
     
    Eclipse Integration for Karaf is the integration of the Apache Karaf application platform and the Eclipse IDE. Notable features include: An Eclipse Run/Debug launcher configuration that configures Karaf to run inside the workbench transparently to the developer Automatic deployment of workspace plugin projects to running Karaf instances without copying files A Target Platform Definition that allows developers to target only the bundles found in Karaf distributions A Target Platform Provisioner that automatically constructs a target platform from any Karaf distribution on the user's local disk JMX instrumentation of the Running/Debugging Karaf instance. Eclipse views that display the Bundle and Service status of Karaf instances Experimental features: Web Tools Platform integration including: Karaf server runtime with associated classpath maintenance Karaf runtime locator that scans local disks for compatible Karaf distributions Install from the EIK Update Site
Hendy Irawan

jMock - An Expressive Mock Object Library for Java - 3 views

www.jmock.org

java testing mock development junit test framework library

shared by Hendy Irawan on 09 Jan 09 - Cached
  • anonymous on 09 Jan 09
     
    JMock is a library that supports test-driven development1 of Java2 code with mock objects3. Mock objects help you design and test the interactions between the objects in your programs.
  • Hendy Irawan on 22 Jun 11
     
    "JMock is a library that supports test-driven development of Java code with mock objects. Mock objects help you design and test the interactions between the objects in your programs. The jMock library: makes it quick and easy to define mock objects, so you don't break the rhythm of programming. lets you precisely specify the interactions between your objects, reducing the brittleness of your tests. works well with the autocompletion and refactoring features of your IDE plugs into your favourite test framework is easy to extend."
Hendy Irawan

Seam Framework - Home - 0 views

seamframework.org/Seam3

framework java jsf javaee seam development web

shared by Hendy Irawan on 19 Jul 10 - Cached
  • Hendy Irawan on 19 Jul 10
     
    "Seam 3 is collection of modules and developer tools based on the Java EE platform. The modules are portable extensions to CDI that integrate with other technologies to extend the core Java EE functionality. These modules bring you many of the beloved features and integrations from Seam 2 (security, internationalization, JSF, rules, business process management) and also branch out into new areas. IDE support is provided by the JBoss Tools Eclipse plugins. Before diving in, get up to speed with the status and direction of Seam 3. Also be sure to check out the latest news at the bottom of the page. "
anonymous

Getting Started with RequestFactory - Google Web Toolkit - Google Code - 0 views

code.google.com/...DevGuideRequestFactory.html

shared by anonymous on 10 Jan 11 - No Cached
  • Entity Proxies
    • anonymous
      anonymous on 10 Jan 11
       
      Proxy type (on the Client) vs Entity type (on the server)
  • proxy types
  • entity types
  • ...147 more annotations...
  • methods that return service stubs
  • one RequestFactory interface for your application
  • employeeRequest();
  • @Service(Employee.class)
  • extends RequestContext
  • extends RequestFactory
  • service stub
  • RequestFactory service stubs
  • must extend RequestContext
  • The methods in a service stub do not return entities directly
  • return subclasses of com.google.gwt.requestfactory.shared.Request.
  • This allows the methods on the interface to be invoked asynchronously with
  • Request.fire()
  • fire(    new Receiver()
  • onSuccess
  • callers pass an AsyncCallback that implements onSuccess()
  • takes a Receiver which must implement onSuccess()
  • Receiver is an abstract class having a default implementation of onFailure()
  • you can extend Receiver and override onFailure()
  • onViolation()
  • any constraint violations on the server
  • The Request type returned from each method
  • parameterized with the return type of the service method.
  • Methods that have no return value should return type Request<Void>
  • BigDecimal, BigInteger, Boolean, Byte, Enum, Character, Date, Double, Float, Integer, Long, Short, String, Void
  • subclass of EntityProxy
  • List<T> or Set<T>
  • primitive types are not supported
  • methods that operate on an entity itself
  • like persist() and remove()
  • return objects of type InstanceRequest rather than Reques
  • Server Implementations
  • methods defined in an
  • entity's service interface
  • implemented in the class named
  • @Service annotation
  • in these examples, is the entity class
  • service implementations do not directly implement the RequestContext interface
  • server-side implementations use the domain entity types
  • @Entity
  • EntityManager
  • createQuery
  • getResultList();
  • entityManager()
  • createEntityManager()
  • em.persist(this);
  • em.remove(attached
  • em.close();
  • defined in the service's
  • RequestContext interface
  • even though the implementation does not formally implement the interface in Java
  • name and argument list for each method
  • same on client and server
  • Client side methods
  • return Request<T>
  • only T on the server
  • EntityProxy types become the domain entity type on the server
  • Methods that return a Request object in the client interface are implemented as static methods on the entity
  • Methods that operate on a single instance of an entity, like persist() and remove(),
  • eturn an
  • InstanceRequest
  • in the client interface
  • Instance methods do not pass the instance directly, but rather via the
  • using()
  • instance methods must be implemented as non-static methods in the entity type
  • Four special methods are required on all entities
  • as they are used by the RequestFactory servlet:
  • constructor
  • findEntity
  • An entity's getId()
  • is typically auto-generated by the persistence engine (JDO, JPA, Objectify, etc.)
  • "find by ID" method has a special naming convention
  • find()
  • "find" plus the type's simple name
  • On the server
  • getVersion() method is used by RequestFactory to infer if an entity has changed
  • backing store (JDO, JPA, etc.) is responsible for updating the version each time the object is persisted,
  • RequestFactoryServlet sends an UPDATE
  • if an entity changes as
  • Second, the client maintains a version cache of recently seen entities
  • Whenever it sees an entity whose version has changed, it fires
  • UPDATE events on the event bus
  • so that listeners can update the view
  • GWT.create
  • and initialize it with your application's EventBus
  • GWT.create
  • requestFactory.initialize
  • create a new entity on the client
  • EmployeeRequest request
  • EmployeeProxy newEmployee
  • All client-side code should use the EmployeeProxy
  • not the Employee entity itself
  • unlike GWT-RPC, where the same concrete type is used on both client and server
  • RequestFactory
  • designed to be used with an ORM layer like JDO or JPA
  • on the server
  • to build data-oriented (CRUD) apps with an ORM-like interface
  • on the client
  • easy to implement a data access layer
  • structure your server-side code in a data-centric way
  • GWT-RPC, which is service-oriented
  • On the client side, RequestFactory keeps track of objects that have been modified and sends only changes
  • lightweight network payloads
  • solid foundation for automatic batching and caching of requests in the future
  • RequestFactoryServlet
  • RequestFactory uses its own servlet
  • own protocol
  • not designed for general purpose services like GWT-RPC
  • implements its
  • It is designed specifically for implementing a persistence layer on both client and server.
  • In persistence frameworks like JDO and JPA, entities are annotated with
  • client-side representation of an entity
  • known as a
  • DTO (Data Transfer Object)
  • hook used to indicate that an object can be managed by RequestFactory
  • RequestFactory
  • EntityProxy interface
  • automatically populates bean-style properties between entities on the server and the corresponding EntityProxy on the client,
  • send only changes ("deltas") to the server
  • extends EntityProxy
  • interface
  • @ProxyFor
  • reference the server-side entity being represented
  • It is not necessary to represent every property and method from the server-side entity in the EntityProxy
  • EntityProxyId returned by this method is used throughout RequestFactory-related classes
  • while getId() is shown in this example, most client code will want to refer to
  • EntityProxy.stableId() i
  • to represent any type
  • is not required to expose an ID and version
  • often used to represent embedded object types within entities
  • @Embedded
  • Address
  • Address type
  • POJO with no persistence annotations
  • Address is represented as a ValueProxy
  • extends ValueProxy
  • interface
  • extends EntityProxy
  • interface
  • AddressProxy
  • AddressProxy
  • ValueProxy can be used to pass any type to and from the server
  • RequestFactory
  • interface between your client and server code
  • RequestContext interface
  • The server-side service
  • must implement each method
Hendy Irawan

Bndtools - Simple, powerful OSGi tools for Eclipse - 0 views

njbartlett.name/bndtools.html

tools bndtools simple powerful eclipse osgi repository p2 build plugin pde bnd

shared by Hendy Irawan on 29 Apr 11 - No Cached
  • Hendy Irawan on 29 Apr 11
     
    Bndtools is an Eclipse-based development environment for OSGi bundles and applications that focuses on: Ease of use and a rapid development lifecycle; Encouraging OSGi best practices; Producing accurate bundle metadata to maximise re-usability; Integration with offline build tools and users of other IDEs. See Features for a summary of Bndtools features. Bndtools is based on Bnd, the powerful bundle tool created by Peter Kriens. Please read Why Bndtools? to learn why Bndtools has been created and why you should use it for OSGi development in Eclipse.
anonymous

The BalusC Code: ImageServlet - 1 views

balusc.blogspot.com/...imageservlet.html

image servlet java database

shared by anonymous on 15 May 11 - No Cached
  • anonymous on 15 May 11
     
Mahmoud Rabie

Using AspectJ to log all methods parameters and return values during application runtime - 8 views

www.adevedo.com/...ues-during-application-runtime

java aspectj log4j logging

shared by Mahmoud Rabie on 09 Oct 12 - No Cached
Cohen Calvin liked it
  • Mahmoud Rabie on 09 Oct 12
     
    AspectJ is an aspect-oriented extension created at PARC for the Java programming language. It is available in Eclipse Foundation open-source projects, both stand-alone and integrated into Eclipse. AspectJ has become the widely used de-facto standard for AOP by emphasizing simplicity and usability for end users. It uses Java-like syntax and has included IDE integrations for displaying crosscutting structure since its initial public release in 2001. In this article we will describe how we can use AspectJ to do the logging job for all methods parameters and methods return values in a Java application
anonymous

Free Open Source UML Tools - 0 views

www.devcurry.com/...ree-open-source-uml-tools.html

ide opensource java uml

shared by anonymous on 19 Aug 12 - No Cached
  • anonymous on 19 Aug 12
     
    "UML Editors` "
Paul Sydney Orozco

Tutorial On Spring with Hibernate and Java Persistence API - 0 views

www.adobocode.com/...ing-with-hibernate-annotations

spring hibernate annotations hbm.xml Entity Table Id Column mysql tutorial

shared by Paul Sydney Orozco on 25 Nov 10 - No Cached
  • Paul Sydney Orozco on 25 Nov 10
     
    Sample of using Hibernate Annotations by reducing XML configuration files thus making it simpler to define required metadata directly into our Java code. When using annotations, we no longer need the additional mapping file (*.hbm.xml). The metadata for the ORM is specified in the individual classes.
Paul Sydney Orozco

How to create Dynamic Web Project in Eclipse - 0 views

www.adobocode.com/...project-environment-in-eclipse

dynamic web project eclipse IDE

shared by Paul Sydney Orozco on 25 Nov 10 - No Cached
  • Paul Sydney Orozco on 25 Nov 10
     
    A tutorial on how to create a dynamic web project in eclipse
Baron M

GAME OVER - Java Server Faces | ComeSolveGo - 0 views

www.comesolvego.com/...game-over-java-server-faces

java jsf

shared by Baron M on 23 Jul 08 - Cached
  • Almost everything is wrong with the framework
  • Little control over generated HTML
  • While you need basic functionalities, everything is fine. When you need to modify the component (which is configurable, right?) you are facing the problems
  • ...8 more annotations...
  • EXTREMELY idiotic thing - because JSF has their famous lifecycle with lots of magic phases, some backing bean getters are called multiple times!
  • Back button problem.
  • Unreadable URLs. JSF always does the POST.
  • JSF is submitting a form on itself so it could call a backing bean method to handle an event. Of course, if you have a request, there is unnecessary repeated initialization, getter calls, postconstruct etc
  • Reusability? Good joke…
  • JSF - you are FIRED!
  • IDE support
  • Development of custom component? No way, extremely complicated. Extensible? In the movie, maybe…
  • Baron M on 23 Jul 08
     
    I think many people have the same feeling (of course including me)
Hendy Irawan

Eclipse Buckminster Project - 0 views

www.eclipse.org/buckminster

automation deploy development framework ide maven plugin programming java components project eclipsepedia buckminster eclipse build system management tools

shared by Hendy Irawan on 03 Jan 11 - Cached
  • Hendy Irawan on 03 Jan 11
     
    * Buckminster is a set of frameworks and tools for automating build, assemble & deploy (BA&D) development processes in complex or distributed component-based development. Buckminster allows development organizations to define fine-grained "production
Rinav G

JavaBlogging » What is serialVersionUID? - 2 views

www.javablogging.com/what-is-serialversionuid

java Serializable serialVersionUID

shared by Rinav G on 09 Nov 10 - Cached
  • private static final long serialVersionUID = 1L
  • and it is still there even after the program finished. Let’s see if we can read that file once again, this time without creating it first.
  • Now, let’s see what happens, when we change the serialVersionUID value and try to deserialize once again our file. Change the line 2 in the class SerializeMe so that serialVersionUID contains now 2 instead of 1:
  • ...13 more annotations...
  • serialVersionUID = 2L;
  • static final
  • Exception in thread "main" java.io.InvalidClassException:
  • As you can see, this time the deserialization didn’t go well. ObjectInputStream complained about the serialVersionUID being changed.
  • How does he know that it changed? If serialVersinUID is static, then it should not have been serialized in the first place, and there should be no information about the previous value 1 during the deserialization, right? Well, serialVersionUID is an exception to the rule that “static fields don’t get serialized”.
  • Moreover, if there is no serialVersionUID officially declared in the class to be serialized, compiler automatically adds it with a value generated based on the fields declared in the class.
  • The deserialization of that object does not necessarily have to occur exactly after serialization. It can occur after a few months or on a completely different JVM
  • there is a chance that the class declaration has changed between serialization and deserialization.
  • It checks if the data read from the input stream is compatible with the current definition of the class.
  • when the visibility of a field changes, the serialVersionUID changes too.
  • sometimes you just want for some reason to forbid deserialization of old serialized objects,
  • you might tend to write it once for every serializable class ( or have it generated by the IDE ) and forget about it. WRONG !!!
  • If you write it once and don’t take care to update it when necessary, you loose all the merits of serialVersionUID.
  • Rinav G on 09 Nov 10
     
    What is serialVersionUID? What is it Used For???
1 - 18 of 18
Showing 20▼ items per page