精华内容
下载资源
问答
  • SpringBoot整合持久层技术进行一个项目的搭建,做一个练手,以前搞过但是都淡忘了,特意来总结一下。今天是JPA,后面陆续搭建MyBatis、JdbcTemplate等持久层技术,供大家相互学习。
  • 数据持久层在Web应用系统开发中,主要应用于业务逻辑和数据逻辑的松散耦合,提高软件可重用性。分析了Hibernate框架及DAO设计模式的工作原理,设计了基于Hibernate框架采用DAO设计模式的数据持久层架构体系,并通过...
  • 本文实例讲述了PHP基于MySQL数据库实现对象持久层的方法。分享给大家供大家参考。具体如下: 心血来潮,做了一下PHP的对象到数据库的简单持久层。 不常用PHP,对PHP也不熟,关于PHP反射的大部分内容都是现学的。 ...
  • NULL 博文链接:https://snowolf.iteye.com/blog/583161
  • 在本篇文章里小编给大家分享的是一篇关于Java持久层面试题目及答案整理内容,需要的朋友们学习参考下。
  • NULL 博文链接:https://zhangzhi199129.iteye.com/blog/1585556
  • java 实现自定义持久层框架代码,解析配置文件,手动封装返回结果,使用到了构建者模式、工厂模式、代理模式
  • MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google ...本文重点给大家介绍Java持久层框架MyBatis简单实例,非常不错,具有参考借鉴价值,感兴趣的朋友一起看下吧
  • mybatis持久层框架技术

    千人学习 2019-03-09 22:40:20
    MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息,将接口和...
  • MyBatis 本是apache的一个开源项目iBatis,接下来通过本文给大家介绍MyBatis持久层框架的用法知识小结,非常不错,具有参考借鉴价值,感兴趣的朋友一起学习吧
  • 解压后配置mysql-generator.xml文件中的数据库链接信息及表信息,双击generate.bat即可自动生成mysql持久层dao,实体类及映射文件mapper
  • Spring持久层的封装

    2016-03-18 12:03:47
    这份文档以例子的形式讲诉了Spring持久层的封装,希望可以帮助学习的人!
  • 是一个数据持久层(ORM)框架。 iBATIS一词来源于“internet”和“abatis”的组合,是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects(DAO),同时还提供一个利用这个框架开发...
  • Hibernate也是目前Java开发中最为流行的数据库持久层框架,现已归JBOSS所有。 它的设计目标是将软件开发人员从大量相同的数据持久层相关编程工作中解放出来。无论是从设计草案还是从一个遗留数据库开
  • 分析了数据持久层缓存的基本原理、缓存的范围,总结出持久化层缓存的并发访问策略以及哪些数据适合放在什么缓存范围内。最后结合当前流行的Hibernate第二级缓存插件,设计各个插件缓存的配置策略以及插件的使用范围。
  • Spring系列-持久层整合.md
  • 此份代码就是自动生成实体类,dao,及xml的工具,不需要自己手动添加,一键就能够自动生成,为开发省略了更多不必要的时间
  • java持久层框架对比

    2012-02-10 15:07:52
    java持久层框架对比
  • 这个是我自己利用反射机制封装的模仿hibernate的持久层工具,用于学习。里面有我的联系方式,工具类jar包和示例以及源码。有问题或者希望共通学习的同学可以联系我,寻求志同道合之人
  • 持久层开源工具MyBatis-Plus快速入门,Spring Boot整合MyBatis-Plus简化开发示例代码
  • SpringBoot整合持久层技术
  • mybatis持久层框架

    2014-06-16 11:36:14
    该配置文件描述mybatis持久层框架技术的,可有将SQL放到配置文件并且规范数据库连接等
  • EJB+JPA数据库持久层开发实践详解PDF,仅用学习使用,不可用于商业用途,如有版权问题,请联系删除!
  • 个人整理的一套Java WEB 持久层技术知识点的清单,学些一门语言有个知识导图对入门的人可能减少迷茫学习起来方便一点~ 另外有本人整理的Java Web开发其它知识点清单~
  • 使用springboot框架基础上使用MyBatis简化持久层开发。
  • Java持久层框架

    千次阅读 2020-05-28 22:19:46
    Spring Data JPA 进行持久层(即Dao)开发一般分三个步骤: (1)声明持久层的接口,该接口继承 Repository(或Repository的子接口,其中定义了一些常用的增删改查,以及分页相关的方法)。 (2)在接口中声明需要的...

    一、ORM框架

         ORM:对象关系映射(英语:(Object Relational Mapping,简称ORM,或O/RM,或O/R mapping),是一种程序技术,用于实现面向对象编程语言里不同类型系统的数据之间的转换 。从效果上说,它其实是创建了一个可在编程语言里使用的--"虚拟对象数据库"。面向对象是从软件工程基本原则(如耦合、聚合、封装)的基础上发展起来的,而关系数据库则是从数学理论发展而来的,两套理论存在显著的区别。为了解决这个不匹配的现象,对象关系映射技术应运而生。

         对象关系映射(ORM)是一种功能,用于通过将对象状态映射到数据库列来开发和维护对象和关系数据库之间的关系。 它能够轻松处理(或执行)各种数据库操作,如插入,更新,删除等。

    映射方向

    单向关系 - 在这种关系中,只有一个实体可以将属性引用到另一个实体。它仅包含一个侧面,由于指定如何更新可以在数据库中进行。

    双向关系 - 这种关系包含两边 - 既包含一个侧面,也包含另一个侧面。 所以这里每个实体都有一个关系字段或将该属性引用到其他实体。

    映射类型

    一对一 - 此关联由@OneToOne注释表示。在这里,每个实体的实例与另一个实体的单个实例相关。

    一对多 - 此关联由@OneToMany注释表示。 在这种关系中,一个实体的实例可以与另一个实体的多个实例相关联。

    多对一 - 此映射由@ManyToOne注释定义。 在这种关系中,一个实体的多个实例可以与另一个实体的单个实例相关联。

    多对多 - 此关联由@ManyToMany注释表示。 在这种关系中,一个实体的多个实例可能与另一个实体的多个实例有关。 在这个映射中,任何一方都可以成为所有者方。

    二、Mybatis

    什么是 MyBatis?

        MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML注解来配置和映射原始类型、接口和 Java POJO(Plain Old Java Objects,普通老式 Java 对象)为数据库中的记录。

    使用mybatis

      (1)引入jar包

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>x.x.x</version>
    </dependency>

     (2)从 XML 中构建 SqlSessionFactory

          每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。

    String resource = "org/mybatis/example/mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    XML 配置文件中包含了对 MyBatis 系统的核心设置,包括获取数据库连接实例的数据源(DataSource)以及决定事务作用域和控制方式的事务管理器(TransactionManager)。

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
      <environments default="development">
        <environment id="development">
          <transactionManager type="JDBC"/>
          <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${username}"/>
            <property name="password" value="${password}"/>
          </dataSource>
        </environment>
      </environments>
      <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
      </mappers>
    </configuration>

    (3)从 SqlSessionFactory 中获取 SqlSession

    try (SqlSession session = sqlSessionFactory.openSession()) {
      BlogMapper mapper = session.getMapper(BlogMapper.class);
      Blog blog = mapper.selectBlog(101);
    }

    (4)探究已映射的 SQL 语句  xml方式

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
      PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="org.mybatis.example.BlogMapper">
      <select id="selectBlog" resultType="Blog">
        select * from Blog where id = #{id}
      </select>
    </mapper>

    (5)通过java注解方式

    package org.mybatis.example;
    public interface BlogMapper {
      @Select("SELECT * FROM blog WHERE id = #{id}")
      Blog selectBlog(int id);
    }

    使用注解来映射简单语句会使代码显得更加简洁,但对于稍微复杂一点的语句,Java 注解不仅力不从心,还会让你本就复杂的 SQL 语句更加混乱不堪。 因此,如果你需要做一些很复杂的操作,最好用 XML 来映射语句。

    (6)MyBatis 动态SQL

      动态 SQL:MyBatis 的强大特性之一便是它的动态 SQL。

    <select id="findActiveBlogLike"
         resultType="Blog">
      SELECT * FROM BLOG 
      <where> 
        <if test="state != null">
             state = #{state}
        </if> 
        <if test="title != null">
            AND title like #{title}
        </if>
        <if test="author != null and author.name != null">
            AND author_name like #{author.name}
        </if>
      </where>
    </select>

    三、Spring Data JPA

    什么是Spring data jpa ?

      Spring data jpa 是较大的 spring家族的一部分,它使得很容易实现基于 jpa 的存储库。

      Spring Data JPA 进行持久层(即Dao)开发一般分三个步骤:

    (1)声明持久层的接口,该接口继承 Repository(或Repository的子接口,其中定义了一些常用的增删改查,以及分页相关的方法)。

    (2)在接口中声明需要的业务方法。Spring Data 将根据给定的策略生成实现代码。

    (3)在 Spring 配置文件中增加一行声明,让 Spring 为声明的接口创建代理对象。配置了 <jpa:repositories> 后,Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录,为继承 Repository 或其子接口的接口创建代理对象,并将代理对象注册为 Spring Bean,业务层便可以通过 Spring 自动封装的特性来直接使用该对象。

    (1)整合springboot,引入jar包

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>6.0.6</version>
    </dependency>

    (2)项目配置

    #通用数据源配置
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://10.110.2.56:3306/springboot_jpa?charset=utf8mb4&useSSL=false
    spring.datasource.username=springboot
    spring.datasource.password=springboot
    # Hikari 数据源专用配置
    spring.datasource.hikari.maximum-pool-size=20
    spring.datasource.hikari.minimum-idle=5
    # JPA 相关配置
    spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
    spring.jpa.show-sql=true
    spring.jpa.hibernate.ddl-auto=create

    (3)实体类

    @Entity
    @Table(name = "AUTH_USER")
    public class UserDO {
        @Id
        private Long id;
        @Column(length = 32)
        private String name;
        @Column(length = 32)
        private String account;
        @Column(length = 64)
        private String pwd;
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAccount() {
            return account;
        }
    
        public void setAccount(String account) {
            this.account = account;
        }
    
        public String getPwd() {
            return pwd;
        }
    
        public void setPwd(String pwd) {
            this.pwd = pwd;
        }
    }

    (4)持久层服务,实现JpaRepository可以包含很多可用的方法,比如分页,内置的各类查找,无需再编写代码实现。

    @Repository
    public interface UserDao extends JpaRepository<UserDO, Long> {
    }

     

     

    展开全文
  • 火龙果软件工程技术中心 本文内容包括:先决条件导入示例项目引入iBATIS实现StockService组件总结下载参考资料在完成SCAModule建模后用Java对象进行实现时,采用Hibernate和采用iBATIS实现SCAModule的数据持久层,...
  • 17-Spring持久层框架整合

    万次阅读 2020-11-04 19:15:23
    1.为什么Spring要与持久层框架进行整合 spring是一个优秀的框架,他的优秀支持就是能整合所有程序员想要让他整合的框架,这里所说的持久成也不例外。 JavaEE开发需要持久层进行数据库的访问操作,spring 当然不让。...

    上一篇:16-Spring 基于注解的AOP编程、AOP总结https://blog.csdn.net/fsjwin/article/details/109482768

    1.为什么Spring要与持久层框架进行整合

    spring是一个优秀的框架,他的优秀支持就是能整合所有程序员想要让他整合的框架,这里所说的持久成也不例外。

    • JavaEE开发需要持久层进行数据库的访问操作,spring
      当然不让。
    • JDBC Hibernate MyBatis进行持久开发过程存在大量的代码冗余
    • Spring基于模板设计模式对于上述的持久层技术进行了封装

    2.Spring要可以与那些持久层框架进行整合

    1. jdbc JdbcTemplate
    2. Hibernate (JPA) HibernateTemplate
    3. Mybatis SqlSessionFactoryBean、MapperScannerConfiger

    3.Mybatis开发回顾,在Spring没有整合前

    1. 实体
    2. 实体别名
    3. 创建DAO接口
    4. 实现Mapper文件(对maper编程)
    5. 注册Mapper文件
    6. MyBatisApi调用

    3.1 实体 User.java

    package mybatis;
    
    import java.io.Serializable;
    
    /**
     * @author yuhl
     * @Date 2020/11/4 10:51
     * @Classname User
     * @Description 1. 实体
     */
    public class User implements Serializable {
        private Integer id;
        private String name;
        private String password;
    
        public User() {
        }
    
        public User(Integer id, String name, String password) {
            this.id = id;
            this.name = name;
            this.password = password;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    
    

    3.2. 实体别名mybatis-config.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <typeAliases>
           <!-- 2. 实体别名-->
            <typeAlias alias="user" type="mybatis.User"/>
        </typeAliases>
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/yuhl?useSSL=false"/>
                    <property name="username" value="root"/>
                    <property name="password" value="root"/>
                </dataSource>
            </environment>
        </environments>
    
        <mappers>
    
    
        </mappers>
    </configuration>
    

    在这里插入图片描述

    3.3. 表

    在这里插入图片描述

    
    -- ----------------------------
    -- Table structure for t_user
    -- ----------------------------
    DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user`  (
      `id` int(0) NOT NULL AUTO_INCREMENT,
      `name` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
      `password` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
    
    

    3.4. 创建DAO接口 UserDao.java

    package mybatis;
    
    /**
     * @author yuhl
     * @Date 2020/11/4 10:59
     * @Classname UserDao
     * @Description TODO
     */
    public interface UserDao {
        //保存用户
        public void save(User user);
    }
    
    

    3.5. 实现Mapper文件UserDAOMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="mybatis.UserDao"> <!--接口名-->
        <!--id:mybatis.UserDao接口中的方法面
        parameterType:面向对象的对象名字-->
        <insert id="save" parameterType="user">
            insert into t_user(name,password) value (#{name},#{password})
        </insert>
    </mapper>
    

    3.6. 注册Mapper文件UserDAOMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <typeAliases>
           <!-- 2. 实体别名-->
            <typeAlias alias="user" type="mybatis.User"/>
        </typeAliases>
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/yuhl?useSSL=false"/>
                    <property name="username" value="root"/>
                    <property name="password" value="root"/>
                </dataSource>
            </environment>
        </environments>
    
        <mappers>
            <!--注册mapper.xml到mybatis-->
            <mapper resource="UserDAOMapper.xml"/>
        </mappers>
    </configuration>
    

    在这里插入图片描述

    3.7. MyBatisApi调用

    import mybatis.User;
    import mybatis.UserDao;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * @author yuhl
     * @Date 2020/11/4 11:06
     * @Classname MybatisTest
     * @Description 测试
     */
    public class MybatisTest {
    
        @Test
        public void test1(){
            try {
                //通过流加载mybatis的主配置文件:mybatis-config.xml
                InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
                //
                SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
                SqlSession sqlSession = sqlSessionFactory.openSession();
    
                UserDao userDao = sqlSession.getMapper(UserDao.class);
    
                userDao.save(new User("yuhl", "222222"));
                sqlSession.commit();
                sqlSession.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    }
    
    

    插入成功:
    在这里插入图片描述

    3.单纯的Mybatis编程存在的问题

    1. 配置繁琐 第2步和第7步
      如果有9999个类该怎办?
      在这里插入图片描述
    2. 代码冗余
      主要指的是API代码冗余 。
      在这里插入图片描述
      由于以上两个原因,我们不会使用mybatis单独做开发,会使用spring对于mybatis的整合,下面看对于整合后的mybitis的使用是不是更为丝滑呢!
      即spring可以积极2.6.7三个步骤的问题。

    4.Spring的Mybatis整合

    1. 实体
    2. 实体别名(<property name="typeAliasesPackage" value="com.yuhl.entity"/>)
    3. 表
    4. 创建DAO接口
    5. 实现Mapper文件(对maper编程)
    6. 注册Mapper文件(<value>classpath:com.yuhl.mapper/*DAOMapper.xml</value>)
    7. MyBatisApi调用(被优化了直接从factory.getBean("userDAO"))
    以上步在使用spring整合后
    	1. 实体
    	2. 表
    	3. 创建DAO接口
    	4. 实现Mapper文件(对maper编程)
    

    引入jar包:pom.xml 特别注意与mybatis整合是使用druid连接池

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>spring5_20201031</artifactId>
            <groupId>org.yuhl</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>Spring_mybatis</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>5.1.14.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.1.14.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>2.0.2</version>
            </dependency>
    
            <!--阿里巴巴连接池-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.18</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.48</version>
            </dependency>
    
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.4.6</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.11</version>
                <scope>test</scope>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.1.4.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.1.14.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>1.8.8</version>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.3</version>
            </dependency>
    
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>1.7.25</version>
            </dependency>
    
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
        </dependencies>
    
    </project>
    

    4.1在mybatis-config.xml中的有所东西均可以在applicationContex.xml配置消灭mybatis-config.xml

    在这里插入图片描述
    在这里插入图片描述
    至此可以完全消灭mybatis-config.xml文件。仅使用applicationContex.xml

    4.1 代码如下

    1. 实体User .java
    package com.yuhl.entity;
    
    import java.io.Serializable;
    
    /**
     * @author yuhl
     * @Date 2020/11/4 10:51
     * @Classname User
     * @Description 1. 实体
     */
    public class User implements Serializable {
        private Integer id;
        private String name;
        private String password;
    
        public User() {
        }
    
        public User(String name, String password) {
            this.name = name;
            this.password = password;
        }
    
        public User(Integer id, String name, String password) {
            this.id = id;
            this.name = name;
            this.password = password;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    
    
    1. 表t_user 复用之前的表
    -- ----------------------------
    -- Table structure for t_user
    -- ----------------------------
    DROP TABLE IF EXISTS `t_user`;
    CREATE TABLE `t_user`  (
      `id` int(0) NOT NULL AUTO_INCREMENT,
      `name` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
      `password` varchar(12) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
    

    3 创建DAO接口UserDAO.java

    package com.yuhl.dao;
    
    
    import com.yuhl.entity.User;
    
    /**
     * @author yuhl
     * @Date 2020/11/4 10:59
     * @Classname UserDao
     * @Description TODO
     */
    public interface UserDAO {
        //保存用户
        public void save(User user);
    }
    
    
    1. 实现Mapper文件(对maper编程)com.yuhl.mapper/UserDAOMapper.xml
      特别注意:com.yuhl.mapper是一个文件集,不是三级包
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.yuhl.dao.UserDAO"> <!--接口名-->
        <!--id:mybatis.UserDao接口中的方法面
        parameterType:面向对象的对象名字-->
        <insert id="save" parameterType="user">
            insert into t_user(name,password) value (#{name},#{password})
        </insert>
    </mapper>
    
    1. 测试
    import com.yuhl.dao.UserDAO;
    import com.yuhl.entity.User;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * @author yuhl
     * @Date 2020/11/4 11:06
     * @Classname MybatisTest
     * @Description 测试
     */
    public class MybatisTest2 {
    
        @Test
        public void test1() {
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
            UserDAO userDao = (UserDAO) ctx.getBean("userDAO");
            userDao.save(new User("zhangsan","ddd"));
        }
    }
    
    
    1. 结果
      在这里插入图片描述

    5.Mybatis和spring整合事务控制

    在这里插入图片描述
    这句话告诉我们spring并没有提交事务,我们的事务是被谁提交的呢?
    前面我们单独使用mybatis的时候手动提交了了事务
    session.commint;
    这里直接给出答案,是我们引入的第三方数据源druid控制了事务的提交。
    但是在实战中我们不会让他控制我们的事务,我们会把事务的控制权交给spring,让spring来控制事务。
    下一篇:18-Spring事务控制@Transactional https://blog.csdn.net/fsjwin/article/details/109497305

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 334,190
精华内容 133,676
关键字:

持久层