JavaPersistenceWithMyBatis3笔记-第5章Configuring MyBatis in a Spring applications-001

/**
*
*/
package com.mybatis3.mappers;

import java.util.List;

import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.ResultMap;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;

import com.mybatis3.domain.Course;
import com.mybatis3.domain.Tutor;
import com.mybatis3.sqlproviders.TutorDynaSqlProvider;

/**
* @author Siva
*
*/

public interface TutorMapper
{

@Select("select * from courses where tutor_id=#{tutorId}")
@ResultMap("com.mybatis3.mappers.TutorMapper.CourseResult")
List<Course> selectCoursesByTutorId(int tutorId);

@Select("SELECT tutor_id, t.name as tutor_name, email, addr_id FROM tutors t where t.tutor_id=#{tutorId}")
@Results({
@Result(id=true, column="tutor_id", property="tutorId"),
@Result(column="tutor_name", property="name"),
@Result(column="email", property="email"),
@Result(property="address", column="addr_id",
one=@One(select="com.mybatis3.mappers.AddressMapper.selectAddressById")),
@Result(property="courses", column="tutor_id",
many=@Many(select="com.mybatis3.mappers.TutorMapper.selectCoursesByTutorId"))
})
Tutor selectTutorWithCoursesById(int tutorId);

@SelectProvider(type=TutorDynaSqlProvider.class, method="findAllTutorsSql")
List<Tutor> findAllTutors();

@SelectProvider(type=TutorDynaSqlProvider.class, method="findTutorByIdSql")
Tutor findTutorById(int tutorId);

@SelectProvider(type=TutorDynaSqlProvider.class, method="findTutorByNameAndEmailSql")
Tutor findTutorByNameAndEmail(@Param("name")String name, @Param("email")String email);

@InsertProvider(type=TutorDynaSqlProvider.class, method="insertTutor")
@Options(useGeneratedKeys=true, keyProperty="tutorId")
int insertTutor(Tutor tutor);

@UpdateProvider(type=TutorDynaSqlProvider.class, method="updateTutor")
int updateTutor(Tutor tutor);

@DeleteProvider(type=TutorDynaSqlProvider.class, method="deleteTutor")
int deleteTutor(int tutorId);

@SelectProvider(type=TutorDynaSqlProvider.class, method="selectTutorById")
@ResultMap("com.mybatis3.mappers.TutorMapper.TutorResult")
Tutor selectTutorById(int tutorId);

}

package com.mybatis3.services;

import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.mybatis3.domain.Address;
import com.mybatis3.domain.Student;
import com.mybatis3.mappers.AddressMapper;
import com.mybatis3.mappers.StudentMapper;

@Service
@Transactional
public class StudentService
{
private Logger logger = LoggerFactory.getLogger(getClass());

@Autowired
private StudentMapper studentMapper;

@Autowired
private AddressMapper addressMapper;

public List<Student> findAllStudents() {
return studentMapper.findAllStudents();
}

public Student findStudentById(Integer id) {
logger.debug("findStudentById :"+id);
return studentMapper.findStudentById(id);
}

public Student findStudentWithAddressById(int id) {
return studentMapper.selectStudentWithAddress(id);
}

public Student createStudent(Student student) {
Address address = student.getAddress();
if(address != null){
addressMapper.insertAddress(address);
}
if(student.getName()==null || student.getName().trim().length()==0){
throw new RuntimeException("Student Name should not be null");
}
studentMapper.insertStudent(student);
return student;
}

public void createStudentWithMap(Map<String, Object> studentDataMap) {
studentMapper.insertStudentWithMap(studentDataMap);
}

public Student updateStudent(Student student) {
studentMapper.updateStudent(student);
return student;
}

public boolean deleteStudent(int id) {
int count = studentMapper.deleteStudent(id);
return count > 0;
}

public Map<String, Object> findStudentMapById(int id) {
return studentMapper.findStudentMapById(id);
}

public List<Map<String, Object>> findAllStudentsMap() {
return studentMapper.findAllStudentsMap();
}
}

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

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.mybatis3.domain.Tutor;
import com.mybatis3.mappers.TutorMapper;

/**
* @author Siva
*
*/
@Service
@Transactional
public class TutorService
{
@Autowired
private SqlSession sqlSession;

private TutorMapper getTutorMapper(){
return sqlSession.getMapper(TutorMapper.class);
}
public List<Tutor> findAllTutors() {
return getTutorMapper().findAllTutors();
}

public Tutor findTutorById(int tutorId) {
return getTutorMapper().findTutorById(tutorId);
}

public Tutor findTutorByNameAndEmail(String name, String email) {
return getTutorMapper().findTutorByNameAndEmail(name, email);
}

public Tutor createTutor(Tutor tutor) {
getTutorMapper().insertTutor(tutor);
return tutor;
}

public Tutor updateTutor(Tutor tutor) {
getTutorMapper().updateTutor(tutor);
return tutor;
}

public boolean deleteTutor(int tutorId) {
boolean deleted = false;
int nor = getTutorMapper().deleteTutor(tutorId);
deleted = (nor == 1);
return deleted;
}

public Tutor selectTutorById(int tutorId) {
return getTutorMapper().selectTutorById(tutorId);
}

public Tutor selectTutorWithCoursesById(int tutorId) {
return getTutorMapper().selectTutorWithCoursesById(tutorId);
}
}

/**
*
*/
package com.mybatis3.sqlproviders;

import java.util.Map;

import org.apache.ibatis.jdbc.SQL;

import com.mybatis3.domain.Tutor;
/**
* @author Siva
*
*/
public class TutorDynaSqlProvider
{

public String findAllTutorsSql()
{
return new SQL() {{
SELECT("tutor_id as tutorId, name, email");
FROM("tutors");
}}.toString();
}

public String findTutorByIdSql(final int tutorId)
{
return new SQL() {{
SELECT("tutor_id as tutorId, name, email");
FROM("tutors");
WHERE("tutor_id="+tutorId);
}}.toString();
}

public String findTutorByNameAndEmailSql(Map<String, Object> map)
{
//String name = (String) map.get("name");
//String email = (String) map.get("email");
//System.err.println(name+":"+email);
return new SQL() {{
SELECT("tutor_id as tutorId, name, email");
FROM("tutors");
WHERE("name=#{name} AND email=#{email}");
}}.toString();
}

public String insertTutor(final Tutor tutor) {
return new SQL() {{
INSERT_INTO("TUTORS");

if (tutor.getName() != null) {
VALUES("NAME", "#{name}");
}

if (tutor.getEmail() != null) {
VALUES("EMAIL", "#{email}");
}
}}.toString();
}

public String updateTutor(final Tutor tutor)
{
return new SQL() {{
UPDATE("TUTORS");

if (tutor.getName() != null) {
SET("NAME = #{name}");
}

if (tutor.getEmail() != null) {
SET("EMAIL = #{email}");
}
WHERE("TUTOR_ID = #{tutorId}");
}}.toString();
}

public String deleteTutor(int tutorId)
{
return new SQL() {{
DELETE_FROM("TUTORS");
WHERE("TUTOR_ID = #{tutorId}");
}}.toString();
}

public String selectTutorById()
{
return new SQL() {{
SELECT("t.tutor_id, t.name as tutor_name, email, a.addr_id, street, city, state, zip, country,course_id, c.name as course_name, description, start_date, end_date");
FROM("TUTORS t");
LEFT_OUTER_JOIN("addresses a on t.addr_id=a.addr_id");
LEFT_OUTER_JOIN("courses c on t.tutor_id=c.tutor_id");
WHERE("t.TUTOR_ID = #{tutorId}");
}}.toString();
}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd"> 
<context:annotation-config />

<context:component-scan base-package="com.mybatis3" />

<context:property-placeholder location="classpath:application.properties" />

<tx:annotation-driven transaction-manager="transactionManager"/>

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>

<!-- <mybatis:scan base-package="com.mybatis3.mappers"/> -->

<!-- <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.mybatis3.mappers" />
</bean> -->

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory" />
</bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="typeAliasesPackage" value="com.mybatis3.domain"/>
<property name="typeHandlersPackage" value="com.mybatis3.typehandlers"/>
<property name="mapperLocations" value="classpath*:com/mybatis3/**/*.xml" />
</bean>

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>

</beans>

package com.mybatis3.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
/*
import javax.sql.DataSource;
import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
*/
/**
* @author Siva
*
*/
@Configuration
@MapperScan(value="com.mybatis3.mappers")
public class AppConfig
{
/*
@Bean
public DataSource dataSource() {
return new PooledDataSource("com.mysql.jdbc.Driver",
"jdbc:mysql://localhost:3306/elearning",
"root", "admin");
}

@Bean
public SqlSessionFactory sqlSessionFactory() throws Exception {
SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(dataSource());
return sessionFactory.getObject();
}
*/
}

package com.mybatis3.services;

import static org.junit.Assert.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.mybatis3.domain.Address;
import com.mybatis3.domain.PhoneNumber;
import com.mybatis3.domain.Student;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class StudentServiceTest
{
@Autowired
private StudentService studentService;

@BeforeClass
public static void setup() {
TestDataPopulator.initDatabase();
}

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

@Test
public void testFindStudentById() {
Student student = studentService.findStudentById(1);
System.err.println(student);
System.err.println(student.getAddress().getAddrId()+":"+student.getAddress().getCity());

}

@Test
public void testFindStudentWithAddressById() {
Student student = studentService.findStudentWithAddressById(2);
assertNotNull(student);
System.out.println(student.getAddress().getAddrId()+":"+student.getAddress().getCity());
}

@Test
public void testCreateStudent() {
//Address address = new Address();
Address address = new Address(1,"Quaker Ridge Rd.","Bethel","Brooklyn","06801","USA");
/*address.setStreet("Quaker Ridge Rd.");
address.setCity("Bethel");
address.setState("Brooklyn");
address.setZip("06801");
address.setCountry("USA");*/

Student stud = new Student();
long ts = System.currentTimeMillis();
stud.setName("stud_"+ts);
stud.setEmail("stud_"+ts+"@gmail.com");
stud.setPhone(new PhoneNumber("123-456-7890"));
stud.setAddress(address);
Student student = studentService.createStudent(stud);
assertNotNull(student);
assertEquals("stud_"+ts, student.getName());
assertEquals("stud_"+ts+"@gmail.com", student.getEmail());
System.err.println("CreatedStudent: "+student);
}

@Test(expected=DataAccessException.class)
public void testCreateStudentForException() {
Address address = new Address();
address.setStreet("Quaker Ridge Rd.");
address.setCity("Bethel");
address.setState("Brooklyn");
address.setZip("06801");
address.setCountry("USA");

Student stud = new Student();
long ts = System.currentTimeMillis();
stud.setName("stud_"+ts);
stud.setEmail("timothy@gmail.com");
stud.setPhone(new PhoneNumber("123-456-7890"));
stud.setAddress(address);
studentService.createStudent(stud);
fail("You should not reach here");
}

@Test
public void testCreateStudentWithMap() {
Map<String, Object> studMap = new HashMap<String, Object>();
long ts = System.currentTimeMillis();
studMap.put("name","stud_"+ts);
studMap.put("email","stud_"+ts+"@gmail.com");
studMap.put("phone",null);
studentService.createStudentWithMap(studMap);
}

@Test
public void testUpdateStudent() {
Student stud = new Student();
long ts = System.currentTimeMillis();
stud.setStudId(2);
stud.setName("studddd_"+ts);
stud.setEmail("studddd_"+ts+"@gmail.com");
Student student = studentService.updateStudent(stud);
assertNotNull(student);
assertEquals("studddd_"+ts, student.getName());
assertEquals("studddd_"+ts+"@gmail.com", student.getEmail());
assertEquals(new Integer(2), student.getStudId());

System.out.println("UpdatedStudent: "+student);
}

@Test
public void testDeleteStudent() {
boolean deleted = studentService.deleteStudent(3);
assertTrue(deleted);
System.err.println("deleteStudent:"+deleted);
}

@Test
public void testFindStudentMapById() {
Map<String, Object> studentMap = studentService.findStudentMapById(1);
System.err.println(studentMap);
}

@Test
public void testFindAllStudentsMap() {
List<Map<String,Object>> studentMapList = studentService.findAllStudentsMap();
for(Map<String,Object> studentMap : studentMapList)
{
System.out.println("id :"+studentMap.get("id"));
System.out.println("name :"+studentMap.get("name"));
System.out.println("email :"+studentMap.get("email"));
System.out.println("phone :"+studentMap.get("phone"));
}
}

}

package com.mybatis3.services;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.mybatis3.domain.Tutor;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class TutorServiceTest
{
@Autowired
private TutorService tutorService;

@BeforeClass
public static void setup() {
TestDataPopulator.initDatabase();
}

@Test
public void testFindAllTutors() {
List<Tutor> tutors = tutorService.findAllTutors();
assertNotNull(tutors);
for (Tutor tutor : tutors)
{
System.err.println(tutor);
}
}

@Test
public void testFindTutorById() {
Tutor tutor = tutorService.findTutorById(1);
assertNotNull(tutor);
//System.err.println(tutor);
}

@Test
public void testFindTutorByNameAndEmail() {
Tutor tutor = tutorService.findTutorByNameAndEmail("Paul", "paul@gmail.com");
assertNotNull(tutor);
//System.err.println(tutor);
}

@Test
public void testCreateTutor() {
Tutor tutor = new Tutor();
tutor.setName("siva");
tutor.setEmail("siva@gmail.com");
tutor = tutorService.createTutor(tutor);
assertNotNull(tutor);
}

@Test
public void testUpdateTutor() {
Tutor tutor = new Tutor();
tutor.setTutorId(1);
tutor.setName("sivaprasad");
tutor.setEmail("sivaprasad@gmail.com");
tutor = tutorService.updateTutor(tutor);
Tutor updTutor = tutorService.findTutorById(1);
assertNotNull(updTutor);
System.err.println(updTutor);
}

@Test
public void testDeleteTutor() {
boolean deleted = tutorService.deleteTutor(4);
assertTrue(deleted);
}

@Test
public void testSelectTutorById() {
Tutor tutor = tutorService.selectTutorById(1);
assertNotNull(tutor);
System.err.println(tutor);
}

@Test
public void testSelectTutorWithCoursesById() {
Tutor tutor = tutorService.selectTutorWithCoursesById(1);
assertNotNull(tutor);
System.err.println(tutor);
}

}