Jakarta EE and JSF 2.x

Jakarta EE

In September 2017, Oracle announced its intention to transition Java EE to the Eclipse Foundation. Java EE has since been rebranded to Jakarta EE, and JSF 2.3 (Eclipse Mojarra) has been adopted for continuation. The next major release of the JSF specification will be Eclipse Mojarra 3.0. (source from JavaWorld).

Read More

ZK - Difference Between @load,@save,@bind

Can someone please explain me the difference between @load,@save,@bind with an example, i have read about them but i got more confused about the basic difference between them. they all look and work in somewhat same manner.
what does it mean when i write something like below

<textbox value="@load(vm.address.streatName)"/>
<datebox value="@save(vm.trip.leaveDate)"/>
<label value="@bind(vm.name)"/>

thanks in advance

Read More

datatables - datatables.net

1-Datatables trong spring mvc

Introduction

DataTables operates on the principle of progressive enhancement, whereby an enhanced and interactive table will be presented to the end user if their browser has the required capabilities. When you initialise the jQuery.dataTable object, information about the table is read directly from the HTML page. In combination with the default values for the features in DataTables, this makes it very easy to integrate directly into your web-site or web-application. Optionally, you can use the initialisation parameters to load data from locations other than the DOM, such as a server-side processing script or an Ajax obtained JSON file.

Read More

JSTL 1.2

1-JSTL Check Equals, not equals

JSTL Check Equals(==), not equals(!=) explains about how to use logical conditions(equals, not equals etc) with JSTL tag

Consider a JSP Page where you need to check a value whether it is equals or not equals and process accordingly, in that scenario,  you can follow this example.

On the following table, I am showing 2 different ways (Method 1 & Method 2), you can achieve equals & not equals in JSTL 

Logical operation	JSTL Method 1	JSTL Method 2
Equals	Eq	==
Not Equals	Ne	!=

Required Libraries

You need to download

1. Tomcat 7
2. JSTL 1.2

Following jar must be in classpath

1. jstl-1.2.jar

Read More

Struts2 AngularJS integration

Posted by Mohaideen Jamil on May 2, 2015 in Ajax, AngularJS, Struts-2 | 5 comments

In this post, we will learn to implement AJAX calls from a JSP page to a Struts 2 Action class using AngularJS and update the same JSP page back with the Json response from the Struts 2.

Library Required

Since Angular can send and receive only in json format, to handle it you need struts2-json-plugin-2.x.x.jar. This plugin allows you to serialize the Action class attribute which has getter and setter into a JSON object.

Read More

Struts2 AngularJS Insert Operation

LINK

As for the user interface, rather than Bootstrap, we'll use materialize CSS – a modern responsive front-end framework based mostly additionally on Google’s Material design.

FILE STRUCTURE

Knowing the file structure can offer us an outline of what Struts2 files can we need to create and wherever the assets should be placed.

Struts2 AngularJS CRUD Example - Read Operation

Read More

Struts2 vs Struts1

1. Khái quát chung

2. Struts1

Sign up Does Struts 1 create a controller object for each session or is the controller classes singletons?

The framework just uses one instance of it and only one instance is used to process all incoming requests, care must be taken not to do something with in the Action class that is not thread safe. From the javadoc:

Actions must be programmed in a thread-safe manner, because the controller will share the same instance for multiple simultaneous requests. This means you should design with the following items in mind:

1. Instance and static variables MUST NOT be used to store information related to the state of a particular request. They MAY be used to share global resources across requests for the same action.
2. Access to other resources (JavaBeans, session variables, etc.) MUST be synchronized if those resources require protection. (Generally, however, resource classes should be designed to provide their own protection where necessary.

---

This is what the official Apache Struts page says :

Struts 1 Actions are singletons and must be thread-safe since there will only be one instance of a class to handle all requests for that Action. The singleton strategy places restrictions on what can be done with Struts 1 Actions and requires extra care to develop. Action resources must be thread-safe or synchronized.

3. Struts2

4. Tham khảo:

Struts 2 Architecture and Flow
Introduction to the Struts Web Framework
Overview of Struts
Struts document home
Struts Architecture and life-cycle
Struts1 document

Read More

New Features and Enhancements in Spring Framework 4.0

The Spring Framework was first released in 2004; since then there have been significant major revisions: Spring 2.0 provided XML namespaces and AspectJ support; Spring 2.5 embraced annotation-driven configuration; Spring 3.0 introduced a strong Java 5+ foundation across the framework codebase, and features such as the Java-based @Configuration model.
Version 4.0 is the latest major release of the Spring Framework and the first to fully support Java 8 features. You can still use Spring with older versions of Java, however, the minimum requirement has now been raised to Java SE 6. We have also taken the opportunity of a major release to remove many deprecated classes and methods.
A migration guide for upgrading to Spring 4.0 is available on the Spring Framework GitHub Wiki.

1 Improved Getting Started Experience

The new spring.io website provides a whole series of "Getting Started" guides to help you learn Spring. You can read more about the guides in the Chapter 1, Getting Started with Spring section in this document. The new website also provides a comprehensive overview of the many additional projects that are released under the Spring umbrella.
If you are a Maven user you may also be interested in the helpful bill of materials POM file that is now published with each Spring Framework release.

2 Removed Deprecated Packages and Methods

All deprecated packages, and many deprecated classes and methods have been removed with version 4.0. If you are upgrading from a previous release of Spring, you should ensure that you have fixed any deprecated calls that you were making to outdated APIs.
For a complete set of changes, check out the API Differences Report.
Note that optional third-party dependencies have been raised to a 2010/2011 minimum (i.e. Spring 4 generally only supports versions released in late 2010 or later now): notably, Hibernate 3.6+, EhCache 2.1+, Quartz 1.8+, Groovy 1.8+, and Joda-Time 2.0+. As an exception to the rule, Spring 4 requires the recent Hibernate Validator 4.3+, and support for Jackson has been focused on 2.0+ now (with Jackson 1.8/1.9 support retained for the time being where Spring 3.2 had it; now just in deprecated form).

3 Java 8 (as well as 6 and 7)

Spring Framework 4.0 provides support for several Java 8 features. You can make use of lambda expressions and method references with Spring’s callback interfaces. There is first-class support for java.time (JSR-310), and several existing annotations have been retrofitted as @Repeatable. You can also use Java 8’s parameter name discovery (based on the -parameters compiler flag) as an alternative to compiling your code with debug information enabled.
Spring remains compatible with older versions of Java and the JDK: concretely, Java SE 6 (specifically, a minimum level equivalent to JDK 6 update 18, as released in January 2010) and above are still fully supported. However, for newly started development projects based on Spring 4, we recommend the use of Java 7 or 8.

4 Java EE 6 and 7

Java EE version 6 or above is now considered the baseline for Spring Framework 4, with the JPA 2.0 and Servlet 3.0 specifications being of particular relevance. In order to remain compatible with Google App Engine and older application servers, it is possible to deploy a Spring 4 application into a Servlet 2.5 environment. However, Servlet 3.0+ is strongly recommended and a prerequisite in Spring’s test and mock packages for test setups in development environments.

	If you are a WebSphere 7 user, be sure to install the JPA 2.0 feature pack. On WebLogic 10.3.4 or higher, install the JPA 2.0 patch that comes with it. This turns both of those server generations into Spring 4 compatible deployment environments.

On a more forward-looking note, Spring Framework 4.0 supports the Java EE 7 level of applicable specifications now: in particular, JMS 2.0, JTA 1.2, JPA 2.1, Bean Validation 1.1, and JSR-236 Concurrency Utilities. As usual, this support focuses on individual use of those specifications, e.g. on Tomcat or in standalone environments. However, it works equally well when a Spring application is deployed to a Java EE 7 server.
Note that Hibernate 4.3 is a JPA 2.1 provider and therefore only supported as of Spring Framework 4.0. The same applies to Hibernate Validator 5.0 as a Bean Validation 1.1 provider. Neither of the two are officially supported with Spring Framework 3.2.

5 Groovy Bean Definition DSL

Beginning with Spring Framework 4.0, it is possible to define external bean configuration using a Groovy DSL. This is similar in concept to using XML bean definitions but allows for a more concise syntax. Using Groovy also allows you to easily embed bean definitions directly in your bootstrap code. For example:

def reader = new GroovyBeanDefinitionReader(myApplicationContext)
reader.beans {
    dataSource(BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
        settings = [mynew:"setting"]
    }
    sessionFactory(SessionFactory) {
        dataSource = dataSource
    }
    myService(MyService) {
        nestedBean = { AnotherBean bean ->
            dataSource = dataSource
        }
    }
}

For more information consult the GroovyBeanDefinitionReader javadocs.

6 Core Container Improvements

There have been several general improvements to the core container:

• Spring now treats generic types as a form of qualifier when injecting Beans. For example, if you are using a Spring Data Repository you can now easily inject a specific implementation: @Autowired Repository<Customer> customerRepository.
• If you use Spring’s meta-annotation support, you can now develop custom annotations that expose specific attributes from the source annotation.
• Beans can now be ordered when they are autowired into lists and arrays. Both the @Order annotation and Ordered interface are supported.
• The @Lazy annotation can now be used on injection points, as well as on @Bean definitions.
• The @Description annotation has been introduced for developers using Java-based configuration.
• A generalized model for conditionally filtering beans has been added via the @Conditional annotation. This is similar to @Profile support but allows for user-defined strategies to be developed programmatically.
• CGLIB-based proxy classes no longer require a default constructor. Support is provided via the objenesis library which is repackaged inline and distributed as part of the Spring Framework. With this strategy, no constructor at all is being invoked for proxy instances anymore.
• There is managed time zone support across the framework now, e.g. on LocaleContext.

7 General Web Improvements

Deployment to Servlet 2.5 servers remains an option, but Spring Framework 4.0 is now focused primarily on Servlet 3.0+ environments. If you are using the Spring MVC Test Framework you will need to ensure that a Servlet 3.0 compatible JAR is in your test classpath.
In addition to the WebSocket support mentioned later, the following general improvements have been made to Spring’s Web modules:

• You can use the new @RestController annotation with Spring MVC applications, removing the need to add @ResponseBody to each of your @RequestMapping methods.
• The AsyncRestTemplate class has been added, allowing non-blocking asynchronous support when developing REST clients.
• Spring now offers comprehensive timezone support when developing Spring MVC applications.

8 WebSocket, SockJS, and STOMP Messaging

A new spring-websocket module provides comprehensive support for WebSocket-based, two-way communication between client and server in web applications. It is compatible with JSR-356, the Java WebSocket API, and in addition provides SockJS-based fallback options (i.e. WebSocket emulation) for use in browsers that don’t yet support the WebSocket protocol (e.g. Internet Explorer < 10).
A new spring-messaging module adds support for STOMP as the WebSocket sub-protocol to use in applications along with an annotation programming model for routing and processing STOMP messages from WebSocket clients. As a result an @Controller can now contain both @RequestMapping and @MessageMapping methods for handling HTTP requests and messages from WebSocket-connected clients. The new spring-messaging module also contains key abstractions formerly from the Spring Integration project such as Message, MessageChannel, MessageHandler, and others to serve as a foundation for messaging-based applications.
For further details, including a more thorough introduction, see the Chapter 26, WebSocket Support section.

9 Testing Improvements

In addition to pruning of deprecated code within the spring-test module, Spring Framework 4.0 introduces several new features for use in unit and integration testing.

• Almost all annotations in the spring-test module (e.g., @ContextConfiguration, @WebAppConfiguration, @ContextHierarchy, @ActiveProfiles, etc.) can now be used as meta-annotations to create custom composed annotations and reduce configuration duplication across a test suite.
• Active bean definition profiles can now be resolved programmatically, simply by implementing a custom ActiveProfilesResolver and registering it via the resolver attribute of @ActiveProfiles.
• A new SocketUtils class has been introduced in the spring-core module which enables you to scan for free TCP and UDP server ports on localhost. This functionality is not specific to testing but can prove very useful when writing integration tests that require the use of sockets, for example tests that start an in-memory SMTP server, FTP server, Servlet container, etc.
• As of Spring 4.0, the set of mocks in the org.springframework.mock.web package is now based on the Servlet 3.0 API. Furthermore, several of the Servlet API mocks (e.g., MockHttpServletRequest, MockServletContext, etc.) have been updated with minor enhancements and improved configurability. 

A little resume of new features is the following:

• Removed Deprecated Packages and Methods
• Java 8 Support
• Java EE 6 and 7 become the baseline
• Groovy Bean Definition DSL
• Core Container Improvements
• General Web Improvements
• WebSocket, SockJS, and STOMP Messaging
• Testing Improvements with extreme use of annotations

Take also a look to Spring MVC Test Tutorial by Petri Kainulainen that can give you a lot of informations about testing.

Read More

eXo Platform Database Guide with JBoss/Tomcat

By default, eXo Platform uses HSQL and you do not need any configuration to make it work. Follow this chapter only when you need to use another RDBMS.
Assuredly you can use MySQL, PostgreSQL, MSSQL, Oracle, Sybase, DB2. Optimistically any SQL database that provides a JDBC compliant driver can be used.
In this chapter:

• Creating databases
  You need to create databases. The tables are created automatically in Platform first startup.
• Configuring eXo Platform
  This section is a complete guide to configure eXo to use a RDBMS.
• Datasource JNDI name
  If for any reason you want to change JNDI name of the datasources, follow this section.
• Frequently asked questions
  This section especially targets to solve some possible issues.
  

Read More

Selenium in Juzu portlets

Previous steps:
– Learn how to develop great Juzu portlets for eXo Platform!
– Step 2: viewing and posting secrets
– Step 3: Building a sexy secret wall
– Step 4: adding Likes and Comments for Secret
– Step 5: Saving Secrets in the JCR
– Step 6: Let the whole world create new secrets

The JuZcret application is now finished, but our project is not perfect…

All through the previous blog posts, we have neglected to tell you about Unit Test, and this certainly is not a good practice.

The reason is that we wanted to keep you focused on a specific topic during each step. That’s why it’s only during this last step that we’ll talk about Unit Test in Juzu.

The good news is that Juzu allows you to leverage Selenium easily to simulate a real application while taking advantage of the speed of JUnit.

So it’s time to write Unit Test for our JuZcret portlet. The portlet will be deployed to an embedded portlet container. Selenium WebDriver will help to simulate almost all user interactions with the application, and then Arquillian will help to integrate with JUnit.

Read More

Apache Wicket

Wicket framework

The Wicket framework component oriented, serverside, Java web application framework.

• Wicket summary in wikipedia
• 5 days of Wicket!
• Introduction to the Wicket Web Framework
• How to setup Wicket Examples in Eclipse
• Wicket 1.5.3 in NetBeans IDE 7.1
• JavaOne: Wicket open-source framework to debut

Read More

Core Spring

The Spring framework , is an Inversion of control(IoC) framework that is supported on Google App Engine Java.

• Dependency Injection with the Spring Framework
  An article about Spring DI concept

Read More

Seasar 2

The Seasar2 framework the same as Spring framework but It use Convention over Configuration  concept.

• The Seasar Project

Read More

5 days of Wicket!

• Day 1 – Setting up the Project
• Day 2 – Writing the Tests
• Day 3 – Designing the backend
• Day 4 – Designing the Wicket components
• Day 5 – Putting it all together

1-Setting up the project (Ngày 1) :

Wicket is a Java web application framework which allows “Designers” (people good with Dreamweaver) and “Developers” (people good with Java and Databases) to collaborate on a project with minimal chances of stepping on each other’s toes or wearing each other’s hats.

The beauty of Wicket is that it uses plain xhtml pages as it’s templating markup.  This means that html pages can be loaded into Dreamweaver (or whatever tool the Designer is comfortable with) and they will look very close to the same as they would when rendered on the deployment web server.

Read More

Google App Engine Java and GWT Application Development

This book is designed to give developers the tools they need to build their own Google App Engine (GAE) with Google Web Toolkit (GWT) applications, with a particular
focus on some of the technologies useful for building social-media-oriented applications.
The book is centered on a GAE + GWT Java application called Connectr, which is
developed throughout the chapters and demonstrates, by example, the use of the
technologies described in the book. The application includes social-media information
gathering and aggregation activities and incorporates the use of many App Engine
services and APIs, as well as GWT design patterns and widget examples.

Several stages of the Connectr application are used throughout the book as features are
added to the app. Code is included with the book for all application stages, and each
chapter indicates the stage used.

Read More

Introduction to the Wicket Web Framework

This document takes you through the basics of creating reusable components and assembling them into a web application. Each component consists of a Java class and an HTML file. The framework that allows you to develop your application in this way is called Wicket. In addition to its component-based approach, a distinguishing feature of Wicket is the absence of XML configuration files. Instead of an XML configuration file, you use a Java class for application-wide settings, such as the identification of a home page.
Each widget in your web application is created in a Java class and rendered in an HTML page. The Java class and HTML page must have the same name and exist in the same source structure. They are linked to each other via a Wicket identifier. You will be shown how the IDE supports the development of component based applications so that you can quickly and efficiently create reusable components that can give your web application a consistent look and feel without very much work on your part.

Read More

How to setup Wicket Examples in Eclipse

Wicket examples is a good place to learn Apache Wicket by examples, and a must reference site for new or experienced Wicket’s developers. In this Wicket examples site, it almost contains all of the usage of the common wicket’s components.

In this guide, we show you how to setup the above Apache Wicket example site in your local development environment (Eclipse IDE).

Tools used :

1. Apache Wicket 1.4.17
2. Eclipse 3.6
3. Maven 3

Read More

JavaOne: Wicket open-source framework to debut

A new open-source framework aimed at simplifying the development of Java-based Web applications will debut at JavaOne Monday with support from a former Sun Microsystems Java evangelist.

Wicket, an open-source project founded in spring 2004 by Jonathan Locke, a member of the team that developed the JFC (Java Foundation Classes)/Swing framework, will introduce Wicket 1.0 next week at the annual Java developer confab, according to a press statement from the Wicket project.

Miko Matsumura, former Java evangelist at Sun and currently vice president for Infravio, will host a session about Wicket 1.0 Tuesday at JavaOne with one of the members of the project's development team, Martijn Dashorst, senior staff engineer at Topicus.

Wicket 1.0, which will be released under the Apache Software License, simplifies developers' ability to create and package reusable Web components by separating the creation of dynamic Web pages into two separate domains for designing and coding, according to the Wicket team. This allows the design and code teams to work independently without interfering with the other's process.

Read More

Wicket 1.5.3 in NetBeans IDE 7.1

Register this URL in your Plugin Manager: http://blogs.oracle.com/geertjan/resource/NetBeans4Wicket.xml OR http://java.net/projects/nbwicketsupport/sources/nbwicketsupport/show/WicketSuite/updates?rev=56.

(Note: The sources and binaries are at http://java.net/projects/nbwicketsupport, but for some reason you can't access NetBeans update centers if they're on java.net, hence I uploaded it into this blog.)

Then you'll be able to create Wicket applications in NetBeans IDE 7.1, in the final step of the New Web Application wizard:

Read More

A Simple Introduction To HTML5

At this point, you are probably tired of hearing how HTML5 is changing everything. Everything in web applications and even mobile applications are changing. HTML5 even lets you create a web application that works almost like a desktop application. Yes, there is a lot of hype about HTML5, especially when you consider that the specification is not entirely complete. However, there is a lot of information that is fairly stable, and this is driving much of the hype.
So, what is HTML5? Actually, it is not just HTML. It is a family of technologies that includes new HTML tags, CSS3, and some new APIs. The new tags and css are really helpful, but the APIs are the parts of the specification that are the source of the hype. As a simple introduction to HTML5, you can look at the HTML5 Logo site for the high-level categories of new features.

Read More