Je l'ai vérifié une fois, mais comme il est en stock, je le publierai sur Qiita

Motivation

Je ne veux pas écrire beaucoup du même code et SQL
Je veux faire quelque chose comme Rails Active Record en Java

Matériaux sur le Dao générique

C'est un article assez ancien, donc je ne suis pas sûr que ce soit pratique.

Comparaison de la non-utilisation / utilisation de GenericDao

C'est une prédiction parce que je ne l'ai jamais mise dans la bataille réelle

GenericDao?	utilisation	ne pas utiliser
Cordon de plaque de chaudière(Code standard qui ne peut pas être omis en raison des spécifications de la langue)	Peut être réduit	Faites de votre mieux pour écrire
Réglage SQL	ça peut	ça peut
déboguer	Gênant	Gênant

Échantillons et codage

GenericDao（interface）

Effectuez un [traitement CRUD] de base (https://ja.wikipedia.org/wiki/CRUD) de l'application à la base de données, qui définit l'interface comme un modèle.

Une brève explication (bien qu'il y ait des points évidents, je n'écrirai pas en détail car c'est gênant).
** CREATE **: Recevoir une instance du modèle et l'INSÉRER dans la base de données
** LIRE **: SELECT avec la clé primaire si elle existe, SELECT tout sinon
** UPDATE **: recevoir une instance du modèle et la mettre à jour dans la base de données
** DELETE **: Recevoir la clé primaire et SUPPRIMER de la base de données
T ← Il s'agit d'une classe d'objets mappés à une table de la base de données, que vous pouvez voir au moment de la déclaration
PK ← Il s'agit d'une classe de ce qu'est la clé primaire, et dans la plupart des cas, elle sera déclarée comme String, Integer, Long.
Et si vous souhaitez utiliser plusieurs clés?

import java.io.Serializable;
import java.util.List;

/**
 * This is the article 10 years ago, we should follow this
 * @see https://www.ibm.com/developerworks/jp/java/library/j-genericdao/
 */
public interface GenericDao<T, PK extends Serializable> {

	/** Persist the newInstance object into database */
	PK create(T newInstance);

	/**
	 * Retrieve an object that was previously persisted to the database using
	 * the indicated id as primary key
	 */
	T read(PK id);
	List<T> read();

	/** Save changes made to a persistent object. */
	void update(T transientObject);

	/** Remove an object from persistent storage in the database */
	void delete(PK id) throws Exception;
	void delete(T persistentObject) throws Exception;
}

GenericDaoHibernateImpl(class)

En coopération avec Spring, faites entrer SessionFactory dans DI
En faisant sessionFactory.getCurrentSession (), vous pouvez utiliser la session acquise depuis le milieu.
Déclarez le type classe privée <T>; et recevez l'entité de cette classe dans le constructeur
Une astuce pour utiliser la classe réelle plus tard

`GenericDaoHibernateImpl.java`


import java.io.Serializable;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class GenericDaoHibernateImpl<T, PK extends Serializable> implements GenericDao<T, PK> {

	private Class<T> type;

	@Autowired
	private SessionFactory sessionFactory;

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	public GenericDaoHibernateImpl(Class<T> type) {
		this.type = type;
	}

	// Not showing implementations of getSession() and setSessionFactory()
	private Session getSession() {
		Session session = sessionFactory.getCurrentSession();
		return session;
	}

	@Transactional(readOnly = false, rollbackFor = RuntimeException.class)
	public PK create(T o) {
		return (PK) getSession().save(o);
	}

	@Transactional(readOnly = false, rollbackFor = RuntimeException.class)
	public void update(T o) {
		getSession().update(o);
	}

	@Transactional(readOnly = true)
	public T read(PK id) {
		return (T) getSession().get(type, id);
	}

	@SuppressWarnings("unchecked")
	@Transactional(readOnly = true)
	public List<T> read() {
		return (List<T>) getSession().createCriteria(type).list();
	}

	@Transactional(readOnly = false, rollbackFor = RuntimeException.class)
	public void delete(PK id) {
		T o = getSession().load(type, id);
		getSession().delete(o);
	}

	@Transactional(readOnly = false, rollbackFor = RuntimeException.class)
	public void delete(T o) {
		getSession().delete(o);
	}
}

EmployésDao - Exemple de couche de modèle

Écrivons Dao (Data Access Object) pour créer un lien avec le modèle

À titre d'exemple, créons Dao qui effectue le traitement CRUD à partir du tableau suivant de MySQL
ʻEmp_no` est la clé primaire, vous devriez donc pouvoir SELECT etc.

SQL

CREATE TABLE employees (
    emp_no      INT             NOT NULL,  -- UNSIGNED AUTO_INCREMENT??
    birth_date  DATE            NOT NULL,
    first_name  VARCHAR(14)     NOT NULL,
    last_name   VARCHAR(16)     NOT NULL,
    gender      ENUM ('M','F')  NOT NULL,  -- Enumeration of either 'M' or 'F'  
    hire_date   DATE            NOT NULL,
    PRIMARY KEY (emp_no)                   -- Index built automatically on primary-key column
                                           -- INDEX (first_name)
                                           -- INDEX (last_name)
);

Couche de modèle

Écrivons une classe pour la carte O / R. Arrêtez d'écrire Getter / Setter et générez-le avec lombok.

point

Getter / Setter est généré automatiquement en utilisant l'annotation @ Data utilisée dans lombok
Il est nécessaire d'utiliser les annotations JPA, pour plus de détails, voir le site suivant
Comme base des annotations relatives à JPA - Partie 1-
Comme base des annotations liées à JPA - Partie 2
Pour Gender, ENUM est utilisé en SQL, il est donc nécessaire de le séparer dans une autre classe.

`Employees.java`


import java.io.Serializable;
import java.sql.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Data
@NoArgsConstructor
@Table(name = "employees")
public class Employees implements Serializable {

	private static final long serialVersionUID = 1L;

	@Id
	@Column(name = "emp_no", unique = true)
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer empNo;

	@Column(name = "birth_date")
	private Date birthDate;
	
	@Column(name = "first_name")
	private String firstName;
	
	@Column(name = "last_name")
	private String lastName;
	
	@Column(name = "gender")
	@Enumerated(EnumType.STRING)
	private Gender gender;
	
	@Column(name = "hire_date")
	private Date hireDate;
}

Dao

Classe réelle de Dao
J'ai l'impression d'avoir enfin apprécié
Préparez Dao comme interface et injectez l'implémentation avec Spring (← incroyable)

`EmployeesDao.java`


public interface EmployeesDao extends GenericDao<Employees, Integer> {
}

Paramètres de Dao Spring

Préparation pour le réglage de Dao, Spring AOP et Hibernate
Essentiellement, tout ce dont vous avez besoin est la partie <bean id =" emloyeesDao "parent =" abstractDao ">

`applicationContext.xml`


	<!--Paramètres DataSource-->
	<bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- sessionFactory -->
	<bean id="mySessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<!--DataSource défini ci-dessus-->
		<property name="dataSource" ref="myDataSource" />

		<!--Spécifie l'espace de noms dans lequel se trouve la classe de modèle-->
		<property name="packagesToScan" value="package.to.your.models" />

		<!--Paramètres de connexion Hibernate-->
		<property name="hibernateProperties">
			<props>
				<prop key="dialect">org.hibernate.dialect.MySQLDialect</prop>
				<!--Il semble que vous ne pouvez pas déboguer ici à moins que vous ne le définissiez sur true à la fois en production et en test-->
				<prop key="show_sql">true</prop>
				<prop key="format_sql">true</prop>
				<prop key="connection.CharSet">utf8</prop>
				<prop key="connection.characterEncoding">utf8</prop>
				<prop key="connection.useUnicode">true</prop>
			</props>
		</property>
	</bean>

	<!--Utiliser transactionManager-->
	<tx:annotation-driven />
	<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="mySessionFactory" />
	</bean>

	<!--Injectez la sessionFactory créée ci-dessus dans GenericDaoHibernateImpl-->
	<bean id="abstractDaoTarget" class="jp.gr.java_conf.hangedman.dao.GenericDaoHibernateImpl" abstract="true">
		<property name="sessionFactory">
			<ref bean="mySessionFactory" />
		</property>
	</bean>

	<!--Implémentation prête à être injectée à l'aide de Spring AOP-->
	<bean id="abstractDao" class="org.springframework.aop.framework.ProxyFactoryBean"
		abstract="true">
	</bean>

	<!-- Dao,Définissez le modèle et terminez enfin. De là bas<bean>Avez-vous besoin d'une étiquette pour chaque Dao?-->
	<bean id="employeesDao" parent="abstractDao">
		<!-- You need to configure the interface for Dao -->
		<property name="proxyInterfaces">
			<value>jp.gr.java_conf.hangedman.dao.EmployeesDao</value>
		</property>
		<property name="target">
			<bean parent="abstractDaoTarget">
				<constructor-arg>
					<value>jp.gr.java_conf.hangedman.models.Employees</value>
				</constructor-arg>
			</bean>
		</property>
	</bean>

échantillon

Github generic-dao-hibernate

[JAVA] Créons un mécanisme polymorphe de paramètres avec Generic Dao et Hibernate