整理Java的MyBatis框架中一些重要的功能及基本使用示例
程序员文章站
2024-03-09 12:43:17
基本用法回顾：
sql语句存储在xml文件或java 注解中。一个mabatis映射的示例（其中用到了java接口和mybatis注解）：
package or...
基本用法回顾：
sql语句存储在xml文件或java 注解中。一个mabatis映射的示例（其中用到了java接口和mybatis注解）：
package org.mybatis.example;
public interface blogmapper {
@select("select * from blog where id = #{id}")
blog selectblog(int id);
}
执行的示例：
blogmapper mapper = session.getmapper(blogmapper.class); blog blog = mapper.selectblog(101);
sql语句和映射也可以外化到一个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="org.mybatis.example.blogmapper">
<select id="selectblog" parametertype="int" resulttype="blog">
select * from blog where id = #{id}
</select>
</mapper>
也可以使用mybatis api执行语句：
blog blog = session.selectone("org.mybatis.example.blogmapper.selectblog", 101);
详细信息可以参考mybatis网站所提供的用户手册。
与spring集成
mybatis与spring framework集成。spring framework允许mybatis参与spring事务，创建了mybatis映射器和会话，并把他们注入到其他bean中。
如下是一个基本的xml配置示例：创建了映射器，并注入到“blogservice”bean中。
<bean id="sqlsessionfactory" class="org.mybatis.spring.sqlsessionfactorybean"> <property name="datasource" ref="datasource" /> </bean> <bean id="blogmapper" class="org.mybatis.spring.mapper.mapperfactorybean"> <property name="sqlsessionfactory" ref="sqlsessionfactory" /> <property name="mapperinterface" value="org.mybatis.example.blogmapper" /> </bean> <bean id="blogservice" class="org.mybatis.example.blogserviceimpl"> <property name="blogmapper" ref="blogmapper" /> </bean>
现在调用mybatis只需要调用一个bean:
public class blogserviceimpl implements blogservice {
private blogmapper blogmapper;
public void setblogmapper(blogmapper blogmapper) {
this.blogmapper = blogmapper;
}
public void dosomethingwithablog(int blogid) {
blog blog = blogmapper.selectblog(blogid);
...
}
}
sqlsessionfactory
每 一 个 mybatis 的 应 用 程 序 都 以 一 个 sqlsessionfactory 对 象 的 实 例 为 核 心 。sqlsessionfactory本身是由sqlsessionfactorybuilder创建的，一般而言，在一个应用中，一个数据库只会对应一个sqlsessionfactory，所以一般我们都把sqlsessionfactory定义成单例模式，或通过spring等进行注入。
sqlsessionfactorybuilder创建sqlsessionfactory的方法有：
- sqlsessionfactory build(inputstream inputstream)
- sqlsessionfactory build(inputstream inputstream, string environment)
- sqlsessionfactory build(inputstream inputstream, properties properties)
- sqlsessionfactory build(inputstream inputstream, string env, properties props)
- sqlsessionfactory build(configuration config)
这些方法主要设计到的参数有inputstream，environment，properties，其中inputstream是从配置文件中获取的一个输入流；environment表示在配置文件里面配置的众多的environment中，当前要使用的是哪一个environment，包括数据源和事务，缺省则使用默认的environment；使用properties，mybatis则会加载对应的属性或文件，它们可以在配置文件中使用。
从xml中构建sqlsessionfactory
private static sqlsessionfactory sqlsessionfactory = null;
static {
try {
inputstream is = resources.getresourceasstream("config/mybatis_config.xml");
sqlsessionfactory = new sqlsessionfactorybuilder().build(is);
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
}
public static sqlsessionfactory getsqlsessionfactory() {
return sqlsessionfactory;
}
下面讲讲配置文件的基本结构：
mybatis的配置文件一般包括如下几个部分：
- properties：properties用于定义或导入属性，然后在后面的环境中使用
- settings:settings用于设置一些mybatis在运行时的行为方式，具体的设置信息可以查看mybatis的文档
- typealiases:typealiases是为系统中的java类型指定一个较短的别名
- environments:mybatis 可以配置多种环境。这会帮助你将 sql 映射应用于多种数据库之中。
<environments default="development">
<environment id="development">
<transactionmanager type="jdbc" />
<datasource type="pooled">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="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 – 这是数据库的 jdbc url 地址。
- 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 – 发送到数据的侦测查询,用来验证连接是否正常工作,并且准备 接受请求。默认是“no ping query set” ,这会引起许多数据库驱动连接由一 个错误信息而导致失败。
- 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>
<mapper resource="com/tiantian/mybatis/model/blogmapper.xml"/>
</mappers>
下面是我在测试过程中的一个简单的配置文件：
<?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="config/jdbc.properties"></properties>
<typealiases>
<typealias alias="blog" type="com.tiantian.mybatis.model.blog"/>
</typealiases>
<environments default="development">
<environment id="development">
<transactionmanager type="jdbc" />
<datasource type="pooled">
<property name="driver" value="${jdbc.driver}" />
<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/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的时候都应该打开一个，然后在用完了之后再把它关上。
sqlsession session = sqlsessionfactory.opensession();
sqlsessionfactory中湖区sqlsession的方法有：
- sqlsession opensession()
- sqlsession opensession(boolean autocommit)
- sqlsession opensession(connection connection)
- sqlsession opensession(transactionisolationlevel level)
- sqlsession opensession(executortype exectype,transactionisolationlevel level)
- sqlsession opensession(executortype exectype)
- sqlsession opensession(executortype exectype, boolean autocommit)
- sqlsession opensession(executortype exectype, connection connection)
- configuration getconfiguration();
它们的主要区别在于：
- 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的工具类：
import java.io.ioexception;
import java.io.inputstream;
import org.apache.ibatis.io.resources;
import org.apache.ibatis.session.sqlsessionfactory;
import org.apache.ibatis.session.sqlsessionfactorybuilder;
public class util {
private static sqlsessionfactory sqlsessionfactory = null;
static {
try {
inputstream is = resources.getresourceasstream("config/mybatis_config.xml");
sqlsessionfactory = new sqlsessionfactorybuilder().build(is);
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
}
public static sqlsessionfactory getsqlsessionfactory() {
return sqlsessionfactory;
}
}
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>
<properties resource="config/jdbc.properties"></properties>
<typealiases>
<typealias alias="blog" type="com.tiantian.mybatis.model.blog"/>
</typealiases>
<environments default="development">
<environment id="development">
<transactionmanager type="jdbc" />
<datasource type="pooled">
<property name="driver" value="${jdbc.driver}" />
<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/tiantian/mybatis/model/blogmapper.xml"/>
</mappers>
</configuration>
blogmapper.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.tiantian.mybatis.model.blogmapper">
<!-- 新增记录 -->
<insert id="insertblog" parametertype="blog">
insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})
</insert>
<!-- 查询单条记录 -->
<select id="selectblog" parametertype="int" resulttype="blog">
select * from t_blog where id = #{id}
</select>
<!-- 修改记录 -->
<update id="updateblog" parametertype="blog">
update t_blog set title = #{title},content = #{content},owner = #{owner} where id = #{id}
</update>
<!-- 查询所有记录，查询多条记录即返回结果是一个集合的时候，resulttype不是集合类型，而是集合所包含的类型 -->
<select id="selectall" resulttype="blog">
select * from t_blog
</select>
<!-- 模糊查询 -->
<select id="fuzzyquery" resulttype="blog" parametertype="java.lang.string">
select * from t_blog where title like "%"#{title}"%"
</select>
<!-- 删除记录 -->
<delete id="deleteblog" parametertype="int">
delete from t_blog where id = #{id}
</delete>
</mapper>
sql映射语句中一些应该注意的问题：
- resulttype的值应该是返回类型的完全名或别名，当返回的结果是一个集合的时候，resulttype应为集合中所包含的类型，而不是集合类型，如上面的blog
- resulttype和resultmap都是表示指定返回结果的，但两者不能同时使用
- 对于insert映射语句有一个usegeneratedkeys属性，该属性的默认值为false，当该属性的值为true时，在进行插入操作时，mybatis会取到当前正在插入的记录在数据库中的自动递增的主键值，并把它设置给指定的实体的属性，这就需要设置一个keyproperty属性，用于指定实体中表示主键的属性
blog.java
package com.tiantian.mybatis.model;
public class blog {
private int id;
private string title;
private string content;
private string owner;
public int getid() {
return id;
}
public void setid(int id) {
this.id = id;
}
public string gettitle() {
return title;
}
public void settitle(string title) {
this.title = title;
}
public string getcontent() {
return content;
}
public void setcontent(string content) {
this.content = content;
}
public string getowner() {
return owner;
}
public void setowner(string owner) {
this.owner = owner;
}
@override
public string tostring() {
return "id: " + id + ", title: " + title + ", content: " + content
+ ", owner: " + owner;
}
}
blogmapper.java
package com.tiantian.mybatis.model;
import java.util.list;
import org.apache.ibatis.annotations.delete;
import org.apache.ibatis.annotations.insert;
import org.apache.ibatis.annotations.select;
import org.apache.ibatis.annotations.update;
/**
* 以下的操作1都是把sql写在配置文件里面的，而操作2都是直接用注解标明要执行的sql语句
* 因为该mapper的全名跟blogmapper.xml文件里面的namespace是一样的，所以不能在这里面
* 用注解定义一个与blogmapper.xml文件里面同名的映射
* @author andy
*
*/
public interface blogmapper {
public blog selectblog(int id);
@select("select * from t_blog where id = #{id}")
public blog selectblog2(int id);
public void insertblog(blog blog);
@insert("insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})")
public void insertblog2(blog blog);
public void updateblog(blog blog);
@update("update t_blog set title=#{title},content=#{content},owner=#{owner} where id=#{id}")
public void updateblog2(blog blog);
public void deleteblog(int id);
@delete("delete from t_blog where id = #{id}")
public void deleteblog2(int id);
public list<blog> selectall();
@select("select * from t_blog")
public list<blog> selectall2();
public list<blog> fuzzyquery(string title);
@select("select * from t_blog where title like \"%\"#{title}\"%\"")
public list<blog> fuzzyquery2(string title);
}
test1.java
package com.tiantian.mybatis.test;
import java.util.list;
import org.apache.ibatis.session.sqlsession;
import org.junit.test;
import com.tiantian.mybatis.model.blog;
import com.tiantian.mybatis.util.util;
/**
* 该系列操作是通过把sql写在配置文件里面，
* 然后利用sqlsession进行操作的
* @author andy
*
*/
public class test1 {
/**
* 新增记录
*/
@test
public void testinsertblog() {
sqlsession session = util.getsqlsessionfactory().opensession();
blog blog = new blog();
blog.settitle("中国人");
blog.setcontent("五千年的风和雨啊藏了多少梦");
blog.setowner("天天");
session.insert("com.tiantian.mybatis.model.blogmapper.insertblog", blog);
session.commit();
session.close();
}
/**
* 查询单条记录
*/
@test
public void testselectone() {
sqlsession session = util.getsqlsessionfactory().opensession();
blog blog = (blog)session.selectone("com.tiantian.mybatis.model.blogmapper.selectblog", 8);
system.out.println(blog);
session.close();
}
/**
* 修改记录
*/
@test
public void testupdateblog() {
sqlsession session = util.getsqlsessionfactory().opensession();
blog blog = new blog();
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
public void testselectall() {
sqlsession session = util.getsqlsessionfactory().opensession();
list<blog> blogs = session.selectlist("com.tiantian.mybatis.model.blogmapper.selectall");
for (blog blog:blogs)
system.out.println(blog);
session.close();
}
/**
* 模糊查询
*/
@test
public void testfuzzyquery() {
sqlsession session = util.getsqlsessionfactory().opensession();
string title = "中国";
list<blog> blogs = session.selectlist("com.tiantian.mybatis.model.blogmapper.fuzzyquery", title);
for (blog blog:blogs)
system.out.println(blog);
session.close();
}
/**
* 删除记录
*/
@test
public void testdeleteblog() {
sqlsession session = util.getsqlsessionfactory().opensession();
session.delete("com.tiantian.mybatis.model.blogmapper.deleteblog", 8);
session.commit();
session.close();
}
}
test2.java
package com.tiantian.mybatis.test;
import java.util.list;
import org.apache.ibatis.session.sqlsession;
import org.junit.test;
import com.tiantian.mybatis.model.blog;
import com.tiantian.mybatis.model.blogmapper;
import com.tiantian.mybatis.util.util;
/**
* 该系列操作是将sql语句写在配置文件里面，
* 然后通过对应mapper接口来进行操作的
* @author andy
*
*/
public class test2 {
/**
* 新增记录
*/
@test
public void testinsertblog() {
sqlsession session = util.getsqlsessionfactory().opensession();
blog blog = new blog();
blog.settitle("中国人");
blog.setcontent("五千年的风和雨啊藏了多少梦");
blog.setowner("天天");
blogmapper blogmapper = session.getmapper(blogmapper.class);
blogmapper.insertblog(blog);
session.commit();
session.close();
}
/**
* 查询单条记录
*/
@test
public void testselectone() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
blog blog = blogmapper.selectblog(7);
system.out.println(blog);
session.close();
}
/**
* 修改记录
*/
@test
public void testupdateblog() {
sqlsession session = util.getsqlsessionfactory().opensession();
blog blog = new blog();
blog.setid(9);// 需要修改的blog的id
blog.settitle("中国人2");// 修改title
blog.setcontent("黄色的脸，黑色的眼，不变是笑容");// 修改content
blog.setowner("天天2");// 修改owner
blogmapper blogmapper = session.getmapper(blogmapper.class);
blogmapper.updateblog(blog);
session.commit();
session.close();
}
/**
* 查询所有记录
*/
@test
public void testselectall() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
list<blog> blogs = blogmapper.selectall();
for (blog blog : blogs)
system.out.println(blog);
session.close();
}
/**
* 模糊查询
*/
@test
public void testfuzzyquery() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
string title = "中国";
list<blog> blogs = blogmapper.fuzzyquery(title);
for (blog blog : blogs)
system.out.println(blog);
session.close();
}
/**
* 删除记录
*/
@test
public void testdeleteblog() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
blogmapper.deleteblog(10);
session.commit();
session.close();
}
}
test3.java
package com.tiantian.mybatis.test;
import java.util.list;
import org.apache.ibatis.session.sqlsession;
import org.junit.test;
import com.tiantian.mybatis.model.blog;
import com.tiantian.mybatis.model.blogmapper;
import com.tiantian.mybatis.util.util;
/**
* 该系列操作是利用mapper接口来进行的
* ，然而其相应的sql语句是通过对应的
* 注解annotation在mapper中对应的方法上定义的
* @author andy
*
*/
public class test3 {
/**
* 新增记录
*/
@test
public void testinsert() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
blog blog = new blog();
blog.settitle("title2");
blog.setcontent("content2");
blog.setowner("owner2");
blogmapper.insertblog2(blog);
session.commit();
session.close();
}
/**
* 查找单条记录
*/
@test
public void testselectone() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
blog blog = blogmapper.selectblog2(1);
system.out.println(blog);
session.close();
}
/**
* 查找多条记录，返回结果为一集合
*/
@test
public void testselectall() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
list<blog> blogs = blogmapper.selectall2();
for (blog blog:blogs)
system.out.println(blog);
session.close();
}
/**
* 修改某条记录
*/
@test
public void testupdate() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
blog blog = new blog();
blog.setid(3);
blog.settitle("title3");
blog.setcontent("content3");
blog.setowner("owner3");
blogmapper.updateblog2(blog);
session.commit();
session.close();
}
/**
* 删除记录
*/
@test
public void testdelete() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
blogmapper.deleteblog2(5);
session.commit();
session.close();
}
@test
public void testfuzzyquery() {
sqlsession session = util.getsqlsessionfactory().opensession();
blogmapper blogmapper = session.getmapper(blogmapper.class);
list<blog> blogs = blogmapper.fuzzyquery2("中国");
for (blog blog:blogs)
system.out.println(blog);
session.close();
}
}
对应的建表语句：
create table `t_blog` ( `id` int(11) not null auto_increment, `title` varchar(255) default null, `content` varchar(255) default null, `owner` varchar(50) default null, primary key (`id`) )
上一篇： PHP中的函数声明与使用详解