通过Mybatis实现对单表的增删改查-通过定义一个接口实现

Pom.xml文件 定义工程项目依赖的软件库

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.vincent</groupId>
  <artifactId>mybatisweb</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>mybatisweb Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>

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

    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.42</version>
    </dependency>

  </dependencies>
  <build>
  <!-- 将mybatisweb项目打包成mybatisweb.war自动部署到tomcat服务器的webapps目录下面 -->
    <finalName>mybatisweb</finalName>
    <plugins>
        <plugin>
            <!-- 使用 cargo自动化部署 -->
            <groupId>org.codehaus.cargo</groupId>
            <artifactId>cargo-maven2-plugin</artifactId>
            <version>1.4.12</version> <!-- 不能用1.3.2 不然用maven编译不成功 -->
            <configuration>
                <container>
                    <!-- 指明使用的tomcat服务器版本 -->
                    <containerId>tomcat8x</containerId>
                     <!--指明tomcat服务器的安装目录 -->
                    <home>C:\fastDev\Tomcat\apache-tomcat-8.5.14</home>                 
                </container>
              <configuration>
                <type>existing</type>
                 <!--指明tomcat服务器的安装目录 -->
                <home>C:\fastDev\Tomcat\apache-tomcat-8.5.14</home>
                <properties><cargo.servlet.port>9090</cargo.servlet.port></properties>
              </configuration>            
            </configuration>
            <executions>
                <execution>
                    <id>cargo-run</id>
                    <phase>install</phase>
                    <goals>
                        <goal>run</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
  </build>
</project>

src/main/resources目录下放置了mybatis的所有配置文件该目录下文件可以直接被java代码引用

为了管理，在src/main/resources目录下新建mybatis目录管理所有mybatis相关的配置信息。

mybatis配置数据源信息

MybatisConfig.xml 在src/main/resources/mybatis目录

<?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>
    <!-- 给类设置别名, 在mapper文件中可以使用这个别名，就不用使用那么长的类名了。 -->
    <typeAliases>
        <typeAlias type="org.vincent.model.Student"
        alias="Student"/>
    </typeAliases>
    <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/javaee" />
                <property name="username" value="root" />
                <property name="password" value="1557862201" />
            </dataSource>
        </environment>

    </environments>  
    <mappers>
     <!-- 注册SQL映射信息文件，Mapper.xml文件，   Mapper.xml位于src/main/resources/mybatis这个包下，因为src/main/resources/为classpath，所以resource写成mybatis/mappers/Student.xml-->
        <mapper resource="mybatis/mappers/Student.xml"/>
    </mappers>
</configuration>

设置项目中POJO类和数据库表的映射关系

Student.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，namespace的值习惯上设置成包名+sql映射文件名，这样就能够保证namespace的值是唯一的
例如namespace="org.vincent.mapping.Mapper"就是org.vincent.mapping(包名)+Mapper(Mapper.xml文件去除后缀);
但是如有需要通过定义一个接口方法定义访问数据库接口方法，那么namespace必须取接口全类名。
 -->
<mapper namespace="org.vincent.model.IStudentOperation">
    <!-- 在select标签中编写查询的SQL语句， 设置select标签的id属性为getStudent，id属性值必须是唯一的，不能够重复;
    使用parameterType属性指明查询时传递进来使用的参数类型，resultType属性指明查询返回的结果集类型
    resultType="org.vincent.domain.Student"就表示将查询结果映射成一个Student类的对象返回
    Student类就是student表所对应的实体类
    -->
    <!-- 
        根据id查询得到一个student对象
        org.vincent.model.IStudentOperation.getStudentbyId
        id 设置成接口的对应方法名public Student getStudentbyId(int id);
        MyBatis会根据结果自动创建一个ResultMap对象，然后基于查找出来的属性名进行键值对封装，
         然后再看到返回类型是Student对象，再从ResultMap中取出与Student对象匹配的属性名对应的
         键值对进行赋值。
        resultType 是
     -->
    <select id="getStudentbyId" parameterType="int" 
        resultType="Student"> <!-- 直接使用在Mybatis配置文件中定义的类别名 -->
        select * from student where id=#{id}
    </select>

     <!-- 根据一个id 获取一组记录 -->
    <select id="getStudents" parameterType="int"
        resultMap="list">
            select * from student where id >#{id}
     </select>
     <!-- Student是设置别名后 的类型；resultMap是为了返回list类型而设置的。被上面的select引用 
            column 为从数据库查询过来的属性，property属性制定了将从数据库查询过来的属性赋值给对象那个属性。
     -->
     <resultMap type="Student" id="list">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
        <result column="address" property="address"/>
     </resultMap>

     <!-- 插入一条记录 ，
     id和parameterType  分别与IUserOperation接口中的insertStudent方法的名字和  
       参数类型一致。以#{name}的形式引用Student参数的name属性，MyBatis将使用反射读取Student参数  
       的此属性。#{name}中name大小写敏感。引用其他的gender等属性与此一致。useGeneratedKeys设置  
       为"true"表明要MyBatis获取由数据库自动生成的主键id；keyProperty="id"指定将获取到的主键值注入  
       到Student的id属性
     -->
     <insert id="insertStudent" parameterType="Student" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO student(name, age, address) VALUES(#{name}, #{age} ,#{address} )
     </insert>
     <!-- 更新一条记录 -->
     <update id="updateStudent" parameterType="Student" >
        update student SET name=#{name} , address=#{address} ,age=#{age} where id=#{id}
     </update>

     <delete id="deleteStudent" parameterType="int">
        delete from student where id =#{id}
     </delete>

</mapper>

POJO 类

package org.vincent.model;

/**
 * 数据库表对应的Java类；POJO对象
 *
 * @ClassName: Student
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author PengRong
 * @date 2017年6月16日 上午12:35:37
 *
 */
public class Student {
    private int id;
    private String address;
    private String name;
    private int age;

    public int getId() {
        return this.id;
    }

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

    public String getAddress() {
        return this.address;
    }

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

    public String getName() {
        return this.name;
    }

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

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [id=" + this.id + ", address=" + this.address
                + ", name=" + this.name + ", age=" + this.age + "]";
    }

}

接口类

package org.vincent.model;

import java.util.List;

/**
 * 只有接口没有实现类，用于Mybatis中查询结果 这里的接口方法名必须和Student.xml中select中id属性一致；
 * 比如getStudentbyId 必须和<select id="getStudentbyId" parameterType="int"
 * resultType="Student">一致。 不然测试时候报错说不能绑定异常：
 * org.apache.ibatis.binding.BindingException: Invalid bound statement (not
 * found): org.vincent.model.IStudentOperation.getStudent at
 * org.apache.ibatis.binding
 * .MapperMethod$SqlCommand.<init>(MapperMethod.java:225) at
 * org.apache.ibatis.binding.MapperMethod.<init>(MapperMethod.java:48) at
 * org.apache.ibatis.binding.MapperProxy.cachedMapperMethod(MapperProxy.java:65)
 * at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:58) at
 * com.sun.proxy.$Proxy2.getStudent(Unknown Source) at
 * org.vincent.mybatisweb.StudentTest.testMutiStudent(StudentTest.java:69) at
 * sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at
 * sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
 * at sun.reflect.DelegatingMethodAccessorImpl.invoke(
 * DelegatingMethodAccessorImpl.java:43) at
 * java.lang.reflect.Method.invoke(Method.java:498) at
 * org.junit.runners.model.FrameworkMethod$1
 * .runReflectiveCall(FrameworkMethod.java:45) at
 * org.junit.internal.runners.model
 * .ReflectiveCallable.run(ReflectiveCallable.java:15) at
 * org.junit.runners.model
 * .FrameworkMethod.invokeExplosively(FrameworkMethod.java:42) at
 * org.junit.internal
 * .runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at
 * org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:263) at
 * org.junit.runners
 * .BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:68) at
 * org.junit.
 * runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:47) at
 * org.junit.runners.ParentRunner$3.run(ParentRunner.java:231) at
 * org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:60) at
 * org.junit.runners.ParentRunner.runChildren(ParentRunner.java:229) at
 * org.junit.runners.ParentRunner.access$000(ParentRunner.java:50) at
 * org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:222) at
 * org.junit.runners.ParentRunner.run(ParentRunner.java:300) at
 * org.eclipse.jdt.internal
 * .junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50) at
 * org.eclipse
 * .jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at
 * org.eclipse
 * .jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner
 * .java:467) at
 * org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(
 * RemoteTestRunner.java:683) at
 * org.eclipse.jdt.internal.junit.runner.RemoteTestRunner
 * .run(RemoteTestRunner.java:390) at
 * org.eclipse.jdt.internal.junit.runner.RemoteTestRunner
 * .main(RemoteTestRunner.java:197)
 *
 *
 *
 * @ClassName: IStudentOperation
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author PengRong
 * @date 2017年5月16日 上午11:51:04
 *
 */

public interface IStudentOperation {
    // 查询一个数
    public Student getStudentbyId(int id);

    // 查询一列数据
    public List<Student> getStudents(int id);

    // 插入一条记录
    public void insertStudent(Student student);

    // 更新一条记录
    public void updateStudent(Student student);

    // 删除一条记录
    public void deleteStudent(int id);
}

BaseDao

package org.vincent.dao;

import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.log4j.Logger;

public interface BaseDao {
    // 公共的日志记录器和配置文件配置在接口中。
    public Logger logger = Logger.getLogger(BaseDao.class);
    public String MybatisConfig = "mybatis/MybatisConfig.xml";

    // 打开一个Session
    default public SqlSession getSession() throws IOException {
        InputStream inputStream = null;
        inputStream = Resources.getResourceAsStream(BaseDao.MybatisConfig);
        return new SqlSessionFactoryBuilder().build(inputStream).openSession();
    }

    // 关闭一个Session
    default public void closeSession(SqlSession session) {
        if (session != null) {
            session.close();
        }
    }

    // 获取一个日志记录器
    default public Logger getLogger() {
        return BaseDao.logger;
    }

}

Student Dao层

package org.vincent.dao;

import java.io.IOException;
import java.util.List;
import java.util.Objects;

import org.apache.ibatis.session.SqlSession;
import org.vincent.model.IStudentOperation;
import org.vincent.model.Student;

import com.mysql.jdbc.StringUtils;

/**
 * Student 表的单表增删改查实现，基于接口
 *
 * @ClassName: StudentInterfaceDaoImpl
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author PengRong
 * @date 2017年7月23日 上午11:46:00
 *
 */
public class StudentInterfaceDaoImpl implements BaseDao, IStudentOperation {
    private SqlSession session = null;

    public StudentInterfaceDaoImpl() {
        try {
            this.session = this.getSession();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }// 获取到sqlSession
    }

    /**
     * 关闭Session
     * 
     * @Title: closeSession
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param 设定文件
     * @return void 返回类型
     * @throws
     */
    public void closeSession() {
        this.closeSession(this.session);
    }

    // 通关id和匹配到Student.xml中对应的select标签执行单表查询;没用通关Mapper接口
    public Student queryBySql(String sql, int id) {
        Student result = null;
        if (!StringUtils.isNullOrEmpty(sql)) {
            result = this.session.selectOne(sql, id);
        } else {
            result = null;
        }
        return result;
    }

    /**
     * 通过一条记录的id根据IStudentOperation接口方法映射到sql mapper文件中一个select标签；获取到一条记录，
     */
    @Override
    public Student getStudentbyId(int id) {
        // TODO Auto-generated method stub
        IStudentOperation operation = this.session
                .getMapper(IStudentOperation.class);
        Student student = operation.getStudentbyId(id);
        BaseDao.logger.debug(student);
        return student;
    }

    // 获取到大于指定id的所有记录
    @Override
    public List<Student> getStudents(int id) {
        // TODO Auto-generated method stub
        IStudentOperation operation = this.session
                .getMapper(IStudentOperation.class);
        // ② 通过接口方法获取一组数据库记录
        List<Student> list = operation.getStudents(id);
        return list;
    }

    /**
     * 根据一个实例student，将对象插入到数据库中。
     */
    @Override
    public void insertStudent(Student student) {
        // TODO Auto-generated method stub
        IStudentOperation operation = this.session
                .getMapper(IStudentOperation.class);
        if (Objects.nonNull(student)) {
            operation.insertStudent(student);
        } else {
            //
        }
    }

    /**
     * 更新一条记录的相关属性。
     */
    @Override
    public void updateStudent(Student student) {
        // TODO Auto-generated method stub
        IStudentOperation operation = this.session
                .getMapper(IStudentOperation.class);
        operation.updateStudent(student);
    }

    /**
     * 删除一条数据记录
     */
    @Override
    public void deleteStudent(int id) {
        // TODO Auto-generated method stub
        IStudentOperation operation = this.session
                .getMapper(IStudentOperation.class);
        operation.deleteStudent(id);
    }
}

单表增删改查测试类

package org.vincent.mybatisweb;

import java.io.IOException;
import java.util.List;

import org.junit.Test;
import org.vincent.dao.StudentInterfaceDaoImpl;
import org.vincent.model.Student;

/*
 * ORM Mybatis 数据库单表  增 删  改 查操作的单元测试
 * @ClassName: StudentTest
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author PengRong
 * @date 2017年6月16日 上午1:10:46
 *
 */
public class StudentSingleTableTest {
    /**
     * 根据一个sqlStatement获取到一条记录；使用selcetOne 函数，通过
     * sqlStatement字符串直接映射为Student中对应的SQL语句去执行查询。
     *
     * @Title: test
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param @throws IOException 设定文件
     * @return void 返回类型
     * @throws
     */
    @Test
    public void test() throws IOException {
        // sqlStatement是根据Student.xml 这个mapper映射文件中namespace+ select
        // 的id=getStudentbyId 唯一确定的sql字符串
        String sqlStatement = "org.vincent.model.IStudentOperation.getStudentbyId";
        StudentInterfaceDaoImpl studentInterfaceDaoImpl = new StudentInterfaceDaoImpl();
        System.out.println((studentInterfaceDaoImpl
                .queryBySql(sqlStatement, 61)));
        studentInterfaceDaoImpl.closeSession();
    }

    // 通过Id获取一条记录
    @Test
    public void getStudentbyIdTest() {
        StudentInterfaceDaoImpl studentInterfaceDaoImpl = new StudentInterfaceDaoImpl();
        // ① 通过接口方法，查询一条数据库 记录。
        studentInterfaceDaoImpl.getStudentbyId(2);
        studentInterfaceDaoImpl.closeSession();
    }

    /**
     * 用接口的方式编程。这种方式，要注意的一个地方就是。在Student.xml 的映射配置文件中。 mapper节点的
     * namespace="org.vincent.model.IStudentOperation" ，
     * 命名空间非常重要，不能有错，必须与我们定义的接口全类名一致。如果不一致就会出错,
     *
     * @Title: testMutiStudent
     * @Description: TODO(通过接口方法获取到数据库数据)
     * @param
     * @throws IOException
     * @return void 返回类型
     * @throws
     */
    @Test
    public void getStudentsTest() throws IOException {
        StudentInterfaceDaoImpl impl = new StudentInterfaceDaoImpl();
        List<Student> list = impl.getStudents(20);
        for (Student student : list) {
            System.out.println(student);
        }
        impl.closeSession();
    }

    /**
     * 插入一条数据
     *
     * @Title: insertStudentTest
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param @throws IOException 设定文件
     * @return void 返回类型
     * @throws
     */
    @Test
    public void insertStudentTest() throws IOException {
        Student student = new Student();
        student.setAddress("深圳市罗湖区红岭北");
        student.setAge(27);
        student.setName("XX00");
        StudentInterfaceDaoImpl impl = new StudentInterfaceDaoImpl();
        impl.insertStudent(student);
        System.out.println(student);// 能获取到数据库生成得id
        impl.closeSession();
    }

    /**
     * 通过id查询一条记录对应的对象，然后更改记录对象，最后通过接口方法更新一条记录
     *
     * @Title: updateStudent
     * @Description: TODO(这里用一句话描述这个方法的作用)
     * @param
     * @throws IOException
     * @return void 返回类型
     * @throws
     */
    @Test
    public void updateStudent() throws IOException {
        StudentInterfaceDaoImpl impl = new StudentInterfaceDaoImpl();
        Student student = impl.getStudentbyId(60);
        student.setAddress("东莞市长安街");
        impl.updateStudent(student);
        impl.closeSession();
    }

    /**
     * 通过数据库id， 删除一条记录。
     *
     * @Title: deleteStudent
     * @Description: TODO
     * @param @throws IOException 设定文件
     * @return void 返回类型
     * @throws
     */
    @Test
    public void deleteStudent() throws IOException {
        StudentInterfaceDaoImpl dao = new StudentInterfaceDaoImpl();
        dao.deleteStudent(59);
        dao.closeSession();
    }
}