Skip to main content

Home/ Java Development/ Group items tagged view

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
Rinav G

Java BluePrints : Model-View-Controller- J2EE Patterns - 1 views

java.sun.com/...MVC-detailed.html

mvc java blueprints modelviewcontroller j2ee model view controller

shared by Rinav G on 17 Sep 10 - Cached
  • Rinav G on 17 Sep 10
     
    By applying the Model-View-Controller (MVC) architecture to a JavaTM 2 Platform, Enterprise Edition (J2EETM) application, you separate core business model functionality from the presentation and control logic that uses this functionality. Such separation allows multiple views to share the same enterprise data model, which makes supporting multiple clients easier to implement, test, and maintain.
  • Rinav G on 17 Sep 10
     
    Java BluePrints Model-View-Controller
Rinav G

Design Patterns: Front Controller - 0 views

java.sun.com/...FrontController.html

design patterns frontController Java J2EE blueprints

shared by Rinav G on 17 Sep 10 - Cached
  • Rinav G on 17 Sep 10
     
    Many interactive Web applications are composed of brittle collections of interdependent Web pages. Such applications can be hard to maintain and extend. The Front Controller pattern defines a single component that is responsible for processing application requests. A front controller centralizes functions such as view selection, security, and templating, and applies them consistently across all pages or views. Consequently, when the behavior of these functions need to change, only a small part of the application needs to be changed: the controller and its helper classes.
  • Rinav G on 17 Sep 10
     
    Many interactive Web applications are composed of brittle collections of interdependent Web pages. Such applications can be hard to maintain and extend. The Front Controller pattern defines a single component that is responsible for processing application requests. A front controller centralizes functions such as view selection, security, and templating, and applies them consistently across all pages or views. Consequently, when the behavior of these functions need to change, only a small part of the application needs to be changed: the controller and its helper classes.
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.
Paul Sydney Orozco

A Spoon-feed, step by step fast Spring Web MVC Tutorial - 0 views

www.adobocode.com/...a-spring-web-mvc-tutorial

spring mvc tutorial web application Model View Controller Tomcat Eclipse ant build jdk dynamic project

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 web application using basic Spring MVC from spring-framework 3.0.5. We will design our web-based application based on the standard Spring MVC where request to the web-app will be routed to a Controller module, then to it's jsp View with data from our business Model
Javin Paul

How to find memory usage in Java Program with example - 0 views

javarevisited.blogspot.com/...free-total-memory-in-java.html

java programming developement memory

shared by Javin Paul on 21 Jan 12 - No Cached
  • Javin Paul on 21 Jan 12
     
    Good and quick tutorial on how to find memory usage in java with example. step by step guide to get free memory, max memory and total memory from JVM. memory usage is critical for performance point of view
Hendy Irawan

Spring Surf | SpringSource.org - 0 views

www.springsource.org/...se-surf

spring java framework web project opensource surf springsource

shared by Hendy Irawan on 19 Jul 10 - Cached
  • Hendy Irawan on 19 Jul 10
     
    "Spring Surf is a view composition framework for Spring MVC that plugs into your existing Spring applications. It provides a scriptable and content-centric approach to building web applications. You can drop Spring Surf right into your existing Spring web applications or you can begin building new Spring Surf applications using SpringSource Tool Suite or Spring Roo's command-line magic."
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.
anonymous

untitled - 0 views

code.google.com/...DevGuideUiBinder.html

java TODO

shared by anonymous on 29 Dec 10 - Cached
  • initWidget(uiBinder.createAndBindUi(this));
    • anonymous
      anonymous on 29 Dec 10
       
      To inizialize the "menber variable" whith the widget object described in the XML view despription
  • uiBinder.createAndBindUi(this)
  • GWT compiler won't actually visit this URL to fetch the file, because a copy of it is baked into the compiler
  • ...15 more annotations...
  • @UiField have default visibility
  • UIObject
  • DivElement
  • If your factory method needs arguments, those will be required as attributes.
  • Every widget that is declared in a template is created by a call to GWT.create().
  • @UiConstructor annotation.
  • you can mark your own widgets with
  • CricketScores has no default (zero args) constructor
  • you can define a @UiFactory method on the UiBinder's owner
  • annotate a constructor of CricketScores with @UiConstructor.
  •   @UiFactory
  • public class UserDashboard extends Composite {  interface MyUiBinder extends UiBinder<Widget, UserDashboard> {}  private static MyUiBinder uiBinder = GWT.create(MyUiBinder.class);  public UserDashboard() {    initWidget(uiBinder.createAndBindUi(this));  }}
  • use several different XML templates for the same view
  • public interface Display
  • methods can be called to fill in attribute values
Hendy Irawan

Assembla project workspaces to accelerate software teams, with issue tracking, GIT, SVN... - 0 views

www.assembla.com/?affiliate=ceefour

project assembla software workspaces

shared by Hendy Irawan on 26 May 11 - No Cached
  • Hendy Irawan on 26 May 11
     
    "Assembla workspaces to accelerate software teams Ticketing and issue management, Subversion, Git, Mercurial, Wiki, and other collaboration tools to accelerate development. Unite your team with a single activity stream view. Free starter offers include free subversion, free git, standup/scrum reporting, and unlimited free services for public communities and open source projects. "
DJHell .

http://www.getopt.org/luke - 1 views

Luke - Lucene Index Toolbox

Lucene Luke Index search IT development tool Java Open Source

shared by DJHell . on 15 Apr 09 - No Cached
  • DJHell . on 15 Apr 09
     
    Lucene is an Open Source, mature and high-performance Java search engine. It is highly flexible, and scalable from hundreds to millions of documents. Luke is a handy development and diagnostic tool, which accesses already existing Lucene indexes and allows you to display and modify their content in several ways: * browse by document number, or by term * view documents / copy to clipboard * retrieve a ranked list of most frequent terms * execute a search, and browse the results * analyze search results * selectively delete documents from the index * reconstruct the original document fields, edit them and re-insert to the index * optimize indexes * and much more... Recent versions of Luke are also extensible through plugins and scripting. I started this project because I needed a tool like this. I decided to distribute it under Open Source license to express my gratitude to the Lucene team for creating such a high-quality product. Lucene is one of the landmark proofs that Open Source paradigm can result in high-quality and free products.
Hendy Irawan

Chapter 6. HTTP Caching - 0 views

hc.apache.org/...caching.html

caching http client apache components library

shared by Hendy Irawan on 14 Apr 11 - No Cached
  • Hendy Irawan on 14 Apr 11
     
    HttpClient Cache provides an HTTP/1.1-compliant caching layer to be used with HttpClient--the Java equivalent of a browser cache. The implementation follows the Decorator design pattern, where the CachingHttpClient class is a drop-in replacement for a DefaultHttpClient; requests that can be satisfied entirely from the cache will not result in actual origin requests. Stale cache entries are automatically validated with the origin where possible, using conditional GETs and the If-Modified-Since and/or If-None-Match request headers. HTTP/1.1 caching in general is designed to be semantically transparent; that is, a cache should not change the meaning of the request-response exchange between client and server. As such, it should be safe to drop a CachingHttpClient into an existing compliant client-server relationship. Although the caching module is part of the client from an HTTP protocol point of view, the implementation aims to be compatible with the requirements placed on a transparent caching proxy. Finally, CachingHttpClient includes support the Cache-Control extensions specified by RFC 5861 (stale-if-error and stale-while-revalidate).
Hendy Irawan

Scout/Overview - Eclipsepedia - 0 views

wiki.eclipse.org/Overview

project eclipse framework SDK platform business application overview eclipsepedia scout

shared by Hendy Irawan on 24 Apr 11 - No Cached
  • Hendy Irawan on 24 Apr 11
     
    The goal of the Eclipse Scout project is making it easy to build distributed enterprise applications based on the Eclipse platform. It consists of a runtime framework providing transparent service communication between the client and backend part and is shipped with a rich set of common user interface components. The user interface is not built for a particular rendering technology but it encapsulates the core functionality into a headless model. GUI factories are available for rendering the client model into a particular target UI platform. SWT and Swing are supported out of the box and an AJAX GUI factory could be easily added. Developing Scout applications is supported by the Scout SDK, a plug-in set built on top of Eclipse PDE and Eclipse JDT. The Scout SDK works directly on the bare Java resources and assists the development task by providing an augmented view on the underlying Java code. Additionally, it comes with a rich set of wizards and operations for modifying the Scout application project just by editing the underlying Java code. There is no meta-data required. Hence a developer can switch between editing resources using Eclipse's standard editors and leveraging the features of Scout SDK at any point in time. Eclipse Scout can be used to create multi-tier client/server applications, standalone client applications or OSGi-based server applications. Basically, there are three main advantages when choosing Scout as your framework for building such applications. First, the Scout runtime is service oriented by design. Almost every functionality is provided as an OSGi service. Every OSGi bundle may make use of them. Second, Scout provides a rich set of UI elements being uncoupled from a particular GUI technology. And third, building distributed client/server applications is as easy as if both parts would run within the same local JVM.
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
marketngedwisor

How to become a Front-end developer in 2019 - 0 views

blog.edwisor.com/...-a-front-end-developer-in-2019

front-end development developers front end engineer frontend salary javascript

shared by marketngedwisor on 03 Aug 19 - No Cached
  • marketngedwisor on 03 Aug 19
     
    Front End Development or Client-Side Development is the practice of coding in technologies like HTML, CSS, and Javascript in a website. The practice involves converting Data into a Graphical Interface for a user to view and interact. Growth in Front-end development is excellent and there are plenteous opportunities available, especially because companies now want their customers to have a good experience while using their Web applications. Want to get hired as a Front End Developer in 2019? Acquire skills in Front End Development, Build live Projects and Get Guaranteed Interviews with edWisor.
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
Baron M

Page 2 - Java Developers Leery of IBM-Sun Merger - 0 views

www.eweek.com/...1

java

shared by Baron M on 01 Apr 09 - Cached
  • IBM still runs basic physics last I checked and has deep resources in research to throw at any problem it wants
  • with more money and influence than nearly all of their competitors
  • both companies are highly invested in Java, which means it will continue, but in what form we have no idea
  • ...7 more annotations...
  • IBM is not interested in Sun software but in the Sun hardware and storage
    • Baron M
      Baron M on 01 Apr 09
       
      different perspective
  • pose a number of integration issues for IBM Software Group
  • shed a lot of the weaker products (and a significant number of redundant staff)
  • some observers say IBM would do well to merge the best parts of both platforms into one.
  • IBM has been a proponent of open standards in the Java ecosystem, and I expect that will continue
  • expect that IBM will take the long view, that an open, flourishing ecosystem around Java will be the tide that lifts all boats
    • Baron M
      Baron M on 01 Apr 09
       
      conclusion: SUN and JCP suck, so they deserve this. God bless java and java dependent vendors.
Gistia Labs

Custom Software App Development Company in Miami - 0 views

www.mobypicture.com/...17990237

software development company Miami app development companies Miami application development Miami custom software development Miami software application development Miami web application development Miami web app development Miami

shared by Gistia Labs on 07 Apr 15 - No Cached
  • Gistia Labs on 07 Apr 15
     
    Gistia Labs is best software application Development Company based in Miami that offer mobile app & Custom software App development. We turn web application roadmaps into highly scalable cloud apps.
mikhail-miguel

java.net's Javapedia web - 0 views

wiki.java.net/...WebRss

wiki

shared by mikhail-miguel on 12 Jul 23 - No Cached
  • mikhail-miguel on 12 Jul 23
     
    Unread
krowddigital

Salesforce CRM Features and Benefits [Guide 2022] - 1 views

www.krowd.com.au/...orce-crm-features-and-benefits

java programming development web opensource mobile app web app

shared by krowddigital on 30 May 22 - No Cached
  • krowddigital on 30 May 22
     
    CRM platforms such as Salesforce provide a single view of all departments, including sales, service, and marketing
krowddigital

Salesforce CRM Features and Benefits [Guide 2022] - 1 views

flutterdevelopmentgoogle.blogspot.com/...crm-features-and-benefits.html

java programming development web opensource framework Eclipse online library

shared by krowddigital on 08 Jun 22 - No Cached
  • krowddigital on 08 Jun 22
     
    Salesforce services is an integrated CRM platform that gives a single view of all departments including marketing and commerce.
1 - 20 of 20
Showing 20▼ items per page