Java

BareTail

• line highlighting;
• you can create batch files to open related log files together, ex:

  SET SERVER=TEST
  SET DIR=\Logs\Applications\
   
  START baretail.exe \\%SERVER%%DIR%Application1.Console.log \\%SERVER%%DIR%Application2.Console.log \\%SERVER%%DIR%Application3.log

• many more...

• Official Baretail download site
• A good Baretail overview with lots of tips and tricks

Log4J

• Logging in Tomcat: use log4j with tomcat;
• Log4j Tutorial : Adding Log4j logger to your project: nice straight to the point basic tutorial;
• Short introduction to log4j: Ceki Gülcü, March 2002
• Log4j.Properties Example: (great) lots of examples of configurations (log to a file; console; etc). Note the lo4j.properties should be placed on  your classpath (if you are using eclipse and your it is using a separate folder for the compiled classes (ex.bin), paste the log4.jproperties file there);
• Log4j.properties: Eclipse Log4j HOWTO In 10 Minutes: example of a .properties configuration file;
• Configuration
• log4j: on the wikipedia

#DEFINE A CONSOLE APPENDER:
log4j.appender.consoleAppender = org.apache.log4j.ConsoleAppender
#define the layout for the console appender:
log4j.appender.consoleAppender.layout = org.apache.log4j.PatternLayout
log4j.appender.consoleAppender.layout.ConversionPattern=[%d{HH:mm:ss.SSS}] %5p %l - %m%n

#DEFINE A FILE APPENDER (direct log messages to a log file)
log4j.appender.fileAppender=org.apache.log4j.RollingFileAppender
log4j.appender.fileAppender.File=C:\\logs\\TesteLogger.log
log4j.appender.fileAppender.MaxFileSize=1MB
log4j.appender.fileAppender.MaxBackupIndex=1
log4j.appender.fileAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.fileAppender.layout.ConversionPattern=[%d{ABSOLUTE}] %5p %c{1}:%L - %m%n

# DEFINE ROOT LOGGER OPTIONS
# the first attribute is the logging level (the level specified and above will be logged)
# the other attributes: map our console appender and file appender as a root logger (means all log messages will go to this appenders)
log4j.rootLogger = DEBUG, fileAppender, consoleAppender

# Print only messages of level WARN or above in the package novaPack
log4j.logger.novaPack=WARN

Logging Exceptions trick

try {
 Integer.parseInt("3d");
} catch (Exception ex) {
 log.error(ex); // only logs the Exception message
 log.error("Some text here", ex); // logs the full stack trace!
}

References:

• Official Axis2 site (Java version)
  Apache Axis2 is a Web Services / SOAP / WSDL engine.
  There are two implementations of the Apache Axis2 Web services engine - Apache Axis2/Java and Apache Axis2/C (we are interested on the java version here)
• Apache Axis2 Installation Guide
• Apache Axis2 - Apache Axis2 Tutorial - a nice tutorial building everything from scratch (no IDE);
• Axis2 Quick Start Guide 
• Apache Axis2 User's Guide -Building Services 
• AXIS STEP BY STEP (nice tutorial with: axis2; tomcat; eclipse; ant)
• Introducão de  web services PT muita informaçao;

Axis2 wsdl2java and java2wsdl

• Parameters info;
• Building a webservice starting from a wsdl file

7,5º obviamente... :o)

Porque:

1. Em 360º temos 12h
2. Portanto temos 360/12 = 30º/h
3. Logo a cada 1/4h temos 30/4 = 7,5º

EDIT: Fibonacci

• Recursivo;
• Iterativo;
• Memoization (fazer cache dos números já calculados para obtermos melhor performance);

NOTE: This page is a child of JPA page.

EntityManager

@Stateless
public class ProductFacade extends AbstractFacade<Product> {
    @PersistenceContext(unitName = "AffableBeanPU")
    private EntityManager em;

    protected EntityManager getEntityManager() {
        return em;
    }

    ...

    // manually created
    public List<Product> findForCategory(Category category) {
        return em.createQuery("SELECT p FROM Product p WHERE p.category = :category").
               setParameter("category", category).getResultList();
    }
}

• A transaction-scoped persistence context (default behavior): is created at the start of a transaction, and terminated when the transaction ends. 
• An extended persistence context: applies to stateful session beans only, and spans multiple transactions. 

You can use JPA in JavaSE almost the same way has you use it in JavaEE.
Some diferences are:

• In JavaSE, you don't get an EntityManager instance from the Application Server (there isn't one!) so you have to create a new instance yourself, ex:

  EntityManagerFactory emf =
      Persistence.createEntityManagerFactory("EmployeeServicePU");
  EntityManager em = emf.createEntityManager();

• In JavaSE you cant use the container managed transactions like JTA (there is no Application Server!) so you have to do it manually.
  You can use the EntityTransaction service for this, ex:

  em.getTransaction().begin();
  createEmployee(158, "John Doe", 45000);
  em.getTransaction().commit();

• In JavaSE you need to specify every Entity class in the Persistence Unit definition (in persistence.xml);
  I.e. define XML <class> elements like the "myentities.Employee" class below:

    <persistence-unit name="JPAJavaSEPU" transaction-type="RESOURCE_LOCAL">
      <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
      <class>myentities.Employee</class>
      <properties>

1. Create a normal JavaSE project;
    
2. Add the jar that contains the javax.persistence package into your project libraries.
   If you are using Glassfish you can find it on the installation folder.
   Ex.: C:\glassfish3\glassfish\modules\javax.persistence.jar
    
3. Create a normal class and turn it into an entity:
    - Annotate your class with @Entity;
    - Annotate a class field with @Id;
    - Create get/set methods to the id field to turn in into a property;
    - The class must implement Serializable;
   Ex.:

   @Entity
   public class Employee implements Serializable {
   
       @Id 
    private int id;
       private String name;
       private long salary;  
    ...
   } 
   

     
4. Create the database on your DBMS
   For example, if you are using MySQL you can use "MySQL Workbench" to create the database schema.
   In this example I've created a database with this attributes:
    - database name: "jpa_javase"
    - user/pass: "root" "1234";
    - MySQL is running on localhost and listening on port  3306 (the default port);
    
5. Create a persistence unit (PU) and add the the JPA implementation jars into your project libraries:
   If you are using Netbeans you can click on the light bulb next to the class name and it will take you through the entire configuration of the PU and the connection that it uses for the database.
   
   
   This will:
   • Generate the necessary xml definitions for the PU in your projects persistence.xml file.
     Example of the persistence.xml file:

     <?xml version="1.0" encoding="UTF-8"?>
     <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
       <persistence-unit name="JPAJavaSEPU" transaction-type="RESOURCE_LOCAL">
         <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
         <properties>
           <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa_javase"/>
           <property name="javax.persistence.jdbc.password" value="1234"/>
           <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
           <property name="javax.persistence.jdbc.user" value="root"/>
           <property name="eclipselink.ddl-generation" value="drop-and-create-tables"/>
         </properties>
       </persistence-unit>
     </persistence>

   • Add the jars of your JPA implementation (ex. Hibernate; EclipseLink, etc.) into your project libraries.
     For the EclipseLink it would import these 2 jars:
     TODO
   
   
6. Create a test method to run a JPA instruction and check if everything is ok
   Ex.:
   

   public static void main(String[] args) {
    try {
     EntityManagerFactory emf = Persistence.createEntityManagerFactory("JPAJavaSEPU");
     EntityManager em = emf.createEntityManager();
     Employee employee = new Employee();
     employee.setId(1);
     employee.setName("Antero");
     employee.setSalary(3000);
     
     em.getTransaction().begin();
     em.persist(employee);
     em.getTransaction().commit();
    } catch (Exception ex) {
     System.out.println("Error: " + ex.getMessage());
    }
   } 
   

    
   NOTE: you need to surround em.persist with the em.getTransaction().begin() and em.getTransaction().commit() to start and end a transaction otherwise nothing will get persisted on the database!
    
7. Add your "DBMS JDBC driver" jar into your project libraries
   For MySQL this driver is called "Connector/J".
   The file name is something like "mysql-connector-java-5.1.21-bin.jar" depending on your version of the driver.
   I've mine in: C:\glassfish3\glassfish\domains\domain1\lib\mysql-connector-java-5.1.21-bin.jar
   If you don't have it yet check the JDBC page on this site to see where to find it and download it.
   
   If you skip this step and run the program you'll get and error like:

   ...
   Exception Description: Configuration error.  Class [com.mysql.jdbc.Driver] not found.
   ... 
   

    
8. Add your entity classes into the Persistence Unit (PU) configuration (persistence.xml)
   
   • You can add them manually in the persistence.xml
     For example for the entity "Employee" you would add a line like:

     <class>entities.Employee</class>
     

     Where "entities" is the package name for the "Employee" class.
   • Or you can use "NetBeans XML editor" to edit the persistence.xml and add the entities through the GUI:
     Double click "persistence.xml" on the project tree to open the XML editor. Then click the "Add Class..." button to select and add the entities;

   
   If you skip this step you'll get an error like:
   

   Error: Object: entities.Employee@1aa8d4 is not a known entity type.
   

   
   

Code example

@Entity
public class Employee {
@Id private int id;
private String name;
private long salary;
public Employee() {}
public Employee(int id) { this.id = id; }
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public long getSalary() { return salary; }
public void setSalary (long salary) { this.salary = salary; }
}

import javax.persistence.*;
import java.util.List;

public class EmployeeService {

    protected EntityManager em;

    public EmployeeService(EntityManager em) {
        this.em = em;
    }

    public Employee createEmployee(int id, String name, long salary) {
        Employee emp = new Employee(id);
        emp.setName(name);
        emp.setSalary(salary);
        em.persist(emp);
        return emp;
    }

    public void removeEmployee(int id) {
        Employee emp = findEmployee(id);
        if (emp != null) {
            em.remove(emp);
        }
    }

    public Employee raiseEmployeeSalary(int id, long raise) {
        Employee emp = em.find(Employee.class, id);
        if (emp != null) {
            emp.setSalary(emp.getSalary() + raise);
        }
        return emp;
    }

    public Employee findEmployee(int id) {
        return em.find(Employee.class, id);
    }

    public List<Employee> findAllEmployees() {
        TypedQuery<Employee> query = em.createQuery(
                "SELECT e FROM Employee e", Employee.class);
        return query.getResultList();
    }
}

import javax.persistence.*;
import java.util.List;

public class EmployeeTest {

    public static void main(String[] args) {
        EntityManagerFactory emf =
                Persistence.createEntityManagerFactory("EmployeeService");
        EntityManager em = emf.createEntityManager();
        EmployeeService service = new EmployeeService(em);
// create and persist an employee
        em.getTransaction().begin();
        Employee emp = service.createEmployee(158, "John Doe", 45000);
        em.getTransaction().commit();
        System.out.println("Persisted " + emp);
// find a specific employee
        emp = service.findEmployee(158);
        System.out.println("Found " + emp);
// find all employees
        List<Employee> emps = service.findAllEmployees();
        for (Employee e : emps) {
            System.out.println("Found employee: " + e);
        }
// update the employee
        em.getTransaction().begin();
        emp = service.raiseEmployeeSalary(158, 1000);
        em.getTransaction().commit();
        System.out.println("Updated " + emp);
// remove an employee
        em.getTransaction().begin();
        service.removeEmployee(158);
        em.getTransaction().commit();
        System.out.println("Removed Employee 158");
// close the EM and EMF when done
        em.close();
        emf.close();
    }
}

What is Refactoring?

• Refactoring is a disciplined technique for improving the structure of existing code without changing the observable behavior.
• In short: change the structure of your code, without changing behavior. Using Refactoring, you can easily move fields, methods or classes around without breaking things. Refactorings come as simple as Rename or more complex like Tease Apart Inheritance.

• Refactoring improves the design of software 
• Refactoring makes software easier to understand 
• Refactoring makes software easier to maintain 
• Refactoring helps you find bugs 
• Refactoring helps you program faster 

• Rename: You can change the name of a package, class, method or field to something more meaningful. Netbeans will update all source code in your project to reference the element by its new name.
• Replace block of code with a method;
• Encapsulate Fields: Many IDEs can automatically generates a getter method and and a setter method for a field and optionally update all referencing code to access the field using the getter and setter methods.
• Move Class: Moves a class to another package or into another class. In addition, all source code in your project is updated to reference the class in its new location.
• Safely Delete: Checks for references to a code element and then automatically deletes that element if no other code references it.
• Change Method Parameters: Enables you to add parameters to a method and change the access modifier.
• Extract Interface: Creates a new interface from the selected public non-static methods in a class or interface.
• Extract Superclass: Creates a new abstract class, changes the current class to extend the new class, and moves the selected methods and fields to the new class.
• Move Inner to Outer Level: Moves an inner class one level up in hierarchy. 

Refactoring with Netbeans