Skip to main content

Home/ Java Development/ Group items tagged started

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
Justin Pierce

Enjoy An Excellent Bookkeeping Service - 1 views

It is a small grocery with just 4 staff that I started 6 months ago. I thought I can smoothly run it on my own. But then I noticed that I always encounter troubles in doing the payroll and other mo...

started by Justin Pierce on 28 Dec 12 no follow-up yet
mahesh 1234

Java Tutorial - javatpoint - 0 views

www.javatpoint.com/java-tutorial

shared by mahesh 1234 on 23 Dec 13 - No Cached
  • mahesh 1234 on 23 Dec 13
     
    Java technology is widely used currently. Let's start learning of java from basic questions like what is java, where it is used, what type of applications are created in java and why use java? What is Java? Java is a programming language and a platform.
anonymous

Organize Projects - Google Web Toolkit - Google Code - 0 views

code.google.com/...evGuideOrganizingProjects.html

shared by anonymous on 14 Jan 11 - Cached
  • com.google.gwt.gears.Gears
    • anonymous
      anonymous on 14 Jan 11
       
      Gears.gwt.xml does not define andy entry point. It can only be inherits
  • two ways to approach loading them
  • nclude each module with a separate <script> tag
  • ...118 more annotations...
  • Create a top level module XML definition
  • Compile the top level module
  • the second approach will lead to much better end-user performance
  • each module has to be downloaded separately by the end-user's browser
  • each module will contain redundant copies of GWT library
  • conflict with each other during event handling
  • Linkers are divided into three categories, PRE, POST, and PRIMARY
  • one primary linker is run for a compilation
  • everal linkers are provided by Core.gwt.xml, which is automatically inherited by User.gwt.xml.
  • monolithic JavaScript file.
  • cross-site deployment model.
  • standard iframe-based
  • <add-linker name="xs" />
  • The GWT compiler
  • packaging its output with the Linker subsystem
  • responsible for the final packaging of the JavaScript code
  • providing a pluggable bootstrap mechanism
  • re-use an existing Java API for a GWT project,
  • <super-source>
  • "re-root" a source path
  • to emulate part of the JRE not implemented by GWT
  • tells the compiler to add all subfolders of com/example/myproject/jre/
  • to the source path
  • com/google/myproject/gwt/jre/java/util/UUID.java
  • most commonly used elements in the module XML file.
  • <inherits name="
  • herits all the settings from the specified module
  • <entry-point class=
  • Entry points are all compiled into a single codebase
  • when the onModuleLoad() of your first entry point finishes, the next entry point is called immediately.
  • Any number of entry-point classes can be added
  • <source path="
  • resources get copied into the output directory during a GWT compile.
  • client subpackage is implicitly added to the source path
  • <public path="path" />
  • treated as a publicly-accessible resource.
  • resources get copied into the output directory
  • the public subpackage is implicitly added to the public
  • <servlet
  • For RPC, this element loads a servlet class
  • mounted at the specified URL path
  • path=
    • anonymous
      anonymous on 14 Jan 11
       
      monting location
  • class="
    • anonymous
      anonymous on 14 Jan 11
       
      Which servlet class
  • URL path should be absolute
  • @RemoteServiceRelativePath attribute
  • you must configure a WEB-INF/web.xml in your war directory to load any servlets needed.
  • n development mode,
  • <script src="
  • external JavaScrip
  • <stylesheet src="
  • Extends the set of values
  • for an existing client property
  • <replace-with-class>
  • <generate-with-class>
  • <when-property-is
  • three different types of predicates are
  • <when-type-assignable
  • <when-type-is
  • <all>
  • <any>
  • <none>
  • GWT libraries are organized into modules
  • you want to inherit at least the User module
  • contains all the core GWT functionality
  • including the EntryPoint class
  • widgets and panels
  • History feature
  • Internationalization
  • DOM programming, and more
  • Low-level HTTP
  • Use the following syntax to cause an external JavaScript file to be loaded
  • before your module entry point is called.
  • as if you had included it explicitly using the HTML <script
  • loaded before your onModuleLoad() is called.
  • all included scripts will be loaded when your application starts, in the order in which they are declared.
  • associate external CSS files with your module
  • GWT.getModuleBaseURL() + "foo.css" in client code
  • module's public path
  • useful when
  • inheritance makes resource inclusion particularly convenient.
  • If you wish to create a reusable library that relies upon particular stylesheets or JavaScript files, you can be sure that clients
  • see the documentation for FileSet for a general overview
  • <public>
  • <super-source>
  • <source>
  • includes
  • excludes
  • defaultexcludes
  • casesensitive
  • By default, the patterns listed here are excluded.
  • defaultexcludes is true
  • <script src='myApp/myApp.nocache.js'></script>
  • <script> tags always block evaluation of the page
  • <img> tags do not block page evaluation
  • two simultaneous connections
  • The body.onload() event will only fire once all external resources are fetched, including images and frames.
  • GWT selection script
  • like a normal script tag
  • but the compiled script will be fetched asynchronously.
  • Parsing is blocked until externalScriptZero.js is done fetching and evaluating.
  • myApp/myApp.nocache.js completes
  • the compiled scrip
  • (<hashname>.cache.html
  • begins fetching in a hidden IFRAME (this is non-blocking).
  • onModuleLoad() is not called yet, as we're still waiting on externalScriptOne.js
  • body.onload() fires
  • onload='alert("w00t!")
    • anonymous
      anonymous on 14 Jan 11
       
      is the last line executed
  • put the GWT selection script as early as possible
  • because it won't block any other script requests
  • <img> tags are not guaranteed to be done loading when onModuleLoad() is called
  • <script> tags are guaranteed to be done loading when onModuleLoad() is called
  • multiple EntryPoints
  • will all be called in sequence as soon as that module (and the outer document) is ready
  • multiple GWT modules within the same page
  • each module's EntryPoint will be called as soon as both that module and the outer document is ready
  • EntryPoints are not guaranteed to fire at the same time
  • or in the same order
  • in which their selection scripts were specified in the host 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
anonymous

Large scale application development and MVP - Part II - Google Web Toolkit - Google Code - 0 views

code.google.com/...mvp-architecture-2.html

shared by anonymous on 18 Jan 11 - Cached
  • itself
    • anonymous
      anonymous on 18 Jan 11
       
      The View Implementation
  • @UiHandler("
  • presenter.onAddButtonClicked();
  • ...91 more annotations...
  • onAddButtonClicked
  • eventBus.fireEvent(new AddContactEvent());
  • presenter needs to know more about the view
  • view needs to know more about the data model
  • data types are typically homogeneous within column borders
  • ColumnDefinition abstract class
  • houses the any type-specific code (this is the third party mentioned above)
  • ColumnDefinition
  • ColumnDefinition(s) would be created outside of the presenter
  • we can reuse its logic regardless of what view we've attached ourself to
  • update our views such that we can set their ColumnDefinition(s).
  • setColumnDefinitions
  • this.columnDefinitions = columnDefinitions;
  • so that we can pass in
  • a mocked ContactsView instance when testing our ContactsPresenter
  • in our AppController, when we create the ContactsView,
  • new ContactsViewColumnDefinitions().getColumnDefinitions();
  • we can initialize it with the necessary ColumnDefinition(s).
  • contactsView.setColumnDefiniions(
    • anonymous
      anonymous on 19 Jan 11
       
      Initialize ContactsView with the necessary ColumnDefinition(s)
  • With our ColumnDefinition(s) we can pass the model untouched.
  • As mentioned above we were previously dumbing down the model into a list of Strings
  • current solution
  • List<String> data
  • display.setData(data);
  • how that data type is rendered.
  • use generics
  • third party that abstracts
  • knowledge of a cell's data type
  • stringing together a list of these classes
  • providing the necessary render()
  • and isClickable()/isSelectable() override
  • ContactsViewColumnDefinitions<ContactDetails>
  • columnDefinitions =      new ArrayList<ColumnDefinition<ContactDetails>>()
  • ColumnDefinition<T>
  • ContactsPresenter
  • ContactsViewImpl
  • ColumnDefinition<T> columnDefinition = columnDefinitions.get(j);
  • the presenter can pass the model untouched
  • the view has no rendering code
  • that we would otherwise need to test. And the fun doesn't stop there.
  • presenter.onItemClicked(
  • presenter.onItemSelected
  • ClickEvent
  • cell.getCellIndex()
  • columnDefinition.isClickable()
  • SelectEvent
  • columnDefinition.isSelectable()
  • return shouldFireClickEvent;
  • return shouldFireSelectEvent;
  • respond to user interaction in different ways based upon the cell type that was clicked
  • use them for rendering purposes
  • defining how to interpret user interactions
  • we're going to remove any application state from the ContactsView
  • replace the view's getSelectedRows() with a SelectionModel
  • The SelectionModel is nothing more than a wrapper around a list of model objects.
  • ContactsPresenter holds on to an instance of this class
  • onItemSelected
  • Having the ColumnDefinition create a new widget for each cell is too heavy
  • Replace our FlexTable implementation with an HTML widget
  • calling setHTML()
  • Reduce the event overhead by sinking events on the HTML widget
  • rather than the individual cells
  • update our ContactsView.ui.xml file to use a
  • HTML widget rather than a FlexTable widget.
  • <g:HTML ui:field="contactsTable">
  • Inefficiencies related to inserting new elements via DOM manipulation Overhead associated with sinking events per Widget
  • for each item ask our column definitions to render accordingly
  • each column definition
  • render itself into the StringBuilder
  • rather than passing back a full-on widget
  • calling setHTML on a HTML widget
  • rather than calling setWidget on a FlexTable.
  • This will decrease your load time, especially as your tables start to grow.
  • we're reducing the overhead of sinking events on per-cell widgets
  • instead sinking on a single container
  • ClickEvents are still wired up via our UiHandler annotations
  • get the Element that was clicked on
  • and walk the DOM until we find a parent TableCellElement
  • we can determine the row
  • shouldFirdClickEvent() and shouldFireSelectEvent()
  • to take as a parameter a TableCellElement rather than a HTMLTable.Cell.
  • faster startup times via Code Splitting.
  • runAsync() points
  • split portion of your code is purely segmented
  • not referenced by other parts of the app
  • it will be downloaded and executed at the point that it needs to run
  • Do we really want to download all of that code before the user even logs in?
  • Not really.
  • simply grab the login code, and leave the rest for when we actually need it
  • wrap the code that creates the ContactsView and ContactsPresenter in a runAsync() call
  • as optimizations such as this one become easier and easier to implement.
seth kutcher

My Husband Is Happy With Their PC Repair Services - 1 views

My husband was so frustrated the other night because his laptop was not working properly. I told him to calm down and we will call Remote PC Repair Now. I told them they are the expert when it come...

remote PC repair

started by seth kutcher on 17 Aug 11 no follow-up yet
shai edrote

They Fixed My Slow Computer - 1 views

My computer started running so slow that it takes me 10 minutes just to open a site. So I called Fix Slow Computer Today to help me with my concern. They have expert computer technicians who can fi...

They Fixed My Slow Computer

started by shai edrote on 12 Sep 11 no follow-up yet
Rem PC

The Best Remote PC Support I Ever Had - 1 views

The Remote PC Support Now excellent remote PC support services are the best. They have skilled computer tech professionals who can fix your PC while you wait or just go back to work or just simply...

remote PC support

started by Rem PC on 12 Sep 11 no follow-up yet
anonymous

How Offshore Java Development Companies Create 2D Game In Java ME - 0 views

technohub2.webnode.com/...nies-create-2d-game-in-java-me

Java Development vendors

shared by anonymous on 23 Mar 15 - No Cached
  • anonymous on 23 Mar 15
     
    With this article, we are going to provide you a quick introduction to Java ME development tools used by offshore Java Development vendors to create MIDlet. Java ME contains small JVM and a set of Java APIs that are used for developing mobile applications. So let's start and create your first mobile app with perfection.
krowddigital

Startup App Development Services In Melbourne - 1 views

www.krowd.com.au/start-up.php

Startup App iOS App Mobile App Android App

shared by krowddigital on 09 Feb 22 - No Cached
  • krowddigital on 09 Feb 22
     
    A startup app development company, we develop amazing apps for startups and entrepreneurs.
‹ Previous 21 - 30 of 30
Showing 20▼ items per page