整理Java的MyBatis框架中一些重要的功能及基本使用示例
基本用法回顾：
SQL语句存储在XML文件或Java注解中。一个MaBatis映射的示例（其中用到了Java接口和MyBatis注解）：
packageorg.mybatis.example;
publicinterfaceBlogMapper{
@Select("select*fromBlogwhereid=#{id}")
BlogselectBlog(intid);
}
执行的示例：
BlogMappermapper=session.getMapper(BlogMapper.class); Blogblog=mapper.selectBlog(101);
SQL语句和映射也可以外化到一个XML文件中：
<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEmapperPUBLIC"-//mybatis.org//DTDMapper3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mappernamespace="org.mybatis.example.BlogMapper">
<selectid="selectBlog"parameterType="int"resultType="Blog">
select*fromBlogwhereid=#{id}
</select>
</mapper>
也可以使用MyBatisAPI执行语句：
Blogblog=session.selectOne("org.mybatis.example.BlogMapper.selectBlog",101);
详细信息可以参考MyBatis网站所提供的用户手册。
与Spring集成
MyBatis与SpringFramework集成。SpringFramework允许MyBatis参与Spring事务，创建了MyBatis映射器和会话，并把他们注入到其他bean中。
如下是一个基本的XML配置示例：创建了映射器，并注入到“BlogService”bean中。
<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean"> <propertyname="dataSource"ref="dataSource"/> </bean> <beanid="blogMapper"class="org.mybatis.spring.mapper.MapperFactoryBean"> <propertyname="sqlSessionFactory"ref="sqlSessionFactory"/> <propertyname="mapperInterface"value="org.mybatis.example.BlogMapper"/> </bean> <beanid="blogService"class="org.mybatis.example.BlogServiceImpl"> <propertyname="blogMapper"ref="blogMapper"/> </bean>
现在调用MyBatis只需要调用一个bean:
publicclassBlogServiceImplimplementsBlogService{
privateBlogMapperblogMapper;
publicvoidsetBlogMapper(BlogMapperblogMapper){
this.blogMapper=blogMapper;
}
publicvoiddoSomethingWithABlog(intblogId){
Blogblog=blogMapper.selectBlog(blogId);
...
}
}
SqlSessionFactory
每一个MyBatis的应用程序都以一个SqlSessionFactory对象的实例为核心。SqlSessionFactory本身是由SqlSessionFactoryBuilder创建的，一般而言，在一个应用中，一个数据库只会对应一个SqlSessionFactory，所以一般我们都把SqlSessionFactory定义成单例模式，或通过Spring等进行注入。
SqlSessionFactoryBuilder创建SqlSessionFactory的方法有：
- SqlSessionFactorybuild(InputStreaminputStream)
- SqlSessionFactorybuild(InputStreaminputStream,Stringenvironment)
- SqlSessionFactorybuild(InputStreaminputStream,Propertiesproperties)
- SqlSessionFactorybuild(InputStreaminputStream,Stringenv,Propertiesprops)
- SqlSessionFactorybuild(Configurationconfig)
这些方法主要设计到的参数有InputStream，environment，properties，其中InputStream是从配置文件中获取的一个输入流；environment表示在配置文件里面配置的众多的environment中，当前要使用的是哪一个environment，包括数据源和事务，缺省则使用默认的environment；使用properties，MyBatis则会加载对应的属性或文件，它们可以在配置文件中使用。
从XML中构建SqlSessionFactory
privatestaticSqlSessionFactorysqlSessionFactory=null;
static{
try{
InputStreamis=Resources.getResourceAsStream("config/mybatis_config.xml");
sqlSessionFactory=newSqlSessionFactoryBuilder().build(is);
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicstaticSqlSessionFactorygetSqlSessionFactory(){
returnsqlSessionFactory;
}
下面讲讲配置文件的基本结构：
mybatis的配置文件一般包括如下几个部分：
- properties：properties用于定义或导入属性，然后在后面的环境中使用
- settings:settings用于设置一些mybatis在运行时的行为方式，具体的设置信息可以查看mybatis的文档
- typeAliases:typeAliases是为系统中的Java类型指定一个较短的别名
- environments:MyBatis可以配置多种环境。这会帮助你将SQL映射应用于多种数据库之中。
<environmentsdefault="development">
<environmentid="development">
<transactionManagertype="JDBC"/>
<dataSourcetype="POOLED">
<propertyname="driver"value="${jdbc.driver}"/>
<propertyname="url"value="${jdbc.url}"/>
<propertyname="username"value="${jdbc.username}"/>
<propertyname="password"value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
由于MyBatis可以配置多个environment，所以可以在创建SqlSessionFactory的时候指定具体的环境来创建特定的环境下的SqlSessionFactory， 不指定则使用默认的环境。
transactionManager
在MyBatis中有两种事务管理器类型(也就是type=”[JDBC|MANAGED]”):
JDBC–这个配置直接简单使用了JDBC的提交和回滚设置。它依赖于从数据源得到的连接来管理事务范围。
MANAGED–这个配置几乎没做什么。它从来不提交或回滚一个连接。而它会让容器来管理事务的整个生命周期(比如Spring或JEE应用服务器的上下文)默认情况下它会关闭连接。然而一些容器并不希望这样,因此如果你需要从连接中停止它,将closeConnection属性设置为false。
dataSource
dataSource元素使用基本的JDBC数据源接口来配置JDBC连接对象的资源。
许多MyBatis的应用程序将会按示例中的例子来配置数据源。然而它并不是必须的。要知道为了方便使用延迟加载,数据源才是必须的。
有三种内建的数据源类型(也就是type=”???”):
UNPOOLED–这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢,这是对简单应用程序的一个很好的选择,因为它不需要及时的可用连接。不同的数据库对这个的表现也是不一样的,所以对某些数据库来说配置数据源并不重要,这个配置也是闲置的。UNPOOLED类型的数据源仅仅用来配置以下5种属性:
- driver–这是JDBC驱动的Java类的完全限定名(如果你的驱动包含,它也不是数据源类)。
- url–这是数据库的JDBCURL地址。
- username–登录数据库的用户名。
- password–登录数据库的密码。
- defaultTransactionIsolationLevel–默认的连接事务隔离级别。
作为可选项,你可以传递数据库驱动的属性。要这样做,属性的前缀是以“driver.”开头的,例如:
driver.encoding=UTF8
这样就会传递以值“UTF8”来传递属性“encoding”,它是通过DriverManager.getConnection(url,driverProperties)方法传递给数据库驱动。
POOLED–这是JDBC连接对象的数据源连接池的实现,用来避免创建新的连接实例时必要的初始连接和认证时间。这是一种当前Web应用程序用来快速响应请求很流行的方法。
除了上述(UNPOOLED)的属性之外,还有很多属性可以用来配置POOLED数据源:
- poolMaximumActiveConnections–在任意时间存在的活动(也就是正在使用)连接的数量。默认值:10
- poolMaximumIdleConnections–任意时间存在的空闲连接数。
- poolMaximumCheckoutTime–在被强制返回之前,池中连接被检查的时间。默认值:20000毫秒(也就是20秒)
- poolTimeToWait–这是给连接池一个打印日志状态机会的低层次设置,还有重新尝试获得连接,这些情况下往往需要很长时间为了避免连接池没有配置时静默失败)。默认值:20000毫秒(也就是20秒)
- poolPingQuery–发送到数据的侦测查询,用来验证连接是否正常工作,并且准备接受请求。默认是“NOPINGQUERYSET”,这会引起许多数据库驱动连接由一个错误信息而导致失败。
- poolPingEnabled–这是开启或禁用侦测查询。如果开启,你必须用一个合法的SQL语句(最好是很快速的)设置poolPingQuery属性。默认值:false。
- poolPingConnectionsNotUsedFor–这是用来配置poolPingQuery多次时间被用一次。这可以被设置匹配标准的数据库连接超时时间,来避免不必要的侦测。默认值:0(也就是所有连接每一时刻都被侦测-但仅仅当poolPingEnabled为true时适用)。
- JNDI–这个数据源的实现是为了使用如Spring或应用服务器这类的容器,容器可以集中或在外部配置数据源,然后放置一个JNDI上下文的引用。
其中JNDI这个数据源配置只需要两个属性:
（1）initial_context–这个属性用来从初始上下文中寻找环境(也就是initialContext.lookup(initial——context)。这是个可选属性,如果被忽略,那么data_source属性将会直接以initialContext为背景再次寻找。
（2）data_source–这是引用数据源实例位置的上下文的路径。它会以由initial_context查询返回的环境为背景来查找,如果initial_context没有返回结果时,直接以初始上下文为环境来查找。
再之后就是Mapper了，Mapper就是映射SQL语句的，首先要告诉mybatis要到哪里去找这些SQL语句，即指定资源位置。
<mappers> <mapperresource="com/tiantian/mybatis/model/BlogMapper.xml"/> </mappers>
下面是我在测试过程中的一个简单的配置文件：
<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEconfiguration
PUBLIC"-//mybatis.org//DTDConfig3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<propertiesresource="config/jdbc.properties"></properties>
<typeAliases>
<typeAliasalias="Blog"type="com.tiantian.mybatis.model.Blog"/>
</typeAliases>
<environmentsdefault="development">
<environmentid="development">
<transactionManagertype="JDBC"/>
<dataSourcetype="POOLED">
<propertyname="driver"value="${jdbc.driver}"/>
<propertyname="url"value="${jdbc.url}"/>
<propertyname="username"value="${jdbc.username}"/>
<propertyname="password"value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapperresource="com/tiantian/mybatis/model/BlogMapper.xml"/>
</mappers>
</configuration>
在上面配置文件中导入了一个外部的属性文件，MyBatis配置文件中的属性引入可以是直接包含在properties元素中的，也可以是利用properties元素从外部引入的，还可以是在创建SqlSessionFactory的时候，作为一个参数properties传入。既然MyBatis配置文件中的属性可以从这么多地方引入，那就牵涉到一个优先级的问题，MyBatis将会按照下面的顺序来寻找它们：
先是配置文件中，properties元素体中的属性被读取
再是利用properties元素从外部引入的属性文件中的属性被读取，会覆盖前面读取的相同的属性
最后是创建SqlSessionFactory时传入的properties中的属性被读取，同样会覆盖前面相同的属性
在有了SqlSessionFactory之后就是获取特定的SqlSession了，在使用mybatis的过程中每一个操作都是离不开SqlSession的，所以获取SqlSession是相当重要的。此外，SqlSession是不能被共享、线程不安全的，所以在每次需要SqlSession的时候都应该打开一个，然后在用完了之后再把它关上。
SqlSessionsession=sqlSessionFactory.openSession();
SqlSessionFactory中湖区SqlSession的方法有：
- SqlSessionopenSession()
- SqlSessionopenSession(booleanautoCommit)
- SqlSessionopenSession(Connectionconnection)
- SqlSessionopenSession(TransactionIsolationLevellevel)
- SqlSessionopenSession(ExecutorTypeexecType,TransactionIsolationLevellevel)
- SqlSessionopenSession(ExecutorTypeexecType)
- SqlSessionopenSession(ExecutorTypeexecType,booleanautoCommit)
- SqlSessionopenSession(ExecutorTypeexecType,Connectionconnection)
- ConfigurationgetConfiguration();
它们的主要区别在于：
- Transaction(事务):你想为session使用事务或者使用自动提交
- Connection(连接):你想MyBatis获得来自配置的数据源的连接还是提供你自己
- Execution(执行):你想MyBatis复用预处理语句和/或批量更新语句(包括插入和删除)
默认的opensession方法没有参数，它会创建有如下特性的SqlSession：
- 会开启一个事务，也就是不自动提交
- 连接对象会从当前正在使用的environment中的数据源中得到
- 事务隔离级别将会使用驱动或数据源的默认值
- 预处理语句不会被复用，也不会批量更新语句
ExecutorType有三个值：
- ExecutorType.SIMPLE它会为每个语句的执行创建一个新的预处理语句
- ExecutorType.REUSE它会复用预处理语句
- ExecutorType.BATCH这个执行器会批量执行更新语句
mybatis的基本操作就是增、删、改、查，即insert、delete、update和select。在进行这些基本的操作的时候可以直接利用SqlSession访问Mapper配置文件里面的映射来进行，也可以利用与Mapper配置文件相对应的Mapper接口来进行操作，条件是Mapper接口中定义的方法的参数和返回值要与Mapper配置文件中定义的参数和返回值相同。此外，在使用Mapper接口的时候，对应的SQL语句是可以写在Mapper配置文件中的，也可以直接利用对应的注解在Mapper接口中对应的方法上进行标明，这将在下面的示例代码中看到。
下面是一系列的示例代码：
先贴一个用于获取SqlSessionFactory的工具类：
importjava.io.IOException;
importjava.io.InputStream;
importorg.apache.ibatis.io.Resources;
importorg.apache.ibatis.session.SqlSessionFactory;
importorg.apache.ibatis.session.SqlSessionFactoryBuilder;
publicclassUtil{
privatestaticSqlSessionFactorysqlSessionFactory=null;
static{
try{
InputStreamis=Resources.getResourceAsStream("config/mybatis_config.xml");
sqlSessionFactory=newSqlSessionFactoryBuilder().build(is);
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicstaticSqlSessionFactorygetSqlSessionFactory(){
returnsqlSessionFactory;
}
}
mybatis的配置文件：
<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEconfiguration
PUBLIC"-//mybatis.org//DTDConfig3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<propertiesresource="config/jdbc.properties"></properties>
<typeAliases>
<typeAliasalias="Blog"type="com.tiantian.mybatis.model.Blog"/>
</typeAliases>
<environmentsdefault="development">
<environmentid="development">
<transactionManagertype="JDBC"/>
<dataSourcetype="POOLED">
<propertyname="driver"value="${jdbc.driver}"/>
<propertyname="url"value="${jdbc.url}"/>
<propertyname="username"value="${jdbc.username}"/>
<propertyname="password"value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapperresource="com/tiantian/mybatis/model/BlogMapper.xml"/>
</mappers>
</configuration>
BlogMapper.xml
<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEmapper
PUBLIC"-//mybatis.org//DTDMapper3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mappernamespace="com.tiantian.mybatis.model.BlogMapper">
<!--新增记录-->
<insertid="insertBlog"parameterType="Blog">
insertintot_blog(title,content,owner)values(#{title},#{content},#{owner})
</insert>
<!--查询单条记录-->
<selectid="selectBlog"parameterType="int"resultType="Blog">
select*fromt_blogwhereid=#{id}
</select>
<!--修改记录-->
<updateid="updateBlog"parameterType="Blog">
updatet_blogsettitle=#{title},content=#{content},owner=#{owner}whereid=#{id}
</update>
<!--查询所有记录，查询多条记录即返回结果是一个集合的时候，resultType不是集合类型，而是集合所包含的类型-->
<selectid="selectAll"resultType="Blog">
select*fromt_blog
</select>
<!--模糊查询-->
<selectid="fuzzyQuery"resultType="Blog"parameterType="java.lang.String">
select*fromt_blogwheretitlelike"%"#{title}"%"
</select>
<!--删除记录-->
<deleteid="deleteBlog"parameterType="int">
deletefromt_blogwhereid=#{id}
</delete>
</mapper>
SQL映射语句中一些应该注意的问题：
- resultType的值应该是返回类型的完全名或别名，当返回的结果是一个集合的时候，resultType应为集合中所包含的类型，而不是集合类型，如上面的Blog
- resultType和resultMap都是表示指定返回结果的，但两者不能同时使用
- 对于Insert映射语句有一个useGeneratedKeys属性，该属性的默认值为false，当该属性的值为true时，在进行插入操作时，mybatis会取到当前正在插入的记录在数据库中的自动递增的主键值，并把它设置给指定的实体的属性，这就需要设置一个keyProperty属性，用于指定实体中表示主键的属性
Blog.java
packagecom.tiantian.mybatis.model;
publicclassBlog{
privateintid;
privateStringtitle;
privateStringcontent;
privateStringowner;
publicintgetId(){
returnid;
}
publicvoidsetId(intid){
this.id=id;
}
publicStringgetTitle(){
returntitle;
}
publicvoidsetTitle(Stringtitle){
this.title=title;
}
publicStringgetContent(){
returncontent;
}
publicvoidsetContent(Stringcontent){
this.content=content;
}
publicStringgetOwner(){
returnowner;
}
publicvoidsetOwner(Stringowner){
this.owner=owner;
}
@Override
publicStringtoString(){
return"id:"+id+",title:"+title+",content:"+content
+",owner:"+owner;
}
}
BlogMapper.java
packagecom.tiantian.mybatis.model;
importjava.util.List;
importorg.apache.ibatis.annotations.Delete;
importorg.apache.ibatis.annotations.Insert;
importorg.apache.ibatis.annotations.Select;
importorg.apache.ibatis.annotations.Update;
/**
*以下的操作1都是把SQL写在配置文件里面的，而操作2都是直接用注解标明要执行的SQL语句
*因为该Mapper的全名跟BlogMapper.xml文件里面的namespace是一样的，所以不能在这里面
*用注解定义一个与BlogMapper.xml文件里面同名的映射
*@authorandy
*
*/
publicinterfaceBlogMapper{
publicBlogselectBlog(intid);
@Select("select*fromt_blogwhereid=#{id}")
publicBlogselectBlog2(intid);
publicvoidinsertBlog(Blogblog);
@Insert("insertintot_blog(title,content,owner)values(#{title},#{content},#{owner})")
publicvoidinsertBlog2(Blogblog);
publicvoidupdateBlog(Blogblog);
@Update("updatet_blogsettitle=#{title},content=#{content},owner=#{owner}whereid=#{id}")
publicvoidupdateBlog2(Blogblog);
publicvoiddeleteBlog(intid);
@Delete("deletefromt_blogwhereid=#{id}")
publicvoiddeleteBlog2(intid);
publicList<Blog>selectAll();
@Select("select*fromt_blog")
publicList<Blog>selectAll2();
publicList<Blog>fuzzyQuery(Stringtitle);
@Select("select*fromt_blogwheretitlelike\"%\"#{title}\"%\"")
publicList<Blog>fuzzyQuery2(Stringtitle);
}
Test1.java
packagecom.tiantian.mybatis.test;
importjava.util.List;
importorg.apache.ibatis.session.SqlSession;
importorg.junit.Test;
importcom.tiantian.mybatis.model.Blog;
importcom.tiantian.mybatis.util.Util;
/**
*该系列操作是通过把SQL写在配置文件里面，
*然后利用SqlSession进行操作的
*@authorandy
*
*/
publicclassTest1{
/**
*新增记录
*/
@Test
publicvoidtestInsertBlog(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
Blogblog=newBlog();
blog.setTitle("中国人");
blog.setContent("五千年的风和雨啊藏了多少梦");
blog.setOwner("天天");
session.insert("com.tiantian.mybatis.model.BlogMapper.insertBlog",blog);
session.commit();
session.close();
}
/**
*查询单条记录
*/
@Test
publicvoidtestSelectOne(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
Blogblog=(Blog)session.selectOne("com.tiantian.mybatis.model.BlogMapper.selectBlog",8);
System.out.println(blog);
session.close();
}
/**
*修改记录
*/
@Test
publicvoidtestUpdateBlog(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
Blogblog=newBlog();
blog.setId(7);//需要修改的Blog的id
blog.setTitle("中国人2");//修改Title
blog.setContent("黄色的脸，黑色的眼，不变是笑容");//修改Content
blog.setOwner("天天2");//修改Owner
session.update("com.tiantian.mybatis.model.BlogMapper.updateBlog",blog);
session.commit();
session.close();
}
/**
*查询所有的记录
*/
@Test
publicvoidtestSelectAll(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
List<Blog>blogs=session.selectList("com.tiantian.mybatis.model.BlogMapper.selectAll");
for(Blogblog:blogs)
System.out.println(blog);
session.close();
}
/**
*模糊查询
*/
@Test
publicvoidtestFuzzyQuery(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
Stringtitle="中国";
List<Blog>blogs=session.selectList("com.tiantian.mybatis.model.BlogMapper.fuzzyQuery",title);
for(Blogblog:blogs)
System.out.println(blog);
session.close();
}
/**
*删除记录
*/
@Test
publicvoidtestDeleteBlog(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
session.delete("com.tiantian.mybatis.model.BlogMapper.deleteBlog",8);
session.commit();
session.close();
}
}
Test2.java
packagecom.tiantian.mybatis.test;
importjava.util.List;
importorg.apache.ibatis.session.SqlSession;
importorg.junit.Test;
importcom.tiantian.mybatis.model.Blog;
importcom.tiantian.mybatis.model.BlogMapper;
importcom.tiantian.mybatis.util.Util;
/**
*该系列操作是将SQL语句写在配置文件里面，
*然后通过对应Mapper接口来进行操作的
*@authorandy
*
*/
publicclassTest2{
/**
*新增记录
*/
@Test
publicvoidtestInsertBlog(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
Blogblog=newBlog();
blog.setTitle("中国人");
blog.setContent("五千年的风和雨啊藏了多少梦");
blog.setOwner("天天");
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
blogMapper.insertBlog(blog);
session.commit();
session.close();
}
/**
*查询单条记录
*/
@Test
publicvoidtestSelectOne(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
Blogblog=blogMapper.selectBlog(7);
System.out.println(blog);
session.close();
}
/**
*修改记录
*/
@Test
publicvoidtestUpdateBlog(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
Blogblog=newBlog();
blog.setId(9);//需要修改的Blog的id
blog.setTitle("中国人2");//修改Title
blog.setContent("黄色的脸，黑色的眼，不变是笑容");//修改Content
blog.setOwner("天天2");//修改Owner
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
blogMapper.updateBlog(blog);
session.commit();
session.close();
}
/**
*查询所有记录
*/
@Test
publicvoidtestSelectAll(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
List<Blog>blogs=blogMapper.selectAll();
for(Blogblog:blogs)
System.out.println(blog);
session.close();
}
/**
*模糊查询
*/
@Test
publicvoidtestFuzzyQuery(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
Stringtitle="中国";
List<Blog>blogs=blogMapper.fuzzyQuery(title);
for(Blogblog:blogs)
System.out.println(blog);
session.close();
}
/**
*删除记录
*/
@Test
publicvoidtestDeleteBlog(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
blogMapper.deleteBlog(10);
session.commit();
session.close();
}
}
Test3.java
packagecom.tiantian.mybatis.test;
importjava.util.List;
importorg.apache.ibatis.session.SqlSession;
importorg.junit.Test;
importcom.tiantian.mybatis.model.Blog;
importcom.tiantian.mybatis.model.BlogMapper;
importcom.tiantian.mybatis.util.Util;
/**
*该系列操作是利用Mapper接口来进行的
*，然而其相应的SQL语句是通过对应的
*注解Annotation在Mapper中对应的方法上定义的
*@authorandy
*
*/
publicclassTest3{
/**
*新增记录
*/
@Test
publicvoidtestInsert(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
Blogblog=newBlog();
blog.setTitle("title2");
blog.setContent("content2");
blog.setOwner("owner2");
blogMapper.insertBlog2(blog);
session.commit();
session.close();
}
/**
*查找单条记录
*/
@Test
publicvoidtestSelectOne(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
Blogblog=blogMapper.selectBlog2(1);
System.out.println(blog);
session.close();
}
/**
*查找多条记录，返回结果为一集合
*/
@Test
publicvoidtestSelectAll(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
List<Blog>blogs=blogMapper.selectAll2();
for(Blogblog:blogs)
System.out.println(blog);
session.close();
}
/**
*修改某条记录
*/
@Test
publicvoidtestUpdate(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
Blogblog=newBlog();
blog.setId(3);
blog.setTitle("title3");
blog.setContent("content3");
blog.setOwner("owner3");
blogMapper.updateBlog2(blog);
session.commit();
session.close();
}
/**
*删除记录
*/
@Test
publicvoidtestDelete(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
blogMapper.deleteBlog2(5);
session.commit();
session.close();
}
@Test
publicvoidtestFuzzyQuery(){
SqlSessionsession=Util.getSqlSessionFactory().openSession();
BlogMapperblogMapper=session.getMapper(BlogMapper.class);
List<Blog>blogs=blogMapper.fuzzyQuery2("中国");
for(Blogblog:blogs)
System.out.println(blog);
session.close();
}
}
对应的建表语句：
CREATETABLE`t_blog`( `id`int(11)NOTNULLAUTO_INCREMENT, `title`varchar(255)DEFAULTNULL, `content`varchar(255)DEFAULTNULL, `owner`varchar(50)DEFAULTNULL, PRIMARYKEY(`id`) )