mybatis入门(二):增删改查

mybatis的原理:

　　1.mybatis是一个持久层框架，是apache下的顶级项目
　　mybatis托管到googlecode下，目前托管到了github下面
　　2.mybatis可以将向prepareStatement中输入的参数自动进行输入映射，将查询结果集灵活的映射成java对象。(输出映射)

　　

mybatis的一般使用到的maven包:

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.42</version>
        </dependency>

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

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>

其中
　　流程:
　　　　1.新建log4j.properties
　　　　2.新建sqlMapConfig.xml(名称可以替换,用来配置事务，数据库连接等等)(约束文件是config.dtd)
　　　　3.新建映射文件
　　　　　　映射文件命名:
　　　　　　User.xml(原始ibatis命名),mapper代理开发映射文件名称为xxxMapper.xml,比如:UserMapper.xml、ItemsMapper.xml
　　　　　　新建原始的User.xml(约束文件是mapper.dtd结尾)
　　　　4.创建一个pojo类
　　　　　　User.java:创建的理由是要和数据库里面的数据要保持一致，这样就可以把mybatis里面返回的结果直接映射为一个java对象
　　　　5.在sqlMapConfig.xml加载映射文件
　　　　6.建立mybatis的查询语句

　　1.新添加一个log4j.properties

 ### set log levels ###
         #在开发环境下日志的级别设置为DEBUG,生产环境设置成为info或error
         log4j.rootLogger = INFO , console , debug , error

         ### console ###
         log4j.appender.console = org.apache.log4j.ConsoleAppender
         log4j.appender.console.Target = System.out
         log4j.appender.console.layout = org.apache.log4j.PatternLayout
         log4j.appender.console.layout.ConversionPattern = %-d{yyyy-MM-dd HH\:mm\:ss} [%p]-[%c] %m%n

　　2.新建sqlMapConfig.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>
     <!-- 环境：配置mybatis的环境 -->
     <environments default="development">
         <!-- 环境变量：可以配置多个环境变量，比如使用多数据源时，就需要配置多个环境变量 -->
         <environment id="development">
             <!-- 事务管理器 -->
             <transactionManager type="JDBC"/>
             <!-- 数据源 -->
             <dataSource type="POOLED">
                 <property name="driver" value="com.mysql.jdbc.Driver"/>
                 <property name="url" value="jdbc:mysql://localhost:3306/mybatisData?characterEncoding=utf-8"/>
                 <property name="username" value="root"/>
                 <property name="password" value="root"/>
             </dataSource>
         </environment>
     </environments>
     <!-- 加载映射文件-->
     <mappers>
         <mapper resource="sqlMap/User.xml"/>
     </mappers>
 </configuration>

　　3.新建映射文件

　　User.xml

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.apache.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <!-- namespace命名空间,作用就是对sql进行分类化管理,理解sql隔离-->
 <!--注意:使用mapper代理方法开发,namespace有特殊重要的作用-->
 <mapper namespace="test">
     <!-- 在映射文件中配置很多sql语句-->
     <!--通过select执行数据库查询
          id:标识映射文件中的sql
          将sql语句封装到mappedStatement对象中，所以id称为statement的id
          parameterType：指定参数类型，这里指定int型
          #{id}标识一个占位符，其中i表示接收输入的参数,如果输入的参数是简单类型，#{}D的参数可以任意，可以是value或其他名称
          resultType:指定sql输出结果的所映射的java的对象类型，select指定resultType表示将单条记录所映射单条记录
     -->
     <select id="findUserById" parameterType="int" resultType="cn.wj.test.mybatis.pojo.User">
         select * from user where id = #{id}
     </select>

     <!--
         根据用户名称模糊查询用户信息,可能返回多条
         resultType:指定的是单条记录所映射的java对象类型
         ${}:标识拼接字符串，将接收到参数的内容不加任何修饰拼接在sql中(不是占位符)
         使用${}拼接sql,可能会引起sql注入
         ${value}:接收输入参数的内容，如果传入的参数是简单类型,${}中只能使用value
     -->
     <select id="findUserByName" parameterType="String" resultType="cn.wj.test.mybatis.pojo.User">
         select * from user where username like '%${value}%'
     </select>

     <!--添加用户
         parameterType:指定输入参数类型是pojo(包括用户信息)
         #{}中指定的pojo的属性名,接收到pojo对象的属性值,mybatis通过ognl获取对象的属性值
      -->
     <insert id="insertUser" parameterType="cn.wj.test.mybatis.pojo.User">
         <!--
             将插入的数据的主键返回,返回到user对象中
             SELECT LAST_INSERT_TD():得到刚insert进去记录的主键值，只适用于自增主键

             keyProperty:将查询到主键值设置到parameterType指定的对象的那个属性
             order:SELECT LAST_INSERT_ID()执行顺序,相对于insert语句他的执行顺序
             resultType:指定SELECT LAST_INSERT_ID()的结果类型
         -->
         <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
         SELECT LAST_INSERT_ID()
         </selectKey>
         insert into user(username,birthday,sex,address) value(#{username},#{birthday},#{sex},#{address})
     </insert>

     <insert id="insertUserUUID" parameterType="cn.wj.test.mybatis.pojo.UserUUID">
         <!--
        使用mysql的uuid生成主键
        执行过程:
        首先通过uuid()的到主键,将主键设置到user对象的id属性中
        其次在insert执行过程时,从user对象取出id属性
        -->
         <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">
             SELECT uuid()
         </selectKey>
         insert into useruuid(id,name) value(#{id},#{name})
     </insert>

     <!--
         删除用户
         根据id删除用户，需要输入id值
     -->
     <delete id="deleteUserById" parameterType="java.lang.Integer">
         delete from user where id = #{id}
     </delete>

     <!--
         根据用户id更新用户
         分析:
         需要传入用户的id
         需要传入用户的更新信息
         parameterType指定的user对象,包括id和跟更新xinxi,注意id必须存在
         #{id}:从输入user对象中获取id的属性值
     -->
     <update id="updateUser" parameterType="cn.wj.test.mybatis.pojo.User">
         update user set id = #{id} , username =#{username} , birthday = #{birthday},sex = #{sex},address = #{address} where id = #{id}
     </update>

 </mapper>

　　4.创建一个pojo类

　　User.java

 package cn.wj.test.mybatis.pojo;

 import java.util.Date;

 /**
  * Created by WJ on 2017/8/10
  */
 public class User {
     //属性名称和数据库表的字段对应
     private int id;
     private String username;
     private String sex;
     private Date birthday;
     private String address;

     public User(String username, String sex, Date birthday, String address) {
         this.username = username;
         this.sex = sex;
         this.birthday = birthday;
         this.address = address;
     }

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     public String getUsername() {
         return username;
     }

     public void setUsername(String username) {
         this.username = username;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public Date getBirthday() {
         return birthday;
     }

     public void setBirthday(Date birthday) {
         this.birthday = birthday;
     }

     public String getAddress() {
         return address;
     }

     public void setAddress(String address) {
         this.address = address;
     }

     @Override
     public String toString() {
         return "User{" +
                 "id=" + id +
                 ", username='" + username + '\'' +
                 ", sex='" + sex + '\'' +
                 ", birthday=" + birthday +
                 ", address='" + address + '\'' +
                 '}';
     }
 }

UserUUID.java

 package cn.wj.test.mybatis.pojo;

 /**
  * Created by WJ on 2017/8/11
  */
 public class UserUUID {
     private String id;
     private String name;

     public String getId() {
         return id;
     }

     public void setId(String id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }
 }

　　6.建立mybatis的查询语句

 package cn.wj.test.mybatis.first;

 import cn.wj.test.mybatis.pojo.User;
 import cn.wj.test.mybatis.pojo.UserUUID;
 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;
 import java.util.Date;
 import java.util.List;

 /**
  * Created by WJ on 2017/8/10
  */
 public class mybatisFirst {

     //根据id查询用户信息,得到一条记录结果
     @Test
     public void findUserByIdTests() throws IOException {
         //mybatis配置文件
         String resouce = "sqlMapConfig.xml";
         //得到配置文件流
         InputStream inputStream = Resources.getResourceAsStream(resouce);
         //创建会话工厂,传入mybatis的配置文件信息
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
         //通过工厂得到sqlSession
         SqlSession sqlSession = sqlSessionFactory.openSession();
         //通过sqlSession来操作数据库
         //第一个参数,映射文件中statement的id,等于namespace.statementid（User.xml）
         //第二个参数:指定和映射文件中所匹配的parameterType的类型的参数
         //sqlSession.selectOne的结果是与映射文件中所匹配resultType的对象
         User user = sqlSession.selectOne("test.findUserById", 1);
         System.out.println(user.toString());
         //释放资源
         sqlSession.close();
     }

     //根据用户名称模糊查询用户列表
     @Test
     public void findUserByNameTests() throws IOException {
         //mybatis配置文件
         String resouce = "sqlMapConfig.xml";
         //得到配置文件流
         InputStream inputStream = Resources.getResourceAsStream(resouce);
         //创建会话工厂,传入mybatis的配置文件信息
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
         //通过工厂得到sqlSession
         SqlSession sqlSession = sqlSessionFactory.openSession();
         //通过sqlSession来操作数据库
         //第一个参数,映射文件中statement的id,等于namespace.statementid（User.xml）
         //第二个参数:指定和映射文件中所匹配的parameterType的类型的参数
         //sqlSession.selectOne的结果是与映射文件中所匹配resultType的对象
         List<User> userList = sqlSession.selectList("test.findUserByName", "wangjing");
         for (User user:userList) {
             System.out.println(user);
         }
         //释放资源
         sqlSession.close();
     }

     //添加用户信息主键自增
     @Test
     public void insertUser() throws IOException {
         //mybatis配置文件
         String resouce = "sqlMapConfig.xml";
         //得到配置文件流
         InputStream inputStream = Resources.getResourceAsStream(resouce);
         //创建会话工厂,传入mybatis的配置文件信息
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
         //通过工厂得到sqlSession
         SqlSession sqlSession = sqlSessionFactory.openSession();
         //通过sqlSession来操作数据库
         //第一个参数,映射文件中statement的id,等于namespace.statementid（User.xml）
         //第二个参数:指定和映射文件中所匹配的parameterType的类型的参数
         User user = new User("myname", "m", new Date(), "BJ");
         sqlSession.insert("test.insertUser",user);
         System.out.println(user.getId());
         //提交事务
         sqlSession.commit();
         //释放资源
         sqlSession.close();
     }

     //添加用户信息通过UUID方式自增的添加
     @Test
     public void insertUserUUID() throws IOException {
         //mybatis配置文件
         String resouce = "sqlMapConfig.xml";
         //得到配置文件流
         InputStream inputStream = Resources.getResourceAsStream(resouce);
         //创建会话工厂,传入mybatis的配置文件信息
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
         //通过工厂得到sqlSession
         SqlSession sqlSession = sqlSessionFactory.openSession();
         //通过sqlSession来操作数据库
         //第一个参数,映射文件中statement的id,等于namespace.statementid（User.xml）
         //第二个参数:指定和映射文件中所匹配的parameterType的类型的参数
         UserUUID userUUID = new UserUUID();
         userUUID.setName("xxx");
         sqlSession.insert("test.insertUserUUID",userUUID);
         System.out.println(userUUID.getId());
         //提交事务
         sqlSession.commit();
         //释放资源
         sqlSession.close();
     }

     //通过id删除用户
     @Test
     public void deleteUser() throws IOException {
         //mybatis配置文件
         String resouce = "sqlMapConfig.xml";
         //得到配置文件流
         InputStream inputStream = Resources.getResourceAsStream(resouce);
         //创建会话工厂,传入mybatis的配置文件信息
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
         //通过工厂得到sqlSession
         SqlSession sqlSession = sqlSessionFactory.openSession();
         //通过sqlSession来操作数据库
         //第一个参数,映射文件中statement的id,等于namespace.statementid（User.xml）
         //第二个参数:指定和映射文件中所匹配的parameterType的类型的参数
         sqlSession.delete("test.deleteUserById",-1);
         //提交事务
         sqlSession.commit();
         //释放资源
         sqlSession.close();
     }

     //更新用户
     @Test
     public void updateUser() throws IOException {
         //mybatis配置文件
         String resouce = "sqlMapConfig.xml";
         //得到配置文件流
         InputStream inputStream = Resources.getResourceAsStream(resouce);
         //创建会话工厂,传入mybatis的配置文件信息
         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
         //通过工厂得到sqlSession
         SqlSession sqlSession = sqlSessionFactory.openSession();
         //通过sqlSession来操作数据库
         //第一个参数,映射文件中statement的id,等于namespace.statementid（User.xml）
         //第二个参数:指定和映射文件中所匹配的parameterType的类型的参数
         User user = new User("myname123", "m", new Date(), "BJ123");
         user.setId(1);
         sqlSession.update("test.updateUser",user);
         //提交事务
         sqlSession.commit();
         //释放资源
         sqlSession.close();
     }

 }

　　有关于查询的小总结:
　　　　parameterType:在映射文件中通过parameterType指定输入参数的类型
　　　　resultType:在映射文件中通过resultType指定输出结果的类型
　　　　#{}:
　　　　　　表示一个占位符,#{}接收输入参数,类型可以是简单类型,pojo,hashmap
　　　　　　如果接收简单类型,#{}可以写成value或其他的名称
　　　　　　接收输入参数,类型可以是简单类型,pojo,hashmap
　　　　　　#{}接收pojo对象值，通过ognl读取对象中的属性值，通过属性.属性的方式获取对象属性值
　　　　${}:
　　　　　　表示一个拼接符号,会引入sql注入，所以不建议使用
　　　　　　接收输入参数,类型可以是简单类型,pojo,hashmap
　　　　　　如果接收简单类型，${}只能写成value
　　　　　　${}接收pojo对象值，通过ognl读取对象中的属性值，通过属性.属性的方式获取对象属性值
　　　　selectOne:表示查询出一条记录进行映射(selectList也可以使用,这个List的只用一条记录)
　　　　selectList:表示查询一个列表(多条记录)进行映射(selectOne不可以使用，就会查询多条记录，不支持)

　　

　　　　我们在User.xml如果要添加一个查询用户，我们可以这样说，我们可以在User.xml中创建一个添加用户的statement
　　　　mybatis中映射文件中sql语句后面不要加;号

　　自增主键返回
　　　　mysql自增主键
　　　　　　执行insert提交之前自动生成一个自增主键。
　　　　　　通过mysql函数获取到刚插入记录的自增主键
　　　　　　LAST_INSERT_ID()
　　　　　　是insert之后调用函数,这我需要把insert的statement的改为:
　　　　　　　　--------------------------------------------------------------------------------
　　　　　　　　<insert id="insertUser" parameterType="cn.wj.test.mybatis.pojo.User">
　　　　　　　　　　<!--
　　　　　　　　　　　　将插入的数据的主键返回,返回到user对象中
　　　　　　　　　　　　SELECT LAST_INSERT_TD():得到刚insert进去记录的主键值，只适用于自增主键

　　　　　　　　　　　　keyProperty:将查询到主键值设置到parameterType指定的对象的那个属性
　　　　　　　　　　　　order:SELECT LAST_INSERT_ID()执行顺序,相对于insert语句他的执行顺序
　　　　　　　　　　　　resultType:指定SELECT LAST_INSERT_ID()的结果类型
　　　　　　　　　　-->
　　　　　　　　　　<selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
　　　　　　　　　　　　SELECT LAST_INSERT_ID()
　　　　　　　　　　</selectKey>
　　　　　　　　　　　　insert into user(id,username,birthday,sex,address) value(#{id},#{username},#{birthday},#{sex},#{address})
　　　　　　　　</insert>
　　　　　　　　--------------------------------------------------------------------------------

　　非自增主键的返回(uuid)
　　　　uuid()生成主键的方法
　　　　　　使用mysql的uuid函数生成主键,需要修改表中的id字段类型为String，长度设置为50位(这个没有一定标准，大于35位即可)
　　　　　　执行思路:
　　　　　　　　先通过uuid()查询到主键,将主键输入到sql语句中.
　　　　　　　　执行uuid()语句顺序相当于insert语句之前执行
　　　　　　--------------------------------------------------------------------------------
　　　　　　<insert id="insertUserUUID" parameterType="cn.wj.test.mybatis.pojo.UserUUID">
　　　　　　　　<!--
　　　　　　　　　　使用mysql的uuid生成主键
　　　　　　　　　　执行过程:
　　　　　　　　　　　　首先通过uuid()的到主键,将主键设置到user对象的id属性中
　　　　　　　　　　　　其次在insert执行过程时,从user对象取出id属性
　　　　　　　　-->
　　　　　　　　<selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">
　　　　　　　　　　SELECT uuid()
　　　　　　　　</selectKey>
　　　　　　　　insert into useruuid(id,name) value(#{id},#{name})
　　　　　　</insert>
　　　　　　--------------------------------------------------------------------------------