[JAVA] Bis zur Verwendung von Spring Data und JPA Part 1

Die Schwierigkeit beim Einstellen ist ziemlich hoch.

Ich denke, es ist eine einzigartige Art, Spring Framework zu schreiben, aber es ist eine Eigenschaftendatei, eine XML-Datei und Java. Ich denke, es ist ein ziemlich Anfänger-Mord, also habe ich die Verwendung von JPA zusammengefasst.

Ziele teilen

1. 1. Was Sie brauchen, um sich mit SQL zu verbinden -Hibernate EntityManager-Bibliothek ・ Spring JDBC-Bibliothek ・ Datenbanktreiber Haltung oder H2 · Eigenschaftendatei -Bean Konfigurationsdatei (xml) JavaConfig wird diesmal nicht verwendet. Vielleicht wird es verwirrend

2. Darüber hinaus, was für JPA erforderlich ist ・ Spring Data JPA-Bibliothek ・ Entitätsklasse · Persistence.xml-Datei (Java EJB-Funktionalität) -Bean Konfigurationsdatei (XML) -Ausführungsklasse mit Hauptmethode

Überprüfen Sie die Konsole, um festzustellen, ob die Abfrage ordnungsgemäß in der Datenbank eingegangen ist. Später im Web verwenden.

Verbindung mit DB

Bibliotheks- und Treibereinstellungen

POM-Einstellungen.

Zu pom hinzufügen und Abhängigkeiten hinzufügen. Ich verwende die Spring IO-Plattform, daher werde ich die Version nicht beschreiben!

pom.xml

		<!-- Hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
		</dependency>

		<!-- jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
		</dependency>
		
		<!-- postgresql database -->
		<dependency>
   			 <groupId>org.postgresql</groupId>
    		<artifactId>postgresql</artifactId>
		</dependency>

Klicken Sie nach dem Zeichnen mit der rechten Maustaste auf ** Maven → updateProject **

Erstellen einer Eigenschaftendatei

Ich werde Spring Informationen über den postgrauen Treiber geben. Erstellen Sie eine Eigenschaftendatei von ** database.properties ** in src / main / resource.

database.properties

jdbc.driverClassName=org.postgresql.Driver
jdbc.url=jdbc:postgresql://localhost:5432/sample
jdbc.username=postgres
jdbc.password=password

Wenn es sich um einen Beitrag handelt, sieht er je nach verwendeter Datenbank folgendermaßen aus.

Erstellen einer Bean-Konfigurationsdatei

Registrieren Sie die DataSource und JdbcTemplate im DI-Container. Erstellen Sie ** bean.xml ** in src / main / resource

Sie lesen den Wert aus der Eigenschaftendatei und registrieren ihn in der Bean.

• So etwas sollte nicht handgeschrieben sein. Klicken Sie mit der rechten Maustaste und wählen Sie ** Neu → Andere ** und ** Spring → Spring Bean-Konfigurationsdatei **, um den XML-Namespace im Assistentenformat auszuwählen. Diesmal habe ich Beans-Kontext jdbc tx (Transaktion) gewählt.

bean.xml

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


	<!--Einstellungen für eingebettete Datenbank>
	<jdbc:embedded-database id="dataSource" type="H2">
		<jdbc:script location="classpath:script.sql"/>
	</jdbc:embedded-database-->

	<!--Datenbankeigenschaften festlegen-->
	<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	  	<property name="location" value="database.properties" />
	</bean>

	<!--Einstellungen für die DB-Verbindung-->
	<bean id="dataSource" 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>

	<!--Erstellen einer JDBC-Template-Bean-->
	<bean class="org.springframework.jdbc.core.JdbcTemplate">
		<constructor-arg ref="dataSource" />
	</bean>

Versuchen Sie tatsächlich eine Verbindung herzustellen

Nehmen wir dies aus DI heraus und führen es aus Greifen Sie mit ** execute ** und ** queryForList ** von JdbcTemplate auf die Datenbank zu!

App.java

@Component
@ComponentScan
public class App {
	//private static JdbcTemplate jdbcTemplate;
	private static ApplicationContext context;
	private static JdbcTemplate jdbcTemplate;
	
	public static void main(String args[]) {
		
		//Erstellen einer Vorlage mit Anmerkungen
		//context = new AnnotationConfigApplicationContext(DataSourceConfig.class);
		//JdbcTemplate jdbcTemplate = (JdbcTemplate)context.getBean(JdbcTemplate.class);
		//Kontext abrufen
		context = new ClassPathXmlApplicationContext("bean.xml");
		jdbcTemplate = context.getBean(JdbcTemplate.class);
	
		List<Map<String, Object>> list = jdbcTemplate
				.queryForList("SELECT * FROM mytable");
		
		for(Map<String, Object> obj : list) {
			System.out.println(obj);
		}
	
	}

}

Mach das und schau zu

Unten sehen Sie, dass die Spalten aus der Datenbank abgerufen wurden.

Fortsetzung von Teil 2