Group items tagged

PMD scans Java source code and looks for potential problems

Best practices

Maven plugin usage

FindBugs, a program which uses static analysis to look for bugs in Java code

Maven http://mojo.codehaus.org/findbugs-maven-plugin/

Netbeans SQE: Software Quality Environment

Services, practices & tools that should exist in any software development house, part 2

Code quality (Practices and tools)

Continuous ... training (Practice)

Developing with Maven

artifacts are available in the Maven central repository

group org.graniteds

Debugging PHP Source Code in the NetBeans IDE

JBoss AS 7.0.2 (Full Profile)

JBoss AS 7, claiming to be lightning fast

Eclipse Integration

Auditing Entities With JPA Events

An alternative is if you are using a generic DAO class to handle entity persistence is to put the enhanced populateTimestamp method on there and call it prior to inserting or updating the entity in the DAO

EA User Guide (pdf)

Reference Booklets

Enterprise Architect Online Help

Interface RolePermissionResolver

RolePermissionResolver resolves a String value and converts it into a Collection of Permission instances

resolve the roles into permissions

If your application's authentication process is username/password based (like most), instead of implementing this interface yourself, take a look at the UsernamePasswordToken class, as it is probably sufficient for your needs.

UsernamePasswordToken

HostAuthenticationToken interface to retain the host name or IP address location from where the authentication attempt is occuring.

A simple username/password authentication token to support the most widely-used authentication mechanism

createNamedQuery(java.lang.String name)

Java Persistence query language or in native SQL

Connection

If you need to determine if the connection is still valid, issue a simple query, such as SELECT 1. The driver will throw an exception if the connection is no longer valid.

Mapping enum to database column using JPA/Hibernate You can use any of the 3 approaches discussed above. Map the enum to an integer column. The persistence implementation should automatically convert enum to ordinal() and back for you. Map the enum to a String column. The persistence implementation should automatically convert the enum value to String value via the name() function. Map the enum using a business value. You should mark the enum field as @Transient, and create another String field which you can map to a String column in your database table. Here’s an example code snippet. view plaincopy to clipboardprint?@Entity  public class Product {   @Column   private String colorValue;     @Transient   public Color getColor() {    return Color.fromValue(colorValue);   }     public void setColor(Color color) {    this.colorValue = color.toValue();   }  }  

Approach 3: Using a user defined business value – Recommended approach! This approach involves assigning a an explicit user defined value to each enum constant and defining a toValue() and fromValue() methods on the enum to do the serialization and deserialization.

public enum Color {   RED("RED"), GREEN("GREEN"), BLUE("BLUE"), UNKNOWN("UNKNOWN");     private final String value;     Color(String value) {     this.value = value;   }     public static Color fromValue(String value) {     if (value != null) {       for (Color color : values()) {         if (color.value.equals(value)) {           return color;         }       }     }       // you may return a default value     return getDefault();     // or throw an exception     // throw new IllegalArgumentException("Invalid color: " + value);   }     public String toValue() {     return value;   }     public static Color getDefault() {     return UNKNOWN;   }  }  public enum Color { RED("RED"), GREEN("GREEN"), BLUE("BLUE"), UNKNOWN("UNKNOWN"); private final String value; Color(String value) { this.value = value; } public static Color fromValue(String value) { if (value != null) { for (Color color : values()) { if (color.value.equals(value)) { return color; } } } // you may return a default value return getDefault(); // or throw an exception // throw new IllegalArgumentException("Invalid color: " + value); } public String toValue() { return value; } public static Color getDefault() { return UNKNOWN; } } This approach is better than approach 1 and approach 2 above. It neither depends on the order in which the enum constants are declared nor on the constant names.

used for: Strategy Pattern: there are already several implementations of an algorithm or concept Layering: there is a clear need to hide e.g. an ugly implementation of a legacy framework API (not very common): you have to expose a API, which gets implemented by SPI (e.g. JDBC)