精华内容
下载资源
问答
  • 主流数据持久层框架特性与实践 1.什么是数据持久层数据持久层负责对数据库中的数据进行增删改查。 2.JDBC是什么?有什么缺点? JDBC代表Java Database Connectivity,它是提供了一组Java API来访问关系数据库...

    1.什么是数据持久层?

    数据持久层负责对数据库中的数据进行增删改查。

    2.JDBC是什么?有什么缺点?

    JDBC代表Java Database Connectivity,它是提供了一组Java API来访问关系数据库的Java程序。使用框架的访问都是在原生的JDBC基础上进行封装。

    缺点:需要写的代码量比较多,不利于快速开发

    获取到的结果集非面向对象,解析结果的时候需要自己编码处理

    3.主流数据持久层框架有哪些?

    Hibernate, MyBatis, Springdata Jpa

    4.Hibernate

    Hibernate是一个采用ORM的主流数据持久层框架。

    - ORM框架
    - 提供简单APIs直接储存和检索数据库,不需要程序员写SQL

    5.MyBatis特点

    - 半ORM框架
    - 需要程序员自己维护SQL,一方面可以增加对SQL的掌控,有利于提高某些SQL执行速度,另一方面也增加了工作量和代码量
    - 因为需要自己维护SQL,不利于在不同数据库之间移植

    6.Spring Data Jpa

    JPA是Sun公司提出的一套持久化规范,意在整合ORM框架,简化开发。

    Spring Data Jpa是Spring生态的一部分。Spring Data Jpa进一步精简了ORM框架的代码量,可以做到无缝切换ORM,而无需改变代码。

    展开全文
  • 1.数据持久层   主流的数据持久层技术按照其实现思路分为4类技术方案,包括基于数据库连接(JDBC封装)、命令转换(SQL Mapping)、对象关系映射(O/R Mapping)和数据持久化对象(Entity Bean)。   Hibernate...

    1.数据持久层

      主流的数据持久层技术按照其实现思路分为4类技术方案,包括基于数据库连接(JDBC封装)、命令转换(SQL Mapping)、对象关系映射(O/R Mapping)和数据持久化对象(Entity Bean)。
      Hibernate和iBatis是轻量级Java EE框架中两种数据持久层技术,两者都是优秀的开源项目。iBatis相对简单易学而且更灵活,但是开发工作量大,数据之间是关联关系;Hibernate框架相对复杂,所生成的持久化对象能够表达面向对象中的继承和聚合等关系,开发工作量较小,且能适用目前所有主流的关系数据库。

    2.状态图和活动图

      状态图用来描述一个特定对象的所有可能状态以及其引发状态转移的事件,一个状态图包括一系列的状态及状态之间的转移,状态图通常用于表示单个对象在其生命周期中的行为。活动图用来描述操作的行为,但也用于描述用例和对象内部的工作过程。状态图和活动图都是用来描述系统的动态行为特征的,主要用于描述事物的状态变化和处理过程。
      本质区别,状态图和活动图用于不同的目的,状态图着重描述一系列的状态及状态间的转移,状态间的变迁需要外部事件的触发。活动图用于捕获动作及动作的结果,活动图中一个活动结束将立即进入下一个活动,是内部处理驱动的流程

    展开全文
  • 软考高级系统架构设计师:数据持久层一、数据持久层二、数据持久层好处三、采用Hibernate框架实现数据持久层四、数据持久层技术分类 MVC模式: 表示层 业务逻辑层 数据持久层 数据层 简要说明数据持久层,使用数据...

    MVC模式:

    • 表示层
    • 业务逻辑层
    • 数据持久层
    • 数据层

    简要说明数据持久层,使用数据持久层的好处

    一、数据持久层

    • 根据分层思想,通过建立逻辑数据操作接口,采取一定的对象/关系映射策略隐藏数据库访问代码细节,向开发人员提供透明的对象持久化操作机制。

    二、数据持久层好处

    • 分离业务逻辑层和数据层,降低两者之间的耦合
    • 通过对象/关系映射向业务逻辑提供面向对象的数据访问
    • 简化数据层访问,隐藏数据库链接、数据读写命令和事物管理细节。

    三、采用Hibernate框架实现数据持久层

    项目组应该采用Hibernate框架。

    • Hibernaete支持不同类型数据库,满足项目组数据库移植需求
    • Hibernate相对于iBatis减少了SQL语句开发的工作量
    • iBatis生成的PO是扁平化的,无法像Hibernate一样支持对象的继承和聚合等立体化关系。

    四、数据持久层技术分类

    • JDBC封装:Spring JdbcTemplate
    • SQL Mapping:iBatis/MyBatis
    • O/R Mapping:TopLink、JDO、Hibernate
    • Entity Bean:BMP、CMP
    展开全文
  • 一、目标 1:实现一个数据持久层框架,既能像JPA那样不用写sql直接调用框架自带方法操作数据库,又能像mybatis那样执行自定义sql语句。 2:能够在spring中使用,支持spring事务管理。 3:能够拦截sql,并在自定义拦截器...

    一、目标

           1:实现一个数据持久层框架,既能像JPA那样不用写sql直接调用框架自带方法操作数据库,又能像mybatis那样执行自定义sql语句。

           2:能够在spring中使用,支持spring事务管理。

           3:能够拦截sql,并在自定义拦截器判断是否执行sql。

           4:插入数据后能选择性将数据库自增列的值写回插入的数据对象。

    二、实现思路

           1:新增接口SqlSession,提供数据库操作方法供用户操作。

           2:新增接口SqlGenerator,生成sql语句,供SqlSession实现类调用。

           3:新增接口Executor,执行Sql语句,供SqlSession实现类调用。

           4:新增接口ResultSetHandler,将结果集封装成返回对象,供Executor实现类调用。

           5:新增接口Transaction,内部包含数据库连接(Connection)成员对象,供Executor实现类调用。

           6:核心接口图:

    三、核心代码

    1:Sql拦截器拦截SqlSession

    基于java动态代理实现,Executor拦截与此类似。

    @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //执行拦截器
            Configuration configuration = this.sqlSession.getConfiguration();
            List<Interceptor> interceptorList = configuration.getInterceptorList();
            for (Interceptor interceptor : interceptorList) {
                List<InterceptorScopeEnum> scopeEnums = interceptor.getInterceptorScopes();
                if (scopeEnums == null || scopeEnums.isEmpty() || !scopeEnums.contains( InterceptorScopeEnum.SQL_SESSION )) continue;
    
                if ( !interceptor.process( new Invocation(method, args) ) ) return null;
            }
            //保存方法返回类型等信息,供处理结果集使用
            String methodName = method.getName();
            if ( sqlSessionMethodNames.contains(methodName) ){
                if ( configuration.getMethodSignature(methodName) == null){
                    configuration.addMethodSignature(methodName, new MethodSignature(method));
                }
            }
            return method.invoke(this.sqlSession, args);
        }

    2:封装结果集成返回结果

    @Override
        public <E> E handleResultSetsForSingle(ResultSet resultSet, Class<E> clazz) throws SQLException {
            if ( !resultSet.next() ) return null;
    
            //属性与对应的setter方法,去除sql忽略的属性
            Map<String, Method> methodMap = this.getFieldSetterMethodMap(clazz);
            //数据库字段名与对象字段名映射关系
            Map<String, String> fieldNameMap = EdrHelper.getFieldDbRelateEntity(clazz);
            try {
                return this.generateRsObj(clazz, resultSet, methodMap, fieldNameMap);
            } catch (Exception ex) {
                LOG.error("Building result from database Error", ex);
                throw new BuildResultException("Building result from database Error", ex);
            }
        }
    
        private <E> E generateRsObj(Class<E> clazz, ResultSet resultSet, Map<String, Method> methodMap, Map<String, String> fieldNameMap) throws Exception{
            ResultSetMetaData metaData = resultSet.getMetaData();
            final int columnCount = metaData.getColumnCount();
            if (columnCount == 1){
                try {
                    Constructor<E> constructor = clazz.getDeclaredConstructor(clazz);
                    Object javaObj = configuration.getTypeHandler().jdbcToJavaBeanType(resultSet, 1, clazz);
                    E instance = constructor.newInstance(javaObj);
                    //再走一遍javaBean逻辑,尽最大努力避免出错
                    return this.generateRsByJavaBean(instance, resultSet, methodMap, fieldNameMap);
                } catch (Exception ex){}
            }
            E instance = clazz.getDeclaredConstructor().newInstance();
            return this.generateRsByJavaBean(instance, resultSet, methodMap, fieldNameMap);
        }
    
    private <E> E generateRsByJavaBean(E instance, ResultSet resultSet, Map<String, Method> methodMap, Map<String, String> fieldNameMap) throws Exception {
            if (methodMap.isEmpty() || fieldNameMap.isEmpty()) return instance;
    
            //走javaBean逻辑
            ResultSetMetaData metaData = resultSet.getMetaData();
            final int columnCount = metaData.getColumnCount();
            int i = 0;
            TypeHandler typeHandler = configuration.getTypeHandler();
            while (i++ < columnCount){
                String columnName = metaData.getColumnName(i);
                Method method = methodMap.get( fieldNameMap.get(columnName) );
                if (method == null){
                    continue;
                }
                Object javaObj = typeHandler.jdbcToJavaBeanType(resultSet, i, method.getParameterTypes()[0]);
                method.invoke(instance, javaObj);
            }
            return instance;
        }

    3:接入Spring事务管理

    1:  新增SpringSqlSessionUtil类用于spring环境下SqlSession的获取关闭等操作,spring事务管理原理可参考之前的文章:https://blog.csdn.net/qq_41633199/article/details/115832730

    SpringSqlSessionUtil类核心代码。

    //sql session是否处于Transactional作用范围
        public static boolean isSqlSessionTransactional(SqlSession session, SqlSessionFactory sessionFactory) {
            Assert.notNull(session, "No SqlSession specified");
            Assert.notNull(sessionFactory, "No SessionFactory specified");
    //通过SqlSessionFactory获取以便兼容多数据源情况下含有多个连接池的情况。
            SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    
            return holder != null && holder.getSqlSession() == session;
        }
    
        public static SqlSession getSqlSession(SqlSessionFactory sessionFactory) {
            Assert.notNull(sessionFactory, "No SqlSession specified");
    
            SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    
            SqlSession session = sessionTransactionHolder(holder);
            if (session != null) {
                if ( session.isClosed() ){
                    LOG.warn("SqlSession has been closed!");
                } else {
                    return session;
                }
            }
    
            session = sessionFactory.openSession();
            //注册到spring事务管理中去
            registerSessionHolder(sessionFactory, session);
            return session;
        }
    
        public static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) {
            Assert.notNull(session, "No SqlSession specified");
            Assert.notNull(sessionFactory, "No SessionFactory specified");
    
            SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
            if (holder != null && holder.getSqlSession() == session) {
                holder.released();
            } else {
                session.close();
            }
        }
    
        //获取Transaction范围内的sqlSession
        private static SqlSession sessionTransactionHolder(SqlSessionHolder holder) {
            SqlSession session = null;
            if (holder != null && holder.isSynchronizedWithTransaction()) {
                holder.requested();
    
                session = holder.getSqlSession();
            }
            return session;
        }
    
        private static void registerSessionHolder(SqlSessionFactory sessionFactory, SqlSession session) {
            SqlSessionHolder holder;
            if ( TransactionSynchronizationManager.isSynchronizationActive() ) {//当前线程是否存在活跃的事务同步器
                TransactionFactory transactionFactory = session.getConfiguration().getTransactionFactory();
    
                if (transactionFactory instanceof SpringManagedTransactionFactory) {
    
                    holder = new SqlSessionHolder(session);
                    //sqlSession写入threadLocal
                    TransactionSynchronizationManager.bindResource(sessionFactory, holder);
                    //注册事务回调
                    TransactionSynchronizationManager.registerSynchronization(new SqlSessionTransactionSyncAdapter(sessionFactory, holder));
                    holder.setSynchronizedWithTransaction(true);
                    holder.requested();
                } else {
                    //检查是否设置了数据连接池到spring事务环境
                    if (TransactionSynchronizationManager.getResource( session.getConfiguration().getDataSource() ) == null) {
                        if ( LOG.isWarnEnabled() ) {
                            LOG.warn("SqlSession [{}] was not registered for synchronization because DataSource is not transactional", session);
                        }
                    } else {
                        throw new TransientDataAccessResourceException(
                                "SqlSessionFactory must be using a SpringManagedTransactionFactory in order to use Spring transaction synchronization");
                    }
                }
            } else {
                if ( LOG.isWarnEnabled() ) {
                    LOG.warn("SqlSession [{}] was not registered for synchronization because synchronization is not active", session);
                }
            }
        }

    2:  SpringSqlSessionUtil类用到的事务回调SqlSessionTransactionSyncAdapter继承了spring事务的TransactionSynchronizationAdapter类,其关键方法如下:

    @Override//事务终止回调
        public void suspend() {
            if (this.sqlSessionHolderActive){
                TransactionSynchronizationManager.unbindResource(this.sqlSessionFactory);
            }
        }
    
        @Override
        public void resume() {//重试
            if (this.sqlSessionHolderActive){
                TransactionSynchronizationManager.bindResource(this.sqlSessionFactory, this.sqlSessionHolder);
            }
        }
    
        @Override
        public void beforeCommit(boolean readOnly) {
            if ( TransactionSynchronizationManager.isActualTransactionActive() ){
                this.sqlSessionHolder.getSqlSession().commit();
            }
        }
    
        @Override
        public void beforeCompletion() {
            if ( !this.sqlSessionHolder.isOpen() ) return;
            //从threadLocal移除
            TransactionSynchronizationManager.unbindResource(this.sqlSessionFactory);
            //释放数据库连接
            this.sqlSessionHolder.getSqlSession().close();
        }
    
        @Override
        public void afterCompletion(int status) {
            if (this.sqlSessionHolderActive) {
                TransactionSynchronizationManager.unbindResourceIfPossible(this.sqlSessionFactory);
                this.sqlSessionHolderActive = false;
                this.sqlSessionHolder.getSqlSession().close();
            }
            this.sqlSessionHolder.reset();
        }

    3:新增数据库连接容器类SpringManagedTransaction,实现Transaction接口,内部包含数据库连接对象Connection,这里需要在获取数据库连接和关闭数据库连接方法中接入到spring:

    public Connection getConnection() throws SQLException {
            if (this.connection != null) return this.connection;
    
            this.openConnection();
            return this.connection;
        }
    
        protected void openConnection() throws SQLException {
            if (this.dataSource == null) return;
    
            this.connection = DataSourceUtils.getConnection(this.dataSource);
            if (this.connection == null) return;
            this.autoCommit = this.connection.getAutoCommit();
            this.closed = false;
    
            this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
        }
    
    public void close() {
            DataSourceUtils.releaseConnection(this.connection, this.dataSource);
            this.closed = true;
        }

    4:  新增类SpringManagedSqlSessionProxy,基于java动态代理,用来将SqlSession接入spring管理中,并支持事务回滚等,核心代码如下:

    @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            SqlSession sqlSession = SpringSqlSessionUtil.getSqlSession(this.sqlSessionFactory);
    
            try {
                Object rs = method.invoke(sqlSession, args);
                //没有纳入spring事务中,直接提交
                if ( !SpringSqlSessionUtil.isSqlSessionTransactional(sqlSession, this.sqlSessionFactory) ){
                    sqlSession.commit();
                }
                return rs;
            } catch (Throwable throwable){
                throw throwable;
            } finally {
                if (sqlSession != null){
                    SpringSqlSessionUtil.closeSqlSession(sqlSession, this.sqlSessionFactory);
                }
            }
        }

    5:新增类SpringManagedSqlSessionFactory用于生成SpringManagedSqlSessionProxy代理对象,核心代码:

    @Override
        public SqlSession openSession() {
            SqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(this.configuration, this.sqlGenerator, this.resultSetHandler);
            //构建代理对象spring manage
            return (SqlSession) Proxy.newProxyInstance(SqlSession.class.getClassLoader(), new Class[]{SqlSession.class}, new SpringManagedSqlSessionProxy(defaultSqlSessionFactory));
        }

    4:构建spring-boot-starter

            将SqlSessionFactory对象存入spring bean容器,以便业务代码中能自动注入该对象再获取SqlSession。核心代码如下:

    /**
     *持久化框架 edr自动配置
     * @author tfq qq:1394965066
     */
    @Configuration
    @ConditionalOnMissingBean(SqlSessionFactory.class)
    @ConditionalOnClass(DefaultSqlSessionFactory.class)
    @ConditionalOnBean({DataSource.class, Environment.class})
    @AutoConfigureAfter(DataSourceAutoConfiguration.class)//指定顺序
    public class SmpEdrAutoConfiguration {
    
        @Bean
        public SqlSessionFactory buildDefaultSessionFactory(DataSource dataSource, Environment environment){
            LoggerFactory.getLogger(SmpEdrAutoConfiguration.class).debug("Init DefaultSqlSessionFactory of SmpEdr");
    //拦截器
            String interceptors = environment.getProperty("com.lauor.smpedr.interceptors");
    
            com.lauor.smpedr.Configuration configuration = new com.lauor.smpedr.Configuration(dataSource, new SpringManagedTransactionFactory());
            configuration = this.bindInterceptors(interceptors, configuration);
    
            SqlSessionFactory sqlSessionFactory = new SpringManagedSqlSessionFactory(configuration, new SqlGeneratorMysql());
            return sqlSessionFactory;
        }
    
        //设置拦截器
        private com.lauor.smpedr.Configuration bindInterceptors(String interceptors, com.lauor.smpedr.Configuration configuration){
            if ( Str.isEmpty(interceptors) ) return configuration;
    
            String[] interceptorArr = interceptors.split(",");
            for (String interceptor : interceptorArr) {
                try {
                    Class interceptorCls = ClassUtils.forName(interceptor, this.getClass().getClassLoader());
                    Constructor constructor = interceptorCls.getDeclaredConstructor();
                    configuration.addInterceptor( (Interceptor) constructor.newInstance() );
                } catch (Exception ex){
                    LoggerFactory.getLogger(SmpEdrAutoConfiguration.class).error(String.format("error to add interceptor: %s", interceptor), ex);
                    System.exit(-1);
                }
            }
            return configuration;
        }
    }

    5:springboot使用

          引入依赖后直接通过sqlSessionFactory bean操作DBMS。

    6:使用JMeter进行压力测试

       1:测试机器性能参数

            处理器: Intel(R) Core(TM) i7-8550U CPU @ 1.8GHZ

            内存: 8GB

            硬盘: 固态硬盘/嵌入式多媒体控制器 (EMMC) 1 238GB, Micron_1100_MTFDDAV256TBN

            系统:windows10家庭中文版

        2:  测试样例

             一分钟1200次查询单表前10条数据,时间排序,无缓存,总记84万三千次请求。

        3:  测试结果

    7:源码地址

         完整代码:https://gitee.com/tandatda/smpedr

         使用完整demo:https://gitee.com/tandatda/demo-edr-smpdb

    展开全文
  • 在处理数据时,将数据库分成了冷库和热库 2 个库,不常用数据放冷库,常用数据放热库。通过这样的方法处理后,常用的数据量大大减少了,也大大提升了数据库响应速度。
  • 数据库持久层

    2021-01-19 11:03:23
    http://ibatis.apache.org/dotnet.cgihttp://www.orm.net/ibatis, hibernate一、目前流行的 ORM 产品目前众多厂商和开源社区都提供了持久层框架的实现,常见的有:Apache OJB (http://db.apache.org/ojb/)Cayenne ...
  • 持久化和持久层

    2021-05-22 09:07:53
    所谓持久化就是把内存中的数据同步保存到数据库(如关系数据库)或永久存储设备(如硬盘、磁带等)中,其原理如图4-1所示 ...从上图不难发现,持久层封装了所有与数据库有关的操作和细节,作为一个专业的持久层
  • 关于Java的持久层种类,可谓是多之甚多,各种介绍也是铺天盖地。每个人都在讲各个持久层之类的区别,这边我对这些持久层就不再多废话了,今天主要介绍下proc、jdbc、hibernate以及ibatis操作数据库效率比较。由于...
  • 数据持久层 百度百科: 数据持久层位于领域层和基础架构层之间。由于对象范例和关系范例这两大领域之间存在“阻抗不匹配”,所以把数据持久层单独作为J2EE体系的一个层提出来的原因就是能够在对象-关系数据库之间...
  • } } } } } jdbc存在的问题: 自定义框架设计 使用端(项目):引入自定义持久层框架的jar包 提供两部分配置信息:数据库配置信息、sql配置信息:sql语句、参数类型、返回值类型 使用配置文件来提供这两部分信息: ...
  • 先说结论:2020年了,推荐mybatis-plus面向对象or程序逻辑和sql解耦?在之前hibernate和mybatis比较时,两者最主要的区别是hibernate用面相对象的方式解决数据库操作问题,sql相对来说是不透明的,甚至你换数据库都...
  • 是一个数据持久层(ORM)框架。 MyBatis框架 [1] iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO),同时还提供一个...
  • 原文关于"贫血模型"的讨论几乎没有停止过,在openfans.org的开发过程中,我们也讨论了很久,我觉的有很多东西应该记下来:明确一下意思先:DAO:数据操作对象,会操作数据库持久层:能提供对象持久化服务的一系列组件或服务...
  • springboob实现前端与后端的交互,实现分层mvc开发...持久层(Dao) 实体类(bean) 每层实现自己的功能 在Dao和Service层中,先定义一个接口,让实现类去实现接口中 的方法,这样都实现一个规范,更具有灵活性 ...
  • DAO模式为了减少业务逻辑和数据访问逻辑之间的耦合,当一个持久曾框架被应用时,该模式将会减少业务对象和该框架之间的耦合,这样我们可以不修改业务对象而选择不同的持久层框架的实现。实际上在DAO模式中包含两种...
  • 的文章,文中比较了四种流行的持久化框架:CMP Entity EJBs、JPA、Hibernate和TopLink.Acharya讨论了每种技术并在一个表格中总结了他的结论,其结论归结为:JPA适合J2SE和J2EE的简单框架,并入了其他框架...
  • Struts(表示层)+Spring(业务层)+Hibernate(持久层) Struts: Struts是一个表示层框架,主要作用是界面展示,接收请求,分发请求。 在MVC框架中,Struts属于VC层次,负责界面表现,负责MVC关系的分发。 (View...
  • Spring持久层

    2021-03-23 22:16:48
    spring为什么要与持久层技术整合 1、需要访问数据库。 2、jdbc、mybatis等存在代码冗余,对其进行整合。 jdbc——jdbcTemplate Hibernate——HibernateTemplate MyBatis——SqlSessionFactroyBean、...
  • 在我接触这个概念的时候好像是05年,那时候有hibernate出来很流行,各个企业招聘都不在只是j2ee了还要求struts和hibernate,我当时理解的数据库持久层就是就是数据库长链接,觉得设计的目的就是为了减少数据库服务的...
  • 框架定义在持久层,除提供ORMapping功能外加点权限控制。ORMapping的代码学习iBatis和ActiveRecord的做法,可使用任意一种,想象中xml应该这样子定义select c1,c2 from table where c1=:name调用时类似:sqlmap....
  • 转自:http://www.blogjava.net/jiabao/archive/2007/04/08/109189.html为了实现web层(struts)和持久层(Hibernate)之间的松散耦合,我们采用业务代表(Business Delegate)和DAO(Data Access Object)两种模式。...
  • java持久层框架数据源加密 文章目录学习目标: 1、 mybatis框架数据源加密 https://www.cnblogs.com/melovemingming/p/10699613.html 这里是引用https://www.cnblogs.com/melovemingming/p/10699613.html 2、 ...
  • 在绝大多数在线应用场景中,数据是存储在关系型数据库中的,当然,有特殊要求的场景中,我们也会将其他持久化存储(如 ElasticSearch、HBase、MongoDB 等)作为辅助存储。但不可否认的是,关系型数据库凭借几十年的...
  • 1.整合mybatis-plus的步骤 (1)导入依赖 com.baomidou mybatis-plus-boot-starter 3.4.3.1 mysql mysql-connector-java runtime (2)配置数据源 application.yml #配置连接数据库使用的数据源 spring: ...
  • 序列化定义:为了方便数据的传输,我们将对象转换为其他形式,比如字节的过程。 反序列化定义:将其他形式的数据转换为对象的过程。 举例:在淘宝上买了一件衣服,卖家为了方便快递送货,将衣服打包,这个打包的过程...
  • 框架实战系列(一)-持久层介绍篇">ABP框架实战系列(一)-持久层介绍篇 <li><a href="#abp%E6%A1%86%E6%9E%B6%E5%AE
  • 前言在使用数据库的时候,总会担心数据丢失,那在使用MySQL的时候,都有哪些情况可能造成数据丢失呢,...影响MySQL Innodb数据持久化的参数有:innodb_flush_log_at_trx_commitinnodb_doublewriteinnodb_flush_me...
  • 首先先说数据访问,这个一般都叫做Dao(Data Access Object),主要就是用来和数据库打交道的,该也目标和十分明确,就是需要我们在这写一些最底层的方法,比如最常见的几种:save、update、deleteById、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 305,020
精华内容 122,008
关键字:

数据持久层

友情链接: F-16非线性仿真.rar