Ich habe es einmal überprüft, aber da es gespeichert ist, werde ich es in Qiita veröffentlichen

Motivation

Ich möchte nicht viel von demselben Code und SQL schreiben
Ich möchte so etwas wie Rails Active Record in Java machen

Materialien über generisches Dao

Es ist ein ziemlich alter Artikel, daher bin ich mir nicht sicher, ob er praktisch ist.

Vergleich der Nichtverwendung / Verwendung von GenericDao

Es ist eine Vorhersage, weil ich sie nie in den eigentlichen Kampf gesteckt habe

GenericDao?	verwenden	verwende nicht
Kesselplattenkabel(Standardcode, der aufgrund von Sprachspezifikationen nicht weggelassen werden kann)	Kann reduziert werden	Gib dein Bestes, um zu schreiben
SQL-Optimierung	es kann	es kann
debuggen	Problematisch	Problematisch

Proben und Codierung

GenericDao（interface）

Führen Sie eine grundlegende CRUD-Verarbeitung von der Anwendung bis zur Datenbank durch, die die Schnittstelle als Modell definiert.

Eine kurze Erklärung (obwohl es offensichtliche Punkte gibt, werde ich nicht im Detail schreiben, weil es problematisch ist).
** CREATE **: Empfängt eine Instanz des Modells und fügt sie in die Datenbank ein
** READ **: SELECT mit dem Primärschlüssel, falls vorhanden, SELECT all wenn nicht
** UPDATE **: Empfängt eine Instanz des Modells und aktualisiert sie in der Datenbank
** DELETE **: Empfängt den Primärschlüssel und DELETE aus der Datenbank
T ← Dies ist eine Klasse von Objekten, die einer Tabelle in der Datenbank zugeordnet sind, die Sie zum Zeitpunkt der Deklaration sehen können
PK ← Dies ist eine Klasse des Primärschlüssels und wird in den meisten Fällen als String, Integer, Long deklariert.
Was ist, wenn Sie mehrere Schlüssel verwenden möchten?

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)

In Zusammenarbeit mit Spring muss "SessionFactory" in DI eingegeben werden
Mit "sessionFactory.getCurrentSession ()" können Sie die erfasste Sitzung von der Mitte aus verwenden.
Deklarieren Sie den Typ "private Klasse " und empfangen Sie die Entität dieser Klasse im Konstruktor
Ein Trick, um die eigentliche Klasse später zu verwenden

`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);
	}
}

EmployeesDao - Beispiel für eine Modellschicht

Schreiben wir Dao (Data Access Object), um tatsächlich mit dem Modell zu arbeiten

Als Beispiel erstellen wir Dao, das die CRUD-Verarbeitung aus der folgenden Tabelle von MySQL ausführt
emp_no ist der Primärschlüssel, daher sollten Sie SELECT usw. können.

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)
);

Modellschicht

Schreiben wir eine Klasse für O / R Map. Hör auf, Getter / Setter zu schreiben und generiere es mit lombok.

Punkt

Getter / Setter wird automatisch mithilfe der in lombok verwendeten Anmerkung "@ Data" generiert
Es ist erforderlich, JPA-Anmerkungen zu verwenden. Einzelheiten finden Sie auf der folgenden Website
Als Grundlage für JPA-bezogene Anmerkungen - Teil 1-
Als Grundlage für JPA-bezogene Anmerkungen - Teil 2-
Für Gender wird ENUM in SQL verwendet, daher muss es in eine andere Klasse unterteilt werden.

`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

Tatsächliche Dao-Klasse
Ich habe das Gefühl, dass ich es endlich genossen habe
Bereite Dao als Schnittstelle vor und füge der Implementierung Spring hinzu (← erstaunlich)

`EmployeesDao.java`


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

Dao Spring Einstellungen

Vorbereitung zum Einstellen von Dao, Spring AOP und Hibernate
Im Wesentlichen benötigen Sie nur den Teil <bean id =" employeeDao "parent =" abstractDao ">

`applicationContext.xml`


	<!--DataSource-Einstellungen-->
	<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 oben eingestellt-->
		<property name="dataSource" ref="myDataSource" />

		<!--Gibt den Namespace an, in dem sich die Modellklasse befindet-->
		<property name="packagesToScan" value="package.to.your.models" />

		<!--Verbindungseinstellungen im Ruhezustand-->
		<property name="hibernateProperties">
			<props>
				<prop key="dialect">org.hibernate.dialect.MySQLDialect</prop>
				<!--Es scheint, dass Sie hier nur debuggen können, wenn Sie es sowohl in der Produktion als auch im Test auf true setzen-->
				<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>

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

	<!--Fügen Sie die oben erstellte sessionFactory in GenericDaoHibernateImpl ein-->
	<bean id="abstractDaoTarget" class="jp.gr.java_conf.hangedman.dao.GenericDaoHibernateImpl" abstract="true">
		<property name="sessionFactory">
			<ref bean="mySessionFactory" />
		</property>
	</bean>

	<!--Bereit zum Injizieren der Implementierung mit Spring AOP-->
	<bean id="abstractDao" class="org.springframework.aop.framework.ProxyFactoryBean"
		abstract="true">
	</bean>

	<!-- Dao,Stellen Sie das Modell ein und beenden Sie es. Von hier runter<bean>Benötigen Sie für jedes Dao ein Tag?-->
	<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>

Stichprobe

Github generic-dao-hibernate

[JAVA] Lassen Sie uns mit Generic Dao und Hibernate einen Parameter-Polymorph-Mechanismus erstellen