Java J2EE Spring How to Convert Double to String to Double in Java Program with Example

Many scenarios come in day to day Java programming when we need to convert a Double value to String or vice versa. In my earlier article we have seen how to convert String to Integer and in this article we will first see how to convert double to String and later opposite of  that from String to double. One important thing to note is Autoboxing which automatically converts primitive type to Object type and only available from Java 5 onwards. These conversion example assumes code is running above Java 5 version and actually tested in JDK 1.6, which makes it enable to pass Double object when method is expecting double primitive value e.g. String.valueOf(double d) which expect a double value.
Read more »

Java J2EE Spring JavaFX exercise: Reflection effect

Reflection effect
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package javafx_extext;

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.effect.Reflection;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;

/**
*
* @author erix7
*/
public class JavaFX_exText extends Application {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("java-buddy.blogspot.com");
Group root = new Group();
Scene scene = new Scene(root, 400, 300, Color.WHITE);

Reflection reflection = new Reflection();

Text text = new Text(50, 50, "Serif");
text.setFill(Color.RED);
text.setFont(Font.font("Serif", 20));
text.setEffect(reflection);

Text text2 = new Text(50, 100, "SanSerif");
text2.setFill(Color.GREEN);
text2.setFont(Font.font("SanSerif", 30));
text2.setEffect(reflection);

Text text3 = new Text(50, 150, "Monospaced");
text3.setFill(Color.BLUE);
text3.setFont(Font.font("Monospaced", 40));
text3.setEffect(reflection);

root.getChildren().add(text);
root.getChildren().add(text2);
root.getChildren().add(text3);

primaryStage.setScene(scene);
primaryStage.show();
}
}

Java J2EE Spring JavaFX exercise: add shadow effect on text

shadow effect on text
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package javafx_extext;

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.effect.DropShadow;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;

/**
*
* @author erix7
*/
public class JavaFX_exText extends Application {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("java-buddy.blogspot.com");
Group root = new Group();
Scene scene = new Scene(root, 400, 300, Color.WHITE);

DropShadow shadow = new DropShadow();
shadow.setOffsetX(5.0);
shadow.setOffsetY(5.0);
shadow.setColor(Color.BLACK);

Text text = new Text(50, 50, "Serif");
text.setFill(Color.RED);
text.setFont(Font.font("Serif", 20));
text.setEffect(shadow);

Text text2 = new Text(50, 100, "SanSerif");
text2.setFill(Color.GREEN);
text2.setFont(Font.font("SanSerif", 30));
text2.setEffect(shadow);

Text text3 = new Text(50, 150, "Monospaced");
text3.setFill(Color.BLUE);
text3.setFont(Font.font("Monospaced", 40));
text3.setEffect(shadow);

root.getChildren().add(text);
root.getChildren().add(text2);
root.getChildren().add(text3);

primaryStage.setScene(scene);
primaryStage.show();
}
}

Java J2EE Spring JavaFX exercise: Set text font

Set text font
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package javafx_extext;

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;

/**
*
* @author erix7
*/
public class JavaFX_exText extends Application {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("java-buddy.blogspot.com");
Group root = new Group();
Scene scene = new Scene(root, 400, 300, Color.WHITE);

Text text = new Text(50, 50, "Serif");
text.setFill(Color.RED);
text.setFont(Font.font("Serif", 20));

Text text2 = new Text(50, 100, "SanSerif");
text2.setFill(Color.GREEN);
text2.setFont(Font.font("SanSerif", 30));

Text text3 = new Text(50, 150, "Monospaced");
text3.setFill(Color.BLUE);
text3.setFont(Font.font("Monospaced", 40));

root.getChildren().add(text);
root.getChildren().add(text2);
root.getChildren().add(text3);

primaryStage.setScene(scene);
primaryStage.show();
}
}

Java J2EE Spring JavaFX exercise: Set text color using javafx.scene.paint.Color

Set text color using javafx.scene.paint.Color
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package javafx_extext;

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.text.Text;
import javafx.stage.Stage;

/**
*
* @author erix7
*/
public class JavaFX_exText extends Application {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("java-buddy.blogspot.com");
Group root = new Group();
Scene scene = new Scene(root, 400, 300, Color.WHITE);

Text text = new Text(50, 50, "Hello Java-Buddy");
int red = 255;
int green = 0;
int blue = 0;
text.setFill(Color.rgb(red, green, blue, 0.9));

Text text2 = new Text(50, 100, "Hello Java-Buddy");
text2.setFill(Color.GREEN);
Text text3 = new Text(50, 150, "Hello Java-Buddy");
text3.setFill(Color.hsb(40, 0.7, 0.8));

root.getChildren().add(text);
root.getChildren().add(text2);
root.getChildren().add(text3);

primaryStage.setScene(scene);
primaryStage.show();
}
}

Java J2EE Spring Hibernate Interview Questions and Answers: with annotations and Spring framework

This is more like a Hibernate and Spring tutorial. Takes you through the key steps with code snippets. Also, very handy to refresh your memory prior to your job interviews.

Q. What are the general steps involved in creating Hibernate related class?
A. The general steps involved in creating Hibernate related classes involve the following steps

  • Define the domain (aka entity) objects like Employee, Address, etc to represent relevant tables in the underlying database with the appropriate annotations or using the *.hbm.xml mapping files.
  • Define the Repository  (aka DAO -- Data Access Objects) interfaces and implementations classes that use the domain objects and the hibernate session to perform data base CRUD (Create, Read, Update and Delete) operations the hibernate way.
  • Define the service interfaces and the classes that make use of one or more repositories (aka DAOs) in a transactional context.A transaction manager will be used to coordinate transactions (i.e. commit or rollback) between  a number of repositories.
  • Finally, use an IoC container like Spring framework to wire up the Hibernate classes like SessionFactory, Session, transaction manager, etc and the user defined repositories, and the service classes. A number of interceptors can be wired up as well for deadlock retry, logging, auditing, etc using Spring.
For more detail, refer to Spring and Hibernate integration Interview questions and answers
Q. How would you define a hibernate domain object with table mappings, native named queries, and custom data conversion using annotations?
A.

Firstly, define a parent domain object class for any common method implementations.


package com.myapp.domain.model;

public class MyAppDomainObject {

//for example
protected boolean isPropertyEqual(Object comparee, Object compareToo) {
if (comparee == null) {
if (compareToo != null) {
return false;
}
} else if (!comparee.equals(compareToo)) {
return false;
}
return true;
}

}


Now, extend the common DomainObject for specific DomainObject classes.


package com.myapp.domain.model;

@Entity
@org.hibernate.annotations.Entity(selectBeforeUpdate = true)
@Table(name = "tbl_employee")
@TypeDefs(value = { @TypeDef(name = "dec", typeClass = DecimalUserType.class)}) // custom data type conversion

@NamedNativeQueries({
@NamedNativeQuery(name = "HighSalary", query = "select * from tbl_employee where salary > :median_salary " , resultClass = Employee.class),
@NamedNativeQuery(name = "LowSalary", query = "select * from tbl_employee where salary < :median_salary " , resultClass = Employee.class)
})

public class Employee extends MyAppDomainObject implements Serializable {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "employee_id")
private Long id;

@Column(name = "emp_code")
private String accountCode;

@Column(name = "manager_code")
private String adviserCode;



@Column(name = "type")
@Enumerated(EnumType.STRING)
private EmployeeType type = EmployeeType.PERMANENT;


@Type(type = "dec")
@Column(name = "base_salary")
private Decimal salary = Decimal.ZERO;

@Transient
private Decimal salaryWithBonus; //not persisted to database

@Formula("base_salary*2")
private Decimal doubleSalary; //derived or calculated read only property

@Formula("(select base_salary where type = 'Permanent' )")
private Decimal permanantLeaveLoading; //derived or calculated read only property


@OneToOne(cascade = { CascadeType.REFRESH })
@JoinColumn(name = "emp_code", insertable = false, updatable = false)
private EmployeeExtrInfo extraInfo;

@ManyToOne(cascade = { CascadeType.REFRESH })
@JoinColumn(name = "manager_code", insertable = false, updatable = false)
private Manager manager;

@OneToMany(cascade = { ALL, MERGE, PERSIST, REFRESH }, fetch = FetchType.LAZY)
@JoinColumn(name = "emp_code", nullable = false)
@Cascade({ org.hibernate.annotations.CascadeType.SAVE_UPDATE, org.hibernate.annotations.CascadeType.DELETE_ORPHAN })
private List<PaymentDetail> paymentDetails = new ArrayList<PaymentDetail>();

//getters and setters omitted for brevity

}

The dependency classes like EmployeeExtrInfo, Manager, and PaymentDetail will be mapped in a similar manner as the Employee class. The EmployeeType enum class is shown below. Also note the verys usefull annotations like @NamedNativeQueries, @TypeDefs, and @Formula. The @Formula marks a property as derived, or calculated, read-only property, where its value is calculated at fetch time using SQL expressions.

package com.myapp.domain.model;


public enum EmployeeType {

PERMANENT("Permanent"),
CONTRACTOR("Contractor"),
CASUAL("Casual");

private String type;

private EmployeeType (String type) {
this.type = type;
}

public String getType() {
return this.type;
}
}


The "dec" is a custom data type, you need to define the custom data type class. The "salary" attribute will be making use of this special data type. This is ust a trivial example, but more powerful custom type conversion classes can be created.

package com.myapp.domain.model;

import java.io.Serializable;
import java.math.BigDecimal;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Properties;

import org.hibernate.usertype.ParameterizedType;
import org.hibernate.usertype.UserType;

public class DecimalUserType implements UserType, ParameterizedType {
public static final int PRECISION = 28;
public static final int SCALE = 15;

public int[] sqlTypes() {
return new int[]{Types.DECIMAL};
}

public Class<Decimal> returnedClass() {
return BigDecimal.class;
}

public boolean equals(Object x, Object y) {
if (x == y) {
return true;
}
if (x == null || y == null) {
return false;
}
return x.equals(y);
}

public int hashCode(Object x) {
return 0;
}

public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws SQLException {
BigDecimal forReading = rs.getBigDecimal(names[0]);

if (forReading == null) {
return null;
}

return forReading.setScale(2, RoundingMode.HALF_EVEN); //round to 2 decimal places
}


public void nullSafeSet(PreparedStatement st, Object value, int index) throws SQLException {
if (value == null) {
st.setNull(index, Types.NUMERIC);
return;
}


BigDecimal forSaving = (BigDecimal) value;
st.setBigDecimal(index, forSaving.setScale(2, RoundingMode.HALF_EVEN));
}

public Object deepCopy(Object value) {
return value;
}

public boolean isMutable() {
return false;
}

public Serializable disassemble(Object value) {
return null;
}

public Object assemble(Serializable cached, Object owner) {
return null;
}

public Object replace(Object original, Object target, Object owner) {
return original;
}

public void setParameterValues(Properties parameters) {
}
}



The named queries are also shown above with the @NamedNativeQueries and @NamedNativeQuery annotations. The parametrized values like :median_salary needs to be supplied via the Hibernate repository class that makes use of the Employee domain object. Firstly define the interface.

package com.myapp.domain.repo;

import java.util.List;


public interface EmployeeTableRepository {

Employee saveEmployee(Employee employee) throws RepositoryException ;
Employee loadEmployee(Long employeeId) throws RepositoryException ;
List<Employee> findAllEmployeesWithHighSalary(BigDecimal medianSalary) throws RepositoryException;
List<Employee> findAllEmployeesWithLowSalary(BigDecimal medianSalary) throws RepositoryException

}




Next the implementation of the above interface.
package com.myapp.domain.repo;


@SuppressWarnings("unchecked")
public class EmployeeTableHibernateRepository extends HibernateDaoSupport implements EmployeeTableRepository {

public EmployeeTableHibernateRepository (HibernateTemplate hibernateTemplate) {
setHibernateTemplate(hibernateTemplate);
}

//The employee objects gets constructed and passed to repo via the Business Service layer
public Employee saveEmployee(Employee employee) throws RepositoryException {
Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
session.saveOrUpdate(employee);
session.flush();
session.evict(employee);
return this.loadEmployee(employee.getId());
}

public Employee loadEmployee(Long employeeId) throws RepositoryException {
Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
Criteria crit = session.createCriteria(Employee.class);
crit.add(Restrictions.eq("id",employeeId));
List<Employee> employees = crit.list();
if (employees.size() == 1) {
return employees.get(0);
}

//this is a custom exception class
throw new RepositoryException("Found more than one or no employee with Id:" + employeeId);
}


public List<Employee> findAllEmployeesWithHighSalary(BigDecimal medianSalary) throws RepositoryException {
Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
Query query = session.getNamedQuery("HighSalary"); // query name defined in Employee class
query.setBigDecimal(":median_salary", medianSalary); // query parameter defined in Employee class
return (List<Employee>) query.list();
}

public List<Employee> findAllEmployeesWithLowSalary(BigDecimal medianSalary) throws RepositoryException {
Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
Query query = session.getNamedQuery("LowSalary"); // query name defined in Employee class
query.setBigDecimal(":median_salary", medianSalary); // query parameter defined in Employee class
return (List<Employee>) query.list();
}


//other methods can be defined here
}

The Service classes shown below will be making use of the repository (or DAO) classes. The service class can use any number of the repository classes, and also responsible for cordinating the transaction as well with a TransactionManger. In the example below, we will be using the "PlatformTransactionManager" implementation provided by the Spring framework.
package com.myapp.service;

public interface EmployeeService {

Employee saveEmployee(Employeee employee) throws RepositoryException;
Employee loadEmployee(Long employeeId) throws RepositoryException;

}

The implementation class is shown with the transaction manager. The employeeRepository and transactionManager are dependency injected
package com.myapp.service;


import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
//....other imports

public class EmployeeServiceImpl implements EmployeeService {


private final EmployeeTableRepository employeeRepository;
private PlatformTransactionManager transactionManager;

public EmployeeServiceImpl (EmployeeTableRepository employeeRepository, PlatformTransactionManager transactionManager) {
this.employeeRepository = employeeRepository;
this.transactionManager = transactionManager;
}


public Employee saveEmployee(Employeee employee) throws RepositoryException {
TransactionStatus transactionStatus =
transactionManager.getTransaction(new DefaultTransactionDefinition(
TransactionDefinition.PROPAGATION_REQUIRED));
try {
employee = this.employeeRepository.saveEmployee(employee);
} catch (Exception e) {
transactionManager.rollback(transactionStatus);
throw new RepositoryException(e);
} finally {
if (!transactionStatus.isCompleted()) {
transactionManager.commit(transactionStatus);
}
}
return employee;
}

public Employee loadEmployee(Long employeeId) throws RepositoryException {
return this.employeeRepository.loadEmployee(employeeId);
}


//....other methods

}




Q. How will you wire up the code snippet discussed above using Spring?
A. The following 3 Spring configuration files are used for wiring up the classes defined above.


  • The daoContext.xml file to define the hibernate session factory, jndi data source, hibernate properties, and the user defined domain class and the repository.
  • The transactionContext.xml file to define the transaction manager.
  • The servicesContext.xml to define the custom services class


Firstly the daoContext.xml file:


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

<bean id="dataSourceMyDB" class="org.springframework.jndi.JndiObjectFactoryBean" scope="singleton">
<property name="jndiName">
<value>java:comp/env/jdbc/dataSource/mydb</value>
</property>
</bean>

<bean id="hibernateProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="properties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.SybaseDialect</prop>
<prop key="hibernate.generate_statistics">false</prop>
<prop key="hibernate.hbm2ddl.auto">verify</prop>
<prop key="hibernate.jdbc.batch_size">50</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.format_sql">false</prop>
<prop key="hibernate.cache.use_query_cache">false</prop>
<prop key="hibernate.cache.use_second_level_cache">false</prop>
<prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
</props>
</property>
<property name="location">
<value>classpath:/hibernate.properties</value>
</property>
</bean>

<bean id="hibernateAnnotatedClasses" class="org.springframework.beans.factory.config.ListFactoryBean">
<property name="sourceList">
<list>
<value>com.myapp.domain.model.Employee</value>
</list>
</property>
</bean>

<bean id="hibernateSessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSourceShadow" />
<property name="hibernateProperties">
<ref local="hibernateProperties" />
</property>
<property name="entityInterceptor">
</property>
<property name="annotatedClasses">
<ref local="hibernateAnnotatedClasses" />
</property>
<property name="annotatedPackages">
<list></list>
</property>
</bean>

<bean id="daoTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<constructor-arg index="0" ref="sessionFactory" />
<constructor-arg index="1" value="true" />
</bean>

<!-- Repository beans -->
<bean id="employeeTableRepository" class="com.myapp.domain.repo.EmployeeTableHibernateRepository">
<constructor-arg ref="daoTemplate" />
</bean>

</beans>



The transactionContext.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"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<!-- Transaction manager for a single Hibernate SessionFactory (alternative to JTA) -->

<alias name="hibernateSessionFactory" alias="sessionFactory"/>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="advisorAutoProxy" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
<bean id="transactionAttrSource" class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
<property name="transactionInterceptor" ref="transactionInterceptor" />
</bean>
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributeSource">
<bean class="org.springframework.transaction.annotation.AnnotationTransactionAttributeSource" />
</property>
</bean>

</beans>



Finally the servicesContext.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" xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<!-- CONFIGURE SERVICE BEANS -->
<!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
<bean id="employeeService" class="com.myapp.service.EmployeeService">
<constructor-arg ref="employeeTableRepository" />
<constructor-arg ref="transactionManager" />
</bean>

</beans>

Q. How will you go about writing an integration or unit test for the EmployeeService described above?
A. Since the dataSource is looked up via JNDI, you need to emulate the JNDI lookup.  This can be achieved with the Spring helper classes SimpleNamingContextBuilder and DriverManagerDataSource.

This involves 3 steps.

  • Define a bootsrapper class that emulates JNDI lookup using Spring helper classes like SimpleNamingContextBuilder and DriverManagerDataSource. For example, SybaseDevBootstrapper.java file.
  • Wire-up this via a Spring config file named sybaseDevBootstrapContext.xml.
  • Finally, write the JUnit test class EmployeeServicesSybTest.java.
  • Define the TestExecutionListeners if required.
 Firstly the SybaseDevBootstrapper.java


package com.myapp.test.db;

import javax.naming.NamingException;

import org.springframework.beans.factory.BeanCreationException;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.mock.jndi.SimpleNamingContextBuilder;

/**
* helper class to bootstrap the sybase database datasources
*/
public class SybaseDevBootstrapper {

public static final String JNDI_BINDING_DB = "java:comp/env/jdbc/dataSource/mydb";
public static final String DRIVER_CLASS = "com.sybase.jdbc3.jdbc.SybDriver";

private SimpleNamingContextBuilder builder; //Spring JNDI emulator class

/**
* setup sybase databases, and bind to specific places in jndi tree
*/
public void start() {
try {
builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();

DriverManagerDataSource ds = new DriverManagerDataSource();
ds.setDriverClassName(DRIVER_CLASS);
ds.setUrl("jdbc:sybase:Tds:host-name:10004/my_db");
ds.setUsername("user");
ds.setPassword("pwd");
builder.bind(JNDI_BINDING_DB, ds);


} catch (NamingException e) {
throw new BeanCreationException(e.getExplanation());
}
}

public void stop() {
builder.deactivate();
builder.clear();
}
}




Next, wire the above Java class.



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

<bean id="sybaseDevBootstrapper" class="com.myapp.test.db.SybaseDevBootstrapper" init-method="start" destroy-method="stop"/>

</beans>



Finally the test class EmployeeServicesSybTest.java


package com.myapp.test.services;

import javax.annotation.Resource;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;

//...other imports


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={
"classpath:/sybaseDevBootstrapContext.xml",
"classpath:/transactionContext.xml",
"classpath:/daoContext.xml",
"classpath:/servicesContext.xml",
})
@TestExecutionListeners(value = {
DependencyInjectionTestExecutionListener.class,
SessionBindingHibernateListener.class
})

public class EmployeeServicesSybTest {

@Resource
EmployeeService employeeService;

@Test
public void testSaveEmployee() throws RepositoryException {
Assert.assertTrue(employeeService != null);

Employee employee = new Emloyee();
//....assign values here

employeeService.seaveEmployee(employee);

}

}


The JUnit's way of setting up cross cutting concerns like security, locale, currency, timezone, and any other pre-initilization rules for the test cases function correctly is via annoattions like @Before and @After. The Spring's TestContext framework uses the anootation @TestExecutionListeners to acheive setting up of these cross cutting concerns. In the above example, we are using the DependencyInjectionTestExecutionListener.class from the Spring framework to provide support for dependncy injection and the custom SessionBindingHibernateListener.class to bind the session to the current thread. The custom implementation shown below extends the AbstractTestExecutionListener, which is the abstract implementation of TestExecutionListener class from the Spring framework.





/**
* Helper class for binding sessions to the current thread
*
*/
public class SessionBindingHibernateListener extends SessionBindingListener {

private static final String BEAN_NAME = "hibernateSessionFactory";

public SessionBindingHibernateListener() {
super(BEAN_NAME);
}
}








import org.hibernate.FlushMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
import org.springframework.orm.hibernate3.SessionHolder;
import org.springframework.test.context.TestContext;
import org.springframework.test.context.support.AbstractTestExecutionListener;
import org.springframework.transaction.support.TransactionSynchronizationManager;


/**
* Helper class for binding sessions to the current thread
*
*/
public class SessionBindingListener extends AbstractTestExecutionListener {

private final String beanName;

public SessionBindingListener(String beanName) {
this.beanName = beanName;
}

@Override
public void prepareTestInstance(TestContext testContext) throws Exception {
ApplicationContext context = testContext.getApplicationContext();
SessionFactory sessionFactory = (SessionFactory) context.getBean(beanName);

Session session = SessionFactoryUtils.getSession(sessionFactory, true);
session.setFlushMode(FlushMode.MANUAL);
if (!TransactionSynchronizationManager.hasResource(sessionFactory)) {
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
}
}
}


Spring Hibernate Communication between JavaFX and JavaScript inside WebView, using JSObject

The former articles demonstrate how to "Execute JavaScript in WebView from Java code" and "implement OnAlert EventHandler of WebEngine".

In order to call JavaFX from Javascript in WebView, we can create a JSObject in JavaFX, and then calling it's setMember() method to make it known to Javascript. After that, Javascript can call it's public methods and access it's public field.

Communication between JavaFX and JavaScript inside WebView


JavaFX code:
package javafxweb;

import java.net.URL;
import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.concurrent.Worker.State;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.HPos;
import javafx.geometry.Insets;
import javafx.geometry.VPos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Region;
import javafx.scene.layout.VBox;
import javafx.scene.web.WebEngine;
import javafx.scene.web.WebView;
import javafx.stage.Stage;
import netscape.javascript.JSObject;

/**
*
* @web http://java-buddy.blogspot.com/
*/
public class JavaFXWeb extends Application {

private Scene scene;
MyBrowser myBrowser;

Label labelFromJavascript;

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
launch(args);
}

@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("java-buddy.blogspot.com");

myBrowser = new MyBrowser();
scene = new Scene(myBrowser, 640, 480);

primaryStage.setScene(scene);
primaryStage.show();
}

class MyBrowser extends Region{

HBox toolbar;
VBox toolbox;

WebView webView = new WebView();
WebEngine webEngine = webView.getEngine();

public MyBrowser(){

final URL urlHello = getClass().getResource("hello.html");
webEngine.load(urlHello.toExternalForm());

webEngine.getLoadWorker().stateProperty().addListener(
new ChangeListener<State>(){

@Override
public void changed(ObservableValue<? extends State> ov, State oldState, State newState) {
if(newState == State.SUCCEEDED){
JSObject window = (JSObject)webEngine.executeScript("window");
window.setMember("app", new JavaApplication());
}
}
});


JSObject window = (JSObject)webEngine.executeScript("window");
window.setMember("app", new JavaApplication());

final TextField textField = new TextField ();
textField.setPromptText("Hello! Who are?");

Button buttonEnter = new Button("Enter");
buttonEnter.setOnAction(new EventHandler<ActionEvent>(){

@Override
public void handle(ActionEvent arg0) {
webEngine.executeScript( " updateHello(' " + textField.getText() + " ') " );
}
});

Button buttonClear = new Button("Clear");
buttonClear.setOnAction(new EventHandler<ActionEvent>(){

@Override
public void handle(ActionEvent arg0) {
webEngine.executeScript( "clearHello()" );
}
});

toolbar = new HBox();
toolbar.setPadding(new Insets(10, 10, 10, 10));
toolbar.setSpacing(10);
toolbar.setStyle("-fx-background-color: #336699");
toolbar.getChildren().addAll(textField, buttonEnter, buttonClear);

toolbox = new VBox();
labelFromJavascript = new Label();
toolbox.getChildren().addAll(toolbar, labelFromJavascript);
labelFromJavascript.setText("Wait");

getChildren().add(toolbox);
getChildren().add(webView);

}

@Override
protected void layoutChildren(){
double w = getWidth();
double h = getHeight();
double toolboxHeight = toolbox.prefHeight(w);
layoutInArea(webView, 0, 0, w, h-toolboxHeight, 0, HPos.CENTER, VPos.CENTER);
layoutInArea(toolbox, 0, h-toolboxHeight, w, toolboxHeight, 0, HPos.CENTER, VPos.CENTER);
}

}

public class JavaApplication {
public void callFromJavascript(String msg) {
labelFromJavascript.setText("Click from Javascript: " + msg);
}
}

}


hello.html
<!DOCTYPE html>
<html lang="en-US">
<head>
<meta charset=utf-8>
<title>Hello Java-Buddy!</title>

<script>

function updateHello(user){
document.getElementById("helloprompt").innerHTML="Hello: " + user;
}

function clearHello(user){
document.getElementById("helloprompt").innerHTML="Hello <a href='http://java-buddy.blogspot.com/'>Java-Buddy</a>";
}

function callJavaFX(){
var msg = document.getElementById("textto").value;
app.callFromJavascript(msg);
}
</script>

</head>
<body>
<img src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjlRq_8YevlOSHrtrlvhf3k7o0E0fLS1Wv90sbMxIgQlsGaPxFOvAa8wULLxqAw707tewfbIqZj4qSflE56poWxfJYnotevZnW0JMlNAxpnobpL1CL1aNYz4uM4gpxvpKotR_TjvuvyNFSh/s150/duke_44x80.png"/>
<p id="helloprompt">Hello <a href="http://java-buddy.blogspot.com/">Java-Buddy</a></p>
<p><textarea id="textto"> </textarea></p>
<p><input type="button" value="Click to send message to Javascript" onclick="callJavaFX()"></p>
</body>
</html>


Labels

.equals = operator abstract class abstract method abstract window toolkit Access Modifiers accessing java beans accessing javabeans action events actionperformed active addition Advanced Advanced Overloading AdvJavaBooks Agile development ajax alive AMQP and Android anonymous class anonymous inner class Ant ant tutorials anti patterns antipatterns Apache Camel api for jsp api for servlet api for servlets api jsp application context application scope application session Apps Architecture are you eligible for the ocmjd certificaiton are you eligible for the scjd certification arithmetic operator arpanet array construction array declaration array initialization array list array to list conversion arraylist arraylist of strings arraylist of types arraylist questions arraylists Arrays arrays in java ask for help assert assert in java assertions assertions in java assignment assignment operator Atlassian attribute visibility authentication authorization autoboxing autounboxing awt AWT Event Handling awt interview questions AWT Layouts awt questions awt questions and answers backed collection backed collections Basic Basics of event handling bean attributes bean properties bean scope Beginner best practices BigData blocked books boxing buffer size bufferedreader bufferedwriter business delegate business delegate pattern calendar case statement casting in java casting interview questions chapter review choosing a java locking mechanism choosing a locking mechanism choosing a thread locking mechanism class inside a method class questions class with no name class without a name classes interview questions Clipboard closing jsp tags code snap coding cohesion collection generics collection interview questions collection methods collection of types collection questions collection searching collection types Collections Collections Framework collections interview questions collections sorting colors in java swings colors in swing command line arguments communication between threads comparable comparator comparison operators compiling java classes computers concurrency example and tutorial config Configuration ConnectionPooling constructor creation constructor interview questions constructor overloading constructors in java containers contents of deployment descriptor contents of web.xml context context scope converting array to list converting list to array core java core java interview core java interview question core java interview questions core java questions core java; core java; object oriented programming CoreJava CoreJavaBooks CORS coupling create threads creating 2 dimensional shapes creating 2D shapes creating a frame creating a jframe creating a thread creating an arraylist creating an inner class creating an interface creating java beans creating java threads creating javabeans creating threads creating threads in java CSS cURL currency current thread determination custom tag library custom taglib custom taglibs custom tags CVS dao dao design pattern dao factory pattern dao pattern data access object data access object pattern data structure and algorithm database date and time tutorial date format dateformat dates deadlock deadlocks debugging Declarations decorator pattern decrement default deleting sessions deploy web app deployment deployment descriptor deployment descriptor contents deployment of web application deserialization deserialize design pattern design pattern interview questions design patterns Designpatterns destory method destroy destroying sessions determining current thread determining the current thread Developer Differences different types of collections display stuff in a frame displaying images displaying images in java swings displaying images in swings displaying text in a component division do while loop doget dohead dopost doput DOS Downloads drawing a line drawing an ellipse drawing circles drawing ellipses drawing lines Drools tutorial eBooks Eclipse Eclipse Tutorial Encapsulation encapsulation in java enhanced for loop entity facade pattern enumerations enumerations in java enums equal to equals equals comparison error and exception error codes error handling in servlets error page event handling in swings event listeners exam prep tips example servlet Examples exception exception handling exception handling in servlets exception handling interview questions exception handling questions Exceptions exceptions in java exceptions in web applications explicit locking explicit locking of objects file file navigation filereader filewriter final class final method FireBug first servlet FIX protocol FIX Protocol interview questions FIX protocol tutorial font fonts for each loop for loop form parameters form values formatting forwarding requests frame frame creation frame positioning frame swings front controller front controller design pattern front controller pattern fundamental.Java FXML Games garbage collection garbage collection interview questions garbage collection questions garbage collector gc gc questions general generic Generics generics collections Geo get get set methods getattribute getting bean property getting form values getting form values in servlet getting scwcd certified getting servlet initialization parameters getting sun certified Google Graphics2D gregorian calendar handling strings in java hash hash map hash table hashcode hashmap hashset hashtable head head request HeadFirst heap heaps hibernate hibernate interview questions hibernate interview questions and answers hibernate questions hibernate questions and answers Hibernate Tutorial HibernateBooks homework How To HTML HTML and JavaScript html form http request http request handling http request header http request methods http request servlet http request type http session httprequest httprequest methods httpservlet httpservlet interview questions httpservlet interview questions with answers httpsession httpsession interview questions httpsession questions HttpSessionActivationListener HttpSessionAttributeListener HttpSessionBindingListener if if else if else block if else statement Image IO implementing an interface Implicit objects increment info inheritance inheritance in java init init method Initialization Blocks inner class inner class inside a method inner classes innerclass installation instanceof instanceof operator IntelliJ interaction between threads interface interface interview interface questions interfaces interfaces in java interfaces interview questions internet history interrupting a thread interrupting threads Interview interview questions interview questions on design patterns interview questions on exception handling interview questions on java collections interview questions on serialization introduction to java threads introduction to jsps introduction to threading introduction to threads invalidating session Investment Banking IO Package iscurrentthread iterator J2EE j2ee api j2ee design pattern j2ee design pattern interview questions j2ee design patterns j2ee hibernate interview questions j2ee history j2ee interview j2ee interview questions j2ee mvc j2ee mvc pattern j2ee programmer j2ee questions j2ee servlet api j2ee session j2ee struts interview questions java java 5 tutorial Java 8 java arrays java assertions java assignments java awt questions java bean java bean scope java beans java beginners tutorial Java career java certification Java Class java collection interview questions and answers java collection tutorial java collections java collections interview questions java constructors java currency Java CV java data base connectivity java database connectivity java database connectivity interview questions and answers java dates java design pattern java design patterns java developer certification Java EE java encapsulation java enums java event listeners java exceptions java formatting java garbage collection java garbage collector java gc java heap Java I/O java inheritance java input output Java Interface Java Interview Java Interview Answers Java Interview Questions Java Introduction java io java IO tutorial java iterator java jdbc Java JSON tutorial Java Key Areas java lists java literals java locks nested Java Media Framework java methods java multithreading Java multithreading Tutorials java nested locks java networking tutorial java numbers Java Objects java operators java overloading java parsing Java Programming Tutorials java race conditions java regex java regular expressions Java resume java scjp java searching java serialization java server pages java server pages api java server pages questions java spring interview questions. j2ee spring interview questions java stack java strings java swing java swing event listeners java swing frame java swing images java swings java swings images java thread explicit locking java thread lock scope java thread locking java thread locking mechanism java thread locking objects java threads java threads race condition java tips java tokenizing Java Tools Java Tutorial java ui questions Java Utilities java variables java wrappers Java xml tutorial java.lang java8 javabean javabean accessing javabean scope JavaBeans javac JavaEE JavaFX JavaFX 3D JavaFX 8 JavaOne JavaScript JavaTips JDBC jdbc driver jdbc example jdbc interview questions jdbc interview questions and answers jdbc interview questions with answers jdbc sample code JDBC Tutorial jdbc type 1 driver jdbc type 2 driver jdbc type 3 driver jdbc type 4 driver Jdeveloper JDK JDK8 JEE Tutorial jframe jframe creation jframe position jframe positioning JIRA JMeter JMS JMX join() joining threads JPA JQuery JS JSF JSF Tutorial JSONP JSP jsp and java beans jsp and servlets jsp and xml jsp api jsp code jsp compilation jsp conversion jsp directives jsp error page jsp error page directive jsp implicit objects jsp interview jsp interview questions jsp introduction jsp intvw questions jsp life jsp life cycle jsp life-cycle jsp lifecycle jsp page directive jsp questions jsp sample jsp scripting jsp scriptlets jsp servlets jsp summary jsp synopsis jsp tag libraries jsp tag library jsp taglib jsp tags jsp technology jsp to servlet jsp to servlet conversion jsp translation jsp usage jsp usebean jsp xml tags jsp xml tags usage jsp-servlet jsp:getProperty jsp:setProperty jsp:usebean jsps JSTL JUnit testing keyword synchronized keyword volatile Keywords Lambda Expressions Learning libraries life cycle life cycle of a jsp life cycle of a servlet life cycle of a thread life cycle of jsp life cycle of threads lifecycle of a thread linked list linkedhashmap linkedhashset linkedlist linux List listeners lists Literals locale lock manager pattern lock scope locking objects using threads log Logging logging errors logical and logical operators logical or loops loosely coupled making an arraylist making threads sleep making threads sleep for time MapReduce maps maps usage Maven Maven Tutorial max priority member access method arguments method local inner class method overloading method overriding method return types methods creating classes min priority Miscellaneous mobile mock exam model view controller model view controller design pattern model view controller pattern Multi Threading Multi-threading multiple threads multiplication multithreading multithreading in java multithreading interview questions multithreading questions mvc mvc design pattern mvc pattern MyEclipse mysql nested java lock nested java locks nested java thread locks nested locks nested thread locks NetBeans Networking new news nio NonAccess Modifiers norm priority normal inner class Normalization not equal to Notepad notify notifyall number format numberformat numbers object comparison object notify object orientation object oriented object oriented programming Object Oriented Programming in java objects interview questions ocmjd certification ocmjd certification eligibility OO OO Java oops OpenCSV OpenCV opening jsp tags OpenJDK OpenJFX Operators or Oracle Oracle ADF Mobile Oracle Certified Exams oracle certified master java developer oracle database ORM other topics out overloading overloading constructors overloading in java overriding page page directive page scope parsing passing variables passing variables to methods performance Platform Playing with Numbers points to remember polymorphism positioning a frame post practice exam Primitive Casting primitive variables printwriter priority queue priority queues priorityqueue priorityqueues private processing form values Products programming Projects protected public put questions questions on garbage collection questions on java strings queue quick recap quick review race conditions read objects from stream reading http request header RealTime_Tips redirecting to another servlet redirection reference reference variable casting reference variables Refreshing Java regex Regular Expressions regular inner class relational operators reminder request request dispatcher request forwarding request header request object. httpservletrequest request scope requestdispatcher response RESTClient RESTful retrieving values from session return error codes return types returning values runnable runnable interface running running java programs RUP sample jsp sample questions sample questions scwcd sample servlet scanner Scene Builder scjd certification scjd certification eligibility requirements scjp SCJP Certification scjp exam scjp exam questions scjp exam sample questions scjp questions scjp test scjp test questions scope scope of java locks scope of java thread locks scope of locks scripting in jsp scriptlet tags scriptlets scriptlets in jsp pages scwcd scwcd certification scwcd certification practice exam scwcd exam scwcd exam questions scwcd jsp summary scwcd mock exam scwcd mock exam answers scwcd practice exam scwcd practice test scwcd questions scwcd test SDLC searching searching arrays searching collections searching in java searching treemap searching treesets security self assement self assement scwcd self assessment scjp self test self test scjp self test scwcd send error method senderror method sending error code to browser serialization serialization in java serialization interview questions Serialization on Swing serialization questions service service method servlet servlet and forms servlet and jsp servlet api servlet attributes servlet code servlet container servlet context servlet error handling servlet exception handling servlet handling http request servlet initialization servlet initialization parameters servlet interview servlet interview questions servlet interview questions with answers servlet intvw questions servlet life cycle servlet lifecycle servlet questions servlet questions with answers servlet request servlet request dispatcher servlet request type servlet skeleton servletcontext servletcontextevent servletrequest Servlets servlets and jsps servlets api servlets details servlets request handling session session clean up session event listeners session facade pattern session interview questions session invalidation session listeners session management session questions session scope session timeout session tracking through url rewriting set collections set status method setattribute sets setstatus method setting bean property setting request type short circuit operators Singleton sleep sleeping threads soapUI Software Installation sorting sorting arraylist sorting arrays sorting collections special collections special inner classes split spring spring and hibernate interview questions spring batch Spring Core Spring Framework Spring Integration spring interview questions Spring JDBC Spring MVC Spring security Spring tutorial SQL SQL and database tutorial examples SQL Tutorial SSL stack stacks stacks and heaps static static class static declaration static imports static inner static inner class static method Static variable stopped stopping a thread stopping thread stopping threads Stored Procedure storing values in session Streams strictfp StrictMath string string buffer string builder string class string formatting String Handling string interview questions string manupulation string questions string tokenizer stringbuffer stringbuffer questions stringbuilder Strings strings in java struts Struts 1 Struts 1.2 Struts 2 struts framework interview questions struts interview questions struts interview questions with answers struts mvc interview questions struts questions Struts2 StrutsBooks submitting request subtraction Sun Certification sun certified java developer Sun Certified Java Programmer swing swing action performed swing and colors Swing Components swing event handling swing event listeners swing events Swing Hacks swing images Swing Look And Feels swings swings frame switch block switch case block switch case statement Sybase Sybase and SQL Server synchronization synchronized code synchronized keyword synchronized method System Properties tag lib tag library tag-lib taglibs tags TDD Technical Blogging ternary operator Test Driven Development test scjp Testing the context the session the volatile keyword thread thread class thread deadlocks thread interaction thread interruption thread life cycle thread lifecycle thread lock scope thread locks thread notify thread priorities thread race conditions race conditions in threads thread sleep thread states thread stoppage thread stopping thread synchronization thread syncing thread yield Threads threads in java threads interview questions threads life cycle threads questions tibco tightly coupled tips tips and tricks tips.FXML tokenizing Tomcat Tools toString transitions treemap treeset tricks Tricks Bag try catch try catch finally. finally block Tutorial type casting in java ui programming with java swings UML unboxing unit testing unix url rewriting use bean usebean using a arraylist using collections using colors using colours using command line arguments using different fonts using expressions using font using fonts using fonts in swings using hashmap using http session using httpsession using iterator using java beans in jsp using javabean in jsp using javabeans in jsp using javac using lists using maps using request dispatcher using scriptlets using session persistense using sets using special fonts using system properties using the jsp use bean using treeset using use bean Using Variables using volatile Using Wrappers using xml in jsp Util pack value object value object design pattern value object pattern var-args varargs Variable Arguments Variables vector vector questions vectors visibility vo pattern volatile volatile keyword volatile variables wait method waiting web app exception handling web app interview web application deployment web application exceptions web application scope web application security web component developer web component developer certification web context web context interfaces web context listeners web interview questions web security web server web servers Web services web.xml web.xml deployment webapp log weblogic website hacking website security what are threads what is a java thread what is a thread what is thread while loop windows windows 8 wrapper classes wrappers write objects to stream WSAD xml xml and jsp xml tags xslt yield()