zoukankan      html  css  js  c++  java

  • Mybatis_One

    Mabatis的概述

    JavaEE开发是分层的：表现层 业务层 持久层

    框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。 
    简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

    mybatis框架

    明确：它是一个持久层框架，解决项目对数据库的CRUD操作，只要会方法名、sql语句，学mybatis框架很轻松。

    什么是ORM？ 
    ORM ：Object Relational Mapping 对象关系映射（目的：操作对象，就可以操作数据库） 
    通过建立数据库表和Java实体类的对应关系，从而实现操作实体类就相当于操作数据库表。 
    ORM思想对应的框架有：mybatis，hibernate，spring data jpa 
    现阶段的数据访问层框架。 

    Mybatis框架入门

    开发环境的准备及统一 
    1.检查JDK环境 

    2.检查Tomcat环境（忽略，springmvc用到） 
    3.检查maven环境 

    4.2导入Maven依赖

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.  <modelVersion>4.0.0</modelVersion>
    7.  <groupId>com.it.mybatis003</groupId>
    8.  <artifactId>mybatis00302</artifactId>
    9.  <version>1.0-SNAPSHOT</version>
    11.  <!--需要添加的是以下部分-->
    12.  <dependencies>
    13.  <!--数据库依赖-->
    14.  <dependency>
    15.  <groupId>mysql</groupId>
    16.  <artifactId>mysql-connector-java</artifactId>
    17.  <version>5.1.45</version>
    18.  </dependency>
    19.  <!--mybatis依赖-->
    20.  <dependency>
    21.  <groupId>org.mybatis</groupId>
    22.  <artifactId>mybatis</artifactId>
    23.  <version>3.4.5</version>
    24.  </dependency>
    25.  <!--测试依赖-->
    26.  <dependency>
    27.  <groupId>junit</groupId>
    28.  <artifactId>junit</artifactId>
    29.  <version>4.12</version>
    30.  </dependency>
    31.  <!--日志依赖-->
    32.  <dependency>
    33.  <groupId>log4j</groupId>
    34.  <artifactId>log4j</artifactId>
    35.  <version>1.2.17</version>
    36.  </dependency>
    37.  </dependencies>
    39. </project>

    4.3创建数据库 
    创建数据库 
    DROP TABLE IF EXISTS user;

    1. CREATE TABLE `user` (
    2.   `id` int(11) NOT NULL auto_increment,
    3.   `username` varchar(32) NOT NULL COMMENT '用户名称',
    4.   `birthday` datetime default NULL COMMENT '生日',
    5.   `sex` char(1) default NULL COMMENT '性别',
    6.   `address` varchar(256) default NULL COMMENT '地址',
    7.   PRIMARY KEY  (`id`)
    8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    导入数据

    1. insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (41,'老王','2018-02-27 17:47:08','男','北京'),(42,'小二王','2018-03-02 15:09:37','女','北京金燕龙'),(43,'小二王','2018-03-04 11:34:34','女','北京金燕龙'),(45,'传智播客','2018-03-04 12:04:06','男','北京金燕龙'),(46,'老王','2018-03-07 17:37:26','男','北京'),(48,'小马宝莉','2018-03-08 11:44:00','女','北京修正');

    4.4创建实体类 
    创建包：com.it.domain 
    创建类：User.java

    1. public class User implements Serializable {
    2.  private int id;// 主键ID
    3.  private String username;// 用户姓名
    4.  private String sex;// 性别
    5.  private Date birthday;// 生日
    6.  private String address;// 地址
    8.  此处省略getset	ostring方法

    4.5创建接口UserDao.java 
    创建接口，用来操作数据库 
    创建包com.it.dao 
    创建接口UserDao.java

    1. public interface UserDao {
    2.  /**
    3.      * 查询所有
    4.      */
    5.  List<User> findAll();
    6. }

    也有人将它命名UserMapper，这个是因人而异，我们为了大家的编程习惯，叫做Dao。

    4.6创建sqlMapConfig.xml 
    在resources包下，新建sqlMapConfig.xml 

    sqlMapConfig.xml 
    为了更好将数据库连接信息抽取出来，我们原来在C3P0连接池中也已经将数据库连接信息抽取出来，我们现在也一样将数据库的连接信息抽取出来，放到一个xml（SqlMapConfig.xml）文件中，后面再去对此配置文件进行xml解析，这样就可以将配置文件中的信息读取出来，以便在jdbc代码中直接使用这些数据库连接信息

    1. <!--初始版-->
    2. <?xml version="1.0" encoding="UTF-8"?>
    3. <!DOCTYPE configuration
    4.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    5.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    6. <configuration>
    7.  <!--配置mybatis的环境-->
    8.  <environments default="mysql">
    9.  <environment id="mysql">
    10.  <!--配置事务管理策略-->
    11.  <transactionManager type="JDBC"></transactionManager>
    12.  <!--配置数据源-->
    13.  <dataSource type="POOLED">
    14.  <property name="driver" value="com.mysql.jdbc.Driver"/>
    15.  <property name="url" value="jdbc:mysql:///itcastmybatis"/>
    16.  <property name="username" value="root"/>
    17.  <property name="password" value="root"/>
    18.  </dataSource>
    19.  </environment>
    20.  </environments>
    21.  <!--配置映射文件的信息-->
    22.  <mappers>
    23.  <mapper resource="com/it/dao/UserDao.xml"></mapper>
    24.  </mappers>
    25. </configuration>

    更新版:↓

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2.  <!DOCTYPE configuration
    3.                 PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.                 "http://mybatis.org/dtd/mybatis-3-config.dtd">
    6. <configuration>
    7.  <!--这里是后面的知识用外部配置文件的方式导入数据库信息-->
    8.  <properties resource="jdbcconfig.properties"></properties>
    9.  <!--用于指定要配置别名的包,当指定之后,该包下的实体类都会注册别名,并且类名就是别名,不再区分大小写-->
    10.  <typeAliases>
    11.  <package name="com.it.domain"></package>
    12.  </typeAliases>
    13.  <!--配置mystis的环境-->
    14.  <environments default="mysql">
    15.  <environment id="mysql">
    16.  <!--固定配置事务管理器为JDBC-->
    17.  <transactionManager type="JDBC"></transactionManager>
    18.  <!--固定配置数据源为POOLED-->
    19.  <dataSource type="POOLED">
    20.  <!--当使用外部配置文件是需要用${}引用-->
    21.  <property name="driver" value="${jdbc.driver}"/>
    22.  <property name="url" value="${jdbc.url}"/>
    23.  <property name="username" value="${jdbc.username}"/>
    24.  <property name="password" value="${jdbc.password}"/>
    25.  </dataSource>
    26.  </environment>
    27.  </environments>
    28.  <!--配置接口与映射文件的信息与默认的区别为后面同包名下的地址前缀无需写和不区分大小写-->
    29.  <mappers>
    30.  <package name="com.it.dao"></package>
    31.  </mappers>
    32. </configuration>

    4.7创建UserDao.xml 
    因为是maven项目，所有xml的文件应该放在resources下，创建包com.it.dao(要注意此包名结构需与上面的接口包名结构一致)，创建UserDao.xml 
     

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5.  <mapper namespace="com.it.dao.UserDao">
    6.  <!--查询所有-->
    7.  <select id="findAll" resultType="com.it.domain.User">
    8.         select * from user
    9.  </select>
    10. </mapper>

    4.8创建测试类

    在test文件夹下，创建包com.it.test，创建类MyBatisTest.java

    1. public class MyBatisTest {
    2.  /**
    3.      * 测试mybatis的环境搭建
    4.      */
    5.  public static void main(String[] args) throws IOException {
    6.  // 1.读取配置文件
    7.  InputStream in = Resources.getResourceAsStream("sqlMapConfig.xml");
    8.  // 2.根据配置文件构建SqlSessionFactory
    9.  SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    10.  SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(in);
    11.  // 3.使用SqlSessionFactory创建SqlSession
    12.  SqlSession sqlSession = sqlSessionFactory.openSession();
    13.  // 4.使用SqlSession构建Dao的代理对象
    14.  UserDao userDao = sqlSession.getMapper(UserDao.class);
    15.  // 5.执行dao的findAll方法
    16.  List<User> list = userDao.findAll();
    17.  // 第4，第5步骤可以写成
    18.  // List<User> list = sqlSession.selectList("com.it.dao.UserDao.findAll");
    19.  for(User user:list){
    20.  System.out.println(user);
    21.  }
    22.  // 5.关闭资源
    23.         sqlSession.close();
    24.         in.close();
    26.  }
    27. }

    最后如果没有发现日志，引入日志包，在resources文件下创建log4j.properties 
    附件为日志文件,可下载后拖入即可

    保存

    UserDao.java 
    为了实现新增操作，我们可以在原有入门示例的UserDao.java类中添加一个用于saveUser()的方法用于用户新增操作。 
    UserDao类中新增saveUser()方法，如下：

    1. /**
    2.  * 保存用户
    3.  * @param user
    4.  */
    5. void saveUser(User user);

    UserDao.xml 
    在UserDao.xml文件中加入新增用户的配置，如下： 
    添加标签

    1. <!--保存用户-->
    2. <insert id="saveUser" parameterType="com.it.domain.User">
    3.     insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday});
    4. </insert>

    我们可以发现，这个sql语句中使用#{}字符，#{}代表占位符，我们可以理解是原来jdbc所学的?，它们都是代表占位符， 具体的值是由User类的username属性来决定的。使用OGNL表达式 
    parameterType属性：代表参数的类型，因为我们要传入的是一个类的对象，所以类型就写类的全名称。 
    注意： 
    这种方式要求<mapper namespace=”映射接口所在的包名+类名”>,同时还要求<select>,<insert>,<delete>,<update>这些标签中的id属性一定与代理接口中的方法名相同。

    MybatisTest.java 
    测试初始化：

    • 读取SqlMapConfig.xml
    • 构建SqlSessionFactory
    • 打开SqlSession
    • 获取UserDao对象 
      测试结束
    • 提交事务
    • 释放资源 
      这样方便测试。
    1. /**
    2.  * 测试mybatis的crud操作
    3.  */
    4. public class MybatisTest {
    6.  private InputStream in;
    7.  private SqlSession sqlSession;
    8.  private UserDao userDao;
    10.  @Before//用于在测试方法执行之前执行
    11.  public void init()throws Exception{
    12.  //1.读取配置文件，生成字节输入流
    13.         in = Resources.getResourceAsStream("SqlMapConfig.xml");
    14.  //2.获取SqlSessionFactory
    15.  SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
    16.  //3.获取SqlSession对象
    17.         sqlSession = factory.openSession();
    18.  //4.获取dao的代理对象
    19.         userDao = sqlSession.getMapper(UserDao.class);
    20.  }
    22.  @After//用于在测试方法执行之后执行
    23.  public void destroy()throws Exception{
    24.  //提交事务
    25.         sqlSession.commit();
    26.  //6.释放资源
    27.         sqlSession.close();
    28.         in.close();
    29.  }
    31.  /**
    32.      * 测试查询所有
    33.      */
    34.  @Test
    35.  public void testFindAll(){
    36.  //5.执行查询所有方法
    37.  List<User> users = userDao.findAll();
    38.  for(User user : users){
    39.  System.out.println(user);
    40.  }
    42.  }
    44.  /**
    45.      * 测试保存操作
    46.      */
    47.  @Test
    48.  public void testSave(){
    49.  User user = new User();
    50.         user.setUsername("吴邪");
    51.         user.setAddress("洛阳");
    52.         user.setSex("男");
    53.         user.setBirthday(new Date());
    54.  System.out.println("保存操作之前："+user);
    55.  //5.执行保存方法
    56.         userDao.saveUser(user);
    57.  System.out.println("保存操作之后："+user);
    58.  }
    59. }

    如果发现测试没有添加任何记录，原因是什么？ 
    这一点和jdbc是一样的，我们在实现增删改时一定要去控制事务的提交，那么在mybatis中如何控制事务提交呢？ 
    可以使用:session.commit();来实现事务提交。加入事务提交后的代码如下： 
    但是：这时候发现保存操作之前User对象的id和保存操作之后User对象的id都为null，如果我们想在保存之后获取User对象的id呢？

    问题扩展：新增用户id的返回值 
    新增用户后，同时还要返回当前新增用户的id值，因为id是由数据库的自动增长来实现的，所以就相当于我们要在新增后将自动增长auto_increment的值返回。 
    Mysql自增主键的返回，配置如下：

    1. insert into user(username,address,sex,birthday) values('张三','深圳','女','2018-07-24');
    2. select last_insert_id()

    配置：UserDao.xml

    1. <!--保存用户-->
    2. <insert id="saveUser" parameterType="com.it.domain.User">
    3.  <!-- 配置插入操作后，获取插入数据的id -->
    4.  <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
    5.         select last_insert_id();
    6.  </selectKey>
    7.     insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday});
    9. </insert>

    测试类MyBatisTest.java

    1. /**
    2.  * 测试保存操作
    3.  */
    4. @Test
    5. public void testSave(){
    6.  User user = new User();
    7.     user.setUsername("吴邪");
    8.     user.setAddress("海底墓");
    9.     user.setSex("男");
    10.     user.setBirthday(new Date());
    11.  System.out.println("保存操作之前："+user);
    12.  //5.执行保存方法
    13.     userDao.saveUser(user);
    14.  System.out.println("保存操作之后："+user);
    15. }

    修改

    UserDao.java

    1. /**
    2.  * 更新用户
    3.  * @param user
    4.  */
    5. void updateUser(User user);

    5.3.2UserDao.xml

    1. <update id="updateUser" parameterType="com.it.domain.User">
    2.     update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id}
    3. </update>

    5.3.3MybatisTest.java

    1. /**
    2.  * 测试更新操作
    3.  */
    4. @Test
    5. public void testUpdate(){
    6.  User user = new User();
    7.     user.setId(50);
    8.     user.setUsername("如花2");
    9.     user.setAddress("中粮商务公园");
    10.     user.setSex("男");
    11.     user.setBirthday(new Date());
    13.  //5.执行保存方法
    14.     userDao.updateUser(user);
    15. }

    删除

    UserDao.java

    1. /**
    2.  * 根据Id删除用户
    3.  * @param userId
    4.  */
    5. void deleteUser(Integer userId);

    5.4.2UserDao.xml

    1. <!-- 删除用户-->
    2. <delete id="deleteUser" parameterType="java.lang.Integer">
    3.     delete from user where id = #{uid}
    4. </delete>

    其中的#{uid}是占位符，代表参数的值由方法的参数传入进来的。 
    注意： 
    1.此处的#{uid}中的id其实只是一个形参，所以它的名称是自由定义的，比如定义成#{abc}也是可以的。 
    2.关于parameterType的取值问题，对于基本类型我们可以直接写成int,short,double…..也可以写成java.lang.Integer。 
    3.字符串可以写成string,也可以写成java.lang.String 
    也就是说：int是java.lang.Integer的别名 
    string是java.lang.String的别名 
    别名是不区分大小写 
    5.4.3MybatisTest.java

    1. /**
    2.  * 测试删除操作
    3.  */
    4. @Test
    5. public void testDelete(){
    6.  //5.执行删除方法
    7.     userDao.deleteUser(48);
    8. }

    主键查询

    UserDao.java

    1. /**
    2.  * 根据id查询用户信息
    3.  * @param id
    4.  * @return
    5.  */
    6. User findById(Integer id);

    5.5.2UserDao.xml

    1. <!-- 根据id查询用户 -->
    2. <select id="findById" parameterType="INT" resultType="com.it.domain.User">
    3.     select * from user where id = #{uid}
    4. </select>

    5.5.3MybatisTest.java

    1. /**
    2.  * 测试主键ID查询操作
    3.  */
    4. @Test
    5. public void testFindOne(){
    6.  //5.执行查询一个方法
    7.  User  user = userDao.findById(50);
    8.  System.out.println(user);
    9. }

    模糊查询

    现在来实现根据用户名查询用户信息，此时如果用户名想用模糊搜索的话，我就可以想到前面Web课程中所学的模糊查询来实现。

    UserDao.java 
    可以在UserDao类中添加一个findByName()的方法，如下：

    1. /**
    2.  * 根据名称模糊查询用户信息
    3.  * @param name
    4.  * @return
    5.  */
    6. List<User> findByName(String name);

    UserDao.xml 
    下面在UserDao.xml文件中加入模糊查询的配置代码，如下：

    1. <!-- 根据名称模糊查询 -->
    2. <select id="findByName" parameterType="string" resultType="com.it.domain.User">
    3.     select * from user where username like #{name}
    4. </select>

    注意：此时的#{name}中的因为这时候是普通的参数，所以它的起名是随意的，比如我们改成#{abc}也是可以的。 
    MybatisTest.java

    1. /**
    2.  * 测试模糊查询操作
    3.  */
    4. @Test
    5. public void testFindByName(){
    6.  //5.执行查询一个方法
    7.  List<User> users = userDao.findByName("%王%");
    8.  for(User user : users){
    9.  System.out.println(user);
    10.  }
    11. }

    我们在UserDao.xml配置文件中没有加入%来作为模糊查询的条件，所以在传入字符串实参时，就需要给定模糊查询的标识%。配置文件中的#{name}也只是一个占位符，所以SQL语句显示为“？”。 
    如何将模糊查询的匹配符%写到配置文件中呢？

    模糊查询的另一种配置方式 
    第一步：编写UserDao.xml文件，配置如下：

    1. <!-- 根据名称模糊查询 -->
    2. <select id="findByName" parameterType="string" resultType="com.it.domain.User">
    3.     select * from user where username like '%${value}%'
    4. </select>

    我们在上面将原来的#{}占位符，改成了value。注意如果用模糊查询的这种写法，那么{value}的写法就是固定的，不能写成其它名字。 
    第二步：编写测试方法，如下：

    1. /**
    2.      * 测试模糊查询操作
    3.      */
    4.  @Test
    5.  public void testFindByName(){
    6.  //5.执行查询一个方法
    7. //         List<User> users = userDao.findByName("%王%");
    8.  List<User> users = userDao.findByName("王");
    9.  for(User user : users){
    10.  System.out.println(user);
    11.  }
    12.  }

    #{}与${}的区别

    #{}表示一个占位符号 
    通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。 
    ${}表示拼接sql串

    通过可以将parameterType传入的内容拼接在sql中且不进行jdbc类型转换，{}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，括号中只能是value。那么为什么一定要写成{value}呢？我们一起来看TextSqlNode类的源码：

    这就说明了源码中指定了读取的key的名字就是”value”，所以我们在绑定参数时就只能叫value的名字了。

    定义resultMap

    由于上边的userDao.xml中sql查询列和Users.java类属性不一致，需要定义resultMap： 
    第一步：修改UserDao.xml

    1. <!-- 查询所有 -->
    2. <select id="findAll" resultMap="userMap">
    3.  <!--select id as userId,username as userName,address as userAddress,sex as userSex,birthday as userBirthday from user; -->
    4.     select * from user;
    5. </select>

    第二步：在UserDao.xml中的下定义：

    1. <!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    2. <resultMap id="userMap" type="com.it.domain.User">
    3.  <!-- 主键字段的对应 -->
    4.  <id property="userId" column="id"></id>
    5.  <!--非主键字段的对应-->
    6.  <result property="userName" column="username"></result>
    7.  <result property="userAddress" column="address"></result>
    8.  <result property="userSex" column="sex"></result>
    9.  <result property="userBirthday" column="birthday"></result>
    10. </resultMap>

    <id />：此属性表示查询结果集的唯一标识，非常重要。如果是多个字段为复合唯一约束则定义多个<id />。 
    property：表示User类的属性。 
    column：表示sql查询出来的字段名。 
    column和property放在一块儿表示将sql查询出来的字段映射到指定的pojo类属性上。 
    <result />：普通属性（普通字段），即pojo的属性。

    QueryVo.java

    开发中通过pojo传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。 
    Pojo类中包含pojo。 
    需求：根据用户名查询用户信息，查询条件放到QueryVo的user属性中。 
    在com.it.domain中，创建QueryVO.java

    1. public class QueryVo {
    3.  private User user;
    5.  public User getUser() {
    6.  return user;
    7.  }
    9.  public void setUser(User user) {
    10.  this.user = user;
    11.  }
    12. }

    6.2.3UserDao.java

    1. /**
    2.  * 根据queryVo中的条件查询用户
    3.  * @param vo
    4.  * @return
    5.  */
    6. List<User> findUserByVo(QueryVo vo);

    6.2.4UserDao.xml

    1. <!-- 根据queryVo的条件查询用户 -->
    2. <select id="findUserByVo" parameterType="com.it.domain.QueryVo" resultType="com.it.domain.User">
    3.     select * from user where username like #{user.username}
    4. </select>

    如果我们使用的是包装类作为参数，比如这个示例的QueryVo类作为findUserByVo()方法的参数，那么在使用时，因为QueryVo类中有一个User类的user对象，而这个user对象中才能找到username属性，所以我们在访问属性时，就使用OGNL表达式才访问对象的属性，即#{user.username}。

    MybatisTest.java

    1. /**
    2.  * 测试使用QueryVo作为查询条件
    3.  */
    4. @Test
    5. public void testFindByVo(){
    6.  QueryVo vo = new QueryVo();
    7.  User user = new User();
    8.     user.setUsername("%王%");
    9.     vo.setUser(user);
    10.  //5.执行查询一个方法
    11.  List<User> users = userDao.findUserByVo(vo);
    12.  for(User u : users){
    13.  System.out.println(u);
    14.  }
    15. }
  • 相关阅读:
    LeetCode 83. Remove Duplicates from Sorted List （从有序链表中去除重复项）
    LeetCode 21. Merge Two Sorted Lists （合并两个有序链表）
    LeetCode 720. Longest Word in Dictionary （字典里最长的单词）
    LeetCode 690. Employee Importance （职员的重要值）
    LeetCode 645. Set Mismatch （集合不匹配）
    LeetCode 500. Keyboard Row （键盘行）
    LeetCode 463. Island Perimeter （岛的周长）
    115.Distinct Subsequences
    55.Jump Game
    124.Binary Tree Maximum Path Sum
  • 原文地址：https://www.cnblogs.com/leccoo/p/11105408.html
Copyright © 2011-2022 走看看