Forbind Java til en MySQL-database
Jeg har lige annonceret det nye Lær foråret kursus med fokus på det grundlæggende i Spring 5 og Spring Boot 2:
>> KONTROLLER KURSEN1. Oversigt
Der er mange måder, vi kan oprette forbindelse til en MySQL-database fra Java, og i denne vejledning vil vi undersøge flere muligheder for at se, hvordan man opnår dette.
Vi starter med at se på uden tvivl de mest populære muligheder ved hjælp af JDBC og Hibernate.
Derefter ser vi også på nogle eksterne biblioteker, herunder MyBatis, Apache Cayenne og Spring Data. Undervejs giver vi et antal praktiske eksempler.
2. Forudsætninger
Vi antager, at vi allerede har en MySQL-server installeret og kører på localhost (standardport 3306), og at vi har et testskema med følgende persontabel:
OPRET TABELperson (ID INT, FIRST_NAME VARCHAR (100), LAST_NAME VARCHAR (100));Vi har også brug for mysql-connector-java artefakt, som som altid er tilgængelig fra Maven Central:
mysql mysql-connector-java 8.0.19 3.Tilslutning ved hjælp af JDBC
JDBC (Java Database Connectivity) er en API til at forbinde og udføre forespørgsler i en database.
3.1. Almindelige egenskaber
I løbet af denne artikel bruger vi typisk flere almindelige JDBC-egenskaber:
- Forbindelses-URL - en streng, som JDBC-driveren bruger til at oprette forbindelse til en database. Det kan indeholde oplysninger som hvor man skal søge efter databasen, navnet på databasen, der skal oprettes forbindelse til, og andre konfigurationsegenskaber:
jdbc: mysql: // [host] [, failoverhost ...] [: port] / [database] [? propertyName1] [= propertyValue1] [& propertyName2] [= propertyValue2] ...Vi indstiller denne ejendom således: jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC
- Førerklasse - det fuldt kvalificerede klassenavn på den driver, der skal bruges. I vores tilfælde bruger vi MySQL-driveren: com.mysql.cj.jdbc.Driver
- Brugernavn og adgangskode - legitimationsoplysningerne til MySQL-kontoen
3.2. Eksempel på JDBC-forbindelse
Lad os se, hvordan vi kan oprette forbindelse til vores database og udføre en simpel select-all gennem en prøve-med-flere ressourcer:
String sqlSelectAllPersons = "VÆLG * FRA person"; String connectionUrl = "jdbc: mysql: // localhost: 3306 / test? ServerTimezone = UTC"; prøv (Connection conn = DriverManager.getConnection (connectionUrl, "brugernavn", "password"); PreparedStatement ps = conn.prepareStatement (sqlSelectAllPersons); ResultSet rs = ps.executeQuery ()) {while (rs.next ()) {long id = rs.getLong ("ID"); String name = rs.getString ("FIRST_NAME"); Streng efternavn = rs.getString ("LAST_NAME"); // gør noget med de udpakkede data ...}} fangst (SQLException e) {// håndter undtagelsen}Som vi kan se, inde i prøve body, gentages vi gennem resultatsættet og udtrækker værdierne fra persontabellen.
4.Tilslutning ved hjælp af ORM'er
Mere typisk vil vi oprette forbindelse til vores MySQL-database ved hjælp af en Object Relational Mapping (ORM) Framework. Så lad os se nogle forbindelseseksempler ved hjælp af de mere populære af disse rammer.
4.1. Indfødte dvale-API'er
I dette afsnit vil vi se, hvordan du bruger dvale til at styre en JDBC-forbindelse til vores database.
Først skal vi tilføje dvale-kerne Maven afhængighed:
org. dvale-dvale-core 5.4.10.Final Dvaletilstand kræver, at der oprettes en enhedsklasse for hver tabel. Lad os gå videre og definere Person klasse:
@Entity @Table (name = "Person") offentlig klasse person {@Id Lang id; @Column (name = "FIRST_NAME") Streng fornavn; @Column (name = "LAST_NAME") Strengens efternavn; // getters & setters} Et andet vigtigt aspekt er at oprette ressourcefilen Hibernate, der typisk er navngivet hibernate.cfg.xml, hvor vi definerer konfigurationsoplysninger:
com.mysql.cj.jdbc.Driver jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC brugernavn adgangskode org.hibernate.dialect.MySQL5Dialect validere Dvaletilstand har mange konfigurationsegenskaber. Bortset fra standardforbindelsesegenskaberne er det værd at nævne dialektegenskaben, der giver os mulighed for at specificere navnet på SQL-dialekten til databasen.
Denne egenskab bruges af rammen til korrekt konvertering af Hibernate Query Language (HQL) udsagn til den relevante SQL til vores givne database. Dvale skibe med mere end 40 SQL-dialekter. Når vi fokuserer på MySQL i denne artikel, holder vi os til MySQL5Dialect dialekt.
Endelig skal dvale også kende det fuldt kvalificerede navn på enhedsklassen via kortlægningstagget. Når vi har afsluttet konfigurationen, bruger vi SessionFactory klasse, som er den klasse, der er ansvarlig for at oprette og samle JDBC-forbindelser.
Dette skal typisk kun konfigureres en gang til en applikation:
SessionFactory sessionFabrik; // konfigurerer indstillinger fra hibernate.cfg.xml StandardServiceRegistry registry = ny StandardServiceRegistryBuilder (). configure (). build (); prøv {sessionFactory = nye MetadataSources (registry) .buildMetadata (). buildSessionFactory (); } fange (Undtagelse e) {// håndtere undtagelsen}Nu hvor vores forbindelse er oprettet, kan vi køre en forespørgsel for at vælge alle personer fra vores persontabel:
Session session = sessionFactory.openSession (); session.beginTransaction (); Listeresultat = session.createQuery ("fra person", person.klasse). Liste (); result.forEach (person -> {// gør noget med personinstans ...}); session.getTransaction (). commit (); session.close ();4.2. MyBatis
MyBatis blev introduceret i 2010 og er en SQL mapper-ramme med enkelhed som styrke. I en anden vejledning talte vi om, hvordan man integrerer MyBatis med Spring og Spring Boot. Her vil vi fokusere på, hvordan du konfigurerer MyBatis direkte.
For at bruge det skal vi tilføje mybatis afhængighed:
org.mybatis mybatis 3.5.3 Forudsat at vi genbruger Person klasse ovenfor uden kommentarer, kan vi fortsætte med at oprette en PersonMapper grænseflade:
offentlig grænseflade PersonMapper {String selectAll = "SELECT * FROM Person"; @Vælg (selectAll) @Results (værdi = {@Result (egenskab = "id", kolonne = "ID"), @Result (egenskab = "fornavn", kolonne = "FIRST_NAME"), @Result (egenskab = "efternavn ", column =" LAST_NAME ")}) List selectAll (); }Det næste trin handler om MyBatis-konfigurationen:
KonfigurationsinitMybatis () kaster SQLException {DataSource dataSource = getDataSource (); TransactionFactory trxFactory = ny JdbcTransactionFactory (); Miljø env = nyt miljø ("dev", trxFactory, dataSource); Configuration config = new Configuration (env); TypeAliasRegistry aliases = config.getTypeAliasRegistry (); aliases.registerAlias ("person", Person.class); config.addMapper (PersonMapper.class); returkonfiguration; } DataSource getDataSource () kaster SQLException {MysqlDataSource dataSource = ny MysqlDataSource (); dataSource.setDatabaseName ("test"); dataSource.setServerName ("localhost"); dataSource.setPort (3306); dataSource.setUser ("brugernavn"); dataSource.setPassword ("adgangskode"); dataSource.setServerTimezone ("UTC"); returnere datakilde; }Konfigurationen består i at oprette en Konfiguration objekt, som er en beholder til indstillinger som f.eks Miljø. Den indeholder også datakildens indstillinger.
Vi kan derefter bruge Konfiguration objekt, som normalt oprettes en gang for en applikation til at oprette et SqlSessionFactory:
Konfigurationskonfiguration = initMybatis (); SqlSessionFactory sqlSessionFactory = ny SqlSessionFactoryBuilder (). Build (konfiguration); prøv (SqlSession session = sqlSessionFactory.openSession ()) {PersonMapper mapper = session.getMapper (PersonMapper.class); Listepersoner = mapper.selectAll (); // gør noget med listen over personer ...}4.3. Apache Cayenne
Apache Cayenne er en udholdenhedsramme, hvis første udgivelse går tilbage til 2002. For at lære mere om det, foreslår vi at læse vores introduktion til Apache Cayenne.
Lad os som sædvanligt tilføje cayenne-server Maven afhængighed:
org.apache.cayenne cayenne-server 4.0.2 Vi vil specifikt fokusere på MySQL-forbindelsesindstillingerne. I dette tilfælde konfigurerer vi cayenne-project.xml:
Efter den automatiske generation af datamap.map.xml og Person klasse i form af en CayenneDataObject, kan vi udføre nogle forespørgsler.
For eksempel fortsætter vi som tidligere med en select all:
ServerRuntime cayenneRuntime = ServerRuntime.builder () .addConfig ("cayenne-project.xml") .build (); ObjectContext context = cayenneRuntime.newContext (); Listepersoner = ObjectSelect.query (Person.class) .select (context); // gør noget med listen over personer ...5.Tilslutning ved hjælp af fjederdata
Spring Data er en Spring-baseret programmeringsmodel til dataadgang. Teknisk set er Spring Data et paraplyprojekt, der indeholder mange delprojekter, der er specifikke for en given database.
Lad os se, hvordan man bruger to af disse projekter til at oprette forbindelse til en MySQL-database.
5.1. Forårsdata / JPA
Spring Data JPA er en robust ramme, der hjælper med at reducere kedelpladekode og tilvejebringer en mekanisme til implementering af grundlæggende CRUD-operationer via en af flere foruddefinerede lagergrænseflader. Ud over dette har den mange andre nyttige funktioner.
Sørg for at tjekke vores introduktion til Spring Data JPA for at lære mere.
Det spring-data-jpa artefakt kan findes på Maven Central:
org.springframework.data spring-data-jpa 2.2.4.RELEASE Vi fortsætter med at bruge Person klasse. Det næste trin er at konfigurere JPA ved hjælp af annoteringer:
@Configuration @EnableJpaRepositories ("packages.to.scan") offentlig klasse JpaConfiguration {@Bean public DataSource dataSource () {DriverManagerDataSource dataSource = ny DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC"); dataSource.setUsername ("brugernavn"); dataSource.setPassword ("adgangskode"); returnere datakilde; } @Bean public JpaTransactionManager transactionManager (EntityManagerFactory emf) {returner ny JpaTransactionManager (emf); } @Bean public JpaVendorAdapter jpaVendorAdapter () {HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter (); jpaVendorAdapter.setDatabase (Database.MYSQL); jpaVendorAdapter.setGenerateDdl (sand); returner jpaVendorAdapter; } @Bean offentlig LocalContainerEntityManagerFactoryBean entityManagerFactory () {LocalContainerEntityManagerFactoryBean lemfb = ny LocalContainerEntityManagerFactoryBean (); lemfb.setDataSource (dataSource ()); lemfb.setJpaVendorAdapter (jpaVendorAdapter ()); lemfb.setPackagesToScan ("packages.containing.entity.classes"); returner lemfb; }}For at lade Spring Data implementere CRUD-operationerne, er vi nødt til at oprette en grænseflade, der udvider CrudRepository grænseflade:
@Repository offentlig grænseflade PersonRepository udvider CrudRepository {}Og endelig, lad os se et eksempel på select-all med Spring Data:
personRepository.findAll (). forEach (person -> {// gør noget med den udpakkede person});5.2. Forårsdata / JDBC
Spring Data JDBC er en begrænset implementering af Spring Data-familien med sit primære mål at give enkel adgang til relationsdatabaser.
Af denne grund giver den ikke funktioner som caching, snavset sporing, doven indlæsning og mange andre JPA-funktioner.
Denne gang er den Maven-afhængighed, vi har brug for fjeder-data-jdbc:
org.springframework.data spring-data-jdbc 1.1.4.RELEASE Konfigurationen er lettere sammenlignet med den, vi brugte i det forrige afsnit for Spring Data JPA:
@Configuration @EnableJdbcRepositories ("packages.to.scan") offentlig klasse JdbcConfiguration udvider AbstractJdbcConfiguration {// NamedParameterJdbcOperations bruges internt til at indsende SQL-udsagn til databasen @Bean NamedParameterJdbcOperations-operationer () {returner NamadParameter) } @Bean PlatformTransactionManager transactionManager () {returner ny DataSourceTransactionManager (dataSource ()); } @Bean public DataSource dataSource () {DriverManagerDataSource dataSource = ny DriverManagerDataSource (); dataSource.setDriverClassName ("com.mysql.cj.jdbc.Driver"); dataSource.setUrl ("jdbc: mysql: // localhost: 3306 / test? serverTimezone = UTC"); dataSource.setUsername ("brugernavn"); dataSource.setPassword ("adgangskode"); returnere datakilde; }}I tilfælde af Spring Data JDBC er vi nødt til at definere en ny Person klasse eller ændre den eksisterende for at tilføje nogle forårsspecifikke kommentarer.
Dette skyldes, at Spring Data JDBC tager sig direkte af enhedskortlægningen i stedet for dvaletilstand:
import org.springframework.data.annotation.Id; import org.springframework.data.relational.core.mapping.Column; import org.springframework.data.relational.core.mapping.Table; @Table (value = "Person") Person i offentlig klasse {@Id Lang id; @Column (værdi = "FIRST_NAME") Streng fornavn; @Column (værdi = "LAST_NAME") Strengens efternavn; // getters og setters}Med Spring Data JDBC kan vi også bruge CrudRepository interface. Så erklæringen vil være identisk med den, vi skrev ovenfor i Spring Data JPA-eksemplet. Ligeledes gælder det samme for alt-i-eksemplet.
6. Konklusion
I denne vejledning har vi set flere forskellige måder at oprette forbindelse til en MySQL-database fra Java. Vi startede med den essentielle JDBC-forbindelse. Derefter kiggede vi på almindeligt anvendte ORM'er som Hibernate, Mybatis og Apache Cayenne. Endelig kiggede vi på Spring Data JPA og Spring Data JDBC.
Brug af JDBC eller Hibernate API'er betyder mere kedelpladekode. Brug af robuste rammer, såsom Spring Data eller Mybatis, kræver mere konfiguration, men giver en betydelig fordel, fordi de leverer standardimplementeringer og funktioner som caching og doven indlæsning.
Java bund
