Después de aprender SpringDataJpa, perdí un poco

Prólogo

SpringDataJpa, como Mybatis, está en la capa de persistencia de la arquitectura de tres niveles, que se ocupa específicamente de la base de datos. Luego uso Mybatis bien. ¿Por qué debería aprender SpringDataJpa nuevamente? Esto comienza con la definición.

1. JPA

JPA, el nombre completo es Java Persistence Api, Java Persistence Interface, no es una tecnología, sino una especificación . Como especificación, desacopla el proceso de creación de objetos Java del formulario de creación específico. En nuestro programa, no todos los objetos Java se conservan, solo se retienen los objetos comerciales clave. La especificación JPA es para permitirnos personalizar qué objetos se deben retener y cómo retener estos objetos en la aplicación Java.

2. Hibernar

Hibernate es el primer marco de capa de persistencia que también aprendí cuando estaba en la universidad. Es un marco que sigue la especificación JPA. También hay artículos que dicen que Hibernate es el predecesor de JPA. En resumen, Hibernate es un marco de capa de persistencia de peso pesado. Se caracteriza por un alto costo de aprendizaje y una automatización total, y estas características también lo hacen inadecuado para proyectos de Internet.

3. Mybatis

Mybatis e Hibernate tienen la misma función, y ambos interactúan con la base de datos, pero el posicionamiento es diferente. El peso ligero de Mybatis y su personalización SQL lo convierten en la primera opción para el marco de capa de persistencia de los proyectos de Internet. Por supuesto, SQL requiere que los desarrolladores escriban (incluso si es una anotación) Las características del modelo) lo hacen inferior al Hibernate que sigue a JPA frente a proyectos tradicionales, por lo que la tecnología no tiene un nivel alto o bajo, solo la diferencia en el objetivo.

4. SpringDataJpa

Habiendo dicho tanto, ¿qué es exactamente SpringDataJpa? Tengo entendido que todavía es una nueva encapsulación de JPA, el estado es entre JPA y la tecnología de aterrizaje real (como Hibernate), por lo que SpringDataJpa todavía no es una "tecnología de trabajo", Hibernate es el trabajador del trabajo, SpringDataJpa es la asignación Capataz de trabajo. La razón es que, según SpringDataJpa, también puede especificar qué marco de capa de persistencia usar para interactuar con la base de datos. Además, creo que en el mundo actual de Spring, elegir SpringDataJpa en la selección de la tecnología del proyecto puede integrarse mejor con Spring, lo cual es una ventaja oculta. Vea el archivo de configuración para más detalles:

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

    <!--对Spring和SpringDataJpa进行配置-->

    <!--1.数据源-->
    <context:property-placeholder location="classpath*:jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>



    <!--2.配置Jpa中一个非常重要的对象——entityManagerFactory
    它相当于MyBatis中的SqlSessionFactory，就是一些框架的细节配置-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>

        <!--配置包扫描：packagesToScan
        ，就是框架要帮我们生成sql，那要帮哪些pojo对应的数据表生成呢？就指定pojo包路径，告诉框架去生成可以操作这个包下的pojo类的sql-->
        <property name="packagesToScan" value="cn.lamb.pojo"/>

        <!--指定jpa的具体实现：persistenceProvider(持久化提供者)
        ，jpa是一种规范，并不直接操作持久层，它的具体实现要靠遵循jap规范的持久化层框架，这里使用的是Hibernate，所以将它指定为jpa的具体实现-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>

        <!--指定jpa的方言
        ，不同框架对sql的处理是不同的，每种框架都有自己的一套“规则”，所以要指定方言，这里要和persistenceProvider一致-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>

        <!--===================既然使用的是Hibernate框架做具体实现，那么也要对hibernate做具体配置========================-->

        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--需不需要在每次程序启动时创建不存在的数据表
                ，这个不需要我们操心-->
                <property name="generateDdl" value="false"/>

                <!--现在Hibernate要处理什么数据库-->
                <property name="database" value="MYSQL"/>

                <!--要和现在使用的数据库有照应
                ，数据库之间的语法或多或少有差异，因此要根据database设置方言-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>

                <!--是否显示SQL
                ，操作数据库时是否打印SQL-->
                <property name="showSql" value="true"/>
            </bean>
        </property>

    </bean>



    <!--3.使用上面的entityManagerFactory
    <jpa:repositories>配置jpa的Dao层细节
    base-package指定Dao层 -->
    <jpa:repositories base-package="cn.lamb.dao" entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="jpaTransactionManager"/>



    <!--4.事务处理器
    ，Mybatis、jdbcTemplate使用的事务管理器是org.springframework.jdbc.datasource.DataSourceTransactionManager
                        jpa使用的事务管理器是org.springframework.orm.jpa.JpaTransactionManager-->
    <bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>


    <!--5.开启Spring包扫描-->
    <context:component-scan base-package="cn.lamb"/>

</beans>
复制代码

Di algunas palabras mas

Hablando de operar la base de datos, se puede dividir aproximadamente en dos etapas:

Etapa JDBC: Principiante JDBC utilizará la API JDBC nativa para interactuar con la base de datos escribiendo código muerto.
Utilizará el conjunto de conexiones de la base de datos: por ejemplo: c3p0, dbcp, druid e incluso algunas herramientas de terceros, como dbutils.

Creo que JDBC es el que nunca cambia, y se ejecuta todo el tiempo. Incluso cuando se trata del marco, integrará JDBC, entonces, ¿cuándo volverá a la simplicidad y recogerá el código fuente de JDBC?