JavaPersistenceWithMyBatis3笔记-第1章-001

一、介绍

1.项目结构

2.数据库结构

二、代码

1.Mapper

 package com.mybatis3.mappers;

 import java.util.List;

 import com.mybatis3.domain.Student;

 /**
  * @author Siva
  *
  */
 public interface StudentMapper
 {

     List<Student> findAllStudents();

     Student findStudentById(Integer id);

     void insertStudent(Student student);

     void updateStudent(Student student);

 }

StudentMapper.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="com.mybatis3.mappers.StudentMapper">

     <resultMap type="Student" id="StudentResult">
         <id     property="studId" column="stud_id"/>
         <result property="name" column="name"/>
         <result property="email" column="email"/>
         <result property="dob" column="dob"/>
     </resultMap>

       <select id="findAllStudents" resultMap="StudentResult">
         select * from Students
       </select>

       <select id="findStudentById" parameterType="int" resultType="Student">
         select stud_id as studId, name, email, dob from Students where stud_id=#{studId}
       </select>

       <insert id="insertStudent" parameterType="Student">
           INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB) VALUES(#{studId},#{name},#{email},#{dob})
       </insert>

       <update id="updateStudent" parameterType="Student">
           UPDATE STUDENTS SET NAME=#{name}, EMAIL=#{email}, DOB=#{dob} WHERE STUD_ID=#{studId}
       </update>

 </mapper>

2.Service

 package com.mybatis3.services;

 import java.util.List;

 import org.apache.ibatis.session.SqlSession;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import com.mybatis3.domain.Student;
 import com.mybatis3.mappers.StudentMapper;
 import com.mybatis3.util.MyBatisSqlSessionFactory;

 /**
  * @author Siva
  *
  */
 public class StudentService
 {
     private Logger logger = LoggerFactory.getLogger(getClass());

     public List<Student> findAllStudents()
     {
         SqlSession sqlSession = MyBatisSqlSessionFactory.getSqlSession();
         try {
             StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
             return studentMapper.findAllStudents();
         } finally {
             sqlSession.close();
         }
     }

     public Student findStudentById(Integer studId)
     {
         logger.debug("Select Student By ID :{}", studId);
         SqlSession sqlSession = MyBatisSqlSessionFactory.getSqlSession();
         try {
             StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
             return studentMapper.findStudentById(studId);
             //return sqlSession.selectOne("com.mybatis3.StudentMapper.findStudentById", studId);
         } finally {
             sqlSession.close();
         }
     }

     public void createStudent(Student student)
     {
         SqlSession sqlSession = MyBatisSqlSessionFactory.getSqlSession();
         try {
             StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
             studentMapper.insertStudent(student);
             sqlSession.commit();
         } finally {
             sqlSession.close();
         }
     }

     public void updateStudent(Student student)
     {
         SqlSession sqlSession = MyBatisSqlSessionFactory.getSqlSession();
         try {
             StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
             studentMapper.updateStudent(student);
             sqlSession.commit();
         } finally {
             sqlSession.close();
         }
     }
 }

老式的JDBC

 package com.mybatis3.services;

 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Date;

 import com.mybatis3.domain.Student;

 /**
  * @author Siva
  *
  */

 public class JdbcStudentService
 {

     private static final String DRIVER = "com.mysql.jdbc.Driver";
     private static final String URL = "jdbc:mysql://localhost:3306/elearning";
     private static final String USERNAME = "root";
     private static final String PASSWORD = "admin";

     public static void main(String[] args)
     {

         JdbcStudentService service = new JdbcStudentService();

         Student existingStudent = service.findStudentById(1);
         System.out.println(existingStudent);

         long ts = System.currentTimeMillis();//For creating unique student names
         Student newStudent = new Student(0,"student_"+ts,"student_"+ts+"@gmail.com",new Date());
         service.createStudent(newStudent);
         System.out.println(newStudent);

         int updateStudId = 3;
         Student updateStudent = service.findStudentById(updateStudId);
         ts = System.currentTimeMillis();//For creating unique student email
         updateStudent.setEmail("student_"+ts+"@gmail.com");
         service.updateStudent(updateStudent);

     }

     public Student findStudentById(int studId)
     {
         Student student = null;
         Connection conn = null;
         try
         {
             conn = getDatabaseConnection();
             String sql = "select * from students where stud_id=?";
             PreparedStatement pstmt = conn.prepareStatement(sql);
             pstmt.setInt(1, studId);
             ResultSet rs = pstmt.executeQuery();
             if(rs.next())
             {
                 student = new Student();
                 student.setStudId(rs.getInt("stud_id"));
                 student.setName(rs.getString("name"));
                 student.setEmail(rs.getString("email"));
                 student.setDob(rs.getDate("dob"));
             }

         } catch (SQLException e)
         {
             throw new RuntimeException(e);
         }
         finally
         {
             if(conn!= null){
                 try {
                     conn.close();
                 } catch (SQLException e){ }
             }
         }
         return student;
     }

     public void createStudent(Student student)
     {
         Connection conn = null;
         try
         {
             conn = getDatabaseConnection();
             String sql = "INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB) VALUES(?,?,?,?)";
             PreparedStatement pstmt = conn.prepareStatement(sql);
             pstmt.setInt(1, student.getStudId());
             pstmt.setString(2, student.getName());
             pstmt.setString(3, student.getEmail());
             pstmt.setDate(4, new java.sql.Date(student.getDob().getTime()));
             pstmt.executeUpdate();

         } catch (SQLException e)
         {
             throw new RuntimeException(e);
         }
         finally
         {
             if(conn!= null){
                 try {
                     conn.close();
                 } catch (SQLException e){ }
             }
         }
     }

     public void updateStudent(Student student)
     {
         Connection conn = null;
         try
         {
             conn = getDatabaseConnection();
             conn = getDatabaseConnection();
             String sql = "UPDATE STUDENTS SET NAME=?,EMAIL=?,DOB=? WHERE STUD_ID=?";
             PreparedStatement pstmt = conn.prepareStatement(sql);
             pstmt.setString(1, student.getName());
             pstmt.setString(2, student.getEmail());
             pstmt.setDate(3, new java.sql.Date(student.getDob().getTime()));
             pstmt.setInt(4, student.getStudId());
             pstmt.executeUpdate();

         } catch (SQLException e)
         {
             throw new RuntimeException(e.getCause());
         }
         finally
         {
             if(conn!= null){
                 try {
                     conn.close();
                 } catch (SQLException e){ }
             }
         }
     }

     protected Connection getDatabaseConnection() throws SQLException
     {
         try
         {
             Class.forName(JdbcStudentService.DRIVER);
             return DriverManager.getConnection(JdbcStudentService.URL,
                                                 JdbcStudentService.USERNAME,
                                                 JdbcStudentService.PASSWORD);
         } catch (SQLException e)
         {
             throw e;
         } catch (Exception e)
         {
             throw new RuntimeException(e.getCause());
         }
     }

 }

3.Domain

 package com.mybatis3.domain;

 import java.util.Date;

 /**
  * @author Siva
  *
  */
 public class Student
 {
     private Integer studId;
     private String name;
     private String email;
     private Date dob;

     public Student() {

     }

     public Student(Integer studId) {
         this.studId = studId;
     }

     public Student(Integer studId, String name, String email, Date dob) {
         this.studId = studId;
         this.name = name;
         this.email = email;
         this.dob = dob;
     }

     @Override
     public String toString() {
         return "Student [studId=" + studId + ", name=" + name + ", email="
                 + email + ", dob=" + dob + "]";
     }

     public Integer getStudId() {
         return studId;
     }
     public void setStudId(Integer studId) {
         this.studId = studId;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getEmail() {
         return email;
     }
     public void setEmail(String email) {
         this.email = email;
     }
     public Date getDob() {
         return dob;
     }
     public void setDob(Date dob) {
         this.dob = dob;
     }

 }

4.辅助类

 package com.mybatis3.util;

 import java.io.IOException;
 import java.io.InputStream;
 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.util.Properties;

 import org.apache.ibatis.datasource.DataSourceFactory;
 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;

 /**
  * @author Siva
  *
  */
 public class MyBatisSqlSessionFactory
 {
     private static SqlSessionFactory sqlSessionFactory;

     private static final Properties PROPERTIES = new Properties();

     static
     {
         try {
             InputStream is = DataSourceFactory.class.getResourceAsStream("/application.properties");
             PROPERTIES.load(is);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     public static SqlSessionFactory getSqlSessionFactory()
     {
         if(sqlSessionFactory==null)
         {
             InputStream inputStream = null;
             try
             {
                 inputStream = Resources.getResourceAsStream("mybatis-config.xml");
                 sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
             }catch (IOException e)
             {
                 throw new RuntimeException(e.getCause());
             }finally {
                 if(inputStream != null){
                     try {
                         inputStream.close();
                     } catch (IOException e) {
                     }
                 }
             }
         }
         return sqlSessionFactory;
     }

     public static SqlSession getSqlSession()
     {
         return getSqlSessionFactory().openSession();
     }

     public static Connection getConnection()
     {
         String driver = PROPERTIES.getProperty("jdbc.driverClassName");
         String url = PROPERTIES.getProperty("jdbc.url");
         String username = PROPERTIES.getProperty("jdbc.username");
         String password = PROPERTIES.getProperty("jdbc.password");
         Connection connection = null;
         try {
             Class.forName(driver);
             connection = DriverManager.getConnection(url, username, password);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
         return connection;
     }
 }

5.配置及资源文件

(1)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>

       <properties resource="application.properties"/>

       <typeAliases>
           <package name="com.mybatis3.domain"/>
       </typeAliases>

       <environments default="development">
         <environment id="development">
           <transactionManager type="JDBC"/>
           <dataSource type="POOLED">
             <property name="driver" value="${jdbc.driverClassName}"/>
             <property name="url" value="${jdbc.url}"/>
             <property name="username" value="${jdbc.username}"/>
             <property name="password" value="${jdbc.password}"/>
           </dataSource>
         </environment>
       </environments>

       <mappers>
         <mapper resource="com/mybatis3/mappers/StudentMapper.xml"/>
       </mappers>

 </configuration>

(2)application.properties

 ################### DataSource Configuration ##########################

 jdbc.driverClassName=com.mysql.jdbc.Driver
 jdbc.url=jdbc:mysql://localhost:3306/elearning
 jdbc.username=root
 jdbc.password=1234

 CREATE TABLE ADDRESSES
 (
   ADDR_ID INT(11) NOT NULL AUTO_INCREMENT,
   STREET VARCHAR(50) NOT NULL,
   CITY VARCHAR(50) NOT NULL,
   STATE VARCHAR(50) NOT NULL,
   ZIP VARCHAR(10) DEFAULT NULL,
   COUNTRY VARCHAR(50) NOT NULL,
   PRIMARY KEY (ADDR_ID)
 ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=LATIN1;

 CREATE TABLE STUDENTS
 (
   STUD_ID INT(11) NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(50) NOT NULL,
   EMAIL VARCHAR(50) NOT NULL,
   PHONE VARCHAR(15) DEFAULT NULL,
   DOB DATE DEFAULT NULL,
   BIO LONGTEXT DEFAULT NULL,
   PIC BLOB DEFAULT NULL,
   ADDR_ID INT(11) DEFAULT NULL,
   PRIMARY KEY (STUD_ID),
   CONSTRAINT FK_STUDENTS_ADDR FOREIGN KEY (ADDR_ID) REFERENCES ADDRESSES (ADDR_ID)
 ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=LATIN1;

 CREATE TABLE TUTORS
 (
   TUTOR_ID INT(11) NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(50) NOT NULL,
   EMAIL VARCHAR(50) NOT NULL,
   PHONE VARCHAR(15) DEFAULT NULL,
   DOB DATE DEFAULT NULL,
   BIO LONGTEXT DEFAULT NULL,
   PIC BLOB DEFAULT NULL,
   ADDR_ID INT(11) DEFAULT NULL,
   PRIMARY KEY (TUTOR_ID),
   CONSTRAINT FK_TUTORS_ADDR FOREIGN KEY (ADDR_ID) REFERENCES ADDRESSES (ADDR_ID)
 ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=LATIN1;

 CREATE TABLE COURSES
 (
   COURSE_ID INT(11) NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(100) NOT NULL,
   DESCRIPTION VARCHAR(512) DEFAULT NULL,
   START_DATE DATE DEFAULT NULL,
   END_DATE DATE DEFAULT NULL,
   TUTOR_ID INT(11) NOT NULL,
   PRIMARY KEY (COURSE_ID),
   CONSTRAINT FK_COURSE_TUTOR FOREIGN KEY (TUTOR_ID) REFERENCES TUTORS (TUTOR_ID)
 ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=LATIN1;

 CREATE TABLE COURSE_ENROLLMENT
 (
   COURSE_ID INT(11) NOT NULL,
   STUD_ID INT(11) NOT NULL,
   PRIMARY KEY (COURSE_ID,STUD_ID),
   CONSTRAINT FK_ENROLLMENT_STUD FOREIGN KEY (STUD_ID) REFERENCES STUDENTS (STUD_ID),
   CONSTRAINT FK_ENROLLMENT_COURSE FOREIGN KEY (COURSE_ID) REFERENCES COURSES (COURSE_ID)
 ) ENGINE=INNODB DEFAULT CHARSET=LATIN1;

 CREATE TABLE USER_PICS
 (
   ID INT(11) NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(50) DEFAULT NULL,
   PIC BLOB,
   BIO LONGTEXT,
   PRIMARY KEY (ID)
 ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=LATIN1;

 DROP TABLE IF EXISTS USER_PICS;
 DROP TABLE IF EXISTS COURSE_ENROLLMENT;
 DROP TABLE IF EXISTS COURSES;
 DROP TABLE IF EXISTS TUTORS;
 DROP TABLE IF EXISTS STUDENTS;
 DROP TABLE IF EXISTS ADDRESSES;

 --Sample data for table ADDRESSES

 INSERT INTO ADDRESSES (ADDR_ID,STREET,CITY,STATE,ZIP,COUNTRY) VALUES
  (1,'4891 Pacific Hwy','San Diego','CA','92110','San Diego'),
  (2,'2400 N Jefferson St','Perry','FL','32347','Taylor'),
  (3,'710 N Cable Rd','Lima','OH','45825','Allen'),
  (4,'5108 W Gore Blvd','Lawton','OK','32365','Comanche');

 -- Sample data for table STUDENTS

 INSERT INTO STUDENTS (STUD_ID,NAME,EMAIL,PHONE,DOB,BIO,PIC,ADDR_ID) VALUES
  (1,'Timothy','timothy@gmail.com','123-123-1234','1988-04-25',NULL,NULL,3),
  (2,'Douglas','douglas@gmail.com','789-456-1234','1990-08-15',NULL,NULL,4);

 -- Sample data for table TUTORS

 INSERT INTO TUTORS (TUTOR_ID,NAME,EMAIL,PHONE,DOB,BIO,PIC,ADDR_ID) VALUES
  (1,'John','john@gmail.com','111-222-3333','1980-05-20',NULL,NULL,1),
  (2,'Paul','paul@gmail.com','123-321-4444','1981-03-15',NULL,NULL,2);

 -- Sample data for table courses

 INSERT INTO COURSES (COURSE_ID,NAME,DESCRIPTION,START_DATE,END_DATE,TUTOR_ID) VALUES
  (1,'Quickstart Core Java','Core Java Programming','2013-03-01','2013-04-15',1),
  (2,'Quickstart JavaEE6','Enterprise App Development using JavaEE6','2013-04-01','2013-08-30',1),
  (3,'MyBatis3 Premier','MyBatis 3 framework','2013-06-01','2013-07-15',2);

 -- Sample data for table COURSE_ENROLLMENT

 INSERT INTO COURSE_ENROLLMENT (COURSE_ID,STUD_ID) VALUES
  (1,1),
  (1,2),
  (2,2);

 log4j.rootLogger=INFO, stdout

 log4j.appender.stdout=org.apache.log4j.ConsoleAppender
 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 log4j.appender.stdout.layout.ConversionPattern=%d [%-5p] %c - %m%n

 log4j.logger.com.mybatis3=DEBUG

6.测试文件

 package com.mybatis3.services;

 import java.util.Date;
 import java.util.List;

 import org.junit.AfterClass;
 import static org.junit.Assert.*;
 import org.junit.BeforeClass;
 import org.junit.Test;

 import com.mybatis3.domain.Student;

 /**
  * @author Siva
  *
  */
 public class StudentServiceTest
 {
     private static StudentService studentService;

     @BeforeClass
     public static void setup()
     {
         studentService = new StudentService();
         TestDataPopulator.initDatabase();
     }
     @AfterClass
     public static void teardown()
     {
         studentService = null;
     }

     @Test
     public void testFindAllStudents()
     {
         List<Student> students = studentService.findAllStudents();
         assertNotNull(students);
         for (Student student : students)
         {
             assertNotNull(student);
             System.out.println(student);
         }

     }

     @Test
     public void testFindStudentById()
     {
         Student student = studentService.findStudentById(1);
         assertNotNull(student);
     }

     @Test
     public void testCreateUStudent()
     {
         Student student = new Student();
         int id = 4;
         student.setStudId(id);
         student.setName("student_"+id);
         student.setEmail("student_"+id+"gmail.com");
         student.setDob(new Date());
         studentService.createStudent(student);
         Student newStudent = studentService.findStudentById(id);
         assertNotNull(newStudent);
         assertEquals("student_"+id, newStudent.getName());
         assertEquals("student_"+id+"gmail.com", newStudent.getEmail());
     }

     @Test
     public void testUpdateStudent()
     {
         int id = 2;
         Student student =studentService.findStudentById(id);
         student.setStudId(id);
         student.setName("student_"+id);
         student.setEmail("student_"+id+"gmail.com");
         Date now = new Date();
         student.setDob(now);
         studentService.updateStudent(student);
         Student updatedStudent = studentService.findStudentById(id);
         assertNotNull(updatedStudent);
         assertEquals("student_"+id, updatedStudent.getName());
         assertEquals("student_"+id+"gmail.com", updatedStudent.getEmail());

     }
 }

 /**
  *
  */
 package com.mybatis3.services;

 import java.io.Reader;
 import java.sql.Connection;

 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.jdbc.ScriptRunner;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import com.mybatis3.util.MyBatisSqlSessionFactory;

 /**
  * @author Siva
  *
  */
 public class TestDataPopulator
 {
     private static Logger logger = LoggerFactory.getLogger(TestDataPopulator.class);

     public static void main(String[] args) {
         initDatabase();
     }

     public static void initDatabase()
     {
         Connection connection = null;
         Reader reader = null;
         try {
             connection = MyBatisSqlSessionFactory.getConnection();
             ScriptRunner scriptRunner = new ScriptRunner(connection);
             reader = Resources.getResourceAsReader("sql/drop_tables.sql");
             scriptRunner.runScript(reader);
             logger.info("drop_tables.sql executed successfully");
             reader = Resources.getResourceAsReader("sql/create_tables.sql");
             scriptRunner.runScript(reader );
             logger.info("create_tables.sql executed successfully");
             reader = Resources.getResourceAsReader("sql/sample_data.sql");
             scriptRunner.runScript(reader );
             logger.info("sample_data.sql executed successfully");
             connection.commit();
             reader.close();
             scriptRunner.closeConnection();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }

     }
 }