Package java.util.concurrent.atomic
A small toolkit of classes that support lock-free thread-safe
programming on single variables.
Group items matching
in title, tags, annotations or url
9More
shared by Rinav G on 17 Sep 10
- 
Cached
Overview (Java Platform SE 6) - 0 views
download.oracle.com/...index.html
java platform java.util.concurrent.atomic concurrent AutomicInteger
shared by Rinav G on 17 Sep 10
- Cached
-
-
A small toolkit of classes that support lock-free thread-safe programming on single variables. In essence, the classes in this package extend the notion of volatile values, fields, and array elements to those that also provide an atomic conditional update operation of the form: boolean compareAndSet(expectedValue, updateValue);
-
Atomic classes are not general purpose replacements for java.lang.Integer and related classes. They do not define methods such as hashCode and compareTo. (Because atomic variables are expected to be mutated, they are poor choices for hash table keys.)
- ...4 more annotations...
-
The specifications of these methods enable implementations to employ efficient machine-level atomic instructions that are available on contemporary processors.
-
java.util.concurrent.atomic Class AtomicInteger java.lang.Object java.lang.Number java.util.concurrent.atomic.AtomicInteger
-
An int value that may be updated atomically. See the java.util.concurrent.atomic package specification for description of the properties of atomic variables. An AtomicInteger is used in applications such as atomically incremented counters, and cannot be used as a replacement for an Integer. However, this class does extend Number to allow uniform access by tools and utilities that deal with numerically-based classes.
-
int incrementAndGet() Atomically increments by one the current value.
-
-
Package java.util.concurrent.atomic Description A small toolkit of classes that support lock-free thread-safe programming on single variables. In essence, the classes in this package extend the notion of volatile values, fields, and array elements to those that also provide an atomic conditional update operation of the form: boolean compareAndSet(expectedValue, updateValue);
1More
shared by Hendy Irawan on 09 Oct 10
- Cached
LiquiBase | Database Refactoring | home - 0 views
www.liquibase.org
java sql jdbc tools opensource database db schema tool refactoring versioning development
shared by Hendy Irawan on 09 Oct 10
- Cached
-
Database Change Management You never develop code without version control, why do you develop your database without it? Liquibase is an open source (Apache 2.0 Licensed), database-independent library for tracking, managing and applying database changes. It is built on a simple premise: All database changes are stored in a human readable yet trackable form and checked into source control. Liquibase Supports: Extensibility Merging changes from multiple developers Code branches Multiple Databases Managing production data as well as various test datasets Cluster-safe database upgrades Automated updates or generation of SQL scripts that can be approved and applied by a DBA update rollbacks Database "diff"s Generating starting change logs from existing database
151More
Getting Started with RequestFactory - Google Web Toolkit - Google Code - 0 views
-
Entity Proxies
-
-
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
1More
shared by Paul Sydney Orozco on 25 Nov 10
- No Cached
How to Add CRUD Capability On Spring MVC using Hibernate JPA - 0 views
www.adobocode.com/...-crud-capability-to-spring-mvc
crud create read update delete spring mvc hibernate jpa saving editing mysql annotation
shared by Paul Sydney Orozco on 25 Nov 10
- No Cached
-
A step by step tutorial on adding CRUD (Create,Read,Update,Delete) capability on Spring MVC using Hibernate JPA.
5More
ResultSet (Java 2 Platform SE 5.0) - 0 views
-
to insert column values into the insert row. An updatable ResultSet object has a special row associated with it that serves as a staging area for building a row to be inserted. The following code fragment moves the cursor to the insert row, builds a three-column row, and inserts it into rs and into the data source table using the method insertRow
-
moveToInsertRow
-
updateString
- ...1 more annotation...
-
insertRow
-
to insert column values into the insert row. An updatable ResultSet object has a special row associated with it that serves as a staging area for building a row to be inserted. The following code fragment moves the cursor to the insert row, builds a three-column row, and inserts it into rs and into the data source table using the method insertRow.
2More
Installation Instructions - Eclipse Subversive - 0 views
-
d Eclipse is rebooted, Subversive automatically displays the dialog that shows Subversive SVN Connectors compatible with the installed version of the plug-in. Alternatively, you can install Subversive SVN Connectors from online and archived update sites for connectors. Visit Polarion.com, to get information about the available update sites.
1More
AutoPatch - 0 views
-
With AutoPatch, an agile development process that requires a database change looks like this: Developer alters the model, which requires a change to the database Developer possibly consults a DBA, and develops a SQL patch against their personal database that implements the alteration Developer commits the patch to source control at the same time as they commit their dependent code Other developers' and environments' databases are automatically updated by AutoPatch the next time the new source is run This represents streamlined environment maintenance, allowing developers to cheaply have their own databases and all databases to stay in synch with massively lower costs and no environment skew. That's what AutoPatch does. Clusters with one database? Multiple schemas? Logical migrations, instead of just DDL changes? Need to do something special/custom? Need to distribute your changes commercially? All without paying anything? No problem.
1More
Nimbus Look and Feel - 0 views
-
Nimbus, a cross platform look and feel introduced in the Java SE 6 update 10 release, is drawn with 2D vector graphics and can be rendered at any resolution.
96More
Large scale application development and MVP - Part II - Google Web Toolkit - Google Code - 0 views
-
itself
-
-
@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(
-
-
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.
1More
shared by Hendy Irawan on 24 Apr 11
- No Cached
Ajax Push - Overview - ICEfaces - ICEfaces.org Community Wiki - 0 views
wiki.icefaces.org/...Ajax+Push+-+Overview
ajax push overview community icefaces application jsf java javaee web
shared by Hendy Irawan on 24 Apr 11
- No Cached
-
Ajax Push allows the application to incrementally update any part of the page at any time, for any group of clients. This is a small change in terms of the technical capabilities of Ajax applications, but it is a revolutionary change in terms of what applications can actually provide to users. Ajax Push is the key to building collaborative multi-user applications for the web. Under the Hood The intricacies of the Ajax Push implementation are completely transparent to the ICEfaces developer, as you work with a straightforward set of APIs. It is, however, useful to understand the basic mechanics. Ajax Push in ICEfaces 2.0 leverages an asynchronous notification mechanism call ICEpush. Simply put, ICEpush uses long polling to provide asynchronous notification over standard HTTP, using only standard browser capabilities. The sequence of events involved in Ajax Push is illustrated below.
1More
Eclipse Gemini Blueprint - Home - 0 views
-
Eclipse Gemini Blueprint is the reference implementation for the OSGi Alliance Blueprint Service (chapter 121 of the OSGi 4.2 Compendium Specification). Gemini Blueprint project makes it easy to build Java applications that run in an OSGi framework. By using Gemini Blueprint, applications benefit from using a better separation of modules, the ability to dynamically add, remove, and update modules in a running system, the ability to deploy multiple versions of a module simultaneously (and have clients automatically bind to the appropriate one), and a dynamic service model. Gemini users may also be interested in Eclipse Virgo, an open source, completely modular, OSGi-based Java application server. Its documentation is considered a supplement to Gemini Blueprint as it explains in detail, how OSGi can be used in various development and production scenarios.
1More
eik - Eclipse Integration for Apache Karaf runtimes - Google Project Hosting - 0 views
-
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
Java SE 6 Update 10 Beta Overview - 0 views
Java 7, JDK 7, Java SE 7 News, Update | tutego - 0 views
17More
JavaBlogging » What is serialVersionUID? - 2 views
-
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.
1More
Future of Architects after Java 9 - 1 views
-
Java chief architects are planning to make some changes into current Java version and how updates can bring changes to future of Java application development after Java 9.