Search This Blog

Wednesday, August 28, 2013

import sun.misc.BASE64Encoder got error in Eclipse

Problem:
while importing sun.misc.BASE64Encoder got error in Eclipse; For this two imports;
import sun.misc.BASE64Encoder;
import sun.misc.BASE64Decoder;

I got this error:
Access restriction: The type BASE64Decoder is not accessible due to restriction on required library xxx.jar

Cause:
That error is caused by your Eclipse configuration. You can reduce it to a warning. Better still, use a Base64 encoder that isn't part of a non-public API. Apache Commons has one.

Solution:
  1. Go to Window-->Preferences-->Java-->Compiler-->Error/Warnings.
  2. Select Deprecated and Restricted API. Change it to warning.
  3. Change forbidden and Discouraged Reference and change it to warning. (or as your need.)

Thursday, August 22, 2013

JPQL/Custom data retrieve from JPQL SELECT Statment

To retrieve specific columns from table and mapped it into new Class not the JPA contains the entire Table columns, to reduce the memory allocation for the entire JPA Entity Class.
The result of this query is a list of AnimalInfo objects that have been instantiated with the new operator and initialized with the animal ID, and Type of the animals.


TABLE CREATION:

CREATE TABLE ANIMAL 
(
  ANIMAL_ID NUMBER NOT NULL 
, TYPE VARCHAR2(45 BYTE) 
, TOTAL_NO NUMBER 
, CATEGORY_ID NUMBER 
, CONSTRAINT ANIMAL_PK PRIMARY KEY 
  (
    ANIMAL_ID 
  )
   ENABLE
);

SEQUENCES AND TRIGGERS CREATION:

CREATE SEQUENCE ANIMAL_SEQ NOCACHE;

create or replace TRIGGER ANIMAL_TRG 
BEFORE INSERT ON ANIMAL 
FOR EACH ROW 
BEGIN
    IF :NEW.ANIMAL_ID IS NULL THEN
      SELECT ANIMAL_SEQ.NEXTVAL INTO :NEW.ANIMAL_ID FROM DUAL;
    END IF;
END;

INSERT TEST DATA:

REM INSERTING into ANIMAL
Insert into ANIMAL (ANIMAL_ID,TYPE,TOTAL_NO,CATEGORY_ID) values (1,'Elephant',4,1);
Insert into ANIMAL (ANIMAL_ID,TYPE,TOTAL_NO,CATEGORY_ID) values (2,'Turtle',33,3);
Insert into ANIMAL (ANIMAL_ID,TYPE,TOTAL_NO,CATEGORY_ID) values (3,'Snake',3,3);
Insert into ANIMAL (ANIMAL_ID,TYPE,TOTAL_NO,CATEGORY_ID) values (4,'Pelican',6,3);
Insert into ANIMAL (ANIMAL_ID,TYPE,TOTAL_NO,CATEGORY_ID) values (5,'Lion',2,1);
Insert into ANIMAL (ANIMAL_ID,TYPE,TOTAL_NO,CATEGORY_ID) values (6,'Zebra',4,1);
Insert into ANIMAL (ANIMAL_ID,TYPE,TOTAL_NO,CATEGORY_ID) values (7,'Owl',2,2);

CLASS CREATION:


Animal JPA Entity Class
@Entity
@Table(name = "ANIMAL")
public class Animal implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @Column(name = "ANIMAL_ID")
    private Integer animalId;
    @Column(name = "TYPE")
    private String type;
    @Column(name = "TOTAL_NO")
    private Integer totalNo;
    @Column(name = "CATEGORY_ID")
    private Integer categoryId;
    //generate getters, setters, toString(), hashCode(),equals()
}

Custom AnimalInfo Class
public class AnimalInfo {

    private Integer animalId;
    private String type;
    private Integer totalNo;

    public AnimalInfo() {
    }

    public AnimalInfo(Integer animalId, String type) {
        this.animalId = animalId;
        this.type = type;
    }

    public AnimalInfo(Integer animalId, String type, Integer totalNo) {
        this.animalId = animalId;
        this.type = type;
        this.totalNo = totalNo;
    }
    //generate getters, setters, toString(), hashCode(),equals()
}

JUNIT TEST CASE:

public class InheritanceJUnit {
    
    static EntityManagerFactory emf;
    static EntityManager em;
    
    @BeforeClass
    public static void initEntityManager() throws Exception {
        emf = Persistence.createEntityManagerFactory("JavaApplicationJPAPU");
        em = emf.createEntityManager();
    }
    
    @AfterClass
    public static void closeEntityManager() throws Exception {
        if (em != null) {
            em.close();
        }
        if (emf != null) {
            emf.close();
        }
    }

@Test
    @Ignore
    public void testTypedQueryReturnInCustomClass() {
        
        TypedQuery typedQuery;
        typedQuery = em.createQuery("select NEW com.jpa.entity.info.AnimalInfo( a.animalId,a.type) from Animal a", AnimalInfo.class);
        List animalInfoList = typedQuery.getResultList();
        for (AnimalInfo animalInfo : animalInfoList) {
            assertNotNull(animalInfo);
            System.out.println(animalInfo);
        }
        
    }
}    

Wednesday, August 21, 2013

JPA @SecondaryTables

Up to now, I have assumed that an entity gets mapped to a single table, also known as a  primary table. But sometimes when you have an existing data model, you need to spread the data across multiple tables, or secondary tables. To do this, you need to use the annotation @SecondaryTable to associate a secondary table to an entity or @SecondaryTables (with an “s”) for several secondary tables. You can distribute the data of an entity across columns in both the primary table and the secondary tables simply by defining the secondary tables with anno-tations and then specifying for each attribute which table it is in (with the @Column annotation, which I’ll describe in the “Attributes” section in more detail).

Example below shows an Address entity mapping its attributes in one primary table and two secondary tables.




TABLE CREATION:


T_ADDRESS Table
CREATE TABLE T_ADDRESS 
(
  ID NUMBER NOT NULL 
, STREET1 VARCHAR2(245) 
, STREET2 VARCHAR2(245) 
, CONSTRAINT T_ADDRESS_PK PRIMARY KEY 
  (
    ID 
  )
  ENABLE 
);

T_CITY Table
CREATE TABLE T_CITY 
(
  ID NUMBER NOT NULL 
, CITY VARCHAR2(45) 
, STATE VARCHAR2(50) 
, ZIPCODE VARCHAR2(10) 
, CONSTRAINT T_CITY_PK PRIMARY KEY 
  (
    ID 
  )
  ENABLE 
);

T_COUNTRY Table
CREATE TABLE T_COUNTRY 
(
  ID NUMBER NOT NULL 
, COUNTRY VARCHAR2(50) 
, CONSTRAINT T_COUNTRY_PK PRIMARY KEY 
  (
    ID 
  )
  ENABLE 
);

SEQUENCES AND TRIGGERS CREATION:

CREATE SEQUENCE T_ADDRESS_SEQ;

CREATE TRIGGER T_ADDRESS_TRG 
BEFORE INSERT ON T_ADDRESS 
FOR EACH ROW 
BEGIN
    IF :NEW.ID IS NULL THEN
      SELECT T_ADDRESS_SEQ.NEXTVAL INTO :NEW.ID FROM DUAL;
    END IF;
END;
/

CONSTRAINT:


T_CITY Table
ALTER TABLE T_CITY
ADD CONSTRAINT T_CITY_FK FOREIGN KEY
(
  ID 
)
REFERENCES T_ADDRESS
(
  ID 
)
ENABLE;

T_COUNTRY Table
ALTER TABLE T_COUNTRY
ADD CONSTRAINT T_COUNTRY_FK FOREIGN KEY
(
  ID 
)
REFERENCES T_ADDRESS
(
  ID 
)
ENABLE;

INSERT TEST DATA:


T_ADDRESS Table
REM INSERTING into T_ADDRESS
Insert into T_ADDRESS (ID,STREET1,STREET2) values (1,'STREET_1 1','STREET_2 1');
Insert into T_ADDRESS (ID,STREET1,STREET2) values (2,'STREET_1 2','STREET_2 2');
Insert into T_ADDRESS (ID,STREET1,STREET2) values (3,'STREET_1 3','STREET_2 3');

T_CITY Table
REM INSERTING into T_CITY
Insert into T_CITY (ID,CITY,STATE,ZIPCODE) values (1,'CITY 1','STATE 1','111');
Insert into T_CITY (ID,CITY,STATE,ZIPCODE) values (2,'CITY 2','STATE 2','222');
Insert into T_CITY (ID,CITY,STATE,ZIPCODE) values (3,'CITY 3','STATE 3','333');

T_COUNTRY Table
REM INSERTING into T_COUNTRY
Insert into T_COUNTRY (ID,COUNTRY) values (1,'COUNTRY 1');
Insert into T_COUNTRY (ID,COUNTRY) values (2,'COUNTRY 2');
Insert into T_COUNTRY (ID,COUNTRY) values (3,'COUNTRY 3');

CLASS CREATION:


TAddress Class
@Entity
@Table(name = "T_ADDRESS")
@SecondaryTables(
        {
    @SecondaryTable(name = "T_COUNTRY"),
    @SecondaryTable(name = "T_CITY")
})
public class TAddress implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @Column(name = "ID")
    private Integer id;
    @Column(name = "STREET1")
    private String street1;
    @Column(name = "STREET2")
    private String street2;

    @Column(table = "T_COUNTRY", name = "COUNTRY")
    private String country;
    
    @Column(table = "T_CITY", name = "CITY")
    private String city;
    @Column(table = "T_CITY", name = "STATE")
    private String state;
    @Column(table = "T_CITY", name = "ZIPCODE")
    private String zipcode;
    
    //generate getters, setters, toString(), hashCode(),equals()
}

JUNIT TEST CASE:

public class InheritanceJUnit {
    
    static EntityManagerFactory emf;
    static EntityManager em;
    static EntityTransaction trx;
    
    @BeforeClass
    public static void initEntityManager() throws Exception {
        emf = Persistence.createEntityManagerFactory("JavaApplicationJPAPU");
        em = emf.createEntityManager();
        trx = em.getTransaction();
    }
    
    @AfterClass
    public static void closeEntityManager() throws Exception {
        if (em != null) {
            em.close();
        }
        if (emf != null) {
            emf.close();
        }
    }
    
    @Before
    public void initTransaction() throws Exception {
        trx.begin();
    }
    
    @After
    public void endTransaction() throws Exception {
        if (!trx.getRollbackOnly()) {
            trx.commit();
        }
    }

    @Test
    @Ignore
    public void testSecondaryTableInsert() {
        
        TAddress tAddress = new TAddress();
        tAddress.setId(10);
        tAddress.setStreet1("Street 1 10");
        tAddress.setStreet2("Street 2 10");
        
        tAddress.setCountry("Country 1 10");
        
        tAddress.setCity("City 10");
        tAddress.setState("State 10");
        tAddress.setZipcode("1010");
        assertNotNull(tAddress);
        em.persist(tAddress);
        System.out.println("TAddress : " + tAddress);
        
        TAddress tAddress2 = new TAddress();
        tAddress2.setId(11);
        tAddress2.setStreet1("Street 1 11");
        tAddress2.setStreet2("Street 2 11");
        
        tAddress2.setCountry("Country 1 11");
        
        
        assertNotNull(tAddress2);
        em.persist(tAddress2);
        System.out.println("TAddress2 : " + tAddress2);
        
    }

    @Test
    @Ignore
    public void testSecondaryTableSelect() {
        
        TAddress tAddress = em.find(TAddress.class, 10);
        assertNotNull(tAddress);
        
        System.out.println("TAddress : " + tAddress);
        
    }
        
    @Test
    @Ignore
    public void testSecondaryTableUpdate() {
        
        TAddress tAddress = em.find(TAddress.class, 10);
        assertNotNull(tAddress);

        tAddress.setStreet1("Street 1 10 edited");
        tAddress.setStreet2("Street 2 10 edited");
        
        tAddress.setCountry("Country 1 10 edited");
        
        tAddress.setCity("City 10 edited");
        tAddress.setState(null);
        tAddress.setZipcode("1010");
        em.merge(tAddress);
        System.out.println("TAddress : " + tAddress);
        
        TAddress tAddress2 = em.find(TAddress.class, 11);
        assertNotNull(tAddress2);
        
        tAddress2.setStreet1("Street 1 11 edited");
        tAddress2.setStreet2("");
        
        tAddress2.setCountry("Country 1 11 edited");
        
        tAddress2.setCity("City 10 edited");
        tAddress2.setState("State 10 edited");
        tAddress2.setZipcode(null);
        
        em.merge(tAddress2);
        System.out.println("TAddress2 : " + tAddress2);
    }
    
    @Test
    @Ignore
    public void testSecondaryTableDelete() {
        
        TAddress tAddress = em.find(TAddress.class, 10);
        assertNotNull(tAddress);
        
        em.detach(tAddress);
        System.out.println("TAddress : " + tAddress);
        
        TAddress tAddress2 = em.find(TAddress.class, 11);
        assertNotNull(tAddress2);
        
        em.detach(tAddress2);
        System.out.println("TAddress2 : " + tAddress2);
        
    }
}

Monday, August 19, 2013

Java Persistence/Embeddables

An embeddable object can be shared between multiple classes. Consider a Address object, that both a Customer and an Orders contain. Both Customer  and Orders have their own tables.


TABLE CREATION:


ORDERS Table
CREATE TABLE ORDERS 
(
  ID NUMBER NOT NULL 
, ORDER_DATE Date
, BENF_NAME VARCHAR2(20) 
, STREET1 VARCHAR2(255) 
, STREET2 VARCHAR2(225) 
, ZIPCODE VARCHAR2(6) 
, STATE VARCHAR2(20) 
, COUNTRY VARCHAR2(20) 
, CITY VARCHAR2(50) 
, CONSTRAINT ORDERS_PK PRIMARY KEY 
  (
    ID 
  )
  ENABLE 
);

CUSTOMER Table
CREATE TABLE CUSTOMER 
(
  ID NUMBER NOT NULL 
, FIRST_NAME VARCHAR2(20) 
, LAST_NAME VARCHAR2(45) 
, PHONE_NUMBER VARCHAR2(15) 
, EMAIL VARCHAR2(50) 
, STREET1 VARCHAR2(255) 
, STREET2 VARCHAR2(255) 
, ZIPCODE VARCHAR2(6) 
, STATE VARCHAR2(20) 
, COUNTRY VARCHAR2(50) 
, CITY VARCHAR2(50) 
, CONSTRAINT CUSTOMER_PK PRIMARY KEY 
  (
    ID 
  )
  ENABLE 
);

SEQUENCES AND TRIGGERS CREATION:


ORDERS Table
CREATE SEQUENCE ORDERS_SEQ NOCACHE;

CREATE TRIGGER ORDERS_TRG 
BEFORE INSERT ON ORDERS 
FOR EACH ROW 
BEGIN
    IF :NEW.ID IS NULL THEN
      SELECT ORDERS_SEQ.NEXTVAL INTO :NEW.ID FROM DUAL;
    END IF;
END;
/

CUSTOMER Table
CREATE SEQUENCE CUSTOMER_SEQ NOCACHE;

CREATE TRIGGER CUSTOMER_TRG 
BEFORE INSERT ON CUSTOMER 
FOR EACH ROW 
BEGIN
    IF :NEW.ID IS NULL THEN
      SELECT CUSTOMER_SEQ.NEXTVAL INTO :NEW.ID FROM DUAL;
    END IF;
END;
/

INSERT TEST DATA:


ORDERS Table
REM INSERTING into ORDERS
Insert into ORDERS (ID,ORDER_DATE,BENF_NAME,STREET1,STREET2,ZIPCADE,STATE,COUNTRY,CITY) values (1,to_timestamp('17-AUG-13','DD-MON-RR HH.MI.SSXFF AM'),'benf 1','street 1','street 2','11','state 11','country 11','city 11');
Insert into ORDERS (ID,ORDER_DATE,BENF_NAME,STREET1,STREET2,ZIPCADE,STATE,COUNTRY,CITY) values (2,to_timestamp('18-AUG-13','DD-MON-RR HH.MI.SSXFF AM'),'benf 2','street 1 -2','street 2 -2','22','state 22','country 22','city 22');

CUSTOMER Table
REM INSERTING into CUSTOMER
Insert into CUSTOMER (ID,FIRST_NAME,LAST_NAME,PHONE_NUMBER,EMAIL,STREET1,STREET2,ZIPCODE,STATE,COUNTRY,CITY) values (1,'cust f name 1','cust l name 1',null,'custfname1@mail.com','cust f name 1 street 1','cust f name 1 street 2','11','state1','cust f name 1 counntry 1','cust f name 1 city 1');
Insert into CUSTOMER (ID,FIRST_NAME,LAST_NAME,PHONE_NUMBER,EMAIL,STREET1,STREET2,ZIPCODE,STATE,COUNTRY,CITY) values (2,'cust f name 2','cust 2 name',null,'custfname2@mail.com','cust f name 2 street 1','cust f name 2 street 2','22','state2','cust f name 2 counntry','cust f name 2 city ');

CLASS CREATION:


Address Class
@Embeddable
public class Address {

    @Column(name = "STREET1")
    private String street1;
    @Column(name = "STREET2")
    private String street2;
    @Column(name = "ZIPCODE")
    private String zipcode;
    @Column(name = "STATE")
    private String state;
    @Column(name = "COUNTRY")
    private String country;
    @Column(name = "CITY")
    private String city;
    //generate getters, setters, toString(), hashCode(),equals()
}


Orders Class
@Entity
@Table(name = "ORDERS")
public class Orders implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @Column(name = "ID")
    private Integer id;
    @Column(name = "ORDER_DATE")
    @Temporal(TemporalType.DATE)
    private Date orderDate;
    @Column(name = "BENF_NAME")
    private String benfName;
    @Embedded
    private Address address;
    //generate getters, setters, toString(), hashCode(),equals()
}

Customer Class
@Entity
@Table(name = "CUSTOMER")
public class Customer implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @Column(name = "ID")
    private Integer id;
    @Column(name = "FIRST_NAME")
    private String firstName;
    @Column(name = "LAST_NAME")
    private String lastName;
    @Column(name = "PHONE_NUMBER")
    private String phoneNumber;
    @Column(name = "EMAIL")
    private String email;
    @Embedded
    private Address address;
    //generate getters, setters, toString(), hashCode(),equals()
}

JUNIT TEST CASE:


public class InheritanceJUnit {

    static EntityManagerFactory emf;
    static EntityManager em;
    static EntityTransaction trx;

    @BeforeClass
    public static void initEntityManager() throws Exception {
        emf = Persistence.createEntityManagerFactory("JavaApplicationJPAPU");
        em = emf.createEntityManager();
        trx = em.getTransaction();
    }

    @AfterClass
    public static void closeEntityManager() throws Exception {
        if (em != null) {
            em.close();
        }
        if (emf != null) {
            emf.close();
        }
    }

    @Before
    public void initTransaction() throws Exception {
        trx.begin();
    }

    @After
    public void endTransaction() throws Exception {
        if (!trx.getRollbackOnly()) {
            trx.commit();
        }
    }
    @Test
    @Ignore
    public void testEmbeddableStrategyInsert() {

        Address address = new Address();
        address.setCity("Cust City");
        address.setCountry("Cust Country");
        address.setState("Cust State");
        address.setStreet1("Cust Street1");
        address.setStreet2("Cust Street2");
        address.setZipcode("Zcode");

        Customer customer = new Customer();
        customer.setId(10);
        customer.setFirstName("Cust FirstName");
        customer.setLastName("Cust LastName");
        customer.setPhoneNumber("Cust Phone");
        customer.setEmail("CustMail@host.com");
        customer.setAddress(address);
        em.persist(customer);
        System.out.println("Customer : " + customer);

        Orders orders = new Orders();
        orders.setId(10);
        orders.setBenfName("Benf Name");
        orders.setOrderDate(new Date());
        //orders.setAddress(null);
        em.persist(orders);
        System.out.println("Orders : " + orders);
    }

    @Test
    @Ignore
    public void testEmbeddableStrategySelect() {

        Customer customer = em.find(Customer.class, 10);
        assertNotNull(customer);
        System.out.println("Customer : " + customer);

        Orders orders = em.find(Orders.class, 10);
        assertNotNull(orders);
        System.out.println("Orders : " + orders);

    }

    @Test
    @Ignore
    public void testEmbeddableStrategyUpdate() {
        Address address = new Address();
        address.setCity("Cust City1");
        address.setCountry("Cust Country");
        address.setState("Cust State");
        address.setStreet1("Cust Street1");
        address.setZipcode("Zcode");

        Customer customer = em.find(Customer.class, 10);
        assertNotNull(customer);
        customer.setEmail("new Mail");
        customer.setAddress(null);
        em.merge(customer);
        System.out.println("Customer : " + customer);

        Orders orders = em.find(Orders.class, 10);
        assertNotNull(orders);
        orders.setBenfName("New Benf Name");
        orders.setAddress(address);
        em.merge(orders);
        System.out.println("Orders : " + orders);


    }

    @Test
    @Ignore
    public void testEmbeddableStrategyDelete() {

        Customer customer = em.find(Customer.class, 10);
        assertNotNull(customer);
        em.remove(customer);

        Orders orders = em.find(Orders.class, 10);
        assertNotNull(orders);
        em.remove(orders);

    }
}

Inheritance Mapping Stategies in JPA

In JPA, an entity class may inherit from another entity class its behavior and state. The behavior and state become shared between entity classes enabling the inheritance of existing mappings. There are several types of inheritance which are  Joined Strategy, Single-Table Strategy, Table-per-Concrete-Class Strategy. Two of these types; Single table inheritance and Joined table inheritance have many similarities:

When it comes to mapping inheritance, JPA supports three different strategies. When an entity hierarchy exists, it always has an entity as its root. The root entity class can define the inheritance strategy by using the @Inheritance annotation. If it doesn’t, the default single-table-per-class strategy will be applied.

Their object model is the same.
  • They can be configured using either annotations or XML.
  • A discriminator column (a single column used for distinguishing to which class type a database row belongs) is required on the database.
  • The underlying database structure of the single table and joined table inheritance is, however, slightly different.
please refer to each type link for further discussion, example and code snippts.

Joined Strategy

In the joined table inheritance, each class shares data from the root table. In addition, each subclass defines its own table that adds its extended state. The following example shows two child tables, EXTERNAT_VET and IN_HOUSE_VET, as well as parent table VET.
Click here for mode details about Joined Strategy

Single-Table Strategy

In the single table inheritance, the entire class hierarchy is represented by a single table. As the following example shows, the Three classes map to the same VET_ALL table.
Click here for mode details about Single Table Strategy


Table-per-Concrete-Class Strategy

In the table-per-concrete class, each Table contains the shared data as its specific data. In addition, each subclass defines its own table that adds its extended state. The following example shows two child tables, VET_IN and VET_OUT.
Click here for mode details about Table-per-Concrete Class Strategy

JPA Table-Per-Concrete Strategy

In the table-per-class (or table-per-concrete-class) strategy, each entity is mapped to its own dedicated table like the joined strategy. The difference is that all attributes of the root entity will also be mapped to columns of the child entity table. From a database point of view, this strategy de-normalizes the model and causes all root entity attributes to be redefined in the tables of all leaf entities that inherit from it. With the table-per-class strategy, there is no shared table, no shared columns, and no discriminator column. The only requirement is that all tables must share a common primary key that matches across all tables in the hierarchy.

In the table-per-concrete class, each Table contains the shared data as its specific data. In addition, each subclass defines its own table that adds its extended state. The following example shows two child tables, VET_IN and VET_OUT

TABLE CREATION:


VET_IN Table
CREATE TABLE VET_IN 
(
  VET_ID NUMBER NOT NULL 
, NAME VARCHAR2(45 BYTE) 
, QUALIFICATION VARCHAR2(45 BYTE) 
, SALARY NUMBER 
, CONSTRAINT VET_IN_PK PRIMARY KEY 
  (
    VET_ID 
  )
   ENABLE
);

VET_OUT Table
CREATE TABLE VET_OUT 
(
  VET_ID NUMBER NOT NULL 
, NAME VARCHAR2(45 BYTE) 
, COUNTRY VARCHAR2(45 BYTE) 
, VISITING_FEES NUMBER 
, QUALIFICATION VARCHAR2(45 BYTE) 
, CONSTRAINT VET_OUT_PK PRIMARY KEY 
  (
    VET_ID 
  )
   ENABLE
);

SEQUENCES AND TRIGGERS CREATION:


Table VET_IN Sequence and Trigger
CREATE SEQUENCE VET_IN_SEQ NOCACHE;

create or replace TRIGGER VET_IN_TRG 
BEFORE INSERT ON VET_IN 
FOR EACH ROW 
BEGIN
    IF :NEW.VET_ID IS NULL THEN
      SELECT VET_IN_SEQ.NEXTVAL INTO :NEW.VET_ID FROM DUAL;
    END IF;
END; 

Table VET_OUT Sequence and Trigger
CREATE SEQUENCE VET_OUT_SEQ NOCACHE;

create or replace TRIGGER VET_OUT_TRG 
BEFORE INSERT ON VET_OUT
FOR EACH ROW 
BEGIN
    IF :NEW.VET_ID IS NULL THEN
      SELECT VET_OUT_SEQ.NEXTVAL INTO :NEW.VET_ID FROM DUAL;
    END IF;
end; 

INSERT TEST DATA:


inserting into VET_IN
REM INSERTING into VET_IN
Insert into VET_IN (VET_ID,NAME,QUALIFICATION,SALARY) values (1,'Ashitraj more','mvsc',35000);
Insert into VET_IN (VET_ID,NAME,QUALIFICATION,SALARY) values (2,'Raj','bvsc',30000);
Insert into VET_IN (VET_ID,NAME,QUALIFICATION,SALARY) values (4,'Rakesh','mvsc',29000);

inserting into VET_OUT
REM INSERTING into VET_OUT
Insert into VET_OUT (VET_ID,NAME,COUNTRY,VISITING_FEES,QUALIFICATION) values (3,'Steven','UK',500,'mvsc');
Insert into VET_OUT (VET_ID,NAME,COUNTRY,VISITING_FEES,QUALIFICATION) values (5,'John','US',450,'mvsc');

CLASS CREATION:


ConcreteVet Class
@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public abstract class ConcreteVet implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @Id
    @Basic(optional = false)
    @Column(name = "VET_ID")
    private Integer vetId;
    @Column(name = "NAME")
    private String name;
    @Column(name = "QUALIFICATION")
    private String qualification;
    //generate getters, setters, toString(), hashCode(),equals()
}

ConcreteInVet Class
@Entity
@Table(name = "VET_IN")
public class ConcreteInVet extends ConcreteVet{
 
    @Column(name = "SALARY")
    private Integer salary;
    //generate getters, setters, toString(), hashCode(),equals()
}

ConcreteOutVet Class
@Entity
@Table(name = "VET_OUT")
public class ConcreteOutVet extends ConcreteVet{
    
    @Column(name = "COUNTRY")
    private String country;
    @Column(name = "VISITING_FEES")
    private Integer visitingFees;
    //generate getters, setters, toString(), hashCode(),equals()

}

JUNIT TEST CASE:

public class InheritanceJUnit {

    static EntityManagerFactory emf;
    static EntityManager em;
    static EntityTransaction trx;

    @BeforeClass
    public static void initEntityManager() throws Exception {
        emf = Persistence.createEntityManagerFactory("JavaApplicationJPAPU");
        em = emf.createEntityManager();
        trx = em.getTransaction();
    }

    @AfterClass
    public static void closeEntityManager() throws Exception {
        em.close();
        emf.close();
    }

    @Before
    public void initTransaction() throws Exception {
        trx.begin();
    }

    @After
    public void endTransaction() throws Exception {
        if (!trx.getRollbackOnly()) {
            trx.commit();
        }
    }
    @Test
    @Ignore
    public void testConcreteStrategyInsert() {

        ConcreteInVet inVet = new ConcreteInVet();
        inVet.setName("Invet name 10");
        inVet.setQualification("invet Qualification 10");
        inVet.setSalary(1010);
        inVet.setVetId(10);
        em.persist(inVet);
        System.out.println("InHouseVet inserted");

        ConcreteOutVet extVet = new ConcreteOutVet();
        extVet.setName("extVet name 11");
        extVet.setQualification("extVet Qualification 11");
        extVet.setCountry("xy");
        extVet.setVisitingFees(1111);
        extVet.setVetId(11);
        em.persist(extVet);
        System.out.println("ExternatVet inserted");
    }

    @Test
    @Ignore
    public void testConcreteStrategySelect() {

        ConcreteVet vet = em.find(ConcreteVet.class, 10);
        assertNotNull(vet);

        if (vet instanceof ConcreteInVet) {
            ConcreteInVet concreteInVet = (ConcreteInVet) vet;
            System.out.println(concreteInVet);
        } else if (vet instanceof ConcreteOutVet) {
            ConcreteOutVet concreteOutVet = (ConcreteOutVet) vet;
            System.out.println(concreteOutVet);
        } else {
            System.out.println("ERROR in Type");
        }

        ConcreteVet vet2 = em.find(ConcreteVet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof ConcreteInVet) {
            ConcreteInVet concreteInVet = (ConcreteInVet) vet2;
            System.out.println(concreteInVet);
        } else if (vet2 instanceof ConcreteOutVet) {
            ConcreteOutVet concreteOutVet = (ConcreteOutVet) vet2;
            System.out.println(concreteOutVet);
        } else {
            System.out.println("ERROR in Type");
        }

    }

    @Test
    @Ignore
    public void testConcreteStrategyUpdate() {

        ConcreteVet vet = em.find(ConcreteVet.class, 10);
        assertNotNull(vet);

        if (vet instanceof ConcreteOutVet) {
            ConcreteOutVet concreteOutVet = (ConcreteOutVet) vet;
            concreteOutVet.setName("extVet Qualification 10 updated");
            concreteOutVet.setVisitingFees(101010);
            em.merge(concreteOutVet);
            System.out.println(concreteOutVet);
        } else if (vet instanceof ConcreteInVet) {
            ConcreteInVet concreteInVet = (ConcreteInVet) vet;
            concreteInVet.setName("Invet name 10 updated");
            concreteInVet.setSalary(1111);
            em.merge(concreteInVet);
            System.out.println(concreteInVet);
        } else {
            System.out.println("ERROR in Type");
        }

        ConcreteVet vet2 = em.find(ConcreteVet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof ConcreteOutVet) {
            ConcreteOutVet concreteOutVet = (ConcreteOutVet) vet2;
            concreteOutVet.setName("extVet Qualification 11 updated");
            concreteOutVet.setVisitingFees(101010);
            em.merge(concreteOutVet);
            System.out.println(concreteOutVet);
        } else if (vet2 instanceof ConcreteInVet) {
            ConcreteInVet concreteInVet = (ConcreteInVet) vet2;
            concreteInVet.setName("extVet name 11 updated");
            concreteInVet.setSalary(1111);
            em.merge(concreteInVet);
            System.out.println(concreteInVet);
        } else {
            System.out.println("ERROR in Type");
        }


    }

    @Test
    @Ignore
    public void testConcreteStrategyDelete() {

        ConcreteVet vet = em.find(ConcreteVet.class, 10);
        assertNotNull(vet);
        em.remove(vet);
        System.out.println("InHouseVet 10 : deleteds");

        ConcreteVet vet2 = em.find(ConcreteVet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof ConcreteOutVet) {
            ConcreteOutVet concreteOutVet = (ConcreteOutVet) vet2;
            em.remove(concreteOutVet);
            System.out.println("ExternatVet 11 : deleted");
        } else if (vet2 instanceof ConcreteInVet) {
            ConcreteInVet concreteInVet = (ConcreteInVet) vet2;
            em.remove(concreteInVet);
            System.out.println("InHouseVet 11 : deleteds");
        } else {
            System.out.println("ERROR in Type");
        }
    }
}


Sunday, August 18, 2013

JPA Single Table Strategy

The default inheritance mapping strategy is the single-table strategy, in which all the entities in the hierarchy are mapped to a single table. As it is the default, you can completely omit the @Inheritance annotation on the root entity (thanks to configuration by exception).
In the single table inheritance, the entire class hierarchy is represented by a single table. As the following example shows, the Three classes map to the same VET_ALL table

TABLE CREATION:

CREATE TABLE VET_ALL 
(
  VET_ID NUMBER NOT NULL 
, NAME VARCHAR2(45 BYTE) 
, QUALIFICATION VARCHAR2(45 BYTE) 
, SALARY NUMBER 
, COUNTRY VARCHAR2(45 BYTE) 
, VISITING_FEES NUMBER 
, VET_TYPE VARCHAR2(10 BYTE) 
, CONSTRAINT VET_ALL_PK PRIMARY KEY 
  (
    VET_ID 
  )
   ENABLE
);

SEQUENCES AND TRIGGERS CREATION:

CREATE SEQUENCE VET_ALL_SEQ NOCACHE;

create or replace TRIGGER VET_ALL_TRG 
BEFORE INSERT ON VET_ALL 
FOR EACH ROW 
BEGIN
    IF :NEW.VET_ID IS NULL THEN
      SELECT VET_ALL_SEQ.NEXTVAL INTO :NEW.VET_ID FROM DUAL;
    END IF;
END; 


INSERT TEST DATA:

REM INSERTING into VET_ALL
Insert into VET_ALL (VET_ID,NAME,QUALIFICATION,SALARY,COUNTRY,VISITING_FEES,VET_TYPE) values (1,'Ashitraj more','mvsc',35000,null,null,'IN_VET9');
Insert into VET_ALL (VET_ID,NAME,QUALIFICATION,SALARY,COUNTRY,VISITING_FEES,VET_TYPE) values (2,'Raj','bvsc',30000,null,null,'IN_VET');
Insert into VET_ALL (VET_ID,NAME,QUALIFICATION,SALARY,COUNTRY,VISITING_FEES,VET_TYPE) values (4,'Rakesh','mvsc',29000,null,null,'IN_VET');
Insert into VET_ALL (VET_ID,NAME,QUALIFICATION,SALARY,COUNTRY,VISITING_FEES,VET_TYPE) values (5,'John','mvsc',null,'US',450,'EXT_VET');
Insert into VET_ALL (VET_ID,NAME,QUALIFICATION,SALARY,COUNTRY,VISITING_FEES,VET_TYPE) values (3,'Steven','mvsc',null,'UK',500,'EXT_VET');

CLASS CREATION:


SingleVet Class
@Entity
@Table(name = "VET_ALL")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "VET_TYPE")
public abstract class SingleVet implements Serializable {
    
private static final long serialVersionUID = 1L;
    
@Id
@Basic(optional = false)
@Column(name = "VET_ID")
private Integer vetId;
@Column(name = "NAME")
private String name;
@Column(name = "QUALIFICATION")
private String qualification;
//generate getters, setters, toString(), hashCode(),equals()
}

SingleOutVet Class
@Entity
@DiscriminatorValue("EXT_VET")
public class SingleOutVet extends SingleVet{
    
@Column(name = "COUNTRY")
private String country;
@Column(name = "VISITING_FEES")
private Integer visitingFees;
//generate getters, setters, toString(), hashCode(),equals()
}

SingleInVet Class
@Entity
@DiscriminatorValue("IN_VET")
public class SingleInVet extends SingleVet{
 
@Column(name = "SALARY")
private Integer salary;
//generate getters, setters, toString(), hashCode(),equals()
}

JUNIT TEST CASE:

public class InheritanceJUnit {

    static EntityManagerFactory emf;
    static EntityManager em;
    static EntityTransaction trx;

    @BeforeClass
    public static void initEntityManager() throws Exception {
        emf = Persistence.createEntityManagerFactory("JavaApplicationJPAPU");
        em = emf.createEntityManager();
        trx = em.getTransaction();
    }

    @AfterClass
    public static void closeEntityManager() throws Exception {
        em.close();
        emf.close();
    }

    @Before
    public void initTransaction() throws Exception {
        trx.begin();
    }

    @After
    public void endTransaction() throws Exception {
        if (!trx.getRollbackOnly()) {
            trx.commit();
        }
    }
    
    @Test
    @Ignore
    public void testSingleStrategyInsert() {

        SingleInVet inVet = new SingleInVet();
        inVet.setName("Invet name 10");
        inVet.setQualification("invet Qualification 10");
        inVet.setSalary(1010);
        inVet.setVetId(10);
        em.persist(inVet);
        System.out.println("InHouseVet inserted");

        SingleOutVet extVet = new SingleOutVet();
        extVet.setName("extVet name 11");
        extVet.setQualification("extVet Qualification 11");
        extVet.setCountry("xy");
        extVet.setVisitingFees(1111);
        extVet.setVetId(11);
        em.persist(extVet);
        System.out.println("ExternatVet inserted");
    }

    @Test
    @Ignore
    public void testSingleStrategySelect() {
        SingleVet vet = em.find(SingleVet.class, 10);
        assertNotNull(vet);

        if (vet instanceof SingleOutVet) {
            SingleOutVet singleOutVet = (SingleOutVet) vet;
            System.out.println(singleOutVet);
        } else if (vet instanceof SingleInVet) {
            SingleInVet singleInVet = (SingleInVet) vet;
            System.out.println(singleInVet);
        } else {
            System.out.println("ERROR in Type");
        }

        SingleVet vet2 = em.find(SingleVet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof SingleOutVet) {
            SingleOutVet singleOutVet = (SingleOutVet) vet2;
            System.out.println(singleOutVet);
        } else if (vet2 instanceof SingleInVet) {
            SingleInVet singleInVet = (SingleInVet) vet2;
            System.out.println(singleInVet);
        } else {
            System.out.println("ERROR in Type");
        }

    }

    @Test
    @Ignore
    public void testSingleStrategyUpdate() {

        SingleVet vet = em.find(SingleVet.class, 10);
        assertNotNull(vet);

        if (vet instanceof SingleOutVet) {
            SingleOutVet SingleOutVet = (SingleOutVet) vet;
            SingleOutVet.setName("extVet Qualification 11 updated");
            SingleOutVet.setVisitingFees(101010);
            em.merge(SingleOutVet);
            System.out.println(SingleOutVet);
        } else if (vet instanceof SingleInVet) {
            SingleInVet SingleInVet = (SingleInVet) vet;
            SingleInVet.setName("Invet name 10 updated");
            SingleInVet.setSalary(1010);
            em.merge(SingleInVet);
            System.out.println(SingleInVet);
        } else {
            System.out.println("ERROR in Type");
        }

        SingleVet vet2 = em.find(SingleVet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof SingleOutVet) {
            SingleOutVet SingleOutVet = (SingleOutVet) vet2;
            SingleOutVet.setName("extVet Qualification 11 updated");
            SingleOutVet.setVisitingFees(111111);
            em.merge(SingleOutVet);
            System.out.println(SingleOutVet);
        } else if (vet2 instanceof SingleInVet) {
            SingleInVet SingleInVet = (SingleInVet) vet2;
            SingleInVet.setName("Invet name 11 updated");
            SingleInVet.setSalary(1111);
            em.merge(SingleInVet);
            System.out.println(SingleInVet);
        } else {
            System.out.println("ERROR in Type");
        }
    }

    @Test
    @Ignore
    public void testSingleStrategyDelete() {

        SingleVet vet = em.find(SingleVet.class, 10);
        assertNotNull(vet);
        em.remove(vet);
        System.out.println("InHouseVet 10 : deleteds");

        SingleVet vet2 = em.find(SingleVet.class, 11);
        assertNotNull(vet2);
        if (vet2 instanceof SingleOutVet) {
            SingleOutVet singleOutVet = (SingleOutVet) vet2;
            em.remove(singleOutVet);
            System.out.println("ExternatVet 11 : deleted");
        } else if (vet2 instanceof SingleInVet) {
            SingleInVet singleInVet = (SingleInVet) vet2;
            em.remove(singleInVet);
            System.out.println("InHouseVet 11 : deleteds");
        } else {
            System.out.println("ERROR in Type");
        }
    }

}

JPA Joined Strategy

In the joined strategy, each entity in the hierarchy is mapped to its own table. The root entity maps to a table that defines the primary key to be used by all tables in the hierarchy, as well as the discriminator column. Each subclass is represented by a separate table that contains its own attributes (not inherited from the root class) and a primary key that refers to the root table’s primary key. The non-root tables do not hold a discriminator column.

In the joined table inheritance, each class shares data from the root table. In addition, each subclass defines its own table that adds its extended state. The following example shows two child tables, EXTERNAT_VET and IN_HOUSE_VET, as well as parent table VET:


Table Creation:


VET table
CREATE TABLE VET 
(
  VET_ID NUMBER NOT NULL 
, NAME VARCHAR2(45 BYTE) 
, QUALIFICATION VARCHAR2(45 BYTE) 
, VET_TYPE VARCHAR2(10 BYTE) 
, CONSTRAINT VET_PK PRIMARY KEY 
  (
    VET_ID 
  )
   ENABLE
);

EXTERNAT_VET  table
CREATE TABLE EXTERNAT_VET 
(
  VET_ID NUMBER NOT NULL 
, COUNTRY VARCHAR2(45 BYTE) 
, VISITING_FEES NUMBER 
, CONSTRAINT EXTERNAT_VET_PK PRIMARY KEY 
  (
    VET_ID 
  )
  ENABLE
);

IN_HOUSE_VET table
CREATE TABLE IN_HOUSE_VET 
(
  VET_ID NUMBER NOT NULL 
, SALARY NUMBER 
, CONSTRAINT IN_HOUSE_VET_PK PRIMARY KEY 
  (
    VET_ID 
  )
  ENABLE
);

Sequences and Triggers Creation:

CREATE SEQUENCE VET_SEQ NOCACHE;

create or replace TRIGGER VET_TRG 
BEFORE INSERT ON VET 
FOR EACH ROW 
BEGIN
    IF :NEW.VET_ID IS NULL THEN
      SELECT VET_SEQ.NEXTVAL INTO :NEW.VET_ID FROM DUAL;
    END IF;
END;
/

Insert Test Data:

VET table
REM INSERTING into VET
Insert into VET (VET_ID,NAME,QUALIFICATION,VET_TYPE) values (1,'Ashitraj more','mvsc','IN_VET');
Insert into VET (VET_ID,NAME,QUALIFICATION,VET_TYPE) values (2,'Raj','bvsc','IN_VET');
Insert into VET (VET_ID,NAME,QUALIFICATION,VET_TYPE) values (3,'Steven','mvsc','EXT_VET');
Insert into VET (VET_ID,NAME,QUALIFICATION,VET_TYPE) values (4,'Rakesh','mvsc','IN_VET');
Insert into VET (VET_ID,NAME,QUALIFICATION,VET_TYPE) values (5,'John','mvsc','EXT_VET');
Insert into VET (VET_ID,NAME,QUALIFICATION,VET_TYPE) values (6,'vet','vet qualification','VET');

EXTERNAT_VET  table
REM INSERTING into EXTERNAT_VET
Insert into EXTERNAT_VET (VET_ID,COUNTRY,VISITING_FEES) values (3,'UK',500);
Insert into EXTERNAT_VET (VET_ID,COUNTRY,VISITING_FEES) values (5,'US',450);

IN_HOUSE_VET table
REM INSERTING into IN_HOUSE_VET
Insert into IN_HOUSE_VET (VET_ID,SALARY) values (1,35000);
Insert into IN_HOUSE_VET (VET_ID,SALARY) values (2,30000);
Insert into IN_HOUSE_VET (VET_ID,SALARY) values (3,29000);

Class Creation:


VET Class
@Entity
@Table(name = "VET")
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name = "VET_TYPE")
@DiscriminatorValue("VET")
public class Vet implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @Id
    @Basic(optional = false)
    @Column(name = "VET_ID")
    private Integer vetId;
    @Column(name = "NAME")
    private String name;
    @Column(name = "QUALIFICATION")
    private String qualification;
    //generate getters, setters, toString(), hashCode(),equals()
}

EXTERNAT_VET Class
@Entity
@Table(name = "EXTERNAT_VET")
@DiscriminatorValue("EXT_VIT")
public class ExternatVet extends Vet{
    
    @Column(name = "COUNTRY")
    private String country;
    @Column(name = "VISITING_FEES")
    private Integer visitingFees;
    //generate getters, setters, toString(), hashCode(),equals()
}

IN_HOUSE_VET Class
@Entity
@Table(name = "IN_HOUSE_VET")
@DiscriminatorValue("IN_VET")
public class InHouseVet extends Vet{
 
    @Column(name = "SALARY")
    private Integer salary;
    //generate getters, setters, toString(), hashCode(),equals()
}

JUnit Test Case:

public class InheritanceJUnit {

    static EntityManagerFactory emf;
    static EntityManager em;
    static EntityTransaction trx;

    @BeforeClass
    public static void initEntityManager() throws Exception {
        emf = Persistence.createEntityManagerFactory("JavaApplicationJPAPU");
        em = emf.createEntityManager();
        trx = em.getTransaction();
    }

    @AfterClass
    public static void closeEntityManager() throws Exception {
        em.close();
        emf.close();
    }

    @Before
    public void initTransaction() throws Exception {
        trx.begin();
    }

    @After
    public void endTransaction() throws Exception {
        if (!trx.getRollbackOnly()) {
            trx.commit();
        }
    }

    @Test
    @Ignore
    public void testJoinedStrategyInsert() {

        InHouseVet inVet = new InHouseVet();
        inVet.setName("Invet name 10");
        inVet.setQualification("invet Qualification 10");
        inVet.setSalary(1010);
        inVet.setVetId(10);
        em.persist(inVet);
        System.out.println("InHouseVet inserted");

        ExternatVet extVet = new ExternatVet();
        extVet.setName("extVet name 11");
        extVet.setQualification("extVet Qualification 11");
        extVet.setCountry("xy");
        extVet.setVisitingFees(1111);
        extVet.setVetId(11);
        em.persist(extVet);
        System.out.println("ExternatVet inserted");
    }

    @Test
    @Ignore
    public void testJoinedStrategySelect() {

        Vet vet = em.find(Vet.class, 10);
        assertNotNull(vet);

        if (vet instanceof ExternatVet) {
            ExternatVet externatVet = (ExternatVet) vet;
            System.out.println(externatVet);
        } else if (vet instanceof InHouseVet) {
            InHouseVet inHouseVet = (InHouseVet) vet;
            System.out.println(inHouseVet);
        } else {
            System.out.println("ERROR in Type");
        }

        Vet vet2 = em.find(Vet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof ExternatVet) {
            ExternatVet externatVet = (ExternatVet) vet2;
            System.out.println(externatVet);
        } else if (vet2 instanceof InHouseVet) {
            InHouseVet inHouseVet = (InHouseVet) vet2;
            System.out.println(inHouseVet);
        } else {
            System.out.println("ERROR in Type");
        }

        Vet vet = em.find(Vet.class, 6);
        assertNotNull(vet);

        if (vet instanceof ExternatVet) {
            ExternatVet externatVet = (ExternatVet) vet;
            System.out.println(externatVet);
        } else if (vet instanceof InHouseVet) {
            InHouseVet inHouseVet = (InHouseVet) vet;
            System.out.println(inHouseVet);
        } else if (vet instanceof Vet) {
            System.out.println(vet);
        } else {
            System.out.println("ERROR in Type");
        }
    }

    @Test
    @Ignore
    public void testJoinedStrategyUpdate() {

        Vet vet = em.find(Vet.class, 10);
        assertNotNull(vet);

        if (vet instanceof ExternatVet) {
            ExternatVet externatVet = (ExternatVet) vet;
            externatVet.setName("extVet Qualification 11 updated");
            externatVet.setVisitingFees(101010);
            em.merge(externatVet);
            System.out.println(externatVet);
        } else if (vet instanceof InHouseVet) {
            InHouseVet inHouseVet = (InHouseVet) vet;
            inHouseVet.setName("Invet name 10 updated");
            inHouseVet.setSalary(1010);
            em.merge(inHouseVet);
            System.out.println(inHouseVet);
        } else {
            System.out.println("ERROR in Type");
        }

        Vet vet2 = em.find(Vet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof ExternatVet) {
            ExternatVet externatVet = (ExternatVet) vet2;
            externatVet.setName("extVet Qualification 11 updated");
            externatVet.setVisitingFees(111111);
            em.merge(externatVet);
            System.out.println(externatVet);
        } else if (vet2 instanceof InHouseVet) {
            InHouseVet inHouseVet = (InHouseVet) vet2;
            inHouseVet.setName("Invet name 11 updated");
            inHouseVet.setSalary(1111);
            em.merge(inHouseVet);
            System.out.println(inHouseVet);
        } else {
            System.out.println("ERROR in Type");
        }
    }

    @Test
    @Ignore
    public void testJoinedStrategyDelete() {

        Vet vet = em.find(Vet.class, 10);
        assertNotNull(vet);
        em.remove(vet);
        System.out.println("InHouseVet 10 : deleteds");

        Vet vet2 = em.find(Vet.class, 11);
        assertNotNull(vet2);

        if (vet2 instanceof ExternatVet) {
            ExternatVet externatVet = (ExternatVet) vet2;
            em.remove(externatVet);
            System.out.println("ExternatVet 11 : deleted");
        } else if (vet2 instanceof InHouseVet) {
            InHouseVet inHouseVet = (InHouseVet) vet2;
            em.remove(inHouseVet);
            System.out.println("InHouseVet 11 : deleteds");
        } else {
            System.out.println("ERROR in Type");
        }
    }

}

Tuesday, August 13, 2013

UML Use Case Diagram

Purpose:

The purpose of use case diagram is to capture the dynamic aspect of a system. But this definition is too generic to describe the purpose. Use case diagrams are used to gather the requirements of a system including internal and external influences. These requirements are mostly design requirements. So when a system is analyzed to gather its functionalities use cases are prepared and actors are identified.

The purposes of use case diagrams can be as follows:
  • Used to gather requirements of a system.
  • Used to get an outside view of a system.
  • Identify external and internal factors influencing the system.
  • Show the interacting among the requirements are actors.
How to draw Use Case Diagram?
Use case diagrams are considered for high level requirement analysis of a system. So when the requirements of a system are analyzed the functionalities are captured in use cases. So we can say that uses cases are nothing but the system functionalities written in an organized manner. Now the second things which are relevant to the use cases are the actors. Actors can be defined as something that interacts with the system.

The actors can be human user, some internal applications or may be some external applications. So in a brief when we are planning to draw an use case diagram we should have the following items identified:
  • Functionalities to be represented as an use case
  • Actors
  • Relationships among the use cases and actors.

Use case diagrams are drawn to capture the functional requirements of a system. So after identifying the above items we have to follow the following guidelines to draw an efficient use case diagram.

The name of a use case is very important. So the name should be chosen in such a way so that it can identify the functionality performed.
  • Give a suitable name for actors.
  • Show relationships and dependencies clearly in the diagram.
  • Do not try to include all types of relationships. Because the main purpose of the diagram is to identify requirements.
  • Use note when ever required to clarify some important points.

These diagrams are used at a very high level of design. Then this high level design is refined again and again to get a complete and practical picture of the system. A well structured use case also describes the pre condition, post condition, exceptions. And these extra elements are used to make test cases when performing the testing.

The following are the places where use case diagrams are used:

  • Requirement analysis and high level design.
  • Model the context of a system.
  • Reverse engineering.
  • Forward engineering.



For example an online reservation system use case diagram had been introduced with the system boundaries separated by rectangular box, including two actors: the primary actor which is Customer can make all those use cases (Search flight use case, Make a reservation use case, Purchase a ticket use case, Check flight status use case, Cancel flight use case), other actor which is system actor Payment Process use a Validate credit card use case. This diagram show an extend relationship between Reschedule flight use case which extends Cancel flight use case and the Select seat use case which extends Purchase a ticket use case. A dependency relationship between Purchase a ticket Invoking use case include a Validate credit card Included use case

The following topics describe the relationships that you can use in use case diagrams:

Association relationships
In UML models, an association is a relationship between two classifiers, such as classes or use cases, that describes the reasons for the relationship and the rules that govern the relationship.
Generalization relationships
In UML modeling, a generalization relationship is a relationship in which one model element (the child) is based on another model element (the parent). Generalization relationships are used in class, component, deployment, and use case diagrams.
Include relationships
In UML modeling, an include relationship is a relationship in which one use case (the base use case) includes the functionality of another use case (the inclusion use case). The include relationship supports the reuse of functionality in a use case model.
Extend relationships
In UML modeling, you can use an extend relationship to specify that one use case (extension) extends the behavior of another use case (base). This type of relationship reveals details about a system or application that are typically hidden in a use case.

a good diagram i find while googling

Wednesday, August 07, 2013

UML Class Diagram

There are five key relationships between classes in a UML class diagram : dependency, aggregation, composition, inheritance and realization. These five relationships are depicted in the following diagram:
  • Dependency : class A uses class B
  • Aggregation : class A has a class B
  • Composition : class A owns a class B
  • Inheritance : class B is a Class A  (or class A is extended by class B)
  • Realization : class B realizes Class A (or class A is realized by class B)

What I hope to show here is how these relationships would manifest themselves in Java so we can better understand what these relationships mean and how/when to use each one. The above relationships are read as follows:

Dependency :
class A uses class B
Is represented when a reference to one class is passed in as a method parameter to another class. For example, an instance of class B is passed in to a method of class A:
public class A {
 
    public void doSomething(B b) {
    
    }

}

Aggregation :
class A has a class B
If class A stored the reference to class B for later use we would have a different relationship called Aggregation. A more common and more obvious example of Aggregation would be via setter injection:
public class A {
 
    private B _b;
 
    public void setB(B b) {
    _b = b; 
    }

}  

Composition :
class A owns a class B
Aggregation is the weaker form of object containment (one object contains other objects). The stronger form is called Composition. In Composition the containing object is responsible for the creation and life cycle of the contained object. Following are a few examples of Composition. First, via member initialization:
public class A {
 
    private B _b = new B();

}

Second, via constructor initialization:
public class A {
 
    private B _b;
 
    public A() {
        _b = new B();
    } // default constructor

}

Third, via lazy init:
public class A {
 
    private B _b;
 
    public B getB() {
        if (null == _b) {
            _b = new B();
        }
        return _b;
    } // getB()

}

Inheritance :
class B is a Class A  (or class A is extended by class B)
is a fairly straightforward relationship to depict in Java:
public class A {
 
    ...
 
} // class A
 
public class B extends A {
 
    ....
 
} // class B

Realization :
class B realizes Class A (or class A is realized by class B)
is also straighforward in Java and deals with implementing an interface:
public interface A {
 
    ...
 
} // interface A
 
public class B implements A {
 
    ...
 
} // class B

For more information about Association, Aggregation,and Composition visit this link.

Understanding Association, Aggregation, and Composition

In this article, we will try to understand three important concepts: association, aggregation, and composition. We will also try to understand in what kind of scenarios we need them. These three concepts have really confused a lot of developers and in this article.

For a little bit introduction on types of relationship visit this link

The UML Class diagram is used to visually describe the problem domain in terms of types of object (classes) related to each other in different ways. There are three primary inter-object relationships: association, aggregation, and composition. Using the right relationship line is important for placing implicit restrictions on the visibility and propagation of changes to the related classes, matter which play major role in reducing system complexity.

1. Association

The most abstract way to describe static relationship between classes(classifiers) is using the ‘Association’ link, which simply states that there is some kind of a link or a dependency between two classes or more.


An association defines a relationship between two or more classes. Binary associations are relationships between exactly two classes and a n-ary association is an association between three or more classes.

1.1. Weak Association

ClassA may be linked to ClassB in order to show that one of its methods includes parameter of ClassB instance, or returns instance of ClassB.


1.2. Strong Association

ClassA may also be linked to ClassB in order to show that it holds reference to ClassB instance.


2. Aggregation (Shared Association/Relation Aggregation)

Is a specialized association. It is specified by an aggregation association with a hollow diamond. A part in this type of aggregation can participate in several aggregates. In cases where there’s a part-of relationship between ClassA (whole) and ClassB (part), we can be more specific and use the aggregation link instead of the association link, taking special notice that ClassB can also be aggregated by other classes in the application.


Aggregation protects the integrity of an assembly of objects by defining a single point of control, called the aggregate, in the object that represents the assembly. Aggregation also uses the control object to decide how the assembled objects respond to changes or instructions that might affect the collection.


A part classifier can belong to more than one aggregate classifier and it can exist independently of the aggregate. For example, an Engine class can have an aggregation relationship with a Car class;at the same time an Engine class can have an aggregation relationship with an Order class which indicates that the engine is part of the Car and the Order. Aggregations are closely related to compositions.

3. Composition (Not-Shared Association/Real Aggregation)

Is a stronger form of aggregation where the parts cannot exist without the whole. The parts can only participate in one composite. In a composition association relationship, data usually flows in only one direction (that is, from the whole classifier to the part classifier). Composition is shown as an association with a filled solid diamond nearest the class constituting the whole.



In cases where in addition to the part-of relationship between class Person and booth class Hand and class Leg - there’s a strong life cycle dependency between those classes, meaning that when class Person deleted then booth class Hand and class Leg are also deleted as a result, we should be more specific and use the composition link instead of the aggregation link or the association link.

NB:

Unlike association and aggregation, in the composition relationship, the composed class cannot appear as a return type or parameter type of the composite class,  thus changes in the composed class cannot be propagated to the rest of the system. Consequently, usage of composition limits complexity growth as the system grows.

Aggregation v.s. Association:

The association link can replace the aggregation link in every situation, while aggregation cannot replace association in situations were there is only a ‘weak link’ between the classes.

Summarizing:

To avoid confusion henceforth for these three terms, I have put forward a table below which will help us compare them from three angles: owner, lifetime, and child object.

Association
Aggregation
Composition
Owner
No owner
Single or Multiple owner
Single owner
Life time
Have their own lifetime
Owner's life time
Child object
Child objects all are independent
Child objects belong to a single/multiple parent
Child objects belong to a single parent

Step by step Association, Aggregation, and Composition decision making

References:

ibm ,tutorialspoint, codeproject, sintef9013

How to link Java Classes to UML Class Diagram in JDeveloper

1.       Create an Aplication
2.       Create a Java Project  with type Custom Project
3.       Create UML project with type UML Project
3.1.    To Make UML Class Diagram:
3.1.1.  Create a new “Java Class Diagram”
3.1.2. Drag and drop the UML element into this diagram
3.1.3. Use a suitable relationship between each element
3.2.    To Link the UML to the Classes bi-directionally  and generate the classes from diagram
3.2.1. Select the UML Project
3.2.2. Right Click Select “Project Properties”
3.2.3. Go to “Project Source Paths”
3.2.4. Click Remove button to delete the original “src“ folder
3.2.5. Click add button and go through the source folder of the JAVA Project, and save this path

4.       Now your Application had a link between diagram and Classes