How do I mark method as @deprecated?

By I Wayan Saryada in Basic, Core API 0 Comment

To mark a method as deprecated we can use the JavaDoc @deprecated tag. This is what we did since the beginning of Java. But when a new metadata support introduced to the Java language we can also use annotation. The annotation for marking method as deprecated is @Depreated.

The difference between these two that the @deprecated is place in the JavaDoc comment block while the @Deprecated is placed as a source code element.

package org.kodejava.basic;

import java.util.Date;
import java.util.Calendar;

public class DeprecatedExample {
    public static void main(String[] args) {
        DeprecatedExample de = new DeprecatedExample();
        de.getDate();
        System.out.println(de.getMonthFromDate());
    }

    /**
     * Get current system date.
     *
     * @return current system date.
     * @deprecated This method will be removed in the near future.
     */
    @Deprecated
    public Date getDate() {
        return new Date();
    }

    public int getMonthFromDate() {
        return Calendar.getInstance().get(Calendar.MONTH);
    }
}

How do I programmatically compile Java class?

By I Wayan Saryada in Core API, Tools 0 Comment

This example using the Java Compiler API introduced in JDK 1.6 to programmatically compile a Java class. Here we’ll compile the Hello.java. The process of compiling can be start by obtaining a JavaCompiler from the ToolProvider.getSystemJavaCompiler().

The simplest way to compile is by calling the run() method of the compiler and passing the first three arguments with null value. These three argument will use the default System.in, System.out and System.err. The final parameter is the file of the Java class to be compiled.

When error happened during compilation process the non-zero result code will be returned. After the compile process you’ll have the Hello.class just as if you were compiling using the javac command.

package org.kodejava.tools;

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;

public class CompileHello {
    public static void main(String[] args) {
        System.out.println(System.getProperty("user.dir"));
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        int result = compiler.run(null, null, null,
                "kodejava-tools/src/main/java/org/kodejava/tools/Hello.java");

        System.out.println("Compile result code = " + result);
    }
}

How do I list property names of a Bean?

By I Wayan Saryada in Beans 0 Comment 
package org.kodejava.bean;

import java.io.Serializable;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.beans.IntrospectionException;

public class Fruit implements Serializable {
    private Long id;
    private String name;
    private String latinName;
    private double price;

    public Fruit() {
    }

    public static void main(String[] args) {
        try {
            BeanInfo bi = Introspector.getBeanInfo(Fruit.class);
            PropertyDescriptor[] pds = bi.getPropertyDescriptors();

            for (PropertyDescriptor pd : pds) {
                String propertyName = pd.getName();

                System.out.println("propertyName = " + propertyName);
            }
        } catch (IntrospectionException e) {
            e.printStackTrace();
        }
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLatinName() {
        return latinName;
    }

    public void setLatinName(String latinName) {
        this.latinName = latinName;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

The output of the code snippet above are:

propertyName = class
propertyName = id
propertyName = latinName
propertyName = name
propertyName = price

How do I create an instance of a Bean?

By I Wayan Saryada in Beans 0 Comment 
package org.kodejava.bean;

import java.io.Serializable;
import java.io.IOException;
import java.beans.Beans;

public class TheBean implements Serializable {
    private Long id;
    private String name;

    public TheBean() {
    }

    public static void main(String[] args) {
        try {
            TheBean bean = (TheBean) Beans.instantiate(
                    ClassLoader.getSystemClassLoader(), "org.kodejava.bean.TheBean");
            bean.setId(1L);
            bean.setName("John");
            System.out.println("The Bean = " + bean);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "[id=" + id + "; name=" + name + "]";
    }
}

How do I listen for a constrained property change?

By I Wayan Saryada in Beans 0 Comment

The constrained property change is fired when a bean’s value is about to change. When a VetoableChangeListener veto the value change the bean’s value will be rolled-back to the previous value. In this example we have a constrained property called interest.

package org.kodejava.bean;

import java.beans.VetoableChangeSupport;
import java.beans.PropertyVetoException;

public class VetoBean {
    private double interest;

    private final VetoableChangeSupport vcs = new VetoableChangeSupport(this);

    public VetoBean() {
        vcs.addVetoableChangeListener(new VetoChangeListener());
    }

    public void setInterest(double interest) {
        try {
            vcs.fireVetoableChange("interest", this.interest, interest);

            this.interest = interest;
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        VetoBean bean = new VetoBean();
        bean.setInterest(10.99);
        bean.setInterest(15.99);

        // PropertyVetoException will be thrown because the interest value
        // should not exceed 20.00.
        bean.setInterest(20.99);
    }
}

package org.kodejava.bean;

import java.beans.VetoableChangeListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyVetoException;

public class VetoChangeListener implements VetoableChangeListener {
    /**
     * This method gets called when a constrained property is changed.
     *
     * @param evt a `PropertyChangeEvent` object describing the
     *            event source and the property that has changed.
     * @throws java.beans.PropertyVetoException
     *          if the recipient wishes the property
     *          change to be rolled back.
     */
    public void vetoableChange(PropertyChangeEvent evt) throws PropertyVetoException {
        String eventName = evt.getPropertyName();
        if (eventName.equalsIgnoreCase("interest")) {
            double interest = (Double) evt.getNewValue();
            if (interest > 20.00) {
                throw new PropertyVetoException("Interest must be below 20.00", evt);
            }
            System.out.println("Interest applied = " + interest);
        }
    }
}