Group items matching

in title, tags, annotations or url

Java supports two selection statements - if and switch. These statements allow us to control the flow of the program. Depending upon the expressions or values, the corresponding blocks/statements of code will be executed or by passed. The two statements are if statement is a conditional branch statement. This is a two way branch statement. Depending upon the whether a condition is true or false, the corresponding code is executed. switch statement is a multiway branch statement. Depending upon the value used for switching, the corresponding code is executed. These two statements are very powerful and are used widely across any application. They provide effective solutions for branching problems.

Sample tutorial on how of Spring Dependency Injection and Inversion of Control using Constructor Injection and Setter Injection

Weld is the reference implementation (RI) for JSR-299: Java Contexts and Dependency Injection for the Java EE platform (CDI). CDI is the Java standard for dependency injection and contextual lifecycle management, led by Gavin King for Red Hat, Inc. and is a Java Community Process (JCP) specification that integrates cleanly with the Java EE platform. Any Java EE 6-compliant application server provides support for JSR-299 (even the web profile). Weld and the JSR-299 TCK (Technology Compatibility Kit) are developed here at seamframework.org. Both are licensed under the Apache License, Version 2.0.

"The WAR Plugin is responsible for collecting all artifact dependencies, classes and resources of the web application and packaging them into a web application archive."

The Simple Logging Facade for Java or (SLF4J) serves as a simple facade or abstraction for various logging frameworks, e.g. java.util.logging, log4j and logback, allowing the end user to plug in the desired logging framework at deployment time. Before you start using SLF4J, we highly recommend that you read the two-page SLF4J user manual. In case you wish to migrate your Java source files to SLF4J, consider our migrator tool which can migrate your project into SLF4J in minutes. In case an externally-maintained component you depend on uses a logging API other than SLF4J, such as commons logging, log4j or j.u.l, have a look at SLF4J's binary-support for legacy APIs.

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.

Special thanks to Piero Sartini who came up with this alternative. It is basically the same as the previous alternative, but it uses the new JEE6 Context and Dependency Injection (CDI) and session scoped beans instead of EJBs. This alternative should have better performance than using EJBs. Instead of annotating the Vaadin application as a stateful session bean, it should be annotated using the @SessionScoped annotation, like so:

Aspect-oriented computing is continuing to increase in popularity. The modularity inherent in OSGi and Eclipse offers unique opportunities for managing and applying aspects by supplying them in bundles and directing their application to particular sets of bundles. This incubator work area is dedicated to delivering an integration of aspects and OSGi. The goal is to allow developers to use the Equinox together with AspectJ by combining the benefits of both worlds. Using a load-time weaving extension you are able to add AspectJ aspects to your bundle-based system just by putting them into general OSGi bundles. It does not matter if the pointcuts you defined inside the aspects contain join points that are defined by classes within the same bundle or any other bundle in your installation. The load-time weaving extension will take care that your aspects are woven with the appropriate classes at load-time. To illustrate this lets assume the following situation: You would like to write an aspect that traces something within the JDT plug-ins of Eclipse. Without some kind of load-time aspect weaving you would somehow need to recompile those JDT plug-ins using AJDT (for example) together with your aspect. By using the load-time aspect weaving extension all you need is to implement your aspect and add that bundle to your system. The load-time aspect weaving extension takes care of weaving your aspect with the JDT code as it is loaded. And it doesn't matter if a new JDT is installed by the user later on. The next time your application is started the load-time aspect weaving will take care of weaving your aspect into these bundles as well, if necessary. With this technology is becomes possible to modularize crosscutting concerns across different plug-ins while keeping the idea of separate compilation for bundles. Goals Provide Runtime Modularity and Versioning for Crosscutting Concerns: Aspects are used to implement crosscutting concerns. However such concerns usually compr

"what if I just dropped the EMF bundles into the same place, modified the demo .plan file to include them, and.. No way that could possibly work, right? Not only did it work, but it actually worked before I thought it would. I was ready for endless rounds of editing, rebuilding, restarting, reloading, re.. But instead, I saved the changes to the .plan file and Equinox/Virgo automagically hot-loaded them and ran through the dependencies there and then. I cleaned a couple of things up, and then I navigated to the URL, and there it was. Seriously, I haven't been that impressed by a technology that "just worked" since the first time I built an EMF model and editor. I'll say it: The Virgo/RAP/EMF stack is going to be -- already is -- a kick-ass combination. Light-weight development, light-weight deployment, industrial strength, web-based MDSD."

JavaHL is  platform-dependent

"Executing external processes from Java is a well-known problem area. It is inheriently platform dependent and requires the developer to know and test for platform specific behaviors, for example using cmd.exe on Windows or limited buffer sizes causing deadlocks. The JRE support for this is very limited, albeit better with the new Java SE 1.5 ProcessBuilder class. Reliably executing external processes can also require knowledge of the environment variables before or after the command is executed. In J2SE 1.1-1.4 there is not support for this, since the method, System.getenv(), for retriving environment variables is deprecated. There are currently several different libraries that for their own purposes have implemented frameworks around Runtime.exec() to handle the various issues outlined above. The proposed project should aim at coordinating and learning from these initatives to create and maintain a simple, reusable and well-tested package. Since some of the more problematic platforms are not readily available, it is my hope that the broad Apache community can be a great help."

When developing a mobile application, you need not focus on the limitations or capabilities of different browsers, as Trinidad enables you to develop applications that function properly on different browser types. The Trinidad renderer ensures that the target browser can consume contents correctly. It handles the variations in both browser implementations of HTML, JavaScript, CSS, DOM, XMLHttpRequest and system performance. For example, if a browser does not support XMLHttpRequest and is incapable of posting a partial page request to a server, support for AJAX enables the application to revert automatically to a full page submit so that the same page functions whether the browser supports XMLHttpRequest or not. Furthermore, if the target browser does no support JavaScript Trinidad will automatically render contents that work on HTML by removing all dependencies on JavaScript.

A library of Generally Useful Stuff (tm) for developing applications, extensions or frameworks based on CDI (JSR-299: Java Contexts and Dependency Injection). A swiss army knife for CDI extension writers.

iPOJO is a service component runtime aiming to simplify OSGi application development. It natively supports ALL the dynamism of OSGi. Based on the concept of POJO, application logic is developed easily. Non-functional properties are just injected in the component at runtime. iPOJO strength points are : components are developed as POJO, nothing else is required ! the component model is extensible, so feel free to adapt it to your needs the standard component model manages service providing and service dependencies, and so can require any other OSGi services iPOJO manages the component instance lifecycle and the environment dynamics as it has never been possible iPOJO provides a powerful composition system to create highly dynamic applications iPOJO supports annotations, XML or Java-based API to define the component

Java is amongst the striking programming languages which find its execution even in contemporary day world that is heavily subjective by the iOS and Android platforms