Conhecendo pacotes no Flutter
Há 40 minutos
Este é um blog para programadores de computador independente da linguagem usada.
@PersistenceContext
private EntityManager em;
public void persist(Object o){
em.persist(o);
}
@Local
public interface RepositorySession {
@TransactionAttribute(TransactionAttributeType.NEVER)
public LoginRepository getLoginRepository();
@TransactionAttribute(TransactionAttributeType.NEVER)
public TimesheetRepository getTimesheetRepository();
}
@Stateless
public class RepositorySessionImpl implements RepositorySession{
@PersistenceContext
private EntityManager em;
@TransactionAttribute(TransactionAttributeType.NEVER)
public LoginRepository getLoginRepository(){
return new LoginDAO().setEntityManager(em);
}
@TransactionAttribute(TransactionAttributeType.NEVER)
public TimesheetRepository getTimesheetRepository(){
return new TimesheetDAO().setEntityManager(em);
}
}
@Local
public interface TimesheetFacade {
@PostConstruct
public void initialize();
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void persist(Timesheet Timesheet);
}
@Stateless
public class TimesheetFacadeImpl implements TimesheetFacade {
@EJB
RepositorySession repository;
TimesheetRepository timesheetRepository;
@PostConstruct
public void initialize() {
timesheetRepository = repository.getTimesheetRepository();
}
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void persist(Timesheet timesheet) {
timesheetRepository.persist(timesheet);
}
}
package org.iprogramming.model.repository;
public interface GenericRepository<T> {
public void persist(T entity);
public void remove(T entity);
}
package org.iprogramming.model.repository;
import java.util.List;
import org.iprogramming.model.entity.Login;
public interface LoginRepository extends GenericRepository<Login>{
public Login findById(Long id);
public Login findByName(String login);
public List<Login> list();
public List<Login> listOrderedBy(String column);
}
package org.iprogramming.model.persistence;
import javax.persistence.EntityManager;
import org.iprogramming.model.repository.GenericRepository;
public class GenericDAO<T, DAOImpl extends GenericRepository> implements GenericRepository<T>{
protected EntityManager em;
public DAOImpl setEntityManager(EntityManager em){
this.em = em;
return (DAOImpl)this;
}
public void persist(T entity){
em.persist(entity);
}
public void remove(T entity){
em.remove(entity);
}
}
package org.iprogramming.model.persistence;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.NoResultException;
import javax.persistence.NonUniqueResultException;
import org.iprogramming.model.entity.Login;
import org.iprogramming.model.repository.LoginRepository;
public class LoginDAO extends GenericDAO<Login, LoginRepository> implements LoginRepository {
private static final Logger logger = Logger.getLogger(LoginDAO.class.getName());
private static final String msg = "Signals that a method has been invoked at an " +
"illegal or inappropriate time. In other words, the Java environment " +
"or Java application is not in an appropriate state for the requested operation";
public Login findById(Long id) {
return (Login)em.createNamedQuery("Login.findByPkLogin").
setParameter("pkLogin", id).getSingleResult();
}
public Login findByName(String name) {
try{
return (Login)em.createNamedQuery("Login.findByName").
setParameter("name", name).getSingleResult();
}catch(NoResultException e){
logger.log(Level.SEVERE, "Cannot find data");
throw new DAOException(e);
}catch(NonUniqueResultException e){
logger.log(Level.SEVERE, "Have more than one result");
throw new DAOException(e);
}catch(IllegalStateException e){
logger.log(Level.SEVERE, msg, e);
throw new DAOException(e);
}
}
public List<Login> list(){
try{
return em.createQuery("SELECT l FROM Login l").getResultList();
}catch(IllegalStateException e){
logger.log(Level.SEVERE, msg, e);
throw new DAOException(e);
}
}
public List<Login> listOrderedBy(String column) {
return em.createQuery("SELECT login FROM Login login order by login."+column).getResultList();
}
}
package org.iprogramming.model.entity;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
@Entity
@Table(name = "login")
@NamedQueries({
@NamedQuery(name = "Login.findByPkLogin",query = "SELECT l FROM Login l WHERE l.pkLogin = :pkLogin"),
@NamedQuery(name = "Login.findByName",query = "SELECT l FROM Login l WHERE l.name = :name"),
@NamedQuery(name = "Login.findByPassword",query = "SELECT l FROM Login l WHERE l.password = :password"),
@NamedQuery(name = "Login.findByEmail",query = "SELECT l FROM Login l WHERE l.email = :email"),
@NamedQuery(name = "Login.findByTelephone",query = "SELECT l FROM Login l WHERE l.telephone = :telephone"),
@NamedQuery(name = "Login.findByDescription",query = "SELECT l FROM Login l WHERE l.description = :description")})
public class Login implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name = "pk_login", nullable = false)
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator="seq_login")
@SequenceGenerator(name="seq_login", sequenceName="seq_login", allocationSize=1)
private Integer pkLogin;
@Column(name = "name", nullable = false)
private String name;
@Column(name = "password", nullable = false)
private String password;
@Column(name = "email", nullable = false)
private String email;
@Column(name = "telephone", nullable = false)
private String telephone;
@Column(name = "description")
private String description;
@JoinTable(name = "login_x_role", joinColumns = {@JoinColumn(name = "fk_login", referencedColumnName = "pk_login")}, inverseJoinColumns = {@JoinColumn(name = "fk_role", referencedColumnName = "pk_role")})
@ManyToMany
private CollectionfkRoleCollection;
@JoinTable(name = "login_x_page", joinColumns = {@JoinColumn(name = "fk_login", referencedColumnName = "pk_login")}, inverseJoinColumns = {@JoinColumn(name = "fk_page", referencedColumnName = "pk_page")})
@ManyToMany
private CollectionfkPageCollection;
@OneToMany(cascade = CascadeType.ALL, mappedBy = "fkLogin")
private CollectiontimesheetCollection;
public Login() {
}
public Login(Integer pkLogin) {
this.pkLogin = pkLogin;
}
public Login(Integer pkLogin, String name, String password, String email, String telephone) {
this.pkLogin = pkLogin;
this.name = name;
this.password = password;
this.email = email;
this.telephone = telephone;
}
public Integer getPkLogin() {
return pkLogin;
}
public void setPkLogin(Integer pkLogin) {
this.pkLogin = pkLogin;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public CollectiongetFkRoleCollection() {
return fkRoleCollection;
}
public void setFkRoleCollection(CollectionfkRoleCollection) {
this.fkRoleCollection = fkRoleCollection;
}
public CollectiongetFkPageCollection() {
return fkPageCollection;
}
public void setFkPageCollection(CollectionfkPageCollection) {
this.fkPageCollection = fkPageCollection;
}
public CollectiongetTimesheetCollection() {
return timesheetCollection;
}
public void setTimesheetCollection(CollectiontimesheetCollection) {
this.timesheetCollection = timesheetCollection;
}
@Override
public int hashCode() {
int hash = 0;
hash += (pkLogin != null ? pkLogin.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object object) {
// TODO: Warning - this method won't work in the case the id fields are not set
if (!(object instanceof Login)) {
return false;
}
Login other = (Login) object;
if ((this.pkLogin == null && other.pkLogin != null) || (this.pkLogin != null && !this.pkLogin.equals(other.pkLogin))) {
return false;
}
return true;
}
@Override
public String toString() {
return "org.iprogramming.model.entity.Login[pkLogin=" + pkLogin + "]";
}
}
public class GenericHibernateDAO <T, ID extends Serializable, DAOImpl extends GenericRepository<T, ID>> extends HibernateDaoSupport implements GenericRepository<T, ID> {
protected Session getCurrentSession() {
SessionFactory SessionFactory = this.getHibernateTemplate().getSessionFactory();
return SessionFactory.getCurrentSession();
}
@SuppressWarnings("unchecked")
public T findById(Class<T> clazz, ID id) {
return (T)getCurrentSession().get(clazz, id);
}
@SuppressWarnings("unchecked")
public List<T> list(Class<T> clazz) {
return getCurrentSession().createCriteria(clazz).list();
}
@SuppressWarnings("unchecked")
public List<T> list(Class<T> clazz, int firstResult, int maxResults) {
Criteria criteria = getCurrentSession().createCriteria(clazz);
criteria.setFirstResult(firstResult);
criteria.setMaxResults(maxResults);
return criteria.list();
}
@SuppressWarnings("unchecked")
public List<T> listByExample(T entity) {
Criteria criteria = getCurrentSession().createCriteria(entity.getClass());
Example sample = Example.create(entity);
sample.enableLike();
sample.excludeZeroes();
criteria.add(sample);
return criteria.list();
}
public T makePersistent(T entity) {
getCurrentSession().saveOrUpdate(entity);
return entity;
}
public void makeTransient(T entity) {
getCurrentSession().delete(entity);
}
}
public class HibernateDAOFactory extends DAOFactory{
private static final ApplicationContext context;
static {
try {
context = new ClassPathXmlApplicationContext("iocForHibernate.xml");
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
@Override
public CompanyRepository getCompanyRepository() {
return (CompanyDAO) context.getBean("companyDAO");
}
}
<beans>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.postgresql.Driver</value>
</property>
<property name="url">
<value>jdbc:postgresql://localhost:5432/iprogramming</value>
</property>
<property name="username">
<value>postgres</value>
</property>
<property name="password">
<value>postgres</value>
</property>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource"/>
</property>
<property name="mappingResources">
<list>
<value>org/iprogramming/model/domain/entity/Company.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</prop>
<prop key="show_sql">true</prop>
<prop key="hibernate.generate_statistics">true</prop>
<prop key="hibernate.use_sql_comments">true</prop>
</props>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<bean id="hibernateCompanyDAO" class="org.iprogramming.model.persistence.hibernate.global.HibernateCompanyDAO">
<property name="sessionFactory">
<ref local="sessionFactory"/>
</property>
</bean>
<bean id="companyDAO" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref local="transactionManager"/>
</property>
<property name="target">
<ref local="hibernateCompanyDAO"/>
</property>
<property name="transactionAttributes">
<props>
<prop key="make*">
PROPAGATION_REQUIRED, ISOLATION_READ_COMMITTED
</prop>
<prop key="find*">
PROPAGATION_SUPPORTS, readOnly
</prop>
<prop key="list*">
PROPAGATION_SUPPORTS, readOnly
</prop>
</props>
</property>
</bean>
</beans>
|---+model
|
|---+busines
|---+persistence
|---dao
|---dto
|---factory
|---transaction
public class LoginBO{
private DAOFactory factory = null;
public LoginBO(){
factory = DAOFactory.getDAOFactory(DAOFactory.HIBERNATE);
}
@HibernateTransaction
public Person makePersistent(Person person) throws RuntimeException {
return factory.getPersonDAO().makePersistent(person);
}
}
public class BOFactory {
public static LoginBO getLogin(){
try{
return (LoginBO)TransactionClass.
create(LoginBO.class, HibernateInterceptorAnnotation.class);
}catch (Exception ex){
return null;
}
}
}
LoginBO loginBO = BOFactory.getLogin();
Person person = new Person("Ronildo Braga Jr","26-01-1982","M");
loginBO.makePersistent(person);
package org.iprogramming.model.persistence.hibernateTransaction;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Utilizaremos esta anotação para marcar os métodos que
* queremos que sejam transacionais. Consideramos como
* métodos transacionais aqueles cujo processamento
* constitui uma única transação com o banco
* @author Ronildo
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface HibernateTransaction {}
package org.iprogramming.model.persistence.hibernateTransaction;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.apache.log4j.Logger;
import org.iprogramming.Util;
/**
* Cerne do componente para controle de transacao. Faz uso de CGLib,
* uma biblioteca que provê mecanismos de manipulação de bytecode, permitindo
* implementar interfaces dinamicamente, interceptar a chamada de métodos.
* Chamando determinado método, interceptamos a sua ação, e verificamos se este método
* é transacional. Se for, abrimos uma transação, e executamos o método.
* Se ele for executado com sucesso, damos commit na operação.
* Porém, se der exceção, fazemos um rollback
*
* Isso se parece com a solução de Filtros Http, porém com uma vantagem:
* o controle transacional não fica misturado com a API do Controller (C do padrão MVC),
* e é mais flexível, pois não se prende ao contexto web
*
* Observe também que esta solução é melhor que tratar as transações diretamente nas classes Java.
* Isso porque você vai evitar muito código repetitivo (try, catch, commit, rollback, etc),
* e não vai “poluir” inúmeras classes com este tipo de código.
* @author Ronildo
*/
public abstract class HibernateInterceptor implements MethodInterceptor {
private static final Logger logger = Util.startLogger(HibernateInterceptor.class);
/**
* O método intercept, proveniente da interface MethodInterceptor (CGLib), se encarrega
* de fazer o controle transacional. Veja que ele usa o HibernateHelper,
* e que o método transacional é explicitamente invocado, através de methodProxy.invokeSuper(),
* e o seu retorno é explicitamente devolvido
* @throws Throwable
*/
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
if (isTransactional(object, method)){
logger.debug("logica de negocio deve ser executada dentro de uma transacao");
HibernateHelper.beginTransaction();
}
Object result = null;
try {
result = methodProxy.invokeSuper(object, args);
HibernateHelper.commitTransaction();
logger.debug("logica de negocio executada com sucesso");
}catch (Throwable e){
logger.debug("erro ao executar logica de negocio");
HibernateHelper.rollbackTransaction();
throw e;
}
return result;
}
/**
* Definido como abstrato para para obter máxima flexibilidade, pois apenas
* estendendo esta classe e implementando este método, podemos saber se o
* método é transacional ou não de diversas maneiras, como arquivos XML,
* arquivos texto, e anotações! (Esta classe é um caso do pattern Template Method).
*/
public abstract boolean isTransactional(Object object, Method method) ;
}
package org.iprogramming.model.persistence.hibernateTransaction;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
/**
* Está é a nossa implementação de HibernateInterceptor. O método isTransactional
* procura no método a anotação @HibernateTransaction. Se encontrar, retorna true,
* indicando que o método é transacional. Se não encontrar, retorna false.
* @author Ronildo
*/
public class HibernateInterceptorAnnotation extends HibernateInterceptor {
public boolean isTransactional(Object object, Method method) {
Annotation annotation = method.getAnnotation(HibernateTransaction.class);
return annotation == null ? false : true;
}
}
package org.iprogramming.model.persistence.hibernateTransaction;
import net.sf.cglib.proxy.Enhancer;
/**
* Para podermos interceptar os nossos métodos usando CGLib, não podemos criar
* suas classes através de um construtor. Devemos criá-las a partir do objeto Enhancer,
* fornecido pela API. Assim, implementamos uma classe para nos ajudar na construção
* de objetos que possuam métodos transacionais.
*
* Esta classe possui o método create, que recebe dois argumentos do tipo Class: o beanClass,
* que se refere à classe que desejamos criar; e o interceptorClass, que se refere ao tipo de Interceptor usado.
* Neste último argumento, passaremos HibernateInterceptorAnnotation.class, mas poderíamos
* também passar HibernateInterceptorXML.class, HibernateInterceptorTextFile.class, enfim,
* qualquer coisa que a sua imaginação permitir.
*
* Esta classe nao deve ser conhecida em vários lugares da aplicação. Procure escondê-la utilizando o
* pattern Factory, ou integrá-la com o seu mecanismo de IoC (como Spring Framework ou PicoContainer).
* Assim, você evita “poluir” suas classes desnecessariamente.
* Bem, em termos práticos: se quisermos que determinada classe possua um método transacional,
* ela deve ser criada por meio de TransactionClass
* @author Ronildo
*
*/
public class TransactionClass {
public static Object create(Class beanClass, Class interceptorClass) throws InstantiationException, IllegalAccessException{
HibernateInterceptor interceptor = (HibernateInterceptor)interceptorClass.newInstance();
Object object = Enhancer.create(beanClass, interceptor);
return object;
}
}
|---+model
|
|---+busines
|---+persistence
|---dao
|---dto
|---factory
|---transaction
public class LoginBO{
private DAOFactory factory = null;
public LoginBO(){
factory = DAOFactory.getDAOFactory(DAOFactory.HIBERNATE);
}
public Person makePersistent(Person person) throws RuntimeException {
try {
HibernateHelper.beginTransaction();
person = factory.getPersonDAO().makePersistent(person);
HibernateHelper.commitTransaction();
}catch (RuntimeException e){
HibernateHelper.rollbackTransaction();
throw e;
}
return person;
}
}
LoginBO loginBO = new LoginBO();
Person person = new Person("Ronildo Braga Jr","26-01-1982","M");
loginBO.makePersistent(person);
public class HibernateHelper {
private static final SessionFactory sessionFactory;
private static final ThreadLocalsessionThread = new ThreadLocal ();
private static final ThreadLocaltransactionThread = new ThreadLocal ();
static {
try {
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
//Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static Session currentSession() {
if (sessionThread.get() == null) {
Session session = sessionFactory.openSession();
sessionThread.set(session);
}
return (Session) sessionThread.get();
}
private static void closeSession() {
Session session = (Session) sessionThread.get();
if (session != null)
session.close();
sessionThread.set(null);
}
public static void beginTransaction() {
if (transactionThread.get() == null){
Transaction transaction = currentSession().beginTransaction();
transactionThread.set(transaction);
}
}
public static void commitTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if (transaction != null && !transaction.wasCommitted() && !transaction.wasRolledBack()) {
transaction.commit();
transactionThread.set(null);
}
closeSession();
}
public static void rollbackTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if (transaction != null && !transaction.wasCommitted() && !transaction.wasRolledBack()) {
transaction.rollback();
transactionThread.set(null);
}
closeSession();
}
}
|---+persistence
|
|---dao
|---dto
|---factory
|---transaction
public abstract class DAOFactory {
public static final int HIBERNATE = 1;
public static final int SQLServer = 2;
public static DAOFactory getDAOFactory(int whichFactory){
switch(whichFactory){
case 1:
return new HibernateDAOFactory();
case 2:
return new SQLDAOFactory();
default:
return null;
}
}
public abstract LoginDAO getLoginDAO();
}
public class HibernateDAOFactory extends DAOFactory{
private static Session getCurrentSession() {
return HibernateHelper.currentSession();
}
public LoginDAO getLoginDAO() {
return new HibernateLoginDAO().setSession(getCurrentSession());
}
}
DAOFactory factory = DAOFactory.getDAOFactory(DAOFactory.HIBERNATE);
LoginDAO loginDAO = factory.getLoginDAO();
List list = loginDAO.list(Login.class);
|---+dao
| |
| |---generic
| |---hibernate
public interface GenericDAO <T, ID extends Serializable>{
public T findById(Class clazz, ID id);
public List list(Class clazz);
public List list(Class clazz, int firstResult, int maxResults);
public List listByExample(T entity);
public T makePersistent(T entity);
public void makeTransient(T entity);
}
interface LoginDAO extends GenericDAO<Login, Long>{
public Login findLoginByNamedQuery(Login arg);
}
public class GenericHibernateDAO <T, ID extends Serializable, DAOImpl extends GenericDAO<T, ID>> implements GenericDAO<T, ID> {
private Session session;
public DAOImpl setSession(Session s) {
this.session = s;
return (DAOImpl)this;
}
protected Session getSession() {
if (session == null)
throw new IllegalStateException("Session has not been set on DAO before usage");
return session;
}
public T findById(Class clazz, ID id) {
return (T)getSession().get(clazz, id);
}
public List list(Class clazz) {
return getSession().createCriteria(clazz).list();
}
public List list(Class clazz, int firstResult, int maxResults) {
Criteria criteria = getSession().createCriteria(clazz);
criteria.setFirstResult(firstResult);
criteria.setMaxResults(maxResults);
return criteria.list();
}
public List listByExample(T entity) {
Criteria criteria = getSession().createCriteria(entity.getClass());
Example sample = Example.create(entity);
sample.enableLike();
sample.excludeZeroes();
criteria.add(sample);
return criteria.list();
}
public T makePersistent(T entity) {
getSession().saveOrUpdate(entity);
return entity;
}
public void makeTransient(T entity) {
getSession().delete(entity);
}
}
public class HibernateLoginDAO extends GenericHibernateDAO<Login, Long, LoginDAO> implements LoginDAO {
public Login findLoginByNamedQuery(Login arg)
Query select = getSession().getNamedQuery("findUser");
select.setLong("pkUsers", arg.getPkLogin());
select.setString("roleName", arg.getRoles().iterator().next().getName());
List<Login> logins = (List<Login>) select.list();
for(Login login : logins)
return login;
return null;
}
}
--+ITrust
|
|--+src
| |
| |---+org.iprogramming
| |
| |---+controller
| |---+model
| |---+view
|--+web
|
|---+css
|---+images
|---+include
|---+js
|---+pages
|---+WEB-INF
model
|
|
|---busines
|--+persistence
|
|---+dao
| |
| |---generic
| |---hibernate
|
|---dto
|---factory
|---transaction
model --------> Contem todos os packages resposaveis pelo modelo do distema
busines ------> Representa as classes de logica de negocio do sistema
persistence --> Contem todos os packages envolvidos ao banco de dados
dao ----------> Representa as interfaces de nossos Data Access Object(DAO)
generic ------> Representa as classes e as interfaces genericas para dar suporte ao nossos DAOs
hibernate ----> Representa as classes de persistencia no banco de dados
dto ----------> Representa as classes referente aos registros no banco de dados
factory ------> Representa as classes para criar instancia de nossos DAOs
transaction --> Representa as classes para controle de transações do hibernate
create sequence seq_company;
CREATE TABLE company
(
pk_company bigint NOT NULL DEFAULT nextval('seq_company'::regclass),
name character varying(45) NOT NULL,
description text,
CONSTRAINT ctr_company PRIMARY KEY (pk_company)
);
create sequence seq_person;
CREATE TABLE person
(
pk_person bigint NOT NULL DEFAULT nextval('seq_person'::regclass),
fk_company bigint NOT NULL,
name character varying(45) NOT NULL,
born date,
description text,
CONSTRAINT ctr_person PRIMARY KEY (pk_person),
CONSTRAINT ctr_company_in_person FOREIGN KEY (fk_company)
REFERENCES company (pk_company) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
);
create sequence seq_login;
CREATE TABLE "login"
(
pk_login bigint NOT NULL DEFAULT nextval('seq_login'::regclass),
fk_person bigint NOT NULL,
"login" character varying(10) NOT NULL,
"password" character varying(10) NOT NULL,
description text,
CONSTRAINT ctr_login PRIMARY KEY (pk_login),
CONSTRAINT ctr_person_in_login FOREIGN KEY (fk_person)
REFERENCES person (pk_person) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
);
public class Company implements java.io.Serializable {
//Non Fields
public boolean marked = false;
// Fields
private long pkCompany;
private String name;
private String description;
private Set<Person> persons = new HashSet<Person>(0);
//...geters and seters
}
<hibernate-mapping>
<class name="org.iprogramming.model.persistence.dto.Company" table="company" schema="public">
<id name="pkCompany" type="long">
<column name="pk_company" />
<generator class="sequence">
<param name="sequence">seq_company</param>
</generator>
</id>
<property name="name" type="string">
<column name="name" length="45" not-null="true" />
</property>
<property name="description" type="string">
<column name="description" />
</property>
<set name="persons" inverse="true">
<key>
<column name="fk_company" not-null="true" />
</key>
<one-to-many class="br.com.verano.model.persistence.dto.Person" />
</set>
</class>
</hibernate-mapping>