Java Frameworks

Windows - Copy all zip files from sub directories to separate folder.

noreply@blogger.com (Unknown) — Fri, 8 Dec 2023 06:55:00 -0800

Windows - Copy all zip files from sub directories to separate folder.

Please copy below script and run it in PowerShell in windows

-------------------------------------------------------------------------------------------------------

# Replace these paths with your actual source and destination directories

$sourceDirectory = "C:\path\to\source"

$destinationDirectory = "C:\path\to\destination"

# Check if the destination directory exists, and create it if not

if (-not (Test-Path -Path $destinationDirectory -PathType Container)) {

New-Item -ItemType Directory -Force -Path $destinationDirectory

Write-Host "Created destination directory: $($destinationDirectory)"

}

# Get all zip files in subdirectories containing "extract" in the path

$zipFiles = Get-ChildItem -Path $sourceDirectory -Recurse -Filter *.zip | Where-Object { $_.FullName -like "*extract*" }

# Copy each zip file to the destination directory

foreach ($zipFile in $zipFiles) {

$destinationPath = Join-Path -Path $destinationDirectory -ChildPath $zipFile.Name

Copy-Item -Path $zipFile.FullName -Destination $destinationPath -Force

Write-Host "Copied $($zipFile.Name) to $($destinationPath)"

}

Spring Exception: Spring boot package org.springframework.boot is not visible

noreply@blogger.com (Unknown) — Wed, 29 Nov 2023 22:02:00 -0800

DemoApplication.java: package org.springframework.boot is not visible.

(package org.springframework.boot is declared in the unnamed module, but module demo does not read it

Fix: Please delete the module-info.java file which is created by the IDE automatically and try again.

Sample Log:

[INFO] Scanning for projects...

[INFO]

[INFO] [1m--------------------------< [0;36mcom.example:demo [0;1m >-------------------------- [m

[INFO] [1mBuilding demo 0.0.1-SNAPSHOT [m

[INFO] from pom.xml

[INFO] [1m--------------------------------[ jar ]--------------------------------- [m

[INFO]

[INFO] [1m--- [0;32mresources:3.3.1:resources [m [1m(default-resources) [m @ [36mdemo [0;1m --- [m

[INFO] Copying 1 resource from src\main\resources to target\classes

[INFO] Copying 0 resource from src\main\resources to target\classes

[INFO]

[INFO] [1m--- [0;32mcompiler:3.11.0:compile [m [1m(default-compile) [m @ [36mdemo [0;1m --- [m

[INFO] Changes detected - recompiling the module! :input tree

[INFO] Compiling 2 source files with javac [debug release 17 module-path] to target\classes

[INFO] -------------------------------------------------------------

[ERROR] COMPILATION ERROR :

[INFO] -------------------------------------------------------------

[ERROR] /C:/Users/admin/Downloads/demo/src/main/java/com/example/demo/DemoApplication.java:[3,27] package org.springframework.boot is not visible

(package org.springframework.boot is declared in the unnamed module, but module demo does not read it)

[ERROR] /C:/Users/admin/Downloads/demo/src/main/java/com/example/demo/DemoApplication.java:[4,32] package org.springframework.boot.autoconfigure is not visible

(package org.springframework.boot.autoconfigure is declared in the unnamed module, but module demo does not read it)

[INFO] 2 errors

[INFO] -------------------------------------------------------------

[INFO] [1m------------------------------------------------------------------------ [m

[INFO] [1;31mBUILD FAILURE [m

[INFO] [1m------------------------------------------------------------------------ [m

[INFO] Total time: 2.215 s

[INFO] Finished at: 2023-11-30T11:22:46+05:30

[INFO] [1m------------------------------------------------------------------------ [m

[ERROR] Failed to execute goal [32morg.apache.maven.plugins:maven-compiler-plugin:3.11.0:compile [m [1m(default-compile) [m on project [36mdemo [m: [1;31mCompilation failure [m: Compilation failure:

[ERROR] /C:/Users/admin/Downloads/demo/src/main/java/com/example/demo/DemoApplication.java:[3,27] package org.springframework.boot is not visible

[ERROR] (package org.springframework.boot is declared in the unnamed module, but module demo does not read it)

[ERROR] /C:/Users/admin/Downloads/demo/src/main/java/com/example/demo/DemoApplication.java:[4,32] package org.springframework.boot.autoconfigure is not visible

[ERROR] (package org.springframework.boot.autoconfigure is declared in the unnamed module, but module demo does not read it)

[ERROR] -> [1m[Help 1] [m

[ERROR]

[ERROR] To see the full stack trace of the errors, re-run Maven with the [1m-e [m switch.

[ERROR] Re-run Maven using the [1m-X [m switch to enable full debug logging.

[ERROR]

[ERROR] For more information about the errors and possible solutions, please read the following articles:

[ERROR] [1m[Help 1] [m http://cwiki.apache.org/confluence/display/MAVEN/MojoFailureException

Interview Question - Important Spring Annotations to create REST API's

noreply@blogger.com (Unknown) — Wed, 29 Nov 2023 21:25:00 -0800

Essential Spring Annotations for REST API Development

Spring is a popular Java framework that simplifies the development of Java applications, including the creation of RESTful APIs. Here are some basic Spring annotations used in building a REST API along with brief descriptions:

Annotations for REST API:

@RestController

@RequestMapping

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping

@PathVariable

@RequestBody

@RequestParam

Annotations for Component Scanning:

@Service

@Repository

@Component

Annotations for Exception Handling:

@ControllerAdvice

@ExceptionHandler

@ResponseStatus

@RestControllerAdvice

1. Annotation: @RestController:

Description: This annotation is used to define a class as a RESTful controller. It combines the functionality of `@Controller` and `@ResponseBody`, indicating that the returned value from the methods should be directly written into the response body.

Example

@RestController

public class MyController {

// Controller methods go here

}

2. Annotation: @RequestMapping:

Description: This annotation is used to map HTTP requests to handler methods in the controller. It can be applied at the class level to specify a base URI for the entire controller, and at the method level to define specific URI patterns.

Example

@RestController

@RequestMapping("/api")

public class MyController {

@RequestMapping("/endpoint")

public String myEndpoint() {

// Method logic

return "Hello, World!";

}

3. Annotation: @GetMapping, @PostMapping, @PutMapping, @DeleteMapping:

Description: These annotations are shortcuts for `@RequestMapping` with the HTTP methods GET, POST, PUT, and DELETE respectively. They are used to define handler methods for specific HTTP methods.

Example

@RestController

@RequestMapping("/api")

public class MyController {

@GetMapping("/get")

public String getData() {

// Method logic

return "Data retrieved!";

}

@PostMapping("/post")

public String postData() {

// Method logic

return "Data posted!";

}

4. Annotation: @PathVariable:

Description: This annotation is used to extract values from the URI and bind them to method parameters. It is often used to capture template variables in the URI.

Example

@RestController

@RequestMapping("/api")

public class MyController {

@GetMapping("/user/{id}")

public String getUser(@PathVariable Long id) {

// Method logic

return "User ID: " + id;

}

5. Annotation: @RequestBody:

Description: This annotation is used to bind the HTTP request body to a method parameter. It is commonly used to handle data sent in the request body, such as JSON or XML.

Example

@RestController

@RequestMapping("/api")

public class MyController {

@PostMapping("/user")

public String createUser(@RequestBody User user) {

// Method logic

return "User created: " + user.getName();

}

6. Annotation: @RequestParam

Description: This annotation in Spring is used to extract query parameters from the request URL and bind them to method parameters. Here's an example of how to use `@RequestParam`:

Example

@RestController

@RequestMapping("/api")

public class MyController {

@GetMapping("/greet")

public String greetUser(@RequestParam(name = "name", defaultValue = "Guest") String userName) {

// Method logic

return "Hello, " + userName + "!";

}

In this example:

- `@RequestParam` is used to bind the value of the query parameter "name" to the `userName` method parameter.

- The `name` attribute in `@RequestParam` specifies the name of the query parameter.

- The `defaultValue` attribute provides a default value for the parameter if it is not present in the request.

For instance, if you send a GET request to `/api/greet` without any query parameters, the `userName` parameter will default to "Guest". If you send a request like `/api/greet?name=John`, then `userName` will be bound to "John".

Certainly! In Spring, `@Service`, `@Repository`, and `@Component` are stereotypes that define the roles of the annotated classes. These annotations are used to indicate the purpose of a class within the application and enable Spring to automatically discover and manage these components. Here's a brief description of each:

7. Annotation: @Service:

Description: This annotation is used to indicate that a class is a service class. Service classes in Spring typically contain business logic and are used to perform operations, manipulate data, or orchestrate the flow of the application. Service classes are often used in the service layer of a Spring application.

Example:

@Service

public class MyService {

// Service methods go here

}

8. Annotation: @Repository:

Description: This annotation is used to indicate that a class is a repository class. Repository classes in Spring are responsible for data access, database interactions, and generally encapsulate the logic to interact with a data source. It is commonly used in the data access layer of a Spring application.

Example:

@Repository

public class MyRepository {

// Repository methods go here

}

9. Annotation: @Component:

Description: This is a generic stereotype annotation indicating that a class is a Spring component. It is a general-purpose stereotype and is often used when the purpose of a class doesn't fit into the more specific categories of `@Service` or `@Repository`. Components are typically used as general-purpose beans that don't fall into more specific categories.

Example:

@Component

public class MyComponent {

// Component methods go here

}

These annotations play a crucial role in the Spring framework's component scanning mechanism. When you annotate a class with `@Service`, `@Repository`, or `@Component`, Spring automatically detects and registers these classes as Spring beans, making them available for dependency injection and other Spring features.

Remember that the specific choice between `@Service`, `@Repository`, or `@Component` often depends on the role or purpose of the class within your application. The primary distinction is more semantic than functional, but it helps in organizing and understanding the responsibilities of different classes within your codebase.

In Spring, there are several annotations related to exception handling that help you handle exceptions in a more organized and centralized manner. Here are some commonly used annotations:

10. Annotation: @ControllerAdvice:

Description: This annotation is used to define a global exception handler for the entire application. It allows you to consolidate your exception handling logic in one place and apply it across multiple controllers.

Example:

@ControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler(Exception.class)

public ResponseEntity<String> handleException(Exception ex) {

// Handle the exception

return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("An error occurred");

}

11. Annotation: @ExceptionHandler:

Description: This annotation is used within a class annotated with `@ControllerAdvice` to define methods that handle specific exceptions. Each method annotated with `@ExceptionHandler` will handle a particular type of exception.

Example:

@ControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler(ResourceNotFoundException.class)

public ResponseEntity<String> handleResourceNotFoundException(ResourceNotFoundException ex) {

// Handle the specific exception

return ResponseEntity.status(HttpStatus.NOT_FOUND).body(ex.getMessage());

}

12. Annotation: @ResponseStatus:

Description: This annotation is used to specify the HTTP status code to be returned when a specific exception is thrown. It can be used in conjunction with `@ExceptionHandler`.

Example:

@ControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler(ResourceNotFoundException.class)

@ResponseStatus(HttpStatus.NOT_FOUND)

public String handleResourceNotFoundException(ResourceNotFoundException ex) {

// Handle the exception, no need to return ResponseEntity

return ex.getMessage();

}

13. Annotation: @ControllerAdvice + @RestControllerAdvice:

Description: While `@ControllerAdvice` is designed for traditional MVC controllers returning views, `@RestControllerAdvice` is tailored for RESTful controllers returning data. It combines `@ControllerAdvice` and `@ResponseBody`.

Example:

@RestControllerAdvice

public class GlobalExceptionHandler {

@ExceptionHandler(Exception.class)

public ResponseEntity<String> handleException(Exception ex) {

// Handle the exception for RESTful controllers

return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("An error occurred");

}

These annotations allow you to define a centralized and consistent approach to handle exceptions in your Spring application. By using `@ControllerAdvice` and `@ExceptionHandler`, you can customize the response for different types of exceptions, making your exception handling logic more modular and maintainable.

These are just a few of the basic annotations in Spring for building RESTful APIs. There are many more annotations and features provided by the Spring framework to handle various aspects of RESTful service development, such as content negotiation, exception handling, and security.

Building a RESTful API with Spring Boot: A Comprehensive Guide with annotations

noreply@blogger.com (Unknown) — Sun, 30 Jul 2023 23:47:00 -0700

Spring Boot: End to end example with annotations

Note: You can create and download the sample maven Spring Boot application by using Spring Starter website - https://start.spring.io/

Create a Spring Boot Application Class:

@SpringBootApplication: This annotation is the heart of a Spring Boot application. It is a combination of three annotations: @Configuration, @EnableAutoConfiguration, and @ComponentScan.
This single annotation initializes the Spring context, enables auto-configuration, and scans for Spring components within the package and its sub-packages.

Use Case: Place this annotation on the main class of your Spring Boot application to bootstrap the application.

BookApplication.java

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class BookApplication {

public static void main(String[] args) {

SpringApplication.run(BookApplication.class, args);

}

2. Create a Book Entity:

@Entity: Marks the Book class as an entity, allowing it to be persisted in the database.

Book.java

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

@Entity

public class Book {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String title;

private String author;

// Constructors, getters, and setters (or) use Lombok @Data annotation

}

3. Create a Book Repository:

@Repository: Not shown explicitly, but Spring Data JPA automatically detects the BookRepository interface as a repository and provides implementation for CRUD operations.

BookRepository.java

import org.springframework.data.jpa.repository.JpaRepository;

@Repository

public interface BookRepository extends JpaRepository<Book, Long> {

// Custom queries if needed - @Query("your custom query here")

}

4. Create a REST Controller:

@RestController: Marks the BookController class as a REST controller, allowing it to handle HTTP requests.
@RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping: Define the endpoints for the REST API and map them to specific controller methods.
@Autowired: Injects the BookRepository bean into the BookController constructor.

BookController.java

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController

@RequestMapping("/api/books")

public class BookController {

private final BookRepository bookRepository;

@Autowired

public BookController(BookRepository bookRepository) {

this.bookRepository = bookRepository;

}

@GetMapping

public List<Book> getAllBooks() {

return bookRepository.findAll();

}

@GetMapping("/{id}")

public Book getBookById(@PathVariable Long id) {

return bookRepository.findById(id)

.orElseThrow(() -> new ResourceNotFoundException("Book not found with id: " + id));

}

@PostMapping

public Book createBook(@RequestBody Book book) {

return bookRepository.save(book);

}

@PutMapping("/{id}")

public Book updateBook(@PathVariable Long id, @RequestBody Book book) {

Book existingBook = bookRepository.findById(id)

.orElseThrow(() -> new ResourceNotFoundException("Book not found with id: " + id));

existingBook.setTitle(book.getTitle());

existingBook.setAuthor(book.getAuthor());

return bookRepository.save(existingBook);

}

@DeleteMapping("/{id}")

public void deleteBook(@PathVariable Long id) {

bookRepository.deleteById(id);

}

5. Create a Custom Exception Handler: Resulting HTTP Response (optional) :

If the book with the given id is not found, Spring will catch the ResourceNotFoundException, and as a result of the @ResponseStatus(HttpStatus.NOT_FOUND) annotation, the HTTP response will have a status code of 404 (Not Found). The response will look like this:

HTTP/1.1 404 Not Found

Content-Type: application/json

Date: [Current Date]

{

"message": "Book not found with id: [id]"

}

By using the @ResponseStatus annotation, we can easily control the HTTP status codes returned to the client in specific scenarios, making it easier to communicate the status of the request and handle errors gracefully.

ResourceNotFoundException.java

import org.springframework.http.HttpStatus;

import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(HttpStatus.NOT_FOUND)

public class ResourceNotFoundException extends RuntimeException {

public ResourceNotFoundException(String message) {

super(message);

}

6. Enable Caching (optional) :

@EnableCaching: Enables Spring's caching support in the application (not shown with actual caching logic).

CachingConfig.java

import org.springframework.cache.annotation.EnableCaching;

import org.springframework.context.annotation.Configuration;

@Configuration

@EnableCaching

public class CachingConfig {

// Caching configuration (if needed)

}

Remember that this is just a basic example to illustrate the usage of the annotations. In a real-world scenario, you might want to add more features, validation, error handling, security configurations, etc., based on your application requirements.

Real-Time Spring Boot Application with Spring Web, Spring Data JPA, Database, Postman in 25 mins

noreply@blogger.com (Unknown) — Sat, 29 Jul 2023 05:45:00 -0700

Building a Real-Time Spring Boot Application in 25 mins by using

1. Spring Web,

2. Spring Data JPA

3. H2 Database (In-Memory)

4. Lombok - How to install Lombok

5. Log4j,

6. and Testing with Postman

Using SonarLint: 🚀 Boost Your Code Quality with SonarLint! 🚀 A Step-by-Step Tutorial with Visuals and Screenshots

noreply@blogger.com (Unknown) — Sat, 29 Jul 2023 04:56:00 -0700

Step-by-step tutorial on how to use SonarLint, a code analysis tool, along with a textual description of a sample scenario.

What is SonarLint?

SonarLint is a code quality tool that helps developers identify and fix issues in their code as they write it. It integrates with various Integrated Development Environments (IDEs) like Eclipse, IntelliJ IDEA, Visual Studio, and more.

2. Install SonarLint:

a. Go to the official SonarLint website or use your IDE's plugin repository to find and install the SonarLint plugin relevant to your IDE.

b. If you are using Eclipse/STS, follow these steps: To install from Marketplace

- Go to Help -> Eclipse Marketplace.

- Search for "Sonar" and locate "SonarLint."

- Click "Install" and accept any necessary permissions.

- Restart Eclipse when prompted.

c. (or) Install via offline plugin, if you have any proxy or certificate issues

- Download latest offline SonarLint plugin archive file from official Sonar repository

Official Site: Offline Plugin - Sonarlint

Example file name: org.sonarlint.eclipse.site-7.9.0.66038.zip

- Open Eclipse

- From the menu choose: Help => Install New Software...

- Click the Add button

- In the Add Repository dialog that appears, click the Archive button next to the Location field

- Select your plugin file, click OK

3. Setting up SonarLint:

- After installation, open your IDE and find the SonarLint settings. Usually, you can find it under the "Preferences" or "Settings" menu.

- In the SonarLint settings, configure the tool to connect to your preferred SonarQube or SonarCloud server if you have one. This step is optional but allows you to use a centralized server to manage and track code quality across projects.

4. Open a Project:

- Open an existing project or create a new one in your IDE.

5. Analyzing Code with SonarLint:

- As you start writing or modifying code, SonarLint will automatically analyze it in the background and provide real-time feedback on potential issues.

- It will display notifications, warnings, and error markers within the code editor, highlighting problematic lines.

6. Review and Fix Issues:

- Click on the SonarLint markers or hover over them to see more information about the issue.

- SonarLint will display a description of the problem and suggest potential fixes or improvements.

- Manually review the suggestions and apply the necessary changes to improve the code quality.

Sample Scenario:

Imagine you're working on a Java project in any IDE, and you have just installed the SonarLint plugin.

1. Open your IDE and create a new Java project.

2. In the Java file you're working on, intentionally add a piece of code that violates a coding rule, like a method with a high cyclomatic complexity.

3. As you type, SonarLint will analyze your code in the background. It will detect the high cyclomatic complexity issue and highlight the problematic method.

4. Click on the SonarLint marker or hover over it to see the issue description, which will likely explain that the method has a high complexity and provide suggestions to refactor it.

5. Follow the suggestions provided by SonarLint to improve the code. For example, you might break down the complex method into smaller, more manageable methods to reduce the cyclomatic complexity.

6. Save the changes and observe how the SonarLint marker disappears or changes color, indicating that the issue has been addressed.

Remember that SonarLint is an invaluable tool for maintaining code quality, but it's not a substitute for manual code review and careful consideration. It's essential to use SonarLint as a supplement to your own expertise in writing clean and maintainable code.

Multiple OR and AND SELECT query in JDBC with example Java program

noreply@blogger.com (Unknown) — Thu, 8 Jun 2023 07:13:00 -0700

Here's an example of a SELECT query with multiple OR and AND combinations:

Sample select query to get the all the matching data of first name and last name combination :

SELECT *

FROM Employee

WHERE

(First_Name = ‘value1’ AND Last_Name = ‘value2’)

OR (First_Name = ‘value3’ AND Last_Name = ‘value4’)

OR (First_Name = ‘value5’ AND Last_Name = ‘value6’);

You can modify the column names and values to fit your specific use case. Additionally, you can include more OR and AND combinations as needed.

To implement the same query using Java JDBC, you'll need to establish a connection to your database and execute the query using a PreparedStatement object. Here's an example:

import java.sql.*;

import java.util.Map;

public class JDBCExample {

public static void main(String[] args) {

String url = "jdbc:mysql://localhost:3306/database_name";

String username = "your_username";

String password = "your_password";

try (Connection conn = DriverManager.getConnection(url, username, password)) {

String tableName = “Employee”;

// Your method to get the dynamic column-value map, First Name as Key and Last Name as Value

Map<String, String> columnValueMap = getDynamicColumnValueMap();

StringBuilder sqlBuilder = new StringBuilder("SELECT Emp_Id, First_Name, Last_Name FROM ");

sqlBuilder.append(tableName);

if (!columnValueMap.isEmpty()) {

sqlBuilder.append(" WHERE ");

int paramCount = 1;

for (Map.Entry<String, String> entry : columnValueMap.entrySet()) {

if (paramCount > 1) {

sqlBuilder.append(" OR ");

}

sqlBuilder.append(" First_Name = ?");

sqlBuilder.append(“ Last_Name = ?");

paramCount++;

}

String sql = sqlBuilder.toString();

System.out.println(“sql: ” + sql);

PreparedStatement stmt = conn.prepareStatement(sql);

int paramIndex = 1;

for (Map.Entry<String, String> entry : columnValueMap.entrySet()) {

stmt.setObject(++paramIndex, entry.getKey());

stmt.setObject(++paramIndex, entry.getValue());

}

ResultSet rs = stmt.executeQuery();

// Process the ResultSet as needed

while (rs.next()) {

// Retrieve column values using rs.getXXX() methods and store into custom employee object

// Replace XXX with the appropriate data type of the column

// Example: String value = rs.getInt(“Emp_Id”);

// Example: String value = rs.getString(“First_Name”);

}

rs.close();

stmt.close();

} catch (SQLException e) {

e.printStackTrace();

}

private static Map<String, Object> getDynamicColumnValueMap() {

// Your implementation to populate and return the dynamic column-value map

// This could be based on user input, configuration, or any other source

// Return a map where the keys are column names and values are the corresponding values

// Example: Map<String, String> columnValueMap = new HashMap<>();

// columnValueMap.put(“value1”, “value2”);

// columnValueMap.put(“value3”, “value4”);

// return columnValueMap;

}

This example assumes you are using the MySQL database, but you can modify the URL and driver class accordingly for your specific database management system. Also, remember to handle any potential SQLExceptions that may occur during the execution of the query.

Another example to implement with IN keyword

If you want to use the IN keyword to match multiple values for a single column, you can modify the Java JDBC code accordingly. Here's an example:

import java.sql.*;

import java.util.List;

public class JDBCExample {

public static void main(String[] args) {

String url = "jdbc:mysql://localhost:3306/database_name";

String username = "your_username";

String password = "your_password";

try (Connection conn = DriverManager.getConnection(url, username, password)) {

String tableName = "table_name";

String columnName = "column_name";

List<Object> values = getDynamicValues(); // Your method to get the dynamic values

StringBuilder sqlBuilder = new StringBuilder("SELECT * FROM ");

sqlBuilder.append(tableName);

if (!values.isEmpty()) {

sqlBuilder.append(" WHERE ").append(columnName).append(" IN (");

int paramCount = 1;

for (int i = 0; i < values.size(); i++) {

if (paramCount > 1) {

sqlBuilder.append(", ");

}

sqlBuilder.append("?");

paramCount++;

}

sqlBuilder.append(")");

}

String sql = sqlBuilder.toString();

PreparedStatement stmt = conn.prepareStatement(sql);

for (int i = 0; i < values.size(); i++) {

stmt.setObject(i + 1, values.get(i));

}

ResultSet rs = stmt.executeQuery();

// Process the ResultSet as needed

while (rs.next()) {

// Retrieve column values using rs.getXXX() methods

// Replace XXX with the appropriate data type of the column

// Example: String value = rs.getString("column_name");

}

rs.close();

stmt.close();

} catch (SQLException e) {

e.printStackTrace();

}

private static List<Object> getDynamicValues() {

// Your implementation to populate and return the dynamic values

// This could be based on user input, configuration, or any other source

// Return a list of values to be used in the IN clause

// Example: List<Object> values = List.of(value1, value2, value3);

// return values;

}

In this example, the getDynamicValues() method represents your implementation to populate the dynamic list of values to be used in the IN clause. The list can be retrieved based on your requirements (e.g., user input, configuration, etc.).

The code then builds the SQL query dynamically using a StringBuilder, appending the IN clause with the appropriate number of placeholders (?) based on the size of the values list.

The values are then set using the setObject() method on the PreparedStatement object.

Remember to adjust the tableName and columnName variables with your specific table and column names.

Again, ensure proper input validation and handling for the dynamic values to maintain the integrity and safety of the query execution.

Java Collection Framework: A Comprehensive Overview

noreply@blogger.com (Unknown) — Sat, 15 Apr 2023 07:10:00 -0700

About Java's Collection Framework

Java is a popular programming language used in a wide range of applications, from mobile applications to large-scale enterprise software. One of the key features that make Java a powerful language is its Collection Framework.

The Java Collection Framework provides a comprehensive set of classes and interfaces for managing and manipulating groups of objects. It is designed to be efficient, flexible, and easy to use. In this article, we'll take a closer look at the Java Collection Framework and its various components.

The Java Collection Framework Hierarchy

The Java Collection Framework is based on a hierarchy of interfaces and classes. At the top of the hierarchy is the Collection interface, which defines the basic operations that all collections should support, such as adding and removing elements, checking for the presence of an element, and getting an iterator.

Below the Collection interface are two sub-interfaces: List and Set. List is an ordered collection of elements, where each element can be accessed by its index. Set is an unordered collection of unique elements. Both List and Set extend the Collection interface and provide additional operations specific to their behavior.

The Map interface is a separate branch in the hierarchy. A Map is an object that maps keys to values, where each key is unique. The Map interface defines operations for adding, removing, and retrieving key-value pairs.

Concrete Implementations

Java provides several concrete implementations of the Collection interfaces, each with its own strengths and weaknesses. Some of the most commonly used implementations are:

ArrayList: A resizable array that provides fast random access and insertion at the end of the list.

LinkedList: A linked list that provides fast insertion and deletion at any position in the list.

HashSet: A set that uses a hash table to store its elements, providing fast access and insertion, but unordered iteration.

TreeSet: A set that uses a red-black tree to store its elements, providing ordered iteration and fast access.

HashMap: A map that uses a hash table to store its key-value pairs, providing fast access and insertion, but unordered iteration.

TreeMap: A map that uses a red-black tree to store its key-value pairs, providing ordered iteration and fast access.

There are several other concrete implementations available, each with its own characteristics and use cases.

Iterators

One of the key features of the Java Collection Framework is its support for iterators. An iterator is an object that allows you to iterate over the elements of a collection, one at a time. All collections in the Java Collection Framework provide an iterator() method that returns an Iterator object.

The Iterator interface defines the hasNext() and next() methods, which allow you to check if there are more elements in the collection and retrieve the next element, respectively. Iterators also provide a remove() method for removing the current element from the collection.

Java also provides a for-each loop, which makes it easy to iterate over the elements of a collection without having to explicitly use an iterator.

Conclusion

The Java Collection Framework provides a powerful set of tools for managing and manipulating collections of objects. By using the right collection class for the job and taking advantage of iterators, you can write efficient and flexible code that is easy to read and maintain.

How to Install Lombok in your IDE: Step-by-Step Guide to install Lombok in Mac

noreply@blogger.com (MP) — Sat, 15 Apr 2023 02:28:00 -0700

To install Lombok in any IDE, follow the steps below:

Download the latest Lombok Jar file from the Project Lombok website by clicking on this link: Project Lombok jar . Make sure to choose the correct version of the Jar file based on the version of Java you are using.

Once the download is complete, open the downloaded jar file by double-clicking on it. If you are using a Mac, you may need to run the command "sudo java -jar lombok.jar" in the terminal to open the file.

Mac: sudo java -jar lombok.jar

Windows: java -jar lombok.jar

A popup window will appear with a message "I con't find any IDEs on your computer" to install Lombok. Click the "Okay" button to choose the IDE location manually to proceed with the installation.

Next, click on the "Specify Location" button to manually add your IDE location for installing Lombok. This is important as it tells Lombok where to install itself so that it can work with your IDE.

In the file dialog that appears, navigate to the location where your IDE is installed and select the configuration file. For example, in the case of Spring Tool Suite, you would select the "SpringToolSuite4.ini" file.

Path: /Applications/SpringToolSuite4.app/Contents/Eclipse/SpringToolSuite4.ini

Once you have selected the configuration file, you will see a screen with details about your IDE. Click on the "Install/Update" button to begin installing Lombok in your IDE.

The installation process may take a few minutes to complete. Once it's finished, you will see a screen confirming that Lombok has been successfully installed in your IDE.

Finally, to verify that Lombok is installed and working properly, go to the installation location of your IDE and open the configuration file. You should see details about the Lombok jar file and its version number.

By following these steps, you should be able to install Lombok in your IDE and start using its features to simplify your Java code.

org.apache.catalina.LifecycleException: Failed to start component

noreply@blogger.com (MP) — Wed, 12 Mar 2014 07:00:00 -0700

SEVERE: A child container failed during start
java.util.concurrent.ExecutionException: org.apache.catalina.LifecycleException: Failed to start component [StandardEngine[Catalina].StandardHost[localhost].StandardContext[/JSFApp]]
at java.util.concurrent.FutureTask.report(Unknown Source)
at java.util.concurrent.FutureTask.get(Unknown Source)
at org.apache.catalina.core.ContainerBase.startInternal(ContainerBase.java:1123)
at org.apache.catalina.core.StandardHost.startInternal(StandardHost.java:800)
at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:150)
at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1559)
at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1549)
at java.util.concurrent.FutureTask.run(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)

You are missing commons-digester3-3.2.jar from Apache Commons Digester LINK. If you are using Maven dependies you can add:

<dependency>
<groupId>commons-digester</groupId>
<artifactId>commons-digester</artifactId>
<version>2.1</version>
</dependency>

to your project dependencies.

HTTP Status 406 The resource identified by this request is only capable of generating responses with characteristics not acceptable according to the request "accept" headers.

noreply@blogger.com (MP) — Tue, 11 Mar 2014 12:25:00 -0700

HTTP Status 406

The resource identified by this request is only capable of generating responses with characteristics not acceptable according to the request "accept" headers.

Add following JSON jars to Project lib link

1. jackson-annotations-2.2.3.jar
2. jackson-core-2.2.3.jar
3. jackson-databind-2.2.3.jar

Or

Add following dependies

<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.2.3</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.2.3</version>
</dependency>

Flex Application performance improvement

noreply@blogger.com (MP) — Fri, 7 Feb 2014 03:14:00 -0800

Flex Application’s performance improvement

1) Flex Profiling
2) SWF size improvement

3) Loading styles dynamically

1. Flex Profiling:

By using Flex Profiling we can identify performance bottlenecks and memory leaks in your application.

Flex Profiler records data about the state of the application, including the number of objects, the size of those objects, the number of method calls, and the time spent in those method calls.

Types of profiling:

Before you use the profiler, you should decide what kind of profiling you are going to do: performance profiling or memory profiling.

Performance profiling: is the process of looking for methods in your application that run slowly and can be improved. Once identified, these hot spots can be optimized to speed up execution times so that your application runs faster and responds more quickly to user interaction. You generally look for two things when doing performance profiling: a method that is called only once but takes more time to run than similar methods, or a method that may not take much time to run but is called many times. You use the performance profiling data to identify the methods that you then optimize. You might find that reducing the number of calls to a method is more effective than refactoring the code within the method.

Memory profiling: is the process of examining how much memory each object or type of object is using in the application. You use the memory profiling data in several ways: to see if there are objects that are larger than necessary, to see if there are too many objects of a single type, and to identify objects that are not garbage collected (memory leaks). By using the memory profiling data, you can try to reduce the size of objects, reduce the number of objects that are created, or allow objects to be garbage collected by removing references to them.

2. SWF Size reduction techniques:

1) RSL

2) Modules

3) Bin Release Version

RSL (Runtime Shared Library):

One way to reduce the size of your applications' SWF files is by externalizing shared assets into stand-alone files that can be separately downloaded and cached on the client. These shared assets can be loaded and used by any number of applications at run time, but must be transferred only once to the client. These shared files are known as Runtime Shared Libraries or RSLs.

Steps: Right Click on the Project, go to Properties.

Modules:

Modular development is an approach to software design and architecture that separates application components into separate logical components, or modules. Each module is a logical grouping of functionality, thus common logic and common tasks are bundled into the same module.

Modules are SWF files that can be loaded and unloaded by an application. They cannot be run independently of an application, but any number of applications can share the modules.

Modules let you split your application into several pieces, or modules. The main application, or shell, can dynamically load other modules that it requires, when it needs them. It does not have to load all modules when it starts, nor does it have to load any modules if the user does not interact with them. When the application no longer needs a module, it can unload the module to free up memory and resources.

Modular applications have the following benefits:

· Smaller initial download size of the SWF file.

· Shorter load time due to smaller SWF file size.

· Better encapsulation of related aspects of an application. For example, a "reporting" feature can be separated into a module that you can then work on independently.

Bin Release Version: By default Output SWF files contain debugging information. We can use bin-release option to remove all the debugging information, so that your SWF file size is decreased.

Adobe Flex 4 Features

noreply@blogger.com (MP) — Fri, 7 Feb 2014 03:02:00 -0800

Adobe Flex 4 Features

Features:

§ Spark component architecture

§ Component layout

§ Effects

§ Text Layout Framework

§ Themes

§ Skinning

§ FXG

1.Spark component architecture:

The biggest change to Flex 4 is the introduction of a new skinning and component architecture called Spark. Many components from the previous versions of Flex are re-implemented using the Spark component architecture.

Define a clean separation between the functional logic of the component and its appearance.

Spark components consists of two classes to support the separation of logic and appearance: an Action Script class that defines a component's logic and an MXML skin class that defines its visual appearance. To change the component's logic, subclass the component class and add your own behavior. To change the component's appearance but not its logic, customize the skin.

Create a small set of basic components that are easily customized by developers.

2. Component layout:

Component layout is the process where a parent component sizes and positions its child components. In the Spark component architecture, layout has been decoupled from individual components. You can now set the layout declaratively in MXML, or modify it at runtime in ActionScript.

§ BasicLayout Uses absolute positioning. You explicitly position all component children, or use constraints to position them.

§ HorizontalLayout Lays out children in a single horizontal row.

§ TileLayout Lays out children in one or more vertical columns or horizontal rows, starting new rows or columns as necessary. All cells of the tile layout have the same size, which is the height of the tallest child and the width of the widest child.

§ VerticalLayout Lays out children in a single vertical column.

MX component	Spark equivalent
Canvas	Group with BasicLayout
HBox	Group with HorizontalLayout, or HGroup
VBox	Group with VerticalLayout, or VGroup
Tile	Group with TileLayout, or TileGroup
List	List with VerticalLayout
TileList	List with TileLayout
HorizontalList	List with HorizontalLayout

3.Text Layout Framework:

The Text Layout Framework (TLF) is a class library built on top of the Flash Text Engine (FTE). The FTE, available in Adobe® Flash Player® 10 and Adobe® AIR® 1.5, adds advanced text capabilities to Flash Player.

The new FTE classes offer low-level support for controlling text metrics, vertical text, typographic elements such as ligatures, and bidirectional text. Also, device fonts now have most of the functionality of embedded fonts and can be anti-aliased, rotated, and styled. In most cases, you do not use the FTE classes directly.

Text Layout Framework (TLF) provides high-level text functionality:

1. Bidirectional text, vertical text, and over 30 writing systems, including Arabic, Hebrew, Chinese, Japanese, Korean, Thai, Lao, and the major writing systems of India

2. Selecting, editing, and flowing text across multiple columns and linked containers, as well as around inline images

3. Vertical text, Tate-Chu-Yoko (horizontal within vertical text), and justifiers for East Asian typography

4. Rich typographical controls, including kerning, ligatures, typographic case, digit case, digit width, and discretionary hyphens

5. Cut, copy, paste, undo, and standard keyboard and mouse controls for editing.

4.Flash XML Graphics:

§ Graphics and text primitives, like Rectangles, Paths, and Ellipses

§ Fills, strokes, gradients, and bitmaps

§ Support for effects such as filters, masks, alphas, transforms, and blend modes

Write a program to find the given number is armstrong or not?

noreply@blogger.com (MP) — Thu, 30 Jan 2014 03:31:00 -0800

Write a program to find the given number is Armstrong or not in java?

An Armstrong number is a number that is equal to the sum of their individual digit cubes
Ex: 153 = (1*1*1 + 5*5*5 + 3*3*3)

Program:

package com.java.javafws.example;

public class AmstrongEx {

 public boolean isArmstrongNumber(int number) {

  int tmp = number;
  int sum = 0;
  int div = 0;
  while (tmp > 0) {
   div = tmp % 10;
   sum += div * div * div; // or Math.pow(div, 3);
   tmp = tmp / 10;
  }
  if (number == sum) {
   return true;
  } else {
   return false;
  }
 }

 public static void main(String a[]) {
  AmstrongEx an = new AmstrongEx();
  System.out.println("Is 371 Armstrong number? = "
    + an.isArmstrongNumber(371));
  System.out.println("Is 523 Armstrong number? = "
    + an.isArmstrongNumber(523));
  System.out.println("Is 153 Armstrong number? = "
    + an.isArmstrongNumber(153));
 }
}

Result :

Is 371 Armstrong number? = true
Is 523 Armstrong number? = false
Is 153 Armstrong number? = true

Converting XML to ArrayCollection or Array in ActionScript Example

noreply@blogger.com (MP) — Fri, 27 Dec 2013 09:54:00 -0800

Convert and Store XML data to ArrayCollection or Array in ActionScript Example.

1. XML
books.xml

<?xml version="1.0"?>
<catalog>
   <book id="bk101">
      <author>Gambardella, Matthew</author>
      <title>XML Developer's Guide</title>
      <genre>Computer</genre>
      <price>44.95</price>
      <publish_date>2000-10-01</publish_date>
      <description>An in-depth look at creating applications 
      with XML.</description>
   </book>
   <book id="bk102">
      <author>Ralls, Kim</author>
      <title>Midnight Rain</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2000-12-16</publish_date>
      <description>A former architect battles corporate zombies, 
      an evil sorceress, and her own childhood to become queen 
      of the world.</description>
   </book>
   <book id="bk103">
      <author>Corets, Eva</author>
      <title>Maeve Ascendant</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2000-11-17</publish_date>
      <description>After the collapse of a nanotechnology 
      society in England, the young survivors lay the 
      foundation for a new society.</description>
   </book>
   <book id="bk104">
      <author>Corets, Eva</author>
      <title>Oberon's Legacy</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2001-03-10</publish_date>
      <description>In post-apocalypse England, the mysterious 
      agent known only as Oberon helps to create a new life 
      for the inhabitants of London. Sequel to Maeve 
      Ascendant.</description>
   </book>
   <book id="bk105">
      <author>Corets, Eva</author>
      <title>The Sundered Grail</title>
      <genre>Fantasy</genre>
      <price>5.95</price>
      <publish_date>2001-09-10</publish_date>
      <description>The two daughters of Maeve, half-sisters, 
      battle one another for control of England. Sequel to 
      Oberon's Legacy.</description>
   </book>
   <book id="bk106">
      <author>Randall, Cynthia</author>
      <title>Lover Birds</title>
      <genre>Romance</genre>
      <price>4.95</price>
      <publish_date>2000-09-02</publish_date>
      <description>When Carla meets Paul at an ornithology 
      conference, tempers fly as feathers get ruffled.</description>
   </book>
   <book id="bk107">
      <author>Thurman, Paula</author>
      <title>Splish Splash</title>
      <genre>Romance</genre>
      <price>4.95</price>
      <publish_date>2000-11-02</publish_date>
      <description>A deep sea diver finds true love twenty 
      thousand leagues beneath the sea.</description>
   </book>
   <book id="bk108">
      <author>Knorr, Stefan</author>
      <title>Creepy Crawlies</title>
      <genre>Horror</genre>
      <price>4.95</price>
      <publish_date>2000-12-06</publish_date>
      <description>An anthology of horror stories about roaches,
      centipedes, scorpions  and other insects.</description>
   </book>
   <book id="bk109">
      <author>Kress, Peter</author>
      <title>Paradox Lost</title>
      <genre>Science Fiction</genre>
      <price>6.95</price>
      <publish_date>2000-11-02</publish_date>
      <description>After an inadvertant trip through a Heisenberg
      Uncertainty Device, James Salway discovers the problems 
      of being quantum.</description>
   </book>
   <book id="bk110">
      <author>O'Brien, Tim</author>
      <title>Microsoft .NET: The Programming Bible</title>
      <genre>Computer</genre>
      <price>36.95</price>
      <publish_date>2000-12-09</publish_date>
      <description>Microsoft's .NET initiative is explored in 
      detail in this deep programmer's reference.</description>
   </book>
   <book id="bk111">
      <author>O'Brien, Tim</author>
      <title>MSXML3: A Comprehensive Guide</title>
      <genre>Computer</genre>
      <price>36.95</price>
      <publish_date>2000-12-01</publish_date>
      <description>The Microsoft MSXML3 parser is covered in 
      detail, with attention to XML DOM interfaces, XSLT processing, 
      SAX and more.</description>
   </book>
   <book id="bk112">
      <author>Galos, Mike</author>
      <title>Visual Studio 7: A Comprehensive Guide</title>
      <genre>Computer</genre>
      <price>49.95</price>
      <publish_date>2001-04-16</publish_date>
      <description>Microsoft Visual Studio 7 is explored in depth,
      looking at how Visual Basic, Visual C++, C#, and ASP+ are 
      integrated into a comprehensive development 
      environment.</description>
   </book>
</catalog>

2. MXML Application.

XMLApp.mxml

<?xml version="1.0" encoding="utf-8"?> 
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"               
  xmlns:s="library://ns.adobe.com/flex/spark"               
  xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600"              
  creationComplete="loadXMLFile()">     
 <fx:Declarations>             
 </fx:Declarations>         
 <fx:Script>        
  <![CDATA[             
   import flash.events.Event;             
   import flash.net.URLLoader;             
   import flash.net.URLRequest;                         
   import mx.collections.ArrayCollection;                         
   private var _xml:XML;
   private var _bookArray:ArrayCollection = new ArrayCollection(); 
   private function loadXMLFile():void {   
    var loader= new URLLoader(new URLRequest("books.xml"));                
    loader.addEventListener(Event.COMPLETE, loadedCompleteHandler);          
   }                        
   private function loadedCompleteHandler(e:Event):void             {               
    e.target.removeEventListener(Event.COMPLETE, loadedCompleteHandler);            
    _xml = XML(e.target.data);              
    for each (var book:XML in _xml.book) { 
     var bookObj:Object = new Object();                              
     bookObj.author = book.author;                  
     bookObj.title = book.title;                 
     bookObj.genre = book.genre;                 
     bookObj.price = book.price;                 
     bookObj.publish_date = book.publish_date;    
     bookObj.description = book.description;      
     _bookArray.addItem(bookObj);                 
     trace("author: " + book.author);             
     trace("title: " + book.title);               
     trace("genre: " + book.genre);               
     trace("price: " + book.price);              
     trace("publish_date: " + book.publish_date);    
     trace("description: " + book.description);      
    }        
   }         
   ]]>   
  </fx:Script>  
  <s:DataGrid id="dataGrid" dataProvider="{_bookArray}" requestedRowCount="10" >   
   <s:columns>            
    <s:ArrayList>                
     <s:GridColumn dataField="author" headerText="Author" width="130"></s:GridColumn>    
     <s:GridColumn dataField="title" headerText="Title" width="180" ></s:GridColumn>     
     <s:GridColumn dataField="genre" headerText="Genre" width="100" ></s:GridColumn>      
     <s:GridColumn dataField="price" headerText="Price" width="80" ></s:GridColumn>       
     <s:GridColumn dataField="publish_date" headerText="Publish Date" width="100" ></s:GridColumn>    
     <s:GridColumn dataField="description" headerText="Description" width="300" ></s:GridColumn>                             
   </s:ArrayList>         
  </s:columns>     
 </s:DataGrid>     
</s:Application>

3. Result.

Flex Interview Questions with Answer for Experienced Page 3

noreply@blogger.com (MP) — Wed, 11 Dec 2013 02:51:00 -0800

Flex Interview Questions with Answer for Experienced Page 3

41. By using push( ) and pop( ) methods

42. What type of skinning is available in Flex?

Graphical skinning, Programmatic Skinning and Stateful skinning.

Graphical Skins: Images that define the appearance of the skin. These images can JPEG, GIF, or PNG files, or they can be symbols embedded in SWF files. Typically you use drawing software such as Adobe Photoshop or Adobe Illustrator to create graphical skins.

Programmatic Skins: Action Script or MXML classes that define a skin. To change the appearance of controls that use programmatic skins, you edit an Action Script or MXML file. You can use a single class to define multiple skins.

Sateful Skins: A type of programmatic skin that uses view states, where each view state corresponds to a state of the component. The definition of the view state controls the look of the skin. Since you can have multiple view states in a component, you can use a single component to define multiple skins.

43. What is the difference between Graphical skinning and Stateful skinning?

44. What is CSS (Cascading Style Sheet)?

Cascading Style Sheets (CSS) are used in Flex to apply styles to visual components on the application display list. CSS is a standard for encapsulating the code that makes up the design of an Application. Given the power and maturity of CSS, most experienced Web designers/developers strive to implement as much of the design and layout properties of a Web site/application in CSS as possible. The result is much greater control and flexibility over the look and feel of the site.

Some features of CSS

Global: styles applied to all the components.

Type selector: Applied to particular type of components in entire project.

Style Name selector: Applied to only one component by specifying the Style Name property.

45. Difference between SWC and SWF file?

SWC file is a library file and SWF file is a runnable file. We will copy to Flex Projects libs folder.

SWC is what you use when you're looking for a library to compile into your app. You have access to the classes and can import individual parts. SWF is more likely what you're looking for when embedding graphics.

46. Difference between Label and Text?

Label: If you explicitly size a label control so that it is not large enough to accommodate it's text the text is truncated and terminated by an ellipsis(...)

Text: Here the text is displayed in new lines.

47. What is Shared Object? (OR) How to store the data in local?

Shared objects function like browser cookies. The SharedObject class to store data on the user's local hard disk and call that data during the same session or in a later session. Applications can access only their own SharedObject data and only if they are running on the same domain. The data is not sent to the server and is not accessible by other Adobe® Flex® applications running on other domains, but can be made accessible by applications from the same domain.

Public var so : SharedObject = SharedObject.getLocal("mySO");

so.data.fName = "Ram Kishoore";

48. What is over loading? Is method over loading possible in Flex?

No. Method overloading is not supported in Action Script3.0.

49. What is method overriding?

override a method of a base class in your ActionScript component. To override the method, you add a method with the same signature to your class, and prefix it with the override keyword

50. What is composition?

Making use of the already created class functionality or behaviour by instantiating the class and calling the required methods.

51. Difference between String and String Buffer?

String is immutable and String Buffer is mutable. String class creates new instance for any method but String Buffer updates/modifies same instance.

52. What is serialization?

Object can be represented as sequence of bytes that includes the object's data as well as information.

Transfer of data from client to the server like sending the Java objects from Java to Flex.

53. What are the differences between 4.6/4.5/4.0 and Flex 3.0?

4.5 and 4.6 are used for developing mobile based applications. 4.6 has few new components.

4.0: 1) Spark components have been introduced. Component logic and appearance has been separated. Appearance of the components is specified in skins.

2) FXG

3) FTE (Flash Text Engine)

4) States changed

5) Effects changed

54. Difference between Flash and Flex?

Flash is used by the designers. Flex is used by the developers. Flash uses only Flash Player API but Flex uses both Flash Player API and Flex SDK library also. like datavisualization.swc, automation.swc, rpc.swc.

In flash no coding only designing.

In flex you can create big projects.

55. Difference between Sealed Class and Dynamic class?

Sealed Class:

1. A sealed class possesses only fixed set of properties and methods that were defined at compile time. Additional properties and methods cannot be added at runtime.

2. This enables strict compile time checking.

3. It also improves memory usage. Because it doesn’t require an internal hash table for each object instance.

4. All classes in Action Script 3.0 are sealed classes by default.

Dynamic Class:

1. A dynamic class defines an object that can be altered at run time by adding or changing the properties and methods.

2. It doesn’t enable strict compile time checking.

3. It consumes more memory because it requires an internal hash table for each object instance.

4. You can create dynamic classes by using the dynamic attribute when you declare a new class.

56. Difference between Data Grid and Advanced Data Grid?

(1) Advance Data Grid allows sort by multiple column when you click in the column header. DataGrid allows only single column sort.

(2) Styling rows and columns: Use the style function property to specify a function to apply styles to rows and columns of the controls.

(3) Display Hierarchical and Grouped Data: Use an expandable navigation tree in a column to control the visible rows of the control.

(4) Creating Column Groups: Collect multiple columns under a single column heading.

(5) Using Item Renderers: Span multiple columns with an item renderer and use multiple item renderers in the same column.

57. Explain about Modules?

Modules are classes just like application files. You can create them either in ActionScript or by extending a Flex class by using MXML tags. You can create modules in MXML and in ActionScript. Modules are dynamically loadable SWF that contains an IFlexModuleFactory class factory. They can be loaded if application requires loading these module and they can be unloaded when application no longer needs a module. These modules cannot be run independently of an application.

An MXML-based module file's root tag is <mx:Module>.

Creating MXML-based modules

To create a module in MXML, you extend the mx.modules.Module class by creating a file whose root tag is <mx:Module>. In that tag, ensure that you add any namespaces that are used in that module. You must also include an XML type declaration tag at the beginning of the file:

<?xml version="1.0"?>

After you create a module, you compile it as if it were an application. After you compile a module, you can load it into an application or another module. Typically, you use one of the following techniques to load MXML-based modules:

• ModuleLoader -- The ModuleLoader class provides the highest-level API for handling modules. For more information, see Using the ModuleLoader class to load modules.

• ModuleManager -- The ModuleManager class provides a lower-level API for handling modules than the ModuleLoader class does. For more information, see Using the ModuleManager class to load modules.

Ex:

Public var mo:ModuleLoader =new ModuleLoader();

Mo.loadModule(“my.swf”);

Mo.unloadModule();

Creating ActionScript-based modules

To create a module in ActionScript, you can create a file that extends either the mx.modules.Module class or the mx.modules.ModuleBase class.

Extending the Module class is the same as using the <mx:Module> tag in an MXML file. You should extend this class if your module interacts with the framework; this typically means that it adds objects to the display list or otherwise interacts with visible objects.

To see an example of an ActionScript class that extends the Module class, create an MXML file with the root tag of <mx:Module>. When you compile this file, set the value of the keep-generated-actionscript compiler property to true. The Flex compiler stores the generated ActionScript class in a directory called generated. You will notice that this generated class contains code that you probably will not understand. As a result, you should not write ActionScript-based modules that extend the Module class; instead, you should use MXML to write such modules.

If your module does not include any framework code, you can create a class that extends ModuleBase. If you use the ModuleBase class, your module will typically be smaller than if you use a module based on the Module class because it does not have any framework class dependencies.

The following example creates a simple module that does not contain any framework code and therefore extends the ModuleBase class:

// modules/asmodules/SimpleModule.as

package {

import mx.modules.ModuleBase;

public class SimpleModule extends ModuleBase {

public function SimpleModule() {

trace("SimpleModule created");

}

public function computeAnswer(a:Number, b:Number):Number {

return a + b;

}

To call the computeAnswer() method on the ActionScript module

58. What is RSL (Runtime Shared Library)?

If you have multiple applications but those applications share a core set of components or classes, clients can download those assets only once as an RSL rather than once for each application. The RSLs are persisted on the client disk so that they do not need to be transferred across the network a second time. The resulting file size for the applications can be reduced. The benefits increase as the number of applications that use the RSL increases.

Flex applications support the following types of RSLs:

1 Standard RSLs -- A library of custom classes created by you to use across applications that are in the same domain. Standard RSLs are stored in the browser's cache.

2 Cross-domain RSLs -- A library of custom classes, like standard RSLs, with the difference being that they can be loaded by applications in different domains and sub-domains. Cross-domain RSLs are stored in the browser's cache.

3 Framework RSLs -- Precompiled libraries of Flex components and framework classes that all applications can share. Framework RSLs are precompiled for you.

59. How to call Java Script from Action Script and Action Script from Java Script? (OR) How do you call Java Script from flex and flex from Java Script?

From Action Script you can directly call any JavaScript function on the HTML page, passing any number of arguments of any data type, and receive a return value from the call. Similarly, from JavaScript on the HTML page you can call an Action Script function in Flash Player and get a return value.

Calling Java script methods from Action script:

Syntax: ExternalInterface.call( methodName:String, [parameter1:Object])

The parameters have the following meanings:

MethodName: The name of a JavaScript function to call

parameter1: Any parameters to be passed to the function; you can specify zero or more parameters, separating them by commas

Accessing Flex from Java script:

You can call Flex methods from your enclosing wrapper by using the ExternalInterface API. You do this by adding a public method in your Flex application to a list of callable methods. In your Flex application, you add a local Flex function to the list by using the addCallback() method of the ExternalInterface API. This method registers an Action Script method as callable from the JavaScript or VBScript in the wrapper.

Syntax: addCallback(function_name:String, closure:Function):void

The function_name parameter is the name by which you call the Flex function from your HTML page's scripts. The closure parameter is the local name of the function that you want to call. This parameter can be a method on the application or an object instance.

60. What is the use of Arraycollection filter function?

filterFunction: Function [read-write]

A function that the view will use to eliminate items that do not match the function criteria. A filter function is expected to

function (item: Object): Boolean

When the return value is true if the specified item should remain in the view. If a filter is unsupported, flex throws as error when accessing this property. We must call refresh () method after setting the filter function property for the view to update.

61. What is CallLater () method?

The callLater () method queues an operation to be performed for the next screen refresh, rather than in the current update. Without the callLater () method, you might try to access a property of a component that is not yet available.

Syn: callLater(method:Function, args:Array):void

Ex: We have a button click event that loads data from a XML file or a webservice. That loading of data would probably have another resultHandler which will wait for the loading to finish. And meanwhile your button click handler might be doing some other things …so in these situations we can use callLater.

62. Advantages of Adobe Flex?

(1) Complete browser portability: any browser that supports flash player and that includes almost every browser.

(2) Strong backend connectivity: from its inception, flex has featured excellent support for popular backend technologies such as the java and dot Net.

(3) Streaming: flex offers excellent support for streaming binary data. Heavy allocations that needs to transfer large amount of data to the end user.

(4) Asynchronous: Asynchronous request/response model. Flex offers complete support for asynchronous processing of user requests.

(5) SVGs (Scalable Vector Graphics): flex stands out from most other RIA-based technologies because it supports vector-based drawing and direct embedding of SVG mark-up files. SVG based images look equally good at any resolution a given browser supports.

(6) Security and Rich User Interfaces: Robust security flex leverages the highly tested flash player security.

RUI, flex benefits from halo skins, gradient fills, vector graphics and other flash player features

63. Difference between view stack and view states?

States

1. This is used to change view of a single container itself.

2. This should be used when you just want to add or remove a few components based on certain conditions.

3. Login/Registration/Forgot password is the best example for using the states as each page will either add or remove to the already existing one.

View Stack

1. This is used to switch between different containers for a single view.

2. This is used where there is a complete change in the controls used.

3.TabNavigator, TabBar, LinkBar etc are the best examples.

<mx:states>

<mx:State name="Register">

<mx:SetProperty name="text" target="{l1}" value="Return to Login" />

<mx:SetProperty name="title" target="{p1}" value="Register" />

<mx:SetProperty name="label" target="{b1}" value="Register" />

<mx:AddChild relativeTo="{fo1}" position="lastChild">

<mx:FormItem label="Confirm">

<mx:TextInput/>

</mx:FormItem>

</mx:AddChild>

<mx:SetEventHandler target="{l1}" name="click" handler="currentState=''"/>

</mx:State>

64. What are the differences between Flex 3.0 and Flex 4.0?

Flex 3 used the Eclipse framework but had some integration issues. These are cleared up in FB4.

FB4 introduces the Spark framework for enhancing the user inteface, and even comes with some nice templates and many more online...build your application first, then skin it with free pre-made skins, or some very professional ones at a reasonable price.

You no longer need flexbuilder as flashbuilder can be used to create projects using either the flex 3 sdk (flashplayer 9) or the flex 4 sdk (flashplayer 10).

Another Ans:

	Flex 3	Flex 4 Flash Builder 4
SDK Code Name	Moxie	Gumbo
Compiler	Poor performance than Flex4 compiler	Iimproved compiler performance upto 25% more.
Packages available	com flash mx adobe	com flash mx spark flashX
Flash Player	Some features of flash player 10 are not supported.i.e Graphical	Supports all features of flash player 10
States	Complexto use states syntax diffcult to use	States are now easier to use with simplified syntax
Namespace URI	http://www.adobe.com/2006/mxml	http://ns.adobe.com/mxml/2009 Library http://ns.adobe.com/flex/spark http://ns.adobe.com/flex/halo
Components	Halo Components	Supports both Halo and Spark Components
Components Skinning Enhancements	Design and behaviour of component is included inside and integrated.	Design and behaviour is clearily separated to create a smooth workflow among designing and development.
Text engine	NA	New text engine supports Bidirectional text, vertical text and over 30 writing systems including Arabic, Hebrew, Chinese, Japanese, Korean etc. Standard keyboard and mouse gestures for editing. New text classes (RichText, SimpleText, etc)
FXG Support	NA	FXG is a declarative graphics format, it enables portability of assets between tools. Assets created in Catalyst or CS4 Illustrator can be used without modifying.
Layout Model	NA	Layout containers like HBox and Vbox are not required. Instead Group class can be used to accomplish the purpose.
Adobe Catalyst	Adobe Catalyst not supported	Support and integration with Adobe Catalyst which is Adobe's new designer tool for creating rich Internet application assets without need of writing code.

Flex Interview Questions with Answer for Experienced Page 2

noreply@blogger.com (MP) — Wed, 11 Dec 2013 02:45:00 -0800

Flex Interview Questions with Answer Page 2

21. What is adapter in Blaze DS?

Java Adapter is used to communicate with Java and JMS adapter is used to communicate with JMS. Java adapter class allows us to invoke methods on a Java object.

22. Explain about different types of channels available in Blaze DS?

HTTP Channel, AMF Channel, RTMP Channel.

AMF Channel: A simple channel endpoint that transport data over HTTP in the binary AMF format in an asynchronous call and response model.

HTTP Channel: Provides the sample behaviour the AMF Channel/endpoint, but transport data in AMFX format, which is the text based representation of AMF.

RTMP Channel: The RTMP Channel creates a single duplex socket connection to the server and gives the server the best notification of the player being shut down.

23. Explain about Remote Object? What is end point in Remote Object?

Remote Object: Remote Service automatically serializes and deserializes the data between Flex client and your server side language. As a result, you can directly call methods on your Java/.Net/ColdFusion/PHP etc… objects. This service connects to an AMF (Action Message Format) Gateway. AMF protocol transfers data in a binary format, so the data can be moved across the network more quickly.

endpoint: This property is used to identify the Java web project from your flex client project.

Ex: http://localhost:8080/JavaTest/messagebroker/amf

• http: this is a protocol used to communicate with webserver from client. http means “Hyper Text Transfer Protocol”

• localhost: Host name of the machine where you have deployed your Java web project.

• 8080: Port number of the web server where you have deployed your Java project.

• JavaTest: Context root of the web application to identify the web project uniquely.

• Messagebroker/amf: this is the URL pattern of the servlet which we have defined in web.xml file.

• <<protocol>>://<<hostname>>:<<port no>>/<<context root>>/<<URL Pattern>>

24. Explain about ResultEvent and FaultEvent in Remote Object? (OR) Explain about result handler and fault handler methods?

result: This is the event listener for the event ResultEvent. This event is automatically dispatched by the Flash Player when it receives the successful results from the backend Java service.

fault: This is the event listener for the event FaultEvent. This event is automatically dispatched by the Flash Player when it receives any error in calling the Java method.

25. Explain about Flex Data Services like HTTP Service, Web service and Remote Object?

26. Difference between HTTP Service and Remote Object? (OR) Which one you will prefer?

Data Service(Remote Object)

1. Remote Objects specifies named or unnamed sources.

2. This service connects to an AMF(Action Message Format) Gateway

3. AMF protocol transfers data in a binary format, so the data can be moved across the network more quickly.

4. Remote Service automatically serializes and deserializes the data between Flex client and your server side language. As a result, you can directly call methods on your Java/.Net/ColdFusion/PHP etc… objects

HTTP Service/Web Service

1. These services use named or raw URLs

2. These services connect to an HTTP Proxy Gateway.

HTTP Service use HTTP protocol/requests

Web Services use SOAP (Simple Object Access Protocol).

3. These services transfer data in XML format. This is slow.

4. Here the data transfer is in XML only.

27. Explain about component life cycle?

A set of methods the framework calls to instantiate, control and destroy components. OR

The component instantiation life cycle describes the sequence of steps that occur when you create a component object from a component class. As part of the life cycle, Flex automatically calls component methods, dispatches events, and makes the component visible.

3 Main Phases:

BIRTH

Construction, configuration, attachment, initialization

LIFE

Invalidation, validation, interaction

DEATH

Detachment, garbage collection

override protected function createChildren():void{

myLab=new Label();

myLab.text="my label";

myLab.setStyle('color',"green");

this.addChild(myLab);

}

override protected function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void {

myLab.move(0,0);

myLab.setActualSize(100,100);

}

28. Explain about Application life cycle?

29. Explain about the custom components method? What are the methods we have to override when we are creating a custom component?

(OR)

Explain about the validation and invalidation methods?

30. Explain about measure() method? When this measure() method is called?

The measure() method sets the default component size, in pixels, and optionally sets the component's default minimum size.

This method is used for following reasons.

1) To set the components measuredWidth, measuredHeight, measuredMinWidth and measuredMinHeight.

2) To set the default width and height values to this component.

3) To measure the child components widths and Heights. So that we can specify how much width and height is required for our component.

4) Measure method is called only when you are not specifying both width and height externally at the time of calling this component.

5) This method can be called multiple times by calling the invalidateSize() method.

31. Difference between Item Renderer and Item Editors?

Both are used for editing,but item renderer is used for displaying visual elements..

item editor is used for editing purpose. Item editor can pass data back from the particular control to save it as a new value for item being edited. We can also use item renderer as editor by using boolean property renderIsEditor.

itemrenderer is used to format and display the contents in a components whereas itemeditor allows us to edit the displayed content

32. How to display the Check Box in Data Grid header?

<mx:DataGridColumn headerText="ADD" dataField="add" itemRenderer="mx.controls.Button"/>

</itemRenderer>

36. Can we use Text Input/Editable component as Item Renderer?

Yes,

37. What are all the events dispatched in Item Editor?

Item Edit Beginning, Item Edit Begin, Item Edit End

38. What are the collections classes available in Flex?

Array Collection, XML List Collection, Grouping Collection.

39. Difference between Array and Array Collection?

1) Array Collection is a wrapper class based on Array.

2) Array Collection contains sorting, filtering features but Array not.

3) Array Collection dispatches the Event when new item is added, updated or deleted.

4) Array Collection automatically refreshes/updates the view whenever the change happens in Array Collection.

40. How to get/retrieve an item from Array?

Flex Interview Questions with Answer for Experienced Page 1

noreply@blogger.com (MP) — Wed, 11 Dec 2013 02:38:00 -0800

Flex Interview Questions with Answer Part 1.

1. Please explain about yourself?

2. Tell about your current project and roles and responsibilities?

3. Explain Data Binding in Flex?

Data binding is the process by which changes in one action script object are reflected in another action script object. (OR) Data binding automatically copies the value of a property of a source object to a property of a destination object when the source property changes.

Data binding requires a source property, a destination property, and a triggering event that indicates when to copy the data from the source to the destination. An object dispatches the triggering event when the source property changes

Adobe Flex provides 3 ways to specify Data binding:

1) Curly braces ({ }) syntax in mxml and [Bindable] metadata tag

2) <mx: Binding> tag in MXML

3) BindingUtils.bindProperty/bindSetter methods in Action Script at runtime.

4. Explain Event Life Cycle/Event Phases/Event flow?

Flex is an event driven programming model. Events let a developer know when something happen within in a flex application. They can be generated by user devices such as the mouse and keyboard or other external inputs such as the return of a webservice call. Events are also triggered when changes happen in the lifecycle of a component such as the creation or destruction of a component.

The event flow is conceptually divided into 3 parts.

(1) Capturing Phase (2) Targeting Phase (3) Bubbling Phase

Application

HDividedBox

ViewStack

Panel id="medical"

Button label="Submit"

Panel id="dental"

Button label="Submit"

In the above example there are two Submit Buttons — one in the medical Panel and the other in the dental Panel. You can imagine an application that has many forms and many Submit Buttons.

When the user clicks the Submit Button in the medical Panel, a click event (data type MouseEvent.CLICK) begins its journey within the event framework.

(1) Capturing Phase:

The first part of the event flow is called the capturing phase. This phase comprises all of the nodes from the root node to the parent of the target node. During this phase, Flash Player examines each node, starting with the root and stops after it reaches the target node's parent.

The capture phase works from the outermost component downward toward the Button. This means the click event is first given to the Application to handle. If the click event is not consumed by the Application, it is given to the HDividedBox. It is then given to the ViewStack and then to the medical Panel

(2) Targeting phase:

The second part of the event flow, the targeting phase, consists solely of the target node. Flash Player sets the appropriate values on the Event object, checks the target node for registered event listeners, and then calls those listeners

(3) Bubbling phase:

The third part of the event flow, the bubbling phase, comprises all of the nodes from the target node's parent to the root node. .Starting with the target node's parent, Flash Player sets the appropriate values on the Event object and then calls event listeners on each of these nodes. Flash Player stops after calling any listeners on the root node.

5. What is stopPropagation() and stopImmediatePropagation()? (OR) Difference between stopPropagation and stopImmediatePropagation()? (OR)

How to stop the event flow/ event phases?

stopPropagation: Prevents processing of any event listeners in nodes subsequent to the current node in the event flow. This method does not affect any event listeners in the current node (current target).

stopImmediatePropagation: Prevents processing of any event listeners in the current node and any subsequent nodes in the event flow. This method takes effect immediately and it affects event listeners in the current node.

6. What is clone() method?

Clone method creates duplicate copy of the event class. This method is executed automatically when the event is redispatched in the event listeners.

7. What is preventDefault () method?

To cancel the default behaviour of the event. The methods of the Event class can be used in event listener functions to affect the behaviour of the event object. Some events have an associated default behaviour. For example, the doubleClick event has an associated default behaviour that highlights the word under the mouse pointer at the time of the event. Your event listener can cancel this behaviour by calling the preventDefault () method.

PreventDefault () method will work only if Cancellable property is true, otherwise it’s not working.

8. What is the difference between Target and Current Target?

Target: The object that dispatched the event (doesn’t change). Target will not change.

Current Target: The object who is currently being checked for specific event listeners (changes). Current target is keep on change.

9. How to create Custom Events? Explain the steps to create a new custom event?

To dispatch a new event from your custom component, you must do the following:

1.(Optional) Create a subclassfrom the flash.events.Eventclass to create an event class that describes the event object.

2.(Optional) Use the [Event]metadata tag to make the event public so that the MXML compiler recognizes it.

3.Dispatch the event using the dispatchEvent() method.

10. How to enable capturing or Targeting and Bubbling Phases?

11. How to execute only Targeting phase listeners?

12. Tell me arguments of addEventListener() method?

addEventListener (type: string, listener: function, useCapture: Boolean=false, priority:int=0, useWeakReference:Boolean=false):void

type: Type of Event(MouseClick, MouseOver)

listener: It’s a function

useCapture(dfault:false): If True: Enable only Capturing Phase

Flase: Enable Targetting and Bubbling Phase.

Priority(int=0): The priority level of the listener. The higher the number the higher the priority.

useWeakReference(default =false): whether the reference to the listener is strong or weak. A strong reference (default) preventing your listener from being garbage-collected, a weak reference does not.

13. Explain about cairngorm architecture

Cairngorm is an implementation of several design patterns that form a lightweight architectural framework. Cairngorm follows the principle of separating the view and business logic which is known as the Model-View-Controller pattern (MVC).

The Pieces of Cairngorm:

Model Locator, View, Front Controller, Command, Delegate and Service

Model Locator: Stores all of your application’s Value Objects (data) and shared variables, in one place. Similar to an HTTP Session object, except that its stored client side in the Flex interface instead of server side within a middle tier application server.

View: One or more Flex components (button, panel, combo box, Tile, etc) bundled together as a named unit, bound to data in the Model Locator, and generating custom Cairngorm Events based on user interaction (clicks, rollovers, drag n drop.)

Front Controller: Receives Cairngorm Events and maps them to Cairngorm Commands.

Command: Handles business logic, calls Cairngorm Delegates and/or other Commands, and updates the Value Objects and variables stored in the Model Locator

Delegate: Created by a Command, they instantiate remote procedure calls (HTTP, Web Services, etc) and hand the results back to that Command.

Service: Defines the remote procedure calls (HTTP, Web Services, etc) to connect to remote data stores.

14. Advantages and disadvantages of Cairngorm Framework?

Advantages:

(1) Multiple handlers for a single event.

DisAdvantages:

• The ModelLocator can get huge and unwieldy; depending on how large your application is and how much data it keeps. To resolve this, I have seen using more than one ModelLocator to separate, say, the business data from the presentation data. But it still won’t be fun to handle merge conflicts with everyone updating it, if you’re in a large team.

• Extending the CairngormEvent for each event to encapsulate the event name ID and data was not too pleasant. I would imagine it’s easy to end up with duplicate event IDs in a large application (which is why a naming convention would be vital). I suppose you can create a generic Cairngorm event, but the data parameters wouldn’t be type-checked.

• Lastly, I wasn’t in favor of referencing the ModelLocator in all of my Flex components. I favored passing a data reference from a parent component to keep my view components as reusable and un-Cairngorm-ish as possible.

15. Difference between Cairngorm Event and Flex Event?

Cairngorm Event is not a bubbled event and it can be understand by only flex commands.

Flex events can be dispatched by every component in Flex.

16. How to add two commands to one single event type?

Sequence Command is used to add multiple commands to one event type.

17. Should Model Locator as a singleton class? can't we instantiate this class as like normal class?

You can call as a normal class because constructor is public.

18. What is Singleton class? Explain the steps to create a Singleton class?

The singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. If we create the class as a singleton then no way to create more than one instance. But, we can get that single instance in any number of classes. So all the classes will share the same properties and behaviours of that singleton object.

Steps to create a Singleton class:

Consider the MySingleTon class as a singleton class.

package {

public class MySingleTon {

// Single Instance of Our MySingleTon

private static var instance:MySingleTon;

//DEFINE YOUR VARIABLES HERE

public function MySingleTon (enforcer:SingletonEnforcer)

{

if (enforcer == null)

{

throw new Error( "You Can Only Have One MySingleTon");

}

// Returns the Single Instance

public static function getInstance() : MySingleTon

{

if (instance == null)

{

instance = new MySingleTon ( new SingletonEnforcer );

}

return instance;

}

// Utility Class to Deny Access to Constructor

class SingletonEnforcer {}

1). We should create one static variable. It will be called "instance" and it will be of type MySingleTon. This will be the variable where we will store our one instance of our class.

2). Then we should create one constructor. The constructor takes one argument - "enforcer". You will notice that this "enforcer" has a type of "SingletonEnforcer" which is defined directly after our class. Here is the logic behind that:

• When you put a class in an ActionScript file below the main class, it is only available to that class.

• If the constructor requires this argument – then only our main class can create an instance of itself, because we do not have access to the “SingletonEnforcer” class. Only the main class has this access.

• We will not access our class in the normal way by using the “new” statement because we can’t call the constructor. Once we get inside of the constructor, we have a few lines that make sure things work as planned. The “if” statement ensures that we had a valid “enforcer” passed in. If there wasn’t it throws an Error stating that “You Can Have Only One MySingleTon”.

19. Explain about Blaze Ds and Blaze DS services?

BlazeDS provides a set of services that lets you connect a client-side application to server-side data, and pass data among multiple clients connected to the server. BlazeDS implements real-time messaging between clients.

Blaze DS services:

(1) HTTP Service

(2) Webservice

(3) Remote Object

HTTP Service: HTTP Service components to interact with JSP’s, Servlets and ASP Pages that are not available as Webservice or remoting services destinations.

<mx:HTTPService id=”myService” url=”http://localhost:8400/middlejava/LoginServlet” result=”resultHandler(event)” fault=faultHandler(event)” method=”Get”/>

Webservice: Webservice components let you access webservices, which are software modules with methods. Webservices methods are commonly referred to as operations. Webservice interfaces are defined by using XML.

Flex application can interact with webservices that define their interfaces in a Webservices Description Language (WSDL) document, which is available as a URL. WSDL is a standard format for describing the messages that a webservice understands the format of these responses to those messages.

<mx: WebService id=”Webservice” wsdl=”http://search.yahoo.com/searchservice?wsdl” result=”resultHandler (event)” fault=faultHandler (event)” method=”Get”/>

Remote Object: Remote object components let us access the methods of server side java objects, without manually configuring the objects as webservices. We can use remote object components in MXML or ActionScript.

We can use RemoteObject components with a standard alone BLAZE DS web application or macromedia ColdFusion MX from Adobe.

20. Explain the configuration details of Blaze DS?

(1) Add BlazeDS JAR files and dependent JAR files to the WEB-INF/lib directory from BlazeDS project.

(2) Add BlazeDS configuration files in the WEB-INF/flex directory from BlazeDS project.

(3) Define Message Broker Servlet and a session listener in WEB-INF/web.xml from BlazeDS project

The Blaze DS uses four main configuration files namely:

1.Services-config.xml: The top level Blaze Ds configuration file, this file usually contains security constraints, channel definitions and logging settings that each of the services can use.

2.Remoting-config.xml: The remoting service configuration file, which defines remoting service destinations for working with remote objects.

3.Proxy-config.xml : The proxy service configuration file which defines proxy service destinations for working with webservices and HTTP Service (REST Services)

4.Messaging-config.xml: The messaging service configuration file, which defines messaging service destinations for performing publish subscribe messaging.

Adobe Flex Setup in Eclipse or Use Adobe Flash Builder

noreply@blogger.com (MP) — Thu, 7 Nov 2013 04:32:00 -0800

Adobe Flex Setup with Eclipse plugin or Use Adobe Flash Builder or Adobe Flex Builder

1. To develop Flex application use Adobe Flash Builder download it from Adobe site

2. Use eclipse and install Adobe Flex Plugin in Eclipse .

First Project.
In Flex Builder

File -> New -> Flex Project -> Enter Project Name and click Finish.

It create Welcome.mxml in src folder. Like in the following diagram.

Internal Concepts of Adobe Flex

noreply@blogger.com (MP) — Thu, 7 Nov 2013 03:32:00 -0800

Internal Concepts of Adobe Flex

Every time i am discuss Flex with comparing Java. In next tutorial we combined both Flex (User Interface) and Java( Server side).

Already told by using Flex we can develop Web, Mobile, Desktop applications. We can also develop this type of applications by using Java.

The following are the different type of Flex Projects

AS - Action Script

SWF - Shockwave Flash

In the above diagram shows that Flex having three type of Projects.
1. Flex Projects
2. Action Script Project
3. Flex Project

This three projects takes input as MXML or Action Script (AS) or both. And generate SWF + HTML or SWF.

Here .swf files directly run any Browser compatible with Adobe Flash Player . In HTML some tags are browser specific . So output is change browser to browser (Look an Fields). To verify those tags go W3Schools website there mention some tags and supported Web Browsers.

About Adobe Flex and Its importance

noreply@blogger.com (MP) — Thu, 7 Nov 2013 02:48:00 -0800

What About Adobe Flex and Its importance.

Adobe Flex is a freeware and open-source framework for building applications runs on different platforms like mobile, web applications, and desktop.

By using Adobe Flex we can develop rich UI Application . And also we use these UI Components as front-end any web framework like Java, .Net and any other. It is alternative to JSP, ASPX. so we can replace JSP, ASPX with MXML(Macromedia eXtensible Markup Language) applications . It shows in the following diagram.

Web Applications with Java and .Net

Web Applications with MXML in Java and .Net

BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext

noreply@blogger.com (Unknown) — Thu, 6 Jun 2013 05:42:00 -0700

To solve the above problem please verify applicationContext.xml . Its having problem with some configuration verify one more time.

BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext

Exception:
SEVERE: Exception sending context destroyed event to listener instance of class org.springframework.web.context.ContextLoaderListener
java.lang.IllegalStateException: BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext
at org.springframework.context.support.AbstractRefreshableApplicationContext.getBeanFactory(AbstractRefreshableApplicationContext.java:172)
at org.springframework.context.support.AbstractApplicationContext.destroyBeans(AbstractApplicationContext.java:1090)
at org.springframework.context.support.AbstractApplicationContext.doClose(AbstractApplicationContext.java:1064)
at org.springframework.context.support.AbstractApplicationContext.close(AbstractApplicationContext.java:1010)
at org.springframework.web.context.ContextLoader.closeWebApplicationContext(ContextLoader.java:549)
at org.springframework.web.context.ContextLoaderListener.contextDestroyed(ContextLoaderListener.java:143)
at org.apache.catalina.core.StandardContext.listenerStop(StandardContext.java:4831)
at org.apache.catalina.core.StandardContext.stopInternal(StandardContext.java:5478)
at org.apache.catalina.util.LifecycleBase.stop(LifecycleBase.java:232)
at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:160)
at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1559)
at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1549)
at java.util.concurrent.FutureTask$Sync.innerRun(Unknown Source)
at java.util.concurrent.FutureTask.run(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)

Simple Spring MVC Annotation Example Step by Step.

noreply@blogger.com (Unknown) — Sun, 5 May 2013 05:09:00 -0700

Simple Spring MVC Annotation Example explain Step by Step Procedure.

Tools and Technologies used in this Example.

1. Eclipse
2. Java 7
3. Spring 3.2

Steps:
1.Create Dynamic Web Project by using Eclipse and all jar to lib folder.
Jar files List.
spring-web-3.2.0.RELEASE.jar
spring-webmvc-3.2.0.RELEASE.jar
spring-beans-3.2.0.RELEASE.jar
spring-context-3.2.0.RELEASE.jar
spring-core-3.2.0.RELEASE.jar
spring-expression-3.2.0.RELEASE.jar and
commons-logging-1.1.1.jar

Project Explorer is

2. Configure web.xml file in the following.

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">

<display-name>Spring MVC</display-name>
<listener>
<display-name>contextLoaderListener</display-name>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
</web-app>

3. Create Controller By using Annotations

MyController.java

package com.javafws.blog;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping(value="/main")
public class MyController {

@RequestMapping(value="/hello")
public String hello(){

System.out.println("We are in hello()");
return "display";
}

@RequestMapping(value = "/welcome")
public String sayWelcome(Model model){

// To send message to JSP view from Controller
model.addAttribute("msg","Welcome To Spring MVC with Annotation Example");
return "welcome";
}
}

4. Create Spring Configuration files

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

</beans>

spring-servlet.xml

<beans xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<context:annotation-config/>


<context:component-scan base-package="com.javafws.blog"/>


<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/" />
<property name="suffix" value=".jsp" />
</bean>

</beans>

5. Create folder pages and place all jsp files in this folder.

hello.jsp

Hello

welcome.jsp

<html>
<body>

<h2>Hello : ${msg}</h2>

</body>
</html>

Finally URLs :
1. http://localhost:8090/webmvc/main/hello.html
2. http://localhost:8090/webmvc/main/welcome.html

BeanDefinitionStoreException: IOException parsing XML document from ServletContext resource

noreply@blogger.com (Unknown) — Fri, 3 May 2013 06:11:00 -0700

org.springframework.beans.factory.BeanDefinitionStoreException: IOException parsing XML document from ServletContext resource [/WEB-INF/spring-servlet.xml]; nested exception is java.io.FileNotFoundException: Could not open ServletContext resource [/WEB-INF/spring-servlet.xml]

Solution:
Spring is excepting to supply spring-servlet.xml file in [/WEB-INF/spring-servlet.xml] . Why because we create servlet in web.xml with the name "spring"

web.xml

<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>

spring-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

</beans>

SEVERE: Context initialization failed
org.springframework.beans.factory.BeanDefinitionStoreException: IOException parsing XML document from ServletContext resource [/WEB-INF/spring-servlet.xml]; nested exception is java.io.FileNotFoundException: Could not open ServletContext resource [/WEB-INF/spring-servlet.xml]
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:341)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:302)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:174)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:209)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:180)
at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:125)
at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:94)
at org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory(AbstractRefreshableApplicationContext.java:131)
at org.springframework.context.support.AbstractApplicationContext.obtainFreshBeanFactory(AbstractApplicationContext.java:537)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:451)
at org.springframework.web.servlet.FrameworkServlet.configureAndRefreshWebApplicationContext(FrameworkServlet.java:647)
at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:598)
at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:661)
at org.springframework.web.servlet.FrameworkServlet.initWebApplicationContext(FrameworkServlet.java:517)
at org.springframework.web.servlet.FrameworkServlet.initServletBean(FrameworkServlet.java:458)
at org.springframework.web.servlet.HttpServletBean.init(HttpServletBean.java:138)
at javax.servlet.GenericServlet.init(GenericServlet.java:160)
at org.apache.catalina.core.StandardWrapper.initServlet(StandardWrapper.java:1266)
at org.apache.catalina.core.StandardWrapper.loadServlet(StandardWrapper.java:1185)
at org.apache.catalina.core.StandardWrapper.allocate(StandardWrapper.java:857)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:136)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:472)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:168)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99)
at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:929)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:407)
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1002)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:585)
at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:310)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)
Caused by: java.io.FileNotFoundException: Could not open ServletContext resource [/WEB-INF/spring-servlet.xml]
at org.springframework.web.context.support.ServletContextResource.getInputStream(ServletContextResource.java:140)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:328)
... 33 more

May 03, 2013 6:31:01 PM org.apache.catalina.core.ApplicationContext log
SEVERE: StandardWrapper.Throwable
org.springframework.beans.factory.BeanDefinitionStoreException: IOException parsing XML document from ServletContext resource [/WEB-INF/spring-servlet.xml]; nested exception is java.io.FileNotFoundException: Could not open ServletContext resource [/WEB-INF/spring-servlet.xml]
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:341)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:302)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:174)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:209)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:180)
at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:125)
at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:94)
at org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory(AbstractRefreshableApplicationContext.java:131)
at org.springframework.context.support.AbstractApplicationContext.obtainFreshBeanFactory(AbstractApplicationContext.java:537)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:451)
at org.springframework.web.servlet.FrameworkServlet.configureAndRefreshWebApplicationContext(FrameworkServlet.java:647)
at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:598)
at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:661)
at org.springframework.web.servlet.FrameworkServlet.initWebApplicationContext(FrameworkServlet.java:517)
at org.springframework.web.servlet.FrameworkServlet.initServletBean(FrameworkServlet.java:458)
at org.springframework.web.servlet.HttpServletBean.init(HttpServletBean.java:138)
at javax.servlet.GenericServlet.init(GenericServlet.java:160)
at org.apache.catalina.core.StandardWrapper.initServlet(StandardWrapper.java:1266)
at org.apache.catalina.core.StandardWrapper.loadServlet(StandardWrapper.java:1185)
at org.apache.catalina.core.StandardWrapper.allocate(StandardWrapper.java:857)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:136)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:472)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:168)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99)
at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:929)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:407)
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1002)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:585)
at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:310)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)
Caused by: java.io.FileNotFoundException: Could not open ServletContext resource [/WEB-INF/spring-servlet.xml]
at org.springframework.web.context.support.ServletContextResource.getInputStream(ServletContextResource.java:140)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:328)
... 33 more

May 03, 2013 6:31:01 PM org.apache.catalina.core.StandardWrapperValve invoke
SEVERE: Allocate exception for servlet spring
java.io.FileNotFoundException: Could not open ServletContext resource [/WEB-INF/spring-servlet.xml]
at org.springframework.web.context.support.ServletContextResource.getInputStream(ServletContextResource.java:140)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:328)
at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:302)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:174)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:209)
at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:180)
at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:125)
at org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(XmlWebApplicationContext.java:94)
at org.springframework.context.support.AbstractRefreshableApplicationContext.refreshBeanFactory(AbstractRefreshableApplicationContext.java:131)
at org.springframework.context.support.AbstractApplicationContext.obtainFreshBeanFactory(AbstractApplicationContext.java:537)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:451)
at org.springframework.web.servlet.FrameworkServlet.configureAndRefreshWebApplicationContext(FrameworkServlet.java:647)
at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:598)
at org.springframework.web.servlet.FrameworkServlet.createWebApplicationContext(FrameworkServlet.java:661)
at org.springframework.web.servlet.FrameworkServlet.initWebApplicationContext(FrameworkServlet.java:517)
at org.springframework.web.servlet.FrameworkServlet.initServletBean(FrameworkServlet.java:458)
at org.springframework.web.servlet.HttpServletBean.init(HttpServletBean.java:138)
at javax.servlet.GenericServlet.init(GenericServlet.java:160)
at org.apache.catalina.core.StandardWrapper.initServlet(StandardWrapper.java:1266)
at org.apache.catalina.core.StandardWrapper.loadServlet(StandardWrapper.java:1185)
at org.apache.catalina.core.StandardWrapper.allocate(StandardWrapper.java:857)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:136)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:472)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:168)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99)
at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:929)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:407)
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1002)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:585)
at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:310)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)

BatchUpdateException: ORA-02291: integrity constraint () violated - parent key not found

noreply@blogger.com (Unknown) — Thu, 2 May 2013 08:13:00 -0700

To solve this problem add cascade="all" to mapping file in the following location.

<set name="courses" table="STUDENT_COURSE" inverse="false" cascade="all" lazy="true" fetch="select">

Exception in thread "main" org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:96)
at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:275)
at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:268)
at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:188)
at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:51)
at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1216)
at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:383)
at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:133)
at com.javafws.blog.MyApp.main(MyApp.java:34)
Caused by: java.sql.BatchUpdateException: ORA-02291: integrity constraint (HIB.SYS_C004204) violated - parent key not found

at oracle.jdbc.driver.DatabaseError.throwBatchUpdateException(DatabaseError.java:343)
at oracle.jdbc.driver.OraclePreparedStatement.executeBatch(OraclePreparedStatement.java:10657)
at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:70)
at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:268)
... 8 more